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