gprof/corefile.c

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