gprof/corefile.c

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