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