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