This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [patch/rfc] regcache_raw_read_as_address() -> regcache_cooked_read_as_ulongest()
- From: Andrew Cagney <ac131313 at ges dot redhat dot com>
- To: Kevin Buettner <kevinb at redhat dot com>
- Cc: Daniel Jacobowitz <drow at mvista dot com>,Mark Kettenis <kettenis at science dot uva dot nl>,gdb-patches at sources dot redhat dot com
- Date: Tue, 13 Aug 2002 09:46:52 -0400
- Subject: Re: [patch/rfc] regcache_raw_read_as_address() -> regcache_cooked_read_as_ulongest()
- References: <3D5811CA.2070205@ges.redhat.com> <20020812201218.GA17509@nevyn.them.org> <1020812202845.ZM934@localhost.localdomain>
On Aug 12, 4:12pm, Daniel Jacobowitz wrote:
> I think the change is ok (i386 shows no regressions, the mips doesn't
> use this code :-). I'm just wondering about the names. Perhaps:
> regcache_cooked_read_signed() & regcache_cooked_read_unsigned()?
>
> thoughts?
Hmm, I like _read_signed and _read_unsigned... the _as_longest bit is
implicit.
I agree with Daniel.
Good enough for me.
I took the liberty of revising the exact interface. It uses a reference
parameter, rather than function return, when passing back the result.
The comment:
+/* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
+ for indicating when a ``cooked'' register was constructed from
+ invalid or unavailable ``raw'' registers. One fairly easy way of
+ adding such a mechanism would be for the cooked functions to return
+ a register valid indication. Given the possibility of such a
+ change, the extract functions below use a reference parameter,
+ rather than a function result. */
explains why. I should note that this is a somewhat pervasive problem
in GDB, there are few checks to ensure that a register is valid and
those that do, check the raw register cache :-(
enjoy,
Andrew
2002-08-12 Andrew Cagney <cagney@redhat.com>
* regcache.c (regcache_raw_read_as_address): Delete function.
(regcache_cooked_read_signed): New function.
(regcache_cooked_read_unsigned): New function.
* regcache.h (regcache_cooked_read_signed): Declare.
(regcache_cooked_read_unsigned): Declare.
(regcache_raw_read_as_address): Delete declaration.
* blockframe.c (generic_read_register_dummy): Use
regcache_cooked_read_unsigned.
* i386-tdep.c (i386_extract_struct_value_address): Use
regcache_cooked_read_unsigned.
Index: blockframe.c
===================================================================
RCS file: /cvs/src/src/gdb/blockframe.c,v
retrieving revision 1.35
diff -u -r1.35 blockframe.c
--- blockframe.c 9 Aug 2002 18:26:15 -0000 1.35
+++ blockframe.c 13 Aug 2002 13:39:24 -0000
@@ -1215,7 +1215,20 @@
struct regcache *dummy_regs = generic_find_dummy_frame (pc, fp);
if (dummy_regs)
- return regcache_raw_read_as_address (dummy_regs, regno);
+ {
+ /* NOTE: cagney/2002-08-12: Replaced a call to
+ regcache_raw_read_as_address() with a call to
+ regcache_cooked_read_unsigned(). The old, ...as_address
+ function was eventually calling extract_unsigned_integer (via
+ extract_address) to unpack the registers value. The below is
+ doing an unsigned extract so that it is functionally
+ equivalent. The read needs to be cooked as, otherwise, it
+ will never correctly return the value of a register in the
+ [NUM_REGS .. NUM_REGS+NUM_PSEUDO_REGS) range. */
+ ULONGEST val;
+ regcache_cooked_read_unsigned (dummy_regs, regno, &val);
+ return val;
+ }
else
return 0;
}
Index: i386-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/i386-tdep.c,v
retrieving revision 1.74
diff -u -r1.74 i386-tdep.c
--- i386-tdep.c 12 Aug 2002 19:05:33 -0000 1.74
+++ i386-tdep.c 13 Aug 2002 13:39:25 -0000
@@ -1028,7 +1028,18 @@
static CORE_ADDR
i386_extract_struct_value_address (struct regcache *regcache)
{
- return regcache_raw_read_as_address (regcache, LOW_RETURN_REGNUM);
+ /* NOTE: cagney/2002-08-12: Replaced a call to
+ regcache_raw_read_as_address() with a call to
+ regcache_cooked_read_unsigned(). The old, ...as_address function
+ was eventually calling extract_unsigned_integer (via
+ extract_address) to unpack the registers value. The below is
+ doing an unsigned extract so that it is functionally equivalent.
+ The read needs to be cooked as, otherwise, it will never
+ correctly return the value of a register in the [NUM_REGS
+ .. NUM_REGS+NUM_PSEUDO_REGS) range. */
+ ULONGEST val;
+ regcache_cooked_read_unsigned (regcache, LOW_RETURN_REGNUM, &val);
+ return val;
}
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.50
diff -u -r1.50 regcache.c
--- regcache.c 10 Aug 2002 02:00:16 -0000 1.50
+++ regcache.c 13 Aug 2002 13:39:25 -0000
@@ -366,17 +366,6 @@
return regcache->raw_register_valid_p[regnum];
}
-CORE_ADDR
-regcache_raw_read_as_address (struct regcache *regcache, int regnum)
-{
- char *buf;
- gdb_assert (regcache != NULL);
- gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
- buf = alloca (regcache->descr->sizeof_register[regnum]);
- regcache_raw_read (regcache, regnum, buf);
- return extract_address (buf, regcache->descr->sizeof_register[regnum]);
-}
-
char *
deprecated_grub_regcache_for_registers (struct regcache *regcache)
{
@@ -694,6 +683,32 @@
else
gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
regnum, buf);
+}
+
+void
+regcache_cooked_read_signed (struct regcache *regcache, int regnum,
+ LONGEST *val)
+{
+ char *buf;
+ gdb_assert (regcache != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+ buf = alloca (regcache->descr->sizeof_register[regnum]);
+ regcache_cooked_read (regcache, regnum, buf);
+ (*val) = extract_signed_integer (buf,
+ regcache->descr->sizeof_register[regnum]);
+}
+
+void
+regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
+ ULONGEST *val)
+{
+ char *buf;
+ gdb_assert (regcache != NULL);
+ gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
+ buf = alloca (regcache->descr->sizeof_register[regnum]);
+ regcache_cooked_read (regcache, regnum, buf);
+ (*val) = extract_unsigned_integer (buf,
+ regcache->descr->sizeof_register[regnum]);
}
/* Write register REGNUM at MYADDR to the target. MYADDR points at
Index: regcache.h
===================================================================
RCS file: /cvs/src/src/gdb/regcache.h,v
retrieving revision 1.12
diff -u -r1.12 regcache.h
--- regcache.h 2 Aug 2002 18:08:31 -0000 1.12
+++ regcache.h 13 Aug 2002 13:39:25 -0000
@@ -39,12 +39,25 @@
void regcache_raw_write (struct regcache *regcache, int rawnum,
const void *buf);
int regcache_valid_p (struct regcache *regcache, int regnum);
-CORE_ADDR regcache_raw_read_as_address (struct regcache *regcache, int rawnum);
/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
void regcache_cooked_read (struct regcache *regcache, int rawnum, void *buf);
void regcache_cooked_write (struct regcache *regcache, int rawnum,
const void *buf);
+
+/* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
+ for indicating when a ``cooked'' register was constructed from
+ invalid or unavailable ``raw'' registers. One fairly easy way of
+ adding such a mechanism would be for the cooked functions to return
+ a register valid indication. Given the possibility of such a
+ change, the extract functions below use a reference parameter,
+ rather than a function result. */
+
+/* Read a register as a signed/unsigned quantity. */
+extern void regcache_cooked_read_signed (struct regcache *regcache,
+ int regnum, LONGEST *val);
+extern void regcache_cooked_read_unsigned (struct regcache *regcache,
+ int regnum, ULONGEST *val);
/* Transfer a raw register [0..NUM_REGS) between the regcache and the
target. These functions are called by the target in response to a