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