1 /* Inline frame unwinder for GDB. 2 3 Copyright (C) 2008, 2009, 2010, 2011 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 3 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, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "addrmap.h" 22 #include "block.h" 23 #include "frame-unwind.h" 24 #include "inferior.h" 25 #include "regcache.h" 26 #include "symtab.h" 27 #include "vec.h" 28 29 #include "gdb_assert.h" 30 31 /* We need to save a few variables for every thread stopped at the 32 virtual call site of an inlined function. If there was always a 33 "struct thread_info", we could hang it off that; in the mean time, 34 keep our own list. */ 35 struct inline_state 36 { 37 /* The thread this data relates to. It should be a currently 38 stopped thread; we assume thread IDs never change while the 39 thread is stopped. */ 40 ptid_t ptid; 41 42 /* The number of inlined functions we are skipping. Each of these 43 functions can be stepped in to. */ 44 int skipped_frames; 45 46 /* Only valid if SKIPPED_FRAMES is non-zero. This is the PC used 47 when calculating SKIPPED_FRAMES; used to check whether we have 48 moved to a new location by user request. If so, we invalidate 49 any skipped frames. */ 50 CORE_ADDR saved_pc; 51 52 /* Only valid if SKIPPED_FRAMES is non-zero. This is the symbol 53 of the outermost skipped inline function. It's used to find the 54 call site of the current frame. */ 55 struct symbol *skipped_symbol; 56 }; 57 58 typedef struct inline_state inline_state_s; 59 DEF_VEC_O(inline_state_s); 60 61 static VEC(inline_state_s) *inline_states; 62 63 /* Locate saved inlined frame state for PTID, if it exists 64 and is valid. */ 65 66 static struct inline_state * 67 find_inline_frame_state (ptid_t ptid) 68 { 69 struct inline_state *state; 70 int ix; 71 72 for (ix = 0; VEC_iterate (inline_state_s, inline_states, ix, state); ix++) 73 { 74 if (ptid_equal (state->ptid, ptid)) 75 { 76 struct regcache *regcache = get_thread_regcache (ptid); 77 CORE_ADDR current_pc = regcache_read_pc (regcache); 78 79 if (current_pc != state->saved_pc) 80 { 81 /* PC has changed - this context is invalid. Use the 82 default behavior. */ 83 VEC_unordered_remove (inline_state_s, inline_states, ix); 84 return NULL; 85 } 86 else 87 return state; 88 } 89 } 90 91 return NULL; 92 } 93 94 /* Allocate saved inlined frame state for PTID. */ 95 96 static struct inline_state * 97 allocate_inline_frame_state (ptid_t ptid) 98 { 99 struct inline_state *state; 100 101 state = VEC_safe_push (inline_state_s, inline_states, NULL); 102 memset (state, 0, sizeof (*state)); 103 state->ptid = ptid; 104 105 return state; 106 } 107 108 /* Forget about any hidden inlined functions in PTID, which is new or 109 about to be resumed. PTID may be minus_one_ptid (all processes) 110 or a PID (all threads in this process). */ 111 112 void 113 clear_inline_frame_state (ptid_t ptid) 114 { 115 struct inline_state *state; 116 int ix; 117 118 if (ptid_equal (ptid, minus_one_ptid)) 119 { 120 VEC_free (inline_state_s, inline_states); 121 return; 122 } 123 124 if (ptid_is_pid (ptid)) 125 { 126 VEC (inline_state_s) *new_states = NULL; 127 int pid = ptid_get_pid (ptid); 128 129 for (ix = 0; 130 VEC_iterate (inline_state_s, inline_states, ix, state); 131 ix++) 132 if (pid != ptid_get_pid (state->ptid)) 133 VEC_safe_push (inline_state_s, new_states, state); 134 VEC_free (inline_state_s, inline_states); 135 inline_states = new_states; 136 return; 137 } 138 139 for (ix = 0; VEC_iterate (inline_state_s, inline_states, ix, state); ix++) 140 if (ptid_equal (state->ptid, ptid)) 141 { 142 VEC_unordered_remove (inline_state_s, inline_states, ix); 143 return; 144 } 145 } 146 147 static void 148 inline_frame_this_id (struct frame_info *this_frame, 149 void **this_cache, 150 struct frame_id *this_id) 151 { 152 struct symbol *func; 153 154 /* In order to have a stable frame ID for a given inline function, 155 we must get the stack / special addresses from the underlying 156 real frame's this_id method. So we must call get_prev_frame. 157 Because we are inlined into some function, there must be previous 158 frames, so this is safe - as long as we're careful not to 159 create any cycles. */ 160 *this_id = get_frame_id (get_prev_frame (this_frame)); 161 162 /* We need a valid frame ID, so we need to be based on a valid 163 frame. FSF submission NOTE: this would be a good assertion to 164 apply to all frames, all the time. That would fix the ambiguity 165 of null_frame_id (between "no/any frame" and "the outermost 166 frame"). This will take work. */ 167 gdb_assert (frame_id_p (*this_id)); 168 169 /* For now, require we don't match outer_frame_id either (see 170 comment above). */ 171 gdb_assert (!frame_id_eq (*this_id, outer_frame_id)); 172 173 /* Future work NOTE: Alexandre Oliva applied a patch to GCC 4.3 174 which generates DW_AT_entry_pc for inlined functions when 175 possible. If this attribute is available, we should use it 176 in the frame ID (and eventually, to set breakpoints). */ 177 func = get_frame_function (this_frame); 178 gdb_assert (func != NULL); 179 (*this_id).code_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (func)); 180 (*this_id).inline_depth++; 181 } 182 183 static struct value * 184 inline_frame_prev_register (struct frame_info *this_frame, void **this_cache, 185 int regnum) 186 { 187 /* Use get_frame_register_value instead of 188 frame_unwind_got_register, to avoid requiring this frame's ID. 189 This frame's ID depends on the previous frame's ID (unusual), and 190 the previous frame's ID depends on this frame's unwound 191 registers. If unwinding registers from this frame called 192 get_frame_id, there would be a loop. 193 194 Do not copy this code into any other unwinder! Inlined functions 195 are special; other unwinders must not have a dependency on the 196 previous frame's ID, and therefore can and should use 197 frame_unwind_got_register instead. */ 198 return get_frame_register_value (this_frame, regnum); 199 } 200 201 /* Check whether we are at an inlining site that does not already 202 have an associated frame. */ 203 204 static int 205 inline_frame_sniffer (const struct frame_unwind *self, 206 struct frame_info *this_frame, 207 void **this_cache) 208 { 209 CORE_ADDR this_pc; 210 struct block *frame_block, *cur_block; 211 int depth; 212 struct frame_info *next_frame; 213 struct inline_state *state = find_inline_frame_state (inferior_ptid); 214 215 this_pc = get_frame_address_in_block (this_frame); 216 frame_block = block_for_pc (this_pc); 217 if (frame_block == NULL) 218 return 0; 219 220 /* Calculate DEPTH, the number of inlined functions at this 221 location. */ 222 depth = 0; 223 cur_block = frame_block; 224 while (BLOCK_SUPERBLOCK (cur_block)) 225 { 226 if (block_inlined_p (cur_block)) 227 depth++; 228 229 cur_block = BLOCK_SUPERBLOCK (cur_block); 230 } 231 232 /* Check how many inlined functions already have frames. */ 233 for (next_frame = get_next_frame (this_frame); 234 next_frame && get_frame_type (next_frame) == INLINE_FRAME; 235 next_frame = get_next_frame (next_frame)) 236 { 237 gdb_assert (depth > 0); 238 depth--; 239 } 240 241 /* If this is the topmost frame, or all frames above us are inlined, 242 then check whether we were requested to skip some frames (so they 243 can be stepped into later). */ 244 if (state != NULL && state->skipped_frames > 0 && next_frame == NULL) 245 { 246 gdb_assert (depth >= state->skipped_frames); 247 depth -= state->skipped_frames; 248 } 249 250 /* If all the inlined functions here already have frames, then pass 251 to the normal unwinder for this PC. */ 252 if (depth == 0) 253 return 0; 254 255 /* If the next frame is an inlined function, but not the outermost, then 256 we are the next outer. If it is not an inlined function, then we 257 are the innermost inlined function of a different real frame. */ 258 return 1; 259 } 260 261 const struct frame_unwind inline_frame_unwind = { 262 INLINE_FRAME, 263 default_frame_unwind_stop_reason, 264 inline_frame_this_id, 265 inline_frame_prev_register, 266 NULL, 267 inline_frame_sniffer 268 }; 269 270 /* Return non-zero if BLOCK, an inlined function block containing PC, 271 has a group of contiguous instructions starting at PC (but not 272 before it). */ 273 274 static int 275 block_starting_point_at (CORE_ADDR pc, struct block *block) 276 { 277 struct blockvector *bv; 278 struct block *new_block; 279 280 bv = blockvector_for_pc (pc, NULL); 281 if (BLOCKVECTOR_MAP (bv) == NULL) 282 return 0; 283 284 new_block = addrmap_find (BLOCKVECTOR_MAP (bv), pc - 1); 285 if (new_block == NULL) 286 return 1; 287 288 if (new_block == block || contained_in (new_block, block)) 289 return 0; 290 291 /* The immediately preceeding address belongs to a different block, 292 which is not a child of this one. Treat this as an entrance into 293 BLOCK. */ 294 return 1; 295 } 296 297 /* Skip all inlined functions whose call sites are at the current PC. 298 Frames for the hidden functions will not appear in the backtrace until the 299 user steps into them. */ 300 301 void 302 skip_inline_frames (ptid_t ptid) 303 { 304 CORE_ADDR this_pc; 305 struct block *frame_block, *cur_block; 306 struct symbol *last_sym = NULL; 307 int skip_count = 0; 308 struct inline_state *state; 309 310 /* This function is called right after reinitializing the frame 311 cache. We try not to do more unwinding than absolutely 312 necessary, for performance. */ 313 this_pc = get_frame_pc (get_current_frame ()); 314 frame_block = block_for_pc (this_pc); 315 316 if (frame_block != NULL) 317 { 318 cur_block = frame_block; 319 while (BLOCK_SUPERBLOCK (cur_block)) 320 { 321 if (block_inlined_p (cur_block)) 322 { 323 /* See comments in inline_frame_this_id about this use 324 of BLOCK_START. */ 325 if (BLOCK_START (cur_block) == this_pc 326 || block_starting_point_at (this_pc, cur_block)) 327 { 328 skip_count++; 329 last_sym = BLOCK_FUNCTION (cur_block); 330 } 331 else 332 break; 333 } 334 cur_block = BLOCK_SUPERBLOCK (cur_block); 335 } 336 } 337 338 gdb_assert (find_inline_frame_state (ptid) == NULL); 339 state = allocate_inline_frame_state (ptid); 340 state->skipped_frames = skip_count; 341 state->saved_pc = this_pc; 342 state->skipped_symbol = last_sym; 343 344 if (skip_count != 0) 345 reinit_frame_cache (); 346 } 347 348 /* Step into an inlined function by unhiding it. */ 349 350 void 351 step_into_inline_frame (ptid_t ptid) 352 { 353 struct inline_state *state = find_inline_frame_state (ptid); 354 355 gdb_assert (state != NULL && state->skipped_frames > 0); 356 state->skipped_frames--; 357 reinit_frame_cache (); 358 } 359 360 /* Return the number of hidden functions inlined into the current 361 frame. */ 362 363 int 364 inline_skipped_frames (ptid_t ptid) 365 { 366 struct inline_state *state = find_inline_frame_state (ptid); 367 368 if (state == NULL) 369 return 0; 370 else 371 return state->skipped_frames; 372 } 373 374 /* If one or more inlined functions are hidden, return the symbol for 375 the function inlined into the current frame. */ 376 377 struct symbol * 378 inline_skipped_symbol (ptid_t ptid) 379 { 380 struct inline_state *state = find_inline_frame_state (ptid); 381 382 gdb_assert (state != NULL); 383 return state->skipped_symbol; 384 } 385 386 /* Return the number of functions inlined into THIS_FRAME. Some of 387 the callees may not have associated frames (see 388 skip_inline_frames). */ 389 390 int 391 frame_inlined_callees (struct frame_info *this_frame) 392 { 393 struct frame_info *next_frame; 394 int inline_count = 0; 395 396 /* First count how many inlined functions at this PC have frames 397 above FRAME (are inlined into FRAME). */ 398 for (next_frame = get_next_frame (this_frame); 399 next_frame && get_frame_type (next_frame) == INLINE_FRAME; 400 next_frame = get_next_frame (next_frame)) 401 inline_count++; 402 403 /* Simulate some most-inner inlined frames which were suppressed, so 404 they can be stepped into later. If we are unwinding already 405 outer frames from some non-inlined frame this does not apply. */ 406 if (next_frame == NULL) 407 inline_count += inline_skipped_frames (inferior_ptid); 408 409 return inline_count; 410 } 411