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
))