[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"

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)
{
  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 (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)
                    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)
                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);

  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"
	40
0c552dc1	41	static bfd_boolean unwind_inlines; /* -i, unwind inlined functions. */
be6f6493	42	static bfd_boolean with_addresses; /* -a, show addresses. */
b34976b6 AM	43	static bfd_boolean with_functions; /* -f, show function names. */
b34976b6 AM	44	static bfd_boolean do_demangle; /* -C, demangle names. */
68cdf72f	45	static bfd_boolean pretty_print; /* -p, print on one line. */
b34976b6	46	static bfd_boolean base_names; /* -s, strip directory names. */
252b5132 RH	47
	48	static int naddr; /* Number of addresses to process. */
	49	static char *addr; / Hex addresses to process. */
	50
	51	static asymbol *syms; / Symbol table. */
	52
	53	static struct option long_options[] =
	54	{
be6f6493	55	{"addresses", no_argument, NULL, 'a'},
252b5132	56	{"basenames", no_argument, NULL, 's'},
28c309a2	57	{"demangle", optional_argument, NULL, 'C'},
252b5132 RH	58	{"exe", required_argument, NULL, 'e'},
252b5132 RH	59	{"functions", no_argument, NULL, 'f'},
0c552dc1	60	{"inlines", no_argument, NULL, 'i'},
68cdf72f	61	{"pretty-print", no_argument, NULL, 'p'},
c5f8c388	62	{"section", required_argument, NULL, 'j'},
252b5132 RH	63	{"target", required_argument, NULL, 'b'},
	64	{"help", no_argument, NULL, 'H'},
	65	{"version", no_argument, NULL, 'V'},
	66	{0, no_argument, 0, 0}
	67	};
	68
2da42df6 AJ	69	static void usage (FILE *, int);
	70	static void slurp_symtab (bfd *);
	71	static void find_address_in_section (bfd , asection , void *);
c5f8c388 EB	72	static void find_offset_in_section (bfd , asection );
c5f8c388 EB	73	static void translate_addresses (bfd , asection );
252b5132 RH	74	\f
	75	/* Print a usage message to STREAM and exit with STATUS. */
	76
	77	static void
2da42df6	78	usage (FILE *stream, int status)
252b5132	79	{
8b53311e NC	80	fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
	81	fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
	82	fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
	83	fprintf (stream, _(" The options are:\n\
07012eee	84	@<file> Read options from <file>\n\
be6f6493	85	-a --addresses Show addresses\n\
8b53311e NC	86	-b --target=<bfdname> Set the binary file format\n\
8b53311e NC	87	-e --exe=<executable> Set the input file name (default is a.out)\n\
c5f8c388 EB	88	-i --inlines Unwind inlined functions\n\
c5f8c388 EB	89	-j --section=<name> Read section-relative offsets instead of addresses\n\
68cdf72f	90	-p --pretty-print Make the output easier to read for humans\n\
8b53311e NC	91	-s --basenames Strip directory names\n\
	92	-f --functions Show function names\n\
	93	-C --demangle[=style] Demangle function names\n\
	94	-h --help Display this information\n\
	95	-v --version Display the program's version\n\
	96	\n"));
	97
252b5132	98	list_supported_targets (program_name, stream);
92f01d61	99	if (REPORT_BUGS_TO[0] && status == 0)
8ad3436c	100	fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
252b5132 RH	101	exit (status);
	102	}
	103	\f
	104	/* Read in the symbol table. */
	105
	106	static void
2da42df6	107	slurp_symtab (bfd *abfd)
252b5132	108	{
d5e7ea07	109	long storage;
252b5132	110	long symcount;
d5e7ea07	111	bfd_boolean dynamic = FALSE;
252b5132 RH	112
	113	if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
	114	return;
	115
d5e7ea07 AM	116	storage = bfd_get_symtab_upper_bound (abfd);
	117	if (storage == 0)
	118	{
	119	storage = bfd_get_dynamic_symtab_upper_bound (abfd);
	120	dynamic = TRUE;
	121	}
	122	if (storage < 0)
	123	bfd_fatal (bfd_get_filename (abfd));
252b5132	124
d5e7ea07 AM	125	syms = (asymbol **) xmalloc (storage);
	126	if (dynamic)
	127	symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
	128	else
	129	symcount = bfd_canonicalize_symtab (abfd, syms);
252b5132 RH	130	if (symcount < 0)
	131	bfd_fatal (bfd_get_filename (abfd));
	132	}
	133	\f
	134	/* These global variables are used to pass information between
	135	translate_addresses and find_address_in_section. */
	136
	137	static bfd_vma pc;
	138	static const char *filename;
	139	static const char *functionname;
	140	static unsigned int line;
b34976b6	141	static bfd_boolean found;
252b5132 RH	142
	143	/* Look for an address in a section. This is called via
	144	bfd_map_over_sections. */
	145
	146	static void
2da42df6 AJ	147	find_address_in_section (bfd abfd, asection section,
2da42df6 AJ	148	void *data ATTRIBUTE_UNUSED)
252b5132 RH	149	{
	150	bfd_vma vma;
	151	bfd_size_type size;
	152
	153	if (found)
	154	return;
	155
	156	if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	157	return;
	158
	159	vma = bfd_get_section_vma (abfd, section);
	160	if (pc < vma)
	161	return;
	162
135dfb4a	163	size = bfd_get_section_size (section);
252b5132 RH	164	if (pc >= vma + size)
	165	return;
	166
	167	found = bfd_find_nearest_line (abfd, section, syms, pc - vma,
	168	&filename, &functionname, &line);
	169	}
	170
c5f8c388 EB	171	/* Look for an offset in a section. This is directly called. */
	172
	173	static void
	174	find_offset_in_section (bfd abfd, asection section)
	175	{
	176	bfd_size_type size;
	177
	178	if (found)
	179	return;
	180
	181	if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0)
	182	return;
	183
	184	size = bfd_get_section_size (section);
	185	if (pc >= size)
	186	return;
	187
	188	found = bfd_find_nearest_line (abfd, section, syms, pc,
	189	&filename, &functionname, &line);
	190	}
	191
252b5132 RH	192	/* Read hexadecimal addresses from stdin, translate into
	193	file_name:line_number and optionally function name. */
	194
	195	static void
c5f8c388	196	translate_addresses (bfd abfd, asection section)
252b5132 RH	197	{
	198	int read_stdin = (naddr == 0);
	199
	200	for (;;)
	201	{
	202	if (read_stdin)
	203	{
	204	char addr_hex[100];
	205
	206	if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
	207	break;
	208	pc = bfd_scan_vma (addr_hex, NULL, 16);
	209	}
	210	else
	211	{
	212	if (naddr <= 0)
	213	break;
	214	--naddr;
	215	pc = bfd_scan_vma (*addr++, NULL, 16);
	216	}
	217
be6f6493 TG	218	if (with_addresses)
	219	{
	220	printf ("0x");
	221	bfd_printf_vma (abfd, pc);
68cdf72f TG	222
	223	if (pretty_print)
	224	printf (": ");
	225	else
	226	printf ("\n");
be6f6493 TG	227	}
be6f6493 TG	228
b34976b6	229	found = FALSE;
c5f8c388 EB	230	if (section)
	231	find_offset_in_section (abfd, section);
	232	else
	233	bfd_map_over_sections (abfd, find_address_in_section, NULL);
252b5132 RH	234
	235	if (! found)
	236	{
	237	if (with_functions)
	238	printf ("??\n");
	239	printf ("??:0\n");
	240	}
	241	else
	242	{
68cdf72f TG	243	while (1)
	244	{
	245	if (with_functions)
	246	{
	247	const char *name;
	248	char *alloc = NULL;
	249
	250	name = functionname;
	251	if (name == NULL \|\| *name == '\0')
	252	name = "??";
	253	else if (do_demangle)
	254	{
	255	alloc = bfd_demangle (abfd, name, DMGL_ANSI \| DMGL_PARAMS);
	256	if (alloc != NULL)
	257	name = alloc;
	258	}
	259
	260	printf ("%s", name);
	261	if (pretty_print)
	262	printf (_(" at "));
	263	else
	264	printf ("\n");
	265
	266	if (alloc != NULL)
	267	free (alloc);
	268	}
	269
	270	if (base_names && filename != NULL)
	271	{
	272	char *h;
	273
	274	h = strrchr (filename, '/');
	275	if (h != NULL)
	276	filename = h + 1;
	277	}
	278
	279	printf ("%s:%u\n", filename ? filename : "??", line);
	280	if (!unwind_inlines)
	281	found = FALSE;
	282	else
	283	found = bfd_find_inliner_info (abfd, &filename, &functionname, &line);
	284	if (! found)
	285	break;
	286	if (pretty_print)
	287	printf (_(" (inlined by) "));
	288	}
252b5132 RH	289	}
	290
	291	/* fflush() is essential for using this command as a server
	292	child process that reads addresses from a pipe and responds
	293	with line number information, processing one address at a
	294	time. */
	295	fflush (stdout);
	296	}
	297	}
	298
d68c385b	299	/* Process a file. Returns an exit value for main(). */
252b5132	300
d68c385b	301	static int
c5f8c388 EB	302	process_file (const char file_name, const char section_name,
c5f8c388 EB	303	const char *target)
252b5132 RH	304	{
252b5132 RH	305	bfd *abfd;
c5f8c388	306	asection *section;
252b5132 RH	307	char **matching;
252b5132 RH	308
f24ddbdd	309	if (get_file_size (file_name) < 1)
d68c385b	310	return 1;
f24ddbdd	311
47badb7b	312	abfd = bfd_openr (file_name, target);
252b5132	313	if (abfd == NULL)
47badb7b	314	bfd_fatal (file_name);
252b5132 RH	315
252b5132 RH	316	if (bfd_check_format (abfd, bfd_archive))
c5f8c388	317	fatal (_("%s: cannot get addresses from archive"), file_name);
252b5132 RH	318
	319	if (! bfd_check_format_matches (abfd, bfd_object, &matching))
	320	{
	321	bfd_nonfatal (bfd_get_filename (abfd));
	322	if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
	323	{
	324	list_matching_formats (matching);
	325	free (matching);
	326	}
	327	xexit (1);
	328	}
	329
c5f8c388 EB	330	if (section_name != NULL)
	331	{
	332	section = bfd_get_section_by_name (abfd, section_name);
	333	if (section == NULL)
	334	fatal (_("%s: cannot find section %s"), file_name, section_name);
	335	}
	336	else
	337	section = NULL;
	338
252b5132 RH	339	slurp_symtab (abfd);
252b5132 RH	340
c5f8c388	341	translate_addresses (abfd, section);
252b5132 RH	342
	343	if (syms != NULL)
	344	{
	345	free (syms);
	346	syms = NULL;
	347	}
	348
	349	bfd_close (abfd);
d68c385b NC	350
d68c385b NC	351	return 0;
252b5132 RH	352	}
	353	\f
	354	int
2da42df6	355	main (int argc, char **argv)
252b5132	356	{
47badb7b	357	const char *file_name;
c5f8c388	358	const char *section_name;
252b5132 RH	359	char *target;
	360	int c;
	361
	362	#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
	363	setlocale (LC_MESSAGES, "");
3882b010 L	364	#endif
	365	#if defined (HAVE_SETLOCALE)
	366	setlocale (LC_CTYPE, "");
252b5132 RH	367	#endif
	368	bindtextdomain (PACKAGE, LOCALEDIR);
	369	textdomain (PACKAGE);
	370
	371	program_name = *argv;
	372	xmalloc_set_program_name (program_name);
	373
869b9d07 MM	374	expandargv (&argc, &argv);
869b9d07 MM	375
252b5132 RH	376	bfd_init ();
	377	set_default_bfd_target ();
	378
47badb7b	379	file_name = NULL;
c5f8c388	380	section_name = NULL;
252b5132	381	target = NULL;
68cdf72f	382	while ((c = getopt_long (argc, argv, "ab:Ce:sfHhij:pVv", long_options, (int *) 0))
252b5132 RH	383	!= EOF)
	384	{
	385	switch (c)
	386	{
	387	case 0:
8b53311e	388	break; /* We've been given a long option. */
be6f6493 TG	389	case 'a':
	390	with_addresses = TRUE;
	391	break;
252b5132 RH	392	case 'b':
	393	target = optarg;
	394	break;
	395	case 'C':
b34976b6	396	do_demangle = TRUE;
28c309a2 NC	397	if (optarg != NULL)
	398	{
	399	enum demangling_styles style;
f462a9ea	400
28c309a2	401	style = cplus_demangle_name_to_style (optarg);
f462a9ea	402	if (style == unknown_demangling)
28c309a2 NC	403	fatal (_("unknown demangling style `%s'"),
28c309a2 NC	404	optarg);
f462a9ea	405
28c309a2	406	cplus_demangle_set_style (style);
f462a9ea	407	}
252b5132 RH	408	break;
252b5132 RH	409	case 'e':
47badb7b	410	file_name = optarg;
252b5132 RH	411	break;
252b5132 RH	412	case 's':
b34976b6	413	base_names = TRUE;
252b5132 RH	414	break;
252b5132 RH	415	case 'f':
b34976b6	416	with_functions = TRUE;
252b5132	417	break;
68cdf72f TG	418	case 'p':
	419	pretty_print = TRUE;
	420	break;
8b53311e	421	case 'v':
252b5132 RH	422	case 'V':
	423	print_version ("addr2line");
	424	break;
8b53311e	425	case 'h':
252b5132 RH	426	case 'H':
	427	usage (stdout, 0);
	428	break;
0c552dc1 FF	429	case 'i':
	430	unwind_inlines = TRUE;
	431	break;
c5f8c388 EB	432	case 'j':
	433	section_name = optarg;
	434	break;
252b5132 RH	435	default:
	436	usage (stderr, 1);
	437	break;
	438	}
	439	}
	440
47badb7b NC	441	if (file_name == NULL)
47badb7b NC	442	file_name = "a.out";
252b5132 RH	443
	444	addr = argv + optind;
	445	naddr = argc - optind;
	446
d68c385b	447	return process_file (file_name, section_name, target);
252b5132	448	}