/* 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_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
- descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
+ descr->nr_cooked_registers = gdbarch_num_regs (current_gdbarch)
+ + gdbarch_num_pseudo_regs (current_gdbarch);
+ descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (current_gdbarch)
+ + gdbarch_num_pseudo_regs
+ (current_gdbarch);
/* Fill in a table of register types. */
descr->register_type
/* Construct a strictly RAW register cache. Don't allow pseudo's
into the register cache. */
- descr->nr_raw_registers = NUM_REGS;
+ descr->nr_raw_registers = gdbarch_num_regs (current_gdbarch);
/* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
array. This pretects GDB from erant code that accesses elements
- of the global register_valid_p[] array in the range [NUM_REGS
- .. NUM_REGS + NUM_PSEUDO_REGS). */
+ of the global register_valid_p[] array in the range
+ [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs). */
descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
/* Lay out the register cache.
{
struct regcache_descr *descr = regcache_descr (gdbarch);
int size;
- gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
+ gdb_assert (regnum >= 0
+ && regnum < (gdbarch_num_regs (current_gdbarch)
+ + gdbarch_num_pseudo_regs (current_gdbarch)));
size = descr->sizeof_register[regnum];
return size;
}
{
struct regcache_descr *descr;
/* The register buffers. A read-only register cache can hold the
- full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
- register cache can only hold [0 .. NUM_REGS). */
+ full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
+ register cache can only hold [0 .. gdbarch_num_regs). */
gdb_byte *registers;
/* Register cache status:
register_valid_p[REG] == 0 if REG value is not in the cache
regcache_cpy(). The actual contents are determined by the
reggroup_save and reggroup_restore methods. */
int readonly_p;
+ /* If this is a read-write cache, which thread's registers is
+ it connected to? */
+ ptid_t ptid;
};
struct regcache *
regcache->register_valid_p
= XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
regcache->readonly_p = 1;
+ regcache->ptid = minus_one_ptid;
return regcache;
}
memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
/* Copy over any registers (identified by their membership in the
- save_reggroup) and mark them as valid. The full [0 .. NUM_REGS +
- NUM_PSEUDO_REGS) range is checked since some architectures need
+ save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
+ gdbarch_num_pseudo_regs) range is checked since some architectures need
to save/restore `cooked' registers that live in memory. */
for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
{
doesn't make much sense. */
gdb_assert (!dst->readonly_p);
/* Copy over any registers, being careful to only restore those that
- were both saved and need to be restored. The full [0 .. NUM_REGS
- + NUM_PSEUDO_REGS) range is checked since some architectures need
+ were both saved and need to be restored. The full [0 .. gdbarch_num_regs
+ + gdbarch_num_pseudo_regs) range is checked since some architectures need
to save/restore `cooked' registers that live in memory. */
for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
{
gdb_assert (src != NULL && dst != NULL);
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
/* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
- move of data into the current_regcache(). Doing this would be
+ move of data into the current regcache. Doing this would be
silly - it would mean that valid_p would be completely invalid. */
- gdb_assert (dst != current_regcache);
+ gdb_assert (dst->readonly_p);
memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
memcpy (dst->register_valid_p, src->register_valid_p,
dst->descr->sizeof_raw_register_valid_p);
regcache_dup (struct regcache *src)
{
struct regcache *newbuf;
- gdb_assert (current_regcache != NULL);
newbuf = regcache_xmalloc (src->descr->gdbarch);
regcache_cpy (newbuf, src);
return newbuf;
regcache_dup_no_passthrough (struct regcache *src)
{
struct regcache *newbuf;
- gdb_assert (current_regcache != NULL);
newbuf = regcache_xmalloc (src->descr->gdbarch);
regcache_cpy_no_passthrough (newbuf, src);
return newbuf;
/* 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. */
-struct regcache *current_regcache;
+static struct regcache *current_regcache;
/* 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. */
-/* The thread/process associated with the current set of registers. */
+struct regcache *get_thread_regcache (ptid_t ptid)
+{
+ /* NOTE: uweigand/2007-05-05: We need to detect the thread's
+ current architecture at this point. */
+ struct gdbarch *thread_gdbarch = current_gdbarch;
+
+ if (current_regcache && ptid_equal (current_regcache->ptid, ptid)
+ && get_regcache_arch (current_regcache) == thread_gdbarch)
+ return current_regcache;
+
+ if (current_regcache)
+ regcache_xfree (current_regcache);
+
+ current_regcache = regcache_xmalloc (thread_gdbarch);
+ current_regcache->readonly_p = 0;
+ current_regcache->ptid = ptid;
+
+ return current_regcache;
+}
+
+struct regcache *get_current_regcache (void)
+{
+ return get_thread_regcache (inferior_ptid);
+}
-static ptid_t registers_ptid;
/* Observer for the target_changed event. */
{
int i;
- registers_ptid = pid_to_ptid (-1);
+ regcache_xfree (current_regcache);
+ current_regcache = NULL;
/* Force cleanup of any alloca areas if using C alloca instead of
a builtin alloca. This particular call is used to clean up
during lengthy interactions between gdb and the target before
gdb gives control to the user (ie watchpoints). */
alloca (0);
-
- for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
- regcache_invalidate (current_regcache, i);
}
On the bright side, at least there is a regcache object. */
if (!regcache->readonly_p)
{
- gdb_assert (regcache == current_regcache);
- if (! ptid_equal (registers_ptid, inferior_ptid))
+ if (!regcache_valid_p (regcache, regnum))
{
- registers_changed ();
- registers_ptid = inferior_ptid;
+ struct cleanup *old_chain = save_inferior_ptid ();
+ inferior_ptid = regcache->ptid;
+ target_fetch_registers (regcache, regnum);
+ do_cleanups (old_chain);
}
- if (!regcache_valid_p (regcache, regnum))
- target_fetch_registers (regcache, regnum);
#if 0
/* FIXME: cagney/2004-08-07: At present a number of targets
forget (or didn't know that they needed) to set this leading to
regcache_raw_write (struct regcache *regcache, int regnum,
const gdb_byte *buf)
{
+ struct cleanup *old_chain;
+
gdb_assert (regcache != NULL && buf != NULL);
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
gdb_assert (!regcache->readonly_p);
/* 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 (regnum))
+ if (gdbarch_cannot_store_register (current_gdbarch, regnum))
return;
- /* Make certain that the correct cache is selected. */
- gdb_assert (regcache == current_regcache);
- if (! ptid_equal (registers_ptid, inferior_ptid))
- {
- registers_changed ();
- registers_ptid = inferior_ptid;
- }
-
/* If we have a valid copy of the register, and new value == old
value, then don't bother doing the actual store. */
if (regcache_valid_p (regcache, regnum)
regcache->descr->sizeof_register[regnum]) == 0))
return;
+ old_chain = save_inferior_ptid ();
+ inferior_ptid = regcache->ptid;
+
target_prepare_to_store (regcache);
memcpy (register_buffer (regcache, regnum), buf,
regcache->descr->sizeof_register[regnum]);
regcache->register_valid_p[regnum] = 1;
target_store_registers (regcache, regnum);
+
+ do_cleanups (old_chain);
}
void
return descr->register_offset[regnum];
}
-/* Return the contents of register REGNUM as an unsigned integer. */
-
-ULONGEST
-read_register (int regnum)
-{
- gdb_byte *buf = alloca (register_size (current_gdbarch, regnum));
- gdb_assert (current_regcache != NULL);
- gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
- regcache_cooked_read (current_regcache, regnum, buf);
- return (extract_unsigned_integer (buf, register_size (current_gdbarch, regnum)));
-}
-
-ULONGEST
-read_register_pid (int regnum, ptid_t ptid)
-{
- ptid_t save_ptid;
- int save_pid;
- CORE_ADDR retval;
-
- if (ptid_equal (ptid, inferior_ptid))
- return read_register (regnum);
-
- save_ptid = inferior_ptid;
-
- inferior_ptid = ptid;
-
- retval = read_register (regnum);
-
- inferior_ptid = save_ptid;
-
- return retval;
-}
-
-/* Store VALUE into the raw contents of register number REGNUM. */
-
-void
-write_register (int regnum, LONGEST val)
-{
- void *buf;
- int size;
- size = register_size (current_gdbarch, regnum);
- buf = alloca (size);
- store_signed_integer (buf, size, (LONGEST) val);
- gdb_assert (current_regcache != NULL);
- gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
- regcache_cooked_write (current_regcache, regnum, buf);
-}
-
-void
-write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
-{
- ptid_t save_ptid;
-
- if (ptid_equal (ptid, inferior_ptid))
- {
- write_register (regnum, val);
- return;
- }
-
- save_ptid = inferior_ptid;
-
- inferior_ptid = ptid;
-
- write_register (regnum, val);
-
- inferior_ptid = save_ptid;
-}
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
gdb_assert (!regcache->readonly_p);
- /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
- CURRENT_REGCACHE specially here. */
- if (regcache == current_regcache
- && !ptid_equal (registers_ptid, inferior_ptid))
- {
- registers_changed ();
- registers_ptid = inferior_ptid;
- }
-
regbuf = register_buffer (regcache, regnum);
size = regcache->descr->sizeof_register[regnum];
CORE_ADDR
read_pc_pid (ptid_t ptid)
{
- ptid_t saved_inferior_ptid;
- CORE_ADDR pc_val;
+ struct regcache *regcache = get_thread_regcache (ptid);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
- /* In case ptid != inferior_ptid. */
- saved_inferior_ptid = inferior_ptid;
- inferior_ptid = ptid;
+ CORE_ADDR pc_val;
- if (TARGET_READ_PC_P ())
- pc_val = TARGET_READ_PC (ptid);
+ if (gdbarch_read_pc_p (gdbarch))
+ pc_val = gdbarch_read_pc (gdbarch, regcache);
/* Else use per-frame method on get_current_frame. */
else if (PC_REGNUM >= 0)
{
- CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
- pc_val = ADDR_BITS_REMOVE (raw_val);
+ ULONGEST raw_val;
+ regcache_cooked_read_unsigned (regcache, PC_REGNUM, &raw_val);
+ pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
}
else
internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
- inferior_ptid = saved_inferior_ptid;
return pc_val;
}
return read_pc_pid (inferior_ptid);
}
-void
-generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
-{
- if (PC_REGNUM >= 0)
- write_register_pid (PC_REGNUM, pc, ptid);
- else
- internal_error (__FILE__, __LINE__,
- _("generic_target_write_pc"));
-}
-
void
write_pc_pid (CORE_ADDR pc, ptid_t ptid)
{
- ptid_t saved_inferior_ptid;
-
- /* In case ptid != inferior_ptid. */
- saved_inferior_ptid = inferior_ptid;
- inferior_ptid = ptid;
-
- TARGET_WRITE_PC (pc, ptid);
+ struct regcache *regcache = get_thread_regcache (ptid);
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
- inferior_ptid = saved_inferior_ptid;
+ if (gdbarch_write_pc_p (gdbarch))
+ gdbarch_write_pc (gdbarch, regcache, pc);
+ else if (PC_REGNUM >= 0)
+ regcache_cooked_write_unsigned (regcache, PC_REGNUM, pc);
+ else
+ internal_error (__FILE__, __LINE__,
+ _("write_pc_pid: Unable to update PC"));
}
void
printf_filtered (_("Register cache flushed.\n"));
}
-static void
-build_regcache (void)
-{
- current_regcache = regcache_xmalloc (current_gdbarch);
- current_regcache->readonly_p = 0;
-}
-
static void
dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
const unsigned char *buf, long len)
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, "NUM_REGS %d\n", NUM_REGS);
- fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
+ fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
+ gdbarch_num_regs (current_gdbarch));
+ fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
+ gdbarch_num_pseudo_regs (current_gdbarch));
#endif
gdb_assert (regcache->descr->nr_cooked_registers
- == (NUM_REGS + NUM_PSEUDO_REGS));
+ == (gdbarch_num_regs (current_gdbarch)
+ + gdbarch_num_pseudo_regs (current_gdbarch)));
for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
{
fprintf_unfiltered (file, " %-10s", "Name");
else
{
- const char *p = REGISTER_NAME (regnum);
+ const char *p = gdbarch_register_name (current_gdbarch, regnum);
if (p == NULL)
p = "";
else if (p[0] == '\0')
/* Relative number. */
if (regnum < 0)
fprintf_unfiltered (file, " %4s", "Rel");
- else if (regnum < NUM_REGS)
+ else if (regnum < gdbarch_num_regs (current_gdbarch))
fprintf_unfiltered (file, " %4d", regnum);
else
- fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
+ fprintf_unfiltered (file, " %4d",
+ (regnum - gdbarch_num_regs (current_gdbarch)));
/* Offset. */
if (regnum < 0)
_initialize_regcache (void)
{
regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
- DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
- deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
observer_attach_target_changed (regcache_observer_target_changed);
add_com ("flushregs", class_maintenance, reg_flush_command,
_("Force gdb to flush its register cache (maintainer command)"));
- /* Initialize the thread/process associated with the current set of
- registers. For now, -1 is special, and means `no current process'. */
- registers_ptid = pid_to_ptid (-1);
-
add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
Print the internal register configuration.\n\
Takes an optional file parameter."), &maintenanceprintlist);
projects / deliverable / binutils-gdb.git / blobdiff