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   int core_sym_bytes;
 146   core_bfd = bfd_openr (aout_name, 0);
 147
 148   if (!core_bfd)
 149     {
 150       perror (aout_name);
 151       done (1);
 152     }
 153
 154   if (!bfd_check_format (core_bfd, bfd_object))
 155     {
 156       fprintf (stderr, _("%s: %s: not in a.out format\n"), whoami, aout_name);
 157       done (1);
 158     }
 159
 160   /* Get core's text section.  */
 161   core_text_sect = bfd_get_section_by_name (core_bfd, ".text");
 162   if (!core_text_sect)
 163     {
 164       core_text_sect = bfd_get_section_by_name (core_bfd, "$CODE$");
 165       if (!core_text_sect)
 166         {
 167           fprintf (stderr, _("%s: can't find .text section in %s\n"),
 168                    whoami, aout_name);
 169           done (1);
 170         }
 171     }
 172
 173   /* Read core's symbol table.  */
 174
 175   /* This will probably give us more than we need, but that's ok.  */
 176   core_sym_bytes = bfd_get_symtab_upper_bound (core_bfd);
 177   if (core_sym_bytes < 0)
 178     {
 179       fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
 180                bfd_errmsg (bfd_get_error ()));
 181       done (1);
 182     }
 183
 184   core_syms = (asymbol **) xmalloc (core_sym_bytes);
 185   core_num_syms = bfd_canonicalize_symtab (core_bfd, core_syms);
 186
 187   if (core_num_syms < 0)
 188     {
 189       fprintf (stderr, "%s: %s: %s\n", whoami, aout_name,
 190                bfd_errmsg (bfd_get_error ()));
 191       done (1);
 192     }
 193
 194   min_insn_size = 1;
 195   offset_to_code = 0;
 196
 197   switch (bfd_get_arch (core_bfd))
 198     {
 199     case bfd_arch_vax:
 200     case bfd_arch_tahoe:
 201       offset_to_code = 2;
 202       break;
 203
 204     case bfd_arch_alpha:
 205       min_insn_size = 4;
 206       break;
 207
 208     default:
 209       break;
 210     }
 211
 212   if (function_mapping_file)
 213     read_function_mappings (function_mapping_file);
 214 }
 215
 216 /* Read in the text space of an a.out file.  */
 217
 218 void
 219 core_get_text_space (cbfd)
 220      bfd *cbfd;
 221 {
 222   core_text_space = (PTR) malloc ((unsigned int) core_text_sect->_raw_size);
 223
 224   if (!core_text_space)
 225     {
 226       fprintf (stderr, _("%s: ran out room for %lu bytes of text space\n"),
 227                whoami, (unsigned long) core_text_sect->_raw_size);
 228       done (1);
 229     }
 230
 231   if (!bfd_get_section_contents (cbfd, core_text_sect, core_text_space,
 232                                  (bfd_vma) 0, core_text_sect->_raw_size))
 233     {
 234       bfd_perror ("bfd_get_section_contents");
 235       free (core_text_space);
 236       core_text_space = 0;
 237     }
 238
 239   if (!core_text_space)
 240     fprintf (stderr, _("%s: can't do -c\n"), whoami);
 241 }
 242
 243
 244 void
 245 find_call (parent, p_lowpc, p_highpc)
 246      Sym *parent;
 247      bfd_vma p_lowpc;
 248      bfd_vma p_highpc;
 249 {
 250   switch (bfd_get_arch (core_bfd))
 251     {
 252     case bfd_arch_i386:
 253       i386_find_call (parent, p_lowpc, p_highpc);
 254       break;
 255
 256     case bfd_arch_alpha:
 257       alpha_find_call (parent, p_lowpc, p_highpc);
 258       break;
 259
 260     case bfd_arch_vax:
 261       vax_find_call (parent, p_lowpc, p_highpc);
 262       break;
 263
 264     case bfd_arch_sparc:
 265       sparc_find_call (parent, p_lowpc, p_highpc);
 266       break;
 267
 268     case bfd_arch_tahoe:
 269       tahoe_find_call (parent, p_lowpc, p_highpc);
 270       break;
 271
 272     case bfd_arch_mips:
 273       mips_find_call (parent, p_lowpc, p_highpc);
 274       break;
 275
 276     default:
 277       fprintf (stderr, _("%s: -c not supported on architecture %s\n"),
 278                whoami, bfd_printable_name(core_bfd));
 279
 280       /* Don't give the error more than once.  */
 281       ignore_direct_calls = FALSE;
 282     }
 283 }
 284
 285 /* Return class of symbol SYM.  The returned class can be any of:
 286         0   -> symbol is not interesting to us
 287         'T' -> symbol is a global name
 288         't' -> symbol is a local (static) name.  */
 289
 290 static int
 291 core_sym_class (sym)
 292      asymbol *sym;
 293 {
 294   symbol_info syminfo;
 295   const char *name;
 296   char sym_prefix;
 297   int i;
 298
 299   if (sym->section == NULL || (sym->flags & BSF_DEBUGGING) != 0)
 300     return 0;
 301
 302   /* Must be a text symbol, and static text symbols
 303      don't qualify if ignore_static_funcs set.   */
 304   if (ignore_static_funcs && (sym->flags & BSF_LOCAL))
 305     {
 306       DBG (AOUTDEBUG, printf ("[core_sym_class] %s: not a function\n",
 307                               sym->name));
 308       return 0;
 309     }
 310
 311   bfd_get_symbol_info (core_bfd, sym, &syminfo);
 312   i = syminfo.type;
 313
 314   if (i == 'T')
 315     return i;                   /* It's a global symbol.  */
 316
 317   if (i == 'W')
 318     /* Treat weak symbols as text symbols.  FIXME: a weak symbol may
 319        also be a data symbol.  */
 320     return 'T';
 321
 322   if (i != 't')
 323     {
 324       /* Not a static text symbol.  */
 325       DBG (AOUTDEBUG, printf ("[core_sym_class] %s is of class %c\n",
 326                               sym->name, i));
 327       return 0;
 328     }
 329
 330   /* Do some more filtering on static function-names.  */
 331   if (ignore_static_funcs)
 332     return 0;
 333
 334   /* Can't zero-length name or funny characters in name, where
 335      `funny' includes: `.' (.o file names) and `$' (Pascal labels).  */
 336   if (!sym->name || sym->name[0] == '\0')
 337     return 0;
 338
 339   for (name = sym->name; *name; ++name)
 340     {
 341       if (*name == '.' || *name == '$')
 342         return 0;
 343     }
 344
 345   /* On systems where the C compiler adds an underscore to all
 346      names, static names without underscores seem usually to be
 347      labels in hand written assembler in the library.  We don't want
 348      these names.  This is certainly necessary on a Sparc running
 349      SunOS 4.1 (try profiling a program that does a lot of
 350      division). I don't know whether it has harmful side effects on
 351      other systems.  Perhaps it should be made configurable.  */
 352   sym_prefix = bfd_get_symbol_leading_char (core_bfd);
 353
 354   if ((sym_prefix && sym_prefix != sym->name[0])
 355       /* GCC may add special symbols to help gdb figure out the file
 356         language.  We want to ignore these, since sometimes they mask
 357         the real function.  (dj@ctron)  */
 358       || !strncmp (sym->name, "__gnu_compiled", 14)
 359       || !strncmp (sym->name, "___gnu_compiled", 15))
 360     {
 361       return 0;
 362     }
 363
 364   /* If the object file supports marking of function symbols, then
 365      we can zap anything that doesn't have BSF_FUNCTION set.  */
 366   if (ignore_non_functions && (sym->flags & BSF_FUNCTION) == 0)
 367     return 0;
 368
 369   return 't';                   /* It's a static text symbol.  */
 370 }
 371
 372 /* Get whatever source info we can get regarding address ADDR.  */
 373
 374 static bfd_boolean
 375 get_src_info (addr, filename, name, line_num)
 376      bfd_vma addr;
 377      const char **filename;
 378      const char **name;
 379      int *line_num;
 380 {
 381   const char *fname = 0, *func_name = 0;
 382   int l = 0;
 383
 384   if (bfd_find_nearest_line (core_bfd, core_text_sect, core_syms,
 385                              addr - core_text_sect->vma,
 386                              &fname, &func_name, (unsigned int *) &l)
 387       && fname && func_name && l)
 388     {
 389       DBG (AOUTDEBUG, printf ("[get_src_info] 0x%lx -> %s:%d (%s)\n",
 390                               (unsigned long) addr, fname, l, func_name));
 391       *filename = fname;
 392       *name = func_name;
 393       *line_num = l;
 394       return TRUE;
 395     }
 396   else
 397     {
 398       DBG (AOUTDEBUG, printf ("[get_src_info] no info for 0x%lx (%s:%d,%s)\n",
 399                               (long) addr, fname ? fname : "<unknown>", l,
 400                               func_name ? func_name : "<unknown>"));
 401       return FALSE;
 402     }
 403 }
 404
 405 /* Read in symbol table from core.
 406    One symbol per function is entered.  */
 407
 408 void
 409 core_create_function_syms ()
 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 ()
 596 {
 597   char *prev_name, *prev_filename;
 598   unsigned int prev_name_len, prev_filename_len;
 599   bfd_vma vma, min_vma = ~(bfd_vma) 0, max_vma = 0;
 600   Sym *prev, dummy, *sentinel, *sym;
 601   const char *filename;
 602   int prev_line_num;
 603   Sym_Table ltab;
 604
 605   /* Create symbols for functions as usual.  This is necessary in
 606      cases where parts of a program were not compiled with -g.  For
 607      those parts we still want to get info at the function level.  */
 608   core_create_function_syms ();
 609
 610   /* Pass 1: count the number of symbols.  */
 611
 612   /* To find all line information, walk through all possible
 613      text-space addresses (one by one!) and get the debugging
 614      info for each address.  When the debugging info changes,
 615      it is time to create a new symbol.
 616
 617      Of course, this is rather slow and it would be better if
 618      BFD would provide an iterator for enumerating all line infos.  */
 619   prev_name_len = PATH_MAX;
 620   prev_filename_len = PATH_MAX;
 621   prev_name = xmalloc (prev_name_len);
 622   prev_filename = xmalloc (prev_filename_len);
 623   ltab.len = 0;
 624   prev_line_num = 0;
 625
 626   bfd_vma vma_high = core_text_sect->vma + core_text_sect->_raw_size;
 627   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 628     {
 629       unsigned int len;
 630
 631       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 632           || (prev_line_num == dummy.line_num
 633               && prev_name != NULL
 634               && strcmp (prev_name, dummy.name) == 0
 635               && strcmp (prev_filename, filename) == 0))
 636         continue;
 637
 638       ++ltab.len;
 639       prev_line_num = dummy.line_num;
 640
 641       len = strlen (dummy.name);
 642       if (len >= prev_name_len)
 643         {
 644           prev_name_len = len + 1024;
 645           free (prev_name);
 646           prev_name = xmalloc (prev_name_len);
 647         }
 648
 649       strcpy (prev_name, dummy.name);
 650       len = strlen (filename);
 651
 652       if (len >= prev_filename_len)
 653         {
 654           prev_filename_len = len + 1024;
 655           free (prev_filename);
 656           prev_filename = xmalloc (prev_filename_len);
 657         }
 658
 659       strcpy (prev_filename, filename);
 660
 661       min_vma = MIN (vma, min_vma);
 662       max_vma = MAX (vma, max_vma);
 663     }
 664
 665   free (prev_name);
 666   free (prev_filename);
 667
 668   /* Make room for function symbols, too.  */
 669   ltab.len += symtab.len;
 670   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 671   ltab.limit = ltab.base;
 672
 673   /* Pass 2 - create symbols.  */
 674
 675   /* We now set is_static as we go along, rather than by running
 676      through the symbol table at the end.
 677
 678      The old way called symtab_finalize before the is_static pass,
 679      causing a problem since symtab_finalize uses is_static as part of
 680      its address conflict resolution algorithm.  Since global symbols
 681      were prefered over static symbols, and all line symbols were
 682      global at that point, static function names that conflicted with
 683      their own line numbers (static, but labeled as global) were
 684      rejected in favor of the line num.
 685
 686      This was not the desired functionality.  We always want to keep
 687      our function symbols and discard any conflicting line symbols.
 688      Perhaps symtab_finalize should be modified to make this
 689      distinction as well, but the current fix works and the code is a
 690      lot cleaner now.  */
 691   prev = 0;
 692
 693   for (vma = core_text_sect->vma; vma < vma_high; vma += min_insn_size)
 694     {
 695       sym_init (ltab.limit);
 696
 697       if (!get_src_info (vma, &filename, &ltab.limit->name, &ltab.limit->line_num)
 698           || (prev && prev->line_num == ltab.limit->line_num
 699               && strcmp (prev->name, ltab.limit->name) == 0
 700               && strcmp (prev->file->name, filename) == 0))
 701         continue;
 702
 703       /* Make name pointer a malloc'ed string.  */
 704       ltab.limit->name = xstrdup (ltab.limit->name);
 705       ltab.limit->file = source_file_lookup_path (filename);
 706
 707       ltab.limit->addr = vma;
 708
 709       /* Set is_static based on the enclosing function, using either:
 710          1) the previous symbol, if it's from the same function, or
 711          2) a symtab lookup.  */
 712       if (prev && ltab.limit->file == prev->file &&
 713           strcmp (ltab.limit->name, prev->name) == 0)
 714         {
 715           ltab.limit->is_static = prev->is_static;
 716         }
 717       else
 718         {
 719           sym = sym_lookup(&symtab, ltab.limit->addr);
 720           ltab.limit->is_static = sym->is_static;
 721         }
 722
 723       prev = ltab.limit;
 724
 725       /* If we see "main" without an initial '_', we assume names
 726          are *not* prefixed by '_'.  */
 727       if (ltab.limit->name[0] == 'm' && discard_underscores
 728           && strcmp (ltab.limit->name, "main") == 0)
 729         discard_underscores = 0;
 730
 731       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %lu %s 0x%lx\n",
 732                               (unsigned long) (ltab.limit - ltab.base),
 733                               ltab.limit->name,
 734                               (unsigned long) ltab.limit->addr));
 735       ++ltab.limit;
 736     }
 737
 738   /* Update sentinels.  */
 739   sentinel = sym_lookup (&symtab, (bfd_vma) 0);
 740
 741   if (sentinel
 742       && strcmp (sentinel->name, "<locore>") == 0
 743       && min_vma <= sentinel->end_addr)
 744     sentinel->end_addr = min_vma - 1;
 745
 746   sentinel = sym_lookup (&symtab, ~(bfd_vma) 0);
 747
 748   if (sentinel
 749       && strcmp (sentinel->name, "<hicore>") == 0
 750       && max_vma >= sentinel->addr)
 751     sentinel->addr = max_vma + 1;
 752
 753   /* Copy in function symbols.  */
 754   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 755   ltab.limit += symtab.len;
 756
 757   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 758     {
 759       fprintf (stderr,
 760                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 761                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 762       done (1);
 763     }
 764
 765   /* Finalize ltab and make it symbol table.  */
 766   symtab_finalize (&ltab);
 767   free (symtab.base);
 768   symtab = ltab;
 769 }