gprof/corefile.c

   1 /* corefile.c
   2
   3    Copyright (C) 1999-2021 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 bool 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   core_bfd->flags |= BFD_DECOMPRESS;
 190
 191   if (!bfd_check_format (core_bfd, bfd_object))
 192     {
 193       fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
 194       done (1);
 195     }
 196
 197   /* Get core's text section.  */
 198   core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
 199   if (!core_text_sect)
 200     {
 201       core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
 202       if (!core_text_sect)
 203         {
 204           fprintf (stderr, _("%s: can't find .text section in %s\n"),
 205                    whoami, aout_name);
 206           done (1);
 207         }
 208     }
 209
 210   /* Read core's symbol table.  */
 211
 212   /* This will probably give us more than we need, but that's ok.  */
 213   core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
 214   if (core_sym_bytes < 0)
 215     {
 216       fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
 217                bfd_errmsg (bfd_get_error ()));
 218       done (1);
 219     }
 220
 221   core_syms = (asymbol **) xmalloc (core_sym_bytes);
 222   core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
 223
 224   if (core_num_syms < 0)
 225     {
 226       fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
 227                bfd_errmsg (bfd_get_error ()));
 228       done (1);
 229     }
 230
 231   synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
 232                                           0, NULL, &synthsyms);
 233   if (synth_count > 0)
 234     {
 235       asymbol **symp;
 236       long new_size;
 237       long i;
 238
 239       new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
 240       core_syms = (asymbol **) xrealloc (core_syms, new_size);
 241       symp = core_syms + core_num_syms;
 242       core_num_syms += synth_count;
 243       for (i = 0; i < synth_count; i++)
 244         *symp++ = synthsyms + i;
 245       *symp = 0;
 246     }
 247
 248   min_insn_size = 1;
 249   offset_to_code = 0;
 250
 251   switch (bfd_get_arch (core_bfd))
 252     {
 253     case bfd_arch_vax:
 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
 271 void
 272 core_get_text_space (bfd *cbfd)
 273 {
 274   core_text_space = malloc (bfd_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_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_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
 296 void
 297 find_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_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 bool
 457 get_src_info (bfd_vma addr, const char **filename, const char **name,
 458               int *line_num)
 459 {
 460   const char *fname = 0, *func_name = 0;
 461   int l = 0;
 462
 463   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
 464                              addr - core_text_sect->vma,
 465                              &fname, &func_name, (unsigned int *) &l)
 466       && fname && func_name && l)
 467     {
 468       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 469                               (unsigned long) addr, fname, l, func_name));
 470       *filename = fname;
 471       *name = func_name;
 472       *line_num = l;
 473       return true;
 474     }
 475   else
 476     {
 477       DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 478                               (unsigned long) addr,
 479                               fname ? fname : "<unknown>", l,
 480                               func_name ? func_name : "<unknown>"));
 481       return false;
 482     }
 483 }
 484
 485 static char buf[BUFSIZE];
 486 static char address[BUFSIZE];
 487 static char name[BUFSIZE];
 488
 489 /* Return number of symbols in a symbol-table file.  */
 490
 491 static unsigned int
 492 num_of_syms_in (FILE * f)
 493 {
 494   char   type;
 495   unsigned int num = 0;
 496
 497   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 498     {
 499       if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
 500         if (type == 't' || type == 'T')
 501           {
 502             /* PR 20499 - prevent integer overflow computing argument to xmalloc.  */
 503             if (++num >= UINT_MAX / sizeof (Sym))
 504               return -1U;
 505           }
 506     }
 507
 508   return num;
 509 }
 510
 511 /* Read symbol table from a file.  */
 512
 513 void
 514 core_create_syms_from (const char * sym_table_file)
 515 {
 516   char type;
 517   bfd_vma min_vma = ~(bfd_vma) 0;
 518   bfd_vma max_vma = 0;
 519   FILE * f;
 520
 521   f = fopen (sym_table_file, "r");
 522   if (!f)
 523     {
 524       fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
 525       done (1);
 526     }
 527
 528   /* Pass 1 - determine upper bound on number of function names.  */
 529   symtab.len = num_of_syms_in (f);
 530
 531   if (symtab.len == 0)
 532     {
 533       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
 534       done (1);
 535     }
 536   else if (symtab.len == -1U)
 537     {
 538       fprintf (stderr, _("%s: file `%s' has too many symbols\n"),
 539                whoami, sym_table_file);
 540       done (1);
 541     }
 542
 543   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 544
 545   /* Pass 2 - create symbols.  */
 546   symtab.limit = symtab.base;
 547
 548   if (fseek (f, 0, SEEK_SET) != 0)
 549     {
 550       perror (sym_table_file);
 551       done (1);
 552     }
 553
 554   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 555     {
 556       if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) != 3)
 557         continue;
 558       if (type != 't' && type != 'T')
 559         continue;
 560
 561       sym_init (symtab.limit);
 562
 563       sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
 564
 565       symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
 566       strcpy ((char *) symtab.limit->name, name);
 567       symtab.limit->mapped = 0;
 568       symtab.limit->is_func = true;
 569       symtab.limit->is_bb_head = true;
 570       symtab.limit->is_static = (type == 't');
 571       min_vma = MIN (symtab.limit->addr, min_vma);
 572       max_vma = MAX (symtab.limit->addr, max_vma);
 573
 574       ++symtab.limit;
 575     }
 576   fclose (f);
 577
 578   symtab.len = symtab.limit - symtab.base;
 579   symtab_finalize (&symtab);
 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_som_flavour:
 610       core_has_func_syms = 1;
 611     }
 612
 613   /* Pass 1 - determine upper bound on number of function names.  */
 614   symtab.len = 0;
 615
 616   for (i = 0; i < core_num_syms; ++i)
 617     {
 618       if (!core_sym_class (core_syms[i]))
 619         continue;
 620
 621       /* Don't create a symtab entry for a function that has
 622          a mapping to a file, unless it's the first function
 623          in the file.  */
 624       if (symbol_map_count != 0)
 625         {
 626           /* Note: some systems (SunOS 5.8) crash if bsearch base argument
 627              is NULL.  */
 628           found = (struct function_map *) bsearch
 629             (core_syms[i]->name, symbol_map, symbol_map_count,
 630              sizeof (struct function_map), search_mapped_symbol);
 631         }
 632       if (found == NULL || found->is_first)
 633         ++symtab.len;
 634     }
 635
 636   if (symtab.len == 0)
 637     {
 638       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 639       done (1);
 640     }
 641
 642   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 643
 644   /* Pass 2 - create symbols.  */
 645   symtab.limit = symtab.base;
 646
 647   for (i = 0; i < core_num_syms; ++i)
 648     {
 649       asection *sym_sec;
 650
 651       cxxclass = core_sym_class (core_syms[i]);
 652
 653       if (!cxxclass)
 654         {
 655           DBG (AOUTDEBUG,
 656                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 657                        (unsigned long) core_syms[i]->value,
 658                        core_syms[i]->name));
 659           continue;
 660         }
 661
 662       if (symbol_map_count != 0)
 663         {
 664           /* Note: some systems (SunOS 5.8) crash if bsearch base argument
 665              is NULL.  */
 666           found = (struct function_map *) bsearch
 667             (core_syms[i]->name, symbol_map, symbol_map_count,
 668              sizeof (struct function_map), search_mapped_symbol);
 669         }
 670       if (found && ! found->is_first)
 671         continue;
 672
 673       sym_init (symtab.limit);
 674
 675       /* Symbol offsets are always section-relative.  */
 676       sym_sec = core_syms[i]->section;
 677       symtab.limit->addr = core_syms[i]->value;
 678       if (sym_sec)
 679         symtab.limit->addr += bfd_section_vma (sym_sec);
 680
 681       if (found)
 682         {
 683           symtab.limit->name = found->file_name;
 684           symtab.limit->mapped = 1;
 685         }
 686       else
 687         {
 688           symtab.limit->name = core_syms[i]->name;
 689           symtab.limit->mapped = 0;
 690         }
 691
 692       /* Lookup filename and line number, if we can.  */
 693       {
 694         const char * filename;
 695         const char * func_name;
 696
 697         if (get_src_info (symtab.limit->addr, & filename, & func_name,
 698                           & symtab.limit->line_num))
 699           {
 700             symtab.limit->file = source_file_lookup_path (filename);
 701
 702             /* FIXME: Checking __osf__ here does not work with a cross
 703                gprof.  */
 704 #ifdef __osf__
 705             /* Suppress symbols that are not function names.  This is
 706                useful to suppress code-labels and aliases.
 707
 708                This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
 709                labels do not appear in the symbol table info, so this isn't
 710                necessary.  */
 711
 712             if (strcmp (symtab.limit->name, func_name) != 0)
 713               {
 714                 /* The symbol's address maps to a different name, so
 715                    it can't be a function-entry point.  This happens
 716                    for labels, for example.  */
 717                 DBG (AOUTDEBUG,
 718                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
 719                              symtab.limit->name, func_name));
 720                 continue;
 721               }
 722 #endif
 723           }
 724       }
 725
 726       symtab.limit->is_func = (!core_has_func_syms
 727                                || (core_syms[i]->flags & BSF_FUNCTION) != 0);
 728       symtab.limit->is_bb_head = true;
 729
 730       if (cxxclass == 't')
 731         symtab.limit->is_static = true;
 732
 733       /* Keep track of the minimum and maximum vma addresses used by all
 734          symbols.  When computing the max_vma, use the ending address of the
 735          section containing the symbol, if available.  */
 736       min_vma = MIN (symtab.limit->addr, min_vma);
 737       if (sym_sec)
 738         max_vma = MAX (bfd_section_vma (sym_sec)
 739                        + bfd_section_size (sym_sec) - 1,
 740                        max_vma);
 741       else
 742         max_vma = MAX (symtab.limit->addr, max_vma);
 743
 744       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
 745                               (long) (symtab.limit - symtab.base),
 746                               symtab.limit->name,
 747                               (unsigned long) symtab.limit->addr));
 748       ++symtab.limit;
 749     }
 750
 751   symtab.len = symtab.limit - symtab.base;
 752   symtab_finalize (&symtab);
 753 }
 754
 755 /* Read in symbol table from core.
 756    One symbol per line of source code is entered.  */
 757
 758 void
 759 core_create_line_syms (void)
 760 {
 761   char *prev_name, *prev_filename;
 762   unsigned int prev_name_len, prev_filename_len;
 763   bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
 764   Sym *prev, dummy, *sym;
 765   const char *filename;
 766   int prev_line_num;
 767   Sym_Table ltab;
 768   bfd_vma vma_high;
 769
 770   /* Create symbols for functions as usual.  This is necessary in
 771      cases where parts of a program were not compiled with -g.  For
 772      those parts we still want to get info at the function level.  */
 773   core_create_function_syms ();
 774
 775   /* Pass 1: count the number of symbols.  */
 776
 777   /* To find all line information, walk through all possible
 778      text-space addresses (one by one!) and get the debugging
 779      info for each address.  When the debugging info changes,
 780      it is time to create a new symbol.
 781
 782      Of course, this is rather slow and it would be better if
 783      BFD would provide an iterator for enumerating all line infos.  */
 784   prev_name_len = 1024;
 785   prev_filename_len = 1024;
 786   prev_name = (char *) xmalloc (prev_name_len);
 787   prev_filename = (char *) xmalloc (prev_filename_len);
 788   ltab.len = 0;
 789   prev_line_num = 0;
 790
 791   vma_high = core_text_sect->vma + bfd_section_size (core_text_sect);
 792   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 793     {
 794       unsigned int len;
 795
 796       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 797           || (prev_line_num == dummy.line_num
 798               && prev_name != NULL
 799               && strcmp (prev_name, dummy.name) == 0
 800               && filename_cmp (prev_filename, filename) == 0))
 801         continue;
 802
 803       ++ltab.len;
 804       prev_line_num = dummy.line_num;
 805
 806       len = strlen (dummy.name);
 807       if (len >= prev_name_len)
 808         {
 809           prev_name_len = len + 1024;
 810           free (prev_name);
 811           prev_name = (char *) xmalloc (prev_name_len);
 812         }
 813
 814       strcpy (prev_name, dummy.name);
 815       len = strlen (filename);
 816
 817       if (len >= prev_filename_len)
 818         {
 819           prev_filename_len = len + 1024;
 820           free (prev_filename);
 821           prev_filename = (char *) xmalloc (prev_filename_len);
 822         }
 823
 824       strcpy (prev_filename, filename);
 825
 826       min_vma = MIN (vma, min_vma);
 827       max_vma = MAX (vma, max_vma);
 828     }
 829
 830   free (prev_name);
 831   free (prev_filename);
 832
 833   /* Make room for function symbols, too.  */
 834   ltab.len += symtab.len;
 835   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 836   ltab.limit = ltab.base;
 837
 838   /* Pass 2 - create symbols.  */
 839
 840   /* We now set is_static as we go along, rather than by running
 841      through the symbol table at the end.
 842
 843      The old way called symtab_finalize before the is_static pass,
 844      causing a problem since symtab_finalize uses is_static as part of
 845      its address conflict resolution algorithm.  Since global symbols
 846      were preferred over static symbols, and all line symbols were
 847      global at that point, static function names that conflicted with
 848      their own line numbers (static, but labeled as global) were
 849      rejected in favor of the line num.
 850
 851      This was not the desired functionality.  We always want to keep
 852      our function symbols and discard any conflicting line symbols.
 853      Perhaps symtab_finalize should be modified to make this
 854      distinction as well, but the current fix works and the code is a
 855      lot cleaner now.  */
 856   prev = 0;
 857
 858   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 859     {
 860       sym_init (ltab.limit);
 861
 862       if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
 863           || (prev && prev->line_num == ltab.limit->line_num
 864               && strcmp (prev->name, ltab.limit->name) == 0
 865               && filename_cmp (prev->file->name, filename) == 0))
 866         continue;
 867
 868       /* Make name pointer a malloc'ed string.  */
 869       ltab.limit->name = xstrdup (ltab.limit->name);
 870       ltab.limit->file = source_file_lookup_path (filename);
 871
 872       ltab.limit->addr = vma;
 873
 874       /* Set is_static based on the enclosing function, using either:
 875          1) the previous symbol, if it's from the same function, or
 876          2) a symtab lookup.  */
 877       if (prev && ltab.limit->file == prev->file &&
 878           strcmp (ltab.limit->name, prev->name) == 0)
 879         {
 880           ltab.limit->is_static = prev->is_static;
 881         }
 882       else
 883         {
 884           sym = sym_lookup(&symtab, ltab.limit->addr);
 885           if (sym)
 886             ltab.limit->is_static = sym->is_static;
 887         }
 888
 889       prev = ltab.limit;
 890
 891       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
 892                               (unsigned long) (ltab.limit - ltab.base),
 893                               ltab.limit->name,
 894                               (unsigned long) ltab.limit->addr));
 895       ++ltab.limit;
 896     }
 897
 898   /* Copy in function symbols.  */
 899   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 900   ltab.limit += symtab.len;
 901
 902   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 903     {
 904       fprintf (stderr,
 905                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 906                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 907       done (1);
 908     }
 909
 910   /* Finalize ltab and make it symbol table.  */
 911   symtab_finalize (&ltab);
 912   free (symtab.base);
 913   symtab = ltab;
 914 }