From 46654a5bcc3430a7219b2a8430578b4a5473214c Mon Sep 17 00:00:00 2001 From: Andrew Cagney Date: Sun, 4 May 2003 17:34:51 +0000 Subject: [PATCH] 2003-05-02 Andrew Cagney * sentinel-frame.c (sentinel_frame_prev_register): Replace REGISTER_BYTE with register_offset_hack. * regcache.c (init_regcache_descr): When REGISTER_BYTE_P, check that REGISTER_BYTE is consistent with the regcache. * gdbarch.sh (REGISTER_BYTE): Add a predicate. * gdbarch.h, gdbarch.c: Regenerate. --- gdb/ChangeLog | 9 +++++++++ gdb/gdbarch.c | 19 ++++++++++++++++++- gdb/gdbarch.h | 26 ++++++++++++++++++++++++++ gdb/gdbarch.sh | 7 ++++++- gdb/regcache.c | 22 +++++++++++++--------- gdb/sentinel-frame.c | 2 +- 6 files changed, 73 insertions(+), 12 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 14dfacc97e5..9de8f01673a 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,12 @@ +2003-05-04 Andrew Cagney + + * sentinel-frame.c (sentinel_frame_prev_register): Replace + REGISTER_BYTE with register_offset_hack. + * regcache.c (init_regcache_descr): When REGISTER_BYTE_P, check + that REGISTER_BYTE is consistent with the regcache. + * gdbarch.sh (REGISTER_BYTE): Add a predicate. + * gdbarch.h, gdbarch.c: Regenerate. + 2003-05-04 Mark Kettenis * i387-tdep.c (fxsave_offset): Add entries for %xmm8-%xmm15. diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c index f4058ff67ab..7bfd06a013b 100644 --- a/gdb/gdbarch.c +++ b/gdb/gdbarch.c @@ -643,7 +643,7 @@ verify_gdbarch (struct gdbarch *gdbarch) /* Skip verify of sdb_reg_to_regnum, invalid_p == 0 */ /* Skip verify of dwarf2_reg_to_regnum, invalid_p == 0 */ /* Skip verify of register_name, invalid_p == 0 */ - /* Skip verify of register_byte, invalid_p == 0 */ + /* Skip verify of register_byte, has predicate */ /* Skip verify of register_raw_size, invalid_p == 0 */ /* Skip verify of deprecated_max_register_raw_size, has predicate */ /* Skip verify of register_virtual_size, invalid_p == 0 */ @@ -1975,6 +1975,15 @@ gdbarch_dump (struct gdbarch *gdbarch, struct ui_file *file) fprintf_unfiltered (file, "gdbarch_dump: push_dummy_code = 0x%08lx\n", (long) current_gdbarch->push_dummy_code); +#ifdef REGISTER_BYTE_P + fprintf_unfiltered (file, + "gdbarch_dump: %s # %s\n", + "REGISTER_BYTE_P()", + XSTRING (REGISTER_BYTE_P ())); + fprintf_unfiltered (file, + "gdbarch_dump: REGISTER_BYTE_P() = %d\n", + REGISTER_BYTE_P ()); +#endif #ifdef REGISTER_BYTE fprintf_unfiltered (file, "gdbarch_dump: %s # %s\n", @@ -3317,6 +3326,13 @@ set_gdbarch_register_bytes (struct gdbarch *gdbarch, gdbarch->register_bytes = register_bytes; } +int +gdbarch_register_byte_p (struct gdbarch *gdbarch) +{ + gdb_assert (gdbarch != NULL); + return gdbarch->register_byte != generic_register_byte; +} + int gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr) { @@ -3324,6 +3340,7 @@ gdbarch_register_byte (struct gdbarch *gdbarch, int reg_nr) if (gdbarch->register_byte == 0) internal_error (__FILE__, __LINE__, "gdbarch: gdbarch_register_byte invalid"); + /* Ignore predicate (gdbarch->register_byte != generic_register_byte). */ if (gdbarch_debug >= 2) fprintf_unfiltered (gdb_stdlog, "gdbarch_register_byte called\n"); return gdbarch->register_byte (reg_nr); diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h index f00cc34a360..7cbb19cb72a 100644 --- a/gdb/gdbarch.h +++ b/gdb/gdbarch.h @@ -739,6 +739,32 @@ extern void set_gdbarch_register_bytes (struct gdbarch *gdbarch, int register_by #define REGISTER_BYTES (gdbarch_register_bytes (current_gdbarch)) #endif +/* NOTE: cagney/2002-05-02: This function with predicate has a valid + (callable) initial value. As a consequence, even when the predicate + is false, the corresponding function works. This simplifies the + migration process - old code, calling REGISTER_BYTE, doesn't need to + be modified. */ + +#if defined (REGISTER_BYTE) +/* Legacy for systems yet to multi-arch REGISTER_BYTE */ +#if !defined (REGISTER_BYTE_P) +#define REGISTER_BYTE_P() (1) +#endif +#endif + +/* Default predicate for non- multi-arch targets. */ +#if (!GDB_MULTI_ARCH) && !defined (REGISTER_BYTE_P) +#define REGISTER_BYTE_P() (0) +#endif + +extern int gdbarch_register_byte_p (struct gdbarch *gdbarch); +#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) && defined (REGISTER_BYTE_P) +#error "Non multi-arch definition of REGISTER_BYTE" +#endif +#if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) || !defined (REGISTER_BYTE_P) +#define REGISTER_BYTE_P() (gdbarch_register_byte_p (current_gdbarch)) +#endif + /* Default (function) for non- multi-arch platforms. */ #if (!GDB_MULTI_ARCH) && !defined (REGISTER_BYTE) #define REGISTER_BYTE(reg_nr) (generic_register_byte (reg_nr)) diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh index 37e61b0e4ee..8fa98dfc6bc 100755 --- a/gdb/gdbarch.sh +++ b/gdb/gdbarch.sh @@ -474,7 +474,12 @@ f:2:DWARF2_REG_TO_REGNUM:int:dwarf2_reg_to_regnum:int dwarf2_regnr:dwarf2_regnr: f:2:REGISTER_NAME:const char *:register_name:int regnr:regnr:::legacy_register_name::0 v::REGISTER_SIZE:int:register_size v::REGISTER_BYTES:int:register_bytes -f:2:REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte::0 +# NOTE: cagney/2002-05-02: This function with predicate has a valid +# (callable) initial value. As a consequence, even when the predicate +# is false, the corresponding function works. This simplifies the +# migration process - old code, calling REGISTER_BYTE, doesn't need to +# be modified. +F::REGISTER_BYTE:int:register_byte:int reg_nr:reg_nr::generic_register_byte:generic_register_byte # The methods REGISTER_VIRTUAL_TYPE, MAX_REGISTER_RAW_SIZE, # MAX_REGISTER_VIRTUAL_SIZE, MAX_REGISTER_RAW_SIZE, # REGISTER_VIRTUAL_SIZE and REGISTER_RAW_SIZE are all being replaced diff --git a/gdb/regcache.c b/gdb/regcache.c index e0a0b89336b..5bfe9581501 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -187,6 +187,12 @@ init_regcache_descr (struct gdbarch *gdbarch) && !gdbarch_pseudo_register_write_p (gdbarch) && !gdbarch_register_type_p (gdbarch)) { + /* NOTE: cagney/2003-05-02: Don't add a test for REGISTER_BYTE_P + to the above. Doing that would cause all the existing + architectures to revert back to the legacy regcache + mechanisms, and that is not a good thing. Instead just, + later, check that the register cache's layout is consistent + with REGISTER_BYTE. */ descr->legacy_p = 1; init_legacy_regcache_descr (gdbarch, descr); return descr; @@ -233,21 +239,19 @@ init_regcache_descr (struct gdbarch *gdbarch) buffer. Ulgh! */ descr->sizeof_raw_registers = descr->sizeof_cooked_registers; -#if 0 - /* Sanity check. Confirm that the assumptions about gdbarch are - true. The REGCACHE_DESCR_HANDLE is set before doing the checks - so that targets using the generic methods supplied by regcache - don't go into infinite recursion trying to, again, create the - regcache. */ - set_gdbarch_data (gdbarch, regcache_descr_handle, descr); + /* Sanity check. Confirm that there is agreement between the + regcache and the target's redundant REGISTER_BYTE (new targets + should not even be defining it). */ for (i = 0; i < descr->nr_cooked_registers; i++) { + if (REGISTER_BYTE_P ()) + gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i)); +#if 0 gdb_assert (descr->sizeof_register[i] == REGISTER_RAW_SIZE (i)); gdb_assert (descr->sizeof_register[i] == REGISTER_VIRTUAL_SIZE (i)); - gdb_assert (descr->register_offset[i] == REGISTER_BYTE (i)); +#endif } /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i)); */ -#endif return descr; } diff --git a/gdb/sentinel-frame.c b/gdb/sentinel-frame.c index dab16478413..dcc583ec98e 100644 --- a/gdb/sentinel-frame.c +++ b/gdb/sentinel-frame.c @@ -56,7 +56,7 @@ sentinel_frame_prev_register (struct frame_info *next_frame, onto the corresponding hardware register. */ *optimized = 0; *lvalp = lval_register; - *addrp = REGISTER_BYTE (regnum); + *addrp = register_offset_hack (current_gdbarch, regnum); *realnum = regnum; /* If needed, find and return the value of the register. */ -- 2.30.2