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[PATH_MAX], prev_filename[PATH_MAX];
 579   bfd_vma vma, min_vma = ~0, max_vma = 0;
 580   bfd_vma offset;
 581   Sym *prev, dummy, *sentinel, *sym;
 582   const char *filename;
 583   int prev_line_num;
 584   Sym_Table ltab;
 585   /*
 586    * Create symbols for functions as usual.  This is necessary in
 587    * cases where parts of a program were not compiled with -g.  For
 588    * those parts we still want to get info at the function level:
 589    */
 590   core_create_function_syms (core_bfd);
 591
 592   /* pass 1 - counter number of symbols: */
 593
 594   /*
 595    * To find all line information, walk through all possible
 596    * text-space addresses (one by one!) and get the debugging
 597    * info for each address.  When the debugging info changes,
 598    * it is time to create a new symbol.
 599    *
 600    * Of course, this is rather slow and it would be better if
 601    * bfd would provide an iterator for enumerating all line infos
 602    */
 603   prev_name[0] = '\0';
 604   ltab.len = 0;
 605   prev_filename[0] = '\0';
 606   prev_line_num = 0;
 607   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
 608     {
 609       vma = core_text_sect->vma + offset;
 610       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 611           || (prev_line_num == dummy.line_num &&
 612               strcmp (prev_name, dummy.name) == 0
 613               && strcmp (prev_filename, filename) == 0))
 614         {
 615           continue;
 616         }
 617
 618       ++ltab.len;
 619       prev_line_num = dummy.line_num;
 620       strcpy (prev_name, dummy.name);
 621       strcpy (prev_filename, filename);
 622
 623       min_vma = MIN (vma, min_vma);
 624       max_vma = MAX (vma, max_vma);
 625     }
 626
 627   /* make room for function symbols, too: */
 628   ltab.len += symtab.len;
 629   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 630   ltab.limit = ltab.base;
 631
 632   /* pass 2 - create symbols: */
 633
 634   /* We now set is_static as we go along, rather than by running
 635      through the symbol table at the end.
 636
 637      The old way called symtab_finalize before the is_static pass,
 638      causing a problem since symtab_finalize uses is_static as part of
 639      its address conflict resolution algorithm.  Since global symbols
 640      were prefered over static symbols, and all line symbols were
 641      global at that point, static function names that conflicted with
 642      their own line numbers (static, but labeled as global) were
 643      rejected in favor of the line num.
 644
 645      This was not the desired functionality.  We always want to keep
 646      our function symbols and discard any conflicting line symbols.
 647      Perhaps symtab_finalize should be modified to make this
 648      distinction as well, but the current fix works and the code is a
 649      lot cleaner now.  */
 650
 651   prev = 0;
 652   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
 653     {
 654       sym_init (ltab.limit);
 655       if (!get_src_info (core_text_sect->vma + offset, &filename,
 656                          &ltab.limit->name, &ltab.limit->line_num)
 657           || (prev && prev->line_num == ltab.limit->line_num
 658               && strcmp (prev->name, ltab.limit->name) == 0
 659               && strcmp (prev->file->name, filename) == 0))
 660         {
 661           continue;
 662         }
 663
 664       /* make name pointer a malloc'ed string: */
 665       ltab.limit->name = xstrdup (ltab.limit->name);
 666       ltab.limit->file = source_file_lookup_path (filename);
 667
 668       ltab.limit->addr = core_text_sect->vma + offset;
 669
 670       /* Set is_static based on the enclosing function, using either:
 671        * 1) the previous symbol, if it's from the same function, or
 672        * 2) a symtab lookup
 673        */
 674
 675       if (prev && ltab.limit->file == prev->file &&
 676           strcmp (ltab.limit->name, prev->name) == 0)
 677         {
 678           ltab.limit->is_static = prev->is_static;
 679         }
 680       else
 681         {
 682           sym = sym_lookup(&symtab, ltab.limit->addr);
 683           ltab.limit->is_static = sym->is_static;
 684         }
 685
 686       prev = ltab.limit;
 687
 688       /*
 689        * If we see "main" without an initial '_', we assume names
 690        * are *not* prefixed by '_'.
 691        */
 692       if (ltab.limit->name[0] == 'm' && discard_underscores
 693           && strcmp (ltab.limit->name, "main") == 0)
 694         {
 695           discard_underscores = 0;
 696         }
 697
 698       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %d %s 0x%lx\n",
 699                               ltab.limit - ltab.base, ltab.limit->name,
 700                               ltab.limit->addr));
 701       ++ltab.limit;
 702     }
 703
 704   /* update sentinels: */
 705
 706   sentinel = sym_lookup (&symtab, 0);
 707   if (strcmp (sentinel->name, "<locore>") == 0
 708       && min_vma <= sentinel->end_addr)
 709     {
 710       sentinel->end_addr = min_vma - 1;
 711     }
 712
 713   sentinel = sym_lookup (&symtab, ~0);
 714   if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
 715     {
 716       sentinel->addr = max_vma + 1;
 717     }
 718
 719   /* copy in function symbols: */
 720   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 721   ltab.limit += symtab.len;
 722
 723   if ((unsigned int) (ltab.limit - ltab.base) != ltab.len)
 724     {
 725       fprintf (stderr,
 726                _("%s: somebody miscounted: ltab.len=%d instead of %ld\n"),
 727                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 728       done (1);
 729     }
 730
 731   /* finalize ltab and make it symbol table: */
 732
 733   symtab_finalize (&ltab);
 734   free (symtab.base);
 735   symtab = ltab;
 736
 737 }