/* Target-dependent code for the Fujitsu FR-V, for GDB, the GNU Debugger.
- Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009
+ Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of GDB.
{
var->frv_abi = FRV_ABI_FDPIC;
var->register_names[fdpic_loadmap_exec_regnum] = xstrdup ("loadmap_exec");
- var->register_names[fdpic_loadmap_interp_regnum] = xstrdup ("loadmap_interp");
+ var->register_names[fdpic_loadmap_interp_regnum]
+ = xstrdup ("loadmap_interp");
}
static void
/* Find the end of the previous packing sequence. This will be indicated
by either attempting to access some inaccessible memory or by finding
- an instruction word whose packing bit is set to one. */
+ an instruction word whose packing bit is set to one. */
while (count-- > 0 && addr >= func_start)
{
char instr[frv_instr_size];
struct frame_info *this_frame,
struct frv_unwind_cache *info)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
/* When writing out instruction bitpatterns, we use the following
letters to label instruction fields:
P - The parallel bit. We don't use this.
the stack pointer to frame pointer: fp = sp + fp_offset. */
int fp_offset = 0;
- /* Total size of frame prior to any alloca operations. */
+ /* Total size of frame prior to any alloca operations. */
int framesize = 0;
/* Flag indicating if lr has been saved on the stack. */
/* The address of the most recently scanned prologue instruction. */
CORE_ADDR last_prologue_pc;
- /* The address of the next instruction. */
+ /* The address of the next instruction. */
CORE_ADDR next_pc;
/* The upper bound to of the pc values to scan. */
if (target_read_memory (pc, buf, sizeof buf) != 0)
break;
- op = extract_signed_integer (buf, sizeof buf);
+ op = extract_signed_integer (buf, sizeof buf, byte_order);
next_pc = pc + 4;
/* 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;
+ 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
static CORE_ADDR
frv_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte buf[4];
unsigned long op;
CORE_ADDR orig_pc = pc;
if (target_read_memory (pc, buf, 4))
return pc;
- op = extract_unsigned_integer (buf, 4);
+ op = extract_unsigned_integer (buf, 4, byte_order);
/* In PIC code, GR15 may be loaded from some offset off of FP prior
to the call instruction.
Skip over this instruction if present. It won't be present in
- non-PIC code, and even in PIC code, it might not be present.
+ non-PIC code, and even in PIC code, it might not be present.
(This is due to the fact that GR15, the FDPIC register, already
contains the correct value.)
pc += 4;
if (target_read_memory (pc, buf, 4))
return orig_pc;
- op = extract_unsigned_integer (buf, 4);
+ op = extract_unsigned_integer (buf, 4, byte_order);
}
/* The format of an FRV CALL instruction is as follows:
frv_extract_return_value (struct type *type, struct regcache *regcache,
gdb_byte *valbuf)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int len = TYPE_LENGTH (type);
if (len <= 4)
{
ULONGEST gpr8_val;
regcache_cooked_read_unsigned (regcache, 8, &gpr8_val);
- store_unsigned_integer (valbuf, len, gpr8_val);
+ store_unsigned_integer (valbuf, len, byte_order, gpr8_val);
}
else if (len == 8)
{
ULONGEST regval;
+
regcache_cooked_read_unsigned (regcache, 8, ®val);
- store_unsigned_integer (valbuf, 4, regval);
+ store_unsigned_integer (valbuf, 4, byte_order, regval);
regcache_cooked_read_unsigned (regcache, 9, ®val);
- store_unsigned_integer ((bfd_byte *) valbuf + 4, 4, regval);
+ store_unsigned_integer ((bfd_byte *) valbuf + 4, 4, byte_order, regval);
}
else
- internal_error (__FILE__, __LINE__, _("Illegal return value length: %d"), len);
+ internal_error (__FILE__, __LINE__,
+ _("Illegal return value length: %d"), len);
}
static CORE_ADDR
static CORE_ADDR
find_func_descr (struct gdbarch *gdbarch, CORE_ADDR entry_point)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR descr;
char valbuf[4];
CORE_ADDR start_addr;
the stack. */
descr = value_as_long (value_allocate_space_in_inferior (8));
- store_unsigned_integer (valbuf, 4, entry_point);
+ store_unsigned_integer (valbuf, 4, byte_order, entry_point);
write_memory (descr, valbuf, 4);
- store_unsigned_integer (valbuf, 4,
+ store_unsigned_integer (valbuf, 4, byte_order,
frv_fdpic_find_global_pointer (entry_point));
write_memory (descr + 4, valbuf, 4);
return descr;
frv_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
struct target_ops *targ)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR entry_point;
CORE_ADDR got_address;
- entry_point = get_target_memory_unsigned (targ, addr, 4);
- got_address = get_target_memory_unsigned (targ, addr + 4, 4);
+ entry_point = get_target_memory_unsigned (targ, addr, 4, byte_order);
+ got_address = get_target_memory_unsigned (targ, addr + 4, 4, byte_order);
if (got_address == frv_fdpic_find_global_pointer (entry_point))
return entry_point;
int nargs, struct value **args, CORE_ADDR sp,
int struct_return, CORE_ADDR struct_addr)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
int argreg;
int argnum;
char *val;
if (stack_space > 0)
sp -= stack_space;
- /* Make sure stack is dword aligned. */
+ /* Make sure stack is dword aligned. */
sp = align_down (sp, 8);
stack_offset = 0;
if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
{
- store_unsigned_integer (valbuf, 4, value_address (arg));
+ store_unsigned_integer (valbuf, 4, byte_order,
+ value_address (arg));
typecode = TYPE_CODE_PTR;
len = 4;
val = valbuf;
{
/* The FDPIC ABI requires function descriptors to be passed instead
of entry points. */
- store_unsigned_integer
- (valbuf, 4,
- find_func_descr (gdbarch,
- extract_unsigned_integer (value_contents (arg),
- 4)));
+ CORE_ADDR addr = extract_unsigned_integer
+ (value_contents (arg), 4, byte_order);
+ addr = find_func_descr (gdbarch, addr);
+ store_unsigned_integer (valbuf, 4, byte_order, addr);
typecode = TYPE_CODE_PTR;
len = 4;
val = valbuf;
if (argreg < 14)
{
- regval = extract_unsigned_integer (val, partial_len);
+ regval = extract_unsigned_integer (val, partial_len, byte_order);
#if 0
printf(" Argnum %d data %x -> reg %d\n",
argnum, (int) regval, argreg);
{
#if 0
printf(" Argnum %d data %x -> offset %d (%x)\n",
- argnum, *((int *)val), stack_offset, (int) (sp + stack_offset));
+ argnum, *((int *)val), stack_offset,
+ (int) (sp + stack_offset));
#endif
write_memory (sp + stack_offset, val, partial_len);
stack_offset += align_up (partial_len, 4);