FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2007-10-10 Markus Deuling <deuling@de.ibm.com>

Browse source 
* 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 2007-10-10 17:03:36 +00:00
parent 6b50c0b03a
commit 72a155b44d
2 changed files with 190 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

19
gdb/ChangeLog
View file

@ -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> 2007-10-10 Markus Deuling <deuling@de.ibm.com>
* xtensa-tdep.c (xtensa_register_type, xtensa_pseudo_register_read) * xtensa-tdep.c (xtensa_register_type, xtensa_pseudo_register_read)

349
gdb/mips-tdep.c
View file

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