[thirdparty/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 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 (abfd, section, syms, pc - vma,
				 &filename, &functionname, &line);
}

/* 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 (abfd, section, syms, pc,
				 &filename, &functionname, &line);
}

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

static void
translate_addresses (bfd *abfd, asection *section)
{
  const struct elf_backend_data * bed;

  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
	  && (bed = get_elf_backend_data (abfd)) != NULL
	  && bed->sign_extend_vma
	  && (pc & (bfd_vma) 1 << (bed->s->arch_size - 1)))
	pc |= ((bfd_vma) -1) << bed->s->arch_size;

      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)
	    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:%u\n", filename ? filename : "??", line);
              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;
b34976b6	142	static bfd_boolean found;
252b5132 RH	143
	144	/* Look for an address in a section. This is called via
	145	bfd_map_over_sections. */
	146
	147	static void
2da42df6 AJ	148	find_address_in_section (bfd abfd, asection section,
2da42df6 AJ	149	void *data ATTRIBUTE_UNUSED)
252b5132 RH	150	{
	151	bfd_vma vma;
	152	bfd_size_type size;
	153
	154	if (found)
	155	return;
	156
	157	if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	158	return;
	159
	160	vma = bfd_get_section_vma (abfd, section);
	161	if (pc < vma)
	162	return;
	163
135dfb4a	164	size = bfd_get_section_size (section);
252b5132 RH	165	if (pc >= vma + size)
	166	return;
	167
	168	found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
	169	&filename, &functionname, &line);
	170	}
	171
c5f8c388 EB	172	/* Look for an offset in a section. This is directly called. */
	173
	174	static void
	175	find_offset_in_section (bfd abfd, asection section)
	176	{
	177	bfd_size_type size;
	178
	179	if (found)
	180	return;
	181
	182	if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	183	return;
	184
	185	size = bfd_get_section_size (section);
	186	if (pc >= size)
	187	return;
	188
	189	found = bfd_find_nearest_line (abfd, section, syms, pc,
	190	&filename, &functionname, &line);
	191	}
	192
252b5132 RH	193	/* Read hexadecimal addresses from stdin, translate into
	194	file_name:line_number and optionally function name. */
	195
	196	static void
c5f8c388	197	translate_addresses (bfd abfd, asection section)
252b5132	198	{
877c169d CM	199	const struct elf_backend_data * bed;
877c169d CM	200
252b5132 RH	201	int read_stdin = (naddr == 0);
	202
	203	for (;;)
	204	{
	205	if (read_stdin)
	206	{
	207	char addr_hex[100];
	208
	209	if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
	210	break;
	211	pc = bfd_scan_vma (addr_hex, NULL, 16);
	212	}
	213	else
	214	{
	215	if (naddr <= 0)
	216	break;
	217	--naddr;
	218	pc = bfd_scan_vma (*addr++, NULL, 16);
	219	}
	220
877c169d CM	221	if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
	222	&& (bed = get_elf_backend_data (abfd)) != NULL
	223	&& bed->sign_extend_vma
	224	&& (pc & (bfd_vma) 1 << (bed->s->arch_size - 1)))
	225	pc \|= ((bfd_vma) -1) << bed->s->arch_size;
	226
be6f6493 TG	227	if (with_addresses)
	228	{
	229	printf ("0x");
	230	bfd_printf_vma (abfd, pc);
68cdf72f TG	231
	232	if (pretty_print)
	233	printf (": ");
	234	else
	235	printf ("\n");
be6f6493 TG	236	}
be6f6493 TG	237
b34976b6	238	found = FALSE;
c5f8c388 EB	239	if (section)
	240	find_offset_in_section (abfd, section);
	241	else
	242	bfd_map_over_sections (abfd, find_address_in_section, NULL);
252b5132 RH	243
	244	if (! found)
	245	{
	246	if (with_functions)
	247	printf ("??\n");
	248	printf ("??:0\n");
	249	}
	250	else
	251	{
68cdf72f TG	252	while (1)
	253	{
	254	if (with_functions)
	255	{
	256	const char *name;
	257	char *alloc = NULL;
	258
	259	name = functionname;
	260	if (name == NULL \|\| *name == '\0')
	261	name = "??";
	262	else if (do_demangle)
	263	{
	264	alloc = bfd_demangle (abfd, name, DMGL_ANSI \| DMGL_PARAMS);
	265	if (alloc != NULL)
	266	name = alloc;
	267	}
	268
	269	printf ("%s", name);
	270	if (pretty_print)
9cf03b7e NC	271	/* Note for translators: This printf is used to join the
	272	function name just printed above to the line number/
	273	file name pair that is about to be printed below. Eg:
	274
	275	foo at 123:bar.c */
68cdf72f TG	276	printf (_(" at "));
	277	else
	278	printf ("\n");
	279
	280	if (alloc != NULL)
	281	free (alloc);
	282	}
	283
	284	if (base_names && filename != NULL)
	285	{
	286	char *h;
	287
	288	h = strrchr (filename, '/');
	289	if (h != NULL)
	290	filename = h + 1;
	291	}
	292
	293	printf ("%s:%u\n", filename ? filename : "??", line);
	294	if (!unwind_inlines)
	295	found = FALSE;
	296	else
9cf03b7e NC	297	found = bfd_find_inliner_info (abfd, &filename, &functionname,
9cf03b7e NC	298	&line);
68cdf72f TG	299	if (! found)
	300	break;
	301	if (pretty_print)
9cf03b7e NC	302	/* Note for translators: This printf is used to join the
	303	line number/file name pair that has just been printed with
	304	the line number/file name pair that is going to be printed
	305	by the next iteration of the while loop. Eg:
	306
	307	123:bar.c (inlined by) 456:main.c */
68cdf72f TG	308	printf (_(" (inlined by) "));
68cdf72f TG	309	}
252b5132 RH	310	}
	311
	312	/* fflush() is essential for using this command as a server
	313	child process that reads addresses from a pipe and responds
	314	with line number information, processing one address at a
	315	time. */
	316	fflush (stdout);
	317	}
	318	}
	319
d68c385b	320	/* Process a file. Returns an exit value for main(). */
252b5132	321
d68c385b	322	static int
c5f8c388 EB	323	process_file (const char file_name, const char section_name,
c5f8c388 EB	324	const char *target)
252b5132 RH	325	{
252b5132 RH	326	bfd *abfd;
c5f8c388	327	asection *section;
252b5132 RH	328	char **matching;
252b5132 RH	329
f24ddbdd	330	if (get_file_size (file_name) < 1)
d68c385b	331	return 1;
f24ddbdd	332
47badb7b	333	abfd = bfd_openr (file_name, target);
252b5132	334	if (abfd == NULL)
47badb7b	335	bfd_fatal (file_name);
252b5132	336
4a114e3e L	337	/* Decompress sections. */
	338	abfd->flags \|= BFD_DECOMPRESS;
	339
252b5132	340	if (bfd_check_format (abfd, bfd_archive))
c5f8c388	341	fatal (_("%s: cannot get addresses from archive"), file_name);
252b5132 RH	342
	343	if (! bfd_check_format_matches (abfd, bfd_object, &matching))
	344	{
	345	bfd_nonfatal (bfd_get_filename (abfd));
	346	if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
	347	{
	348	list_matching_formats (matching);
	349	free (matching);
	350	}
	351	xexit (1);
	352	}
	353
c5f8c388 EB	354	if (section_name != NULL)
	355	{
	356	section = bfd_get_section_by_name (abfd, section_name);
	357	if (section == NULL)
	358	fatal (_("%s: cannot find section %s"), file_name, section_name);
	359	}
	360	else
	361	section = NULL;
	362
252b5132 RH	363	slurp_symtab (abfd);
252b5132 RH	364
c5f8c388	365	translate_addresses (abfd, section);
252b5132 RH	366
	367	if (syms != NULL)
	368	{
	369	free (syms);
	370	syms = NULL;
	371	}
	372
	373	bfd_close (abfd);
d68c385b NC	374
d68c385b NC	375	return 0;
252b5132 RH	376	}
	377	\f
	378	int
2da42df6	379	main (int argc, char **argv)
252b5132	380	{
47badb7b	381	const char *file_name;
c5f8c388	382	const char *section_name;
252b5132 RH	383	char *target;
	384	int c;
	385
	386	#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
	387	setlocale (LC_MESSAGES, "");
3882b010 L	388	#endif
	389	#if defined (HAVE_SETLOCALE)
	390	setlocale (LC_CTYPE, "");
252b5132 RH	391	#endif
	392	bindtextdomain (PACKAGE, LOCALEDIR);
	393	textdomain (PACKAGE);
	394
	395	program_name = *argv;
	396	xmalloc_set_program_name (program_name);
	397
869b9d07 MM	398	expandargv (&argc, &argv);
869b9d07 MM	399
252b5132 RH	400	bfd_init ();
	401	set_default_bfd_target ();
	402
47badb7b	403	file_name = NULL;
c5f8c388	404	section_name = NULL;
252b5132	405	target = NULL;
68cdf72f	406	while ((c = getopt_long (argc, argv, "ab:Ce:sfHhij:pVv", long_options, (int *) 0))
252b5132 RH	407	!= EOF)
	408	{
	409	switch (c)
	410	{
	411	case 0:
8b53311e	412	break; /* We've been given a long option. */
be6f6493 TG	413	case 'a':
	414	with_addresses = TRUE;
	415	break;
252b5132 RH	416	case 'b':
	417	target = optarg;
	418	break;
	419	case 'C':
b34976b6	420	do_demangle = TRUE;
28c309a2 NC	421	if (optarg != NULL)
	422	{
	423	enum demangling_styles style;
f462a9ea	424
28c309a2	425	style = cplus_demangle_name_to_style (optarg);
f462a9ea	426	if (style == unknown_demangling)
28c309a2 NC	427	fatal (_("unknown demangling style `%s'"),
28c309a2 NC	428	optarg);
f462a9ea	429
28c309a2	430	cplus_demangle_set_style (style);
f462a9ea	431	}
252b5132 RH	432	break;
252b5132 RH	433	case 'e':
47badb7b	434	file_name = optarg;
252b5132 RH	435	break;
252b5132 RH	436	case 's':
b34976b6	437	base_names = TRUE;
252b5132 RH	438	break;
252b5132 RH	439	case 'f':
b34976b6	440	with_functions = TRUE;
252b5132	441	break;
68cdf72f TG	442	case 'p':
	443	pretty_print = TRUE;
	444	break;
8b53311e	445	case 'v':
252b5132 RH	446	case 'V':
	447	print_version ("addr2line");
	448	break;
8b53311e	449	case 'h':
252b5132 RH	450	case 'H':
	451	usage (stdout, 0);
	452	break;
0c552dc1 FF	453	case 'i':
	454	unwind_inlines = TRUE;
	455	break;
c5f8c388 EB	456	case 'j':
	457	section_name = optarg;
	458	break;
252b5132 RH	459	default:
	460	usage (stderr, 1);
	461	break;
	462	}
	463	}
	464
47badb7b NC	465	if (file_name == NULL)
47badb7b NC	466	file_name = "a.out";
252b5132 RH	467
	468	addr = argv + optind;
	469	naddr = argc - optind;
	470
d68c385b	471	return process_file (file_name, section_name, target);
252b5132	472	}