1 /* Support routines for building symbol tables in GDB's internal format.
2 Copyright (C) 1986-2018 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... */
77 #include "filenames.h" /* For DOSish file names. */
79 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
81 #include "cp-support.h"
82 #include "dictionary.h"
86 /* Ask buildsym.h to define the vars it normally declares `extern'. */
89 #include "buildsym.h" /* Our own declarations. */
92 /* For cleanup_undefined_stabs_types and finish_global_stabs (somewhat
93 questionable--see comment where we call them). */
95 #include "stabsread.h"
97 /* Buildsym's counterpart to struct compunit_symtab.
98 TODO(dje): Move all related global state into here. */
100 struct buildsym_compunit
102 /* Start recording information about a primary source file (IOW, not an
103 included source file).
104 COMP_DIR is the directory in which the compilation unit was compiled
105 (or NULL if not known). */
107 buildsym_compunit (struct objfile
*objfile_
, const char *name
,
108 const char *comp_dir_
, enum language language_
,
110 : objfile (objfile_
),
111 m_last_source_file (name
== nullptr ? nullptr : xstrdup (name
)),
112 comp_dir (comp_dir_
== nullptr ? nullptr : xstrdup (comp_dir_
)),
113 language (language_
),
114 m_last_source_start_addr (last_addr
)
118 ~buildsym_compunit ()
120 struct subfile
*subfile
, *nextsub
;
122 if (m_pending_macros
!= nullptr)
123 free_macro_table (m_pending_macros
);
125 for (subfile
= subfiles
;
129 nextsub
= subfile
->next
;
130 xfree (subfile
->name
);
131 xfree (subfile
->line_vector
);
136 void set_last_source_file (const char *name
)
138 char *new_name
= name
== NULL
? NULL
: xstrdup (name
);
139 m_last_source_file
.reset (new_name
);
142 struct macro_table
*get_macro_table ()
144 if (m_pending_macros
== nullptr)
145 m_pending_macros
= new_macro_table (&objfile
->per_bfd
->storage_obstack
,
146 objfile
->per_bfd
->macro_cache
,
148 return m_pending_macros
;
151 struct macro_table
*release_macros ()
153 struct macro_table
*result
= m_pending_macros
;
154 m_pending_macros
= nullptr;
158 /* The objfile we're reading debug info from. */
159 struct objfile
*objfile
;
161 /* List of subfiles (source files).
162 Files are added to the front of the list.
163 This is important mostly for the language determination hacks we use,
164 which iterate over previously added files. */
165 struct subfile
*subfiles
= nullptr;
167 /* The subfile of the main source file. */
168 struct subfile
*main_subfile
= nullptr;
170 /* Name of source file whose symbol data we are now processing. This
171 comes from a symbol of type N_SO for stabs. For DWARF it comes
172 from the DW_AT_name attribute of a DW_TAG_compile_unit DIE. */
173 gdb::unique_xmalloc_ptr
<char> m_last_source_file
;
175 /* E.g., DW_AT_comp_dir if DWARF. Space for this is malloc'd. */
176 gdb::unique_xmalloc_ptr
<char> comp_dir
;
178 /* Space for this is not malloc'd, and is assumed to have at least
179 the same lifetime as objfile. */
180 const char *producer
= nullptr;
182 /* Space for this is not malloc'd, and is assumed to have at least
183 the same lifetime as objfile. */
184 const char *debugformat
= nullptr;
186 /* The compunit we are building. */
187 struct compunit_symtab
*compunit_symtab
= nullptr;
189 /* Language of this compunit_symtab. */
190 enum language language
;
192 /* The macro table for the compilation unit whose symbols we're
193 currently reading. */
194 struct macro_table
*m_pending_macros
= nullptr;
196 /* True if symtab has line number info. This prevents an otherwise
197 empty symtab from being tossed. */
198 bool m_have_line_numbers
= false;
200 /* Core address of start of text of current source file. This too
201 comes from the N_SO symbol. For Dwarf it typically comes from the
202 DW_AT_low_pc attribute of a DW_TAG_compile_unit DIE. */
203 CORE_ADDR m_last_source_start_addr
;
205 /* Stack of subfile names. */
206 std::vector
<const char *> m_subfile_stack
;
208 /* The "using" directives local to lexical context. */
209 struct using_direct
*m_local_using_directives
= nullptr;
211 /* Global "using" directives. */
212 struct using_direct
*m_global_using_directives
= nullptr;
215 /* The work-in-progress of the compunit we are building.
216 This is created first, before any subfiles by start_symtab. */
218 static struct buildsym_compunit
*buildsym_compunit
;
220 /* List of free `struct pending' structures for reuse. */
222 static struct pending
*free_pendings
;
224 /* The mutable address map for the compilation unit whose symbols
225 we're currently reading. The symtabs' shared blockvector will
226 point to a fixed copy of this. */
227 static struct addrmap
*pending_addrmap
;
229 /* The obstack on which we allocate pending_addrmap.
230 If pending_addrmap is NULL, this is uninitialized; otherwise, it is
231 initialized (and holds pending_addrmap). */
232 static struct obstack pending_addrmap_obstack
;
234 /* Non-zero if we recorded any ranges in the addrmap that are
235 different from those in the blockvector already. We set this to
236 zero when we start processing a symfile, and if it's still zero at
237 the end, then we just toss the addrmap. */
238 static int pending_addrmap_interesting
;
240 /* An obstack used for allocating pending blocks. */
242 static struct obstack pending_block_obstack
;
244 /* List of blocks already made (lexical contexts already closed).
245 This is used at the end to make the blockvector. */
249 struct pending_block
*next
;
253 /* Pointer to the head of a linked list of symbol blocks which have
254 already been finalized (lexical contexts already closed) and which
255 are just waiting to be built into a blockvector when finalizing the
256 associated symtab. */
258 static struct pending_block
*pending_blocks
;
260 /* Currently allocated size of context stack. */
262 static int context_stack_size
;
264 static void free_buildsym_compunit (void);
266 static int compare_line_numbers (const void *ln1p
, const void *ln2p
);
268 static void record_pending_block (struct objfile
*objfile
,
270 struct pending_block
*opblock
);
272 static void free_pending_blocks ();
274 /* Initial sizes of data structures. These are realloc'd larger if
275 needed, and realloc'd down to the size actually used, when
278 #define INITIAL_CONTEXT_STACK_SIZE 10
279 #define INITIAL_LINE_VECTOR_LENGTH 1000
282 /* Maintain the lists of symbols and blocks. */
284 /* Add a symbol to one of the lists of symbols. */
287 add_symbol_to_list (struct symbol
*symbol
, struct pending
**listhead
)
289 struct pending
*link
;
291 /* If this is an alias for another symbol, don't add it. */
292 if (symbol
->ginfo
.name
&& symbol
->ginfo
.name
[0] == '#')
295 /* We keep PENDINGSIZE symbols in each link of the list. If we
296 don't have a link with room in it, add a new link. */
297 if (*listhead
== NULL
|| (*listhead
)->nsyms
== PENDINGSIZE
)
301 link
= free_pendings
;
302 free_pendings
= link
->next
;
306 link
= XNEW (struct pending
);
309 link
->next
= *listhead
;
314 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
317 /* Find a symbol named NAME on a LIST. NAME need not be
318 '\0'-terminated; LENGTH is the length of the name. */
321 find_symbol_in_list (struct pending
*list
, char *name
, int length
)
328 for (j
= list
->nsyms
; --j
>= 0;)
330 pp
= SYMBOL_LINKAGE_NAME (list
->symbol
[j
]);
331 if (*pp
== *name
&& strncmp (pp
, name
, length
) == 0
332 && pp
[length
] == '\0')
334 return (list
->symbol
[j
]);
342 scoped_free_pendings::scoped_free_pendings ()
344 gdb_assert (pending_blocks
== nullptr);
347 /* At end of reading syms, or in case of quit, ensure everything
348 associated with building symtabs is freed.
350 N.B. This is *not* intended to be used when building psymtabs. Some debug
351 info readers call this anyway, which is harmless if confusing. */
353 scoped_free_pendings::~scoped_free_pendings ()
355 struct pending
*next
, *next1
;
357 for (next
= free_pendings
; next
; next
= next1
)
360 xfree ((void *) next
);
362 free_pendings
= NULL
;
364 free_pending_blocks ();
366 for (next
= file_symbols
; next
!= NULL
; next
= next1
)
369 xfree ((void *) next
);
373 for (next
= global_symbols
; next
!= NULL
; next
= next1
)
376 xfree ((void *) next
);
378 global_symbols
= NULL
;
381 obstack_free (&pending_addrmap_obstack
, NULL
);
382 pending_addrmap
= NULL
;
384 free_buildsym_compunit ();
387 /* This function is called to discard any pending blocks. */
390 free_pending_blocks ()
392 if (pending_blocks
!= NULL
)
394 obstack_free (&pending_block_obstack
, NULL
);
395 pending_blocks
= NULL
;
399 /* Take one of the lists of symbols and make a block from it. Keep
400 the order the symbols have in the list (reversed from the input
401 file). Put the block on the list of pending blocks. */
403 static struct block
*
404 finish_block_internal (struct symbol
*symbol
,
405 struct pending
**listhead
,
406 struct pending_block
*old_blocks
,
407 const struct dynamic_prop
*static_link
,
408 CORE_ADDR start
, CORE_ADDR end
,
409 int is_global
, int expandable
)
411 struct objfile
*objfile
= buildsym_compunit
->objfile
;
412 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
413 struct pending
*next
, *next1
;
415 struct pending_block
*pblock
;
416 struct pending_block
*opblock
;
419 ? allocate_global_block (&objfile
->objfile_obstack
)
420 : allocate_block (&objfile
->objfile_obstack
));
425 = dict_create_linear (&objfile
->objfile_obstack
,
426 buildsym_compunit
->language
, *listhead
);
433 = dict_create_hashed_expandable (buildsym_compunit
->language
);
434 dict_add_pending (BLOCK_DICT (block
), *listhead
);
439 dict_create_hashed (&objfile
->objfile_obstack
,
440 buildsym_compunit
->language
, *listhead
);
444 BLOCK_START (block
) = start
;
445 BLOCK_END (block
) = end
;
447 /* Put the block in as the value of the symbol that names it. */
451 struct type
*ftype
= SYMBOL_TYPE (symbol
);
452 struct dict_iterator iter
;
453 SYMBOL_BLOCK_VALUE (symbol
) = block
;
454 BLOCK_FUNCTION (block
) = symbol
;
456 if (TYPE_NFIELDS (ftype
) <= 0)
458 /* No parameter type information is recorded with the
459 function's type. Set that from the type of the
460 parameter symbols. */
461 int nparams
= 0, iparams
;
464 /* Here we want to directly access the dictionary, because
465 we haven't fully initialized the block yet. */
466 ALL_DICT_SYMBOLS (BLOCK_DICT (block
), iter
, sym
)
468 if (SYMBOL_IS_ARGUMENT (sym
))
473 TYPE_NFIELDS (ftype
) = nparams
;
474 TYPE_FIELDS (ftype
) = (struct field
*)
475 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
478 /* Here we want to directly access the dictionary, because
479 we haven't fully initialized the block yet. */
480 ALL_DICT_SYMBOLS (BLOCK_DICT (block
), iter
, sym
)
482 if (iparams
== nparams
)
485 if (SYMBOL_IS_ARGUMENT (sym
))
487 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
488 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
497 BLOCK_FUNCTION (block
) = NULL
;
500 if (static_link
!= NULL
)
501 objfile_register_static_link (objfile
, block
, static_link
);
503 /* Now "free" the links of the list, and empty the list. */
505 for (next
= *listhead
; next
; next
= next1
)
508 next
->next
= free_pendings
;
509 free_pendings
= next
;
513 /* Check to be sure that the blocks have an end address that is
514 greater than starting address. */
516 if (BLOCK_END (block
) < BLOCK_START (block
))
520 complaint (_("block end address less than block "
521 "start address in %s (patched it)"),
522 SYMBOL_PRINT_NAME (symbol
));
526 complaint (_("block end address %s less than block "
527 "start address %s (patched it)"),
528 paddress (gdbarch
, BLOCK_END (block
)),
529 paddress (gdbarch
, BLOCK_START (block
)));
531 /* Better than nothing. */
532 BLOCK_END (block
) = BLOCK_START (block
);
535 /* Install this block as the superblock of all blocks made since the
536 start of this scope that don't have superblocks yet. */
539 for (pblock
= pending_blocks
;
540 pblock
&& pblock
!= old_blocks
;
541 pblock
= pblock
->next
)
543 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
545 /* Check to be sure the blocks are nested as we receive
546 them. If the compiler/assembler/linker work, this just
547 burns a small amount of time.
549 Skip blocks which correspond to a function; they're not
550 physically nested inside this other blocks, only
552 if (BLOCK_FUNCTION (pblock
->block
) == NULL
553 && (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
554 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)))
558 complaint (_("inner block not inside outer block in %s"),
559 SYMBOL_PRINT_NAME (symbol
));
563 complaint (_("inner block (%s-%s) not "
564 "inside outer block (%s-%s)"),
565 paddress (gdbarch
, BLOCK_START (pblock
->block
)),
566 paddress (gdbarch
, BLOCK_END (pblock
->block
)),
567 paddress (gdbarch
, BLOCK_START (block
)),
568 paddress (gdbarch
, BLOCK_END (block
)));
570 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
))
571 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
572 if (BLOCK_END (pblock
->block
) > BLOCK_END (block
))
573 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
575 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
580 block_set_using (block
,
582 ? buildsym_compunit
->m_global_using_directives
583 : buildsym_compunit
->m_local_using_directives
),
584 &objfile
->objfile_obstack
);
586 buildsym_compunit
->m_global_using_directives
= NULL
;
588 buildsym_compunit
->m_local_using_directives
= NULL
;
590 record_pending_block (objfile
, block
, opblock
);
596 finish_block (struct symbol
*symbol
,
597 struct pending
**listhead
,
598 struct pending_block
*old_blocks
,
599 const struct dynamic_prop
*static_link
,
600 CORE_ADDR start
, CORE_ADDR end
)
602 return finish_block_internal (symbol
, listhead
, old_blocks
, static_link
,
606 /* Record BLOCK on the list of all blocks in the file. Put it after
607 OPBLOCK, or at the beginning if opblock is NULL. This puts the
608 block in the list after all its subblocks.
610 Allocate the pending block struct in the objfile_obstack to save
611 time. This wastes a little space. FIXME: Is it worth it? */
614 record_pending_block (struct objfile
*objfile
, struct block
*block
,
615 struct pending_block
*opblock
)
617 struct pending_block
*pblock
;
619 if (pending_blocks
== NULL
)
620 obstack_init (&pending_block_obstack
);
622 pblock
= XOBNEW (&pending_block_obstack
, struct pending_block
);
623 pblock
->block
= block
;
626 pblock
->next
= opblock
->next
;
627 opblock
->next
= pblock
;
631 pblock
->next
= pending_blocks
;
632 pending_blocks
= pblock
;
637 /* Record that the range of addresses from START to END_INCLUSIVE
638 (inclusive, like it says) belongs to BLOCK. BLOCK's start and end
639 addresses must be set already. You must apply this function to all
640 BLOCK's children before applying it to BLOCK.
642 If a call to this function complicates the picture beyond that
643 already provided by BLOCK_START and BLOCK_END, then we create an
644 address map for the block. */
646 record_block_range (struct block
*block
,
647 CORE_ADDR start
, CORE_ADDR end_inclusive
)
649 /* If this is any different from the range recorded in the block's
650 own BLOCK_START and BLOCK_END, then note that the address map has
651 become interesting. Note that even if this block doesn't have
652 any "interesting" ranges, some later block might, so we still
653 need to record this block in the addrmap. */
654 if (start
!= BLOCK_START (block
)
655 || end_inclusive
+ 1 != BLOCK_END (block
))
656 pending_addrmap_interesting
= 1;
658 if (! pending_addrmap
)
660 obstack_init (&pending_addrmap_obstack
);
661 pending_addrmap
= addrmap_create_mutable (&pending_addrmap_obstack
);
664 addrmap_set_empty (pending_addrmap
, start
, end_inclusive
, block
);
667 static struct blockvector
*
668 make_blockvector (void)
670 struct objfile
*objfile
= buildsym_compunit
->objfile
;
671 struct pending_block
*next
;
672 struct blockvector
*blockvector
;
675 /* Count the length of the list of blocks. */
677 for (next
= pending_blocks
, i
= 0; next
; next
= next
->next
, i
++)
681 blockvector
= (struct blockvector
*)
682 obstack_alloc (&objfile
->objfile_obstack
,
683 (sizeof (struct blockvector
)
684 + (i
- 1) * sizeof (struct block
*)));
686 /* Copy the blocks into the blockvector. This is done in reverse
687 order, which happens to put the blocks into the proper order
688 (ascending starting address). finish_block has hair to insert
689 each block into the list after its subblocks in order to make
690 sure this is true. */
692 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
693 for (next
= pending_blocks
; next
; next
= next
->next
)
695 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
698 free_pending_blocks ();
700 /* If we needed an address map for this symtab, record it in the
702 if (pending_addrmap
&& pending_addrmap_interesting
)
703 BLOCKVECTOR_MAP (blockvector
)
704 = addrmap_create_fixed (pending_addrmap
, &objfile
->objfile_obstack
);
706 BLOCKVECTOR_MAP (blockvector
) = 0;
708 /* Some compilers output blocks in the wrong order, but we depend on
709 their being in the right order so we can binary search. Check the
710 order and moan about it.
711 Note: Remember that the first two blocks are the global and static
712 blocks. We could special case that fact and begin checking at block 2.
713 To avoid making that assumption we do not. */
714 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
716 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
718 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
- 1))
719 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
)))
722 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
));
724 complaint (_("block at %s out of order"),
725 hex_string ((LONGEST
) start
));
730 return (blockvector
);
733 /* Start recording information about source code that came from an
734 included (or otherwise merged-in) source file with a different
735 name. NAME is the name of the file (cannot be NULL). */
738 start_subfile (const char *name
)
740 const char *subfile_dirname
;
741 struct subfile
*subfile
;
743 gdb_assert (buildsym_compunit
!= NULL
);
745 subfile_dirname
= buildsym_compunit
->comp_dir
.get ();
747 /* See if this subfile is already registered. */
749 for (subfile
= buildsym_compunit
->subfiles
; subfile
; subfile
= subfile
->next
)
753 /* If NAME is an absolute path, and this subfile is not, then
754 attempt to create an absolute path to compare. */
755 if (IS_ABSOLUTE_PATH (name
)
756 && !IS_ABSOLUTE_PATH (subfile
->name
)
757 && subfile_dirname
!= NULL
)
758 subfile_name
= concat (subfile_dirname
, SLASH_STRING
,
759 subfile
->name
, (char *) NULL
);
761 subfile_name
= subfile
->name
;
763 if (FILENAME_CMP (subfile_name
, name
) == 0)
765 current_subfile
= subfile
;
766 if (subfile_name
!= subfile
->name
)
767 xfree (subfile_name
);
770 if (subfile_name
!= subfile
->name
)
771 xfree (subfile_name
);
774 /* This subfile is not known. Add an entry for it. */
776 subfile
= XNEW (struct subfile
);
777 memset (subfile
, 0, sizeof (struct subfile
));
778 subfile
->buildsym_compunit
= buildsym_compunit
;
780 subfile
->next
= buildsym_compunit
->subfiles
;
781 buildsym_compunit
->subfiles
= subfile
;
783 current_subfile
= subfile
;
785 subfile
->name
= xstrdup (name
);
787 /* Initialize line-number recording for this subfile. */
788 subfile
->line_vector
= NULL
;
790 /* Default the source language to whatever can be deduced from the
791 filename. If nothing can be deduced (such as for a C/C++ include
792 file with a ".h" extension), then inherit whatever language the
793 previous subfile had. This kludgery is necessary because there
794 is no standard way in some object formats to record the source
795 language. Also, when symtabs are allocated we try to deduce a
796 language then as well, but it is too late for us to use that
797 information while reading symbols, since symtabs aren't allocated
798 until after all the symbols have been processed for a given
801 subfile
->language
= deduce_language_from_filename (subfile
->name
);
802 if (subfile
->language
== language_unknown
803 && subfile
->next
!= NULL
)
805 subfile
->language
= subfile
->next
->language
;
808 /* If the filename of this subfile ends in .C, then change the
809 language of any pending subfiles from C to C++. We also accept
810 any other C++ suffixes accepted by deduce_language_from_filename. */
811 /* Likewise for f2c. */
816 enum language sublang
= deduce_language_from_filename (subfile
->name
);
818 if (sublang
== language_cplus
|| sublang
== language_fortran
)
819 for (s
= buildsym_compunit
->subfiles
; s
!= NULL
; s
= s
->next
)
820 if (s
->language
== language_c
)
821 s
->language
= sublang
;
824 /* And patch up this file if necessary. */
825 if (subfile
->language
== language_c
826 && subfile
->next
!= NULL
827 && (subfile
->next
->language
== language_cplus
828 || subfile
->next
->language
== language_fortran
))
830 subfile
->language
= subfile
->next
->language
;
834 /* Delete the buildsym compunit. */
837 free_buildsym_compunit (void)
839 if (buildsym_compunit
== NULL
)
841 delete buildsym_compunit
;
842 buildsym_compunit
= NULL
;
843 current_subfile
= NULL
;
846 /* For stabs readers, the first N_SO symbol is assumed to be the
847 source file name, and the subfile struct is initialized using that
848 assumption. If another N_SO symbol is later seen, immediately
849 following the first one, then the first one is assumed to be the
850 directory name and the second one is really the source file name.
852 So we have to patch up the subfile struct by moving the old name
853 value to dirname and remembering the new name. Some sanity
854 checking is performed to ensure that the state of the subfile
855 struct is reasonable and that the old name we are assuming to be a
856 directory name actually is (by checking for a trailing '/'). */
859 patch_subfile_names (struct subfile
*subfile
, const char *name
)
862 && buildsym_compunit
->comp_dir
== NULL
863 && subfile
->name
!= NULL
864 && IS_DIR_SEPARATOR (subfile
->name
[strlen (subfile
->name
) - 1]))
866 buildsym_compunit
->comp_dir
.reset (subfile
->name
);
867 subfile
->name
= xstrdup (name
);
868 set_last_source_file (name
);
870 /* Default the source language to whatever can be deduced from
871 the filename. If nothing can be deduced (such as for a C/C++
872 include file with a ".h" extension), then inherit whatever
873 language the previous subfile had. This kludgery is
874 necessary because there is no standard way in some object
875 formats to record the source language. Also, when symtabs
876 are allocated we try to deduce a language then as well, but
877 it is too late for us to use that information while reading
878 symbols, since symtabs aren't allocated until after all the
879 symbols have been processed for a given source file. */
881 subfile
->language
= deduce_language_from_filename (subfile
->name
);
882 if (subfile
->language
== language_unknown
883 && subfile
->next
!= NULL
)
885 subfile
->language
= subfile
->next
->language
;
890 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for
891 switching source files (different subfiles, as we call them) within
892 one object file, but using a stack rather than in an arbitrary
898 gdb_assert (buildsym_compunit
!= nullptr);
899 gdb_assert (current_subfile
!= NULL
&& current_subfile
->name
!= NULL
);
900 buildsym_compunit
->m_subfile_stack
.push_back (current_subfile
->name
);
906 gdb_assert (buildsym_compunit
!= nullptr);
907 gdb_assert (!buildsym_compunit
->m_subfile_stack
.empty ());
908 const char *name
= buildsym_compunit
->m_subfile_stack
.back ();
909 buildsym_compunit
->m_subfile_stack
.pop_back ();
913 /* Add a linetable entry for line number LINE and address PC to the
914 line vector for SUBFILE. */
917 record_line (struct subfile
*subfile
, int line
, CORE_ADDR pc
)
919 struct linetable_entry
*e
;
921 /* Ignore the dummy line number in libg.o */
927 /* Make sure line vector exists and is big enough. */
928 if (!subfile
->line_vector
)
930 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
931 subfile
->line_vector
= (struct linetable
*)
932 xmalloc (sizeof (struct linetable
)
933 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
934 subfile
->line_vector
->nitems
= 0;
935 buildsym_compunit
->m_have_line_numbers
= true;
938 if (subfile
->line_vector
->nitems
+ 1 >= subfile
->line_vector_length
)
940 subfile
->line_vector_length
*= 2;
941 subfile
->line_vector
= (struct linetable
*)
942 xrealloc ((char *) subfile
->line_vector
,
943 (sizeof (struct linetable
)
944 + (subfile
->line_vector_length
945 * sizeof (struct linetable_entry
))));
948 /* Normally, we treat lines as unsorted. But the end of sequence
949 marker is special. We sort line markers at the same PC by line
950 number, so end of sequence markers (which have line == 0) appear
951 first. This is right if the marker ends the previous function,
952 and there is no padding before the next function. But it is
953 wrong if the previous line was empty and we are now marking a
954 switch to a different subfile. We must leave the end of sequence
955 marker at the end of this group of lines, not sort the empty line
956 to after the marker. The easiest way to accomplish this is to
957 delete any empty lines from our table, if they are followed by
958 end of sequence markers. All we lose is the ability to set
959 breakpoints at some lines which contain no instructions
961 if (line
== 0 && subfile
->line_vector
->nitems
> 0)
963 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
- 1;
964 while (subfile
->line_vector
->nitems
> 0 && e
->pc
== pc
)
967 subfile
->line_vector
->nitems
--;
971 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
976 /* Needed in order to sort line tables from IBM xcoff files. Sigh! */
979 compare_line_numbers (const void *ln1p
, const void *ln2p
)
981 struct linetable_entry
*ln1
= (struct linetable_entry
*) ln1p
;
982 struct linetable_entry
*ln2
= (struct linetable_entry
*) ln2p
;
984 /* Note: this code does not assume that CORE_ADDRs can fit in ints.
985 Please keep it that way. */
986 if (ln1
->pc
< ln2
->pc
)
989 if (ln1
->pc
> ln2
->pc
)
992 /* If pc equal, sort by line. I'm not sure whether this is optimum
993 behavior (see comment at struct linetable in symtab.h). */
994 return ln1
->line
- ln2
->line
;
997 /* See buildsym.h. */
999 struct compunit_symtab
*
1000 buildsym_compunit_symtab (void)
1002 gdb_assert (buildsym_compunit
!= NULL
);
1004 return buildsym_compunit
->compunit_symtab
;
1007 /* See buildsym.h. */
1009 struct macro_table
*
1010 get_macro_table (void)
1012 struct objfile
*objfile
;
1014 gdb_assert (buildsym_compunit
!= NULL
);
1015 return buildsym_compunit
->get_macro_table ();
1018 /* Init state to prepare for building a symtab.
1019 Note: This can't be done in buildsym_init because dbxread.c and xcoffread.c
1020 can call start_symtab+end_symtab multiple times after one call to
1024 prepare_for_building ()
1026 local_symbols
= NULL
;
1028 context_stack_depth
= 0;
1030 /* These should have been reset either by successful completion of building
1031 a symtab, or by the scoped_free_pendings destructor. */
1032 gdb_assert (file_symbols
== NULL
);
1033 gdb_assert (global_symbols
== NULL
);
1034 gdb_assert (pending_addrmap
== NULL
);
1035 gdb_assert (current_subfile
== NULL
);
1036 gdb_assert (buildsym_compunit
== nullptr);
1039 /* Start a new symtab for a new source file in OBJFILE. Called, for example,
1040 when a stabs symbol of type N_SO is seen, or when a DWARF
1041 TAG_compile_unit DIE is seen. It indicates the start of data for
1042 one original source file.
1044 NAME is the name of the file (cannot be NULL). COMP_DIR is the
1045 directory in which the file was compiled (or NULL if not known).
1046 START_ADDR is the lowest address of objects in the file (or 0 if
1047 not known). LANGUAGE is the language of the source file, or
1048 language_unknown if not known, in which case it'll be deduced from
1051 struct compunit_symtab
*
1052 start_symtab (struct objfile
*objfile
, const char *name
, const char *comp_dir
,
1053 CORE_ADDR start_addr
, enum language language
)
1055 prepare_for_building ();
1057 buildsym_compunit
= new struct buildsym_compunit (objfile
, name
, comp_dir
,
1058 language
, start_addr
);
1060 /* Allocate the compunit symtab now. The caller needs it to allocate
1061 non-primary symtabs. It is also needed by get_macro_table. */
1062 buildsym_compunit
->compunit_symtab
= allocate_compunit_symtab (objfile
,
1065 /* Build the subfile for NAME (the main source file) so that we can record
1066 a pointer to it for later.
1067 IMPORTANT: Do not allocate a struct symtab for NAME here.
1068 It can happen that the debug info provides a different path to NAME than
1069 DIRNAME,NAME. We cope with this in watch_main_source_file_lossage but
1070 that only works if the main_subfile doesn't have a symtab yet. */
1071 start_subfile (name
);
1072 /* Save this so that we don't have to go looking for it at the end
1073 of the subfiles list. */
1074 buildsym_compunit
->main_subfile
= current_subfile
;
1076 return buildsym_compunit
->compunit_symtab
;
1079 /* Restart compilation for a symtab.
1080 CUST is the result of end_expandable_symtab.
1081 NAME, START_ADDR are the source file we are resuming with.
1083 This is used when a symtab is built from multiple sources.
1084 The symtab is first built with start_symtab/end_expandable_symtab
1085 and then for each additional piece call restart_symtab/augment_*_symtab.
1086 Note: At the moment there is only augment_type_symtab. */
1089 restart_symtab (struct compunit_symtab
*cust
,
1090 const char *name
, CORE_ADDR start_addr
)
1092 prepare_for_building ();
1095 = new struct buildsym_compunit (COMPUNIT_OBJFILE (cust
),
1097 COMPUNIT_DIRNAME (cust
),
1098 compunit_language (cust
),
1100 buildsym_compunit
->compunit_symtab
= cust
;
1103 /* Subroutine of end_symtab to simplify it. Look for a subfile that
1104 matches the main source file's basename. If there is only one, and
1105 if the main source file doesn't have any symbol or line number
1106 information, then copy this file's symtab and line_vector to the
1107 main source file's subfile and discard the other subfile. This can
1108 happen because of a compiler bug or from the user playing games
1109 with #line or from things like a distributed build system that
1110 manipulates the debug info. This can also happen from an innocent
1111 symlink in the paths, we don't canonicalize paths here. */
1114 watch_main_source_file_lossage (void)
1116 struct subfile
*mainsub
, *subfile
;
1118 /* We have to watch for buildsym_compunit == NULL here. It's a quirk of
1119 end_symtab, it can return NULL so there may not be a main subfile. */
1120 if (buildsym_compunit
== NULL
)
1123 /* Get the main source file. */
1124 mainsub
= buildsym_compunit
->main_subfile
;
1126 /* If the main source file doesn't have any line number or symbol
1127 info, look for an alias in another subfile. */
1129 if (mainsub
->line_vector
== NULL
1130 && mainsub
->symtab
== NULL
)
1132 const char *mainbase
= lbasename (mainsub
->name
);
1134 struct subfile
*prevsub
;
1135 struct subfile
*mainsub_alias
= NULL
;
1136 struct subfile
*prev_mainsub_alias
= NULL
;
1139 for (subfile
= buildsym_compunit
->subfiles
;
1141 subfile
= subfile
->next
)
1143 if (subfile
== mainsub
)
1145 if (filename_cmp (lbasename (subfile
->name
), mainbase
) == 0)
1148 mainsub_alias
= subfile
;
1149 prev_mainsub_alias
= prevsub
;
1154 if (nr_matches
== 1)
1156 gdb_assert (mainsub_alias
!= NULL
&& mainsub_alias
!= mainsub
);
1158 /* Found a match for the main source file.
1159 Copy its line_vector and symtab to the main subfile
1160 and then discard it. */
1162 mainsub
->line_vector
= mainsub_alias
->line_vector
;
1163 mainsub
->line_vector_length
= mainsub_alias
->line_vector_length
;
1164 mainsub
->symtab
= mainsub_alias
->symtab
;
1166 if (prev_mainsub_alias
== NULL
)
1167 buildsym_compunit
->subfiles
= mainsub_alias
->next
;
1169 prev_mainsub_alias
->next
= mainsub_alias
->next
;
1170 xfree (mainsub_alias
->name
);
1171 xfree (mainsub_alias
);
1176 /* Reset state after a successful building of a symtab.
1177 This exists because dbxread.c and xcoffread.c can call
1178 start_symtab+end_symtab multiple times after one call to buildsym_init,
1179 and before the scoped_free_pendings destructor is called.
1180 We keep the free_pendings list around for dbx/xcoff sake. */
1183 reset_symtab_globals (void)
1185 local_symbols
= NULL
;
1186 file_symbols
= NULL
;
1187 global_symbols
= NULL
;
1189 if (pending_addrmap
)
1190 obstack_free (&pending_addrmap_obstack
, NULL
);
1191 pending_addrmap
= NULL
;
1193 free_buildsym_compunit ();
1196 /* Implementation of the first part of end_symtab. It allows modifying
1197 STATIC_BLOCK before it gets finalized by end_symtab_from_static_block.
1198 If the returned value is NULL there is no blockvector created for
1199 this symtab (you still must call end_symtab_from_static_block).
1201 END_ADDR is the same as for end_symtab: the address of the end of the
1204 If EXPANDABLE is non-zero the STATIC_BLOCK dictionary is made
1207 If REQUIRED is non-zero, then a symtab is created even if it does
1208 not contain any symbols. */
1211 end_symtab_get_static_block (CORE_ADDR end_addr
, int expandable
, int required
)
1213 struct objfile
*objfile
= buildsym_compunit
->objfile
;
1215 /* Finish the lexical context of the last function in the file; pop
1216 the context stack. */
1218 if (context_stack_depth
> 0)
1220 struct context_stack
*cstk
= pop_context ();
1222 /* Make a block for the local symbols within. */
1223 finish_block (cstk
->name
, &local_symbols
, cstk
->old_blocks
, NULL
,
1224 cstk
->start_addr
, end_addr
);
1226 if (context_stack_depth
> 0)
1228 /* This is said to happen with SCO. The old coffread.c
1229 code simply emptied the context stack, so we do the
1230 same. FIXME: Find out why it is happening. This is not
1231 believed to happen in most cases (even for coffread.c);
1232 it used to be an abort(). */
1233 complaint (_("Context stack not empty in end_symtab"));
1234 context_stack_depth
= 0;
1238 /* Reordered executables may have out of order pending blocks; if
1239 OBJF_REORDERED is true, then sort the pending blocks. */
1241 if ((objfile
->flags
& OBJF_REORDERED
) && pending_blocks
)
1243 struct pending_block
*pb
;
1245 std::vector
<block
*> barray
;
1247 for (pb
= pending_blocks
; pb
!= NULL
; pb
= pb
->next
)
1248 barray
.push_back (pb
->block
);
1250 /* Sort blocks by start address in descending order. Blocks with the
1251 same start address must remain in the original order to preserve
1252 inline function caller/callee relationships. */
1253 std::stable_sort (barray
.begin (), barray
.end (),
1254 [] (const block
*a
, const block
*b
)
1256 return BLOCK_START (a
) > BLOCK_START (b
);
1260 for (pb
= pending_blocks
; pb
!= NULL
; pb
= pb
->next
)
1261 pb
->block
= barray
[i
++];
1264 /* Cleanup any undefined types that have been left hanging around
1265 (this needs to be done before the finish_blocks so that
1266 file_symbols is still good).
1268 Both cleanup_undefined_stabs_types and finish_global_stabs are stabs
1269 specific, but harmless for other symbol readers, since on gdb
1270 startup or when finished reading stabs, the state is set so these
1271 are no-ops. FIXME: Is this handled right in case of QUIT? Can
1272 we make this cleaner? */
1274 cleanup_undefined_stabs_types (objfile
);
1275 finish_global_stabs (objfile
);
1278 && pending_blocks
== NULL
1279 && file_symbols
== NULL
1280 && global_symbols
== NULL
1281 && !buildsym_compunit
->m_have_line_numbers
1282 && buildsym_compunit
->m_pending_macros
== NULL
1283 && buildsym_compunit
->m_global_using_directives
== NULL
)
1285 /* Ignore symtabs that have no functions with real debugging info. */
1290 /* Define the STATIC_BLOCK. */
1291 return finish_block_internal (NULL
, &file_symbols
, NULL
, NULL
,
1292 buildsym_compunit
->m_last_source_start_addr
,
1293 end_addr
, 0, expandable
);
1297 /* Subroutine of end_symtab_from_static_block to simplify it.
1298 Handle the "have blockvector" case.
1299 See end_symtab_from_static_block for a description of the arguments. */
1301 static struct compunit_symtab
*
1302 end_symtab_with_blockvector (struct block
*static_block
,
1303 int section
, int expandable
)
1305 struct objfile
*objfile
= buildsym_compunit
->objfile
;
1306 struct compunit_symtab
*cu
= buildsym_compunit
->compunit_symtab
;
1307 struct symtab
*symtab
;
1308 struct blockvector
*blockvector
;
1309 struct subfile
*subfile
;
1312 gdb_assert (static_block
!= NULL
);
1313 gdb_assert (buildsym_compunit
!= NULL
);
1314 gdb_assert (buildsym_compunit
->subfiles
!= NULL
);
1316 end_addr
= BLOCK_END (static_block
);
1318 /* Create the GLOBAL_BLOCK and build the blockvector. */
1319 finish_block_internal (NULL
, &global_symbols
, NULL
, NULL
,
1320 buildsym_compunit
->m_last_source_start_addr
, end_addr
,
1322 blockvector
= make_blockvector ();
1324 /* Read the line table if it has to be read separately.
1325 This is only used by xcoffread.c. */
1326 if (objfile
->sf
->sym_read_linetable
!= NULL
)
1327 objfile
->sf
->sym_read_linetable (objfile
);
1329 /* Handle the case where the debug info specifies a different path
1330 for the main source file. It can cause us to lose track of its
1331 line number information. */
1332 watch_main_source_file_lossage ();
1334 /* Now create the symtab objects proper, if not already done,
1335 one for each subfile. */
1337 for (subfile
= buildsym_compunit
->subfiles
;
1339 subfile
= subfile
->next
)
1341 int linetablesize
= 0;
1343 if (subfile
->line_vector
)
1345 linetablesize
= sizeof (struct linetable
) +
1346 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
1348 /* Like the pending blocks, the line table may be
1349 scrambled in reordered executables. Sort it if
1350 OBJF_REORDERED is true. */
1351 if (objfile
->flags
& OBJF_REORDERED
)
1352 qsort (subfile
->line_vector
->item
,
1353 subfile
->line_vector
->nitems
,
1354 sizeof (struct linetable_entry
), compare_line_numbers
);
1357 /* Allocate a symbol table if necessary. */
1358 if (subfile
->symtab
== NULL
)
1359 subfile
->symtab
= allocate_symtab (cu
, subfile
->name
);
1360 symtab
= subfile
->symtab
;
1362 /* Fill in its components. */
1364 if (subfile
->line_vector
)
1366 /* Reallocate the line table on the symbol obstack. */
1367 SYMTAB_LINETABLE (symtab
) = (struct linetable
*)
1368 obstack_alloc (&objfile
->objfile_obstack
, linetablesize
);
1369 memcpy (SYMTAB_LINETABLE (symtab
), subfile
->line_vector
,
1374 SYMTAB_LINETABLE (symtab
) = NULL
;
1377 /* Use whatever language we have been using for this
1378 subfile, not the one that was deduced in allocate_symtab
1379 from the filename. We already did our own deducing when
1380 we created the subfile, and we may have altered our
1381 opinion of what language it is from things we found in
1383 symtab
->language
= subfile
->language
;
1386 /* Make sure the symtab of main_subfile is the first in its list. */
1388 struct symtab
*main_symtab
, *prev_symtab
;
1390 main_symtab
= buildsym_compunit
->main_subfile
->symtab
;
1392 ALL_COMPUNIT_FILETABS (cu
, symtab
)
1394 if (symtab
== main_symtab
)
1396 if (prev_symtab
!= NULL
)
1398 prev_symtab
->next
= main_symtab
->next
;
1399 main_symtab
->next
= COMPUNIT_FILETABS (cu
);
1400 COMPUNIT_FILETABS (cu
) = main_symtab
;
1404 prev_symtab
= symtab
;
1406 gdb_assert (main_symtab
== COMPUNIT_FILETABS (cu
));
1409 /* Fill out the compunit symtab. */
1411 if (buildsym_compunit
->comp_dir
!= NULL
)
1413 /* Reallocate the dirname on the symbol obstack. */
1414 const char *comp_dir
= buildsym_compunit
->comp_dir
.get ();
1415 COMPUNIT_DIRNAME (cu
)
1416 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
1417 comp_dir
, strlen (comp_dir
));
1420 /* Save the debug format string (if any) in the symtab. */
1421 COMPUNIT_DEBUGFORMAT (cu
) = buildsym_compunit
->debugformat
;
1423 /* Similarly for the producer. */
1424 COMPUNIT_PRODUCER (cu
) = buildsym_compunit
->producer
;
1426 COMPUNIT_BLOCKVECTOR (cu
) = blockvector
;
1428 struct block
*b
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
1430 set_block_compunit_symtab (b
, cu
);
1433 COMPUNIT_BLOCK_LINE_SECTION (cu
) = section
;
1435 COMPUNIT_MACRO_TABLE (cu
) = buildsym_compunit
->release_macros ();
1437 /* Default any symbols without a specified symtab to the primary symtab. */
1441 /* The main source file's symtab. */
1442 symtab
= COMPUNIT_FILETABS (cu
);
1444 for (block_i
= 0; block_i
< BLOCKVECTOR_NBLOCKS (blockvector
); block_i
++)
1446 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, block_i
);
1448 struct dict_iterator iter
;
1450 /* Inlined functions may have symbols not in the global or
1451 static symbol lists. */
1452 if (BLOCK_FUNCTION (block
) != NULL
)
1453 if (symbol_symtab (BLOCK_FUNCTION (block
)) == NULL
)
1454 symbol_set_symtab (BLOCK_FUNCTION (block
), symtab
);
1456 /* Note that we only want to fix up symbols from the local
1457 blocks, not blocks coming from included symtabs. That is why
1458 we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
1459 ALL_DICT_SYMBOLS (BLOCK_DICT (block
), iter
, sym
)
1460 if (symbol_symtab (sym
) == NULL
)
1461 symbol_set_symtab (sym
, symtab
);
1465 add_compunit_symtab_to_objfile (cu
);
1470 /* Implementation of the second part of end_symtab. Pass STATIC_BLOCK
1471 as value returned by end_symtab_get_static_block.
1473 SECTION is the same as for end_symtab: the section number
1474 (in objfile->section_offsets) of the blockvector and linetable.
1476 If EXPANDABLE is non-zero the GLOBAL_BLOCK dictionary is made
1479 struct compunit_symtab
*
1480 end_symtab_from_static_block (struct block
*static_block
,
1481 int section
, int expandable
)
1483 struct compunit_symtab
*cu
;
1485 if (static_block
== NULL
)
1487 /* Handle the "no blockvector" case.
1488 When this happens there is nothing to record, so there's nothing
1489 to do: memory will be freed up later.
1491 Note: We won't be adding a compunit to the objfile's list of
1492 compunits, so there's nothing to unchain. However, since each symtab
1493 is added to the objfile's obstack we can't free that space.
1494 We could do better, but this is believed to be a sufficiently rare
1499 cu
= end_symtab_with_blockvector (static_block
, section
, expandable
);
1501 reset_symtab_globals ();
1506 /* Finish the symbol definitions for one main source file, close off
1507 all the lexical contexts for that file (creating struct block's for
1508 them), then make the struct symtab for that file and put it in the
1511 END_ADDR is the address of the end of the file's text. SECTION is
1512 the section number (in objfile->section_offsets) of the blockvector
1515 Note that it is possible for end_symtab() to return NULL. In
1516 particular, for the DWARF case at least, it will return NULL when
1517 it finds a compilation unit that has exactly one DIE, a
1518 TAG_compile_unit DIE. This can happen when we link in an object
1519 file that was compiled from an empty source file. Returning NULL
1520 is probably not the correct thing to do, because then gdb will
1521 never know about this empty file (FIXME).
1523 If you need to modify STATIC_BLOCK before it is finalized you should
1524 call end_symtab_get_static_block and end_symtab_from_static_block
1527 struct compunit_symtab
*
1528 end_symtab (CORE_ADDR end_addr
, int section
)
1530 struct block
*static_block
;
1532 static_block
= end_symtab_get_static_block (end_addr
, 0, 0);
1533 return end_symtab_from_static_block (static_block
, section
, 0);
1536 /* Same as end_symtab except create a symtab that can be later added to. */
1538 struct compunit_symtab
*
1539 end_expandable_symtab (CORE_ADDR end_addr
, int section
)
1541 struct block
*static_block
;
1543 static_block
= end_symtab_get_static_block (end_addr
, 1, 0);
1544 return end_symtab_from_static_block (static_block
, section
, 1);
1547 /* Subroutine of augment_type_symtab to simplify it.
1548 Attach the main source file's symtab to all symbols in PENDING_LIST that
1552 set_missing_symtab (struct pending
*pending_list
,
1553 struct compunit_symtab
*cu
)
1555 struct pending
*pending
;
1558 for (pending
= pending_list
; pending
!= NULL
; pending
= pending
->next
)
1560 for (i
= 0; i
< pending
->nsyms
; ++i
)
1562 if (symbol_symtab (pending
->symbol
[i
]) == NULL
)
1563 symbol_set_symtab (pending
->symbol
[i
], COMPUNIT_FILETABS (cu
));
1568 /* Same as end_symtab, but for the case where we're adding more symbols
1569 to an existing symtab that is known to contain only type information.
1570 This is the case for DWARF4 Type Units. */
1573 augment_type_symtab (void)
1575 struct compunit_symtab
*cust
= buildsym_compunit
->compunit_symtab
;
1576 const struct blockvector
*blockvector
= COMPUNIT_BLOCKVECTOR (cust
);
1578 if (context_stack_depth
> 0)
1580 complaint (_("Context stack not empty in augment_type_symtab"));
1581 context_stack_depth
= 0;
1583 if (pending_blocks
!= NULL
)
1584 complaint (_("Blocks in a type symtab"));
1585 if (buildsym_compunit
->m_pending_macros
!= NULL
)
1586 complaint (_("Macro in a type symtab"));
1587 if (buildsym_compunit
->m_have_line_numbers
)
1588 complaint (_("Line numbers recorded in a type symtab"));
1590 if (file_symbols
!= NULL
)
1592 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
1594 /* First mark any symbols without a specified symtab as belonging
1595 to the primary symtab. */
1596 set_missing_symtab (file_symbols
, cust
);
1598 dict_add_pending (BLOCK_DICT (block
), file_symbols
);
1601 if (global_symbols
!= NULL
)
1603 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
1605 /* First mark any symbols without a specified symtab as belonging
1606 to the primary symtab. */
1607 set_missing_symtab (global_symbols
, cust
);
1609 dict_add_pending (BLOCK_DICT (block
), global_symbols
);
1612 reset_symtab_globals ();
1615 /* Push a context block. Args are an identifying nesting level
1616 (checkable when you pop it), and the starting PC address of this
1619 struct context_stack
*
1620 push_context (int desc
, CORE_ADDR valu
)
1622 struct context_stack
*newobj
;
1624 if (context_stack_depth
== context_stack_size
)
1626 context_stack_size
*= 2;
1627 context_stack
= (struct context_stack
*)
1628 xrealloc ((char *) context_stack
,
1629 (context_stack_size
* sizeof (struct context_stack
)));
1632 newobj
= &context_stack
[context_stack_depth
++];
1633 newobj
->depth
= desc
;
1634 newobj
->locals
= local_symbols
;
1635 newobj
->old_blocks
= pending_blocks
;
1636 newobj
->start_addr
= valu
;
1637 newobj
->local_using_directives
1638 = buildsym_compunit
->m_local_using_directives
;
1639 newobj
->name
= NULL
;
1641 local_symbols
= NULL
;
1642 buildsym_compunit
->m_local_using_directives
= NULL
;
1647 /* Pop a context block. Returns the address of the context block just
1650 struct context_stack
*
1653 gdb_assert (context_stack_depth
> 0);
1654 return (&context_stack
[--context_stack_depth
]);
1660 record_debugformat (const char *format
)
1662 buildsym_compunit
->debugformat
= format
;
1666 record_producer (const char *producer
)
1668 buildsym_compunit
->producer
= producer
;
1673 /* See buildsym.h. */
1676 set_last_source_file (const char *name
)
1678 gdb_assert (buildsym_compunit
!= nullptr || name
== nullptr);
1679 if (buildsym_compunit
!= nullptr)
1680 buildsym_compunit
->set_last_source_file (name
);
1683 /* See buildsym.h. */
1686 get_last_source_file (void)
1688 if (buildsym_compunit
== nullptr)
1690 return buildsym_compunit
->m_last_source_file
.get ();
1693 /* See buildsym.h. */
1696 set_last_source_start_addr (CORE_ADDR addr
)
1698 gdb_assert (buildsym_compunit
!= nullptr);
1699 buildsym_compunit
->m_last_source_start_addr
= addr
;
1702 /* See buildsym.h. */
1705 get_last_source_start_addr ()
1707 gdb_assert (buildsym_compunit
!= nullptr);
1708 return buildsym_compunit
->m_last_source_start_addr
;
1711 /* See buildsym.h. */
1713 struct using_direct
**
1714 get_local_using_directives ()
1716 gdb_assert (buildsym_compunit
!= nullptr);
1717 return &buildsym_compunit
->m_local_using_directives
;
1720 /* See buildsym.h. */
1723 set_local_using_directives (struct using_direct
*new_local
)
1725 gdb_assert (buildsym_compunit
!= nullptr);
1726 buildsym_compunit
->m_local_using_directives
= new_local
;
1729 /* See buildsym.h. */
1731 struct using_direct
**
1732 get_global_using_directives ()
1734 gdb_assert (buildsym_compunit
!= nullptr);
1735 return &buildsym_compunit
->m_global_using_directives
;
1740 /* Initialize anything that needs initializing when starting to read a
1741 fresh piece of a symbol file, e.g. reading in the stuff
1742 corresponding to a psymtab. */
1747 pending_addrmap_interesting
= 0;
1749 /* Context stack is initially empty. Allocate first one with room
1750 for a few levels; reuse it forever afterward. */
1751 if (context_stack
== NULL
)
1753 context_stack_size
= INITIAL_CONTEXT_STACK_SIZE
;
1754 context_stack
= XNEWVEC (struct context_stack
, context_stack_size
);
1757 /* Ensure the scoped_free_pendings destructor was called after
1759 gdb_assert (free_pendings
== NULL
);
1760 gdb_assert (pending_blocks
== NULL
);
1761 gdb_assert (file_symbols
== NULL
);
1762 gdb_assert (global_symbols
== NULL
);
1763 gdb_assert (pending_addrmap
== NULL
);
1764 gdb_assert (buildsym_compunit
== NULL
);