/* 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, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "inferior.h"
/* 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;
}
struct regcache
{
struct regcache_descr *descr;
+
+ /* The address space of this register cache (for registers where it
+ makes sense, like PC or SP). */
+ struct address_space *aspace;
+
/* The register buffers. A read-only register cache can hold the
full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
register cache can only hold [0 .. gdbarch_num_regs). */
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_xmalloc (struct gdbarch *gdbarch)
+regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
{
struct regcache_descr *descr;
struct regcache *regcache;
= XCALLOC (descr->sizeof_raw_registers, gdb_byte);
regcache->register_valid_p
= XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
+ regcache->aspace = aspace;
regcache->readonly_p = 1;
+ regcache->ptid = minus_one_ptid;
return regcache;
}
return regcache->descr->gdbarch;
}
+struct address_space *
+get_regcache_aspace (const struct regcache *regcache)
+{
+ return regcache->aspace;
+}
+
/* Return a pointer to register REGNUM's buffer cache. */
static gdb_byte *
{
int i;
gdb_byte *buf;
+
gdb_assert (src != NULL && dst != NULL);
gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
gdb_assert (src != dst);
gdb_assert (src->readonly_p || dst->readonly_p);
+
if (!src->readonly_p)
regcache_save (dst, do_cooked_read, src);
else if (!dst->readonly_p)
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);
+ newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
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);
+ newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
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;
/* 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_list
+{
+ struct regcache *regcache;
+ struct regcache_list *next;
+};
+
+static struct regcache_list *current_regcache;
+
+struct regcache *
+get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
+{
+ struct regcache_list *list;
+ struct regcache *new_regcache;
+
+ for (list = current_regcache; list; list = list->next)
+ if (ptid_equal (list->regcache->ptid, ptid)
+ && get_regcache_arch (list->regcache) == gdbarch)
+ return list->regcache;
+
+ new_regcache = regcache_xmalloc (gdbarch,
+ target_thread_address_space (ptid));
+ new_regcache->readonly_p = 0;
+ new_regcache->ptid = ptid;
+ gdb_assert (new_regcache->aspace != NULL);
+
+ list = xmalloc (sizeof (struct regcache_list));
+ list->regcache = new_regcache;
+ list->next = current_regcache;
+ current_regcache = list;
+
+ return new_regcache;
+}
+
+static ptid_t current_thread_ptid;
+static struct gdbarch *current_thread_arch;
+
+struct regcache *
+get_thread_regcache (ptid_t ptid)
+{
+ if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
+ {
+ current_thread_ptid = ptid;
+ current_thread_arch = target_thread_architecture (ptid);
+ }
+
+ return get_thread_arch_regcache (ptid, current_thread_arch);
+}
+
+struct regcache *
+get_current_regcache (void)
+{
+ return get_thread_regcache (inferior_ptid);
+}
-static ptid_t registers_ptid;
/* Observer for the target_changed event. */
-void
+static void
regcache_observer_target_changed (struct target_ops *target)
{
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)
+{
+ struct regcache_list *list;
+
+ for (list = current_regcache; list; list = list->next)
+ if (ptid_equal (list->regcache->ptid, old_ptid))
+ list->regcache->ptid = new_ptid;
+}
+
/* Low level examining and depositing of registers.
The caller is responsible for making sure that the inferior is
void
registers_changed (void)
{
- int i;
+ struct regcache_list *list, *next;
- registers_ptid = pid_to_ptid (-1);
+ for (list = current_regcache; list; list = next)
+ {
+ next = list->next;
+ regcache_xfree (list->regcache);
+ xfree (list);
+ }
+
+ current_regcache = NULL;
+
+ current_thread_ptid = null_ptid;
+ current_thread_arch = 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
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
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
regcache_raw_read (regcache, regnum, buf);
- (*val) = extract_signed_integer (buf,
- regcache->descr->sizeof_register[regnum]);
+ (*val) = extract_signed_integer
+ (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch));
}
void
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
regcache_raw_read (regcache, regnum, buf);
- (*val) = extract_unsigned_integer (buf,
- regcache->descr->sizeof_register[regnum]);
+ (*val) = extract_unsigned_integer
+ (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch));
}
void
gdb_assert (regcache != NULL);
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
- store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
+ store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch), val);
regcache_raw_write (regcache, regnum, buf);
}
gdb_assert (regcache != NULL);
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
- store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
+ store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch), val);
regcache_raw_write (regcache, regnum, buf);
}
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
regcache_cooked_read (regcache, regnum, buf);
- (*val) = extract_signed_integer (buf,
- regcache->descr->sizeof_register[regnum]);
+ (*val) = extract_signed_integer
+ (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch));
}
void
gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
regcache_cooked_read (regcache, regnum, buf);
- (*val) = extract_unsigned_integer (buf,
- regcache->descr->sizeof_register[regnum]);
+ (*val) = extract_unsigned_integer
+ (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch));
}
void
gdb_assert (regcache != NULL);
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
- store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
+ store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch), val);
regcache_cooked_write (regcache, regnum, buf);
}
gdb_assert (regcache != NULL);
gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
buf = alloca (regcache->descr->sizeof_register[regnum]);
- store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
+ store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
+ gdbarch_byte_order (regcache->descr->gdbarch), val);
regcache_cooked_write (regcache, regnum, buf);
}
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 (gdbarch_cannot_store_register (current_gdbarch, regnum))
+ if (gdbarch_cannot_store_register (get_regcache_arch (regcache), 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
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];
-}
-
-/* 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. */
void
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];
}
-/* 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)
{
- ptid_t saved_inferior_ptid;
- CORE_ADDR pc_val;
+ 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)
+ else if (gdbarch_pc_regnum (gdbarch) >= 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,
+ gdbarch_pc_regnum (gdbarch),
+ &raw_val);
+ pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
}
else
- internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
-
- inferior_ptid = saved_inferior_ptid;
+ 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);
-}
-
void
-generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
+regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
{
- if (PC_REGNUM >= 0)
- write_register_pid (PC_REGNUM, pc, 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 (gdbarch) >= 0)
+ regcache_cooked_write_unsigned (regcache,
+ gdbarch_pc_regnum (gdbarch), pc);
else
internal_error (__FILE__, __LINE__,
- _("generic_target_write_pc"));
-}
+ _("regcache_write_pc: Unable to update 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);
-
- inferior_ptid = saved_inferior_ptid;
-}
-
-void
-write_pc (CORE_ADDR pc)
-{
- write_pc_pid (pc, inferior_ptid);
+ /* Writing the PC (for instance, from "load") invalidates the
+ current frame. */
+ reinit_frame_cache ();
}
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)
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 = REGISTER_NAME (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_print (char *args, enum regcache_dump_what what_to_dump)
{
if (args == NULL)
- regcache_dump (current_regcache, gdb_stdout, what_to_dump);
+ regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
else
{
+ struct cleanup *cleanups;
struct ui_file *file = gdb_fopen (args, "w");
if (file == NULL)
perror_with_name (_("maintenance print architecture"));
- regcache_dump (current_regcache, file, what_to_dump);
- ui_file_delete (file);
+ cleanups = make_cleanup_ui_file_delete (file);
+ regcache_dump (get_current_regcache (), file, what_to_dump);
+ do_cleanups (cleanups);
}
}
_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);
+ 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)"));
- /* 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