GDB (xrefs)
/tmp/gdb-7.10/gdb/dummy-frame.c
Go to the documentation of this file.
1 /* Code dealing with dummy stack frames, for GDB, the GNU debugger.
2 
3  Copyright (C) 1986-2015 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 
21 #include "defs.h"
22 #include "dummy-frame.h"
23 #include "regcache.h"
24 #include "frame.h"
25 #include "inferior.h"
26 #include "frame-unwind.h"
27 #include "command.h"
28 #include "gdbcmd.h"
29 #include "observer.h"
30 #include "gdbthread.h"
31 #include "infcall.h"
32 
34 {
35  /* This frame's ID. Must match the value returned by
36  gdbarch_dummy_id. */
37  struct frame_id id;
38 
39  /* The thread this dummy_frame relates to. */
41 };
42 
43 /* Return whether dummy_frame_id *ID1 and *ID2 are equal. */
44 
45 static int
47  struct dummy_frame_id *id2)
48 {
49  return frame_id_eq (id1->id, id2->id) && ptid_equal (id1->ptid, id2->ptid);
50 }
51 
52 /* List of dummy_frame destructors. */
53 
55 {
56  /* Next element in the list or NULL if this is the last element. */
58 
59  /* If non-NULL, a destructor that is run when this dummy frame is freed. */
61 
62  /* Arbitrary data that is passed to DTOR. */
63  void *dtor_data;
64 };
65 
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). */
69 
71 {
72  struct dummy_frame *next;
73 
74  /* An id represents a dummy frame. */
76 
77  /* The caller's state prior to the call. */
79 
80  /* First element of destructors list or NULL if there are no
81  destructors registered for this dummy_frame. */
83 };
84 
85 static struct dummy_frame *dummy_frame_stack = NULL;
86 
87 /* Push the caller's state, along with the dummy frame info, onto the
88  dummy-frame stack. */
89 
90 void
92  const struct frame_id *dummy_id, ptid_t ptid)
93 {
94  struct dummy_frame *dummy_frame;
95 
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;
102 }
103 
104 /* Remove *DUMMY_PTR from the dummy frame stack. */
105 
106 static void
107 remove_dummy_frame (struct dummy_frame **dummy_ptr)
108 {
109  struct dummy_frame *dummy = *dummy_ptr;
110 
111  while (dummy->dtor_list != NULL)
112  {
113  struct dummy_frame_dtor_list *list = dummy->dtor_list;
114 
115  dummy->dtor_list = list->next;
116  list->dtor (list->dtor_data, 0);
117  xfree (list);
118  }
119 
120  *dummy_ptr = dummy->next;
122  xfree (dummy);
123 }
124 
125 /* Delete any breakpoint B which is a momentary breakpoint for return from
126  inferior call matching DUMMY_VOIDP. */
127 
128 static int
129 pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
130 {
131  struct dummy_frame *dummy = dummy_voidp;
132 
133  if (b->thread == pid_to_thread_id (dummy->id.ptid)
134  && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
135  {
136  while (b->related_breakpoint != b)
138 
139  delete_breakpoint (b);
140 
141  /* Stop the traversal. */
142  return 1;
143  }
144 
145  /* Continue the traversal. */
146  return 0;
147 }
148 
149 /* Pop *DUMMY_PTR, restoring program state to that before the
150  frame was created. */
151 
152 static void
153 pop_dummy_frame (struct dummy_frame **dummy_ptr)
154 {
155  struct dummy_frame *dummy = *dummy_ptr;
156 
158 
159  while (dummy->dtor_list != NULL)
160  {
161  struct dummy_frame_dtor_list *list = dummy->dtor_list;
162 
163  dummy->dtor_list = list->next;
164  list->dtor (list->dtor_data, 1);
165  xfree (list);
166  }
167 
169 
171 
172  /* restore_infcall_control_state frees inf_state,
173  all that remains is to pop *dummy_ptr. */
174  *dummy_ptr = dummy->next;
175  xfree (dummy);
176 
177  /* We've made right mess of GDB's local state, just discard
178  everything. */
180 }
181 
182 /* Look up DUMMY_ID.
183  Return NULL if not found. */
184 
185 static struct dummy_frame **
187 {
188  struct dummy_frame **dp;
189 
190  for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next)
191  {
192  if (dummy_frame_id_eq (&(*dp)->id, dummy_id))
193  return dp;
194  }
195 
196  return NULL;
197 }
198 
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. */
203 
204 void
206 {
207  struct dummy_frame **dp;
208  struct dummy_frame_id id = { dummy_id, ptid };
209 
210  dp = lookup_dummy_frame (&id);
211  gdb_assert (dp != NULL);
212 
213  pop_dummy_frame (dp);
214 }
215 
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
218  free its memory. */
219 
220 void
222 {
223  struct dummy_frame **dp;
224  struct dummy_frame_id id = { dummy_id, ptid };
225 
226  dp = lookup_dummy_frame (&id);
227  if (dp)
228  remove_dummy_frame (dp);
229 }
230 
231 /* See dummy-frame.h. */
232 
233 void
235  dummy_frame_dtor_ftype *dtor, void *dtor_data)
236 {
237  struct dummy_frame_id id = { dummy_id, ptid };
238  struct dummy_frame **dp, *d;
239  struct dummy_frame_dtor_list *list;
240 
241  dp = lookup_dummy_frame (&id);
242  gdb_assert (dp != NULL);
243  d = *dp;
244  list = xmalloc (sizeof (*list));
245  list->next = d->dtor_list;
246  d->dtor_list = list;
247  list->dtor = dtor;
248  list->dtor_data = dtor_data;
249 }
250 
251 /* See dummy-frame.h. */
252 
253 int
255 {
256  struct dummy_frame *d;
257 
258  for (d = dummy_frame_stack; d != NULL; d = d->next)
259  {
260  struct dummy_frame_dtor_list *list;
261 
262  for (list = d->dtor_list; list != NULL; list = list->next)
263  if (list->dtor == dtor && list->dtor_data == dtor_data)
264  return 1;
265  }
266  return 0;
267 }
268 
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. */
272 
273 static void
274 cleanup_dummy_frames (struct target_ops *target, int from_tty)
275 {
276  while (dummy_frame_stack != NULL)
277  remove_dummy_frame (&dummy_frame_stack);
278 }
279 
280 /* Return the dummy frame cache, it contains both the ID, and a
281  pointer to the regcache. */
283 {
286 };
287 
288 static int
289 dummy_frame_sniffer (const struct frame_unwind *self,
290  struct frame_info *this_frame,
291  void **this_prologue_cache)
292 {
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. */
300 
301  /* Don't bother unless there is at least one dummy frame. */
302  if (dummy_frame_stack != NULL)
303  {
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 };
310 
311  /* Use that ID to find the corresponding cache entry. */
312  for (dummyframe = dummy_frame_stack;
313  dummyframe != NULL;
314  dummyframe = dummyframe->next)
315  {
316  if (dummy_frame_id_eq (&dummyframe->id, &dummy_id))
317  {
318  struct dummy_frame_cache *cache;
319 
320  cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
322  (dummyframe->caller_state);
323  cache->this_id = this_id;
324  (*this_prologue_cache) = cache;
325  return 1;
326  }
327  }
328  }
329  return 0;
330 }
331 
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. */
334 
335 static struct value *
337  void **this_prologue_cache,
338  int regnum)
339 {
340  struct dummy_frame_cache *cache = (*this_prologue_cache);
341  struct gdbarch *gdbarch = get_frame_arch (this_frame);
342  struct value *reg_val;
343 
344  /* The dummy-frame sniffer always fills in the cache. */
345  gdb_assert (cache != NULL);
346 
347  /* Describe the register's location. Generic dummy frames always
348  have the register value in an ``expression''. */
349  reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
350 
351  /* Use the regcache_cooked_read() method so that it, on the fly,
352  constructs either a raw or pseudo register from the raw
353  register cache. */
354  regcache_cooked_read (cache->prev_regcache, regnum,
355  value_contents_writeable (reg_val));
356  return reg_val;
357 }
358 
359 /* Assuming that THIS_FRAME is a dummy, return its ID. That ID is
360  determined by examining the NEXT frame's unwound registers using
361  the method dummy_id(). As a side effect, THIS dummy frame's
362  dummy cache is located and saved in THIS_PROLOGUE_CACHE. */
363 
364 static void
365 dummy_frame_this_id (struct frame_info *this_frame,
366  void **this_prologue_cache,
367  struct frame_id *this_id)
368 {
369  /* The dummy-frame sniffer always fills in the cache. */
370  struct dummy_frame_cache *cache = (*this_prologue_cache);
371 
372  gdb_assert (cache != NULL);
373  (*this_id) = cache->this_id;
374 }
375 
376 const struct frame_unwind dummy_frame_unwind =
377 {
378  DUMMY_FRAME,
382  NULL,
384 };
385 
386 static void
388 {
389  struct dummy_frame *s;
390 
391  for (s = dummy_frame_stack; s != NULL; s = s->next)
392  {
393  gdb_print_host_address (s, file);
394  fprintf_unfiltered (file, ":");
395  fprintf_unfiltered (file, " id=");
396  fprint_frame_id (file, s->id.id);
397  fprintf_unfiltered (file, ", ptid=%s",
398  target_pid_to_str (s->id.ptid));
399  fprintf_unfiltered (file, "\n");
400  }
401 }
402 
403 static void
404 maintenance_print_dummy_frames (char *args, int from_tty)
405 {
406  if (args == NULL)
408  else
409  {
410  struct cleanup *cleanups;
411  struct ui_file *file = gdb_fopen (args, "w");
412 
413  if (file == NULL)
414  perror_with_name (_("maintenance print dummy-frames"));
415  cleanups = make_cleanup_ui_file_delete (file);
416  fprint_dummy_frames (file);
417  do_cleanups (cleanups);
418  }
419 }
420 
421 extern void _initialize_dummy_frame (void);
422 
423 void
425 {
427  _("Print the contents of the internal dummy-frame stack."),
429 
431 }
static void pop_dummy_frame(struct dummy_frame **dummy_ptr)
Definition: dummy-frame.c:153
struct value * value_zero(struct type *type, enum lval_type lv)
Definition: valops.c:842
void discard_infcall_suspend_state(struct infcall_suspend_state *)
Definition: infrun.c:7363
struct dummy_frame * next
Definition: dummy-frame.c:72
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
void xfree(void *)
Definition: common-utils.c:97
void dummy_frame_pop(struct frame_id dummy_id, ptid_t ptid)
Definition: dummy-frame.c:205
struct dummy_frame_dtor_list * dtor_list
Definition: dummy-frame.c:82
struct frame_id id
Definition: dummy-frame.c:37
static struct dummy_frame * dummy_frame_stack
Definition: dummy-frame.c:85
struct ui_file * gdb_stdout
Definition: main.c:71
static int dummy_frame_id_eq(struct dummy_frame_id *id1, struct dummy_frame_id *id2)
Definition: dummy-frame.c:46
void register_dummy_frame_dtor(struct frame_id dummy_id, ptid_t ptid, dummy_frame_dtor_ftype *dtor, void *dtor_data)
Definition: dummy-frame.c:234
void _initialize_dummy_frame(void)
Definition: dummy-frame.c:424
struct ui_file * gdb_fopen(const char *name, const char *mode)
Definition: ui-file.c:723
static struct value * dummy_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: dummy-frame.c:336
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
#define _(String)
Definition: gdb_locale.h:40
static void fprint_dummy_frames(struct ui_file *file)
Definition: dummy-frame.c:387
struct frame_id this_id
Definition: dummy-frame.c:284
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:660
void dummy_frame_discard(struct frame_id dummy_id, ptid_t ptid)
Definition: dummy-frame.c:221
Definition: ptid.h:35
struct frame_id gdbarch_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: gdbarch.c:2165
enum bpdisp disposition
Definition: breakpoint.h:673
struct observer * observer_attach_inferior_created(observer_inferior_created_ftype *f)
int frame_id_eq(struct frame_id l, struct frame_id r)
Definition: frame.c:604
struct infcall_suspend_state * caller_state
Definition: dummy-frame.c:78
static struct dummy_frame ** lookup_dummy_frame(struct dummy_frame_id *dummy_id)
Definition: dummy-frame.c:186
static void maintenance_print_dummy_frames(char *args, int from_tty)
Definition: dummy-frame.c:404
dummy_frame_dtor_ftype * dtor
Definition: dummy-frame.c:60
void dummy_frame_push(struct infcall_suspend_state *caller_state, const struct frame_id *dummy_id, ptid_t ptid)
Definition: dummy-frame.c:91
struct breakpoint * iterate_over_breakpoints(int(*callback)(struct breakpoint *, void *), void *data)
Definition: breakpoint.c:15504
struct regcache * prev_regcache
Definition: dummy-frame.c:285
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:157
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
static int pop_dummy_frame_bpt(struct breakpoint *b, void *dummy_voidp)
Definition: dummy-frame.c:129
void( dummy_frame_dtor_ftype)(void *data, int registers_valid)
Definition: dummy-frame.h:59
gdb_byte * value_contents_writeable(struct value *value)
Definition: value.c:1338
#define gdb_assert(expr)
Definition: gdb_assert.h:33
unsigned dummy
Definition: go32-nat.c:1071
int regnum
Definition: aarch64-tdep.c:69
void * xmalloc(YYSIZE_T)
struct cmd_list_element * maintenanceprintlist
Definition: cli-cmds.c:167
Definition: value.c:172
void restore_infcall_suspend_state(struct infcall_suspend_state *)
Definition: infrun.c:7321
void gdb_print_host_address(const void *addr, struct ui_file *stream)
Definition: utils.c:1106
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
struct dummy_frame_id id
Definition: dummy-frame.c:75
struct dummy_frame_dtor_list * next
Definition: dummy-frame.c:57
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
ptid_t inferior_ptid
Definition: infcmd.c:124
struct regcache * get_infcall_suspend_state_regcache(struct infcall_suspend_state *)
Definition: infrun.c:7371
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
static int dummy_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: dummy-frame.c:289
static void dummy_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: dummy-frame.c:365
void fprint_frame_id(struct ui_file *file, struct frame_id id)
Definition: frame.c:318
struct breakpoint * related_breakpoint
Definition: breakpoint.h:736
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
static void cleanup_dummy_frames(struct target_ops *target, int from_tty)
Definition: dummy-frame.c:274
int pid_to_thread_id(ptid_t ptid)
Definition: thread.c:459
static void remove_dummy_frame(struct dummy_frame **dummy_ptr)
Definition: dummy-frame.c:107
void reinit_frame_cache(void)
Definition: frame.c:1687
Definition: defs.h:353
int find_dummy_frame_dtor(dummy_frame_dtor_ftype *dtor, void *dtor_data)
Definition: dummy-frame.c:254
void delete_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:13539
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
struct frame_id frame_id
Definition: breakpoint.h:698