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