/* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
Debugger.
- Copyright (C) 2000, 2004, 2005, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2004, 2005, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
Contributed by Red Hat.
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 bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
- CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
+ 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 bfd_endian byte_order = gdbarch_byte_order (gdbarch);
enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
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;
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. */
if ((insn & 0xffe00000) == 0xac200000)
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;
iq2000_init_frame_cache (cache);
*this_cache = cache;
- cache->base = frame_unwind_register_unsigned (next_frame, E_FP_REGNUM);
+ cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
//if (cache->base == 0)
//return cache;
- 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,
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)
{
}
static struct frame_id
-iq2000_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
+iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- return frame_id_build (iq2000_unwind_sp (gdbarch, next_frame),
- frame_pc_unwind (next_frame));
+ CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
+ return frame_id_build (sp, get_frame_pc (this_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_extract_return_value (struct type *type, struct regcache *regcache,
void *valbuf)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ 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;
}
}
static enum return_value_convention
-iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache,
+iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
+ 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
int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
const bfd_byte *val;
bfd_byte buf[4];
struct type *type;
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;
}
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);
+ set_gdbarch_dummy_id (gdbarch, iq2000_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;
}
Initializer function for the iq2000 module.
Called by gdb at start-up. */
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_iq2000_tdep;
+
void
_initialize_iq2000_tdep (void)
{
projects / deliverable / binutils-gdb.git / blobdiff