1 /* Code dealing with dummy stack frames, for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
5 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "dummy-frame.h"
28 #include "gdb_assert.h"
29 #include "frame-unwind.h"
32 #include "gdb_string.h"
35 /* Dummy frame. This saves the processor state just prior to setting
36 up the inferior function call. Older targets save the registers
37 on the target stack (but that really slows down function calls). */
41 struct dummy_frame
*next
;
42 /* This frame's ID. Must match the value returned by
45 /* The caller's regcache. */
46 struct regcache
*regcache
;
49 static struct dummy_frame
*dummy_frame_stack
= NULL
;
51 /* Function: deprecated_pc_in_call_dummy (pc)
53 Return non-zero if the PC falls in a dummy frame created by gdb for
54 an inferior call. The code below which allows gdbarch_decr_pc_after_break
55 is for infrun.c, which may give the function a PC without that
58 FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can
59 figure out what the real PC (as in the resume address) is BEFORE
60 calling this function.
62 NOTE: cagney/2004-08-02: I'm pretty sure that, with the introduction of
63 infrun.c:adjust_pc_after_break (thanks), this function is now
64 always called with a correctly adjusted PC!
66 NOTE: cagney/2004-08-02: Code should not need to call this. */
69 deprecated_pc_in_call_dummy (CORE_ADDR pc
)
71 struct dummy_frame
*dummyframe
;
72 for (dummyframe
= dummy_frame_stack
;
74 dummyframe
= dummyframe
->next
)
76 if ((pc
>= dummyframe
->id
.code_addr
)
77 && (pc
<= dummyframe
->id
.code_addr
78 + gdbarch_decr_pc_after_break (current_gdbarch
)))
84 /* Push the caller's state, along with the dummy frame info, onto a
88 dummy_frame_push (struct regcache
*caller_regcache
,
89 const struct frame_id
*dummy_id
)
91 struct dummy_frame
*dummy_frame
;
93 dummy_frame
= XZALLOC (struct dummy_frame
);
94 dummy_frame
->regcache
= caller_regcache
;
95 dummy_frame
->id
= (*dummy_id
);
96 dummy_frame
->next
= dummy_frame_stack
;
97 dummy_frame_stack
= dummy_frame
;
100 /* Pop the dummy frame with ID dummy_id from the dummy-frame stack. */
103 dummy_frame_pop (struct frame_id dummy_id
)
105 struct dummy_frame
**dummy_ptr
;
107 for (dummy_ptr
= &dummy_frame_stack
;
108 (*dummy_ptr
) != NULL
;
109 dummy_ptr
= &(*dummy_ptr
)->next
)
111 struct dummy_frame
*dummy
= *dummy_ptr
;
112 if (frame_id_eq (dummy
->id
, dummy_id
))
114 *dummy_ptr
= dummy
->next
;
115 regcache_xfree (dummy
->regcache
);
122 /* There may be stale dummy frames, perhaps left over from when a longjump took us
123 out of a function that was called by the debugger. Clean them up at least once
124 whenever we start a new inferior. */
127 cleanup_dummy_frames (struct target_ops
*target
, int from_tty
)
129 struct dummy_frame
*dummy
, *next
;
131 for (dummy
= dummy_frame_stack
; dummy
; dummy
= next
)
134 regcache_xfree (dummy
->regcache
);
138 dummy_frame_stack
= NULL
;
141 /* Return the dummy frame cache, it contains both the ID, and a
142 pointer to the regcache. */
143 struct dummy_frame_cache
145 struct frame_id this_id
;
146 struct regcache
*prev_regcache
;
150 dummy_frame_sniffer (const struct frame_unwind
*self
,
151 struct frame_info
*this_frame
,
152 void **this_prologue_cache
)
154 struct dummy_frame
*dummyframe
;
155 struct frame_id this_id
;
157 /* When unwinding a normal frame, the stack structure is determined
158 by analyzing the frame's function's code (be it using brute force
159 prologue analysis, or the dwarf2 CFI). In the case of a dummy
160 frame, that simply isn't possible. The PC is either the program
161 entry point, or some random address on the stack. Trying to use
162 that PC to apply standard frame ID unwind techniques is just
163 asking for trouble. */
165 /* Don't bother unles there is at least one dummy frame. */
166 if (dummy_frame_stack
!= NULL
)
168 /* Use an architecture specific method to extract this frame's
169 dummy ID, assuming it is a dummy frame. */
170 this_id
= gdbarch_dummy_id (get_frame_arch (this_frame
), this_frame
);
172 /* Use that ID to find the corresponding cache entry. */
173 for (dummyframe
= dummy_frame_stack
;
175 dummyframe
= dummyframe
->next
)
177 if (frame_id_eq (dummyframe
->id
, this_id
))
179 struct dummy_frame_cache
*cache
;
180 cache
= FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache
);
181 cache
->prev_regcache
= dummyframe
->regcache
;
182 cache
->this_id
= this_id
;
183 (*this_prologue_cache
) = cache
;
191 /* Given a call-dummy dummy-frame, return the registers. Here the
192 register value is taken from the local copy of the register buffer. */
194 static struct value
*
195 dummy_frame_prev_register (struct frame_info
*this_frame
,
196 void **this_prologue_cache
,
199 struct dummy_frame_cache
*cache
= (*this_prologue_cache
);
200 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
201 struct value
*reg_val
;
203 /* The dummy-frame sniffer always fills in the cache. */
204 gdb_assert (cache
!= NULL
);
206 /* Describe the register's location. Generic dummy frames always
207 have the register value in an ``expression''. */
208 reg_val
= value_zero (register_type (gdbarch
, regnum
), not_lval
);
210 /* Use the regcache_cooked_read() method so that it, on the fly,
211 constructs either a raw or pseudo register from the raw
213 regcache_cooked_read (cache
->prev_regcache
, regnum
,
214 value_contents_writeable (reg_val
));
218 /* Assuming that THIS frame is a dummy, return the ID of THIS frame. That ID is
219 determined by examining the NEXT frame's unwound registers using
220 the method dummy_id(). As a side effect, THIS dummy frame's
221 dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */
224 dummy_frame_this_id (struct frame_info
*this_frame
,
225 void **this_prologue_cache
,
226 struct frame_id
*this_id
)
228 /* The dummy-frame sniffer always fills in the cache. */
229 struct dummy_frame_cache
*cache
= (*this_prologue_cache
);
230 gdb_assert (cache
!= NULL
);
231 (*this_id
) = cache
->this_id
;
234 static const struct frame_unwind dummy_frame_unwinder
=
238 dummy_frame_prev_register
,
243 const struct frame_unwind
*const dummy_frame_unwind
= {
244 &dummy_frame_unwinder
248 fprint_dummy_frames (struct ui_file
*file
)
250 struct dummy_frame
*s
;
251 for (s
= dummy_frame_stack
; s
!= NULL
; s
= s
->next
)
253 gdb_print_host_address (s
, file
);
254 fprintf_unfiltered (file
, ":");
255 fprintf_unfiltered (file
, " id=");
256 fprint_frame_id (file
, s
->id
);
257 fprintf_unfiltered (file
, "\n");
262 maintenance_print_dummy_frames (char *args
, int from_tty
)
265 fprint_dummy_frames (gdb_stdout
);
268 struct cleanup
*cleanups
;
269 struct ui_file
*file
= gdb_fopen (args
, "w");
271 perror_with_name (_("maintenance print dummy-frames"));
272 cleanups
= make_cleanup_ui_file_delete (file
);
273 fprint_dummy_frames (file
);
274 do_cleanups (cleanups
);
278 extern void _initialize_dummy_frame (void);
281 _initialize_dummy_frame (void)
283 add_cmd ("dummy-frames", class_maintenance
, maintenance_print_dummy_frames
,
284 _("Print the contents of the internal dummy-frame stack."),
285 &maintenanceprintlist
);
287 observer_attach_inferior_created (cleanup_dummy_frames
);