cris: Check UNDEFWEAK_NO_DYNAMIC_RELOC

[deliverable/binutils-gdb.git] / gdb / regcache.h

diff --git a/gdb/regcache.h b/gdb/regcache.h
index da00abd9f902805a126aaeae764f4031ad9e43ad..6f42fb93769168ee8ab96cf971917ef17ca0e2c8 100644 (file)
--- a/gdb/regcache.h
+++ b/gdb/regcache.h
@@ -21,6 +21,7 @@
 #define REGCACHE_H
 
 #include "common-regcache.h"
+#include <forward_list>
 
 struct regcache;
 struct regset;
@@ -34,11 +35,6 @@ extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
                                                         struct gdbarch *,
                                                         struct address_space *);
 
-void regcache_xfree (struct regcache *regcache);
-struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
-struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
-                                  struct address_space *aspace);
-
 /* Return REGCACHE's ptid.  */
 
 extern ptid_t regcache_get_ptid (const struct regcache *regcache);
@@ -83,7 +79,7 @@ extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
 /* Set a raw register's value in the regcache's buffer.  Unlike
    regcache_raw_write, this is not write-through.  The intention is
    allowing to change the buffer contents of a read-only regcache
-   allocated with regcache_xmalloc.  */
+   allocated with new.  */
 
 extern void regcache_raw_set_cached_value
   (struct regcache *regcache, int regnum, const gdb_byte *buf);
@@ -231,6 +227,14 @@ enum regcache_dump_what
   regcache_dump_remote
 };
 
+/* A (register_number, register_value) pair.  */
+
+typedef struct cached_reg
+{
+  int num;
+  gdb_byte *data;
+} cached_reg_t;
+
 /* The register cache for storing raw register values.  */
 
 class regcache
@@ -246,8 +250,7 @@ public:
   /* Create a readonly regcache from a non-readonly regcache.  */
   regcache (readonly_t, const regcache &src);
 
-  regcache (const regcache &) = delete;
-  void operator= (const regcache &) = delete;
+  DISABLE_COPY_AND_ASSIGN (regcache);
 
   ~regcache ()
   {
@@ -268,32 +271,35 @@ public:
   void cooked_write (int regnum, const gdb_byte *buf);
 
   enum register_status raw_read (int regnum, gdb_byte *buf);
-  void raw_write (int regnum, const gdb_byte *buf);
 
-  enum register_status raw_read_signed (int regnum, LONGEST *val);
-
-  void raw_write_signed (int regnum, LONGEST val);
+  void raw_write (int regnum, const gdb_byte *buf);
 
-  enum register_status raw_read_unsigned (int regnum, ULONGEST *val);
+  template<typename T, typename = RequireLongest<T>>
+  enum register_status raw_read (int regnum, T *val);
 
-  void raw_write_unsigned (int regnum, ULONGEST val);
+  template<typename T, typename = RequireLongest<T>>
+  void raw_write (int regnum, T val);
 
   struct value *cooked_read_value (int regnum);
 
-  enum register_status cooked_read_signed (int regnum, LONGEST *val);
-
-  void cooked_write_signed (int regnum, LONGEST val);
+  template<typename T, typename = RequireLongest<T>>
+  enum register_status cooked_read (int regnum, T *val);
 
-  enum register_status cooked_read_unsigned (int regnum, ULONGEST *val);
-
-  void cooked_write_unsigned (int regnum, ULONGEST val);
+  template<typename T, typename = RequireLongest<T>>
+  void cooked_write (int regnum, T val);
 
   void raw_update (int regnum);
 
   void raw_collect (int regnum, void *buf) const;
 
+  void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
+                           bool is_signed) const;
+
   void raw_supply (int regnum, const void *buf);
 
+  void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
+                          bool is_signed);
+
   void raw_supply_zeroed (int regnum);
 
   enum register_status get_register_status (int regnum) const;
@@ -336,15 +342,17 @@ public:
    debug.  */
   void debug_print_register (const char *func, int regno);
 
-private:
+  static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid);
+protected:
   regcache (gdbarch *gdbarch, address_space *aspace_, bool readonly_p_);
 
+  static std::forward_list<regcache *> current_regcache;
+
+private:
   gdb_byte *register_buffer (int regnum) const;
 
   void restore (struct regcache *src);
 
-  void cpy_no_passthrough (struct regcache *src);
-
   enum register_status xfer_part (int regnum, int offset, int len, void *in,
                                  const void *out,
                                  decltype (regcache_raw_read) read,
@@ -382,17 +390,19 @@ private:
   get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
                                   struct address_space *aspace);
 
+  friend void
+  registers_changed_ptid (ptid_t ptid);
+
   friend void
   regcache_cpy (struct regcache *dst, struct regcache *src);
 };
 
-/* Copy/duplicate the contents of a register cache.  By default, the
-   operation is pass-through.  Writes to DST and reads from SRC will
-   go through to the target.  See also regcache_cpy_no_passthrough.
-
-   regcache_cpy can not have overlapping SRC and DST buffers.  */
-
+/* Duplicate the contents of a register cache to a read-only register
+   cache.  The operation is pass-through.  */
 extern struct regcache *regcache_dup (struct regcache *regcache);
+
+/* Writes to DEST will go through to the target.  SRC is a read-only
+   register cache.  */
 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
 
 extern void registers_changed (void);