This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[rfc] [12/14] Push REGCACHE into supply_gregset etc.
- From: "Ulrich Weigand" <uweigand at de dot ibm dot com>
- To: gdb-patches at sourceware dot org
- Date: Tue, 1 May 2007 03:30:25 +0200 (CEST)
- Subject: [rfc] [12/14] Push REGCACHE into supply_gregset etc.
Hello,
after all the preparation patches, this one pushes REGCACHE into
the supply_gregset family of routines.
Bye,
Ulrich
ChangeLog:
* gregset.h (struct regcache): Add forward declaration.
(supply_gregset): Add REGCACHE parameter, make GREGS const.
(supply_fpregset): Add REGCACHE parameter, make FPREGS const.
(supply_fpxregset): Add REGCACHE parameter, make FPXREGS const.
(fill_gregset): Add REGCACHE parameter.
(fill_fpregset): Likewise.
(fill_fpxregset): Likewise.
Update all definitions accordingly:
* alphabsd-nat.c, alpha-linux-nat.c, alpha-nat.c, amd64-linux-nat.c,
arm-linux-nat.c, hppa-linux-nat.c, i386gnu-nat.c, i386-linux-nat.c,
i386-sol2-nat.c, i386v4-nat.c, ia64-linux-nat.c, irix5-nat.c,
m32r-linux-nat.c, m68klinux-nat.c, mips-linux-nat.c, ppc-linux-nat.c,
s390-nat.c, sparc64-linux-nat.c, sparc-linux-nat.c, sparc-sol2-nat.c
(supply_gregset): Add REGCACHE parameter, use it instead of
current_regcache. Make GREGSETP parameter const, adapt casts.
(supply_fpregset): Add REGCACHE parameter, use it instead of
current_regcache. Make FPREGSETP parameter const, adapt casts.
(fill_gregset): Add REGCACHE parameter, use it instead of
current_regcache.
(fill_fpregset): Likewise.
Update all callers to pass in current_regcache as the new argument:
* core-regset.c: Include "regcache.h".
(fetch_core_registers): Update supply_gregset,and supply_fpregset calls.
* procfs.c: Include "regcache.h".
(procfs_fetch_registers): Update supply_gregset, supply_fpregset calls.
(procfs_store_registers): Update fill_gregset, fill_fpregset calls.
(procfs_do_thread_registers): Likewise.
(procfs_make_note_section): Likewise.
* proc-service.c: Include "regcache.h".
(ps_lgetregs): Update fill_gregset call.
(ps_lsetregs): Update supply_gregset call.
(ps_lgetfpregs): Update fill_fpregset call.
(ps_lsetfpregs): Update supply_fpregset call.
* sol-thread.c (sol_thread_fetch_registers): Update supply_gregset,
supply_fpregset calls.
(sol_thread_store_registers): Update fill_gregset, fill_fpregset calls.
(ps_lgetregs): Update fill_gregset call.
(ps_lsetregs): Update supply_gregset call.
(ps_lgetfpregs): Update fill_fpregset call.
(ps_lsetfpregs): Update supply_fpregset call.
* linux-nat.c (linux_nat_do_thread_registers): Update fill_gregset,
fill_fpregset, and fill_fpxregset calls.
* i386-linux-nat.c (fetch_regs): Update supply_gregset call.
(store_regs): Update fill_gregset call.
(fetch_fpregs): Update supply_fpregset call.
(store_fpregs): Update fill_fpregset call.
(fetch_fpxregs): Update supply_fpxregset call.
(store_fpxregs): Update fill_fpxregset call.
* m32r-linux-nat.c (fetch_regs): Update supply_gregset call.
(store_regs): Update fill_gregset call.
* m68klinux-nat.c (fetch_regs): Update supply_gregset call.
(store_regs): Update fill_gregset call.
(fetch_fpregs): Update supply_fpregset call.
(store_fpregs): Update fill_fpregset call.
(fetch_core_registers): Update supply_gregset, supply_fpregset calls.
* s390-nat.c (fetch_regs): Update supply_gregset call.
(store_regs): Update fill_gregset call.
(fetch_fpregs): Update supply_fpregset call.
(store_fpregs): Update fill_fpregset call.
* Makefile.in (core-regset.o, procfs.o, proc-service.o): Update
dependencies.
diff -urNp gdb-orig/gdb/alphabsd-nat.c gdb-head/gdb/alphabsd-nat.c
--- gdb-orig/gdb/alphabsd-nat.c 2007-05-01 00:10:28.130216172 +0200
+++ gdb-head/gdb/alphabsd-nat.c 2007-05-01 00:14:01.654332566 +0200
@@ -50,27 +50,27 @@ typedef struct fpreg fpregset_t;
supply/fill routines. */
void
-supply_gregset (gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
{
- alphabsd_supply_reg (current_regcache, (char *) gregsetp, -1);
+ alphabsd_supply_reg (regcache, (const char *) gregsetp, -1);
}
void
-fill_gregset (gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
{
- alphabsd_fill_reg (current_regcache, (char *) gregsetp, regno);
+ alphabsd_fill_reg (regcache, (char *) gregsetp, regno);
}
void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{
- alphabsd_supply_fpreg (current_regcache, (char *) fpregsetp, -1);
+ alphabsd_supply_fpreg (regcache, (const char *) fpregsetp, -1);
}
void
-fill_fpregset (fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache, fpregset_t *fpregsetp, int regno)
{
- alphabsd_fill_fpreg (current_regcache, (char *) fpregsetp, regno);
+ alphabsd_fill_fpreg (regcache, (char *) fpregsetp, regno);
}
/* Determine if PT_GETREGS fetches this register. */
diff -urNp gdb-orig/gdb/alpha-linux-nat.c gdb-head/gdb/alpha-linux-nat.c
--- gdb-orig/gdb/alpha-linux-nat.c 2007-05-01 00:10:28.141214611 +0200
+++ gdb-head/gdb/alpha-linux-nat.c 2007-05-01 00:14:01.658331998 +0200
@@ -40,21 +40,22 @@
*/
void
-supply_gregset (gdb_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
- long *regp = (long *)gregsetp;
+ const long *regp = (const long *)gregsetp;
/* PC is in slot 32, UNIQUE is in slot 33. */
- alpha_supply_int_regs (current_regcache, -1, regp, regp + 31, regp + 32);
+ alpha_supply_int_regs (regcache, -1, regp, regp + 31, regp + 32);
}
void
-fill_gregset (gdb_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregsetp, int regno)
{
long *regp = (long *)gregsetp;
/* PC is in slot 32, UNIQUE is in slot 33. */
- alpha_fill_int_regs (current_regcache, regno, regp, regp + 31, regp + 32);
+ alpha_fill_int_regs (regcache, regno, regp, regp + 31, regp + 32);
}
/*
@@ -63,21 +64,22 @@ fill_gregset (gdb_gregset_t *gregsetp, i
*/
void
-supply_fpregset (gdb_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
- long *regp = (long *)fpregsetp;
+ const long *regp = (const long *)fpregsetp;
/* FPCR is in slot 32. */
- alpha_supply_fp_regs (current_regcache, -1, regp, regp + 31);
+ alpha_supply_fp_regs (regcache, -1, regp, regp + 31);
}
void
-fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregsetp, int regno)
{
long *regp = (long *)fpregsetp;
/* FPCR is in slot 32. */
- alpha_fill_fp_regs (current_regcache, regno, regp, regp + 31);
+ alpha_fill_fp_regs (regcache, regno, regp, regp + 31);
}
diff -urNp gdb-orig/gdb/alpha-nat.c gdb-head/gdb/alpha-nat.c
--- gdb-orig/gdb/alpha-nat.c 2007-05-01 00:10:28.146213901 +0200
+++ gdb-head/gdb/alpha-nat.c 2007-05-01 00:14:01.663331289 +0200
@@ -153,21 +153,22 @@ kernel_u_size (void)
*/
void
-supply_gregset (gdb_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
- long *regp = gregsetp->regs;
+ const long *regp = gregsetp->regs;
/* PC is in slot 32. */
- alpha_supply_int_regs (current_regcache, -1, regp, regp + 31, NULL);
+ alpha_supply_int_regs (regcache, -1, regp, regp + 31, NULL);
}
void
-fill_gregset (gdb_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregsetp, int regno)
{
long *regp = gregsetp->regs;
/* PC is in slot 32. */
- alpha_fill_int_regs (current_regcache, regno, regp, regp + 31, NULL);
+ alpha_fill_int_regs (regcache, regno, regp, regp + 31, NULL);
}
/*
@@ -176,21 +177,22 @@ fill_gregset (gdb_gregset_t *gregsetp, i
*/
void
-supply_fpregset (gdb_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
- long *regp = fpregsetp->regs;
+ const long *regp = fpregsetp->regs;
/* FPCR is in slot 32. */
- alpha_supply_fp_regs (current_regcache, -1, regp, regp + 31);
+ alpha_supply_fp_regs (regcache, -1, regp, regp + 31);
}
void
-fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregsetp, int regno)
{
long *regp = fpregsetp->regs;
/* FPCR is in slot 32. */
- alpha_fill_fp_regs (current_regcache, regno, regp, regp + 31);
+ alpha_fill_fp_regs (regcache, regno, regp, regp + 31);
}
#endif
diff -urNp gdb-orig/gdb/amd64-linux-nat.c gdb-head/gdb/amd64-linux-nat.c
--- gdb-orig/gdb/amd64-linux-nat.c 2007-04-30 23:02:43.189217282 +0200
+++ gdb-head/gdb/amd64-linux-nat.c 2007-05-01 00:14:01.668330579 +0200
@@ -111,9 +111,9 @@ static int amd64_linux_gregset32_reg_off
in *GREGSETP. */
void
-supply_gregset (elf_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
{
- amd64_supply_native_gregset (current_regcache, gregsetp, -1);
+ amd64_supply_native_gregset (regcache, gregsetp, -1);
}
/* Fill register REGNUM (if it is a general-purpose register) in
@@ -121,9 +121,10 @@ supply_gregset (elf_gregset_t *gregsetp)
do this for all registers. */
void
-fill_gregset (elf_gregset_t *gregsetp, int regnum)
+fill_gregset (const struct regcache *regcache,
+ elf_gregset_t *gregsetp, int regnum)
{
- amd64_collect_native_gregset (current_regcache, gregsetp, regnum);
+ amd64_collect_native_gregset (regcache, gregsetp, regnum);
}
/* Transfering floating-point registers between GDB, inferiors and cores. */
@@ -132,9 +133,9 @@ fill_gregset (elf_gregset_t *gregsetp, i
values in *FPREGSETP. */
void
-supply_fpregset (elf_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
{
- amd64_supply_fxsave (current_regcache, -1, fpregsetp);
+ amd64_supply_fxsave (regcache, -1, fpregsetp);
}
/* Fill register REGNUM (if it is a floating-point or SSE register) in
@@ -142,9 +143,10 @@ supply_fpregset (elf_fpregset_t *fpregse
-1, do this for all registers. */
void
-fill_fpregset (elf_fpregset_t *fpregsetp, int regnum)
+fill_fpregset (const struct regcache *regcache,
+ elf_fpregset_t *fpregsetp, int regnum)
{
- amd64_collect_fxsave (current_regcache, regnum, fpregsetp);
+ amd64_collect_fxsave (regcache, regnum, fpregsetp);
}
diff -urNp gdb-orig/gdb/arm-linux-nat.c gdb-head/gdb/arm-linux-nat.c
--- gdb-orig/gdb/arm-linux-nat.c 2007-04-30 23:02:43.194216573 +0200
+++ gdb-head/gdb/arm-linux-nat.c 2007-05-01 00:14:01.673329869 +0200
@@ -503,30 +503,32 @@ arm_linux_store_inferior_registers (int
thread debugging. */
void
-fill_gregset (gdb_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregsetp, int regno)
{
- arm_linux_collect_gregset (NULL, current_regcache, regno, gregsetp, 0);
+ arm_linux_collect_gregset (NULL, regcache, regno, gregsetp, 0);
}
void
-supply_gregset (gdb_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
- arm_linux_supply_gregset (NULL, current_regcache, -1, gregsetp, 0);
+ arm_linux_supply_gregset (NULL, regcache, -1, gregsetp, 0);
}
void
-fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregsetp, int regno)
{
- arm_linux_collect_nwfpe (NULL, current_regcache, regno, fpregsetp, 0);
+ arm_linux_collect_nwfpe (NULL, regcache, regno, fpregsetp, 0);
}
/* Fill GDB's register array with the floating-point register values
in *fpregsetp. */
void
-supply_fpregset (gdb_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
- arm_linux_supply_nwfpe (NULL, current_regcache, -1, fpregsetp, 0);
+ arm_linux_supply_nwfpe (NULL, regcache, -1, fpregsetp, 0);
}
/* Fetch the thread-local storage pointer for libthread_db. */
diff -urNp gdb-orig/gdb/core-regset.c gdb-head/gdb/core-regset.c
--- gdb-orig/gdb/core-regset.c 2007-04-30 23:02:43.199215863 +0200
+++ gdb-head/gdb/core-regset.c 2007-05-01 00:14:01.677329302 +0200
@@ -34,6 +34,7 @@
#include "gdbcore.h"
#include "inferior.h"
#include "target.h"
+#include "regcache.h"
#include <fcntl.h>
#include <errno.h>
@@ -73,7 +74,7 @@ fetch_core_registers (char *core_reg_sec
else
{
memcpy (&gregset, core_reg_sect, sizeof (gregset));
- supply_gregset (&gregset);
+ supply_gregset (current_regcache, (const gdb_gregset_t *) &gregset);
}
break;
@@ -84,7 +85,7 @@ fetch_core_registers (char *core_reg_sec
{
memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
if (FP0_REGNUM >= 0)
- supply_fpregset (&fpregset);
+ supply_fpregset (current_regcache, (const gdb_fpregset_t *) &fpregset);
}
break;
diff -urNp gdb-orig/gdb/gregset.h gdb-head/gdb/gregset.h
--- gdb-orig/gdb/gregset.h 2007-04-30 23:02:43.203215296 +0200
+++ gdb-head/gdb/gregset.h 2007-05-01 00:14:01.682328592 +0200
@@ -32,6 +32,8 @@
typedef GDB_GREGSET_T gdb_gregset_t;
typedef GDB_FPREGSET_T gdb_fpregset_t;
+struct regcache;
+
/* A gregset is a data structure supplied by the native OS containing
the general register values of the debugged process. Usually this
includes integer registers and control registers. An fpregset is a
@@ -42,15 +44,19 @@ typedef GDB_FPREGSET_T gdb_fpregset_t;
/* Copy register values from the native target gregset/fpregset
into GDB's internal register cache. */
-extern void supply_gregset (gdb_gregset_t *gregs);
-extern void supply_fpregset (gdb_fpregset_t *fpregs);
+extern void supply_gregset (struct regcache *regcache,
+ const gdb_gregset_t *gregs);
+extern void supply_fpregset (struct regcache *regcache,
+ const gdb_fpregset_t *fpregs);
/* Copy register values from GDB's register cache into
the native target gregset/fpregset. If regno is -1,
copy all the registers. */
-extern void fill_gregset (gdb_gregset_t *gregs, int regno);
-extern void fill_fpregset (gdb_fpregset_t *fpregs, int regno);
+extern void fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregs, int regno);
+extern void fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregs, int regno);
#ifdef FILL_FPXREGSET
/* GNU/Linux i386: Copy register values between GDB's internal register cache
@@ -62,8 +68,10 @@ extern void fill_fpregset (gdb_fpregset_
typedef GDB_FPXREGSET_T gdb_fpxregset_t;
-extern void supply_fpxregset (gdb_fpxregset_t *fpxregs);
-extern void fill_fpxregset (gdb_fpxregset_t *fpxregs, int regno);
+extern void supply_fpxregset (struct regcache *regcache,
+ const gdb_fpxregset_t *fpxregs);
+extern void fill_fpxregset (const struct regcache *regcache,
+ gdb_fpxregset_t *fpxregs, int regno);
#endif
#endif
diff -urNp gdb-orig/gdb/hppa-linux-nat.c gdb-head/gdb/hppa-linux-nat.c
--- gdb-orig/gdb/hppa-linux-nat.c 2007-04-30 23:02:43.208214586 +0200
+++ gdb-head/gdb/hppa-linux-nat.c 2007-05-01 00:14:01.687327882 +0200
@@ -305,15 +305,15 @@ hppa_linux_store_inferior_registers (int
in *gregsetp. */
void
-supply_gregset (gdb_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
int i;
- greg_t *regp = (elf_greg_t *) gregsetp;
+ const greg_t *regp = (const elf_greg_t *) gregsetp;
for (i = 0; i < sizeof (greg_map) / sizeof (greg_map[0]); i++, regp++)
{
int regno = greg_map[i];
- regcache_raw_supply (current_regcache, regno, regp);
+ regcache_raw_supply (regcache, regno, regp);
}
}
@@ -322,7 +322,8 @@ supply_gregset (gdb_gregset_t *gregsetp)
If regno is -1, do this for all registers. */
void
-fill_gregset (gdb_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregsetp, int regno)
{
int i;
@@ -332,7 +333,7 @@ fill_gregset (gdb_gregset_t *gregsetp, i
if (regno == -1 || regno == mregno)
{
- regcache_raw_collect(current_regcache, mregno, &(*gregsetp)[i]);
+ regcache_raw_collect(regcache, mregno, &(*gregsetp)[i]);
}
}
}
@@ -342,17 +343,16 @@ fill_gregset (gdb_gregset_t *gregsetp, i
idea of the current floating point register values. */
void
-supply_fpregset (gdb_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
int regi;
- char *from;
+ const char *from;
for (regi = 0; regi <= 31; regi++)
{
- from = (char *) &((*fpregsetp)[regi]);
- regcache_raw_supply (current_regcache, 2*regi + HPPA_FP0_REGNUM, from);
- regcache_raw_supply (current_regcache, 2*regi + HPPA_FP0_REGNUM + 1,
- from + 4);
+ from = (const char *) &((*fpregsetp)[regi]);
+ regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM, from);
+ regcache_raw_supply (regcache, 2*regi + HPPA_FP0_REGNUM + 1, from + 4);
}
}
@@ -362,7 +362,8 @@ supply_fpregset (gdb_fpregset_t *fpregse
them all. */
void
-fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregsetp, int regno)
{
int i;
@@ -373,7 +374,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp
char *to = (char *) &((*fpregsetp)[(i - HPPA_FP0_REGNUM) / 2]);
if ((i - HPPA_FP0_REGNUM) & 1)
to += 4;
- regcache_raw_collect (current_regcache, i, to);
+ regcache_raw_collect (regcache, i, to);
}
}
diff -urNp gdb-orig/gdb/i386gnu-nat.c gdb-head/gdb/i386gnu-nat.c
--- gdb-orig/gdb/i386gnu-nat.c 2007-05-01 00:10:35.069294398 +0200
+++ gdb-head/gdb/i386gnu-nat.c 2007-05-01 00:14:01.692327173 +0200
@@ -59,6 +59,7 @@ static int reg_offset[] =
};
#define REG_ADDR(state, regnum) ((char *)(state) + reg_offset[regnum])
+#define CREG_ADDR(state, regnum) ((const char *)(state) + reg_offset[regnum])
/* Get the whole floating-point state of THREAD and record the values
@@ -96,17 +97,17 @@ fetch_fpregs (struct proc *thread)
/* These two calls are used by the core-regset.c code for
reading ELF core files. */
void
-supply_gregset (gdb_gregset_t *gregs)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregs)
{
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
- regcache_raw_supply (current_regcache, i, REG_ADDR (gregs, i));
+ regcache_raw_supply (regcache, i, CREG_ADDR (gregs, i));
}
void
-supply_fpregset (gdb_fpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs)
{
- i387_supply_fsave (current_regcache, -1, fpregs);
+ i387_supply_fsave (regcache, -1, fpregs);
}
#endif
diff -urNp gdb-orig/gdb/i386-linux-nat.c gdb-head/gdb/i386-linux-nat.c
--- gdb-orig/gdb/i386-linux-nat.c 2007-05-01 00:10:35.074293688 +0200
+++ gdb-head/gdb/i386-linux-nat.c 2007-05-01 00:14:01.699326179 +0200
@@ -201,16 +201,16 @@ store_register (int regno)
in *GREGSETP. */
void
-supply_gregset (elf_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
{
- elf_greg_t *regp = (elf_greg_t *) gregsetp;
+ const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
- regcache_raw_supply (current_regcache, i, regp + regmap[i]);
+ regcache_raw_supply (regcache, i, regp + regmap[i]);
if (I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
- regcache_raw_supply (current_regcache, I386_LINUX_ORIG_EAX_REGNUM,
+ regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM,
regp + ORIG_EAX);
}
@@ -219,18 +219,19 @@ supply_gregset (elf_gregset_t *gregsetp)
do this for all registers. */
void
-fill_gregset (elf_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ elf_gregset_t *gregsetp, int regno)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
if (regno == -1 || regno == i)
- regcache_raw_collect (current_regcache, i, regp + regmap[i]);
+ regcache_raw_collect (regcache, i, regp + regmap[i]);
if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
&& I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
- regcache_raw_collect (current_regcache, I386_LINUX_ORIG_EAX_REGNUM,
+ regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM,
regp + ORIG_EAX);
}
@@ -257,7 +258,7 @@ fetch_regs (int tid)
perror_with_name (_("Couldn't get registers"));
}
- supply_gregset (®s);
+ supply_gregset (current_regcache, (const elf_gregset_t *) ®s);
}
/* Store all valid general-purpose registers in GDB's register array
@@ -271,7 +272,7 @@ store_regs (int tid, int regno)
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (®s, regno);
+ fill_gregset (current_regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't write registers"));
@@ -291,9 +292,9 @@ static void store_regs (int tid, int reg
*FPREGSETP. */
void
-supply_fpregset (elf_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
{
- i387_supply_fsave (current_regcache, -1, fpregsetp);
+ i387_supply_fsave (regcache, -1, fpregsetp);
}
/* Fill register REGNO (if it is a floating-point register) in
@@ -301,9 +302,10 @@ supply_fpregset (elf_fpregset_t *fpregse
do this for all registers. */
void
-fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ elf_fpregset_t *fpregsetp, int regno)
{
- i387_collect_fsave (current_regcache, regno, fpregsetp);
+ i387_collect_fsave (regcache, regno, fpregsetp);
}
#ifdef HAVE_PTRACE_GETREGS
@@ -319,7 +321,7 @@ fetch_fpregs (int tid)
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
- supply_fpregset (&fpregs);
+ supply_fpregset (current_regcache, (const elf_fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register array
@@ -333,7 +335,7 @@ store_fpregs (int tid, int regno)
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
- fill_fpregset (&fpregs, regno);
+ fill_fpregset (current_regcache, &fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't write floating point status"));
@@ -355,9 +357,10 @@ static void store_fpregs (int tid, int r
values in *FPXREGSETP. */
void
-supply_fpxregset (elf_fpxregset_t *fpxregsetp)
+supply_fpxregset (struct regcache *regcache,
+ const elf_fpxregset_t *fpxregsetp)
{
- i387_supply_fxsave (current_regcache, -1, fpxregsetp);
+ i387_supply_fxsave (regcache, -1, fpxregsetp);
}
/* Fill register REGNO (if it is a floating-point or SSE register) in
@@ -365,9 +368,10 @@ supply_fpxregset (elf_fpxregset_t *fpxre
-1, do this for all registers. */
void
-fill_fpxregset (elf_fpxregset_t *fpxregsetp, int regno)
+fill_fpxregset (const struct regcache *regcache,
+ elf_fpxregset_t *fpxregsetp, int regno)
{
- i387_collect_fxsave (current_regcache, regno, fpxregsetp);
+ i387_collect_fxsave (regcache, regno, fpxregsetp);
}
/* Fetch all registers covered by the PTRACE_GETFPXREGS request from
@@ -393,7 +397,7 @@ fetch_fpxregs (int tid)
perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
- supply_fpxregset (&fpxregs);
+ supply_fpxregset (current_regcache, (const elf_fpxregset_t *) &fpxregs);
return 1;
}
@@ -420,7 +424,7 @@ store_fpxregs (int tid, int regno)
perror_with_name (_("Couldn't read floating-point and SSE registers"));
}
- fill_fpxregset (&fpxregs, regno);
+ fill_fpxregset (current_regcache, &fpxregs, regno);
if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
perror_with_name (_("Couldn't write floating-point and SSE registers"));
diff -urNp gdb-orig/gdb/i386-sol2-nat.c gdb-head/gdb/i386-sol2-nat.c
--- gdb-orig/gdb/i386-sol2-nat.c 2007-04-30 23:02:43.223212458 +0200
+++ gdb-head/gdb/i386-sol2-nat.c 2007-05-01 00:14:01.703325612 +0200
@@ -99,27 +99,29 @@ static int amd64_sol2_gregset32_reg_offs
};
void
-supply_gregset (prgregset_t *gregs)
+supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
{
- amd64_supply_native_gregset (current_regcache, gregs, -1);
+ amd64_supply_native_gregset (regcache, gregs, -1);
}
void
-supply_fpregset (prfpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
{
- amd64_supply_fxsave (current_regcache, -1, fpregs);
+ amd64_supply_fxsave (regcache, -1, fpregs);
}
void
-fill_gregset (prgregset_t *gregs, int regnum)
+fill_gregset (const struct regcache *regcache,
+ prgregset_t *gregs, int regnum)
{
- amd64_collect_native_gregset (current_regcache, gregs, regnum);
+ amd64_collect_native_gregset (regcache, gregs, regnum);
}
void
-fill_fpregset (prfpregset_t *fpregs, int regnum)
+fill_fpregset (const struct regcache *regcache,
+ prfpregset_t *fpregs, int regnum)
{
- amd64_collect_fxsave (current_regcache, regnum, fpregs);
+ amd64_collect_fxsave (regcache, regnum, fpregs);
}
#else
diff -urNp gdb-orig/gdb/i386v4-nat.c gdb-head/gdb/i386v4-nat.c
--- gdb-orig/gdb/i386v4-nat.c 2007-05-01 00:10:35.082292553 +0200
+++ gdb-head/gdb/i386v4-nat.c 2007-05-01 00:14:01.707325044 +0200
@@ -104,13 +104,13 @@ static int regmap[] =
in *GREGSETP. */
void
-supply_gregset (gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
{
- greg_t *regp = (greg_t *) gregsetp;
+ const greg_t *regp = (const greg_t *) gregsetp;
int regnum;
for (regnum = 0; regnum < I386_NUM_GREGS; regnum++)
- regcache_raw_supply (current_regcache, regnum, regp + regmap[regnum]);
+ regcache_raw_supply (regcache, regnum, regp + regmap[regnum]);
}
/* Fill register REGNUM (if it is a general-purpose register) in
@@ -118,14 +118,15 @@ supply_gregset (gregset_t *gregsetp)
do this for all registers. */
void
-fill_gregset (gregset_t *gregsetp, int regnum)
+fill_gregset (const struct regcache *regcache,
+ gregset_t *gregsetp, int regnum)
{
greg_t *regp = (greg_t *) gregsetp;
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
if (regnum == -1 || regnum == i)
- regcache_raw_collect (current_regcache, i, regp + regmap[i]);
+ regcache_raw_collect (regcache, i, regp + regmap[i]);
}
#endif /* HAVE_GREGSET_T */
@@ -136,12 +137,12 @@ fill_gregset (gregset_t *gregsetp, int r
*FPREGSETP. */
void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{
if (FP0_REGNUM == 0)
return;
- i387_supply_fsave (current_regcache, -1, fpregsetp);
+ i387_supply_fsave (regcache, -1, fpregsetp);
}
/* Fill register REGNO (if it is a floating-point register) in
@@ -149,12 +150,13 @@ supply_fpregset (fpregset_t *fpregsetp)
do this for all registers. */
void
-fill_fpregset (fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ fpregset_t *fpregsetp, int regno)
{
if (FP0_REGNUM == 0)
return;
- i387_collect_fsave (current_regcache, regno, fpregsetp);
+ i387_collect_fsave (regcache, regno, fpregsetp);
}
#endif /* HAVE_FPREGSET_T */
diff -urNp gdb-orig/gdb/ia64-linux-nat.c gdb-head/gdb/ia64-linux-nat.c
--- gdb-orig/gdb/ia64-linux-nat.c 2007-04-30 23:02:43.233211038 +0200
+++ gdb-head/gdb/ia64-linux-nat.c 2007-05-01 00:14:01.713324192 +0200
@@ -362,65 +362,51 @@ ia64_cannot_store_register (int regno)
}
void
-supply_gregset (gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
{
int regi;
- greg_t *regp = (greg_t *) gregsetp;
+ const greg_t *regp = (const greg_t *) gregsetp;
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
{
- regcache_raw_supply (current_regcache, regi,
- (char *) (regp + (regi - IA64_GR0_REGNUM)));
+ regcache_raw_supply (regcache, regi, regp + (regi - IA64_GR0_REGNUM));
}
/* FIXME: NAT collection bits are at index 32; gotta deal with these
somehow... */
- regcache_raw_supply (current_regcache, IA64_PR_REGNUM, (char *) (regp + 33));
+ regcache_raw_supply (regcache, IA64_PR_REGNUM, regp + 33);
for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++)
{
- regcache_raw_supply (current_regcache, regi,
- (char *) (regp + 34 + (regi - IA64_BR0_REGNUM)));
+ regcache_raw_supply (regcache, regi,
+ regp + 34 + (regi - IA64_BR0_REGNUM));
}
- 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));
+ regcache_raw_supply (regcache, IA64_IP_REGNUM, regp + 42);
+ regcache_raw_supply (regcache, IA64_CFM_REGNUM, regp + 43);
+ regcache_raw_supply (regcache, IA64_PSR_REGNUM, regp + 44);
+ regcache_raw_supply (regcache, IA64_RSC_REGNUM, regp + 45);
+ regcache_raw_supply (regcache, IA64_BSP_REGNUM, regp + 46);
+ regcache_raw_supply (regcache, IA64_BSPSTORE_REGNUM, regp + 47);
+ regcache_raw_supply (regcache, IA64_RNAT_REGNUM, regp + 48);
+ regcache_raw_supply (regcache, IA64_CCV_REGNUM, regp + 49);
+ regcache_raw_supply (regcache, IA64_UNAT_REGNUM, regp + 50);
+ regcache_raw_supply (regcache, IA64_FPSR_REGNUM, regp + 51);
+ regcache_raw_supply (regcache, IA64_PFS_REGNUM, regp + 52);
+ regcache_raw_supply (regcache, IA64_LC_REGNUM, regp + 53);
+ regcache_raw_supply (regcache, IA64_EC_REGNUM, regp + 54);
}
void
-fill_gregset (gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
{
int regi;
greg_t *regp = (greg_t *) gregsetp;
#define COPY_REG(_idx_,_regi_) \
if ((regno == -1) || regno == _regi_) \
- regcache_raw_collect (current_regcache, _regi_, regp + _idx_)
+ regcache_raw_collect (regcache, _regi_, regp + _idx_)
for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
{
@@ -456,15 +442,15 @@ fill_gregset (gregset_t *gregsetp, int r
idea of the current floating point register values. */
void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{
int regi;
- char *from;
+ const char *from;
for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
{
- from = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
- regcache_raw_supply (current_regcache, regi, from);
+ from = (const char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
+ regcache_raw_supply (regcache, regi, from);
}
}
@@ -474,14 +460,15 @@ supply_fpregset (fpregset_t *fpregsetp)
them all. */
void
-fill_fpregset (fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ fpregset_t *fpregsetp, int regno)
{
int regi;
for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
{
if ((regno == -1) || (regno == regi))
- regcache_raw_collect (current_regcache, regi,
+ regcache_raw_collect (regcache, regi,
&((*fpregsetp)[regi - IA64_FR0_REGNUM]));
}
}
diff -urNp gdb-orig/gdb/irix5-nat.c gdb-head/gdb/irix5-nat.c
--- gdb-orig/gdb/irix5-nat.c 2007-05-01 00:10:17.428141874 +0200
+++ gdb-head/gdb/irix5-nat.c 2007-05-01 00:15:32.809214625 +0200
@@ -54,32 +54,32 @@ static void fetch_core_registers (char *
*/
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 (regcache, regi,
+ (const 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, 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, size;
greg_t *regp = &(*gregsetp)[0];
@@ -93,7 +93,7 @@ fill_gregset (gregset_t *gregsetp, int r
if ((regno == -1) || (regno == regi))
{
size = register_size (current_gdbarch, regi);
- regcache_raw_collect (current_regcache, regi, buf);
+ regcache_raw_collect (regcache, regi, buf);
*(regp + regi) = extract_signed_integer (buf, size);
}
@@ -101,7 +101,7 @@ fill_gregset (gregset_t *gregsetp, int r
{
regi = mips_regnum (current_gdbarch)->pc;
size = register_size (current_gdbarch, regi);
- regcache_raw_collect (current_regcache, regi, buf);
+ regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_EPC) = extract_signed_integer (buf, size);
}
@@ -109,7 +109,7 @@ fill_gregset (gregset_t *gregsetp, int r
{
regi = mips_regnum (current_gdbarch)->cause;
size = register_size (current_gdbarch, regi);
- regcache_raw_collect (current_regcache, regi, buf);
+ regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_CAUSE) = extract_signed_integer (buf, size);
}
@@ -117,7 +117,7 @@ fill_gregset (gregset_t *gregsetp, int r
{
regi = mips_regnum (current_gdbarch)->hi;
size = register_size (current_gdbarch, regi);
- regcache_raw_collect (current_regcache, regi, buf);
+ regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_MDHI) = extract_signed_integer (buf, size);
}
@@ -125,7 +125,7 @@ fill_gregset (gregset_t *gregsetp, int r
{
regi = mips_regnum (current_gdbarch)->lo;
size = register_size (current_gdbarch, regi);
- regcache_raw_collect (current_regcache, regi, buf);
+ regcache_raw_collect (regcache, regi, buf);
*(regp + CTX_MDLO) = extract_signed_integer (buf, size);
}
}
@@ -139,7 +139,7 @@ fill_gregset (gregset_t *gregsetp, int r
*/
void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
{
int regi;
static char zerobuf[32] = {0};
@@ -148,8 +148,8 @@ 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++)
- 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
@@ -159,18 +159,18 @@ supply_fpregset (fpregset_t *fpregsetp)
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;
@@ -182,7 +182,7 @@ fill_fpregset (fpregset_t *fpregsetp, in
if ((regno == -1) || (regno == regi))
{
to = (char *) &(fpregsetp->fp_r.fp_regs[regi - FP0_REGNUM]);
- regcache_raw_collect (current_regcache, regi, to);
+ regcache_raw_collect (regcache, regi, to);
}
}
@@ -196,7 +196,7 @@ fill_fpregset (fpregset_t *fpregsetp, in
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_collect (current_regcache,
+ regcache_raw_collect (regcache,
mips_regnum (current_gdbarch)->fp_control_status,
fsrbuf);
diff -urNp gdb-orig/gdb/linux-nat.c gdb-head/gdb/linux-nat.c
--- gdb-orig/gdb/linux-nat.c 2007-04-30 23:02:43.248208910 +0200
+++ gdb-head/gdb/linux-nat.c 2007-05-01 00:14:01.742320076 +0200
@@ -2591,7 +2591,7 @@ linux_nat_do_thread_registers (bfd *obfd
regset->collect_regset (regset, current_regcache, -1,
&gregs, sizeof (gregs));
else
- fill_gregset (&gregs, -1);
+ fill_gregset (current_regcache, &gregs, -1);
note_data = (char *) elfcore_write_prstatus (obfd,
note_data,
@@ -2606,7 +2606,7 @@ linux_nat_do_thread_registers (bfd *obfd
regset->collect_regset (regset, current_regcache, -1,
&fpregs, sizeof (fpregs));
else
- fill_fpregset (&fpregs, -1);
+ fill_fpregset (current_regcache, &fpregs, -1);
note_data = (char *) elfcore_write_prfpreg (obfd,
note_data,
@@ -2621,7 +2621,7 @@ linux_nat_do_thread_registers (bfd *obfd
regset->collect_regset (regset, current_regcache, -1,
&fpxregs, sizeof (fpxregs));
else
- fill_fpxregset (&fpxregs, -1);
+ fill_fpxregset (current_regcache, &fpxregs, -1);
note_data = (char *) elfcore_write_prxfpreg (obfd,
note_data,
diff -urNp gdb-orig/gdb/m32r-linux-nat.c gdb-head/gdb/m32r-linux-nat.c
--- gdb-orig/gdb/m32r-linux-nat.c 2007-05-01 00:10:19.235149929 +0200
+++ gdb-head/gdb/m32r-linux-nat.c 2007-05-01 00:16:22.481739959 +0200
@@ -69,9 +69,9 @@ static int regmap[] = {
in *GREGSETP. */
void
-supply_gregset (elf_gregset_t * gregsetp)
+supply_gregset (struct regcache *regcache, const elf_gregset_t * gregsetp)
{
- elf_greg_t *regp = (elf_greg_t *) gregsetp;
+ const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
int i;
unsigned long psw, bbpsw;
@@ -96,11 +96,11 @@ supply_gregset (elf_gregset_t * gregsetp
}
if (i != M32R_SP_REGNUM)
- regcache_raw_supply (current_regcache, i, ®val);
+ regcache_raw_supply (regcache, i, ®val);
else if (psw & 0x8000)
- regcache_raw_supply (current_regcache, i, regp + SPU_REGMAP);
+ regcache_raw_supply (regcache, i, regp + SPU_REGMAP);
else
- regcache_raw_supply (current_regcache, i, regp + SPI_REGMAP);
+ regcache_raw_supply (regcache, i, regp + SPI_REGMAP);
}
}
@@ -115,7 +115,7 @@ fetch_regs (int tid)
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- supply_gregset (®s);
+ supply_gregset (current_regcache, (const elf_gregset_t *) ®s);
}
/* Fill register REGNO (if it is a general-purpose register) in
@@ -123,7 +123,8 @@ fetch_regs (int tid)
do this for all registers. */
void
-fill_gregset (elf_gregset_t * gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ elf_gregset_t * gregsetp, int regno)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
@@ -144,11 +145,11 @@ fill_gregset (elf_gregset_t * gregsetp,
continue;
if (i != M32R_SP_REGNUM)
- regcache_raw_collect (current_regcache, i, regp + regmap[i]);
+ regcache_raw_collect (regcache, i, regp + regmap[i]);
else if (psw & 0x8000)
- regcache_raw_collect (current_regcache, i, regp + SPU_REGMAP);
+ regcache_raw_collect (regcache, i, regp + SPU_REGMAP);
else
- regcache_raw_collect (current_regcache, i, regp + SPI_REGMAP);
+ regcache_raw_collect (regcache, i, regp + SPI_REGMAP);
}
}
@@ -163,7 +164,7 @@ store_regs (int tid, int regno)
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (®s, regno);
+ fill_gregset (current_regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't write registers"));
@@ -175,12 +176,13 @@ store_regs (int tid, int regno)
Since M32R has no floating-point registers, these functions do nothing. */
void
-supply_fpregset (gdb_fpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs)
{
}
void
-fill_fpregset (gdb_fpregset_t *fpregs, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregs, int regno)
{
}
diff -urNp gdb-orig/gdb/m68klinux-nat.c gdb-head/gdb/m68klinux-nat.c
--- gdb-orig/gdb/m68klinux-nat.c 2007-04-30 23:02:43.296202098 +0200
+++ gdb-head/gdb/m68klinux-nat.c 2007-05-01 00:14:01.767316528 +0200
@@ -242,29 +242,30 @@ old_store_inferior_registers (int regno)
them as gdb's idea of the current register values. */
void
-supply_gregset (elf_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
{
- elf_greg_t *regp = (elf_greg_t *) gregsetp;
+ const elf_greg_t *regp = (const elf_greg_t *) gregsetp;
int regi;
for (regi = M68K_D0_REGNUM; regi <= SP_REGNUM; regi++)
- 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]);
+ regcache_raw_supply (regcache, regi, ®p[regmap[regi]]);
+ regcache_raw_supply (regcache, PS_REGNUM, ®p[PT_SR]);
+ regcache_raw_supply (regcache, PC_REGNUM, ®p[PT_PC]);
}
/* Fill register REGNO (if it is a general-purpose register) in
*GREGSETPS with the value in GDB's register array. If REGNO is -1,
do this for all registers. */
void
-fill_gregset (elf_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ elf_gregset_t *gregsetp, int regno)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
for (i = 0; i < NUM_GREGS; i++)
if (regno == -1 || regno == i)
- regcache_raw_collect (current_regcache, i, regp + regmap[i]);
+ regcache_raw_collect (regcache, i, regp + regmap[i]);
}
#ifdef HAVE_PTRACE_GETREGS
@@ -290,7 +291,7 @@ fetch_regs (int tid)
perror_with_name (_("Couldn't get registers"));
}
- supply_gregset (®s);
+ supply_gregset (current_regcache, (const elf_gregset_t *) ®s);
}
/* Store all valid general-purpose registers in GDB's register array
@@ -304,7 +305,7 @@ store_regs (int tid, int regno)
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (®s, regno);
+ fill_gregset (current_regcache, ®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
perror_with_name (_("Couldn't write registers"));
@@ -321,25 +322,22 @@ static void store_regs (int tid, int reg
/* Transfering floating-point registers between GDB, inferiors and cores. */
/* What is the address of fpN within the floating-point register set F? */
-#define FPREG_ADDR(f, n) ((char *) &(f)->fpregs[(n) * 3])
+#define FPREG_ADDR(f, n) (&(f)->fpregs[(n) * 3])
/* Fill GDB's register array with the floating-point register values in
*FPREGSETP. */
void
-supply_fpregset (elf_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
{
int regi;
for (regi = FP0_REGNUM; regi < FP0_REGNUM + 8; regi++)
- regcache_raw_supply (current_regcache, regi,
+ regcache_raw_supply (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]);
+ regcache_raw_supply (regcache, M68K_FPC_REGNUM, &fpregsetp->fpcntl[0]);
+ regcache_raw_supply (regcache, M68K_FPS_REGNUM, &fpregsetp->fpcntl[1]);
+ regcache_raw_supply (regcache, M68K_FPI_REGNUM, &fpregsetp->fpcntl[2]);
}
/* Fill register REGNO (if it is a floating-point register) in
@@ -347,21 +345,22 @@ supply_fpregset (elf_fpregset_t *fpregse
do this for all registers. */
void
-fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ elf_fpregset_t *fpregsetp, int regno)
{
int i;
/* Fill in the floating-point registers. */
for (i = FP0_REGNUM; i < FP0_REGNUM + 8; i++)
if (regno == -1 || regno == i)
- regcache_raw_collect (current_regcache, i,
+ regcache_raw_collect (regcache, i,
FPREG_ADDR (fpregsetp, i - FP0_REGNUM));
/* Fill in the floating-point control registers. */
for (i = M68K_FPC_REGNUM; i <= M68K_FPI_REGNUM; i++)
if (regno == -1 || regno == i)
- regcache_raw_collect (current_regcache, i,
- (char *) &fpregsetp->fpcntl[i - M68K_FPC_REGNUM]);
+ regcache_raw_collect (regcache, i,
+ &fpregsetp->fpcntl[i - M68K_FPC_REGNUM]);
}
#ifdef HAVE_PTRACE_GETREGS
@@ -377,7 +376,7 @@ fetch_fpregs (int tid)
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
- supply_fpregset (&fpregs);
+ supply_fpregset (current_regcache, (const elf_fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register array
@@ -391,7 +390,7 @@ store_fpregs (int tid, int regno)
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't get floating point status"));
- fill_fpregset (&fpregs, regno);
+ fill_fpregset (current_regcache, &fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name (_("Couldn't write floating point status"));
@@ -543,7 +542,7 @@ fetch_core_registers (char *core_reg_sec
else
{
memcpy (&gregset, core_reg_sect, sizeof (gregset));
- supply_gregset (&gregset);
+ supply_gregset (current_regcache, (const elf_gregset_t *) &gregset);
}
break;
@@ -553,7 +552,7 @@ fetch_core_registers (char *core_reg_sec
else
{
memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
- supply_fpregset (&fpregset);
+ supply_fpregset (current_regcache, (const elf_fpregset_t *) &fpregset);
}
break;
diff -urNp gdb-orig/gdb/Makefile.in gdb-head/gdb/Makefile.in
--- gdb-orig/gdb/Makefile.in 2007-05-01 00:10:45.320433441 +0200
+++ gdb-head/gdb/Makefile.in 2007-05-01 00:14:01.780314683 +0200
@@ -1887,7 +1887,7 @@ corelow.o: corelow.c $(defs_h) $(arch_ut
$(exec_h) $(readline_h) $(gdb_assert_h) \
$(exceptions_h) $(solib_h)
core-regset.o: core-regset.c $(defs_h) $(command_h) $(gdbcore_h) \
- $(inferior_h) $(target_h) $(gdb_string_h) $(gregset_h)
+ $(inferior_h) $(target_h) $(regcache_h) $(gdb_string_h) $(gregset_h)
cp-abi.o: cp-abi.c $(defs_h) $(value_h) $(cp_abi_h) $(command_h) $(gdbcmd_h) \
$(ui_out_h) $(gdb_string_h)
cp-name-parser.o: cp-name-parser.c $(safe_ctype_h) $(libiberty_h) $(demangle_h)
@@ -2462,11 +2462,11 @@ proc-api.o: proc-api.c $(defs_h) $(gdbcm
proc-events.o: proc-events.c $(defs_h)
proc-flags.o: proc-flags.c $(defs_h)
procfs.o: procfs.c $(defs_h) $(inferior_h) $(target_h) $(gdbcore_h) \
- $(elf_bfd_h) $(gdbcmd_h) $(gdbthread_h) $(gdb_wait_h) \
+ $(elf_bfd_h) $(gdbcmd_h) $(gdbthread_h) $(regcache_h) $(gdb_wait_h) \
$(gdb_string_h) $(gdb_assert_h) $(inflow_h) $(auxv_h) \
$(gdb_dirent_h) $(gdb_stat_h) $(proc_utils_h) $(gregset_h)
proc-service.o: proc-service.c $(defs_h) $(gdb_proc_service_h) $(inferior_h) \
- $(symtab_h) $(target_h) $(gregset_h)
+ $(symtab_h) $(target_h) $(regcache_h) $(gregset_h)
proc-why.o: proc-why.c $(defs_h) $(proc_utils_h)
prologue-value.o: prologue-value.c $(defs_h) $(gdb_string_h) $(gdb_assert_h) \
$(prologue_value_h) $(regcache_h)
diff -urNp gdb-orig/gdb/mips-linux-nat.c gdb-head/gdb/mips-linux-nat.c
--- gdb-orig/gdb/mips-linux-nat.c 2007-05-01 00:10:38.832423968 +0200
+++ gdb-head/gdb/mips-linux-nat.c 2007-05-01 00:14:01.786313832 +0200
@@ -177,39 +177,41 @@ ps_get_thread_area (const struct ps_proc
/* Wrapper functions. These are only used by libthread_db. */
void
-supply_gregset (gdb_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
if (mips_isa_regsize (current_gdbarch) == 4)
- mips_supply_gregset (current_regcache, (void *) gregsetp);
+ mips_supply_gregset (regcache, (const mips_elf_gregset_t *) gregsetp);
else
- mips64_supply_gregset (current_regcache, (void *) gregsetp);
+ mips64_supply_gregset (regcache, (const mips64_elf_gregset_t *) gregsetp);
}
void
-fill_gregset (gdb_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregsetp, int regno)
{
if (mips_isa_regsize (current_gdbarch) == 4)
- mips_fill_gregset (current_regcache, (void *) gregsetp, regno);
+ mips_fill_gregset (regcache, (mips_elf_gregset_t *) gregsetp, regno);
else
- mips64_fill_gregset (current_regcache, (void *) gregsetp, regno);
+ mips64_fill_gregset (regcache, (mips64_elf_gregset_t *) gregsetp, regno);
}
void
-supply_fpregset (gdb_fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
{
if (mips_isa_regsize (current_gdbarch) == 4)
- mips_supply_fpregset (current_regcache, (void *) fpregsetp);
+ mips_supply_fpregset (regcache, (const mips_elf_fpregset_t *) fpregsetp);
else
- mips64_supply_fpregset (current_regcache, (void *) fpregsetp);
+ mips64_supply_fpregset (regcache, (const mips64_elf_fpregset_t *) fpregsetp);
}
void
-fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregsetp, int regno)
{
if (mips_isa_regsize (current_gdbarch) == 4)
- mips_fill_fpregset (current_regcache, (void *) fpregsetp, regno);
+ mips_fill_fpregset (regcache, (mips_elf_fpregset_t *) fpregsetp, regno);
else
- mips64_fill_fpregset (current_regcache, (void *) fpregsetp, regno);
+ mips64_fill_fpregset (regcache, (mips64_elf_fpregset_t *) fpregsetp, regno);
}
diff -urNp gdb-orig/gdb/ppc-linux-nat.c gdb-head/gdb/ppc-linux-nat.c
--- gdb-orig/gdb/ppc-linux-nat.c 2007-04-30 23:02:43.319198835 +0200
+++ gdb-head/gdb/ppc-linux-nat.c 2007-05-01 00:14:01.792312980 +0200
@@ -904,30 +904,31 @@ ppc_linux_store_inferior_registers (int
}
void
-supply_gregset (gdb_gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
{
/* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
interface, and not the wordsize of the program's ABI. */
int wordsize = sizeof (long);
- ppc_linux_supply_gregset (current_regcache, -1, gregsetp,
+ ppc_linux_supply_gregset (regcache, -1, gregsetp,
sizeof (gdb_gregset_t), wordsize);
}
static void
-right_fill_reg (int regnum, void *reg)
+right_fill_reg (const struct regcache *regcache, int regnum, void *reg)
{
/* NOTE: cagney/2003-11-25: This is the word size used by the ptrace
interface, and not the wordsize of the program's ABI. */
int wordsize = sizeof (long);
/* Right fill the register. */
- regcache_raw_collect (current_regcache, regnum,
+ regcache_raw_collect (regcache, regnum,
((bfd_byte *) reg
+ wordsize
- register_size (current_gdbarch, regnum)));
}
void
-fill_gregset (gdb_gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache,
+ gdb_gregset_t *gregsetp, int regno)
{
int regi;
elf_greg_t *regp = (elf_greg_t *) gregsetp;
@@ -941,34 +942,35 @@ fill_gregset (gdb_gregset_t *gregsetp, i
for (regi = 0; regi < ppc_num_gprs; regi++)
{
if ((regno == -1) || regno == tdep->ppc_gp0_regnum + regi)
- right_fill_reg (tdep->ppc_gp0_regnum + regi, (regp + PT_R0 + regi));
+ right_fill_reg (regcache, tdep->ppc_gp0_regnum + regi,
+ (regp + PT_R0 + regi));
}
if ((regno == -1) || regno == PC_REGNUM)
- right_fill_reg (PC_REGNUM, regp + PT_NIP);
+ right_fill_reg (regcache, PC_REGNUM, regp + PT_NIP);
if ((regno == -1) || regno == tdep->ppc_lr_regnum)
- right_fill_reg (tdep->ppc_lr_regnum, regp + PT_LNK);
+ right_fill_reg (regcache, tdep->ppc_lr_regnum, regp + PT_LNK);
if ((regno == -1) || regno == tdep->ppc_cr_regnum)
- regcache_raw_collect (current_regcache, tdep->ppc_cr_regnum,
+ regcache_raw_collect (regcache, tdep->ppc_cr_regnum,
regp + PT_CCR);
if ((regno == -1) || regno == tdep->ppc_xer_regnum)
- regcache_raw_collect (current_regcache, tdep->ppc_xer_regnum,
+ regcache_raw_collect (regcache, tdep->ppc_xer_regnum,
regp + PT_XER);
if ((regno == -1) || regno == tdep->ppc_ctr_regnum)
right_fill_reg (tdep->ppc_ctr_regnum, regp + PT_CTR);
#ifdef PT_MQ
if (((regno == -1) || regno == tdep->ppc_mq_regnum)
&& (tdep->ppc_mq_regnum != -1))
- right_fill_reg (tdep->ppc_mq_regnum, regp + PT_MQ);
+ right_fill_reg (regcache, tdep->ppc_mq_regnum, regp + PT_MQ);
#endif
if ((regno == -1) || regno == tdep->ppc_ps_regnum)
- right_fill_reg (tdep->ppc_ps_regnum, regp + PT_MSR);
+ right_fill_reg (regcache, tdep->ppc_ps_regnum, regp + PT_MSR);
}
void
-supply_fpregset (gdb_fpregset_t * fpregsetp)
+supply_fpregset (struct regcache *regcache, const gdb_fpregset_t * fpregsetp)
{
- ppc_linux_supply_fpregset (NULL, current_regcache, -1, fpregsetp,
+ ppc_linux_supply_fpregset (NULL, regcache, -1, fpregsetp,
sizeof (gdb_fpregset_t));
}
@@ -977,7 +979,8 @@ supply_fpregset (gdb_fpregset_t * fpregs
idea of the current floating point register set. If REGNO is -1,
update them all. */
void
-fill_fpregset (gdb_fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+ gdb_fpregset_t *fpregsetp, int regno)
{
int regi;
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
@@ -988,7 +991,7 @@ fill_fpregset (gdb_fpregset_t *fpregsetp
for (regi = 0; regi < ppc_num_fprs; regi++)
{
if ((regno == -1) || (regno == tdep->ppc_fp0_regnum + regi))
- regcache_raw_collect (current_regcache, tdep->ppc_fp0_regnum + regi,
+ regcache_raw_collect (regcache, tdep->ppc_fp0_regnum + regi,
fpp + 8 * regi);
}
if (regno == -1 || regno == tdep->ppc_fpscr_regnum)
diff -urNp gdb-orig/gdb/procfs.c gdb-head/gdb/procfs.c
--- gdb-orig/gdb/procfs.c 2007-04-30 23:02:43.332196990 +0200
+++ gdb-head/gdb/procfs.c 2007-05-01 00:14:01.806310993 +0200
@@ -30,6 +30,7 @@ Boston, MA 02110-1301, USA. */
#include "elf-bfd.h" /* for elfcore_write_* */
#include "gdbcmd.h"
#include "gdbthread.h"
+#include "regcache.h"
#if defined (NEW_PROC_API)
#define _STRUCTURED_PROC 1 /* Should be done by configure script. */
@@ -3705,7 +3706,7 @@ procfs_fetch_registers (int regnum)
if (gregs == NULL)
proc_error (pi, "fetch_registers, get_gregs", __LINE__);
- supply_gregset (gregs);
+ supply_gregset (current_regcache, (const gdb_gregset_t *) gregs);
if (FP0_REGNUM >= 0) /* Do we have an FPU? */
{
@@ -3720,7 +3721,7 @@ procfs_fetch_registers (int regnum)
if (fpregs == NULL)
proc_error (pi, "fetch_registers, get_fpregs", __LINE__);
- supply_fpregset (fpregs);
+ supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregs);
}
}
@@ -3773,7 +3774,7 @@ procfs_store_registers (int regnum)
if (gregs == NULL)
proc_error (pi, "store_registers, get_gregs", __LINE__);
- fill_gregset (gregs, regnum);
+ fill_gregset (current_regcache, gregs, regnum);
if (!proc_set_gregs (pi))
proc_error (pi, "store_registers, set_gregs", __LINE__);
@@ -3790,7 +3791,7 @@ procfs_store_registers (int regnum)
if (fpregs == NULL)
proc_error (pi, "store_registers, get_fpregs", __LINE__);
- fill_fpregset (fpregs, regnum);
+ fill_fpregset (current_regcache, fpregs, regnum);
if (!proc_set_fpregs (pi))
proc_error (pi, "store_registers, set_fpregs", __LINE__);
}
@@ -6020,7 +6021,7 @@ procfs_do_thread_registers (bfd *obfd, p
merged_pid = TIDGET (ptid) << 16 | PIDGET (ptid);
- fill_gregset (&gregs, -1);
+ fill_gregset (current_regcache, &gregs, -1);
#if defined (UNIXWARE)
note_data = (char *) elfcore_write_lwpstatus (obfd,
note_data,
@@ -6036,7 +6037,7 @@ procfs_do_thread_registers (bfd *obfd, p
stop_signal,
&gregs);
#endif
- fill_fpregset (&fpregs, -1);
+ fill_fpregset (current_regcache, &fpregs, -1);
note_data = (char *) elfcore_write_prfpreg (obfd,
note_data,
note_size,
@@ -6107,7 +6108,7 @@ procfs_make_note_section (bfd *obfd, int
psargs);
#ifdef UNIXWARE
- fill_gregset (&gregs, -1);
+ fill_gregset (current_regcache, &gregs, -1);
note_data = elfcore_write_pstatus (obfd, note_data, note_size,
PIDGET (inferior_ptid),
stop_signal, &gregs);
diff -urNp gdb-orig/gdb/proc-service.c gdb-head/gdb/proc-service.c
--- gdb-orig/gdb/proc-service.c 2007-04-30 23:02:43.374191030 +0200
+++ gdb-head/gdb/proc-service.c 2007-05-01 00:14:01.811310283 +0200
@@ -27,6 +27,7 @@
#include "inferior.h"
#include "symtab.h"
#include "target.h"
+#include "regcache.h"
/* Prototypes for supply_gregset etc. */
#include "gregset.h"
@@ -234,7 +235,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwp
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
target_fetch_registers (-1);
- fill_gregset ((gdb_gregset_t *) gregset, -1);
+ fill_gregset (current_regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
return PS_OK;
@@ -250,8 +251,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwp
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
- /* FIXME: We should really make supply_gregset const-correct. */
- supply_gregset ((gdb_gregset_t *) gregset);
+ supply_gregset (current_regcache, (const gdb_gregset_t *) gregset);
target_store_registers (-1);
do_cleanups (old_chain);
@@ -270,7 +270,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, l
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
target_fetch_registers (-1);
- fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
+ fill_fpregset (current_regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
return PS_OK;
@@ -287,8 +287,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, l
inferior_ptid = BUILD_LWP (lwpid, ph->pid);
- /* FIXME: We should really make supply_fpregset const-correct. */
- supply_fpregset ((gdb_fpregset_t *) fpregset);
+ supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregset);
target_store_registers (-1);
do_cleanups (old_chain);
diff -urNp gdb-orig/gdb/s390-nat.c gdb-head/gdb/s390-nat.c
--- gdb-orig/gdb/s390-nat.c 2007-04-30 23:02:43.378190462 +0200
+++ gdb-head/gdb/s390-nat.c 2007-05-01 00:14:01.816309574 +0200
@@ -64,53 +64,53 @@
/* Fill GDB's register array with the general-purpose register values
in *REGP. */
void
-supply_gregset (gregset_t *regp)
+supply_gregset (struct regcache *regcache, const gregset_t *regp)
{
int i;
for (i = 0; i < S390_NUM_REGS; i++)
if (regmap_gregset[i] != -1)
- regcache_raw_supply (current_regcache, i,
- (char *)regp + regmap_gregset[i] + SUBOFF (i));
+ regcache_raw_supply (regcache, i,
+ (const char *)regp + regmap_gregset[i] + SUBOFF (i));
}
/* Fill register REGNO (if it is a general-purpose register) in
*REGP with the value in GDB's register array. If REGNO is -1,
do this for all registers. */
void
-fill_gregset (gregset_t *regp, int regno)
+fill_gregset (const struct regcache *regcache, gregset_t *regp, int regno)
{
int i;
for (i = 0; i < S390_NUM_REGS; i++)
if (regmap_gregset[i] != -1)
if (regno == -1 || regno == i)
- regcache_raw_collect (current_regcache, i,
+ regcache_raw_collect (regcache, i,
(char *)regp + regmap_gregset[i] + SUBOFF (i));
}
/* Fill GDB's register array with the floating-point register values
in *REGP. */
void
-supply_fpregset (fpregset_t *regp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *regp)
{
int i;
for (i = 0; i < S390_NUM_REGS; i++)
if (regmap_fpregset[i] != -1)
- regcache_raw_supply (current_regcache, i,
- ((char *)regp) + regmap_fpregset[i]);
+ regcache_raw_supply (regcache, i,
+ (const char *)regp + regmap_fpregset[i]);
}
/* Fill register REGNO (if it is a general-purpose register) in
*REGP with the value in GDB's register array. If REGNO is -1,
do this for all registers. */
void
-fill_fpregset (fpregset_t *regp, int regno)
+fill_fpregset (const struct regcache *regcache, fpregset_t *regp, int regno)
{
int i;
for (i = 0; i < S390_NUM_REGS; i++)
if (regmap_fpregset[i] != -1)
if (regno == -1 || regno == i)
- regcache_raw_collect (current_regcache, i,
- ((char *)regp) + regmap_fpregset[i]);
+ regcache_raw_collect (regcache, i,
+ (char *)regp + regmap_fpregset[i]);
}
/* Find the TID for the current inferior thread to use with ptrace. */
@@ -139,7 +139,7 @@ fetch_regs (int tid)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get registers"));
- supply_gregset (®s);
+ supply_gregset (current_regcache, (const gregset_t *) ®s);
}
/* Store all valid general-purpose registers in GDB's register cache
@@ -156,7 +156,7 @@ store_regs (int tid, int regnum)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get registers"));
- fill_gregset (®s, regnum);
+ fill_gregset (current_regcache, ®s, regnum);
if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't write registers"));
@@ -176,7 +176,7 @@ fetch_fpregs (int tid)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get floating point status"));
- supply_fpregset (&fpregs);
+ supply_fpregset (current_regcache, (const fpregset_t *) &fpregs);
}
/* Store all valid floating-point registers in GDB's register cache
@@ -193,7 +193,7 @@ store_fpregs (int tid, int regnum)
if (ptrace (PTRACE_PEEKUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't get floating point status"));
- fill_fpregset (&fpregs, regnum);
+ fill_fpregset (current_regcache, &fpregs, regnum);
if (ptrace (PTRACE_POKEUSR_AREA, tid, (long) &parea) < 0)
perror_with_name (_("Couldn't write floating point status"));
diff -urNp gdb-orig/gdb/sol-thread.c gdb-head/gdb/sol-thread.c
--- gdb-orig/gdb/sol-thread.c 2007-04-30 23:02:43.385189469 +0200
+++ gdb-head/gdb/sol-thread.c 2007-05-01 00:14:01.823308580 +0200
@@ -531,8 +531,8 @@ sol_thread_fetch_registers (int regnum)
calling the td routines because the td routines call ps_lget*
which affect the values stored in the registers array. */
- supply_gregset ((gdb_gregset_t *) &gregset);
- supply_fpregset ((gdb_fpregset_t *) &fpregset);
+ supply_gregset (current_regcache, (const gdb_gregset_t *) &gregset);
+ supply_fpregset (current_regcache, (const gdb_fpregset_t *) &fpregset);
#if 0
/* FIXME: libthread_db doesn't seem to handle this right. */
@@ -618,8 +618,8 @@ sol_thread_store_registers (int regnum)
#endif
}
- fill_gregset ((gdb_gregset_t *) &gregset, regnum);
- fill_fpregset ((gdb_fpregset_t *) &fpregset, regnum);
+ fill_gregset (current_regcache, (gdb_gregset_t *) &gregset, regnum);
+ fill_fpregset (current_regcache, (gdb_fpregset_t *) &fpregset, regnum);
val = p_td_thr_setgregs (&thandle, gregset);
if (val != TD_OK)
@@ -1107,7 +1107,7 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwp
procfs_ops.to_fetch_registers (-1);
else
orig_core_ops.to_fetch_registers (-1);
- fill_gregset ((gdb_gregset_t *) gregset, -1);
+ fill_gregset (current_regcache, (gdb_gregset_t *) gregset, -1);
do_cleanups (old_chain);
@@ -1126,7 +1126,7 @@ ps_lsetregs (gdb_ps_prochandle_t ph, lwp
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
- supply_gregset ((gdb_gregset_t *) gregset);
+ supply_gregset (current_regcache, (const gdb_gregset_t *) gregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
else
@@ -1239,7 +1239,7 @@ ps_lgetfpregs (gdb_ps_prochandle_t ph, l
procfs_ops.to_fetch_registers (-1);
else
orig_core_ops.to_fetch_registers (-1);
- fill_fpregset ((gdb_fpregset_t *) fpregset, -1);
+ fill_fpregset (current_regcache, (gdb_fpregset_t *) fpregset, -1);
do_cleanups (old_chain);
@@ -1258,7 +1258,7 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, l
inferior_ptid = BUILD_LWP (lwpid, PIDGET (inferior_ptid));
- supply_fpregset ((gdb_fpregset_t *) fpregset);
+ supply_fpregset (current_regcache, (const gdb_fpregset_t *) fpregset);
if (target_has_execution)
procfs_ops.to_store_registers (-1);
else
diff -urNp gdb-orig/gdb/sparc64-linux-nat.c gdb-head/gdb/sparc64-linux-nat.c
--- gdb-orig/gdb/sparc64-linux-nat.c 2007-04-30 23:02:43.389188901 +0200
+++ gdb-head/gdb/sparc64-linux-nat.c 2007-05-01 00:14:01.827308013 +0200
@@ -47,27 +47,28 @@ static const struct sparc_gregset sparc6
void
-supply_gregset (prgregset_t *gregs)
+supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
{
- sparc64_supply_gregset (sparc_gregset, current_regcache, -1, gregs);
+ sparc64_supply_gregset (sparc_gregset, regcache, -1, gregs);
}
void
-supply_fpregset (prfpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
{
- sparc64_supply_fpregset (current_regcache, -1, fpregs);
+ sparc64_supply_fpregset (regcache, -1, fpregs);
}
void
-fill_gregset (prgregset_t *gregs, int regnum)
+fill_gregset (const struct regcache *regcache, prgregset_t *gregs, int regnum)
{
- sparc64_collect_gregset (sparc_gregset, current_regcache, regnum, gregs);
+ sparc64_collect_gregset (sparc_gregset, regcache, regnum, gregs);
}
void
-fill_fpregset (prfpregset_t *fpregs, int regnum)
+fill_fpregset (const struct regcache *regcache,
+ prfpregset_t *fpregs, int regnum)
{
- sparc64_collect_fpregset (current_regcache, regnum, fpregs);
+ sparc64_collect_fpregset (regcache, regnum, fpregs);
}
/* Provide a prototype to silence -Wmissing-prototypes. */
diff -urNp gdb-orig/gdb/sparc-linux-nat.c gdb-head/gdb/sparc-linux-nat.c
--- gdb-orig/gdb/sparc-linux-nat.c 2007-04-30 23:02:43.393188334 +0200
+++ gdb-head/gdb/sparc-linux-nat.c 2007-05-01 00:14:01.831307445 +0200
@@ -31,27 +31,27 @@
#include "linux-nat.h"
void
-supply_gregset (prgregset_t *gregs)
+supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
{
- sparc32_supply_gregset (sparc_gregset, current_regcache, -1, gregs);
+ sparc32_supply_gregset (sparc_gregset, regcache, -1, gregs);
}
void
-supply_fpregset (prfpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
{
- sparc32_supply_fpregset (current_regcache, -1, fpregs);
+ sparc32_supply_fpregset (regcache, -1, fpregs);
}
void
-fill_gregset (prgregset_t *gregs, int regnum)
+fill_gregset (const struct regcache *regcache, prgregset_t *gregs, int regnum)
{
- sparc32_collect_gregset (sparc_gregset, current_regcache, regnum, gregs);
+ sparc32_collect_gregset (sparc_gregset, regcache, regnum, gregs);
}
void
-fill_fpregset (prfpregset_t *fpregs, int regnum)
+fill_fpregset (const struct regcache *regcache, prfpregset_t *fpregs, int regnum)
{
- sparc32_collect_fpregset (current_regcache, regnum, fpregs);
+ sparc32_collect_fpregset (regcache, regnum, fpregs);
}
void _initialialize_sparc_linux_nat (void);
diff -urNp gdb-orig/gdb/sparc-sol2-nat.c gdb-head/gdb/sparc-sol2-nat.c
--- gdb-orig/gdb/sparc-sol2-nat.c 2007-04-30 23:02:43.397187766 +0200
+++ gdb-head/gdb/sparc-sol2-nat.c 2007-05-01 00:14:01.835306877 +0200
@@ -74,25 +74,25 @@
#endif
void
-supply_gregset (prgregset_t *gregs)
+supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
{
- sparc_supply_gregset (&sparc_sol2_gregset, current_regcache, -1, gregs);
+ sparc_supply_gregset (&sparc_sol2_gregset, regcache, -1, gregs);
}
void
-supply_fpregset (prfpregset_t *fpregs)
+supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
{
- sparc_supply_fpregset (current_regcache, -1, fpregs);
+ sparc_supply_fpregset (regcache, -1, fpregs);
}
void
-fill_gregset (prgregset_t *gregs, int regnum)
+fill_gregset (const struct regcache *regcache, prgregset_t *gregs, int regnum)
{
- sparc_collect_gregset (&sparc_sol2_gregset, current_regcache, regnum, gregs);
+ sparc_collect_gregset (&sparc_sol2_gregset, regcache, regnum, gregs);
}
void
-fill_fpregset (prfpregset_t *fpregs, int regnum)
+fill_fpregset (const struct regcache *regcache, prfpregset_t *fpregs, int regnum)
{
- sparc_collect_fpregset (current_regcache, regnum, fpregs);
+ sparc_collect_fpregset (regcache, regnum, fpregs);
}
--
Dr. Ulrich Weigand
GNU Toolchain for Linux on System z and Cell BE
Ulrich.Weigand@de.ibm.com