1 /* Support routines for building symbol tables in GDB's internal format.
2 Copyright (C) 1986-2020 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/>. */
20 #include "buildsym-legacy.h"
22 #include "gdb_obstack.h"
27 #include "complaints.h"
28 #include "expression.h" /* For "enum exp_opcode" used by... */
29 #include "filenames.h" /* For DOSish file names. */
31 #include "demangle.h" /* Needed by SYMBOL_INIT_DEMANGLED_NAME. */
33 #include "cp-support.h"
34 #include "dictionary.h"
38 /* For cleanup_undefined_stabs_types and finish_global_stabs (somewhat
39 questionable--see comment where we call them). */
41 #include "stabsread.h"
43 /* List of blocks already made (lexical contexts already closed).
44 This is used at the end to make the blockvector. */
48 struct pending_block
*next
;
52 /* Initial sizes of data structures. These are realloc'd larger if
53 needed, and realloc'd down to the size actually used, when
56 #define INITIAL_LINE_VECTOR_LENGTH 1000
59 buildsym_compunit::buildsym_compunit (struct objfile
*objfile_
,
61 const char *comp_dir_
,
62 enum language language_
,
64 : m_objfile (objfile_
),
65 m_last_source_file (name
== nullptr ? nullptr : xstrdup (name
)),
66 m_comp_dir (comp_dir_
== nullptr ? nullptr : xstrdup (comp_dir_
)),
67 m_language (language_
),
68 m_last_source_start_addr (last_addr
)
70 /* Allocate the compunit symtab now. The caller needs it to allocate
71 non-primary symtabs. It is also needed by get_macro_table. */
72 m_compunit_symtab
= allocate_compunit_symtab (m_objfile
, name
);
74 /* Build the subfile for NAME (the main source file) so that we can record
75 a pointer to it for later.
76 IMPORTANT: Do not allocate a struct symtab for NAME here.
77 It can happen that the debug info provides a different path to NAME than
78 DIRNAME,NAME. We cope with this in watch_main_source_file_lossage but
79 that only works if the main_subfile doesn't have a symtab yet. */
81 /* Save this so that we don't have to go looking for it at the end
82 of the subfiles list. */
83 m_main_subfile
= m_current_subfile
;
86 buildsym_compunit::~buildsym_compunit ()
88 struct subfile
*subfile
, *nextsub
;
90 if (m_pending_macros
!= nullptr)
91 free_macro_table (m_pending_macros
);
93 for (subfile
= m_subfiles
;
97 nextsub
= subfile
->next
;
98 xfree (subfile
->name
);
99 xfree (subfile
->line_vector
);
103 struct pending
*next
, *next1
;
105 for (next
= m_file_symbols
; next
!= NULL
; next
= next1
)
108 xfree ((void *) next
);
111 for (next
= m_global_symbols
; next
!= NULL
; next
= next1
)
114 xfree ((void *) next
);
119 buildsym_compunit::get_macro_table ()
121 if (m_pending_macros
== nullptr)
122 m_pending_macros
= new_macro_table (&m_objfile
->per_bfd
->storage_obstack
,
123 &m_objfile
->per_bfd
->string_cache
,
125 return m_pending_macros
;
128 /* Maintain the lists of symbols and blocks. */
130 /* Add a symbol to one of the lists of symbols. */
133 add_symbol_to_list (struct symbol
*symbol
, struct pending
**listhead
)
135 struct pending
*link
;
137 /* If this is an alias for another symbol, don't add it. */
138 if (symbol
->linkage_name () && symbol
->linkage_name ()[0] == '#')
141 /* We keep PENDINGSIZE symbols in each link of the list. If we
142 don't have a link with room in it, add a new link. */
143 if (*listhead
== NULL
|| (*listhead
)->nsyms
== PENDINGSIZE
)
145 link
= XNEW (struct pending
);
146 link
->next
= *listhead
;
151 (*listhead
)->symbol
[(*listhead
)->nsyms
++] = symbol
;
154 /* Find a symbol named NAME on a LIST. NAME need not be
155 '\0'-terminated; LENGTH is the length of the name. */
158 find_symbol_in_list (struct pending
*list
, char *name
, int length
)
165 for (j
= list
->nsyms
; --j
>= 0;)
167 pp
= list
->symbol
[j
]->linkage_name ();
168 if (*pp
== *name
&& strncmp (pp
, name
, length
) == 0
169 && pp
[length
] == '\0')
171 return (list
->symbol
[j
]);
179 /* Record BLOCK on the list of all blocks in the file. Put it after
180 OPBLOCK, or at the beginning if opblock is NULL. This puts the
181 block in the list after all its subblocks. */
184 buildsym_compunit::record_pending_block (struct block
*block
,
185 struct pending_block
*opblock
)
187 struct pending_block
*pblock
;
189 pblock
= XOBNEW (&m_pending_block_obstack
, struct pending_block
);
190 pblock
->block
= block
;
193 pblock
->next
= opblock
->next
;
194 opblock
->next
= pblock
;
198 pblock
->next
= m_pending_blocks
;
199 m_pending_blocks
= pblock
;
203 /* Take one of the lists of symbols and make a block from it. Keep
204 the order the symbols have in the list (reversed from the input
205 file). Put the block on the list of pending blocks. */
208 buildsym_compunit::finish_block_internal
209 (struct symbol
*symbol
,
210 struct pending
**listhead
,
211 struct pending_block
*old_blocks
,
212 const struct dynamic_prop
*static_link
,
213 CORE_ADDR start
, CORE_ADDR end
,
214 int is_global
, int expandable
)
216 struct gdbarch
*gdbarch
= get_objfile_arch (m_objfile
);
217 struct pending
*next
, *next1
;
219 struct pending_block
*pblock
;
220 struct pending_block
*opblock
;
223 ? allocate_global_block (&m_objfile
->objfile_obstack
)
224 : allocate_block (&m_objfile
->objfile_obstack
));
228 BLOCK_MULTIDICT (block
)
229 = mdict_create_linear (&m_objfile
->objfile_obstack
, *listhead
);
235 BLOCK_MULTIDICT (block
) = mdict_create_hashed_expandable (m_language
);
236 mdict_add_pending (BLOCK_MULTIDICT (block
), *listhead
);
240 BLOCK_MULTIDICT (block
) =
241 mdict_create_hashed (&m_objfile
->objfile_obstack
, *listhead
);
245 BLOCK_START (block
) = start
;
246 BLOCK_END (block
) = end
;
248 /* Put the block in as the value of the symbol that names it. */
252 struct type
*ftype
= SYMBOL_TYPE (symbol
);
253 struct mdict_iterator miter
;
254 SYMBOL_BLOCK_VALUE (symbol
) = block
;
255 BLOCK_FUNCTION (block
) = symbol
;
257 if (TYPE_NFIELDS (ftype
) <= 0)
259 /* No parameter type information is recorded with the
260 function's type. Set that from the type of the
261 parameter symbols. */
262 int nparams
= 0, iparams
;
265 /* Here we want to directly access the dictionary, because
266 we haven't fully initialized the block yet. */
267 ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block
), miter
, sym
)
269 if (SYMBOL_IS_ARGUMENT (sym
))
274 TYPE_NFIELDS (ftype
) = nparams
;
275 TYPE_FIELDS (ftype
) = (struct field
*)
276 TYPE_ALLOC (ftype
, nparams
* sizeof (struct field
));
279 /* Here we want to directly access the dictionary, because
280 we haven't fully initialized the block yet. */
281 ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block
), miter
, sym
)
283 if (iparams
== nparams
)
286 if (SYMBOL_IS_ARGUMENT (sym
))
288 TYPE_FIELD_TYPE (ftype
, iparams
) = SYMBOL_TYPE (sym
);
289 TYPE_FIELD_ARTIFICIAL (ftype
, iparams
) = 0;
298 BLOCK_FUNCTION (block
) = NULL
;
301 if (static_link
!= NULL
)
302 objfile_register_static_link (m_objfile
, block
, static_link
);
304 /* Now free the links of the list, and empty the list. */
306 for (next
= *listhead
; next
; next
= next1
)
313 /* Check to be sure that the blocks have an end address that is
314 greater than starting address. */
316 if (BLOCK_END (block
) < BLOCK_START (block
))
320 complaint (_("block end address less than block "
321 "start address in %s (patched it)"),
322 symbol
->print_name ());
326 complaint (_("block end address %s less than block "
327 "start address %s (patched it)"),
328 paddress (gdbarch
, BLOCK_END (block
)),
329 paddress (gdbarch
, BLOCK_START (block
)));
331 /* Better than nothing. */
332 BLOCK_END (block
) = BLOCK_START (block
);
335 /* Install this block as the superblock of all blocks made since the
336 start of this scope that don't have superblocks yet. */
339 for (pblock
= m_pending_blocks
;
340 pblock
&& pblock
!= old_blocks
;
341 pblock
= pblock
->next
)
343 if (BLOCK_SUPERBLOCK (pblock
->block
) == NULL
)
345 /* Check to be sure the blocks are nested as we receive
346 them. If the compiler/assembler/linker work, this just
347 burns a small amount of time.
349 Skip blocks which correspond to a function; they're not
350 physically nested inside this other blocks, only
352 if (BLOCK_FUNCTION (pblock
->block
) == NULL
353 && (BLOCK_START (pblock
->block
) < BLOCK_START (block
)
354 || BLOCK_END (pblock
->block
) > BLOCK_END (block
)))
358 complaint (_("inner block not inside outer block in %s"),
359 symbol
->print_name ());
363 complaint (_("inner block (%s-%s) not "
364 "inside outer block (%s-%s)"),
365 paddress (gdbarch
, BLOCK_START (pblock
->block
)),
366 paddress (gdbarch
, BLOCK_END (pblock
->block
)),
367 paddress (gdbarch
, BLOCK_START (block
)),
368 paddress (gdbarch
, BLOCK_END (block
)));
370 if (BLOCK_START (pblock
->block
) < BLOCK_START (block
))
371 BLOCK_START (pblock
->block
) = BLOCK_START (block
);
372 if (BLOCK_END (pblock
->block
) > BLOCK_END (block
))
373 BLOCK_END (pblock
->block
) = BLOCK_END (block
);
375 BLOCK_SUPERBLOCK (pblock
->block
) = block
;
380 block_set_using (block
,
382 ? m_global_using_directives
383 : m_local_using_directives
),
384 &m_objfile
->objfile_obstack
);
386 m_global_using_directives
= NULL
;
388 m_local_using_directives
= NULL
;
390 record_pending_block (block
, opblock
);
396 buildsym_compunit::finish_block (struct symbol
*symbol
,
397 struct pending_block
*old_blocks
,
398 const struct dynamic_prop
*static_link
,
399 CORE_ADDR start
, CORE_ADDR end
)
401 return finish_block_internal (symbol
, &m_local_symbols
,
402 old_blocks
, static_link
, start
, end
, 0, 0);
405 /* Record that the range of addresses from START to END_INCLUSIVE
406 (inclusive, like it says) belongs to BLOCK. BLOCK's start and end
407 addresses must be set already. You must apply this function to all
408 BLOCK's children before applying it to BLOCK.
410 If a call to this function complicates the picture beyond that
411 already provided by BLOCK_START and BLOCK_END, then we create an
412 address map for the block. */
414 buildsym_compunit::record_block_range (struct block
*block
,
416 CORE_ADDR end_inclusive
)
418 /* If this is any different from the range recorded in the block's
419 own BLOCK_START and BLOCK_END, then note that the address map has
420 become interesting. Note that even if this block doesn't have
421 any "interesting" ranges, some later block might, so we still
422 need to record this block in the addrmap. */
423 if (start
!= BLOCK_START (block
)
424 || end_inclusive
+ 1 != BLOCK_END (block
))
425 m_pending_addrmap_interesting
= true;
427 if (m_pending_addrmap
== nullptr)
428 m_pending_addrmap
= addrmap_create_mutable (&m_pending_addrmap_obstack
);
430 addrmap_set_empty (m_pending_addrmap
, start
, end_inclusive
, block
);
434 buildsym_compunit::make_blockvector ()
436 struct pending_block
*next
;
437 struct blockvector
*blockvector
;
440 /* Count the length of the list of blocks. */
442 for (next
= m_pending_blocks
, i
= 0; next
; next
= next
->next
, i
++)
446 blockvector
= (struct blockvector
*)
447 obstack_alloc (&m_objfile
->objfile_obstack
,
448 (sizeof (struct blockvector
)
449 + (i
- 1) * sizeof (struct block
*)));
451 /* Copy the blocks into the blockvector. This is done in reverse
452 order, which happens to put the blocks into the proper order
453 (ascending starting address). finish_block has hair to insert
454 each block into the list after its subblocks in order to make
455 sure this is true. */
457 BLOCKVECTOR_NBLOCKS (blockvector
) = i
;
458 for (next
= m_pending_blocks
; next
; next
= next
->next
)
460 BLOCKVECTOR_BLOCK (blockvector
, --i
) = next
->block
;
463 free_pending_blocks ();
465 /* If we needed an address map for this symtab, record it in the
467 if (m_pending_addrmap
!= nullptr && m_pending_addrmap_interesting
)
468 BLOCKVECTOR_MAP (blockvector
)
469 = addrmap_create_fixed (m_pending_addrmap
, &m_objfile
->objfile_obstack
);
471 BLOCKVECTOR_MAP (blockvector
) = 0;
473 /* Some compilers output blocks in the wrong order, but we depend on
474 their being in the right order so we can binary search. Check the
475 order and moan about it.
476 Note: Remember that the first two blocks are the global and static
477 blocks. We could special case that fact and begin checking at block 2.
478 To avoid making that assumption we do not. */
479 if (BLOCKVECTOR_NBLOCKS (blockvector
) > 1)
481 for (i
= 1; i
< BLOCKVECTOR_NBLOCKS (blockvector
); i
++)
483 if (BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
- 1))
484 > BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
)))
487 = BLOCK_START (BLOCKVECTOR_BLOCK (blockvector
, i
));
489 complaint (_("block at %s out of order"),
490 hex_string ((LONGEST
) start
));
495 return (blockvector
);
498 /* Start recording information about source code that came from an
499 included (or otherwise merged-in) source file with a different
500 name. NAME is the name of the file (cannot be NULL). */
503 buildsym_compunit::start_subfile (const char *name
)
505 const char *subfile_dirname
;
506 struct subfile
*subfile
;
508 subfile_dirname
= m_comp_dir
.get ();
510 /* See if this subfile is already registered. */
512 for (subfile
= m_subfiles
; subfile
; subfile
= subfile
->next
)
516 /* If NAME is an absolute path, and this subfile is not, then
517 attempt to create an absolute path to compare. */
518 if (IS_ABSOLUTE_PATH (name
)
519 && !IS_ABSOLUTE_PATH (subfile
->name
)
520 && subfile_dirname
!= NULL
)
521 subfile_name
= concat (subfile_dirname
, SLASH_STRING
,
522 subfile
->name
, (char *) NULL
);
524 subfile_name
= subfile
->name
;
526 if (FILENAME_CMP (subfile_name
, name
) == 0)
528 m_current_subfile
= subfile
;
529 if (subfile_name
!= subfile
->name
)
530 xfree (subfile_name
);
533 if (subfile_name
!= subfile
->name
)
534 xfree (subfile_name
);
537 /* This subfile is not known. Add an entry for it. */
539 subfile
= XNEW (struct subfile
);
540 memset (subfile
, 0, sizeof (struct subfile
));
541 subfile
->buildsym_compunit
= this;
543 subfile
->next
= m_subfiles
;
544 m_subfiles
= subfile
;
546 m_current_subfile
= subfile
;
548 subfile
->name
= xstrdup (name
);
550 /* Initialize line-number recording for this subfile. */
551 subfile
->line_vector
= NULL
;
553 /* Default the source language to whatever can be deduced from the
554 filename. If nothing can be deduced (such as for a C/C++ include
555 file with a ".h" extension), then inherit whatever language the
556 previous subfile had. This kludgery is necessary because there
557 is no standard way in some object formats to record the source
558 language. Also, when symtabs are allocated we try to deduce a
559 language then as well, but it is too late for us to use that
560 information while reading symbols, since symtabs aren't allocated
561 until after all the symbols have been processed for a given
564 subfile
->language
= deduce_language_from_filename (subfile
->name
);
565 if (subfile
->language
== language_unknown
566 && subfile
->next
!= NULL
)
568 subfile
->language
= subfile
->next
->language
;
571 /* If the filename of this subfile ends in .C, then change the
572 language of any pending subfiles from C to C++. We also accept
573 any other C++ suffixes accepted by deduce_language_from_filename. */
574 /* Likewise for f2c. */
579 enum language sublang
= deduce_language_from_filename (subfile
->name
);
581 if (sublang
== language_cplus
|| sublang
== language_fortran
)
582 for (s
= m_subfiles
; s
!= NULL
; s
= s
->next
)
583 if (s
->language
== language_c
)
584 s
->language
= sublang
;
587 /* And patch up this file if necessary. */
588 if (subfile
->language
== language_c
589 && subfile
->next
!= NULL
590 && (subfile
->next
->language
== language_cplus
591 || subfile
->next
->language
== language_fortran
))
593 subfile
->language
= subfile
->next
->language
;
597 /* For stabs readers, the first N_SO symbol is assumed to be the
598 source file name, and the subfile struct is initialized using that
599 assumption. If another N_SO symbol is later seen, immediately
600 following the first one, then the first one is assumed to be the
601 directory name and the second one is really the source file name.
603 So we have to patch up the subfile struct by moving the old name
604 value to dirname and remembering the new name. Some sanity
605 checking is performed to ensure that the state of the subfile
606 struct is reasonable and that the old name we are assuming to be a
607 directory name actually is (by checking for a trailing '/'). */
610 buildsym_compunit::patch_subfile_names (struct subfile
*subfile
,
614 && m_comp_dir
== NULL
615 && subfile
->name
!= NULL
616 && IS_DIR_SEPARATOR (subfile
->name
[strlen (subfile
->name
) - 1]))
618 m_comp_dir
.reset (subfile
->name
);
619 subfile
->name
= xstrdup (name
);
620 set_last_source_file (name
);
622 /* Default the source language to whatever can be deduced from
623 the filename. If nothing can be deduced (such as for a C/C++
624 include file with a ".h" extension), then inherit whatever
625 language the previous subfile had. This kludgery is
626 necessary because there is no standard way in some object
627 formats to record the source language. Also, when symtabs
628 are allocated we try to deduce a language then as well, but
629 it is too late for us to use that information while reading
630 symbols, since symtabs aren't allocated until after all the
631 symbols have been processed for a given source file. */
633 subfile
->language
= deduce_language_from_filename (subfile
->name
);
634 if (subfile
->language
== language_unknown
635 && subfile
->next
!= NULL
)
637 subfile
->language
= subfile
->next
->language
;
642 /* Handle the N_BINCL and N_EINCL symbol types that act like N_SOL for
643 switching source files (different subfiles, as we call them) within
644 one object file, but using a stack rather than in an arbitrary
648 buildsym_compunit::push_subfile ()
650 gdb_assert (m_current_subfile
!= NULL
);
651 gdb_assert (m_current_subfile
->name
!= NULL
);
652 m_subfile_stack
.push_back (m_current_subfile
->name
);
656 buildsym_compunit::pop_subfile ()
658 gdb_assert (!m_subfile_stack
.empty ());
659 const char *name
= m_subfile_stack
.back ();
660 m_subfile_stack
.pop_back ();
664 /* Add a linetable entry for line number LINE and address PC to the
665 line vector for SUBFILE. */
668 buildsym_compunit::record_line (struct subfile
*subfile
, int line
,
669 CORE_ADDR pc
, bool is_stmt
)
671 struct linetable_entry
*e
;
673 /* Make sure line vector exists and is big enough. */
674 if (!subfile
->line_vector
)
676 subfile
->line_vector_length
= INITIAL_LINE_VECTOR_LENGTH
;
677 subfile
->line_vector
= (struct linetable
*)
678 xmalloc (sizeof (struct linetable
)
679 + subfile
->line_vector_length
* sizeof (struct linetable_entry
));
680 subfile
->line_vector
->nitems
= 0;
681 m_have_line_numbers
= true;
684 if (subfile
->line_vector
->nitems
>= subfile
->line_vector_length
)
686 subfile
->line_vector_length
*= 2;
687 subfile
->line_vector
= (struct linetable
*)
688 xrealloc ((char *) subfile
->line_vector
,
689 (sizeof (struct linetable
)
690 + (subfile
->line_vector_length
691 * sizeof (struct linetable_entry
))));
694 /* The end of sequence marker is special. We need to reset the
695 is_stmt flag on previous lines at the same PC, otherwise these
696 lines may cause problems since they might be at the same address
697 as the following function. For instance suppose a function calls
698 abort there is no reason to emit a ret after that point (no joke).
699 So the label may be at the same address where the following
700 function begins. A similar problem appears if a label is at the
701 same address where an inline function ends we cannot reliably tell
702 if this is considered part of the inline function or the calling
703 program or even the next inline function, so stack traces may
704 give surprising results. Expect gdb.cp/step-and-next-inline.exp
705 to fail if these lines are not modified here. */
706 if (line
== 0 && subfile
->line_vector
->nitems
> 0)
708 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
;
712 if (e
->pc
!= pc
|| e
->line
== 0)
716 while (e
> subfile
->line_vector
->item
);
719 e
= subfile
->line_vector
->item
+ subfile
->line_vector
->nitems
++;
721 e
->is_stmt
= is_stmt
? 1 : 0;
726 /* Subroutine of end_symtab to simplify it. Look for a subfile that
727 matches the main source file's basename. If there is only one, and
728 if the main source file doesn't have any symbol or line number
729 information, then copy this file's symtab and line_vector to the
730 main source file's subfile and discard the other subfile. This can
731 happen because of a compiler bug or from the user playing games
732 with #line or from things like a distributed build system that
733 manipulates the debug info. This can also happen from an innocent
734 symlink in the paths, we don't canonicalize paths here. */
737 buildsym_compunit::watch_main_source_file_lossage ()
739 struct subfile
*mainsub
, *subfile
;
741 /* Get the main source file. */
742 mainsub
= m_main_subfile
;
744 /* If the main source file doesn't have any line number or symbol
745 info, look for an alias in another subfile. */
747 if (mainsub
->line_vector
== NULL
748 && mainsub
->symtab
== NULL
)
750 const char *mainbase
= lbasename (mainsub
->name
);
752 struct subfile
*prevsub
;
753 struct subfile
*mainsub_alias
= NULL
;
754 struct subfile
*prev_mainsub_alias
= NULL
;
757 for (subfile
= m_subfiles
;
759 subfile
= subfile
->next
)
761 if (subfile
== mainsub
)
763 if (filename_cmp (lbasename (subfile
->name
), mainbase
) == 0)
766 mainsub_alias
= subfile
;
767 prev_mainsub_alias
= prevsub
;
774 gdb_assert (mainsub_alias
!= NULL
&& mainsub_alias
!= mainsub
);
776 /* Found a match for the main source file.
777 Copy its line_vector and symtab to the main subfile
778 and then discard it. */
780 mainsub
->line_vector
= mainsub_alias
->line_vector
;
781 mainsub
->line_vector_length
= mainsub_alias
->line_vector_length
;
782 mainsub
->symtab
= mainsub_alias
->symtab
;
784 if (prev_mainsub_alias
== NULL
)
785 m_subfiles
= mainsub_alias
->next
;
787 prev_mainsub_alias
->next
= mainsub_alias
->next
;
788 xfree (mainsub_alias
->name
);
789 xfree (mainsub_alias
);
794 /* Implementation of the first part of end_symtab. It allows modifying
795 STATIC_BLOCK before it gets finalized by end_symtab_from_static_block.
796 If the returned value is NULL there is no blockvector created for
797 this symtab (you still must call end_symtab_from_static_block).
799 END_ADDR is the same as for end_symtab: the address of the end of the
802 If EXPANDABLE is non-zero the STATIC_BLOCK dictionary is made
805 If REQUIRED is non-zero, then a symtab is created even if it does
806 not contain any symbols. */
809 buildsym_compunit::end_symtab_get_static_block (CORE_ADDR end_addr
,
810 int expandable
, int required
)
812 /* Finish the lexical context of the last function in the file; pop
813 the context stack. */
815 if (!m_context_stack
.empty ())
817 struct context_stack cstk
= pop_context ();
819 /* Make a block for the local symbols within. */
820 finish_block (cstk
.name
, cstk
.old_blocks
, NULL
,
821 cstk
.start_addr
, end_addr
);
823 if (!m_context_stack
.empty ())
825 /* This is said to happen with SCO. The old coffread.c
826 code simply emptied the context stack, so we do the
827 same. FIXME: Find out why it is happening. This is not
828 believed to happen in most cases (even for coffread.c);
829 it used to be an abort(). */
830 complaint (_("Context stack not empty in end_symtab"));
831 m_context_stack
.clear ();
835 /* Reordered executables may have out of order pending blocks; if
836 OBJF_REORDERED is true, then sort the pending blocks. */
838 if ((m_objfile
->flags
& OBJF_REORDERED
) && m_pending_blocks
)
840 struct pending_block
*pb
;
842 std::vector
<block
*> barray
;
844 for (pb
= m_pending_blocks
; pb
!= NULL
; pb
= pb
->next
)
845 barray
.push_back (pb
->block
);
847 /* Sort blocks by start address in descending order. Blocks with the
848 same start address must remain in the original order to preserve
849 inline function caller/callee relationships. */
850 std::stable_sort (barray
.begin (), barray
.end (),
851 [] (const block
*a
, const block
*b
)
853 return BLOCK_START (a
) > BLOCK_START (b
);
857 for (pb
= m_pending_blocks
; pb
!= NULL
; pb
= pb
->next
)
858 pb
->block
= barray
[i
++];
861 /* Cleanup any undefined types that have been left hanging around
862 (this needs to be done before the finish_blocks so that
863 file_symbols is still good).
865 Both cleanup_undefined_stabs_types and finish_global_stabs are stabs
866 specific, but harmless for other symbol readers, since on gdb
867 startup or when finished reading stabs, the state is set so these
868 are no-ops. FIXME: Is this handled right in case of QUIT? Can
869 we make this cleaner? */
871 cleanup_undefined_stabs_types (m_objfile
);
872 finish_global_stabs (m_objfile
);
875 && m_pending_blocks
== NULL
876 && m_file_symbols
== NULL
877 && m_global_symbols
== NULL
878 && !m_have_line_numbers
879 && m_pending_macros
== NULL
880 && m_global_using_directives
== NULL
)
882 /* Ignore symtabs that have no functions with real debugging info. */
887 /* Define the STATIC_BLOCK. */
888 return finish_block_internal (NULL
, get_file_symbols (), NULL
, NULL
,
889 m_last_source_start_addr
,
890 end_addr
, 0, expandable
);
894 /* Subroutine of end_symtab_from_static_block to simplify it.
895 Handle the "have blockvector" case.
896 See end_symtab_from_static_block for a description of the arguments. */
898 struct compunit_symtab
*
899 buildsym_compunit::end_symtab_with_blockvector (struct block
*static_block
,
900 int section
, int expandable
)
902 struct compunit_symtab
*cu
= m_compunit_symtab
;
903 struct blockvector
*blockvector
;
904 struct subfile
*subfile
;
907 gdb_assert (static_block
!= NULL
);
908 gdb_assert (m_subfiles
!= NULL
);
910 end_addr
= BLOCK_END (static_block
);
912 /* Create the GLOBAL_BLOCK and build the blockvector. */
913 finish_block_internal (NULL
, get_global_symbols (), NULL
, NULL
,
914 m_last_source_start_addr
, end_addr
,
916 blockvector
= make_blockvector ();
918 /* Read the line table if it has to be read separately.
919 This is only used by xcoffread.c. */
920 if (m_objfile
->sf
->sym_read_linetable
!= NULL
)
921 m_objfile
->sf
->sym_read_linetable (m_objfile
);
923 /* Handle the case where the debug info specifies a different path
924 for the main source file. It can cause us to lose track of its
925 line number information. */
926 watch_main_source_file_lossage ();
928 /* Now create the symtab objects proper, if not already done,
929 one for each subfile. */
931 for (subfile
= m_subfiles
;
933 subfile
= subfile
->next
)
935 int linetablesize
= 0;
937 if (subfile
->line_vector
)
939 linetablesize
= sizeof (struct linetable
) +
940 subfile
->line_vector
->nitems
* sizeof (struct linetable_entry
);
942 const auto lte_is_less_than
943 = [] (const linetable_entry
&ln1
,
944 const linetable_entry
&ln2
) -> bool
946 return (ln1
.pc
< ln2
.pc
);
949 /* Like the pending blocks, the line table may be scrambled in
950 reordered executables. Sort it if OBJF_REORDERED is true. It
951 is important to preserve the order of lines at the same
952 address, as this maintains the inline function caller/callee
953 relationships, this is why std::stable_sort is used. */
954 if (m_objfile
->flags
& OBJF_REORDERED
)
955 std::stable_sort (subfile
->line_vector
->item
,
956 subfile
->line_vector
->item
957 + subfile
->line_vector
->nitems
,
961 /* Allocate a symbol table if necessary. */
962 if (subfile
->symtab
== NULL
)
963 subfile
->symtab
= allocate_symtab (cu
, subfile
->name
);
964 struct symtab
*symtab
= subfile
->symtab
;
966 /* Fill in its components. */
968 if (subfile
->line_vector
)
970 /* Reallocate the line table on the symbol obstack. */
971 SYMTAB_LINETABLE (symtab
) = (struct linetable
*)
972 obstack_alloc (&m_objfile
->objfile_obstack
, linetablesize
);
973 memcpy (SYMTAB_LINETABLE (symtab
), subfile
->line_vector
,
978 SYMTAB_LINETABLE (symtab
) = NULL
;
981 /* Use whatever language we have been using for this
982 subfile, not the one that was deduced in allocate_symtab
983 from the filename. We already did our own deducing when
984 we created the subfile, and we may have altered our
985 opinion of what language it is from things we found in
987 symtab
->language
= subfile
->language
;
990 /* Make sure the symtab of main_subfile is the first in its list. */
992 struct symtab
*main_symtab
, *prev_symtab
;
994 main_symtab
= m_main_subfile
->symtab
;
996 for (symtab
*symtab
: compunit_filetabs (cu
))
998 if (symtab
== main_symtab
)
1000 if (prev_symtab
!= NULL
)
1002 prev_symtab
->next
= main_symtab
->next
;
1003 main_symtab
->next
= COMPUNIT_FILETABS (cu
);
1004 COMPUNIT_FILETABS (cu
) = main_symtab
;
1008 prev_symtab
= symtab
;
1010 gdb_assert (main_symtab
== COMPUNIT_FILETABS (cu
));
1013 /* Fill out the compunit symtab. */
1015 if (m_comp_dir
!= NULL
)
1017 /* Reallocate the dirname on the symbol obstack. */
1018 const char *comp_dir
= m_comp_dir
.get ();
1019 COMPUNIT_DIRNAME (cu
) = obstack_strdup (&m_objfile
->objfile_obstack
,
1023 /* Save the debug format string (if any) in the symtab. */
1024 COMPUNIT_DEBUGFORMAT (cu
) = m_debugformat
;
1026 /* Similarly for the producer. */
1027 COMPUNIT_PRODUCER (cu
) = m_producer
;
1029 COMPUNIT_BLOCKVECTOR (cu
) = blockvector
;
1031 struct block
*b
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
1033 set_block_compunit_symtab (b
, cu
);
1036 COMPUNIT_BLOCK_LINE_SECTION (cu
) = section
;
1038 COMPUNIT_MACRO_TABLE (cu
) = release_macros ();
1040 /* Default any symbols without a specified symtab to the primary symtab. */
1044 /* The main source file's symtab. */
1045 struct symtab
*symtab
= COMPUNIT_FILETABS (cu
);
1047 for (block_i
= 0; block_i
< BLOCKVECTOR_NBLOCKS (blockvector
); block_i
++)
1049 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, block_i
);
1051 struct mdict_iterator miter
;
1053 /* Inlined functions may have symbols not in the global or
1054 static symbol lists. */
1055 if (BLOCK_FUNCTION (block
) != NULL
)
1056 if (symbol_symtab (BLOCK_FUNCTION (block
)) == NULL
)
1057 symbol_set_symtab (BLOCK_FUNCTION (block
), symtab
);
1059 /* Note that we only want to fix up symbols from the local
1060 blocks, not blocks coming from included symtabs. That is why
1061 we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
1062 ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block
), miter
, sym
)
1063 if (symbol_symtab (sym
) == NULL
)
1064 symbol_set_symtab (sym
, symtab
);
1068 add_compunit_symtab_to_objfile (cu
);
1073 /* Implementation of the second part of end_symtab. Pass STATIC_BLOCK
1074 as value returned by end_symtab_get_static_block.
1076 SECTION is the same as for end_symtab: the section number
1077 (in objfile->section_offsets) of the blockvector and linetable.
1079 If EXPANDABLE is non-zero the GLOBAL_BLOCK dictionary is made
1082 struct compunit_symtab
*
1083 buildsym_compunit::end_symtab_from_static_block (struct block
*static_block
,
1084 int section
, int expandable
)
1086 struct compunit_symtab
*cu
;
1088 if (static_block
== NULL
)
1090 /* Handle the "no blockvector" case.
1091 When this happens there is nothing to record, so there's nothing
1092 to do: memory will be freed up later.
1094 Note: We won't be adding a compunit to the objfile's list of
1095 compunits, so there's nothing to unchain. However, since each symtab
1096 is added to the objfile's obstack we can't free that space.
1097 We could do better, but this is believed to be a sufficiently rare
1102 cu
= end_symtab_with_blockvector (static_block
, section
, expandable
);
1107 /* Finish the symbol definitions for one main source file, close off
1108 all the lexical contexts for that file (creating struct block's for
1109 them), then make the struct symtab for that file and put it in the
1112 END_ADDR is the address of the end of the file's text. SECTION is
1113 the section number (in objfile->section_offsets) of the blockvector
1116 Note that it is possible for end_symtab() to return NULL. In
1117 particular, for the DWARF case at least, it will return NULL when
1118 it finds a compilation unit that has exactly one DIE, a
1119 TAG_compile_unit DIE. This can happen when we link in an object
1120 file that was compiled from an empty source file. Returning NULL
1121 is probably not the correct thing to do, because then gdb will
1122 never know about this empty file (FIXME).
1124 If you need to modify STATIC_BLOCK before it is finalized you should
1125 call end_symtab_get_static_block and end_symtab_from_static_block
1128 struct compunit_symtab
*
1129 buildsym_compunit::end_symtab (CORE_ADDR end_addr
, int section
)
1131 struct block
*static_block
;
1133 static_block
= end_symtab_get_static_block (end_addr
, 0, 0);
1134 return end_symtab_from_static_block (static_block
, section
, 0);
1137 /* Same as end_symtab except create a symtab that can be later added to. */
1139 struct compunit_symtab
*
1140 buildsym_compunit::end_expandable_symtab (CORE_ADDR end_addr
, int section
)
1142 struct block
*static_block
;
1144 static_block
= end_symtab_get_static_block (end_addr
, 1, 0);
1145 return end_symtab_from_static_block (static_block
, section
, 1);
1148 /* Subroutine of augment_type_symtab to simplify it.
1149 Attach the main source file's symtab to all symbols in PENDING_LIST that
1153 set_missing_symtab (struct pending
*pending_list
,
1154 struct compunit_symtab
*cu
)
1156 struct pending
*pending
;
1159 for (pending
= pending_list
; pending
!= NULL
; pending
= pending
->next
)
1161 for (i
= 0; i
< pending
->nsyms
; ++i
)
1163 if (symbol_symtab (pending
->symbol
[i
]) == NULL
)
1164 symbol_set_symtab (pending
->symbol
[i
], COMPUNIT_FILETABS (cu
));
1169 /* Same as end_symtab, but for the case where we're adding more symbols
1170 to an existing symtab that is known to contain only type information.
1171 This is the case for DWARF4 Type Units. */
1174 buildsym_compunit::augment_type_symtab ()
1176 struct compunit_symtab
*cust
= m_compunit_symtab
;
1177 const struct blockvector
*blockvector
= COMPUNIT_BLOCKVECTOR (cust
);
1179 if (!m_context_stack
.empty ())
1180 complaint (_("Context stack not empty in augment_type_symtab"));
1181 if (m_pending_blocks
!= NULL
)
1182 complaint (_("Blocks in a type symtab"));
1183 if (m_pending_macros
!= NULL
)
1184 complaint (_("Macro in a type symtab"));
1185 if (m_have_line_numbers
)
1186 complaint (_("Line numbers recorded in a type symtab"));
1188 if (m_file_symbols
!= NULL
)
1190 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, STATIC_BLOCK
);
1192 /* First mark any symbols without a specified symtab as belonging
1193 to the primary symtab. */
1194 set_missing_symtab (m_file_symbols
, cust
);
1196 mdict_add_pending (BLOCK_MULTIDICT (block
), m_file_symbols
);
1199 if (m_global_symbols
!= NULL
)
1201 struct block
*block
= BLOCKVECTOR_BLOCK (blockvector
, GLOBAL_BLOCK
);
1203 /* First mark any symbols without a specified symtab as belonging
1204 to the primary symtab. */
1205 set_missing_symtab (m_global_symbols
, cust
);
1207 mdict_add_pending (BLOCK_MULTIDICT (block
),
1212 /* Push a context block. Args are an identifying nesting level
1213 (checkable when you pop it), and the starting PC address of this
1216 struct context_stack
*
1217 buildsym_compunit::push_context (int desc
, CORE_ADDR valu
)
1219 m_context_stack
.emplace_back ();
1220 struct context_stack
*newobj
= &m_context_stack
.back ();
1222 newobj
->depth
= desc
;
1223 newobj
->locals
= m_local_symbols
;
1224 newobj
->old_blocks
= m_pending_blocks
;
1225 newobj
->start_addr
= valu
;
1226 newobj
->local_using_directives
= m_local_using_directives
;
1227 newobj
->name
= NULL
;
1229 m_local_symbols
= NULL
;
1230 m_local_using_directives
= NULL
;
1235 /* Pop a context block. Returns the address of the context block just
1238 struct context_stack
1239 buildsym_compunit::pop_context ()
1241 gdb_assert (!m_context_stack
.empty ());
1242 struct context_stack result
= m_context_stack
.back ();
1243 m_context_stack
.pop_back ();