Make frv-tdep.c use new frame mechanisms.
This commit is contained in:
Kevin Buettner
parent
68f6cf990a
commit
1cb761c72b
|
|
@ -1,3 +1,43 @@
|
|||
2003-09-08 Kevin Buettner <kevinb@redhat.com>
|
||||
|
||||
* frv-tdep.c (frame-unwind.h, frame-base.h): Include.
|
||||
(frame_extra_info): Rename this struct to frv_unwind_cache.
|
||||
Delete fields ``fp_to_callers_sp_offset'' and ``lr_saved_on_stack''.
|
||||
Add fields ``prev_sp'' and ``base''.
|
||||
(frv_frame_chain, frv_frame_saved_pc, frv_frame_init_saved_regs)
|
||||
(frv_saved_pc_after_call, frv_init_extra_frame_info)
|
||||
(frv_push_return_address, frv_pop_frame, frv_pop_frame_regular):
|
||||
Delete.
|
||||
(frv_analyze_prologue): Add ``struct frv_unwind_cache *'' argument.
|
||||
Revise all callers. Fill in the unwind cache argument and make
|
||||
other adjustments to account for new frame mechanisms.
|
||||
(frv_frame_unwind_cache, frv_frame_align, frv_unwind_pc)
|
||||
(frv_frame_this_id, frv_frame_prev_register, frv_frame_sniffer)
|
||||
(frv_frame_base_address, frv_unwind_dummy_id): New functions.
|
||||
(frv_frame_unwind, frv_frame_base): New structs.
|
||||
(frv_push_arguments): Change name to frv_push_dummy_call(). Add
|
||||
additional arguments expected by this method and adjust function
|
||||
body accordingly.
|
||||
(frv_gdbarch_init): Remove calls to the following functions:
|
||||
set_gdbarch_deprecated_init_frame_pc(),
|
||||
set_gdbarch_deprecated_saved_pc_after_call(),
|
||||
set_gdbarch_deprecated_frame_chain(),
|
||||
set_gdbarch_deprecated_frame_saved_pc(),
|
||||
set_gdbarch_deprecated_frame_init_saved_regs(),
|
||||
set_gdbarch_deprecated_push_arguments(),
|
||||
set_gdbarch_deprecated_push_return_address(),
|
||||
set_gdbarch_deprecated_pop_frame(),
|
||||
set_gdbarch_deprecated_call_dummy_words(),
|
||||
set_gdbarch_deprecated_sizeof_call_dummy_words(),
|
||||
set_gdbarch_deprecated_init_extra_frame_info(),
|
||||
set_gdbarch_deprecated_dummy_write_sp(), and
|
||||
set_gdbarch_deprecated_pc_in_call_dummy().
|
||||
Add calls to the following functions:
|
||||
set_gdbarch_unwind_pc(), set_gdbarch_unwind_sp(),
|
||||
set_gdbarch_frame_align(), frame_unwind_append_sniffer(), and
|
||||
frame_base_set_default().
|
||||
* Makefile.in (frv-tdep.o): Update dependencies.
|
||||
|
||||
2003-09-09 Mark Kettenis <kettenis@gnu.org>
|
||||
|
||||
* dwarf2-frame.c (read_encoded_value): Add support for
|
||||
|
|
|
|||
|
|
@ -1770,7 +1770,7 @@ frame-unwind.o: frame-unwind.c $(defs_h) $(frame_h) $(frame_unwind_h) \
|
|||
$(gdb_assert_h) $(dummy_frame_h)
|
||||
frv-tdep.o: frv-tdep.c $(defs_h) $(gdb_string_h) $(inferior_h) $(symfile_h) \
|
||||
$(gdbcore_h) $(arch_utils_h) $(regcache_h) $(frame_h) \
|
||||
$(trad_frame_h)
|
||||
$(frame_unwind_h) $(frame_base_h) $(trad_frame_h)
|
||||
f-typeprint.o: f-typeprint.c $(defs_h) $(gdb_obstack_h) $(bfd_h) $(symtab_h) \
|
||||
$(gdbtypes_h) $(expression_h) $(value_h) $(gdbcore_h) $(target_h) \
|
||||
$(f_lang_h) $(gdb_string_h)
|
||||
|
|
|
|||
394
gdb/frv-tdep.c
394
gdb/frv-tdep.c
|
|
@ -26,6 +26,8 @@
|
|||
#include "arch-utils.h"
|
||||
#include "regcache.h"
|
||||
#include "frame.h"
|
||||
#include "frame-unwind.h"
|
||||
#include "frame-base.h"
|
||||
#include "trad-frame.h"
|
||||
|
||||
extern void _initialize_frv_tdep (void);
|
||||
|
|
@ -40,9 +42,6 @@ static gdbarch_deprecated_extract_struct_value_address_ftype frv_extract_struct_
|
|||
static gdbarch_frameless_function_invocation_ftype frv_frameless_function_invocation;
|
||||
static gdbarch_deprecated_push_arguments_ftype frv_push_arguments;
|
||||
static gdbarch_deprecated_saved_pc_after_call_ftype frv_saved_pc_after_call;
|
||||
static void frv_frame_init_saved_regs (struct frame_info *frame);
|
||||
|
||||
static void frv_pop_frame_regular (struct frame_info *frame);
|
||||
|
||||
/* Register numbers. You can change these as needed, but don't forget
|
||||
to update the simulator accordingly. */
|
||||
|
|
@ -85,17 +84,14 @@ static LONGEST frv_call_dummy_words[] =
|
|||
{0};
|
||||
|
||||
|
||||
/* The contents of this structure can only be trusted after we've
|
||||
frv_frame_init_saved_regs on the frame. */
|
||||
struct frame_extra_info
|
||||
struct frv_unwind_cache /* was struct frame_extra_info */
|
||||
{
|
||||
/* The offset from our frame pointer to our caller's stack
|
||||
pointer. */
|
||||
int fp_to_callers_sp_offset;
|
||||
/* The previous frame's inner-most stack address. Used as this
|
||||
frame ID's stack_addr. */
|
||||
CORE_ADDR prev_sp;
|
||||
|
||||
/* Non-zero if we've saved our return address on the stack yet.
|
||||
Zero if it's still sitting in the link register. */
|
||||
int lr_saved_on_stack;
|
||||
/* The frame's base, optionally used by the high-level debug info. */
|
||||
CORE_ADDR base;
|
||||
|
||||
/* Table indicating the location of each and every register. */
|
||||
struct trad_frame_saved_reg *saved_regs;
|
||||
|
|
@ -274,55 +270,6 @@ frv_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenp)
|
|||
return breakpoint;
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_frame_chain (struct frame_info *frame)
|
||||
{
|
||||
CORE_ADDR saved_fp_addr;
|
||||
struct frame_extra_info *extra_info =
|
||||
get_frame_extra_info (frame);
|
||||
|
||||
if (extra_info &&
|
||||
extra_info->saved_regs &&
|
||||
extra_info->saved_regs[fp_regnum].addr != 0)
|
||||
saved_fp_addr = extra_info->saved_regs[fp_regnum].addr;
|
||||
else
|
||||
/* Just assume it was saved in the usual place. */
|
||||
saved_fp_addr = get_frame_base (frame);
|
||||
|
||||
return read_memory_integer (saved_fp_addr, 4);
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_frame_saved_pc (struct frame_info *frame)
|
||||
{
|
||||
struct frame_extra_info *extra_info =
|
||||
get_frame_extra_info (frame);
|
||||
|
||||
frv_frame_init_saved_regs (frame);
|
||||
|
||||
/* Perhaps the prologue analyzer recorded where it was stored.
|
||||
(As of 14 Oct 2001, it never does.) */
|
||||
if (extra_info && extra_info->saved_regs &&
|
||||
extra_info->saved_regs[pc_regnum].addr != 0)
|
||||
return read_memory_integer (extra_info->saved_regs[pc_regnum].addr, 4);
|
||||
|
||||
/* If the prologue analyzer tells us the link register was saved on
|
||||
the stack, get it from there. */
|
||||
if (extra_info->lr_saved_on_stack)
|
||||
return read_memory_integer (get_frame_base (frame) + 8, 4);
|
||||
|
||||
/* Otherwise, it's still in LR.
|
||||
However, if FRAME isn't the youngest frame, this is kind of
|
||||
suspicious --- if this frame called somebody else, then its LR
|
||||
has certainly been overwritten. */
|
||||
if (! get_next_frame (frame))
|
||||
return read_register (lr_regnum);
|
||||
|
||||
/* By default, assume it's saved in the standard place, relative to
|
||||
the frame pointer. */
|
||||
return read_memory_integer (get_frame_base (frame) + 8, 4);
|
||||
}
|
||||
|
||||
|
||||
/* Return true if REG is a caller-saves ("scratch") register,
|
||||
false otherwise. */
|
||||
|
|
@ -365,7 +312,8 @@ is_argument_reg (int reg)
|
|||
arguments in any frame but the top, you'll need to do this serious
|
||||
prologue analysis. */
|
||||
static CORE_ADDR
|
||||
frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
||||
frv_analyze_prologue (CORE_ADDR pc, struct frame_info *next_frame,
|
||||
struct frv_unwind_cache *info)
|
||||
{
|
||||
/* When writing out instruction bitpatterns, we use the following
|
||||
letters to label instruction fields:
|
||||
|
|
@ -390,12 +338,16 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
|||
/* Total size of frame prior to any alloca operations. */
|
||||
int framesize = 0;
|
||||
|
||||
/* Flag indicating if lr has been saved on the stack. */
|
||||
int lr_saved_on_stack = 0;
|
||||
|
||||
/* The number of the general-purpose register we saved the return
|
||||
address ("link register") in, or -1 if we haven't moved it yet. */
|
||||
int lr_save_reg = -1;
|
||||
|
||||
/* Non-zero iff we've saved the LR onto the stack. */
|
||||
int lr_saved_on_stack = 0;
|
||||
/* Offset (from sp) at which lr has been saved on the stack. */
|
||||
|
||||
int lr_sp_offset = 0;
|
||||
|
||||
/* If gr_saved[i] is non-zero, then we've noticed that general
|
||||
register i has been saved at gr_sp_offset[i] from the stack
|
||||
|
|
@ -405,7 +357,7 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
|||
|
||||
memset (gr_saved, 0, sizeof (gr_saved));
|
||||
|
||||
while (! frame || pc < get_frame_pc (frame))
|
||||
while (! next_frame || pc < frame_pc_unwind (next_frame))
|
||||
{
|
||||
LONGEST op = read_memory_integer (pc, 4);
|
||||
|
||||
|
|
@ -637,7 +589,10 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
|||
|
||||
/* Saving the old FP in the new frame (relative to the SP). */
|
||||
if (gr_k == fp_regnum && gr_i == sp_regnum)
|
||||
;
|
||||
{
|
||||
gr_saved[fp_regnum] = 1;
|
||||
gr_sp_offset[fp_regnum] = offset;
|
||||
}
|
||||
|
||||
/* Saving callee-saves register(s) on the stack, relative to
|
||||
the SP. */
|
||||
|
|
@ -645,13 +600,22 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
|||
&& is_callee_saves_reg (gr_k))
|
||||
{
|
||||
gr_saved[gr_k] = 1;
|
||||
if (gr_i == sp_regnum)
|
||||
gr_sp_offset[gr_k] = offset;
|
||||
else
|
||||
gr_sp_offset[gr_k] = offset + fp_offset;
|
||||
}
|
||||
|
||||
/* Saving the scratch register holding the return address. */
|
||||
else if (lr_save_reg != -1
|
||||
&& gr_k == lr_save_reg)
|
||||
{
|
||||
lr_saved_on_stack = 1;
|
||||
if (gr_i == sp_regnum)
|
||||
lr_sp_offset = offset;
|
||||
else
|
||||
lr_sp_offset = offset + fp_offset;
|
||||
}
|
||||
|
||||
/* Spilling int-sized arguments to the stack. */
|
||||
else if (is_argument_reg (gr_k))
|
||||
|
|
@ -671,12 +635,10 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
|||
pc += 4;
|
||||
}
|
||||
|
||||
if (frame)
|
||||
if (next_frame && info)
|
||||
{
|
||||
struct frame_extra_info *extra_info =
|
||||
get_frame_extra_info (frame);
|
||||
|
||||
extra_info->lr_saved_on_stack = lr_saved_on_stack;
|
||||
int i;
|
||||
ULONGEST this_base;
|
||||
|
||||
/* If we know the relationship between the stack and frame
|
||||
pointers, record the addresses of the registers we noticed.
|
||||
|
|
@ -684,19 +646,29 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
|
|||
because instructions may save relative to the SP, but we need
|
||||
their addresses relative to the FP. */
|
||||
if (fp_set)
|
||||
{
|
||||
struct trad_frame_saved_reg *saved_regs;
|
||||
int i;
|
||||
frame_unwind_unsigned_register (next_frame, fp_regnum, &this_base);
|
||||
else
|
||||
frame_unwind_unsigned_register (next_frame, sp_regnum, &this_base);
|
||||
|
||||
saved_regs = extra_info->saved_regs;
|
||||
for (i = 0; i < 64; i++)
|
||||
if (gr_saved[i])
|
||||
trad_frame_set_value (saved_regs, i,
|
||||
get_frame_base (frame) - fp_offset
|
||||
+ gr_sp_offset[i]);
|
||||
info->saved_regs[i].addr = this_base - fp_offset + gr_sp_offset[i];
|
||||
|
||||
extra_info->fp_to_callers_sp_offset = framesize - fp_offset;
|
||||
}
|
||||
info->prev_sp = this_base - fp_offset + framesize;
|
||||
info->base = this_base;
|
||||
|
||||
/* If LR was saved on the stack, record its location. */
|
||||
if (lr_saved_on_stack)
|
||||
info->saved_regs[lr_regnum].addr = this_base - fp_offset + lr_sp_offset;
|
||||
|
||||
/* The call instruction moves the caller's PC in the callee's LR.
|
||||
Since this is an unwind, do the reverse. Copy the location of LR
|
||||
into PC (the address / regnum) so that a request for PC will be
|
||||
converted into a request for the LR. */
|
||||
info->saved_regs[pc_regnum] = info->saved_regs[lr_regnum];
|
||||
|
||||
/* Save the previous frame's computed SP value. */
|
||||
trad_frame_set_value (info->saved_regs, sp_regnum, info->prev_sp);
|
||||
}
|
||||
|
||||
return pc;
|
||||
|
|
@ -729,33 +701,33 @@ frv_skip_prologue (CORE_ADDR pc)
|
|||
If we didn't find a real source location past that, then
|
||||
do a full analysis of the prologue. */
|
||||
if (new_pc < pc + 20)
|
||||
new_pc = frv_analyze_prologue (pc, 0);
|
||||
new_pc = frv_analyze_prologue (pc, 0, 0);
|
||||
|
||||
return new_pc;
|
||||
}
|
||||
|
||||
static void
|
||||
frv_frame_init_saved_regs (struct frame_info *frame)
|
||||
|
||||
static struct frv_unwind_cache *
|
||||
frv_frame_unwind_cache (struct frame_info *next_frame,
|
||||
void **this_prologue_cache)
|
||||
{
|
||||
struct frame_extra_info *extra_info =
|
||||
get_frame_extra_info (frame);
|
||||
struct gdbarch *gdbarch = get_frame_arch (next_frame);
|
||||
CORE_ADDR pc;
|
||||
ULONGEST prev_sp;
|
||||
ULONGEST this_base;
|
||||
struct frv_unwind_cache *info;
|
||||
|
||||
if (extra_info && extra_info->saved_regs)
|
||||
return;
|
||||
if ((*this_prologue_cache))
|
||||
return (*this_prologue_cache);
|
||||
|
||||
extra_info->saved_regs = trad_frame_alloc_saved_regs (frame);
|
||||
trad_frame_set_value (extra_info->saved_regs,
|
||||
fp_regnum, get_frame_base (frame));
|
||||
info = FRAME_OBSTACK_ZALLOC (struct frv_unwind_cache);
|
||||
(*this_prologue_cache) = info;
|
||||
info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
|
||||
|
||||
/* Find the beginning of this function, so we can analyze its
|
||||
prologue. */
|
||||
{
|
||||
CORE_ADDR func_addr, func_end;
|
||||
/* Prologue analysis does the rest... */
|
||||
frv_analyze_prologue (frame_func_unwind (next_frame), next_frame, info);
|
||||
|
||||
if (find_pc_partial_function (get_frame_pc (frame),
|
||||
NULL, &func_addr, &func_end))
|
||||
frv_analyze_prologue (func_addr, frame);
|
||||
}
|
||||
return info;
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -787,28 +759,20 @@ frv_frameless_function_invocation (struct frame_info *frame)
|
|||
return frameless_look_for_prologue (frame);
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_saved_pc_after_call (struct frame_info *frame)
|
||||
{
|
||||
return read_register (lr_regnum);
|
||||
}
|
||||
|
||||
static void
|
||||
frv_init_extra_frame_info (int fromleaf, struct frame_info *frame)
|
||||
{
|
||||
struct frame_extra_info *extra_info =
|
||||
frame_extra_info_zalloc (frame, sizeof (struct frame_extra_info));
|
||||
|
||||
extra_info->fp_to_callers_sp_offset = 0;
|
||||
extra_info->lr_saved_on_stack = 0;
|
||||
extra_info->saved_regs = trad_frame_alloc_saved_regs (frame);
|
||||
}
|
||||
|
||||
#define ROUND_UP(n,a) (((n)+(a)-1) & ~((a)-1))
|
||||
#define ROUND_DOWN(n,a) ((n) & ~((a)-1))
|
||||
|
||||
static CORE_ADDR
|
||||
frv_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
|
||||
frv_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
|
||||
{
|
||||
/* Require dword alignment. */
|
||||
return ROUND_DOWN (sp, 8);
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
|
||||
struct regcache *regcache, CORE_ADDR bp_addr,
|
||||
int nargs, struct value **args, CORE_ADDR sp,
|
||||
int struct_return, CORE_ADDR struct_addr)
|
||||
{
|
||||
int argreg;
|
||||
|
|
@ -844,7 +808,8 @@ frv_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
|
|||
argreg = 8;
|
||||
|
||||
if (struct_return)
|
||||
write_register (struct_return_regnum, struct_addr);
|
||||
regcache_cooked_write_unsigned (regcache, struct_return_regnum,
|
||||
struct_addr);
|
||||
|
||||
for (argnum = 0; argnum < nargs; ++argnum)
|
||||
{
|
||||
|
|
@ -876,7 +841,7 @@ frv_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
|
|||
printf(" Argnum %d data %x -> reg %d\n",
|
||||
argnum, (int) regval, argreg);
|
||||
#endif
|
||||
write_register (argreg, regval);
|
||||
regcache_cooked_write_unsigned (regcache, argreg, regval);
|
||||
++argreg;
|
||||
}
|
||||
else
|
||||
|
|
@ -892,13 +857,14 @@ frv_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
|
|||
val += partial_len;
|
||||
}
|
||||
}
|
||||
return sp;
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
|
||||
{
|
||||
write_register (lr_regnum, CALL_DUMMY_ADDRESS ());
|
||||
/* Set the return address. For the frv, the return breakpoint is
|
||||
always at BP_ADDR. */
|
||||
regcache_cooked_write_unsigned (regcache, lr_regnum, bp_addr);
|
||||
|
||||
/* Finally, update the SP register. */
|
||||
regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
|
||||
|
||||
return sp;
|
||||
}
|
||||
|
||||
|
|
@ -918,40 +884,6 @@ frv_store_return_value (struct type *type, char *valbuf)
|
|||
"Don't know how to return a %d-byte value.", length);
|
||||
}
|
||||
|
||||
static void
|
||||
frv_pop_frame (void)
|
||||
{
|
||||
generic_pop_current_frame (frv_pop_frame_regular);
|
||||
}
|
||||
|
||||
static void
|
||||
frv_pop_frame_regular (struct frame_info *frame)
|
||||
{
|
||||
struct frame_extra_info *extra_info;
|
||||
struct trad_frame_saved_reg *saved_regs;
|
||||
|
||||
CORE_ADDR fp;
|
||||
int regno;
|
||||
|
||||
fp = get_frame_base (frame);
|
||||
|
||||
frv_frame_init_saved_regs (frame);
|
||||
extra_info = get_frame_extra_info (frame);
|
||||
saved_regs = extra_info->saved_regs;
|
||||
write_register (pc_regnum, frv_frame_saved_pc (frame));
|
||||
for (regno = 0; regno < frv_num_regs; ++regno)
|
||||
{
|
||||
if (extra_info->saved_regs[regno].addr
|
||||
&& regno != pc_regnum
|
||||
&& regno != sp_regnum)
|
||||
{
|
||||
write_register (regno,
|
||||
read_memory_integer (saved_regs[regno].addr, 4));
|
||||
}
|
||||
}
|
||||
write_register (sp_regnum, fp + extra_info->fp_to_callers_sp_offset);
|
||||
flush_cached_frames ();
|
||||
}
|
||||
|
||||
/* Hardware watchpoint / breakpoint support for the FR500
|
||||
and FR400. */
|
||||
|
|
@ -1008,6 +940,120 @@ frv_stopped_data_address (void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||||
{
|
||||
return frame_unwind_register_unsigned (next_frame, pc_regnum);
|
||||
}
|
||||
|
||||
/* Given a GDB frame, determine the address of the calling function's
|
||||
frame. This will be used to create a new GDB frame struct. */
|
||||
|
||||
static void
|
||||
frv_frame_this_id (struct frame_info *next_frame,
|
||||
void **this_prologue_cache, struct frame_id *this_id)
|
||||
{
|
||||
struct frv_unwind_cache *info
|
||||
= frv_frame_unwind_cache (next_frame, this_prologue_cache);
|
||||
CORE_ADDR base;
|
||||
CORE_ADDR func;
|
||||
struct minimal_symbol *msym_stack;
|
||||
struct frame_id id;
|
||||
|
||||
/* The FUNC is easy. */
|
||||
func = frame_func_unwind (next_frame);
|
||||
|
||||
/* This is meant to halt the backtrace at "_start". Make sure we
|
||||
don't halt it at a generic dummy frame. */
|
||||
if (inside_entry_file (func))
|
||||
return;
|
||||
|
||||
/* Check if the stack is empty. */
|
||||
msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
|
||||
if (msym_stack && info->base == SYMBOL_VALUE_ADDRESS (msym_stack))
|
||||
return;
|
||||
|
||||
/* Hopefully the prologue analysis either correctly determined the
|
||||
frame's base (which is the SP from the previous frame), or set
|
||||
that base to "NULL". */
|
||||
base = info->prev_sp;
|
||||
if (base == 0)
|
||||
return;
|
||||
|
||||
id = frame_id_build (base, func);
|
||||
|
||||
/* Check that we're not going round in circles with the same frame
|
||||
ID (but avoid applying the test to sentinel frames which do go
|
||||
round in circles). Can't use frame_id_eq() as that doesn't yet
|
||||
compare the frame's PC value. */
|
||||
if (frame_relative_level (next_frame) >= 0
|
||||
&& get_frame_type (next_frame) != DUMMY_FRAME
|
||||
&& frame_id_eq (get_frame_id (next_frame), id))
|
||||
return;
|
||||
|
||||
(*this_id) = id;
|
||||
}
|
||||
|
||||
static void
|
||||
frv_frame_prev_register (struct frame_info *next_frame,
|
||||
void **this_prologue_cache,
|
||||
int regnum, int *optimizedp,
|
||||
enum lval_type *lvalp, CORE_ADDR *addrp,
|
||||
int *realnump, void *bufferp)
|
||||
{
|
||||
struct frv_unwind_cache *info
|
||||
= frv_frame_unwind_cache (next_frame, this_prologue_cache);
|
||||
trad_frame_prev_register (next_frame, info->saved_regs, regnum,
|
||||
optimizedp, lvalp, addrp, realnump, bufferp);
|
||||
}
|
||||
|
||||
static const struct frame_unwind frv_frame_unwind = {
|
||||
NORMAL_FRAME,
|
||||
frv_frame_this_id,
|
||||
frv_frame_prev_register
|
||||
};
|
||||
|
||||
static const struct frame_unwind *
|
||||
frv_frame_sniffer (struct frame_info *next_frame)
|
||||
{
|
||||
return &frv_frame_unwind;
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
frv_frame_base_address (struct frame_info *next_frame, void **this_cache)
|
||||
{
|
||||
struct frv_unwind_cache *info
|
||||
= frv_frame_unwind_cache (next_frame, this_cache);
|
||||
return info->base;
|
||||
}
|
||||
|
||||
static const struct frame_base frv_frame_base = {
|
||||
&frv_frame_unwind,
|
||||
frv_frame_base_address,
|
||||
frv_frame_base_address,
|
||||
frv_frame_base_address
|
||||
};
|
||||
|
||||
static CORE_ADDR
|
||||
frv_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||||
{
|
||||
return frame_unwind_register_unsigned (next_frame, sp_regnum);
|
||||
}
|
||||
|
||||
|
||||
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
|
||||
dummy frame. The frame ID's base needs to match the TOS value
|
||||
saved by save_dummy_frame_tos(), and the PC match the dummy frame's
|
||||
breakpoint. */
|
||||
|
||||
static struct frame_id
|
||||
frv_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||||
{
|
||||
return frame_id_build (frv_unwind_sp (gdbarch, next_frame),
|
||||
frame_pc_unwind (next_frame));
|
||||
}
|
||||
|
||||
|
||||
static struct gdbarch *
|
||||
frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
||||
{
|
||||
|
|
@ -1044,10 +1090,6 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|||
|
||||
gdbarch = gdbarch_alloc (&info, var);
|
||||
|
||||
/* NOTE: cagney/2002-12-06: This can be deleted when this arch is
|
||||
ready to unwind the PC first (see frame.c:get_prev_frame()). */
|
||||
set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
|
||||
|
||||
set_gdbarch_short_bit (gdbarch, 16);
|
||||
set_gdbarch_int_bit (gdbarch, 32);
|
||||
set_gdbarch_long_bit (gdbarch, 32);
|
||||
|
|
@ -1078,13 +1120,6 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|||
set_gdbarch_frame_args_skip (gdbarch, 0);
|
||||
set_gdbarch_frameless_function_invocation (gdbarch, frv_frameless_function_invocation);
|
||||
|
||||
set_gdbarch_deprecated_saved_pc_after_call (gdbarch, frv_saved_pc_after_call);
|
||||
|
||||
set_gdbarch_deprecated_frame_chain (gdbarch, frv_frame_chain);
|
||||
set_gdbarch_deprecated_frame_saved_pc (gdbarch, frv_frame_saved_pc);
|
||||
|
||||
set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, frv_frame_init_saved_regs);
|
||||
|
||||
set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention);
|
||||
set_gdbarch_deprecated_extract_return_value (gdbarch, frv_extract_return_value);
|
||||
|
||||
|
|
@ -1092,22 +1127,21 @@ frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
|
|||
set_gdbarch_deprecated_store_return_value (gdbarch, frv_store_return_value);
|
||||
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, frv_extract_struct_value_address);
|
||||
|
||||
/* Settings for calling functions in the inferior. */
|
||||
set_gdbarch_deprecated_push_arguments (gdbarch, frv_push_arguments);
|
||||
set_gdbarch_deprecated_push_return_address (gdbarch, frv_push_return_address);
|
||||
set_gdbarch_deprecated_pop_frame (gdbarch, frv_pop_frame);
|
||||
/* Frame stuff. */
|
||||
set_gdbarch_unwind_pc (gdbarch, frv_unwind_pc);
|
||||
set_gdbarch_unwind_sp (gdbarch, frv_unwind_sp);
|
||||
set_gdbarch_frame_align (gdbarch, frv_frame_align);
|
||||
frame_unwind_append_sniffer (gdbarch, frv_frame_sniffer);
|
||||
frame_base_set_default (gdbarch, &frv_frame_base);
|
||||
|
||||
set_gdbarch_deprecated_call_dummy_words (gdbarch, frv_call_dummy_words);
|
||||
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (frv_call_dummy_words));
|
||||
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, frv_init_extra_frame_info);
|
||||
/* Settings for calling functions in the inferior. */
|
||||
set_gdbarch_push_dummy_call (gdbarch, frv_push_dummy_call);
|
||||
set_gdbarch_unwind_dummy_id (gdbarch, frv_unwind_dummy_id);
|
||||
|
||||
/* Settings that should be unnecessary. */
|
||||
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
|
||||
|
||||
set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
|
||||
set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
|
||||
|
||||
set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
|
||||
|
||||
set_gdbarch_decr_pc_after_break (gdbarch, 0);
|
||||
set_gdbarch_function_start_offset (gdbarch, 0);
|
||||
|
|
@ -1150,5 +1184,3 @@ _initialize_frv_tdep (void)
|
|||
{
|
||||
register_gdbarch_init (bfd_arch_frv, frv_gdbarch_init);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue