Commit | Line | Data |
---|---|---|
fe898f56 DC |
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" | |
9219021c DC |
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); | |
fe898f56 DC |
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 (struct block *a, 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 * | |
60 | block_function (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 * | |
74 | blockvector_for_pc_sect (register CORE_ADDR pc, struct sec *section, | |
75 | int *pindex, struct symtab *symtab) | |
76 | { | |
77 | register struct block *b; | |
78 | register 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 | if ((symtab = find_pc_sect_symtab (pc, section)) == 0) | |
85 | return 0; | |
86 | } | |
87 | ||
88 | bl = BLOCKVECTOR (symtab); | |
89 | b = BLOCKVECTOR_BLOCK (bl, 0); | |
90 | ||
91 | /* Then search that symtab for the smallest block that wins. */ | |
92 | /* Use binary search to find the last block that starts before PC. */ | |
93 | ||
94 | bot = 0; | |
95 | top = BLOCKVECTOR_NBLOCKS (bl); | |
96 | ||
97 | while (top - bot > 1) | |
98 | { | |
99 | half = (top - bot + 1) >> 1; | |
100 | b = BLOCKVECTOR_BLOCK (bl, bot + half); | |
101 | if (BLOCK_START (b) <= pc) | |
102 | bot += half; | |
103 | else | |
104 | top = bot + half; | |
105 | } | |
106 | ||
107 | /* Now search backward for a block that ends after PC. */ | |
108 | ||
109 | while (bot >= 0) | |
110 | { | |
111 | b = BLOCKVECTOR_BLOCK (bl, bot); | |
112 | if (BLOCK_END (b) > pc) | |
113 | { | |
114 | if (pindex) | |
115 | *pindex = bot; | |
116 | return bl; | |
117 | } | |
118 | bot--; | |
119 | } | |
120 | return 0; | |
121 | } | |
122 | ||
123 | /* Return the blockvector immediately containing the innermost lexical block | |
124 | containing the specified pc value, or 0 if there is none. | |
125 | Backward compatibility, no section. */ | |
126 | ||
127 | struct blockvector * | |
128 | blockvector_for_pc (register CORE_ADDR pc, int *pindex) | |
129 | { | |
130 | return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc), | |
131 | pindex, NULL); | |
132 | } | |
133 | ||
134 | /* Return the innermost lexical block containing the specified pc value | |
135 | in the specified section, or 0 if there is none. */ | |
136 | ||
137 | struct block * | |
138 | block_for_pc_sect (register CORE_ADDR pc, struct sec *section) | |
139 | { | |
140 | register struct blockvector *bl; | |
141 | int index; | |
142 | ||
143 | bl = blockvector_for_pc_sect (pc, section, &index, NULL); | |
144 | if (bl) | |
145 | return BLOCKVECTOR_BLOCK (bl, index); | |
146 | return 0; | |
147 | } | |
148 | ||
149 | /* Return the innermost lexical block containing the specified pc value, | |
150 | or 0 if there is none. Backward compatibility, no section. */ | |
151 | ||
152 | struct block * | |
153 | block_for_pc (register CORE_ADDR pc) | |
154 | { | |
155 | return block_for_pc_sect (pc, find_pc_mapped_section (pc)); | |
156 | } | |
9219021c | 157 | |
1fcb5155 DC |
158 | /* Now come some functions designed to deal with C++ namespace issues. |
159 | The accessors are safe to use even in the non-C++ case. */ | |
160 | ||
161 | /* This returns the namespace that BLOCK is enclosed in, or "" if it | |
162 | isn't enclosed in a namespace at all. This travels the chain of | |
163 | superblocks looking for a scope, if necessary. */ | |
164 | ||
165 | const char * | |
166 | block_scope (const struct block *block) | |
167 | { | |
168 | for (; block != NULL; block = BLOCK_SUPERBLOCK (block)) | |
169 | { | |
170 | if (BLOCK_NAMESPACE (block) != NULL | |
171 | && BLOCK_NAMESPACE (block)->scope != NULL) | |
172 | return BLOCK_NAMESPACE (block)->scope; | |
173 | } | |
174 | ||
175 | return ""; | |
176 | } | |
9219021c DC |
177 | |
178 | /* Set BLOCK's scope member to SCOPE; if needed, allocate memory via | |
179 | OBSTACK. (It won't make a copy of SCOPE, however, so that already | |
180 | has to be allocated correctly.) */ | |
181 | ||
182 | void | |
183 | block_set_scope (struct block *block, const char *scope, | |
184 | struct obstack *obstack) | |
185 | { | |
186 | block_initialize_namespace (block, obstack); | |
187 | ||
188 | BLOCK_NAMESPACE (block)->scope = scope; | |
189 | } | |
190 | ||
1fcb5155 DC |
191 | /* This returns the first using directives associated to BLOCK, if |
192 | any. */ | |
193 | ||
194 | /* FIXME: carlton/2003-04-23: This uses the fact that we currently | |
195 | only have using directives in static blocks, because we only | |
196 | generate using directives from anonymous namespaces. Eventually, | |
197 | when we support using directives everywhere, we'll want to replace | |
198 | this by some iterator functions. */ | |
199 | ||
200 | struct using_direct * | |
201 | block_using (const struct block *block) | |
202 | { | |
203 | const struct block *static_block = block_static_block (block); | |
204 | ||
205 | if (static_block == NULL | |
206 | || BLOCK_NAMESPACE (static_block) == NULL) | |
207 | return NULL; | |
208 | else | |
209 | return BLOCK_NAMESPACE (static_block)->using; | |
210 | } | |
211 | ||
9219021c DC |
212 | /* Set BLOCK's using member to USING; if needed, allocate memory via |
213 | OBSTACK. (It won't make a copy of USING, however, so that already | |
214 | has to be allocated correctly.) */ | |
215 | ||
216 | void | |
217 | block_set_using (struct block *block, | |
218 | struct using_direct *using, | |
219 | struct obstack *obstack) | |
220 | { | |
221 | block_initialize_namespace (block, obstack); | |
222 | ||
223 | BLOCK_NAMESPACE (block)->using = using; | |
224 | } | |
225 | ||
226 | /* If BLOCK_NAMESPACE (block) is NULL, allocate it via OBSTACK and | |
227 | ititialize its members to zero. */ | |
228 | ||
229 | static void | |
230 | block_initialize_namespace (struct block *block, struct obstack *obstack) | |
231 | { | |
232 | if (BLOCK_NAMESPACE (block) == NULL) | |
233 | { | |
234 | BLOCK_NAMESPACE (block) | |
235 | = obstack_alloc (obstack, sizeof (struct block_namespace_info)); | |
236 | BLOCK_NAMESPACE (block)->scope = NULL; | |
237 | BLOCK_NAMESPACE (block)->using = NULL; | |
238 | } | |
239 | } | |
89a9d1b1 DC |
240 | |
241 | /* Return the static block associated to BLOCK. Return NULL if block | |
242 | is NULL or if block is a global block. */ | |
243 | ||
244 | const struct block * | |
245 | block_static_block (const struct block *block) | |
246 | { | |
247 | if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL) | |
248 | return NULL; | |
249 | ||
250 | while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL) | |
251 | block = BLOCK_SUPERBLOCK (block); | |
252 | ||
253 | return block; | |
254 | } | |
1fcb5155 DC |
255 | |
256 | /* Return the static block associated to BLOCK. Return NULL if block | |
257 | is NULL. */ | |
258 | ||
259 | const struct block * | |
260 | block_global_block (const struct block *block) | |
261 | { | |
262 | if (block == NULL) | |
263 | return NULL; | |
264 | ||
265 | while (BLOCK_SUPERBLOCK (block) != NULL) | |
266 | block = BLOCK_SUPERBLOCK (block); | |
267 | ||
268 | return block; | |
269 | } |