1 /* Code dealing with dummy stack frames, for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "dummy-frame.h"
26 #include "frame-unwind.h"
30 #include "gdbthread.h"
35 /* This frame's ID. Must match the value returned by
39 /* The thread this dummy_frame relates to. */
43 /* Return whether dummy_frame_id *ID1 and *ID2 are equal. */
46 dummy_frame_id_eq (struct dummy_frame_id *id1,
47 struct dummy_frame_id *id2)
49 return frame_id_eq (id1->id, id2->id) && ptid_equal (id1->ptid, id2->ptid);
52 /* List of dummy_frame destructors. */
54 struct dummy_frame_dtor_list
56 /* Next element in the list or NULL if this is the last element. */
57 struct dummy_frame_dtor_list *next;
59 /* If non-NULL, a destructor that is run when this dummy frame is freed. */
60 dummy_frame_dtor_ftype *dtor;
62 /* Arbitrary data that is passed to DTOR. */
66 /* Dummy frame. This saves the processor state just prior to setting
67 up the inferior function call. Older targets save the registers
68 on the target stack (but that really slows down function calls). */
72 struct dummy_frame *next;
74 /* An id represents a dummy frame. */
75 struct dummy_frame_id id;
77 /* The caller's state prior to the call. */
78 struct infcall_suspend_state *caller_state;
80 /* First element of destructors list or NULL if there are no
81 destructors registered for this dummy_frame. */
82 struct dummy_frame_dtor_list *dtor_list;
85 static struct dummy_frame *dummy_frame_stack = NULL;
87 /* Push the caller's state, along with the dummy frame info, onto the
91 dummy_frame_push (struct infcall_suspend_state *caller_state,
92 const struct frame_id *dummy_id, ptid_t ptid)
94 struct dummy_frame *dummy_frame;
96 dummy_frame = XCNEW (struct dummy_frame);
97 dummy_frame->caller_state = caller_state;
98 dummy_frame->id.id = (*dummy_id);
99 dummy_frame->id.ptid = ptid;
100 dummy_frame->next = dummy_frame_stack;
101 dummy_frame_stack = dummy_frame;
104 /* Remove *DUMMY_PTR from the dummy frame stack. */
107 remove_dummy_frame (struct dummy_frame **dummy_ptr)
109 struct dummy_frame *dummy = *dummy_ptr;
111 while (dummy->dtor_list != NULL)
113 struct dummy_frame_dtor_list *list = dummy->dtor_list;
115 dummy->dtor_list = list->next;
116 list->dtor (list->dtor_data, 0);
120 *dummy_ptr = dummy->next;
121 discard_infcall_suspend_state (dummy->caller_state);
125 /* Delete any breakpoint B which is a momentary breakpoint for return from
126 inferior call matching DUMMY_VOIDP. */
129 pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
131 struct dummy_frame *dummy = (struct dummy_frame *) dummy_voidp;
133 if (b->thread == ptid_to_global_thread_id (dummy->id.ptid)
134 && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
136 while (b->related_breakpoint != b)
137 delete_breakpoint (b->related_breakpoint);
139 delete_breakpoint (b);
141 /* Stop the traversal. */
145 /* Continue the traversal. */
149 /* Pop *DUMMY_PTR, restoring program state to that before the
150 frame was created. */
153 pop_dummy_frame (struct dummy_frame **dummy_ptr)
155 struct dummy_frame *dummy = *dummy_ptr;
157 gdb_assert (ptid_equal (dummy->id.ptid, inferior_ptid));
159 while (dummy->dtor_list != NULL)
161 struct dummy_frame_dtor_list *list = dummy->dtor_list;
163 dummy->dtor_list = list->next;
164 list->dtor (list->dtor_data, 1);
168 restore_infcall_suspend_state (dummy->caller_state);
170 iterate_over_breakpoints (pop_dummy_frame_bpt, dummy);
172 /* restore_infcall_control_state frees inf_state,
173 all that remains is to pop *dummy_ptr. */
174 *dummy_ptr = dummy->next;
177 /* We've made right mess of GDB's local state, just discard
179 reinit_frame_cache ();
183 Return NULL if not found. */
185 static struct dummy_frame **
186 lookup_dummy_frame (struct dummy_frame_id *dummy_id)
188 struct dummy_frame **dp;
190 for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next)
192 if (dummy_frame_id_eq (&(*dp)->id, dummy_id))
199 /* Find the dummy frame by DUMMY_ID and PTID, and pop it, restoring
200 program state to that before the frame was created.
201 On return reinit_frame_cache has been called.
202 If the frame isn't found, flag an internal error. */
205 dummy_frame_pop (struct frame_id dummy_id, ptid_t ptid)
207 struct dummy_frame **dp;
208 struct dummy_frame_id id = { dummy_id, ptid };
210 dp = lookup_dummy_frame (&id);
211 gdb_assert (dp != NULL);
213 pop_dummy_frame (dp);
216 /* Find the dummy frame by DUMMY_ID and PTID and drop it. Do nothing
217 if it is not found. Do not restore its state into inferior, just
221 dummy_frame_discard (struct frame_id dummy_id, ptid_t ptid)
223 struct dummy_frame **dp;
224 struct dummy_frame_id id = { dummy_id, ptid };
226 dp = lookup_dummy_frame (&id);
228 remove_dummy_frame (dp);
231 /* See dummy-frame.h. */
234 register_dummy_frame_dtor (struct frame_id dummy_id, ptid_t ptid,
235 dummy_frame_dtor_ftype *dtor, void *dtor_data)
237 struct dummy_frame_id id = { dummy_id, ptid };
238 struct dummy_frame **dp, *d;
239 struct dummy_frame_dtor_list *list;
241 dp = lookup_dummy_frame (&id);
242 gdb_assert (dp != NULL);
244 list = XNEW (struct dummy_frame_dtor_list);
245 list->next = d->dtor_list;
248 list->dtor_data = dtor_data;
251 /* See dummy-frame.h. */
254 find_dummy_frame_dtor (dummy_frame_dtor_ftype *dtor, void *dtor_data)
256 struct dummy_frame *d;
258 for (d = dummy_frame_stack; d != NULL; d = d->next)
260 struct dummy_frame_dtor_list *list;
262 for (list = d->dtor_list; list != NULL; list = list->next)
263 if (list->dtor == dtor && list->dtor_data == dtor_data)
269 /* There may be stale dummy frames, perhaps left over from when an uncaught
270 longjmp took us out of a function that was called by the debugger. Clean
271 them up at least once whenever we start a new inferior. */
274 cleanup_dummy_frames (struct target_ops *target, int from_tty)
276 while (dummy_frame_stack != NULL)
277 remove_dummy_frame (&dummy_frame_stack);
280 /* Return the dummy frame cache, it contains both the ID, and a
281 pointer to the regcache. */
282 struct dummy_frame_cache
284 struct frame_id this_id;
285 readonly_detached_regcache *prev_regcache;
289 dummy_frame_sniffer (const struct frame_unwind *self,
290 struct frame_info *this_frame,
291 void **this_prologue_cache)
293 /* When unwinding a normal frame, the stack structure is determined
294 by analyzing the frame's function's code (be it using brute force
295 prologue analysis, or the dwarf2 CFI). In the case of a dummy
296 frame, that simply isn't possible. The PC is either the program
297 entry point, or some random address on the stack. Trying to use
298 that PC to apply standard frame ID unwind techniques is just
299 asking for trouble. */
301 /* Don't bother unless there is at least one dummy frame. */
302 if (dummy_frame_stack != NULL)
304 struct dummy_frame *dummyframe;
305 /* Use an architecture specific method to extract this frame's
306 dummy ID, assuming it is a dummy frame. */
307 struct frame_id this_id
308 = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
309 struct dummy_frame_id dummy_id = { this_id, inferior_ptid };
311 /* Use that ID to find the corresponding cache entry. */
312 for (dummyframe = dummy_frame_stack;
314 dummyframe = dummyframe->next)
316 if (dummy_frame_id_eq (&dummyframe->id, &dummy_id))
318 struct dummy_frame_cache *cache;
320 cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
321 cache->prev_regcache = get_infcall_suspend_state_regcache
322 (dummyframe->caller_state);
323 cache->this_id = this_id;
324 (*this_prologue_cache) = cache;
332 /* Given a call-dummy dummy-frame, return the registers. Here the
333 register value is taken from the local copy of the register buffer. */
335 static struct value *
336 dummy_frame_prev_register (struct frame_info *this_frame,
337 void **this_prologue_cache,
340 struct dummy_frame_cache *cache
341 = (struct dummy_frame_cache *) *this_prologue_cache;
342 struct gdbarch *gdbarch = get_frame_arch (this_frame);
343 struct value *reg_val;
345 /* The dummy-frame sniffer always fills in the cache. */
346 gdb_assert (cache != NULL);
348 /* Describe the register's location. Generic dummy frames always
349 have the register value in an ``expression''. */
350 reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
352 /* Use the regcache_cooked_read() method so that it, on the fly,
353 constructs either a raw or pseudo register from the raw
355 cache->prev_regcache->cooked_read (regnum,
356 value_contents_writeable (reg_val));
360 /* Assuming that THIS_FRAME is a dummy, return its ID. That ID is
361 determined by examining the NEXT frame's unwound registers using
362 the method dummy_id(). As a side effect, THIS dummy frame's
363 dummy cache is located and saved in THIS_PROLOGUE_CACHE. */
366 dummy_frame_this_id (struct frame_info *this_frame,
367 void **this_prologue_cache,
368 struct frame_id *this_id)
370 /* The dummy-frame sniffer always fills in the cache. */
371 struct dummy_frame_cache *cache
372 = (struct dummy_frame_cache *) *this_prologue_cache;
374 gdb_assert (cache != NULL);
375 (*this_id) = cache->this_id;
378 const struct frame_unwind dummy_frame_unwind =
381 default_frame_unwind_stop_reason,
383 dummy_frame_prev_register,
389 fprint_dummy_frames (struct ui_file *file)
391 struct dummy_frame *s;
393 for (s = dummy_frame_stack; s != NULL; s = s->next)
395 gdb_print_host_address (s, file);
396 fprintf_unfiltered (file, ":");
397 fprintf_unfiltered (file, " id=");
398 fprint_frame_id (file, s->id.id);
399 fprintf_unfiltered (file, ", ptid=%s",
400 target_pid_to_str (s->id.ptid));
401 fprintf_unfiltered (file, "\n");
406 maintenance_print_dummy_frames (const char *args, int from_tty)
409 fprint_dummy_frames (gdb_stdout);
414 if (!file.open (args, "w"))
415 perror_with_name (_("maintenance print dummy-frames"));
416 fprint_dummy_frames (&file);
421 _initialize_dummy_frame (void)
423 add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
424 _("Print the contents of the internal dummy-frame stack."),
425 &maintenanceprintlist);
427 observer_attach_inferior_created (cleanup_dummy_frames);