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