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