]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/block.c
block.c (allocate_block): Use OBSTACK_ZALLOC instead of obstack_alloc.
[thirdparty/binutils-gdb.git] / gdb / block.c
1 /* Block-related functions for the GNU debugger, GDB.
2
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "block.h"
22 #include "symtab.h"
23 #include "symfile.h"
24 #include "gdb_obstack.h"
25 #include "cp-support.h"
26 #include "addrmap.h"
27 #include "gdbtypes.h"
28
29 /* This is used by struct block to store namespace-related info for
30 C++ files, namely using declarations and the current namespace in
31 scope. */
32
33 struct block_namespace_info
34 {
35 const char *scope;
36 struct using_direct *using;
37 };
38
39 static void block_initialize_namespace (struct block *block,
40 struct obstack *obstack);
41
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. */
45
46 int
47 contained_in (const struct block *a, const struct block *b)
48 {
49 if (!a || !b)
50 return 0;
51
52 do
53 {
54 if (a == b)
55 return 1;
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))
59 return 0;
60 a = BLOCK_SUPERBLOCK (a);
61 }
62 while (a != NULL);
63
64 return 0;
65 }
66
67
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
71 returned instead. */
72
73 struct symbol *
74 block_linkage_function (const struct block *bl)
75 {
76 while ((BLOCK_FUNCTION (bl) == NULL || block_inlined_p (bl))
77 && BLOCK_SUPERBLOCK (bl) != NULL)
78 bl = BLOCK_SUPERBLOCK (bl);
79
80 return BLOCK_FUNCTION (bl);
81 }
82
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
86 function. */
87
88 struct symbol *
89 block_containing_function (const struct block *bl)
90 {
91 while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
92 bl = BLOCK_SUPERBLOCK (bl);
93
94 return BLOCK_FUNCTION (bl);
95 }
96
97 /* Return one if BL represents an inlined function. */
98
99 int
100 block_inlined_p (const struct block *bl)
101 {
102 return BLOCK_FUNCTION (bl) != NULL && SYMBOL_INLINED (BLOCK_FUNCTION (bl));
103 }
104
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. */
107
108 static struct block *
109 find_block_in_blockvector (const struct blockvector *bl, CORE_ADDR pc)
110 {
111 struct block *b;
112 int bot, top, half;
113
114 /* If we have an addrmap mapping code addresses to blocks, then use
115 that. */
116 if (BLOCKVECTOR_MAP (bl))
117 return addrmap_find (BLOCKVECTOR_MAP (bl), pc);
118
119 /* Otherwise, use binary search to find the last block that starts
120 before PC.
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);
126 bot = STATIC_BLOCK;
127 top = BLOCKVECTOR_NBLOCKS (bl);
128
129 while (top - bot > 1)
130 {
131 half = (top - bot + 1) >> 1;
132 b = BLOCKVECTOR_BLOCK (bl, bot + half);
133 if (BLOCK_START (b) <= pc)
134 bot += half;
135 else
136 top = bot + half;
137 }
138
139 /* Now search backward for a block that ends after PC. */
140
141 while (bot >= STATIC_BLOCK)
142 {
143 b = BLOCKVECTOR_BLOCK (bl, bot);
144 if (BLOCK_END (b) > pc)
145 return b;
146 bot--;
147 }
148
149 return NULL;
150 }
151
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. */
156
157 const struct blockvector *
158 blockvector_for_pc_sect (CORE_ADDR pc, struct obj_section *section,
159 const struct block **pblock, struct symtab *symtab)
160 {
161 const struct blockvector *bl;
162 struct block *b;
163
164 if (symtab == 0) /* if no symtab specified by caller */
165 {
166 /* First search all symtabs for one whose file contains our pc */
167 symtab = find_pc_sect_symtab (pc, section);
168 if (symtab == 0)
169 return 0;
170 }
171
172 bl = BLOCKVECTOR (symtab);
173
174 /* Then search that symtab for the smallest block that wins. */
175 b = find_block_in_blockvector (bl, pc);
176 if (b == NULL)
177 return NULL;
178
179 if (pblock)
180 *pblock = b;
181 return bl;
182 }
183
184 /* Return true if the blockvector BV contains PC, false otherwise. */
185
186 int
187 blockvector_contains_pc (const struct blockvector *bv, CORE_ADDR pc)
188 {
189 return find_block_in_blockvector (bv, pc) != NULL;
190 }
191
192 /* Return call_site for specified PC in GDBARCH. PC must match exactly, it
193 must be the next instruction after call (or after tail call jump). Throw
194 NO_ENTRY_VALUE_ERROR otherwise. This function never returns NULL. */
195
196 struct call_site *
197 call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
198 {
199 struct symtab *symtab;
200 void **slot = NULL;
201
202 /* -1 as tail call PC can be already after the compilation unit range. */
203 symtab = find_pc_symtab (pc - 1);
204
205 if (symtab != NULL && symtab->call_site_htab != NULL)
206 slot = htab_find_slot (symtab->call_site_htab, &pc, NO_INSERT);
207
208 if (slot == NULL)
209 {
210 struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (pc);
211
212 /* DW_TAG_gnu_call_site will be missing just if GCC could not determine
213 the call target. */
214 throw_error (NO_ENTRY_VALUE_ERROR,
215 _("DW_OP_GNU_entry_value resolving cannot find "
216 "DW_TAG_GNU_call_site %s in %s"),
217 paddress (gdbarch, pc),
218 (msym.minsym == NULL ? "???"
219 : MSYMBOL_PRINT_NAME (msym.minsym)));
220 }
221
222 return *slot;
223 }
224
225 /* Return the blockvector immediately containing the innermost lexical block
226 containing the specified pc value, or 0 if there is none.
227 Backward compatibility, no section. */
228
229 const struct blockvector *
230 blockvector_for_pc (CORE_ADDR pc, const struct block **pblock)
231 {
232 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
233 pblock, NULL);
234 }
235
236 /* Return the innermost lexical block containing the specified pc value
237 in the specified section, or 0 if there is none. */
238
239 const struct block *
240 block_for_pc_sect (CORE_ADDR pc, struct obj_section *section)
241 {
242 const struct blockvector *bl;
243 const struct block *b;
244
245 bl = blockvector_for_pc_sect (pc, section, &b, NULL);
246 if (bl)
247 return b;
248 return 0;
249 }
250
251 /* Return the innermost lexical block containing the specified pc value,
252 or 0 if there is none. Backward compatibility, no section. */
253
254 const struct block *
255 block_for_pc (CORE_ADDR pc)
256 {
257 return block_for_pc_sect (pc, find_pc_mapped_section (pc));
258 }
259
260 /* Now come some functions designed to deal with C++ namespace issues.
261 The accessors are safe to use even in the non-C++ case. */
262
263 /* This returns the namespace that BLOCK is enclosed in, or "" if it
264 isn't enclosed in a namespace at all. This travels the chain of
265 superblocks looking for a scope, if necessary. */
266
267 const char *
268 block_scope (const struct block *block)
269 {
270 for (; block != NULL; block = BLOCK_SUPERBLOCK (block))
271 {
272 if (BLOCK_NAMESPACE (block) != NULL
273 && BLOCK_NAMESPACE (block)->scope != NULL)
274 return BLOCK_NAMESPACE (block)->scope;
275 }
276
277 return "";
278 }
279
280 /* Set BLOCK's scope member to SCOPE; if needed, allocate memory via
281 OBSTACK. (It won't make a copy of SCOPE, however, so that already
282 has to be allocated correctly.) */
283
284 void
285 block_set_scope (struct block *block, const char *scope,
286 struct obstack *obstack)
287 {
288 block_initialize_namespace (block, obstack);
289
290 BLOCK_NAMESPACE (block)->scope = scope;
291 }
292
293 /* This returns the using directives list associated with BLOCK, if
294 any. */
295
296 struct using_direct *
297 block_using (const struct block *block)
298 {
299 if (block == NULL || BLOCK_NAMESPACE (block) == NULL)
300 return NULL;
301 else
302 return BLOCK_NAMESPACE (block)->using;
303 }
304
305 /* Set BLOCK's using member to USING; if needed, allocate memory via
306 OBSTACK. (It won't make a copy of USING, however, so that already
307 has to be allocated correctly.) */
308
309 void
310 block_set_using (struct block *block,
311 struct using_direct *using,
312 struct obstack *obstack)
313 {
314 block_initialize_namespace (block, obstack);
315
316 BLOCK_NAMESPACE (block)->using = using;
317 }
318
319 /* If BLOCK_NAMESPACE (block) is NULL, allocate it via OBSTACK and
320 ititialize its members to zero. */
321
322 static void
323 block_initialize_namespace (struct block *block, struct obstack *obstack)
324 {
325 if (BLOCK_NAMESPACE (block) == NULL)
326 {
327 BLOCK_NAMESPACE (block)
328 = obstack_alloc (obstack, sizeof (struct block_namespace_info));
329 BLOCK_NAMESPACE (block)->scope = NULL;
330 BLOCK_NAMESPACE (block)->using = NULL;
331 }
332 }
333
334 /* Return the static block associated to BLOCK. Return NULL if block
335 is NULL or if block is a global block. */
336
337 const struct block *
338 block_static_block (const struct block *block)
339 {
340 if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL)
341 return NULL;
342
343 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
344 block = BLOCK_SUPERBLOCK (block);
345
346 return block;
347 }
348
349 /* Return the static block associated to BLOCK. Return NULL if block
350 is NULL. */
351
352 const struct block *
353 block_global_block (const struct block *block)
354 {
355 if (block == NULL)
356 return NULL;
357
358 while (BLOCK_SUPERBLOCK (block) != NULL)
359 block = BLOCK_SUPERBLOCK (block);
360
361 return block;
362 }
363
364 /* Allocate a block on OBSTACK, and initialize its elements to
365 zero/NULL. This is useful for creating "dummy" blocks that don't
366 correspond to actual source files.
367
368 Warning: it sets the block's BLOCK_DICT to NULL, which isn't a
369 valid value. If you really don't want the block to have a
370 dictionary, then you should subsequently set its BLOCK_DICT to
371 dict_create_linear (obstack, NULL). */
372
373 struct block *
374 allocate_block (struct obstack *obstack)
375 {
376 struct block *bl = OBSTACK_ZALLOC (obstack, struct block);
377
378 return bl;
379 }
380
381 /* Allocate a global block. */
382
383 struct block *
384 allocate_global_block (struct obstack *obstack)
385 {
386 struct global_block *bl = OBSTACK_ZALLOC (obstack, struct global_block);
387
388 return &bl->block;
389 }
390
391 /* Set the symtab of the global block. */
392
393 void
394 set_block_symtab (struct block *block, struct symtab *symtab)
395 {
396 struct global_block *gb;
397
398 gdb_assert (BLOCK_SUPERBLOCK (block) == NULL);
399 gb = (struct global_block *) block;
400 gdb_assert (gb->symtab == NULL);
401 gb->symtab = symtab;
402 }
403
404 /* Return the symtab of the global block. */
405
406 static struct symtab *
407 get_block_symtab (const struct block *block)
408 {
409 struct global_block *gb;
410
411 gdb_assert (BLOCK_SUPERBLOCK (block) == NULL);
412 gb = (struct global_block *) block;
413 gdb_assert (gb->symtab != NULL);
414 return gb->symtab;
415 }
416
417 \f
418
419 /* Initialize a block iterator, either to iterate over a single block,
420 or, for static and global blocks, all the included symtabs as
421 well. */
422
423 static void
424 initialize_block_iterator (const struct block *block,
425 struct block_iterator *iter)
426 {
427 enum block_enum which;
428 struct symtab *symtab;
429
430 iter->idx = -1;
431
432 if (BLOCK_SUPERBLOCK (block) == NULL)
433 {
434 which = GLOBAL_BLOCK;
435 symtab = get_block_symtab (block);
436 }
437 else if (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL)
438 {
439 which = STATIC_BLOCK;
440 symtab = get_block_symtab (BLOCK_SUPERBLOCK (block));
441 }
442 else
443 {
444 iter->d.block = block;
445 /* A signal value meaning that we're iterating over a single
446 block. */
447 iter->which = FIRST_LOCAL_BLOCK;
448 return;
449 }
450
451 /* If this is an included symtab, find the canonical includer and
452 use it instead. */
453 while (symtab->user != NULL)
454 symtab = symtab->user;
455
456 /* Putting this check here simplifies the logic of the iterator
457 functions. If there are no included symtabs, we only need to
458 search a single block, so we might as well just do that
459 directly. */
460 if (symtab->includes == NULL)
461 {
462 iter->d.block = block;
463 /* A signal value meaning that we're iterating over a single
464 block. */
465 iter->which = FIRST_LOCAL_BLOCK;
466 }
467 else
468 {
469 iter->d.symtab = symtab;
470 iter->which = which;
471 }
472 }
473
474 /* A helper function that finds the current symtab over whose static
475 or global block we should iterate. */
476
477 static struct symtab *
478 find_iterator_symtab (struct block_iterator *iterator)
479 {
480 if (iterator->idx == -1)
481 return iterator->d.symtab;
482 return iterator->d.symtab->includes[iterator->idx];
483 }
484
485 /* Perform a single step for a plain block iterator, iterating across
486 symbol tables as needed. Returns the next symbol, or NULL when
487 iteration is complete. */
488
489 static struct symbol *
490 block_iterator_step (struct block_iterator *iterator, int first)
491 {
492 struct symbol *sym;
493
494 gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
495
496 while (1)
497 {
498 if (first)
499 {
500 struct symtab *symtab = find_iterator_symtab (iterator);
501 const struct block *block;
502
503 /* Iteration is complete. */
504 if (symtab == NULL)
505 return NULL;
506
507 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), iterator->which);
508 sym = dict_iterator_first (BLOCK_DICT (block), &iterator->dict_iter);
509 }
510 else
511 sym = dict_iterator_next (&iterator->dict_iter);
512
513 if (sym != NULL)
514 return sym;
515
516 /* We have finished iterating the appropriate block of one
517 symtab. Now advance to the next symtab and begin iteration
518 there. */
519 ++iterator->idx;
520 first = 1;
521 }
522 }
523
524 /* See block.h. */
525
526 struct symbol *
527 block_iterator_first (const struct block *block,
528 struct block_iterator *iterator)
529 {
530 initialize_block_iterator (block, iterator);
531
532 if (iterator->which == FIRST_LOCAL_BLOCK)
533 return dict_iterator_first (block->dict, &iterator->dict_iter);
534
535 return block_iterator_step (iterator, 1);
536 }
537
538 /* See block.h. */
539
540 struct symbol *
541 block_iterator_next (struct block_iterator *iterator)
542 {
543 if (iterator->which == FIRST_LOCAL_BLOCK)
544 return dict_iterator_next (&iterator->dict_iter);
545
546 return block_iterator_step (iterator, 0);
547 }
548
549 /* Perform a single step for a "name" block iterator, iterating across
550 symbol tables as needed. Returns the next symbol, or NULL when
551 iteration is complete. */
552
553 static struct symbol *
554 block_iter_name_step (struct block_iterator *iterator, const char *name,
555 int first)
556 {
557 struct symbol *sym;
558
559 gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
560
561 while (1)
562 {
563 if (first)
564 {
565 struct symtab *symtab = find_iterator_symtab (iterator);
566 const struct block *block;
567
568 /* Iteration is complete. */
569 if (symtab == NULL)
570 return NULL;
571
572 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), iterator->which);
573 sym = dict_iter_name_first (BLOCK_DICT (block), name,
574 &iterator->dict_iter);
575 }
576 else
577 sym = dict_iter_name_next (name, &iterator->dict_iter);
578
579 if (sym != NULL)
580 return sym;
581
582 /* We have finished iterating the appropriate block of one
583 symtab. Now advance to the next symtab and begin iteration
584 there. */
585 ++iterator->idx;
586 first = 1;
587 }
588 }
589
590 /* See block.h. */
591
592 struct symbol *
593 block_iter_name_first (const struct block *block,
594 const char *name,
595 struct block_iterator *iterator)
596 {
597 initialize_block_iterator (block, iterator);
598
599 if (iterator->which == FIRST_LOCAL_BLOCK)
600 return dict_iter_name_first (block->dict, name, &iterator->dict_iter);
601
602 return block_iter_name_step (iterator, name, 1);
603 }
604
605 /* See block.h. */
606
607 struct symbol *
608 block_iter_name_next (const char *name, struct block_iterator *iterator)
609 {
610 if (iterator->which == FIRST_LOCAL_BLOCK)
611 return dict_iter_name_next (name, &iterator->dict_iter);
612
613 return block_iter_name_step (iterator, name, 0);
614 }
615
616 /* Perform a single step for a "match" block iterator, iterating
617 across symbol tables as needed. Returns the next symbol, or NULL
618 when iteration is complete. */
619
620 static struct symbol *
621 block_iter_match_step (struct block_iterator *iterator,
622 const char *name,
623 symbol_compare_ftype *compare,
624 int first)
625 {
626 struct symbol *sym;
627
628 gdb_assert (iterator->which != FIRST_LOCAL_BLOCK);
629
630 while (1)
631 {
632 if (first)
633 {
634 struct symtab *symtab = find_iterator_symtab (iterator);
635 const struct block *block;
636
637 /* Iteration is complete. */
638 if (symtab == NULL)
639 return NULL;
640
641 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), iterator->which);
642 sym = dict_iter_match_first (BLOCK_DICT (block), name,
643 compare, &iterator->dict_iter);
644 }
645 else
646 sym = dict_iter_match_next (name, compare, &iterator->dict_iter);
647
648 if (sym != NULL)
649 return sym;
650
651 /* We have finished iterating the appropriate block of one
652 symtab. Now advance to the next symtab and begin iteration
653 there. */
654 ++iterator->idx;
655 first = 1;
656 }
657 }
658
659 /* See block.h. */
660
661 struct symbol *
662 block_iter_match_first (const struct block *block,
663 const char *name,
664 symbol_compare_ftype *compare,
665 struct block_iterator *iterator)
666 {
667 initialize_block_iterator (block, iterator);
668
669 if (iterator->which == FIRST_LOCAL_BLOCK)
670 return dict_iter_match_first (block->dict, name, compare,
671 &iterator->dict_iter);
672
673 return block_iter_match_step (iterator, name, compare, 1);
674 }
675
676 /* See block.h. */
677
678 struct symbol *
679 block_iter_match_next (const char *name,
680 symbol_compare_ftype *compare,
681 struct block_iterator *iterator)
682 {
683 if (iterator->which == FIRST_LOCAL_BLOCK)
684 return dict_iter_match_next (name, compare, &iterator->dict_iter);
685
686 return block_iter_match_step (iterator, name, compare, 0);
687 }