1 /* corefile.c 2 3 Copyright (C) 1999-2016 Free Software Foundation, Inc. 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 of the License, or 10 (at your option) 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, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 20 02110-1301, USA. */ 21 22 #include "gprof.h" 23 #include "libiberty.h" 24 #include "filenames.h" 25 #include "search_list.h" 26 #include "source.h" 27 #include "symtab.h" 28 #include "hist.h" 29 #include "corefile.h" 30 #include "safe-ctype.h" 31 32 bfd *core_bfd; 33 static int core_num_syms; 34 static asymbol **core_syms; 35 asection *core_text_sect; 36 void * core_text_space; 37 38 static int min_insn_size; 39 int offset_to_code; 40 41 /* For mapping symbols to specific .o files during file ordering. */ 42 struct function_map * symbol_map; 43 unsigned int symbol_map_count; 44 45 static void read_function_mappings (const char *); 46 static int core_sym_class (asymbol *); 47 static bfd_boolean get_src_info 48 (bfd_vma, const char **, const char **, int *); 49 50 extern void i386_find_call (Sym *, bfd_vma, bfd_vma); 51 extern void alpha_find_call (Sym *, bfd_vma, bfd_vma); 52 extern void vax_find_call (Sym *, bfd_vma, bfd_vma); 53 extern void tahoe_find_call (Sym *, bfd_vma, bfd_vma); 54 extern void sparc_find_call (Sym *, bfd_vma, bfd_vma); 55 extern void mips_find_call (Sym *, bfd_vma, bfd_vma); 56 extern void aarch64_find_call (Sym *, bfd_vma, bfd_vma); 57 58 static void 59 parse_error (const char *filename) 60 { 61 fprintf (stderr, _("%s: unable to parse mapping file %s.\n"), whoami, filename); 62 done (1); 63 } 64 65 /* Compare two function_map structs based on function name. 66 We want to sort in ascending order. */ 67 68 static int 69 cmp_symbol_map (const void * l, const void * r) 70 { 71 return strcmp (((struct function_map *) l)->function_name, 72 ((struct function_map *) r)->function_name); 73 } 74 75 static void 76 read_function_mappings (const char *filename) 77 { 78 FILE * file = fopen (filename, "r"); 79 char dummy[1024]; 80 int count = 0; 81 unsigned int i; 82 83 if (!file) 84 { 85 fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename); 86 done (1); 87 } 88 89 /* First parse the mapping file so we know how big we need to 90 make our tables. We also do some sanity checks at this 91 time. */ 92 while (!feof (file)) 93 { 94 int matches; 95 96 matches = fscanf (file, "%[^\n:]", dummy); 97 if (!matches) 98 parse_error (filename); 99 100 /* Just skip messages about files with no symbols. */ 101 if (!strncmp (dummy, "No symbols in ", 14)) 102 { 103 matches = fscanf (file, "\n"); 104 if (matches == EOF) 105 parse_error (filename); 106 continue; 107 } 108 109 /* Don't care what else is on this line at this point. */ 110 matches = fscanf (file, "%[^\n]\n", dummy); 111 if (!matches) 112 parse_error (filename); 113 count++; 114 } 115 116 /* Now we know how big we need to make our table. */ 117 symbol_map = ((struct function_map *) 118 xmalloc (count * sizeof (struct function_map))); 119 120 /* Rewind the input file so we can read it again. */ 121 rewind (file); 122 123 /* Read each entry and put it into the table. */ 124 count = 0; 125 while (!feof (file)) 126 { 127 int matches; 128 char *tmp; 129 130 matches = fscanf (file, "%[^\n:]", dummy); 131 if (!matches) 132 parse_error (filename); 133 134 /* Just skip messages about files with no symbols. */ 135 if (!strncmp (dummy, "No symbols in ", 14)) 136 { 137 matches = fscanf (file, "\n"); 138 if (matches == EOF) 139 parse_error (filename); 140 continue; 141 } 142 143 /* dummy has the filename, go ahead and copy it. */ 144 symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1); 145 strcpy (symbol_map[count].file_name, dummy); 146 147 /* Now we need the function name. */ 148 matches = fscanf (file, "%[^\n]\n", dummy); 149 if (!matches) 150 parse_error (filename); 151 tmp = strrchr (dummy, ' ') + 1; 152 symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1); 153 strcpy (symbol_map[count].function_name, tmp); 154 count++; 155 } 156 157 /* Record the size of the map table for future reference. */ 158 symbol_map_count = count; 159 160 for (i = 0; i < symbol_map_count; ++i) 161 if (i == 0 162 || filename_cmp (symbol_map[i].file_name, symbol_map[i - 1].file_name)) 163 symbol_map[i].is_first = 1; 164 165 qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map); 166 167 fclose (file); 168 } 169 170 void 171 core_init (const char * aout_name) 172 { 173 int core_sym_bytes; 174 asymbol *synthsyms; 175 long synth_count; 176 177 core_bfd = bfd_openr (aout_name, 0); 178 179 if (!core_bfd) 180 { 181 perror (aout_name); 182 done (1); 183 } 184 185 if (!bfd_check_format (core_bfd, bfd_object)) 186 { 187 fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name); 188 done (1); 189 } 190 191 /* Get core's text section. */ 192 core_text_sect = bfd_get_section_by_name (core_bfd, ".text"); 193 if (!core_text_sect) 194 { 195 core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$"); 196 if (!core_text_sect) 197 { 198 fprintf (stderr, _("%s: can't find .text section in %s\n"), 199 whoami, aout_name); 200 done (1); 201 } 202 } 203 204 /* Read core's symbol table. */ 205 206 /* This will probably give us more than we need, but that's ok. */ 207 core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd); 208 if (core_sym_bytes < 0) 209 { 210 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name, 211 bfd_errmsg (bfd_get_error ())); 212 done (1); 213 } 214 215 core_syms = (asymbol **) xmalloc (core_sym_bytes); 216 core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms); 217 218 if (core_num_syms < 0) 219 { 220 fprintf (stderr, "%s: %s: %s\n", whoami, aout_name, 221 bfd_errmsg (bfd_get_error ())); 222 done (1); 223 } 224 225 synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms, 226 0, NULL, &synthsyms); 227 if (synth_count > 0) 228 { 229 asymbol **symp; 230 long new_size; 231 long i; 232 233 new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms); 234 core_syms = (asymbol **) xrealloc (core_syms, new_size); 235 symp = core_syms + core_num_syms; 236 core_num_syms += synth_count; 237 for (i = 0; i < synth_count; i++) 238 *symp++ = synthsyms + i; 239 *symp = 0; 240 } 241 242 min_insn_size = 1; 243 offset_to_code = 0; 244 245 switch (bfd_get_arch (core_bfd)) 246 { 247 case bfd_arch_vax: 248 case bfd_arch_tahoe: 249 offset_to_code = 2; 250 break; 251 252 case bfd_arch_alpha: 253 min_insn_size = 4; 254 break; 255 256 default: 257 break; 258 } 259 260 if (function_mapping_file) 261 read_function_mappings (function_mapping_file); 262 } 263 264 /* Read in the text space of an a.out file. */ 265 266 void 267 core_get_text_space (bfd *cbfd) 268 { 269 core_text_space = malloc (bfd_get_section_size (core_text_sect)); 270 271 if (!core_text_space) 272 { 273 fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"), 274 whoami, (unsigned long) bfd_get_section_size (core_text_sect)); 275 done (1); 276 } 277 278 if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space, 279 0, bfd_get_section_size (core_text_sect))) 280 { 281 bfd_perror ("bfd_get_section_contents"); 282 free (core_text_space); 283 core_text_space = 0; 284 } 285 286 if (!core_text_space) 287 fprintf (stderr, _("%s: can't do -c\n"), whoami); 288 } 289 290 291 void 292 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc) 293 { 294 if (core_text_space == 0) 295 return; 296 297 hist_clip_symbol_address (&p_lowpc, &p_highpc); 298 299 switch (bfd_get_arch (core_bfd)) 300 { 301 case bfd_arch_i386: 302 i386_find_call (parent, p_lowpc, p_highpc); 303 break; 304 305 case bfd_arch_alpha: 306 alpha_find_call (parent, p_lowpc, p_highpc); 307 break; 308 309 case bfd_arch_vax: 310 vax_find_call (parent, p_lowpc, p_highpc); 311 break; 312 313 case bfd_arch_sparc: 314 sparc_find_call (parent, p_lowpc, p_highpc); 315 break; 316 317 case bfd_arch_tahoe: 318 tahoe_find_call (parent, p_lowpc, p_highpc); 319 break; 320 321 case bfd_arch_mips: 322 mips_find_call (parent, p_lowpc, p_highpc); 323 break; 324 325 case bfd_arch_aarch64: 326 aarch64_find_call (parent, p_lowpc, p_highpc); 327 break; 328 329 default: 330 fprintf (stderr, _("%s: -c not supported on architecture %s\n"), 331 whoami, bfd_printable_name(core_bfd)); 332 333 /* Don't give the error more than once. */ 334 ignore_direct_calls = FALSE; 335 } 336 } 337 338 /* Return class of symbol SYM. The returned class can be any of: 339 0 -> symbol is not interesting to us 340 'T' -> symbol is a global name 341 't' -> symbol is a local (static) name. */ 342 343 static int 344 core_sym_class (asymbol *sym) 345 { 346 symbol_info syminfo; 347 const char *name; 348 char sym_prefix; 349 int i; 350 351 if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0) 352 return 0; 353 354 /* Must be a text symbol, and static text symbols 355 don't qualify if ignore_static_funcs set. */ 356 if (ignore_static_funcs && (sym->flags & BSF_LOCAL)) 357 { 358 DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n", 359 sym->name)); 360 return 0; 361 } 362 363 bfd_get_symbol_info (core_bfd, sym, &syminfo); 364 i = syminfo.type; 365 366 if (i == 'T') 367 return i; /* It's a global symbol. */ 368 369 if (i == 'W') 370 /* Treat weak symbols as text symbols. FIXME: a weak symbol may 371 also be a data symbol. */ 372 return 'T'; 373 374 if (i != 't') 375 { 376 /* Not a static text symbol. */ 377 DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n", 378 sym->name, i)); 379 return 0; 380 } 381 382 /* Do some more filtering on static function-names. */ 383 if (ignore_static_funcs) 384 return 0; 385 386 /* Can't zero-length name or funny characters in name, where 387 `funny' includes: `.' (.o file names) and `$' (Pascal labels). */ 388 if (!sym->name || sym->name[0] == '\0') 389 return 0; 390 391 for (name = sym->name; *name; ++name) 392 { 393 if (*name == '$') 394 return 0; 395 396 while (*name == '.') 397 { 398 /* Allow both nested subprograms (which end with ".NNN", where N is 399 a digit) and GCC cloned functions (which contain ".clone"). 400 Allow for multiple iterations of both - apparently GCC can clone 401 clones and subprograms. */ 402 int digit_seen = 0; 403 #define CLONE_NAME ".clone." 404 #define CLONE_NAME_LEN strlen (CLONE_NAME) 405 #define CONSTPROP_NAME ".constprop." 406 #define CONSTPROP_NAME_LEN strlen (CONSTPROP_NAME) 407 408 if (strlen (name) > CLONE_NAME_LEN 409 && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0) 410 name += CLONE_NAME_LEN - 1; 411 412 else if (strlen (name) > CONSTPROP_NAME_LEN 413 && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0) 414 name += CONSTPROP_NAME_LEN - 1; 415 416 for (name++; *name; name++) 417 if (digit_seen && *name == '.') 418 break; 419 else if (ISDIGIT (*name)) 420 digit_seen = 1; 421 else 422 return 0; 423 } 424 } 425 426 /* On systems where the C compiler adds an underscore to all 427 names, static names without underscores seem usually to be 428 labels in hand written assembler in the library. We don't want 429 these names. This is certainly necessary on a Sparc running 430 SunOS 4.1 (try profiling a program that does a lot of 431 division). I don't know whether it has harmful side effects on 432 other systems. Perhaps it should be made configurable. */ 433 sym_prefix = bfd_get_symbol_leading_char (core_bfd); 434 435 if ((sym_prefix && sym_prefix != sym->name[0]) 436 /* GCC may add special symbols to help gdb figure out the file 437 language. We want to ignore these, since sometimes they mask 438 the real function. (dj@ctron) */ 439 || !strncmp (sym->name, "__gnu_compiled", 14) 440 || !strncmp (sym->name, "___gnu_compiled", 15)) 441 { 442 return 0; 443 } 444 445 /* If the object file supports marking of function symbols, then 446 we can zap anything that doesn't have BSF_FUNCTION set. */ 447 if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0) 448 return 0; 449 450 return 't'; /* It's a static text symbol. */ 451 } 452 453 /* Get whatever source info we can get regarding address ADDR. */ 454 455 static bfd_boolean 456 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num) 457 { 458 const char *fname = 0, *func_name = 0; 459 int l = 0; 460 461 if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms, 462 addr - core_text_sect->vma, 463 &fname, &func_name, (unsigned int *) &l) 464 && fname && func_name && l) 465 { 466 DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n", 467 (unsigned long) addr, fname, l, func_name)); 468 *filename = fname; 469 *name = func_name; 470 *line_num = l; 471 return TRUE; 472 } 473 else 474 { 475 DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n", 476 (unsigned long) addr, 477 fname ? fname : "<unknown>", l, 478 func_name ? func_name : "<unknown>")); 479 return FALSE; 480 } 481 } 482 483 /* Return number of symbols in a symbol-table file. */ 484 485 static int 486 num_of_syms_in (FILE * f) 487 { 488 const int BUFSIZE = 1024; 489 char * buf = (char *) xmalloc (BUFSIZE); 490 char * address = (char *) xmalloc (BUFSIZE); 491 char type; 492 char * name = (char *) xmalloc (BUFSIZE); 493 int num = 0; 494 495 while (!feof (f) && fgets (buf, BUFSIZE - 1, f)) 496 { 497 if (sscanf (buf, "%s %c %s", address, &type, name) == 3) 498 if (type == 't' || type == 'T') 499 ++num; 500 } 501 502 free (buf); 503 free (address); 504 free (name); 505 506 return num; 507 } 508 509 /* Read symbol table from a file. */ 510 511 void 512 core_create_syms_from (const char * sym_table_file) 513 { 514 const int BUFSIZE = 1024; 515 char * buf = (char *) xmalloc (BUFSIZE); 516 char * address = (char *) xmalloc (BUFSIZE); 517 char type; 518 char * name = (char *) xmalloc (BUFSIZE); 519 bfd_vma min_vma = ~(bfd_vma) 0; 520 bfd_vma max_vma = 0; 521 FILE * f; 522 523 f = fopen (sym_table_file, "r"); 524 if (!f) 525 { 526 fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file); 527 done (1); 528 } 529 530 /* Pass 1 - determine upper bound on number of function names. */ 531 symtab.len = num_of_syms_in (f); 532 533 if (symtab.len == 0) 534 { 535 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file); 536 done (1); 537 } 538 539 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym)); 540 541 /* Pass 2 - create symbols. */ 542 symtab.limit = symtab.base; 543 544 if (fseek (f, 0, SEEK_SET) != 0) 545 { 546 perror (sym_table_file); 547 done (1); 548 } 549 550 while (!feof (f) && fgets (buf, BUFSIZE - 1, f)) 551 { 552 if (sscanf (buf, "%s %c %s", address, &type, name) == 3) 553 if (type != 't' && type != 'T') 554 continue; 555 556 sym_init (symtab.limit); 557 558 sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) ); 559 560 symtab.limit->name = (char *) xmalloc (strlen (name) + 1); 561 strcpy ((char *) symtab.limit->name, name); 562 symtab.limit->mapped = 0; 563 symtab.limit->is_func = TRUE; 564 symtab.limit->is_bb_head = TRUE; 565 symtab.limit->is_static = (type == 't'); 566 min_vma = MIN (symtab.limit->addr, min_vma); 567 max_vma = MAX (symtab.limit->addr, max_vma); 568 569 ++symtab.limit; 570 } 571 fclose (f); 572 573 symtab.len = symtab.limit - symtab.base; 574 symtab_finalize (&symtab); 575 576 free (buf); 577 free (address); 578 free (name); 579 } 580 581 static int 582 search_mapped_symbol (const void * l, const void * r) 583 { 584 return strcmp ((const char *) l, ((const struct function_map *) r)->function_name); 585 } 586 587 /* Read in symbol table from core. 588 One symbol per function is entered. */ 589 590 void 591 core_create_function_syms (void) 592 { 593 bfd_vma min_vma = ~ (bfd_vma) 0; 594 bfd_vma max_vma = 0; 595 int cxxclass; 596 long i; 597 struct function_map * found = NULL; 598 int core_has_func_syms = 0; 599 600 switch (core_bfd->xvec->flavour) 601 { 602 default: 603 break; 604 case bfd_target_coff_flavour: 605 case bfd_target_ecoff_flavour: 606 case bfd_target_xcoff_flavour: 607 case bfd_target_elf_flavour: 608 case bfd_target_nlm_flavour: 609 case bfd_target_som_flavour: 610 core_has_func_syms = 1; 611 } 612 613 /* Pass 1 - determine upper bound on number of function names. */ 614 symtab.len = 0; 615 616 for (i = 0; i < core_num_syms; ++i) 617 { 618 if (!core_sym_class (core_syms[i])) 619 continue; 620 621 /* Don't create a symtab entry for a function that has 622 a mapping to a file, unless it's the first function 623 in the file. */ 624 if (symbol_map_count != 0) 625 { 626 /* Note: some systems (SunOS 5.8) crash if bsearch base argument 627 is NULL. */ 628 found = (struct function_map *) bsearch 629 (core_syms[i]->name, symbol_map, symbol_map_count, 630 sizeof (struct function_map), search_mapped_symbol); 631 } 632 if (found == NULL || found->is_first) 633 ++symtab.len; 634 } 635 636 if (symtab.len == 0) 637 { 638 fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name); 639 done (1); 640 } 641 642 symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym)); 643 644 /* Pass 2 - create symbols. */ 645 symtab.limit = symtab.base; 646 647 for (i = 0; i < core_num_syms; ++i) 648 { 649 asection *sym_sec; 650 651 cxxclass = core_sym_class (core_syms[i]); 652 653 if (!cxxclass) 654 { 655 DBG (AOUTDEBUG, 656 printf ("[core_create_function_syms] rejecting: 0x%lx %s\n", 657 (unsigned long) core_syms[i]->value, 658 core_syms[i]->name)); 659 continue; 660 } 661 662 if (symbol_map_count != 0) 663 { 664 /* Note: some systems (SunOS 5.8) crash if bsearch base argument 665 is NULL. */ 666 found = (struct function_map *) bsearch 667 (core_syms[i]->name, symbol_map, symbol_map_count, 668 sizeof (struct function_map), search_mapped_symbol); 669 } 670 if (found && ! found->is_first) 671 continue; 672 673 sym_init (symtab.limit); 674 675 /* Symbol offsets are always section-relative. */ 676 sym_sec = core_syms[i]->section; 677 symtab.limit->addr = core_syms[i]->value; 678 if (sym_sec) 679 symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec); 680 681 if (found) 682 { 683 symtab.limit->name = found->file_name; 684 symtab.limit->mapped = 1; 685 } 686 else 687 { 688 symtab.limit->name = core_syms[i]->name; 689 symtab.limit->mapped = 0; 690 } 691 692 /* Lookup filename and line number, if we can. */ 693 { 694 const char * filename; 695 const char * func_name; 696 697 if (get_src_info (symtab.limit->addr, & filename, & func_name, 698 & symtab.limit->line_num)) 699 { 700 symtab.limit->file = source_file_lookup_path (filename); 701 702 /* FIXME: Checking __osf__ here does not work with a cross 703 gprof. */ 704 #ifdef __osf__ 705 /* Suppress symbols that are not function names. This is 706 useful to suppress code-labels and aliases. 707 708 This is known to be useful under DEC's OSF/1. Under SunOS 4.x, 709 labels do not appear in the symbol table info, so this isn't 710 necessary. */ 711 712 if (strcmp (symtab.limit->name, func_name) != 0) 713 { 714 /* The symbol's address maps to a different name, so 715 it can't be a function-entry point. This happens 716 for labels, for example. */ 717 DBG (AOUTDEBUG, 718 printf ("[core_create_function_syms: rej %s (maps to %s)\n", 719 symtab.limit->name, func_name)); 720 continue; 721 } 722 #endif 723 } 724 } 725 726 symtab.limit->is_func = (!core_has_func_syms 727 || (core_syms[i]->flags & BSF_FUNCTION) != 0); 728 symtab.limit->is_bb_head = TRUE; 729 730 if (cxxclass == 't') 731 symtab.limit->is_static = TRUE; 732 733 /* Keep track of the minimum and maximum vma addresses used by all 734 symbols. When computing the max_vma, use the ending address of the 735 section containing the symbol, if available. */ 736 min_vma = MIN (symtab.limit->addr, min_vma); 737 if (sym_sec) 738 max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec) 739 + bfd_section_size (sym_sec->owner, sym_sec) - 1, 740 max_vma); 741 else 742 max_vma = MAX (symtab.limit->addr, max_vma); 743 744 DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n", 745 (long) (symtab.limit - symtab.base), 746 symtab.limit->name, 747 (unsigned long) symtab.limit->addr)); 748 ++symtab.limit; 749 } 750 751 symtab.len = symtab.limit - symtab.base; 752 symtab_finalize (&symtab); 753 } 754 755 /* Read in symbol table from core. 756 One symbol per line of source code is entered. */ 757 758 void 759 core_create_line_syms (void) 760 { 761 char *prev_name, *prev_filename; 762 unsigned int prev_name_len, prev_filename_len; 763 bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0; 764 Sym *prev, dummy, *sym; 765 const char *filename; 766 int prev_line_num; 767 Sym_Table ltab; 768 bfd_vma vma_high; 769 770 /* Create symbols for functions as usual. This is necessary in 771 cases where parts of a program were not compiled with -g. For 772 those parts we still want to get info at the function level. */ 773 core_create_function_syms (); 774 775 /* Pass 1: count the number of symbols. */ 776 777 /* To find all line information, walk through all possible 778 text-space addresses (one by one!) and get the debugging 779 info for each address. When the debugging info changes, 780 it is time to create a new symbol. 781 782 Of course, this is rather slow and it would be better if 783 BFD would provide an iterator for enumerating all line infos. */ 784 prev_name_len = PATH_MAX; 785 prev_filename_len = PATH_MAX; 786 prev_name = (char *) xmalloc (prev_name_len); 787 prev_filename = (char *) xmalloc (prev_filename_len); 788 ltab.len = 0; 789 prev_line_num = 0; 790 791 vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect); 792 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size) 793 { 794 unsigned int len; 795 796 if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num) 797 || (prev_line_num == dummy.line_num 798 && prev_name != NULL 799 && strcmp (prev_name, dummy.name) == 0 800 && filename_cmp (prev_filename, filename) == 0)) 801 continue; 802 803 ++ltab.len; 804 prev_line_num = dummy.line_num; 805 806 len = strlen (dummy.name); 807 if (len >= prev_name_len) 808 { 809 prev_name_len = len + 1024; 810 free (prev_name); 811 prev_name = (char *) xmalloc (prev_name_len); 812 } 813 814 strcpy (prev_name, dummy.name); 815 len = strlen (filename); 816 817 if (len >= prev_filename_len) 818 { 819 prev_filename_len = len + 1024; 820 free (prev_filename); 821 prev_filename = (char *) xmalloc (prev_filename_len); 822 } 823 824 strcpy (prev_filename, filename); 825 826 min_vma = MIN (vma, min_vma); 827 max_vma = MAX (vma, max_vma); 828 } 829 830 free (prev_name); 831 free (prev_filename); 832 833 /* Make room for function symbols, too. */ 834 ltab.len += symtab.len; 835 ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym)); 836 ltab.limit = ltab.base; 837 838 /* Pass 2 - create symbols. */ 839 840 /* We now set is_static as we go along, rather than by running 841 through the symbol table at the end. 842 843 The old way called symtab_finalize before the is_static pass, 844 causing a problem since symtab_finalize uses is_static as part of 845 its address conflict resolution algorithm. Since global symbols 846 were prefered over static symbols, and all line symbols were 847 global at that point, static function names that conflicted with 848 their own line numbers (static, but labeled as global) were 849 rejected in favor of the line num. 850 851 This was not the desired functionality. We always want to keep 852 our function symbols and discard any conflicting line symbols. 853 Perhaps symtab_finalize should be modified to make this 854 distinction as well, but the current fix works and the code is a 855 lot cleaner now. */ 856 prev = 0; 857 858 for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size) 859 { 860 sym_init (ltab.limit); 861 862 if (!get_src_info (vma, &filename, <ab.limit->name, <ab.limit->line_num) 863 || (prev && prev->line_num == ltab.limit->line_num 864 && strcmp (prev->name, ltab.limit->name) == 0 865 && filename_cmp (prev->file->name, filename) == 0)) 866 continue; 867 868 /* Make name pointer a malloc'ed string. */ 869 ltab.limit->name = xstrdup (ltab.limit->name); 870 ltab.limit->file = source_file_lookup_path (filename); 871 872 ltab.limit->addr = vma; 873 874 /* Set is_static based on the enclosing function, using either: 875 1) the previous symbol, if it's from the same function, or 876 2) a symtab lookup. */ 877 if (prev && ltab.limit->file == prev->file && 878 strcmp (ltab.limit->name, prev->name) == 0) 879 { 880 ltab.limit->is_static = prev->is_static; 881 } 882 else 883 { 884 sym = sym_lookup(&symtab, ltab.limit->addr); 885 if (sym) 886 ltab.limit->is_static = sym->is_static; 887 } 888 889 prev = ltab.limit; 890 891 DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n", 892 (unsigned long) (ltab.limit - ltab.base), 893 ltab.limit->name, 894 (unsigned long) ltab.limit->addr)); 895 ++ltab.limit; 896 } 897 898 /* Copy in function symbols. */ 899 memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym)); 900 ltab.limit += symtab.len; 901 902 if ((unsigned int) (ltab.limit - ltab.base) != ltab.len) 903 { 904 fprintf (stderr, 905 _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"), 906 whoami, ltab.len, (long) (ltab.limit - ltab.base)); 907 done (1); 908 } 909 910 /* Finalize ltab and make it symbol table. */ 911 symtab_finalize (<ab); 912 free (symtab.base); 913 symtab = ltab; 914 } 915