Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / dummy-frame.c
CommitLineData
5796c8dc
SS
1/* Code dealing with dummy stack frames, for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
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
21#include "defs.h"
22#include "dummy-frame.h"
23#include "regcache.h"
24#include "frame.h"
25#include "inferior.h"
26#include "gdb_assert.h"
27#include "frame-unwind.h"
28#include "command.h"
29#include "gdbcmd.h"
30#include "gdb_string.h"
31#include "observer.h"
ef5ccd6c 32#include "gdbthread.h"
5796c8dc
SS
33
34/* Dummy frame. This saves the processor state just prior to setting
35 up the inferior function call. Older targets save the registers
36 on the target stack (but that really slows down function calls). */
37
38struct dummy_frame
39{
40 struct dummy_frame *next;
41 /* This frame's ID. Must match the value returned by
42 gdbarch_dummy_id. */
43 struct frame_id id;
44 /* The caller's state prior to the call. */
c50c785c 45 struct infcall_suspend_state *caller_state;
5796c8dc
SS
46};
47
48static struct dummy_frame *dummy_frame_stack = NULL;
49
5796c8dc
SS
50/* Push the caller's state, along with the dummy frame info, onto the
51 dummy-frame stack. */
52
53void
c50c785c 54dummy_frame_push (struct infcall_suspend_state *caller_state,
5796c8dc
SS
55 const struct frame_id *dummy_id)
56{
57 struct dummy_frame *dummy_frame;
58
59 dummy_frame = XZALLOC (struct dummy_frame);
60 dummy_frame->caller_state = caller_state;
61 dummy_frame->id = (*dummy_id);
62 dummy_frame->next = dummy_frame_stack;
63 dummy_frame_stack = dummy_frame;
64}
65
66/* Remove *DUMMY_PTR from the dummy frame stack. */
67
68static void
69remove_dummy_frame (struct dummy_frame **dummy_ptr)
70{
71 struct dummy_frame *dummy = *dummy_ptr;
72
73 *dummy_ptr = dummy->next;
c50c785c 74 discard_infcall_suspend_state (dummy->caller_state);
5796c8dc
SS
75 xfree (dummy);
76}
77
ef5ccd6c
JM
78/* Delete any breakpoint B which is a momentary breakpoint for return from
79 inferior call matching DUMMY_VOIDP. */
80
81static int
82pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
83{
84 struct dummy_frame *dummy = dummy_voidp;
85
86 if (b->thread == pid_to_thread_id (inferior_ptid)
87 && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id))
88 {
89 while (b->related_breakpoint != b)
90 delete_breakpoint (b->related_breakpoint);
91
92 delete_breakpoint (b);
93
94 /* Stop the traversal. */
95 return 1;
96 }
97
98 /* Continue the traversal. */
99 return 0;
100}
101
5796c8dc
SS
102/* Pop *DUMMY_PTR, restoring program state to that before the
103 frame was created. */
104
105static void
106pop_dummy_frame (struct dummy_frame **dummy_ptr)
107{
ef5ccd6c
JM
108 struct dummy_frame *dummy = *dummy_ptr;
109
110 restore_infcall_suspend_state (dummy->caller_state);
5796c8dc 111
ef5ccd6c 112 iterate_over_breakpoints (pop_dummy_frame_bpt, dummy);
5796c8dc 113
c50c785c
JM
114 /* restore_infcall_control_state frees inf_state,
115 all that remains is to pop *dummy_ptr. */
5796c8dc
SS
116 *dummy_ptr = dummy->next;
117 xfree (dummy);
118
119 /* We've made right mess of GDB's local state, just discard
120 everything. */
121 reinit_frame_cache ();
122}
123
124/* Look up DUMMY_ID.
125 Return NULL if not found. */
126
127static struct dummy_frame **
128lookup_dummy_frame (struct frame_id dummy_id)
129{
130 struct dummy_frame **dp;
131
132 for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next)
133 {
134 if (frame_id_eq ((*dp)->id, dummy_id))
135 return dp;
136 }
137
138 return NULL;
139}
140
141/* Pop the dummy frame DUMMY_ID, restoring program state to that before the
142 frame was created.
143 On return reinit_frame_cache has been called.
144 If the frame isn't found, flag an internal error.
145
146 NOTE: This can only pop the one frame, even if it is in the middle of the
147 stack, because the other frames may be for different threads, and there's
148 currently no way to tell which stack frame is for which thread. */
149
150void
151dummy_frame_pop (struct frame_id dummy_id)
152{
153 struct dummy_frame **dp;
154
155 dp = lookup_dummy_frame (dummy_id);
156 gdb_assert (dp != NULL);
157
158 pop_dummy_frame (dp);
159}
160
ef5ccd6c
JM
161/* Drop dummy frame DUMMY_ID. Do nothing if it is not found. Do not restore
162 its state into inferior, just free its memory. */
163
164void
165dummy_frame_discard (struct frame_id dummy_id)
166{
167 struct dummy_frame **dp;
168
169 dp = lookup_dummy_frame (dummy_id);
170 if (dp)
171 remove_dummy_frame (dp);
172}
173
174/* There may be stale dummy frames, perhaps left over from when an uncaught
175 longjmp took us out of a function that was called by the debugger. Clean
176 them up at least once whenever we start a new inferior. */
5796c8dc
SS
177
178static void
179cleanup_dummy_frames (struct target_ops *target, int from_tty)
180{
181 while (dummy_frame_stack != NULL)
182 remove_dummy_frame (&dummy_frame_stack);
183}
184
185/* Return the dummy frame cache, it contains both the ID, and a
186 pointer to the regcache. */
187struct dummy_frame_cache
188{
189 struct frame_id this_id;
190 struct regcache *prev_regcache;
191};
192
193static int
194dummy_frame_sniffer (const struct frame_unwind *self,
195 struct frame_info *this_frame,
196 void **this_prologue_cache)
197{
198 struct dummy_frame *dummyframe;
199 struct frame_id this_id;
200
201 /* When unwinding a normal frame, the stack structure is determined
202 by analyzing the frame's function's code (be it using brute force
203 prologue analysis, or the dwarf2 CFI). In the case of a dummy
204 frame, that simply isn't possible. The PC is either the program
205 entry point, or some random address on the stack. Trying to use
206 that PC to apply standard frame ID unwind techniques is just
207 asking for trouble. */
208
209 /* Don't bother unless there is at least one dummy frame. */
210 if (dummy_frame_stack != NULL)
211 {
212 /* Use an architecture specific method to extract this frame's
213 dummy ID, assuming it is a dummy frame. */
214 this_id = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
215
216 /* Use that ID to find the corresponding cache entry. */
217 for (dummyframe = dummy_frame_stack;
218 dummyframe != NULL;
219 dummyframe = dummyframe->next)
220 {
221 if (frame_id_eq (dummyframe->id, this_id))
222 {
223 struct dummy_frame_cache *cache;
cf7f2e2d 224
5796c8dc 225 cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
c50c785c
JM
226 cache->prev_regcache = get_infcall_suspend_state_regcache
227 (dummyframe->caller_state);
5796c8dc
SS
228 cache->this_id = this_id;
229 (*this_prologue_cache) = cache;
230 return 1;
231 }
232 }
233 }
234 return 0;
235}
236
237/* Given a call-dummy dummy-frame, return the registers. Here the
238 register value is taken from the local copy of the register buffer. */
239
240static struct value *
241dummy_frame_prev_register (struct frame_info *this_frame,
242 void **this_prologue_cache,
243 int regnum)
244{
245 struct dummy_frame_cache *cache = (*this_prologue_cache);
246 struct gdbarch *gdbarch = get_frame_arch (this_frame);
247 struct value *reg_val;
248
249 /* The dummy-frame sniffer always fills in the cache. */
250 gdb_assert (cache != NULL);
251
252 /* Describe the register's location. Generic dummy frames always
253 have the register value in an ``expression''. */
254 reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
255
256 /* Use the regcache_cooked_read() method so that it, on the fly,
257 constructs either a raw or pseudo register from the raw
258 register cache. */
259 regcache_cooked_read (cache->prev_regcache, regnum,
260 value_contents_writeable (reg_val));
261 return reg_val;
262}
263
264/* Assuming that THIS_FRAME is a dummy, return its ID. That ID is
265 determined by examining the NEXT frame's unwound registers using
266 the method dummy_id(). As a side effect, THIS dummy frame's
a45ae5f8 267 dummy cache is located and saved in THIS_PROLOGUE_CACHE. */
5796c8dc
SS
268
269static void
270dummy_frame_this_id (struct frame_info *this_frame,
271 void **this_prologue_cache,
272 struct frame_id *this_id)
273{
274 /* The dummy-frame sniffer always fills in the cache. */
275 struct dummy_frame_cache *cache = (*this_prologue_cache);
cf7f2e2d 276
5796c8dc
SS
277 gdb_assert (cache != NULL);
278 (*this_id) = cache->this_id;
279}
280
c50c785c 281const struct frame_unwind dummy_frame_unwind =
5796c8dc
SS
282{
283 DUMMY_FRAME,
c50c785c 284 default_frame_unwind_stop_reason,
5796c8dc
SS
285 dummy_frame_this_id,
286 dummy_frame_prev_register,
287 NULL,
288 dummy_frame_sniffer,
289};
290
5796c8dc
SS
291static void
292fprint_dummy_frames (struct ui_file *file)
293{
294 struct dummy_frame *s;
cf7f2e2d 295
5796c8dc
SS
296 for (s = dummy_frame_stack; s != NULL; s = s->next)
297 {
298 gdb_print_host_address (s, file);
299 fprintf_unfiltered (file, ":");
300 fprintf_unfiltered (file, " id=");
301 fprint_frame_id (file, s->id);
302 fprintf_unfiltered (file, "\n");
303 }
304}
305
306static void
307maintenance_print_dummy_frames (char *args, int from_tty)
308{
309 if (args == NULL)
310 fprint_dummy_frames (gdb_stdout);
311 else
312 {
313 struct cleanup *cleanups;
314 struct ui_file *file = gdb_fopen (args, "w");
cf7f2e2d 315
5796c8dc
SS
316 if (file == NULL)
317 perror_with_name (_("maintenance print dummy-frames"));
318 cleanups = make_cleanup_ui_file_delete (file);
319 fprint_dummy_frames (file);
320 do_cleanups (cleanups);
321 }
322}
323
324extern void _initialize_dummy_frame (void);
325
326void
327_initialize_dummy_frame (void)
328{
329 add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
330 _("Print the contents of the internal dummy-frame stack."),
331 &maintenanceprintlist);
332
333 observer_attach_inferior_created (cleanup_dummy_frames);
334}