/* Code dealing with dummy stack frames, for GDB, the GNU debugger.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "frame.h"
#include "inferior.h"
-#include "gdb_assert.h"
#include "frame-unwind.h"
#include "command.h"
#include "gdbcmd.h"
-#include "gdb_string.h"
-#include "observer.h"
+#include "observable.h"
#include "gdbthread.h"
+#include "infcall.h"
+#include "gdbarch.h"
-/* Dummy frame. This saves the processor state just prior to setting
- up the inferior function call. Older targets save the registers
- on the target stack (but that really slows down function calls). */
-
-struct dummy_frame
+struct dummy_frame_id
{
- struct dummy_frame *next;
/* This frame's ID. Must match the value returned by
gdbarch_dummy_id. */
struct frame_id id;
- /* The caller's state prior to the call. */
- struct infcall_suspend_state *caller_state;
+
+ /* The thread this dummy_frame relates to. */
+ thread_info *thread;
};
-static struct dummy_frame *dummy_frame_stack = NULL;
+/* Return whether dummy_frame_id *ID1 and *ID2 are equal. */
-/* Function: deprecated_pc_in_call_dummy (pc)
+static int
+dummy_frame_id_eq (struct dummy_frame_id *id1,
+ struct dummy_frame_id *id2)
+{
+ return frame_id_eq (id1->id, id2->id) && id1->thread == id2->thread;
+}
- Return non-zero if the PC falls in a dummy frame created by gdb for
- an inferior call. The code below which allows gdbarch_decr_pc_after_break
- is for infrun.c, which may give the function a PC without that
- subtracted out.
+/* List of dummy_frame destructors. */
- FIXME: cagney/2002-11-23: This is silly. Surely "infrun.c" can
- figure out what the real PC (as in the resume address) is BEFORE
- calling this function.
+struct dummy_frame_dtor_list
+{
+ /* Next element in the list or NULL if this is the last element. */
+ struct dummy_frame_dtor_list *next;
- NOTE: cagney/2004-08-02: I'm pretty sure that, with the introduction of
- infrun.c:adjust_pc_after_break (thanks), this function is now
- always called with a correctly adjusted PC!
+ /* If non-NULL, a destructor that is run when this dummy frame is freed. */
+ dummy_frame_dtor_ftype *dtor;
- NOTE: cagney/2004-08-02: Code should not need to call this. */
+ /* Arbitrary data that is passed to DTOR. */
+ void *dtor_data;
+};
-int
-deprecated_pc_in_call_dummy (struct gdbarch *gdbarch, CORE_ADDR pc)
+/* Dummy frame. This saves the processor state just prior to setting
+ up the inferior function call. Older targets save the registers
+ on the target stack (but that really slows down function calls). */
+
+struct dummy_frame
{
- struct dummy_frame *dummyframe;
+ struct dummy_frame *next;
- 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 (gdbarch)))
- return 1;
- }
- return 0;
-}
+ /* An id represents a dummy frame. */
+ struct dummy_frame_id id;
+
+ /* The caller's state prior to the call. */
+ struct infcall_suspend_state *caller_state;
+
+ /* First element of destructors list or NULL if there are no
+ destructors registered for this dummy_frame. */
+ struct dummy_frame_dtor_list *dtor_list;
+};
+
+static struct dummy_frame *dummy_frame_stack = NULL;
/* Push the caller's state, along with the dummy frame info, onto the
dummy-frame stack. */
void
dummy_frame_push (struct infcall_suspend_state *caller_state,
- const struct frame_id *dummy_id)
+ const frame_id *dummy_id, thread_info *thread)
{
struct dummy_frame *dummy_frame;
- dummy_frame = XZALLOC (struct dummy_frame);
+ dummy_frame = XCNEW (struct dummy_frame);
dummy_frame->caller_state = caller_state;
- dummy_frame->id = (*dummy_id);
+ dummy_frame->id.id = (*dummy_id);
+ dummy_frame->id.thread = thread;
dummy_frame->next = dummy_frame_stack;
dummy_frame_stack = dummy_frame;
}
{
struct dummy_frame *dummy = *dummy_ptr;
+ while (dummy->dtor_list != NULL)
+ {
+ struct dummy_frame_dtor_list *list = dummy->dtor_list;
+
+ dummy->dtor_list = list->next;
+ list->dtor (list->dtor_data, 0);
+ xfree (list);
+ }
+
*dummy_ptr = dummy->next;
discard_infcall_suspend_state (dummy->caller_state);
xfree (dummy);
/* Delete any breakpoint B which is a momentary breakpoint for return from
inferior call matching DUMMY_VOIDP. */
-static int
-pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
+static bool
+pop_dummy_frame_bpt (struct breakpoint *b, struct dummy_frame *dummy)
{
- struct dummy_frame *dummy = dummy_voidp;
-
- if (b->thread == pid_to_thread_id (inferior_ptid)
- && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id))
+ if (b->thread == dummy->id.thread->global_num
+ && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
{
while (b->related_breakpoint != b)
delete_breakpoint (b->related_breakpoint);
delete_breakpoint (b);
/* Stop the traversal. */
- return 1;
+ return true;
}
/* Continue the traversal. */
- return 0;
+ return false;
}
/* Pop *DUMMY_PTR, restoring program state to that before the
{
struct dummy_frame *dummy = *dummy_ptr;
+ gdb_assert (dummy->id.thread == inferior_thread ());
+
+ while (dummy->dtor_list != NULL)
+ {
+ struct dummy_frame_dtor_list *list = dummy->dtor_list;
+
+ dummy->dtor_list = list->next;
+ list->dtor (list->dtor_data, 1);
+ xfree (list);
+ }
+
restore_infcall_suspend_state (dummy->caller_state);
- iterate_over_breakpoints (pop_dummy_frame_bpt, dummy);
+ iterate_over_breakpoints ([dummy] (breakpoint* bp)
+ {
+ return pop_dummy_frame_bpt (bp, dummy);
+ });
/* restore_infcall_control_state frees inf_state,
all that remains is to pop *dummy_ptr. */
Return NULL if not found. */
static struct dummy_frame **
-lookup_dummy_frame (struct frame_id dummy_id)
+lookup_dummy_frame (struct dummy_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))
+ if (dummy_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.
+/* Find the dummy frame by DUMMY_ID and THREAD, and pop it, 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. */
+ If the frame isn't found, flag an internal error. */
void
-dummy_frame_pop (struct frame_id dummy_id)
+dummy_frame_pop (frame_id dummy_id, thread_info *thread)
{
struct dummy_frame **dp;
+ struct dummy_frame_id id = { dummy_id, thread };
- dp = lookup_dummy_frame (dummy_id);
+ dp = lookup_dummy_frame (&id);
gdb_assert (dp != NULL);
pop_dummy_frame (dp);
}
-/* Drop dummy frame DUMMY_ID. Do nothing if it is not found. Do not restore
- its state into inferior, just free its memory. */
+/* Find the dummy frame by DUMMY_ID and PTID and drop it. Do nothing
+ if it is not found. Do not restore its state into inferior, just
+ free its memory. */
void
-dummy_frame_discard (struct frame_id dummy_id)
+dummy_frame_discard (struct frame_id dummy_id, thread_info *thread)
{
struct dummy_frame **dp;
+ struct dummy_frame_id id = { dummy_id, thread };
- dp = lookup_dummy_frame (dummy_id);
+ dp = lookup_dummy_frame (&id);
if (dp)
remove_dummy_frame (dp);
}
+/* See dummy-frame.h. */
+
+void
+register_dummy_frame_dtor (frame_id dummy_id, thread_info *thread,
+ dummy_frame_dtor_ftype *dtor, void *dtor_data)
+{
+ struct dummy_frame_id id = { dummy_id, thread };
+ struct dummy_frame **dp, *d;
+ struct dummy_frame_dtor_list *list;
+
+ dp = lookup_dummy_frame (&id);
+ gdb_assert (dp != NULL);
+ d = *dp;
+ list = XNEW (struct dummy_frame_dtor_list);
+ list->next = d->dtor_list;
+ d->dtor_list = list;
+ list->dtor = dtor;
+ list->dtor_data = dtor_data;
+}
+
+/* See dummy-frame.h. */
+
+int
+find_dummy_frame_dtor (dummy_frame_dtor_ftype *dtor, void *dtor_data)
+{
+ struct dummy_frame *d;
+
+ for (d = dummy_frame_stack; d != NULL; d = d->next)
+ {
+ struct dummy_frame_dtor_list *list;
+
+ for (list = d->dtor_list; list != NULL; list = list->next)
+ if (list->dtor == dtor && list->dtor_data == dtor_data)
+ return 1;
+ }
+ return 0;
+}
+
/* There may be stale dummy frames, perhaps left over from when an uncaught
longjmp took us out of a function that was called by the debugger. Clean
them up at least once whenever we start a new inferior. */
struct dummy_frame_cache
{
struct frame_id this_id;
- struct regcache *prev_regcache;
+ readonly_detached_regcache *prev_regcache;
};
static int
struct frame_info *this_frame,
void **this_prologue_cache)
{
- struct dummy_frame *dummyframe;
- struct frame_id this_id;
-
/* When unwinding a normal frame, the stack structure is determined
by analyzing the frame's function's code (be it using brute force
prologue analysis, or the dwarf2 CFI). In the case of a dummy
/* Don't bother unless there is at least one dummy frame. */
if (dummy_frame_stack != NULL)
{
+ struct dummy_frame *dummyframe;
/* 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);
+ struct frame_id this_id
+ = gdbarch_dummy_id (get_frame_arch (this_frame), this_frame);
+ struct dummy_frame_id dummy_id = { this_id, inferior_thread () };
/* Use that ID to find the corresponding cache entry. */
for (dummyframe = dummy_frame_stack;
dummyframe != NULL;
dummyframe = dummyframe->next)
{
- if (frame_id_eq (dummyframe->id, this_id))
+ if (dummy_frame_id_eq (&dummyframe->id, &dummy_id))
{
struct dummy_frame_cache *cache;
void **this_prologue_cache,
int regnum)
{
- struct dummy_frame_cache *cache = (*this_prologue_cache);
+ struct dummy_frame_cache *cache
+ = (struct dummy_frame_cache *) *this_prologue_cache;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct value *reg_val;
/* 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));
+ cache->prev_regcache->cooked_read (regnum,
+ value_contents_writeable (reg_val));
return reg_val;
}
struct frame_id *this_id)
{
/* The dummy-frame sniffer always fills in the cache. */
- struct dummy_frame_cache *cache = (*this_prologue_cache);
+ struct dummy_frame_cache *cache
+ = (struct dummy_frame_cache *) *this_prologue_cache;
gdb_assert (cache != NULL);
(*this_id) = cache->this_id;
dummy_frame_sniffer,
};
+/* See dummy-frame.h. */
+
+struct frame_id
+default_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+ CORE_ADDR sp, pc;
+
+ sp = get_frame_sp (this_frame);
+ pc = get_frame_pc (this_frame);
+ return frame_id_build (sp, pc);
+}
+
static void
fprint_dummy_frames (struct ui_file *file)
{
gdb_print_host_address (s, file);
fprintf_unfiltered (file, ":");
fprintf_unfiltered (file, " id=");
- fprint_frame_id (file, s->id);
+ fprint_frame_id (file, s->id.id);
+ fprintf_unfiltered (file, ", ptid=%s",
+ target_pid_to_str (s->id.thread->ptid).c_str ());
fprintf_unfiltered (file, "\n");
}
}
static void
-maintenance_print_dummy_frames (char *args, int from_tty)
+maintenance_print_dummy_frames (const char *args, int from_tty)
{
if (args == NULL)
fprint_dummy_frames (gdb_stdout);
else
{
- struct cleanup *cleanups;
- struct ui_file *file = gdb_fopen (args, "w");
+ stdio_file file;
- if (file == NULL)
+ if (!file.open (args, "w"))
perror_with_name (_("maintenance print dummy-frames"));
- cleanups = make_cleanup_ui_file_delete (file);
- fprint_dummy_frames (file);
- do_cleanups (cleanups);
+ fprint_dummy_frames (&file);
}
}
-extern void _initialize_dummy_frame (void);
-
void
_initialize_dummy_frame (void)
{
_("Print the contents of the internal dummy-frame stack."),
&maintenanceprintlist);
- observer_attach_inferior_created (cleanup_dummy_frames);
+ gdb::observers::inferior_created.attach (cleanup_dummy_frames);
}