gdb/buildsym.c

   1 /* Support routines for building symbol tables in GDB's internal format.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
   3              Free Software Foundation, Inc.
   4
   5 This file is part of GDB.
   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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* This module provides subroutines used for creating and adding to
  22    the symbol table.  These routines are called from various symbol-
  23    file-reading routines.
  24
  25    Routines to support specific debugging information formats (stabs,
  26    DWARF, etc) belong somewhere else. */
  27
  28 #include "defs.h"
  29 #include "bfd.h"
  30 #include "obstack.h"
  31 #include "symtab.h"
  32 #include "symfile.h"            /* Needed for "struct complaint" */
  33 #include "objfiles.h"
  34 #include "complaints.h"
  35 #include <string.h>
  36
  37 /* Ask buildsym.h to define the vars it normally declares `extern'.  */
  38 #define EXTERN  /**/
  39 #include "buildsym.h"           /* Our own declarations */
  40 #undef  EXTERN
  41
  42 /* For cleanup_undefined_types and finish_global_stabs (somewhat
  43    questionable--see comment where we call them).  */
  44 #include "stabsread.h"
  45
  46 static int
  47 compare_line_numbers PARAMS ((const void *, const void *));
  48
  49 static struct blockvector *
  50 make_blockvector PARAMS ((struct objfile *));
  51
  52 \f
  53 /* Initial sizes of data structures.  These are realloc'd larger if needed,
  54    and realloc'd down to the size actually used, when completed.  */
  55
  56 #define INITIAL_CONTEXT_STACK_SIZE      10
  57 #define INITIAL_LINE_VECTOR_LENGTH      1000
  58
  59 \f
  60 /* Complaints about the symbols we have encountered.  */
  61
  62 struct complaint innerblock_complaint =
  63   {"inner block not inside outer block in %s", 0, 0};
  64
  65 struct complaint innerblock_anon_complaint =
  66   {"inner block not inside outer block", 0, 0};
  67
  68 struct complaint blockvector_complaint =
  69   {"block at 0x%lx out of order", 0, 0};
  70
  71 \f
  72 /* maintain the lists of symbols and blocks */
  73
  74 /* Add a symbol to one of the lists of symbols.  */
  75
  76 void
  77 add_symbol_to_list (symbol, listhead)
  78      struct symbol *symbol;
  79      struct pending **listhead;
  80 {
  81   register struct pending *link;
  82
  83   /* We keep PENDINGSIZE symbols in each link of the list.
  84      If we don't have a link with room in it, add a new link.  */
  85   if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE)
  86     {
  87       if (free_pendings)
  88         {
  89           link = free_pendings;
  90           free_pendings = link->next;
  91         }
  92       else
  93         {
  94           link = (struct pending *) xmalloc (sizeof (struct pending));
  95         }
  96
  97       link->next = *listhead;
  98       *listhead = link;
  99       link->nsyms = 0;
 100     }
 101
 102   (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
 103 }
 104
 105 /* Find a symbol named NAME on a LIST.  NAME need not be '\0'-terminated;
 106    LENGTH is the length of the name.  */
 107
 108 struct symbol *
 109 find_symbol_in_list (list, name, length)
 110      struct pending *list;
 111      char *name;
 112      int length;
 113 {
 114   int j;
 115   char *pp;
 116
 117   while (list != NULL)
 118     {
 119       for (j = list->nsyms; --j >= 0; )
 120         {
 121           pp = SYMBOL_NAME (list->symbol[j]);
 122           if (*pp == *name && strncmp (pp, name, length) == 0 &&
 123               pp[length] == '\0')
 124             {
 125               return (list->symbol[j]);
 126             }
 127         }
 128       list = list->next;
 129     }
 130   return (NULL);
 131 }
 132
 133 /* At end of reading syms, or in case of quit,
 134    really free as many `struct pending's as we can easily find. */
 135
 136 /* ARGSUSED */
 137 void
 138 really_free_pendings (foo)
 139      int foo;
 140 {
 141   struct pending *next, *next1;
 142 #if 0
 143   struct pending_block *bnext, *bnext1;
 144 #endif
 145
 146   for (next = free_pendings; next; next = next1)
 147     {
 148       next1 = next->next;
 149       free ((PTR)next);
 150     }
 151   free_pendings = NULL;
 152
 153 #if 0 /* Now we make the links in the symbol_obstack, so don't free them.  */
 154   for (bnext = pending_blocks; bnext; bnext = bnext1)
 155     {
 156       bnext1 = bnext->next;
 157       free ((PTR)bnext);
 158     }
 159 #endif
 160   pending_blocks = NULL;
 161
 162   for (next = file_symbols; next != NULL; next = next1)
 163     {
 164       next1 = next->next;
 165       free ((PTR)next);
 166     }
 167   file_symbols = NULL;
 168
 169   for (next = global_symbols; next != NULL; next = next1)
 170     {
 171       next1 = next->next;
 172       free ((PTR)next);
 173     }
 174   global_symbols = NULL;
 175 }
 176
 177 /* Take one of the lists of symbols and make a block from it.
 178    Keep the order the symbols have in the list (reversed from the input file).
 179    Put the block on the list of pending blocks.  */
 180
 181 void
 182 finish_block (symbol, listhead, old_blocks, start, end, objfile)
 183      struct symbol *symbol;
 184      struct pending **listhead;
 185      struct pending_block *old_blocks;
 186      CORE_ADDR start, end;
 187      struct objfile *objfile;
 188 {
 189   register struct pending *next, *next1;
 190   register struct block *block;
 191   register struct pending_block *pblock;
 192   struct pending_block *opblock;
 193   register int i;
 194   register int j;
 195
 196   /* Count the length of the list of symbols.  */
 197
 198   for (next = *listhead, i = 0;
 199        next;
 200        i += next->nsyms, next = next->next)
 201     {
 202       /*EMPTY*/;
 203     }
 204
 205   block = (struct block *) obstack_alloc (&objfile -> symbol_obstack,
 206           (sizeof (struct block) + ((i - 1) * sizeof (struct symbol *))));
 207
 208   /* Copy the symbols into the block.  */
 209
 210   BLOCK_NSYMS (block) = i;
 211   for (next = *listhead; next; next = next->next)
 212     {
 213       for (j = next->nsyms - 1; j >= 0; j--)
 214         {
 215           BLOCK_SYM (block, --i) = next->symbol[j];
 216         }
 217     }
 218
 219   BLOCK_START (block) = start;
 220   BLOCK_END (block) = end;
 221  /* Superblock filled in when containing block is made */
 222   BLOCK_SUPERBLOCK (block) = NULL;
 223   BLOCK_GCC_COMPILED (block) = processing_gcc_compilation;
 224
 225   /* Put the block in as the value of the symbol that names it.  */
 226
 227   if (symbol)
 228     {
 229       SYMBOL_BLOCK_VALUE (symbol) = block;
 230       BLOCK_FUNCTION (block) = symbol;
 231     }
 232   else
 233     {
 234       BLOCK_FUNCTION (block) = NULL;
 235     }
 236
 237   /* Now "free" the links of the list, and empty the list.  */
 238
 239   for (next = *listhead; next; next = next1)
 240     {
 241       next1 = next->next;
 242       next->next = free_pendings;
 243       free_pendings = next;
 244     }
 245   *listhead = NULL;
 246
 247   /* Install this block as the superblock
 248      of all blocks made since the start of this scope
 249      that don't have superblocks yet.  */
 250
 251   opblock = NULL;
 252   for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
 253     {
 254       if (BLOCK_SUPERBLOCK (pblock->block) == NULL)
 255         {
 256 #if 1
 257           /* Check to be sure the blocks are nested as we receive them.
 258              If the compiler/assembler/linker work, this just burns a small
 259              amount of time.  */
 260           if (BLOCK_START (pblock->block) < BLOCK_START (block) ||
 261               BLOCK_END   (pblock->block) > BLOCK_END   (block))
 262             {
 263               if (symbol)
 264                 {
 265                   complain (&innerblock_complaint,
 266                             SYMBOL_SOURCE_NAME (symbol));
 267                 }
 268               else
 269                 {
 270                   complain (&innerblock_anon_complaint);
 271                 }
 272               BLOCK_START (pblock->block) = BLOCK_START (block);
 273               BLOCK_END   (pblock->block) = BLOCK_END   (block);
 274             }
 275 #endif
 276           BLOCK_SUPERBLOCK (pblock->block) = block;
 277         }
 278       opblock = pblock;
 279     }
 280
 281   /* Record this block on the list of all blocks in the file.
 282      Put it after opblock, or at the beginning if opblock is 0.
 283      This puts the block in the list after all its subblocks.  */
 284
 285   /* Allocate in the symbol_obstack to save time.
 286      It wastes a little space.  */
 287   pblock = (struct pending_block *)
 288     obstack_alloc (&objfile -> symbol_obstack,
 289                    sizeof (struct pending_block));
 290   pblock->block = block;
 291   if (opblock)
 292     {
 293       pblock->next = opblock->next;
 294       opblock->next = pblock;
 295     }
 296   else
 297     {
 298       pblock->next = pending_blocks;
 299       pending_blocks = pblock;
 300     }
 301 }
 302
 303 static struct blockvector *
 304 make_blockvector (objfile)
 305      struct objfile *objfile;
 306 {
 307   register struct pending_block *next;
 308   register struct blockvector *blockvector;
 309   register int i;
 310
 311   /* Count the length of the list of blocks.  */
 312
 313   for (next = pending_blocks, i = 0; next; next = next->next, i++) {;}
 314
 315   blockvector = (struct blockvector *)
 316     obstack_alloc (&objfile -> symbol_obstack,
 317                    (sizeof (struct blockvector)
 318                     + (i - 1) * sizeof (struct block *)));
 319
 320   /* Copy the blocks into the blockvector.
 321      This is done in reverse order, which happens to put
 322      the blocks into the proper order (ascending starting address).
 323      finish_block has hair to insert each block into the list
 324      after its subblocks in order to make sure this is true.  */
 325
 326   BLOCKVECTOR_NBLOCKS (blockvector) = i;
 327   for (next = pending_blocks; next; next = next->next)
 328     {
 329       BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
 330     }
 331
 332 #if 0 /* Now we make the links in the obstack, so don't free them.  */
 333   /* Now free the links of the list, and empty the list.  */
 334
 335   for (next = pending_blocks; next; next = next1)
 336     {
 337       next1 = next->next;
 338       free (next);
 339     }
 340 #endif
 341   pending_blocks = NULL;
 342
 343 #if 1  /* FIXME, shut this off after a while to speed up symbol reading.  */
 344   /* Some compilers output blocks in the wrong order, but we depend
 345      on their being in the right order so we can binary search.
 346      Check the order and moan about it.  FIXME.  */
 347   if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
 348     {
 349       for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++)
 350         {
 351           if (BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i-1))
 352               > BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)))
 353             {
 354               complain (&blockvector_complaint,
 355                         (unsigned long) BLOCK_START(BLOCKVECTOR_BLOCK (blockvector, i)));
 356             }
 357         }
 358     }
 359 #endif
 360
 361   return (blockvector);
 362 }
 363
 364 \f
 365 /* Start recording information about source code that came from an included
 366    (or otherwise merged-in) source file with a different name.  NAME is
 367    the name of the file (cannot be NULL), DIRNAME is the directory in which
 368    it resides (or NULL if not known).  */
 369
 370 void
 371 start_subfile (name, dirname)
 372      char *name;
 373      char *dirname;
 374 {
 375   register struct subfile *subfile;
 376
 377   /* See if this subfile is already known as a subfile of the
 378      current main source file.  */
 379
 380   for (subfile = subfiles; subfile; subfile = subfile->next)
 381     {
 382       if (STREQ (subfile->name, name))
 383         {
 384           current_subfile = subfile;
 385           return;
 386         }
 387     }
 388
 389   /* This subfile is not known.  Add an entry for it.
 390      Make an entry for this subfile in the list of all subfiles
 391      of the current main source file.  */
 392
 393   subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
 394   subfile->next = subfiles;
 395   subfiles = subfile;
 396   current_subfile = subfile;
 397
 398   /* Save its name and compilation directory name */
 399   subfile->name = (name == NULL)? NULL : strdup (name);
 400   subfile->dirname = (dirname == NULL) ? NULL : strdup (dirname);
 401
 402   /* Initialize line-number recording for this subfile.  */
 403   subfile->line_vector = NULL;
 404
 405   /* Default the source language to whatever can be deduced from
 406      the filename.  If nothing can be deduced (such as for a C/C++
 407      include file with a ".h" extension), then inherit whatever
 408      language the previous subfile had.  This kludgery is necessary
 409      because there is no standard way in some object formats to
 410      record the source language.  Also, when symtabs are allocated
 411      we try to deduce a language then as well, but it is too late
 412      for us to use that information while reading symbols, since
 413      symtabs aren't allocated until after all the symbols have
 414      been processed for a given source file. */
 415
 416   subfile->language = deduce_language_from_filename (subfile->name);
 417   if (subfile->language == language_unknown &&
 418       subfile->next != NULL)
 419     {
 420       subfile->language = subfile->next->language;
 421     }
 422
 423   /* cfront output is a C program, so in most ways it looks like a C
 424      program.  But to demangle we need to set the language to C++.  We
 425      can distinguish cfront code by the fact that it has #line
 426      directives which specify a file name ending in .C.
 427
 428      So if the filename of this subfile ends in .C, then change the language
 429      of any pending subfiles from C to C++.  We also accept any other C++
 430      suffixes accepted by deduce_language_from_filename (in particular,
 431      some people use .cxx with cfront).  */
 432
 433   if (subfile->name)
 434     {
 435       struct subfile *s;
 436
 437       if (deduce_language_from_filename (subfile->name) == language_cplus)
 438         for (s = subfiles; s != NULL; s = s->next)
 439           if (s->language == language_c)
 440             s->language = language_cplus;
 441     }
 442
 443   /* And patch up this file if necessary.  */
 444   if (subfile->language == language_c
 445       && subfile->next != NULL
 446       && subfile->next->language == language_cplus)
 447     {
 448       subfile->language = language_cplus;
 449     }
 450 }
 451
 452 /* For stabs readers, the first N_SO symbol is assumed to be the source
 453    file name, and the subfile struct is initialized using that assumption.
 454    If another N_SO symbol is later seen, immediately following the first
 455    one, then the first one is assumed to be the directory name and the
 456    second one is really the source file name.
 457
 458    So we have to patch up the subfile struct by moving the old name value to
 459    dirname and remembering the new name.  Some sanity checking is performed
 460    to ensure that the state of the subfile struct is reasonable and that the
 461    old name we are assuming to be a directory name actually is (by checking
 462    for a trailing '/'). */
 463
 464 void
 465 patch_subfile_names (subfile, name)
 466      struct subfile *subfile;
 467      char *name;
 468 {
 469   if (subfile != NULL && subfile->dirname == NULL && subfile->name != NULL
 470       && subfile->name[strlen(subfile->name)-1] == '/')
 471     {
 472       subfile->dirname = subfile->name;
 473       subfile->name = strdup (name);
 474
 475       /* Default the source language to whatever can be deduced from
 476          the filename.  If nothing can be deduced (such as for a C/C++
 477          include file with a ".h" extension), then inherit whatever
 478          language the previous subfile had.  This kludgery is necessary
 479          because there is no standard way in some object formats to
 480          record the source language.  Also, when symtabs are allocated
 481          we try to deduce a language then as well, but it is too late
 482          for us to use that information while reading symbols, since
 483          symtabs aren't allocated until after all the symbols have
 484          been processed for a given source file. */
 485
 486       subfile->language = deduce_language_from_filename (subfile->name);
 487       if (subfile->language == language_unknown &&
 488           subfile->next != NULL)
 489         {
 490           subfile->language = subfile->next->language;
 491         }
 492     }
 493 }
 494
 495 \f
 496 /* Handle the N_BINCL and N_EINCL symbol types
 497    that act like N_SOL for switching source files
 498    (different subfiles, as we call them) within one object file,
 499    but using a stack rather than in an arbitrary order.  */
 500
 501 void
 502 push_subfile ()
 503 {
 504   register struct subfile_stack *tem
 505     = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
 506
 507   tem->next = subfile_stack;
 508   subfile_stack = tem;
 509   if (current_subfile == NULL || current_subfile->name == NULL)
 510     {
 511       abort ();
 512     }
 513   tem->name = current_subfile->name;
 514 }
 515
 516 char *
 517 pop_subfile ()
 518 {
 519   register char *name;
 520   register struct subfile_stack *link = subfile_stack;
 521
 522   if (link == NULL)
 523     {
 524       abort ();
 525     }
 526   name = link->name;
 527   subfile_stack = link->next;
 528   free ((PTR)link);
 529   return (name);
 530 }
 531
 532 \f
 533 /* Add a linetable entry for line number LINE and address PC to the line
 534    vector for SUBFILE.  */
 535
 536 void
 537 record_line (subfile, line, pc)
 538      register struct subfile *subfile;
 539      int line;
 540      CORE_ADDR pc;
 541 {
 542   struct linetable_entry *e;
 543   /* Ignore the dummy line number in libg.o */
 544
 545   if (line == 0xffff)
 546     {
 547       return;
 548     }
 549
 550   /* Make sure line vector exists and is big enough.  */
 551   if (!subfile->line_vector)
 552     {
 553       subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH;
 554       subfile->line_vector = (struct linetable *)
 555         xmalloc (sizeof (struct linetable)
 556           + subfile->line_vector_length * sizeof (struct linetable_entry));
 557       subfile->line_vector->nitems = 0;
 558     }
 559
 560   if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length)
 561     {
 562       subfile->line_vector_length *= 2;
 563       subfile->line_vector = (struct linetable *)
 564         xrealloc ((char *) subfile->line_vector, (sizeof (struct linetable)
 565           + subfile->line_vector_length * sizeof (struct linetable_entry)));
 566     }
 567
 568   e = subfile->line_vector->item + subfile->line_vector->nitems++;
 569   e->line = line; e->pc = pc;
 570 }
 571
 572
 573 /* Needed in order to sort line tables from IBM xcoff files.  Sigh!  */
 574
 575 static int
 576 compare_line_numbers (ln1p, ln2p)
 577      const PTR ln1p;
 578      const PTR ln2p;
 579 {
 580   struct linetable_entry *ln1 = (struct linetable_entry *) ln1p;
 581   struct linetable_entry *ln2 = (struct linetable_entry *) ln2p;
 582
 583   /* Note: this code does not assume that CORE_ADDRs can fit in ints.
 584      Please keep it that way.  */
 585   if (ln1->pc < ln2->pc)
 586     return -1;
 587
 588   if (ln1->pc > ln2->pc)
 589     return 1;
 590
 591   /* If pc equal, sort by line.  I'm not sure whether this is optimum
 592      behavior (see comment at struct linetable in symtab.h).  */
 593   return ln1->line - ln2->line;
 594 }
 595
 596 \f
 597 /* Start a new symtab for a new source file.
 598    Called, for example, when a stabs symbol of type N_SO is seen, or when
 599    a DWARF TAG_compile_unit DIE is seen.
 600    It indicates the start of data for one original source file.  */
 601
 602 void
 603 start_symtab (name, dirname, start_addr)
 604      char *name;
 605      char *dirname;
 606      CORE_ADDR start_addr;
 607 {
 608
 609   last_source_file = name;
 610   last_source_start_addr = start_addr;
 611   file_symbols = NULL;
 612   global_symbols = NULL;
 613   within_function = 0;
 614
 615   /* Context stack is initially empty.  Allocate first one with room for
 616      10 levels; reuse it forever afterward.  */
 617   if (context_stack == NULL)
 618     {
 619       context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
 620       context_stack = (struct context_stack *)
 621         xmalloc (context_stack_size * sizeof (struct context_stack));
 622     }
 623   context_stack_depth = 0;
 624
 625   /* Initialize the list of sub source files with one entry
 626      for this file (the top-level source file).  */
 627
 628   subfiles = NULL;
 629   current_subfile = NULL;
 630   start_subfile (name, dirname);
 631 }
 632
 633 /* Finish the symbol definitions for one main source file,
 634    close off all the lexical contexts for that file
 635    (creating struct block's for them), then make the struct symtab
 636    for that file and put it in the list of all such.
 637
 638    END_ADDR is the address of the end of the file's text.
 639    SECTION is the section number (in objfile->section_offsets) of
 640    the blockvector and linetable.
 641
 642    Note that it is possible for end_symtab() to return NULL.  In particular,
 643    for the DWARF case at least, it will return NULL when it finds a
 644    compilation unit that has exactly one DIE, a TAG_compile_unit DIE.  This
 645    can happen when we link in an object file that was compiled from an empty
 646    source file.  Returning NULL is probably not the correct thing to do,
 647    because then gdb will never know about this empty file (FIXME). */
 648
 649 struct symtab *
 650 end_symtab (end_addr, sort_pending, sort_linevec, objfile, section)
 651      CORE_ADDR end_addr;
 652      int sort_pending;
 653      int sort_linevec;
 654      struct objfile *objfile;
 655      int section;
 656 {
 657   register struct symtab *symtab = NULL;
 658   register struct blockvector *blockvector;
 659   register struct subfile *subfile;
 660   register struct context_stack *cstk;
 661   struct subfile *nextsub;
 662
 663   /* Finish the lexical context of the last function in the file;
 664      pop the context stack.  */
 665
 666   if (context_stack_depth > 0)
 667     {
 668       context_stack_depth--;
 669       cstk = &context_stack[context_stack_depth];
 670       /* Make a block for the local symbols within.  */
 671       finish_block (cstk->name, &local_symbols, cstk->old_blocks,
 672                     cstk->start_addr, end_addr, objfile);
 673
 674       if (context_stack_depth > 0)
 675         {
 676           /* This is said to happen with SCO.  The old coffread.c code
 677              simply emptied the context stack, so we do the same.  FIXME:
 678              Find out why it is happening.  This is not believed to happen
 679              in most cases (even for coffread.c); it used to be an abort().  */
 680           static struct complaint msg =
 681             {"Context stack not empty in end_symtab", 0, 0};
 682           complain (&msg);
 683           context_stack_depth = 0;
 684         }
 685     }
 686
 687   /* It is unfortunate that in xcoff, pending blocks might not be ordered
 688      in this stage. Especially, blocks for static functions will show up at
 689      the end.  We need to sort them, so tools like `find_pc_function' and
 690      `find_pc_block' can work reliably. */
 691
 692   if (sort_pending && pending_blocks)
 693     {
 694       /* FIXME!  Remove this horrid bubble sort and use qsort!!! */
 695       int swapped;
 696       do
 697         {
 698           struct pending_block *pb, *pbnext;
 699
 700           pb = pending_blocks;
 701           pbnext = pb->next;
 702           swapped = 0;
 703
 704           while (pbnext)
 705             {
 706               /* swap blocks if unordered! */
 707
 708               if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block))
 709                 {
 710                   struct block *tmp = pb->block;
 711                   pb->block = pbnext->block;
 712                   pbnext->block = tmp;
 713                   swapped = 1;
 714                 }
 715               pb = pbnext;
 716               pbnext = pbnext->next;
 717             }
 718         } while (swapped);
 719     }
 720
 721   /* Cleanup any undefined types that have been left hanging around
 722      (this needs to be done before the finish_blocks so that
 723      file_symbols is still good).
 724
 725      Both cleanup_undefined_types and finish_global_stabs are stabs
 726      specific, but harmless for other symbol readers, since on gdb
 727      startup or when finished reading stabs, the state is set so these
 728      are no-ops.  FIXME: Is this handled right in case of QUIT?  Can
 729      we make this cleaner?  */
 730
 731   cleanup_undefined_types ();
 732   finish_global_stabs (objfile);
 733
 734   if (pending_blocks == NULL
 735       && file_symbols == NULL
 736       && global_symbols == NULL)
 737     {
 738       /* Ignore symtabs that have no functions with real debugging info */
 739       blockvector = NULL;
 740     }
 741   else
 742     {
 743       /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the blockvector. */
 744       finish_block (0, &file_symbols, 0, last_source_start_addr, end_addr,
 745                     objfile);
 746       finish_block (0, &global_symbols, 0, last_source_start_addr, end_addr,
 747                     objfile);
 748       blockvector = make_blockvector (objfile);
 749     }
 750
 751 #ifdef PROCESS_LINENUMBER_HOOK
 752   PROCESS_LINENUMBER_HOOK ();                   /* Needed for xcoff. */
 753 #endif
 754
 755   /* Now create the symtab objects proper, one for each subfile.  */
 756   /* (The main file is the last one on the chain.)  */
 757
 758   for (subfile = subfiles; subfile; subfile = nextsub)
 759     {
 760       int linetablesize = 0;
 761       /* If we have blocks of symbols, make a symtab.
 762          Otherwise, just ignore this file and any line number info in it.  */
 763       symtab = NULL;
 764       if (blockvector)
 765         {
 766           if (subfile->line_vector)
 767             {
 768               linetablesize = sizeof (struct linetable) +
 769                 subfile->line_vector->nitems * sizeof (struct linetable_entry);
 770 #if 0
 771               /* I think this is artifact from before it went on the obstack.
 772                  I doubt we'll need the memory between now and when we
 773                  free it later in this function.  */
 774               /* First, shrink the linetable to make more memory.  */
 775               subfile->line_vector = (struct linetable *)
 776                 xrealloc ((char *) subfile->line_vector, linetablesize);
 777 #endif
 778               /* If sort_linevec is false, we might want just check to make
 779                  sure they are sorted and complain() if not, as a way of
 780                  tracking down compilers/symbol readers which don't get
 781                  them sorted right.  */
 782
 783               if (sort_linevec)
 784                 qsort (subfile->line_vector->item,
 785                        subfile->line_vector->nitems,
 786                        sizeof (struct linetable_entry), compare_line_numbers);
 787             }
 788
 789           /* Now, allocate a symbol table.  */
 790           symtab = allocate_symtab (subfile->name, objfile);
 791
 792           /* Fill in its components.  */
 793           symtab->blockvector = blockvector;
 794           if (subfile->line_vector)
 795             {
 796               /* Reallocate the line table on the symbol obstack */
 797               symtab->linetable = (struct linetable *)
 798                 obstack_alloc (&objfile -> symbol_obstack, linetablesize);
 799               memcpy (symtab->linetable, subfile->line_vector, linetablesize);
 800             }
 801           else
 802             {
 803               symtab->linetable = NULL;
 804             }
 805           symtab->block_line_section = section;
 806           if (subfile->dirname)
 807             {
 808               /* Reallocate the dirname on the symbol obstack */
 809               symtab->dirname = (char *)
 810                 obstack_alloc (&objfile -> symbol_obstack,
 811                                strlen (subfile -> dirname) + 1);
 812               strcpy (symtab->dirname, subfile->dirname);
 813             }
 814           else
 815             {
 816               symtab->dirname = NULL;
 817             }
 818           symtab->free_code = free_linetable;
 819           symtab->free_ptr = NULL;
 820
 821           /* Use whatever language we have been using for this subfile,
 822              not the one that was deduced in allocate_symtab from the
 823              filename.  We already did our own deducing when we created
 824              the subfile, and we may have altered our opinion of what
 825              language it is from things we found in the symbols. */
 826           symtab->language = subfile->language;
 827
 828           /* All symtabs for the main file and the subfiles share a
 829              blockvector, so we need to clear primary for everything but
 830              the main file.  */
 831
 832           symtab->primary = 0;
 833         }
 834       if (subfile->name != NULL)
 835         {
 836           free ((PTR) subfile->name);
 837         }
 838       if (subfile->dirname != NULL)
 839         {
 840           free ((PTR) subfile->dirname);
 841         }
 842       if (subfile->line_vector != NULL)
 843         {
 844           free ((PTR) subfile->line_vector);
 845         }
 846
 847       nextsub = subfile->next;
 848       free ((PTR)subfile);
 849     }
 850
 851   /* Set this for the main source file.  */
 852   if (symtab)
 853     {
 854       symtab->primary = 1;
 855     }
 856
 857   last_source_file = NULL;
 858   current_subfile = NULL;
 859
 860   return (symtab);
 861 }
 862
 863
 864 /* Push a context block.  Args are an identifying nesting level (checkable
 865    when you pop it), and the starting PC address of this context.  */
 866
 867 struct context_stack *
 868 push_context (desc, valu)
 869      int desc;
 870      CORE_ADDR valu;
 871 {
 872   register struct context_stack *new;
 873
 874   if (context_stack_depth == context_stack_size)
 875     {
 876       context_stack_size *= 2;
 877       context_stack = (struct context_stack *)
 878         xrealloc ((char *) context_stack,
 879                   (context_stack_size * sizeof (struct context_stack)));
 880     }
 881
 882   new = &context_stack[context_stack_depth++];
 883   new->depth = desc;
 884   new->locals = local_symbols;
 885   new->old_blocks = pending_blocks;
 886   new->start_addr = valu;
 887   new->name = NULL;
 888
 889   local_symbols = NULL;
 890
 891   return (new);
 892 }
 893
 894 \f
 895 /* Compute a small integer hash code for the given name. */
 896
 897 int
 898 hashname (name)
 899      char *name;
 900 {
 901   register char *p = name;
 902   register int total = p[0];
 903   register int c;
 904
 905   c = p[1];
 906   total += c << 2;
 907   if (c)
 908     {
 909       c = p[2];
 910       total += c << 4;
 911       if (c)
 912         {
 913           total += p[3] << 6;
 914         }
 915     }
 916
 917   /* Ensure result is positive.  */
 918   if (total < 0)
 919     {
 920       total += (1000 << 6);
 921     }
 922   return (total % HASHSIZE);
 923 }
 924
 925 \f
 926 /* Initialize anything that needs initializing when starting to read
 927    a fresh piece of a symbol file, e.g. reading in the stuff corresponding
 928    to a psymtab.  */
 929
 930 void
 931 buildsym_init ()
 932 {
 933   free_pendings = NULL;
 934   file_symbols = NULL;
 935   global_symbols = NULL;
 936   pending_blocks = NULL;
 937 }
 938
 939 /* Initialize anything that needs initializing when a completely new
 940    symbol file is specified (not just adding some symbols from another
 941    file, e.g. a shared library).  */
 942
 943 void
 944 buildsym_new_init ()
 945 {
 946   buildsym_init ();
 947 }
 948
 949 /* Initializer for this module */
 950
 951 void
 952 _initialize_buildsym ()
 953 {
 954 }