gprof/corefile.c

   1 /* corefile.c
   2
   3    Copyright (C) 1999-2019 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 #include <limits.h>    /* For UINT_MAX.  */
  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 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       offset_to_code = 2;
 253       break;
 254
 255     case bfd_arch_alpha:
 256       min_insn_size = 4;
 257       break;
 258
 259     default:
 260       break;
 261     }
 262
 263   if (function_mapping_file)
 264     read_function_mappings (function_mapping_file);
 265 }
 266
 267 /* Read in the text space of an a.out file.  */
 268
 269 void
 270 core_get_text_space (bfd *cbfd)
 271 {
 272   core_text_space = malloc (bfd_get_section_size (core_text_sect));
 273
 274   if (!core_text_space)
 275     {
 276       fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
 277                whoami, (unsigned long) bfd_get_section_size (core_text_sect));
 278       done (1);
 279     }
 280
 281   if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
 282                                  0, bfd_get_section_size (core_text_sect)))
 283     {
 284       bfd_perror ("bfd_get_section_contents");
 285       free (core_text_space);
 286       core_text_space = 0;
 287     }
 288
 289   if (!core_text_space)
 290     fprintf (stderr, _("%s: can't do -c\n"), whoami);
 291 }
 292
 293
 294 void
 295 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
 296 {
 297   if (core_text_space == 0)
 298     return;
 299
 300   hist_clip_symbol_address (&p_lowpc, &p_highpc);
 301
 302   switch (bfd_get_arch (core_bfd))
 303     {
 304     case bfd_arch_i386:
 305       i386_find_call (parent, p_lowpc, p_highpc);
 306       break;
 307
 308     case bfd_arch_alpha:
 309       alpha_find_call (parent, p_lowpc, p_highpc);
 310       break;
 311
 312     case bfd_arch_vax:
 313       vax_find_call (parent, p_lowpc, p_highpc);
 314       break;
 315
 316     case bfd_arch_sparc:
 317       sparc_find_call (parent, p_lowpc, p_highpc);
 318       break;
 319
 320     case bfd_arch_mips:
 321       mips_find_call (parent, p_lowpc, p_highpc);
 322       break;
 323
 324     case bfd_arch_aarch64:
 325       aarch64_find_call (parent, p_lowpc, p_highpc);
 326       break;
 327
 328     default:
 329       fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
 330                whoami, bfd_printable_name(core_bfd));
 331
 332       /* Don't give the error more than once.  */
 333       ignore_direct_calls = FALSE;
 334     }
 335 }
 336
 337 /* Return class of symbol SYM.  The returned class can be any of:
 338         0   -> symbol is not interesting to us
 339         'T' -> symbol is a global name
 340         't' -> symbol is a local (static) name.  */
 341
 342 static int
 343 core_sym_class (asymbol *sym)
 344 {
 345   symbol_info syminfo;
 346   const char *name;
 347   char sym_prefix;
 348   int i;
 349
 350   if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
 351     return 0;
 352
 353   /* Must be a text symbol, and static text symbols
 354      don't qualify if ignore_static_funcs set.   */
 355   if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
 356     {
 357       DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
 358                               sym->name));
 359       return 0;
 360     }
 361
 362   bfd_get_symbol_info (core_bfd, sym, &syminfo);
 363   i = syminfo.type;
 364
 365   if (i == 'T')
 366     return i;                   /* It's a global symbol.  */
 367
 368   if (i == 'W')
 369     /* Treat weak symbols as text symbols.  FIXME: a weak symbol may
 370        also be a data symbol.  */
 371     return 'T';
 372
 373   if (i != 't')
 374     {
 375       /* Not a static text symbol.  */
 376       DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
 377                               sym->name, i));
 378       return 0;
 379     }
 380
 381   /* Do some more filtering on static function-names.  */
 382   if (ignore_static_funcs)
 383     return 0;
 384
 385   /* Can't zero-length name or funny characters in name, where
 386      `funny' includes: `.' (.o file names) and `$' (Pascal labels).  */
 387   if (!sym->name || sym->name[0] == '\0')
 388     return 0;
 389
 390   for (name = sym->name; *name; ++name)
 391     {
 392       if (*name == '$')
 393         return 0;
 394
 395       while (*name == '.')
 396         {
 397           /* Allow both nested subprograms (which end with ".NNN", where N is
 398              a digit) and GCC cloned functions (which contain ".clone").
 399              Allow for multiple iterations of both - apparently GCC can clone
 400              clones and subprograms.  */
 401           int digit_seen = 0;
 402 #define CLONE_NAME          ".clone."
 403 #define CLONE_NAME_LEN      strlen (CLONE_NAME)
 404 #define CONSTPROP_NAME      ".constprop."
 405 #define CONSTPROP_NAME_LEN  strlen (CONSTPROP_NAME)
 406
 407           if (strlen (name) > CLONE_NAME_LEN
 408               && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0)
 409             name += CLONE_NAME_LEN - 1;
 410
 411           else if (strlen (name) > CONSTPROP_NAME_LEN
 412               && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0)
 413             name += CONSTPROP_NAME_LEN - 1;
 414
 415           for (name++; *name; name++)
 416             if (digit_seen && *name == '.')
 417               break;
 418             else if (ISDIGIT (*name))
 419               digit_seen = 1;
 420             else
 421               return 0;
 422         }
 423     }
 424
 425   /* On systems where the C compiler adds an underscore to all
 426      names, static names without underscores seem usually to be
 427      labels in hand written assembler in the library.  We don't want
 428      these names.  This is certainly necessary on a Sparc running
 429      SunOS 4.1 (try profiling a program that does a lot of
 430      division). I don't know whether it has harmful side effects on
 431      other systems.  Perhaps it should be made configurable.  */
 432   sym_prefix = bfd_get_symbol_leading_char (core_bfd);
 433
 434   if ((sym_prefix && sym_prefix != sym->name[0])
 435       /* GCC may add special symbols to help gdb figure out the file
 436         language.  We want to ignore these, since sometimes they mask
 437         the real function.  (dj@ctron)  */
 438       || !strncmp (sym->name, "__gnu_compiled", 14)
 439       || !strncmp (sym->name, "___gnu_compiled", 15))
 440     {
 441       return 0;
 442     }
 443
 444   /* If the object file supports marking of function symbols, then
 445      we can zap anything that doesn't have BSF_FUNCTION set.  */
 446   if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
 447     return 0;
 448
 449   return 't';                   /* It's a static text symbol.  */
 450 }
 451
 452 /* Get whatever source info we can get regarding address ADDR.  */
 453
 454 static bfd_boolean
 455 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
 456 {
 457   const char *fname = 0, *func_name = 0;
 458   int l = 0;
 459
 460   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
 461                              addr - core_text_sect->vma,
 462                              &fname, &func_name, (unsigned int *) &l)
 463       && fname && func_name && l)
 464     {
 465       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 466                               (unsigned long) addr, fname, l, func_name));
 467       *filename = fname;
 468       *name = func_name;
 469       *line_num = l;
 470       return TRUE;
 471     }
 472   else
 473     {
 474       DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 475                               (unsigned long) addr,
 476                               fname ? fname : "<unknown>", l,
 477                               func_name ? func_name : "<unknown>"));
 478       return FALSE;
 479     }
 480 }
 481
 482 static char buf[BUFSIZE];
 483 static char address[BUFSIZE];
 484 static char name[BUFSIZE];
 485
 486 /* Return number of symbols in a symbol-table file.  */
 487
 488 static unsigned int
 489 num_of_syms_in (FILE * f)
 490 {
 491   char   type;
 492   unsigned int num = 0;
 493
 494   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 495     {
 496       if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
 497         if (type == 't' || type == 'T')
 498           {
 499             /* PR 20499 - prevent integer overflow computing argument to xmalloc.  */
 500             if (++num >= UINT_MAX / sizeof (Sym))
 501               return -1U;
 502           }
 503     }
 504
 505   return num;
 506 }
 507
 508 /* Read symbol table from a file.  */
 509
 510 void
 511 core_create_syms_from (const char * sym_table_file)
 512 {
 513   char type;
 514   bfd_vma min_vma = ~(bfd_vma) 0;
 515   bfd_vma max_vma = 0;
 516   FILE * f;
 517
 518   f = fopen (sym_table_file, "r");
 519   if (!f)
 520     {
 521       fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
 522       done (1);
 523     }
 524
 525   /* Pass 1 - determine upper bound on number of function names.  */
 526   symtab.len = num_of_syms_in (f);
 527
 528   if (symtab.len == 0)
 529     {
 530       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
 531       done (1);
 532     }
 533   else if (symtab.len == -1U)
 534     {
 535       fprintf (stderr, _("%s: file `%s' has too many symbols\n"),
 536                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, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) != 3)
 554         continue;
 555       if (type != 't' && type != 'T')
 556         continue;
 557
 558       sym_init (symtab.limit);
 559
 560       sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
 561
 562       symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
 563       strcpy ((char *) symtab.limit->name, name);
 564       symtab.limit->mapped = 0;
 565       symtab.limit->is_func = TRUE;
 566       symtab.limit->is_bb_head = TRUE;
 567       symtab.limit->is_static = (type == 't');
 568       min_vma = MIN (symtab.limit->addr, min_vma);
 569       max_vma = MAX (symtab.limit->addr, max_vma);
 570
 571       ++symtab.limit;
 572     }
 573   fclose (f);
 574
 575   symtab.len = symtab.limit - symtab.base;
 576   symtab_finalize (&symtab);
 577 }
 578
 579 static int
 580 search_mapped_symbol (const void * l, const void * r)
 581 {
 582     return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
 583 }
 584
 585 /* Read in symbol table from core.
 586    One symbol per function is entered.  */
 587
 588 void
 589 core_create_function_syms (void)
 590 {
 591   bfd_vma min_vma = ~ (bfd_vma) 0;
 592   bfd_vma max_vma = 0;
 593   int cxxclass;
 594   long i;
 595   struct function_map * found = NULL;
 596   int core_has_func_syms = 0;
 597
 598   switch (core_bfd->xvec->flavour)
 599     {
 600     default:
 601       break;
 602     case bfd_target_coff_flavour:
 603     case bfd_target_ecoff_flavour:
 604     case bfd_target_xcoff_flavour:
 605     case bfd_target_elf_flavour:
 606     case bfd_target_som_flavour:
 607       core_has_func_syms = 1;
 608     }
 609
 610   /* Pass 1 - determine upper bound on number of function names.  */
 611   symtab.len = 0;
 612
 613   for (i = 0; i < core_num_syms; ++i)
 614     {
 615       if (!core_sym_class (core_syms[i]))
 616         continue;
 617
 618       /* Don't create a symtab entry for a function that has
 619          a mapping to a file, unless it's the first function
 620          in the file.  */
 621       if (symbol_map_count != 0)
 622         {
 623           /* Note: some systems (SunOS 5.8) crash if bsearch base argument
 624              is NULL.  */
 625           found = (struct function_map *) bsearch
 626             (core_syms[i]->name, symbol_map, symbol_map_count,
 627              sizeof (struct function_map), search_mapped_symbol);
 628         }
 629       if (found == NULL || found->is_first)
 630         ++symtab.len;
 631     }
 632
 633   if (symtab.len == 0)
 634     {
 635       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 636       done (1);
 637     }
 638
 639   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 640
 641   /* Pass 2 - create symbols.  */
 642   symtab.limit = symtab.base;
 643
 644   for (i = 0; i < core_num_syms; ++i)
 645     {
 646       asection *sym_sec;
 647
 648       cxxclass = core_sym_class (core_syms[i]);
 649
 650       if (!cxxclass)
 651         {
 652           DBG (AOUTDEBUG,
 653                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 654                        (unsigned long) core_syms[i]->value,
 655                        core_syms[i]->name));
 656           continue;
 657         }
 658
 659       if (symbol_map_count != 0)
 660         {
 661           /* Note: some systems (SunOS 5.8) crash if bsearch base argument
 662              is NULL.  */
 663           found = (struct function_map *) bsearch
 664             (core_syms[i]->name, symbol_map, symbol_map_count,
 665              sizeof (struct function_map), search_mapped_symbol);
 666         }
 667       if (found && ! found->is_first)
 668         continue;
 669
 670       sym_init (symtab.limit);
 671
 672       /* Symbol offsets are always section-relative.  */
 673       sym_sec = core_syms[i]->section;
 674       symtab.limit->addr = core_syms[i]->value;
 675       if (sym_sec)
 676         symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
 677
 678       if (found)
 679         {
 680           symtab.limit->name = found->file_name;
 681           symtab.limit->mapped = 1;
 682         }
 683       else
 684         {
 685           symtab.limit->name = core_syms[i]->name;
 686           symtab.limit->mapped = 0;
 687         }
 688
 689       /* Lookup filename and line number, if we can.  */
 690       {
 691         const char * filename;
 692         const char * func_name;
 693
 694         if (get_src_info (symtab.limit->addr, & filename, & func_name,
 695                           & symtab.limit->line_num))
 696           {
 697             symtab.limit->file = source_file_lookup_path (filename);
 698
 699             /* FIXME: Checking __osf__ here does not work with a cross
 700                gprof.  */
 701 #ifdef __osf__
 702             /* Suppress symbols that are not function names.  This is
 703                useful to suppress code-labels and aliases.
 704
 705                This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
 706                labels do not appear in the symbol table info, so this isn't
 707                necessary.  */
 708
 709             if (strcmp (symtab.limit->name, func_name) != 0)
 710               {
 711                 /* The symbol's address maps to a different name, so
 712                    it can't be a function-entry point.  This happens
 713                    for labels, for example.  */
 714                 DBG (AOUTDEBUG,
 715                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
 716                              symtab.limit->name, func_name));
 717                 continue;
 718               }
 719 #endif
 720           }
 721       }
 722
 723       symtab.limit->is_func = (!core_has_func_syms
 724                                || (core_syms[i]->flags & BSF_FUNCTION) != 0);
 725       symtab.limit->is_bb_head = TRUE;
 726
 727       if (cxxclass == 't')
 728         symtab.limit->is_static = TRUE;
 729
 730       /* Keep track of the minimum and maximum vma addresses used by all
 731          symbols.  When computing the max_vma, use the ending address of the
 732          section containing the symbol, if available.  */
 733       min_vma = MIN (symtab.limit->addr, min_vma);
 734       if (sym_sec)
 735         max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
 736                        + bfd_section_size (sym_sec->owner, sym_sec) - 1,
 737                        max_vma);
 738       else
 739         max_vma = MAX (symtab.limit->addr, max_vma);
 740
 741       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
 742                               (long) (symtab.limit - symtab.base),
 743                               symtab.limit->name,
 744                               (unsigned long) symtab.limit->addr));
 745       ++symtab.limit;
 746     }
 747
 748   symtab.len = symtab.limit - symtab.base;
 749   symtab_finalize (&symtab);
 750 }
 751
 752 /* Read in symbol table from core.
 753    One symbol per line of source code is entered.  */
 754
 755 void
 756 core_create_line_syms (void)
 757 {
 758   char *prev_name, *prev_filename;
 759   unsigned int prev_name_len, prev_filename_len;
 760   bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
 761   Sym *prev, dummy, *sym;
 762   const char *filename;
 763   int prev_line_num;
 764   Sym_Table ltab;
 765   bfd_vma vma_high;
 766
 767   /* Create symbols for functions as usual.  This is necessary in
 768      cases where parts of a program were not compiled with -g.  For
 769      those parts we still want to get info at the function level.  */
 770   core_create_function_syms ();
 771
 772   /* Pass 1: count the number of symbols.  */
 773
 774   /* To find all line information, walk through all possible
 775      text-space addresses (one by one!) and get the debugging
 776      info for each address.  When the debugging info changes,
 777      it is time to create a new symbol.
 778
 779      Of course, this is rather slow and it would be better if
 780      BFD would provide an iterator for enumerating all line infos.  */
 781   prev_name_len = PATH_MAX;
 782   prev_filename_len = PATH_MAX;
 783   prev_name = (char *) xmalloc (prev_name_len);
 784   prev_filename = (char *) xmalloc (prev_filename_len);
 785   ltab.len = 0;
 786   prev_line_num = 0;
 787
 788   vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
 789   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 790     {
 791       unsigned int len;
 792
 793       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 794           || (prev_line_num == dummy.line_num
 795               && prev_name != NULL
 796               && strcmp (prev_name, dummy.name) == 0
 797               && filename_cmp (prev_filename, filename) == 0))
 798         continue;
 799
 800       ++ltab.len;
 801       prev_line_num = dummy.line_num;
 802
 803       len = strlen (dummy.name);
 804       if (len >= prev_name_len)
 805         {
 806           prev_name_len = len + 1024;
 807           free (prev_name);
 808           prev_name = (char *) xmalloc (prev_name_len);
 809         }
 810
 811       strcpy (prev_name, dummy.name);
 812       len = strlen (filename);
 813
 814       if (len >= prev_filename_len)
 815         {
 816           prev_filename_len = len + 1024;
 817           free (prev_filename);
 818           prev_filename = (char *) xmalloc (prev_filename_len);
 819         }
 820
 821       strcpy (prev_filename, filename);
 822
 823       min_vma = MIN (vma, min_vma);
 824       max_vma = MAX (vma, max_vma);
 825     }
 826
 827   free (prev_name);
 828   free (prev_filename);
 829
 830   /* Make room for function symbols, too.  */
 831   ltab.len += symtab.len;
 832   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 833   ltab.limit = ltab.base;
 834
 835   /* Pass 2 - create symbols.  */
 836
 837   /* We now set is_static as we go along, rather than by running
 838      through the symbol table at the end.
 839
 840      The old way called symtab_finalize before the is_static pass,
 841      causing a problem since symtab_finalize uses is_static as part of
 842      its address conflict resolution algorithm.  Since global symbols
 843      were preferred over static symbols, and all line symbols were
 844      global at that point, static function names that conflicted with
 845      their own line numbers (static, but labeled as global) were
 846      rejected in favor of the line num.
 847
 848      This was not the desired functionality.  We always want to keep
 849      our function symbols and discard any conflicting line symbols.
 850      Perhaps symtab_finalize should be modified to make this
 851      distinction as well, but the current fix works and the code is a
 852      lot cleaner now.  */
 853   prev = 0;
 854
 855   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 856     {
 857       sym_init (ltab.limit);
 858
 859       if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
 860           || (prev && prev->line_num == ltab.limit->line_num
 861               && strcmp (prev->name, ltab.limit->name) == 0
 862               && filename_cmp (prev->file->name, filename) == 0))
 863         continue;
 864
 865       /* Make name pointer a malloc'ed string.  */
 866       ltab.limit->name = xstrdup (ltab.limit->name);
 867       ltab.limit->file = source_file_lookup_path (filename);
 868
 869       ltab.limit->addr = vma;
 870
 871       /* Set is_static based on the enclosing function, using either:
 872          1) the previous symbol, if it's from the same function, or
 873          2) a symtab lookup.  */
 874       if (prev && ltab.limit->file == prev->file &&
 875           strcmp (ltab.limit->name, prev->name) == 0)
 876         {
 877           ltab.limit->is_static = prev->is_static;
 878         }
 879       else
 880         {
 881           sym = sym_lookup(&symtab, ltab.limit->addr);
 882           if (sym)
 883             ltab.limit->is_static = sym->is_static;
 884         }
 885
 886       prev = ltab.limit;
 887
 888       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
 889                               (unsigned long) (ltab.limit - ltab.base),
 890                               ltab.limit->name,
 891                               (unsigned long) ltab.limit->addr));
 892       ++ltab.limit;
 893     }
 894
 895   /* Copy in function symbols.  */
 896   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 897   ltab.limit += symtab.len;
 898
 899   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 900     {
 901       fprintf (stderr,
 902                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 903                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 904       done (1);
 905     }
 906
 907   /* Finalize ltab and make it symbol table.  */
 908   symtab_finalize (&ltab);
 909   free (symtab.base);
 910   symtab = ltab;
 911 }