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   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_get_section_size (core_text_sect));
 275
 276   if (!core_text_space)
 277     {
 278       fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
 279                whoami, (unsigned long) bfd_get_section_size (core_text_sect));
 280       done (1);
 281     }
 282
 283   if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
 284                                  0, bfd_get_section_size (core_text_sect)))
 285     {
 286       bfd_perror ("bfd_get_section_contents");
 287       free (core_text_space);
 288       core_text_space = 0;
 289     }
 290
 291   if (!core_text_space)
 292     fprintf (stderr, _("%s: can't do -c\n"), whoami);
 293 }
 294
 295
 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 bfd_boolean
 457 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
 458 {
 459   const char *fname = 0, *func_name = 0;
 460   int l = 0;
 461
 462   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
 463                              addr - core_text_sect->vma,
 464                              &fname, &func_name, (unsigned int *) &l)
 465       && fname && func_name && l)
 466     {
 467       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 468                               (unsigned long) addr, fname, l, func_name));
 469       *filename = fname;
 470       *name = func_name;
 471       *line_num = l;
 472       return TRUE;
 473     }
 474   else
 475     {
 476       DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 477                               (unsigned long) addr,
 478                               fname ? fname : "<unknown>", l,
 479                               func_name ? func_name : "<unknown>"));
 480       return FALSE;
 481     }
 482 }
 483
 484 static char buf[BUFSIZE];
 485 static char address[BUFSIZE];
 486 static char name[BUFSIZE];
 487
 488 /* Return number of symbols in a symbol-table file.  */
 489
 490 static unsigned int
 491 num_of_syms_in (FILE * f)
 492 {
 493   char   type;
 494   unsigned int num = 0;
 495
 496   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 497     {
 498       if (sscanf (buf, "%" STR_BUFSIZE "s %c %" STR_BUFSIZE "s", address, &type, name) == 3)
 499         if (type == 't' || type == 'T')
 500           {
 501             /* PR 20499 - prevent integer overflow computing argument to xmalloc.  */
 502             if (++num >= UINT_MAX / sizeof (Sym))
 503               return -1U;
 504           }
 505     }
 506
 507   return num;
 508 }
 509
 510 /* Read symbol table from a file.  */
 511
 512 void
 513 core_create_syms_from (const char * sym_table_file)
 514 {
 515   char type;
 516   bfd_vma min_vma = ~(bfd_vma) 0;
 517   bfd_vma max_vma = 0;
 518   FILE * f;
 519
 520   f = fopen (sym_table_file, "r");
 521   if (!f)
 522     {
 523       fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
 524       done (1);
 525     }
 526
 527   /* Pass 1 - determine upper bound on number of function names.  */
 528   symtab.len = num_of_syms_in (f);
 529
 530   if (symtab.len == 0)
 531     {
 532       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
 533       done (1);
 534     }
 535   else if (symtab.len == -1U)
 536     {
 537       fprintf (stderr, _("%s: file `%s' has too many symbols\n"),
 538                whoami, sym_table_file);
 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     }
 575   fclose (f);
 576
 577   symtab.len = symtab.limit - symtab.base;
 578   symtab_finalize (&symtab);
 579 }
 580
 581 static int
 582 search_mapped_symbol (const void * l, const void * r)
 583 {
 584     return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
 585 }
 586
 587 /* Read in symbol table from core.
 588    One symbol per function is entered.  */
 589
 590 void
 591 core_create_function_syms (void)
 592 {
 593   bfd_vma min_vma = ~ (bfd_vma) 0;
 594   bfd_vma max_vma = 0;
 595   int cxxclass;
 596   long i;
 597   struct function_map * found = NULL;
 598   int core_has_func_syms = 0;
 599
 600   switch (core_bfd->xvec->flavour)
 601     {
 602     default:
 603       break;
 604     case bfd_target_coff_flavour:
 605     case bfd_target_ecoff_flavour:
 606     case bfd_target_xcoff_flavour:
 607     case bfd_target_elf_flavour:
 608     case bfd_target_som_flavour:
 609       core_has_func_syms = 1;
 610     }
 611
 612   /* Pass 1 - determine upper bound on number of function names.  */
 613   symtab.len = 0;
 614
 615   for (i = 0; i < core_num_syms; ++i)
 616     {
 617       if (!core_sym_class (core_syms[i]))
 618         continue;
 619
 620       /* Don't create a symtab entry for a function that has
 621          a mapping to a file, unless it's the first function
 622          in the file.  */
 623       if (symbol_map_count != 0)
 624         {
 625           /* Note: some systems (SunOS 5.8) crash if bsearch base argument
 626              is NULL.  */
 627           found = (struct function_map *) bsearch
 628             (core_syms[i]->name, symbol_map, symbol_map_count,
 629              sizeof (struct function_map), search_mapped_symbol);
 630         }
 631       if (found == NULL || found->is_first)
 632         ++symtab.len;
 633     }
 634
 635   if (symtab.len == 0)
 636     {
 637       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 638       done (1);
 639     }
 640
 641   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 642
 643   /* Pass 2 - create symbols.  */
 644   symtab.limit = symtab.base;
 645
 646   for (i = 0; i < core_num_syms; ++i)
 647     {
 648       asection *sym_sec;
 649
 650       cxxclass = core_sym_class (core_syms[i]);
 651
 652       if (!cxxclass)
 653         {
 654           DBG (AOUTDEBUG,
 655                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 656                        (unsigned long) core_syms[i]->value,
 657                        core_syms[i]->name));
 658           continue;
 659         }
 660
 661       if (symbol_map_count != 0)
 662         {
 663           /* Note: some systems (SunOS 5.8) crash if bsearch base argument
 664              is NULL.  */
 665           found = (struct function_map *) bsearch
 666             (core_syms[i]->name, symbol_map, symbol_map_count,
 667              sizeof (struct function_map), search_mapped_symbol);
 668         }
 669       if (found && ! found->is_first)
 670         continue;
 671
 672       sym_init (symtab.limit);
 673
 674       /* Symbol offsets are always section-relative.  */
 675       sym_sec = core_syms[i]->section;
 676       symtab.limit->addr = core_syms[i]->value;
 677       if (sym_sec)
 678         symtab.limit->addr += bfd_get_section_vma (sym_sec->owner, sym_sec);
 679
 680       if (found)
 681         {
 682           symtab.limit->name = found->file_name;
 683           symtab.limit->mapped = 1;
 684         }
 685       else
 686         {
 687           symtab.limit->name = core_syms[i]->name;
 688           symtab.limit->mapped = 0;
 689         }
 690
 691       /* Lookup filename and line number, if we can.  */
 692       {
 693         const char * filename;
 694         const char * func_name;
 695
 696         if (get_src_info (symtab.limit->addr, & filename, & func_name,
 697                           & symtab.limit->line_num))
 698           {
 699             symtab.limit->file = source_file_lookup_path (filename);
 700
 701             /* FIXME: Checking __osf__ here does not work with a cross
 702                gprof.  */
 703 #ifdef __osf__
 704             /* Suppress symbols that are not function names.  This is
 705                useful to suppress code-labels and aliases.
 706
 707                This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
 708                labels do not appear in the symbol table info, so this isn't
 709                necessary.  */
 710
 711             if (strcmp (symtab.limit->name, func_name) != 0)
 712               {
 713                 /* The symbol's address maps to a different name, so
 714                    it can't be a function-entry point.  This happens
 715                    for labels, for example.  */
 716                 DBG (AOUTDEBUG,
 717                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
 718                              symtab.limit->name, func_name));
 719                 continue;
 720               }
 721 #endif
 722           }
 723       }
 724
 725       symtab.limit->is_func = (!core_has_func_syms
 726                                || (core_syms[i]->flags & BSF_FUNCTION) != 0);
 727       symtab.limit->is_bb_head = TRUE;
 728
 729       if (cxxclass == 't')
 730         symtab.limit->is_static = TRUE;
 731
 732       /* Keep track of the minimum and maximum vma addresses used by all
 733          symbols.  When computing the max_vma, use the ending address of the
 734          section containing the symbol, if available.  */
 735       min_vma = MIN (symtab.limit->addr, min_vma);
 736       if (sym_sec)
 737         max_vma = MAX (bfd_get_section_vma (sym_sec->owner, sym_sec)
 738                        + bfd_section_size (sym_sec->owner, sym_sec) - 1,
 739                        max_vma);
 740       else
 741         max_vma = MAX (symtab.limit->addr, max_vma);
 742
 743       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
 744                               (long) (symtab.limit - symtab.base),
 745                               symtab.limit->name,
 746                               (unsigned long) symtab.limit->addr));
 747       ++symtab.limit;
 748     }
 749
 750   symtab.len = symtab.limit - symtab.base;
 751   symtab_finalize (&symtab);
 752 }
 753
 754 /* Read in symbol table from core.
 755    One symbol per line of source code is entered.  */
 756
 757 void
 758 core_create_line_syms (void)
 759 {
 760   char *prev_name, *prev_filename;
 761   unsigned int prev_name_len, prev_filename_len;
 762   bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
 763   Sym *prev, dummy, *sym;
 764   const char *filename;
 765   int prev_line_num;
 766   Sym_Table ltab;
 767   bfd_vma vma_high;
 768
 769   /* Create symbols for functions as usual.  This is necessary in
 770      cases where parts of a program were not compiled with -g.  For
 771      those parts we still want to get info at the function level.  */
 772   core_create_function_syms ();
 773
 774   /* Pass 1: count the number of symbols.  */
 775
 776   /* To find all line information, walk through all possible
 777      text-space addresses (one by one!) and get the debugging
 778      info for each address.  When the debugging info changes,
 779      it is time to create a new symbol.
 780
 781      Of course, this is rather slow and it would be better if
 782      BFD would provide an iterator for enumerating all line infos.  */
 783   prev_name_len = PATH_MAX;
 784   prev_filename_len = PATH_MAX;
 785   prev_name = (char *) xmalloc (prev_name_len);
 786   prev_filename = (char *) xmalloc (prev_filename_len);
 787   ltab.len = 0;
 788   prev_line_num = 0;
 789
 790   vma_high = core_text_sect->vma + bfd_get_section_size (core_text_sect);
 791   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 792     {
 793       unsigned int len;
 794
 795       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 796           || (prev_line_num == dummy.line_num
 797               && prev_name != NULL
 798               && strcmp (prev_name, dummy.name) == 0
 799               && filename_cmp (prev_filename, filename) == 0))
 800         continue;
 801
 802       ++ltab.len;
 803       prev_line_num = dummy.line_num;
 804
 805       len = strlen (dummy.name);
 806       if (len >= prev_name_len)
 807         {
 808           prev_name_len = len + 1024;
 809           free (prev_name);
 810           prev_name = (char *) xmalloc (prev_name_len);
 811         }
 812
 813       strcpy (prev_name, dummy.name);
 814       len = strlen (filename);
 815
 816       if (len >= prev_filename_len)
 817         {
 818           prev_filename_len = len + 1024;
 819           free (prev_filename);
 820           prev_filename = (char *) xmalloc (prev_filename_len);
 821         }
 822
 823       strcpy (prev_filename, filename);
 824
 825       min_vma = MIN (vma, min_vma);
 826       max_vma = MAX (vma, max_vma);
 827     }
 828
 829   free (prev_name);
 830   free (prev_filename);
 831
 832   /* Make room for function symbols, too.  */
 833   ltab.len += symtab.len;
 834   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 835   ltab.limit = ltab.base;
 836
 837   /* Pass 2 - create symbols.  */
 838
 839   /* We now set is_static as we go along, rather than by running
 840      through the symbol table at the end.
 841
 842      The old way called symtab_finalize before the is_static pass,
 843      causing a problem since symtab_finalize uses is_static as part of
 844      its address conflict resolution algorithm.  Since global symbols
 845      were preferred over static symbols, and all line symbols were
 846      global at that point, static function names that conflicted with
 847      their own line numbers (static, but labeled as global) were
 848      rejected in favor of the line num.
 849
 850      This was not the desired functionality.  We always want to keep
 851      our function symbols and discard any conflicting line symbols.
 852      Perhaps symtab_finalize should be modified to make this
 853      distinction as well, but the current fix works and the code is a
 854      lot cleaner now.  */
 855   prev = 0;
 856
 857   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 858     {
 859       sym_init (ltab.limit);
 860
 861       if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
 862           || (prev && prev->line_num == ltab.limit->line_num
 863               && strcmp (prev->name, ltab.limit->name) == 0
 864               && filename_cmp (prev->file->name, filename) == 0))
 865         continue;
 866
 867       /* Make name pointer a malloc'ed string.  */
 868       ltab.limit->name = xstrdup (ltab.limit->name);
 869       ltab.limit->file = source_file_lookup_path (filename);
 870
 871       ltab.limit->addr = vma;
 872
 873       /* Set is_static based on the enclosing function, using either:
 874          1) the previous symbol, if it's from the same function, or
 875          2) a symtab lookup.  */
 876       if (prev && ltab.limit->file == prev->file &&
 877           strcmp (ltab.limit->name, prev->name) == 0)
 878         {
 879           ltab.limit->is_static = prev->is_static;
 880         }
 881       else
 882         {
 883           sym = sym_lookup(&symtab, ltab.limit->addr);
 884           if (sym)
 885             ltab.limit->is_static = sym->is_static;
 886         }
 887
 888       prev = ltab.limit;
 889
 890       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
 891                               (unsigned long) (ltab.limit - ltab.base),
 892                               ltab.limit->name,
 893                               (unsigned long) ltab.limit->addr));
 894       ++ltab.limit;
 895     }
 896
 897   /* Copy in function symbols.  */
 898   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 899   ltab.limit += symtab.len;
 900
 901   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 902     {
 903       fprintf (stderr,
 904                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 905                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 906       done (1);
 907     }
 908
 909   /* Finalize ltab and make it symbol table.  */
 910   symtab_finalize (&ltab);
 911   free (symtab.base);
 912   symtab = ltab;
 913 }