gdb/buildsym.c

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