1 /* Locate source files and line information for given addresses 2 Copyright (C) 2005-2010, 2012, 2013, 2015 Red Hat, Inc. 3 This file is part of elfutils. 4 Written by Ulrich Drepper <drepper (at) redhat.com>, 2005. 5 6 This file is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 elfutils is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #ifdef HAVE_CONFIG_H 20 # include <config.h> 21 #endif 22 23 #include <argp.h> 24 #include <assert.h> 25 #include <errno.h> 26 #include <error.h> 27 #include <fcntl.h> 28 #include <inttypes.h> 29 #include <libdwfl.h> 30 #include <dwarf.h> 31 #include <libintl.h> 32 #include <locale.h> 33 #include <stdbool.h> 34 #include <stdio.h> 35 #include <stdio_ext.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <unistd.h> 39 40 #include <system.h> 41 42 43 /* Name and version of program. */ 44 static void print_version (FILE *stream, struct argp_state *state); 45 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version; 46 47 /* Bug report address. */ 48 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT; 49 50 51 /* Values for the parameters which have no short form. */ 52 #define OPT_DEMANGLER 0x100 53 #define OPT_PRETTY 0x101 /* 'p' is already used to select the process. */ 54 55 /* Definitions of arguments for argp functions. */ 56 static const struct argp_option options[] = 57 { 58 { NULL, 0, NULL, 0, N_("Input format options:"), 2 }, 59 { "section", 'j', "NAME", 0, 60 N_("Treat addresses as offsets relative to NAME section."), 0 }, 61 62 { NULL, 0, NULL, 0, N_("Output format options:"), 3 }, 63 { "addresses", 'a', NULL, 0, N_("Print address before each entry"), 0 }, 64 { "basenames", 's', NULL, 0, N_("Show only base names of source files"), 0 }, 65 { "absolute", 'A', NULL, 0, 66 N_("Show absolute file names using compilation directory"), 0 }, 67 { "functions", 'f', NULL, 0, N_("Also show function names"), 0 }, 68 { "symbols", 'S', NULL, 0, N_("Also show symbol or section names"), 0 }, 69 { "symbols-sections", 'x', NULL, 0, N_("Also show symbol and the section names"), 0 }, 70 { "flags", 'F', NULL, 0, N_("Also show line table flags"), 0 }, 71 { "inlines", 'i', NULL, 0, 72 N_("Show all source locations that caused inline expansion of subroutines at the address."), 73 0 }, 74 { "demangle", 'C', "ARG", OPTION_ARG_OPTIONAL, 75 N_("Show demangled symbols (ARG is always ignored)"), 0 }, 76 { "pretty-print", OPT_PRETTY, NULL, 0, 77 N_("Print all information on one line, and indent inlines"), 0 }, 78 79 { NULL, 0, NULL, 0, N_("Miscellaneous:"), 0 }, 80 /* Unsupported options. */ 81 { "target", 'b', "ARG", OPTION_HIDDEN, NULL, 0 }, 82 { "demangler", OPT_DEMANGLER, "ARG", OPTION_HIDDEN, NULL, 0 }, 83 { NULL, 0, NULL, 0, NULL, 0 } 84 }; 85 86 /* Short description of program. */ 87 static const char doc[] = N_("\ 88 Locate source files and line information for ADDRs (in a.out by default)."); 89 90 /* Strings for arguments in help texts. */ 91 static const char args_doc[] = N_("[ADDR...]"); 92 93 /* Prototype for option handler. */ 94 static error_t parse_opt (int key, char *arg, struct argp_state *state); 95 96 static struct argp_child argp_children[2]; /* [0] is set in main. */ 97 98 /* Data structure to communicate with argp functions. */ 99 static const struct argp argp = 100 { 101 options, parse_opt, args_doc, doc, argp_children, NULL, NULL 102 }; 103 104 105 /* Handle ADDR. */ 106 static int handle_address (const char *addr, Dwfl *dwfl); 107 108 /* True when we should print the address for each entry. */ 109 static bool print_addresses; 110 111 /* True if only base names of files should be shown. */ 112 static bool only_basenames; 113 114 /* True if absolute file names based on DW_AT_comp_dir should be shown. */ 115 static bool use_comp_dir; 116 117 /* True if line flags should be shown. */ 118 static bool show_flags; 119 120 /* True if function names should be shown. */ 121 static bool show_functions; 122 123 /* True if ELF symbol or section info should be shown. */ 124 static bool show_symbols; 125 126 /* True if section associated with a symbol address should be shown. */ 127 static bool show_symbol_sections; 128 129 /* If non-null, take address parameters as relative to named section. */ 130 static const char *just_section; 131 132 /* True if all inlined subroutines of the current address should be shown. */ 133 static bool show_inlines; 134 135 /* True if all names need to be demangled. */ 136 static bool demangle; 137 138 /* True if all information should be printed on one line. */ 139 static bool pretty; 140 141 #ifdef USE_DEMANGLE 142 static size_t demangle_buffer_len = 0; 143 static char *demangle_buffer = NULL; 144 #endif 145 146 int 147 main (int argc, char *argv[]) 148 { 149 int remaining; 150 int result = 0; 151 152 /* We use no threads here which can interfere with handling a stream. */ 153 (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER); 154 155 /* Set locale. */ 156 (void) setlocale (LC_ALL, ""); 157 158 /* Make sure the message catalog can be found. */ 159 (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR); 160 161 /* Initialize the message catalog. */ 162 (void) textdomain (PACKAGE_TARNAME); 163 164 /* Parse and process arguments. This includes opening the modules. */ 165 argp_children[0].argp = dwfl_standard_argp (); 166 argp_children[0].group = 1; 167 Dwfl *dwfl = NULL; 168 (void) argp_parse (&argp, argc, argv, 0, &remaining, &dwfl); 169 assert (dwfl != NULL); 170 171 /* Now handle the addresses. In case none are given on the command 172 line, read from stdin. */ 173 if (remaining == argc) 174 { 175 /* We use no threads here which can interfere with handling a stream. */ 176 (void) __fsetlocking (stdin, FSETLOCKING_BYCALLER); 177 178 char *buf = NULL; 179 size_t len = 0; 180 ssize_t chars; 181 while (!feof_unlocked (stdin)) 182 { 183 if ((chars = getline (&buf, &len, stdin)) < 0) 184 break; 185 186 if (buf[chars - 1] == '\n') 187 buf[chars - 1] = '\0'; 188 189 result = handle_address (buf, dwfl); 190 } 191 192 free (buf); 193 } 194 else 195 { 196 do 197 result = handle_address (argv[remaining], dwfl); 198 while (++remaining < argc); 199 } 200 201 dwfl_end (dwfl); 202 203 #ifdef USE_DEMANGLE 204 free (demangle_buffer); 205 #endif 206 207 return result; 208 } 209 210 211 /* Print the version information. */ 212 static void 213 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused))) 214 { 215 fprintf (stream, "addr2line (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); 216 fprintf (stream, gettext ("\ 217 Copyright (C) %s Red Hat, Inc.\n\ 218 This is free software; see the source for copying conditions. There is NO\n\ 219 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ 220 "), "2012"); 221 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); 222 } 223 224 225 /* Handle program arguments. */ 226 static error_t 227 parse_opt (int key, char *arg, struct argp_state *state) 228 { 229 switch (key) 230 { 231 case ARGP_KEY_INIT: 232 state->child_inputs[0] = state->input; 233 break; 234 235 case 'a': 236 print_addresses = true; 237 break; 238 239 case 'b': 240 case 'C': 241 case OPT_DEMANGLER: 242 demangle = true; 243 break; 244 245 case 's': 246 only_basenames = true; 247 break; 248 249 case 'A': 250 use_comp_dir = true; 251 break; 252 253 case 'f': 254 show_functions = true; 255 break; 256 257 case 'F': 258 show_flags = true; 259 break; 260 261 case 'S': 262 show_symbols = true; 263 break; 264 265 case 'x': 266 show_symbols = true; 267 show_symbol_sections = true; 268 break; 269 270 case 'j': 271 just_section = arg; 272 break; 273 274 case 'i': 275 show_inlines = true; 276 break; 277 278 case OPT_PRETTY: 279 pretty = true; 280 break; 281 282 default: 283 return ARGP_ERR_UNKNOWN; 284 } 285 return 0; 286 } 287 288 static const char * 289 symname (const char *name) 290 { 291 #ifdef USE_DEMANGLE 292 // Require GNU v3 ABI by the "_Z" prefix. 293 if (demangle && name[0] == '_' && name[1] == 'Z') 294 { 295 int status = -1; 296 char *dsymname = __cxa_demangle (name, demangle_buffer, 297 &demangle_buffer_len, &status); 298 if (status == 0) 299 name = demangle_buffer = dsymname; 300 } 301 #endif 302 return name; 303 } 304 305 static const char * 306 get_diename (Dwarf_Die *die) 307 { 308 Dwarf_Attribute attr; 309 const char *name; 310 311 name = dwarf_formstring (dwarf_attr_integrate (die, DW_AT_MIPS_linkage_name, 312 &attr) 313 ?: dwarf_attr_integrate (die, DW_AT_linkage_name, 314 &attr)); 315 316 if (name == NULL) 317 name = dwarf_diename (die) ?: "??"; 318 319 return name; 320 } 321 322 static bool 323 print_dwarf_function (Dwfl_Module *mod, Dwarf_Addr addr) 324 { 325 Dwarf_Addr bias = 0; 326 Dwarf_Die *cudie = dwfl_module_addrdie (mod, addr, &bias); 327 328 Dwarf_Die *scopes; 329 int nscopes = dwarf_getscopes (cudie, addr - bias, &scopes); 330 if (nscopes <= 0) 331 return false; 332 333 bool res = false; 334 for (int i = 0; i < nscopes; ++i) 335 switch (dwarf_tag (&scopes[i])) 336 { 337 case DW_TAG_subprogram: 338 { 339 const char *name = get_diename (&scopes[i]); 340 if (name == NULL) 341 goto done; 342 printf ("%s%c", symname (name), pretty ? ' ' : '\n'); 343 res = true; 344 goto done; 345 } 346 347 case DW_TAG_inlined_subroutine: 348 { 349 const char *name = get_diename (&scopes[i]); 350 if (name == NULL) 351 goto done; 352 353 /* When using --pretty-print we only show inlines on their 354 own line. Just print the first subroutine name. */ 355 if (pretty) 356 { 357 printf ("%s ", symname (name)); 358 res = true; 359 goto done; 360 } 361 else 362 printf ("%s inlined", symname (name)); 363 364 Dwarf_Files *files; 365 if (dwarf_getsrcfiles (cudie, &files, NULL) == 0) 366 { 367 Dwarf_Attribute attr_mem; 368 Dwarf_Word val; 369 if (dwarf_formudata (dwarf_attr (&scopes[i], 370 DW_AT_call_file, 371 &attr_mem), &val) == 0) 372 { 373 const char *file = dwarf_filesrc (files, val, NULL, NULL); 374 unsigned int lineno = 0; 375 unsigned int colno = 0; 376 if (dwarf_formudata (dwarf_attr (&scopes[i], 377 DW_AT_call_line, 378 &attr_mem), &val) == 0) 379 lineno = val; 380 if (dwarf_formudata (dwarf_attr (&scopes[i], 381 DW_AT_call_column, 382 &attr_mem), &val) == 0) 383 colno = val; 384 385 const char *comp_dir = ""; 386 const char *comp_dir_sep = ""; 387 388 if (file == NULL) 389 file = "???"; 390 else if (only_basenames) 391 file = basename (file); 392 else if (use_comp_dir && file[0] != '/') 393 { 394 const char *const *dirs; 395 size_t ndirs; 396 if (dwarf_getsrcdirs (files, &dirs, &ndirs) == 0 397 && dirs[0] != NULL) 398 { 399 comp_dir = dirs[0]; 400 comp_dir_sep = "/"; 401 } 402 } 403 404 if (lineno == 0) 405 printf (" from %s%s%s", 406 comp_dir, comp_dir_sep, file); 407 else if (colno == 0) 408 printf (" at %s%s%s:%u", 409 comp_dir, comp_dir_sep, file, lineno); 410 else 411 printf (" at %s%s%s:%u:%u", 412 comp_dir, comp_dir_sep, file, lineno, colno); 413 } 414 } 415 printf (" in "); 416 continue; 417 } 418 } 419 420 done: 421 free (scopes); 422 return res; 423 } 424 425 static void 426 print_addrsym (Dwfl_Module *mod, GElf_Addr addr) 427 { 428 GElf_Sym s; 429 GElf_Off off; 430 const char *name = dwfl_module_addrinfo (mod, addr, &off, &s, 431 NULL, NULL, NULL); 432 if (name == NULL) 433 { 434 /* No symbol name. Get a section name instead. */ 435 int i = dwfl_module_relocate_address (mod, &addr); 436 if (i >= 0) 437 name = dwfl_module_relocation_info (mod, i, NULL); 438 if (name == NULL) 439 printf ("??%c", pretty ? ' ': '\n'); 440 else 441 printf ("(%s)+%#" PRIx64 "%c", name, addr, pretty ? ' ' : '\n'); 442 } 443 else 444 { 445 name = symname (name); 446 if (off == 0) 447 printf ("%s", name); 448 else 449 printf ("%s+%#" PRIx64 "", name, off); 450 451 // Also show section name for address. 452 if (show_symbol_sections) 453 { 454 Dwarf_Addr ebias; 455 Elf_Scn *scn = dwfl_module_address_section (mod, &addr, &ebias); 456 if (scn != NULL) 457 { 458 GElf_Shdr shdr_mem; 459 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 460 if (shdr != NULL) 461 { 462 Elf *elf = dwfl_module_getelf (mod, &ebias); 463 GElf_Ehdr ehdr; 464 if (gelf_getehdr (elf, &ehdr) != NULL) 465 printf (" (%s)", elf_strptr (elf, ehdr.e_shstrndx, 466 shdr->sh_name)); 467 } 468 } 469 } 470 printf ("%c", pretty ? ' ' : '\n'); 471 } 472 } 473 474 static int 475 see_one_module (Dwfl_Module *mod, 476 void **userdata __attribute__ ((unused)), 477 const char *name __attribute__ ((unused)), 478 Dwarf_Addr start __attribute__ ((unused)), 479 void *arg) 480 { 481 Dwfl_Module **result = arg; 482 if (*result != NULL) 483 return DWARF_CB_ABORT; 484 *result = mod; 485 return DWARF_CB_OK; 486 } 487 488 static int 489 find_symbol (Dwfl_Module *mod, 490 void **userdata __attribute__ ((unused)), 491 const char *name __attribute__ ((unused)), 492 Dwarf_Addr start __attribute__ ((unused)), 493 void *arg) 494 { 495 const char *looking_for = ((void **) arg)[0]; 496 GElf_Sym *symbol = ((void **) arg)[1]; 497 GElf_Addr *value = ((void **) arg)[2]; 498 499 int n = dwfl_module_getsymtab (mod); 500 for (int i = 1; i < n; ++i) 501 { 502 const char *symbol_name = dwfl_module_getsym_info (mod, i, symbol, 503 value, NULL, NULL, 504 NULL); 505 if (symbol_name == NULL || symbol_name[0] == '\0') 506 continue; 507 switch (GELF_ST_TYPE (symbol->st_info)) 508 { 509 case STT_SECTION: 510 case STT_FILE: 511 case STT_TLS: 512 break; 513 default: 514 if (!strcmp (symbol_name, looking_for)) 515 { 516 ((void **) arg)[0] = NULL; 517 return DWARF_CB_ABORT; 518 } 519 } 520 } 521 522 return DWARF_CB_OK; 523 } 524 525 static bool 526 adjust_to_section (const char *name, uintmax_t *addr, Dwfl *dwfl) 527 { 528 /* It was (section)+offset. This makes sense if there is 529 only one module to look in for a section. */ 530 Dwfl_Module *mod = NULL; 531 if (dwfl_getmodules (dwfl, &see_one_module, &mod, 0) != 0 532 || mod == NULL) 533 error (EXIT_FAILURE, 0, gettext ("Section syntax requires" 534 " exactly one module")); 535 536 int nscn = dwfl_module_relocations (mod); 537 for (int i = 0; i < nscn; ++i) 538 { 539 GElf_Word shndx; 540 const char *scn = dwfl_module_relocation_info (mod, i, &shndx); 541 if (unlikely (scn == NULL)) 542 break; 543 if (!strcmp (scn, name)) 544 { 545 /* Found the section. */ 546 GElf_Shdr shdr_mem; 547 GElf_Addr shdr_bias; 548 GElf_Shdr *shdr = gelf_getshdr 549 (elf_getscn (dwfl_module_getelf (mod, &shdr_bias), shndx), 550 &shdr_mem); 551 if (unlikely (shdr == NULL)) 552 break; 553 554 if (*addr >= shdr->sh_size) 555 error (0, 0, 556 gettext ("offset %#" PRIxMAX " lies outside" 557 " section '%s'"), 558 *addr, scn); 559 560 *addr += shdr->sh_addr + shdr_bias; 561 return true; 562 } 563 } 564 565 return false; 566 } 567 568 static void 569 print_src (const char *src, int lineno, int linecol, Dwarf_Die *cu) 570 { 571 const char *comp_dir = ""; 572 const char *comp_dir_sep = ""; 573 574 if (only_basenames) 575 src = basename (src); 576 else if (use_comp_dir && src[0] != '/') 577 { 578 Dwarf_Attribute attr; 579 comp_dir = dwarf_formstring (dwarf_attr (cu, DW_AT_comp_dir, &attr)); 580 if (comp_dir != NULL) 581 comp_dir_sep = "/"; 582 } 583 584 if (linecol != 0) 585 printf ("%s%s%s:%d:%d", 586 comp_dir, comp_dir_sep, src, lineno, linecol); 587 else 588 printf ("%s%s%s:%d", 589 comp_dir, comp_dir_sep, src, lineno); 590 } 591 592 static int 593 get_addr_width (Dwfl_Module *mod) 594 { 595 // Try to find the address width if possible. 596 static int width = 0; 597 if (width == 0 && mod != NULL) 598 { 599 Dwarf_Addr bias; 600 Elf *elf = dwfl_module_getelf (mod, &bias); 601 if (elf != NULL) 602 { 603 GElf_Ehdr ehdr_mem; 604 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem); 605 if (ehdr != NULL) 606 width = ehdr->e_ident[EI_CLASS] == ELFCLASS32 ? 8 : 16; 607 } 608 } 609 if (width == 0) 610 width = 16; 611 612 return width; 613 } 614 615 static int 616 handle_address (const char *string, Dwfl *dwfl) 617 { 618 char *endp; 619 uintmax_t addr = strtoumax (string, &endp, 16); 620 if (endp == string || *endp != '\0') 621 { 622 bool parsed = false; 623 int i, j; 624 char *name = NULL; 625 if (sscanf (string, "(%m[^)])%" PRIiMAX "%n", &name, &addr, &i) == 2 626 && string[i] == '\0') 627 parsed = adjust_to_section (name, &addr, dwfl); 628 switch (sscanf (string, "%m[^-+]%n%" PRIiMAX "%n", &name, &i, &addr, &j)) 629 { 630 default: 631 break; 632 case 1: 633 addr = 0; 634 j = i; 635 case 2: 636 if (string[j] != '\0') 637 break; 638 639 /* It was symbol[+offset]. */ 640 GElf_Sym sym; 641 GElf_Addr value = 0; 642 void *arg[3] = { name, &sym, &value }; 643 (void) dwfl_getmodules (dwfl, &find_symbol, arg, 0); 644 if (arg[0] != NULL) 645 error (0, 0, gettext ("cannot find symbol '%s'"), name); 646 else 647 { 648 if (sym.st_size != 0 && addr >= sym.st_size) 649 error (0, 0, 650 gettext ("offset %#" PRIxMAX " lies outside" 651 " contents of '%s'"), 652 addr, name); 653 addr += value; 654 parsed = true; 655 } 656 break; 657 } 658 659 free (name); 660 if (!parsed) 661 return 1; 662 } 663 else if (just_section != NULL 664 && !adjust_to_section (just_section, &addr, dwfl)) 665 return 1; 666 667 Dwfl_Module *mod = dwfl_addrmodule (dwfl, addr); 668 669 if (print_addresses) 670 { 671 int width = get_addr_width (mod); 672 printf ("0x%.*" PRIx64 "%s", width, addr, pretty ? ": " : "\n"); 673 } 674 675 if (show_functions) 676 { 677 /* First determine the function name. Use the DWARF information if 678 possible. */ 679 if (! print_dwarf_function (mod, addr) && !show_symbols) 680 { 681 const char *name = dwfl_module_addrname (mod, addr); 682 name = name != NULL ? symname (name) : "??"; 683 printf ("%s%c", name, pretty ? ' ' : '\n'); 684 } 685 } 686 687 if (show_symbols) 688 print_addrsym (mod, addr); 689 690 if ((show_functions || show_symbols) && pretty) 691 printf ("at "); 692 693 Dwfl_Line *line = dwfl_module_getsrc (mod, addr); 694 695 const char *src; 696 int lineno, linecol; 697 698 if (line != NULL && (src = dwfl_lineinfo (line, &addr, &lineno, &linecol, 699 NULL, NULL)) != NULL) 700 { 701 print_src (src, lineno, linecol, dwfl_linecu (line)); 702 if (show_flags) 703 { 704 Dwarf_Addr bias; 705 Dwarf_Line *info = dwfl_dwarf_line (line, &bias); 706 assert (info != NULL); 707 708 inline void show (int (*get) (Dwarf_Line *, bool *), 709 const char *note) 710 { 711 bool flag; 712 if ((*get) (info, &flag) == 0 && flag) 713 fputs (note, stdout); 714 } 715 inline void show_int (int (*get) (Dwarf_Line *, unsigned int *), 716 const char *name) 717 { 718 unsigned int val; 719 if ((*get) (info, &val) == 0 && val != 0) 720 printf (" (%s %u)", name, val); 721 } 722 723 show (&dwarf_linebeginstatement, " (is_stmt)"); 724 show (&dwarf_lineblock, " (basic_block)"); 725 show (&dwarf_lineprologueend, " (prologue_end)"); 726 show (&dwarf_lineepiloguebegin, " (epilogue_begin)"); 727 show_int (&dwarf_lineisa, "isa"); 728 show_int (&dwarf_linediscriminator, "discriminator"); 729 } 730 putchar ('\n'); 731 } 732 else 733 puts ("??:0"); 734 735 if (show_inlines) 736 { 737 Dwarf_Addr bias = 0; 738 Dwarf_Die *cudie = dwfl_module_addrdie (mod, addr, &bias); 739 740 Dwarf_Die *scopes = NULL; 741 int nscopes = dwarf_getscopes (cudie, addr - bias, &scopes); 742 if (nscopes < 0) 743 return 1; 744 745 if (nscopes > 0) 746 { 747 Dwarf_Die subroutine; 748 Dwarf_Off dieoff = dwarf_dieoffset (&scopes[0]); 749 dwarf_offdie (dwfl_module_getdwarf (mod, &bias), 750 dieoff, &subroutine); 751 free (scopes); 752 scopes = NULL; 753 754 nscopes = dwarf_getscopes_die (&subroutine, &scopes); 755 if (nscopes > 1) 756 { 757 Dwarf_Die cu; 758 Dwarf_Files *files; 759 if (dwarf_diecu (&scopes[0], &cu, NULL, NULL) != NULL 760 && dwarf_getsrcfiles (cudie, &files, NULL) == 0) 761 { 762 for (int i = 0; i < nscopes - 1; i++) 763 { 764 Dwarf_Word val; 765 Dwarf_Attribute attr; 766 Dwarf_Die *die = &scopes[i]; 767 if (dwarf_tag (die) != DW_TAG_inlined_subroutine) 768 continue; 769 770 if (pretty) 771 printf (" (inlined by) "); 772 773 if (show_functions) 774 { 775 /* Search for the parent inline or function. It 776 might not be directly above this inline -- e.g. 777 there could be a lexical_block in between. */ 778 for (int j = i + 1; j < nscopes; j++) 779 { 780 Dwarf_Die *parent = &scopes[j]; 781 int tag = dwarf_tag (parent); 782 if (tag == DW_TAG_inlined_subroutine 783 || tag == DW_TAG_entry_point 784 || tag == DW_TAG_subprogram) 785 { 786 printf ("%s%s", 787 symname (get_diename (parent)), 788 pretty ? " at " : "\n"); 789 break; 790 } 791 } 792 } 793 794 src = NULL; 795 lineno = 0; 796 linecol = 0; 797 if (dwarf_formudata (dwarf_attr (die, DW_AT_call_file, 798 &attr), &val) == 0) 799 src = dwarf_filesrc (files, val, NULL, NULL); 800 801 if (dwarf_formudata (dwarf_attr (die, DW_AT_call_line, 802 &attr), &val) == 0) 803 lineno = val; 804 805 if (dwarf_formudata (dwarf_attr (die, DW_AT_call_column, 806 &attr), &val) == 0) 807 linecol = val; 808 809 if (src != NULL) 810 { 811 print_src (src, lineno, linecol, &cu); 812 putchar ('\n'); 813 } 814 else 815 puts ("??:0"); 816 } 817 } 818 } 819 } 820 free (scopes); 821 } 822 823 return 0; 824 } 825 826 827 #include "debugpred.h" 828
