gprof/core.c

   1 #include "libiberty.h"
   2 #include "gprof.h"
   3 #include "core.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 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, j, found, skip;
 400
 401   /* pass 1 - determine upper bound on number of function names: */
 402   symtab.len = 0;
 403   for (i = 0; i < core_num_syms; ++i)
 404     {
 405       if (!core_sym_class (core_syms[i]))
 406         {
 407           continue;
 408         }
 409
 410       /* This should be replaced with a binary search or hashed
 411          search.  Gross.
 412
 413          Don't create a symtab entry for a function that has
 414          a mapping to a file, unless it's the first function
 415          in the file.  */
 416       skip = 0;
 417       for (j = 0; j < symbol_map_count; j++)
 418         if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
 419           {
 420             if (j > 0 && ! strcmp (symbol_map [j].file_name,
 421                                    symbol_map [j - 1].file_name))
 422               skip = 1;
 423             break;
 424           }
 425       if (!skip)
 426         ++symtab.len;
 427     }
 428
 429   if (symtab.len == 0)
 430     {
 431       fprintf (stderr, "%s: file `%s' has no symbols\n", whoami, a_out_name);
 432       done (1);
 433     }
 434
 435   /* the "+ 2" is for the sentinels: */
 436   symtab.base = (Sym *) xmalloc ((symtab.len + 2) * sizeof (Sym));
 437
 438   /* pass 2 - create symbols: */
 439
 440   symtab.limit = symtab.base;
 441   for (i = 0; i < core_num_syms; ++i)
 442     {
 443       class = core_sym_class (core_syms[i]);
 444       if (!class)
 445         {
 446           DBG (AOUTDEBUG,
 447                printf ("[core_create_function_syms] rejecting: 0x%lx %s\n",
 448                        core_syms[i]->value, core_syms[i]->name));
 449           continue;
 450         }
 451       /* This should be replaced with a binary search or hashed
 452          search.  Gross.   */
 453
 454       skip = 0;
 455       found = 0;
 456       for (j = 0; j < symbol_map_count; j++)
 457         if (!strcmp (core_syms[i]->name, symbol_map[j].function_name))
 458           {
 459             if (j > 0 && ! strcmp (symbol_map [j].file_name,
 460                                    symbol_map [j - 1].file_name))
 461               skip = 1;
 462             else
 463               found = j;
 464             break;
 465           }
 466
 467       if (skip)
 468         continue;
 469
 470       sym_init (symtab.limit);
 471
 472       /* symbol offsets are always section-relative: */
 473
 474       symtab.limit->addr = core_syms[i]->value + core_syms[i]->section->vma;
 475       if (symbol_map_count
 476           && !strcmp (core_syms[i]->name, symbol_map[found].function_name))
 477         {
 478           symtab.limit->name = symbol_map[found].file_name;
 479           symtab.limit->mapped = 1;
 480         }
 481       else
 482         {
 483           symtab.limit->name = core_syms[i]->name;
 484           symtab.limit->mapped = 0;
 485         }
 486
 487       /* Lookup filename and line number, if we can */
 488
 489       {
 490         const char *filename, *func_name;
 491
 492         if (get_src_info (symtab.limit->addr, &filename, &func_name,
 493                           &symtab.limit->line_num))
 494           {
 495             symtab.limit->file = source_file_lookup_path (filename);
 496
 497             /* FIXME: Checking __osf__ here does not work with a cross
 498                gprof.  */
 499 #ifdef __osf__
 500             /*
 501              * Suppress symbols that are not function names.  This is
 502              * useful to suppress code-labels and aliases.
 503              *
 504              * This is known to be useful under DEC's OSF/1.  Under SunOS 4.x,
 505              * labels do not appear in the symbol table info, so this isn't
 506              * necessary.
 507              */
 508
 509             if (strcmp (symtab.limit->name, func_name) != 0)
 510               {
 511                 /*
 512                  * The symbol's address maps to a different name, so
 513                  * it can't be a function-entry point.  This happens
 514                  * for labels, for example.
 515                  */
 516                 DBG (AOUTDEBUG,
 517                      printf ("[core_create_function_syms: rej %s (maps to %s)\n",
 518                              symtab.limit->name, func_name));
 519                 continue;
 520               }
 521 #endif
 522           }
 523       }
 524
 525       symtab.limit->is_func = TRUE;
 526       symtab.limit->is_bb_head = TRUE;
 527       if (class == 't')
 528         {
 529           symtab.limit->is_static = TRUE;
 530         }
 531
 532       min_vma = MIN (symtab.limit->addr, min_vma);
 533       max_vma = MAX (symtab.limit->addr, max_vma);
 534
 535       /*
 536        * If we see "main" without an initial '_', we assume names
 537        * are *not* prefixed by '_'.
 538        */
 539       if (symtab.limit->name[0] == 'm' && discard_underscores
 540           && strcmp (symtab.limit->name, "main") == 0)
 541         {
 542           discard_underscores = 0;
 543         }
 544
 545       DBG (AOUTDEBUG, printf ("[core_create_function_syms] %ld %s 0x%lx\n",
 546                               (long) (symtab.limit - symtab.base),
 547                               symtab.limit->name, symtab.limit->addr));
 548       ++symtab.limit;
 549     }
 550
 551   /* create sentinels: */
 552
 553   sym_init (symtab.limit);
 554   symtab.limit->name = "<locore>";
 555   symtab.limit->addr = 0;
 556   symtab.limit->end_addr = min_vma - 1;
 557   ++symtab.limit;
 558
 559   sym_init (symtab.limit);
 560   symtab.limit->name = "<hicore>";
 561   symtab.limit->addr = max_vma + 1;
 562   symtab.limit->end_addr = ~0;
 563   ++symtab.limit;
 564
 565   symtab.len = symtab.limit - symtab.base;
 566   symtab_finalize (&symtab);
 567 }
 568
 569
 570 /*
 571  * Read in symbol table from core.  One symbol per line of source code
 572  * is entered.
 573  */
 574 void
 575 DEFUN (core_create_line_syms, (core_bfd), bfd * core_bfd)
 576 {
 577   char prev_name[PATH_MAX], prev_filename[PATH_MAX];
 578   bfd_vma vma, min_vma = ~0, max_vma = 0;
 579   bfd_vma offset;
 580   Sym *prev, dummy, *sentinel, *sym;
 581   const char *filename;
 582   int prev_line_num;
 583   Sym_Table ltab;
 584   /*
 585    * Create symbols for functions as usual.  This is necessary in
 586    * cases where parts of a program were not compiled with -g.  For
 587    * those parts we still want to get info at the function level:
 588    */
 589   core_create_function_syms (core_bfd);
 590
 591   /* pass 1 - counter number of symbols: */
 592
 593   /*
 594    * To find all line information, walk through all possible
 595    * text-space addresses (one by one!) and get the debugging
 596    * info for each address.  When the debugging info changes,
 597    * it is time to create a new symbol.
 598    *
 599    * Of course, this is rather slow and it would be better if
 600    * bfd would provide an iterator for enumerating all line infos
 601    */
 602   prev_name[0] = '\0';
 603   ltab.len = 0;
 604   prev_filename[0] = '\0';
 605   prev_line_num = 0;
 606   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
 607     {
 608       vma = core_text_sect->vma + offset;
 609       if (!get_src_info (vma, &filename, &dummy.name, &dummy.line_num)
 610           || (prev_line_num == dummy.line_num &&
 611               strcmp (prev_name, dummy.name) == 0
 612               && strcmp (prev_filename, filename) == 0))
 613         {
 614           continue;
 615         }
 616
 617       ++ltab.len;
 618       prev_line_num = dummy.line_num;
 619       strcpy (prev_name, dummy.name);
 620       strcpy (prev_filename, filename);
 621
 622       min_vma = MIN (vma, min_vma);
 623       max_vma = MAX (vma, max_vma);
 624     }
 625
 626   /* make room for function symbols, too: */
 627   ltab.len += symtab.len;
 628   ltab.base = (Sym *) xmalloc (ltab.len * sizeof (Sym));
 629   ltab.limit = ltab.base;
 630
 631   /* pass 2 - create symbols: */
 632
 633   /* We now set is_static as we go along, rather than by running
 634      through the symbol table at the end.
 635
 636      The old way called symtab_finalize before the is_static pass,
 637      causing a problem since symtab_finalize uses is_static as part of
 638      its address conflict resolution algorithm.  Since global symbols
 639      were prefered over static symbols, and all line symbols were
 640      global at that point, static function names that conflicted with
 641      their own line numbers (static, but labeled as global) were
 642      rejected in favor of the line num.
 643
 644      This was not the desired functionality.  We always want to keep
 645      our function symbols and discard any conflicting line symbols.
 646      Perhaps symtab_finalize should be modified to make this
 647      distinction as well, but the current fix works and the code is a
 648      lot cleaner now.  */
 649
 650   prev = 0;
 651   for (offset = 0; offset < core_text_sect->_raw_size; offset += min_insn_size)
 652     {
 653       sym_init (ltab.limit);
 654       if (!get_src_info (core_text_sect->vma + offset, &filename,
 655                          &ltab.limit->name, &ltab.limit->line_num)
 656           || (prev && prev->line_num == ltab.limit->line_num
 657               && strcmp (prev->name, ltab.limit->name) == 0
 658               && strcmp (prev->file->name, filename) == 0))
 659         {
 660           continue;
 661         }
 662
 663       /* make name pointer a malloc'ed string: */
 664       ltab.limit->name = xstrdup (ltab.limit->name);
 665       ltab.limit->file = source_file_lookup_path (filename);
 666
 667       ltab.limit->addr = core_text_sect->vma + offset;
 668
 669       /* Set is_static based on the enclosing function, using either:
 670        * 1) the previous symbol, if it's from the same function, or
 671        * 2) a symtab lookup
 672        */
 673
 674       if (prev && ltab.limit->file == prev->file &&
 675           strcmp (ltab.limit->name, prev->name) == 0)
 676         {
 677           ltab.limit->is_static = prev->is_static;
 678         }
 679       else
 680         {
 681           sym = sym_lookup(&symtab, ltab.limit->addr);
 682           ltab.limit->is_static = sym->is_static;
 683         }
 684
 685       prev = ltab.limit;
 686
 687       /*
 688        * If we see "main" without an initial '_', we assume names
 689        * are *not* prefixed by '_'.
 690        */
 691       if (ltab.limit->name[0] == 'm' && discard_underscores
 692           && strcmp (ltab.limit->name, "main") == 0)
 693         {
 694           discard_underscores = 0;
 695         }
 696
 697       DBG (AOUTDEBUG, printf ("[core_create_line_syms] %d %s 0x%lx\n",
 698                               ltab.limit - ltab.base, ltab.limit->name,
 699                               ltab.limit->addr));
 700       ++ltab.limit;
 701     }
 702
 703   /* update sentinels: */
 704
 705   sentinel = sym_lookup (&symtab, 0);
 706   if (strcmp (sentinel->name, "<locore>") == 0
 707       && min_vma <= sentinel->end_addr)
 708     {
 709       sentinel->end_addr = min_vma - 1;
 710     }
 711
 712   sentinel = sym_lookup (&symtab, ~0);
 713   if (strcmp (sentinel->name, "<hicore>") == 0 && max_vma >= sentinel->addr)
 714     {
 715       sentinel->addr = max_vma + 1;
 716     }
 717
 718   /* copy in function symbols: */
 719   memcpy (ltab.limit, symtab.base, symtab.len * sizeof (Sym));
 720   ltab.limit += symtab.len;
 721
 722   if (ltab.limit - ltab.base != ltab.len)
 723     {
 724       fprintf (stderr,
 725                "%s: somebody miscounted: ltab.len=%d instead of %ld\n",
 726                whoami, ltab.len, (long) (ltab.limit - ltab.base));
 727       done (1);
 728     }
 729
 730   /* finalize ltab and make it symbol table: */
 731
 732   symtab_finalize (&ltab);
 733   free (symtab.base);
 734   symtab = ltab;
 735
 736 }