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