1 /* Block-related functions for the GNU debugger, GDB. 2 3 Copyright (C) 2003, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "block.h" 23 #include "symtab.h" 24 #include "symfile.h" 25 #include "gdb_obstack.h" 26 #include "cp-support.h" 27 #include "addrmap.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 one if BL represents an inlined function. */ 84 85 int 86 block_inlined_p (const struct block *bl) 87 { 88 return BLOCK_FUNCTION (bl) != NULL && SYMBOL_INLINED (BLOCK_FUNCTION (bl)); 89 } 90 91 /* Return the blockvector immediately containing the innermost lexical 92 block containing the specified pc value and section, or 0 if there 93 is none. PBLOCK is a pointer to the block. If PBLOCK is NULL, we 94 don't pass this information back to the caller. */ 95 96 struct blockvector * 97 blockvector_for_pc_sect (CORE_ADDR pc, struct obj_section *section, 98 struct block **pblock, struct symtab *symtab) 99 { 100 struct block *b; 101 int bot, top, half; 102 struct blockvector *bl; 103 104 if (symtab == 0) /* if no symtab specified by caller */ 105 { 106 /* First search all symtabs for one whose file contains our pc */ 107 symtab = find_pc_sect_symtab (pc, section); 108 if (symtab == 0) 109 return 0; 110 } 111 112 bl = BLOCKVECTOR (symtab); 113 114 /* Then search that symtab for the smallest block that wins. */ 115 116 /* If we have an addrmap mapping code addresses to blocks, then use 117 that. */ 118 if (BLOCKVECTOR_MAP (bl)) 119 { 120 b = addrmap_find (BLOCKVECTOR_MAP (bl), pc); 121 if (b) 122 { 123 if (pblock) 124 *pblock = b; 125 return bl; 126 } 127 else 128 return 0; 129 } 130 131 132 /* Otherwise, use binary search to find the last block that starts 133 before PC. */ 134 bot = 0; 135 top = BLOCKVECTOR_NBLOCKS (bl); 136 137 while (top - bot > 1) 138 { 139 half = (top - bot + 1) >> 1; 140 b = BLOCKVECTOR_BLOCK (bl, bot + half); 141 if (BLOCK_START (b) <= pc) 142 bot += half; 143 else 144 top = bot + half; 145 } 146 147 /* Now search backward for a block that ends after PC. */ 148 149 while (bot >= 0) 150 { 151 b = BLOCKVECTOR_BLOCK (bl, bot); 152 if (BLOCK_END (b) > pc) 153 { 154 if (pblock) 155 *pblock = b; 156 return bl; 157 } 158 bot--; 159 } 160 return 0; 161 } 162 163 /* Return the blockvector immediately containing the innermost lexical block 164 containing the specified pc value, or 0 if there is none. 165 Backward compatibility, no section. */ 166 167 struct blockvector * 168 blockvector_for_pc (CORE_ADDR pc, struct block **pblock) 169 { 170 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc), 171 pblock, NULL); 172 } 173 174 /* Return the innermost lexical block containing the specified pc value 175 in the specified section, or 0 if there is none. */ 176 177 struct block * 178 block_for_pc_sect (CORE_ADDR pc, struct obj_section *section) 179 { 180 struct blockvector *bl; 181 struct block *b; 182 183 bl = blockvector_for_pc_sect (pc, section, &b, NULL); 184 if (bl) 185 return b; 186 return 0; 187 } 188 189 /* Return the innermost lexical block containing the specified pc value, 190 or 0 if there is none. Backward compatibility, no section. */ 191 192 struct block * 193 block_for_pc (CORE_ADDR pc) 194 { 195 return block_for_pc_sect (pc, find_pc_mapped_section (pc)); 196 } 197 198 /* Now come some functions designed to deal with C++ namespace issues. 199 The accessors are safe to use even in the non-C++ case. */ 200 201 /* This returns the namespace that BLOCK is enclosed in, or "" if it 202 isn't enclosed in a namespace at all. This travels the chain of 203 superblocks looking for a scope, if necessary. */ 204 205 const char * 206 block_scope (const struct block *block) 207 { 208 for (; block != NULL; block = BLOCK_SUPERBLOCK (block)) 209 { 210 if (BLOCK_NAMESPACE (block) != NULL 211 && BLOCK_NAMESPACE (block)->scope != NULL) 212 return BLOCK_NAMESPACE (block)->scope; 213 } 214 215 return ""; 216 } 217 218 /* Set BLOCK's scope member to SCOPE; if needed, allocate memory via 219 OBSTACK. (It won't make a copy of SCOPE, however, so that already 220 has to be allocated correctly.) */ 221 222 void 223 block_set_scope (struct block *block, const char *scope, 224 struct obstack *obstack) 225 { 226 block_initialize_namespace (block, obstack); 227 228 BLOCK_NAMESPACE (block)->scope = scope; 229 } 230 231 /* This returns the using directives list associated with BLOCK, if 232 any. */ 233 234 struct using_direct * 235 block_using (const struct block *block) 236 { 237 if (block == NULL || BLOCK_NAMESPACE (block) == NULL) 238 return NULL; 239 else 240 return BLOCK_NAMESPACE (block)->using; 241 } 242 243 /* Set BLOCK's using member to USING; if needed, allocate memory via 244 OBSTACK. (It won't make a copy of USING, however, so that already 245 has to be allocated correctly.) */ 246 247 void 248 block_set_using (struct block *block, 249 struct using_direct *using, 250 struct obstack *obstack) 251 { 252 block_initialize_namespace (block, obstack); 253 254 BLOCK_NAMESPACE (block)->using = using; 255 } 256 257 /* If BLOCK_NAMESPACE (block) is NULL, allocate it via OBSTACK and 258 ititialize its members to zero. */ 259 260 static void 261 block_initialize_namespace (struct block *block, struct obstack *obstack) 262 { 263 if (BLOCK_NAMESPACE (block) == NULL) 264 { 265 BLOCK_NAMESPACE (block) 266 = obstack_alloc (obstack, sizeof (struct block_namespace_info)); 267 BLOCK_NAMESPACE (block)->scope = NULL; 268 BLOCK_NAMESPACE (block)->using = NULL; 269 } 270 } 271 272 /* Return the static block associated to BLOCK. Return NULL if block 273 is NULL or if block is a global block. */ 274 275 const struct block * 276 block_static_block (const struct block *block) 277 { 278 if (block == NULL || BLOCK_SUPERBLOCK (block) == NULL) 279 return NULL; 280 281 while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL) 282 block = BLOCK_SUPERBLOCK (block); 283 284 return block; 285 } 286 287 /* Return the static block associated to BLOCK. Return NULL if block 288 is NULL. */ 289 290 const struct block * 291 block_global_block (const struct block *block) 292 { 293 if (block == NULL) 294 return NULL; 295 296 while (BLOCK_SUPERBLOCK (block) != NULL) 297 block = BLOCK_SUPERBLOCK (block); 298 299 return block; 300 } 301 302 /* Allocate a block on OBSTACK, and initialize its elements to 303 zero/NULL. This is useful for creating "dummy" blocks that don't 304 correspond to actual source files. 305 306 Warning: it sets the block's BLOCK_DICT to NULL, which isn't a 307 valid value. If you really don't want the block to have a 308 dictionary, then you should subsequently set its BLOCK_DICT to 309 dict_create_linear (obstack, NULL). */ 310 311 struct block * 312 allocate_block (struct obstack *obstack) 313 { 314 struct block *bl = obstack_alloc (obstack, sizeof (struct block)); 315 316 BLOCK_START (bl) = 0; 317 BLOCK_END (bl) = 0; 318 BLOCK_FUNCTION (bl) = NULL; 319 BLOCK_SUPERBLOCK (bl) = NULL; 320 BLOCK_DICT (bl) = NULL; 321 BLOCK_NAMESPACE (bl) = NULL; 322 323 return bl; 324 } 325