1 /* Support routines for building symbol tables in GDB's internal format.
2 Copyright (C) 1986-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
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.
23 Routines to support specific debugging information formats (stabs,
24 DWARF, etc) belong somewhere else.
26 The basic way this module is used is as follows:
29 scoped_free_pendings free_pending;
30 cust = start_symtab (...);
31 ... read debug info ...
32 cust = end_symtab (...);
34 The compunit symtab pointer ("cust") is returned from both start_symtab
35 and end_symtab to simplify the debug info readers.
37 There are minor variations on this, e.g., dwarf2read.c splits end_symtab
38 into two calls: end_symtab_get_static_block, end_symtab_from_static_block,
39 but all debug info readers follow this basic flow.
41 Reading DWARF Type Units is another variation:
44 scoped_free_pendings free_pending;
45 cust = start_symtab (...);
46 ... read debug info ...
47 cust = end_expandable_symtab (...);
49 And then reading subsequent Type Units within the containing "Comp Unit"
50 will use a second flow:
53 scoped_free_pendings free_pending;
54 cust = restart_symtab (...);
55 ... read debug info ...
56 cust = augment_type_symtab (...);
58 dbxread.c and xcoffread.c use another variation:
61 scoped_free_pendings free_pending;
62 cust = start_symtab (...);
63 ... read debug info ...
64 cust = end_symtab (...);
65 ... start_symtab + read + end_symtab repeated ...
70 #include "gdb_obstack.h"
75 #include "complaints.h"
76 #include "expression.h" /* For "enum exp_opcode" used by... */
78 #include "filenames.h" /* For DOSish file names. */
80 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
82 #include "cp-support.h"
83 #include "dictionary.h"
87 /* Ask buildsym.h to define the vars it normally declares `extern'. */
90 #include "buildsym.h" /* Our own declarations. */
93 /* For cleanup_undefined_stabs_types and finish_global_stabs (somewhat
94 questionable--see comment where we call them). */
96 #include "stabsread.h"
98 /* Buildsym's counterpart to struct compunit_symtab.
99 TODO(dje): Move all related global state into here. */
101 struct buildsym_compunit
103 /* The objfile we're reading debug info from. */
104 struct objfile
*objfile
;
106 /* List of subfiles (source files).
107 Files are added to the front of the list.
108 This is important mostly for the language determination hacks we use,
109 which iterate over previously added files. */
110 struct subfile
*subfiles
;
112 /* The subfile of the main source file. */
113 struct subfile
*main_subfile
;
115 /* E.g., DW_AT_comp_dir if DWARF. Space for this is malloc'd. */
118 /* Space for this is not malloc'd, and is assumed to have at least
119 the same lifetime as objfile. */
120 const char *producer
;
122 /* Space for this is not malloc'd, and is assumed to have at least
123 the same lifetime as objfile. */
124 const char *debugformat
;
126 /* The compunit we are building. */
127 struct compunit_symtab
*compunit_symtab
;
130 /* The work-in-progress of the compunit we are building.
131 This is created first, before any subfiles by start_symtab. */
133 static struct buildsym_compunit
*buildsym_compunit
;
135 /* List of free `struct pending' structures for reuse. */
137 static struct pending
*free_pendings
;
139 /* Non-zero if symtab has line number info. This prevents an
140 otherwise empty symtab from being tossed. */
142 static int have_line_numbers
;
144 /* The mutable address map for the compilation unit whose symbols
145 we're currently reading. The symtabs' shared blockvector will
146 point to a fixed copy of this. */
147 static struct addrmap
*pending_addrmap
;
149 /* The obstack on which we allocate pending_addrmap.
150 If pending_addrmap is NULL, this is uninitialized; otherwise, it is
151 initialized (and holds pending_addrmap). */
152 static struct obstack pending_addrmap_obstack
;
154 /* Non-zero if we recorded any ranges in the addrmap that are
155 different from those in the blockvector already. We set this to
156 zero when we start processing a symfile, and if it's still zero at
157 the end, then we just toss the addrmap. */
158 static int pending_addrmap_interesting
;
160 /* An obstack used for allocating pending blocks. */
162 static struct obstack pending_block_obstack
;
164 /* List of blocks already made (lexical contexts already closed).
165 This is used at the end to make the blockvector. */
169 struct pending_block
*next
;
173 /* Pointer to the head of a linked list of symbol blocks which have
174 already been finalized (lexical contexts already closed) and which
175 are just waiting to be built into a blockvector when finalizing the
176 associated symtab. */
178 static struct pending_block
*pending_blocks
;
182 struct subfile_stack
*next
;
186 static struct subfile_stack
*subfile_stack
;
188 /* The macro table for the compilation unit whose symbols we're
189 currently reading. */
190 static struct macro_table
*pending_macros
;
192 static void free_buildsym_compunit (void);
194 static int compare_line_numbers (const void *ln1p
, const void *ln2p
);
196 static void record_pending_block (struct objfile
*objfile
,
198 struct pending_block
*opblock
);
200 /* Initial sizes of data structures. These are realloc'd larger if
201 needed, and realloc'd down to the size actually used, when
204 #define INITIAL_CONTEXT_STACK_SIZE 10
205 #define INITIAL_LINE_VECTOR_LENGTH 1000
208 /* Maintain the lists of symbols and blocks. */
210 /* Add a symbol to one of the lists of symbols. */
213 add_symbol_to_list (struct symbol
*symbol
, struct pending
**listhead
)
215 struct pending
*link
;
217 /* If this is an alias for another symbol, don't add it. */
218 if (symbol
->ginfo
.name
&& symbol
->ginfo
.name
[0] == '#')
221 /* We keep PENDINGSIZE symbols in each link of the list. If we
222 don't have a link with room in it, add a new link. */
223 if (*listhead
== NULL
|| (*listhead
)->nsyms
== PENDINGSIZE
)
227 link
= free_pendings
;
228 free_pendings
= link
->next
;
232 link
= XNEW (struct pending
);
235 link
->next
= *listhead
;
240 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
243 /* Find a symbol named NAME on a LIST. NAME need not be
244 '\0'-terminated; LENGTH is the length of the name. */
247 find_symbol_in_list (struct pending
*list
, char *name
, int length
)
254 for (j
= list
->nsyms
; --j
>= 0;)
256 pp
= SYMBOL_LINKAGE_NAME (list
->symbol
[j
]);
257 if (*pp
== *name
&& strncmp (pp
, name
, length
) == 0
258 && pp
[length
] == '\0')
260 return (list
->symbol
[j
]);
268 /* At end of reading syms, or in case of quit, ensure everything
269 associated with building symtabs is freed.
271 N.B. This is *not* intended to be used when building psymtabs. Some debug
272 info readers call this anyway, which is harmless if confusing. */
274 scoped_free_pendings::~scoped_free_pendings ()
276 struct pending
*next
, *next1
;
278 for (next
= free_pendings
; next
; next
= next1
)
281 xfree ((void *) next
);
283 free_pendings
= NULL
;
285 free_pending_blocks ();
287 for (next
= file_symbols
; next
!= NULL
; next
= next1
)
290 xfree ((void *) next
);
294 for (next
= global_symbols
; next
!= NULL
; next
= next1
)
297 xfree ((void *) next
);
299 global_symbols
= NULL
;
302 free_macro_table (pending_macros
);
303 pending_macros
= NULL
;
306 obstack_free (&pending_addrmap_obstack
, NULL
);
307 pending_addrmap
= NULL
;
309 free_buildsym_compunit ();
312 /* This function is called to discard any pending blocks. */
315 free_pending_blocks (void)
317 if (pending_blocks
!= NULL
)
319 obstack_free (&pending_block_obstack
, NULL
);
320 pending_blocks
= NULL
;
324 /* Take one of the lists of symbols and make a block from it. Keep
325 the order the symbols have in the list (reversed from the input
326 file). Put the block on the list of pending blocks. */
328 static struct block
*
329 finish_block_internal (struct symbol
*symbol
,
330 struct pending
**listhead
,
331 struct pending_block
*old_blocks
,
332 const struct dynamic_prop
*static_link
,
333 CORE_ADDR start
, CORE_ADDR end
,
334 int is_global
, int expandable
)
336 struct objfile
*objfile
= buildsym_compunit
->objfile
;
337 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
338 struct pending
*next
, *next1
;
340 struct pending_block
*pblock
;
341 struct pending_block
*opblock
;
344 ? allocate_global_block (&objfile
->objfile_obstack
)
345 : allocate_block (&objfile
->objfile_obstack
));
349 BLOCK_DICT (block
) = dict_create_linear (&objfile
->objfile_obstack
,
356 BLOCK_DICT (block
) = dict_create_hashed_expandable ();
357 dict_add_pending (BLOCK_DICT (block
), *listhead
);
362 dict_create_hashed (&objfile
->objfile_obstack
, *listhead
);
366 BLOCK_START (block
) = start
;
367 BLOCK_END (block
) = end
;
369 /* Put the block in as the value of the symbol that names it. */
373 struct type
*ftype
= SYMBOL_TYPE (symbol
);
374 struct dict_iterator iter
;
375 SYMBOL_BLOCK_VALUE (symbol
) = block
;
376 BLOCK_FUNCTION (block
) = symbol
;
378 if (TYPE_NFIELDS (ftype
) <= 0)
380 /* No parameter type information is recorded with the
381 function's type. Set that from the type of the
382 parameter symbols. */
383 int nparams
= 0, iparams
;
386 /* Here we want to directly access the dictionary, because
387 we haven't fully initialized the block yet. */
388 ALL_DICT_SYMBOLS (BLOCK_DICT (block
), iter
, sym
)
390 if (SYMBOL_IS_ARGUMENT (sym
))
395 TYPE_NFIELDS (ftype
) = nparams
;
396 TYPE_FIELDS (ftype
) = (struct field
*)
397 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
400 /* Here we want to directly access the dictionary, because
401 we haven't fully initialized the block yet. */
402 ALL_DICT_SYMBOLS (BLOCK_DICT (block
), iter
, sym
)
404 if (iparams
== nparams
)
407 if (SYMBOL_IS_ARGUMENT (sym
))
409 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
410 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
419 BLOCK_FUNCTION (block
) = NULL
;
422 if (static_link
!= NULL
)
423 objfile_register_static_link (objfile
, block
, static_link
);
425 /* Now "free" the links of the list, and empty the list. */
427 for (next
= *listhead
; next
; next
= next1
)
430 next
->next
= free_pendings
;
431 free_pendings
= next
;
435 /* Check to be sure that the blocks have an end address that is
436 greater than starting address. */
438 if (BLOCK_END (block
) < BLOCK_START (block
))
442 complaint (&symfile_complaints
,
443 _("block end address less than block "
444 "start address in %s (patched it)"),
445 SYMBOL_PRINT_NAME (symbol
));
449 complaint (&symfile_complaints
,
450 _("block end address %s less than block "
451 "start address %s (patched it)"),
452 paddress (gdbarch
, BLOCK_END (block
)),
453 paddress (gdbarch
, BLOCK_START (block
)));
455 /* Better than nothing. */
456 BLOCK_END (block
) = BLOCK_START (block
);
459 /* Install this block as the superblock of all blocks made since the
460 start of this scope that don't have superblocks yet. */
463 for (pblock
= pending_blocks
;
464 pblock
&& pblock
!= old_blocks
;
465 pblock
= pblock
->next
)
467 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
469 /* Check to be sure the blocks are nested as we receive
470 them. If the compiler/assembler/linker work, this just
471 burns a small amount of time.
473 Skip blocks which correspond to a function; they're not
474 physically nested inside this other blocks, only
476 if (BLOCK_FUNCTION (pblock
->block
) == NULL
477 && (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
478 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)))
482 complaint (&symfile_complaints
,
483 _("inner block not inside outer block in %s"),
484 SYMBOL_PRINT_NAME (symbol
));
488 complaint (&symfile_complaints
,
489 _("inner block (%s-%s) not "
490 "inside outer block (%s-%s)"),
491 paddress (gdbarch
, BLOCK_START (pblock
->block
)),
492 paddress (gdbarch
, BLOCK_END (pblock
->block
)),
493 paddress (gdbarch
, BLOCK_START (block
)),
494 paddress (gdbarch
, BLOCK_END (block
)));
496 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
))
497 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
498 if (BLOCK_END (pblock
->block
) > BLOCK_END (block
))
499 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
501 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
506 block_set_using (block
,
508 ? global_using_directives
509 : local_using_directives
),
510 &objfile
->objfile_obstack
);
512 global_using_directives
= NULL
;
514 local_using_directives
= NULL
;
516 record_pending_block (objfile
, block
, opblock
);
522 finish_block (struct symbol
*symbol
,
523 struct pending
**listhead
,
524 struct pending_block
*old_blocks
,
525 const struct dynamic_prop
*static_link
,
526 CORE_ADDR start
, CORE_ADDR end
)
528 return finish_block_internal (symbol
, listhead
, old_blocks
, static_link
,
532 /* Record BLOCK on the list of all blocks in the file. Put it after
533 OPBLOCK, or at the beginning if opblock is NULL. This puts the
534 block in the list after all its subblocks.
536 Allocate the pending block struct in the objfile_obstack to save
537 time. This wastes a little space. FIXME: Is it worth it? */
540 record_pending_block (struct objfile
*objfile
, struct block
*block
,
541 struct pending_block
*opblock
)
543 struct pending_block
*pblock
;
545 if (pending_blocks
== NULL
)
546 obstack_init (&pending_block_obstack
);
548 pblock
= XOBNEW (&pending_block_obstack
, struct pending_block
);
549 pblock
->block
= block
;
552 pblock
->next
= opblock
->next
;
553 opblock
->next
= pblock
;
557 pblock
->next
= pending_blocks
;
558 pending_blocks
= pblock
;
563 /* Record that the range of addresses from START to END_INCLUSIVE
564 (inclusive, like it says) belongs to BLOCK. BLOCK's start and end
565 addresses must be set already. You must apply this function to all
566 BLOCK's children before applying it to BLOCK.
568 If a call to this function complicates the picture beyond that
569 already provided by BLOCK_START and BLOCK_END, then we create an
570 address map for the block. */
572 record_block_range (struct block
*block
,
573 CORE_ADDR start
, CORE_ADDR end_inclusive
)
575 /* If this is any different from the range recorded in the block's
576 own BLOCK_START and BLOCK_END, then note that the address map has
577 become interesting. Note that even if this block doesn't have
578 any "interesting" ranges, some later block might, so we still
579 need to record this block in the addrmap. */
580 if (start
!= BLOCK_START (block
)
581 || end_inclusive
+ 1 != BLOCK_END (block
))
582 pending_addrmap_interesting
= 1;
584 if (! pending_addrmap
)
586 obstack_init (&pending_addrmap_obstack
);
587 pending_addrmap
= addrmap_create_mutable (&pending_addrmap_obstack
);
590 addrmap_set_empty (pending_addrmap
, start
, end_inclusive
, block
);
593 static struct blockvector
*
594 make_blockvector (void)
596 struct objfile
*objfile
= buildsym_compunit
->objfile
;
597 struct pending_block
*next
;
598 struct blockvector
*blockvector
;
601 /* Count the length of the list of blocks. */
603 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++)
607 blockvector
= (struct blockvector
*)
608 obstack_alloc (&objfile
->objfile_obstack
,
609 (sizeof (struct blockvector
)
610 + (i
- 1) * sizeof (struct block
*)));
612 /* Copy the blocks into the blockvector. This is done in reverse
613 order, which happens to put the blocks into the proper order
614 (ascending starting address). finish_block has hair to insert
615 each block into the list after its subblocks in order to make
616 sure this is true. */
618 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
619 for (next
= pending_blocks
; next
; next
= next
->next
)
621 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
624 free_pending_blocks ();
626 /* If we needed an address map for this symtab, record it in the
628 if (pending_addrmap
&& pending_addrmap_interesting
)
629 BLOCKVECTOR_MAP (blockvector
)
630 = addrmap_create_fixed (pending_addrmap
, &objfile
->objfile_obstack
);
632 BLOCKVECTOR_MAP (blockvector
) = 0;
634 /* Some compilers output blocks in the wrong order, but we depend on
635 their being in the right order so we can binary search. Check the
636 order and moan about it.
637 Note: Remember that the first two blocks are the global and static
638 blocks. We could special case that fact and begin checking at block 2.
639 To avoid making that assumption we do not. */
640 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
642 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
644 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
- 1))
645 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
)))
648 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
));
650 complaint (&symfile_complaints
, _("block at %s out of order"),
651 hex_string ((LONGEST
) start
));
656 return (blockvector
);
659 /* Start recording information about source code that came from an
660 included (or otherwise merged-in) source file with a different
661 name. NAME is the name of the file (cannot be NULL). */
664 start_subfile (const char *name
)
666 const char *subfile_dirname
;
667 struct subfile
*subfile
;
669 gdb_assert (buildsym_compunit
!= NULL
);
671 subfile_dirname
= buildsym_compunit
->comp_dir
;
673 /* See if this subfile is already registered. */
675 for (subfile
= buildsym_compunit
->subfiles
; subfile
; subfile
= subfile
->next
)
679 /* If NAME is an absolute path, and this subfile is not, then
680 attempt to create an absolute path to compare. */
681 if (IS_ABSOLUTE_PATH (name
)
682 && !IS_ABSOLUTE_PATH (subfile
->name
)
683 && subfile_dirname
!= NULL
)
684 subfile_name
= concat (subfile_dirname
, SLASH_STRING
,
685 subfile
->name
, (char *) NULL
);
687 subfile_name
= subfile
->name
;
689 if (FILENAME_CMP (subfile_name
, name
) == 0)
691 current_subfile
= subfile
;
692 if (subfile_name
!= subfile
->name
)
693 xfree (subfile_name
);
696 if (subfile_name
!= subfile
->name
)
697 xfree (subfile_name
);
700 /* This subfile is not known. Add an entry for it. */
702 subfile
= XNEW (struct subfile
);
703 memset (subfile
, 0, sizeof (struct subfile
));
704 subfile
->buildsym_compunit
= buildsym_compunit
;
706 subfile
->next
= buildsym_compunit
->subfiles
;
707 buildsym_compunit
->subfiles
= subfile
;
709 current_subfile
= subfile
;
711 subfile
->name
= xstrdup (name
);
713 /* Initialize line-number recording for this subfile. */
714 subfile
->line_vector
= NULL
;
716 /* Default the source language to whatever can be deduced from the
717 filename. If nothing can be deduced (such as for a C/C++ include
718 file with a ".h" extension), then inherit whatever language the
719 previous subfile had. This kludgery is necessary because there
720 is no standard way in some object formats to record the source
721 language. Also, when symtabs are allocated we try to deduce a
722 language then as well, but it is too late for us to use that
723 information while reading symbols, since symtabs aren't allocated
724 until after all the symbols have been processed for a given
727 subfile
->language
= deduce_language_from_filename (subfile
->name
);
728 if (subfile
->language
== language_unknown
729 && subfile
->next
!= NULL
)
731 subfile
->language
= subfile
->next
->language
;
734 /* If the filename of this subfile ends in .C, then change the
735 language of any pending subfiles from C to C++. We also accept
736 any other C++ suffixes accepted by deduce_language_from_filename. */
737 /* Likewise for f2c. */
742 enum language sublang
= deduce_language_from_filename (subfile
->name
);
744 if (sublang
== language_cplus
|| sublang
== language_fortran
)
745 for (s
= buildsym_compunit
->subfiles
; s
!= NULL
; s
= s
->next
)
746 if (s
->language
== language_c
)
747 s
->language
= sublang
;
750 /* And patch up this file if necessary. */
751 if (subfile
->language
== language_c
752 && subfile
->next
!= NULL
753 && (subfile
->next
->language
== language_cplus
754 || subfile
->next
->language
== language_fortran
))
756 subfile
->language
= subfile
->next
->language
;
760 /* Start recording information about a primary source file (IOW, not an
761 included source file).
762 COMP_DIR is the directory in which the compilation unit was compiled
763 (or NULL if not known). */
765 static struct buildsym_compunit
*
766 start_buildsym_compunit (struct objfile
*objfile
, const char *comp_dir
)
768 struct buildsym_compunit
*bscu
;
770 bscu
= XNEW (struct buildsym_compunit
);
771 memset (bscu
, 0, sizeof (struct buildsym_compunit
));
773 bscu
->objfile
= objfile
;
774 bscu
->comp_dir
= (comp_dir
== NULL
) ? NULL
: xstrdup (comp_dir
);
776 /* Initialize the debug format string to NULL. We may supply it
777 later via a call to record_debugformat. */
778 bscu
->debugformat
= NULL
;
780 /* Similarly for the producer. */
781 bscu
->producer
= NULL
;
786 /* Delete the buildsym compunit. */
789 free_buildsym_compunit (void)
791 struct subfile
*subfile
, *nextsub
;
793 if (buildsym_compunit
== NULL
)
795 for (subfile
= buildsym_compunit
->subfiles
;
799 nextsub
= subfile
->next
;
800 xfree (subfile
->name
);
801 xfree (subfile
->line_vector
);
804 xfree (buildsym_compunit
->comp_dir
);
805 xfree (buildsym_compunit
);
806 buildsym_compunit
= NULL
;
807 current_subfile
= NULL
;
810 /* For stabs readers, the first N_SO symbol is assumed to be the
811 source file name, and the subfile struct is initialized using that
812 assumption. If another N_SO symbol is later seen, immediately
813 following the first one, then the first one is assumed to be the
814 directory name and the second one is really the source file name.
816 So we have to patch up the subfile struct by moving the old name
817 value to dirname and remembering the new name. Some sanity
818 checking is performed to ensure that the state of the subfile
819 struct is reasonable and that the old name we are assuming to be a
820 directory name actually is (by checking for a trailing '/'). */
823 patch_subfile_names (struct subfile
*subfile
, const char *name
)
826 && buildsym_compunit
->comp_dir
== NULL
827 && subfile
->name
!= NULL
828 && IS_DIR_SEPARATOR (subfile
->name
[strlen (subfile
->name
) - 1]))
830 buildsym_compunit
->comp_dir
= subfile
->name
;
831 subfile
->name
= xstrdup (name
);
832 set_last_source_file (name
);
834 /* Default the source language to whatever can be deduced from
835 the filename. If nothing can be deduced (such as for a C/C++
836 include file with a ".h" extension), then inherit whatever
837 language the previous subfile had. This kludgery is
838 necessary because there is no standard way in some object
839 formats to record the source language. Also, when symtabs
840 are allocated we try to deduce a language then as well, but
841 it is too late for us to use that information while reading
842 symbols, since symtabs aren't allocated until after all the
843 symbols have been processed for a given source file. */
845 subfile
->language
= deduce_language_from_filename (subfile
->name
);
846 if (subfile
->language
== language_unknown
847 && subfile
->next
!= NULL
)
849 subfile
->language
= subfile
->next
->language
;
854 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for
855 switching source files (different subfiles, as we call them) within
856 one object file, but using a stack rather than in an arbitrary
862 struct subfile_stack
*tem
= XNEW (struct subfile_stack
);
864 tem
->next
= subfile_stack
;
866 if (current_subfile
== NULL
|| current_subfile
->name
== NULL
)
868 internal_error (__FILE__
, __LINE__
,
869 _("failed internal consistency check"));
871 tem
->name
= current_subfile
->name
;
878 struct subfile_stack
*link
= subfile_stack
;
882 internal_error (__FILE__
, __LINE__
,
883 _("failed internal consistency check"));
886 subfile_stack
= link
->next
;
887 xfree ((void *) link
);
891 /* Add a linetable entry for line number LINE and address PC to the
892 line vector for SUBFILE. */
895 record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
897 struct linetable_entry
*e
;
899 /* Ignore the dummy line number in libg.o */
905 /* Make sure line vector exists and is big enough. */
906 if (!subfile
->line_vector
)
908 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
909 subfile
->line_vector
= (struct linetable
*)
910 xmalloc (sizeof (struct linetable
)
911 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
912 subfile
->line_vector
->nitems
= 0;
913 have_line_numbers
= 1;
916 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
918 subfile
->line_vector_length
*= 2;
919 subfile
->line_vector
= (struct linetable
*)
920 xrealloc ((char *) subfile
->line_vector
,
921 (sizeof (struct linetable
)
922 + (subfile
->line_vector_length
923 * sizeof (struct linetable_entry
))));
926 /* Normally, we treat lines as unsorted. But the end of sequence
927 marker is special. We sort line markers at the same PC by line
928 number, so end of sequence markers (which have line == 0) appear
929 first. This is right if the marker ends the previous function,
930 and there is no padding before the next function. But it is
931 wrong if the previous line was empty and we are now marking a
932 switch to a different subfile. We must leave the end of sequence
933 marker at the end of this group of lines, not sort the empty line
934 to after the marker. The easiest way to accomplish this is to
935 delete any empty lines from our table, if they are followed by
936 end of sequence markers. All we lose is the ability to set
937 breakpoints at some lines which contain no instructions
939 if (line
== 0 && subfile
->line_vector
->nitems
> 0)
941 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
- 1;
942 while (subfile
->line_vector
->nitems
> 0 && e
->pc
== pc
)
945 subfile
->line_vector
->nitems
--;
949 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
954 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
957 compare_line_numbers (const void *ln1p
, const void *ln2p
)
959 struct linetable_entry
*ln1
= (struct linetable_entry
*) ln1p
;
960 struct linetable_entry
*ln2
= (struct linetable_entry
*) ln2p
;
962 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
963 Please keep it that way. */
964 if (ln1
->pc
< ln2
->pc
)
967 if (ln1
->pc
> ln2
->pc
)
970 /* If pc equal, sort by line. I'm not sure whether this is optimum
971 behavior (see comment at struct linetable in symtab.h). */
972 return ln1
->line
- ln2
->line
;
975 /* See buildsym.h. */
977 struct compunit_symtab
*
978 buildsym_compunit_symtab (void)
980 gdb_assert (buildsym_compunit
!= NULL
);
982 return buildsym_compunit
->compunit_symtab
;
985 /* See buildsym.h. */
988 get_macro_table (void)
990 struct objfile
*objfile
;
992 gdb_assert (buildsym_compunit
!= NULL
);
994 objfile
= buildsym_compunit
->objfile
;
996 if (! pending_macros
)
998 pending_macros
= new_macro_table (&objfile
->per_bfd
->storage_obstack
,
999 objfile
->per_bfd
->macro_cache
,
1000 buildsym_compunit
->compunit_symtab
);
1003 return pending_macros
;
1006 /* Init state to prepare for building a symtab.
1007 Note: This can't be done in buildsym_init because dbxread.c and xcoffread.c
1008 can call start_symtab+end_symtab multiple times after one call to
1012 prepare_for_building (const char *name
, CORE_ADDR start_addr
)
1014 set_last_source_file (name
);
1015 last_source_start_addr
= start_addr
;
1017 local_symbols
= NULL
;
1018 local_using_directives
= NULL
;
1019 within_function
= 0;
1020 have_line_numbers
= 0;
1022 context_stack_depth
= 0;
1024 /* These should have been reset either by successful completion of building
1025 a symtab, or by the scoped_free_pendings destructor. */
1026 gdb_assert (file_symbols
== NULL
);
1027 gdb_assert (global_symbols
== NULL
);
1028 gdb_assert (global_using_directives
== NULL
);
1029 gdb_assert (pending_macros
== NULL
);
1030 gdb_assert (pending_addrmap
== NULL
);
1031 gdb_assert (current_subfile
== NULL
);
1034 /* Start a new symtab for a new source file in OBJFILE. Called, for example,
1035 when a stabs symbol of type N_SO is seen, or when a DWARF
1036 TAG_compile_unit DIE is seen. It indicates the start of data for
1037 one original source file.
1039 NAME is the name of the file (cannot be NULL). COMP_DIR is the directory in
1040 which the file was compiled (or NULL if not known). START_ADDR is the
1041 lowest address of objects in the file (or 0 if not known). */
1043 struct compunit_symtab
*
1044 start_symtab (struct objfile
*objfile
, const char *name
, const char *comp_dir
,
1045 CORE_ADDR start_addr
)
1047 prepare_for_building (name
, start_addr
);
1049 buildsym_compunit
= start_buildsym_compunit (objfile
, comp_dir
);
1051 /* Allocate the compunit symtab now. The caller needs it to allocate
1052 non-primary symtabs. It is also needed by get_macro_table. */
1053 buildsym_compunit
->compunit_symtab
= allocate_compunit_symtab (objfile
,
1056 /* Build the subfile for NAME (the main source file) so that we can record
1057 a pointer to it for later.
1058 IMPORTANT: Do not allocate a struct symtab for NAME here.
1059 It can happen that the debug info provides a different path to NAME than
1060 DIRNAME,NAME. We cope with this in watch_main_source_file_lossage but
1061 that only works if the main_subfile doesn't have a symtab yet. */
1062 start_subfile (name
);
1063 /* Save this so that we don't have to go looking for it at the end
1064 of the subfiles list. */
1065 buildsym_compunit
->main_subfile
= current_subfile
;
1067 return buildsym_compunit
->compunit_symtab
;
1070 /* Restart compilation for a symtab.
1071 CUST is the result of end_expandable_symtab.
1072 NAME, START_ADDR are the source file we are resuming with.
1074 This is used when a symtab is built from multiple sources.
1075 The symtab is first built with start_symtab/end_expandable_symtab
1076 and then for each additional piece call restart_symtab/augment_*_symtab.
1077 Note: At the moment there is only augment_type_symtab. */
1080 restart_symtab (struct compunit_symtab
*cust
,
1081 const char *name
, CORE_ADDR start_addr
)
1083 prepare_for_building (name
, start_addr
);
1085 buildsym_compunit
= start_buildsym_compunit (COMPUNIT_OBJFILE (cust
),
1086 COMPUNIT_DIRNAME (cust
));
1087 buildsym_compunit
->compunit_symtab
= cust
;
1090 /* Subroutine of end_symtab to simplify it. Look for a subfile that
1091 matches the main source file's basename. If there is only one, and
1092 if the main source file doesn't have any symbol or line number
1093 information, then copy this file's symtab and line_vector to the
1094 main source file's subfile and discard the other subfile. This can
1095 happen because of a compiler bug or from the user playing games
1096 with #line or from things like a distributed build system that
1097 manipulates the debug info. This can also happen from an innocent
1098 symlink in the paths, we don't canonicalize paths here. */
1101 watch_main_source_file_lossage (void)
1103 struct subfile
*mainsub
, *subfile
;
1105 /* We have to watch for buildsym_compunit == NULL here. It's a quirk of
1106 end_symtab, it can return NULL so there may not be a main subfile. */
1107 if (buildsym_compunit
== NULL
)
1110 /* Get the main source file. */
1111 mainsub
= buildsym_compunit
->main_subfile
;
1113 /* If the main source file doesn't have any line number or symbol
1114 info, look for an alias in another subfile. */
1116 if (mainsub
->line_vector
== NULL
1117 && mainsub
->symtab
== NULL
)
1119 const char *mainbase
= lbasename (mainsub
->name
);
1121 struct subfile
*prevsub
;
1122 struct subfile
*mainsub_alias
= NULL
;
1123 struct subfile
*prev_mainsub_alias
= NULL
;
1126 for (subfile
= buildsym_compunit
->subfiles
;
1128 subfile
= subfile
->next
)
1130 if (subfile
== mainsub
)
1132 if (filename_cmp (lbasename (subfile
->name
), mainbase
) == 0)
1135 mainsub_alias
= subfile
;
1136 prev_mainsub_alias
= prevsub
;
1141 if (nr_matches
== 1)
1143 gdb_assert (mainsub_alias
!= NULL
&& mainsub_alias
!= mainsub
);
1145 /* Found a match for the main source file.
1146 Copy its line_vector and symtab to the main subfile
1147 and then discard it. */
1149 mainsub
->line_vector
= mainsub_alias
->line_vector
;
1150 mainsub
->line_vector_length
= mainsub_alias
->line_vector_length
;
1151 mainsub
->symtab
= mainsub_alias
->symtab
;
1153 if (prev_mainsub_alias
== NULL
)
1154 buildsym_compunit
->subfiles
= mainsub_alias
->next
;
1156 prev_mainsub_alias
->next
= mainsub_alias
->next
;
1157 xfree (mainsub_alias
->name
);
1158 xfree (mainsub_alias
);
1163 /* Reset state after a successful building of a symtab.
1164 This exists because dbxread.c and xcoffread.c can call
1165 start_symtab+end_symtab multiple times after one call to buildsym_init,
1166 and before the scoped_free_pendings destructor is called.
1167 We keep the free_pendings list around for dbx/xcoff sake. */
1170 reset_symtab_globals (void)
1172 set_last_source_file (NULL
);
1174 local_symbols
= NULL
;
1175 local_using_directives
= NULL
;
1176 file_symbols
= NULL
;
1177 global_symbols
= NULL
;
1178 global_using_directives
= NULL
;
1180 /* We don't free pending_macros here because if the symtab was successfully
1181 built then ownership was transferred to the symtab. */
1182 pending_macros
= NULL
;
1184 if (pending_addrmap
)
1185 obstack_free (&pending_addrmap_obstack
, NULL
);
1186 pending_addrmap
= NULL
;
1188 free_buildsym_compunit ();
1191 /* Implementation of the first part of end_symtab. It allows modifying
1192 STATIC_BLOCK before it gets finalized by end_symtab_from_static_block.
1193 If the returned value is NULL there is no blockvector created for
1194 this symtab (you still must call end_symtab_from_static_block).
1196 END_ADDR is the same as for end_symtab: the address of the end of the
1199 If EXPANDABLE is non-zero the STATIC_BLOCK dictionary is made
1202 If REQUIRED is non-zero, then a symtab is created even if it does
1203 not contain any symbols. */
1206 end_symtab_get_static_block (CORE_ADDR end_addr
, int expandable
, int required
)
1208 struct objfile
*objfile
= buildsym_compunit
->objfile
;
1210 /* Finish the lexical context of the last function in the file; pop
1211 the context stack. */
1213 if (context_stack_depth
> 0)
1215 struct context_stack
*cstk
= pop_context ();
1217 /* Make a block for the local symbols within. */
1218 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
, NULL
,
1219 cstk
->start_addr
, end_addr
);
1221 if (context_stack_depth
> 0)
1223 /* This is said to happen with SCO. The old coffread.c
1224 code simply emptied the context stack, so we do the
1225 same. FIXME: Find out why it is happening. This is not
1226 believed to happen in most cases (even for coffread.c);
1227 it used to be an abort(). */
1228 complaint (&symfile_complaints
,
1229 _("Context stack not empty in end_symtab"));
1230 context_stack_depth
= 0;
1234 /* Reordered executables may have out of order pending blocks; if
1235 OBJF_REORDERED is true, then sort the pending blocks. */
1237 if ((objfile
->flags
& OBJF_REORDERED
) && pending_blocks
)
1239 struct pending_block
*pb
;
1241 std::vector
<block
*> barray
;
1243 for (pb
= pending_blocks
; pb
!= NULL
; pb
= pb
->next
)
1244 barray
.push_back (pb
->block
);
1246 /* Sort blocks by start address in descending order. Blocks with the
1247 same start address must remain in the original order to preserve
1248 inline function caller/callee relationships. */
1249 std::stable_sort (barray
.begin (), barray
.end (),
1250 [] (const block
*a
, const block
*b
)
1252 return BLOCK_START (a
) > BLOCK_START (b
);
1256 for (pb
= pending_blocks
; pb
!= NULL
; pb
= pb
->next
)
1257 pb
->block
= barray
[i
++];
1260 /* Cleanup any undefined types that have been left hanging around
1261 (this needs to be done before the finish_blocks so that
1262 file_symbols is still good).
1264 Both cleanup_undefined_stabs_types and finish_global_stabs are stabs
1265 specific, but harmless for other symbol readers, since on gdb
1266 startup or when finished reading stabs, the state is set so these
1267 are no-ops. FIXME: Is this handled right in case of QUIT? Can
1268 we make this cleaner? */
1270 cleanup_undefined_stabs_types (objfile
);
1271 finish_global_stabs (objfile
);
1274 && pending_blocks
== NULL
1275 && file_symbols
== NULL
1276 && global_symbols
== NULL
1277 && have_line_numbers
== 0
1278 && pending_macros
== NULL
1279 && global_using_directives
== NULL
)
1281 /* Ignore symtabs that have no functions with real debugging info. */
1286 /* Define the STATIC_BLOCK. */
1287 return finish_block_internal (NULL
, &file_symbols
, NULL
, NULL
,
1288 last_source_start_addr
, end_addr
,
1293 /* Subroutine of end_symtab_from_static_block to simplify it.
1294 Handle the "have blockvector" case.
1295 See end_symtab_from_static_block for a description of the arguments. */
1297 static struct compunit_symtab
*
1298 end_symtab_with_blockvector (struct block
*static_block
,
1299 int section
, int expandable
)
1301 struct objfile
*objfile
= buildsym_compunit
->objfile
;
1302 struct compunit_symtab
*cu
= buildsym_compunit
->compunit_symtab
;
1303 struct symtab
*symtab
;
1304 struct blockvector
*blockvector
;
1305 struct subfile
*subfile
;
1308 gdb_assert (static_block
!= NULL
);
1309 gdb_assert (buildsym_compunit
!= NULL
);
1310 gdb_assert (buildsym_compunit
->subfiles
!= NULL
);
1312 end_addr
= BLOCK_END (static_block
);
1314 /* Create the GLOBAL_BLOCK and build the blockvector. */
1315 finish_block_internal (NULL
, &global_symbols
, NULL
, NULL
,
1316 last_source_start_addr
, end_addr
,
1318 blockvector
= make_blockvector ();
1320 /* Read the line table if it has to be read separately.
1321 This is only used by xcoffread.c. */
1322 if (objfile
->sf
->sym_read_linetable
!= NULL
)
1323 objfile
->sf
->sym_read_linetable (objfile
);
1325 /* Handle the case where the debug info specifies a different path
1326 for the main source file. It can cause us to lose track of its
1327 line number information. */
1328 watch_main_source_file_lossage ();
1330 /* Now create the symtab objects proper, if not already done,
1331 one for each subfile. */
1333 for (subfile
= buildsym_compunit
->subfiles
;
1335 subfile
= subfile
->next
)
1337 int linetablesize
= 0;
1339 if (subfile
->line_vector
)
1341 linetablesize
= sizeof (struct linetable
) +
1342 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
1344 /* Like the pending blocks, the line table may be
1345 scrambled in reordered executables. Sort it if
1346 OBJF_REORDERED is true. */
1347 if (objfile
->flags
& OBJF_REORDERED
)
1348 qsort (subfile
->line_vector
->item
,
1349 subfile
->line_vector
->nitems
,
1350 sizeof (struct linetable_entry
), compare_line_numbers
);
1353 /* Allocate a symbol table if necessary. */
1354 if (subfile
->symtab
== NULL
)
1355 subfile
->symtab
= allocate_symtab (cu
, subfile
->name
);
1356 symtab
= subfile
->symtab
;
1358 /* Fill in its components. */
1360 if (subfile
->line_vector
)
1362 /* Reallocate the line table on the symbol obstack. */
1363 SYMTAB_LINETABLE (symtab
) = (struct linetable
*)
1364 obstack_alloc (&objfile
->objfile_obstack
, linetablesize
);
1365 memcpy (SYMTAB_LINETABLE (symtab
), subfile
->line_vector
,
1370 SYMTAB_LINETABLE (symtab
) = NULL
;
1373 /* Use whatever language we have been using for this
1374 subfile, not the one that was deduced in allocate_symtab
1375 from the filename. We already did our own deducing when
1376 we created the subfile, and we may have altered our
1377 opinion of what language it is from things we found in
1379 symtab
->language
= subfile
->language
;
1382 /* Make sure the symtab of main_subfile is the first in its list. */
1384 struct symtab
*main_symtab
, *prev_symtab
;
1386 main_symtab
= buildsym_compunit
->main_subfile
->symtab
;
1388 ALL_COMPUNIT_FILETABS (cu
, symtab
)
1390 if (symtab
== main_symtab
)
1392 if (prev_symtab
!= NULL
)
1394 prev_symtab
->next
= main_symtab
->next
;
1395 main_symtab
->next
= COMPUNIT_FILETABS (cu
);
1396 COMPUNIT_FILETABS (cu
) = main_symtab
;
1400 prev_symtab
= symtab
;
1402 gdb_assert (main_symtab
== COMPUNIT_FILETABS (cu
));
1405 /* Fill out the compunit symtab. */
1407 if (buildsym_compunit
->comp_dir
!= NULL
)
1409 /* Reallocate the dirname on the symbol obstack. */
1410 COMPUNIT_DIRNAME (cu
)
1411 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
1412 buildsym_compunit
->comp_dir
,
1413 strlen (buildsym_compunit
->comp_dir
));
1416 /* Save the debug format string (if any) in the symtab. */
1417 COMPUNIT_DEBUGFORMAT (cu
) = buildsym_compunit
->debugformat
;
1419 /* Similarly for the producer. */
1420 COMPUNIT_PRODUCER (cu
) = buildsym_compunit
->producer
;
1422 COMPUNIT_BLOCKVECTOR (cu
) = blockvector
;
1424 struct block
*b
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
1426 set_block_compunit_symtab (b
, cu
);
1429 COMPUNIT_BLOCK_LINE_SECTION (cu
) = section
;
1431 COMPUNIT_MACRO_TABLE (cu
) = pending_macros
;
1433 /* Default any symbols without a specified symtab to the primary symtab. */
1437 /* The main source file's symtab. */
1438 symtab
= COMPUNIT_FILETABS (cu
);
1440 for (block_i
= 0; block_i
< BLOCKVECTOR_NBLOCKS (blockvector
); block_i
++)
1442 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, block_i
);
1444 struct dict_iterator iter
;
1446 /* Inlined functions may have symbols not in the global or
1447 static symbol lists. */
1448 if (BLOCK_FUNCTION (block
) != NULL
)
1449 if (symbol_symtab (BLOCK_FUNCTION (block
)) == NULL
)
1450 symbol_set_symtab (BLOCK_FUNCTION (block
), symtab
);
1452 /* Note that we only want to fix up symbols from the local
1453 blocks, not blocks coming from included symtabs. That is why
1454 we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
1455 ALL_DICT_SYMBOLS (BLOCK_DICT (block
), iter
, sym
)
1456 if (symbol_symtab (sym
) == NULL
)
1457 symbol_set_symtab (sym
, symtab
);
1461 add_compunit_symtab_to_objfile (cu
);
1466 /* Implementation of the second part of end_symtab. Pass STATIC_BLOCK
1467 as value returned by end_symtab_get_static_block.
1469 SECTION is the same as for end_symtab: the section number
1470 (in objfile->section_offsets) of the blockvector and linetable.
1472 If EXPANDABLE is non-zero the GLOBAL_BLOCK dictionary is made
1475 struct compunit_symtab
*
1476 end_symtab_from_static_block (struct block
*static_block
,
1477 int section
, int expandable
)
1479 struct compunit_symtab
*cu
;
1481 if (static_block
== NULL
)
1483 /* Handle the "no blockvector" case.
1484 When this happens there is nothing to record, so there's nothing
1485 to do: memory will be freed up later.
1487 Note: We won't be adding a compunit to the objfile's list of
1488 compunits, so there's nothing to unchain. However, since each symtab
1489 is added to the objfile's obstack we can't free that space.
1490 We could do better, but this is believed to be a sufficiently rare
1495 cu
= end_symtab_with_blockvector (static_block
, section
, expandable
);
1497 reset_symtab_globals ();
1502 /* Finish the symbol definitions for one main source file, close off
1503 all the lexical contexts for that file (creating struct block's for
1504 them), then make the struct symtab for that file and put it in the
1507 END_ADDR is the address of the end of the file's text. SECTION is
1508 the section number (in objfile->section_offsets) of the blockvector
1511 Note that it is possible for end_symtab() to return NULL. In
1512 particular, for the DWARF case at least, it will return NULL when
1513 it finds a compilation unit that has exactly one DIE, a
1514 TAG_compile_unit DIE. This can happen when we link in an object
1515 file that was compiled from an empty source file. Returning NULL
1516 is probably not the correct thing to do, because then gdb will
1517 never know about this empty file (FIXME).
1519 If you need to modify STATIC_BLOCK before it is finalized you should
1520 call end_symtab_get_static_block and end_symtab_from_static_block
1523 struct compunit_symtab
*
1524 end_symtab (CORE_ADDR end_addr
, int section
)
1526 struct block
*static_block
;
1528 static_block
= end_symtab_get_static_block (end_addr
, 0, 0);
1529 return end_symtab_from_static_block (static_block
, section
, 0);
1532 /* Same as end_symtab except create a symtab that can be later added to. */
1534 struct compunit_symtab
*
1535 end_expandable_symtab (CORE_ADDR end_addr
, int section
)
1537 struct block
*static_block
;
1539 static_block
= end_symtab_get_static_block (end_addr
, 1, 0);
1540 return end_symtab_from_static_block (static_block
, section
, 1);
1543 /* Subroutine of augment_type_symtab to simplify it.
1544 Attach the main source file's symtab to all symbols in PENDING_LIST that
1548 set_missing_symtab (struct pending
*pending_list
,
1549 struct compunit_symtab
*cu
)
1551 struct pending
*pending
;
1554 for (pending
= pending_list
; pending
!= NULL
; pending
= pending
->next
)
1556 for (i
= 0; i
< pending
->nsyms
; ++i
)
1558 if (symbol_symtab (pending
->symbol
[i
]) == NULL
)
1559 symbol_set_symtab (pending
->symbol
[i
], COMPUNIT_FILETABS (cu
));
1564 /* Same as end_symtab, but for the case where we're adding more symbols
1565 to an existing symtab that is known to contain only type information.
1566 This is the case for DWARF4 Type Units. */
1569 augment_type_symtab (void)
1571 struct compunit_symtab
*cust
= buildsym_compunit
->compunit_symtab
;
1572 const struct blockvector
*blockvector
= COMPUNIT_BLOCKVECTOR (cust
);
1574 if (context_stack_depth
> 0)
1576 complaint (&symfile_complaints
,
1577 _("Context stack not empty in augment_type_symtab"));
1578 context_stack_depth
= 0;
1580 if (pending_blocks
!= NULL
)
1581 complaint (&symfile_complaints
, _("Blocks in a type symtab"));
1582 if (pending_macros
!= NULL
)
1583 complaint (&symfile_complaints
, _("Macro in a type symtab"));
1584 if (have_line_numbers
)
1585 complaint (&symfile_complaints
,
1586 _("Line numbers recorded in a type symtab"));
1588 if (file_symbols
!= NULL
)
1590 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
1592 /* First mark any symbols without a specified symtab as belonging
1593 to the primary symtab. */
1594 set_missing_symtab (file_symbols
, cust
);
1596 dict_add_pending (BLOCK_DICT (block
), file_symbols
);
1599 if (global_symbols
!= NULL
)
1601 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
1603 /* First mark any symbols without a specified symtab as belonging
1604 to the primary symtab. */
1605 set_missing_symtab (global_symbols
, cust
);
1607 dict_add_pending (BLOCK_DICT (block
), global_symbols
);
1610 reset_symtab_globals ();
1613 /* Push a context block. Args are an identifying nesting level
1614 (checkable when you pop it), and the starting PC address of this
1617 struct context_stack
*
1618 push_context (int desc
, CORE_ADDR valu
)
1620 struct context_stack
*newobj
;
1622 if (context_stack_depth
== context_stack_size
)
1624 context_stack_size
*= 2;
1625 context_stack
= (struct context_stack
*)
1626 xrealloc ((char *) context_stack
,
1627 (context_stack_size
* sizeof (struct context_stack
)));
1630 newobj
= &context_stack
[context_stack_depth
++];
1631 newobj
->depth
= desc
;
1632 newobj
->locals
= local_symbols
;
1633 newobj
->old_blocks
= pending_blocks
;
1634 newobj
->start_addr
= valu
;
1635 newobj
->local_using_directives
= local_using_directives
;
1636 newobj
->name
= NULL
;
1638 local_symbols
= NULL
;
1639 local_using_directives
= NULL
;
1644 /* Pop a context block. Returns the address of the context block just
1647 struct context_stack
*
1650 gdb_assert (context_stack_depth
> 0);
1651 return (&context_stack
[--context_stack_depth
]);
1656 /* Compute a small integer hash code for the given name. */
1659 hashname (const char *name
)
1661 return (hash(name
,strlen(name
)) % HASHSIZE
);
1666 record_debugformat (const char *format
)
1668 buildsym_compunit
->debugformat
= format
;
1672 record_producer (const char *producer
)
1674 buildsym_compunit
->producer
= producer
;
1677 /* Merge the first symbol list SRCLIST into the second symbol list
1678 TARGETLIST by repeated calls to add_symbol_to_list(). This
1679 procedure "frees" each link of SRCLIST by adding it to the
1680 free_pendings list. Caller must set SRCLIST to a null list after
1681 calling this function.
1686 merge_symbol_lists (struct pending
**srclist
, struct pending
**targetlist
)
1690 if (!srclist
|| !*srclist
)
1693 /* Merge in elements from current link. */
1694 for (i
= 0; i
< (*srclist
)->nsyms
; i
++)
1695 add_symbol_to_list ((*srclist
)->symbol
[i
], targetlist
);
1697 /* Recurse on next. */
1698 merge_symbol_lists (&(*srclist
)->next
, targetlist
);
1700 /* "Free" the current link. */
1701 (*srclist
)->next
= free_pendings
;
1702 free_pendings
= (*srclist
);
1706 /* Name of source file whose symbol data we are now processing. This
1707 comes from a symbol of type N_SO for stabs. For Dwarf it comes
1708 from the DW_AT_name attribute of a DW_TAG_compile_unit DIE. */
1710 static char *last_source_file
;
1712 /* See buildsym.h. */
1715 set_last_source_file (const char *name
)
1717 xfree (last_source_file
);
1718 last_source_file
= name
== NULL
? NULL
: xstrdup (name
);
1721 /* See buildsym.h. */
1724 get_last_source_file (void)
1726 return last_source_file
;
1731 /* Initialize anything that needs initializing when starting to read a
1732 fresh piece of a symbol file, e.g. reading in the stuff
1733 corresponding to a psymtab. */
1736 buildsym_init (void)
1738 subfile_stack
= NULL
;
1740 pending_addrmap_interesting
= 0;
1742 /* Context stack is initially empty. Allocate first one with room
1743 for a few levels; reuse it forever afterward. */
1744 if (context_stack
== NULL
)
1746 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
1747 context_stack
= XNEWVEC (struct context_stack
, context_stack_size
);
1750 /* Ensure the scoped_free_pendings destructor was called after
1752 gdb_assert (free_pendings
== NULL
);
1753 gdb_assert (pending_blocks
== NULL
);
1754 gdb_assert (file_symbols
== NULL
);
1755 gdb_assert (global_symbols
== NULL
);
1756 gdb_assert (global_using_directives
== NULL
);
1757 gdb_assert (pending_macros
== NULL
);
1758 gdb_assert (pending_addrmap
== NULL
);
1759 gdb_assert (buildsym_compunit
== NULL
);
1762 /* Initialize anything that needs initializing when a completely new
1763 symbol file is specified (not just adding some symbols from another
1764 file, e.g. a shared library). */
1767 buildsym_new_init (void)