This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[commit] s/supply_register/regcache_raw_supply/
- From: Andrew Cagney <cagney at gnu dot org>
- To: gdb-patches at sources dot redhat dot com
- Date: Wed, 21 Jul 2004 21:32:46 -0400
- Subject: [commit] s/supply_register/regcache_raw_supply/
Hello,
Per earlier e-mail this eliminates all occurances of "supply_register"
(including some in comments :-).
committed,
Andrew
2004-07-21 Andrew Cagney <cagney@gnu.org>
* regcache.h (supply_register): Delete declaration.
* regcache.c (supply_register): Delete function.
* wince.c (do_child_fetch_inferior_registers): Update.
* win32-nat.c (do_child_fetch_inferior_registers)
(fetch_elf_core_registers): Update.
* v850ice.c (v850ice_fetch_registers): Update.
* thread-db.c (thread_db_store_registers): Update.
* sol-thread.c (sol_thread_store_registers): Update.
* shnbsd-tdep.c (shnbsd_supply_reg): Update.
* rs6000-nat.c (fetch_register): Update.
* rom68k-rom.c (rom68k_supply_one_register): Update.
* remote.c (remote_wait, remote_async_wait): Update.
* remote-st.c (get_hex_regs): Update.
* remote-sim.c (gdbsim_fetch_register): Update.
* remote-sds.c (sds_fetch_registers): Update.
* remote-rdp.c (remote_rdp_fetch_register): Update.
* remote-rdi.c (arm_rdi_fetch_registers): Update.
* remote-mips.c (mips_wait, mips_fetch_registers): Update.
* remote-m32r-sdi.c (m32r_fetch_register): Update.
* remote-hms.c (init_hms_cmds): Update.
* remote-est.c (init_est_cmds): Update.
* remote-e7000.c (get_hex_regs, fetch_regs_from_dump)
(e7000_fetch_registers, sub2_from_pc, e7000_wait): Update.
* ppcnbsd-tdep.c (ppcnbsd_supply_reg, ppcnbsd_supply_fpreg): Update.
* ppc-linux-nat.c (fetch_altivec_register, fetch_spe_register)
(fetch_register, supply_vrregset, supply_vrregset)
(fetch_spe_registers): Update.
* ppc-bdm.c (bdm_ppc_fetch_registers): Update.
* monitor.c (monitor_supply_register): Update.
* mipsv4-nat.c (supply_gregset, supply_fpregset): Update.
* mipsnbsd-tdep.c (mipsnbsd_supply_reg)
(mipsnbsd_supply_fpreg): Update.
* mips-nat.c (fetch_inferior_registers)
(fetch_core_registers): Update.
* mips-linux-tdep.c (supply_32bit_reg, supply_gregset)
(supply_fpregset, mips64_supply_gregset)
(mips64_supply_fpregset): Update.
* m68klinux-nat.c (fetch_register, supply_gregset)
(supply_fpregset): Update.
* m68k-tdep.c (supply_gregset, supply_fpregset): Update.
* m32r-rom.c (init_m32r_cmds, init_mon2000_cmds): Update.
* lynx-nat.c (fetch_inferior_registers, fetch_core_registers): Update.
* irix5-nat.c (supply_gregset, supply_fpregset): Update.
* infptrace.c (fetch_register): Update.
* ia64-linux-nat.c (supply_gregset, supply_fpregset): Update.
* ia64-aix-nat.c (supply_gregset, supply_fpregset): Update.
* i386gnu-nat.c (fetch_fpregs, supply_gregset)
(gnu_fetch_registers, gnu_store_registers): Update.
* i386-nto-tdep.c (i386nto_supply_gregset): Update.
* i386-linux-nat.c (fetch_register, supply_gregset)
(dummy_sse_values): Update.
* hpux-thread.c (hpux_thread_fetch_registers): Update.
* hppah-nat.c (fetch_register): Update.
* hppa-linux-nat.c (fetch_register, supply_gregset)
(supply_fpregset): Update.
* go32-nat.c (fetch_register): Update.
* dve3900-rom.c (fetch_bitmapped_register)
(_initialize_r3900_rom): Update.
* cris-tdep.c (supply_gregset): Update.
* abug-rom.c (init_abug_cmds): Update.
* core-aout.c (fetch_core_registers): Update.
* armnbsd-nat.c (supply_gregset, supply_fparegset)
(fetch_register, fetch_fp_register): Update.
* arm-linux-nat.c (fetch_nwfpe_single, fetch_nwfpe_none)
(fetch_nwfpe_extended, fetch_fpregister, fetch_fpregs)
(fetch_register, fetch_regs, supply_gregset, supply_fpregset): Update.
* alphanbsd-tdep.c (fetch_core_registers): Update.
* alpha-tdep.c (alpha_supply_int_regs, alpha_supply_fp_regs): Update.
* alpha-nat.c (fetch_osf_core_registers)
(fetch_osf_core_registers, fetch_osf_core_registers): Update.
* aix-thread.c (supply_gprs64, supply_reg32, supply_fprs)
(supply_sprs64, supply_sprs32, fetch_regs_kernel_thread): Update.
Index: abug-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/abug-rom.c,v
retrieving revision 1.8
diff -p -u -r1.8 abug-rom.c
--- abug-rom.c 11 Jun 2003 13:16:26 -0000 1.8
+++ abug-rom.c 22 Jul 2004 01:26:53 -0000
@@ -144,7 +144,7 @@ init_abug_cmds (void)
abug_cmds.getreg.term_cmd = ".\r"; /* getreg.term_cmd */
abug_cmds.dump_registers = "rd\r"; /* dump_registers */
abug_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
- abug_cmds.supply_register = abug_supply_register; /* supply_register */
+ abug_cmds.supply_register = abug_supply_register;
abug_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
abug_cmds.load = "lo 0\r"; /* download command */
abug_cmds.loadresp = "\n"; /* load response */
Index: aix-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/aix-thread.c,v
retrieving revision 1.29
diff -p -u -r1.29 aix-thread.c
--- aix-thread.c 28 Jun 2004 23:59:27 -0000 1.29
+++ aix-thread.c 22 Jul 2004 01:26:55 -0000
@@ -1006,7 +1006,8 @@ supply_gprs64 (uint64_t *vals)
int regno;
for (regno = 0; regno < ppc_num_gprs; regno++)
- supply_register (tdep->ppc_gp0_regnum + regno, (char *) (vals + regno));
+ regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regno,
+ (char *) (vals + regno));
}
/* Record that 32-bit register REGNO contains VAL. */
@@ -1014,7 +1015,7 @@ supply_gprs64 (uint64_t *vals)
static void
supply_reg32 (int regno, uint32_t val)
{
- supply_register (regno, (char *) &val);
+ regcache_raw_supply (current_regcache, regno, (char *) &val);
}
/* Record that the floating-point registers contain VALS. */
@@ -1030,7 +1031,8 @@ supply_fprs (double *vals)
gdb_assert (ppc_floating_point_unit_p (current_gdbarch));
for (regno = 0; regno < ppc_num_fprs; regno++)
- supply_register (regno + tdep->ppc_fp0_regnum, (char *) (vals + regno));
+ regcache_raw_supply (current_regcache, regno + tdep->ppc_fp0_regnum,
+ (char *) (vals + regno));
}
/* Predicate to test whether given register number is a "special" register. */
@@ -1060,14 +1062,15 @@ supply_sprs64 (uint64_t iar, uint64_t ms
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- supply_register (PC_REGNUM, (char *) &iar);
- supply_register (tdep->ppc_ps_regnum, (char *) &msr);
- supply_register (tdep->ppc_cr_regnum, (char *) &cr);
- supply_register (tdep->ppc_lr_regnum, (char *) &lr);
- supply_register (tdep->ppc_ctr_regnum, (char *) &ctr);
- supply_register (tdep->ppc_xer_regnum, (char *) &xer);
+ regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar);
+ regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr);
+ regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr);
+ regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr);
+ regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
+ regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer);
if (tdep->ppc_fpscr_regnum >= 0)
- supply_register (tdep->ppc_fpscr_regnum, (char *) &fpscr);
+ regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ (char *) &fpscr);
}
/* Record that the special registers contain the specified 32-bit
@@ -1080,14 +1083,15 @@ supply_sprs32 (uint32_t iar, uint32_t ms
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- supply_register (PC_REGNUM, (char *) &iar);
- supply_register (tdep->ppc_ps_regnum, (char *) &msr);
- supply_register (tdep->ppc_cr_regnum, (char *) &cr);
- supply_register (tdep->ppc_lr_regnum, (char *) &lr);
- supply_register (tdep->ppc_ctr_regnum, (char *) &ctr);
- supply_register (tdep->ppc_xer_regnum, (char *) &xer);
+ regcache_raw_supply (current_regcache, PC_REGNUM, (char *) &iar);
+ regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum, (char *) &msr);
+ regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum, (char *) &cr);
+ regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum, (char *) &lr);
+ regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
+ regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum, (char *) &xer);
if (tdep->ppc_fpscr_regnum >= 0)
- supply_register (tdep->ppc_fpscr_regnum, (char *) &fpscr);
+ regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ (char *) &fpscr);
}
/* Fetch all registers from pthread PDTID, which doesn't have a kernel
@@ -1223,7 +1227,8 @@ fetch_regs_kernel_thread (int regno, pth
sprs32.pt_fpscr);
if (tdep->ppc_mq_regnum >= 0)
- supply_register (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq);
+ regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
+ (char *) &sprs32.pt_mq);
}
}
}
Index: alpha-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-nat.c,v
retrieving revision 1.21
diff -p -u -r1.21 alpha-nat.c
--- alpha-nat.c 21 Apr 2004 17:47:10 -0000 1.21
+++ alpha-nat.c 22 Jul 2004 01:26:55 -0000
@@ -99,7 +99,7 @@ fetch_osf_core_registers (char *core_reg
{
if (CANNOT_FETCH_REGISTER (regno))
{
- supply_register (regno, NULL);
+ regcache_raw_supply (current_regcache, regno, NULL);
continue;
}
addr = 8 * core_reg_mapping[regno];
@@ -108,7 +108,7 @@ fetch_osf_core_registers (char *core_reg
/* ??? UNIQUE is a new addition. Don't generate an error. */
if (regno == ALPHA_UNIQUE_REGNUM)
{
- supply_register (regno, NULL);
+ regcache_raw_supply (current_regcache, regno, NULL);
continue;
}
if (bad_reg < 0)
@@ -116,7 +116,7 @@ fetch_osf_core_registers (char *core_reg
}
else
{
- supply_register (regno, core_reg_sect + addr);
+ regcache_raw_supply (current_regcache, regno, core_reg_sect + addr);
}
}
if (bad_reg >= 0)
Index: alpha-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-tdep.c,v
retrieving revision 1.134
diff -p -u -r1.134 alpha-tdep.c
--- alpha-tdep.c 20 Jul 2004 19:45:04 -0000 1.134
+++ alpha-tdep.c 22 Jul 2004 01:26:57 -0000
@@ -1303,16 +1303,16 @@ alpha_supply_int_regs (int regno, const
for (i = 0; i < 31; ++i)
if (regno == i || regno == -1)
- supply_register (i, (const char *)r0_r30 + i*8);
+ regcache_raw_supply (current_regcache, i, (const char *)r0_r30 + i*8);
if (regno == ALPHA_ZERO_REGNUM || regno == -1)
- supply_register (ALPHA_ZERO_REGNUM, NULL);
+ regcache_raw_supply (current_regcache, ALPHA_ZERO_REGNUM, NULL);
if (regno == ALPHA_PC_REGNUM || regno == -1)
- supply_register (ALPHA_PC_REGNUM, pc);
+ regcache_raw_supply (current_regcache, ALPHA_PC_REGNUM, pc);
if (regno == ALPHA_UNIQUE_REGNUM || regno == -1)
- supply_register (ALPHA_UNIQUE_REGNUM, unique);
+ regcache_raw_supply (current_regcache, ALPHA_UNIQUE_REGNUM, unique);
}
void
@@ -1338,10 +1338,11 @@ alpha_supply_fp_regs (int regno, const v
for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
if (regno == i || regno == -1)
- supply_register (i, (const char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8);
+ regcache_raw_supply (current_regcache, i,
+ (const char *)f0_f30 + (i - ALPHA_FP0_REGNUM) * 8);
if (regno == ALPHA_FPCR_REGNUM || regno == -1)
- supply_register (ALPHA_FPCR_REGNUM, fpcr);
+ regcache_raw_supply (current_regcache, ALPHA_FPCR_REGNUM, fpcr);
}
void
Index: alphanbsd-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alphanbsd-tdep.c,v
retrieving revision 1.24
diff -p -u -r1.24 alphanbsd-tdep.c
--- alphanbsd-tdep.c 20 Jul 2004 19:45:04 -0000 1.24
+++ alphanbsd-tdep.c 22 Jul 2004 01:26:57 -0000
@@ -70,9 +70,9 @@ fetch_core_registers (char *core_reg_sec
/* Integer registers. */
for (regno = 0; regno < ALPHA_ZERO_REGNUM; regno++)
- supply_register (regno, regs + (regmap[regno] * 8));
- supply_register (ALPHA_ZERO_REGNUM, NULL);
- supply_register (PC_REGNUM, regs + (28 * 8));
+ regcache_raw_supply (current_regcache, regno, regs + (regmap[regno] * 8));
+ regcache_raw_supply (current_regcache, ALPHA_ZERO_REGNUM, NULL);
+ regcache_raw_supply (current_regcache, PC_REGNUM, regs + (28 * 8));
/* Floating point registers. */
alphabsd_supply_fpreg (fpregs, -1);
Index: arm-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/arm-linux-nat.c,v
retrieving revision 1.19
diff -p -u -r1.19 arm-linux-nat.c
--- arm-linux-nat.c 23 Feb 2002 12:36:50 -0000 1.19
+++ arm-linux-nat.c 22 Jul 2004 01:26:57 -0000
@@ -102,7 +102,7 @@ fetch_nwfpe_single (unsigned int fn, FPA
mem[0] = fpa11->fpreg[fn].fSingle;
mem[1] = 0;
mem[2] = 0;
- supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
@@ -113,7 +113,7 @@ fetch_nwfpe_double (unsigned int fn, FPA
mem[0] = fpa11->fpreg[fn].fDouble[1];
mem[1] = fpa11->fpreg[fn].fDouble[0];
mem[2] = 0;
- supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
@@ -122,7 +122,7 @@ fetch_nwfpe_none (unsigned int fn)
unsigned int mem[3] =
{0, 0, 0};
- supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
@@ -133,7 +133,7 @@ fetch_nwfpe_extended (unsigned int fn, F
mem[0] = fpa11->fpreg[fn].fExtended[0]; /* sign & exponent */
mem[1] = fpa11->fpreg[fn].fExtended[2]; /* ls bits */
mem[2] = fpa11->fpreg[fn].fExtended[1]; /* ms bits */
- supply_register (ARM_F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
@@ -239,7 +239,7 @@ fetch_fpregister (int regno)
/* Fetch fpsr. */
if (ARM_FPS_REGNUM == regno)
- supply_register (ARM_FPS_REGNUM, (char *) &fp.fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Fetch the floating point register. */
if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
@@ -287,7 +287,7 @@ fetch_fpregs (void)
}
/* Fetch fpsr. */
- supply_register (ARM_FPS_REGNUM, (char *) &fp.fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Fetch the floating point registers. */
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
@@ -410,20 +410,23 @@ fetch_register (int regno)
}
if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
- supply_register (regno, (char *) ®s[regno]);
+ regcache_raw_supply (current_regcache, regno, (char *) ®s[regno]);
if (ARM_PS_REGNUM == regno)
{
if (arm_apcs_32)
- supply_register (ARM_PS_REGNUM, (char *) ®s[ARM_CPSR_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_CPSR_REGNUM]);
else
- supply_register (ARM_PS_REGNUM, (char *) ®s[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
}
if (ARM_PC_REGNUM == regno)
{
regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
- supply_register (ARM_PC_REGNUM, (char *) ®s[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
}
}
@@ -447,15 +450,18 @@ fetch_regs (void)
}
for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
- supply_register (regno, (char *) ®s[regno]);
+ regcache_raw_supply (current_regcache, regno, (char *) ®s[regno]);
if (arm_apcs_32)
- supply_register (ARM_PS_REGNUM, (char *) ®s[ARM_CPSR_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_CPSR_REGNUM]);
else
- supply_register (ARM_PS_REGNUM, (char *) ®s[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
- supply_register (ARM_PC_REGNUM, (char *) ®s[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
}
/* Store all general registers of the process from the values in
@@ -604,15 +610,18 @@ supply_gregset (gdb_gregset_t *gregsetp)
int regno, reg_pc;
for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
- supply_register (regno, (char *) &(*gregsetp)[regno]);
+ regcache_raw_supply (current_regcache, regno,
+ (char *) &(*gregsetp)[regno]);
if (arm_apcs_32)
- supply_register (ARM_PS_REGNUM, (char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
else
- supply_register (ARM_PS_REGNUM, (char *) &(*gregsetp)[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &(*gregsetp)[ARM_PC_REGNUM]);
reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[ARM_PC_REGNUM]);
- supply_register (ARM_PC_REGNUM, (char *) ®_pc);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM, (char *) ®_pc);
}
/* Fill register regno (if it is a floating-point register) in
@@ -651,7 +660,7 @@ supply_fpregset (gdb_fpregset_t *fpregse
FPA11 *fp = (FPA11 *) fpregsetp;
/* Fetch fpsr. */
- supply_register (ARM_FPS_REGNUM, (char *) &fp->fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp->fpsr);
/* Fetch the floating point registers. */
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
Index: armnbsd-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/armnbsd-nat.c,v
retrieving revision 1.9
diff -p -u -r1.9 armnbsd-nat.c
--- armnbsd-nat.c 21 Apr 2004 17:47:10 -0000 1.9
+++ armnbsd-nat.c 22 Jul 2004 01:26:57 -0000
@@ -45,18 +45,22 @@ supply_gregset (struct reg *gregset)
/* Integer registers. */
for (regno = ARM_A1_REGNUM; regno < ARM_SP_REGNUM; regno++)
- supply_register (regno, (char *) &gregset->r[regno]);
+ regcache_raw_supply (current_regcache, regno, (char *) &gregset->r[regno]);
- supply_register (ARM_SP_REGNUM, (char *) &gregset->r_sp);
- supply_register (ARM_LR_REGNUM, (char *) &gregset->r_lr);
+ regcache_raw_supply (current_regcache, ARM_SP_REGNUM,
+ (char *) &gregset->r_sp);
+ regcache_raw_supply (current_regcache, ARM_LR_REGNUM,
+ (char *) &gregset->r_lr);
/* This is ok: we're running native... */
r_pc = ADDR_BITS_REMOVE (gregset->r_pc);
- supply_register (ARM_PC_REGNUM, (char *) &r_pc);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM, (char *) &r_pc);
if (arm_apcs_32)
- supply_register (ARM_PS_REGNUM, (char *) &gregset->r_cpsr);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &gregset->r_cpsr);
else
- supply_register (ARM_PS_REGNUM, (char *) &gregset->r_pc);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &gregset->r_pc);
}
static void
@@ -65,10 +69,11 @@ supply_fparegset (struct fpreg *fparegse
int regno;
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
- supply_register
- (regno, (char *) &fparegset->fpr[regno - ARM_F0_REGNUM]);
+ regcache_raw_supply (current_regcache, regno,
+ (char *) &fparegset->fpr[regno - ARM_F0_REGNUM]);
- supply_register (ARM_FPS_REGNUM, (char *) &fparegset->fpr_fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
+ (char *) &fparegset->fpr_fpsr);
}
static void
@@ -89,28 +94,34 @@ fetch_register (int regno)
switch (regno)
{
case ARM_SP_REGNUM:
- supply_register (ARM_SP_REGNUM, (char *) &inferior_registers.r_sp);
+ regcache_raw_supply (current_regcache, ARM_SP_REGNUM,
+ (char *) &inferior_registers.r_sp);
break;
case ARM_LR_REGNUM:
- supply_register (ARM_LR_REGNUM, (char *) &inferior_registers.r_lr);
+ regcache_raw_supply (current_regcache, ARM_LR_REGNUM,
+ (char *) &inferior_registers.r_lr);
break;
case ARM_PC_REGNUM:
/* This is ok: we're running native... */
inferior_registers.r_pc = ADDR_BITS_REMOVE (inferior_registers.r_pc);
- supply_register (ARM_PC_REGNUM, (char *) &inferior_registers.r_pc);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+ (char *) &inferior_registers.r_pc);
break;
case ARM_PS_REGNUM:
if (arm_apcs_32)
- supply_register (ARM_PS_REGNUM, (char *) &inferior_registers.r_cpsr);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &inferior_registers.r_cpsr);
else
- supply_register (ARM_PS_REGNUM, (char *) &inferior_registers.r_pc);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &inferior_registers.r_pc);
break;
default:
- supply_register (regno, (char *) &inferior_registers.r[regno]);
+ regcache_raw_supply (current_regcache, regno,
+ (char *) &inferior_registers.r[regno]);
break;
}
}
@@ -152,13 +163,13 @@ fetch_fp_register (int regno)
switch (regno)
{
case ARM_FPS_REGNUM:
- supply_register (ARM_FPS_REGNUM,
- (char *) &inferior_fp_registers.fpr_fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM,
+ (char *) &inferior_fp_registers.fpr_fpsr);
break;
default:
- supply_register
- (regno, (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
+ regcache_raw_supply (current_regcache, regno,
+ (char *) &inferior_fp_registers.fpr[regno - ARM_F0_REGNUM]);
break;
}
}
Index: core-aout.c
===================================================================
RCS file: /cvs/src/src/gdb/core-aout.c,v
retrieving revision 1.8
diff -p -u -r1.8 core-aout.c
--- core-aout.c 21 Apr 2004 17:47:10 -0000 1.8
+++ core-aout.c 22 Jul 2004 01:26:57 -0000
@@ -37,7 +37,7 @@
#include <sys/types.h>
#include <sys/param.h>
#include "gdbcore.h"
-#include "value.h" /* For supply_register. */
+#include "value.h"
#include "regcache.h"
/* These are needed on various systems to expand REGISTER_U_ADDR. */
@@ -99,7 +99,7 @@ fetch_core_registers (char *core_reg_sec
&& bad_reg < 0)
bad_reg = regno;
else
- supply_register (regno, core_reg_sect + addr);
+ regcache_raw_supply (current_regcache, regno, core_reg_sect + addr);
}
if (bad_reg >= 0)
Index: cpu32bug-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/cpu32bug-rom.c,v
retrieving revision 1.8
diff -p -u -r1.8 cpu32bug-rom.c
--- cpu32bug-rom.c 11 Jun 2003 13:16:27 -0000 1.8
+++ cpu32bug-rom.c 22 Jul 2004 01:26:57 -0000
@@ -142,7 +142,7 @@ init_cpu32bug_cmds (void)
cpu32bug_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
cpu32bug_cmds.dump_registers = "rd\r"; /* dump_registers */
cpu32bug_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
- cpu32bug_cmds.supply_register = cpu32bug_supply_register; /* supply_register */
+ cpu32bug_cmds.supply_register = cpu32bug_supply_register;
cpu32bug_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
cpu32bug_cmds.load = "lo\r"; /* download command */
cpu32bug_cmds.loadresp = "\n"; /* load response */
Index: cris-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/cris-tdep.c,v
retrieving revision 1.108
diff -p -u -r1.108 cris-tdep.c
--- cris-tdep.c 20 Jun 2004 17:18:04 -0000 1.108
+++ cris-tdep.c 22 Jul 2004 01:26:59 -0000
@@ -3336,7 +3336,7 @@ supply_gregset (elf_gregset_t *gregsetp)
knows about the actual size of each register so that's no problem. */
for (i = 0; i < NUM_GENREGS + NUM_SPECREGS; i++)
{
- supply_register (i, (char *)®p[i]);
+ regcache_raw_supply (current_regcache, i, (char *)®p[i]);
}
}
Index: dbug-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/dbug-rom.c,v
retrieving revision 1.8
diff -p -u -r1.8 dbug-rom.c
--- dbug-rom.c 11 Jun 2003 13:16:27 -0000 1.8
+++ dbug-rom.c 22 Jul 2004 01:26:59 -0000
@@ -140,7 +140,7 @@ init_dbug_cmds (void)
dbug_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
dbug_cmds.dump_registers = "rd\r"; /* dump_registers */
dbug_cmds.register_pattern = "\\(\\w+\\) +:\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
- dbug_cmds.supply_register = dbug_supply_register; /* supply_register */
+ dbug_cmds.supply_register = dbug_supply_register;
dbug_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
dbug_cmds.load = "dl\r"; /* download command */
dbug_cmds.loadresp = "\n"; /* load response */
Index: dve3900-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/dve3900-rom.c,v
retrieving revision 1.14
diff -p -u -r1.14 dve3900-rom.c
--- dve3900-rom.c 16 Nov 2003 19:24:04 -0000 1.14
+++ dve3900-rom.c 22 Jul 2004 01:27:00 -0000
@@ -473,7 +473,7 @@ fetch_bitmapped_register (int regno, str
/* supply register stores in target byte order, so swap here */
store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
- supply_register (regno, regbuf);
+ regcache_raw_supply (current_regcache, regno, regbuf);
}
Index: go32-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/go32-nat.c,v
retrieving revision 1.38
diff -p -u -r1.38 go32-nat.c
--- go32-nat.c 25 May 2004 14:58:26 -0000 1.38
+++ go32-nat.c 22 Jul 2004 01:27:01 -0000
@@ -466,7 +466,8 @@ static void
fetch_register (int regno)
{
if (regno < FP0_REGNUM)
- supply_register (regno, (char *) &a_tss + regno_mapping[regno].tss_ofs);
+ regcache_raw_supply (current_regcache, regno,
+ (char *) &a_tss + regno_mapping[regno].tss_ofs);
else if (i386_fp_regnum_p (regno) || i386_fpc_regnum_p (regno))
i387_supply_fsave (current_regcache, regno, &npx);
else
Index: hppa-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppa-linux-nat.c,v
retrieving revision 1.6
diff -p -u -r1.6 hppa-linux-nat.c
--- hppa-linux-nat.c 17 Jul 2004 14:15:30 -0000 1.6
+++ hppa-linux-nat.c 22 Jul 2004 01:27:03 -0000
@@ -221,7 +221,7 @@ fetch_register (int regno)
if (CANNOT_FETCH_REGISTER (regno))
{
- supply_register (regno, NULL);
+ regcache_raw_supply (current_regcache, regno, NULL);
return;
}
@@ -311,7 +311,7 @@ supply_gregset (gdb_gregset_t *gregsetp)
for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++)
{
int regno = greg_map[i];
- supply_register (regno, regp);
+ regcache_raw_supply (current_regcache, regno, regp);
}
}
@@ -348,8 +348,9 @@ supply_fpregset (gdb_fpregset_t *fpregse
for (regi = 0; regi <= 31; regi++)
{
from = (char *) &((*fpregsetp)[regi]);
- supply_register (2*regi + HPPA_FP0_REGNUM, from);
- supply_register (2*regi + HPPA_FP0_REGNUM + 1, from + 4);
+ regcache_raw_supply (current_regcache, 2*regi + HPPA_FP0_REGNUM, from);
+ regcache_raw_supply (current_regcache, 2*regi + HPPA_FP0_REGNUM + 1,
+ from + 4);
}
}
Index: hppah-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/hppah-nat.c,v
retrieving revision 1.31
diff -p -u -r1.31 hppah-nat.c
--- hppah-nat.c 7 May 2004 05:48:49 -0000 1.31
+++ hppah-nat.c 22 Jul 2004 01:27:03 -0000
@@ -282,7 +282,7 @@ fetch_register (int regno)
if (regno == HPPA_PCOQ_HEAD_REGNUM || regno == HPPA_PCOQ_TAIL_REGNUM)
buf[len - 1] &= ~0x3;
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
Index: hpux-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/hpux-thread.c,v
retrieving revision 1.23
diff -p -u -r1.23 hpux-thread.c
--- hpux-thread.c 25 May 2004 14:58:26 -0000 1.23
+++ hpux-thread.c 22 Jul 2004 01:27:03 -0000
@@ -299,7 +299,7 @@ hpux_thread_fetch_registers (int regno)
else
read_memory (sp + regmap[regno], buf, DEPRECATED_REGISTER_RAW_SIZE (regno));
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
}
Index: i386-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-linux-nat.c,v
retrieving revision 1.57
diff -p -u -r1.57 i386-linux-nat.c
--- i386-linux-nat.c 20 Jul 2004 19:45:06 -0000 1.57
+++ i386-linux-nat.c 22 Jul 2004 01:27:03 -0000
@@ -179,7 +179,7 @@ fetch_register (int regno)
gdb_assert (!have_ptrace_getregs);
if (cannot_fetch_register (regno))
{
- supply_register (regno, NULL);
+ regcache_raw_supply (current_regcache, regno, NULL);
return;
}
@@ -194,7 +194,7 @@ fetch_register (int regno)
error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regno),
regno, safe_strerror (errno));
- supply_register (regno, &val);
+ regcache_raw_supply (current_regcache, regno, &val);
}
/* Store one register. */
@@ -236,10 +236,11 @@ supply_gregset (elf_gregset_t *gregsetp)
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
- supply_register (i, regp + regmap[i]);
+ regcache_raw_supply (current_regcache, i, regp + regmap[i]);
if (I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
- supply_register (I386_LINUX_ORIG_EAX_REGNUM, regp + ORIG_EAX);
+ regcache_raw_supply (current_regcache, I386_LINUX_ORIG_EAX_REGNUM,
+ regp + ORIG_EAX);
}
/* Fill register REGNO (if it is a general-purpose register) in
@@ -472,9 +473,9 @@ dummy_sse_values (void)
int reg;
for (reg = 0; reg < tdep->num_xmm_regs; reg++)
- supply_register (XMM0_REGNUM + reg, (char *) dummy);
+ regcache_raw_supply (current_regcache, XMM0_REGNUM + reg, (char *) dummy);
if (tdep->num_xmm_regs > 0)
- supply_register (MXCSR_REGNUM, (char *) &mxcsr);
+ regcache_raw_supply (current_regcache, MXCSR_REGNUM, (char *) &mxcsr);
}
#else
Index: i386-nto-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-nto-tdep.c,v
retrieving revision 1.11
diff -p -u -r1.11 i386-nto-tdep.c
--- i386-nto-tdep.c 9 Apr 2004 16:28:50 -0000 1.11
+++ i386-nto-tdep.c 22 Jul 2004 01:27:03 -0000
@@ -77,9 +77,9 @@ i386nto_supply_gregset (char *gpregs)
{
int offset = nto_reg_offset (regno);
if (offset == -1)
- supply_register (regno, (char *) &empty);
+ regcache_raw_supply (current_regcache, regno, (char *) &empty);
else
- supply_register (regno, gpregs + offset);
+ regcache_raw_supply (current_regcache, regno, gpregs + offset);
}
}
Index: i386gnu-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/i386gnu-nat.c,v
retrieving revision 1.17
diff -p -u -r1.17 i386gnu-nat.c
--- i386gnu-nat.c 2 Oct 2003 20:28:29 -0000 1.17
+++ i386gnu-nat.c 22 Jul 2004 01:27:04 -0000
@@ -83,7 +83,7 @@ fetch_fpregs (struct proc *thread)
int i;
for (i = FP0_REGNUM; i <= FOP_REGNUM; i++)
- supply_register (i, NULL);
+ regcache_raw_supply (current_regcache, i, NULL);
return;
}
@@ -100,7 +100,7 @@ supply_gregset (gdb_gregset_t *gregs)
{
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
- supply_register (i, REG_ADDR (gregs, i));
+ regcache_raw_supply (current_regcache, i, REG_ADDR (gregs, i));
}
void
@@ -144,14 +144,15 @@ gnu_fetch_registers (int regno)
proc_debug (thread, "fetching all register");
for (i = 0; i < I386_NUM_GREGS; i++)
- supply_register (i, REG_ADDR (state, i));
+ regcache_raw_supply (current_regcache, i, REG_ADDR (state, i));
thread->fetched_regs = ~0;
}
else
{
proc_debug (thread, "fetching register %s", REGISTER_NAME (regno));
- supply_register (regno, REG_ADDR (state, regno));
+ regcache_raw_supply (current_regcache, regno,
+ REG_ADDR (state, regno));
thread->fetched_regs |= (1 << regno);
}
}
@@ -249,7 +250,8 @@ gnu_store_registers (int regno)
REGISTER_NAME (check_regno));
if (regno >= 0 && regno != check_regno)
/* Update GDB's copy of the register. */
- supply_register (check_regno, REG_ADDR (state, check_regno));
+ regcache_raw_supply (current_regcache, check_regno,
+ REG_ADDR (state, check_regno));
else
warning ("... also writing this register! Suspicious...");
}
Index: ia64-aix-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-aix-nat.c,v
retrieving revision 1.8
diff -p -u -r1.8 ia64-aix-nat.c
--- ia64-aix-nat.c 2 Oct 2003 20:28:29 -0000 1.8
+++ ia64-aix-nat.c 22 Jul 2004 01:27:04 -0000
@@ -42,31 +42,45 @@ supply_gregset (prgregset_t *gregsetp)
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
{
- supply_register (regi,
- (char *) &(gregsetp->__gpr[regi - IA64_GR0_REGNUM]));
+ regcache_raw_supply (current_regcache, regi,
+ (char *) &(gregsetp->__gpr[regi - IA64_GR0_REGNUM]));
}
for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++)
{
- supply_register (regi,
- (char *) &(gregsetp->__br[regi - IA64_BR0_REGNUM]));
+ regcache_raw_supply (current_regcache, regi,
+ (char *) &(gregsetp->__br[regi - IA64_BR0_REGNUM]));
}
- supply_register (IA64_PSR_REGNUM, (char *) &(gregsetp->__psr));
- supply_register (IA64_IP_REGNUM, (char *) &(gregsetp->__ip));
- supply_register (IA64_CFM_REGNUM, (char *) &(gregsetp->__ifs));
- supply_register (IA64_RSC_REGNUM, (char *) &(gregsetp->__rsc));
- supply_register (IA64_BSP_REGNUM, (char *) &(gregsetp->__bsp));
- supply_register (IA64_BSPSTORE_REGNUM, (char *) &(gregsetp->__bspstore));
- supply_register (IA64_RNAT_REGNUM, (char *) &(gregsetp->__rnat));
- supply_register (IA64_PFS_REGNUM, (char *) &(gregsetp->__pfs));
- supply_register (IA64_UNAT_REGNUM, (char *) &(gregsetp->__unat));
- supply_register (IA64_PR_REGNUM, (char *) &(gregsetp->__preds));
- supply_register (IA64_CCV_REGNUM, (char *) &(gregsetp->__ccv));
- supply_register (IA64_LC_REGNUM, (char *) &(gregsetp->__lc));
- supply_register (IA64_EC_REGNUM, (char *) &(gregsetp->__ec));
+ regcache_raw_supply (current_regcache, IA64_PSR_REGNUM,
+ (char *) &(gregsetp->__psr));
+ regcache_raw_supply (current_regcache, IA64_IP_REGNUM,
+ (char *) &(gregsetp->__ip));
+ regcache_raw_supply (current_regcache, IA64_CFM_REGNUM,
+ (char *) &(gregsetp->__ifs));
+ regcache_raw_supply (current_regcache, IA64_RSC_REGNUM,
+ (char *) &(gregsetp->__rsc));
+ regcache_raw_supply (current_regcache, IA64_BSP_REGNUM,
+ (char *) &(gregsetp->__bsp));
+ regcache_raw_supply (current_regcache, IA64_BSPSTORE_REGNUM,
+ (char *) &(gregsetp->__bspstore));
+ regcache_raw_supply (current_regcache, IA64_RNAT_REGNUM,
+ (char *) &(gregsetp->__rnat));
+ regcache_raw_supply (current_regcache, IA64_PFS_REGNUM,
+ (char *) &(gregsetp->__pfs));
+ regcache_raw_supply (current_regcache, IA64_UNAT_REGNUM,
+ (char *) &(gregsetp->__unat));
+ regcache_raw_supply (current_regcache, IA64_PR_REGNUM,
+ (char *) &(gregsetp->__preds));
+ regcache_raw_supply (current_regcache, IA64_CCV_REGNUM,
+ (char *) &(gregsetp->__ccv));
+ regcache_raw_supply (current_regcache, IA64_LC_REGNUM,
+ (char *) &(gregsetp->__lc));
+ regcache_raw_supply (current_regcache, IA64_EC_REGNUM,
+ (char *) &(gregsetp->__ec));
/* FIXME: __nats */
- supply_register (IA64_FPSR_REGNUM, (char *) &(gregsetp->__fpsr));
+ regcache_raw_supply (current_regcache, IA64_FPSR_REGNUM,
+ (char *) &(gregsetp->__fpsr));
/* These (for the most part) are pseudo registers and are obtained
by other means. Those that aren't are already handled by the
@@ -139,7 +153,7 @@ supply_fpregset (prfpregset_t *fpregsetp
int regi;
for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
- supply_register (regi,
+ regcache_raw_supply (current_regcache, regi,
(char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]));
}
Index: ia64-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ia64-linux-nat.c,v
retrieving revision 1.21
diff -p -u -r1.21 ia64-linux-nat.c
--- ia64-linux-nat.c 14 Nov 2003 20:49:23 -0000 1.21
+++ ia64-linux-nat.c 22 Jul 2004 01:27:04 -0000
@@ -367,32 +367,47 @@ supply_gregset (gregset_t *gregsetp)
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
{
- supply_register (regi, (char *) (regp + (regi - IA64_GR0_REGNUM)));
+ regcache_raw_supply (current_regcache, regi,
+ (char *) (regp + (regi - IA64_GR0_REGNUM)));
}
/* FIXME: NAT collection bits are at index 32; gotta deal with these
somehow... */
- supply_register (IA64_PR_REGNUM, (char *) (regp + 33));
+ regcache_raw_supply (current_regcache, IA64_PR_REGNUM, (char *) (regp + 33));
for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++)
{
- supply_register (regi, (char *) (regp + 34 + (regi - IA64_BR0_REGNUM)));
+ regcache_raw_supply (current_regcache, regi,
+ (char *) (regp + 34 + (regi - IA64_BR0_REGNUM)));
}
- supply_register (IA64_IP_REGNUM, (char *) (regp + 42));
- supply_register (IA64_CFM_REGNUM, (char *) (regp + 43));
- supply_register (IA64_PSR_REGNUM, (char *) (regp + 44));
- supply_register (IA64_RSC_REGNUM, (char *) (regp + 45));
- supply_register (IA64_BSP_REGNUM, (char *) (regp + 46));
- supply_register (IA64_BSPSTORE_REGNUM, (char *) (regp + 47));
- supply_register (IA64_RNAT_REGNUM, (char *) (regp + 48));
- supply_register (IA64_CCV_REGNUM, (char *) (regp + 49));
- supply_register (IA64_UNAT_REGNUM, (char *) (regp + 50));
- supply_register (IA64_FPSR_REGNUM, (char *) (regp + 51));
- supply_register (IA64_PFS_REGNUM, (char *) (regp + 52));
- supply_register (IA64_LC_REGNUM, (char *) (regp + 53));
- supply_register (IA64_EC_REGNUM, (char *) (regp + 54));
+ regcache_raw_supply (current_regcache, IA64_IP_REGNUM,
+ (char *) (regp + 42));
+ regcache_raw_supply (current_regcache, IA64_CFM_REGNUM,
+ (char *) (regp + 43));
+ regcache_raw_supply (current_regcache, IA64_PSR_REGNUM,
+ (char *) (regp + 44));
+ regcache_raw_supply (current_regcache, IA64_RSC_REGNUM,
+ (char *) (regp + 45));
+ regcache_raw_supply (current_regcache, IA64_BSP_REGNUM,
+ (char *) (regp + 46));
+ regcache_raw_supply (current_regcache, IA64_BSPSTORE_REGNUM,
+ (char *) (regp + 47));
+ regcache_raw_supply (current_regcache, IA64_RNAT_REGNUM,
+ (char *) (regp + 48));
+ regcache_raw_supply (current_regcache, IA64_CCV_REGNUM,
+ (char *) (regp + 49));
+ regcache_raw_supply (current_regcache, IA64_UNAT_REGNUM,
+ (char *) (regp + 50));
+ regcache_raw_supply (current_regcache, IA64_FPSR_REGNUM,
+ (char *) (regp + 51));
+ regcache_raw_supply (current_regcache, IA64_PFS_REGNUM,
+ (char *) (regp + 52));
+ regcache_raw_supply (current_regcache, IA64_LC_REGNUM,
+ (char *) (regp + 53));
+ regcache_raw_supply (current_regcache, IA64_EC_REGNUM,
+ (char *) (regp + 54));
}
void
@@ -448,7 +463,7 @@ supply_fpregset (fpregset_t *fpregsetp)
for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
{
from = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
- supply_register (regi, from);
+ regcache_raw_supply (current_regcache, regi, from);
}
}
Index: infptrace.c
===================================================================
RCS file: /cvs/src/src/gdb/infptrace.c,v
retrieving revision 1.31
diff -p -u -r1.31 infptrace.c
--- infptrace.c 9 Jun 2004 20:09:42 -0000 1.31
+++ infptrace.c 22 Jul 2004 01:27:05 -0000
@@ -375,7 +375,7 @@ fetch_register (int regno)
if (CANNOT_FETCH_REGISTER (regno))
{
memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno)); /* Supply zeroes */
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
return;
}
@@ -399,7 +399,7 @@ fetch_register (int regno)
perror_with_name (mess);
}
}
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
Index: irix5-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/irix5-nat.c,v
retrieving revision 1.31
diff -p -u -r1.31 irix5-nat.c
--- irix5-nat.c 29 Apr 2004 18:28:42 -0000 1.31
+++ irix5-nat.c 22 Jul 2004 01:27:05 -0000
@@ -62,19 +62,20 @@ supply_gregset (gregset_t *gregsetp)
static char zerobuf[32] = {0};
for (regi = 0; regi <= CTX_RA; regi++)
- supply_register (regi, (char *) (regp + regi) + gregoff);
+ regcache_raw_supply (current_regcache, regi,
+ (char *) (regp + regi) + gregoff);
- supply_register (mips_regnum (current_gdbarch)->pc,
- (char *) (regp + CTX_EPC) + gregoff);
- supply_register (mips_regnum (current_gdbarch)->hi,
- (char *) (regp + CTX_MDHI) + gregoff);
- supply_register (mips_regnum (current_gdbarch)->lo,
- (char *) (regp + CTX_MDLO) + gregoff);
- supply_register (mips_regnum (current_gdbarch)->cause,
- (char *) (regp + CTX_CAUSE) + 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);
/* Fill inaccessible registers with zero. */
- supply_register (mips_regnum (current_gdbarch)->badvaddr, zerobuf);
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->badvaddr, zerobuf);
}
void
@@ -132,15 +133,17 @@ supply_fpregset (fpregset_t *fpregsetp)
/* FIXME, this is wrong for the N32 ABI which has 64 bit FP regs. */
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi,
- (char *) &fpregsetp->fp_r.fp_regs[regi]);
+ regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
+ (char *) &fpregsetp->fp_r.fp_regs[regi]);
- supply_register (mips_regnum (current_gdbarch)->fp_control_status,
- (char *) &fpregsetp->fp_csr);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_control_status,
+ (char *) &fpregsetp->fp_csr);
/* FIXME: how can we supply FCRIR? SGI doesn't tell us. */
- supply_register (mips_regnum (current_gdbarch)->fp_implementation_revision,
- zerobuf);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_implementation_revision,
+ zerobuf);
}
void
Index: lynx-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/lynx-nat.c,v
retrieving revision 1.19
diff -p -u -r1.19 lynx-nat.c
--- lynx-nat.c 21 Apr 2004 17:47:10 -0000 1.19
+++ lynx-nat.c 22 Jul 2004 01:27:05 -0000
@@ -325,7 +325,7 @@ fetch_inferior_registers (int regno)
*(int *) &buf[i] = reg;
}
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
}
}
@@ -593,8 +593,8 @@ fetch_core_registers (char *core_reg_sec
for (regno = 0; regno < NUM_REGS; regno++)
if (regmap[regno] != -1)
- supply_register (regno, core_reg_sect + offsetof (st_t, ec)
- + regmap[regno]);
+ regcache_raw_supply (current_regcache, regno,
+ core_reg_sect + offsetof (st_t, ec) + regmap[regno]);
#ifdef SPARC
/* Fetching this register causes all of the I & L regs to be read from the
Index: m32r-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/m32r-rom.c,v
retrieving revision 1.14
diff -p -u -r1.14 m32r-rom.c
--- m32r-rom.c 27 Jan 2004 23:19:51 -0000 1.14
+++ m32r-rom.c 22 Jul 2004 01:27:05 -0000
@@ -319,7 +319,7 @@ init_m32r_cmds (void)
m32r_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
m32r_cmds.dump_registers = ".reg\r"; /* dump_registers */
m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
- m32r_cmds.supply_register = m32r_supply_register; /* supply_register */
+ m32r_cmds.supply_register = m32r_supply_register;
m32r_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
m32r_cmds.load = NULL; /* download command */
m32r_cmds.loadresp = NULL; /* load response */
@@ -379,7 +379,7 @@ init_mon2000_cmds (void)
mon2000_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
mon2000_cmds.dump_registers = ".reg\r"; /* dump_registers */
mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
- mon2000_cmds.supply_register = m32r_supply_register; /* supply_register */
+ mon2000_cmds.supply_register = m32r_supply_register;
mon2000_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
mon2000_cmds.load = NULL; /* download command */
mon2000_cmds.loadresp = NULL; /* load response */
Index: m68k-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/m68k-tdep.c,v
retrieving revision 1.92
diff -p -u -r1.92 m68k-tdep.c
--- m68k-tdep.c 7 Jun 2004 02:02:51 -0000 1.92
+++ m68k-tdep.c 22 Jul 2004 01:27:06 -0000
@@ -963,10 +963,10 @@ supply_gregset (gregset_t *gregsetp)
for (regi = 0; regi < R_PC; regi++)
{
- supply_register (regi, (char *) (regp + regi));
+ regcache_raw_supply (current_regcache, regi, (char *) (regp + regi));
}
- supply_register (PS_REGNUM, (char *) (regp + R_PS));
- supply_register (PC_REGNUM, (char *) (regp + R_PC));
+ regcache_raw_supply (current_regcache, PS_REGNUM, (char *) (regp + R_PS));
+ regcache_raw_supply (current_regcache, PC_REGNUM, (char *) (regp + R_PC));
}
void
@@ -1001,11 +1001,14 @@ supply_fpregset (fpregset_t *fpregsetp)
for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
{
from = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
- supply_register (regi, from);
+ regcache_raw_supply (current_regcache, regi, from);
}
- supply_register (M68K_FPC_REGNUM, (char *) &(fpregsetp->f_pcr));
- supply_register (M68K_FPS_REGNUM, (char *) &(fpregsetp->f_psr));
- supply_register (M68K_FPI_REGNUM, (char *) &(fpregsetp->f_fpiaddr));
+ regcache_raw_supply (current_regcache, M68K_FPC_REGNUM,
+ (char *) &(fpregsetp->f_pcr));
+ regcache_raw_supply (current_regcache, M68K_FPS_REGNUM,
+ (char *) &(fpregsetp->f_psr));
+ regcache_raw_supply (current_regcache, M68K_FPI_REGNUM,
+ (char *) &(fpregsetp->f_fpiaddr));
}
/* Given a pointer to a floating point register set in /proc format
Index: m68klinux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/m68klinux-nat.c,v
retrieving revision 1.23
diff -p -u -r1.23 m68klinux-nat.c
--- m68klinux-nat.c 21 Apr 2004 17:47:10 -0000 1.23
+++ m68klinux-nat.c 22 Jul 2004 01:27:06 -0000
@@ -141,7 +141,7 @@ fetch_register (int regno)
if (CANNOT_FETCH_REGISTER (regno))
{
memset (buf, '\0', register_size (current_gdbarch, regno)); /* Supply zeroes */
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
return;
}
@@ -167,7 +167,7 @@ fetch_register (int regno)
perror_with_name (mess);
}
}
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
/* Fetch register values from the inferior.
@@ -282,9 +282,9 @@ supply_gregset (elf_gregset_t *gregsetp)
int regi;
for (regi = M68K_D0_REGNUM; regi <= SP_REGNUM; regi++)
- supply_register (regi, (char *) ®p[regmap[regi]]);
- supply_register (PS_REGNUM, (char *) ®p[PT_SR]);
- supply_register (PC_REGNUM, (char *) ®p[PT_PC]);
+ regcache_raw_supply (current_regcache, regi, (char *) ®p[regmap[regi]]);
+ regcache_raw_supply (current_regcache, PS_REGNUM, (char *) ®p[PT_SR]);
+ regcache_raw_supply (current_regcache, PC_REGNUM, (char *) ®p[PT_PC]);
}
/* Fill register REGNO (if it is a general-purpose register) in
@@ -366,10 +366,14 @@ supply_fpregset (elf_fpregset_t *fpregse
int regi;
for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++)
- supply_register (regi, FPREG_ADDR (fpregsetp, regi - FP0_REGNUM));
- supply_register (M68K_FPC_REGNUM, (char *) &fpregsetp->fpcntl[0]);
- supply_register (M68K_FPS_REGNUM, (char *) &fpregsetp->fpcntl[1]);
- supply_register (M68K_FPI_REGNUM, (char *) &fpregsetp->fpcntl[2]);
+ regcache_raw_supply (current_regcache, regi,
+ FPREG_ADDR (fpregsetp, regi - FP0_REGNUM));
+ regcache_raw_supply (current_regcache, M68K_FPC_REGNUM,
+ (char *) &fpregsetp->fpcntl[0]);
+ regcache_raw_supply (current_regcache, M68K_FPS_REGNUM,
+ (char *) &fpregsetp->fpcntl[1]);
+ regcache_raw_supply (current_regcache, M68K_FPI_REGNUM,
+ (char *) &fpregsetp->fpcntl[2]);
}
/* Fill register REGNO (if it is a floating-point register) in
Index: mips-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-linux-tdep.c,v
retrieving revision 1.25
diff -p -u -r1.25 mips-linux-tdep.c
--- mips-linux-tdep.c 20 Jul 2004 15:11:36 -0000 1.25
+++ mips-linux-tdep.c 22 Jul 2004 01:27:06 -0000
@@ -89,8 +89,8 @@ mips_linux_get_longjmp_target (CORE_ADDR
}
/* Transform the bits comprising a 32-bit register to the right size
- for supply_register(). This is needed when mips_isa_regsize() is
- 8. */
+ for regcache_raw_supply(). This is needed when mips_isa_regsize()
+ is 8. */
static void
supply_32bit_reg (int regnum, const void *addr)
@@ -98,7 +98,7 @@ supply_32bit_reg (int regnum, const void
char buf[MAX_REGISTER_SIZE];
store_signed_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum),
extract_signed_integer (addr, 4));
- supply_register (regnum, buf);
+ regcache_raw_supply (current_regcache, regnum, buf);
}
/* Unpack an elf_gregset_t into GDB's register cache. */
@@ -129,9 +129,9 @@ supply_gregset (elf_gregset_t *gregsetp)
(char *)(regp + EF_CP0_CAUSE));
/* Fill inaccessible registers with zero. */
- supply_register (UNUSED_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, UNUSED_REGNUM, zerobuf);
for (regi = FIRST_EMBED_REGNUM; regi < LAST_EMBED_REGNUM; regi++)
- supply_register (regi, zerobuf);
+ regcache_raw_supply (current_regcache, regi, zerobuf);
}
/* Pack our registers (or one register) into an elf_gregset_t. */
@@ -198,15 +198,17 @@ supply_fpregset (elf_fpregset_t *fpregse
memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi,
- (char *)(*fpregsetp + regi));
+ regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
+ (char *)(*fpregsetp + regi));
- supply_register (mips_regnum (current_gdbarch)->fp_control_status,
- (char *)(*fpregsetp + 32));
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_control_status,
+ (char *)(*fpregsetp + 32));
/* FIXME: how can we supply FCRIR? The ABI doesn't tell us. */
- supply_register (mips_regnum (current_gdbarch)->fp_implementation_revision,
- zerobuf);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_implementation_revision,
+ zerobuf);
}
/* Likewise, pack one or all floating point registers into an
@@ -388,25 +390,27 @@ mips64_supply_gregset (mips64_elf_gregse
memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = MIPS64_EF_REG0; regi <= MIPS64_EF_REG31; regi++)
- supply_register ((regi - MIPS64_EF_REG0), (char *)(regp + regi));
+ regcache_raw_supply (current_regcache, (regi - MIPS64_EF_REG0),
+ (char *)(regp + regi));
- supply_register (mips_regnum (current_gdbarch)->lo,
- (char *)(regp + MIPS64_EF_LO));
- supply_register (mips_regnum (current_gdbarch)->hi,
- (char *)(regp + MIPS64_EF_HI));
-
- supply_register (mips_regnum (current_gdbarch)->pc,
- (char *)(regp + MIPS64_EF_CP0_EPC));
- supply_register (mips_regnum (current_gdbarch)->badvaddr,
- (char *)(regp + MIPS64_EF_CP0_BADVADDR));
- supply_register (PS_REGNUM, (char *)(regp + MIPS64_EF_CP0_STATUS));
- supply_register (mips_regnum (current_gdbarch)->cause,
- (char *)(regp + MIPS64_EF_CP0_CAUSE));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
+ (char *)(regp + MIPS64_EF_LO));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
+ (char *)(regp + MIPS64_EF_HI));
+
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
+ (char *)(regp + MIPS64_EF_CP0_EPC));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->badvaddr,
+ (char *)(regp + MIPS64_EF_CP0_BADVADDR));
+ regcache_raw_supply (current_regcache, PS_REGNUM,
+ (char *)(regp + MIPS64_EF_CP0_STATUS));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
+ (char *)(regp + MIPS64_EF_CP0_CAUSE));
/* Fill inaccessible registers with zero. */
- supply_register (UNUSED_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, UNUSED_REGNUM, zerobuf);
for (regi = FIRST_EMBED_REGNUM; regi < LAST_EMBED_REGNUM; regi++)
- supply_register (regi, zerobuf);
+ regcache_raw_supply (current_regcache, regi, zerobuf);
}
/* Pack our registers (or one register) into an elf_gregset_t. */
@@ -473,15 +477,17 @@ mips64_supply_fpregset (mips64_elf_fpreg
memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = 0; regi < 32; regi++)
- supply_register (FP0_REGNUM + regi,
- (char *)(*fpregsetp + regi));
+ regcache_raw_supply (current_regcache, FP0_REGNUM + regi,
+ (char *)(*fpregsetp + regi));
- supply_register (mips_regnum (current_gdbarch)->fp_control_status,
- (char *)(*fpregsetp + 32));
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_control_status,
+ (char *)(*fpregsetp + 32));
/* FIXME: how can we supply FCRIR? The ABI doesn't tell us. */
- supply_register (mips_regnum (current_gdbarch)->fp_implementation_revision,
- zerobuf);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_implementation_revision,
+ zerobuf);
}
/* Likewise, pack one or all floating point registers into an
Index: mips-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mips-nat.c,v
retrieving revision 1.17
diff -p -u -r1.17 mips-nat.c
--- mips-nat.c 21 Apr 2004 17:47:10 -0000 1.17
+++ mips-nat.c 22 Jul 2004 01:27:07 -0000
@@ -89,12 +89,12 @@ fetch_inferior_registers (int regno)
(PTRACE_ARG3_TYPE) regaddr, 0);
regaddr += sizeof (int);
}
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
- supply_register (ZERO_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, ZERO_REGNUM, zerobuf);
/* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
- supply_register (DEPRECATED_FP_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, zerobuf);
}
/* Store our register values back into the inferior.
@@ -206,16 +206,16 @@ fetch_core_registers (char *core_reg_sec
}
else
{
- supply_register (regno, core_reg_sect + addr);
+ regcache_raw_supply (current_regcache, regno, core_reg_sect + addr);
}
}
if (bad_reg >= 0)
{
error ("Register %s not found in core file.", REGISTER_NAME (bad_reg));
}
- supply_register (ZERO_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, ZERO_REGNUM, zerobuf);
/* Frame ptr reg must appear to be 0; it is faked by stack handling code. */
- supply_register (DEPRECATED_FP_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, zerobuf);
}
/* Return the address in the core dump or inferior of register REGNO.
Index: mipsnbsd-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/mipsnbsd-tdep.c,v
retrieving revision 1.14
diff -p -u -r1.14 mipsnbsd-tdep.c
--- mipsnbsd-tdep.c 20 Jul 2004 19:45:06 -0000 1.14
+++ mipsnbsd-tdep.c 22 Jul 2004 01:27:07 -0000
@@ -45,9 +45,10 @@ mipsnbsd_supply_reg (char *regs, int reg
if (regno == i || regno == -1)
{
if (CANNOT_FETCH_REGISTER (i))
- supply_register (i, NULL);
+ regcache_raw_supply (current_regcache, i, NULL);
else
- supply_register (i, regs + (i * mips_isa_regsize (current_gdbarch)));
+ regcache_raw_supply (current_regcache, i,
+ regs + (i * mips_isa_regsize (current_gdbarch)));
}
}
}
@@ -74,9 +75,10 @@ mipsnbsd_supply_fpreg (char *fpregs, int
if (regno == i || regno == -1)
{
if (CANNOT_FETCH_REGISTER (i))
- supply_register (i, NULL);
+ regcache_raw_supply (current_regcache, i, NULL);
else
- supply_register (i, fpregs + ((i - FP0_REGNUM) * mips_isa_regsize (current_gdbarch)));
+ regcache_raw_supply (current_regcache, i,
+ fpregs + ((i - FP0_REGNUM) * mips_isa_regsize (current_gdbarch)));
}
}
}
Index: mipsv4-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/mipsv4-nat.c,v
retrieving revision 1.15
diff -p -u -r1.15 mipsv4-nat.c
--- mipsv4-nat.c 16 Nov 2003 19:24:05 -0000 1.15
+++ mipsv4-nat.c 22 Jul 2004 01:27:07 -0000
@@ -51,24 +51,26 @@ supply_gregset (gregset_t *gregsetp)
memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = 0; regi <= CXT_RA; regi++)
- supply_register (regi, (char *) (regp + regi));
+ regcache_raw_supply (current_regcache, regi, (char *) (regp + regi));
- supply_register (mips_regnum (current_gdbarch)->pc,
- (char *) (regp + CXT_EPC));
- supply_register (mips_regnum (current_gdbarch)->hi,
- (char *) (regp + CXT_MDHI));
- supply_register (mips_regnum (current_gdbarch)->lo,
- (char *) (regp + CXT_MDLO));
- supply_register (mips_regnum (current_gdbarch)->cause,
- (char *) (regp + CXT_CAUSE));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->pc,
+ (char *) (regp + CXT_EPC));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->hi,
+ (char *) (regp + CXT_MDHI));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->lo,
+ (char *) (regp + CXT_MDLO));
+ regcache_raw_supply (current_regcache, mips_regnum (current_gdbarch)->cause,
+ (char *) (regp + CXT_CAUSE));
/* Fill inaccessible registers with zero. */
- supply_register (PS_REGNUM, zerobuf);
- supply_register (mips_regnum (current_gdbarch)->badvaddr, zerobuf);
- supply_register (DEPRECATED_FP_REGNUM, zerobuf);
- supply_register (UNUSED_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, PS_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->badvaddr,
+ zerobuf);
+ regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, zerobuf);
+ regcache_raw_supply (current_regcache, UNUSED_REGNUM, zerobuf);
for (regi = FIRST_EMBED_REGNUM; regi <= LAST_EMBED_REGNUM; regi++)
- supply_register (regi, zerobuf);
+ regcache_raw_supply (current_regcache, regi, zerobuf);
}
void
@@ -110,15 +112,18 @@ supply_fpregset (fpregset_t *fpregsetp)
memset (zerobuf, 0, MAX_REGISTER_SIZE);
for (regi = 0; regi < 32; regi++)
- supply_register (mips_regnum (current_gdbarch)->fp0 + regi,
- (char *) &fpregsetp->fp_r.fp_regs[regi]);
-
- supply_register (mips_regnum (current_gdbarch)->fp_control_status,
- (char *) &fpregsetp->fp_csr);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp0 + regi,
+ (char *) &fpregsetp->fp_r.fp_regs[regi]);
+
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_control_status,
+ (char *) &fpregsetp->fp_csr);
/* FIXME: how can we supply FCRIR? The ABI doesn't tell us. */
- supply_register (mips_regnum (current_gdbarch)->fp_implementation_revision,
- zerobuf);
+ regcache_raw_supply (current_regcache,
+ mips_regnum (current_gdbarch)->fp_implementation_revision,
+ zerobuf);
}
void
Index: monitor.c
===================================================================
RCS file: /cvs/src/src/gdb/monitor.c,v
retrieving revision 1.48
diff -p -u -r1.48 monitor.c
--- monitor.c 10 Jul 2004 01:17:52 -0000 1.48
+++ monitor.c 22 Jul 2004 01:27:08 -0000
@@ -923,7 +923,7 @@ monitor_supply_register (int regno, char
store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
- supply_register (regno, regbuf);
+ regcache_raw_supply (current_regcache, regno, regbuf);
return p;
}
@@ -1184,7 +1184,7 @@ monitor_fetch_register (int regno)
if (!name || (*name == '\0'))
{
monitor_debug ("No register known for %d\n", regno);
- supply_register (regno, zerobuf);
+ regcache_raw_supply (current_regcache, regno, zerobuf);
return;
}
Index: ppc-bdm.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-bdm.c,v
retrieving revision 1.24
diff -p -u -r1.24 ppc-bdm.c
--- ppc-bdm.c 11 May 2004 06:12:55 -0000 1.24
+++ ppc-bdm.c 22 Jul 2004 01:27:08 -0000
@@ -180,7 +180,7 @@ bdm_ppc_fetch_registers (int regno)
if (first_bdm_regno == -1)
{
- supply_register (first_regno, NULL);
+ regcache_raw_supply (current_regcache, first_regno, NULL);
return; /* Unsupported register */
}
@@ -204,7 +204,7 @@ bdm_ppc_fetch_registers (int regno)
&& (first_regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
{
/* printf("invalid reg request!\n"); */
- supply_register (first_regno, NULL);
+ regcache_raw_supply (current_regcache, first_regno, NULL);
return; /* Unsupported register */
}
else
@@ -235,10 +235,10 @@ bdm_ppc_fetch_registers (int regno)
if (regoffset >= reglen / 4)
continue;
- supply_register (i, regs + 4 * regoffset);
+ regcache_raw_supply (current_regcache, i, regs + 4 * regoffset);
}
else
- supply_register (i, NULL); /* Unsupported register */
+ regcache_raw_supply (current_regcache, i, NULL); /* Unsupported register */
}
}
Index: ppc-linux-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-nat.c,v
retrieving revision 1.47
diff -p -u -r1.47 ppc-linux-nat.c
--- ppc-linux-nat.c 17 Jul 2004 14:24:07 -0000 1.47
+++ ppc-linux-nat.c 22 Jul 2004 01:27:08 -0000
@@ -249,8 +249,8 @@ fetch_altivec_register (int tid, int reg
if (regno == (tdep->ppc_vrsave_regnum - 1))
offset = vrregsize - DEPRECATED_REGISTER_RAW_SIZE (tdep->ppc_vrsave_regnum);
- supply_register (regno,
- regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
+ regcache_raw_supply (current_regcache, regno,
+ regs + (regno - tdep->ppc_vr0_regnum) * vrregsize + offset);
}
/* Fetch the top 32 bits of TID's general-purpose registers and the
@@ -366,19 +366,19 @@ fetch_spe_register (int tid, int regno)
{
char buf[MAX_REGISTER_SIZE];
read_spliced_spe_reg (tid, regno, &evrregs, buf);
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
else if (regno == tdep->ppc_acc_regnum)
{
gdb_assert (sizeof (evrregs.acc)
== register_size (current_gdbarch, regno));
- supply_register (regno, &evrregs.acc);
+ regcache_raw_supply (current_regcache, regno, &evrregs.acc);
}
else if (regno == tdep->ppc_spefscr_regnum)
{
gdb_assert (sizeof (evrregs.spefscr)
== register_size (current_gdbarch, regno));
- supply_register (regno, &evrregs.spefscr);
+ regcache_raw_supply (current_regcache, regno, &evrregs.spefscr);
}
else
gdb_assert (0);
@@ -424,7 +424,7 @@ fetch_register (int tid, int regno)
if (regaddr == -1)
{
memset (buf, '\0', DEPRECATED_REGISTER_RAW_SIZE (regno)); /* Supply zeroes */
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
return;
}
@@ -485,10 +485,11 @@ supply_vrregset (gdb_vrregset_t *vrregse
occupies a whole vector, while VRSAVE occupies a full 4 bytes
slot. */
if (i == (num_of_vrregs - 2))
- supply_register (tdep->ppc_vr0_regnum + i,
- *vrregsetp + i * vrregsize + offset);
+ regcache_raw_supply (current_regcache, tdep->ppc_vr0_regnum + i,
+ *vrregsetp + i * vrregsize + offset);
else
- supply_register (tdep->ppc_vr0_regnum + i, *vrregsetp + i * vrregsize);
+ regcache_raw_supply (current_regcache, tdep->ppc_vr0_regnum + i,
+ *vrregsetp + i * vrregsize);
}
}
@@ -529,12 +530,13 @@ fetch_spe_registers (int tid)
char buf[MAX_REGISTER_SIZE];
read_spliced_spe_reg (tid, tdep->ppc_ev0_regnum + i, &evrregs, buf);
- supply_register (tdep->ppc_ev0_regnum + i, buf);
+ regcache_raw_supply (current_regcache, tdep->ppc_ev0_regnum + i, buf);
}
/* Supply the SPE-specific registers. */
- supply_register (tdep->ppc_acc_regnum, &evrregs.acc);
- supply_register (tdep->ppc_spefscr_regnum, &evrregs.spefscr);
+ regcache_raw_supply (current_regcache, tdep->ppc_acc_regnum, &evrregs.acc);
+ regcache_raw_supply (current_regcache, tdep->ppc_spefscr_regnum,
+ &evrregs.spefscr);
}
static void
Index: ppc-linux-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppc-linux-tdep.c,v
retrieving revision 1.64
diff -p -u -r1.64 ppc-linux-tdep.c
--- ppc-linux-tdep.c 17 Jul 2004 14:15:30 -0000 1.64
+++ ppc-linux-tdep.c 22 Jul 2004 01:27:08 -0000
@@ -842,8 +842,7 @@ right_supply_register (struct regcache *
const bfd_byte *buf)
{
regcache_raw_supply (regcache, regnum,
- (buf + wordsize
- - register_size (current_gdbarch, regnum)));
+ (buf + wordsize - register_size (current_gdbarch, regnum)));
}
/* Extract the register values found in the WORDSIZED ABI GREGSET,
Index: ppcbug-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/ppcbug-rom.c,v
retrieving revision 1.6
diff -p -u -r1.6 ppcbug-rom.c
--- ppcbug-rom.c 11 Jun 2003 13:16:28 -0000 1.6
+++ ppcbug-rom.c 22 Jul 2004 01:27:08 -0000
@@ -166,7 +166,7 @@ init_ppc_cmds (char *LOAD_CMD,
OPS->getreg.term = NULL; /* getreg.term */
OPS->getreg.term_cmd = NULL; /* getreg.term_cmd */
OPS->register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
- OPS->supply_register = ppcbug_supply_register; /* supply_register */
+ OPS->supply_register = ppcbug_supply_register;
OPS->dump_registers = "rd\r"; /* dump all registers */
OPS->load_routine = NULL; /* load_routine (defaults to SRECs) */
OPS->load = LOAD_CMD; /* download command */
Index: ppcnbsd-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/ppcnbsd-tdep.c,v
retrieving revision 1.23
diff -p -u -r1.23 ppcnbsd-tdep.c
--- ppcnbsd-tdep.c 20 Jul 2004 15:11:37 -0000 1.23
+++ ppcnbsd-tdep.c 22 Jul 2004 01:27:08 -0000
@@ -58,24 +58,29 @@ ppcnbsd_supply_reg (char *regs, int regn
for (i = 0; i < ppc_num_gprs; i++)
{
if (regno == tdep->ppc_gp0_regnum + i || regno == -1)
- supply_register (tdep->ppc_gp0_regnum + i,
- regs + REG_FIXREG_OFFSET (i));
+ regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + i,
+ regs + REG_FIXREG_OFFSET (i));
}
if (regno == tdep->ppc_lr_regnum || regno == -1)
- supply_register (tdep->ppc_lr_regnum, regs + REG_LR_OFFSET);
+ regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
+ regs + REG_LR_OFFSET);
if (regno == tdep->ppc_cr_regnum || regno == -1)
- supply_register (tdep->ppc_cr_regnum, regs + REG_CR_OFFSET);
+ regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
+ regs + REG_CR_OFFSET);
if (regno == tdep->ppc_xer_regnum || regno == -1)
- supply_register (tdep->ppc_xer_regnum, regs + REG_XER_OFFSET);
+ regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
+ regs + REG_XER_OFFSET);
if (regno == tdep->ppc_ctr_regnum || regno == -1)
- supply_register (tdep->ppc_ctr_regnum, regs + REG_CTR_OFFSET);
+ regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
+ regs + REG_CTR_OFFSET);
if (regno == PC_REGNUM || regno == -1)
- supply_register (PC_REGNUM, regs + REG_PC_OFFSET);
+ regcache_raw_supply (current_regcache, PC_REGNUM,
+ regs + REG_PC_OFFSET);
}
void
@@ -128,12 +133,13 @@ ppcnbsd_supply_fpreg (char *fpregs, int
for (i = 0; i < ppc_num_fprs; i++)
{
if (regno == tdep->ppc_fp0_regnum + i || regno == -1)
- supply_register (tdep->ppc_fp0_regnum + i,
- fpregs + FPREG_FPR_OFFSET (i));
+ regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + i,
+ fpregs + FPREG_FPR_OFFSET (i));
}
if (regno == tdep->ppc_fpscr_regnum || regno == -1)
- supply_register (tdep->ppc_fpscr_regnum, fpregs + FPREG_FPSCR_OFFSET);
+ regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ fpregs + FPREG_FPSCR_OFFSET);
}
void
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.116
diff -p -u -r1.116 regcache.c
--- regcache.c 10 Jul 2004 01:17:52 -0000 1.116
+++ regcache.c 22 Jul 2004 01:27:11 -0000
@@ -611,12 +611,9 @@ registers_changed (void)
Indicate that all registers have been fetched, so mark them all valid. */
-/* NOTE: cagney/2001-12-04: This function does not set valid on the
- pseudo-register range since pseudo registers are always supplied
- using supply_register(). */
/* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
code was blatting the registers[] array and then calling this.
- Since targets should only be using supply_register() the need for
+ Since targets should only be using regcache_raw_supply() the need for
this function/hack is eliminated. */
void
@@ -1221,26 +1218,6 @@ write_register_pid (int regnum, CORE_ADD
inferior_ptid = save_ptid;
}
-/* FIXME: kettenis/20030828: We should get rid of supply_register and
- regcache_collect in favour of regcache_raw_supply and
- regcache_raw_collect. */
-
-/* SUPPLY_REGISTER()
-
- Record that register REGNUM contains VAL. This is used when the
- value is obtained from the inferior or core dump, so there is no
- need to store the value there.
-
- If VAL is a NULL pointer, then it's probably an unsupported register.
- We just set its value to all zeros. We might want to record this
- fact, and report it to the users of read_register and friends. */
-
-void
-supply_register (int regnum, const void *val)
-{
- regcache_raw_supply (current_regcache, regnum, val);
-}
-
void
regcache_collect (int regnum, void *buf)
{
Index: regcache.h
===================================================================
RCS file: /cvs/src/src/gdb/regcache.h,v
retrieving revision 1.40
diff -p -u -r1.40 regcache.h
--- regcache.h 24 Oct 2003 17:37:03 -0000 1.40
+++ regcache.h 22 Jul 2004 01:27:11 -0000
@@ -96,7 +96,6 @@ void regcache_cooked_write_part (struct
target. These functions are called by the target in response to a
target_fetch_registers() or target_store_registers(). */
-extern void supply_register (int regnum, const void *val);
extern void regcache_collect (int regnum, void *buf);
extern void regcache_raw_supply (struct regcache *regcache,
int regnum, const void *buf);
@@ -216,7 +215,7 @@ extern void deprecated_write_register_by
referenced thread. This global is often found in close proximity
to code that is directly manipulating the deprecated_registers[]
array. In such cases, it should be possible to replace the lot
- with a call to supply_register(). If you find yourself in dire
+ with a call to regcache_raw_supply(). If you find yourself in dire
straits, still needing access to the cache status bit, the
regcache_valid_p() and set_register_cached() functions are
available. */
@@ -226,13 +225,14 @@ extern signed char *deprecated_register_
registers for the most recently referenced thread.
NOTE: cagney/2002-11-14: Target side code should be using
- supply_register() and/or regcache_collect() while architecture side
- code should use the more generic regcache methods. */
+ regcache_raw_supply() and/or regcache_collect() while architecture
+ side code should use the more generic regcache methods. */
extern char *deprecated_registers;
/* NOTE: cagney/2002-11-05: This function, and its co-conspirator
- deprecated_registers[], have been superseeded by supply_register(). */
+ deprecated_registers[], have been superseeded by
+ regcache_raw_supply(). */
extern void deprecated_registers_fetched (void);
extern int register_cached (int regnum);
Index: remote-e7000.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-e7000.c,v
retrieving revision 1.42
diff -p -u -r1.42 remote-e7000.c
--- remote-e7000.c 15 Jun 2004 01:04:19 -0000 1.42
+++ remote-e7000.c 22 Jul 2004 01:27:11 -0000
@@ -362,7 +362,7 @@ get_hex_regs (int n, int regno)
val = 0;
for (j = 0; j < 8; j++)
val = (val << 4) + get_hex_digit (j == 0);
- supply_register (regno++, (char *) &val);
+ regcache_raw_supply (current_regcache, regno++, (char *) &val);
}
}
#endif
@@ -881,7 +881,7 @@ fetch_regs_from_dump (int (*nextchar) ()
store_signed_integer (buf,
DEPRECATED_REGISTER_RAW_SIZE (regno),
(LONGEST) get_hex (&thischar));
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
break;
}
}
@@ -926,7 +926,7 @@ e7000_fetch_registers (void)
{
int buf = 0;
- supply_register (regno, (char *) (&buf));
+ regcache_raw_supply (current_regcache, regno, (char *) (&buf));
}
}
@@ -1966,7 +1966,7 @@ sub2_from_pc (void)
store_signed_integer (buf,
DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM),
read_register (PC_REGNUM) - 2);
- supply_register (PC_REGNUM, buf);
+ regcache_raw_supply (current_regcache, PC_REGNUM, buf);
sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0));
puts_e7000debug (buf2);
}
@@ -2064,7 +2064,7 @@ e7000_wait (ptid_t ptid, struct target_w
for (regno = NUM_REALREGS; regno < NUM_REGS; regno++)
{
int buf = 0;
- supply_register (regno, (char *) &buf);
+ regcache_raw_supply (current_regcache, regno, (char *) &buf);
}
stop_reason = why_stop ();
Index: remote-est.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-est.c,v
retrieving revision 1.9
diff -p -u -r1.9 remote-est.c
--- remote-est.c 11 Jun 2003 13:16:28 -0000 1.9
+++ remote-est.c 22 Jul 2004 01:27:11 -0000
@@ -148,7 +148,7 @@ init_est_cmds (void)
est_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
est_cmds.dump_registers = "dr\r"; /* dump_registers */
est_cmds.register_pattern = "\\(\\w+\\) = \\([0-9a-fA-F]+\\)"; /* register_pattern */
- est_cmds.supply_register = est_supply_register; /* supply_register */
+ est_cmds.supply_register = est_supply_register;
est_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
est_cmds.load = "dl\r"; /* download command */
est_cmds.loadresp = "+"; /* load response */
Index: remote-hms.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-hms.c,v
retrieving revision 1.8
diff -p -u -r1.8 remote-hms.c
--- remote-hms.c 10 Oct 2003 07:13:10 -0000 1.8
+++ remote-hms.c 22 Jul 2004 01:27:11 -0000
@@ -119,7 +119,7 @@ init_hms_cmds (void)
hms_cmds.getreg.term_cmd = "\003"; /* getreg.term_cmd */
hms_cmds.dump_registers = "r\r"; /* dump_registers */
hms_cmds.register_pattern = "\\(\\w+\\)=\\([0-9a-fA-F]+\\)"; /* register_pattern */
- hms_cmds.supply_register = hms_supply_register; /* supply_register */
+ hms_cmds.supply_register = hms_supply_register;
hms_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
hms_cmds.load = "tl\r"; /* download command */
hms_cmds.loadresp = NULL; /* load response */
Index: remote-m32r-sdi.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-m32r-sdi.c,v
retrieving revision 1.5
diff -p -u -r1.5 remote-m32r-sdi.c
--- remote-m32r-sdi.c 16 Jul 2004 21:16:48 -0000 1.5
+++ remote-m32r-sdi.c 22 Jul 2004 01:27:12 -0000
@@ -965,7 +965,7 @@ m32r_fetch_register (int regno)
/* We got the number the register holds, but gdb expects to see a
value in the target byte ordering. */
store_unsigned_integer (buffer, 4, val);
- supply_register (regno, buffer);
+ regcache_raw_supply (current_regcache, regno, buffer);
}
return;
}
Index: remote-mips.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-mips.c,v
retrieving revision 1.48
diff -p -u -r1.48 remote-mips.c
--- remote-mips.c 15 Jun 2004 01:04:19 -0000 1.48
+++ remote-mips.c 22 Jul 2004 01:27:13 -0000
@@ -1758,16 +1758,16 @@ mips_wait (ptid_t ptid, struct target_wa
char buf[MAX_REGISTER_SIZE];
store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rpc);
- supply_register (PC_REGNUM, buf);
+ regcache_raw_supply (current_regcache, PC_REGNUM, buf);
store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rfp);
- supply_register (30, buf); /* This register they are avoiding and so it is unnamed */
+ regcache_raw_supply (current_regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM), rsp);
- supply_register (SP_REGNUM, buf);
+ regcache_raw_supply (current_regcache, SP_REGNUM, buf);
store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
- supply_register (DEPRECATED_FP_REGNUM, buf);
+ regcache_raw_supply (current_regcache, DEPRECATED_FP_REGNUM, buf);
if (nfields == 9)
{
@@ -1939,7 +1939,7 @@ mips_fetch_registers (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, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
}
Index: remote-rdi.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-rdi.c,v
retrieving revision 1.32
diff -p -u -r1.32 remote-rdi.c
--- remote-rdi.c 25 May 2004 14:58:30 -0000 1.32
+++ remote-rdi.c 22 Jul 2004 01:27:14 -0000
@@ -496,10 +496,10 @@ arm_rdi_fetch_registers (int regno)
for (regno = 0; regno < 15; regno++)
{
store_unsigned_integer (cookedreg, 4, rawregs[regno]);
- supply_register (regno, (char *) cookedreg);
+ regcache_raw_supply (current_regcache, regno, (char *) cookedreg);
}
store_unsigned_integer (cookedreg, 4, rawregs[15]);
- supply_register (ARM_PS_REGNUM, (char *) cookedreg);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM, (char *) cookedreg);
arm_rdi_fetch_registers (ARM_PC_REGNUM);
}
else
@@ -511,7 +511,7 @@ arm_rdi_fetch_registers (int regno)
else if (regno < 0 || regno > 15)
{
rawreg = 0;
- supply_register (regno, (char *) &rawreg);
+ regcache_raw_supply (current_regcache, regno, (char *) &rawreg);
return;
}
else
@@ -523,7 +523,7 @@ arm_rdi_fetch_registers (int regno)
printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
}
store_unsigned_integer (cookedreg, 4, rawreg);
- supply_register (regno, (char *) cookedreg);
+ regcache_raw_supply (current_regcache, regno, (char *) cookedreg);
}
}
Index: remote-rdp.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-rdp.c,v
retrieving revision 1.39
diff -p -u -r1.39 remote-rdp.c
--- remote-rdp.c 28 Jun 2004 23:59:28 -0000 1.39
+++ remote-rdp.c 22 Jul 2004 01:27:14 -0000
@@ -645,7 +645,7 @@ remote_rdp_fetch_register (int regno)
{
printf ("Help me with fetch reg %d\n", regno);
}
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
}
}
Index: remote-sds.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-sds.c,v
retrieving revision 1.29
diff -p -u -r1.29 remote-sds.c
--- remote-sds.c 25 May 2004 14:58:30 -0000 1.29
+++ remote-sds.c 22 Jul 2004 01:27:14 -0000
@@ -482,7 +482,8 @@ sds_fetch_registers (int regno)
/* (should warn about reply too short) */
for (i = 0; i < NUM_REGS; i++)
- supply_register (i, ®s[DEPRECATED_REGISTER_BYTE (i)]);
+ regcache_raw_supply (current_regcache, i,
+ ®s[DEPRECATED_REGISTER_BYTE (i)]);
}
/* Prepare to store registers. Since we may send them all, we have to
Index: remote-sim.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-sim.c,v
retrieving revision 1.39
diff -p -u -r1.39 remote-sim.c
--- remote-sim.c 25 Jun 2004 19:46:08 -0000 1.39
+++ remote-sim.c 22 Jul 2004 01:27:14 -0000
@@ -304,7 +304,7 @@ gdbsim_fetch_register (int regno)
char buf[MAX_REGISTER_SIZE];
int nr_bytes;
memset (buf, 0, MAX_REGISTER_SIZE);
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
set_register_cached (regno, -1);
break;
}
@@ -332,7 +332,7 @@ gdbsim_fetch_register (int regno)
which registers are fetchable. */
/* Else if (nr_bytes < 0): an old simulator, that doesn't
think to return the register size. Just assume all is ok. */
- supply_register (regno, buf);
+ regcache_raw_supply (current_regcache, regno, buf);
if (sr_get_debug ())
{
printf_filtered ("gdbsim_fetch_register: %d", regno);
Index: remote-st.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-st.c,v
retrieving revision 1.20
diff -p -u -r1.20 remote-st.c
--- remote-st.c 25 May 2004 14:58:30 -0000 1.20
+++ remote-st.c 22 Jul 2004 01:27:14 -0000
@@ -222,7 +222,7 @@ get_hex_regs (int n, int regno)
val = 0;
for (j = 0; j < 8; j++)
val = (val << 4) + get_hex_digit (j == 0);
- supply_register (regno++, (char *) &val);
+ regcache_raw_supply (current_regcache, regno++, (char *) &val);
}
}
Index: remote.c
===================================================================
RCS file: /cvs/src/src/gdb/remote.c,v
retrieving revision 1.138
diff -p -u -r1.138 remote.c
--- remote.c 28 Jun 2004 23:59:28 -0000 1.138
+++ remote.c 22 Jul 2004 01:27:15 -0000
@@ -2883,7 +2883,7 @@ Packet: '%s'\n",
p += 2 * fieldsize;
if (fieldsize < DEPRECATED_REGISTER_RAW_SIZE (reg->regnum))
warning ("Remote reply is too short: %s", buf);
- supply_register (reg->regnum, regs);
+ regcache_raw_supply (current_regcache, reg->regnum, regs);
}
if (*p++ != ';')
@@ -3071,7 +3071,7 @@ remote_async_wait (ptid_t ptid, struct t
p += 2 * fieldsize;
if (fieldsize < DEPRECATED_REGISTER_RAW_SIZE (reg->regnum))
warning ("Remote reply is too short: %s", buf);
- supply_register (reg->regnum, regs);
+ regcache_raw_supply (current_regcache, reg->regnum, regs);
}
if (*p++ != ';')
Index: rom68k-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/rom68k-rom.c,v
retrieving revision 1.13
diff -p -u -r1.13 rom68k-rom.c
--- rom68k-rom.c 2 Oct 2003 20:28:30 -0000 1.13
+++ rom68k-rom.c 22 Jul 2004 01:27:15 -0000
@@ -102,7 +102,7 @@ rom68k_supply_one_register (int regno, u
hex++;
store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), value);
- supply_register (regno, regbuf);
+ regcache_raw_supply (current_regcache, regno, regbuf);
return hex;
}
Index: rs6000-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/rs6000-nat.c,v
retrieving revision 1.49
diff -p -u -r1.49 rs6000-nat.c
--- rs6000-nat.c 14 May 2004 14:12:12 -0000 1.49
+++ rs6000-nat.c 22 Jul 2004 01:27:15 -0000
@@ -263,7 +263,7 @@ fetch_register (int regno)
}
if (!errno)
- supply_register (regno, (char *) addr);
+ regcache_raw_supply (current_regcache, regno, (char *) addr);
else
{
#if 0
@@ -587,44 +587,59 @@ fetch_core_registers (char *core_reg_sec
if (ARCH64 ())
{
for (regi = 0; regi < ppc_num_gprs; regi++)
- supply_register (tdep->ppc_gp0_regnum + regi,
- (char *) ®s->r64.gpr[regi]);
+ regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
+ (char *) ®s->r64.gpr[regi]);
if (tdep->ppc_fp0_regnum >= 0)
for (regi = 0; regi < ppc_num_fprs; regi++)
- supply_register (tdep->ppc_fp0_regnum + regi,
- (char *) ®s->r64.fpr[regi]);
+ regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
+ (char *) ®s->r64.fpr[regi]);
- supply_register (PC_REGNUM, (char *) ®s->r64.iar);
- supply_register (tdep->ppc_ps_regnum, (char *) ®s->r64.msr);
- supply_register (tdep->ppc_cr_regnum, (char *) ®s->r64.cr);
- supply_register (tdep->ppc_lr_regnum, (char *) ®s->r64.lr);
- supply_register (tdep->ppc_ctr_regnum, (char *) ®s->r64.ctr);
- supply_register (tdep->ppc_xer_regnum, (char *) ®s->r64.xer);
+ regcache_raw_supply (current_regcache, PC_REGNUM,
+ (char *) ®s->r64.iar);
+ regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
+ (char *) ®s->r64.msr);
+ regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
+ (char *) ®s->r64.cr);
+ regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
+ (char *) ®s->r64.lr);
+ regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
+ (char *) ®s->r64.ctr);
+ regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
+ (char *) ®s->r64.xer);
if (tdep->ppc_fpscr_regnum >= 0)
- supply_register (tdep->ppc_fpscr_regnum, (char *) ®s->r64.fpscr);
+ regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ (char *) ®s->r64.fpscr);
}
else
{
for (regi = 0; regi < ppc_num_gprs; regi++)
- supply_register (tdep->ppc_gp0_regnum + regi,
- (char *) ®s->r32.gpr[regi]);
+ regcache_raw_supply (current_regcache, tdep->ppc_gp0_regnum + regi,
+ (char *) ®s->r32.gpr[regi]);
if (tdep->ppc_fp0_regnum >= 0)
for (regi = 0; regi < ppc_num_fprs; regi++)
- supply_register (tdep->ppc_fp0_regnum + regi,
- (char *) ®s->r32.fpr[regi]);
+ regcache_raw_supply (current_regcache, tdep->ppc_fp0_regnum + regi,
+ (char *) ®s->r32.fpr[regi]);
- supply_register (PC_REGNUM, (char *) ®s->r32.iar);
- supply_register (tdep->ppc_ps_regnum, (char *) ®s->r32.msr);
- supply_register (tdep->ppc_cr_regnum, (char *) ®s->r32.cr);
- supply_register (tdep->ppc_lr_regnum, (char *) ®s->r32.lr);
- supply_register (tdep->ppc_ctr_regnum, (char *) ®s->r32.ctr);
- supply_register (tdep->ppc_xer_regnum, (char *) ®s->r32.xer);
+ regcache_raw_supply (current_regcache, PC_REGNUM,
+ (char *) ®s->r32.iar);
+ regcache_raw_supply (current_regcache, tdep->ppc_ps_regnum,
+ (char *) ®s->r32.msr);
+ regcache_raw_supply (current_regcache, tdep->ppc_cr_regnum,
+ (char *) ®s->r32.cr);
+ regcache_raw_supply (current_regcache, tdep->ppc_lr_regnum,
+ (char *) ®s->r32.lr);
+ regcache_raw_supply (current_regcache, tdep->ppc_ctr_regnum,
+ (char *) ®s->r32.ctr);
+ regcache_raw_supply (current_regcache, tdep->ppc_xer_regnum,
+ (char *) ®s->r32.xer);
if (tdep->ppc_fpscr_regnum >= 0)
- supply_register (tdep->ppc_fpscr_regnum, (char *) ®s->r32.fpscr);
+ regcache_raw_supply (current_regcache, tdep->ppc_fpscr_regnum,
+ (char *) ®s->r32.fpscr);
if (tdep->ppc_mq_regnum >= 0)
- supply_register (tdep->ppc_mq_regnum, (char *) ®s->r32.mq);
+ regcache_raw_supply (current_regcache, tdep->ppc_mq_regnum,
+ (char *) ®s->r32.mq);
}
}
Index: sh3-rom.c
===================================================================
RCS file: /cvs/src/src/gdb/sh3-rom.c,v
retrieving revision 1.17
diff -p -u -r1.17 sh3-rom.c
--- sh3-rom.c 10 Oct 2003 07:13:11 -0000 1.17
+++ sh3-rom.c 22 Jul 2004 01:27:16 -0000
@@ -228,7 +228,7 @@ init_sh3_cmds (void)
sh3_cmds.getreg.term_cmd = ".\r"; /* getreg.term_cmd */
sh3_cmds.dump_registers = "r\r"; /* dump_registers */
sh3_cmds.register_pattern = "\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)";
- sh3_cmds.supply_register = sh3_supply_register; /* supply_register */
+ sh3_cmds.supply_register = sh3_supply_register;
sh3_cmds.load_routine = sh3_load; /* load_routine */
sh3_cmds.load = NULL; /* download command */
sh3_cmds.loadresp = NULL; /* Load response */
Index: shnbsd-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/shnbsd-tdep.c,v
retrieving revision 1.12
diff -p -u -r1.12 shnbsd-tdep.c
--- shnbsd-tdep.c 1 May 2004 16:52:29 -0000 1.12
+++ shnbsd-tdep.c 22 Jul 2004 01:27:16 -0000
@@ -61,25 +61,26 @@ shnbsd_supply_reg (char *regs, int regno
int i;
if (regno == PC_REGNUM || regno == -1)
- supply_register (PC_REGNUM, regs + (0 * 4));
+ regcache_raw_supply (current_regcache, PC_REGNUM, regs + (0 * 4));
if (regno == SR_REGNUM || regno == -1)
- supply_register (SR_REGNUM, regs + (1 * 4));
+ regcache_raw_supply (current_regcache, SR_REGNUM, regs + (1 * 4));
if (regno == PR_REGNUM || regno == -1)
- supply_register (PR_REGNUM, regs + (2 * 4));
+ regcache_raw_supply (current_regcache, PR_REGNUM, regs + (2 * 4));
if (regno == MACH_REGNUM || regno == -1)
- supply_register (MACH_REGNUM, regs + (3 * 4));
+ regcache_raw_supply (current_regcache, MACH_REGNUM, regs + (3 * 4));
if (regno == MACL_REGNUM || regno == -1)
- supply_register (MACL_REGNUM, regs + (4 * 4));
+ regcache_raw_supply (current_regcache, MACL_REGNUM, regs + (4 * 4));
if ((regno >= R0_REGNUM && regno <= (R0_REGNUM + 15)) || regno == -1)
{
for (i = R0_REGNUM; i <= (R0_REGNUM + 15); i++)
if (regno == i || regno == -1)
- supply_register (i, regs + regmap[i - R0_REGNUM]);
+ regcache_raw_supply (current_regcache, i,
+ regs + regmap[i - R0_REGNUM]);
}
}
Index: sol-thread.c
===================================================================
RCS file: /cvs/src/src/gdb/sol-thread.c,v
retrieving revision 1.42
diff -p -u -r1.42 sol-thread.c
--- sol-thread.c 25 May 2004 14:58:31 -0000 1.42
+++ sol-thread.c 22 Jul 2004 01:27:16 -0000
@@ -597,7 +597,7 @@ sol_thread_store_registers (int regnum)
td_err_string (val));
/* Restore new register value. */
- supply_register (regnum, old_value);
+ regcache_raw_supply (current_regcache, regnum, old_value);
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
Index: thread-db.c
===================================================================
RCS file: /cvs/src/src/gdb/thread-db.c,v
retrieving revision 1.42
diff -p -u -r1.42 thread-db.c
--- thread-db.c 7 Jun 2004 22:35:55 -0000 1.42
+++ thread-db.c 22 Jul 2004 01:27:16 -0000
@@ -1077,7 +1077,7 @@ thread_db_store_registers (int regno)
deprecated_read_register_gen (regno, raw);
thread_db_fetch_registers (-1);
- supply_register (regno, raw);
+ regcache_raw_supply (current_regcache, regno, raw);
}
fill_gregset ((gdb_gregset_t *) gregset, -1);
Index: v850ice.c
===================================================================
RCS file: /cvs/src/src/gdb/v850ice.c,v
retrieving revision 1.20
diff -p -u -r1.20 v850ice.c
--- v850ice.c 25 Jun 2004 19:46:08 -0000 1.20
+++ v850ice.c 22 Jul 2004 01:27:16 -0000
@@ -533,7 +533,7 @@ v850ice_fetch_registers (int regno)
regno, val);
store_unsigned_integer (val, DEPRECATED_REGISTER_RAW_SIZE (regno), regval);
- supply_register (regno, val);
+ regcache_raw_supply (current_regcache, regno, val);
}
/* Store register REGNO, or all registers if REGNO == -1, from the contents
Index: win32-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/win32-nat.c,v
retrieving revision 1.94
diff -p -u -r1.94 win32-nat.c
--- win32-nat.c 1 Jul 2004 21:34:02 -0000 1.94
+++ win32-nat.c 22 Jul 2004 01:27:16 -0000
@@ -358,15 +358,15 @@ do_child_fetch_inferior_registers (int r
if (r == I387_FISEG_REGNUM)
{
l = *((long *) context_offset) & 0xffff;
- supply_register (r, (char *) &l);
+ regcache_raw_supply (current_regcache, r, (char *) &l);
}
else if (r == I387_FOP_REGNUM)
{
l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
- supply_register (r, (char *) &l);
+ regcache_raw_supply (current_regcache, r, (char *) &l);
}
else if (r >= 0)
- supply_register (r, context_offset);
+ regcache_raw_supply (current_regcache, r, context_offset);
else
{
for (r = 0; r < NUM_REGS; r++)
@@ -2441,7 +2441,7 @@ fetch_elf_core_registers (char *core_reg
return;
}
for (r = 0; r < NUM_REGS; r++)
- supply_register (r, core_reg_sect + mappings[r]);
+ regcache_raw_supply (current_regcache, r, core_reg_sect + mappings[r]);
}
static struct core_fns win32_elf_core_fns =
Index: wince.c
===================================================================
RCS file: /cvs/src/src/gdb/wince.c,v
retrieving revision 1.29
diff -p -u -r1.29 wince.c
--- wince.c 25 Jun 2004 19:46:08 -0000 1.29
+++ wince.c 22 Jul 2004 01:27:17 -0000
@@ -1119,7 +1119,8 @@ do_child_fetch_inferior_registers (int r
{
if (r >= 0)
{
- supply_register (r, (char *) regptr (¤t_thread->context, r));
+ regcache_raw_supply (current_regcache, r,
+ (char *) regptr (¤t_thread->context, r));
}
else
{