/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
Debugger.
- Copyright (C) 2000, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 2000-2020 Free Software Foundation, Inc.
Contributed by Red Hat.
#include "frame.h"
#include "frame-base.h"
#include "frame-unwind.h"
-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"
#include "gdbtypes.h"
#include "value.h"
#include "dis-asm.h"
-#include "gdb_string.h"
#include "arch-utils.h"
#include "regcache.h"
#include "osabi.h"
}
/* Function: pointer_to_address
- Convert a target pointer to an address in host (CORE_ADDR) format. */
+ Convert a target pointer to an address in host (CORE_ADDR) format. */
static CORE_ADDR
-iq2000_pointer_to_address (struct type * type, const gdb_byte * buf)
+iq2000_pointer_to_address (struct gdbarch *gdbarch,
+ struct type * type, const gdb_byte * buf)
{
- enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
- CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum type_code target = TYPE_TARGET_TYPE (type)->code ();
+ CORE_ADDR addr
+ = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
if (target == TYPE_CODE_FUNC
|| target == TYPE_CODE_METHOD
- || (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_CODE_SPACE) != 0)
+ || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
addr = insn_addr_from_ptr (addr);
return addr;
Convert a host-format address (CORE_ADDR) into a target pointer. */
static void
-iq2000_address_to_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
+iq2000_address_to_pointer (struct gdbarch *gdbarch,
+ struct type *type, gdb_byte *buf, CORE_ADDR addr)
{
- enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ enum type_code target = TYPE_TARGET_TYPE (type)->code ();
if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
addr = insn_ptr_from_addr (addr);
- store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
+ store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
/* Real register methods: */
Returns the address of the first instruction after the prologue. */
static CORE_ADDR
-iq2000_scan_prologue (CORE_ADDR scan_start,
+iq2000_scan_prologue (struct gdbarch *gdbarch,
+ CORE_ADDR scan_start,
CORE_ADDR scan_end,
struct frame_info *fi,
struct iq2000_frame_cache *cache)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct symtab_and_line sal;
CORE_ADDR pc;
CORE_ADDR loop_end;
- int found_store_lr = 0;
- int found_decr_sp = 0;
int srcreg;
int tgtreg;
signed short offset;
loop_end = scan_end;
if (fi)
sal = find_last_line_symbol (scan_start, scan_end, 0);
+ else
+ sal.end = 0; /* Avoid GCC false warning. */
}
/* Saved registers:
only later do we compute its actual address. Since the
offset can be zero, we must first initialize all the
saved regs to minus one (so we can later distinguish
- between one that's not saved, and one that's saved at zero). */
+ between one that's not saved, and one that's saved at zero). */
for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
cache->saved_regs[srcreg] = -1;
cache->using_fp = 0;
for (pc = scan_start; pc < loop_end; pc += 4)
{
- LONGEST insn = read_memory_unsigned_integer (pc, 4);
+ LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
/* Skip any instructions writing to (sp) or decrementing the
- SP. */
+ SP. */
if ((insn & 0xffe00000) == 0xac200000)
{
/* sw using SP/%1 as base. */
if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
- if (tgtreg == E_LR_REGNUM)
- found_store_lr = 1;
continue;
}
if ((insn & 0xffff8000) == 0x20218000)
{
/* addi %1, %1, -N == addi %sp, %sp, -N */
- /* LEGACY -- from assembly-only port */
- found_decr_sp = 1;
+ /* LEGACY -- from assembly-only port. */
cache->framesize = -((signed short) (insn & 0xffff));
continue;
}
if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
{
- /* "push" to stack (via SP or FP reg) */
+ /* "push" to stack (via SP or FP reg). */
if (cache->saved_regs[srcreg] == -1) /* Don't save twice. */
cache->saved_regs[srcreg] = offset;
continue;
}
/* Unknown instruction encountered in frame. Bail out?
- 1) If we have a subsequent line symbol, we can keep going.
- 2) If not, we need to bail out and quit scanning instructions. */
+ 1) If we have a subsequent line symbol, we can keep going.
+ 2) If not, we need to bail out and quit scanning instructions. */
if (fi && sal.end && (pc < sal.end)) /* Keep scanning. */
continue;
stepped into a function call. */
static CORE_ADDR
-iq2000_skip_prologue (CORE_ADDR pc)
+iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
CORE_ADDR func_addr = 0 , func_end = 0;
/* No useable line symbol. Use prologue parsing method. */
iq2000_init_frame_cache (&cache);
- return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
+ return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache);
}
/* No function symbol -- just return the PC. */
}
static struct iq2000_frame_cache *
-iq2000_frame_cache (struct frame_info *next_frame, void **this_cache)
+iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
{
+ struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct iq2000_frame_cache *cache;
CORE_ADDR current_pc;
int i;
if (*this_cache)
- return *this_cache;
+ return (struct iq2000_frame_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
iq2000_init_frame_cache (cache);
*this_cache = cache;
- cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
- //if (cache->base == 0)
- //return cache;
+ cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
- current_pc = frame_pc_unwind (next_frame);
+ current_pc = get_frame_pc (this_frame);
find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
if (cache->pc != 0)
- iq2000_scan_prologue (cache->pc, current_pc, next_frame, cache);
+ iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache);
if (!cache->using_fp)
- cache->base = frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
+ cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
cache->saved_sp = cache->base + cache->framesize;
return cache;
}
-static void
-iq2000_frame_prev_register (struct frame_info *next_frame, void **this_cache,
- int regnum, int *optimizedp,
- enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, gdb_byte *valuep)
+static struct value *
+iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
+ int regnum)
{
- struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
+ struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
+ this_cache);
+
if (regnum == E_SP_REGNUM && cache->saved_sp)
- {
- *optimizedp = 0;
- *lvalp = not_lval;
- *addrp = 0;
- *realnump = -1;
- if (valuep)
- store_unsigned_integer (valuep, 4, cache->saved_sp);
- return;
- }
+ return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
if (regnum == E_PC_REGNUM)
regnum = E_LR_REGNUM;
if (regnum < E_NUM_REGS && cache->saved_regs[regnum] != -1)
- {
- *optimizedp = 0;
- *lvalp = lval_memory;
- *addrp = cache->saved_regs[regnum];
- *realnump = -1;
- if (valuep)
- read_memory (*addrp, valuep,
- register_size (get_frame_arch (next_frame), regnum));
- return;
- }
+ return frame_unwind_got_memory (this_frame, regnum,
+ cache->saved_regs[regnum]);
- *optimizedp = 0;
- *lvalp = lval_register;
- *addrp = 0;
- *realnump = regnum;
- if (valuep)
- frame_unwind_register (next_frame, (*realnump), valuep);
+ return frame_unwind_got_register (this_frame, regnum, regnum);
}
static void
-iq2000_frame_this_id (struct frame_info *next_frame, void **this_cache,
+iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id)
{
- struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
+ struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
+ this_cache);
/* This marks the outermost frame. */
if (cache->base == 0)
static const struct frame_unwind iq2000_frame_unwind = {
NORMAL_FRAME,
+ default_frame_unwind_stop_reason,
iq2000_frame_this_id,
- iq2000_frame_prev_register
+ iq2000_frame_prev_register,
+ NULL,
+ default_frame_sniffer
};
-static const struct frame_unwind *
-iq2000_frame_sniffer (struct frame_info *next_frame)
-{
- return &iq2000_frame_unwind;
-}
-
-static CORE_ADDR
-iq2000_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
-}
-
-static CORE_ADDR
-iq2000_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
-}
-
-static struct frame_id
-iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
- return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
- frame_pc_unwind (next_frame));
-}
-
static CORE_ADDR
-iq2000_frame_base_address (struct frame_info *next_frame, void **this_cache)
+iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
{
- struct iq2000_frame_cache *cache = iq2000_frame_cache (next_frame, this_cache);
+ struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
+ this_cache);
return cache->base;
}
iq2000_frame_base_address
};
-static const unsigned char *
-iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
- int *lenptr)
+static int
+iq2000_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
{
- static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
- static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
-
if ((*pcptr & 3) != 0)
- error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
+ error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),
(long) *pcptr);
- *lenptr = 4;
+ return 4;
+}
+
+static const gdb_byte *
+iq2000_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
+{
+ static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
+ static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
+ *size = kind;
+
return (gdbarch_byte_order (gdbarch)
== BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
}
while (len > 0)
{
- char buf[4];
+ gdb_byte buf[4];
int size = len % 4 ?: 4;
memset (buf, 0, 4);
memcpy (buf + 4 - size, valbuf, size);
- regcache_raw_write (regcache, regno++, buf);
+ regcache->raw_write (regno++, buf);
len -= size;
valbuf = ((char *) valbuf) + size;
}
static int
iq2000_use_struct_convention (struct type *type)
{
- return ((TYPE_CODE (type) == TYPE_CODE_STRUCT)
- || (TYPE_CODE (type) == TYPE_CODE_UNION))
+ return ((type->code () == TYPE_CODE_STRUCT)
+ || (type->code () == TYPE_CODE_UNION))
&& TYPE_LENGTH (type) > 8;
}
static void
iq2000_extract_return_value (struct type *type, struct regcache *regcache,
- void *valbuf)
+ gdb_byte *valbuf)
{
+ struct gdbarch *gdbarch = regcache->arch ();
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
/* If the function's return value is 8 bytes or less, it is
returned in a register, and if larger than 8 bytes, it is
returned in a stack location which is pointed to by the same
/* By using store_unsigned_integer we avoid having to
do anything special for small big-endian values. */
regcache_cooked_read_unsigned (regcache, regno++, &tmp);
- store_unsigned_integer (valbuf, size, tmp);
+ store_unsigned_integer (valbuf, size, byte_order, tmp);
len -= size;
- valbuf = ((char *) valbuf) + size;
+ valbuf += size;
}
}
else
}
static enum return_value_convention
-iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache,
+iq2000_return_value (struct gdbarch *gdbarch, struct value *function,
+ struct type *type, struct regcache *regcache,
gdb_byte *readbuf, const gdb_byte *writebuf)
{
if (iq2000_use_struct_convention (type))
static struct type *
iq2000_register_type (struct gdbarch *gdbarch, int regnum)
{
- return builtin_type_int32;
+ return builtin_type (gdbarch)->builtin_int32;
}
static CORE_ADDR
}
/* Convenience function to check 8-byte types for being a scalar type
- or a struct with only one long long or double member. */
+ or a struct with only one long long or double member. */
static int
iq2000_pass_8bytetype_by_address (struct type *type)
{
struct type *ftype;
/* Skip typedefs. */
- while (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+ while (type->code () == TYPE_CODE_TYPEDEF)
type = TYPE_TARGET_TYPE (type);
/* Non-struct and non-union types are always passed by value. */
- if (TYPE_CODE (type) != TYPE_CODE_STRUCT
- && TYPE_CODE (type) != TYPE_CODE_UNION)
+ if (type->code () != TYPE_CODE_STRUCT
+ && type->code () != TYPE_CODE_UNION)
return 0;
/* Structs with more than 1 field are always passed by address. */
- if (TYPE_NFIELDS (type) != 1)
+ if (type->num_fields () != 1)
return 1;
/* Get field type. */
- ftype = (TYPE_FIELDS (type))[0].type;
+ ftype = type->field (0).type ();
/* The field type must have size 8, otherwise pass by address. */
if (TYPE_LENGTH (ftype) != 8)
return 1;
/* Skip typedefs of field type. */
- while (TYPE_CODE (ftype) == TYPE_CODE_TYPEDEF)
+ while (ftype->code () == TYPE_CODE_TYPEDEF)
ftype = TYPE_TARGET_TYPE (ftype);
/* If field is int or float, pass by value. */
- if (TYPE_CODE (ftype) == TYPE_CODE_FLT
- || TYPE_CODE (ftype) == TYPE_CODE_INT)
+ if (ftype->code () == TYPE_CODE_FLT
+ || ftype->code () == TYPE_CODE_INT)
return 0;
- /* Everything else, pass by address. */
+ /* Everything else, pass by address. */
return 1;
}
static CORE_ADDR
iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
- struct regcache *regcache, CORE_ADDR bp_addr,
- int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
+ struct regcache *regcache, CORE_ADDR bp_addr,
+ int nargs, struct value **args, CORE_ADDR sp,
+ function_call_return_method return_method,
+ CORE_ADDR struct_addr)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
const bfd_byte *val;
bfd_byte buf[4];
struct type *type;
int i, argreg, typelen, slacklen;
int stackspace = 0;
- /* Used to copy struct arguments into the stack. */
+ /* Used to copy struct arguments into the stack. */
CORE_ADDR struct_ptr;
- /* First determine how much stack space we will need. */
- for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
+ /* First determine how much stack space we will need. */
+ for (i = 0, argreg = E_1ST_ARGREG + (return_method == return_method_struct);
+ i < nargs;
+ i++)
{
type = value_type (args[i]);
typelen = TYPE_LENGTH (type);
if (typelen <= 4)
- {
- /* Scalars of up to 4 bytes,
- structs of up to 4 bytes, and
- pointers. */
- if (argreg <= E_LAST_ARGREG)
- argreg++;
- else
- stackspace += 4;
- }
+ {
+ /* Scalars of up to 4 bytes,
+ structs of up to 4 bytes, and
+ pointers. */
+ if (argreg <= E_LAST_ARGREG)
+ argreg++;
+ else
+ stackspace += 4;
+ }
else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
- {
- /* long long,
- double, and possibly
- structs with a single field of long long or double. */
- if (argreg <= E_LAST_ARGREG - 1)
- {
- /* 8-byte arg goes into a register pair
- (must start with an even-numbered reg) */
- if (((argreg - E_1ST_ARGREG) % 2) != 0)
- argreg ++;
- argreg += 2;
- }
- else
- {
- argreg = E_LAST_ARGREG + 1; /* no more argregs. */
- /* 8-byte arg goes on stack, must be 8-byte aligned. */
- stackspace = ((stackspace + 7) & ~7);
- stackspace += 8;
- }
- }
+ {
+ /* long long,
+ double, and possibly
+ structs with a single field of long long or double. */
+ if (argreg <= E_LAST_ARGREG - 1)
+ {
+ /* 8-byte arg goes into a register pair
+ (must start with an even-numbered reg). */
+ if (((argreg - E_1ST_ARGREG) % 2) != 0)
+ argreg ++;
+ argreg += 2;
+ }
+ else
+ {
+ argreg = E_LAST_ARGREG + 1; /* no more argregs. */
+ /* 8-byte arg goes on stack, must be 8-byte aligned. */
+ stackspace = ((stackspace + 7) & ~7);
+ stackspace += 8;
+ }
+ }
else
{
/* Structs are passed as pointer to a copy of the struct.
So we need room on the stack for a copy of the struct
- plus for the argument pointer. */
- if (argreg <= E_LAST_ARGREG)
- argreg++;
- else
- stackspace += 4;
+ plus for the argument pointer. */
+ if (argreg <= E_LAST_ARGREG)
+ argreg++;
+ else
+ stackspace += 4;
/* Care for 8-byte alignment of structs saved on stack. */
stackspace += ((typelen + 7) & ~7);
}
}
/* Now copy params, in ascending order, into their assigned location
- (either in a register or on the stack). */
+ (either in a register or on the stack). */
sp -= (sp % 8); /* align */
struct_ptr = sp;
stackspace = 0;
argreg = E_1ST_ARGREG;
- if (struct_return)
+ if (return_method == return_method_struct)
{
- /* A function that returns a struct will consume one argreg to do so.
+ /* A function that returns a struct will consume one argreg to do so.
*/
regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
}
typelen = TYPE_LENGTH (type);
val = value_contents (args[i]);
if (typelen <= 4)
- {
- /* Char, short, int, float, pointer, and structs <= four bytes. */
+ {
+ /* Char, short, int, float, pointer, and structs <= four bytes. */
slacklen = (4 - (typelen % 4)) % 4;
memset (buf, 0, sizeof (buf));
memcpy (buf + slacklen, val, typelen);
- if (argreg <= E_LAST_ARGREG)
- {
- /* Passed in a register. */
- regcache_raw_write (regcache, argreg++, buf);
- }
- else
- {
- /* Passed on the stack. */
- write_memory (sp + stackspace, buf, 4);
- stackspace += 4;
- }
- }
+ if (argreg <= E_LAST_ARGREG)
+ {
+ /* Passed in a register. */
+ regcache->raw_write (argreg++, buf);
+ }
+ else
+ {
+ /* Passed on the stack. */
+ write_memory (sp + stackspace, buf, 4);
+ stackspace += 4;
+ }
+ }
else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
- {
- /* (long long), (double), or struct consisting of
- a single (long long) or (double). */
- if (argreg <= E_LAST_ARGREG - 1)
- {
- /* 8-byte arg goes into a register pair
- (must start with an even-numbered reg) */
- if (((argreg - E_1ST_ARGREG) % 2) != 0)
- argreg++;
- regcache_raw_write (regcache, argreg++, val);
- regcache_raw_write (regcache, argreg++, val + 4);
- }
- else
- {
- /* 8-byte arg goes on stack, must be 8-byte aligned. */
- argreg = E_LAST_ARGREG + 1; /* no more argregs. */
- stackspace = ((stackspace + 7) & ~7);
- write_memory (sp + stackspace, val, typelen);
- stackspace += 8;
- }
- }
+ {
+ /* (long long), (double), or struct consisting of
+ a single (long long) or (double). */
+ if (argreg <= E_LAST_ARGREG - 1)
+ {
+ /* 8-byte arg goes into a register pair
+ (must start with an even-numbered reg). */
+ if (((argreg - E_1ST_ARGREG) % 2) != 0)
+ argreg++;
+ regcache->raw_write (argreg++, val);
+ regcache->raw_write (argreg++, val + 4);
+ }
+ else
+ {
+ /* 8-byte arg goes on stack, must be 8-byte aligned. */
+ argreg = E_LAST_ARGREG + 1; /* no more argregs. */
+ stackspace = ((stackspace + 7) & ~7);
+ write_memory (sp + stackspace, val, typelen);
+ stackspace += 8;
+ }
+ }
else
- {
+ {
/* Store struct beginning at the upper end of the previously
computed stack space. Then store the address of the struct
using the usual rules for a 4 byte value. */
regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
else
{
- store_unsigned_integer (buf, 4, struct_ptr);
+ store_unsigned_integer (buf, 4, byte_order, struct_ptr);
write_memory (sp + stackspace, buf, 4);
stackspace += 4;
}
- }
+ }
}
- /* Store return address. */
+ /* Store return address. */
regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
/* Update stack pointer. */
regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
- /* And that should do it. Return the new stack pointer. */
+ /* And that should do it. Return the new stack pointer. */
return sp;
}
set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
set_gdbarch_return_value (gdbarch, iq2000_return_value);
- set_gdbarch_breakpoint_from_pc (gdbarch, iq2000_breakpoint_from_pc);
+ set_gdbarch_breakpoint_kind_from_pc (gdbarch,
+ iq2000_breakpoint_kind_from_pc);
+ set_gdbarch_sw_breakpoint_from_kind (gdbarch,
+ iq2000_sw_breakpoint_from_kind);
set_gdbarch_frame_args_skip (gdbarch, 0);
set_gdbarch_skip_prologue (gdbarch, iq2000_skip_prologue);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- set_gdbarch_print_insn (gdbarch, print_insn_iq2000);
set_gdbarch_register_type (gdbarch, iq2000_register_type);
set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
- set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
- set_gdbarch_unwind_pc (gdbarch, iq2000_unwind_pc);
- set_gdbarch_unwind_dummy_id (gdbarch, iq2000_unwind_dummy_id);
frame_base_set_default (gdbarch, &iq2000_frame_base);
set_gdbarch_push_dummy_call (gdbarch, iq2000_push_dummy_call);
gdbarch_init_osabi (info, gdbarch);
- frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
- frame_unwind_append_sniffer (gdbarch, iq2000_frame_sniffer);
+ dwarf2_append_unwinders (gdbarch);
+ frame_unwind_append_unwinder (gdbarch, &iq2000_frame_unwind);
return gdbarch;
}
/* Function: _initialize_iq2000_tdep
Initializer function for the iq2000 module.
- Called by gdb at start-up. */
+ Called by gdb at start-up. */
+void _initialize_iq2000_tdep ();
void
-_initialize_iq2000_tdep (void)
+_initialize_iq2000_tdep ()
{
register_gdbarch_init (bfd_arch_iq2000, iq2000_gdbarch_init);
}