public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
From: Jan Kratochvil <jkratoch@fedoraproject.org>
To: git-commits@fedoraproject.org
Subject: [rpms/gdb] gdb-17.2-rebase-f44: - Revert FSF GDB gdbserver tracepoints as incomplete now.
Date: Sat, 27 Jun 2026 23:54:32 GMT [thread overview]
Message-ID: <178260447277.1.10728220100538379774.rpms-gdb-39d52ac1d6cf@fedoraproject.org> (raw)
A new commit has been pushed.
Repo : rpms/gdb
Branch : gdb-17.2-rebase-f44
Commit : 39d52ac1d6cf7446f797c9856a426db91b9b849b
Author : Jan Kratochvil <jkratoch@fedoraproject.org>
Date : 2010-01-21T19:53:41+00:00
Stats : +2681/-1 in 2 file(s)
URL : https://src.fedoraproject.org/rpms/gdb/c/39d52ac1d6cf7446f797c9856a426db91b9b849b?branch=gdb-17.2-rebase-f44
Log:
- Revert FSF GDB gdbserver tracepoints as incomplete now.
---
diff --git a/gdb-gdbserver-tracepoint-revert.patch b/gdb-gdbserver-tracepoint-revert.patch
new file mode 100644
index 0000000..4e9624d
--- /dev/null
+++ b/gdb-gdbserver-tracepoint-revert.patch
@@ -0,0 +1,2673 @@
+http://sourceware.org/ml/gdb-cvs/2010-01/msg00183.html
+
+REVERT
+
+--- ./gdb/gdbserver/i387-fp.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/i387-fp.c 2010-01-21 20:33:15.000000000 +0100
+@@ -73,7 +73,7 @@ struct i387_fxsave {
+ };
+
+ void
+-i387_cache_to_fsave (struct regcache *regcache, void *buf)
++i387_cache_to_fsave (void *buf)
+ {
+ struct i387_fsave *fp = (struct i387_fsave *) buf;
+ int i;
+@@ -81,39 +81,38 @@ i387_cache_to_fsave (struct regcache *re
+ unsigned long val, val2;
+
+ for (i = 0; i < 8; i++)
+- collect_register (regcache, i + st0_regnum,
+- ((char *) &fp->st_space[0]) + i * 10);
++ collect_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 10);
+
+- collect_register_by_name (regcache, "fioff", &fp->fioff);
+- collect_register_by_name (regcache, "fooff", &fp->fooff);
++ collect_register_by_name ("fioff", &fp->fioff);
++ collect_register_by_name ("fooff", &fp->fooff);
+
+ /* This one's 11 bits... */
+- collect_register_by_name (regcache, "fop", &val2);
++ collect_register_by_name ("fop", &val2);
+ fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
+
+ /* Some registers are 16-bit. */
+- collect_register_by_name (regcache, "fctrl", &val);
++ collect_register_by_name ("fctrl", &val);
+ fp->fctrl = val;
+
+- collect_register_by_name (regcache, "fstat", &val);
++ collect_register_by_name ("fstat", &val);
+ val &= 0xFFFF;
+ fp->fstat = val;
+
+- collect_register_by_name (regcache, "ftag", &val);
++ collect_register_by_name ("ftag", &val);
+ val &= 0xFFFF;
+ fp->ftag = val;
+
+- collect_register_by_name (regcache, "fiseg", &val);
++ collect_register_by_name ("fiseg", &val);
+ val &= 0xFFFF;
+ fp->fiseg = val;
+
+- collect_register_by_name (regcache, "foseg", &val);
++ collect_register_by_name ("foseg", &val);
+ val &= 0xFFFF;
+ fp->foseg = val;
+ }
+
+ void
+-i387_fsave_to_cache (struct regcache *regcache, const void *buf)
++i387_fsave_to_cache (const void *buf)
+ {
+ struct i387_fsave *fp = (struct i387_fsave *) buf;
+ int i;
+@@ -121,35 +120,34 @@ i387_fsave_to_cache (struct regcache *re
+ unsigned long val;
+
+ for (i = 0; i < 8; i++)
+- supply_register (regcache, i + st0_regnum,
+- ((char *) &fp->st_space[0]) + i * 10);
++ supply_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 10);
+
+- supply_register_by_name (regcache, "fioff", &fp->fioff);
+- supply_register_by_name (regcache, "fooff", &fp->fooff);
++ supply_register_by_name ("fioff", &fp->fioff);
++ supply_register_by_name ("fooff", &fp->fooff);
+
+ /* Some registers are 16-bit. */
+ val = fp->fctrl & 0xFFFF;
+- supply_register_by_name (regcache, "fctrl", &val);
++ supply_register_by_name ("fctrl", &val);
+
+ val = fp->fstat & 0xFFFF;
+- supply_register_by_name (regcache, "fstat", &val);
++ supply_register_by_name ("fstat", &val);
+
+ val = fp->ftag & 0xFFFF;
+- supply_register_by_name (regcache, "ftag", &val);
++ supply_register_by_name ("ftag", &val);
+
+ val = fp->fiseg & 0xFFFF;
+- supply_register_by_name (regcache, "fiseg", &val);
++ supply_register_by_name ("fiseg", &val);
+
+ val = fp->foseg & 0xFFFF;
+- supply_register_by_name (regcache, "foseg", &val);
++ supply_register_by_name ("foseg", &val);
+
+ /* fop has only 11 valid bits. */
+ val = (fp->fop) & 0x7FF;
+- supply_register_by_name (regcache, "fop", &val);
++ supply_register_by_name ("fop", &val);
+ }
+
+ void
+-i387_cache_to_fxsave (struct regcache *regcache, void *buf)
++i387_cache_to_fxsave (void *buf)
+ {
+ struct i387_fxsave *fp = (struct i387_fxsave *) buf;
+ int i;
+@@ -158,29 +156,27 @@ i387_cache_to_fxsave (struct regcache *r
+ unsigned long val, val2;
+
+ for (i = 0; i < 8; i++)
+- collect_register (regcache, i + st0_regnum,
+- ((char *) &fp->st_space[0]) + i * 16);
++ collect_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 16);
+ for (i = 0; i < num_xmm_registers; i++)
+- collect_register (regcache, i + xmm0_regnum,
+- ((char *) &fp->xmm_space[0]) + i * 16);
++ collect_register (i + xmm0_regnum, ((char *) &fp->xmm_space[0]) + i * 16);
+
+- collect_register_by_name (regcache, "fioff", &fp->fioff);
+- collect_register_by_name (regcache, "fooff", &fp->fooff);
+- collect_register_by_name (regcache, "mxcsr", &fp->mxcsr);
++ collect_register_by_name ("fioff", &fp->fioff);
++ collect_register_by_name ("fooff", &fp->fooff);
++ collect_register_by_name ("mxcsr", &fp->mxcsr);
+
+ /* This one's 11 bits... */
+- collect_register_by_name (regcache, "fop", &val2);
++ collect_register_by_name ("fop", &val2);
+ fp->fop = (val2 & 0x7FF) | (fp->fop & 0xF800);
+
+ /* Some registers are 16-bit. */
+- collect_register_by_name (regcache, "fctrl", &val);
++ collect_register_by_name ("fctrl", &val);
+ fp->fctrl = val;
+
+- collect_register_by_name (regcache, "fstat", &val);
++ collect_register_by_name ("fstat", &val);
+ fp->fstat = val;
+
+ /* Convert to the simplifed tag form stored in fxsave data. */
+- collect_register_by_name (regcache, "ftag", &val);
++ collect_register_by_name ("ftag", &val);
+ val &= 0xFFFF;
+ val2 = 0;
+ for (i = 7; i >= 0; i--)
+@@ -192,10 +188,10 @@ i387_cache_to_fxsave (struct regcache *r
+ }
+ fp->ftag = val2;
+
+- collect_register_by_name (regcache, "fiseg", &val);
++ collect_register_by_name ("fiseg", &val);
+ fp->fiseg = val;
+
+- collect_register_by_name (regcache, "foseg", &val);
++ collect_register_by_name ("foseg", &val);
+ fp->foseg = val;
+ }
+
+@@ -247,7 +243,7 @@ i387_ftag (struct i387_fxsave *fp, int r
+ }
+
+ void
+-i387_fxsave_to_cache (struct regcache *regcache, const void *buf)
++i387_fxsave_to_cache (const void *buf)
+ {
+ struct i387_fxsave *fp = (struct i387_fxsave *) buf;
+ int i, top;
+@@ -256,22 +252,20 @@ i387_fxsave_to_cache (struct regcache *r
+ unsigned long val;
+
+ for (i = 0; i < 8; i++)
+- supply_register (regcache, i + st0_regnum,
+- ((char *) &fp->st_space[0]) + i * 16);
++ supply_register (i + st0_regnum, ((char *) &fp->st_space[0]) + i * 16);
+ for (i = 0; i < num_xmm_registers; i++)
+- supply_register (regcache, i + xmm0_regnum,
+- ((char *) &fp->xmm_space[0]) + i * 16);
++ supply_register (i + xmm0_regnum, ((char *) &fp->xmm_space[0]) + i * 16);
+
+- supply_register_by_name (regcache, "fioff", &fp->fioff);
+- supply_register_by_name (regcache, "fooff", &fp->fooff);
+- supply_register_by_name (regcache, "mxcsr", &fp->mxcsr);
++ supply_register_by_name ("fioff", &fp->fioff);
++ supply_register_by_name ("fooff", &fp->fooff);
++ supply_register_by_name ("mxcsr", &fp->mxcsr);
+
+ /* Some registers are 16-bit. */
+ val = fp->fctrl & 0xFFFF;
+- supply_register_by_name (regcache, "fctrl", &val);
++ supply_register_by_name ("fctrl", &val);
+
+ val = fp->fstat & 0xFFFF;
+- supply_register_by_name (regcache, "fstat", &val);
++ supply_register_by_name ("fstat", &val);
+
+ /* Generate the form of ftag data that GDB expects. */
+ top = (fp->fstat >> 11) & 0x7;
+@@ -285,14 +279,14 @@ i387_fxsave_to_cache (struct regcache *r
+ tag = 3;
+ val |= tag << (2 * i);
+ }
+- supply_register_by_name (regcache, "ftag", &val);
++ supply_register_by_name ("ftag", &val);
+
+ val = fp->fiseg & 0xFFFF;
+- supply_register_by_name (regcache, "fiseg", &val);
++ supply_register_by_name ("fiseg", &val);
+
+ val = fp->foseg & 0xFFFF;
+- supply_register_by_name (regcache, "foseg", &val);
++ supply_register_by_name ("foseg", &val);
+
+ val = (fp->fop) & 0x7FF;
+- supply_register_by_name (regcache, "fop", &val);
++ supply_register_by_name ("fop", &val);
+ }
+--- ./gdb/gdbserver/i387-fp.h 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/i387-fp.h 2010-01-21 20:33:15.000000000 +0100
+@@ -20,11 +20,11 @@
+ #ifndef I387_FP_H
+ #define I387_FP_H
+
+-void i387_cache_to_fsave (struct regcache *regcache, void *buf);
+-void i387_fsave_to_cache (struct regcache *regcache, const void *buf);
++void i387_cache_to_fsave (void *buf);
++void i387_fsave_to_cache (const void *buf);
+
+-void i387_cache_to_fxsave (struct regcache *regcache, void *buf);
+-void i387_fxsave_to_cache (struct regcache *regcache, const void *buf);
++void i387_cache_to_fxsave (void *buf);
++void i387_fxsave_to_cache (const void *buf);
+
+ extern int num_xmm_registers;
+
+--- ./gdb/gdbserver/linux-arm-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-arm-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -81,17 +81,17 @@ arm_cannot_fetch_register (int regno)
+ }
+
+ static void
+-arm_fill_gregset (struct regcache *regcache, void *buf)
++arm_fill_gregset (void *buf)
+ {
+ int i;
+
+ for (i = 0; i < arm_num_regs; i++)
+ if (arm_regmap[i] != -1)
+- collect_register (regcache, i, ((char *) buf) + arm_regmap[i]);
++ collect_register (i, ((char *) buf) + arm_regmap[i]);
+ }
+
+ static void
+-arm_store_gregset (struct regcache *regcache, const void *buf)
++arm_store_gregset (const void *buf)
+ {
+ int i;
+ char zerobuf[8];
+@@ -99,13 +99,13 @@ arm_store_gregset (struct regcache *regc
+ memset (zerobuf, 0, 8);
+ for (i = 0; i < arm_num_regs; i++)
+ if (arm_regmap[i] != -1)
+- supply_register (regcache, i, ((char *) buf) + arm_regmap[i]);
++ supply_register (i, ((char *) buf) + arm_regmap[i]);
+ else
+- supply_register (regcache, i, zerobuf);
++ supply_register (i, zerobuf);
+ }
+
+ static void
+-arm_fill_wmmxregset (struct regcache *regcache, void *buf)
++arm_fill_wmmxregset (void *buf)
+ {
+ int i;
+
+@@ -113,16 +113,15 @@ arm_fill_wmmxregset (struct regcache *re
+ return;
+
+ for (i = 0; i < 16; i++)
+- collect_register (regcache, arm_num_regs + i, (char *) buf + i * 8);
++ collect_register (arm_num_regs + i, (char *) buf + i * 8);
+
+ /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
+ for (i = 0; i < 6; i++)
+- collect_register (regcache, arm_num_regs + i + 16,
+- (char *) buf + 16 * 8 + i * 4);
++ collect_register (arm_num_regs + i + 16, (char *) buf + 16 * 8 + i * 4);
+ }
+
+ static void
+-arm_store_wmmxregset (struct regcache *regcache, const void *buf)
++arm_store_wmmxregset (const void *buf)
+ {
+ int i;
+
+@@ -130,16 +129,15 @@ arm_store_wmmxregset (struct regcache *r
+ return;
+
+ for (i = 0; i < 16; i++)
+- supply_register (regcache, arm_num_regs + i, (char *) buf + i * 8);
++ supply_register (arm_num_regs + i, (char *) buf + i * 8);
+
+ /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
+ for (i = 0; i < 6; i++)
+- supply_register (regcache, arm_num_regs + i + 16,
+- (char *) buf + 16 * 8 + i * 4);
++ supply_register (arm_num_regs + i + 16, (char *) buf + 16 * 8 + i * 4);
+ }
+
+ static void
+-arm_fill_vfpregset (struct regcache *regcache, void *buf)
++arm_fill_vfpregset (void *buf)
+ {
+ int i, num, base;
+
+@@ -153,13 +151,13 @@ arm_fill_vfpregset (struct regcache *reg
+
+ base = find_regno ("d0");
+ for (i = 0; i < num; i++)
+- collect_register (regcache, base + i, (char *) buf + i * 8);
++ collect_register (base + i, (char *) buf + i * 8);
+
+- collect_register_by_name (regcache, "fpscr", (char *) buf + 32 * 8);
++ collect_register_by_name ("fpscr", (char *) buf + 32 * 8);
+ }
+
+ static void
+-arm_store_vfpregset (struct regcache *regcache, const void *buf)
++arm_store_vfpregset (const void *buf)
+ {
+ int i, num, base;
+
+@@ -173,28 +171,28 @@ arm_store_vfpregset (struct regcache *re
+
+ base = find_regno ("d0");
+ for (i = 0; i < num; i++)
+- supply_register (regcache, base + i, (char *) buf + i * 8);
++ supply_register (base + i, (char *) buf + i * 8);
+
+- supply_register_by_name (regcache, "fpscr", (char *) buf + 32 * 8);
++ supply_register_by_name ("fpscr", (char *) buf + 32 * 8);
+ }
+
+ extern int debug_threads;
+
+ static CORE_ADDR
+-arm_get_pc (struct regcache *regcache)
++arm_get_pc ()
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ if (debug_threads)
+ fprintf (stderr, "stop pc is %08lx\n", pc);
+ return pc;
+ }
+
+ static void
+-arm_set_pc (struct regcache *regcache, CORE_ADDR pc)
++arm_set_pc (CORE_ADDR pc)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ /* Correct in either endianness. */
+@@ -212,10 +210,9 @@ static const unsigned long arm_eabi_brea
+ static int
+ arm_breakpoint_at (CORE_ADDR where)
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ unsigned long cpsr;
+
+- collect_register_by_name (regcache, "cpsr", &cpsr);
++ collect_register_by_name ("cpsr", &cpsr);
+
+ if (cpsr & 0x20)
+ {
+@@ -246,11 +243,10 @@ arm_breakpoint_at (CORE_ADDR where)
+ is outside of the function. So rather than importing software single-step,
+ we can just run until exit. */
+ static CORE_ADDR
+-arm_reinsert_addr (void)
++arm_reinsert_addr ()
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ unsigned long pc;
+- collect_register_by_name (regcache, "lr", &pc);
++ collect_register_by_name ("lr", &pc);
+ return pc;
+ }
+
+--- ./gdb/gdbserver/linux-cris-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-cris-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -62,20 +62,20 @@ cris_cannot_fetch_register (int regno)
+ extern int debug_threads;
+
+ static CORE_ADDR
+-cris_get_pc (struct regcache *regcache, void)
++cris_get_pc (void)
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ if (debug_threads)
+ fprintf (stderr, "stop pc is %08lx\n", pc);
+ return pc;
+ }
+
+ static void
+-cris_set_pc (struct regcache *regcache, CORE_ADDR pc)
++cris_set_pc (CORE_ADDR pc)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ static const unsigned short cris_breakpoint = 0xe938;
+@@ -102,9 +102,8 @@ cris_breakpoint_at (CORE_ADDR where)
+ static CORE_ADDR
+ cris_reinsert_addr (void)
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ unsigned long pc;
+- collect_register_by_name (regcache, "srp", &pc);
++ collect_register_by_name ("srp", &pc);
+ return pc;
+ }
+
+--- ./gdb/gdbserver/linux-crisv32-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-crisv32-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -54,20 +54,20 @@ static int cris_regmap[] = {
+ extern int debug_threads;
+
+ static CORE_ADDR
+-cris_get_pc (struct regcache *regcache)
++cris_get_pc (void)
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ if (debug_threads)
+ fprintf (stderr, "stop pc is %08lx\n", pc);
+ return pc;
+ }
+
+ static void
+-cris_set_pc (struct regcache *regcache, CORE_ADDR pc)
++cris_set_pc (CORE_ADDR pc)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ static const unsigned short cris_breakpoint = 0xe938;
+@@ -99,41 +99,39 @@ cris_breakpoint_at (CORE_ADDR where)
+ static CORE_ADDR
+ cris_reinsert_addr (void)
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ unsigned long pc;
+- collect_register_by_name (regcache, "srp", &pc);
++ collect_register_by_name ("srp", &pc);
+ return pc;
+ }
+
+ static void
+-cris_write_data_breakpoint (struct regcache *regcache,
+- int bp, unsigned long start, unsigned long end)
++cris_write_data_breakpoint (int bp, unsigned long start, unsigned long end)
+ {
+ switch (bp)
+ {
+ case 0:
+- supply_register_by_name (regcache, "s3", &start);
+- supply_register_by_name (regcache, "s4", &end);
++ supply_register_by_name ("s3", &start);
++ supply_register_by_name ("s4", &end);
+ break;
+ case 1:
+- supply_register_by_name (regcache, "s5", &start);
+- supply_register_by_name (regcache, "s6", &end);
++ supply_register_by_name ("s5", &start);
++ supply_register_by_name ("s6", &end);
+ break;
+ case 2:
+- supply_register_by_name (regcache, "s7", &start);
+- supply_register_by_name (regcache, "s8", &end);
++ supply_register_by_name ("s7", &start);
++ supply_register_by_name ("s8", &end);
+ break;
+ case 3:
+- supply_register_by_name (regcache, "s9", &start);
+- supply_register_by_name (regcache, "s10", &end);
++ supply_register_by_name ("s9", &start);
++ supply_register_by_name ("s10", &end);
+ break;
+ case 4:
+- supply_register_by_name (regcache, "s11", &start);
+- supply_register_by_name (regcache, "s12", &end);
++ supply_register_by_name ("s11", &start);
++ supply_register_by_name ("s12", &end);
+ break;
+ case 5:
+- supply_register_by_name (regcache, "s13", &start);
+- supply_register_by_name (regcache, "s14", &end);
++ supply_register_by_name ("s13", &start);
++ supply_register_by_name ("s14", &end);
+ break;
+ }
+ }
+@@ -145,7 +143,6 @@ cris_insert_point (char type, CORE_ADDR
+ unsigned long bp_ctrl;
+ unsigned long start, end;
+ unsigned long ccs;
+- struct regcache *regcache;
+
+ /* Breakpoint/watchpoint types (GDB terminology):
+ 0 = memory breakpoint for instructions
+@@ -161,15 +158,13 @@ cris_insert_point (char type, CORE_ADDR
+ return 1;
+ }
+
+- regcache = get_thread_regcache (current_inferior, 1);
+-
+ /* Read watchpoints are set as access watchpoints, because of GDB's
+ inability to deal with pure read watchpoints. */
+ if (type == '3')
+ type = '4';
+
+ /* Get the configuration register. */
+- collect_register_by_name (regcache, "s0", &bp_ctrl);
++ collect_register_by_name ("s0", &bp_ctrl);
+
+ /* The watchpoint allocation scheme is the simplest possible.
+ For example, if a region is watched for read and
+@@ -207,19 +202,19 @@ cris_insert_point (char type, CORE_ADDR
+ }
+
+ /* Setup the configuration register. */
+- supply_register_by_name (regcache, "s0", &bp_ctrl);
++ supply_register_by_name ("s0", &bp_ctrl);
+
+ /* Setup the range. */
+ start = addr;
+ end = addr + len - 1;
+
+ /* Configure the watchpoint register. */
+- cris_write_data_breakpoint (regcache, bp, start, end);
++ cris_write_data_breakpoint (bp, start, end);
+
+- collect_register_by_name (regcache, "ccs", &ccs);
++ collect_register_by_name ("ccs", &ccs);
+ /* Set the S1 flag to enable watchpoints. */
+ ccs |= (1 << 19);
+- supply_register_by_name (regcache, "ccs", &ccs);
++ supply_register_by_name ("ccs", &ccs);
+
+ return 0;
+ }
+@@ -230,7 +225,6 @@ cris_remove_point (char type, CORE_ADDR
+ int bp;
+ unsigned long bp_ctrl;
+ unsigned long start, end;
+- struct regcache *regcache;
+
+ /* Breakpoint/watchpoint types:
+ 0 = memory breakpoint for instructions
+@@ -242,15 +236,13 @@ cris_remove_point (char type, CORE_ADDR
+ if (type < '2' || type > '4')
+ return -1;
+
+- regcache = get_thread_regcache (current_inferior, 1);
+-
+ /* Read watchpoints are set as access watchpoints, because of GDB's
+ inability to deal with pure read watchpoints. */
+ if (type == '3')
+ type = '4';
+
+ /* Get the configuration register. */
+- collect_register_by_name (regcache, "s0", &bp_ctrl);
++ collect_register_by_name ("s0", &bp_ctrl);
+
+ /* Try to find a watchpoint that is configured for the
+ specified range, then check that read/write also matches. */
+@@ -262,18 +254,18 @@ cris_remove_point (char type, CORE_ADDR
+ unsigned long bp_d_regs[12];
+
+ /* Get all range registers to simplify search. */
+- collect_register_by_name (regcache, "s3", &bp_d_regs[0]);
+- collect_register_by_name (regcache, "s4", &bp_d_regs[1]);
+- collect_register_by_name (regcache, "s5", &bp_d_regs[2]);
+- collect_register_by_name (regcache, "s6", &bp_d_regs[3]);
+- collect_register_by_name (regcache, "s7", &bp_d_regs[4]);
+- collect_register_by_name (regcache, "s8", &bp_d_regs[5]);
+- collect_register_by_name (regcache, "s9", &bp_d_regs[6]);
+- collect_register_by_name (regcache, "s10", &bp_d_regs[7]);
+- collect_register_by_name (regcache, "s11", &bp_d_regs[8]);
+- collect_register_by_name (regcache, "s12", &bp_d_regs[9]);
+- collect_register_by_name (regcache, "s13", &bp_d_regs[10]);
+- collect_register_by_name (regcache, "s14", &bp_d_regs[11]);
++ collect_register_by_name ("s3", &bp_d_regs[0]);
++ collect_register_by_name ("s4", &bp_d_regs[1]);
++ collect_register_by_name ("s5", &bp_d_regs[2]);
++ collect_register_by_name ("s6", &bp_d_regs[3]);
++ collect_register_by_name ("s7", &bp_d_regs[4]);
++ collect_register_by_name ("s8", &bp_d_regs[5]);
++ collect_register_by_name ("s9", &bp_d_regs[6]);
++ collect_register_by_name ("s10", &bp_d_regs[7]);
++ collect_register_by_name ("s11", &bp_d_regs[8]);
++ collect_register_by_name ("s12", &bp_d_regs[9]);
++ collect_register_by_name ("s13", &bp_d_regs[10]);
++ collect_register_by_name ("s14", &bp_d_regs[11]);
+
+ for (bp = 0; bp < 6; bp++)
+ {
+@@ -307,11 +299,11 @@ cris_remove_point (char type, CORE_ADDR
+ start/end addresses. */
+ bp_ctrl &= ~(3 << (2 + (bp * 4)));
+ /* Setup the configuration register. */
+- supply_register_by_name (regcache, "s0", &bp_ctrl);
++ supply_register_by_name ("s0", &bp_ctrl);
+
+ start = end = 0;
+ /* Configure the watchpoint register. */
+- cris_write_data_breakpoint (regcache, bp, start, end);
++ cris_write_data_breakpoint (bp, start, end);
+
+ /* Note that we don't clear the S1 flag here. It's done when continuing. */
+ return 0;
+--- ./gdb/gdbserver/linux-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -451,8 +451,7 @@ handle_extended_wait (struct lwp_info *e
+ static CORE_ADDR
+ get_stop_pc (void)
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+- CORE_ADDR stop_pc = (*the_low_target.get_pc) (regcache);
++ CORE_ADDR stop_pc = (*the_low_target.get_pc) ();
+
+ if (! get_thread_lwp (current_inferior)->stepping)
+ stop_pc -= the_low_target.decr_pc_after_break;
+@@ -885,7 +884,6 @@ check_removed_breakpoint (struct lwp_inf
+ {
+ CORE_ADDR stop_pc;
+ struct thread_info *saved_inferior;
+- struct regcache *regcache;
+
+ if (event_child->pending_is_breakpoint == 0)
+ return 0;
+@@ -896,7 +894,7 @@ check_removed_breakpoint (struct lwp_inf
+
+ saved_inferior = current_inferior;
+ current_inferior = get_lwp_thread (event_child);
+- regcache = get_thread_regcache (current_inferior, 1);
++
+ stop_pc = get_stop_pc ();
+
+ /* If the PC has changed since we stopped, then we shouldn't do
+@@ -932,7 +930,7 @@ check_removed_breakpoint (struct lwp_inf
+ {
+ if (debug_threads)
+ fprintf (stderr, "Set pc to 0x%lx\n", (long) stop_pc);
+- (*the_low_target.set_pc) (regcache, stop_pc);
++ (*the_low_target.set_pc) (stop_pc);
+ }
+
+ /* We consumed the pending SIGTRAP. */
+@@ -1065,12 +1063,11 @@ retry:
+ && the_low_target.get_pc != NULL)
+ {
+ struct thread_info *saved_inferior = current_inferior;
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ CORE_ADDR pc;
+
+ current_inferior = (struct thread_info *)
+ find_inferior_id (&all_threads, child->head.id);
+- pc = (*the_low_target.get_pc) (regcache);
++ pc = (*the_low_target.get_pc) ();
+ fprintf (stderr, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc);
+ current_inferior = saved_inferior;
+ }
+@@ -1835,8 +1832,7 @@ linux_resume_one_lwp (struct lwp_info *l
+
+ if (debug_threads && the_low_target.get_pc != NULL)
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+- CORE_ADDR pc = (*the_low_target.get_pc) (regcache);
++ CORE_ADDR pc = (*the_low_target.get_pc) ();
+ fprintf (stderr, " resuming from pc 0x%lx\n", (long) pc);
+ }
+
+@@ -2125,7 +2121,7 @@ register_addr (int regnum)
+
+ /* Fetch one register. */
+ static void
+-fetch_register (struct regcache *regcache, int regno)
++fetch_register (int regno)
+ {
+ CORE_ADDR regaddr;
+ int i, size;
+@@ -2164,29 +2160,29 @@ fetch_register (struct regcache *regcach
+ }
+
+ if (the_low_target.supply_ptrace_register)
+- the_low_target.supply_ptrace_register (regcache, regno, buf);
++ the_low_target.supply_ptrace_register (regno, buf);
+ else
+- supply_register (regcache, regno, buf);
++ supply_register (regno, buf);
+
+ error_exit:;
+ }
+
+ /* Fetch all registers, or just one, from the child process. */
+ static void
+-usr_fetch_inferior_registers (struct regcache *regcache, int regno)
++usr_fetch_inferior_registers (int regno)
+ {
+ if (regno == -1)
+ for (regno = 0; regno < the_low_target.num_regs; regno++)
+- fetch_register (regcache, regno);
++ fetch_register (regno);
+ else
+- fetch_register (regcache, regno);
++ fetch_register (regno);
+ }
+
+ /* Store our register values back into the inferior.
+ If REGNO is -1, do this for all registers.
+ Otherwise, REGNO specifies which register (so we can save time). */
+ static void
+-usr_store_inferior_registers (struct regcache *regcache, int regno)
++usr_store_inferior_registers (int regno)
+ {
+ CORE_ADDR regaddr;
+ int i, size;
+@@ -2211,9 +2207,9 @@ usr_store_inferior_registers (struct reg
+ memset (buf, 0, size);
+
+ if (the_low_target.collect_ptrace_register)
+- the_low_target.collect_ptrace_register (regcache, regno, buf);
++ the_low_target.collect_ptrace_register (regno, buf);
+ else
+- collect_register (regcache, regno, buf);
++ collect_register (regno, buf);
+
+ pid = lwpid_of (get_thread_lwp (current_inferior));
+ for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
+@@ -2245,7 +2241,7 @@ usr_store_inferior_registers (struct reg
+ }
+ else
+ for (regno = 0; regno < the_low_target.num_regs; regno++)
+- usr_store_inferior_registers (regcache, regno);
++ usr_store_inferior_registers (regno);
+ }
+ #endif /* HAVE_LINUX_USRREGS */
+
+@@ -2254,7 +2250,7 @@ usr_store_inferior_registers (struct reg
+ #ifdef HAVE_LINUX_REGSETS
+
+ static int
+-regsets_fetch_inferior_registers (struct regcache *regcache)
++regsets_fetch_inferior_registers ()
+ {
+ struct regset_info *regset;
+ int saw_general_regs = 0;
+@@ -2300,7 +2296,7 @@ regsets_fetch_inferior_registers (struct
+ }
+ else if (regset->type == GENERAL_REGS)
+ saw_general_regs = 1;
+- regset->store_function (regcache, buf);
++ regset->store_function (buf);
+ regset ++;
+ free (buf);
+ }
+@@ -2311,7 +2307,7 @@ regsets_fetch_inferior_registers (struct
+ }
+
+ static int
+-regsets_store_inferior_registers (struct regcache *regcache)
++regsets_store_inferior_registers ()
+ {
+ struct regset_info *regset;
+ int saw_general_regs = 0;
+@@ -2345,7 +2341,7 @@ regsets_store_inferior_registers (struct
+ if (res == 0)
+ {
+ /* Then overlay our cached registers on that. */
+- regset->fill_function (regcache, buf);
++ regset->fill_function (buf);
+
+ /* Only now do we write the register set. */
+ #ifndef __sparc__
+@@ -2395,26 +2391,26 @@ regsets_store_inferior_registers (struct
+
+
+ void
+-linux_fetch_registers (struct regcache *regcache, int regno)
++linux_fetch_registers (int regno)
+ {
+ #ifdef HAVE_LINUX_REGSETS
+- if (regsets_fetch_inferior_registers (regcache) == 0)
++ if (regsets_fetch_inferior_registers () == 0)
+ return;
+ #endif
+ #ifdef HAVE_LINUX_USRREGS
+- usr_fetch_inferior_registers (regcache, regno);
++ usr_fetch_inferior_registers (regno);
+ #endif
+ }
+
+ void
+-linux_store_registers (struct regcache *regcache, int regno)
++linux_store_registers (int regno)
+ {
+ #ifdef HAVE_LINUX_REGSETS
+- if (regsets_store_inferior_registers (regcache) == 0)
++ if (regsets_store_inferior_registers () == 0)
+ return;
+ #endif
+ #ifdef HAVE_LINUX_USRREGS
+- usr_store_inferior_registers (regcache, regno);
++ usr_store_inferior_registers (regno);
+ #endif
+ }
+
+--- ./gdb/gdbserver/linux-low.h 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-low.h 2010-01-21 20:33:15.000000000 +0100
+@@ -24,8 +24,8 @@
+ #include "gdb_proc_service.h"
+
+ #ifdef HAVE_LINUX_REGSETS
+-typedef void (*regset_fill_func) (struct regcache *, void *);
+-typedef void (*regset_store_func) (struct regcache *, const void *);
++typedef void (*regset_fill_func) (void *);
++typedef void (*regset_store_func) (const void *);
+ enum regset_type {
+ GENERAL_REGS,
+ FP_REGS,
+@@ -70,8 +70,8 @@ struct linux_target_ops
+ store the register, and 2 if failure to store the register
+ is acceptable. */
+ int (*cannot_store_register) (int);
+- CORE_ADDR (*get_pc) (struct regcache *regcache);
+- void (*set_pc) (struct regcache *regcache, CORE_ADDR newpc);
++ CORE_ADDR (*get_pc) (void);
++ void (*set_pc) (CORE_ADDR newpc);
+ const unsigned char *breakpoint;
+ int breakpoint_len;
+ CORE_ADDR (*breakpoint_reinsert_addr) (void);
+@@ -88,10 +88,8 @@ struct linux_target_ops
+
+ /* Hooks to reformat register data for PEEKUSR/POKEUSR (in particular
+ for registers smaller than an xfer unit). */
+- void (*collect_ptrace_register) (struct regcache *regcache,
+- int regno, char *buf);
+- void (*supply_ptrace_register) (struct regcache *regcache,
+- int regno, const char *buf);
++ void (*collect_ptrace_register) (int regno, char *buf);
++ void (*supply_ptrace_register) (int regno, const char *buf);
+
+ /* Hook to convert from target format to ptrace format and back.
+ Returns true if any conversion was done; false otherwise.
+--- ./gdb/gdbserver/linux-m32r-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-m32r-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -53,20 +53,18 @@ m32r_cannot_fetch_register (int regno)
+ }
+
+ static CORE_ADDR
+-m32r_get_pc (struct regcache *regcache)
++m32r_get_pc ()
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
+- if (debug_threads)
+- fprintf (stderr, "stop pc is %08lx\n", pc);
++ collect_register_by_name ("pc", &pc);
+ return pc;
+ }
+
+ static void
+-m32r_set_pc (struct regcache *regcache, CORE_ADDR pc)
++m32r_set_pc (CORE_ADDR pc)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ static const unsigned short m32r_breakpoint = 0x10f1;
+--- ./gdb/gdbserver/linux-m68k-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-m68k-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -71,40 +71,40 @@ m68k_cannot_fetch_register (int regno)
+ #include <sys/ptrace.h>
+
+ static void
+-m68k_fill_gregset (struct regcache *regcache, void *buf)
++m68k_fill_gregset (void *buf)
+ {
+ int i;
+
+ for (i = 0; i < m68k_num_gregs; i++)
+- collect_register (regcache, i, (char *) buf + m68k_regmap[i]);
++ collect_register (i, (char *) buf + m68k_regmap[i]);
+ }
+
+ static void
+-m68k_store_gregset (struct regcache *regcache, const void *buf)
++m68k_store_gregset (const void *buf)
+ {
+ int i;
+
+ for (i = 0; i < m68k_num_gregs; i++)
+- supply_register (regcache, i, (const char *) buf + m68k_regmap[i]);
++ supply_register (i, (const char *) buf + m68k_regmap[i]);
+ }
+
+ static void
+-m68k_fill_fpregset (struct regcache *regcache, void *buf)
++m68k_fill_fpregset (void *buf)
+ {
+ int i;
+
+ for (i = m68k_num_gregs; i < m68k_num_regs; i++)
+- collect_register (regcache, i, ((char *) buf
+- + (m68k_regmap[i] - m68k_regmap[m68k_num_gregs])));
++ collect_register (i, ((char *) buf
++ + (m68k_regmap[i] - m68k_regmap[m68k_num_gregs])));
+ }
+
+ static void
+-m68k_store_fpregset (struct regcache *regcache, const void *buf)
++m68k_store_fpregset (const void *buf)
+ {
+ int i;
+
+ for (i = m68k_num_gregs; i < m68k_num_regs; i++)
+- supply_register (regcache, i, ((const char *) buf
++ supply_register (i, ((const char *) buf
+ + (m68k_regmap[i] - m68k_regmap[m68k_num_gregs])));
+ }
+
+@@ -126,20 +126,20 @@ static const unsigned char m68k_breakpoi
+ #define m68k_breakpoint_len 2
+
+ static CORE_ADDR
+-m68k_get_pc (struct regcache *regcache)
++m68k_get_pc ()
+ {
+ unsigned long pc;
+
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ return pc;
+ }
+
+ static void
+-m68k_set_pc (struct regcache *regcache, CORE_ADDR value)
++m68k_set_pc (CORE_ADDR value)
+ {
+ unsigned long newpc = value;
+
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ static int
+--- ./gdb/gdbserver/linux-mips-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-mips-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -115,15 +115,15 @@ mips_cannot_store_register (int regno)
+ }
+
+ static CORE_ADDR
+-mips_get_pc (struct regcache *regcache)
++mips_get_pc ()
+ {
+ union mips_register pc;
+- collect_register_by_name (regcache, "pc", pc.buf);
++ collect_register_by_name ("pc", pc.buf);
+ return register_size (0) == 4 ? pc.reg32 : pc.reg64;
+ }
+
+ static void
+-mips_set_pc (struct regcache *regcache, CORE_ADDR pc)
++mips_set_pc (CORE_ADDR pc)
+ {
+ union mips_register newpc;
+ if (register_size (0) == 4)
+@@ -131,7 +131,7 @@ mips_set_pc (struct regcache *regcache,
+ else
+ newpc.reg64 = pc;
+
+- supply_register_by_name (regcache, "pc", newpc.buf);
++ supply_register_by_name ("pc", newpc.buf);
+ }
+
+ /* Correct in either endianness. */
+@@ -142,11 +142,10 @@ static const unsigned int mips_breakpoin
+ is outside of the function. So rather than importing software single-step,
+ we can just run until exit. */
+ static CORE_ADDR
+-mips_reinsert_addr (void)
++mips_reinsert_addr ()
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ union mips_register ra;
+- collect_register_by_name (regcache, "r31", ra.buf);
++ collect_register_by_name ("r31", ra.buf);
+ return register_size (0) == 4 ? ra.reg32 : ra.reg64;
+ }
+
+@@ -184,26 +183,24 @@ ps_get_thread_area (const struct ps_proc
+ #ifdef HAVE_PTRACE_GETREGS
+
+ static void
+-mips_collect_register (struct regcache *regcache,
+- int use_64bit, int regno, union mips_register *reg)
++mips_collect_register (int use_64bit, int regno, union mips_register *reg)
+ {
+ union mips_register tmp_reg;
+
+ if (use_64bit)
+ {
+- collect_register (regcache, regno, &tmp_reg.reg64);
++ collect_register (regno, &tmp_reg.reg64);
+ *reg = tmp_reg;
+ }
+ else
+ {
+- collect_register (regcache, regno, &tmp_reg.reg32);
++ collect_register (regno, &tmp_reg.reg32);
+ reg->reg64 = tmp_reg.reg32;
+ }
+ }
+
+ static void
+-mips_supply_register (struct regcache *regcache,
+- int use_64bit, int regno, const union mips_register *reg)
++mips_supply_register (int use_64bit, int regno, const union mips_register *reg)
+ {
+ int offset = 0;
+
+@@ -212,35 +209,33 @@ mips_supply_register (struct regcache *r
+ if (__BYTE_ORDER == __BIG_ENDIAN && !use_64bit)
+ offset = 4;
+
+- supply_register (regcache, regno, reg->buf + offset);
++ supply_register (regno, reg->buf + offset);
+ }
+
+ static void
+-mips_collect_register_32bit (struct regcache *regcache,
+- int use_64bit, int regno, unsigned char *buf)
++mips_collect_register_32bit (int use_64bit, int regno, unsigned char *buf)
+ {
+ union mips_register tmp_reg;
+ int reg32;
+
+- mips_collect_register (regcache, use_64bit, regno, &tmp_reg);
++ mips_collect_register (use_64bit, regno, &tmp_reg);
+ reg32 = tmp_reg.reg64;
+ memcpy (buf, ®32, 4);
+ }
+
+ static void
+-mips_supply_register_32bit (struct regcache *regcache,
+- int use_64bit, int regno, const unsigned char *buf)
++mips_supply_register_32bit (int use_64bit, int regno, const unsigned char *buf)
+ {
+ union mips_register tmp_reg;
+ int reg32;
+
+ memcpy (®32, buf, 4);
+ tmp_reg.reg64 = reg32;
+- mips_supply_register (regcache, use_64bit, regno, &tmp_reg);
++ mips_supply_register (use_64bit, regno, &tmp_reg);
+ }
+
+ static void
+-mips_fill_gregset (struct regcache *regcache, void *buf)
++mips_fill_gregset (void *buf)
+ {
+ union mips_register *regset = buf;
+ int i, use_64bit;
+@@ -248,27 +243,20 @@ mips_fill_gregset (struct regcache *regc
+ use_64bit = (register_size (0) == 8);
+
+ for (i = 1; i < 32; i++)
+- mips_collect_register (regcache, use_64bit, i, regset + i);
++ mips_collect_register (use_64bit, i, regset + i);
+
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("lo"), regset + 32);
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("hi"), regset + 33);
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("pc"), regset + 34);
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("badvaddr"), regset + 35);
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("status"), regset + 36);
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("cause"), regset + 37);
++ mips_collect_register (use_64bit, find_regno ("lo"), regset + 32);
++ mips_collect_register (use_64bit, find_regno ("hi"), regset + 33);
++ mips_collect_register (use_64bit, find_regno ("pc"), regset + 34);
++ mips_collect_register (use_64bit, find_regno ("badvaddr"), regset + 35);
++ mips_collect_register (use_64bit, find_regno ("status"), regset + 36);
++ mips_collect_register (use_64bit, find_regno ("cause"), regset + 37);
+
+- mips_collect_register (regcache, use_64bit,
+- find_regno ("restart"), regset + 0);
++ mips_collect_register (use_64bit, find_regno ("restart"), regset + 0);
+ }
+
+ static void
+-mips_store_gregset (struct regcache *regcache, const void *buf)
++mips_store_gregset (const void *buf)
+ {
+ const union mips_register *regset = buf;
+ int i, use_64bit;
+@@ -276,24 +264,20 @@ mips_store_gregset (struct regcache *reg
+ use_64bit = (register_size (0) == 8);
+
+ for (i = 0; i < 32; i++)
+- mips_supply_register (regcache, use_64bit, i, regset + i);
++ mips_supply_register (use_64bit, i, regset + i);
+
+- mips_supply_register (regcache, use_64bit, find_regno ("lo"), regset + 32);
+- mips_supply_register (regcache, use_64bit, find_regno ("hi"), regset + 33);
+- mips_supply_register (regcache, use_64bit, find_regno ("pc"), regset + 34);
+- mips_supply_register (regcache, use_64bit,
+- find_regno ("badvaddr"), regset + 35);
+- mips_supply_register (regcache, use_64bit,
+- find_regno ("status"), regset + 36);
+- mips_supply_register (regcache, use_64bit,
+- find_regno ("cause"), regset + 37);
++ mips_supply_register (use_64bit, find_regno ("lo"), regset + 32);
++ mips_supply_register (use_64bit, find_regno ("hi"), regset + 33);
++ mips_supply_register (use_64bit, find_regno ("pc"), regset + 34);
++ mips_supply_register (use_64bit, find_regno ("badvaddr"), regset + 35);
++ mips_supply_register (use_64bit, find_regno ("status"), regset + 36);
++ mips_supply_register (use_64bit, find_regno ("cause"), regset + 37);
+
+- mips_supply_register (regcache, use_64bit,
+- find_regno ("restart"), regset + 0);
++ mips_supply_register (use_64bit, find_regno ("restart"), regset + 0);
+ }
+
+ static void
+-mips_fill_fpregset (struct regcache *regcache, void *buf)
++mips_fill_fpregset (void *buf)
+ {
+ union mips_register *regset = buf;
+ int i, use_64bit, first_fp, big_endian;
+@@ -305,19 +289,18 @@ mips_fill_fpregset (struct regcache *reg
+ /* See GDB for a discussion of this peculiar layout. */
+ for (i = 0; i < 32; i++)
+ if (use_64bit)
+- collect_register (regcache, first_fp + i, regset[i].buf);
++ collect_register (first_fp + i, regset[i].buf);
+ else
+- collect_register (regcache, first_fp + i,
++ collect_register (first_fp + i,
+ regset[i & ~1].buf + 4 * (big_endian != (i & 1)));
+
+- mips_collect_register_32bit (regcache, use_64bit,
+- find_regno ("fcsr"), regset[32].buf);
+- mips_collect_register_32bit (regcache, use_64bit, find_regno ("fir"),
++ mips_collect_register_32bit (use_64bit, find_regno ("fcsr"), regset[32].buf);
++ mips_collect_register_32bit (use_64bit, find_regno ("fir"),
+ regset[32].buf + 4);
+ }
+
+ static void
+-mips_store_fpregset (struct regcache *regcache, const void *buf)
++mips_store_fpregset (const void *buf)
+ {
+ const union mips_register *regset = buf;
+ int i, use_64bit, first_fp, big_endian;
+@@ -329,14 +312,13 @@ mips_store_fpregset (struct regcache *re
+ /* See GDB for a discussion of this peculiar layout. */
+ for (i = 0; i < 32; i++)
+ if (use_64bit)
+- supply_register (regcache, first_fp + i, regset[i].buf);
++ supply_register (first_fp + i, regset[i].buf);
+ else
+- supply_register (regcache, first_fp + i,
++ supply_register (first_fp + i,
+ regset[i & ~1].buf + 4 * (big_endian != (i & 1)));
+
+- mips_supply_register_32bit (regcache, use_64bit,
+- find_regno ("fcsr"), regset[32].buf);
+- mips_supply_register_32bit (regcache, use_64bit, find_regno ("fir"),
++ mips_supply_register_32bit (use_64bit, find_regno ("fcsr"), regset[32].buf);
++ mips_supply_register_32bit (use_64bit, find_regno ("fir"),
+ regset[32].buf + 4);
+ }
+ #endif /* HAVE_PTRACE_GETREGS */
+--- ./gdb/gdbserver/linux-ppc-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-ppc-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -169,27 +169,26 @@ ppc_cannot_fetch_register (int regno)
+ }
+
+ static void
+-ppc_collect_ptrace_register (struct regcache *regcache, int regno, char *buf)
++ppc_collect_ptrace_register (int regno, char *buf)
+ {
+ int size = register_size (regno);
+
+ memset (buf, 0, sizeof (long));
+
+ if (size < sizeof (long))
+- collect_register (regcache, regno, buf + sizeof (long) - size);
++ collect_register (regno, buf + sizeof (long) - size);
+ else
+- collect_register (regcache, regno, buf);
++ collect_register (regno, buf);
+ }
+
+ static void
+-ppc_supply_ptrace_register (struct regcache *regcache,
+- int regno, const char *buf)
++ppc_supply_ptrace_register (int regno, const char *buf)
+ {
+ int size = register_size (regno);
+ if (size < sizeof (long))
+- supply_register (regcache, regno, buf + sizeof (long) - size);
++ supply_register (regno, buf + sizeof (long) - size);
+ else
+- supply_register (regcache, regno, buf);
++ supply_register (regno, buf);
+ }
+
+
+@@ -200,7 +199,7 @@ ppc_supply_ptrace_register (struct regca
+ return to FD and ADDR the file handle and NPC parameter address
+ used with the system call. Return non-zero if successful. */
+ static int
+-parse_spufs_run (struct regcache *regcache, int *fd, CORE_ADDR *addr)
++parse_spufs_run (int *fd, CORE_ADDR *addr)
+ {
+ CORE_ADDR curr_pc;
+ int curr_insn;
+@@ -209,10 +208,10 @@ parse_spufs_run (struct regcache *regcac
+ if (register_size (0) == 4)
+ {
+ unsigned int pc, r0, r3, r4;
+- collect_register_by_name (regcache, "pc", &pc);
+- collect_register_by_name (regcache, "r0", &r0);
+- collect_register_by_name (regcache, "orig_r3", &r3);
+- collect_register_by_name (regcache, "r4", &r4);
++ collect_register_by_name ("pc", &pc);
++ collect_register_by_name ("r0", &r0);
++ collect_register_by_name ("orig_r3", &r3);
++ collect_register_by_name ("r4", &r4);
+ curr_pc = (CORE_ADDR) pc;
+ curr_r0 = (int) r0;
+ *fd = (int) r3;
+@@ -221,10 +220,10 @@ parse_spufs_run (struct regcache *regcac
+ else
+ {
+ unsigned long pc, r0, r3, r4;
+- collect_register_by_name (regcache, "pc", &pc);
+- collect_register_by_name (regcache, "r0", &r0);
+- collect_register_by_name (regcache, "orig_r3", &r3);
+- collect_register_by_name (regcache, "r4", &r4);
++ collect_register_by_name ("pc", &pc);
++ collect_register_by_name ("r0", &r0);
++ collect_register_by_name ("orig_r3", &r3);
++ collect_register_by_name ("r4", &r4);
+ curr_pc = (CORE_ADDR) pc;
+ curr_r0 = (int) r0;
+ *fd = (int) r3;
+@@ -246,12 +245,12 @@ parse_spufs_run (struct regcache *regcac
+ }
+
+ static CORE_ADDR
+-ppc_get_pc (struct regcache *regcache)
++ppc_get_pc (void)
+ {
+ CORE_ADDR addr;
+ int fd;
+
+- if (parse_spufs_run (regcache, &fd, &addr))
++ if (parse_spufs_run (&fd, &addr))
+ {
+ unsigned int pc;
+ (*the_target->read_memory) (addr, (unsigned char *) &pc, 4);
+@@ -260,24 +259,24 @@ ppc_get_pc (struct regcache *regcache)
+ else if (register_size (0) == 4)
+ {
+ unsigned int pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ return (CORE_ADDR) pc;
+ }
+ else
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ return (CORE_ADDR) pc;
+ }
+ }
+
+ static void
+-ppc_set_pc (struct regcache *regcache, CORE_ADDR pc)
++ppc_set_pc (CORE_ADDR pc)
+ {
+ CORE_ADDR addr;
+ int fd;
+
+- if (parse_spufs_run (regcache, &fd, &addr))
++ if (parse_spufs_run (&fd, &addr))
+ {
+ unsigned int newpc = pc;
+ (*the_target->write_memory) (addr, (unsigned char *) &newpc, 4);
+@@ -285,12 +284,12 @@ ppc_set_pc (struct regcache *regcache, C
+ else if (register_size (0) == 4)
+ {
+ unsigned int newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+ else
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+ }
+
+@@ -450,18 +449,18 @@ ppc_breakpoint_at (CORE_ADDR where)
+ /* Provide only a fill function for the general register set. ps_lgetregs
+ will use this for NPTL support. */
+
+-static void ppc_fill_gregset (struct regcache *regcache, void *buf)
++static void ppc_fill_gregset (void *buf)
+ {
+ int i;
+
+ for (i = 0; i < 32; i++)
+- ppc_collect_ptrace_register (regcache, i, (char *) buf + ppc_regmap[i]);
++ ppc_collect_ptrace_register (i, (char *) buf + ppc_regmap[i]);
+
+ for (i = 64; i < 70; i++)
+- ppc_collect_ptrace_register (regcache, i, (char *) buf + ppc_regmap[i]);
++ ppc_collect_ptrace_register (i, (char *) buf + ppc_regmap[i]);
+
+ for (i = 71; i < 73; i++)
+- ppc_collect_ptrace_register (regcache, i, (char *) buf + ppc_regmap[i]);
++ ppc_collect_ptrace_register (i, (char *) buf + ppc_regmap[i]);
+ }
+
+ #ifndef PTRACE_GETVSXREGS
+@@ -472,7 +471,7 @@ static void ppc_fill_gregset (struct reg
+ #define SIZEOF_VSXREGS 32*8
+
+ static void
+-ppc_fill_vsxregset (struct regcache *regcache, void *buf)
++ppc_fill_vsxregset (void *buf)
+ {
+ int i, base;
+ char *regset = buf;
+@@ -482,11 +481,11 @@ ppc_fill_vsxregset (struct regcache *reg
+
+ base = find_regno ("vs0h");
+ for (i = 0; i < 32; i++)
+- collect_register (regcache, base + i, ®set[i * 8]);
++ collect_register (base + i, ®set[i * 8]);
+ }
+
+ static void
+-ppc_store_vsxregset (struct regcache *regcache, const void *buf)
++ppc_store_vsxregset (const void *buf)
+ {
+ int i, base;
+ const char *regset = buf;
+@@ -496,7 +495,7 @@ ppc_store_vsxregset (struct regcache *re
+
+ base = find_regno ("vs0h");
+ for (i = 0; i < 32; i++)
+- supply_register (regcache, base + i, ®set[i * 8]);
++ supply_register (base + i, ®set[i * 8]);
+ }
+
+ #ifndef PTRACE_GETVRREGS
+@@ -507,7 +506,7 @@ ppc_store_vsxregset (struct regcache *re
+ #define SIZEOF_VRREGS 33*16+4
+
+ static void
+-ppc_fill_vrregset (struct regcache *regcache, void *buf)
++ppc_fill_vrregset (void *buf)
+ {
+ int i, base;
+ char *regset = buf;
+@@ -517,14 +516,14 @@ ppc_fill_vrregset (struct regcache *regc
+
+ base = find_regno ("vr0");
+ for (i = 0; i < 32; i++)
+- collect_register (regcache, base + i, ®set[i * 16]);
++ collect_register (base + i, ®set[i * 16]);
+
+- collect_register_by_name (regcache, "vscr", ®set[32 * 16 + 12]);
+- collect_register_by_name (regcache, "vrsave", ®set[33 * 16]);
++ collect_register_by_name ("vscr", ®set[32 * 16 + 12]);
++ collect_register_by_name ("vrsave", ®set[33 * 16]);
+ }
+
+ static void
+-ppc_store_vrregset (struct regcache *regcache, const void *buf)
++ppc_store_vrregset (const void *buf)
+ {
+ int i, base;
+ const char *regset = buf;
+@@ -534,10 +533,10 @@ ppc_store_vrregset (struct regcache *reg
+
+ base = find_regno ("vr0");
+ for (i = 0; i < 32; i++)
+- supply_register (regcache, base + i, ®set[i * 16]);
++ supply_register (base + i, ®set[i * 16]);
+
+- supply_register_by_name (regcache, "vscr", ®set[32 * 16 + 12]);
+- supply_register_by_name (regcache, "vrsave", ®set[33 * 16]);
++ supply_register_by_name ("vscr", ®set[32 * 16 + 12]);
++ supply_register_by_name ("vrsave", ®set[33 * 16]);
+ }
+
+ #ifndef PTRACE_GETEVRREGS
+@@ -553,7 +552,7 @@ struct gdb_evrregset_t
+ };
+
+ static void
+-ppc_fill_evrregset (struct regcache *regcache, void *buf)
++ppc_fill_evrregset (void *buf)
+ {
+ int i, ev0;
+ struct gdb_evrregset_t *regset = buf;
+@@ -563,14 +562,14 @@ ppc_fill_evrregset (struct regcache *reg
+
+ ev0 = find_regno ("ev0h");
+ for (i = 0; i < 32; i++)
+- collect_register (regcache, ev0 + i, ®set->evr[i]);
++ collect_register (ev0 + i, ®set->evr[i]);
+
+- collect_register_by_name (regcache, "acc", ®set->acc);
+- collect_register_by_name (regcache, "spefscr", ®set->spefscr);
++ collect_register_by_name ("acc", ®set->acc);
++ collect_register_by_name ("spefscr", ®set->spefscr);
+ }
+
+ static void
+-ppc_store_evrregset (struct regcache *regcache, const void *buf)
++ppc_store_evrregset (const void *buf)
+ {
+ int i, ev0;
+ const struct gdb_evrregset_t *regset = buf;
+@@ -580,10 +579,10 @@ ppc_store_evrregset (struct regcache *re
+
+ ev0 = find_regno ("ev0h");
+ for (i = 0; i < 32; i++)
+- supply_register (regcache, ev0 + i, ®set->evr[i]);
++ supply_register (ev0 + i, ®set->evr[i]);
+
+- supply_register_by_name (regcache, "acc", ®set->acc);
+- supply_register_by_name (regcache, "spefscr", ®set->spefscr);
++ supply_register_by_name ("acc", ®set->acc);
++ supply_register_by_name ("spefscr", ®set->spefscr);
+ }
+
+ struct regset_info target_regsets[] = {
+--- ./gdb/gdbserver/linux-s390-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-s390-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -106,7 +106,7 @@ s390_cannot_store_register (int regno)
+ }
+
+ static void
+-s390_collect_ptrace_register (struct regcache *regcache, int regno, char *buf)
++s390_collect_ptrace_register (int regno, char *buf)
+ {
+ int size = register_size (regno);
+ if (size < sizeof (long))
+@@ -123,9 +123,9 @@ s390_collect_ptrace_register (struct reg
+ }
+ else if (regaddr == PT_PSWADDR
+ || (regaddr >= PT_GPR0 && regaddr <= PT_GPR15))
+- collect_register (regcache, regno, buf + sizeof (long) - size);
++ collect_register (regno, buf + sizeof (long) - size);
+ else
+- collect_register (regcache, regno, buf);
++ collect_register (regno, buf);
+
+ /* When debugging a 32-bit inferior on a 64-bit host, make sure
+ the 31-bit addressing mode bit is set in the PSW mask. */
+@@ -137,7 +137,7 @@ s390_collect_ptrace_register (struct reg
+ }
+
+ static void
+-s390_supply_ptrace_register (struct regcache *regcache, int regno, const char *buf)
++s390_supply_ptrace_register (int regno, const char *buf)
+ {
+ int size = register_size (regno);
+ if (size < sizeof (long))
+@@ -152,18 +152,18 @@ s390_supply_ptrace_register (struct regc
+ }
+ else if (regaddr == PT_PSWADDR
+ || (regaddr >= PT_GPR0 && regaddr <= PT_GPR15))
+- supply_register (regcache, regno, buf + sizeof (long) - size);
++ supply_register (regno, buf + sizeof (long) - size);
+ else
+- supply_register (regcache, regno, buf);
++ supply_register (regno, buf);
+ }
+ else
+- supply_register (regcache, regno, buf);
++ supply_register (regno, buf);
+ }
+
+ /* Provide only a fill function for the general register set. ps_lgetregs
+ will use this for NPTL support. */
+
+-static void s390_fill_gregset (struct regcache *regcache, void *buf)
++static void s390_fill_gregset (void *buf)
+ {
+ int i;
+
+@@ -173,7 +173,7 @@ static void s390_fill_gregset (struct re
+ || the_low_target.regmap[i] > PT_ACR15)
+ continue;
+
+- s390_collect_ptrace_register (regcache, i, (char *) buf
++ s390_collect_ptrace_register (i, (char *) buf
+ + the_low_target.regmap[i]);
+ }
+ }
+@@ -188,12 +188,12 @@ static const unsigned char s390_breakpoi
+ #define s390_breakpoint_len 2
+
+ static CORE_ADDR
+-s390_get_pc (struct regcache *regcache)
++s390_get_pc ()
+ {
+ if (register_size (0) == 4)
+ {
+ unsigned int pc;
+- collect_register_by_name (regcache, "pswa", &pc);
++ collect_register_by_name ("pswa", &pc);
+ #ifndef __s390x__
+ pc &= 0x7fffffff;
+ #endif
+@@ -202,13 +202,13 @@ s390_get_pc (struct regcache *regcache)
+ else
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pswa", &pc);
++ collect_register_by_name ("pswa", &pc);
+ return pc;
+ }
+ }
+
+ static void
+-s390_set_pc (struct regcache *regcache, CORE_ADDR newpc)
++s390_set_pc (CORE_ADDR newpc)
+ {
+ if (register_size (0) == 4)
+ {
+@@ -216,12 +216,12 @@ s390_set_pc (struct regcache *regcache,
+ #ifndef __s390x__
+ pc |= 0x80000000;
+ #endif
+- supply_register_by_name (regcache, "pswa", &pc);
++ supply_register_by_name ("pswa", &pc);
+ }
+ else
+ {
+ unsigned long pc = newpc;
+- supply_register_by_name (regcache, "pswa", &pc);
++ supply_register_by_name ("pswa", &pc);
+ }
+ }
+
+@@ -268,8 +268,7 @@ s390_arch_setup (void)
+ #ifdef __s390x__
+ {
+ unsigned int pswm;
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+- collect_register_by_name (regcache, "pswm", &pswm);
++ collect_register_by_name ("pswm", &pswm);
+ if (pswm & 1)
+ init_registers_s390x_linux64 ();
+
+--- ./gdb/gdbserver/linux-sh-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-sh-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -59,18 +59,18 @@ sh_cannot_fetch_register (int regno)
+ }
+
+ static CORE_ADDR
+-sh_get_pc (struct regcache *regcache)
++sh_get_pc ()
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ return pc;
+ }
+
+ static void
+-sh_set_pc (struct regcache *regcache, CORE_ADDR pc)
++sh_set_pc (CORE_ADDR pc)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ /* Correct in either endianness, obviously. */
+@@ -94,13 +94,13 @@ sh_breakpoint_at (CORE_ADDR where)
+ /* Provide only a fill function for the general register set. ps_lgetregs
+ will use this for NPTL support. */
+
+-static void sh_fill_gregset (struct regcache *regcache, void *buf)
++static void sh_fill_gregset (void *buf)
+ {
+ int i;
+
+ for (i = 0; i < 23; i++)
+ if (sh_regmap[i] != -1)
+- collect_register (regcache, i, (char *) buf + sh_regmap[i]);
++ collect_register (i, (char *) buf + sh_regmap[i]);
+ }
+
+ struct regset_info target_regsets[] = {
+--- ./gdb/gdbserver/linux-sparc-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-sparc-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -113,7 +113,7 @@ sparc_cannot_fetch_register (int regno)
+ }
+
+ static void
+-sparc_fill_gregset_to_stack (struct regcache *regcache, const void *buf)
++sparc_fill_gregset_to_stack (const void *buf)
+ {
+ int i;
+ CORE_ADDR addr = 0;
+@@ -128,14 +128,14 @@ sparc_fill_gregset_to_stack (struct regc
+
+ for (i = l0_regno; i <= i7_regno; i++)
+ {
+- collect_register (regcache, i, tmp_reg_buf);
++ collect_register (i, tmp_reg_buf);
+ (*the_target->write_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
+ addr += sizeof(tmp_reg_buf);
+ }
+ }
+
+ static void
+-sparc_fill_gregset (struct regcache *regcache, void *buf)
++sparc_fill_gregset (void *buf)
+ {
+ int i;
+ int range;
+@@ -143,25 +143,25 @@ sparc_fill_gregset (struct regcache *reg
+ for (range = 0; range < N_GREGS_RANGES; range++)
+ for (i = gregs_ranges[range].regno_start; i <= gregs_ranges[range].regno_end; i++)
+ if (sparc_regmap[i] != -1)
+- collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
++ collect_register (i, ((char *) buf) + sparc_regmap[i]);
+
+- sparc_fill_gregset_to_stack (regcache, buf);
++ sparc_fill_gregset_to_stack (buf);
+ }
+
+ static void
+-sparc_fill_fpregset (struct regcache *regcache, void *buf)
++sparc_fill_fpregset (void *buf)
+ {
+ int i;
+ int range;
+
+ for (range = 0; range < N_FPREGS_RANGES; range++)
+ for (i = fpregs_ranges[range].regno_start; i <= fpregs_ranges[range].regno_end; i++)
+- collect_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
++ collect_register (i, ((char *) buf) + sparc_regmap[i]);
+
+ }
+
+ static void
+-sparc_store_gregset_from_stack (struct regcache *regcache, const void *buf)
++sparc_store_gregset_from_stack (const void *buf)
+ {
+ int i;
+ CORE_ADDR addr = 0;
+@@ -177,13 +177,13 @@ sparc_store_gregset_from_stack (struct r
+ for (i = l0_regno; i <= i7_regno; i++)
+ {
+ (*the_target->read_memory) (addr, tmp_reg_buf, sizeof(tmp_reg_buf));
+- supply_register (regcache, i, tmp_reg_buf);
++ supply_register (i, tmp_reg_buf);
+ addr += sizeof(tmp_reg_buf);
+ }
+ }
+
+ static void
+-sparc_store_gregset (struct regcache *regcache, const void *buf)
++sparc_store_gregset (const void *buf)
+ {
+ int i;
+ char zerobuf[8];
+@@ -194,33 +194,31 @@ sparc_store_gregset (struct regcache *re
+ for (range = 0; range < N_GREGS_RANGES; range++)
+ for (i = gregs_ranges[range].regno_start; i <= gregs_ranges[range].regno_end; i++)
+ if (sparc_regmap[i] != -1)
+- supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
++ supply_register (i, ((char *) buf) + sparc_regmap[i]);
+ else
+- supply_register (regcache, i, zerobuf);
++ supply_register (i, zerobuf);
+
+- sparc_store_gregset_from_stack (regcache, buf);
++ sparc_store_gregset_from_stack (buf);
+ }
+
+ static void
+-sparc_store_fpregset (struct regcache *regcache, const void *buf)
++sparc_store_fpregset (const void *buf)
+ {
+ int i;
+ int range;
+
+ for (range = 0; range < N_FPREGS_RANGES; range++)
+- for (i = fpregs_ranges[range].regno_start;
+- i <= fpregs_ranges[range].regno_end;
+- i++)
+- supply_register (regcache, i, ((char *) buf) + sparc_regmap[i]);
++ for (i = fpregs_ranges[range].regno_start; i <= fpregs_ranges[range].regno_end; i++)
++ supply_register (i, ((char *) buf) + sparc_regmap[i]);
+ }
+
+ extern int debug_threads;
+
+ static CORE_ADDR
+-sparc_get_pc (struct regcache *regcache)
++sparc_get_pc ()
+ {
+- unsigned long pc;
+- collect_register_by_name (regcache, "pc", &pc);
++ CORE_ADDR pc;
++ collect_register_by_name ("pc", &pc);
+ if (debug_threads)
+ fprintf (stderr, "stop pc is %08lx\n", pc);
+ return pc;
+@@ -249,12 +247,11 @@ sparc_breakpoint_at (CORE_ADDR where)
+ is outside of the function. So rather than importing software single-step,
+ we can just run until exit. */
+ static CORE_ADDR
+-sparc_reinsert_addr (void)
++sparc_reinsert_addr ()
+ {
+- struct regcache *regcache = get_thread_regcache (current_inferior, 1);
+ CORE_ADDR lr;
+ /* O7 is the equivalent to the 'lr' of other archs. */
+- collect_register_by_name (regcache, "o7", &lr);
++ collect_register_by_name ("o7", &lr);
+ return lr;
+ }
+
+--- ./gdb/gdbserver/linux-x86-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-x86-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -173,7 +173,7 @@ i386_cannot_fetch_register (int regno)
+ }
+
+ static void
+-x86_fill_gregset (struct regcache *regcache, void *buf)
++x86_fill_gregset (void *buf)
+ {
+ int i;
+
+@@ -182,20 +182,19 @@ x86_fill_gregset (struct regcache *regca
+ {
+ for (i = 0; i < X86_64_NUM_REGS; i++)
+ if (x86_64_regmap[i] != -1)
+- collect_register (regcache, i, ((char *) buf) + x86_64_regmap[i]);
++ collect_register (i, ((char *) buf) + x86_64_regmap[i]);
+ return;
+ }
+ #endif
+
+ for (i = 0; i < I386_NUM_REGS; i++)
+- collect_register (regcache, i, ((char *) buf) + i386_regmap[i]);
++ collect_register (i, ((char *) buf) + i386_regmap[i]);
+
+- collect_register_by_name (regcache, "orig_eax",
+- ((char *) buf) + ORIG_EAX * 4);
++ collect_register_by_name ("orig_eax", ((char *) buf) + ORIG_EAX * 4);
+ }
+
+ static void
+-x86_store_gregset (struct regcache *regcache, const void *buf)
++x86_store_gregset (const void *buf)
+ {
+ int i;
+
+@@ -204,50 +203,49 @@ x86_store_gregset (struct regcache *regc
+ {
+ for (i = 0; i < X86_64_NUM_REGS; i++)
+ if (x86_64_regmap[i] != -1)
+- supply_register (regcache, i, ((char *) buf) + x86_64_regmap[i]);
++ supply_register (i, ((char *) buf) + x86_64_regmap[i]);
+ return;
+ }
+ #endif
+
+ for (i = 0; i < I386_NUM_REGS; i++)
+- supply_register (regcache, i, ((char *) buf) + i386_regmap[i]);
++ supply_register (i, ((char *) buf) + i386_regmap[i]);
+
+- supply_register_by_name (regcache, "orig_eax",
+- ((char *) buf) + ORIG_EAX * 4);
++ supply_register_by_name ("orig_eax", ((char *) buf) + ORIG_EAX * 4);
+ }
+
+ static void
+-x86_fill_fpregset (struct regcache *regcache, void *buf)
++x86_fill_fpregset (void *buf)
+ {
+ #ifdef __x86_64__
+- i387_cache_to_fxsave (regcache, buf);
++ i387_cache_to_fxsave (buf);
+ #else
+- i387_cache_to_fsave (regcache, buf);
++ i387_cache_to_fsave (buf);
+ #endif
+ }
+
+ static void
+-x86_store_fpregset (struct regcache *regcache, const void *buf)
++x86_store_fpregset (const void *buf)
+ {
+ #ifdef __x86_64__
+- i387_fxsave_to_cache (regcache, buf);
++ i387_fxsave_to_cache (buf);
+ #else
+- i387_fsave_to_cache (regcache, buf);
++ i387_fsave_to_cache (buf);
+ #endif
+ }
+
+ #ifndef __x86_64__
+
+ static void
+-x86_fill_fpxregset (struct regcache *regcache, void *buf)
++x86_fill_fpxregset (void *buf)
+ {
+- i387_cache_to_fxsave (regcache, buf);
++ i387_cache_to_fxsave (buf);
+ }
+
+ static void
+-x86_store_fpxregset (struct regcache *regcache, const void *buf)
++x86_store_fpxregset (const void *buf)
+ {
+- i387_fxsave_to_cache (regcache, buf);
++ i387_fxsave_to_cache (buf);
+ }
+
+ #endif
+@@ -282,38 +280,38 @@ struct regset_info target_regsets[] =
+ };
+
+ static CORE_ADDR
+-x86_get_pc (struct regcache *regcache)
++x86_get_pc (void)
+ {
+ int use_64bit = register_size (0) == 8;
+
+ if (use_64bit)
+ {
+ unsigned long pc;
+- collect_register_by_name (regcache, "rip", &pc);
++ collect_register_by_name ("rip", &pc);
+ return (CORE_ADDR) pc;
+ }
+ else
+ {
+ unsigned int pc;
+- collect_register_by_name (regcache, "eip", &pc);
++ collect_register_by_name ("eip", &pc);
+ return (CORE_ADDR) pc;
+ }
+ }
+
+ static void
+-x86_set_pc (struct regcache *regcache, CORE_ADDR pc)
++x86_set_pc (CORE_ADDR pc)
+ {
+ int use_64bit = register_size (0) == 8;
+
+ if (use_64bit)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "rip", &newpc);
++ supply_register_by_name ("rip", &newpc);
+ }
+ else
+ {
+ unsigned int newpc = pc;
+- supply_register_by_name (regcache, "eip", &newpc);
++ supply_register_by_name ("eip", &newpc);
+ }
+ }
+ \f
+--- ./gdb/gdbserver/linux-xtensa-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/linux-xtensa-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -37,7 +37,7 @@ enum regnum {
+ };
+
+ static void
+-xtensa_fill_gregset (struct regcache *regcache, void *buf)
++xtensa_fill_gregset (void *buf)
+ {
+ elf_greg_t* rset = (elf_greg_t*)buf;
+ int ar0_regnum;
+@@ -51,27 +51,27 @@ xtensa_fill_gregset (struct regcache *re
+
+ for (i = ar0_regnum; i < ar0_regnum + XCHAL_NUM_AREGS; i++)
+ {
+- collect_register (regcache, i, ptr);
++ collect_register (i, ptr);
+ ptr += register_size(i);
+ }
+
+ /* Loop registers, if hardware has it. */
+
+ #if XCHAL_HAVE_LOOP
+- collect_register_by_name (regcache, "lbeg", (char*)&rset[R_LBEG]);
+- collect_register_by_name (regcache, "lend", (char*)&rset[R_LEND]);
+- collect_register_by_name (regcache, "lcount", (char*)&rset[R_LCOUNT]);
++ collect_register_by_name ("lbeg", (char*)&rset[R_LBEG]);
++ collect_register_by_name ("lend", (char*)&rset[R_LEND]);
++ collect_register_by_name ("lcount", (char*)&rset[R_LCOUNT]);
+ #endif
+
+- collect_register_by_name (regcache, "sar", (char*)&rset[R_SAR]);
+- collect_register_by_name (regcache, "pc", (char*)&rset[R_PC]);
+- collect_register_by_name (regcache, "ps", (char*)&rset[R_PS]);
+- collect_register_by_name (regcache, "windowbase", (char*)&rset[R_WB]);
+- collect_register_by_name (regcache, "windowstart", (char*)&rset[R_WS]);
++ collect_register_by_name ("sar", (char*)&rset[R_SAR]);
++ collect_register_by_name ("pc", (char*)&rset[R_PC]);
++ collect_register_by_name ("ps", (char*)&rset[R_PS]);
++ collect_register_by_name ("windowbase", (char*)&rset[R_WB]);
++ collect_register_by_name ("windowstart", (char*)&rset[R_WS]);
+ }
+
+ static void
+-xtensa_store_gregset (struct regcache *regcache, const void *buf)
++xtensa_store_gregset (const void *buf)
+ {
+ const elf_greg_t* rset = (const elf_greg_t*)buf;
+ int ar0_regnum;
+@@ -85,47 +85,47 @@ xtensa_store_gregset (struct regcache *r
+
+ for (i = ar0_regnum; i < ar0_regnum + XCHAL_NUM_AREGS; i++)
+ {
+- supply_register (regcache, i, ptr);
++ supply_register (i, ptr);
+ ptr += register_size(i);
+ }
+
+ /* Loop registers, if hardware has it. */
+
+ #if XCHAL_HAVE_LOOP
+- supply_register_by_name (regcache, "lbeg", (char*)&rset[R_LBEG]);
+- supply_register_by_name (regcache, "lend", (char*)&rset[R_LEND]);
+- supply_register_by_name (regcache, "lcount", (char*)&rset[R_LCOUNT]);
++ supply_register_by_name ("lbeg", (char*)&rset[R_LBEG]);
++ supply_register_by_name ("lend", (char*)&rset[R_LEND]);
++ supply_register_by_name ("lcount", (char*)&rset[R_LCOUNT]);
+ #endif
+
+- supply_register_by_name (regcache, "sar", (char*)&rset[R_SAR]);
+- supply_register_by_name (regcache, "pc", (char*)&rset[R_PC]);
+- supply_register_by_name (regcache, "ps", (char*)&rset[R_PS]);
+- supply_register_by_name (regcache, "windowbase", (char*)&rset[R_WB]);
+- supply_register_by_name (regcache, "windowstart", (char*)&rset[R_WS]);
++ supply_register_by_name ("sar", (char*)&rset[R_SAR]);
++ supply_register_by_name ("pc", (char*)&rset[R_PC]);
++ supply_register_by_name ("ps", (char*)&rset[R_PS]);
++ supply_register_by_name ("windowbase", (char*)&rset[R_WB]);
++ supply_register_by_name ("windowstart", (char*)&rset[R_WS]);
+ }
+
+ /* Xtensa GNU/Linux PTRACE interface includes extended register set. */
+
+ static void
+-xtensa_fill_xtregset (struct regcache *regcache, void *buf)
++xtensa_fill_xtregset (void *buf)
+ {
+ const xtensa_regtable_t *ptr;
+
+ for (ptr = xtensa_regmap_table; ptr->name; ptr++)
+ {
+- collect_register_by_name (regcache, ptr->name,
++ collect_register_by_name (ptr->name,
+ (char*)buf + ptr->ptrace_offset);
+ }
+ }
+
+ static void
+-xtensa_store_xtregset (struct regcache *regcache, const void *buf)
++xtensa_store_xtregset (const void *buf)
+ {
+ const xtensa_regtable_t *ptr;
+
+ for (ptr = xtensa_regmap_table; ptr->name; ptr++)
+ {
+- supply_register_by_name (regcache, ptr->name,
++ supply_register_by_name (ptr->name,
+ (char*)buf + ptr->ptrace_offset);
+ }
+ }
+@@ -150,19 +150,19 @@ static const unsigned char xtensa_breakp
+ #define xtensa_breakpoint_len 2
+
+ static CORE_ADDR
+-xtensa_get_pc (struct regcache *regcache)
++xtensa_get_pc (void)
+ {
+ unsigned long pc;
+
+- collect_register_by_name (regcache, "pc", &pc);
++ collect_register_by_name ("pc", &pc);
+ return pc;
+ }
+
+ static void
+-xtensa_set_pc (struct regcache *regcache, CORE_ADDR pc)
++xtensa_set_pc (CORE_ADDR pc)
+ {
+ unsigned long newpc = pc;
+- supply_register_by_name (regcache, "pc", &newpc);
++ supply_register_by_name ("pc", &newpc);
+ }
+
+ static int
+--- ./gdb/gdbserver/nto-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/nto-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -601,7 +601,7 @@ nto_wait (ptid_t ptid,
+ If REGNO is -1, fetch all registers, or REGNO register only otherwise. */
+
+ static void
+-nto_fetch_registers (struct regcache *regcache, int regno)
++nto_fetch_registers (int regno)
+ {
+ int regsize;
+ procfs_greg greg;
+@@ -629,7 +629,7 @@ nto_fetch_registers (struct regcache *re
+ {
+ const unsigned int registeroffset
+ = the_low_target.register_offset (regno);
+- supply_register (regcache, regno, ((char *)&greg) + registeroffset);
++ supply_register (regno, ((char *)&greg) + registeroffset);
+ }
+ }
+ else
+@@ -638,7 +638,7 @@ nto_fetch_registers (struct regcache *re
+ = the_low_target.register_offset (regno);
+ if (registeroffset == -1)
+ return;
+- supply_register (regcache, regno, ((char *)&greg) + registeroffset);
++ supply_register (regno, ((char *)&greg) + registeroffset);
+ }
+ }
+ else
+@@ -649,7 +649,7 @@ nto_fetch_registers (struct regcache *re
+ We always store all registers, regardless of REGNO. */
+
+ static void
+-nto_store_registers (struct regcache *regcache, int regno)
++nto_store_registers (int regno)
+ {
+ procfs_greg greg;
+ int err;
+@@ -671,7 +671,7 @@ nto_store_registers (struct regcache *re
+ {
+ const unsigned int regoffset
+ = the_low_target.register_offset (regno);
+- collect_register (regcache, regno, ((char *)&greg) + regoffset);
++ collect_register (regno, ((char *)&greg) + regoffset);
+ }
+ err = devctl (nto_inferior.ctl_fd, DCMD_PROC_SETGREG, &greg, sizeof (greg),
+ 0);
+--- ./gdb/gdbserver/proc-service.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/proc-service.c 2010-01-21 20:33:15.000000000 +0100
+@@ -101,7 +101,6 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwp
+ #ifdef HAVE_REGSETS
+ struct lwp_info *lwp;
+ struct thread_info *reg_inferior, *save_inferior;
+- struct regcache *regcache;
+
+ lwp = find_lwp_pid (pid_to_ptid (lwpid));
+ if (lwp == NULL)
+@@ -110,9 +109,9 @@ ps_lgetregs (gdb_ps_prochandle_t ph, lwp
+ reg_inferior = get_lwp_thread (lwp);
+ save_inferior = current_inferior;
+ current_inferior = reg_inferior;
+- regcache = get_thread_regcache (current_inferior, 1);
+- the_target->fetch_registers (regcache, -1);
+- gregset_info ()->fill_function (regcache, gregset);
++
++ the_target->fetch_registers (-1);
++ gregset_info ()->fill_function (gregset);
+
+ current_inferior = save_inferior;
+ return PS_OK;
+--- ./gdb/gdbserver/regcache.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/regcache.c 2010-01-21 20:33:15.000000000 +0100
+@@ -23,6 +23,16 @@
+ #include <stdlib.h>
+ #include <string.h>
+
++/* The private data for the register cache. Note that we have one
++ per inferior; this is primarily for simplicity, as the performance
++ benefit is minimal. */
++
++struct inferior_regcache_data
++{
++ int registers_valid;
++ unsigned char *registers;
++};
++
+ static int register_bytes;
+
+ static struct reg *reg_defs;
+@@ -30,23 +40,20 @@ static int num_registers;
+
+ const char **gdbserver_expedite_regs;
+
+-struct regcache *
+-get_thread_regcache (struct thread_info *thread, int fetch)
++static struct inferior_regcache_data *
++get_regcache (struct thread_info *inf, int fetch)
+ {
+- struct regcache *regcache;
++ struct inferior_regcache_data *regcache;
+
+- regcache = (struct regcache *) inferior_regcache_data (thread);
++ regcache = (struct inferior_regcache_data *) inferior_regcache_data (inf);
+
+ if (regcache == NULL)
+ fatal ("no register cache");
+
++ /* FIXME - fetch registers for INF */
+ if (fetch && regcache->registers_valid == 0)
+ {
+- struct thread_info *saved_inferior = current_inferior;
+-
+- current_inferior = thread;
+- fetch_inferior_registers (regcache, -1);
+- current_inferior = saved_inferior;
++ fetch_inferior_registers (-1);
+ regcache->registers_valid = 1;
+ }
+
+@@ -57,16 +64,16 @@ void
+ regcache_invalidate_one (struct inferior_list_entry *entry)
+ {
+ struct thread_info *thread = (struct thread_info *) entry;
+- struct regcache *regcache;
++ struct inferior_regcache_data *regcache;
+
+- regcache = (struct regcache *) inferior_regcache_data (thread);
++ regcache = (struct inferior_regcache_data *) inferior_regcache_data (thread);
+
+ if (regcache->registers_valid)
+ {
+ struct thread_info *saved_inferior = current_inferior;
+
+ current_inferior = thread;
+- store_inferior_registers (regcache, -1);
++ store_inferior_registers (-1);
+ current_inferior = saved_inferior;
+ }
+
+@@ -74,25 +81,24 @@ regcache_invalidate_one (struct inferior
+ }
+
+ void
+-regcache_invalidate (void)
++regcache_invalidate ()
+ {
+ for_each_inferior (&all_threads, regcache_invalidate_one);
+ }
+
+-struct regcache *
++void *
+ new_register_cache (void)
+ {
+- struct regcache *regcache;
++ struct inferior_regcache_data *regcache;
+
+ if (register_bytes == 0)
+ return NULL; /* The architecture hasn't been initialized yet. */
+
+ regcache = xmalloc (sizeof (*regcache));
+
+- /* Make sure to zero-initialize the register cache when it is
+- created, in case there are registers the target never
+- fetches. This way they'll read as zero instead of
+- garbage. */
++ /* Make sure to zero-initialize the register cache when it is created,
++ in case there are registers the target never fetches. This way they'll
++ read as zero instead of garbage. */
+ regcache->registers = xcalloc (1, register_bytes);
+
+ regcache->registers_valid = 0;
+@@ -101,8 +107,11 @@ new_register_cache (void)
+ }
+
+ void
+-free_register_cache (struct regcache *regcache)
++free_register_cache (void *regcache_p)
+ {
++ struct inferior_regcache_data *regcache
++ = (struct inferior_regcache_data *) regcache_p;
++
+ if (regcache)
+ {
+ free (regcache->registers);
+@@ -114,10 +123,8 @@ static void
+ realloc_register_cache (struct inferior_list_entry *thread_p)
+ {
+ struct thread_info *thread = (struct thread_info *) thread_p;
+- struct regcache *regcache
+- = (struct regcache *) inferior_regcache_data (thread);
+
+- free_register_cache (regcache);
++ free_register_cache (inferior_regcache_data (thread));
+ set_inferior_regcache_data (thread, new_register_cache ());
+ }
+
+@@ -147,18 +154,18 @@ set_register_cache (struct reg *regs, in
+ }
+
+ void
+-registers_to_string (struct regcache *regcache, char *buf)
++registers_to_string (char *buf)
+ {
+- unsigned char *registers = regcache->registers;
++ unsigned char *registers = get_regcache (current_inferior, 1)->registers;
+
+ convert_int_to_ascii (registers, buf, register_bytes);
+ }
+
+ void
+-registers_from_string (struct regcache *regcache, char *buf)
++registers_from_string (char *buf)
+ {
+ int len = strlen (buf);
+- unsigned char *registers = regcache->registers;
++ unsigned char *registers = get_regcache (current_inferior, 1)->registers;
+
+ if (len != register_bytes * 2)
+ {
+@@ -207,40 +214,40 @@ register_size (int n)
+ }
+
+ static unsigned char *
+-register_data (struct regcache *regcache, int n, int fetch)
++register_data (int n, int fetch)
+ {
+- return regcache->registers + (reg_defs[n].offset / 8);
++ unsigned char *registers
++ = get_regcache (current_inferior, fetch)->registers;
++
++ return registers + (reg_defs[n].offset / 8);
+ }
+
+ void
+-supply_register (struct regcache *regcache, int n, const void *buf)
++supply_register (int n, const void *buf)
+ {
+- memcpy (register_data (regcache, n, 0), buf, register_size (n));
++ memcpy (register_data (n, 0), buf, register_size (n));
+ }
+
+ void
+-supply_register_by_name (struct regcache *regcache,
+- const char *name, const void *buf)
++supply_register_by_name (const char *name, const void *buf)
+ {
+- supply_register (regcache, find_regno (name), buf);
++ supply_register (find_regno (name), buf);
+ }
+
+ void
+-collect_register (struct regcache *regcache, int n, void *buf)
++collect_register (int n, void *buf)
+ {
+- memcpy (buf, register_data (regcache, n, 1), register_size (n));
++ memcpy (buf, register_data (n, 1), register_size (n));
+ }
+
+ void
+-collect_register_as_string (struct regcache *regcache, int n, char *buf)
++collect_register_as_string (int n, char *buf)
+ {
+- convert_int_to_ascii (register_data (regcache, n, 1),
+- buf, register_size (n));
++ convert_int_to_ascii (register_data (n, 1), buf, register_size (n));
+ }
+
+ void
+-collect_register_by_name (struct regcache *regcache,
+- const char *name, void *buf)
++collect_register_by_name (const char *name, void *buf)
+ {
+- collect_register (regcache, find_regno (name), buf);
++ collect_register (find_regno (name), buf);
+ }
+--- ./gdb/gdbserver/regcache.h 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/regcache.h 2010-01-21 20:33:15.000000000 +0100
+@@ -21,27 +21,14 @@
+ #define REGCACHE_H
+
+ struct inferior_list_entry;
+-struct thread_info;
+-
+-/* The data for the register cache. Note that we have one per
+- inferior; this is primarily for simplicity, as the performance
+- benefit is minimal. */
+-
+-struct regcache
+-{
+- int registers_valid;
+- unsigned char *registers;
+-};
+
+ /* Create a new register cache for INFERIOR. */
+
+-struct regcache *new_register_cache (void);
+-
+-struct regcache *get_thread_regcache (struct thread_info *thread, int fetch);
++void *new_register_cache (void);
+
+ /* Release all memory associated with the register cache for INFERIOR. */
+
+-void free_register_cache (struct regcache *regcache);
++void free_register_cache (void *regcache);
+
+ /* Invalidate cached registers for one or all threads. */
+
+@@ -51,11 +38,11 @@ void regcache_invalidate (void);
+ /* Convert all registers to a string in the currently specified remote
+ format. */
+
+-void registers_to_string (struct regcache *regcache, char *buf);
++void registers_to_string (char *buf);
+
+ /* Convert a string to register values and fill our register cache. */
+
+-void registers_from_string (struct regcache *regcache, char *buf);
++void registers_from_string (char *buf);
+
+ /* Return a pointer to the description of register ``n''. */
+
+@@ -70,15 +57,14 @@ int find_regno (const char *name);
+ extern const char **gdbserver_expedite_regs;
+ extern const char *gdbserver_xmltarget;
+
+-void supply_register (struct regcache *regcache, int n, const void *buf);
++void supply_register (int n, const void *buf);
+
+-void supply_register_by_name (struct regcache *regcache,
+- const char *name, const void *buf);
++void supply_register_by_name (const char *name, const void *buf);
+
+-void collect_register (struct regcache *regcache, int n, void *buf);
++void collect_register (int n, void *buf);
+
+-void collect_register_as_string (struct regcache *regcache, int n, char *buf);
++void collect_register_as_string (int n, char *buf);
+
+-void collect_register_by_name (struct regcache *regcache, const char *name, void *buf);
++void collect_register_by_name (const char *name, void *buf);
+
+ #endif /* REGCACHE_H */
+--- ./gdb/gdbserver/remote-utils.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/remote-utils.c 2010-01-21 20:33:15.000000000 +0100
+@@ -1053,7 +1053,7 @@ convert_ascii_to_int (char *from, unsign
+ }
+
+ static char *
+-outreg (struct regcache *regcache, int regno, char *buf)
++outreg (int regno, char *buf)
+ {
+ if ((regno >> 12) != 0)
+ *buf++ = tohex ((regno >> 12) & 0xf);
+@@ -1062,7 +1062,7 @@ outreg (struct regcache *regcache, int r
+ *buf++ = tohex ((regno >> 4) & 0xf);
+ *buf++ = tohex (regno & 0xf);
+ *buf++ = ':';
+- collect_register_as_string (regcache, regno, buf);
++ collect_register_as_string (regno, buf);
+ buf += 2 * register_size (regno);
+ *buf++ = ';';
+
+@@ -1116,7 +1116,6 @@ prepare_resume_reply (char *buf, ptid_t
+ {
+ struct thread_info *saved_inferior;
+ const char **regp;
+- struct regcache *regcache;
+
+ sprintf (buf, "T%02x", status->value.sig);
+ buf += strlen (buf);
+@@ -1127,8 +1126,6 @@ prepare_resume_reply (char *buf, ptid_t
+
+ current_inferior = find_thread_ptid (ptid);
+
+- regcache = get_thread_regcache (current_inferior, 1);
+-
+ if (the_target->stopped_by_watchpoint != NULL
+ && (*the_target->stopped_by_watchpoint) ())
+ {
+@@ -1151,7 +1148,7 @@ prepare_resume_reply (char *buf, ptid_t
+
+ while (*regp)
+ {
+- buf = outreg (regcache, find_regno (*regp), buf);
++ buf = outreg (find_regno (*regp), buf);
+ regp ++;
+ }
+ *buf = '\0';
+--- ./gdb/gdbserver/server.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/server.c 2010-01-21 20:33:15.000000000 +0100
+@@ -2456,25 +2456,15 @@ process_serial_event (void)
+ }
+ break;
+ case 'g':
+- {
+- struct regcache *regcache;
+-
+- require_running (own_buf);
+- set_desired_inferior (1);
+- regcache = get_thread_regcache (current_inferior, 1);
+- registers_to_string (regcache, own_buf);
+- }
++ require_running (own_buf);
++ set_desired_inferior (1);
++ registers_to_string (own_buf);
+ break;
+ case 'G':
+- {
+- struct regcache *regcache;
+-
+- require_running (own_buf);
+- set_desired_inferior (1);
+- regcache = get_thread_regcache (current_inferior, 1);
+- registers_from_string (regcache, &own_buf[1]);
+- write_ok (own_buf);
+- }
++ require_running (own_buf);
++ set_desired_inferior (1);
++ registers_from_string (&own_buf[1]);
++ write_ok (own_buf);
+ break;
+ case 'm':
+ require_running (own_buf);
+--- ./gdb/gdbserver/target.h 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/target.h 2010-01-21 20:33:15.000000000 +0100
+@@ -166,13 +166,13 @@ struct target_ops
+
+ If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
+
+- void (*fetch_registers) (struct regcache *regcache, int regno);
++ void (*fetch_registers) (int regno);
+
+ /* Store registers to the inferior process.
+
+ If REGNO is -1, store all registers; otherwise, store at least REGNO. */
+
+- void (*store_registers) (struct regcache *regcache, int regno);
++ void (*store_registers) (int regno);
+
+ /* Read memory from the inferior process. This should generally be
+ called through read_inferior_memory, which handles breakpoint shadowing.
+@@ -307,11 +307,11 @@ void set_target_ops (struct target_ops *
+ #define mythread_alive(pid) \
+ (*the_target->thread_alive) (pid)
+
+-#define fetch_inferior_registers(regcache, regno) \
+- (*the_target->fetch_registers) (regcache, regno)
++#define fetch_inferior_registers(regno) \
++ (*the_target->fetch_registers) (regno)
+
+-#define store_inferior_registers(regcache, regno) \
+- (*the_target->store_registers) (regcache, regno)
++#define store_inferior_registers(regno) \
++ (*the_target->store_registers) (regno)
+
+ #define join_inferior(pid) \
+ (*the_target->join) (pid)
+--- ./gdb/gdbserver/win32-arm-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/win32-arm-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -93,19 +93,17 @@ regptr (CONTEXT* c, int r)
+
+ /* Fetch register from gdbserver regcache data. */
+ static void
+-arm_fetch_inferior_register (struct regcache *regcache,
+- win32_thread_info *th, int r)
++arm_fetch_inferior_register (win32_thread_info *th, int r)
+ {
+ char *context_offset = regptr (&th->context, r);
+- supply_register (regcache, r, context_offset);
++ supply_register (r, context_offset);
+ }
+
+ /* Store a new register value into the thread context of TH. */
+ static void
+-arm_store_inferior_register (struct regcache *regcache,
+- win32_thread_info *th, int r)
++arm_store_inferior_register (win32_thread_info *th, int r)
+ {
+- collect_register (regcache, r, regptr (&th->context, r));
++ collect_register (r, regptr (&th->context, r));
+ }
+
+ /* Correct in either endianness. We do not support Thumb yet. */
+--- ./gdb/gdbserver/win32-i386-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/win32-i386-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -271,8 +271,7 @@ static const int mappings[] = {
+
+ /* Fetch register from gdbserver regcache data. */
+ static void
+-i386_fetch_inferior_register (struct regcache *regcache,
+- win32_thread_info *th, int r)
++i386_fetch_inferior_register (win32_thread_info *th, int r)
+ {
+ char *context_offset = (char *) &th->context + mappings[r];
+
+@@ -280,24 +279,23 @@ i386_fetch_inferior_register (struct reg
+ if (r == FCS_REGNUM)
+ {
+ l = *((long *) context_offset) & 0xffff;
+- supply_register (regcache, r, (char *) &l);
++ supply_register (r, (char *) &l);
+ }
+ else if (r == FOP_REGNUM)
+ {
+ l = (*((long *) context_offset) >> 16) & ((1 << 11) - 1);
+- supply_register (regcache, r, (char *) &l);
++ supply_register (r, (char *) &l);
+ }
+ else
+- supply_register (regcache, r, context_offset);
++ supply_register (r, context_offset);
+ }
+
+ /* Store a new register value into the thread context of TH. */
+ static void
+-i386_store_inferior_register (struct regcache *regcache,
+- win32_thread_info *th, int r)
++i386_store_inferior_register (win32_thread_info *th, int r)
+ {
+ char *context_offset = (char *) &th->context + mappings[r];
+- collect_register (regcache, r, context_offset);
++ collect_register (r, context_offset);
+ }
+
+ static const unsigned char i386_win32_breakpoint = 0xcc;
+--- ./gdb/gdbserver/win32-low.c 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/win32-low.c 2010-01-21 20:33:15.000000000 +0100
+@@ -372,29 +372,29 @@ child_continue (DWORD continue_status, i
+
+ /* Fetch register(s) from the current thread context. */
+ static void
+-child_fetch_inferior_registers (struct regcache *regcache, int r)
++child_fetch_inferior_registers (int r)
+ {
+ int regno;
+ win32_thread_info *th = thread_rec (current_inferior_ptid (), TRUE);
+ if (r == -1 || r > NUM_REGS)
+- child_fetch_inferior_registers (regcache, NUM_REGS);
++ child_fetch_inferior_registers (NUM_REGS);
+ else
+ for (regno = 0; regno < r; regno++)
+- (*the_low_target.fetch_inferior_register) (regcache, th, regno);
++ (*the_low_target.fetch_inferior_register) (th, regno);
+ }
+
+ /* Store a new register value into the current thread context. We don't
+ change the program's context until later, when we resume it. */
+ static void
+-child_store_inferior_registers (struct regcache *regcache, int r)
++child_store_inferior_registers (int r)
+ {
+ int regno;
+ win32_thread_info *th = thread_rec (current_inferior_ptid (), TRUE);
+ if (r == -1 || r == 0 || r > NUM_REGS)
+- child_store_inferior_registers (regcache, NUM_REGS);
++ child_store_inferior_registers (NUM_REGS);
+ else
+ for (regno = 0; regno < r; regno++)
+- (*the_low_target.store_inferior_register) (regcache, th, regno);
++ (*the_low_target.store_inferior_register) (th, regno);
+ }
+
+ /* Map the Windows error number in ERROR to a locale-dependent error
+@@ -1569,7 +1569,6 @@ static ptid_t
+ win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus, int options)
+ {
+ struct process_info *process;
+- struct regcache *regcache;
+
+ while (1)
+ {
+@@ -1591,8 +1590,7 @@ win32_wait (ptid_t ptid, struct target_w
+ OUTMSG2 (("Child Stopped with signal = %d \n",
+ ourstatus->value.sig));
+
+- regcache = get_thread_regcache (current_inferior, 1);
+- child_fetch_inferior_registers (regcache, -1);
++ child_fetch_inferior_registers (-1);
+
+ if (ourstatus->kind == TARGET_WAITKIND_LOADED
+ && !server_waiting)
+@@ -1624,17 +1622,17 @@ win32_wait (ptid_t ptid, struct target_w
+ /* Fetch registers from the inferior process.
+ If REGNO is -1, fetch all registers; otherwise, fetch at least REGNO. */
+ static void
+-win32_fetch_inferior_registers (struct regcache *regcache, int regno)
++win32_fetch_inferior_registers (int regno)
+ {
+- child_fetch_inferior_registers (regcache, regno);
++ child_fetch_inferior_registers (regno);
+ }
+
+ /* Store registers to the inferior process.
+ If REGNO is -1, store all registers; otherwise, store at least REGNO. */
+ static void
+-win32_store_inferior_registers (struct regcache *regcache, int regno)
++win32_store_inferior_registers (int regno)
+ {
+- child_store_inferior_registers (regcache, regno);
++ child_store_inferior_registers (regno);
+ }
+
+ /* Read memory from the inferior process. This should generally be
+--- ./gdb/gdbserver/win32-low.h 2010-01-20 23:55:38.000000000 +0100
++++ ./gdb/gdbserver/win32-low.h 2010-01-21 20:33:15.000000000 +0100
+@@ -61,12 +61,10 @@ struct win32_target_ops
+ void (*thread_added) (win32_thread_info *th);
+
+ /* Fetch register from gdbserver regcache data. */
+- void (*fetch_inferior_register) (struct regcache *regcache,
+- win32_thread_info *th, int r);
++ void (*fetch_inferior_register) (win32_thread_info *th, int r);
+
+ /* Store a new register value into the thread context of TH. */
+- void (*store_inferior_register) (struct regcache *regcache,
+- win32_thread_info *th, int r);
++ void (*store_inferior_register) (win32_thread_info *th, int r);
+
+ void (*single_step) (win32_thread_info *th);
+
diff --git a/gdb.spec b/gdb.spec
index c8284f8..70fb9a1 100644
--- a/gdb.spec
+++ b/gdb.spec
@@ -36,7 +36,7 @@ Version: 7.0.50.20100121
# The release always contains a leading reserved number, start it at 1.
# `upstream' is not a part of `name' to stay fully rpm dependencies compatible for the testing.
-Release: 2%{?_with_upstream:.upstream}%{dist}
+Release: 3%{?_with_upstream:.upstream}%{dist}
License: GPLv3+
Group: Development/Debuggers
@@ -428,6 +428,9 @@ Patch411: gdb-solib-display.patch
# Revert: Add -Wunused-function to compile flags.
Patch412: gdb-unused-revert.patch
+# Revert FSF GDB gdbserver tracepoints as incomplete now.
+Patch413: gdb-gdbserver-tracepoint-revert.patch
+
BuildRequires: ncurses-devel%{?_isa} texinfo gettext flex bison expat-devel%{?_isa}
Requires: readline%{?_isa}
BuildRequires: readline-devel%{?_isa}
@@ -673,6 +676,7 @@ rm -f gdb/jv-exp.c gdb/m2-exp.c gdb/objc-exp.c gdb/p-exp.c
%patch408 -p1
%patch411 -p1
%patch412 -p1
+%patch413 -p1
# Always verify its applicability.
%patch393 -p1
%patch335 -p1
@@ -998,6 +1002,9 @@ fi
%endif
%changelog
+* Thu Jan 21 2010 Jan Kratochvil <jan.kratochvil@redhat.com> - 7.0.50.20100121-3.fc13
+- Revert FSF GDB gdbserver tracepoints as incomplete now.
+
* Thu Jan 21 2010 Jan Kratochvil <jan.kratochvil@redhat.com> - 7.0.50.20100121-2.fc13
- archer-jankratochvil-fedora13 commit: 21e418c04290aa5d2e75543d31fe3fe5d70d6d41
- [expr-cumulative] Fix "break expr if (cond)" regression.
reply other threads:[~2026-06-27 23:54 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=178260447277.1.10728220100538379774.rpms-gdb-39d52ac1d6cf@fedoraproject.org \
--to=jkratoch@fedoraproject.org \
--cc=git-commits@fedoraproject.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox