gprof/corefile.c

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