diff options
| -rw-r--r-- | gdb/ChangeLog | 11 | ||||
| -rw-r--r-- | gdb/regcache.c | 71 |
2 files changed, 53 insertions, 29 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c2fb624..31f0b99 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,14 @@ +2002-07-29 Andrew Cagney <cagney@redhat.com> + + * regcache.c (struct regcache_descr): Rename nr_registers to + nr_cooked_registers. Revise comments describing the structure + member fields. + (init_regcache_descr): Update. + (init_legacy_regcache_descr): Update. + (read_register_gen, write_register_gen): When a cooked register in + the raw register range, directly access the value from the raw + register cache. + 2002-07-29 Andrew Cagney <ac131313@redhat.com> * z8k-tdep.c: Do not include "obstack.h". diff --git a/gdb/regcache.c b/gdb/regcache.c index 75f88a6..592b3e5 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -56,22 +56,25 @@ struct regcache_descr long sizeof_raw_registers; long sizeof_raw_register_valid_p; - /* Offset, in bytes, of reach register in the raw register cache. - Pseudo registers have an offset even though they don't - (shouldn't) have a correspoinding space in the register cache. - It is to keep existing code, that relies on - write/write_register_bytes working. */ + /* The cooked register space. Each cooked register in the range + [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw + register. The remaining [NR_RAW_REGISTERS + .. NR_COOKED_REGISTERS) (a.k.a. pseudo regiters) are mapped onto + both raw registers and memory by the architecture methods + gdbarch_register_read and gdbarch_register_write. */ + int nr_cooked_registers; + + /* Offset and size (in 8 bit bytes), of reach register in the + register cache. All registers (including those in the range + [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset. + Assigning all registers an offset makes it possible to keep + legacy code, such as that found in read_register_bytes() and + write_register_bytes() working. */ long *register_offset; - - /* The cooked / frame / virtual register space. The registers in - the range [0..NR_RAW_REGISTERS) should be mapped directly onto - the corresponding raw register. The next [NR_RAW_REGISTERS - .. NR_REGISTERS) should have been mapped, via - gdbarch_register_read/write onto either raw registers or memory. */ - int nr_registers; long *sizeof_register; - long max_register_size; + /* Useful constant. Largest of all the registers. */ + long max_register_size; }; static void * @@ -89,19 +92,19 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch) /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers in the register buffer. Unfortunatly some architectures do. */ - descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS; - descr->nr_raw_registers = descr->nr_registers; - descr->sizeof_raw_register_valid_p = descr->nr_registers; + descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS; + descr->nr_raw_registers = descr->nr_cooked_registers; + descr->sizeof_raw_register_valid_p = descr->nr_cooked_registers; /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this code should compute the offets et.al. at runtime. This currently isn't possible because some targets overlap register locations - see the mess in read_register_bytes() and write_register_bytes() registers. */ - descr->sizeof_register = XCALLOC (descr->nr_registers, long); - descr->register_offset = XCALLOC (descr->nr_registers, long); + descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long); + descr->register_offset = XCALLOC (descr->nr_cooked_registers, long); descr->max_register_size = 0; - for (i = 0; i < descr->nr_registers; i++) + for (i = 0; i < descr->nr_cooked_registers; i++) { descr->register_offset[i] = REGISTER_BYTE (i); descr->sizeof_register[i] = REGISTER_RAW_SIZE (i); @@ -111,7 +114,7 @@ init_legacy_regcache_descr (struct gdbarch *gdbarch) /* Come up with the real size of the registers buffer. */ descr->sizeof_raw_registers = REGISTER_BYTES; /* OK use. */ - for (i = 0; i < descr->nr_registers; i++) + for (i = 0; i < descr->nr_cooked_registers; i++) { long regend; /* Keep extending the buffer so that there is always enough @@ -148,10 +151,10 @@ init_regcache_descr (struct gdbarch *gdbarch) descr->gdbarch = gdbarch; descr->legacy_p = 0; - /* Total size of the register space. The raw registers should - directly map onto the raw register cache while the pseudo's are + /* Total size of the register space. The raw registers are mapped + directly onto the raw register cache while the pseudo's are either mapped onto raw-registers or memory. */ - descr->nr_registers = NUM_REGS + NUM_PSEUDO_REGS; + descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS; /* Construct a strictly RAW register cache. Don't allow pseudo's into the register cache. */ @@ -170,10 +173,10 @@ init_regcache_descr (struct gdbarch *gdbarch) { long offset = 0; - descr->sizeof_register = XCALLOC (descr->nr_registers, long); - descr->register_offset = XCALLOC (descr->nr_registers, long); + descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long); + descr->register_offset = XCALLOC (descr->nr_cooked_registers, long); descr->max_register_size = 0; - for (i = 0; i < descr->nr_registers; i++) + for (i = 0; i < descr->nr_cooked_registers; i++) { descr->sizeof_register[i] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i)); descr->register_offset[i] = offset; @@ -198,7 +201,7 @@ init_regcache_descr (struct gdbarch *gdbarch) don't go into infinite recursion trying to, again, create the regcache. */ set_gdbarch_data (gdbarch, regcache_descr_handle, descr); - for (i = 0; i < descr->nr_registers; i++) + for (i = 0; i < descr->nr_cooked_registers; i++) { gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i)); gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i)); @@ -716,7 +719,12 @@ read_register_gen (int regnum, char *buf) legacy_read_register_gen (regnum, buf); return; } - gdbarch_register_read (current_gdbarch, regnum, buf); + gdb_assert (regnum >= 0); + gdb_assert (regnum < current_regcache->descr->nr_cooked_registers); + if (regnum < current_regcache->descr->nr_raw_registers) + regcache_raw_read (current_regcache, regnum, buf); + else + gdbarch_register_read (current_gdbarch, regnum, buf); } @@ -825,7 +833,12 @@ write_register_gen (int regnum, char *buf) legacy_write_register_gen (regnum, buf); return; } - gdbarch_register_write (current_gdbarch, regnum, buf); + gdb_assert (regnum >= 0); + gdb_assert (regnum < current_regcache->descr->nr_cooked_registers); + if (regnum < current_regcache->descr->nr_raw_registers) + regcache_raw_write (current_regcache, regnum, buf); + else + gdbarch_register_write (current_gdbarch, regnum, buf); } /* Copy INLEN bytes of consecutive data from memory at MYADDR |