1 /* Block-related functions for the GNU debugger, GDB.
3 Copyright (C) 2003-2014 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 "gdb_obstack.h"
25 #include "cp-support.h"
29 /* This is used by struct block to store namespace-related info for
30 C++ files, namely using declarations and the current namespace in
33 struct block_namespace_info
36 struct using_direct *using;
39 static void block_initialize_namespace (struct block *block,
40 struct obstack *obstack);
42 /* Return Nonzero if block a is lexically nested within block b,
43 or if a and b have the same pc range.
44 Return zero otherwise. */
47 contained_in (const struct block *a, const struct block *b)
56 /* If A is a function block, then A cannot be contained in B,
57 except if A was inlined. */
58 if (BLOCK_FUNCTION (a) != NULL && !block_inlined_p (a))
60 a = BLOCK_SUPERBLOCK (a);
68 /* Return the symbol for the function which contains a specified
69 lexical block, described by a struct block BL. The return value
70 will not be an inlined function; the containing function will be
74 block_linkage_function (const struct block *bl)
76 while ((BLOCK_FUNCTION (bl) == NULL || block_inlined_p (bl))
77 && BLOCK_SUPERBLOCK (bl) != NULL)
78 bl = BLOCK_SUPERBLOCK (bl);
80 return BLOCK_FUNCTION (bl);
83 /* Return the symbol for the function which contains a specified
84 block, described by a struct block BL. The return value will be
85 the closest enclosing function, which might be an inline
89 block_containing_function (const struct block *bl)
91 while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
92 bl = BLOCK_SUPERBLOCK (bl);
94 return BLOCK_FUNCTION (bl);
97 /* Return one if BL represents an inlined function. */
100 block_inlined_p (const struct block *bl)
102 return BLOCK_FUNCTION (bl) != NULL && SYMBOL_INLINED (BLOCK_FUNCTION (bl));
105 /* A helper function that checks whether PC is in the blockvector BL.
106 It returns the containing block if there is one, or else NULL. */
108 static struct block *
109 find_block_in_blockvector (const struct blockvector *bl, CORE_ADDR pc)
114 /* If we have an addrmap mapping code addresses to blocks, then use
116 if (BLOCKVECTOR_MAP (bl))
117 return addrmap_find (BLOCKVECTOR_MAP (bl), pc);
119 /* Otherwise, use binary search to find the last block that starts
121 Note: GLOBAL_BLOCK is block 0, STATIC_BLOCK is block 1.
122 They both have the same START,END values.
123 Historically this code would choose STATIC_BLOCK over GLOBAL_BLOCK but the
124 fact that this choice was made was subtle, now we make it explicit. */
125 gdb_assert (BLOCKVECTOR_NBLOCKS (bl) >= 2);
127 top = BLOCKVECTOR_NBLOCKS (bl);
129 while (top - bot > 1)
131 half = (top - bot + 1) >> 1;
132 b = BLOCKVECTOR_BLOCK (bl, bot + half);
133 if (BLOCK_START (b) <= pc)
139 /* Now search backward for a block that ends after PC. */
141 while (bot >= STATIC_BLOCK)
143 b = BLOCKVECTOR_BLOCK (bl, bot);
144 if (BLOCK_END (b) > pc)
152 /* Return the blockvector immediately containing the innermost lexical
153 block containing the specified pc value and section, or 0 if there
154 is none. PBLOCK is a pointer to the block. If PBLOCK is NULL, we
155 don't pass this information back to the caller. */
157 const struct blockvector *
158 blockvector_for_pc_sect (CORE_ADDR pc, struct obj_section *section,
159 const struct block **pblock,
160 struct compunit_symtab *cust)
162 const struct blockvector *bl;
167 /* First search all symtabs for one whose file contains our pc */
168 cust = find_pc_sect_compunit_symtab (pc, section);
173 bl = COMPUNIT_BLOCKVECTOR (cust);
175 /* Then search that symtab for the smallest block that wins. */
176 b = find_block_in_blockvector (bl, pc);
185 /* Return true if the blockvector BV contains PC, false otherwise. */
188 blockvector_contains_pc (const struct blockvector *bv, CORE_ADDR pc)
190 return find_block_in_blockvector (bv, pc) != NULL;
193 /* Return call_site for specified PC in GDBARCH. PC must match exactly, it
194 must be the next instruction after call (or after tail call jump). Throw
195 NO_ENTRY_VALUE_ERROR otherwise. This function never returns NULL. */
198 call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
200 struct compunit_symtab *cust;
203 /* -1 as tail call PC can be already after the compilation unit range. */
204 cust = find_pc_compunit_symtab (pc - 1);
206 if (cust != NULL && COMPUNIT_CALL_SITE_HTAB (cust) != NULL)
207 slot = htab_find_slot (COMPUNIT_CALL_SITE_HTAB (cust), &pc, NO_INSERT);
211 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (pc);
213 /* DW_TAG_gnu_call_site will be missing just if GCC could not determine
215 throw_error (NO_ENTRY_VALUE_ERROR,
216 _("DW_OP_GNU_entry_value resolving cannot find "
217 "DW_TAG_GNU_call_site %s in %s"),
218 paddress (gdbarch, pc),
219 (msym.minsym == NULL ? "???"
220 : MSYMBOL_PRINT_NAME (msym.minsym)));
226 /* Return the blockvector immediately containing the innermost lexical block
227 containing the specified pc value, or 0 if there is none.
228 Backward compatibility, no section. */
230 const struct blockvector *
231 blockvector_for_pc (CORE_ADDR pc, const struct block **pblock)
233 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
237 /* Return the innermost lexical block containing the specified pc value
238 in the specified section, or 0 if there is none. */
241 block_for_pc_sect (CORE_ADDR pc, struct obj_section *section)
243 const struct blockvector *bl;
244 const struct block *b;
246 bl = blockvector_for_pc_sect (pc, section, &b, NULL);
252 /* Return the innermost lexical block containing the specified pc value,
253 or 0 if there is none. Backward compatibility, no section. */
256 block_for_pc (CORE_ADDR pc)
258 return block_for_pc_sect (pc, find_pc_mapped_section (pc));
261 /* Now come some functions designed to deal with C++ namespace issues.
262 The accessors are safe to use even in the non-C++ case. */
264 /* This returns the namespace that BLOCK is enclosed in, or "" if it
265 isn't enclosed in a namespace at all. This travels the chain of
266 superblocks looking for a scope, if necessary. */
269 block_scope (const struct block *block)
271 for (; block != NULL; block = BLOCK_SUPERBLOCK (block))
273 if (BLOCK_NAMESPACE (block) != NULL
274 && BLOCK_NAMESPACE (block)->scope != NULL)
275 return BLOCK_NAMESPACE (block)->scope;
281 /* Set BLOCK's scope member to SCOPE; if needed, allocate memory via
282 OBSTACK. (It won't make a copy of SCOPE, however, so that already
283 has to be allocated correctly.) */
286 block_set_scope (struct block *block, const char *scope,
287 struct obstack *obstack)
289 block_initialize_namespace (block, obstack);
291 BLOCK_NAMESPACE (block)->scope = scope;
294 /* This returns the using directives list associated with BLOCK, if
297 struct using_direct *
298 block_using (const struct block *block)
300 if (block == NULL || BLOCK_NAMESPACE (block) == NULL)
303 return BLOCK_NAMESPACE (block)->using;
306 /* Set BLOCK's using member to USING; if needed, allocate memory via
307 OBSTACK. (It won't make a copy of USING, however, so that already
308 has to be allocated correctly.) */
311 block_set_using (struct block *block,
312 struct using_direct *using,
313 struct obstack *obstack)
315 block_initialize_namespace (block, obstack);
317 BLOCK_NAMESPACE (block)->using = using;
320 /* If BLOCK_NAMESPACE (block) is NULL, allocate it via OBSTACK and
321 ititialize its members to zero. */
324 block_initialize_namespace (struct block *block, struct obstack *obstack)
326 if (BLOCK_NAMESPACE (block) == NULL)
328 BLOCK_NAMESPACE (block)
329 = obstack_alloc (obstack, sizeof (struct block_namespace_info));
330 BLOCK_NAMESPACE (block)->scope = NULL;
331 BLOCK_NAMESPACE (block)->using = NULL;
335 /* Return the static block associated to BLOCK. Return NULL if block
336 is NULL or if block is a global block. */
339 block_static_block (const struct block *block)
341 if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL)
344 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
345 block = BLOCK_SUPERBLOCK (block);
350 /* Return the static block associated to BLOCK. Return NULL if block
354 block_global_block (const struct block *block)
359 while (BLOCK_SUPERBLOCK (block) != NULL)
360 block = BLOCK_SUPERBLOCK (block);
365 /* Allocate a block on OBSTACK, and initialize its elements to
366 zero/NULL. This is useful for creating "dummy" blocks that don't
367 correspond to actual source files.
369 Warning: it sets the block's BLOCK_DICT to NULL, which isn't a
370 valid value. If you really don't want the block to have a
371 dictionary, then you should subsequently set its BLOCK_DICT to
372 dict_create_linear (obstack, NULL). */
375 allocate_block (struct obstack *obstack)
377 struct block *bl = OBSTACK_ZALLOC (obstack, struct block);
382 /* Allocate a global block. */
385 allocate_global_block (struct obstack *obstack)
387 struct global_block *bl = OBSTACK_ZALLOC (obstack, struct global_block);
392 /* Set the compunit of the global block. */
395 set_block_compunit_symtab (struct block *block, struct compunit_symtab *cu)
397 struct global_block *gb;
399 gdb_assert (BLOCK_SUPERBLOCK (block) == NULL);
400 gb = (struct global_block *) block;
401 gdb_assert (gb->compunit_symtab == NULL);
402 gb->compunit_symtab = cu;
405 /* Return the compunit of the global block. */
407 static struct compunit_symtab *
408 get_block_compunit_symtab (const struct block *block)
410 struct global_block *gb;
412 gdb_assert (BLOCK_SUPERBLOCK (block) == NULL);
413 gb = (struct global_block *) block;
414 gdb_assert (gb->compunit_symtab != NULL);
415 return gb->compunit_symtab;
420 /* Initialize a block iterator, either to iterate over a single block,
421 or, for static and global blocks, all the included symtabs as
425 initialize_block_iterator (const struct block *block,
426 struct block_iterator *iter)
428 enum block_enum which;
429 struct compunit_symtab *cu;
433 if (BLOCK_SUPERBLOCK (block) == NULL)
435 which = GLOBAL_BLOCK;
436 cu = get_block_compunit_symtab (block);
438 else if (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL)
440 which = STATIC_BLOCK;
441 cu = get_block_compunit_symtab (BLOCK_SUPERBLOCK (block));
445 iter->d.block = block;
446 /* A signal value meaning that we're iterating over a single
448 iter->which = FIRST_LOCAL_BLOCK;
452 /* If this is an included symtab, find the canonical includer and
454 while (cu->user != NULL)
457 /* Putting this check here simplifies the logic of the iterator
458 functions. If there are no included symtabs, we only need to
459 search a single block, so we might as well just do that
461 if (cu->includes == NULL)
463 iter->d.block = block;
464 /* A signal value meaning that we're iterating over a single
466 iter->which = FIRST_LOCAL_BLOCK;
470 iter->d.compunit_symtab = cu;
475 /* A helper function that finds the current compunit over whose static
476 or global block we should iterate. */
478 static struct compunit_symtab *
479 find_iterator_compunit_symtab (struct block_iterator *iterator)
481 if (iterator->idx == -1)
482 return iterator->d.compunit_symtab;
483 return iterator->d.compunit_symtab->includes[iterator->idx];
486 /* Perform a single step for a plain block iterator, iterating across
487 symbol tables as needed. Returns the next symbol, or NULL when
488 iteration is complete. */
490 static struct symbol *
491 block_iterator_step (struct block_iterator *iterator, int first)
495 gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
501 struct compunit_symtab *cust
502 = find_iterator_compunit_symtab (iterator);
503 const struct block *block;
505 /* Iteration is complete. */
509 block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
511 sym = dict_iterator_first (BLOCK_DICT (block), &iterator->dict_iter);
514 sym = dict_iterator_next (&iterator->dict_iter);
519 /* We have finished iterating the appropriate block of one
520 symtab. Now advance to the next symtab and begin iteration
530 block_iterator_first (const struct block *block,
531 struct block_iterator *iterator)
533 initialize_block_iterator (block, iterator);
535 if (iterator->which == FIRST_LOCAL_BLOCK)
536 return dict_iterator_first (block->dict, &iterator->dict_iter);
538 return block_iterator_step (iterator, 1);
544 block_iterator_next (struct block_iterator *iterator)
546 if (iterator->which == FIRST_LOCAL_BLOCK)
547 return dict_iterator_next (&iterator->dict_iter);
549 return block_iterator_step (iterator, 0);
552 /* Perform a single step for a "name" block iterator, iterating across
553 symbol tables as needed. Returns the next symbol, or NULL when
554 iteration is complete. */
556 static struct symbol *
557 block_iter_name_step (struct block_iterator *iterator, const char *name,
562 gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
568 struct compunit_symtab *cust
569 = find_iterator_compunit_symtab (iterator);
570 const struct block *block;
572 /* Iteration is complete. */
576 block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
578 sym = dict_iter_name_first (BLOCK_DICT (block), name,
579 &iterator->dict_iter);
582 sym = dict_iter_name_next (name, &iterator->dict_iter);
587 /* We have finished iterating the appropriate block of one
588 symtab. Now advance to the next symtab and begin iteration
598 block_iter_name_first (const struct block *block,
600 struct block_iterator *iterator)
602 initialize_block_iterator (block, iterator);
604 if (iterator->which == FIRST_LOCAL_BLOCK)
605 return dict_iter_name_first (block->dict, name, &iterator->dict_iter);
607 return block_iter_name_step (iterator, name, 1);
613 block_iter_name_next (const char *name, struct block_iterator *iterator)
615 if (iterator->which == FIRST_LOCAL_BLOCK)
616 return dict_iter_name_next (name, &iterator->dict_iter);
618 return block_iter_name_step (iterator, name, 0);
621 /* Perform a single step for a "match" block iterator, iterating
622 across symbol tables as needed. Returns the next symbol, or NULL
623 when iteration is complete. */
625 static struct symbol *
626 block_iter_match_step (struct block_iterator *iterator,
628 symbol_compare_ftype *compare,
633 gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
639 struct compunit_symtab *cust
640 = find_iterator_compunit_symtab (iterator);
641 const struct block *block;
643 /* Iteration is complete. */
647 block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
649 sym = dict_iter_match_first (BLOCK_DICT (block), name,
650 compare, &iterator->dict_iter);
653 sym = dict_iter_match_next (name, compare, &iterator->dict_iter);
658 /* We have finished iterating the appropriate block of one
659 symtab. Now advance to the next symtab and begin iteration
669 block_iter_match_first (const struct block *block,
671 symbol_compare_ftype *compare,
672 struct block_iterator *iterator)
674 initialize_block_iterator (block, iterator);
676 if (iterator->which == FIRST_LOCAL_BLOCK)
677 return dict_iter_match_first (block->dict, name, compare,
678 &iterator->dict_iter);
680 return block_iter_match_step (iterator, name, compare, 1);
686 block_iter_match_next (const char *name,
687 symbol_compare_ftype *compare,
688 struct block_iterator *iterator)
690 if (iterator->which == FIRST_LOCAL_BLOCK)
691 return dict_iter_match_next (name, compare, &iterator->dict_iter);
693 return block_iter_match_step (iterator, name, compare, 0);
698 Note that if NAME is the demangled form of a C++ symbol, we will fail
699 to find a match during the binary search of the non-encoded names, but
700 for now we don't worry about the slight inefficiency of looking for
701 a match we'll never find, since it will go pretty quick. Once the
702 binary search terminates, we drop through and do a straight linear
703 search on the symbols. Each symbol which is marked as being a ObjC/C++
704 symbol (language_cplus or language_objc set) has both the encoded and
705 non-encoded names tested for a match. */
708 block_lookup_symbol (const struct block *block, const char *name,
709 const domain_enum domain)
711 struct block_iterator iter;
714 if (!BLOCK_FUNCTION (block))
716 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
718 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
719 SYMBOL_DOMAIN (sym), domain))
726 /* Note that parameter symbols do not always show up last in the
727 list; this loop makes sure to take anything else other than
728 parameter symbols first; it only uses parameter symbols as a
729 last resort. Note that this only takes up extra computation
732 struct symbol *sym_found = NULL;
734 ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
736 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
737 SYMBOL_DOMAIN (sym), domain))
740 if (!SYMBOL_IS_ARGUMENT (sym))
746 return (sym_found); /* Will be NULL if not found. */
753 block_lookup_symbol_primary (const struct block *block, const char *name,
754 const domain_enum domain)
757 struct dict_iterator dict_iter;
759 /* Verify BLOCK is STATIC_BLOCK or GLOBAL_BLOCK. */
760 gdb_assert (BLOCK_SUPERBLOCK (block) == NULL
761 || BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL);
763 for (sym = dict_iter_name_first (block->dict, name, &dict_iter);
765 sym = dict_iter_name_next (name, &dict_iter))
767 if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
768 SYMBOL_DOMAIN (sym), domain))