1 /* Block-related functions for the GNU debugger, GDB.
3 Copyright (C) 2003-2024 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdbsupport/gdb_obstack.h"
25 #include "cp-support.h"
30 /* This is used by struct block to store namespace-related info for
31 C++ files, namely using declarations and the current namespace in
34 struct block_namespace_info
: public allocate_on_obstack
36 const char *scope
= nullptr;
37 struct using_direct
*using_decl
= nullptr;
43 block::objfile () const
45 const struct global_block
*global_block
;
47 if (function () != nullptr)
48 return function ()->objfile ();
50 global_block
= (struct global_block
*) this->global_block ();
51 return global_block
->compunit_symtab
->objfile ();
57 block::gdbarch () const
59 if (function () != nullptr)
60 return function ()->arch ();
62 return objfile ()->arch ();
68 block::contains (const struct block
*a
, bool allow_nested
) const
77 /* If A is a function block, then A cannot be contained in B,
78 except if A was inlined. */
79 if (!allow_nested
&& a
->function () != NULL
&& !a
->inlined_p ())
91 block::linkage_function () const
93 const block
*bl
= this;
95 while ((bl
->function () == NULL
|| bl
->inlined_p ())
96 && bl
->superblock () != NULL
)
97 bl
= bl
->superblock ();
99 return bl
->function ();
105 block::containing_function () const
107 const block
*bl
= this;
109 while (bl
->function () == NULL
&& bl
->superblock () != NULL
)
110 bl
= bl
->superblock ();
112 return bl
->function ();
118 block::inlined_p () const
120 return function () != nullptr && function ()->is_inlined ();
123 /* A helper function that checks whether PC is in the blockvector BL.
124 It returns the containing block if there is one, or else NULL. */
126 static const struct block
*
127 find_block_in_blockvector (const struct blockvector
*bl
, CORE_ADDR pc
)
129 const struct block
*b
;
132 /* If we have an addrmap mapping code addresses to blocks, then use
135 return (const struct block
*) bl
->map ()->find (pc
);
137 /* Otherwise, use binary search to find the last block that starts
139 Note: GLOBAL_BLOCK is block 0, STATIC_BLOCK is block 1.
140 They both have the same START,END values.
141 Historically this code would choose STATIC_BLOCK over GLOBAL_BLOCK but the
142 fact that this choice was made was subtle, now we make it explicit. */
143 gdb_assert (bl
->blocks ().size () >= 2);
145 top
= bl
->blocks ().size ();
147 while (top
- bot
> 1)
149 half
= (top
- bot
+ 1) >> 1;
150 b
= bl
->block (bot
+ half
);
151 if (b
->start () <= pc
)
157 /* Now search backward for a block that ends after PC. */
159 while (bot
>= STATIC_BLOCK
)
162 if (!(b
->start () <= pc
))
172 /* Return the blockvector immediately containing the innermost lexical
173 block containing the specified pc value and section, or 0 if there
174 is none. PBLOCK is a pointer to the block. If PBLOCK is NULL, we
175 don't pass this information back to the caller. */
177 const struct blockvector
*
178 blockvector_for_pc_sect (CORE_ADDR pc
, struct obj_section
*section
,
179 const struct block
**pblock
,
180 struct compunit_symtab
*cust
)
182 const struct blockvector
*bl
;
183 const struct block
*b
;
187 /* First search all symtabs for one whose file contains our pc */
188 cust
= find_pc_sect_compunit_symtab (pc
, section
);
193 bl
= cust
->blockvector ();
195 /* Then search that symtab for the smallest block that wins. */
196 b
= find_block_in_blockvector (bl
, pc
);
205 /* Return true if the blockvector BV contains PC, false otherwise. */
208 blockvector_contains_pc (const struct blockvector
*bv
, CORE_ADDR pc
)
210 return find_block_in_blockvector (bv
, pc
) != NULL
;
213 /* Return call_site for specified PC in GDBARCH. PC must match exactly, it
214 must be the next instruction after call (or after tail call jump). Throw
215 NO_ENTRY_VALUE_ERROR otherwise. This function never returns NULL. */
218 call_site_for_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
220 struct compunit_symtab
*cust
;
221 call_site
*cs
= nullptr;
223 /* -1 as tail call PC can be already after the compilation unit range. */
224 cust
= find_pc_compunit_symtab (pc
- 1);
227 cs
= cust
->find_call_site (pc
);
231 struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (pc
);
233 /* DW_TAG_gnu_call_site will be missing just if GCC could not determine
235 throw_error (NO_ENTRY_VALUE_ERROR
,
236 _("DW_OP_entry_value resolving cannot find "
237 "DW_TAG_call_site %s in %s"),
238 paddress (gdbarch
, pc
),
239 (msym
.minsym
== NULL
? "???"
240 : msym
.minsym
->print_name ()));
246 /* Return the blockvector immediately containing the innermost lexical block
247 containing the specified pc value, or 0 if there is none.
248 Backward compatibility, no section. */
250 const struct blockvector
*
251 blockvector_for_pc (CORE_ADDR pc
, const struct block
**pblock
)
253 return blockvector_for_pc_sect (pc
, find_pc_mapped_section (pc
),
257 /* Return the innermost lexical block containing the specified pc value
258 in the specified section, or 0 if there is none. */
261 block_for_pc_sect (CORE_ADDR pc
, struct obj_section
*section
)
263 const struct blockvector
*bl
;
264 const struct block
*b
;
266 bl
= blockvector_for_pc_sect (pc
, section
, &b
, NULL
);
272 /* Return the innermost lexical block containing the specified pc value,
273 or 0 if there is none. Backward compatibility, no section. */
276 block_for_pc (CORE_ADDR pc
)
278 return block_for_pc_sect (pc
, find_pc_mapped_section (pc
));
281 /* Now come some functions designed to deal with C++ namespace issues.
282 The accessors are safe to use even in the non-C++ case. */
287 block::scope () const
289 for (const block
*block
= this;
291 block
= block
->superblock ())
293 if (block
->m_namespace_info
!= nullptr
294 && block
->m_namespace_info
->scope
!= nullptr)
295 return block
->m_namespace_info
->scope
;
304 block::initialize_namespace (struct obstack
*obstack
)
306 if (m_namespace_info
== nullptr)
307 m_namespace_info
= new (obstack
) struct block_namespace_info
;
313 block::set_scope (const char *scope
, struct obstack
*obstack
)
315 if (scope
== nullptr || scope
[0] == '\0')
321 initialize_namespace (obstack
);
322 m_namespace_info
->scope
= scope
;
327 struct using_direct
*
328 block::get_using () const
330 if (m_namespace_info
== nullptr)
333 return m_namespace_info
->using_decl
;
339 block::set_using (struct using_direct
*using_decl
, struct obstack
*obstack
)
341 if (using_decl
== nullptr)
347 initialize_namespace (obstack
);
348 m_namespace_info
->using_decl
= using_decl
;
354 block::static_block () const
356 if (superblock () == nullptr)
359 const block
*block
= this;
360 while (block
->superblock ()->superblock () != NULL
)
361 block
= block
->superblock ();
369 block::global_block () const
371 const block
*block
= this;
373 while (block
->superblock () != NULL
)
374 block
= block
->superblock ();
382 block::function_block () const
384 const block
*block
= this;
386 while (block
!= nullptr && block
->function () == nullptr)
387 block
= block
->superblock ();
395 block::set_compunit_symtab (struct compunit_symtab
*cu
)
397 struct global_block
*gb
;
399 gdb_assert (superblock () == NULL
);
400 gb
= (struct global_block
*) this;
401 gdb_assert (gb
->compunit_symtab
== NULL
);
402 gb
->compunit_symtab
= cu
;
407 struct dynamic_prop
*
408 block::static_link () const
410 struct objfile
*objfile
= this->objfile ();
412 /* Only objfile-owned blocks that materialize top function scopes can have
414 if (objfile
== NULL
|| function () == NULL
)
417 return (struct dynamic_prop
*) objfile_lookup_static_link (objfile
, this);
420 /* Return the compunit of the global block. */
422 static struct compunit_symtab
*
423 get_block_compunit_symtab (const struct block
*block
)
425 struct global_block
*gb
;
427 gdb_assert (block
->superblock () == NULL
);
428 gb
= (struct global_block
*) block
;
429 gdb_assert (gb
->compunit_symtab
!= NULL
);
430 return gb
->compunit_symtab
;
435 /* Initialize a block iterator, either to iterate over a single block,
436 or, for static and global blocks, all the included symtabs as
440 initialize_block_iterator (const struct block
*block
,
441 struct block_iterator
*iter
,
442 const lookup_name_info
*name
= nullptr)
444 enum block_enum which
;
445 struct compunit_symtab
*cu
;
450 if (block
->superblock () == NULL
)
452 which
= GLOBAL_BLOCK
;
453 cu
= get_block_compunit_symtab (block
);
455 else if (block
->superblock ()->superblock () == NULL
)
457 which
= STATIC_BLOCK
;
458 cu
= get_block_compunit_symtab (block
->superblock ());
462 iter
->d
.block
= block
;
463 /* A signal value meaning that we're iterating over a single
465 iter
->which
= FIRST_LOCAL_BLOCK
;
469 /* If this is an included symtab, find the canonical includer and
471 while (cu
->user
!= NULL
)
474 /* Putting this check here simplifies the logic of the iterator
475 functions. If there are no included symtabs, we only need to
476 search a single block, so we might as well just do that
478 if (cu
->includes
== NULL
)
480 iter
->d
.block
= block
;
481 /* A signal value meaning that we're iterating over a single
483 iter
->which
= FIRST_LOCAL_BLOCK
;
487 iter
->d
.compunit_symtab
= cu
;
492 /* A helper function that finds the current compunit over whose static
493 or global block we should iterate. */
495 static struct compunit_symtab
*
496 find_iterator_compunit_symtab (struct block_iterator
*iterator
)
498 if (iterator
->idx
== -1)
499 return iterator
->d
.compunit_symtab
;
500 return iterator
->d
.compunit_symtab
->includes
[iterator
->idx
];
503 /* Perform a single step for a plain block iterator, iterating across
504 symbol tables as needed. Returns the next symbol, or NULL when
505 iteration is complete. */
507 static struct symbol
*
508 block_iterator_step (struct block_iterator
*iterator
, int first
)
512 gdb_assert (iterator
->which
!= FIRST_LOCAL_BLOCK
);
518 struct compunit_symtab
*cust
519 = find_iterator_compunit_symtab (iterator
);
520 const struct block
*block
;
522 /* Iteration is complete. */
526 block
= cust
->blockvector ()->block (iterator
->which
);
527 sym
= mdict_iterator_first (block
->multidict (),
528 &iterator
->mdict_iter
);
531 sym
= mdict_iterator_next (&iterator
->mdict_iter
);
536 /* We have finished iterating the appropriate block of one
537 symtab. Now advance to the next symtab and begin iteration
544 /* Perform a single step for a "match" block iterator, iterating
545 across symbol tables as needed. Returns the next symbol, or NULL
546 when iteration is complete. */
548 static struct symbol
*
549 block_iter_match_step (struct block_iterator
*iterator
,
554 gdb_assert (iterator
->which
!= FIRST_LOCAL_BLOCK
);
560 struct compunit_symtab
*cust
561 = find_iterator_compunit_symtab (iterator
);
562 const struct block
*block
;
564 /* Iteration is complete. */
568 block
= cust
->blockvector ()->block (iterator
->which
);
569 sym
= mdict_iter_match_first (block
->multidict (), *iterator
->name
,
570 &iterator
->mdict_iter
);
573 sym
= mdict_iter_match_next (*iterator
->name
, &iterator
->mdict_iter
);
578 /* We have finished iterating the appropriate block of one
579 symtab. Now advance to the next symtab and begin iteration
589 block_iterator_first (const struct block
*block
,
590 struct block_iterator
*iterator
,
591 const lookup_name_info
*name
)
593 initialize_block_iterator (block
, iterator
, name
);
597 if (iterator
->which
== FIRST_LOCAL_BLOCK
)
598 return mdict_iterator_first (block
->multidict (),
599 &iterator
->mdict_iter
);
601 return block_iterator_step (iterator
, 1);
604 if (iterator
->which
== FIRST_LOCAL_BLOCK
)
605 return mdict_iter_match_first (block
->multidict (), *name
,
606 &iterator
->mdict_iter
);
608 return block_iter_match_step (iterator
, 1);
614 block_iterator_next (struct block_iterator
*iterator
)
616 if (iterator
->name
== nullptr)
618 if (iterator
->which
== FIRST_LOCAL_BLOCK
)
619 return mdict_iterator_next (&iterator
->mdict_iter
);
621 return block_iterator_step (iterator
, 0);
624 if (iterator
->which
== FIRST_LOCAL_BLOCK
)
625 return mdict_iter_match_next (*iterator
->name
, &iterator
->mdict_iter
);
627 return block_iter_match_step (iterator
, 0);
633 best_symbol (struct symbol
*a
, const domain_search_flags domain
)
635 if (a
->aclass () == LOC_UNRESOLVED
)
638 if ((domain
& SEARCH_VAR_DOMAIN
) != 0)
639 return a
->domain () == VAR_DOMAIN
;
641 return a
->matches (domain
);
647 better_symbol (struct symbol
*a
, struct symbol
*b
,
648 const domain_search_flags domain
)
655 if (a
->matches (domain
) && !b
->matches (domain
))
658 if (b
->matches (domain
) && !a
->matches (domain
))
661 if (a
->aclass () != LOC_UNRESOLVED
&& b
->aclass () == LOC_UNRESOLVED
)
664 if (b
->aclass () != LOC_UNRESOLVED
&& a
->aclass () == LOC_UNRESOLVED
)
672 Note that if NAME is the demangled form of a C++ symbol, we will fail
673 to find a match during the binary search of the non-encoded names, but
674 for now we don't worry about the slight inefficiency of looking for
675 a match we'll never find, since it will go pretty quick. Once the
676 binary search terminates, we drop through and do a straight linear
677 search on the symbols. Each symbol which is marked as being a ObjC/C++
678 symbol (language_cplus or language_objc set) has both the encoded and
679 non-encoded names tested for a match. */
682 block_lookup_symbol (const struct block
*block
, const char *name
,
683 symbol_name_match_type match_type
,
684 const domain_search_flags domain
)
686 lookup_name_info
lookup_name (name
, match_type
);
688 if (!block
->function ())
690 struct symbol
*other
= NULL
;
692 for (struct symbol
*sym
: block_iterator_range (block
, &lookup_name
))
694 /* See comment related to PR gcc/debug/91507 in
695 block_lookup_symbol_primary. */
696 if (best_symbol (sym
, domain
))
698 /* This is a bit of a hack, but symbol_matches_domain might ignore
699 STRUCT vs VAR domain symbols. So if a matching symbol is found,
700 make sure there is no "better" matching symbol, i.e., one with
701 exactly the same domain. PR 16253. */
702 if (sym
->matches (domain
))
703 other
= better_symbol (other
, sym
, domain
);
709 /* Note that parameter symbols do not always show up last in the
710 list; this loop makes sure to take anything else other than
711 parameter symbols first; it only uses parameter symbols as a
712 last resort. Note that this only takes up extra computation
714 It's hard to define types in the parameter list (at least in
715 C/C++) so we don't do the same PR 16253 hack here that is done
716 for the !BLOCK_FUNCTION case. */
718 struct symbol
*sym_found
= NULL
;
720 for (struct symbol
*sym
: block_iterator_range (block
, &lookup_name
))
722 if (sym
->matches (domain
))
725 if (!sym
->is_argument ())
731 return (sym_found
); /* Will be NULL if not found. */
738 block_lookup_symbol_primary (const struct block
*block
, const char *name
,
739 const domain_search_flags domain
)
741 struct symbol
*sym
, *other
;
742 struct mdict_iterator mdict_iter
;
744 lookup_name_info
lookup_name (name
, symbol_name_match_type::FULL
);
746 /* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK. */
747 gdb_assert (block
->superblock () == NULL
748 || block
->superblock ()->superblock () == NULL
);
751 for (sym
= mdict_iter_match_first (block
->multidict (), lookup_name
,
754 sym
= mdict_iter_match_next (lookup_name
, &mdict_iter
))
756 /* With the fix for PR gcc/debug/91507, we get for:
764 DWARF which will result in two entries in the symbol table, a decl
765 with type char *[] and a def with type char *[2].
767 If we return the decl here, we don't get the value of zzz:
769 $ gdb a.spec.out -batch -ex "p zzz"
772 because we're returning the symbol without location information, and
773 because the fallback that uses the address from the minimal symbols
774 doesn't work either because the type of the decl does not specify a
777 To fix this, we prefer def over decl in best_symbol and
780 In absence of the gcc fix, both def and decl have type char *[], so
781 the only option to make this work is improve the fallback to use the
782 size of the minimal symbol. Filed as PR exp/24989. */
783 if (best_symbol (sym
, domain
))
786 /* This is a bit of a hack, but 'matches' might ignore
787 STRUCT vs VAR domain symbols. So if a matching symbol is found,
788 make sure there is no "better" matching symbol, i.e., one with
789 exactly the same domain. PR 16253. */
790 if (sym
->matches (domain
))
791 other
= better_symbol (other
, sym
, domain
);
800 block_find_symbol (const struct block
*block
, const lookup_name_info
&name
,
801 const domain_search_flags domain
, struct symbol
**stub
)
803 /* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK. */
804 gdb_assert (block
->superblock () == NULL
805 || block
->superblock ()->superblock () == NULL
);
807 for (struct symbol
*sym
: block_iterator_range (block
, &name
))
809 if (!sym
->matches (domain
))
812 if (!TYPE_IS_OPAQUE (sym
->type ()))
824 make_blockranges (struct objfile
*objfile
,
825 const std::vector
<blockrange
> &rangevec
)
827 struct blockranges
*blr
;
828 size_t n
= rangevec
.size();
830 blr
= (struct blockranges
*)
831 obstack_alloc (&objfile
->objfile_obstack
,
832 sizeof (struct blockranges
)
833 + (n
- 1) * sizeof (struct blockrange
));
836 for (int i
= 0; i
< n
; i
++)
837 blr
->range
[i
] = rangevec
[i
];