#include "inferior.h"
#include "gdb_assert.h"
#include "frame-unwind.h"
+#include "command.h"
+#include "gdbcmd.h"
static void dummy_frame_this_id (struct frame_info *next_frame,
void **this_prologue_cache,
FP against the saved SP and FP. NOTE: If you're trying
to fix a problem with GDB not correctly finding a dummy
frame, check the comments that go with FRAME_ALIGN() and
- SAVE_DUMMY_FRAME_TOS(). */
+ UNWIND_DUMMY_ID(). */
if (fp != dummyframe->fp && fp != dummyframe->sp)
continue;
}
}
struct regcache *
-generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
+deprecated_find_dummy_frame_regcache (CORE_ADDR pc, CORE_ADDR fp)
{
struct dummy_frame *dummy = find_dummy_frame (pc, fp);
if (dummy != NULL)
char *
deprecated_generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
{
- struct regcache *regcache = generic_find_dummy_frame (pc, fp);
+ struct regcache *regcache = deprecated_find_dummy_frame_regcache (pc, fp);
if (regcache == NULL)
return NULL;
return deprecated_grub_regcache_for_registers (regcache);
figure out what the real PC (as in the resume address) is BEFORE
calling this function (Oh, and I'm not even sure that this function
is called with an decremented PC, the call to pc_in_call_dummy() in
- that file is conditional on !CALL_DUMMY_BREAKPOINT_OFFSET_P yet
- generic dummy targets set CALL_DUMMY_BREAKPOINT_OFFSET. True?). */
+ that file is conditional on
+ !DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET_P yet generic dummy
+ targets set DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET. True?). */
int
pc_in_dummy_frame (CORE_ADDR pc)
CORE_ADDR
deprecated_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
{
- struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
+ struct regcache *dummy_regs = deprecated_find_dummy_frame_regcache (pc, fp);
if (dummy_regs)
{
/* NOTE: cagney/2002-08-12: Replaced a call to
regcache_raw_read_as_address() with a call to
regcache_cooked_read_unsigned(). The old, ...as_address
- function was eventually calling extract_unsigned_integer (via
+ function was eventually calling extract_unsigned_integer (nee
extract_address) to unpack the registers value. The below is
doing an unsigned extract so that it is functionally
equivalent. The read needs to be cooked as, otherwise, it
discard_innermost_dummy (&dummy_frame_stack);
}
-/* Function: fix_call_dummy
- Stub function. Generic dummy frames typically do not need to fix
- the frame being created */
-
-void
-generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
- struct value **args, struct type *type, int gcc_p)
-{
- return;
-}
-
/* Given a call-dummy dummy-frame, return the registers. Here the
register value is taken from the local copy of the register buffer. */
just asking for trouble. */
if (gdbarch_unwind_dummy_id_p (current_gdbarch))
{
- /* Assume hand_function_call(), via SAVE_DUMMY_FRAME_TOS,
- previously saved the dummy frame's ID. Things only work if
- the two return the same value. */
- gdb_assert (SAVE_DUMMY_FRAME_TOS_P ());
/* 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
same sequence as is found a traditional unwinder. Once all
architectures supply the unwind_dummy_id method, this code
can go away. */
- (*this_id).base = read_fp ();
- (*this_id).pc = read_pc ();
+ (*this_id) = frame_id_build (deprecated_read_fp (), read_pc ());
}
else if (legacy_frame_p (current_gdbarch)
&& get_prev_frame (next_frame))
get_prev_frame code has already created THIS frame and linked
it in to the frame chain (a pretty bold assumption), extract
the ID from THIS base / pc. */
- (*this_id).base = get_frame_base (get_prev_frame (next_frame));
- (*this_id).pc = get_frame_pc (get_prev_frame (next_frame));
+ (*this_id) = frame_id_build (get_frame_base (get_prev_frame (next_frame)),
+ get_frame_pc (get_prev_frame (next_frame)));
}
else
{
- /* Outch! We're not trying to find the innermost frame's ID yet
+ /* Ouch! We're not trying to find the innermost frame's ID yet
we're trying to unwind to a dummy. The architecture must
provide the unwind_dummy_id() method. Abandon the unwind
process but only after first warning the user. */
(*this_id) = null_frame_id;
return;
}
- (*this_prologue_cache) = find_dummy_frame ((*this_id).pc, (*this_id).base);
+ (*this_prologue_cache) = find_dummy_frame ((*this_id).code_addr,
+ (*this_id).stack_addr);
}
static struct frame_unwind dummy_frame_unwind =
{
+ DUMMY_FRAME,
dummy_frame_this_id,
dummy_frame_prev_register
};
const struct frame_unwind *
-dummy_frame_p (CORE_ADDR pc)
+dummy_frame_sniffer (struct frame_info *next_frame)
{
+ CORE_ADDR pc = frame_pc_unwind (next_frame);
if (DEPRECATED_PC_IN_CALL_DUMMY_P ()
? DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0)
: pc_in_dummy_frame (pc))
else
return NULL;
}
+
+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);
+ fprintf_unfiltered (file, ":");
+ fprintf_unfiltered (file, " pc=0x%s", paddr (s->pc));
+ fprintf_unfiltered (file, " fp=0x%s", paddr (s->fp));
+ fprintf_unfiltered (file, " sp=0x%s", paddr (s->sp));
+ fprintf_unfiltered (file, " top=0x%s", paddr (s->top));
+ fprintf_unfiltered (file, " id=");
+ fprint_frame_id (file, s->id);
+ fprintf_unfiltered (file, " call_lo=0x%s", paddr (s->call_lo));
+ fprintf_unfiltered (file, " call_hi=0x%s", paddr (s->call_hi));
+ fprintf_unfiltered (file, "\n");
+ }
+}
+
+static void
+maintenance_print_dummy_frames (char *args, int from_tty)
+{
+ if (args == NULL)
+ fprint_dummy_frames (gdb_stdout);
+ else
+ {
+ struct ui_file *file = gdb_fopen (args, "w");
+ if (file == NULL)
+ perror_with_name ("maintenance print dummy-frames");
+ fprint_dummy_frames (file);
+ ui_file_delete (file);
+ }
+}
+
+extern void _initialize_dummy_frame (void);
+
+void
+_initialize_dummy_frame (void)
+{
+ add_cmd ("dummy-frames", class_maintenance, maintenance_print_dummy_frames,
+ "Print the contents of the internal dummy-frame stack.",
+ &maintenanceprintlist);
+
+}
projects / deliverable / binutils-gdb.git / blobdiff