/* Cache and manage the values of registers for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
- 2002, 2004, 2007 Free Software Foundation, Inc.
+ 2002, 2004, 2007, 2008 Free Software Foundation, Inc.
This file is part of GDB.
/* 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 = gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch);
- descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (current_gdbarch)
+ descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch);
+ descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (gdbarch)
+ gdbarch_num_pseudo_regs
- (current_gdbarch);
+ (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 = gdbarch_num_regs (current_gdbarch);
+ descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
/* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
array. This pretects GDB from erant code that accesses elements
struct regcache_descr *descr = regcache_descr (gdbarch);
int size;
gdb_assert (regnum >= 0
- && regnum < (gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch)));
+ && regnum < (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)));
size = descr->sizeof_register[regnum];
return size;
}
registers_changed ();
}
+/* Update global variables old ptids to hold NEW_PTID if they were
+ holding OLD_PTID. */
+static void
+regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
+{
+ if (current_regcache != NULL
+ && ptid_equal (current_regcache->ptid, old_ptid))
+ current_regcache->ptid = new_ptid;
+}
+
/* Low level examining and depositing of registers.
The caller is responsible for making sure that the inferior is
regcache_xfree (current_regcache);
current_regcache = NULL;
+ /* Need to forget about any frames we have cached, too. */
+ reinit_frame_cache ();
+
/* Force cleanup of any alloca areas if using C alloca instead of
a builtin alloca. This particular call is used to clean up
areas allocated by low level target code which may build up
/* 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 (gdbarch_cannot_store_register (current_gdbarch, regnum))
+ if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
return;
/* If we have a valid copy of the register, and new value == old
regcache_cooked_read, regcache_cooked_write);
}
-/* Hack to keep code that view the register buffer as raw bytes
- working. */
-
-int
-register_offset_hack (struct gdbarch *gdbarch, int regnum)
-{
- struct regcache_descr *descr = regcache_descr (gdbarch);
- gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
- return descr->register_offset[regnum];
-}
-
-
/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
void
}
-/* read_pc, write_pc, etc. Special handling for register PC. */
-
-/* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
- read_sp(), 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. */
-
-/* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
- write_pc_pid() and write_pc(), all need to be replaced by something
- that does not rely on global state. But what? */
+/* Special handling for register PC. */
CORE_ADDR
-read_pc_pid (ptid_t ptid)
+regcache_read_pc (struct regcache *regcache)
{
- struct regcache *regcache = get_thread_regcache (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
CORE_ADDR pc_val;
if (gdbarch_read_pc_p (gdbarch))
pc_val = gdbarch_read_pc (gdbarch, regcache);
/* Else use per-frame method on get_current_frame. */
- else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
+ else if (gdbarch_pc_regnum (gdbarch) >= 0)
{
ULONGEST raw_val;
regcache_cooked_read_unsigned (regcache,
- gdbarch_pc_regnum (current_gdbarch),
+ gdbarch_pc_regnum (gdbarch),
&raw_val);
- pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
+ pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
}
else
- internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
-
+ internal_error (__FILE__, __LINE__,
+ _("regcache_read_pc: Unable to find PC"));
return pc_val;
}
CORE_ADDR
read_pc (void)
{
- return read_pc_pid (inferior_ptid);
+ return regcache_read_pc (get_current_regcache ());
}
void
-write_pc_pid (CORE_ADDR pc, ptid_t ptid)
+regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- struct regcache *regcache = get_thread_regcache (ptid);
struct gdbarch *gdbarch = get_regcache_arch (regcache);
if (gdbarch_write_pc_p (gdbarch))
gdbarch_write_pc (gdbarch, regcache, pc);
- else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
+ else if (gdbarch_pc_regnum (gdbarch) >= 0)
regcache_cooked_write_unsigned (regcache,
- gdbarch_pc_regnum (current_gdbarch), pc);
+ gdbarch_pc_regnum (gdbarch), pc);
else
internal_error (__FILE__, __LINE__,
- _("write_pc_pid: Unable to update PC"));
+ _("regcache_write_pc: Unable to update PC"));
}
void
write_pc (CORE_ADDR pc)
{
- write_pc_pid (pc, inferior_ptid);
+ regcache_write_pc (get_current_regcache (), pc);
}
fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
regcache->descr->sizeof_raw_register_valid_p);
fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
- gdbarch_num_regs (current_gdbarch));
+ gdbarch_num_regs (gdbarch));
fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
- gdbarch_num_pseudo_regs (current_gdbarch));
+ gdbarch_num_pseudo_regs (gdbarch));
#endif
gdb_assert (regcache->descr->nr_cooked_registers
- == (gdbarch_num_regs (current_gdbarch)
- + gdbarch_num_pseudo_regs (current_gdbarch)));
+ == (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)));
for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
{
fprintf_unfiltered (file, " %-10s", "Name");
else
{
- const char *p = gdbarch_register_name (current_gdbarch, regnum);
+ const char *p = gdbarch_register_name (gdbarch, regnum);
if (p == NULL)
p = "";
else if (p[0] == '\0')
/* Relative number. */
if (regnum < 0)
fprintf_unfiltered (file, " %4s", "Rel");
- else if (regnum < gdbarch_num_regs (current_gdbarch))
+ else if (regnum < gdbarch_num_regs (gdbarch))
fprintf_unfiltered (file, " %4d", regnum);
else
fprintf_unfiltered (file, " %4d",
- (regnum - gdbarch_num_regs (current_gdbarch)));
+ (regnum - gdbarch_num_regs (gdbarch)));
/* Offset. */
if (regnum < 0)
regcache_raw_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x");
dump_endian_bytes (file,
- gdbarch_byte_order (current_gdbarch), buf,
+ gdbarch_byte_order (gdbarch), buf,
regcache->descr->sizeof_register[regnum]);
}
}
regcache_cooked_read (regcache, regnum, buf);
fprintf_unfiltered (file, "0x");
dump_endian_bytes (file,
- gdbarch_byte_order (current_gdbarch), buf,
+ gdbarch_byte_order (gdbarch), buf,
regcache->descr->sizeof_register[regnum]);
}
}
regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
observer_attach_target_changed (regcache_observer_target_changed);
+ observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
add_com ("flushregs", class_maintenance, reg_flush_command,
_("Force gdb to flush its register cache (maintainer command)"));