yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
* remote-mips.c (mips_wait, mips_fetch_registers)
	(mips_store_registers): Use get_regcache_arch to get at the
	current architecture by regcache.

	* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg)
	(mipsnbsd_supply_fpreg, mipsnbsd_fill_fpreg): Use get_regcache_arch to
	get at the current architecture by regcache.
	(mipsnbsd_sigtramp_offset): Use get_frame_arch to get at the current
	architecture by frame_info.

	* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
	(mipsnbsd_store_inferior_registers): Use get_regcache_arch to get at
	the current architecture by regcache.

	* mips-linux-tdep.c (mips_linux_get_longjmp_target)
	(mips64_linux_get_longjmp_target, mips_linux_o32_sigframe_init)
	(mips_linux_n32n64_sigframe_init): Use get_frame_arch to get at the
	current architecture by frame_info.
	(supply_32bit_reg, mips_supply_gregset, mips_fill_gregset)
	(mips_supply_fpregset, mips_fill_fpregset, supply_64bit_reg)
	(mips64_supply_gregset, mips64_fill_gregset, mips64_supply_fpregset)
	(mips64_fill_fpregset, mips_linux_write_pc): Use get_regcache_arch to
	get at the current architecture by regcache.

	* mips-linux-nat.c (mips_linux_register_addr)
	(mips64_linux_register_addr): Replace current_gdbarch by gdbarch.
	(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset)
	(mips64_linux_regsets_fetch_registers)
	(mips64_linux_regsets_store_registers): Use get_regcache_arch to get at
	the current architecture by regcache.

	* mips64obsd-tdep.c (mips64obsd_sigframe_init): Use get_frame_arch to
	get at the current architecture by frame_info.
This commit is contained in:
Ulrich Weigand 2007-10-10 17:04:38 +00:00
parent 72a155b44d
commit 2eb4d78bfd
7 changed files with 214 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
gdb/ChangeLog
View File

@ -1,3 +1,39 @@
2007-10-10 Markus Deuling <deuling@de.ibm.com>
* remote-mips.c (mips_wait, mips_fetch_registers)
(mips_store_registers): Use get_regcache_arch to get at the
current architecture by regcache.
* mipsnbsd-tdep.c (mipsnbsd_supply_reg, mipsnbsd_fill_reg)
(mipsnbsd_supply_fpreg, mipsnbsd_fill_fpreg): Use get_regcache_arch to
get at the current architecture by regcache.
(mipsnbsd_sigtramp_offset): Use get_frame_arch to get at the current
architecture by frame_info.
* mipsnbsd-nat.c (mipsnbsd_fetch_inferior_registers)
(mipsnbsd_store_inferior_registers): Use get_regcache_arch to get at
the current architecture by regcache.
* mips-linux-tdep.c (mips_linux_get_longjmp_target)
(mips64_linux_get_longjmp_target, mips_linux_o32_sigframe_init)
(mips_linux_n32n64_sigframe_init): Use get_frame_arch to get at the
current architecture by frame_info.
(supply_32bit_reg, mips_supply_gregset, mips_fill_gregset)
(mips_supply_fpregset, mips_fill_fpregset, supply_64bit_reg)
(mips64_supply_gregset, mips64_fill_gregset, mips64_supply_fpregset)
(mips64_fill_fpregset, mips_linux_write_pc): Use get_regcache_arch to
get at the current architecture by regcache.
* mips-linux-nat.c (mips_linux_register_addr)
(mips64_linux_register_addr): Replace current_gdbarch by gdbarch.
(supply_gregset, fill_gregset, supply_fpregset, fill_fpregset)
(mips64_linux_regsets_fetch_registers)
(mips64_linux_regsets_store_registers): Use get_regcache_arch to get at
the current architecture by regcache.
* mips64obsd-tdep.c (mips64obsd_sigframe_init): Use get_frame_arch to
get at the current architecture by frame_info.
2007-10-10 Markus Deuling <deuling@de.ibm.com>
* mips-tdep.c (mips_xfer_register): Use get_regcache_arch to get at the

32
gdb/mips-linux-nat.c
View File

@ -60,7 +60,7 @@ mips_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
{
CORE_ADDR regaddr;
if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch))
if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
error (_("Bogon register number %d."), regno);
if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
@ -95,14 +95,14 @@ mips64_linux_register_addr (struct gdbarch *gdbarch, int regno, int store)
{
CORE_ADDR regaddr;
if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch))
if (regno < 0 || regno >= gdbarch_num_regs (gdbarch))
error (_("Bogon register number %d."), regno);
if (regno > MIPS_ZERO_REGNUM && regno < MIPS_ZERO_REGNUM + 32)
regaddr = regno;
else if ((regno >= mips_regnum (gdbarch)->fp0)
&& (regno < mips_regnum (gdbarch)->fp0 + 32))
regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (current_gdbarch));
regaddr = MIPS64_FPR_BASE + (regno - gdbarch_fp0_regnum (gdbarch));
else if (regno == mips_regnum (gdbarch)->pc)
regaddr = MIPS64_PC;
else if (regno == mips_regnum (gdbarch)->cause)
@ -147,7 +147,7 @@ ps_get_thread_area (const struct ps_prochandle *ph,
void
supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
if (mips_isa_regsize (current_gdbarch) == 4)
if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp);
else
mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp);
@ -157,7 +157,7 @@ void
fill_gregset (const struct regcache *regcache,
gdb_gregset_t *gregsetp, int regno)
{
if (mips_isa_regsize (current_gdbarch) == 4)
if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno);
else
mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno);
@ -166,7 +166,7 @@ fill_gregset (const struct regcache *regcache,
void
supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
if (mips_isa_regsize (current_gdbarch) == 4)
if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp);
else
mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *) fpregsetp);
@ -176,7 +176,7 @@ void
fill_fpregset (const struct regcache *regcache,
gdb_fpregset_t *fpregsetp, int regno)
{
if (mips_isa_regsize (current_gdbarch) == 4)
if (mips_isa_regsize (get_regcache_arch (regcache)) == 4)
mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno);
else
mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *) fpregsetp, regno);
@ -189,15 +189,16 @@ fill_fpregset (const struct regcache *regcache,
static void
mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int is_fp;
int tid;
if (regno >= mips_regnum (current_gdbarch)->fp0
&& regno <= mips_regnum (current_gdbarch)->fp0 + 32)
if (regno >= mips_regnum (gdbarch)->fp0
&& regno <= mips_regnum (gdbarch)->fp0 + 32)
is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
else if (regno == mips_regnum (gdbarch)->fp_control_status)
is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
is_fp = 1;
else
is_fp = 0;
@ -250,15 +251,16 @@ mips64_linux_regsets_fetch_registers (struct regcache *regcache, int regno)
static void
mips64_linux_regsets_store_registers (const struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int is_fp;
int tid;
if (regno >= mips_regnum (current_gdbarch)->fp0
&& regno <= mips_regnum (current_gdbarch)->fp0 + 32)
if (regno >= mips_regnum (gdbarch)->fp0
&& regno <= mips_regnum (gdbarch)->fp0 + 32)
is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
else if (regno == mips_regnum (gdbarch)->fp_control_status)
is_fp = 1;
else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
is_fp = 1;
else
is_fp = 0;

242
gdb/mips-linux-tdep.c
View File

@ -53,19 +53,18 @@ static int
mips_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
char buf[gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT];
struct gdbarch *gdbarch = get_frame_arch (frame);
char buf[gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT];
jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr
+ MIPS_LINUX_JB_PC * MIPS_LINUX_JB_ELEMENT_SIZE,
buf,
gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
buf, gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
return 0;
*pc = extract_unsigned_integer (buf,
gdbarch_ptr_bit (current_gdbarch)
/ TARGET_CHAR_BIT);
gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
return 1;
}
@ -78,7 +77,8 @@ static void
supply_32bit_reg (struct regcache *regcache, int regnum, const void *addr)
{
gdb_byte buf[MAX_REGISTER_SIZE];
store_signed_integer (buf, register_size (current_gdbarch, regnum),
store_signed_integer (buf,
register_size (get_regcache_arch (regcache), regnum),
extract_signed_integer (addr, 4));
regcache_raw_supply (regcache, regnum, buf);
}
@ -92,26 +92,25 @@ mips_supply_gregset (struct regcache *regcache,
int regi;
const mips_elf_greg_t *regp = *gregsetp;
char zerobuf[MAX_REGISTER_SIZE];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = EF_REG0 + 1; regi <= EF_REG31; regi++)
supply_32bit_reg (regcache, regi - EF_REG0, regp + regi);
if (mips_linux_restart_reg_p (current_gdbarch))
if (mips_linux_restart_reg_p (gdbarch))
supply_32bit_reg (regcache, MIPS_RESTART_REGNUM, regp + EF_REG0);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->lo,
regp + EF_LO);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->hi,
regp + EF_HI);
supply_32bit_reg (regcache, mips_regnum (gdbarch)->lo, regp + EF_LO);
supply_32bit_reg (regcache, mips_regnum (gdbarch)->hi, regp + EF_HI);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->pc,
supply_32bit_reg (regcache, mips_regnum (gdbarch)->pc,
regp + EF_CP0_EPC);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->badvaddr,
supply_32bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
regp + EF_CP0_BADVADDR);
supply_32bit_reg (regcache, MIPS_PS_REGNUM, regp + EF_CP0_STATUS);
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->cause,
supply_32bit_reg (regcache, mips_regnum (gdbarch)->cause,
regp + EF_CP0_CAUSE);
/* Fill inaccessible registers with zero. */
@ -129,6 +128,7 @@ void
mips_fill_gregset (const struct regcache *regcache,
mips_elf_gregset_t *gregsetp, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regaddr, regi;
mips_elf_greg_t *regp = *gregsetp;
void *dst;
@ -138,17 +138,12 @@ mips_fill_gregset (const struct regcache *regcache,
memset (regp, 0, sizeof (mips_elf_gregset_t));
for (regi = 1; regi < 32; regi++)
mips_fill_gregset (regcache, gregsetp, regi);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->lo);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->hi);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->pc);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->badvaddr);
mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
mips_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
mips_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->cause);
mips_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
mips_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
return;
}
@ -160,19 +155,19 @@ mips_fill_gregset (const struct regcache *regcache,
return;
}
if (regno == mips_regnum (current_gdbarch)->lo)
regaddr = EF_LO;
else if (regno == mips_regnum (current_gdbarch)->hi)
if (regno == mips_regnum (gdbarch)->lo)
regaddr = EF_LO;
else if (regno == mips_regnum (gdbarch)->hi)
regaddr = EF_HI;
else if (regno == mips_regnum (current_gdbarch)->pc)
else if (regno == mips_regnum (gdbarch)->pc)
regaddr = EF_CP0_EPC;
else if (regno == mips_regnum (current_gdbarch)->badvaddr)
else if (regno == mips_regnum (gdbarch)->badvaddr)
regaddr = EF_CP0_BADVADDR;
else if (regno == MIPS_PS_REGNUM)
regaddr = EF_CP0_STATUS;
else if (regno == mips_regnum (current_gdbarch)->cause)
else if (regno == mips_regnum (gdbarch)->cause)
regaddr = EF_CP0_CAUSE;
else if (mips_linux_restart_reg_p (current_gdbarch)
else if (mips_linux_restart_reg_p (gdbarch)
&& regno == MIPS_RESTART_REGNUM)
regaddr = EF_REG0;
else
@ -191,6 +186,7 @@ void
mips_supply_fpregset (struct regcache *regcache,
const mips_elf_fpregset_t *fpregsetp)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regi;
char zerobuf[MAX_REGISTER_SIZE];
@ -198,16 +194,16 @@ mips_supply_fpregset (struct regcache *regcache,
for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi,
gdbarch_fp0_regnum (gdbarch) + regi,
*fpregsetp + regi);
regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_control_status,
mips_regnum (gdbarch)->fp_control_status,
*fpregsetp + 32);
/* FIXME: how can we supply FCRIR? The ABI doesn't tell us. */
regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_implementation_revision,
mips_regnum (gdbarch)->fp_implementation_revision,
zerobuf);
}
@ -218,15 +214,16 @@ void
mips_fill_fpregset (const struct regcache *regcache,
mips_elf_fpregset_t *fpregsetp, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
char *from, *to;
if ((regno >= gdbarch_fp0_regnum (current_gdbarch))
&& (regno < gdbarch_fp0_regnum (current_gdbarch) + 32))
if ((regno >= gdbarch_fp0_regnum (gdbarch))
&& (regno < gdbarch_fp0_regnum (gdbarch) + 32))
{
to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (current_gdbarch));
to = (char *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
regcache_raw_collect (regcache, regno, to);
}
else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
else if (regno == mips_regnum (gdbarch)->fp_control_status)
{
to = (char *) (*fpregsetp + 32);
regcache_raw_collect (regcache, regno, to);
@ -237,9 +234,9 @@ mips_fill_fpregset (const struct regcache *regcache,
for (regi = 0; regi < 32; regi++)
mips_fill_fpregset (regcache, fpregsetp,
gdbarch_fp0_regnum (current_gdbarch) + regi);
gdbarch_fp0_regnum (gdbarch) + regi);
mips_fill_fpregset (regcache, fpregsetp,
mips_regnum (current_gdbarch)->fp_control_status);
mips_regnum (gdbarch)->fp_control_status);
}
}
@ -259,19 +256,19 @@ static int
mips64_linux_get_longjmp_target (struct frame_info *frame, CORE_ADDR *pc)
{
CORE_ADDR jb_addr;
void *buf = alloca (gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT);
int element_size = gdbarch_ptr_bit (current_gdbarch) == 32 ? 4 : 8;
struct gdbarch *gdbarch = get_frame_arch (frame);
void *buf = alloca (gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
int element_size = gdbarch_ptr_bit (gdbarch) == 32 ? 4 : 8;
jb_addr = get_frame_register_unsigned (frame, MIPS_A0_REGNUM);
if (target_read_memory (jb_addr + MIPS64_LINUX_JB_PC * element_size,
buf,
gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT))
gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT))
return 0;
*pc = extract_unsigned_integer (buf,
gdbarch_ptr_bit (current_gdbarch)
/ TARGET_CHAR_BIT);
gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT);
return 1;
}
@ -286,8 +283,9 @@ void
supply_64bit_reg (struct regcache *regcache, int regnum,
const gdb_byte *buf)
{
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG
&& register_size (current_gdbarch, regnum) == 4)
struct gdbarch *gdbarch = get_regcache_arch (regcache);
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
&& register_size (gdbarch, regnum) == 4)
regcache_raw_supply (regcache, regnum, buf + 4);
else
regcache_raw_supply (regcache, regnum, buf);
@ -302,6 +300,7 @@ mips64_supply_gregset (struct regcache *regcache,
int regi;
const mips64_elf_greg_t *regp = *gregsetp;
gdb_byte zerobuf[MAX_REGISTER_SIZE];
struct gdbarch *gdbarch = get_regcache_arch (regcache);
memset (zerobuf, 0, MAX_REGISTER_SIZE);
@ -309,22 +308,22 @@ mips64_supply_gregset (struct regcache *regcache,
supply_64bit_reg (regcache, regi - MIPS64_EF_REG0,
(const gdb_byte *)(regp + regi));
if (mips_linux_restart_reg_p (current_gdbarch))
if (mips_linux_restart_reg_p (gdbarch))
supply_64bit_reg (regcache, MIPS_RESTART_REGNUM,
(const gdb_byte *)(regp + MIPS64_EF_REG0));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->lo,
supply_64bit_reg (regcache, mips_regnum (gdbarch)->lo,
(const gdb_byte *) (regp + MIPS64_EF_LO));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->hi,
supply_64bit_reg (regcache, mips_regnum (gdbarch)->hi,
(const gdb_byte *) (regp + MIPS64_EF_HI));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->pc,
supply_64bit_reg (regcache, mips_regnum (gdbarch)->pc,
(const gdb_byte *) (regp + MIPS64_EF_CP0_EPC));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->badvaddr,
supply_64bit_reg (regcache, mips_regnum (gdbarch)->badvaddr,
(const gdb_byte *) (regp + MIPS64_EF_CP0_BADVADDR));
supply_64bit_reg (regcache, MIPS_PS_REGNUM,
(const gdb_byte *) (regp + MIPS64_EF_CP0_STATUS));
supply_64bit_reg (regcache, mips_regnum (current_gdbarch)->cause,
supply_64bit_reg (regcache, mips_regnum (gdbarch)->cause,
(const gdb_byte *) (regp + MIPS64_EF_CP0_CAUSE));
/* Fill inaccessible registers with zero. */
@ -342,6 +341,7 @@ void
mips64_fill_gregset (const struct regcache *regcache,
mips64_elf_gregset_t *gregsetp, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regaddr, regi;
mips64_elf_greg_t *regp = *gregsetp;
void *src, *dst;
@ -351,36 +351,31 @@ mips64_fill_gregset (const struct regcache *regcache,
memset (regp, 0, sizeof (mips64_elf_gregset_t));
for (regi = 1; regi < 32; regi++)
mips64_fill_gregset (regcache, gregsetp, regi);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->lo);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->hi);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->pc);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->badvaddr);
mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->lo);
mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->hi);
mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->pc);
mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->badvaddr);
mips64_fill_gregset (regcache, gregsetp, MIPS_PS_REGNUM);
mips64_fill_gregset (regcache, gregsetp,
mips_regnum (current_gdbarch)->cause);
mips64_fill_gregset (regcache, gregsetp, mips_regnum (gdbarch)->cause);
mips64_fill_gregset (regcache, gregsetp, MIPS_RESTART_REGNUM);
return;
}
if (regno > 0 && regno < 32)
regaddr = regno + MIPS64_EF_REG0;
else if (regno == mips_regnum (current_gdbarch)->lo)
else if (regno == mips_regnum (gdbarch)->lo)
regaddr = MIPS64_EF_LO;
else if (regno == mips_regnum (current_gdbarch)->hi)
else if (regno == mips_regnum (gdbarch)->hi)
regaddr = MIPS64_EF_HI;
else if (regno == mips_regnum (current_gdbarch)->pc)
else if (regno == mips_regnum (gdbarch)->pc)
regaddr = MIPS64_EF_CP0_EPC;
else if (regno == mips_regnum (current_gdbarch)->badvaddr)
else if (regno == mips_regnum (gdbarch)->badvaddr)
regaddr = MIPS64_EF_CP0_BADVADDR;
else if (regno == MIPS_PS_REGNUM)
regaddr = MIPS64_EF_CP0_STATUS;
else if (regno == mips_regnum (current_gdbarch)->cause)
else if (regno == mips_regnum (gdbarch)->cause)
regaddr = MIPS64_EF_CP0_CAUSE;
else if (mips_linux_restart_reg_p (current_gdbarch)
else if (mips_linux_restart_reg_p (gdbarch)
&& regno == MIPS_RESTART_REGNUM)
regaddr = MIPS64_EF_REG0;
else
@ -392,8 +387,7 @@ mips64_fill_gregset (const struct regcache *regcache,
LONGEST val;
regcache_raw_collect (regcache, regno, buf);
val = extract_signed_integer (buf,
register_size (current_gdbarch, regno));
val = extract_signed_integer (buf, register_size (gdbarch, regno));
dst = regp + regaddr;
store_signed_integer (dst, 8, val);
}
@ -405,36 +399,35 @@ void
mips64_supply_fpregset (struct regcache *regcache,
const mips64_elf_fpregset_t *fpregsetp)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int regi;
/* See mips_linux_o32_sigframe_init for a description of the
peculiar FP register layout. */
if (register_size (current_gdbarch,
gdbarch_fp0_regnum (current_gdbarch)) == 4)
if (register_size (gdbarch, gdbarch_fp0_regnum (gdbarch)) == 4)
for (regi = 0; regi < 32; regi++)
{
const gdb_byte *reg_ptr = (const gdb_byte *)(*fpregsetp + (regi & ~1));
if ((gdbarch_byte_order (current_gdbarch)
== BFD_ENDIAN_BIG) != (regi & 1))
if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
reg_ptr += 4;
regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi,
gdbarch_fp0_regnum (gdbarch) + regi,
reg_ptr);
}
else
for (regi = 0; regi < 32; regi++)
regcache_raw_supply (regcache,
gdbarch_fp0_regnum (current_gdbarch) + regi,
gdbarch_fp0_regnum (gdbarch) + regi,
(const char *)(*fpregsetp + regi));
supply_32bit_reg (regcache, mips_regnum (current_gdbarch)->fp_control_status,
supply_32bit_reg (regcache, mips_regnum (gdbarch)->fp_control_status,
(const gdb_byte *)(*fpregsetp + 32));
/* The ABI doesn't tell us how to supply FCRIR, and core dumps don't
include it - but the result of PTRACE_GETFPREGS does. The best we
can do is to assume that its value is present. */
supply_32bit_reg (regcache,
mips_regnum (current_gdbarch)->fp_implementation_revision,
mips_regnum (gdbarch)->fp_implementation_revision,
(const gdb_byte *)(*fpregsetp + 32) + 4);
}
@ -445,49 +438,46 @@ void
mips64_fill_fpregset (const struct regcache *regcache,
mips64_elf_fpregset_t *fpregsetp, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
gdb_byte *to;
if ((regno >= gdbarch_fp0_regnum (current_gdbarch))
&& (regno < gdbarch_fp0_regnum (current_gdbarch) + 32))
if ((regno >= gdbarch_fp0_regnum (gdbarch))
&& (regno < gdbarch_fp0_regnum (gdbarch) + 32))
{
/* See mips_linux_o32_sigframe_init for a description of the
peculiar FP register layout. */
if (register_size (current_gdbarch, regno) == 4)
if (register_size (gdbarch, regno) == 4)
{
int regi = regno - gdbarch_fp0_regnum (current_gdbarch);
int regi = regno - gdbarch_fp0_regnum (gdbarch);
to = (gdb_byte *) (*fpregsetp + (regi & ~1));
if ((gdbarch_byte_order (current_gdbarch)
== BFD_ENDIAN_BIG) != (regi & 1))
if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (regi & 1))
to += 4;
regcache_raw_collect (regcache, regno, to);
}
else
{
to = (gdb_byte *) (*fpregsetp + regno
- gdbarch_fp0_regnum (current_gdbarch));
to = (gdb_byte *) (*fpregsetp + regno - gdbarch_fp0_regnum (gdbarch));
regcache_raw_collect (regcache, regno, to);
}
}
else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
else if (regno == mips_regnum (gdbarch)->fp_control_status)
{
gdb_byte buf[MAX_REGISTER_SIZE];
LONGEST val;
regcache_raw_collect (regcache, regno, buf);
val = extract_signed_integer (buf,
register_size (current_gdbarch, regno));
val = extract_signed_integer (buf, register_size (gdbarch, regno));
to = (gdb_byte *) (*fpregsetp + 32);
store_signed_integer (to, 4, val);
}
else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
{
gdb_byte buf[MAX_REGISTER_SIZE];
LONGEST val;
regcache_raw_collect (regcache, regno, buf);
val = extract_signed_integer (buf,
register_size (current_gdbarch, regno));
val = extract_signed_integer (buf, register_size (gdbarch, regno));
to = (gdb_byte *) (*fpregsetp + 32) + 4;
store_signed_integer (to, 4, val);
}
@ -497,12 +487,12 @@ mips64_fill_fpregset (const struct regcache *regcache,
for (regi = 0; regi < 32; regi++)
mips64_fill_fpregset (regcache, fpregsetp,
gdbarch_fp0_regnum (current_gdbarch) + regi);
gdbarch_fp0_regnum (gdbarch) + regi);
mips64_fill_fpregset (regcache, fpregsetp,
mips_regnum (current_gdbarch)->fp_control_status);
mips_regnum (gdbarch)->fp_control_status);
mips64_fill_fpregset (regcache, fpregsetp,
(mips_regnum (current_gdbarch)
->fp_implementation_revision));
(mips_regnum (gdbarch)
->fp_implementation_revision));
}
}
@ -867,9 +857,10 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
struct gdbarch *gdbarch = get_frame_arch (next_frame);
int ireg, reg_position;
CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
const struct mips_regnum *regs = mips_regnum (current_gdbarch);
const struct mips_regnum *regs = mips_regnum (gdbarch);
CORE_ADDR regs_base;
if (self == &mips_linux_o32_sigframe)
@ -882,21 +873,21 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
per-frame basis, but right now we don't; the kernel saves eight
bytes but we only want four. Use regs_base to access any
64-bit fields. */
if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
regs_base = sigcontext_base + 4;
else
regs_base = sigcontext_base;
if (mips_linux_restart_reg_p (current_gdbarch))
if (mips_linux_restart_reg_p (gdbarch))
trad_frame_set_reg_addr (this_cache,
(MIPS_RESTART_REGNUM
+ gdbarch_num_regs (current_gdbarch)),
+ gdbarch_num_regs (gdbarch)),
regs_base + SIGCONTEXT_REGS);
for (ireg = 1; ireg < 32; ireg++)
trad_frame_set_reg_addr (this_cache,
ireg + MIPS_ZERO_REGNUM
+ gdbarch_num_regs (current_gdbarch),
+ gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_REGS
+ ireg * SIGCONTEXT_REG_SIZE);
@ -909,38 +900,38 @@ mips_linux_o32_sigframe_init (const struct tramp_frame *self,
layout, since we can't tell, and it's much more common. Which bits are
the "high" bits depends on endianness. */
for (ireg = 0; ireg < 32; ireg++)
if ((gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
if ((gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) != (ireg & 1))
trad_frame_set_reg_addr (this_cache,
ireg + regs->fp0 +
gdbarch_num_regs (current_gdbarch),
gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_FPREGS + 4
+ (ireg & ~1) * SIGCONTEXT_REG_SIZE);
else
trad_frame_set_reg_addr (this_cache,
ireg + regs->fp0
+ gdbarch_num_regs (current_gdbarch),
+ gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_FPREGS
+ (ireg & ~1) * SIGCONTEXT_REG_SIZE);
trad_frame_set_reg_addr (this_cache,
regs->pc + gdbarch_num_regs (current_gdbarch),
regs->pc + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_PC);
trad_frame_set_reg_addr (this_cache,
regs->fp_control_status
+ gdbarch_num_regs (current_gdbarch),
+ gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_FPCSR);
trad_frame_set_reg_addr (this_cache,
regs->hi + gdbarch_num_regs (current_gdbarch),
regs->hi + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_HI);
trad_frame_set_reg_addr (this_cache,
regs->lo + gdbarch_num_regs (current_gdbarch),
regs->lo + gdbarch_num_regs (gdbarch),
regs_base + SIGCONTEXT_LO);
trad_frame_set_reg_addr (this_cache,
regs->cause + gdbarch_num_regs (current_gdbarch),
regs->cause + gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_CAUSE);
trad_frame_set_reg_addr (this_cache,
regs->badvaddr + gdbarch_num_regs (current_gdbarch),
regs->badvaddr + gdbarch_num_regs (gdbarch),
sigcontext_base + SIGCONTEXT_BADVADDR);
/* Choice of the bottom of the sigframe is somewhat arbitrary. */
@ -1028,54 +1019,55 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
struct trad_frame_cache *this_cache,
CORE_ADDR func)
{
struct gdbarch *gdbarch = get_frame_arch (next_frame);
int ireg, reg_position;
CORE_ADDR sigcontext_base = func - SIGFRAME_CODE_OFFSET;
const struct mips_regnum *regs = mips_regnum (current_gdbarch);
const struct mips_regnum *regs = mips_regnum (gdbarch);
if (self == &mips_linux_n32_rt_sigframe)
sigcontext_base += N32_SIGFRAME_SIGCONTEXT_OFFSET;
else
sigcontext_base += N64_SIGFRAME_SIGCONTEXT_OFFSET;
if (mips_linux_restart_reg_p (current_gdbarch))
if (mips_linux_restart_reg_p (gdbarch))
trad_frame_set_reg_addr (this_cache,
(MIPS_RESTART_REGNUM
+ gdbarch_num_regs (current_gdbarch)),
+ gdbarch_num_regs (gdbarch)),
sigcontext_base + N64_SIGCONTEXT_REGS);
for (ireg = 1; ireg < 32; ireg++)
trad_frame_set_reg_addr (this_cache,
ireg + MIPS_ZERO_REGNUM
+ gdbarch_num_regs (current_gdbarch),
+ gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_REGS
+ ireg * N64_SIGCONTEXT_REG_SIZE);
for (ireg = 0; ireg < 32; ireg++)
trad_frame_set_reg_addr (this_cache,
ireg + regs->fp0
+ gdbarch_num_regs (current_gdbarch),
+ gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_FPREGS
+ ireg * N64_SIGCONTEXT_REG_SIZE);
trad_frame_set_reg_addr (this_cache,
regs->pc + gdbarch_num_regs (current_gdbarch),
regs->pc + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_PC);
trad_frame_set_reg_addr (this_cache,
regs->fp_control_status
+ gdbarch_num_regs (current_gdbarch),
+ gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_FPCSR);
trad_frame_set_reg_addr (this_cache,
regs->hi + gdbarch_num_regs (current_gdbarch),
regs->hi + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_HI);
trad_frame_set_reg_addr (this_cache,
regs->lo + gdbarch_num_regs (current_gdbarch),
regs->lo + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_LO);
trad_frame_set_reg_addr (this_cache,
regs->cause + gdbarch_num_regs (current_gdbarch),
regs->cause + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_CAUSE);
trad_frame_set_reg_addr (this_cache,
regs->badvaddr + gdbarch_num_regs (current_gdbarch),
regs->badvaddr + gdbarch_num_regs (gdbarch),
sigcontext_base + N64_SIGCONTEXT_BADVADDR);
/* Choice of the bottom of the sigframe is somewhat arbitrary. */
@ -1087,11 +1079,11 @@ mips_linux_n32n64_sigframe_init (const struct tramp_frame *self,
static void
mips_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
regcache_cooked_write_unsigned (regcache,
gdbarch_pc_regnum (current_gdbarch), pc);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
regcache_cooked_write_unsigned (regcache, gdbarch_pc_regnum (gdbarch), pc);
/* Clear the syscall restart flag. */
if (mips_linux_restart_reg_p (current_gdbarch))
if (mips_linux_restart_reg_p (gdbarch))
regcache_cooked_write_unsigned (regcache, MIPS_RESTART_REGNUM, 0);
}

10
gdb/mips64obsd-tdep.c
View File

@ -91,30 +91,30 @@ mips64obsd_sigframe_init (const struct tramp_frame *self,
fixed offset in the signal frame. */
sp = frame_unwind_register_signed (next_frame,
MIPS_SP_REGNUM
+ gdbarch_num_regs (current_gdbarch));
+ gdbarch_num_regs (gdbarch));
sigcontext_addr = sp + 32;
/* PC. */
regnum = mips_regnum (gdbarch)->pc;
trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch),
regnum + gdbarch_num_regs (gdbarch),
sigcontext_addr + 16);
/* GPRs. */
for (regnum = MIPS_AT_REGNUM, addr = sigcontext_addr + 32;
regnum <= MIPS_RA_REGNUM; regnum++, addr += 8)
trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch),
regnum + gdbarch_num_regs (gdbarch),
addr);
/* HI and LO. */
regnum = mips_regnum (gdbarch)->lo;
trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch),
regnum + gdbarch_num_regs (gdbarch),
sigcontext_addr + 280);
regnum = mips_regnum (gdbarch)->hi;
trad_frame_set_reg_addr (cache,
regnum + gdbarch_num_regs (current_gdbarch),
regnum + gdbarch_num_regs (gdbarch),
sigcontext_addr + 288);
/* TODO: Handle the floating-point registers. */

4
gdb/mipsnbsd-nat.c
View File

@ -54,7 +54,7 @@ mipsnbsd_fetch_inferior_registers (struct regcache *regcache, int regno)
return;
}
if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
if (regno == -1 || regno >= gdbarch_fp0_regnum (get_regcache_arch (regcache)))
{
struct fpreg fpregs;
@ -87,7 +87,7 @@ mipsnbsd_store_inferior_registers (struct regcache *regcache, int regno)
return;
}
if (regno == -1 || regno >= gdbarch_fp0_regnum (current_gdbarch))
if (regno == -1 || regno >= gdbarch_fp0_regnum (get_regcache_arch (regcache)))
{
struct fpreg fpregs;

39
gdb/mipsnbsd-tdep.c
View File

@ -142,17 +142,18 @@ mipsnbsd_regset_from_core_section (struct gdbarch *gdbarch,
void
mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i;
for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
{
if (regno == i || regno == -1)
{
if (gdbarch_cannot_fetch_register (current_gdbarch, i))
if (gdbarch_cannot_fetch_register (gdbarch, i))
regcache_raw_supply (regcache, i, NULL);
else
regcache_raw_supply (regcache, i,
regs + (i * mips_isa_regsize (current_gdbarch)));
regs + (i * mips_isa_regsize (gdbarch)));
}
}
}
@ -160,33 +161,35 @@ mipsnbsd_supply_reg (struct regcache *regcache, const char *regs, int regno)
void
mipsnbsd_fill_reg (const struct regcache *regcache, char *regs, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i;
for (i = 0; i <= gdbarch_pc_regnum (current_gdbarch); i++)
for (i = 0; i <= gdbarch_pc_regnum (gdbarch); i++)
if ((regno == i || regno == -1)
&& ! gdbarch_cannot_store_register (current_gdbarch, i))
&& ! gdbarch_cannot_store_register (gdbarch, i))
regcache_raw_collect (regcache, i,
regs + (i * mips_isa_regsize (current_gdbarch)));
regs + (i * mips_isa_regsize (gdbarch)));
}
void
mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i;
for (i = gdbarch_fp0_regnum (current_gdbarch);
i <= mips_regnum (current_gdbarch)->fp_implementation_revision;
for (i = gdbarch_fp0_regnum (gdbarch);
i <= mips_regnum (gdbarch)->fp_implementation_revision;
i++)
{
if (regno == i || regno == -1)
{
if (gdbarch_cannot_fetch_register (current_gdbarch, i))
if (gdbarch_cannot_fetch_register (gdbarch, i))
regcache_raw_supply (regcache, i, NULL);
else
regcache_raw_supply (regcache, i,
fpregs
+ ((i - gdbarch_fp0_regnum (current_gdbarch))
* mips_isa_regsize (current_gdbarch)));
+ ((i - gdbarch_fp0_regnum (gdbarch))
* mips_isa_regsize (gdbarch)));
}
}
}
@ -194,17 +197,17 @@ mipsnbsd_supply_fpreg (struct regcache *regcache, const char *fpregs, int regno)
void
mipsnbsd_fill_fpreg (const struct regcache *regcache, char *fpregs, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int i;
for (i = gdbarch_fp0_regnum (current_gdbarch);
i <= mips_regnum (current_gdbarch)->fp_control_status;
for (i = gdbarch_fp0_regnum (gdbarch);
i <= mips_regnum (gdbarch)->fp_control_status;
i++)
if ((regno == i || regno == -1)
&& ! gdbarch_cannot_store_register (current_gdbarch, i))
&& ! gdbarch_cannot_store_register (gdbarch, i))
regcache_raw_collect (regcache, i,
fpregs + ((i - gdbarch_fp0_regnum
(current_gdbarch))
* mips_isa_regsize (current_gdbarch)));
fpregs + ((i - gdbarch_fp0_regnum (gdbarch))
* mips_isa_regsize (gdbarch)));
}
/* Under NetBSD/mips, signal handler invocations can be identified by the
@ -244,7 +247,7 @@ static LONGEST
mipsnbsd_sigtramp_offset (struct frame_info *next_frame)
{
CORE_ADDR pc = frame_pc_unwind (next_frame);
const char *retcode = gdbarch_byte_order (current_gdbarch)
const char *retcode = gdbarch_byte_order (get_frame_arch (next_frame))
== BFD_ENDIAN_BIG ? sigtramp_retcode_mipseb :
sigtramp_retcode_mipsel;
unsigned char ret[RETCODE_SIZE], w[4];

31
gdb/remote-mips.c
View File

@ -1754,30 +1754,29 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
if (nfields >= 3)
{
struct regcache *regcache = get_current_regcache ();
struct gdbarch *gdbarch = get_regcache_arch (regcache);
char buf[MAX_REGISTER_SIZE];
store_unsigned_integer (buf,
register_size
(current_gdbarch, gdbarch_pc_regnum
(current_gdbarch)), rpc);
regcache_raw_supply (regcache, gdbarch_pc_regnum (current_gdbarch), buf);
(gdbarch, gdbarch_pc_regnum (gdbarch)), rpc);
regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), buf);
store_unsigned_integer
(buf, register_size (current_gdbarch,
gdbarch_pc_regnum (current_gdbarch)), rfp);
(buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)), rfp);
regcache_raw_supply (regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
store_unsigned_integer (buf, register_size (current_gdbarch,
gdbarch_sp_regnum (current_gdbarch)), rsp);
regcache_raw_supply (regcache, gdbarch_sp_regnum (current_gdbarch), buf);
store_unsigned_integer (buf, register_size (gdbarch,
gdbarch_sp_regnum (gdbarch)), rsp);
regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
store_unsigned_integer (buf,
register_size (current_gdbarch,
register_size (gdbarch,
gdbarch_deprecated_fp_regnum
(current_gdbarch)),
(gdbarch)),
0);
regcache_raw_supply (regcache,
gdbarch_deprecated_fp_regnum (current_gdbarch), buf);
gdbarch_deprecated_fp_regnum (gdbarch), buf);
if (nfields == 9)
{
@ -1904,17 +1903,18 @@ mips_map_regno (int regno)
static void
mips_fetch_registers (struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
unsigned LONGEST val;
int err;
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
mips_fetch_registers (regcache, regno);
return;
}
if (regno == gdbarch_deprecated_fp_regnum (current_gdbarch)
if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
|| regno == MIPS_ZERO_REGNUM)
/* gdbarch_deprecated_fp_regnum on the mips is a hack which is just
supposed to read zero (see also mips-nat.c). */
@ -1948,7 +1948,7 @@ mips_fetch_registers (struct regcache *regcache, int regno)
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
store_unsigned_integer (buf, register_size (current_gdbarch, regno), val);
store_unsigned_integer (buf, register_size (gdbarch, regno), val);
regcache_raw_supply (regcache, regno, buf);
}
}
@ -1966,12 +1966,13 @@ mips_prepare_to_store (struct regcache *regcache)
static void
mips_store_registers (struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
ULONGEST val;
int err;
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (current_gdbarch); regno++)
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
mips_store_registers (regcache, regno);
return;
}