2011-05-31 Pedro Alves <pedro@codesourcery.com>

[deliverable/binutils-gdb.git] / gdb / gdbserver / regcache.c

diff --git a/gdb/gdbserver/regcache.c b/gdb/gdbserver/regcache.c
index 9077a7198c8b8561a291b459895c9f4718d06895..ecd974441b00cf842dd5c2d362738eb6c166ad26 100644 (file)
--- a/gdb/gdbserver/regcache.c
+++ b/gdb/gdbserver/regcache.c
@@ -1,5 +1,5 @@
 /* Register support routines for the remote server for GDB.
-   Copyright (C) 2001, 2002, 2004, 2005, 2007, 2008, 2009, 2010
+   Copyright (C) 2001, 2002, 2004, 2005, 2007, 2008, 2009, 2010, 2011
    Free Software Foundation, Inc.
 
    This file is part of GDB.
@@ -30,6 +30,8 @@ static int num_registers;
 
 const char **gdbserver_expedite_regs;
 
+#ifndef IN_PROCESS_AGENT
+
 struct regcache *
 get_thread_regcache (struct thread_info *thread, int fetch)
 {
@@ -82,9 +84,12 @@ regcache_invalidate (void)
   for_each_inferior (&all_threads, regcache_invalidate_one);
 }
 
+#endif
+
 struct regcache *
 init_register_cache (struct regcache *regcache, unsigned char *regbuf)
 {
+#ifndef IN_PROCESS_AGENT
   if (regbuf == NULL)
     {
       /* Make sure to zero-initialize the register cache when it is
@@ -93,11 +98,21 @@ init_register_cache (struct regcache *regcache, unsigned char *regbuf)
         garbage.  */
       regcache->registers = xcalloc (1, register_bytes);
       regcache->registers_owned = 1;
+      regcache->register_status = xcalloc (1, num_registers);
+      gdb_assert (REG_UNAVAILABLE == 0);
     }
   else
+#else
+  if (regbuf == NULL)
+    fatal ("init_register_cache: can't allocate memory from the heap");
+  else
+#endif
     {
       regcache->registers = regbuf;
       regcache->registers_owned = 0;
+#ifndef IN_PROCESS_AGENT
+      regcache->register_status = NULL;
+#endif
     }
 
   regcache->registers_valid = 0;
@@ -105,6 +120,8 @@ init_register_cache (struct regcache *regcache, unsigned char *regbuf)
   return regcache;
 }
 
+#ifndef IN_PROCESS_AGENT
+
 struct regcache *
 new_register_cache (void)
 {
@@ -122,18 +139,27 @@ free_register_cache (struct regcache *regcache)
 {
   if (regcache)
     {
-      free (regcache->registers);
+      if (regcache->registers_owned)
+       free (regcache->registers);
+      free (regcache->register_status);
       free (regcache);
     }
 }
 
+#endif
+
 void
 regcache_cpy (struct regcache *dst, struct regcache *src)
 {
   memcpy (dst->registers, src->registers, register_bytes);
+#ifndef IN_PROCESS_AGENT
+  if (dst->register_status != NULL && src->register_status != NULL)
+    memcpy (dst->register_status, src->register_status, num_registers);
+#endif
   dst->registers_valid = src->registers_valid;
 }
 
+#ifndef IN_PROCESS_AGENT
 static void
 realloc_register_cache (struct inferior_list_entry *thread_p)
 {
@@ -146,15 +172,18 @@ realloc_register_cache (struct inferior_list_entry *thread_p)
   free_register_cache (regcache);
   set_inferior_regcache_data (thread, new_register_cache ());
 }
+#endif
 
 void
 set_register_cache (struct reg *regs, int n)
 {
   int offset, i;
 
+#ifndef IN_PROCESS_AGENT
   /* Before changing the register cache internal layout, flush the
      contents of valid caches back to the threads.  */
   regcache_invalidate ();
+#endif
 
   reg_defs = regs;
   num_registers = n;
@@ -172,8 +201,10 @@ set_register_cache (struct reg *regs, int n)
   if (2 * register_bytes + 32 > PBUFSIZ)
     fatal ("Register packet size exceeds PBUFSIZ.");
 
+#ifndef IN_PROCESS_AGENT
   /* Re-allocate all pre-existing register caches.  */
   for_each_inferior (&all_threads, realloc_register_cache);
+#endif
 }
 
 int
@@ -182,12 +213,29 @@ register_cache_size (void)
   return register_bytes;
 }
 
+#ifndef IN_PROCESS_AGENT
+
 void
 registers_to_string (struct regcache *regcache, char *buf)
 {
   unsigned char *registers = regcache->registers;
+  int i;
 
-  convert_int_to_ascii (registers, buf, register_bytes);
+  for (i = 0; i < num_registers; i++)
+    {
+      if (regcache->register_status[i] == REG_VALID)
+       {
+         convert_int_to_ascii (registers, buf, register_size (i));
+         buf += register_size (i) * 2;
+       }
+      else
+       {
+         memset (buf, 'x', register_size (i) * 2);
+         buf += register_size (i) * 2;
+       }
+      registers += register_size (i);
+    }
+  *buf = '\0';
 }
 
 void
@@ -236,6 +284,8 @@ find_register_by_number (int n)
   return &reg_defs[n];
 }
 
+#endif
+
 int
 register_size (int n)
 {
@@ -248,24 +298,78 @@ register_data (struct regcache *regcache, int n, int fetch)
   return regcache->registers + (reg_defs[n].offset / 8);
 }
 
+/* Supply register N, whose contents are stored in BUF, to REGCACHE.
+   If BUF is NULL, the register's value is recorded as
+   unavailable.  */
+
 void
 supply_register (struct regcache *regcache, int n, const void *buf)
 {
   if (buf)
-    memcpy (register_data (regcache, n, 0), buf, register_size (n));
+    {
+      memcpy (register_data (regcache, n, 0), buf, register_size (n));
+#ifndef IN_PROCESS_AGENT
+      if (regcache->register_status != NULL)
+       regcache->register_status[n] = REG_VALID;
+#endif
+    }
   else
-    memset (register_data (regcache, n, 0), 0, register_size (n));
+    {
+      memset (register_data (regcache, n, 0), 0, register_size (n));
+#ifndef IN_PROCESS_AGENT
+      if (regcache->register_status != NULL)
+       regcache->register_status[n] = REG_UNAVAILABLE;
+#endif
+    }
+}
+
+/* Supply register N with value zero to REGCACHE.  */
+
+void
+supply_register_zeroed (struct regcache *regcache, int n)
+{
+  memset (register_data (regcache, n, 0), 0, register_size (n));
+#ifndef IN_PROCESS_AGENT
+  if (regcache->register_status != NULL)
+    regcache->register_status[n] = REG_VALID;
+#endif
 }
 
+/* Supply the whole register set whose contents are stored in BUF, to
+   REGCACHE.  If BUF is NULL, all the registers' values are recorded
+   as unavailable.  */
+
 void
 supply_regblock (struct regcache *regcache, const void *buf)
 {
   if (buf)
-    memcpy (regcache->registers, buf, register_bytes);
+    {
+      memcpy (regcache->registers, buf, register_bytes);
+#ifndef IN_PROCESS_AGENT
+      {
+       int i;
+
+       for (i = 0; i < num_registers; i++)
+         regcache->register_status[i] = REG_VALID;
+      }
+#endif
+    }
   else
-    memset (regcache->registers, 0, register_bytes);
+    {
+      memset (regcache->registers, 0, register_bytes);
+#ifndef IN_PROCESS_AGENT
+      {
+       int i;
+
+       for (i = 0; i < num_registers; i++)
+         regcache->register_status[i] = REG_UNAVAILABLE;
+      }
+#endif
+    }
 }
 
+#ifndef IN_PROCESS_AGENT
+
 void
 supply_register_by_name (struct regcache *regcache,
                         const char *name, const void *buf)
@@ -273,12 +377,16 @@ supply_register_by_name (struct regcache *regcache,
   supply_register (regcache, find_regno (name), buf);
 }
 
+#endif
+
 void
 collect_register (struct regcache *regcache, int n, void *buf)
 {
   memcpy (buf, register_data (regcache, n, 1), register_size (n));
 }
 
+#ifndef IN_PROCESS_AGENT
+
 void
 collect_register_as_string (struct regcache *regcache, int n, char *buf)
 {
@@ -318,3 +426,5 @@ regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
     internal_error (__FILE__, __LINE__,
                    "regcache_write_pc: Unable to update PC");
 }
+
+#endif