This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
Re: [RFA] regcache.c: "regno" or "regnum"
- To: Nicholas Duffek <nsd at redhat dot com>
- Subject: Re: [RFA] regcache.c: "regno" or "regnum"
- From: Michael Snyder <msnyder at redhat dot com>
- Date: Wed, 03 Jan 2001 12:58:21 -0800
- CC: gdb-patches at sources dot redhat dot com
- Organization: Red Hat
- References: <200101032042.PAA14846@nog.bosbc.com>
Nicholas Duffek wrote:
>
> This is a large but trivial patch.
I'll take it upon myself to approve this. Thanks -- I've always
been annoyed by that "regno" vs. "regnum" thing.
>
> While implementing the register definition interface patch that I'll be
> posting shortly, I noticed that register numbers are called "regno" in
> about half of regcache.c and "regnum" in the other half.
>
> In the interest of consistency, I propose settling on one or the other. I
> picked "regnum" because "no" has always seemed to me a strange
> abbreviation for "number", but I have no strong preference.
>
> The patch also makes the following comment changes:
>
> 1. Describe the register cache as "write-through" instead of
> "write-back". If I understand correctly, write-back means that
> writes are performed at some unspecified time in the future, and
> write-through means they're performed immediately, as they are in
> GDB's register cache.
>
> 2. Document read_register() as:
>
> /* Return the contents of register REGNUM as an unsigned integer. */
>
> instead of:
>
> /* Return the raw contents of register REGNO, regarding it as an
> UNSIGNED integer. */
>
> which seems self-contradictory to me: it says that the return value
> is both raw and non-raw.
>
> 3. Replace contraction "it's" with possessive pronoun "its" in the
> documentation for supply_register().
>
> ChangeLog:
>
> * regcache.c: Change "write-back" comment to "write-through".
> Change "regno" to "regnum".
> (read_register, read_signed_register): Remove "raw" from return
> value description.
> (supply_register): Spelling fix.
> * value.h: Change "regno" to "regnum".
>
> No regressions on i686-pc-linux-gnu. Okay to apply?
>
> Nicholas Duffek
> <nsd@redhat.com>
>
> [patch follows]
>
> Index: gdb/regcache.c
> ===================================================================
> diff -up gdb/regcache.c gdb/regcache.c
> --- gdb/regcache.c Tue Dec 19 11:27:10 2000
> +++ gdb/regcache.c Tue Dec 19 11:26:52 2000
> @@ -32,7 +32,7 @@
> * Here is the actual register cache.
> */
>
> -/* NOTE: this is a write-back cache. There is no "dirty" bit for
> +/* NOTE: this is a write-through cache. There is no "dirty" bit for
> recording if the register values have been changed (eg. by the
> user). Therefore all registers must be written back to the
> target when appropriate. */
> @@ -338,7 +338,7 @@ registers_fetched (void)
> is that register sizes can vary, so a simple index won't suffice.]
> It is far better to call read_register_gen and write_register_gen
> if you want to get at the raw register contents, as it only takes a
> - regno as an argument, and therefore can't do a partial register
> + regnum as an argument, and therefore can't do a partial register
> update.
>
> Prior to the recent fixes to check for partial updates, both read
> @@ -355,7 +355,7 @@ void
> read_register_bytes (int inregbyte, char *myaddr, int inlen)
> {
> int inregend = inregbyte + inlen;
> - int regno;
> + int regnum;
>
> if (registers_pid != inferior_pid)
> {
> @@ -366,38 +366,39 @@ read_register_bytes (int inregbyte, char
> /* See if we are trying to read bytes from out-of-date registers. If so,
> update just those registers. */
>
> - for (regno = 0; regno < NUM_REGS + NUM_PSEUDO_REGS; regno++)
> + for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
> {
> int regstart, regend;
>
> - if (register_valid[regno])
> + if (register_valid[regnum])
> continue;
>
> - if (REGISTER_NAME (regno) == NULL || *REGISTER_NAME (regno) == '\0')
> + if (REGISTER_NAME (regnum) == NULL || *REGISTER_NAME (regnum) == '\0')
> continue;
>
> - regstart = REGISTER_BYTE (regno);
> - regend = regstart + REGISTER_RAW_SIZE (regno);
> + regstart = REGISTER_BYTE (regnum);
> + regend = regstart + REGISTER_RAW_SIZE (regnum);
>
> if (regend <= inregbyte || inregend <= regstart)
> - /* The range the user wants to read doesn't overlap with regno. */
> + /* The range the user wants to read doesn't overlap with regnum. */
> continue;
>
> /* We've found an uncached register where at least one byte will be read.
> Update it from the target. */
> - if (regno < NUM_REGS)
> - target_fetch_registers (regno);
> - else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
> - FETCH_PSEUDO_REGISTER (regno);
> + if (regnum < NUM_REGS)
> + target_fetch_registers (regnum);
> + else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
> + FETCH_PSEUDO_REGISTER (regnum);
>
> - if (!register_valid[regno])
> + if (!register_valid[regnum])
> {
> /* Sometimes pseudoregs are never marked valid, so that they
> will be fetched every time (it can be complicated to know
> if a pseudoreg is valid, while "fetching" them can be cheap).
> */
> - if (regno < NUM_REGS)
> - error ("read_register_bytes: Couldn't update register %d.", regno);
> + if (regnum < NUM_REGS)
> + error ("read_register_bytes: Couldn't update register %d.",
> + regnum);
> }
> }
>
> @@ -405,13 +406,13 @@ read_register_bytes (int inregbyte, char
> memcpy (myaddr, ®isters[inregbyte], inlen);
> }
>
> -/* Read register REGNO into memory at MYADDR, which must be large
> - enough for REGISTER_RAW_BYTES (REGNO). Target byte-order. If the
> +/* Read register REGNUM into memory at MYADDR, which must be large
> + enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
> register is known to be the size of a CORE_ADDR or smaller,
> read_register can be used instead. */
>
> void
> -read_register_gen (int regno, char *myaddr)
> +read_register_gen (int regnum, char *myaddr)
> {
> if (registers_pid != inferior_pid)
> {
> @@ -419,33 +420,33 @@ read_register_gen (int regno, char *myad
> registers_pid = inferior_pid;
> }
>
> - if (!register_valid[regno])
> + if (!register_valid[regnum])
> {
> - if (regno < NUM_REGS)
> - target_fetch_registers (regno);
> - else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
> - FETCH_PSEUDO_REGISTER (regno);
> + if (regnum < NUM_REGS)
> + target_fetch_registers (regnum);
> + else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
> + FETCH_PSEUDO_REGISTER (regnum);
> }
> - memcpy (myaddr, ®isters[REGISTER_BYTE (regno)],
> - REGISTER_RAW_SIZE (regno));
> + memcpy (myaddr, ®isters[REGISTER_BYTE (regnum)],
> + REGISTER_RAW_SIZE (regnum));
> }
>
> -/* Write register REGNO at MYADDR to the target. MYADDR points at
> - REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
> +/* Write register REGNUM at MYADDR to the target. MYADDR points at
> + REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
>
> /* Registers we shouldn't try to store. */
> #if !defined (CANNOT_STORE_REGISTER)
> -#define CANNOT_STORE_REGISTER(regno) 0
> +#define CANNOT_STORE_REGISTER(regnum) 0
> #endif
>
> void
> -write_register_gen (int regno, char *myaddr)
> +write_register_gen (int regnum, char *myaddr)
> {
> int size;
>
> /* On the sparc, writing %g0 is a no-op, so we don't even want to
> change the registers array if something writes to this register. */
> - if (CANNOT_STORE_REGISTER (regno))
> + if (CANNOT_STORE_REGISTER (regnum))
> return;
>
> if (registers_pid != inferior_pid)
> @@ -454,26 +455,26 @@ write_register_gen (int regno, char *mya
> registers_pid = inferior_pid;
> }
>
> - size = REGISTER_RAW_SIZE (regno);
> + size = REGISTER_RAW_SIZE (regnum);
>
> /* If we have a valid copy of the register, and new value == old value,
> then don't bother doing the actual store. */
>
> - if (register_valid[regno]
> - && memcmp (®isters[REGISTER_BYTE (regno)], myaddr, size) == 0)
> + if (register_valid[regnum]
> + && memcmp (®isters[REGISTER_BYTE (regnum)], myaddr, size) == 0)
> return;
>
> - if (regno < NUM_REGS)
> + if (regnum < NUM_REGS)
> target_prepare_to_store ();
>
> - memcpy (®isters[REGISTER_BYTE (regno)], myaddr, size);
> + memcpy (®isters[REGISTER_BYTE (regnum)], myaddr, size);
>
> - register_valid[regno] = 1;
> + register_valid[regnum] = 1;
>
> - if (regno < NUM_REGS)
> - target_store_registers (regno);
> - else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
> - STORE_PSEUDO_REGISTER (regno);
> + if (regnum < NUM_REGS)
> + target_store_registers (regnum);
> + else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
> + STORE_PSEUDO_REGISTER (regnum);
> }
>
> /* Copy INLEN bytes of consecutive data from memory at MYADDR
> @@ -483,7 +484,7 @@ void
> write_register_bytes (int myregstart, char *myaddr, int inlen)
> {
> int myregend = myregstart + inlen;
> - int regno;
> + int regnum;
>
> target_prepare_to_store ();
>
> @@ -492,12 +493,12 @@ write_register_bytes (int myregstart, ch
> nice things like handling threads, and avoiding updates when the
> new and old contents are the same. */
>
> - for (regno = 0; regno < NUM_REGS + NUM_PSEUDO_REGS; regno++)
> + for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
> {
> int regstart, regend;
>
> - regstart = REGISTER_BYTE (regno);
> - regend = regstart + REGISTER_RAW_SIZE (regno);
> + regstart = REGISTER_BYTE (regnum);
> + regend = regstart + REGISTER_RAW_SIZE (regnum);
>
> /* Is this register completely outside the range the user is writing? */
> if (myregend <= regstart || regend <= myregstart)
> @@ -505,7 +506,7 @@ write_register_bytes (int myregstart, ch
>
> /* Is this register completely within the range the user is writing? */
> else if (myregstart <= regstart && regend <= myregend)
> - write_register_gen (regno, myaddr + (regstart - myregstart));
> + write_register_gen (regnum, myaddr + (regstart - myregstart));
>
> /* The register partially overlaps the range being written. */
> else
> @@ -518,26 +519,25 @@ write_register_bytes (int myregstart, ch
>
> /* We may be doing a partial update of an invalid register.
> Update it from the target before scribbling on it. */
> - read_register_gen (regno, regbuf);
> + read_register_gen (regnum, regbuf);
>
> memcpy (registers + overlapstart,
> myaddr + (overlapstart - myregstart),
> overlapend - overlapstart);
>
> - if (regno < NUM_REGS)
> - target_store_registers (regno);
> - else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
> - STORE_PSEUDO_REGISTER (regno);
> + if (regnum < NUM_REGS)
> + target_store_registers (regnum);
> + else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
> + STORE_PSEUDO_REGISTER (regnum);
> }
> }
> }
>
>
> -/* Return the raw contents of register REGNO, regarding it as an
> - UNSIGNED integer. */
> +/* Return the contents of register REGNUM as an unsigned integer. */
>
> ULONGEST
> -read_register (int regno)
> +read_register (int regnum)
> {
> if (registers_pid != inferior_pid)
> {
> @@ -545,43 +545,42 @@ read_register (int regno)
> registers_pid = inferior_pid;
> }
>
> - if (!register_valid[regno])
> + if (!register_valid[regnum])
> {
> - if (regno < NUM_REGS)
> - target_fetch_registers (regno);
> - else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
> - FETCH_PSEUDO_REGISTER (regno);
> + if (regnum < NUM_REGS)
> + target_fetch_registers (regnum);
> + else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
> + FETCH_PSEUDO_REGISTER (regnum);
> }
>
> - return (extract_unsigned_integer (®isters[REGISTER_BYTE (regno)],
> - REGISTER_RAW_SIZE (regno)));
> + return (extract_unsigned_integer (®isters[REGISTER_BYTE (regnum)],
> + REGISTER_RAW_SIZE (regnum)));
> }
>
> ULONGEST
> -read_register_pid (int regno, int pid)
> +read_register_pid (int regnum, int pid)
> {
> int save_pid;
> CORE_ADDR retval;
>
> if (pid == inferior_pid)
> - return read_register (regno);
> + return read_register (regnum);
>
> save_pid = inferior_pid;
>
> inferior_pid = pid;
>
> - retval = read_register (regno);
> + retval = read_register (regnum);
>
> inferior_pid = save_pid;
>
> return retval;
> }
>
> -/* Return the raw contents of register REGNO, regarding it a SIGNED
> - integer. */
> +/* Return the contents of register REGNUM as a signed integer. */
>
> LONGEST
> -read_signed_register (int regno)
> +read_signed_register (int regnum)
> {
> if (registers_pid != inferior_pid)
> {
> @@ -589,44 +588,44 @@ read_signed_register (int regno)
> registers_pid = inferior_pid;
> }
>
> - if (!register_valid[regno])
> - target_fetch_registers (regno);
> + if (!register_valid[regnum])
> + target_fetch_registers (regnum);
>
> - return (extract_signed_integer (®isters[REGISTER_BYTE (regno)],
> - REGISTER_RAW_SIZE (regno)));
> + return (extract_signed_integer (®isters[REGISTER_BYTE (regnum)],
> + REGISTER_RAW_SIZE (regnum)));
> }
>
> LONGEST
> -read_signed_register_pid (int regno, int pid)
> +read_signed_register_pid (int regnum, int pid)
> {
> int save_pid;
> LONGEST retval;
>
> if (pid == inferior_pid)
> - return read_signed_register (regno);
> + return read_signed_register (regnum);
>
> save_pid = inferior_pid;
>
> inferior_pid = pid;
>
> - retval = read_signed_register (regno);
> + retval = read_signed_register (regnum);
>
> inferior_pid = save_pid;
>
> return retval;
> }
>
> -/* Store VALUE, into the raw contents of register number REGNO. */
> +/* Store VALUE into the raw contents of register number REGNUM. */
>
> void
> -write_register (int regno, LONGEST val)
> +write_register (int regnum, LONGEST val)
> {
> PTR buf;
> int size;
>
> /* On the sparc, writing %g0 is a no-op, so we don't even want to
> change the registers array if something writes to this register. */
> - if (CANNOT_STORE_REGISTER (regno))
> + if (CANNOT_STORE_REGISTER (regnum))
> return;
>
> if (registers_pid != inferior_pid)
> @@ -635,38 +634,38 @@ write_register (int regno, LONGEST val)
> registers_pid = inferior_pid;
> }
>
> - size = REGISTER_RAW_SIZE (regno);
> + size = REGISTER_RAW_SIZE (regnum);
> buf = alloca (size);
> store_signed_integer (buf, size, (LONGEST) val);
>
> /* If we have a valid copy of the register, and new value == old value,
> then don't bother doing the actual store. */
>
> - if (register_valid[regno]
> - && memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0)
> + if (register_valid[regnum]
> + && memcmp (®isters[REGISTER_BYTE (regnum)], buf, size) == 0)
> return;
>
> - if (regno < NUM_REGS)
> + if (regnum < NUM_REGS)
> target_prepare_to_store ();
>
> - memcpy (®isters[REGISTER_BYTE (regno)], buf, size);
> + memcpy (®isters[REGISTER_BYTE (regnum)], buf, size);
>
> - register_valid[regno] = 1;
> + register_valid[regnum] = 1;
>
> - if (regno < NUM_REGS)
> - target_store_registers (regno);
> - else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
> - STORE_PSEUDO_REGISTER (regno);
> + if (regnum < NUM_REGS)
> + target_store_registers (regnum);
> + else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
> + STORE_PSEUDO_REGISTER (regnum);
> }
>
> void
> -write_register_pid (int regno, CORE_ADDR val, int pid)
> +write_register_pid (int regnum, CORE_ADDR val, int pid)
> {
> int save_pid;
>
> if (pid == inferior_pid)
> {
> - write_register (regno, val);
> + write_register (regnum, val);
> return;
> }
>
> @@ -674,23 +673,23 @@ write_register_pid (int regno, CORE_ADDR
>
> inferior_pid = pid;
>
> - write_register (regno, val);
> + write_register (regnum, val);
>
> inferior_pid = save_pid;
> }
>
> /* SUPPLY_REGISTER()
>
> - Record that register REGNO contains VAL. This is used when the
> + Record that register REGNUM contains VAL. This is used when the
> value is obtained from the inferior or core dump, so there is no
> need to store the value there.
>
> If VAL is a NULL pointer, then it's probably an unsupported register.
> - We just set it's value to all zeros. We might want to record this
> + We just set its value to all zeros. We might want to record this
> fact, and report it to the users of read_register and friends. */
>
> void
> -supply_register (int regno, char *val)
> +supply_register (int regnum, char *val)
> {
> #if 1
> if (registers_pid != inferior_pid)
> @@ -700,19 +699,19 @@ supply_register (int regno, char *val)
> }
> #endif
>
> - register_valid[regno] = 1;
> + register_valid[regnum] = 1;
> if (val)
> - memcpy (®isters[REGISTER_BYTE (regno)], val,
> - REGISTER_RAW_SIZE (regno));
> + memcpy (®isters[REGISTER_BYTE (regnum)], val,
> + REGISTER_RAW_SIZE (regnum));
> else
> - memset (®isters[REGISTER_BYTE (regno)], '\000',
> - REGISTER_RAW_SIZE (regno));
> + memset (®isters[REGISTER_BYTE (regnum)], '\000',
> + REGISTER_RAW_SIZE (regnum));
>
> /* On some architectures, e.g. HPPA, there are a few stray bits in
> some registers, that the rest of the code would like to ignore. */
>
> #ifdef CLEAN_UP_REGISTER_VALUE
> - CLEAN_UP_REGISTER_VALUE (regno, ®isters[REGISTER_BYTE (regno)]);
> + CLEAN_UP_REGISTER_VALUE (regnum, ®isters[REGISTER_BYTE (regnum)]);
> #endif
> }
>
> Index: gdb/value.h
> ===================================================================
> diff -up gdb/value.h gdb/value.h
> --- gdb/value.h Tue Dec 19 11:27:56 2000
> +++ gdb/value.h Tue Dec 19 11:26:52 2000
> @@ -470,27 +470,27 @@ extern void read_register_bytes (int reg
>
> extern void write_register_bytes (int regbyte, char *myaddr, int len);
>
> -extern void read_register_gen (int regno, char *myaddr);
> +extern void read_register_gen (int regnum, char *myaddr);
>
> -extern void write_register_gen (int regno, char *myaddr);
> +extern void write_register_gen (int regnum, char *myaddr);
>
> /* Rename to read_unsigned_register()? */
> -extern ULONGEST read_register (int regno);
> +extern ULONGEST read_register (int regnum);
>
> -extern LONGEST read_signed_register (int regno);
> +extern LONGEST read_signed_register (int regnum);
>
> /* Rename to read_unsigned_register_pid()? */
> -extern ULONGEST read_register_pid (int regno, int pid);
> +extern ULONGEST read_register_pid (int regnum, int pid);
>
> -extern LONGEST read_signed_register_pid (int regno, int pid);
> +extern LONGEST read_signed_register_pid (int regnum, int pid);
>
> -extern void write_register (int regno, LONGEST val);
> +extern void write_register (int regnum, LONGEST val);
>
> -extern void write_register_pid (int regno, CORE_ADDR val, int pid);
> +extern void write_register_pid (int regnum, CORE_ADDR val, int pid);
>
> -extern void supply_register (int regno, char *val);
> +extern void supply_register (int regnum, char *val);
>
> -extern int register_cached (int regno);
> +extern int register_cached (int regnum);
>
> extern void register_changed (int regnum);
>