/* 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
+ Free Software Foundation, Inc.
Contributed by Red Hat.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "frame.h"
Convert a target pointer to an address in host (CORE_ADDR) format. */
static CORE_ADDR
-iq2000_pointer_to_address (struct type * type, const void * 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, void *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 name of the iq2000 register number N. */
static const char *
-iq2000_register_name (int regnum)
+iq2000_register_name (struct gdbarch *gdbarch, int regnum)
{
static const char * names[E_NUM_REGS] =
{
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, void *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 (current_gdbarch, 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;
}
};
static const unsigned char *
-iq2000_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
+ int *lenptr)
{
static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
(long) *pcptr);
*lenptr = 4;
- return (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? big_breakpoint
- : little_breakpoint;
+ return (gdbarch_byte_order (gdbarch)
+ == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
}
/* Target function return value methods: */
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
register. */
- CORE_ADDR return_buffer;
int len = TYPE_LENGTH (type);
if (len <= (2 * 4))
/* 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;
}
{
/* Return values > 8 bytes are returned in memory,
pointed to by FN_RETURN_REGNUM. */
- regcache_cooked_read (regcache, E_FN_RETURN_REGNUM, & return_buffer);
+ ULONGEST return_buffer;
+ regcache_cooked_read_unsigned (regcache, E_FN_RETURN_REGNUM,
+ &return_buffer);
read_memory (return_buffer, valbuf, TYPE_LENGTH (type));
}
}
static enum return_value_convention
-iq2000_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache,
- void *readbuf, const void *writebuf)
+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))
return RETURN_VALUE_STRUCT_CONVENTION;
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)
{