/* Code dealing with dummy stack frames, for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
- Free Software Foundation, Inc.
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
+ 2010 Free Software Foundation, Inc.
This file is part of GDB.
#include "command.h"
#include "gdbcmd.h"
#include "gdb_string.h"
+#include "observer.h"
/* Dummy frame. This saves the processor state just prior to setting
up the inferior function call. Older targets save the registers
{
struct dummy_frame *next;
/* This frame's ID. Must match the value returned by
- gdbarch_unwind_dummy_id. */
+ gdbarch_dummy_id. */
struct frame_id id;
- /* The caller's regcache. */
- struct regcache *regcache;
+ /* The caller's state prior to the call. */
+ struct inferior_thread_state *caller_state;
};
static struct dummy_frame *dummy_frame_stack = NULL;
NOTE: cagney/2004-08-02: Code should not need to call this. */
int
-deprecated_pc_in_call_dummy (CORE_ADDR pc)
+deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc)
{
struct dummy_frame *dummyframe;
+
for (dummyframe = dummy_frame_stack;
dummyframe != NULL;
dummyframe = dummyframe->next)
{
if ((pc >= dummyframe->id.code_addr)
&& (pc <= dummyframe->id.code_addr
- + gdbarch_decr_pc_after_break (current_gdbarch)))
+ + gdbarch_decr_pc_after_break (gdbarch)))
return 1;
}
return 0;
}
-/* Push the caller's state, along with the dummy frame info, onto a
+/* Push the caller's state, along with the dummy frame info, onto the
dummy-frame stack. */
void
-dummy_frame_push (struct regcache *caller_regcache,
+dummy_frame_push (struct inferior_thread_state *caller_state,
const struct frame_id *dummy_id)
{
- struct gdbarch *gdbarch = get_regcache_arch (caller_regcache);
struct dummy_frame *dummy_frame;
- /* Check to see if there are stale dummy frames, perhaps left over
- from when a longjump took us out of a function that was called by
- the debugger. */
- dummy_frame = dummy_frame_stack;
- while (dummy_frame)
- /* FIXME: cagney/2004-08-02: Should just test IDs. */
- if (frame_id_inner (gdbarch, dummy_frame->id, (*dummy_id)))
- /* Stale -- destroy! */
- {
- dummy_frame_stack = dummy_frame->next;
- regcache_xfree (dummy_frame->regcache);
- xfree (dummy_frame);
- dummy_frame = dummy_frame_stack;
- }
- else
- dummy_frame = dummy_frame->next;
-
dummy_frame = XZALLOC (struct dummy_frame);
- dummy_frame->regcache = caller_regcache;
+ dummy_frame->caller_state = caller_state;
dummy_frame->id = (*dummy_id);
dummy_frame->next = dummy_frame_stack;
dummy_frame_stack = dummy_frame;
}
+/* Remove *DUMMY_PTR from the dummy frame stack. */
+
+static void
+remove_dummy_frame (struct dummy_frame **dummy_ptr)
+{
+ struct dummy_frame *dummy = *dummy_ptr;
+
+ *dummy_ptr = dummy->next;
+ discard_inferior_thread_state (dummy->caller_state);
+ xfree (dummy);
+}
+
+/* Pop *DUMMY_PTR, restoring program state to that before the
+ frame was created. */
+
+static void
+pop_dummy_frame (struct dummy_frame **dummy_ptr)
+{
+ struct dummy_frame *dummy;
+
+ restore_inferior_thread_state ((*dummy_ptr)->caller_state);
+
+ /* restore_inferior_status frees inf_state,
+ all that remains is to pop *dummy_ptr */
+ dummy = *dummy_ptr;
+ *dummy_ptr = dummy->next;
+ xfree (dummy);
+
+ /* We've made right mess of GDB's local state, just discard
+ everything. */
+ reinit_frame_cache ();
+}
+
+/* Look up DUMMY_ID.
+ Return NULL if not found. */
+
+static struct dummy_frame **
+lookup_dummy_frame (struct frame_id dummy_id)
+{
+ struct dummy_frame **dp;
+
+ for (dp = &dummy_frame_stack; *dp != NULL; dp = &(*dp)->next)
+ {
+ if (frame_id_eq ((*dp)->id, dummy_id))
+ return dp;
+ }
+
+ return NULL;
+}
+
+/* Pop the dummy frame DUMMY_ID, restoring program state to that before the
+ frame was created.
+ On return reinit_frame_cache has been called.
+ If the frame isn't found, flag an internal error.
+
+ NOTE: This can only pop the one frame, even if it is in the middle of the
+ stack, because the other frames may be for different threads, and there's
+ currently no way to tell which stack frame is for which thread. */
+
+void
+dummy_frame_pop (struct frame_id dummy_id)
+{
+ struct dummy_frame **dp;
+
+ dp = lookup_dummy_frame (dummy_id);
+ gdb_assert (dp != NULL);
+
+ pop_dummy_frame (dp);
+}
+
+/* There may be stale dummy frames, perhaps left over from when a longjump took
+ us out of a function that was called by the debugger. Clean them up at
+ least once whenever we start a new inferior. */
+
+static void
+cleanup_dummy_frames (struct target_ops *target, int from_tty)
+{
+ while (dummy_frame_stack != NULL)
+ remove_dummy_frame (&dummy_frame_stack);
+}
+
/* Return the dummy frame cache, it contains both the ID, and a
pointer to the regcache. */
struct dummy_frame_cache
struct regcache *prev_regcache;
};
-int
+static int
dummy_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *next_frame,
+ struct frame_info *this_frame,
void **this_prologue_cache)
{
struct dummy_frame *dummyframe;
that PC to apply standard frame ID unwind techniques is just
asking for trouble. */
- /* Don't bother unles there is at least one dummy frame. */
+ /* Don't bother unless there is at least one dummy frame. */
if (dummy_frame_stack != NULL)
{
- /* Use an architecture specific method to extract the prev's
- dummy ID from the next frame. Note that this method uses
- frame_register_unwind to obtain the register values needed to
- determine the dummy frame's ID. */
- this_id = gdbarch_unwind_dummy_id (get_frame_arch (next_frame),
- next_frame);
+ /* Use an architecture specific method to extract this frame's
+ dummy ID, assuming it is a dummy frame. */
+ this_id = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
/* Use that ID to find the corresponding cache entry. */
for (dummyframe = dummy_frame_stack;
if (frame_id_eq (dummyframe->id, this_id))
{
struct dummy_frame_cache *cache;
+
cache = FRAME_OBSTACK_ZALLOC (struct dummy_frame_cache);
- cache->prev_regcache = dummyframe->regcache;
+ cache->prev_regcache = get_inferior_thread_state_regcache (dummyframe->caller_state);
cache->this_id = this_id;
(*this_prologue_cache) = cache;
return 1;
/* Given a call-dummy dummy-frame, return the registers. Here the
register value is taken from the local copy of the register buffer. */
-static void
-dummy_frame_prev_register (struct frame_info *next_frame,
+static struct value *
+dummy_frame_prev_register (struct frame_info *this_frame,
void **this_prologue_cache,
- int regnum, int *optimized,
- enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnum, gdb_byte *bufferp)
+ int regnum)
{
- /* The dummy-frame sniffer always fills in the cache. */
struct dummy_frame_cache *cache = (*this_prologue_cache);
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
+ struct value *reg_val;
+
+ /* The dummy-frame sniffer always fills in the cache. */
gdb_assert (cache != NULL);
/* Describe the register's location. Generic dummy frames always
have the register value in an ``expression''. */
- *optimized = 0;
- *lvalp = not_lval;
- *addrp = 0;
- *realnum = -1;
-
- /* If needed, find and return the value of the register. */
- if (bufferp != NULL)
- {
- /* Return the actual value. */
- /* Use the regcache_cooked_read() method so that it, on the fly,
- constructs either a raw or pseudo register from the raw
- register cache. */
- regcache_cooked_read (cache->prev_regcache, regnum, bufferp);
- }
+ reg_val = value_zero (register_type (gdbarch, regnum), not_lval);
+
+ /* Use the regcache_cooked_read() method so that it, on the fly,
+ constructs either a raw or pseudo register from the raw
+ register cache. */
+ regcache_cooked_read (cache->prev_regcache, regnum,
+ value_contents_writeable (reg_val));
+ return reg_val;
}
-/* Assuming that THIS frame is a dummy (remember, the NEXT and not
- THIS frame is passed in), return the ID of THIS frame. That ID is
+/* Assuming that THIS_FRAME is a dummy, return its ID. That ID is
determined by examining the NEXT frame's unwound registers using
- the method unwind_dummy_id(). As a side effect, THIS dummy frame's
+ the method dummy_id(). As a side effect, THIS dummy frame's
dummy cache is located and and saved in THIS_PROLOGUE_CACHE. */
static void
-dummy_frame_this_id (struct frame_info *next_frame,
+dummy_frame_this_id (struct frame_info *this_frame,
void **this_prologue_cache,
struct frame_id *this_id)
{
/* The dummy-frame sniffer always fills in the cache. */
struct dummy_frame_cache *cache = (*this_prologue_cache);
+
gdb_assert (cache != NULL);
(*this_id) = cache->this_id;
}
-static const struct frame_unwind dummy_frame_unwinder =
+const struct frame_unwind dummy_frame_unwind =
{
DUMMY_FRAME,
dummy_frame_this_id,
dummy_frame_sniffer,
};
-const struct frame_unwind *const dummy_frame_unwind = {
- &dummy_frame_unwinder
-};
-
static void
fprint_dummy_frames (struct ui_file *file)
{
struct dummy_frame *s;
+
for (s = dummy_frame_stack; s != NULL; s = s->next)
{
gdb_print_host_address (s, file);
fprint_dummy_frames (gdb_stdout);
else
{
+ struct cleanup *cleanups;
struct ui_file *file = gdb_fopen (args, "w");
+
if (file == NULL)
perror_with_name (_("maintenance print dummy-frames"));
+ cleanups = make_cleanup_ui_file_delete (file);
fprint_dummy_frames (file);
- ui_file_delete (file);
+ do_cleanups (cleanups);
}
}
_("Print the contents of the internal dummy-frame stack."),
&maintenanceprintlist);
+ observer_attach_inferior_created (cleanup_dummy_frames);
}