gprof/corefile.c

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