#include "gregset.h"
#include "mips-tdep.h"
-static void fetch_core_registers (char *, unsigned int, int, CORE_ADDR);
+static void fetch_core_registers (struct regcache *, char *,
+ unsigned int, int, CORE_ADDR);
/* Size of elements in jmpbuf */
*/
void
-supply_gregset (gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
{
int regi;
- greg_t *regp = &(*gregsetp)[0];
+ const greg_t *regp = &(*gregsetp)[0];
int gregoff = sizeof (greg_t) - mips_isa_regsize (current_gdbarch);
static char zerobuf[32] = {0};
for (regi = 0; regi <= CTX_RA; regi++)
- regcache_raw_supply (current_regcache, regi,
- (char *) (regp + regi) + gregoff);
-
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
- (char *) (regp + CTX_EPC) + gregoff);
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
- (char *) (regp + CTX_MDHI) + gregoff);
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
- (char *) (regp + CTX_MDLO) + gregoff);
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
- (char *) (regp + CTX_CAUSE) + gregoff);
+ regcache_raw_supply (regcache, regi,
+ (const char *) (regp + regi) + gregoff);
+
+ regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->pc,
+ (const char *) (regp + CTX_EPC) + gregoff);
+ regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->hi,
+ (const char *) (regp + CTX_MDHI) + gregoff);
+ regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->lo,
+ (const char *) (regp + CTX_MDLO) + gregoff);
+ regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->cause,
+ (const char *) (regp + CTX_CAUSE) + gregoff);
/* Fill inaccessible registers with zero. */
- regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf);
+ regcache_raw_supply (regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf);
}
void
-fill_gregset (gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
{
- int regi;
+ int regi, size;
greg_t *regp = &(*gregsetp)[0];
- LONGEST regval;
+ gdb_byte buf[MAX_REGISTER_SIZE];
/* Under Irix6, if GDB is built with N32 ABI and is debugging an O32
executable, we have to sign extend the registers to 64 bits before
for (regi = 0; regi <= CTX_RA; regi++)
if ((regno == -1) || (regno == regi))
{
- regcache_raw_read_signed (current_regcache, regi, ®val);
- *(regp + regi) = regval;
+ size = register_size (current_gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + regi) = extract_signed_integer (buf, size);
}
if ((regno == -1) || (regno == PC_REGNUM))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->pc, ®val);
- *(regp + CTX_EPC) = regval;
+ regi = mips_regnum (current_gdbarch)->pc;
+ size = register_size (current_gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_EPC) = extract_signed_integer (buf, size);
}
if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->cause))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->cause, ®val);
- *(regp + CTX_CAUSE) = regval;
+ regi = mips_regnum (current_gdbarch)->cause;
+ size = register_size (current_gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_CAUSE) = extract_signed_integer (buf, size);
}
- if ((regno == -1)
- || (regno == mips_regnum (current_gdbarch)->hi))
+ if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->hi))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->hi, ®val);
- *(regp + CTX_MDHI) = regval;
+ regi = mips_regnum (current_gdbarch)->hi;
+ size = register_size (current_gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_MDHI) = extract_signed_integer (buf, size);
}
if ((regno == -1) || (regno == mips_regnum (current_gdbarch)->lo))
{
- regcache_raw_read_signed
- (current_regcache, mips_regnum (current_gdbarch)->lo, ®val);
- *(regp + CTX_MDLO) = regval;
+ regi = mips_regnum (current_gdbarch)->lo;
+ size = register_size (current_gdbarch, regi);
+ regcache_raw_collect (regcache, regi, buf);
+ *(regp + CTX_MDLO) = extract_signed_integer (buf, size);
}
}
*/
void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{
int regi;
static char zerobuf[32] = {0};
/* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
for (regi = 0; regi < 32; regi++)
- regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
- (char *) &fpregsetp->fp_r.fp_regs[regi]);
+ regcache_raw_supply (regcache, FP0_REGNUM + regi,
+ (const char *) &fpregsetp->fp_r.fp_regs[regi]);
/* We can't supply the FSR register directly to the regcache,
because there is a size issue: On one hand, fpregsetp->fp_csr
memset (fsrbuf, 0, 4);
memcpy (fsrbuf + 4, &fpregsetp->fp_csr, 4);
- regcache_raw_supply (current_regcache,
+ regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_control_status,
fsrbuf);
/* FIXME: how can we supply FCRIR? SGI doesn't tell us. */
- regcache_raw_supply (current_regcache,
+ regcache_raw_supply (regcache,
mips_regnum (current_gdbarch)->fp_implementation_revision,
zerobuf);
}
void
-fill_fpregset (fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno)
{
int regi;
char *from, *to;
if ((regno == -1) || (regno == regi))
{
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
- regcache_raw_read (current_regcache, regi, to);
+ regcache_raw_collect (regcache, regi, to);
}
}
is 32bits long, while the regcache expects a 64bits long buffer.
So we use a buffer of the correct size and copy the register
value from that buffer. */
- regcache_raw_read (current_regcache,
- mips_regnum (current_gdbarch)->fp_control_status,
- fsrbuf);
+ regcache_raw_collect (regcache,
+ mips_regnum (current_gdbarch)->fp_control_status,
+ fsrbuf);
memcpy (&fpregsetp->fp_csr, fsrbuf + 4, 4);
}
REG_ADDR is also unused. */
static void
-fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
+fetch_core_registers (struct regcache *regcache,
+ char *core_reg_sect, unsigned core_reg_size,
int which, CORE_ADDR reg_addr)
{
char *srcp = core_reg_sect;
for (regno = 0; regno < NUM_REGS; regno++)
{
- regcache_raw_write (current_regcache, regno, srcp);
+ regcache_raw_supply (regcache, regno, srcp);
srcp += regsize;
}
}