[deliverable/binutils-gdb.git] / binutils / addr2line.c

/* addr2line.c -- convert addresses to line number and function name
   Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
   2007, 2009  Free Software Foundation, Inc.
   Contributed by Ulrich Lauther <Ulrich.Lauther@mchp.siemens.de>

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */


/* Derived from objdump.c and nm.c by Ulrich.Lauther@mchp.siemens.de

   Usage:
   addr2line [options] addr addr ...
   or
   addr2line [options]

   both forms write results to stdout, the second form reads addresses
   to be converted from stdin.  */

#include "sysdep.h"
#include "bfd.h"
#include "getopt.h"
#include "libiberty.h"
#include "demangle.h"
#include "bucomm.h"
#include "elf-bfd.h"

static bfd_boolean unwind_inlines;	/* -i, unwind inlined functions. */
static bfd_boolean with_addresses;	/* -a, show addresses.  */
static bfd_boolean with_functions;	/* -f, show function names.  */
static bfd_boolean do_demangle;		/* -C, demangle names.  */
static bfd_boolean pretty_print;	/* -p, print on one line.  */
static bfd_boolean base_names;		/* -s, strip directory names.  */

static int naddr;		/* Number of addresses to process.  */
static char **addr;		/* Hex addresses to process.  */

static asymbol **syms;		/* Symbol table.  */

static struct option long_options[] =
{
  {"addresses", no_argument, NULL, 'a'},
  {"basenames", no_argument, NULL, 's'},
  {"demangle", optional_argument, NULL, 'C'},
  {"exe", required_argument, NULL, 'e'},
  {"functions", no_argument, NULL, 'f'},
  {"inlines", no_argument, NULL, 'i'},
  {"pretty-print", no_argument, NULL, 'p'},
  {"section", required_argument, NULL, 'j'},
  {"target", required_argument, NULL, 'b'},
  {"help", no_argument, NULL, 'H'},
  {"version", no_argument, NULL, 'V'},
  {0, no_argument, 0, 0}
};

static void usage (FILE *, int);
static void slurp_symtab (bfd *);
static void find_address_in_section (bfd *, asection *, void *);
static void find_offset_in_section (bfd *, asection *);
static void translate_addresses (bfd *, asection *);
\f
/* Print a usage message to STREAM and exit with STATUS.  */

static void
usage (FILE *stream, int status)
{
  fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
  fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
  fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
  fprintf (stream, _(" The options are:\n\
  @<file>                Read options from <file>\n\
  -a --addresses         Show addresses\n\
  -b --target=<bfdname>  Set the binary file format\n\
  -e --exe=<executable>  Set the input file name (default is a.out)\n\
  -i --inlines           Unwind inlined functions\n\
  -j --section=<name>    Read section-relative offsets instead of addresses\n\
  -p --pretty-print      Make the output easier to read for humans\n\
  -s --basenames         Strip directory names\n\
  -f --functions         Show function names\n\
  -C --demangle[=style]  Demangle function names\n\
  -h --help              Display this information\n\
  -v --version           Display the program's version\n\
\n"));

  list_supported_targets (program_name, stream);
  if (REPORT_BUGS_TO[0] && status == 0)
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
  exit (status);
}
\f
/* Read in the symbol table.  */

static void
slurp_symtab (bfd *abfd)
{
  long storage;
  long symcount;
  bfd_boolean dynamic = FALSE;

  if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
    return;

  storage = bfd_get_symtab_upper_bound (abfd);
  if (storage == 0)
    {
      storage = bfd_get_dynamic_symtab_upper_bound (abfd);
      dynamic = TRUE;
    }
  if (storage < 0)
    bfd_fatal (bfd_get_filename (abfd));

  syms = (asymbol **) xmalloc (storage);
  if (dynamic)
    symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
  else
    symcount = bfd_canonicalize_symtab (abfd, syms);
  if (symcount < 0)
    bfd_fatal (bfd_get_filename (abfd));
}
\f
/* These global variables are used to pass information between
   translate_addresses and find_address_in_section.  */

static bfd_vma pc;
static const char *filename;
static const char *functionname;
static unsigned int line;
static unsigned int discriminator;
static bfd_boolean found;

/* Look for an address in a section.  This is called via
   bfd_map_over_sections.  */

static void
find_address_in_section (bfd *abfd, asection *section,
			 void *data ATTRIBUTE_UNUSED)
{
  bfd_vma vma;
  bfd_size_type size;

  if (found)
    return;

  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
    return;

  vma = bfd_get_section_vma (abfd, section);
  if (pc < vma)
    return;

  size = bfd_get_section_size (section);
  if (pc >= vma + size)
    return;

  found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc - vma,
                                               &filename, &functionname,
                                               &line, &discriminator);
}

/* Look for an offset in a section.  This is directly called.  */

static void
find_offset_in_section (bfd *abfd, asection *section)
{
  bfd_size_type size;

  if (found)
    return;

  if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
    return;

  size = bfd_get_section_size (section);
  if (pc >= size)
    return;

  found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc,
                                               &filename, &functionname,
                                               &line, &discriminator);
}

/* Read hexadecimal addresses from stdin, translate into
   file_name:line_number and optionally function name.  */

static void
translate_addresses (bfd *abfd, asection *section)
{
  int read_stdin = (naddr == 0);

  for (;;)
    {
      if (read_stdin)
	{
	  char addr_hex[100];

	  if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
	    break;
	  pc = bfd_scan_vma (addr_hex, NULL, 16);
	}
      else
	{
	  if (naddr <= 0)
	    break;
	  --naddr;
	  pc = bfd_scan_vma (*addr++, NULL, 16);
	}

      if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
	{
	  const struct elf_backend_data *bed = get_elf_backend_data (abfd);
	  bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);

	  pc &= (sign << 1) - 1;
	  if (bed->sign_extend_vma)
	    pc = (pc ^ sign) - sign;
	}

      if (with_addresses)
        {
          printf ("0x");
          bfd_printf_vma (abfd, pc);

          if (pretty_print)
            printf (": ");
          else
            printf ("\n");
        }

      found = FALSE;
      if (section)
	find_offset_in_section (abfd, section);
      else
	bfd_map_over_sections (abfd, find_address_in_section, NULL);

      if (! found)
	{
	  if (with_functions)
	    {
	      if (pretty_print)
		printf ("?? ");
	      else
		printf ("??\n");
	    }
	  printf ("??:0\n");
	}
      else
	{
	  while (1)
            {
              if (with_functions)
                {
                  const char *name;
                  char *alloc = NULL;

                  name = functionname;
                  if (name == NULL || *name == '\0')
                    name = "??";
                  else if (do_demangle)
                    {
                      alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
                      if (alloc != NULL)
                        name = alloc;
                    }

                  printf ("%s", name);
                  if (pretty_print)
		    /* Note for translators:  This printf is used to join the
		       function name just printed above to the line number/
		       file name pair that is about to be printed below.  Eg:

		         foo at 123:bar.c  */
                    printf (_(" at "));
                  else
                    printf ("\n");

                  if (alloc != NULL)
                    free (alloc);
                }

              if (base_names && filename != NULL)
                {
                  char *h;

                  h = strrchr (filename, '/');
                  if (h != NULL)
                    filename = h + 1;
                }

              printf ("%s:", filename ? filename : "??");
	      if (line != 0)
                {
                  if (discriminator != 0)
                    printf ("%u (discriminator %u)\n", line, discriminator);
                  else
                    printf ("%u\n", line);
                }
	      else
		printf ("?\n");
              if (!unwind_inlines)
                found = FALSE;
              else
                found = bfd_find_inliner_info (abfd, &filename, &functionname,
					       &line);
              if (! found)
                break;
              if (pretty_print)
		/* Note for translators: This printf is used to join the
		   line number/file name pair that has just been printed with
		   the line number/file name pair that is going to be printed
		   by the next iteration of the while loop.  Eg:

		     123:bar.c (inlined by) 456:main.c  */
                printf (_(" (inlined by) "));
            }
	}

      /* fflush() is essential for using this command as a server
         child process that reads addresses from a pipe and responds
         with line number information, processing one address at a
         time.  */
      fflush (stdout);
    }
}

/* Process a file.  Returns an exit value for main().  */

static int
process_file (const char *file_name, const char *section_name,
	      const char *target)
{
  bfd *abfd;
  asection *section;
  char **matching;

  if (get_file_size (file_name) < 1)
    return 1;

  abfd = bfd_openr (file_name, target);
  if (abfd == NULL)
    bfd_fatal (file_name);

  /* Decompress sections.  */
  abfd->flags |= BFD_DECOMPRESS;

  if (bfd_check_format (abfd, bfd_archive))
    fatal (_("%s: cannot get addresses from archive"), file_name);

  if (! bfd_check_format_matches (abfd, bfd_object, &matching))
    {
      bfd_nonfatal (bfd_get_filename (abfd));
      if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
	{
	  list_matching_formats (matching);
	  free (matching);
	}
      xexit (1);
    }

  if (section_name != NULL)
    {
      section = bfd_get_section_by_name (abfd, section_name);
      if (section == NULL)
	fatal (_("%s: cannot find section %s"), file_name, section_name);
    }
  else
    section = NULL;

  slurp_symtab (abfd);

  translate_addresses (abfd, section);

  if (syms != NULL)
    {
      free (syms);
      syms = NULL;
    }

  bfd_close (abfd);

  return 0;
}
\f
int
main (int argc, char **argv)
{
  const char *file_name;
  const char *section_name;
  char *target;
  int c;

#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
  setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
  setlocale (LC_CTYPE, "");
#endif
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

  program_name = *argv;
  xmalloc_set_program_name (program_name);

  expandargv (&argc, &argv);

  bfd_init ();
  set_default_bfd_target ();

  file_name = NULL;
  section_name = NULL;
  target = NULL;
  while ((c = getopt_long (argc, argv, "ab:Ce:sfHhij:pVv", long_options, (int *) 0))
	 != EOF)
    {
      switch (c)
	{
	case 0:
	  break;		/* We've been given a long option.  */
	case 'a':
	  with_addresses = TRUE;
	  break;
	case 'b':
	  target = optarg;
	  break;
	case 'C':
	  do_demangle = TRUE;
	  if (optarg != NULL)
	    {
	      enum demangling_styles style;

	      style = cplus_demangle_name_to_style (optarg);
	      if (style == unknown_demangling)
		fatal (_("unknown demangling style `%s'"),
		       optarg);

	      cplus_demangle_set_style (style);
	    }
	  break;
	case 'e':
	  file_name = optarg;
	  break;
	case 's':
	  base_names = TRUE;
	  break;
	case 'f':
	  with_functions = TRUE;
	  break;
        case 'p':
          pretty_print = TRUE;
          break;
	case 'v':
	case 'V':
	  print_version ("addr2line");
	  break;
	case 'h':
	case 'H':
	  usage (stdout, 0);
	  break;
	case 'i':
	  unwind_inlines = TRUE;
	  break;
	case 'j':
	  section_name = optarg;
	  break;
	default:
	  usage (stderr, 1);
	  break;
	}
    }

  if (file_name == NULL)
    file_name = "a.out";

  addr = argv + optind;
  naddr = argc - optind;

  return process_file (file_name, section_name, target);
}
Commit	Line	Data
252b5132	1	/* addr2line.c -- convert addresses to line number and function name
3f5e193b NC	2	Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3f5e193b NC	3	2007, 2009 Free Software Foundation, Inc.
c8c5888e	4	Contributed by Ulrich Lauther <Ulrich.Lauther@mchp.siemens.de>
252b5132 RH	5
	6	This file is part of GNU Binutils.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
32866df7	10	the Free Software Foundation; either version 3, or (at your option)
252b5132 RH	11	any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
32866df7 NC	20	Foundation, 51 Franklin Street - Fifth Floor, Boston,
	21	MA 02110-1301, USA. */
	22
252b5132	23
c8c5888e	24	/* Derived from objdump.c and nm.c by Ulrich.Lauther@mchp.siemens.de
252b5132	25
f462a9ea	26	Usage:
252b5132 RH	27	addr2line [options] addr addr ...
252b5132 RH	28	or
f462a9ea	29	addr2line [options]
252b5132 RH	30
	31	both forms write results to stdout, the second form reads addresses
	32	to be converted from stdin. */
	33
3db64b00	34	#include "sysdep.h"
252b5132 RH	35	#include "bfd.h"
	36	#include "getopt.h"
	37	#include "libiberty.h"
	38	#include "demangle.h"
	39	#include "bucomm.h"
877c169d	40	#include "elf-bfd.h"
252b5132	41
0c552dc1	42	static bfd_boolean unwind_inlines; /* -i, unwind inlined functions. */
be6f6493	43	static bfd_boolean with_addresses; /* -a, show addresses. */
b34976b6 AM	44	static bfd_boolean with_functions; /* -f, show function names. */
b34976b6 AM	45	static bfd_boolean do_demangle; /* -C, demangle names. */
68cdf72f	46	static bfd_boolean pretty_print; /* -p, print on one line. */
b34976b6	47	static bfd_boolean base_names; /* -s, strip directory names. */
252b5132 RH	48
	49	static int naddr; /* Number of addresses to process. */
	50	static char *addr; / Hex addresses to process. */
	51
	52	static asymbol *syms; / Symbol table. */
	53
	54	static struct option long_options[] =
	55	{
be6f6493	56	{"addresses", no_argument, NULL, 'a'},
252b5132	57	{"basenames", no_argument, NULL, 's'},
28c309a2	58	{"demangle", optional_argument, NULL, 'C'},
252b5132 RH	59	{"exe", required_argument, NULL, 'e'},
252b5132 RH	60	{"functions", no_argument, NULL, 'f'},
0c552dc1	61	{"inlines", no_argument, NULL, 'i'},
68cdf72f	62	{"pretty-print", no_argument, NULL, 'p'},
c5f8c388	63	{"section", required_argument, NULL, 'j'},
252b5132 RH	64	{"target", required_argument, NULL, 'b'},
	65	{"help", no_argument, NULL, 'H'},
	66	{"version", no_argument, NULL, 'V'},
	67	{0, no_argument, 0, 0}
	68	};
	69
2da42df6 AJ	70	static void usage (FILE *, int);
	71	static void slurp_symtab (bfd *);
	72	static void find_address_in_section (bfd , asection , void *);
c5f8c388 EB	73	static void find_offset_in_section (bfd , asection );
c5f8c388 EB	74	static void translate_addresses (bfd , asection );
252b5132 RH	75	\f
	76	/* Print a usage message to STREAM and exit with STATUS. */
	77
	78	static void
2da42df6	79	usage (FILE *stream, int status)
252b5132	80	{
8b53311e NC	81	fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
	82	fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
	83	fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
	84	fprintf (stream, _(" The options are:\n\
07012eee	85	@<file> Read options from <file>\n\
be6f6493	86	-a --addresses Show addresses\n\
8b53311e NC	87	-b --target=<bfdname> Set the binary file format\n\
8b53311e NC	88	-e --exe=<executable> Set the input file name (default is a.out)\n\
c5f8c388 EB	89	-i --inlines Unwind inlined functions\n\
c5f8c388 EB	90	-j --section=<name> Read section-relative offsets instead of addresses\n\
68cdf72f	91	-p --pretty-print Make the output easier to read for humans\n\
8b53311e NC	92	-s --basenames Strip directory names\n\
	93	-f --functions Show function names\n\
	94	-C --demangle[=style] Demangle function names\n\
	95	-h --help Display this information\n\
	96	-v --version Display the program's version\n\
	97	\n"));
	98
252b5132	99	list_supported_targets (program_name, stream);
92f01d61	100	if (REPORT_BUGS_TO[0] && status == 0)
8ad3436c	101	fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 RH	102	exit (status);
	103	}
	104	\f
	105	/* Read in the symbol table. */
	106
	107	static void
2da42df6	108	slurp_symtab (bfd *abfd)
252b5132	109	{
d5e7ea07	110	long storage;
252b5132	111	long symcount;
d5e7ea07	112	bfd_boolean dynamic = FALSE;
252b5132 RH	113
	114	if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
	115	return;
	116
d5e7ea07 AM	117	storage = bfd_get_symtab_upper_bound (abfd);
	118	if (storage == 0)
	119	{
	120	storage = bfd_get_dynamic_symtab_upper_bound (abfd);
	121	dynamic = TRUE;
	122	}
	123	if (storage < 0)
	124	bfd_fatal (bfd_get_filename (abfd));
252b5132	125
d5e7ea07 AM	126	syms = (asymbol **) xmalloc (storage);
	127	if (dynamic)
	128	symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
	129	else
	130	symcount = bfd_canonicalize_symtab (abfd, syms);
252b5132 RH	131	if (symcount < 0)
	132	bfd_fatal (bfd_get_filename (abfd));
	133	}
	134	\f
	135	/* These global variables are used to pass information between
	136	translate_addresses and find_address_in_section. */
	137
	138	static bfd_vma pc;
	139	static const char *filename;
	140	static const char *functionname;
	141	static unsigned int line;
9b8d1a36	142	static unsigned int discriminator;
b34976b6	143	static bfd_boolean found;
252b5132 RH	144
	145	/* Look for an address in a section. This is called via
	146	bfd_map_over_sections. */
	147
	148	static void
2da42df6 AJ	149	find_address_in_section (bfd abfd, asection section,
2da42df6 AJ	150	void *data ATTRIBUTE_UNUSED)
252b5132 RH	151	{
	152	bfd_vma vma;
	153	bfd_size_type size;
	154
	155	if (found)
	156	return;
	157
	158	if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	159	return;
	160
	161	vma = bfd_get_section_vma (abfd, section);
	162	if (pc < vma)
	163	return;
	164
135dfb4a	165	size = bfd_get_section_size (section);
252b5132 RH	166	if (pc >= vma + size)
	167	return;
	168
9b8d1a36 CC	169	found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc - vma,
	170	&filename, &functionname,
	171	&line, &discriminator);
252b5132 RH	172	}
252b5132 RH	173
c5f8c388 EB	174	/* Look for an offset in a section. This is directly called. */
	175
	176	static void
	177	find_offset_in_section (bfd abfd, asection section)
	178	{
	179	bfd_size_type size;
	180
	181	if (found)
	182	return;
	183
	184	if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	185	return;
	186
	187	size = bfd_get_section_size (section);
	188	if (pc >= size)
	189	return;
	190
9b8d1a36 CC	191	found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc,
	192	&filename, &functionname,
	193	&line, &discriminator);
c5f8c388 EB	194	}
c5f8c388 EB	195
252b5132 RH	196	/* Read hexadecimal addresses from stdin, translate into
	197	file_name:line_number and optionally function name. */
	198
	199	static void
c5f8c388	200	translate_addresses (bfd abfd, asection section)
252b5132 RH	201	{
	202	int read_stdin = (naddr == 0);
	203
	204	for (;;)
	205	{
	206	if (read_stdin)
	207	{
	208	char addr_hex[100];
	209
	210	if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
	211	break;
	212	pc = bfd_scan_vma (addr_hex, NULL, 16);
	213	}
	214	else
	215	{
	216	if (naddr <= 0)
	217	break;
	218	--naddr;
	219	pc = bfd_scan_vma (*addr++, NULL, 16);
	220	}
	221
670b0bad AM	222	if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
	223	{
	224	const struct elf_backend_data *bed = get_elf_backend_data (abfd);
	225	bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);
	226
	227	pc &= (sign << 1) - 1;
	228	if (bed->sign_extend_vma)
	229	pc = (pc ^ sign) - sign;
	230	}
877c169d	231
be6f6493 TG	232	if (with_addresses)
	233	{
	234	printf ("0x");
	235	bfd_printf_vma (abfd, pc);
68cdf72f TG	236
	237	if (pretty_print)
	238	printf (": ");
	239	else
	240	printf ("\n");
be6f6493 TG	241	}
be6f6493 TG	242
b34976b6	243	found = FALSE;
c5f8c388 EB	244	if (section)
	245	find_offset_in_section (abfd, section);
	246	else
	247	bfd_map_over_sections (abfd, find_address_in_section, NULL);
252b5132 RH	248
	249	if (! found)
	250	{
	251	if (with_functions)
a477bfd1 NC	252	{
	253	if (pretty_print)
	254	printf ("?? ");
	255	else
	256	printf ("??\n");
	257	}
252b5132 RH	258	printf ("??:0\n");
	259	}
	260	else
	261	{
68cdf72f TG	262	while (1)
	263	{
	264	if (with_functions)
	265	{
	266	const char *name;
	267	char *alloc = NULL;
	268
	269	name = functionname;
	270	if (name == NULL \|\| *name == '\0')
	271	name = "??";
	272	else if (do_demangle)
	273	{
	274	alloc = bfd_demangle (abfd, name, DMGL_ANSI \| DMGL_PARAMS);
	275	if (alloc != NULL)
	276	name = alloc;
	277	}
	278
	279	printf ("%s", name);
	280	if (pretty_print)
9cf03b7e NC	281	/* Note for translators: This printf is used to join the
	282	function name just printed above to the line number/
	283	file name pair that is about to be printed below. Eg:
	284
	285	foo at 123:bar.c */
68cdf72f TG	286	printf (_(" at "));
	287	else
	288	printf ("\n");
	289
	290	if (alloc != NULL)
	291	free (alloc);
	292	}
	293
	294	if (base_names && filename != NULL)
	295	{
	296	char *h;
	297
	298	h = strrchr (filename, '/');
	299	if (h != NULL)
	300	filename = h + 1;
	301	}
	302
670b0bad AM	303	printf ("%s:", filename ? filename : "??");
670b0bad AM	304	if (line != 0)
9b8d1a36 CC	305	{
	306	if (discriminator != 0)
	307	printf ("%u (discriminator %u)\n", line, discriminator);
	308	else
	309	printf ("%u\n", line);
	310	}
670b0bad AM	311	else
670b0bad AM	312	printf ("?\n");
68cdf72f TG	313	if (!unwind_inlines)
	314	found = FALSE;
	315	else
9cf03b7e NC	316	found = bfd_find_inliner_info (abfd, &filename, &functionname,
9cf03b7e NC	317	&line);
68cdf72f TG	318	if (! found)
	319	break;
	320	if (pretty_print)
9cf03b7e NC	321	/* Note for translators: This printf is used to join the
	322	line number/file name pair that has just been printed with
	323	the line number/file name pair that is going to be printed
	324	by the next iteration of the while loop. Eg:
	325
	326	123:bar.c (inlined by) 456:main.c */
68cdf72f TG	327	printf (_(" (inlined by) "));
68cdf72f TG	328	}
252b5132 RH	329	}
	330
	331	/* fflush() is essential for using this command as a server
	332	child process that reads addresses from a pipe and responds
	333	with line number information, processing one address at a
	334	time. */
	335	fflush (stdout);
	336	}
	337	}
	338
d68c385b	339	/* Process a file. Returns an exit value for main(). */
252b5132	340
d68c385b	341	static int
c5f8c388 EB	342	process_file (const char file_name, const char section_name,
c5f8c388 EB	343	const char *target)
252b5132 RH	344	{
252b5132 RH	345	bfd *abfd;
c5f8c388	346	asection *section;
252b5132 RH	347	char **matching;
252b5132 RH	348
f24ddbdd	349	if (get_file_size (file_name) < 1)
d68c385b	350	return 1;
f24ddbdd	351
47badb7b	352	abfd = bfd_openr (file_name, target);
252b5132	353	if (abfd == NULL)
47badb7b	354	bfd_fatal (file_name);
252b5132	355
4a114e3e L	356	/* Decompress sections. */
	357	abfd->flags \|= BFD_DECOMPRESS;
	358
252b5132	359	if (bfd_check_format (abfd, bfd_archive))
c5f8c388	360	fatal (_("%s: cannot get addresses from archive"), file_name);
252b5132 RH	361
	362	if (! bfd_check_format_matches (abfd, bfd_object, &matching))
	363	{
	364	bfd_nonfatal (bfd_get_filename (abfd));
	365	if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
	366	{
	367	list_matching_formats (matching);
	368	free (matching);
	369	}
	370	xexit (1);
	371	}
	372
c5f8c388 EB	373	if (section_name != NULL)
	374	{
	375	section = bfd_get_section_by_name (abfd, section_name);
	376	if (section == NULL)
	377	fatal (_("%s: cannot find section %s"), file_name, section_name);
	378	}
	379	else
	380	section = NULL;
	381
252b5132 RH	382	slurp_symtab (abfd);
252b5132 RH	383
c5f8c388	384	translate_addresses (abfd, section);
252b5132 RH	385
	386	if (syms != NULL)
	387	{
	388	free (syms);
	389	syms = NULL;
	390	}
	391
	392	bfd_close (abfd);
d68c385b NC	393
d68c385b NC	394	return 0;
252b5132 RH	395	}
	396	\f
	397	int
2da42df6	398	main (int argc, char **argv)
252b5132	399	{
47badb7b	400	const char *file_name;
c5f8c388	401	const char *section_name;
252b5132 RH	402	char *target;
	403	int c;
	404
	405	#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
	406	setlocale (LC_MESSAGES, "");
3882b010 L	407	#endif
	408	#if defined (HAVE_SETLOCALE)
	409	setlocale (LC_CTYPE, "");
252b5132 RH	410	#endif
	411	bindtextdomain (PACKAGE, LOCALEDIR);
	412	textdomain (PACKAGE);
	413
	414	program_name = *argv;
	415	xmalloc_set_program_name (program_name);
	416
869b9d07 MM	417	expandargv (&argc, &argv);
869b9d07 MM	418
252b5132 RH	419	bfd_init ();
	420	set_default_bfd_target ();
	421
47badb7b	422	file_name = NULL;
c5f8c388	423	section_name = NULL;
252b5132	424	target = NULL;
68cdf72f	425	while ((c = getopt_long (argc, argv, "ab:Ce:sfHhij:pVv", long_options, (int *) 0))
252b5132 RH	426	!= EOF)
	427	{
	428	switch (c)
	429	{
	430	case 0:
8b53311e	431	break; /* We've been given a long option. */
be6f6493 TG	432	case 'a':
	433	with_addresses = TRUE;
	434	break;
252b5132 RH	435	case 'b':
	436	target = optarg;
	437	break;
	438	case 'C':
b34976b6	439	do_demangle = TRUE;
28c309a2 NC	440	if (optarg != NULL)
	441	{
	442	enum demangling_styles style;
f462a9ea	443
28c309a2	444	style = cplus_demangle_name_to_style (optarg);
f462a9ea	445	if (style == unknown_demangling)
28c309a2 NC	446	fatal (_("unknown demangling style `%s'"),
28c309a2 NC	447	optarg);
f462a9ea	448
28c309a2	449	cplus_demangle_set_style (style);
f462a9ea	450	}
252b5132 RH	451	break;
252b5132 RH	452	case 'e':
47badb7b	453	file_name = optarg;
252b5132 RH	454	break;
252b5132 RH	455	case 's':
b34976b6	456	base_names = TRUE;
252b5132 RH	457	break;
252b5132 RH	458	case 'f':
b34976b6	459	with_functions = TRUE;
252b5132	460	break;
68cdf72f TG	461	case 'p':
	462	pretty_print = TRUE;
	463	break;
8b53311e	464	case 'v':
252b5132 RH	465	case 'V':
	466	print_version ("addr2line");
	467	break;
8b53311e	468	case 'h':
252b5132 RH	469	case 'H':
	470	usage (stdout, 0);
	471	break;
0c552dc1 FF	472	case 'i':
	473	unwind_inlines = TRUE;
	474	break;
c5f8c388 EB	475	case 'j':
	476	section_name = optarg;
	477	break;
252b5132 RH	478	default:
	479	usage (stderr, 1);
	480	break;
	481	}
	482	}
	483
47badb7b NC	484	if (file_name == NULL)
47badb7b NC	485	file_name = "a.out";
252b5132 RH	486
	487	addr = argv + optind;
	488	naddr = argc - optind;
	489
d68c385b	490	return process_file (file_name, section_name, target);
252b5132	491	}