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