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