gprof/corefile.c

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