/* Code dealing with dummy stack frames, for GDB, the GNU debugger.
- Copyright (C) 1986-2014 Free Software Foundation, Inc.
+ Copyright (C) 1986-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame-unwind.h"
#include "command.h"
#include "gdbcmd.h"
-#include "observer.h"
+#include "observable.h"
#include "gdbthread.h"
+#include "infcall.h"
struct dummy_frame_id
{
return frame_id_eq (id1->id, id2->id) && ptid_equal (id1->ptid, id2->ptid);
}
+/* List of dummy_frame destructors. */
+
+struct dummy_frame_dtor_list
+{
+ /* Next element in the list or NULL if this is the last element. */
+ struct dummy_frame_dtor_list *next;
+
+ /* If non-NULL, a destructor that is run when this dummy frame is freed. */
+ dummy_frame_dtor_ftype *dtor;
+
+ /* Arbitrary data that is passed to DTOR. */
+ void *dtor_data;
+};
+
/* 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). */
/* The caller's state prior to the call. */
struct infcall_suspend_state *caller_state;
- /* If non-NULL, a destructor that is run when this dummy frame is
- popped. */
- void (*dtor) (void *data);
-
- /* Arbitrary data that is passed to DTOR. */
- void *dtor_data;
+ /* 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;
{
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);
static int
pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
{
- struct dummy_frame *dummy = dummy_voidp;
+ struct dummy_frame *dummy = (struct dummy_frame *) dummy_voidp;
- if (b->thread == pid_to_thread_id (dummy->id.ptid)
+ if (b->thread == ptid_to_global_thread_id (dummy->id.ptid)
&& b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
{
while (b->related_breakpoint != b)
gdb_assert (ptid_equal (dummy->id.ptid, inferior_ptid));
- if (dummy->dtor != NULL)
- dummy->dtor (dummy->dtor_data);
+ 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);
{
struct dummy_frame_id id = { dummy_id, ptid };
struct dummy_frame **dp, *d;
+ struct dummy_frame_dtor_list *list;
dp = lookup_dummy_frame (&id);
gdb_assert (dp != NULL);
d = *dp;
- gdb_assert (d->dtor == NULL);
- d->dtor = dtor;
- d->dtor_data = dtor_data;
+ 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. */
struct dummy_frame *d;
for (d = dummy_frame_stack; d != NULL; d = d->next)
- if (d->dtor == dtor && d->dtor_data == dtor_data)
- return 1;
+ {
+ 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;
}
struct dummy_frame_cache
{
struct frame_id this_id;
- struct regcache *prev_regcache;
+ readonly_detached_regcache *prev_regcache;
};
static int
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;
}
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);
}