2007-10-10 Markus Deuling <deuling@de.ibm.com>
* mips-tdep.c (mips_xfer_register): Use get_regcache_arch to get at the current architecture by regcache. (mips2_fp_compat, mips32_next_pc, mips16_scan_prologue) (mips_insn16_frame_cache, mips32_scan_prologue, mips_insn32_frame_cache) (mips_stub_frame_cache, mips_read_fp_register_single) (mips_read_fp_register_double, mips_print_fp_register) (mips_print_register, print_gp_register_row): Use get_frame_arch to get at the current architecture by frame_info. (mips_register_reggroup_p, mips_pseudo_register_read, mips_unwind_sp) (mips_pseudo_register_write, mips_register_type, mips_unwind_pc) (mips_unwind_dummy_id, mips_eabi_push_dummy_call) (mips_n32n64_push_dummy_call, mips_n32n64_return_value) (mips_o32_push_dummy_call, mips_o32_return_value) (mips_o64_push_dummy_call, mips_o64_return_value) (mips_print_registers_info, mips_dump_tdep): Replace current_gdbarch by gdbarch.
This commit is contained in:
Ulrich Weigand
parent
6b50c0b03a
commit
72a155b44d
@ -1,3 +1,22 @@
|
||||
2007-10-10 Markus Deuling <deuling@de.ibm.com>
|
||||
|
||||
* mips-tdep.c (mips_xfer_register): Use get_regcache_arch to get at the
|
||||
current architecture by regcache.
|
||||
(mips2_fp_compat, mips32_next_pc, mips16_scan_prologue)
|
||||
(mips_insn16_frame_cache, mips32_scan_prologue, mips_insn32_frame_cache)
|
||||
(mips_stub_frame_cache, mips_read_fp_register_single)
|
||||
(mips_read_fp_register_double, mips_print_fp_register)
|
||||
(mips_print_register, print_gp_register_row): Use get_frame_arch to get
|
||||
at the current architecture by frame_info.
|
||||
(mips_register_reggroup_p, mips_pseudo_register_read, mips_unwind_sp)
|
||||
(mips_pseudo_register_write, mips_register_type, mips_unwind_pc)
|
||||
(mips_unwind_dummy_id, mips_eabi_push_dummy_call)
|
||||
(mips_n32n64_push_dummy_call, mips_n32n64_return_value)
|
||||
(mips_o32_push_dummy_call, mips_o32_return_value)
|
||||
(mips_o64_push_dummy_call, mips_o64_return_value)
|
||||
(mips_print_registers_info, mips_dump_tdep): Replace current_gdbarch by
|
||||
gdbarch.
|
||||
|
||||
2007-10-10 Markus Deuling <deuling@de.ibm.com>
|
||||
|
||||
* xtensa-tdep.c (xtensa_register_type, xtensa_pseudo_register_read)
|
||||
|
||||
349
gdb/mips-tdep.c
349
gdb/mips-tdep.c
@ -348,13 +348,15 @@ mips_xfer_register (struct regcache *regcache, int reg_num, int length,
|
||||
const gdb_byte *out, int buf_offset)
|
||||
{
|
||||
int reg_offset = 0;
|
||||
gdb_assert (reg_num >= gdbarch_num_regs (current_gdbarch));
|
||||
struct gdbarch *gdbarch = get_regcache_arch (regcache);
|
||||
|
||||
gdb_assert (reg_num >= gdbarch_num_regs (gdbarch));
|
||||
/* Need to transfer the left or right part of the register, based on
|
||||
the targets byte order. */
|
||||
switch (endian)
|
||||
{
|
||||
case BFD_ENDIAN_BIG:
|
||||
reg_offset = register_size (current_gdbarch, reg_num) - length;
|
||||
reg_offset = register_size (gdbarch, reg_num) - length;
|
||||
break;
|
||||
case BFD_ENDIAN_LITTLE:
|
||||
reg_offset = 0;
|
||||
@ -400,10 +402,10 @@ mips_xfer_register (struct regcache *regcache, int reg_num, int length,
|
||||
static int
|
||||
mips2_fp_compat (struct frame_info *frame)
|
||||
{
|
||||
struct gdbarch *gdbarch = get_frame_arch (frame);
|
||||
/* MIPS1 and MIPS2 have only 32 bit FPRs, and the FR bit is not
|
||||
meaningful. */
|
||||
if (register_size (current_gdbarch, mips_regnum (current_gdbarch)->fp0) ==
|
||||
4)
|
||||
if (register_size (gdbarch, mips_regnum (gdbarch)->fp0) == 4)
|
||||
return 0;
|
||||
|
||||
#if 0
|
||||
@ -549,17 +551,17 @@ mips_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
|
||||
int vector_p;
|
||||
int float_p;
|
||||
int raw_p;
|
||||
int rawnum = regnum % gdbarch_num_regs (current_gdbarch);
|
||||
int pseudo = regnum / gdbarch_num_regs (current_gdbarch);
|
||||
int rawnum = regnum % gdbarch_num_regs (gdbarch);
|
||||
int pseudo = regnum / gdbarch_num_regs (gdbarch);
|
||||
if (reggroup == all_reggroup)
|
||||
return pseudo;
|
||||
vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
|
||||
float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
|
||||
/* FIXME: cagney/2003-04-13: Can't yet use gdbarch_num_regs
|
||||
(gdbarch), as not all architectures are multi-arch. */
|
||||
raw_p = rawnum < gdbarch_num_regs (current_gdbarch);
|
||||
if (gdbarch_register_name (current_gdbarch, regnum) == NULL
|
||||
|| gdbarch_register_name (current_gdbarch, regnum)[0] == '\0')
|
||||
raw_p = rawnum < gdbarch_num_regs (gdbarch);
|
||||
if (gdbarch_register_name (gdbarch, regnum) == NULL
|
||||
|| gdbarch_register_name (gdbarch, regnum)[0] == '\0')
|
||||
return 0;
|
||||
if (reggroup == float_reggroup)
|
||||
return float_p && pseudo;
|
||||
@ -615,16 +617,16 @@ static void
|
||||
mips_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
|
||||
int cookednum, gdb_byte *buf)
|
||||
{
|
||||
int rawnum = cookednum % gdbarch_num_regs (current_gdbarch);
|
||||
gdb_assert (cookednum >= gdbarch_num_regs (current_gdbarch)
|
||||
&& cookednum < 2 * gdbarch_num_regs (current_gdbarch));
|
||||
int rawnum = cookednum % gdbarch_num_regs (gdbarch);
|
||||
gdb_assert (cookednum >= gdbarch_num_regs (gdbarch)
|
||||
&& cookednum < 2 * gdbarch_num_regs (gdbarch));
|
||||
if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
|
||||
regcache_raw_read (regcache, rawnum, buf);
|
||||
else if (register_size (gdbarch, rawnum) >
|
||||
register_size (gdbarch, cookednum))
|
||||
{
|
||||
if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
|
||||
|| gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
|
||||
|| gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
|
||||
regcache_raw_read_part (regcache, rawnum, 0, 4, buf);
|
||||
else
|
||||
regcache_raw_read_part (regcache, rawnum, 4, 4, buf);
|
||||
@ -638,16 +640,16 @@ mips_pseudo_register_write (struct gdbarch *gdbarch,
|
||||
struct regcache *regcache, int cookednum,
|
||||
const gdb_byte *buf)
|
||||
{
|
||||
int rawnum = cookednum % gdbarch_num_regs (current_gdbarch);
|
||||
gdb_assert (cookednum >= gdbarch_num_regs (current_gdbarch)
|
||||
&& cookednum < 2 * gdbarch_num_regs (current_gdbarch));
|
||||
int rawnum = cookednum % gdbarch_num_regs (gdbarch);
|
||||
gdb_assert (cookednum >= gdbarch_num_regs (gdbarch)
|
||||
&& cookednum < 2 * gdbarch_num_regs (gdbarch));
|
||||
if (register_size (gdbarch, rawnum) == register_size (gdbarch, cookednum))
|
||||
regcache_raw_write (regcache, rawnum, buf);
|
||||
else if (register_size (gdbarch, rawnum) >
|
||||
register_size (gdbarch, cookednum))
|
||||
{
|
||||
if (gdbarch_tdep (gdbarch)->mips64_transfers_32bit_regs_p
|
||||
|| gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
|
||||
|| gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
|
||||
regcache_raw_write_part (regcache, rawnum, 0, 4, buf);
|
||||
else
|
||||
regcache_raw_write_part (regcache, rawnum, 4, 4, buf);
|
||||
@ -723,11 +725,10 @@ mips_value_to_register (struct frame_info *frame, int regnum,
|
||||
static struct type *
|
||||
mips_register_type (struct gdbarch *gdbarch, int regnum)
|
||||
{
|
||||
gdb_assert (regnum >= 0 && regnum < 2 * gdbarch_num_regs (current_gdbarch));
|
||||
if ((regnum % gdbarch_num_regs (current_gdbarch))
|
||||
>= mips_regnum (current_gdbarch)->fp0
|
||||
&& (regnum % gdbarch_num_regs (current_gdbarch))
|
||||
< mips_regnum (current_gdbarch)->fp0 + 32)
|
||||
gdb_assert (regnum >= 0 && regnum < 2 * gdbarch_num_regs (gdbarch));
|
||||
if ((regnum % gdbarch_num_regs (gdbarch)) >= mips_regnum (gdbarch)->fp0
|
||||
&& (regnum % gdbarch_num_regs (gdbarch))
|
||||
< mips_regnum (gdbarch)->fp0 + 32)
|
||||
{
|
||||
/* The floating-point registers raw, or cooked, always match
|
||||
mips_isa_regsize(), and also map 1:1, byte for byte. */
|
||||
@ -736,7 +737,7 @@ mips_register_type (struct gdbarch *gdbarch, int regnum)
|
||||
else
|
||||
return builtin_type_ieee_double;
|
||||
}
|
||||
else if (regnum < gdbarch_num_regs (current_gdbarch))
|
||||
else if (regnum < gdbarch_num_regs (gdbarch))
|
||||
{
|
||||
/* The raw or ISA registers. These are all sized according to
|
||||
the ISA regsize. */
|
||||
@ -749,10 +750,9 @@ mips_register_type (struct gdbarch *gdbarch, int regnum)
|
||||
{
|
||||
/* The cooked or ABI registers. These are sized according to
|
||||
the ABI (with a few complications). */
|
||||
if (regnum >= (gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp_control_status)
|
||||
&& regnum <= gdbarch_num_regs (current_gdbarch)
|
||||
+ MIPS_LAST_EMBED_REGNUM)
|
||||
if (regnum >= (gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp_control_status)
|
||||
&& regnum <= gdbarch_num_regs (gdbarch) + MIPS_LAST_EMBED_REGNUM)
|
||||
/* The pseudo/cooked view of the embedded registers is always
|
||||
32-bit. The raw view is handled below. */
|
||||
return builtin_type_int32;
|
||||
@ -908,17 +908,15 @@ mips_read_pc (struct regcache *regcache)
|
||||
static CORE_ADDR
|
||||
mips_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||||
{
|
||||
return frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (gdbarch)->pc);
|
||||
return frame_unwind_register_signed
|
||||
(next_frame, gdbarch_num_regs (gdbarch) + mips_regnum (gdbarch)->pc);
|
||||
}
|
||||
|
||||
static CORE_ADDR
|
||||
mips_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||||
{
|
||||
return frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ MIPS_SP_REGNUM);
|
||||
return frame_unwind_register_signed
|
||||
(next_frame, gdbarch_num_regs (gdbarch) + MIPS_SP_REGNUM);
|
||||
}
|
||||
|
||||
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
|
||||
@ -931,7 +929,7 @@ mips_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
|
||||
{
|
||||
return frame_id_build
|
||||
(frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ MIPS_SP_REGNUM),
|
||||
frame_pc_unwind (next_frame));
|
||||
}
|
||||
@ -1023,7 +1021,8 @@ mips32_next_pc (struct frame_info *frame, CORE_ADDR pc)
|
||||
int tf = itype_rt (inst) & 0x01;
|
||||
int cnum = itype_rt (inst) >> 2;
|
||||
int fcrcs =
|
||||
get_frame_register_signed (frame, mips_regnum (current_gdbarch)->
|
||||
get_frame_register_signed (frame,
|
||||
mips_regnum (get_frame_arch (frame))->
|
||||
fp_control_status);
|
||||
int cond = ((fcrcs >> 24) & 0x0e) | ((fcrcs >> 23) & 0x01);
|
||||
|
||||
@ -1538,12 +1537,13 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
|
||||
int extend_bytes = 0;
|
||||
int prev_extend_bytes;
|
||||
CORE_ADDR end_prologue_addr = 0;
|
||||
struct gdbarch *gdbarch = get_frame_arch (next_frame);
|
||||
|
||||
/* Can be called when there's no process, and hence when there's no
|
||||
NEXT_FRAME. */
|
||||
if (next_frame != NULL)
|
||||
sp = frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ MIPS_SP_REGNUM);
|
||||
else
|
||||
sp = 0;
|
||||
@ -1674,7 +1674,7 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
|
||||
for (reg = 4, offset = 0; reg < areg_count + 4; reg++)
|
||||
{
|
||||
set_reg_offset (this_cache, reg, sp + offset);
|
||||
offset += mips_abi_regsize (current_gdbarch);
|
||||
offset += mips_abi_regsize (gdbarch);
|
||||
}
|
||||
|
||||
/* Check if the ra register was pushed on the stack. */
|
||||
@ -1682,14 +1682,14 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
|
||||
if (entry_inst & 0x20)
|
||||
{
|
||||
set_reg_offset (this_cache, MIPS_RA_REGNUM, sp + offset);
|
||||
offset -= mips_abi_regsize (current_gdbarch);
|
||||
offset -= mips_abi_regsize (gdbarch);
|
||||
}
|
||||
|
||||
/* Check if the s0 and s1 registers were pushed on the stack. */
|
||||
for (reg = 16; reg < sreg_count + 16; reg++)
|
||||
{
|
||||
set_reg_offset (this_cache, reg, sp + offset);
|
||||
offset -= mips_abi_regsize (current_gdbarch);
|
||||
offset -= mips_abi_regsize (gdbarch);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1697,16 +1697,14 @@ mips16_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
|
||||
{
|
||||
this_cache->base =
|
||||
(frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ frame_reg)
|
||||
gdbarch_num_regs (gdbarch) + frame_reg)
|
||||
+ frame_offset - frame_adjust);
|
||||
/* FIXME: brobecker/2004-10-10: Just as in the mips32 case, we should
|
||||
be able to get rid of the assignment below, evetually. But it's
|
||||
still needed for now. */
|
||||
this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->pc]
|
||||
= this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
|
||||
+ MIPS_RA_REGNUM];
|
||||
this_cache->saved_regs[gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->pc]
|
||||
= this_cache->saved_regs[gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM];
|
||||
}
|
||||
|
||||
/* If we didn't reach the end of the prologue when scanning the function
|
||||
@ -1751,8 +1749,10 @@ mips_insn16_frame_cache (struct frame_info *next_frame, void **this_cache)
|
||||
}
|
||||
|
||||
/* gdbarch_sp_regnum contains the value and not the address. */
|
||||
trad_frame_set_value (cache->saved_regs, gdbarch_num_regs (current_gdbarch)
|
||||
+ MIPS_SP_REGNUM, cache->base);
|
||||
trad_frame_set_value (cache->saved_regs,
|
||||
gdbarch_num_regs (get_frame_arch (next_frame))
|
||||
+ MIPS_SP_REGNUM,
|
||||
cache->base);
|
||||
|
||||
return (*this_cache);
|
||||
}
|
||||
@ -1860,12 +1860,13 @@ mips32_scan_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
|
||||
CORE_ADDR end_prologue_addr = 0;
|
||||
int seen_sp_adjust = 0;
|
||||
int load_immediate_bytes = 0;
|
||||
struct gdbarch *gdbarch = get_frame_arch (next_frame);
|
||||
|
||||
/* Can be called when there's no process, and hence when there's no
|
||||
NEXT_FRAME. */
|
||||
if (next_frame != NULL)
|
||||
sp = frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ MIPS_SP_REGNUM);
|
||||
else
|
||||
sp = 0;
|
||||
@ -1922,8 +1923,7 @@ restart:
|
||||
|
||||
frame_reg = 30;
|
||||
frame_addr = frame_unwind_register_signed
|
||||
(next_frame,
|
||||
gdbarch_num_regs (current_gdbarch) + 30);
|
||||
(next_frame, gdbarch_num_regs (gdbarch) + 30);
|
||||
|
||||
alloca_adjust = (unsigned) (frame_addr - (sp + low_word));
|
||||
if (alloca_adjust > 0)
|
||||
@ -1953,8 +1953,7 @@ restart:
|
||||
|
||||
frame_reg = 30;
|
||||
frame_addr = frame_unwind_register_signed
|
||||
(next_frame,
|
||||
gdbarch_num_regs (current_gdbarch) + 30);
|
||||
(next_frame, gdbarch_num_regs (gdbarch) + 30);
|
||||
|
||||
alloca_adjust = (unsigned) (frame_addr - sp);
|
||||
if (alloca_adjust > 0)
|
||||
@ -2021,15 +2020,14 @@ restart:
|
||||
{
|
||||
this_cache->base =
|
||||
(frame_unwind_register_signed (next_frame,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ frame_reg)
|
||||
gdbarch_num_regs (gdbarch) + frame_reg)
|
||||
+ frame_offset);
|
||||
/* FIXME: brobecker/2004-09-15: We should be able to get rid of
|
||||
this assignment below, eventually. But it's still needed
|
||||
for now. */
|
||||
this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->pc]
|
||||
= this_cache->saved_regs[gdbarch_num_regs (current_gdbarch)
|
||||
this_cache->saved_regs[gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->pc]
|
||||
= this_cache->saved_regs[gdbarch_num_regs (gdbarch)
|
||||
+ MIPS_RA_REGNUM];
|
||||
}
|
||||
|
||||
@ -2087,7 +2085,8 @@ mips_insn32_frame_cache (struct frame_info *next_frame, void **this_cache)
|
||||
|
||||
/* gdbarch_sp_regnum contains the value and not the address. */
|
||||
trad_frame_set_value (cache->saved_regs,
|
||||
gdbarch_num_regs (current_gdbarch) + MIPS_SP_REGNUM,
|
||||
gdbarch_num_regs (get_frame_arch (next_frame))
|
||||
+ MIPS_SP_REGNUM,
|
||||
cache->base);
|
||||
|
||||
return (*this_cache);
|
||||
@ -2165,6 +2164,7 @@ mips_stub_frame_cache (struct frame_info *next_frame, void **this_cache)
|
||||
CORE_ADDR start_addr;
|
||||
CORE_ADDR stack_addr;
|
||||
struct trad_frame_cache *this_trad_cache;
|
||||
struct gdbarch *gdbarch = get_frame_arch (next_frame);
|
||||
|
||||
if ((*this_cache) != NULL)
|
||||
return (*this_cache);
|
||||
@ -2173,9 +2173,8 @@ mips_stub_frame_cache (struct frame_info *next_frame, void **this_cache)
|
||||
|
||||
/* The return address is in the link register. */
|
||||
trad_frame_set_reg_realreg (this_trad_cache,
|
||||
gdbarch_pc_regnum (current_gdbarch),
|
||||
(gdbarch_num_regs (current_gdbarch)
|
||||
+ MIPS_RA_REGNUM));
|
||||
gdbarch_pc_regnum (gdbarch),
|
||||
(gdbarch_num_regs (gdbarch) + MIPS_RA_REGNUM));
|
||||
|
||||
/* Frame ID, since it's a frameless / stackless function, no stack
|
||||
space is allocated and SP on entry is the current SP. */
|
||||
@ -2550,7 +2549,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
|
||||
/* Initialize the integer and float register pointers. */
|
||||
argreg = MIPS_A0_REGNUM;
|
||||
float_argreg = mips_fpa0_regnum (current_gdbarch);
|
||||
float_argreg = mips_fpa0_regnum (gdbarch);
|
||||
|
||||
/* The struct_return pointer occupies the first parameter-passing reg. */
|
||||
if (struct_return)
|
||||
@ -2627,7 +2626,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
making the ABI determination. */
|
||||
if (len == 8 && mips_abi (gdbarch) == MIPS_ABI_EABI32)
|
||||
{
|
||||
int low_offset = gdbarch_byte_order (current_gdbarch)
|
||||
int low_offset = gdbarch_byte_order (gdbarch)
|
||||
== BFD_ENDIAN_BIG ? 4 : 0;
|
||||
unsigned long regval;
|
||||
|
||||
@ -2692,7 +2691,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
int longword_offset = 0;
|
||||
CORE_ADDR addr;
|
||||
stack_used_p = 1;
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
{
|
||||
if (regsize == 8
|
||||
&& (typecode == TYPE_CODE_INT
|
||||
@ -2884,7 +2883,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
|
||||
/* Initialize the integer and float register pointers. */
|
||||
argreg = MIPS_A0_REGNUM;
|
||||
float_argreg = mips_fpa0_regnum (current_gdbarch);
|
||||
float_argreg = mips_fpa0_regnum (gdbarch);
|
||||
|
||||
/* The struct_return pointer occupies the first parameter-passing reg. */
|
||||
if (struct_return)
|
||||
@ -2968,7 +2967,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
int longword_offset = 0;
|
||||
CORE_ADDR addr;
|
||||
stack_used_p = 1;
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
{
|
||||
if ((typecode == TYPE_CODE_INT
|
||||
|| typecode == TYPE_CODE_PTR
|
||||
@ -3019,7 +3018,7 @@ mips_n32n64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
It does not seem to be necessary to do the
|
||||
same for integral types. */
|
||||
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
|
||||
&& partial_len < MIPS64_REGSIZE
|
||||
&& (typecode == TYPE_CODE_STRUCT
|
||||
|| typecode == TYPE_CODE_UNION))
|
||||
@ -3075,7 +3074,7 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
struct type *type, struct regcache *regcache,
|
||||
gdb_byte *readbuf, const gdb_byte *writebuf)
|
||||
{
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||||
|
||||
/* From MIPSpro N32 ABI Handbook, Document Number: 007-2816-004
|
||||
|
||||
@ -3112,14 +3111,14 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float in $f0 and $f2\n");
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0,
|
||||
8, gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0,
|
||||
8, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 0);
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0 + 2,
|
||||
8, gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0 + 2,
|
||||
8, gdbarch_byte_order (gdbarch),
|
||||
readbuf ? readbuf + 8 : readbuf,
|
||||
writebuf ? writebuf + 8 : writebuf, 0);
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
@ -3131,10 +3130,10 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0,
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0,
|
||||
TYPE_LENGTH (type),
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 0);
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
}
|
||||
@ -3156,7 +3155,7 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
register.. */
|
||||
int regnum;
|
||||
int field;
|
||||
for (field = 0, regnum = mips_regnum (current_gdbarch)->fp0;
|
||||
for (field = 0, regnum = mips_regnum (gdbarch)->fp0;
|
||||
field < TYPE_NFIELDS (type); field++, regnum += 2)
|
||||
{
|
||||
int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
|
||||
@ -3164,10 +3163,10 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
|
||||
offset);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch)
|
||||
+ regnum,
|
||||
TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, offset);
|
||||
}
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
@ -3182,17 +3181,17 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
int regnum;
|
||||
for (offset = 0, regnum = MIPS_V0_REGNUM;
|
||||
offset < TYPE_LENGTH (type);
|
||||
offset += register_size (current_gdbarch, regnum), regnum++)
|
||||
offset += register_size (gdbarch, regnum), regnum++)
|
||||
{
|
||||
int xfer = register_size (current_gdbarch, regnum);
|
||||
int xfer = register_size (gdbarch, regnum);
|
||||
if (offset + xfer > TYPE_LENGTH (type))
|
||||
xfer = TYPE_LENGTH (type) - offset;
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
|
||||
offset, xfer, regnum);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
+ regnum, xfer,
|
||||
BFD_ENDIAN_UNKNOWN, readbuf, writebuf, offset);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch) + regnum,
|
||||
xfer, BFD_ENDIAN_UNKNOWN, readbuf, writebuf,
|
||||
offset);
|
||||
}
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
}
|
||||
@ -3204,17 +3203,16 @@ mips_n32n64_return_value (struct gdbarch *gdbarch,
|
||||
int regnum;
|
||||
for (offset = 0, regnum = MIPS_V0_REGNUM;
|
||||
offset < TYPE_LENGTH (type);
|
||||
offset += register_size (current_gdbarch, regnum), regnum++)
|
||||
offset += register_size (gdbarch, regnum), regnum++)
|
||||
{
|
||||
int xfer = register_size (current_gdbarch, regnum);
|
||||
int xfer = register_size (gdbarch, regnum);
|
||||
if (offset + xfer > TYPE_LENGTH (type))
|
||||
xfer = TYPE_LENGTH (type) - offset;
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
|
||||
offset, xfer, regnum);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
+ regnum, xfer,
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch) + regnum,
|
||||
xfer, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, offset);
|
||||
}
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
@ -3275,7 +3273,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
|
||||
/* Initialize the integer and float register pointers. */
|
||||
argreg = MIPS_A0_REGNUM;
|
||||
float_argreg = mips_fpa0_regnum (current_gdbarch);
|
||||
float_argreg = mips_fpa0_regnum (gdbarch);
|
||||
|
||||
/* The struct_return pointer occupies the first parameter-passing reg. */
|
||||
if (struct_return)
|
||||
@ -3332,7 +3330,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
{
|
||||
if (register_size (gdbarch, float_argreg) < 8 && len == 8)
|
||||
{
|
||||
int low_offset = gdbarch_byte_order (current_gdbarch)
|
||||
int low_offset = gdbarch_byte_order (gdbarch)
|
||||
== BFD_ENDIAN_BIG ? 4 : 0;
|
||||
unsigned long regval;
|
||||
|
||||
@ -3484,7 +3482,7 @@ mips_o32_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
identified as such and GDB gets tweaked
|
||||
accordingly. */
|
||||
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
|
||||
&& partial_len < MIPS32_REGSIZE
|
||||
&& (typecode == TYPE_CODE_STRUCT
|
||||
|| typecode == TYPE_CODE_UNION))
|
||||
@ -3532,7 +3530,7 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
struct regcache *regcache,
|
||||
gdb_byte *readbuf, const gdb_byte *writebuf)
|
||||
{
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||||
|
||||
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
|
||||
|| TYPE_CODE (type) == TYPE_CODE_UNION
|
||||
@ -3546,10 +3544,10 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0,
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0,
|
||||
TYPE_LENGTH (type),
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 0);
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
}
|
||||
@ -3561,30 +3559,30 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
FP0. */
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float in $fp1/$fp0\n");
|
||||
switch (gdbarch_byte_order (current_gdbarch))
|
||||
switch (gdbarch_byte_order (gdbarch))
|
||||
{
|
||||
case BFD_ENDIAN_LITTLE:
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0 +
|
||||
0, 4, gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0 +
|
||||
0, 4, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 0);
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0 + 1,
|
||||
4, gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0 + 1,
|
||||
4, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 4);
|
||||
break;
|
||||
case BFD_ENDIAN_BIG:
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0 + 1,
|
||||
4, gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0 + 1,
|
||||
4, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 0);
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0 + 0,
|
||||
4, gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0 + 0,
|
||||
4, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 4);
|
||||
break;
|
||||
default:
|
||||
@ -3612,7 +3610,7 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
gdb_byte reg[MAX_REGISTER_SIZE];
|
||||
int regnum;
|
||||
int field;
|
||||
for (field = 0, regnum = mips_regnum (current_gdbarch)->fp0;
|
||||
for (field = 0, regnum = mips_regnum (gdbarch)->fp0;
|
||||
field < TYPE_NFIELDS (type); field++, regnum += 2)
|
||||
{
|
||||
int offset = (FIELD_BITPOS (TYPE_FIELDS (type)[field])
|
||||
@ -3620,10 +3618,10 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float struct+%d\n",
|
||||
offset);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch)
|
||||
+ regnum,
|
||||
TYPE_LENGTH (TYPE_FIELD_TYPE (type, field)),
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, offset);
|
||||
}
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
@ -3640,15 +3638,15 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
int regnum;
|
||||
for (offset = 0, regnum = MIPS_V0_REGNUM;
|
||||
offset < TYPE_LENGTH (type);
|
||||
offset += register_size (current_gdbarch, regnum), regnum++)
|
||||
offset += register_size (gdbarch, regnum), regnum++)
|
||||
{
|
||||
int xfer = register_size (current_gdbarch, regnum);
|
||||
int xfer = register_size (gdbarch, regnum);
|
||||
if (offset + xfer > TYPE_LENGTH (type))
|
||||
xfer = TYPE_LENGTH (type) - offset;
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return struct+%d:%d in $%d\n",
|
||||
offset, xfer, regnum);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch)
|
||||
+ regnum, xfer,
|
||||
BFD_ENDIAN_UNKNOWN, readbuf, writebuf, offset);
|
||||
}
|
||||
@ -3672,9 +3670,9 @@ mips_o32_return_value (struct gdbarch *gdbarch, struct type *type,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
|
||||
offset, xfer, regnum);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch)
|
||||
+ regnum, xfer,
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, offset);
|
||||
}
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
@ -3734,7 +3732,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
|
||||
/* Initialize the integer and float register pointers. */
|
||||
argreg = MIPS_A0_REGNUM;
|
||||
float_argreg = mips_fpa0_regnum (current_gdbarch);
|
||||
float_argreg = mips_fpa0_regnum (gdbarch);
|
||||
|
||||
/* The struct_return pointer occupies the first parameter-passing reg. */
|
||||
if (struct_return)
|
||||
@ -3821,7 +3819,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
int longword_offset = 0;
|
||||
CORE_ADDR addr;
|
||||
stack_used_p = 1;
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
{
|
||||
if ((typecode == TYPE_CODE_INT
|
||||
|| typecode == TYPE_CODE_PTR
|
||||
@ -3873,7 +3871,7 @@ mips_o64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|
||||
It does not seem to be necessary to do the
|
||||
same for integral types. */
|
||||
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
|
||||
&& partial_len < MIPS64_REGSIZE
|
||||
&& (typecode == TYPE_CODE_STRUCT
|
||||
|| typecode == TYPE_CODE_UNION))
|
||||
@ -3921,7 +3919,7 @@ mips_o64_return_value (struct gdbarch *gdbarch,
|
||||
struct type *type, struct regcache *regcache,
|
||||
gdb_byte *readbuf, const gdb_byte *writebuf)
|
||||
{
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||||
|
||||
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
|
||||
|| TYPE_CODE (type) == TYPE_CODE_UNION
|
||||
@ -3934,10 +3932,10 @@ mips_o64_return_value (struct gdbarch *gdbarch,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return float in $fp0\n");
|
||||
mips_xfer_register (regcache,
|
||||
gdbarch_num_regs (current_gdbarch)
|
||||
+ mips_regnum (current_gdbarch)->fp0,
|
||||
gdbarch_num_regs (gdbarch)
|
||||
+ mips_regnum (gdbarch)->fp0,
|
||||
TYPE_LENGTH (type),
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, 0);
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
}
|
||||
@ -3957,9 +3955,8 @@ mips_o64_return_value (struct gdbarch *gdbarch,
|
||||
if (mips_debug)
|
||||
fprintf_unfiltered (gdb_stderr, "Return scalar+%d:%d in $%d\n",
|
||||
offset, xfer, regnum);
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (current_gdbarch)
|
||||
+ regnum, xfer,
|
||||
gdbarch_byte_order (current_gdbarch),
|
||||
mips_xfer_register (regcache, gdbarch_num_regs (gdbarch) + regnum,
|
||||
xfer, gdbarch_byte_order (gdbarch),
|
||||
readbuf, writebuf, offset);
|
||||
}
|
||||
return RETURN_VALUE_REGISTER_CONVENTION;
|
||||
@ -4015,19 +4012,20 @@ static void
|
||||
mips_read_fp_register_single (struct frame_info *frame, int regno,
|
||||
gdb_byte *rare_buffer)
|
||||
{
|
||||
int raw_size = register_size (current_gdbarch, regno);
|
||||
struct gdbarch *gdbarch = get_frame_arch (frame);
|
||||
int raw_size = register_size (gdbarch, regno);
|
||||
gdb_byte *raw_buffer = alloca (raw_size);
|
||||
|
||||
if (!frame_register_read (frame, regno, raw_buffer))
|
||||
error (_("can't read register %d (%s)"),
|
||||
regno, gdbarch_register_name (current_gdbarch, regno));
|
||||
regno, gdbarch_register_name (gdbarch, regno));
|
||||
if (raw_size == 8)
|
||||
{
|
||||
/* We have a 64-bit value for this register. Find the low-order
|
||||
32 bits. */
|
||||
int offset;
|
||||
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
offset = 4;
|
||||
else
|
||||
offset = 0;
|
||||
@ -4048,7 +4046,8 @@ static void
|
||||
mips_read_fp_register_double (struct frame_info *frame, int regno,
|
||||
gdb_byte *rare_buffer)
|
||||
{
|
||||
int raw_size = register_size (current_gdbarch, regno);
|
||||
struct gdbarch *gdbarch = get_frame_arch (frame);
|
||||
int raw_size = register_size (gdbarch, regno);
|
||||
|
||||
if (raw_size == 8 && !mips2_fp_compat (frame))
|
||||
{
|
||||
@ -4056,20 +4055,20 @@ mips_read_fp_register_double (struct frame_info *frame, int regno,
|
||||
all 64 bits. */
|
||||
if (!frame_register_read (frame, regno, rare_buffer))
|
||||
error (_("can't read register %d (%s)"),
|
||||
regno, gdbarch_register_name (current_gdbarch, regno));
|
||||
regno, gdbarch_register_name (gdbarch, regno));
|
||||
}
|
||||
else
|
||||
{
|
||||
int rawnum = regno % gdbarch_num_regs (current_gdbarch);
|
||||
int rawnum = regno % gdbarch_num_regs (gdbarch);
|
||||
|
||||
if ((rawnum - mips_regnum (current_gdbarch)->fp0) & 1)
|
||||
if ((rawnum - mips_regnum (gdbarch)->fp0) & 1)
|
||||
internal_error (__FILE__, __LINE__,
|
||||
_("mips_read_fp_register_double: bad access to "
|
||||
"odd-numbered FP register"));
|
||||
|
||||
/* mips_read_fp_register_single will find the correct 32 bits from
|
||||
each register. */
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
{
|
||||
mips_read_fp_register_single (frame, regno, rare_buffer + 4);
|
||||
mips_read_fp_register_single (frame, regno + 1, rare_buffer);
|
||||
@ -4086,21 +4085,19 @@ static void
|
||||
mips_print_fp_register (struct ui_file *file, struct frame_info *frame,
|
||||
int regnum)
|
||||
{ /* do values for FP (float) regs */
|
||||
struct gdbarch *gdbarch = get_frame_arch (frame);
|
||||
gdb_byte *raw_buffer;
|
||||
double doub, flt1; /* doubles extracted from raw hex data */
|
||||
int inv1, inv2;
|
||||
|
||||
raw_buffer = alloca (2 * register_size (current_gdbarch,
|
||||
mips_regnum (current_gdbarch)->fp0));
|
||||
raw_buffer = alloca (2 * register_size (gdbarch, mips_regnum (gdbarch)->fp0));
|
||||
|
||||
fprintf_filtered (file, "%s:",
|
||||
gdbarch_register_name (current_gdbarch, regnum));
|
||||
fprintf_filtered (file, "%s:", gdbarch_register_name (gdbarch, regnum));
|
||||
fprintf_filtered (file, "%*s",
|
||||
4 - (int) strlen (gdbarch_register_name
|
||||
(current_gdbarch, regnum)),
|
||||
4 - (int) strlen (gdbarch_register_name (gdbarch, regnum)),
|
||||
"");
|
||||
|
||||
if (register_size (current_gdbarch, regnum) == 4 || mips2_fp_compat (frame))
|
||||
if (register_size (gdbarch, regnum) == 4 || mips2_fp_compat (frame))
|
||||
{
|
||||
/* 4-byte registers: Print hex and floating. Also print even
|
||||
numbered registers as doubles. */
|
||||
@ -4116,7 +4113,7 @@ mips_print_fp_register (struct ui_file *file, struct frame_info *frame,
|
||||
else
|
||||
fprintf_filtered (file, "%-17.9g", flt1);
|
||||
|
||||
if ((regnum - gdbarch_num_regs (current_gdbarch)) % 2 == 0)
|
||||
if ((regnum - gdbarch_num_regs (gdbarch)) % 2 == 0)
|
||||
{
|
||||
mips_read_fp_register_double (frame, regnum, raw_buffer);
|
||||
doub = unpack_double (mips_double_register_type (), raw_buffer,
|
||||
@ -4174,11 +4171,11 @@ mips_print_register (struct ui_file *file, struct frame_info *frame,
|
||||
if (!frame_register_read (frame, regnum, raw_buffer))
|
||||
{
|
||||
fprintf_filtered (file, "%s: [Invalid]",
|
||||
gdbarch_register_name (current_gdbarch, regnum));
|
||||
gdbarch_register_name (gdbarch, regnum));
|
||||
return;
|
||||
}
|
||||
|
||||
fputs_filtered (gdbarch_register_name (current_gdbarch, regnum), file);
|
||||
fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
|
||||
|
||||
/* The problem with printing numeric register names (r26, etc.) is that
|
||||
the user can't use them on input. Probably the best solution is to
|
||||
@ -4189,10 +4186,9 @@ mips_print_register (struct ui_file *file, struct frame_info *frame,
|
||||
else
|
||||
fprintf_filtered (file, ": ");
|
||||
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
offset =
|
||||
register_size (current_gdbarch,
|
||||
regnum) - register_size (current_gdbarch, regnum);
|
||||
register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
|
||||
else
|
||||
offset = 0;
|
||||
|
||||
@ -4230,18 +4226,17 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
|
||||
|
||||
/* For GP registers, we print a separate row of names above the vals */
|
||||
for (col = 0, regnum = start_regnum;
|
||||
col < ncols && regnum < gdbarch_num_regs (current_gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (current_gdbarch);
|
||||
col < ncols && regnum < gdbarch_num_regs (gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (gdbarch);
|
||||
regnum++)
|
||||
{
|
||||
if (*gdbarch_register_name (current_gdbarch, regnum) == '\0')
|
||||
if (*gdbarch_register_name (gdbarch, regnum) == '\0')
|
||||
continue; /* unused register */
|
||||
if (TYPE_CODE (register_type (gdbarch, regnum)) ==
|
||||
TYPE_CODE_FLT)
|
||||
break; /* end the row: reached FP register */
|
||||
/* Large registers are handled separately. */
|
||||
if (register_size (current_gdbarch, regnum)
|
||||
> mips_abi_regsize (current_gdbarch))
|
||||
if (register_size (gdbarch, regnum) > mips_abi_regsize (gdbarch))
|
||||
{
|
||||
if (col > 0)
|
||||
break; /* End the row before this register. */
|
||||
@ -4254,8 +4249,8 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
|
||||
if (col == 0)
|
||||
fprintf_filtered (file, " ");
|
||||
fprintf_filtered (file,
|
||||
mips_abi_regsize (current_gdbarch) == 8 ? "%17s" : "%9s",
|
||||
gdbarch_register_name (current_gdbarch, regnum));
|
||||
mips_abi_regsize (gdbarch) == 8 ? "%17s" : "%9s",
|
||||
gdbarch_register_name (gdbarch, regnum));
|
||||
col++;
|
||||
}
|
||||
|
||||
@ -4263,45 +4258,43 @@ print_gp_register_row (struct ui_file *file, struct frame_info *frame,
|
||||
return regnum;
|
||||
|
||||
/* print the R0 to R31 names */
|
||||
if ((start_regnum % gdbarch_num_regs (current_gdbarch)) < MIPS_NUMREGS)
|
||||
if ((start_regnum % gdbarch_num_regs (gdbarch)) < MIPS_NUMREGS)
|
||||
fprintf_filtered (file, "\n R%-4d",
|
||||
start_regnum % gdbarch_num_regs (current_gdbarch));
|
||||
start_regnum % gdbarch_num_regs (gdbarch));
|
||||
else
|
||||
fprintf_filtered (file, "\n ");
|
||||
|
||||
/* now print the values in hex, 4 or 8 to the row */
|
||||
for (col = 0, regnum = start_regnum;
|
||||
col < ncols && regnum < gdbarch_num_regs (current_gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (current_gdbarch);
|
||||
col < ncols && regnum < gdbarch_num_regs (gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (gdbarch);
|
||||
regnum++)
|
||||
{
|
||||
if (*gdbarch_register_name (current_gdbarch, regnum) == '\0')
|
||||
if (*gdbarch_register_name (gdbarch, regnum) == '\0')
|
||||
continue; /* unused register */
|
||||
if (TYPE_CODE (register_type (gdbarch, regnum)) ==
|
||||
TYPE_CODE_FLT)
|
||||
break; /* end row: reached FP register */
|
||||
if (register_size (current_gdbarch, regnum)
|
||||
> mips_abi_regsize (current_gdbarch))
|
||||
if (register_size (gdbarch, regnum) > mips_abi_regsize (gdbarch))
|
||||
break; /* End row: large register. */
|
||||
|
||||
/* OK: get the data in raw format. */
|
||||
if (!frame_register_read (frame, regnum, raw_buffer))
|
||||
error (_("can't read register %d (%s)"),
|
||||
regnum, gdbarch_register_name (current_gdbarch, regnum));
|
||||
regnum, gdbarch_register_name (gdbarch, regnum));
|
||||
/* pad small registers */
|
||||
for (byte = 0;
|
||||
byte < (mips_abi_regsize (current_gdbarch)
|
||||
- register_size (current_gdbarch, regnum)); byte++)
|
||||
byte < (mips_abi_regsize (gdbarch)
|
||||
- register_size (gdbarch, regnum)); byte++)
|
||||
printf_filtered (" ");
|
||||
/* Now print the register value in hex, endian order. */
|
||||
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
|
||||
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
|
||||
for (byte =
|
||||
register_size (current_gdbarch,
|
||||
regnum) - register_size (current_gdbarch, regnum);
|
||||
byte < register_size (current_gdbarch, regnum); byte++)
|
||||
register_size (gdbarch, regnum) - register_size (gdbarch, regnum);
|
||||
byte < register_size (gdbarch, regnum); byte++)
|
||||
fprintf_filtered (file, "%02x", raw_buffer[byte]);
|
||||
else
|
||||
for (byte = register_size (current_gdbarch, regnum) - 1;
|
||||
for (byte = register_size (gdbarch, regnum) - 1;
|
||||
byte >= 0; byte--)
|
||||
fprintf_filtered (file, "%02x", raw_buffer[byte]);
|
||||
fprintf_filtered (file, " ");
|
||||
@ -4321,8 +4314,8 @@ mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
|
||||
{
|
||||
if (regnum != -1) /* do one specified register */
|
||||
{
|
||||
gdb_assert (regnum >= gdbarch_num_regs (current_gdbarch));
|
||||
if (*(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
|
||||
gdb_assert (regnum >= gdbarch_num_regs (gdbarch));
|
||||
if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
|
||||
error (_("Not a valid register for the current processor type"));
|
||||
|
||||
mips_print_register (file, frame, regnum);
|
||||
@ -4331,9 +4324,9 @@ mips_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
|
||||
else
|
||||
/* do all (or most) registers */
|
||||
{
|
||||
regnum = gdbarch_num_regs (current_gdbarch);
|
||||
while (regnum < gdbarch_num_regs (current_gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (current_gdbarch))
|
||||
regnum = gdbarch_num_regs (gdbarch);
|
||||
while (regnum < gdbarch_num_regs (gdbarch)
|
||||
+ gdbarch_num_pseudo_regs (gdbarch))
|
||||
{
|
||||
if (TYPE_CODE (register_type (gdbarch, regnum)) ==
|
||||
TYPE_CODE_FLT)
|
||||
@ -5739,9 +5732,9 @@ show_mips_abi (struct ui_file *file,
|
||||
}
|
||||
|
||||
static void
|
||||
mips_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
|
||||
mips_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
|
||||
{
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
|
||||
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
|
||||
if (tdep != NULL)
|
||||
{
|
||||
int ef_mips_arch;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user