1 /* Block-related functions for the GNU debugger, GDB.
2
3 Copyright 2003 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include "defs.h"
23 #include "block.h"
24 #include "symtab.h"
25 #include "symfile.h"
26 #include "gdb_obstack.h"
27 #include "cp-support.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
contained_in(const struct block * a,const struct block * b)47 contained_in (const struct block *a, const struct block *b)
48 {
49 if (!a || !b)
50 return 0;
51 return BLOCK_START (a) >= BLOCK_START (b)
52 && BLOCK_END (a) <= BLOCK_END (b);
53 }
54
55
56 /* Return the symbol for the function which contains a specified
57 lexical block, described by a struct block BL. */
58
59 struct symbol *
block_function(const struct block * bl)60 block_function (const struct block *bl)
61 {
62 while (BLOCK_FUNCTION (bl) == 0 && BLOCK_SUPERBLOCK (bl) != 0)
63 bl = BLOCK_SUPERBLOCK (bl);
64
65 return BLOCK_FUNCTION (bl);
66 }
67
68 /* Return the blockvector immediately containing the innermost lexical block
69 containing the specified pc value and section, or 0 if there is none.
70 PINDEX is a pointer to the index value of the block. If PINDEX
71 is NULL, we don't pass this information back to the caller. */
72
73 struct blockvector *
blockvector_for_pc_sect(CORE_ADDR pc,struct bfd_section * section,int * pindex,struct symtab * symtab)74 blockvector_for_pc_sect (CORE_ADDR pc, struct bfd_section *section,
75 int *pindex, struct symtab *symtab)
76 {
77 struct block *b;
78 int bot, top, half;
79 struct blockvector *bl;
80
81 if (symtab == 0) /* if no symtab specified by caller */
82 {
83 /* First search all symtabs for one whose file contains our pc */
84 symtab = find_pc_sect_symtab (pc, section);
85 if (symtab == 0)
86 return 0;
87 }
88
89 bl = BLOCKVECTOR (symtab);
90 b = BLOCKVECTOR_BLOCK (bl, 0);
91
92 /* Then search that symtab for the smallest block that wins. */
93 /* Use binary search to find the last block that starts before PC. */
94
95 bot = 0;
96 top = BLOCKVECTOR_NBLOCKS (bl);
97
98 while (top - bot > 1)
99 {
100 half = (top - bot + 1) >> 1;
101 b = BLOCKVECTOR_BLOCK (bl, bot + half);
102 if (BLOCK_START (b) <= pc)
103 bot += half;
104 else
105 top = bot + half;
106 }
107
108 /* Now search backward for a block that ends after PC. */
109
110 while (bot >= 0)
111 {
112 b = BLOCKVECTOR_BLOCK (bl, bot);
113 if (BLOCK_END (b) > pc)
114 {
115 if (pindex)
116 *pindex = bot;
117 return bl;
118 }
119 bot--;
120 }
121 return 0;
122 }
123
124 /* Return the blockvector immediately containing the innermost lexical block
125 containing the specified pc value, or 0 if there is none.
126 Backward compatibility, no section. */
127
128 struct blockvector *
blockvector_for_pc(CORE_ADDR pc,int * pindex)129 blockvector_for_pc (CORE_ADDR pc, int *pindex)
130 {
131 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
132 pindex, NULL);
133 }
134
135 /* Return the innermost lexical block containing the specified pc value
136 in the specified section, or 0 if there is none. */
137
138 struct block *
block_for_pc_sect(CORE_ADDR pc,struct bfd_section * section)139 block_for_pc_sect (CORE_ADDR pc, struct bfd_section *section)
140 {
141 struct blockvector *bl;
142 int index;
143
144 bl = blockvector_for_pc_sect (pc, section, &index, NULL);
145 if (bl)
146 return BLOCKVECTOR_BLOCK (bl, index);
147 return 0;
148 }
149
150 /* Return the innermost lexical block containing the specified pc value,
151 or 0 if there is none. Backward compatibility, no section. */
152
153 struct block *
block_for_pc(CORE_ADDR pc)154 block_for_pc (CORE_ADDR pc)
155 {
156 return block_for_pc_sect (pc, find_pc_mapped_section (pc));
157 }
158
159 /* Now come some functions designed to deal with C++ namespace issues.
160 The accessors are safe to use even in the non-C++ case. */
161
162 /* This returns the namespace that BLOCK is enclosed in, or "" if it
163 isn't enclosed in a namespace at all. This travels the chain of
164 superblocks looking for a scope, if necessary. */
165
166 const char *
block_scope(const struct block * block)167 block_scope (const struct block *block)
168 {
169 for (; block != NULL; block = BLOCK_SUPERBLOCK (block))
170 {
171 if (BLOCK_NAMESPACE (block) != NULL
172 && BLOCK_NAMESPACE (block)->scope != NULL)
173 return BLOCK_NAMESPACE (block)->scope;
174 }
175
176 return "";
177 }
178
179 /* Set BLOCK's scope member to SCOPE; if needed, allocate memory via
180 OBSTACK. (It won't make a copy of SCOPE, however, so that already
181 has to be allocated correctly.) */
182
183 void
block_set_scope(struct block * block,const char * scope,struct obstack * obstack)184 block_set_scope (struct block *block, const char *scope,
185 struct obstack *obstack)
186 {
187 block_initialize_namespace (block, obstack);
188
189 BLOCK_NAMESPACE (block)->scope = scope;
190 }
191
192 /* This returns the first using directives associated to BLOCK, if
193 any. */
194
195 /* FIXME: carlton/2003-04-23: This uses the fact that we currently
196 only have using directives in static blocks, because we only
197 generate using directives from anonymous namespaces. Eventually,
198 when we support using directives everywhere, we'll want to replace
199 this by some iterator functions. */
200
201 struct using_direct *
block_using(const struct block * block)202 block_using (const struct block *block)
203 {
204 const struct block *static_block = block_static_block (block);
205
206 if (static_block == NULL
207 || BLOCK_NAMESPACE (static_block) == NULL)
208 return NULL;
209 else
210 return BLOCK_NAMESPACE (static_block)->using;
211 }
212
213 /* Set BLOCK's using member to USING; if needed, allocate memory via
214 OBSTACK. (It won't make a copy of USING, however, so that already
215 has to be allocated correctly.) */
216
217 void
block_set_using(struct block * block,struct using_direct * using,struct obstack * obstack)218 block_set_using (struct block *block,
219 struct using_direct *using,
220 struct obstack *obstack)
221 {
222 block_initialize_namespace (block, obstack);
223
224 BLOCK_NAMESPACE (block)->using = using;
225 }
226
227 /* If BLOCK_NAMESPACE (block) is NULL, allocate it via OBSTACK and
228 ititialize its members to zero. */
229
230 static void
block_initialize_namespace(struct block * block,struct obstack * obstack)231 block_initialize_namespace (struct block *block, struct obstack *obstack)
232 {
233 if (BLOCK_NAMESPACE (block) == NULL)
234 {
235 BLOCK_NAMESPACE (block)
236 = obstack_alloc (obstack, sizeof (struct block_namespace_info));
237 BLOCK_NAMESPACE (block)->scope = NULL;
238 BLOCK_NAMESPACE (block)->using = NULL;
239 }
240 }
241
242 /* Return the static block associated to BLOCK. Return NULL if block
243 is NULL or if block is a global block. */
244
245 const struct block *
block_static_block(const struct block * block)246 block_static_block (const struct block *block)
247 {
248 if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL)
249 return NULL;
250
251 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
252 block = BLOCK_SUPERBLOCK (block);
253
254 return block;
255 }
256
257 /* Return the static block associated to BLOCK. Return NULL if block
258 is NULL. */
259
260 const struct block *
block_global_block(const struct block * block)261 block_global_block (const struct block *block)
262 {
263 if (block == NULL)
264 return NULL;
265
266 while (BLOCK_SUPERBLOCK (block) != NULL)
267 block = BLOCK_SUPERBLOCK (block);
268
269 return block;
270 }
271
272 /* Allocate a block on OBSTACK, and initialize its elements to
273 zero/NULL. This is useful for creating "dummy" blocks that don't
274 correspond to actual source files.
275
276 Warning: it sets the block's BLOCK_DICT to NULL, which isn't a
277 valid value. If you really don't want the block to have a
278 dictionary, then you should subsequently set its BLOCK_DICT to
279 dict_create_linear (obstack, NULL). */
280
281 struct block *
allocate_block(struct obstack * obstack)282 allocate_block (struct obstack *obstack)
283 {
284 struct block *bl = obstack_alloc (obstack, sizeof (struct block));
285
286 BLOCK_START (bl) = 0;
287 BLOCK_END (bl) = 0;
288 BLOCK_FUNCTION (bl) = NULL;
289 BLOCK_SUPERBLOCK (bl) = NULL;
290 BLOCK_DICT (bl) = NULL;
291 BLOCK_NAMESPACE (bl) = NULL;
292 BLOCK_GCC_COMPILED (bl) = 0;
293
294 return bl;
295 }
296