OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Make frv-tdep.c use new frame mechanisms.

This commit is contained in:
Kevin Buettner 2003-09-08 23:01:29 +00:00
parent 68f6cf990a
commit 1cb761c72b
3 changed files with 259 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
gdb/ChangeLog
View File

@ -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> 2003-09-09 Mark Kettenis <kettenis@gnu.org>
* dwarf2-frame.c (read_encoded_value): Add support for * dwarf2-frame.c (read_encoded_value): Add support for

2
gdb/Makefile.in
View File

@ -1770,7 +1770,7 @@ frame-unwind.o: frame-unwind.c $(defs_h) $(frame_h) $(frame_unwind_h) \
$(gdb_assert_h) $(dummy_frame_h) $(gdb_assert_h) $(dummy_frame_h)
frv-tdep.o: frv-tdep.c $(defs_h) $(gdb_string_h) $(inferior_h) $(symfile_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) \ $(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) \ 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) \ $(gdbtypes_h) $(expression_h) $(value_h) $(gdbcore_h) $(target_h) \
$(f_lang_h) $(gdb_string_h) $(f_lang_h) $(gdb_string_h)

394
gdb/frv-tdep.c
View File

@ -26,6 +26,8 @@
#include "arch-utils.h" #include "arch-utils.h"
#include "regcache.h" #include "regcache.h"
#include "frame.h" #include "frame.h"
#include "frame-unwind.h"
#include "frame-base.h"
#include "trad-frame.h" #include "trad-frame.h"
extern void _initialize_frv_tdep (void); 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_frameless_function_invocation_ftype frv_frameless_function_invocation;
static gdbarch_deprecated_push_arguments_ftype frv_push_arguments; static gdbarch_deprecated_push_arguments_ftype frv_push_arguments;
static gdbarch_deprecated_saved_pc_after_call_ftype frv_saved_pc_after_call; 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 /* Register numbers. You can change these as needed, but don't forget
to update the simulator accordingly. */ to update the simulator accordingly. */
@ -85,17 +84,14 @@ static LONGEST frv_call_dummy_words[] =
{0}; {0};
/* The contents of this structure can only be trusted after we've struct frv_unwind_cache /* was struct frame_extra_info */
frv_frame_init_saved_regs on the frame. */
struct frame_extra_info
{ {
/* The offset from our frame pointer to our caller's stack /* The previous frame's inner-most stack address. Used as this
pointer. */ frame ID's stack_addr. */
int fp_to_callers_sp_offset; CORE_ADDR prev_sp;
/* Non-zero if we've saved our return address on the stack yet. /* The frame's base, optionally used by the high-level debug info. */
Zero if it's still sitting in the link register. */ CORE_ADDR base;
int lr_saved_on_stack;
/* Table indicating the location of each and every register. */ /* Table indicating the location of each and every register. */
struct trad_frame_saved_reg *saved_regs; struct trad_frame_saved_reg *saved_regs;
@ -274,55 +270,6 @@ frv_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenp)
return breakpoint; 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, /* Return true if REG is a caller-saves ("scratch") register,
false otherwise. */ 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 arguments in any frame but the top, you'll need to do this serious
prologue analysis. */ prologue analysis. */
static CORE_ADDR 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 /* When writing out instruction bitpatterns, we use the following
letters to label instruction fields: 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. */ /* Total size of frame prior to any alloca operations. */
int framesize = 0; 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 /* The number of the general-purpose register we saved the return
address ("link register") in, or -1 if we haven't moved it yet. */ address ("link register") in, or -1 if we haven't moved it yet. */
int lr_save_reg = -1; int lr_save_reg = -1;
/* Non-zero iff we've saved the LR onto the stack. */ /* Offset (from sp) at which lr has been saved on the stack. */
int lr_saved_on_stack = 0;
int lr_sp_offset = 0;
/* If gr_saved[i] is non-zero, then we've noticed that general /* 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 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)); 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); 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). */ /* Saving the old FP in the new frame (relative to the SP). */
if (gr_k == fp_regnum && gr_i == sp_regnum) 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 /* Saving callee-saves register(s) on the stack, relative to
the SP. */ the SP. */
@ -645,13 +600,22 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
&& is_callee_saves_reg (gr_k)) && is_callee_saves_reg (gr_k))
{ {
gr_saved[gr_k] = 1; gr_saved[gr_k] = 1;
if (gr_i == sp_regnum)
gr_sp_offset[gr_k] = offset; gr_sp_offset[gr_k] = offset;
else
gr_sp_offset[gr_k] = offset + fp_offset;
} }
/* Saving the scratch register holding the return address. */ /* Saving the scratch register holding the return address. */
else if (lr_save_reg != -1 else if (lr_save_reg != -1
&& gr_k == lr_save_reg) && gr_k == lr_save_reg)
{
lr_saved_on_stack = 1; 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. */ /* Spilling int-sized arguments to the stack. */
else if (is_argument_reg (gr_k)) else if (is_argument_reg (gr_k))
@ -671,12 +635,10 @@ frv_analyze_prologue (CORE_ADDR pc, struct frame_info *frame)
pc += 4; pc += 4;
} }
if (frame) if (next_frame && info)
{ {
struct frame_extra_info *extra_info = int i;
get_frame_extra_info (frame); ULONGEST this_base;
extra_info->lr_saved_on_stack = lr_saved_on_stack;
/* If we know the relationship between the stack and frame /* If we know the relationship between the stack and frame
pointers, record the addresses of the registers we noticed. 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 because instructions may save relative to the SP, but we need
their addresses relative to the FP. */ their addresses relative to the FP. */
if (fp_set) if (fp_set)
{ frame_unwind_unsigned_register (next_frame, fp_regnum, &this_base);
struct trad_frame_saved_reg *saved_regs; else
int i; frame_unwind_unsigned_register (next_frame, sp_regnum, &this_base);
saved_regs = extra_info->saved_regs;
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
if (gr_saved[i]) if (gr_saved[i])
trad_frame_set_value (saved_regs, i, info->saved_regs[i].addr = this_base - fp_offset + gr_sp_offset[i];
get_frame_base (frame) - 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; return pc;
@ -729,33 +701,33 @@ frv_skip_prologue (CORE_ADDR pc)
If we didn't find a real source location past that, then If we didn't find a real source location past that, then
do a full analysis of the prologue. */ do a full analysis of the prologue. */
if (new_pc < pc + 20) if (new_pc < pc + 20)
new_pc = frv_analyze_prologue (pc, 0); new_pc = frv_analyze_prologue (pc, 0, 0);
return new_pc; 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 = struct gdbarch *gdbarch = get_frame_arch (next_frame);
get_frame_extra_info (frame); CORE_ADDR pc;
ULONGEST prev_sp;
ULONGEST this_base;
struct frv_unwind_cache *info;
if (extra_info && extra_info->saved_regs) if ((*this_prologue_cache))
return; return (*this_prologue_cache);
extra_info->saved_regs = trad_frame_alloc_saved_regs (frame); info = FRAME_OBSTACK_ZALLOC (struct frv_unwind_cache);
trad_frame_set_value (extra_info->saved_regs, (*this_prologue_cache) = info;
fp_regnum, get_frame_base (frame)); info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
/* Find the beginning of this function, so we can analyze its /* Prologue analysis does the rest... */
prologue. */ frv_analyze_prologue (frame_func_unwind (next_frame), next_frame, info);
{
CORE_ADDR func_addr, func_end;
if (find_pc_partial_function (get_frame_pc (frame), return info;
NULL, &func_addr, &func_end))
frv_analyze_prologue (func_addr, frame);
}
} }
static void static void
@ -787,28 +759,20 @@ frv_frameless_function_invocation (struct frame_info *frame)
return frameless_look_for_prologue (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_UP(n,a) (((n)+(a)-1) & ~((a)-1))
#define ROUND_DOWN(n,a) ((n) & ~((a)-1)) #define ROUND_DOWN(n,a) ((n) & ~((a)-1))
static CORE_ADDR 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 struct_return, CORE_ADDR struct_addr)
{ {
int argreg; int argreg;
@ -844,7 +808,8 @@ frv_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
argreg = 8; argreg = 8;
if (struct_return) 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) 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", printf(" Argnum %d data %x -> reg %d\n",
argnum, (int) regval, argreg); argnum, (int) regval, argreg);
#endif #endif
write_register (argreg, regval); regcache_cooked_write_unsigned (regcache, argreg, regval);
++argreg; ++argreg;
} }
else else
@ -892,13 +857,14 @@ frv_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
val += partial_len; val += partial_len;
} }
} }
return sp;
}
static CORE_ADDR /* Set the return address. For the frv, the return breakpoint is
frv_push_return_address (CORE_ADDR pc, CORE_ADDR sp) always at BP_ADDR. */
{ regcache_cooked_write_unsigned (regcache, lr_regnum, bp_addr);
write_register (lr_regnum, CALL_DUMMY_ADDRESS ());
/* Finally, update the SP register. */
regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
return 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); "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 /* Hardware watchpoint / breakpoint support for the FR500
and FR400. */ and FR400. */
@ -1008,6 +940,120 @@ frv_stopped_data_address (void)
return 0; 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 * static struct gdbarch *
frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 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); 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_short_bit (gdbarch, 16);
set_gdbarch_int_bit (gdbarch, 32); set_gdbarch_int_bit (gdbarch, 32);
set_gdbarch_long_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_frame_args_skip (gdbarch, 0);
set_gdbarch_frameless_function_invocation (gdbarch, frv_frameless_function_invocation); 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_use_struct_convention (gdbarch, always_use_struct_convention);
set_gdbarch_deprecated_extract_return_value (gdbarch, frv_extract_return_value); 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_store_return_value (gdbarch, frv_store_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, frv_extract_struct_value_address); set_gdbarch_deprecated_extract_struct_value_address (gdbarch, frv_extract_struct_value_address);
/* Settings for calling functions in the inferior. */ /* Frame stuff. */
set_gdbarch_deprecated_push_arguments (gdbarch, frv_push_arguments); set_gdbarch_unwind_pc (gdbarch, frv_unwind_pc);
set_gdbarch_deprecated_push_return_address (gdbarch, frv_push_return_address); set_gdbarch_unwind_sp (gdbarch, frv_unwind_sp);
set_gdbarch_deprecated_pop_frame (gdbarch, frv_pop_frame); 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); /* Settings for calling functions in the inferior. */
set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (frv_call_dummy_words)); set_gdbarch_push_dummy_call (gdbarch, frv_push_dummy_call);
set_gdbarch_deprecated_init_extra_frame_info (gdbarch, frv_init_extra_frame_info); set_gdbarch_unwind_dummy_id (gdbarch, frv_unwind_dummy_id);
/* Settings that should be unnecessary. */ /* Settings that should be unnecessary. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan); set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_write_pc (gdbarch, generic_target_write_pc); 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_decr_pc_after_break (gdbarch, 0);
set_gdbarch_function_start_offset (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); register_gdbarch_init (bfd_arch_frv, frv_gdbarch_init);
} }