contrib/binutils-2.24/gprof/corefile.c

   1 /* corefile.c
   2
   3    Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009,
   4    2010, 2011, 2012  Free Software Foundation, Inc.
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22 \f
  23 #include "gprof.h"
  24 #include "libiberty.h"
  25 #include "filenames.h"
  26 #include "search_list.h"
  27 #include "source.h"
  28 #include "symtab.h"
  29 #include "hist.h"
  30 #include "corefile.h"
  31 #include "safe-ctype.h"
  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 static void
  77 read_function_mappings (const char *filename)
  78 {
  79   FILE * file = fopen (filename, "r");
  80   char dummy[1024];
  81   int count = 0;
  82   unsigned int i;
  83
  84   if (!file)
  85     {
  86       fprintf (stderr, _("%s: could not open %s.\n"), whoami, filename);
  87       done (1);
  88     }
  89
  90   /* First parse the mapping file so we know how big we need to
  91      make our tables.  We also do some sanity checks at this
  92      time.  */
  93   while (!feof (file))
  94     {
  95       int matches;
  96
  97       matches = fscanf (file, "%[^\n:]", dummy);
  98       if (!matches)
  99         parse_error (filename);
 100
 101       /* Just skip messages about files with no symbols.  */
 102       if (!strncmp (dummy, "No symbols in ", 14))
 103         {
 104           matches = fscanf (file, "\n");
 105           if (matches == EOF)
 106             parse_error (filename);
 107           continue;
 108         }
 109
 110       /* Don't care what else is on this line at this point.  */
 111       matches = fscanf (file, "%[^\n]\n", dummy);
 112       if (!matches)
 113         parse_error (filename);
 114       count++;
 115     }
 116
 117   /* Now we know how big we need to make our table.  */
 118   symbol_map = ((struct function_map *)
 119                 xmalloc (count * sizeof (struct function_map)));
 120
 121   /* Rewind the input file so we can read it again.  */
 122   rewind (file);
 123
 124   /* Read each entry and put it into the table.  */
 125   count = 0;
 126   while (!feof (file))
 127     {
 128       int matches;
 129       char *tmp;
 130
 131       matches = fscanf (file, "%[^\n:]", dummy);
 132       if (!matches)
 133         parse_error (filename);
 134
 135       /* Just skip messages about files with no symbols.  */
 136       if (!strncmp (dummy, "No symbols in ", 14))
 137         {
 138           matches = fscanf (file, "\n");
 139           if (matches == EOF)
 140             parse_error (filename);
 141           continue;
 142         }
 143
 144       /* dummy has the filename, go ahead and copy it.  */
 145       symbol_map[count].file_name = (char *) xmalloc (strlen (dummy) + 1);
 146       strcpy (symbol_map[count].file_name, dummy);
 147
 148       /* Now we need the function name.  */
 149       matches = fscanf (file, "%[^\n]\n", dummy);
 150       if (!matches)
 151         parse_error (filename);
 152       tmp = strrchr (dummy, ' ') + 1;
 153       symbol_map[count].function_name = (char *) xmalloc (strlen (tmp) + 1);
 154       strcpy (symbol_map[count].function_name, tmp);
 155       count++;
 156     }
 157
 158   /* Record the size of the map table for future reference.  */
 159   symbol_map_count = count;
 160
 161   for (i = 0; i < symbol_map_count; ++i)
 162     if (i == 0
 163         || filename_cmp (symbol_map[i].file_name, symbol_map[i - 1].file_name))
 164       symbol_map[i].is_first = 1;
 165
 166   qsort (symbol_map, symbol_map_count, sizeof (struct function_map), cmp_symbol_map);
 167 }
 168
 169 void
 170 core_init (const char * aout_name)
 171 {
 172   int core_sym_bytes;
 173   asymbol *synthsyms;
 174   long synth_count;
 175
 176   core_bfd = bfd_openr (aout_name, 0);
 177
 178   if (!core_bfd)
 179     {
 180       perror (aout_name);
 181       done (1);
 182     }
 183
 184   if (!bfd_check_format (core_bfd, bfd_object))
 185     {
 186       fprintf (stderr, _("%s: %s: not in executable format\n"), whoami, aout_name);
 187       done (1);
 188     }
 189
 190   /* Get core's text section.  */
 191   core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
 192   if (!core_text_sect)
 193     {
 194       core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
 195       if (!core_text_sect)
 196         {
 197           fprintf (stderr, _("%s: can't find .text section in %s\n"),
 198                    whoami, aout_name);
 199           done (1);
 200         }
 201     }
 202
 203   /* Read core's symbol table.  */
 204
 205   /* This will probably give us more than we need, but that's ok.  */
 206   core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
 207   if (core_sym_bytes < 0)
 208     {
 209       fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
 210                bfd_errmsg (bfd_get_error ()));
 211       done (1);
 212     }
 213
 214   core_syms = (asymbol **) xmalloc (core_sym_bytes);
 215   core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
 216
 217   if (core_num_syms < 0)
 218     {
 219       fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
 220                bfd_errmsg (bfd_get_error ()));
 221       done (1);
 222     }
 223
 224   synth_count = bfd_get_synthetic_symtab (core_bfd, core_num_syms, core_syms,
 225                                           0, NULL, &synthsyms);
 226   if (synth_count > 0)
 227     {
 228       asymbol **symp;
 229       long new_size;
 230       long i;
 231
 232       new_size = (core_num_syms + synth_count + 1) * sizeof (*core_syms);
 233       core_syms = (asymbol **) xrealloc (core_syms, new_size);
 234       symp = core_syms + core_num_syms;
 235       core_num_syms += synth_count;
 236       for (i = 0; i < synth_count; i++)
 237         *symp++ = synthsyms + i;
 238       *symp = 0;
 239     }
 240
 241   min_insn_size = 1;
 242   offset_to_code = 0;
 243
 244   switch (bfd_get_arch (core_bfd))
 245     {
 246     case bfd_arch_vax:
 247     case bfd_arch_tahoe:
 248       offset_to_code = 2;
 249       break;
 250
 251     case bfd_arch_alpha:
 252       min_insn_size = 4;
 253       break;
 254
 255     default:
 256       break;
 257     }
 258
 259   if (function_mapping_file)
 260     read_function_mappings (function_mapping_file);
 261 }
 262
 263 /* Read in the text space of an a.out file.  */
 264
 265 void
 266 core_get_text_space (bfd *cbfd)
 267 {
 268   core_text_space = malloc (bfd_get_section_size (core_text_sect));
 269
 270   if (!core_text_space)
 271     {
 272       fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
 273                whoami, (unsigned long) bfd_get_section_size (core_text_sect));
 274       done (1);
 275     }
 276
 277   if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
 278                                  0, bfd_get_section_size (core_text_sect)))
 279     {
 280       bfd_perror ("bfd_get_section_contents");
 281       free (core_text_space);
 282       core_text_space = 0;
 283     }
 284
 285   if (!core_text_space)
 286     fprintf (stderr, _("%s: can't do -c\n"), whoami);
 287 }
 288
 289
 290 void
 291 find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)
 292 {
 293   if (core_text_space == 0)
 294     return;
 295
 296   hist_clip_symbol_address (&p_lowpc, &p_highpc);
 297
 298   switch (bfd_get_arch (core_bfd))
 299     {
 300     case bfd_arch_i386:
 301       i386_find_call (parent, p_lowpc, p_highpc);
 302       break;
 303
 304     case bfd_arch_alpha:
 305       alpha_find_call (parent, p_lowpc, p_highpc);
 306       break;
 307
 308     case bfd_arch_vax:
 309       vax_find_call (parent, p_lowpc, p_highpc);
 310       break;
 311
 312     case bfd_arch_sparc:
 313       sparc_find_call (parent, p_lowpc, p_highpc);
 314       break;
 315
 316     case bfd_arch_tahoe:
 317       tahoe_find_call (parent, p_lowpc, p_highpc);
 318       break;
 319
 320     case bfd_arch_mips:
 321       mips_find_call (parent, p_lowpc, p_highpc);
 322       break;
 323
 324     case bfd_arch_aarch64:
 325       aarch64_find_call (parent, p_lowpc, p_highpc);
 326       break;
 327
 328     default:
 329       fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
 330                whoami, bfd_printable_name(core_bfd));
 331
 332       /* Don't give the error more than once.  */
 333       ignore_direct_calls = FALSE;
 334     }
 335 }
 336
 337 /* Return class of symbol SYM.  The returned class can be any of:
 338         0   -> symbol is not interesting to us
 339         'T' -> symbol is a global name
 340         't' -> symbol is a local (static) name.  */
 341
 342 static int
 343 core_sym_class (asymbol *sym)
 344 {
 345   symbol_info syminfo;
 346   const char *name;
 347   char sym_prefix;
 348   int i;
 349
 350   if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
 351     return 0;
 352
 353   /* Must be a text symbol, and static text symbols
 354      don't qualify if ignore_static_funcs set.   */
 355   if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
 356     {
 357       DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
 358                               sym->name));
 359       return 0;
 360     }
 361
 362   bfd_get_symbol_info (core_bfd, sym, &syminfo);
 363   i = syminfo.type;
 364
 365   if (i == 'T')
 366     return i;                   /* It's a global symbol.  */
 367
 368   if (i == 'W')
 369     /* Treat weak symbols as text symbols.  FIXME: a weak symbol may
 370        also be a data symbol.  */
 371     return 'T';
 372
 373   if (i != 't')
 374     {
 375       /* Not a static text symbol.  */
 376       DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
 377                               sym->name, i));
 378       return 0;
 379     }
 380
 381   /* Do some more filtering on static function-names.  */
 382   if (ignore_static_funcs)
 383     return 0;
 384
 385   /* Can't zero-length name or funny characters in name, where
 386      `funny' includes: `.' (.o file names) and `$' (Pascal labels).  */
 387   if (!sym->name || sym->name[0] == '\0')
 388     return 0;
 389
 390   for (name = sym->name; *name; ++name)
 391     {
 392       if (*name == '$')
 393         return 0;
 394
 395       while (*name == '.')
 396         {
 397           /* Allow both nested subprograms (which end with ".NNN", where N is
 398              a digit) and GCC cloned functions (which contain ".clone").
 399              Allow for multiple iterations of both - apparently GCC can clone
 400              clones and subprograms.  */
 401           int digit_seen = 0;
 402 #define CLONE_NAME          ".clone."
 403 #define CLONE_NAME_LEN      strlen (CLONE_NAME)
 404 #define CONSTPROP_NAME      ".constprop."
 405 #define CONSTPROP_NAME_LEN  strlen (CONSTPROP_NAME)
 406
 407           if (strlen (name) > CLONE_NAME_LEN
 408               && strncmp (name, CLONE_NAME, CLONE_NAME_LEN) == 0)
 409             name += CLONE_NAME_LEN - 1;
 410
 411           else if (strlen (name) > CONSTPROP_NAME_LEN
 412               && strncmp (name, CONSTPROP_NAME, CONSTPROP_NAME_LEN) == 0)
 413             name += CONSTPROP_NAME_LEN - 1;
 414
 415           for (name++; *name; name++)
 416             if (digit_seen && *name == '.')
 417               break;
 418             else if (ISDIGIT (*name))
 419               digit_seen = 1;
 420             else
 421               return 0;
 422         }
 423     }
 424
 425   /* On systems where the C compiler adds an underscore to all
 426      names, static names without underscores seem usually to be
 427      labels in hand written assembler in the library.  We don't want
 428      these names.  This is certainly necessary on a Sparc running
 429      SunOS 4.1 (try profiling a program that does a lot of
 430      division). I don't know whether it has harmful side effects on
 431      other systems.  Perhaps it should be made configurable.  */
 432   sym_prefix = bfd_get_symbol_leading_char (core_bfd);
 433
 434   if ((sym_prefix && sym_prefix != sym->name[0])
 435       /* GCC may add special symbols to help gdb figure out the file
 436         language.  We want to ignore these, since sometimes they mask
 437         the real function.  (dj@ctron)  */
 438       || !strncmp (sym->name, "__gnu_compiled", 14)
 439       || !strncmp (sym->name, "___gnu_compiled", 15))
 440     {
 441       return 0;
 442     }
 443
 444   /* If the object file supports marking of function symbols, then
 445      we can zap anything that doesn't have BSF_FUNCTION set.  */
 446   if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
 447     return 0;
 448
 449   return 't';                   /* It's a static text symbol.  */
 450 }
 451
 452 /* Get whatever source info we can get regarding address ADDR.  */
 453
 454 static bfd_boolean
 455 get_src_info (bfd_vma addr, const char **filename, const char **name, int *line_num)
 456 {
 457   const char *fname = 0, *func_name = 0;
 458   int l = 0;
 459
 460   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
 461                              addr - core_text_sect->vma,
 462                              &fname, &func_name, (unsigned int *) &l)
 463       && fname && func_name && l)
 464     {
 465       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 466                               (unsigned long) addr, fname, l, func_name));
 467       *filename = fname;
 468       *name = func_name;
 469       *line_num = l;
 470       return TRUE;
 471     }
 472   else
 473     {
 474       DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 475                               (unsigned long) addr,
 476                               fname ? fname : "<unknown>", l,
 477                               func_name ? func_name : "<unknown>"));
 478       return FALSE;
 479     }
 480 }
 481
 482 /* Return number of symbols in a symbol-table file.  */
 483
 484 static int
 485 num_of_syms_in (FILE * f)
 486 {
 487   const int BUFSIZE = 1024;
 488   char * buf = (char *) xmalloc (BUFSIZE);
 489   char * address = (char *) xmalloc (BUFSIZE);
 490   char   type;
 491   char * name = (char *) xmalloc (BUFSIZE);
 492   int num = 0;
 493
 494   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 495     {
 496       if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
 497         if (type == 't' || type == 'T')
 498           ++num;
 499     }
 500
 501   free (buf);
 502   free (address);
 503   free (name);
 504
 505   return num;
 506 }
 507
 508 /* Read symbol table from a file.  */
 509
 510 void
 511 core_create_syms_from (const char * sym_table_file)
 512 {
 513   const int BUFSIZE = 1024;
 514   char * buf = (char *) xmalloc (BUFSIZE);
 515   char * address = (char *) xmalloc (BUFSIZE);
 516   char type;
 517   char * name = (char *) xmalloc (BUFSIZE);
 518   bfd_vma min_vma = ~(bfd_vma) 0;
 519   bfd_vma max_vma = 0;
 520   FILE * f;
 521
 522   f = fopen (sym_table_file, "r");
 523   if (!f)
 524     {
 525       fprintf (stderr, _("%s: could not open %s.\n"), whoami, sym_table_file);
 526       done (1);
 527     }
 528
 529   /* Pass 1 - determine upper bound on number of function names.  */
 530   symtab.len = num_of_syms_in (f);
 531
 532   if (symtab.len == 0)
 533     {
 534       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, sym_table_file);
 535       done (1);
 536     }
 537
 538   symtab.base = (Sym *) xmalloc (symtab.len * sizeof (Sym));
 539
 540   /* Pass 2 - create symbols.  */
 541   symtab.limit = symtab.base;
 542
 543   if (fseek (f, 0, SEEK_SET) != 0)
 544     {
 545       perror (sym_table_file);
 546       done (1);
 547     }
 548
 549   while (!feof (f) && fgets (buf, BUFSIZE - 1, f))
 550     {
 551       if (sscanf (buf, "%s %c %s", address, &type, name) == 3)
 552         if (type != 't' && type != 'T')
 553           continue;
 554
 555       sym_init (symtab.limit);
 556
 557       sscanf (address, "%" BFD_VMA_FMT "x", &(symtab.limit->addr) );
 558
 559       symtab.limit->name = (char *) xmalloc (strlen (name) + 1);
 560       strcpy ((char *) symtab.limit->name, name);
 561       symtab.limit->mapped = 0;
 562       symtab.limit->is_func = TRUE;
 563       symtab.limit->is_bb_head = TRUE;
 564       symtab.limit->is_static = (type == 't');
 565       min_vma = MIN (symtab.limit->addr, min_vma);
 566       max_vma = MAX (symtab.limit->addr, max_vma);
 567
 568       ++symtab.limit;
 569     }
 570   fclose (f);
 571
 572   symtab.len = symtab.limit - symtab.base;
 573   symtab_finalize (&symtab);
 574
 575   free (buf);
 576   free (address);
 577   free (name);
 578 }
 579
 580 static int
 581 search_mapped_symbol (const void * l, const void * r)
 582 {
 583     return strcmp ((const char *) l, ((const struct function_map *) r)->function_name);
 584 }
 585
 586 /* Read in symbol table from core.
 587    One symbol per function is entered.  */
 588
 589 void
 590 core_create_function_syms (void)
 591 {
 592   bfd_vma min_vma = ~ (bfd_vma) 0;
 593   bfd_vma max_vma = 0;
 594   int cxxclass;
 595   long i;
 596   struct function_map * found = NULL;
 597   int core_has_func_syms = 0;
 598
 599   switch (core_bfd->xvec->flavour)
 600     {
 601     default:
 602       break;
 603     case bfd_target_coff_flavour:
 604     case bfd_target_ecoff_flavour:
 605     case bfd_target_xcoff_flavour:
 606     case bfd_target_elf_flavour:
 607     case bfd_target_nlm_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 prefered 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 }