gprof/corefile.c

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