1 /* Get info from stack frames; convert between frames, blocks, 2 functions and pc values. 3 4 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 5 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009 6 Free Software Foundation, Inc. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "symtab.h" 25 #include "bfd.h" 26 #include "objfiles.h" 27 #include "frame.h" 28 #include "gdbcore.h" 29 #include "value.h" 30 #include "target.h" 31 #include "inferior.h" 32 #include "annotate.h" 33 #include "regcache.h" 34 #include "gdb_assert.h" 35 #include "dummy-frame.h" 36 #include "command.h" 37 #include "gdbcmd.h" 38 #include "block.h" 39 #include "inline-frame.h" 40 41 /* Prototypes for exported functions. */ 42 43 void _initialize_blockframe (void); 44 45 /* Return the innermost lexical block in execution 46 in a specified stack frame. The frame address is assumed valid. 47 48 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code 49 address we used to choose the block. We use this to find a source 50 line, to decide which macro definitions are in scope. 51 52 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's 53 PC, and may not really be a valid PC at all. For example, in the 54 caller of a function declared to never return, the code at the 55 return address will never be reached, so the call instruction may 56 be the very last instruction in the block. So the address we use 57 to choose the block is actually one byte before the return address 58 --- hopefully pointing us at the call instruction, or its delay 59 slot instruction. */ 60 61 struct block * 62 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block) 63 { 64 const CORE_ADDR pc = get_frame_address_in_block (frame); 65 struct frame_info *next_frame; 66 struct block *bl; 67 int inline_count; 68 69 if (addr_in_block) 70 *addr_in_block = pc; 71 72 bl = block_for_pc (pc); 73 if (bl == NULL) 74 return NULL; 75 76 inline_count = frame_inlined_callees (frame); 77 78 while (inline_count > 0) 79 { 80 if (block_inlined_p (bl)) 81 inline_count--; 82 83 bl = BLOCK_SUPERBLOCK (bl); 84 gdb_assert (bl != NULL); 85 } 86 87 return bl; 88 } 89 90 CORE_ADDR 91 get_pc_function_start (CORE_ADDR pc) 92 { 93 struct block *bl; 94 struct minimal_symbol *msymbol; 95 96 bl = block_for_pc (pc); 97 if (bl) 98 { 99 struct symbol *symbol = block_linkage_function (bl); 100 101 if (symbol) 102 { 103 bl = SYMBOL_BLOCK_VALUE (symbol); 104 return BLOCK_START (bl); 105 } 106 } 107 108 msymbol = lookup_minimal_symbol_by_pc (pc); 109 if (msymbol) 110 { 111 CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol); 112 113 if (find_pc_section (fstart)) 114 return fstart; 115 } 116 117 return 0; 118 } 119 120 /* Return the symbol for the function executing in frame FRAME. */ 121 122 struct symbol * 123 get_frame_function (struct frame_info *frame) 124 { 125 struct block *bl = get_frame_block (frame, 0); 126 127 if (bl == NULL) 128 return NULL; 129 130 while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL) 131 bl = BLOCK_SUPERBLOCK (bl); 132 133 return BLOCK_FUNCTION (bl); 134 } 135 136 137 /* Return the function containing pc value PC in section SECTION. 138 Returns 0 if function is not known. */ 139 140 struct symbol * 141 find_pc_sect_function (CORE_ADDR pc, struct obj_section *section) 142 { 143 struct block *b = block_for_pc_sect (pc, section); 144 if (b == 0) 145 return 0; 146 return block_linkage_function (b); 147 } 148 149 /* Return the function containing pc value PC. 150 Returns 0 if function is not known. Backward compatibility, no section */ 151 152 struct symbol * 153 find_pc_function (CORE_ADDR pc) 154 { 155 return find_pc_sect_function (pc, find_pc_mapped_section (pc)); 156 } 157 158 /* These variables are used to cache the most recent result 159 * of find_pc_partial_function. */ 160 161 static CORE_ADDR cache_pc_function_low = 0; 162 static CORE_ADDR cache_pc_function_high = 0; 163 static char *cache_pc_function_name = 0; 164 static struct obj_section *cache_pc_function_section = NULL; 165 166 /* Clear cache, e.g. when symbol table is discarded. */ 167 168 void 169 clear_pc_function_cache (void) 170 { 171 cache_pc_function_low = 0; 172 cache_pc_function_high = 0; 173 cache_pc_function_name = (char *) 0; 174 cache_pc_function_section = NULL; 175 } 176 177 /* Finds the "function" (text symbol) that is smaller than PC but 178 greatest of all of the potential text symbols in SECTION. Sets 179 *NAME and/or *ADDRESS conditionally if that pointer is non-null. 180 If ENDADDR is non-null, then set *ENDADDR to be the end of the 181 function (exclusive), but passing ENDADDR as non-null means that 182 the function might cause symbols to be read. This function either 183 succeeds or fails (not halfway succeeds). If it succeeds, it sets 184 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1. 185 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and 186 returns 0. */ 187 188 /* Backward compatibility, no section argument. */ 189 190 int 191 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, 192 CORE_ADDR *endaddr) 193 { 194 struct obj_section *section; 195 struct partial_symtab *pst; 196 struct symbol *f; 197 struct minimal_symbol *msymbol; 198 struct partial_symbol *psb; 199 int i; 200 CORE_ADDR mapped_pc; 201 202 /* To ensure that the symbol returned belongs to the correct setion 203 (and that the last [random] symbol from the previous section 204 isn't returned) try to find the section containing PC. First try 205 the overlay code (which by default returns NULL); and second try 206 the normal section code (which almost always succeeds). */ 207 section = find_pc_overlay (pc); 208 if (section == NULL) 209 section = find_pc_section (pc); 210 211 mapped_pc = overlay_mapped_address (pc, section); 212 213 if (mapped_pc >= cache_pc_function_low 214 && mapped_pc < cache_pc_function_high 215 && section == cache_pc_function_section) 216 goto return_cached_value; 217 218 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section); 219 pst = find_pc_sect_psymtab (mapped_pc, section); 220 if (pst) 221 { 222 /* Need to read the symbols to get a good value for the end address. */ 223 if (endaddr != NULL && !pst->readin) 224 { 225 /* Need to get the terminal in case symbol-reading produces 226 output. */ 227 target_terminal_ours_for_output (); 228 PSYMTAB_TO_SYMTAB (pst); 229 } 230 231 if (pst->readin) 232 { 233 /* Checking whether the msymbol has a larger value is for the 234 "pathological" case mentioned in print_frame_info. */ 235 f = find_pc_sect_function (mapped_pc, section); 236 if (f != NULL 237 && (msymbol == NULL 238 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f)) 239 >= SYMBOL_VALUE_ADDRESS (msymbol)))) 240 { 241 cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f)); 242 cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f)); 243 cache_pc_function_name = SYMBOL_LINKAGE_NAME (f); 244 cache_pc_function_section = section; 245 goto return_cached_value; 246 } 247 } 248 else 249 { 250 /* Now that static symbols go in the minimal symbol table, perhaps 251 we could just ignore the partial symbols. But at least for now 252 we use the partial or minimal symbol, whichever is larger. */ 253 psb = find_pc_sect_psymbol (pst, mapped_pc, section); 254 255 if (psb 256 && (msymbol == NULL || 257 (SYMBOL_VALUE_ADDRESS (psb) 258 >= SYMBOL_VALUE_ADDRESS (msymbol)))) 259 { 260 /* This case isn't being cached currently. */ 261 if (address) 262 *address = SYMBOL_VALUE_ADDRESS (psb); 263 if (name) 264 *name = SYMBOL_LINKAGE_NAME (psb); 265 /* endaddr non-NULL can't happen here. */ 266 return 1; 267 } 268 } 269 } 270 271 /* Not in the normal symbol tables, see if the pc is in a known section. 272 If it's not, then give up. This ensures that anything beyond the end 273 of the text seg doesn't appear to be part of the last function in the 274 text segment. */ 275 276 if (!section) 277 msymbol = NULL; 278 279 /* Must be in the minimal symbol table. */ 280 if (msymbol == NULL) 281 { 282 /* No available symbol. */ 283 if (name != NULL) 284 *name = 0; 285 if (address != NULL) 286 *address = 0; 287 if (endaddr != NULL) 288 *endaddr = 0; 289 return 0; 290 } 291 292 cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol); 293 cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol); 294 cache_pc_function_section = section; 295 296 /* If the minimal symbol has a size, use it for the cache. 297 Otherwise use the lesser of the next minimal symbol in the same 298 section, or the end of the section, as the end of the 299 function. */ 300 301 if (MSYMBOL_SIZE (msymbol) != 0) 302 cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol); 303 else 304 { 305 /* Step over other symbols at this same address, and symbols in 306 other sections, to find the next symbol in this section with 307 a different address. */ 308 309 for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++) 310 { 311 if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol) 312 && SYMBOL_OBJ_SECTION (msymbol + i) == SYMBOL_OBJ_SECTION (msymbol)) 313 break; 314 } 315 316 if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL 317 && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (section)) 318 cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i); 319 else 320 /* We got the start address from the last msymbol in the objfile. 321 So the end address is the end of the section. */ 322 cache_pc_function_high = obj_section_endaddr (section); 323 } 324 325 return_cached_value: 326 327 if (address) 328 { 329 if (pc_in_unmapped_range (pc, section)) 330 *address = overlay_unmapped_address (cache_pc_function_low, section); 331 else 332 *address = cache_pc_function_low; 333 } 334 335 if (name) 336 *name = cache_pc_function_name; 337 338 if (endaddr) 339 { 340 if (pc_in_unmapped_range (pc, section)) 341 { 342 /* Because the high address is actually beyond the end of 343 the function (and therefore possibly beyond the end of 344 the overlay), we must actually convert (high - 1) and 345 then add one to that. */ 346 347 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1, 348 section); 349 } 350 else 351 *endaddr = cache_pc_function_high; 352 } 353 354 return 1; 355 } 356 357 /* Return the innermost stack frame executing inside of BLOCK, 358 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */ 359 360 struct frame_info * 361 block_innermost_frame (struct block *block) 362 { 363 struct frame_info *frame; 364 CORE_ADDR start; 365 CORE_ADDR end; 366 367 if (block == NULL) 368 return NULL; 369 370 start = BLOCK_START (block); 371 end = BLOCK_END (block); 372 373 frame = get_current_frame (); 374 while (frame != NULL) 375 { 376 struct block *frame_block = get_frame_block (frame, NULL); 377 if (frame_block != NULL && contained_in (frame_block, block)) 378 return frame; 379 380 frame = get_prev_frame (frame); 381 } 382 383 return NULL; 384 } 385