xref: /openbsd/gnu/usr.bin/binutils/gdb/block.c (revision b725ae77)
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