gdb/buildsym.c

   1 /* Support routines for building symbol tables in GDB's internal format.
   2    Copyright (C) 1986-2004, 2007-2012 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* This module provides subroutines used for creating and adding to
  20    the symbol table.  These routines are called from various symbol-
  21    file-reading routines.
  22
  23    Routines to support specific debugging information formats (stabs,
  24    DWARF, etc) belong somewhere else.  */
  25
  26 #include "defs.h"
  27 #include "bfd.h"
  28 #include "gdb_obstack.h"
  29 #include "symtab.h"
  30 #include "symfile.h"
  31 #include "objfiles.h"
  32 #include "gdbtypes.h"
  33 #include "gdb_assert.h"
  34 #include "complaints.h"
  35 #include "gdb_string.h"
  36 #include "expression.h"         /* For "enum exp_opcode" used by...  */
  37 #include "bcache.h"
  38 #include "filenames.h"          /* For DOSish file names.  */
  39 #include "macrotab.h"
  40 #include "demangle.h"           /* Needed by SYMBOL_INIT_DEMANGLED_NAME.  */
  41 #include "block.h"
  42 #include "cp-support.h"
  43 #include "dictionary.h"
  44 #include "addrmap.h"
  45
  46 /* Ask buildsym.h to define the vars it normally declares `extern'.  */
  47 #define EXTERN
  48 /**/
  49 #include "buildsym.h"           /* Our own declarations.  */
  50 #undef  EXTERN
  51
  52 /* For cleanup_undefined_stabs_types and finish_global_stabs (somewhat
  53    questionable--see comment where we call them).  */
  54
  55 #include "stabsread.h"
  56
  57 /* List of subfiles.  */
  58
  59 static struct subfile *subfiles;
  60
  61 /* List of free `struct pending' structures for reuse.  */
  62
  63 static struct pending *free_pendings;
  64
  65 /* Non-zero if symtab has line number info.  This prevents an
  66    otherwise empty symtab from being tossed.  */
  67
  68 static int have_line_numbers;
  69
  70 /* The mutable address map for the compilation unit whose symbols
  71    we're currently reading.  The symtabs' shared blockvector will
  72    point to a fixed copy of this.  */
  73 static struct addrmap *pending_addrmap;
  74
  75 /* The obstack on which we allocate pending_addrmap.
  76    If pending_addrmap is NULL, this is uninitialized; otherwise, it is
  77    initialized (and holds pending_addrmap).  */
  78 static struct obstack pending_addrmap_obstack;
  79
  80 /* Non-zero if we recorded any ranges in the addrmap that are
  81    different from those in the blockvector already.  We set this to
  82    zero when we start processing a symfile, and if it's still zero at
  83    the end, then we just toss the addrmap.  */
  84 static int pending_addrmap_interesting;
  85
  86 \f
  87 static int compare_line_numbers (const void *ln1p, const void *ln2p);
  88
  89 static void record_pending_block (struct objfile *objfile,
  90                                   struct block *block,
  91                                   struct pending_block *opblock);
  92 \f
  93
  94 /* Initial sizes of data structures.  These are realloc'd larger if
  95    needed, and realloc'd down to the size actually used, when
  96    completed.  */
  97
  98 #define INITIAL_CONTEXT_STACK_SIZE      10
  99 #define INITIAL_LINE_VECTOR_LENGTH      1000
 100 \f
 101
 102 /* Maintain the lists of symbols and blocks.  */
 103
 104 /* Add a symbol to one of the lists of symbols.  */
 105
 106 void
 107 add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
 108 {
 109   struct pending *link;
 110
 111   /* If this is an alias for another symbol, don't add it.  */
 112   if (symbol->ginfo.name && symbol->ginfo.name[0] == '#')
 113     return;
 114
 115   /* We keep PENDINGSIZE symbols in each link of the list.  If we
 116      don't have a link with room in it, add a new link.  */
 117   if (*listhead == NULL || (*listhead)->nsyms == PENDINGSIZE)
 118     {
 119       if (free_pendings)
 120         {
 121           link = free_pendings;
 122           free_pendings = link->next;
 123         }
 124       else
 125         {
 126           link = (struct pending *) xmalloc (sizeof (struct pending));
 127         }
 128
 129       link->next = *listhead;
 130       *listhead = link;
 131       link->nsyms = 0;
 132     }
 133
 134   (*listhead)->symbol[(*listhead)->nsyms++] = symbol;
 135 }
 136
 137 /* Find a symbol named NAME on a LIST.  NAME need not be
 138    '\0'-terminated; LENGTH is the length of the name.  */
 139
 140 struct symbol *
 141 find_symbol_in_list (struct pending *list, char *name, int length)
 142 {
 143   int j;
 144   const char *pp;
 145
 146   while (list != NULL)
 147     {
 148       for (j = list->nsyms; --j >= 0;)
 149         {
 150           pp = SYMBOL_LINKAGE_NAME (list->symbol[j]);
 151           if (*pp == *name && strncmp (pp, name, length) == 0
 152               && pp[length] == '\0')
 153             {
 154               return (list->symbol[j]);
 155             }
 156         }
 157       list = list->next;
 158     }
 159   return (NULL);
 160 }
 161
 162 /* At end of reading syms, or in case of quit, really free as many
 163    `struct pending's as we can easily find.  */
 164
 165 void
 166 really_free_pendings (void *dummy)
 167 {
 168   struct pending *next, *next1;
 169
 170   for (next = free_pendings; next; next = next1)
 171     {
 172       next1 = next->next;
 173       xfree ((void *) next);
 174     }
 175   free_pendings = NULL;
 176
 177   free_pending_blocks ();
 178
 179   for (next = file_symbols; next != NULL; next = next1)
 180     {
 181       next1 = next->next;
 182       xfree ((void *) next);
 183     }
 184   file_symbols = NULL;
 185
 186   for (next = global_symbols; next != NULL; next = next1)
 187     {
 188       next1 = next->next;
 189       xfree ((void *) next);
 190     }
 191   global_symbols = NULL;
 192
 193   if (pending_macros)
 194     free_macro_table (pending_macros);
 195
 196   if (pending_addrmap)
 197     {
 198       obstack_free (&pending_addrmap_obstack, NULL);
 199       pending_addrmap = NULL;
 200     }
 201 }
 202
 203 /* This function is called to discard any pending blocks.  */
 204
 205 void
 206 free_pending_blocks (void)
 207 {
 208   /* The links are made in the objfile_obstack, so we only need to
 209      reset PENDING_BLOCKS.  */
 210   pending_blocks = NULL;
 211 }
 212
 213 /* Take one of the lists of symbols and make a block from it.  Keep
 214    the order the symbols have in the list (reversed from the input
 215    file).  Put the block on the list of pending blocks.  */
 216
 217 static struct block *
 218 finish_block_internal (struct symbol *symbol, struct pending **listhead,
 219                        struct pending_block *old_blocks,
 220                        CORE_ADDR start, CORE_ADDR end,
 221                        struct objfile *objfile,
 222                        int is_global)
 223 {
 224   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 225   struct pending *next, *next1;
 226   struct block *block;
 227   struct pending_block *pblock;
 228   struct pending_block *opblock;
 229
 230   block = (is_global
 231            ? allocate_global_block (&objfile->objfile_obstack)
 232            : allocate_block (&objfile->objfile_obstack));
 233
 234   if (symbol)
 235     {
 236       BLOCK_DICT (block) = dict_create_linear (&objfile->objfile_obstack,
 237                                                *listhead);
 238     }
 239   else
 240     {
 241       BLOCK_DICT (block) = dict_create_hashed (&objfile->objfile_obstack,
 242                                                *listhead);
 243     }
 244
 245   BLOCK_START (block) = start;
 246   BLOCK_END (block) = end;
 247
 248   /* Put the block in as the value of the symbol that names it.  */
 249
 250   if (symbol)
 251     {
 252       struct type *ftype = SYMBOL_TYPE (symbol);
 253       struct dict_iterator iter;
 254       SYMBOL_BLOCK_VALUE (symbol) = block;
 255       BLOCK_FUNCTION (block) = symbol;
 256
 257       if (TYPE_NFIELDS (ftype) <= 0)
 258         {
 259           /* No parameter type information is recorded with the
 260              function's type.  Set that from the type of the
 261              parameter symbols.  */
 262           int nparams = 0, iparams;
 263           struct symbol *sym;
 264
 265           /* Here we want to directly access the dictionary, because
 266              we haven't fully initialized the block yet.  */
 267           ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
 268             {
 269               if (SYMBOL_IS_ARGUMENT (sym))
 270                 nparams++;
 271             }
 272           if (nparams > 0)
 273             {
 274               TYPE_NFIELDS (ftype) = nparams;
 275               TYPE_FIELDS (ftype) = (struct field *)
 276                 TYPE_ALLOC (ftype, nparams * sizeof (struct field));
 277
 278               iparams = 0;
 279               /* Here we want to directly access the dictionary, because
 280                  we haven't fully initialized the block yet.  */
 281               ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
 282                 {
 283                   if (iparams == nparams)
 284                     break;
 285
 286                   if (SYMBOL_IS_ARGUMENT (sym))
 287                     {
 288                       TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
 289                       TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
 290                       iparams++;
 291                     }
 292                 }
 293             }
 294         }
 295     }
 296   else
 297     {
 298       BLOCK_FUNCTION (block) = NULL;
 299     }
 300
 301   /* Now "free" the links of the list, and empty the list.  */
 302
 303   for (next = *listhead; next; next = next1)
 304     {
 305       next1 = next->next;
 306       next->next = free_pendings;
 307       free_pendings = next;
 308     }
 309   *listhead = NULL;
 310
 311   /* Check to be sure that the blocks have an end address that is
 312      greater than starting address.  */
 313
 314   if (BLOCK_END (block) < BLOCK_START (block))
 315     {
 316       if (symbol)
 317         {
 318           complaint (&symfile_complaints,
 319                      _("block end address less than block "
 320                        "start address in %s (patched it)"),
 321                      SYMBOL_PRINT_NAME (symbol));
 322         }
 323       else
 324         {
 325           complaint (&symfile_complaints,
 326                      _("block end address %s less than block "
 327                        "start address %s (patched it)"),
 328                      paddress (gdbarch, BLOCK_END (block)),
 329                      paddress (gdbarch, BLOCK_START (block)));
 330         }
 331       /* Better than nothing.  */
 332       BLOCK_END (block) = BLOCK_START (block);
 333     }
 334
 335   /* Install this block as the superblock of all blocks made since the
 336      start of this scope that don't have superblocks yet.  */
 337
 338   opblock = NULL;
 339   for (pblock = pending_blocks;
 340        pblock && pblock != old_blocks;
 341        pblock = pblock->next)
 342     {
 343       if (BLOCK_SUPERBLOCK (pblock->block) == NULL)
 344         {
 345           /* Check to be sure the blocks are nested as we receive
 346              them.  If the compiler/assembler/linker work, this just
 347              burns a small amount of time.
 348
 349              Skip blocks which correspond to a function; they're not
 350              physically nested inside this other blocks, only
 351              lexically nested.  */
 352           if (BLOCK_FUNCTION (pblock->block) == NULL
 353               && (BLOCK_START (pblock->block) < BLOCK_START (block)
 354                   || BLOCK_END (pblock->block) > BLOCK_END (block)))
 355             {
 356               if (symbol)
 357                 {
 358                   complaint (&symfile_complaints,
 359                              _("inner block not inside outer block in %s"),
 360                              SYMBOL_PRINT_NAME (symbol));
 361                 }
 362               else
 363                 {
 364                   complaint (&symfile_complaints,
 365                              _("inner block (%s-%s) not "
 366                                "inside outer block (%s-%s)"),
 367                              paddress (gdbarch, BLOCK_START (pblock->block)),
 368                              paddress (gdbarch, BLOCK_END (pblock->block)),
 369                              paddress (gdbarch, BLOCK_START (block)),
 370                              paddress (gdbarch, BLOCK_END (block)));
 371                 }
 372               if (BLOCK_START (pblock->block) < BLOCK_START (block))
 373                 BLOCK_START (pblock->block) = BLOCK_START (block);
 374               if (BLOCK_END (pblock->block) > BLOCK_END (block))
 375                 BLOCK_END (pblock->block) = BLOCK_END (block);
 376             }
 377           BLOCK_SUPERBLOCK (pblock->block) = block;
 378         }
 379       opblock = pblock;
 380     }
 381
 382   block_set_using (block, using_directives, &objfile->objfile_obstack);
 383   using_directives = NULL;
 384
 385   record_pending_block (objfile, block, opblock);
 386
 387   return block;
 388 }
 389
 390 struct block *
 391 finish_block (struct symbol *symbol, struct pending **listhead,
 392               struct pending_block *old_blocks,
 393               CORE_ADDR start, CORE_ADDR end,
 394               struct objfile *objfile)
 395 {
 396   return finish_block_internal (symbol, listhead, old_blocks,
 397                                 start, end, objfile, 0);
 398 }
 399
 400 /* Record BLOCK on the list of all blocks in the file.  Put it after
 401    OPBLOCK, or at the beginning if opblock is NULL.  This puts the
 402    block in the list after all its subblocks.
 403
 404    Allocate the pending block struct in the objfile_obstack to save
 405    time.  This wastes a little space.  FIXME: Is it worth it?  */
 406
 407 static void
 408 record_pending_block (struct objfile *objfile, struct block *block,
 409                       struct pending_block *opblock)
 410 {
 411   struct pending_block *pblock;
 412
 413   pblock = (struct pending_block *)
 414     obstack_alloc (&objfile->objfile_obstack, sizeof (struct pending_block));
 415   pblock->block = block;
 416   if (opblock)
 417     {
 418       pblock->next = opblock->next;
 419       opblock->next = pblock;
 420     }
 421   else
 422     {
 423       pblock->next = pending_blocks;
 424       pending_blocks = pblock;
 425     }
 426 }
 427
 428
 429 /* Record that the range of addresses from START to END_INCLUSIVE
 430    (inclusive, like it says) belongs to BLOCK.  BLOCK's start and end
 431    addresses must be set already.  You must apply this function to all
 432    BLOCK's children before applying it to BLOCK.
 433
 434    If a call to this function complicates the picture beyond that
 435    already provided by BLOCK_START and BLOCK_END, then we create an
 436    address map for the block.  */
 437 void
 438 record_block_range (struct block *block,
 439                     CORE_ADDR start, CORE_ADDR end_inclusive)
 440 {
 441   /* If this is any different from the range recorded in the block's
 442      own BLOCK_START and BLOCK_END, then note that the address map has
 443      become interesting.  Note that even if this block doesn't have
 444      any "interesting" ranges, some later block might, so we still
 445      need to record this block in the addrmap.  */
 446   if (start != BLOCK_START (block)
 447       || end_inclusive + 1 != BLOCK_END (block))
 448     pending_addrmap_interesting = 1;
 449
 450   if (! pending_addrmap)
 451     {
 452       obstack_init (&pending_addrmap_obstack);
 453       pending_addrmap = addrmap_create_mutable (&pending_addrmap_obstack);
 454     }
 455
 456   addrmap_set_empty (pending_addrmap, start, end_inclusive, block);
 457 }
 458
 459
 460 static struct blockvector *
 461 make_blockvector (struct objfile *objfile)
 462 {
 463   struct pending_block *next;
 464   struct blockvector *blockvector;
 465   int i;
 466
 467   /* Count the length of the list of blocks.  */
 468
 469   for (next = pending_blocks, i = 0; next; next = next->next, i++)
 470     {;
 471     }
 472
 473   blockvector = (struct blockvector *)
 474     obstack_alloc (&objfile->objfile_obstack,
 475                    (sizeof (struct blockvector)
 476                     + (i - 1) * sizeof (struct block *)));
 477
 478   /* Copy the blocks into the blockvector.  This is done in reverse
 479      order, which happens to put the blocks into the proper order
 480      (ascending starting address).  finish_block has hair to insert
 481      each block into the list after its subblocks in order to make
 482      sure this is true.  */
 483
 484   BLOCKVECTOR_NBLOCKS (blockvector) = i;
 485   for (next = pending_blocks; next; next = next->next)
 486     {
 487       BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
 488     }
 489
 490   free_pending_blocks ();
 491
 492   /* If we needed an address map for this symtab, record it in the
 493      blockvector.  */
 494   if (pending_addrmap && pending_addrmap_interesting)
 495     BLOCKVECTOR_MAP (blockvector)
 496       = addrmap_create_fixed (pending_addrmap, &objfile->objfile_obstack);
 497   else
 498     BLOCKVECTOR_MAP (blockvector) = 0;
 499
 500   /* Some compilers output blocks in the wrong order, but we depend on
 501      their being in the right order so we can binary search.  Check the
 502      order and moan about it.  */
 503   if (BLOCKVECTOR_NBLOCKS (blockvector) > 1)
 504     {
 505       for (i = 1; i < BLOCKVECTOR_NBLOCKS (blockvector); i++)
 506         {
 507           if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i - 1))
 508               > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i)))
 509             {
 510               CORE_ADDR start
 511                 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector, i));
 512
 513               complaint (&symfile_complaints, _("block at %s out of order"),
 514                          hex_string ((LONGEST) start));
 515             }
 516         }
 517     }
 518
 519   return (blockvector);
 520 }
 521 \f
 522 /* Start recording information about source code that came from an
 523    included (or otherwise merged-in) source file with a different
 524    name.  NAME is the name of the file (cannot be NULL), DIRNAME is
 525    the directory in which the file was compiled (or NULL if not
 526    known).  */
 527
 528 void
 529 start_subfile (const char *name, const char *dirname)
 530 {
 531   struct subfile *subfile;
 532
 533   /* See if this subfile is already known as a subfile of the current
 534      main source file.  */
 535
 536   for (subfile = subfiles; subfile; subfile = subfile->next)
 537     {
 538       char *subfile_name;
 539
 540       /* If NAME is an absolute path, and this subfile is not, then
 541          attempt to create an absolute path to compare.  */
 542       if (IS_ABSOLUTE_PATH (name)
 543           && !IS_ABSOLUTE_PATH (subfile->name)
 544           && subfile->dirname != NULL)
 545         subfile_name = concat (subfile->dirname, SLASH_STRING,
 546                                subfile->name, (char *) NULL);
 547       else
 548         subfile_name = subfile->name;
 549
 550       if (FILENAME_CMP (subfile_name, name) == 0)
 551         {
 552           current_subfile = subfile;
 553           if (subfile_name != subfile->name)
 554             xfree (subfile_name);
 555           return;
 556         }
 557       if (subfile_name != subfile->name)
 558         xfree (subfile_name);
 559     }
 560
 561   /* This subfile is not known.  Add an entry for it.  Make an entry
 562      for this subfile in the list of all subfiles of the current main
 563      source file.  */
 564
 565   subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
 566   memset ((char *) subfile, 0, sizeof (struct subfile));
 567   subfile->next = subfiles;
 568   subfiles = subfile;
 569   current_subfile = subfile;
 570
 571   /* Save its name and compilation directory name.  */
 572   subfile->name = (name == NULL) ? NULL : xstrdup (name);
 573   subfile->dirname = (dirname == NULL) ? NULL : xstrdup (dirname);
 574
 575   /* Initialize line-number recording for this subfile.  */
 576   subfile->line_vector = NULL;
 577
 578   /* Default the source language to whatever can be deduced from the
 579      filename.  If nothing can be deduced (such as for a C/C++ include
 580      file with a ".h" extension), then inherit whatever language the
 581      previous subfile had.  This kludgery is necessary because there
 582      is no standard way in some object formats to record the source
 583      language.  Also, when symtabs are allocated we try to deduce a
 584      language then as well, but it is too late for us to use that
 585      information while reading symbols, since symtabs aren't allocated
 586      until after all the symbols have been processed for a given
 587      source file.  */
 588
 589   subfile->language = deduce_language_from_filename (subfile->name);
 590   if (subfile->language == language_unknown
 591       && subfile->next != NULL)
 592     {
 593       subfile->language = subfile->next->language;
 594     }
 595
 596   /* Initialize the debug format string to NULL.  We may supply it
 597      later via a call to record_debugformat.  */
 598   subfile->debugformat = NULL;
 599
 600   /* Similarly for the producer.  */
 601   subfile->producer = NULL;
 602
 603   /* If the filename of this subfile ends in .C, then change the
 604      language of any pending subfiles from C to C++.  We also accept
 605      any other C++ suffixes accepted by deduce_language_from_filename.  */
 606   /* Likewise for f2c.  */
 607
 608   if (subfile->name)
 609     {
 610       struct subfile *s;
 611       enum language sublang = deduce_language_from_filename (subfile->name);
 612
 613       if (sublang == language_cplus || sublang == language_fortran)
 614         for (s = subfiles; s != NULL; s = s->next)
 615           if (s->language == language_c)
 616             s->language = sublang;
 617     }
 618
 619   /* And patch up this file if necessary.  */
 620   if (subfile->language == language_c
 621       && subfile->next != NULL
 622       && (subfile->next->language == language_cplus
 623           || subfile->next->language == language_fortran))
 624     {
 625       subfile->language = subfile->next->language;
 626     }
 627 }
 628
 629 /* For stabs readers, the first N_SO symbol is assumed to be the
 630    source file name, and the subfile struct is initialized using that
 631    assumption.  If another N_SO symbol is later seen, immediately
 632    following the first one, then the first one is assumed to be the
 633    directory name and the second one is really the source file name.
 634
 635    So we have to patch up the subfile struct by moving the old name
 636    value to dirname and remembering the new name.  Some sanity
 637    checking is performed to ensure that the state of the subfile
 638    struct is reasonable and that the old name we are assuming to be a
 639    directory name actually is (by checking for a trailing '/').  */
 640
 641 void
 642 patch_subfile_names (struct subfile *subfile, char *name)
 643 {
 644   if (subfile != NULL && subfile->dirname == NULL && subfile->name != NULL
 645       && IS_DIR_SEPARATOR (subfile->name[strlen (subfile->name) - 1]))
 646     {
 647       subfile->dirname = subfile->name;
 648       subfile->name = xstrdup (name);
 649       last_source_file = name;
 650
 651       /* Default the source language to whatever can be deduced from
 652          the filename.  If nothing can be deduced (such as for a C/C++
 653          include file with a ".h" extension), then inherit whatever
 654          language the previous subfile had.  This kludgery is
 655          necessary because there is no standard way in some object
 656          formats to record the source language.  Also, when symtabs
 657          are allocated we try to deduce a language then as well, but
 658          it is too late for us to use that information while reading
 659          symbols, since symtabs aren't allocated until after all the
 660          symbols have been processed for a given source file.  */
 661
 662       subfile->language = deduce_language_from_filename (subfile->name);
 663       if (subfile->language == language_unknown
 664           && subfile->next != NULL)
 665         {
 666           subfile->language = subfile->next->language;
 667         }
 668     }
 669 }
 670 \f
 671 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for
 672    switching source files (different subfiles, as we call them) within
 673    one object file, but using a stack rather than in an arbitrary
 674    order.  */
 675
 676 void
 677 push_subfile (void)
 678 {
 679   struct subfile_stack *tem
 680     = (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
 681
 682   tem->next = subfile_stack;
 683   subfile_stack = tem;
 684   if (current_subfile == NULL || current_subfile->name == NULL)
 685     {
 686       internal_error (__FILE__, __LINE__,
 687                       _("failed internal consistency check"));
 688     }
 689   tem->name = current_subfile->name;
 690 }
 691
 692 char *
 693 pop_subfile (void)
 694 {
 695   char *name;
 696   struct subfile_stack *link = subfile_stack;
 697
 698   if (link == NULL)
 699     {
 700       internal_error (__FILE__, __LINE__,
 701                       _("failed internal consistency check"));
 702     }
 703   name = link->name;
 704   subfile_stack = link->next;
 705   xfree ((void *) link);
 706   return (name);
 707 }
 708 \f
 709 /* Add a linetable entry for line number LINE and address PC to the
 710    line vector for SUBFILE.  */
 711
 712 void
 713 record_line (struct subfile *subfile, int line, CORE_ADDR pc)
 714 {
 715   struct linetable_entry *e;
 716
 717   /* Ignore the dummy line number in libg.o */
 718   if (line == 0xffff)
 719     {
 720       return;
 721     }
 722
 723   /* Make sure line vector exists and is big enough.  */
 724   if (!subfile->line_vector)
 725     {
 726       subfile->line_vector_length = INITIAL_LINE_VECTOR_LENGTH;
 727       subfile->line_vector = (struct linetable *)
 728         xmalloc (sizeof (struct linetable)
 729            + subfile->line_vector_length * sizeof (struct linetable_entry));
 730       subfile->line_vector->nitems = 0;
 731       have_line_numbers = 1;
 732     }
 733
 734   if (subfile->line_vector->nitems + 1 >= subfile->line_vector_length)
 735     {
 736       subfile->line_vector_length *= 2;
 737       subfile->line_vector = (struct linetable *)
 738         xrealloc ((char *) subfile->line_vector,
 739                   (sizeof (struct linetable)
 740                    + (subfile->line_vector_length
 741                       * sizeof (struct linetable_entry))));
 742     }
 743
 744   /* Normally, we treat lines as unsorted.  But the end of sequence
 745      marker is special.  We sort line markers at the same PC by line
 746      number, so end of sequence markers (which have line == 0) appear
 747      first.  This is right if the marker ends the previous function,
 748      and there is no padding before the next function.  But it is
 749      wrong if the previous line was empty and we are now marking a
 750      switch to a different subfile.  We must leave the end of sequence
 751      marker at the end of this group of lines, not sort the empty line
 752      to after the marker.  The easiest way to accomplish this is to
 753      delete any empty lines from our table, if they are followed by
 754      end of sequence markers.  All we lose is the ability to set
 755      breakpoints at some lines which contain no instructions
 756      anyway.  */
 757   if (line == 0 && subfile->line_vector->nitems > 0)
 758     {
 759       e = subfile->line_vector->item + subfile->line_vector->nitems - 1;
 760       while (subfile->line_vector->nitems > 0 && e->pc == pc)
 761         {
 762           e--;
 763           subfile->line_vector->nitems--;
 764         }
 765     }
 766
 767   e = subfile->line_vector->item + subfile->line_vector->nitems++;
 768   e->line = line;
 769   e->pc = pc;
 770 }
 771
 772 /* Needed in order to sort line tables from IBM xcoff files.  Sigh!  */
 773
 774 static int
 775 compare_line_numbers (const void *ln1p, const void *ln2p)
 776 {
 777   struct linetable_entry *ln1 = (struct linetable_entry *) ln1p;
 778   struct linetable_entry *ln2 = (struct linetable_entry *) ln2p;
 779
 780   /* Note: this code does not assume that CORE_ADDRs can fit in ints.
 781      Please keep it that way.  */
 782   if (ln1->pc < ln2->pc)
 783     return -1;
 784
 785   if (ln1->pc > ln2->pc)
 786     return 1;
 787
 788   /* If pc equal, sort by line.  I'm not sure whether this is optimum
 789      behavior (see comment at struct linetable in symtab.h).  */
 790   return ln1->line - ln2->line;
 791 }
 792 \f
 793 /* Start a new symtab for a new source file.  Called, for example,
 794    when a stabs symbol of type N_SO is seen, or when a DWARF
 795    TAG_compile_unit DIE is seen.  It indicates the start of data for
 796    one original source file.
 797
 798    NAME is the name of the file (cannot be NULL).  DIRNAME is the directory in
 799    which the file was compiled (or NULL if not known).  START_ADDR is the
 800    lowest address of objects in the file (or 0 if not known).  */
 801
 802 void
 803 start_symtab (char *name, char *dirname, CORE_ADDR start_addr)
 804 {
 805   last_source_file = name;
 806   last_source_start_addr = start_addr;
 807   file_symbols = NULL;
 808   global_symbols = NULL;
 809   within_function = 0;
 810   have_line_numbers = 0;
 811
 812   /* Context stack is initially empty.  Allocate first one with room
 813      for 10 levels; reuse it forever afterward.  */
 814   if (context_stack == NULL)
 815     {
 816       context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
 817       context_stack = (struct context_stack *)
 818         xmalloc (context_stack_size * sizeof (struct context_stack));
 819     }
 820   context_stack_depth = 0;
 821
 822   /* We shouldn't have any address map at this point.  */
 823   gdb_assert (! pending_addrmap);
 824
 825   /* Initialize the list of sub source files with one entry for this
 826      file (the top-level source file).  */
 827
 828   subfiles = NULL;
 829   current_subfile = NULL;
 830   start_subfile (name, dirname);
 831 }
 832
 833 /* Subroutine of end_symtab to simplify it.  Look for a subfile that
 834    matches the main source file's basename.  If there is only one, and
 835    if the main source file doesn't have any symbol or line number
 836    information, then copy this file's symtab and line_vector to the
 837    main source file's subfile and discard the other subfile.  This can
 838    happen because of a compiler bug or from the user playing games
 839    with #line or from things like a distributed build system that
 840    manipulates the debug info.  */
 841
 842 static void
 843 watch_main_source_file_lossage (void)
 844 {
 845   struct subfile *mainsub, *subfile;
 846
 847   /* Find the main source file.
 848      This loop could be eliminated if start_symtab saved it for us.  */
 849   mainsub = NULL;
 850   for (subfile = subfiles; subfile; subfile = subfile->next)
 851     {
 852       /* The main subfile is guaranteed to be the last one.  */
 853       if (subfile->next == NULL)
 854         mainsub = subfile;
 855     }
 856
 857   /* If the main source file doesn't have any line number or symbol
 858      info, look for an alias in another subfile.
 859
 860      We have to watch for mainsub == NULL here.  It's a quirk of
 861      end_symtab, it can return NULL so there may not be a main
 862      subfile.  */
 863
 864   if (mainsub
 865       && mainsub->line_vector == NULL
 866       && mainsub->symtab == NULL)
 867     {
 868       const char *mainbase = lbasename (mainsub->name);
 869       int nr_matches = 0;
 870       struct subfile *prevsub;
 871       struct subfile *mainsub_alias = NULL;
 872       struct subfile *prev_mainsub_alias = NULL;
 873
 874       prevsub = NULL;
 875       for (subfile = subfiles;
 876            /* Stop before we get to the last one.  */
 877            subfile->next;
 878            subfile = subfile->next)
 879         {
 880           if (filename_cmp (lbasename (subfile->name), mainbase) == 0)
 881             {
 882               ++nr_matches;
 883               mainsub_alias = subfile;
 884               prev_mainsub_alias = prevsub;
 885             }
 886           prevsub = subfile;
 887         }
 888
 889       if (nr_matches == 1)
 890         {
 891           gdb_assert (mainsub_alias != NULL && mainsub_alias != mainsub);
 892
 893           /* Found a match for the main source file.
 894              Copy its line_vector and symtab to the main subfile
 895              and then discard it.  */
 896
 897           mainsub->line_vector = mainsub_alias->line_vector;
 898           mainsub->line_vector_length = mainsub_alias->line_vector_length;
 899           mainsub->symtab = mainsub_alias->symtab;
 900
 901           if (prev_mainsub_alias == NULL)
 902             subfiles = mainsub_alias->next;
 903           else
 904             prev_mainsub_alias->next = mainsub_alias->next;
 905           xfree (mainsub_alias);
 906         }
 907     }
 908 }
 909
 910 /* Helper function for qsort.  Parameters are `struct block *' pointers,
 911    function sorts them in descending order by their BLOCK_START.  */
 912
 913 static int
 914 block_compar (const void *ap, const void *bp)
 915 {
 916   const struct block *a = *(const struct block **) ap;
 917   const struct block *b = *(const struct block **) bp;
 918
 919   return ((BLOCK_START (b) > BLOCK_START (a))
 920           - (BLOCK_START (b) < BLOCK_START (a)));
 921 }
 922
 923 /* Finish the symbol definitions for one main source file, close off
 924    all the lexical contexts for that file (creating struct block's for
 925    them), then make the struct symtab for that file and put it in the
 926    list of all such.
 927
 928    END_ADDR is the address of the end of the file's text.  SECTION is
 929    the section number (in objfile->section_offsets) of the blockvector
 930    and linetable.
 931
 932    Note that it is possible for end_symtab() to return NULL.  In
 933    particular, for the DWARF case at least, it will return NULL when
 934    it finds a compilation unit that has exactly one DIE, a
 935    TAG_compile_unit DIE.  This can happen when we link in an object
 936    file that was compiled from an empty source file.  Returning NULL
 937    is probably not the correct thing to do, because then gdb will
 938    never know about this empty file (FIXME).  */
 939
 940 struct symtab *
 941 end_symtab (CORE_ADDR end_addr, struct objfile *objfile, int section)
 942 {
 943   struct symtab *symtab = NULL;
 944   struct blockvector *blockvector;
 945   struct subfile *subfile;
 946   struct context_stack *cstk;
 947   struct subfile *nextsub;
 948
 949   /* Finish the lexical context of the last function in the file; pop
 950      the context stack.  */
 951
 952   if (context_stack_depth > 0)
 953     {
 954       cstk = pop_context ();
 955       /* Make a block for the local symbols within.  */
 956       finish_block (cstk->name, &local_symbols, cstk->old_blocks,
 957                     cstk->start_addr, end_addr, objfile);
 958
 959       if (context_stack_depth > 0)
 960         {
 961           /* This is said to happen with SCO.  The old coffread.c
 962              code simply emptied the context stack, so we do the
 963              same.  FIXME: Find out why it is happening.  This is not
 964              believed to happen in most cases (even for coffread.c);
 965              it used to be an abort().  */
 966           complaint (&symfile_complaints,
 967                      _("Context stack not empty in end_symtab"));
 968           context_stack_depth = 0;
 969         }
 970     }
 971
 972   /* Reordered executables may have out of order pending blocks; if
 973      OBJF_REORDERED is true, then sort the pending blocks.  */
 974   if ((objfile->flags & OBJF_REORDERED) && pending_blocks)
 975     {
 976       unsigned count = 0;
 977       struct pending_block *pb;
 978       struct block **barray, **bp;
 979       struct cleanup *back_to;
 980
 981       for (pb = pending_blocks; pb != NULL; pb = pb->next)
 982         count++;
 983
 984       barray = xmalloc (sizeof (*barray) * count);
 985       back_to = make_cleanup (xfree, barray);
 986
 987       bp = barray;
 988       for (pb = pending_blocks; pb != NULL; pb = pb->next)
 989         *bp++ = pb->block;
 990
 991       qsort (barray, count, sizeof (*barray), block_compar);
 992
 993       bp = barray;
 994       for (pb = pending_blocks; pb != NULL; pb = pb->next)
 995         pb->block = *bp++;
 996
 997       do_cleanups (back_to);
 998     }
 999
1000   /* Cleanup any undefined types that have been left hanging around
1001      (this needs to be done before the finish_blocks so that
1002      file_symbols is still good).
1003
1004      Both cleanup_undefined_stabs_types and finish_global_stabs are stabs
1005      specific, but harmless for other symbol readers, since on gdb
1006      startup or when finished reading stabs, the state is set so these
1007      are no-ops.  FIXME: Is this handled right in case of QUIT?  Can
1008      we make this cleaner?  */
1009
1010   cleanup_undefined_stabs_types (objfile);
1011   finish_global_stabs (objfile);
1012
1013   if (pending_blocks == NULL
1014       && file_symbols == NULL
1015       && global_symbols == NULL
1016       && have_line_numbers == 0
1017       && pending_macros == NULL)
1018     {
1019       /* Ignore symtabs that have no functions with real debugging
1020          info.  */
1021       blockvector = NULL;
1022     }
1023   else
1024     {
1025       /* Define the STATIC_BLOCK & GLOBAL_BLOCK, and build the
1026          blockvector.  */
1027       finish_block (0, &file_symbols, 0, last_source_start_addr,
1028                     end_addr, objfile);
1029       finish_block_internal (0, &global_symbols, 0, last_source_start_addr,
1030                              end_addr, objfile, 1);
1031       blockvector = make_blockvector (objfile);
1032     }
1033
1034   /* Read the line table if it has to be read separately.  */
1035   if (objfile->sf->sym_read_linetable != NULL)
1036     objfile->sf->sym_read_linetable ();
1037
1038   /* Handle the case where the debug info specifies a different path
1039      for the main source file.  It can cause us to lose track of its
1040      line number information.  */
1041   watch_main_source_file_lossage ();
1042
1043   /* Now create the symtab objects proper, one for each subfile.  */
1044   /* (The main file is the last one on the chain.)  */
1045
1046   for (subfile = subfiles; subfile; subfile = nextsub)
1047     {
1048       int linetablesize = 0;
1049       symtab = NULL;
1050
1051       /* If we have blocks of symbols, make a symtab.  Otherwise, just
1052          ignore this file and any line number info in it.  */
1053       if (blockvector)
1054         {
1055           if (subfile->line_vector)
1056             {
1057               linetablesize = sizeof (struct linetable) +
1058                 subfile->line_vector->nitems * sizeof (struct linetable_entry);
1059
1060               /* Like the pending blocks, the line table may be
1061                  scrambled in reordered executables.  Sort it if
1062                  OBJF_REORDERED is true.  */
1063               if (objfile->flags & OBJF_REORDERED)
1064                 qsort (subfile->line_vector->item,
1065                        subfile->line_vector->nitems,
1066                      sizeof (struct linetable_entry), compare_line_numbers);
1067             }
1068
1069           /* Now, allocate a symbol table.  */
1070           if (subfile->symtab == NULL)
1071             symtab = allocate_symtab (subfile->name, objfile);
1072           else
1073             symtab = subfile->symtab;
1074
1075           /* Fill in its components.  */
1076           symtab->blockvector = blockvector;
1077           symtab->macro_table = pending_macros;
1078           if (subfile->line_vector)
1079             {
1080               /* Reallocate the line table on the symbol obstack.  */
1081               symtab->linetable = (struct linetable *)
1082                 obstack_alloc (&objfile->objfile_obstack, linetablesize);
1083               memcpy (symtab->linetable, subfile->line_vector, linetablesize);
1084             }
1085           else
1086             {
1087               symtab->linetable = NULL;
1088             }
1089           symtab->block_line_section = section;
1090           if (subfile->dirname)
1091             {
1092               /* Reallocate the dirname on the symbol obstack.  */
1093               symtab->dirname = (char *)
1094                 obstack_alloc (&objfile->objfile_obstack,
1095                                strlen (subfile->dirname) + 1);
1096               strcpy (symtab->dirname, subfile->dirname);
1097             }
1098           else
1099             {
1100               symtab->dirname = NULL;
1101             }
1102
1103           /* Use whatever language we have been using for this
1104              subfile, not the one that was deduced in allocate_symtab
1105              from the filename.  We already did our own deducing when
1106              we created the subfile, and we may have altered our
1107              opinion of what language it is from things we found in
1108              the symbols.  */
1109           symtab->language = subfile->language;
1110
1111           /* Save the debug format string (if any) in the symtab.  */
1112           symtab->debugformat = subfile->debugformat;
1113
1114           /* Similarly for the producer.  */
1115           symtab->producer = subfile->producer;
1116
1117           /* All symtabs for the main file and the subfiles share a
1118              blockvector, so we need to clear primary for everything
1119              but the main file.  */
1120
1121           symtab->primary = 0;
1122         }
1123       else
1124         {
1125           if (subfile->symtab)
1126             {
1127               /* Since we are ignoring that subfile, we also need
1128                  to unlink the associated empty symtab that we created.
1129                  Otherwise, we can run into trouble because various parts
1130                  such as the block-vector are uninitialized whereas
1131                  the rest of the code assumes that they are.
1132
1133                  We can only unlink the symtab because it was allocated
1134                  on the objfile obstack.  */
1135               struct symtab *s;
1136
1137               if (objfile->symtabs == subfile->symtab)
1138                 objfile->symtabs = objfile->symtabs->next;
1139               else
1140                 ALL_OBJFILE_SYMTABS (objfile, s)
1141                   if (s->next == subfile->symtab)
1142                     {
1143                       s->next = s->next->next;
1144                       break;
1145                     }
1146               subfile->symtab = NULL;
1147             }
1148         }
1149       if (subfile->name != NULL)
1150         {
1151           xfree ((void *) subfile->name);
1152         }
1153       if (subfile->dirname != NULL)
1154         {
1155           xfree ((void *) subfile->dirname);
1156         }
1157       if (subfile->line_vector != NULL)
1158         {
1159           xfree ((void *) subfile->line_vector);
1160         }
1161
1162       nextsub = subfile->next;
1163       xfree ((void *) subfile);
1164     }
1165
1166   /* Set this for the main source file.  */
1167   if (symtab)
1168     {
1169       symtab->primary = 1;
1170
1171       if (symtab->blockvector)
1172         {
1173           struct block *b = BLOCKVECTOR_BLOCK (symtab->blockvector,
1174                                                GLOBAL_BLOCK);
1175
1176           set_block_symtab (b, symtab);
1177         }
1178     }
1179
1180   /* Default any symbols without a specified symtab to the primary
1181      symtab.  */
1182   if (blockvector)
1183     {
1184       int block_i;
1185
1186       for (block_i = 0; block_i < BLOCKVECTOR_NBLOCKS (blockvector); block_i++)
1187         {
1188           struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i);
1189           struct symbol *sym;
1190           struct dict_iterator iter;
1191
1192           /* Inlined functions may have symbols not in the global or
1193              static symbol lists.  */
1194           if (BLOCK_FUNCTION (block) != NULL)
1195             if (SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) == NULL)
1196               SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) = symtab;
1197
1198           /* Note that we only want to fix up symbols from the local
1199              blocks, not blocks coming from included symtabs.  That is why
1200              we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS.  */
1201           ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
1202             if (SYMBOL_SYMTAB (sym) == NULL)
1203               SYMBOL_SYMTAB (sym) = symtab;
1204         }
1205     }
1206
1207   last_source_file = NULL;
1208   current_subfile = NULL;
1209   pending_macros = NULL;
1210   if (pending_addrmap)
1211     {
1212       obstack_free (&pending_addrmap_obstack, NULL);
1213       pending_addrmap = NULL;
1214     }
1215
1216   return symtab;
1217 }
1218
1219 /* Push a context block.  Args are an identifying nesting level
1220    (checkable when you pop it), and the starting PC address of this
1221    context.  */
1222
1223 struct context_stack *
1224 push_context (int desc, CORE_ADDR valu)
1225 {
1226   struct context_stack *new;
1227
1228   if (context_stack_depth == context_stack_size)
1229     {
1230       context_stack_size *= 2;
1231       context_stack = (struct context_stack *)
1232         xrealloc ((char *) context_stack,
1233                   (context_stack_size * sizeof (struct context_stack)));
1234     }
1235
1236   new = &context_stack[context_stack_depth++];
1237   new->depth = desc;
1238   new->locals = local_symbols;
1239   new->params = param_symbols;
1240   new->old_blocks = pending_blocks;
1241   new->start_addr = valu;
1242   new->using_directives = using_directives;
1243   new->name = NULL;
1244
1245   local_symbols = NULL;
1246   param_symbols = NULL;
1247   using_directives = NULL;
1248
1249   return new;
1250 }
1251
1252 /* Pop a context block.  Returns the address of the context block just
1253    popped.  */
1254
1255 struct context_stack *
1256 pop_context (void)
1257 {
1258   gdb_assert (context_stack_depth > 0);
1259   return (&context_stack[--context_stack_depth]);
1260 }
1261
1262 \f
1263
1264 /* Compute a small integer hash code for the given name.  */
1265
1266 int
1267 hashname (const char *name)
1268 {
1269     return (hash(name,strlen(name)) % HASHSIZE);
1270 }
1271 \f
1272
1273 void
1274 record_debugformat (const char *format)
1275 {
1276   current_subfile->debugformat = format;
1277 }
1278
1279 void
1280 record_producer (const char *producer)
1281 {
1282   current_subfile->producer = producer;
1283 }
1284
1285 /* Merge the first symbol list SRCLIST into the second symbol list
1286    TARGETLIST by repeated calls to add_symbol_to_list().  This
1287    procedure "frees" each link of SRCLIST by adding it to the
1288    free_pendings list.  Caller must set SRCLIST to a null list after
1289    calling this function.
1290
1291    Void return.  */
1292
1293 void
1294 merge_symbol_lists (struct pending **srclist, struct pending **targetlist)
1295 {
1296   int i;
1297
1298   if (!srclist || !*srclist)
1299     return;
1300
1301   /* Merge in elements from current link.  */
1302   for (i = 0; i < (*srclist)->nsyms; i++)
1303     add_symbol_to_list ((*srclist)->symbol[i], targetlist);
1304
1305   /* Recurse on next.  */
1306   merge_symbol_lists (&(*srclist)->next, targetlist);
1307
1308   /* "Free" the current link.  */
1309   (*srclist)->next = free_pendings;
1310   free_pendings = (*srclist);
1311 }
1312 \f
1313 /* Initialize anything that needs initializing when starting to read a
1314    fresh piece of a symbol file, e.g. reading in the stuff
1315    corresponding to a psymtab.  */
1316
1317 void
1318 buildsym_init (void)
1319 {
1320   free_pendings = NULL;
1321   file_symbols = NULL;
1322   global_symbols = NULL;
1323   pending_blocks = NULL;
1324   pending_macros = NULL;
1325
1326   /* We shouldn't have any address map at this point.  */
1327   gdb_assert (! pending_addrmap);
1328   pending_addrmap_interesting = 0;
1329 }
1330
1331 /* Initialize anything that needs initializing when a completely new
1332    symbol file is specified (not just adding some symbols from another
1333    file, e.g. a shared library).  */
1334
1335 void
1336 buildsym_new_init (void)
1337 {
1338   buildsym_init ();
1339 }