1 /* Code dealing with dummy stack frames, for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "dummy-frame.h"
30 #include "gdb_assert.h"
31 #include "frame-unwind.h"
33 static void dummy_frame_this_id (struct frame_info *next_frame,
34 void **this_prologue_cache,
35 struct frame_id *this_id);
37 /* Dummy frame. This saves the processor state just prior to setting
38 up the inferior function call. Older targets save the registers
39 on the target stack (but that really slows down function calls). */
43 struct dummy_frame *next;
45 /* These values belong to the caller (the previous frame, the frame
46 that this unwinds back to). */
52 struct regcache *regcache;
54 /* Address range of the call dummy code. Look for PC in the range
55 [LO..HI) (after allowing for DECR_PC_AFTER_BREAK). */
60 static struct dummy_frame *dummy_frame_stack = NULL;
62 /* Function: find_dummy_frame(pc, fp, sp)
64 Search the stack of dummy frames for one matching the given PC and
65 FP/SP. Unlike pc_in_dummy_frame(), this function doesn't need to
66 adjust for DECR_PC_AFTER_BREAK. This is because it is only legal
67 to call this function after the PC has been adjusted. */
69 static struct dummy_frame *
70 find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
72 struct dummy_frame *dummyframe;
74 for (dummyframe = dummy_frame_stack; dummyframe != NULL;
75 dummyframe = dummyframe->next)
77 /* Does the PC fall within the dummy frame's breakpoint
78 instruction. If not, discard this one. */
79 if (!(pc >= dummyframe->call_lo && pc < dummyframe->call_hi))
81 /* Does the FP match? */
82 if (dummyframe->top != 0)
84 /* If the target architecture explicitly saved the
85 top-of-stack before the inferior function call, assume
86 that that same architecture will always pass in an FP
87 (frame base) value that eactly matches that saved TOS.
88 Don't check the saved SP and SP as they can lead to false
90 if (fp != dummyframe->top)
95 /* An older target that hasn't explicitly or implicitly
96 saved the dummy frame's top-of-stack. Try matching the
97 FP against the saved SP and FP. NOTE: If you're trying
98 to fix a problem with GDB not correctly finding a dummy
99 frame, check the comments that go with FRAME_ALIGN() and
100 SAVE_DUMMY_FRAME_TOS(). */
101 if (fp != dummyframe->fp && fp != dummyframe->sp)
104 /* The FP matches this dummy frame. */
112 generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
114 struct dummy_frame *dummy = find_dummy_frame (pc, fp);
116 return dummy->regcache;
122 deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
124 struct regcache *regcache = generic_find_dummy_frame (pc, fp);
125 if (regcache == NULL)
127 return deprecated_grub_regcache_for_registers (regcache);
130 /* Function: pc_in_call_dummy (pc, sp, fp)
132 Return true if the PC falls in a dummy frame created by gdb for an
133 inferior call. The code below which allows DECR_PC_AFTER_BREAK is
134 for infrun.c, which may give the function a PC without that
138 generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
140 return pc_in_dummy_frame (pc);
143 /* Return non-zero if the PC falls in a dummy frame.
145 The code below which allows DECR_PC_AFTER_BREAK is for infrun.c,
146 which may give the function a PC without that subtracted out.
148 FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can
149 figure out what the real PC (as in the resume address) is BEFORE
150 calling this function (Oh, and I'm not even sure that this function
151 is called with an decremented PC, the call to pc_in_call_dummy() in
152 that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet
153 generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?). */
156 pc_in_dummy_frame (CORE_ADDR pc)
158 struct dummy_frame *dummyframe;
159 for (dummyframe = dummy_frame_stack;
161 dummyframe = dummyframe->next)
163 if ((pc >= dummyframe->call_lo)
164 && (pc < dummyframe->call_hi + DECR_PC_AFTER_BREAK))
170 /* Function: read_register_dummy
171 Find a saved register from before GDB calls a function in the inferior */
174 deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
176 struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
180 /* NOTE: cagney/2002-08-12: Replaced a call to
181 regcache_raw_read_as_address() with a call to
182 regcache_cooked_read_unsigned(). The old, ...as_address
183 function was eventually calling extract_unsigned_integer (via
184 extract_address) to unpack the registers value. The below is
185 doing an unsigned extract so that it is functionally
186 equivalent. The read needs to be cooked as, otherwise, it
187 will never correctly return the value of a register in the
188 [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */
190 regcache_cooked_read_unsigned (dummy_regs, regno, &val);
197 /* Save all the registers on the dummy frame stack. Most ports save the
198 registers on the target stack. This results in lots of unnecessary memory
199 references, which are slow when debugging via a serial line. Instead, we
200 save all the registers internally, and never write them to the stack. The
201 registers get restored when the called function returns to the entry point,
202 where a breakpoint is laying in wait. */
205 generic_push_dummy_frame (void)
207 struct dummy_frame *dummy_frame;
208 CORE_ADDR fp = get_frame_base (get_current_frame ());
210 /* check to see if there are stale dummy frames,
211 perhaps left over from when a longjump took us out of a
212 function that was called by the debugger */
214 dummy_frame = dummy_frame_stack;
216 if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */
218 dummy_frame_stack = dummy_frame->next;
219 regcache_xfree (dummy_frame->regcache);
221 dummy_frame = dummy_frame_stack;
224 dummy_frame = dummy_frame->next;
226 dummy_frame = xmalloc (sizeof (struct dummy_frame));
227 dummy_frame->regcache = regcache_xmalloc (current_gdbarch);
229 dummy_frame->pc = read_pc ();
230 dummy_frame->sp = read_sp ();
231 dummy_frame->top = 0;
232 dummy_frame->fp = fp;
233 dummy_frame->id = get_frame_id (get_current_frame ());
234 regcache_cpy (dummy_frame->regcache, current_regcache);
235 dummy_frame->next = dummy_frame_stack;
236 dummy_frame_stack = dummy_frame;
240 generic_save_dummy_frame_tos (CORE_ADDR sp)
242 dummy_frame_stack->top = sp;
245 /* Record the upper/lower bounds on the address of the call dummy. */
248 generic_save_call_dummy_addr (CORE_ADDR lo, CORE_ADDR hi)
250 dummy_frame_stack->call_lo = lo;
251 dummy_frame_stack->call_hi = hi;
254 /* Restore the machine state from either the saved dummy stack or a
258 generic_pop_current_frame (void (*popper) (struct frame_info * frame))
260 struct frame_info *frame = get_current_frame ();
261 if (get_frame_type (frame) == DUMMY_FRAME)
262 /* NOTE: cagney/2002-22-23: Does this ever occure? Surely a dummy
263 frame will have already been poped by the "infrun.c" code. */
264 generic_pop_dummy_frame ();
269 /* Discard the innermost dummy frame from the dummy frame stack
270 (passed in as a parameter). */
273 discard_innermost_dummy (struct dummy_frame **stack)
275 struct dummy_frame *tbd = (*stack);
276 (*stack) = (*stack)->next;
277 regcache_xfree (tbd->regcache);
282 generic_pop_dummy_frame (void)
284 struct dummy_frame *dummy_frame = dummy_frame_stack;
286 /* FIXME: what if the first frame isn't the right one, eg..
287 because one call-by-hand function has done a longjmp into another one? */
290 error ("Can't pop dummy frame!");
291 regcache_cpy (current_regcache, dummy_frame->regcache);
292 flush_cached_frames ();
294 discard_innermost_dummy (&dummy_frame_stack);
297 /* Given a call-dummy dummy-frame, return the registers. Here the
298 register value is taken from the local copy of the register buffer. */
301 dummy_frame_prev_register (struct frame_info *next_frame,
302 void **this_prologue_cache,
303 int regnum, int *optimized,
304 enum lval_type *lvalp, CORE_ADDR *addrp,
305 int *realnum, void *bufferp)
307 struct dummy_frame *dummy;
310 /* Call the ID method which, if at all possible, will set the
312 dummy_frame_this_id (next_frame, this_prologue_cache, &id);
313 dummy = (*this_prologue_cache);
314 gdb_assert (dummy != NULL);
316 /* Describe the register's location. Generic dummy frames always
317 have the register value in an ``expression''. */
323 /* If needed, find and return the value of the register. */
326 /* Return the actual value. */
327 /* Use the regcache_cooked_read() method so that it, on the fly,
328 constructs either a raw or pseudo register from the raw
330 regcache_cooked_read (dummy->regcache, regnum, bufferp);
334 /* Assuming that THIS frame is a dummy (remember, the NEXT and not
335 THIS frame is passed in), return the ID of THIS frame. That ID is
336 determined by examining the NEXT frame's unwound registers using
337 the method unwind_dummy_id(). As a side effect, THIS dummy frame's
338 dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */
341 dummy_frame_this_id (struct frame_info *next_frame,
342 void **this_prologue_cache,
343 struct frame_id *this_id)
345 struct dummy_frame *dummy = (*this_prologue_cache);
348 (*this_id) = dummy->id;
351 /* When unwinding a normal frame, the stack structure is determined
352 by analyzing the frame's function's code (be it using brute force
353 prologue analysis, or the dwarf2 CFI). In the case of a dummy
354 frame, that simply isn't possible. The The PC is either the
355 program entry point, or some random address on the stack. Trying
356 to use that PC to apply standard frame ID unwind techniques is
357 just asking for trouble. */
358 if (gdbarch_unwind_dummy_id_p (current_gdbarch))
360 /* Assume call_function_by_hand(), via SAVE_DUMMY_FRAME_TOS,
361 previously saved the dummy frame's ID. Things only work if
362 the two return the same value. */
363 gdb_assert (SAVE_DUMMY_FRAME_TOS_P ());
364 /* Use an architecture specific method to extract the prev's
365 dummy ID from the next frame. Note that this method uses
366 frame_register_unwind to obtain the register values needed to
367 determine the dummy frame's ID. */
368 (*this_id) = gdbarch_unwind_dummy_id (current_gdbarch, next_frame);
370 else if (frame_relative_level (next_frame) < 0)
372 /* We're unwinding a sentinel frame, the PC of which is pointing
373 at a stack dummy. Fake up the dummy frame's ID using the
374 same sequence as is found a traditional unwinder. Once all
375 architectures supply the unwind_dummy_id method, this code
377 (*this_id) = frame_id_build (read_fp (), read_pc ());
379 else if (legacy_frame_p (current_gdbarch)
380 && get_prev_frame (next_frame))
382 /* Things are looking seriously grim! Assume that the legacy
383 get_prev_frame code has already created THIS frame and linked
384 it in to the frame chain (a pretty bold assumption), extract
385 the ID from THIS base / pc. */
386 (*this_id) = frame_id_build (get_frame_base (get_prev_frame (next_frame)),
387 get_frame_pc (get_prev_frame (next_frame)));
391 /* Outch! We're not trying to find the innermost frame's ID yet
392 we're trying to unwind to a dummy. The architecture must
393 provide the unwind_dummy_id() method. Abandon the unwind
394 process but only after first warning the user. */
395 internal_warning (__FILE__, __LINE__,
396 "Missing unwind_dummy_id architecture method");
397 (*this_id) = null_frame_id;
400 (*this_prologue_cache) = find_dummy_frame ((*this_id).pc, (*this_id).base);
403 static struct frame_unwind dummy_frame_unwind =
406 dummy_frame_prev_register
409 const struct frame_unwind *
410 dummy_frame_p (CORE_ADDR pc)
412 if (DEPRECATED_PC_IN_CALL_DUMMY_P ()
413 ? DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0)
414 : pc_in_dummy_frame (pc))
415 return &dummy_frame_unwind;