gprof/corefile.c

   1 /* corefile.c
   2
   3    Copyright 2000, 2001, 2002 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
  40 {
  41   char *function_name;
  42   char *file_name;
  43 };
  44
  45 struct function_map *symbol_map;
  46 unsigned int symbol_map_count;
  47
  48 extern void i386_find_call  PARAMS ((Sym *, bfd_vma, bfd_vma));
  49 extern void alpha_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
  50 extern void vax_find_call   PARAMS ((Sym *, bfd_vma, bfd_vma));
  51 extern void tahoe_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
  52 extern void sparc_find_call PARAMS ((Sym *, bfd_vma, bfd_vma));
  53 extern void mips_find_call  PARAMS ((Sym *, bfd_vma, bfd_vma));
  54
  55 static void
  56 DEFUN (read_function_mappings, (filename), 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 DEFUN (core_init, (a_out_name), const char *a_out_name)
 143 {
 144   core_bfd = bfd_openr (a_out_name, 0);
 145
 146   if (!core_bfd)
 147     {
 148       perror (a_out_name);
 149       done (1);
 150     }
 151
 152   if (!bfd_check_format (core_bfd, bfd_object))
 153     {
 154       fprintf (stderr, _("%s: %s: not in a.out format\n"), whoami, a_out_name);
 155       done (1);
 156     }
 157
 158   /* Get core's text section.  */
 159   core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
 160   if (!core_text_sect)
 161     {
 162       core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
 163       if (!core_text_sect)
 164         {
 165           fprintf (stderr, _("%s: can't find .text section in %s\n"),
 166                    whoami, a_out_name);
 167           done (1);
 168         }
 169     }
 170
 171   /* Read core's symbol table.  */
 172
 173   /* This will probably give us more than we need, but that's ok.  */
 174   core_num_syms = bfd_get_symtab_upper_bound (core_bfd);
 175   if (core_num_syms < 0)
 176     {
 177       fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
 178                bfd_errmsg (bfd_get_error ()));
 179       done (1);
 180     }
 181
 182   core_syms = (asymbol **) xmalloc (core_num_syms);
 183   core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
 184
 185   if (core_num_syms < 0)
 186     {
 187       fprintf (stderr, "%s: %s: %s\n", whoami, a_out_name,
 188                bfd_errmsg (bfd_get_error ()));
 189       done (1);
 190     }
 191
 192   min_insn_size = 1;
 193   offset_to_code = 0;
 194
 195   switch (bfd_get_arch (core_bfd))
 196     {
 197     case bfd_arch_vax:
 198     case bfd_arch_tahoe:
 199       offset_to_code = 2;
 200       break;
 201
 202     case bfd_arch_alpha:
 203       min_insn_size = 4;
 204       break;
 205
 206     default:
 207       break;
 208     }
 209
 210   if (function_mapping_file)
 211     read_function_mappings (function_mapping_file);
 212 }
 213
 214 /* Read in the text space of an a.out file.  */
 215
 216 void
 217 DEFUN (core_get_text_space, (core_bfd), bfd * core_bfd)
 218 {
 219   core_text_space = (PTR) malloc (core_text_sect->_raw_size);
 220
 221   if (!core_text_space)
 222     {
 223       fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
 224                whoami, (unsigned long) core_text_sect->_raw_size);
 225       done (1);
 226     }
 227
 228   if (!bfd_get_section_contents (core_bfd, core_text_sect, core_text_space,
 229                                  0, core_text_sect->_raw_size))
 230     {
 231       bfd_perror ("bfd_get_section_contents");
 232       free (core_text_space);
 233       core_text_space = 0;
 234     }
 235
 236   if (!core_text_space)
 237     fprintf (stderr, _("%s: can't do -c\n"), whoami);
 238 }
 239
 240
 241 void
 242 DEFUN (find_call, (parent, p_lowpc, p_highpc),
 243        Sym * parent AND bfd_vma p_lowpc AND 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 DEFUN (core_sym_class, (sym), 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 bool
 369 DEFUN (get_src_info, (addr, filename, name, line_num),
 370        bfd_vma addr AND const char **filename AND const char **name
 371        AND int *line_num)
 372 {
 373   const char *fname = 0, *func_name = 0;
 374   int l = 0;
 375
 376   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
 377                              addr - core_text_sect->vma,
 378                              &fname, &func_name, (unsigned int *) &l)
 379       && fname && func_name && l)
 380     {
 381       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 382                               (unsigned long) addr, fname, l, func_name));
 383       *filename = fname;
 384       *name = func_name;
 385       *line_num = l;
 386       return TRUE;
 387     }
 388   else
 389     {
 390       DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 391                               (long) addr, fname ? fname : "<unknown>", l,
 392                               func_name ? func_name : "<unknown>"));
 393       return FALSE;
 394     }
 395 }
 396
 397 /* Read in symbol table from core.
 398    One symbol per function is entered.  */
 399
 400 void
 401 core_create_function_syms (core_bfd)
 402      bfd *core_bfd ATTRIBUTE_UNUSED;
 403 {
 404   bfd_vma min_vma = ~0, max_vma = 0;
 405   int class;
 406   long i, found, skip;
 407   unsigned int j;
 408
 409   /* Pass 1 - determine upper bound on number of function names.  */
 410   symtab.len = 0;
 411
 412   for (i = 0; i < core_num_syms; ++i)
 413     {
 414       if (!core_sym_class (core_syms[i]))
 415         continue;
 416
 417       /* This should be replaced with a binary search or hashed
 418          search.  Gross.
 419
 420          Don't create a symtab entry for a function that has
 421          a mapping to a file, unless it's the first function
 422          in the file.  */
 423       skip = 0;
 424       for (j = 0; j < symbol_map_count; j++)
 425         if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
 426           {
 427             if (j > 0 && ! strcmp (symbol_map [j].file_name,
 428                                    symbol_map [j - 1].file_name))
 429               skip = 1;
 430             break;
 431           }
 432
 433       if (!skip)
 434         ++symtab.len;
 435     }
 436
 437   if (symtab.len == 0)
 438     {
 439       fprintf (stderr, _("%s: file `%s' has no symbols\n"), whoami, a_out_name);
 440       done (1);
 441     }
 442
 443   /* The "+ 2" is for the sentinels.  */
 444   symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));
 445
 446   /* Pass 2 - create symbols.  */
 447   symtab.limit = symtab.base;
 448
 449   for (i = 0; i < core_num_syms; ++i)
 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       symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
 485
 486       if (symbol_map_count
 487           && !strcmp (core_syms[i]->name, symbol_map[found].function_name))
 488         {
 489           symtab.limit->name = symbol_map[found].file_name;
 490           symtab.limit->mapped = 1;
 491         }
 492       else
 493         {
 494           symtab.limit->name = core_syms[i]->name;
 495           symtab.limit->mapped = 0;
 496         }
 497
 498       /* Lookup filename and line number, if we can.  */
 499       {
 500         const char *filename, *func_name;
 501
 502         if (get_src_info (symtab.limit->addr, &filename, &func_name,
 503                           &symtab.limit->line_num))
 504           {
 505             symtab.limit->file = source_file_lookup_path (filename);
 506
 507             /* FIXME: Checking __osf__ here does not work with a cross
 508                gprof.  */
 509 #ifdef __osf__
 510             /* Suppress symbols that are not function names.  This is
 511                useful to suppress code-labels and aliases.
 512
 513                This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
 514                labels do not appear in the symbol table info, so this isn't
 515                necessary.  */
 516
 517             if (strcmp (symtab.limit->name, func_name) != 0)
 518               {
 519                 /* The symbol's address maps to a different name, so
 520                    it can't be a function-entry point.  This happens
 521                    for labels, for example.  */
 522                 DBG (AOUTDEBUG,
 523                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
 524                              symtab.limit->name, func_name));
 525                 continue;
 526               }
 527 #endif
 528           }
 529       }
 530
 531       symtab.limit->is_func = TRUE;
 532       symtab.limit->is_bb_head = TRUE;
 533
 534       if (class == 't')
 535         symtab.limit->is_static = TRUE;
 536
 537       min_vma = MIN (symtab.limit->addr, min_vma);
 538       max_vma = MAX (symtab.limit->addr, max_vma);
 539
 540       /* If we see "main" without an initial '_', we assume names
 541          are *not* prefixed by '_'.  */
 542       if (symtab.limit->name[0] == 'm' && discard_underscores
 543           && strcmp (symtab.limit->name, "main") == 0)
 544         discard_underscores = 0;
 545
 546       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
 547                               (long) (symtab.limit - symtab.base),
 548                               symtab.limit->name,
 549                               (unsigned long) symtab.limit->addr));
 550       ++symtab.limit;
 551     }
 552
 553   /* Create sentinels.  */
 554   sym_init (symtab.limit);
 555   symtab.limit->name = "<locore>";
 556   symtab.limit->addr = 0;
 557   symtab.limit->end_addr = min_vma - 1;
 558   ++symtab.limit;
 559
 560   sym_init (symtab.limit);
 561   symtab.limit->name = "<hicore>";
 562   symtab.limit->addr = max_vma + 1;
 563   symtab.limit->end_addr = ~0;
 564   ++symtab.limit;
 565
 566   symtab.len = symtab.limit - symtab.base;
 567   symtab_finalize (&symtab);
 568 }
 569
 570 /* Read in symbol table from core.
 571    One symbol per line of source code is entered.  */
 572
 573 void
 574 DEFUN (core_create_line_syms, (core_bfd), bfd * core_bfd)
 575 {
 576   char *prev_name, *prev_filename;
 577   int prev_name_len, prev_filename_len;
 578   bfd_vma vma, min_vma = ~0, max_vma = 0;
 579   bfd_vma offset;
 580   Sym *prev, dummy, *sentinel, *sym;
 581   const char *filename;
 582   int prev_line_num;
 583   Sym_Table ltab;
 584
 585   /* Create symbols for functions as usual.  This is necessary in
 586      cases where parts of a program were not compiled with -g.  For
 587      those parts we still want to get info at the function level.  */
 588   core_create_function_syms (core_bfd);
 589
 590   /* Pass 1 - counter number of symbols.  */
 591
 592   /* To find all line information, walk through all possible
 593      text-space addresses (one by one!) and get the debugging
 594      info for each address.  When the debugging info changes,
 595      it is time to create a new symbol.
 596
 597      Of course, this is rather slow and it would be better if
 598      bfd would provide an iterator for enumerating all line infos.  */
 599   prev_name_len = PATH_MAX;
 600   prev_filename_len = PATH_MAX;
 601   prev_name = xmalloc (prev_name_len);
 602   prev_filename = xmalloc (prev_filename_len);
 603   ltab.len = 0;
 604   prev_line_num = 0;
 605
 606   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
 607     {
 608       int len;
 609
 610       vma = core_text_sect->vma + offset;
 611
 612       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 613           || (prev_line_num == dummy.line_num
 614               && prev_name != NULL
 615               && strcmp (prev_name, dummy.name) == 0
 616               && strcmp (prev_filename, filename) == 0))
 617         continue;
 618
 619       ++ltab.len;
 620       prev_line_num = dummy.line_num;
 621
 622       len = strlen (dummy.name);
 623       if (len >= prev_name_len)
 624         {
 625           prev_name_len = len + 1024;
 626           free (prev_name);
 627           prev_name = xmalloc (prev_name_len);
 628         }
 629
 630       strcpy (prev_name, dummy.name);
 631       len = strlen (filename);
 632
 633       if (len >= prev_filename_len)
 634         {
 635           prev_filename_len = len + 1024;
 636           free (prev_filename);
 637           prev_filename = xmalloc (prev_filename_len);
 638         }
 639
 640       strcpy (prev_filename, filename);
 641
 642       min_vma = MIN (vma, min_vma);
 643       max_vma = MAX (vma, max_vma);
 644     }
 645
 646   free (prev_name);
 647   free (prev_filename);
 648
 649   /* Make room for function symbols, too.  */
 650   ltab.len += symtab.len;
 651   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 652   ltab.limit = ltab.base;
 653
 654   /* Pass 2 - create symbols.  */
 655
 656   /* We now set is_static as we go along, rather than by running
 657      through the symbol table at the end.
 658
 659      The old way called symtab_finalize before the is_static pass,
 660      causing a problem since symtab_finalize uses is_static as part of
 661      its address conflict resolution algorithm.  Since global symbols
 662      were prefered over static symbols, and all line symbols were
 663      global at that point, static function names that conflicted with
 664      their own line numbers (static, but labeled as global) were
 665      rejected in favor of the line num.
 666
 667      This was not the desired functionality.  We always want to keep
 668      our function symbols and discard any conflicting line symbols.
 669      Perhaps symtab_finalize should be modified to make this
 670      distinction as well, but the current fix works and the code is a
 671      lot cleaner now.  */
 672   prev = 0;
 673
 674   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
 675     {
 676       sym_init (ltab.limit);
 677
 678       if (!get_src_info (core_text_sect->vma + offset, &filename,
 679                          &ltab.limit->name, &ltab.limit->line_num)
 680           || (prev && prev->line_num == ltab.limit->line_num
 681               && strcmp (prev->name, ltab.limit->name) == 0
 682               && strcmp (prev->file->name, filename) == 0))
 683         continue;
 684
 685       /* Make name pointer a malloc'ed string.  */
 686       ltab.limit->name = xstrdup (ltab.limit->name);
 687       ltab.limit->file = source_file_lookup_path (filename);
 688
 689       ltab.limit->addr = core_text_sect->vma + offset;
 690
 691       /* Set is_static based on the enclosing function, using either:
 692          1) the previous symbol, if it's from the same function, or
 693          2) a symtab lookup.  */
 694       if (prev && ltab.limit->file == prev->file &&
 695           strcmp (ltab.limit->name, prev->name) == 0)
 696         {
 697           ltab.limit->is_static = prev->is_static;
 698         }
 699       else
 700         {
 701           sym = sym_lookup(&symtab, ltab.limit->addr);
 702           ltab.limit->is_static = sym->is_static;
 703         }
 704
 705       prev = ltab.limit;
 706
 707       /* If we see "main" without an initial '_', we assume names
 708          are *not* prefixed by '_'.  */
 709       if (ltab.limit->name[0] == 'm' && discard_underscores
 710           && strcmp (ltab.limit->name, "main") == 0)
 711         discard_underscores = 0;
 712
 713       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
 714                               (unsigned long) (ltab.limit - ltab.base),
 715                               ltab.limit->name,
 716                               (unsigned long) ltab.limit->addr));
 717       ++ltab.limit;
 718     }
 719
 720   /* Update sentinels.  */
 721   sentinel = sym_lookup (&symtab, 0);
 722
 723   if (strcmp (sentinel->name, "<locore>") == 0
 724       && min_vma <= sentinel->end_addr)
 725     sentinel->end_addr = min_vma - 1;
 726
 727   sentinel = sym_lookup (&symtab, ~0);
 728
 729   if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
 730     sentinel->addr = max_vma + 1;
 731
 732   /* Copy in function symbols.  */
 733   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 734   ltab.limit += symtab.len;
 735
 736   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 737     {
 738       fprintf (stderr,
 739                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 740                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 741       done (1);
 742     }
 743
 744   /* Finalize ltab and make it symbol table.  */
 745   symtab_finalize (&ltab);
 746   free (symtab.base);
 747   symtab = ltab;
 748 }