GDB (xrefs)

/tmp/gdb-8.1/gdb/block.h
Go to the documentation of this file.
1 /* Code dealing with blocks for GDB.
2
3 Copyright (C) 2003-2018 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 #ifndef BLOCK_H
21 #define BLOCK_H
22
23 #include "dictionary.h"
24
25 /* Opaque declarations. */
26
27 struct symbol;
28 struct compunit_symtab;
29 struct block_namespace_info;
30 struct using_direct;
31 struct obstack;
32 struct addrmap;
33
34 /* All of the name-scope contours of the program
35 are represented by `struct block' objects.
36 All of these objects are pointed to by the blockvector.
37
38 Each block represents one name scope.
39 Each lexical context has its own block.
40
41 The blockvector begins with some special blocks.
42 The GLOBAL_BLOCK contains all the symbols defined in this compilation
43 whose scope is the entire program linked together.
44 The STATIC_BLOCK contains all the symbols whose scope is the
45 entire compilation excluding other separate compilations.
46 Blocks starting with the FIRST_LOCAL_BLOCK are not special.
47
48 Each block records a range of core addresses for the code that
49 is in the scope of the block. The STATIC_BLOCK and GLOBAL_BLOCK
50 give, for the range of code, the entire range of code produced
51 by the compilation that the symbol segment belongs to.
52
53 The blocks appear in the blockvector
54 in order of increasing starting-address,
55 and, within that, in order of decreasing ending-address.
56
57 This implies that within the body of one function
58 the blocks appear in the order of a depth-first tree walk. */
59
60 struct block
61 {
62
63 /* Addresses in the executable code that are in this block. */
64
65 CORE_ADDR startaddr;
66 CORE_ADDR endaddr;
67
68 /* The symbol that names this block, if the block is the body of a
69 function (real or inlined); otherwise, zero. */
70
71 struct symbol *function;
72
73 /* The `struct block' for the containing block, or 0 if none.
74
75 The superblock of a top-level local block (i.e. a function in the
76 case of C) is the STATIC_BLOCK. The superblock of the
77 STATIC_BLOCK is the GLOBAL_BLOCK. */
78
79 struct block *superblock;
80
81 /* This is used to store the symbols in the block. */
82
83 struct dictionary *dict;
84
85 /* Contains information about namespace-related info relevant to this block:
86 using directives and the current namespace scope. */
87
88 struct block_namespace_info *namespace_info;
89 };
90
91 /* The global block is singled out so that we can provide a back-link
92 to the compunit symtab. */
93
94 struct global_block
95 {
96 /* The block. */
97
98 struct block block;
99
100 /* This holds a pointer to the compunit symtab holding this block. */
101
102 struct compunit_symtab *compunit_symtab;
103 };
104
105 #define BLOCK_START(bl) (bl)->startaddr
106 #define BLOCK_END(bl) (bl)->endaddr
107 #define BLOCK_FUNCTION(bl) (bl)->function
108 #define BLOCK_SUPERBLOCK(bl) (bl)->superblock
109 #define BLOCK_DICT(bl) (bl)->dict
110 #define BLOCK_NAMESPACE(bl) (bl)->namespace_info
111
112 struct blockvector
113 {
114 /* Number of blocks in the list. */
115 int nblocks;
116 /* An address map mapping addresses to blocks in this blockvector.
117 This pointer is zero if the blocks' start and end addresses are
118 enough. */
119 struct addrmap *map;
120 /* The blocks themselves. */
121 struct block *block[1];
122 };
123
124 #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks
125 #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n]
126 #define BLOCKVECTOR_MAP(blocklist) ((blocklist)->map)
127
128 /* Return the objfile of BLOCK, which must be non-NULL. */
129
130 extern struct objfile *block_objfile (const struct block *block);
131
132 /* Return the architecture of BLOCK, which must be non-NULL. */
133
134 extern struct gdbarch *block_gdbarch (const struct block *block);
135
136 extern struct symbol *block_linkage_function (const struct block *);
137
138 extern struct symbol *block_containing_function (const struct block *);
139
140 extern int block_inlined_p (const struct block *block);
141
142 extern int contained_in (const struct block *, const struct block *);
143
144 extern const struct blockvector *blockvector_for_pc (CORE_ADDR,
145 const struct block **);
146
147 extern const struct blockvector *
148 blockvector_for_pc_sect (CORE_ADDR, struct obj_section *,
149 const struct block **, struct compunit_symtab *);
150
151 extern int blockvector_contains_pc (const struct blockvector *bv, CORE_ADDR pc);
152
153 extern struct call_site *call_site_for_pc (struct gdbarch *gdbarch,
154 CORE_ADDR pc);
155
156 extern const struct block *block_for_pc (CORE_ADDR);
157
158 extern const struct block *block_for_pc_sect (CORE_ADDR, struct obj_section *);
159
160 extern const char *block_scope (const struct block *block);
161
162 extern void block_set_scope (struct block *block, const char *scope,
163 struct obstack *obstack);
164
165 extern struct using_direct *block_using (const struct block *block);
166
167 extern void block_set_using (struct block *block,
168 struct using_direct *using_decl,
169 struct obstack *obstack);
170
171 extern const struct block *block_static_block (const struct block *block);
172
173 extern const struct block *block_global_block (const struct block *block);
174
175 extern struct block *allocate_block (struct obstack *obstack);
176
177 extern struct block *allocate_global_block (struct obstack *obstack);
178
179 extern void set_block_compunit_symtab (struct block *,
180 struct compunit_symtab *);
181
182 /* Return a property to evaluate the static link associated to BLOCK.
183
184 In the context of nested functions (available in Pascal, Ada and GNU C, for
185 instance), a static link (as in DWARF's DW_AT_static_link attribute) for a
186 function is a way to get the frame corresponding to the enclosing function.
187
188 Note that only objfile-owned and function-level blocks can have a static
189 link. Return NULL if there is no such property. */
190
191 extern struct dynamic_prop *block_static_link (const struct block *block);
192
193 /* A block iterator. This structure should be treated as though it
194 were opaque; it is only defined here because we want to support
195 stack allocation of iterators. */
196
197 struct block_iterator
198 {
199 /* If we're iterating over a single block, this holds the block.
200 Otherwise, it holds the canonical compunit. */
201
202 union
203 {
204 struct compunit_symtab *compunit_symtab;
205 const struct block *block;
206 } d;
207
208 /* If we're iterating over a single block, this is always -1.
209 Otherwise, it holds the index of the current "included" symtab in
210 the canonical symtab (that is, d.symtab->includes[idx]), with -1
211 meaning the canonical symtab itself. */
212
213 int idx;
214
215 /* Which block, either static or global, to iterate over. If this
216 is FIRST_LOCAL_BLOCK, then we are iterating over a single block.
217 This is used to select which field of 'd' is in use. */
218
219 enum block_enum which;
220
221 /* The underlying dictionary iterator. */
222
223 struct dict_iterator dict_iter;
224 };
225
226 /* Initialize ITERATOR to point at the first symbol in BLOCK, and
227 return that first symbol, or NULL if BLOCK is empty. */
228
229 extern struct symbol *block_iterator_first (const struct block *block,
230 struct block_iterator *iterator);
231
232 /* Advance ITERATOR, and return the next symbol, or NULL if there are
233 no more symbols. Don't call this if you've previously received
234 NULL from block_iterator_first or block_iterator_next on this
235 iteration. */
236
237 extern struct symbol *block_iterator_next (struct block_iterator *iterator);
238
239 /* Initialize ITERATOR to point at the first symbol in BLOCK whose
240 SYMBOL_SEARCH_NAME matches NAME, and return that first symbol, or
241 NULL if there are no such symbols. */
242
243 extern struct symbol *block_iter_match_first (const struct block *block,
244 const lookup_name_info &name,
245 struct block_iterator *iterator);
246
247 /* Advance ITERATOR to point at the next symbol in BLOCK whose
248 SYMBOL_SEARCH_NAME matches NAME, or NULL if there are no more such
249 symbols. Don't call this if you've previously received NULL from
250 block_iterator_match_first or block_iterator_match_next on this
251 iteration. And don't call it unless ITERATOR was created by a
252 previous call to block_iter_match_first with the same NAME. */
253
254 extern struct symbol *block_iter_match_next
255 (const lookup_name_info &name, struct block_iterator *iterator);
256
257 /* Search BLOCK for symbol NAME in DOMAIN. */
258
259 extern struct symbol *block_lookup_symbol (const struct block *block,
260 const char *name,
261 symbol_name_match_type match_type,
262 const domain_enum domain);
263
264 /* Search BLOCK for symbol NAME in DOMAIN but only in primary symbol table of
265 BLOCK. BLOCK must be STATIC_BLOCK or GLOBAL_BLOCK. Function is useful if
266 one iterates all global/static blocks of an objfile. */
267
268 extern struct symbol *block_lookup_symbol_primary (const struct block *block,
269 const char *name,
270 const domain_enum domain);
271
272 /* The type of the MATCHER argument to block_find_symbol. */
273
274 typedef int (block_symbol_matcher_ftype) (struct symbol *, void *);
275
276 /* Find symbol NAME in BLOCK and in DOMAIN that satisfies MATCHER.
277 DATA is passed unchanged to MATCHER.
278 BLOCK must be STATIC_BLOCK or GLOBAL_BLOCK. */
279
280 extern struct symbol *block_find_symbol (const struct block *block,
281 const char *name,
282 const domain_enum domain,
283 block_symbol_matcher_ftype *matcher,
284 void *data);
285
286 /* A matcher function for block_find_symbol to find only symbols with
287 non-opaque types. */
288
289 extern int block_find_non_opaque_type (struct symbol *sym, void *data);
290
291 /* A matcher function for block_find_symbol to prefer symbols with
292 non-opaque types. The way to use this function is as follows:
293
294 struct symbol *with_opaque = NULL;
295 struct symbol *sym
296 = block_find_symbol (block, name, domain,
297 block_find_non_opaque_type_preferred, &with_opaque);
298
299 At this point if SYM is non-NULL then a non-opaque type has been found.
300 Otherwise, if WITH_OPAQUE is non-NULL then an opaque type has been found.
301 Otherwise, the symbol was not found. */
302
303 extern int block_find_non_opaque_type_preferred (struct symbol *sym,
304 void *data);
305
306 /* Macro to loop through all symbols in BLOCK, in no particular
307 order. ITER helps keep track of the iteration, and must be a
308 struct block_iterator. SYM points to the current symbol. */
309
310 #define ALL_BLOCK_SYMBOLS(block, iter, sym) \
311 for ((sym) = block_iterator_first ((block), &(iter)); \
312 (sym); \
313 (sym) = block_iterator_next (&(iter)))
314
315 /* Macro to loop through all symbols in BLOCK with a name that matches
316 NAME, in no particular order. ITER helps keep track of the
317 iteration, and must be a struct block_iterator. SYM points to the
318 current symbol. */
319
320 #define ALL_BLOCK_SYMBOLS_WITH_NAME(block, name, iter, sym) \
321 for ((sym) = block_iter_match_first ((block), (name), &(iter)); \
322 (sym) != NULL; \
323 (sym) = block_iter_match_next ((name), &(iter)))
324
325 #endif /* BLOCK_H */
gdbarch
Definition: gdbarch.c:127
block_objfile
struct objfile * block_objfile(const struct block *block)
Definition: block.c:46
block_inlined_p
int block_inlined_p(const struct block *block)
Definition: block.c:126
call_site
Definition: gdbtypes.h:1154
global_block::compunit_symtab
struct compunit_symtab * compunit_symtab
Definition: block.h:102
block_iterator::block
const struct block * block
Definition: block.h:205
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
block_find_symbol
struct symbol * block_find_symbol(const struct block *block, const char *name, const domain_enum domain, block_symbol_matcher_ftype *matcher, void *data)
Definition: block.c:769
block_lookup_symbol
struct symbol * block_lookup_symbol(const struct block *block, const char *name, symbol_name_match_type match_type, const domain_enum domain)
Definition: block.c:675
allocate_block
struct block * allocate_block(struct obstack *obstack)
Definition: block.c:400
block_iterator::compunit_symtab
struct compunit_symtab * compunit_symtab
Definition: block.h:204
block_set_scope
void block_set_scope(struct block *block, const char *scope, struct obstack *obstack)
Definition: block.c:312
block_iter_match_next
struct symbol * block_iter_match_next(const lookup_name_info &name, struct block_iterator *iterator)
Definition: block.c:654
domain_enum
enum domain_enum_tag domain_enum
block::endaddr
CORE_ADDR endaddr
Definition: block.h:66
blockvector_for_pc
const struct blockvector * blockvector_for_pc(CORE_ADDR, const struct block **)
Definition: block.c:257
compunit_symtab
Definition: symtab.h:1380
block_for_pc
const struct block * block_for_pc(CORE_ADDR)
Definition: block.c:282
call_site_for_pc
struct call_site * call_site_for_pc(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: block.c:224
dynamic_prop
Definition: gdbtypes.h:398
block_iterator_next
struct symbol * block_iterator_next(struct block_iterator *iterator)
Definition: block.c:584
block_linkage_function
struct symbol * block_linkage_function(const struct block *)
Definition: block.c:100
blockvector::map
struct addrmap * map
Definition: block.h:119
allocate_global_block
struct block * allocate_global_block(struct obstack *obstack)
Definition: block.c:410
block::dict
struct dictionary * dict
Definition: block.h:83
block_gdbarch
struct gdbarch * block_gdbarch(const struct block *block)
Definition: block.c:60
name
const char *const name
Definition: aarch64-tdep.c:76
block_global_block
const struct block * block_global_block(const struct block *block)
Definition: block.c:379
block_static_link
struct dynamic_prop * block_static_link(const struct block *block)
Definition: block.c:433
block_iterator::dict_iter
struct dict_iterator dict_iter
Definition: block.h:223
call_site::pc
CORE_ADDR pc
Definition: gdbtypes.h:1160
blockvector::nblocks
int nblocks
Definition: block.h:115
block_static_block
const struct block * block_static_block(const struct block *block)
Definition: block.c:364
using_direct
Definition: namespace.h:90
block_iterator::idx
int idx
Definition: block.h:213
dictionary
Definition: dictionary.c:165
global_block
Definition: block.h:94
block_lookup_symbol_primary
struct symbol * block_lookup_symbol_primary(const struct block *block, const char *name, const domain_enum domain)
Definition: block.c:734
block_set_using
void block_set_using(struct block *block, struct using_direct *using_decl, struct obstack *obstack)
Definition: block.c:337
block
Definition: block.h:60
dict_iterator
Definition: dictionary.h:106
block_enum
block_enum
Definition: defs.h:684
blockvector
Definition: block.h:112
block_iterator_first
struct symbol * block_iterator_first(const struct block *block, struct block_iterator *iterator)
Definition: block.c:570
objfile
Definition: objfiles.h:286
block_symbol_matcher_ftype
int() block_symbol_matcher_ftype(struct symbol *, void *)
Definition: block.h:274
block_find_non_opaque_type_preferred
int block_find_non_opaque_type_preferred(struct symbol *sym, void *data)
Definition: block.c:805
obj_section
Definition: objfiles.h:123
block_containing_function
struct symbol * block_containing_function(const struct block *)
Definition: block.c:115
addrmap
Definition: addrmap.c:43
block_using
struct using_direct * block_using(const struct block *block)
Definition: block.c:324
set_block_compunit_symtab
void set_block_compunit_symtab(struct block *, struct compunit_symtab *)
Definition: block.c:420
block_scope
const char * block_scope(const struct block *block)
Definition: block.c:295
blockvector_for_pc_sect
const struct blockvector * blockvector_for_pc_sect(CORE_ADDR, struct obj_section *, const struct block **, struct compunit_symtab *)
Definition: block.c:184
block::namespace_info
struct block_namespace_info * namespace_info
Definition: block.h:88
contained_in
int contained_in(const struct block *, const struct block *)
Definition: block.c:73
block_iterator
Definition: block.h:197
block_iterator::d
union block_iterator::@15 d
block::startaddr
CORE_ADDR startaddr
Definition: block.h:65
block_namespace_info
Definition: block.c:34
block_iter_match_first
struct symbol * block_iter_match_first(const struct block *block, const lookup_name_info &name, struct block_iterator *iterator)
Definition: block.c:639
symbol
Definition: symtab.h:1049
blockvector_contains_pc
int blockvector_contains_pc(const struct blockvector *bv, CORE_ADDR pc)
Definition: block.c:214
block_for_pc_sect
const struct block * block_for_pc_sect(CORE_ADDR, struct obj_section *)
Definition: block.c:267
lookup_name_info
Definition: symtab.h:179
block_iterator::which
enum block_enum which
Definition: block.h:219
block::superblock
struct block * superblock
Definition: block.h:79
dictionary.h
block_find_non_opaque_type
int block_find_non_opaque_type(struct symbol *sym, void *data)
Definition: block.c:797
symbol_name_match_type
symbol_name_match_type
Definition: symtab.h:52
symbol::domain
__extension__ enum domain_enum_tag domain
Definition: symtab.h:1076