for raw and pseudo registers and allow access to both. */
int legacy_p;
- /* The raw register cache. This should contain just [0
- .. NUM_RAW_REGISTERS). However, for older targets, it contains
- space for the full [0 .. NUM_RAW_REGISTERS +
- NUM_PSEUDO_REGISTERS). */
+ /* The raw register cache. Each raw (or hard) register is supplied
+ by the target interface. The raw cache should not contain
+ redundant information - if the PC is constructed from two
+ registers then those regigisters and not the PC lives in the raw
+ cache. */
int nr_raw_registers;
long sizeof_raw_registers;
long sizeof_raw_register_valid_p;
long *register_offset;
long *sizeof_register;
- /* Useful constant. Largest of all the registers. */
- long max_register_size;
-
/* Cached table containing the type of each register. */
struct type **register_type;
};
-void
+static void
init_legacy_regcache_descr (struct gdbarch *gdbarch,
struct regcache_descr *descr)
{
``gdbarch'' as a parameter. */
gdb_assert (gdbarch != NULL);
- /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
- in the register cache. Unfortunatly some architectures still
- rely on this and the pseudo_register_write() method. */
- descr->nr_raw_registers = descr->nr_cooked_registers;
- descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
-
/* Compute the offset of each register. Legacy architectures define
REGISTER_BYTE() so use that. */
/* FIXME: cagney/2002-11-07: Instead of using REGISTER_BYTE() this
offets at runtime. This currently isn't possible as some ISAs
define overlapping register regions - see the mess in
read_register_bytes() and write_register_bytes() registers. */
- descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
- descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
- descr->max_register_size = 0;
+ descr->sizeof_register
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
+ descr->register_offset
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
for (i = 0; i < descr->nr_cooked_registers; i++)
{
/* FIXME: cagney/2001-12-04: This code shouldn't need to use
entirely avoid this uglyness. */
descr->register_offset[i] = REGISTER_BYTE (i);
descr->sizeof_register[i] = REGISTER_RAW_SIZE (i);
- if (descr->max_register_size < REGISTER_RAW_SIZE (i))
- descr->max_register_size = REGISTER_RAW_SIZE (i);
- if (descr->max_register_size < REGISTER_VIRTUAL_SIZE (i))
- descr->max_register_size = REGISTER_VIRTUAL_SIZE (i);
+ gdb_assert (MAX_REGISTER_SIZE >= REGISTER_RAW_SIZE (i));
+ gdb_assert (MAX_REGISTER_SIZE >= REGISTER_VIRTUAL_SIZE (i));
}
/* Compute the real size of the register buffer. Start out by
- trusting REGISTER_BYTES, but then adjust it upwards should that
- be found to not be sufficient. */
- /* FIXME: cagney/2002-11-05: Instead of using REGISTER_BYTES, this
- code should, as is done in init_regcache_descr(), compute the
- total number of register bytes using the accumulated offsets. */
- descr->sizeof_cooked_registers = REGISTER_BYTES; /* OK use. */
+ trusting DEPRECATED_REGISTER_BYTES, but then adjust it upwards
+ should that be found to not be sufficient. */
+ /* FIXME: cagney/2002-11-05: Instead of using the macro
+ DEPRECATED_REGISTER_BYTES, this code should, as is done in
+ init_regcache_descr(), compute the total number of register bytes
+ using the accumulated offsets. */
+ descr->sizeof_cooked_registers = DEPRECATED_REGISTER_BYTES; /* OK */
for (i = 0; i < descr->nr_cooked_registers; i++)
{
long regend;
gdb_assert (gdbarch != NULL);
/* Create an initial, zero filled, table. */
- descr = XCALLOC (1, struct regcache_descr);
+ descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
descr->gdbarch = gdbarch;
/* Total size of the register space. The raw registers are mapped
descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
/* Fill in a table of register types. */
- descr->register_type = XCALLOC (descr->nr_cooked_registers,
- struct type *);
+ descr->register_type
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
for (i = 0; i < descr->nr_cooked_registers; i++)
{
if (gdbarch_register_type_p (gdbarch))
descr->register_type[i] = REGISTER_VIRTUAL_TYPE (i); /* OK */
}
- /* If an old style architecture, fill in the remainder of the
- register cache descriptor using the register macros. */
- if (!gdbarch_pseudo_register_read_p (gdbarch)
- && !gdbarch_pseudo_register_write_p (gdbarch)
- && !gdbarch_register_type_p (gdbarch))
- {
- descr->legacy_p = 1;
- init_legacy_regcache_descr (gdbarch, descr);
- return descr;
- }
-
/* Construct a strictly RAW register cache. Don't allow pseudo's
into the register cache. */
descr->nr_raw_registers = NUM_REGS;
.. NUM_REGS + NUM_PSEUDO_REGS). */
descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
+ /* If an old style architecture, fill in the remainder of the
+ register cache descriptor using the register macros. */
+ /* NOTE: cagney/2003-06-29: If either of REGISTER_BYTE or
+ REGISTER_RAW_SIZE are still present, things are most likely
+ totally screwed. Ex: an architecture with raw register sizes
+ smaller than what REGISTER_BYTE indicates; non monotonic
+ REGISTER_BYTE values. For GDB 6 check for these nasty methods
+ and fall back to legacy code when present. Sigh! */
+ if ((!gdbarch_pseudo_register_read_p (gdbarch)
+ && !gdbarch_pseudo_register_write_p (gdbarch)
+ && !gdbarch_register_type_p (gdbarch))
+ || REGISTER_BYTE_P () || REGISTER_RAW_SIZE_P ())
+ {
+ descr->legacy_p = 1;
+ init_legacy_regcache_descr (gdbarch, descr);
+ return descr;
+ }
+
/* Lay out the register cache.
NOTE: cagney/2002-05-22: Only register_type() is used when
{
long offset = 0;
- descr->sizeof_register = XCALLOC (descr->nr_cooked_registers, long);
- descr->register_offset = XCALLOC (descr->nr_cooked_registers, long);
- descr->max_register_size = 0;
+ descr->sizeof_register
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
+ descr->register_offset
+ = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
for (i = 0; i < descr->nr_cooked_registers; i++)
{
descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
descr->register_offset[i] = offset;
offset += descr->sizeof_register[i];
- if (descr->max_register_size < descr->sizeof_register[i])
- descr->max_register_size = descr->sizeof_register[i];
+ gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
}
/* Set the real size of the register cache buffer. */
descr->sizeof_cooked_registers = offset;
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));
- }
- /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i)); */
#endif
+ }
+ /* gdb_assert (descr->sizeof_raw_registers == DEPRECATED_REGISTER_BYTES (i)); */
return descr;
}
return gdbarch_data (gdbarch, regcache_descr_handle);
}
-static void
-xfree_regcache_descr (struct gdbarch *gdbarch, void *ptr)
-{
- struct regcache_descr *descr = ptr;
- if (descr == NULL)
- return;
- xfree (descr->register_offset);
- xfree (descr->sizeof_register);
- descr->register_offset = NULL;
- descr->sizeof_register = NULL;
- xfree (descr);
-}
-
/* Utility functions returning useful register attributes stored in
the regcache descr. */
/* Utility functions returning useful register attributes stored in
the regcache descr. */
-int
-max_register_size (struct gdbarch *gdbarch)
-{
- struct regcache_descr *descr = regcache_descr (gdbarch);
- return descr->max_register_size;
-}
-
-int
-legacy_max_register_raw_size (void)
-{
- if (DEPRECATED_MAX_REGISTER_RAW_SIZE_P ())
- return DEPRECATED_MAX_REGISTER_RAW_SIZE;
- else
- return max_register_size (current_gdbarch);
-}
-
-int
-legacy_max_register_virtual_size (void)
-{
- if (DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE_P ())
- return DEPRECATED_MAX_REGISTER_VIRTUAL_SIZE;
- else
- return max_register_size (current_gdbarch);
-}
-
int
register_size (struct gdbarch *gdbarch, int regnum)
{
int size;
gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
size = descr->sizeof_register[regnum];
+ /* NB: The deprecated REGISTER_RAW_SIZE, if not provided, defaults
+ to the size of the register's type. */
gdb_assert (size == REGISTER_RAW_SIZE (regnum)); /* OK */
- gdb_assert (size == REGISTER_RAW_SIZE (regnum)); /* OK */
+ /* NB: Don't check the register's virtual size. It, in say the case
+ of the MIPS, may not match the raw size! */
return size;
}
xfree (regcache);
}
-void
+static void
do_regcache_xfree (void *data)
{
regcache_xfree (data);
void *src)
{
struct gdbarch *gdbarch = dst->descr->gdbarch;
- void *buf = alloca (max_register_size (gdbarch));
+ char buf[MAX_REGISTER_SIZE];
int regnum;
/* The DST should be `read-only', if it wasn't then the save would
end up trying to write the register values back out to the
void *src)
{
struct gdbarch *gdbarch = dst->descr->gdbarch;
- void *buf = alloca (max_register_size (gdbarch));
+ char buf[MAX_REGISTER_SIZE];
int regnum;
/* The dst had better not be read-only. If it is, the `restore'
doesn't make much sense. */
do_cooked_read (void *src, int regnum, void *buf)
{
struct regcache *regcache = src;
- if (!regcache_valid_p (regcache, regnum)
- && regcache->readonly_p)
+ if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
/* Don't even think about fetching a register from a read-only
cache when the register isn't yet valid. There isn't a target
from which the register value can be fetched. */
return regcache->registers;
}
-char *
-deprecated_grub_regcache_for_register_valid (struct regcache *regcache)
-{
- return regcache->register_valid_p;
-}
-
/* Global structure containing the current regcache. */
/* FIXME: cagney/2002-05-11: The two global arrays registers[] and
deprecated_register_valid[] currently point into this structure. */
{
int in_end = in_start + in_len;
int regnum;
- char *reg_buf = alloca (MAX_REGISTER_RAW_SIZE);
+ char reg_buf[MAX_REGISTER_SIZE];
/* See if we are trying to read bytes from out-of-date registers. If so,
update just those registers. */
/* The register partially overlaps the range being written. */
else
{
- char *regbuf = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+ char regbuf[MAX_REGISTER_SIZE];
/* What's the overlap between this register's bytes and
those the caller wants to write? */
int overlapstart = max (regstart, myregstart);
typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
const void *buf);
-void
+static void
regcache_xfer_part (struct regcache *regcache, int regnum,
int offset, int len, void *in, const void *out,
regcache_read_ftype *read, regcache_write_ftype *write)
{
struct regcache_descr *descr = regcache->descr;
- bfd_byte *reg = alloca (descr->max_register_size);
+ bfd_byte reg[MAX_REGISTER_SIZE];
gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
/* Something to do? */
return retval;
}
-/* Return the contents of register REGNUM as a signed integer. */
-
-LONGEST
-read_signed_register (int regnum)
-{
- void *buf = alloca (REGISTER_RAW_SIZE (regnum));
- deprecated_read_register_gen (regnum, buf);
- return (extract_signed_integer (buf, REGISTER_RAW_SIZE (regnum)));
-}
-
-LONGEST
-read_signed_register_pid (int regnum, ptid_t ptid)
-{
- ptid_t save_ptid;
- LONGEST retval;
-
- if (ptid_equal (ptid, inferior_ptid))
- return read_signed_register (regnum);
-
- save_ptid = inferior_ptid;
-
- inferior_ptid = ptid;
-
- retval = read_signed_register (regnum);
-
- inferior_ptid = save_ptid;
-
- return retval;
-}
-
/* Store VALUE into the raw contents of register number REGNUM. */
void
}
-/* read_pc, write_pc, read_sp, write_sp, read_fp, etc. Special
+/* read_pc, write_pc, read_sp, deprecated_read_fp, etc. Special
handling for registers PC, SP, and FP. */
-/* NOTE: cagney/2001-02-18: The functions generic_target_read_pc(),
- read_pc_pid(), read_pc(), generic_target_write_pc(),
- write_pc_pid(), write_pc(), generic_target_read_sp(), read_sp(),
- generic_target_write_sp(), write_sp(), generic_target_read_fp() and
- read_fp(), will eventually be moved out of the reg-cache into
- either frame.[hc] or to the multi-arch framework. The are not part
- of the raw register cache. */
-
-/* This routine is getting awfully cluttered with #if's. It's probably
- time to turn this into READ_PC and define it in the tm.h file.
- Ditto for write_pc.
+/* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(),
+ read_sp(), and deprecated_read_fp(), will eventually be replaced by
+ per-frame methods. Instead of relying on the global INFERIOR_PTID,
+ they will use the contextual information provided by the FRAME.
+ These functions do not belong in the register cache. */
- 1999-06-08: The following were re-written so that it assumes the
- existence of a TARGET_READ_PC et.al. macro. A default generic
- version of that macro is made available where needed.
-
- Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
- by the multi-arch framework, it will eventually be possible to
- eliminate the intermediate read_pc_pid(). The client would call
- TARGET_READ_PC directly. (cagney). */
-
-CORE_ADDR
-generic_target_read_pc (ptid_t ptid)
-{
-#ifdef PC_REGNUM
- if (PC_REGNUM >= 0)
- {
- CORE_ADDR pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, ptid));
- return pc_val;
- }
-#endif
- internal_error (__FILE__, __LINE__,
- "generic_target_read_pc");
- return 0;
-}
+/* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
+ write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to
+ be replaced by something that does not rely on global state. But
+ what? */
CORE_ADDR
read_pc_pid (ptid_t ptid)
saved_inferior_ptid = inferior_ptid;
inferior_ptid = ptid;
- pc_val = TARGET_READ_PC (ptid);
+ if (TARGET_READ_PC_P ())
+ pc_val = TARGET_READ_PC (ptid);
+ /* Else use per-frame method on get_current_frame. */
+ else if (PC_REGNUM >= 0)
+ {
+ CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
+ CORE_ADDR pc_val = ADDR_BITS_REMOVE (raw_val);
+ return pc_val;
+ }
+ else
+ internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
inferior_ptid = saved_inferior_ptid;
return pc_val;
/* Cope with strage ways of getting to the stack and frame pointers */
-CORE_ADDR
-generic_target_read_sp (void)
-{
-#ifdef SP_REGNUM
- if (SP_REGNUM >= 0)
- return read_register (SP_REGNUM);
-#endif
- internal_error (__FILE__, __LINE__,
- "generic_target_read_sp");
-}
-
CORE_ADDR
read_sp (void)
{
- return TARGET_READ_SP ();
-}
-
-void
-generic_target_write_sp (CORE_ADDR val)
-{
-#ifdef SP_REGNUM
- if (SP_REGNUM >= 0)
- {
- write_register (SP_REGNUM, val);
- return;
- }
-#endif
- internal_error (__FILE__, __LINE__,
- "generic_target_write_sp");
+ if (TARGET_READ_SP_P ())
+ return TARGET_READ_SP ();
+ else if (gdbarch_unwind_sp_p (current_gdbarch))
+ return get_frame_sp (get_current_frame ());
+ else if (SP_REGNUM >= 0)
+ /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
+ about the architecture so put it at the end. */
+ return read_register (SP_REGNUM);
+ internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
}
void
-write_sp (CORE_ADDR val)
+deprecated_write_sp (CORE_ADDR val)
{
- TARGET_WRITE_SP (val);
+ gdb_assert (SP_REGNUM >= 0);
+ write_register (SP_REGNUM, val);
}
CORE_ADDR
-generic_target_read_fp (void)
+deprecated_read_fp (void)
{
-#ifdef FP_REGNUM
- if (FP_REGNUM >= 0)
- return read_register (FP_REGNUM);
-#endif
- internal_error (__FILE__, __LINE__,
- "generic_target_read_fp");
-}
-
-CORE_ADDR
-read_fp (void)
-{
- return TARGET_READ_FP ();
+ if (DEPRECATED_TARGET_READ_FP_P ())
+ return DEPRECATED_TARGET_READ_FP ();
+ else if (DEPRECATED_FP_REGNUM >= 0)
+ return read_register (DEPRECATED_FP_REGNUM);
+ else
+ internal_error (__FILE__, __LINE__, "deprecated_read_fp");
}
/* ARGSUSED */
current_regcache = regcache_xmalloc (current_gdbarch);
current_regcache->readonly_p = 0;
deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
- deprecated_register_valid = deprecated_grub_regcache_for_register_valid (current_regcache);
+ deprecated_register_valid = current_regcache->register_valid_p;
}
static void
{
struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
struct gdbarch *gdbarch = regcache->descr->gdbarch;
- struct reggroup *const *groups = reggroups (gdbarch);
int regnum;
int footnote_nr = 0;
int footnote_register_size = 0;
int footnote_register_offset = 0;
int footnote_register_type_name_null = 0;
long register_offset = 0;
- unsigned char *buf = alloca (regcache->descr->max_register_size);
+ unsigned char buf[MAX_REGISTER_SIZE];
#if 0
fprintf_unfiltered (file, "legacy_p %d\n", regcache->descr->legacy_p);
regcache->descr->sizeof_raw_registers);
fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
regcache->descr->sizeof_raw_register_valid_p);
- fprintf_unfiltered (file, "max_register_size %ld\n",
- regcache->descr->max_register_size);
fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
#endif
fprintf_unfiltered (file, "Groups");
else
{
- int i;
const char *sep = "";
- for (i = 0; groups[i] != NULL; i++)
+ struct reggroup *group;
+ for (group = reggroup_next (gdbarch, NULL);
+ group != NULL;
+ group = reggroup_next (gdbarch, group))
{
- if (gdbarch_register_reggroup_p (gdbarch, regnum, groups[i]))
+ if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
{
- fprintf_unfiltered (file, "%s%s", sep, reggroup_name (groups[i]));
+ fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
sep = ",";
}
}
regcache_print (args, regcache_dump_groups);
}
+extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
+
void
_initialize_regcache (void)
{
- regcache_descr_handle = register_gdbarch_data (init_regcache_descr,
- xfree_regcache_descr);
+ regcache_descr_handle = register_gdbarch_data (init_regcache_descr);
REGISTER_GDBARCH_SWAP (current_regcache);
register_gdbarch_swap (&deprecated_registers, sizeof (deprecated_registers), NULL);
register_gdbarch_swap (&deprecated_register_valid, sizeof (deprecated_register_valid), NULL);
projects / deliverable / binutils-gdb.git / blobdiff