From: Eberhard Mattes <mattes@azu.informatik.uni-stuttgart.de>

[deliverable/binutils-gdb.git] / gdb / dcache.c

diff --git a/gdb/dcache.c b/gdb/dcache.c
index 71ba6922371c0198ca66b62b6df8ffb85afd1fc2..8020797691df7d5f11d440b41ec14015dd38ff73 100644 (file)
--- a/gdb/dcache.c
+++ b/gdb/dcache.c
@@ -23,7 +23,7 @@
 #include "dcache.h"
 #include "gdbcmd.h"
 #include "gdb_string.h"
-
+#include "gdbcore.h"
 
 /* 
    The data cache could lead to incorrect results because it doesn't know
@@ -111,7 +111,7 @@
 struct dcache_block
 {
   struct dcache_block *p;      /* next in list */
-  unsigned int addr;           /* Address for which data is recorded.  */
+  CORE_ADDR addr;              /* Address for which data is recorded.  */
   char data[LINE_SIZE];                /* bytes at given address */
   unsigned char state[LINE_SIZE]; /* what state the data is in */
 
@@ -148,7 +148,24 @@ struct dcache_struct
   int cache_has_stuff;
 } ;
 
-int remote_dcache = 1;
+static int
+dcache_poke_byte PARAMS ((DCACHE *dcache, CORE_ADDR addr, char *ptr));
+
+static int
+dcache_peek_byte PARAMS ((DCACHE *dcache, CORE_ADDR addr, char *ptr));
+
+static struct dcache_block *
+dcache_hit PARAMS ((DCACHE *dcache, CORE_ADDR addr));
+
+static int dcache_write_line PARAMS ((DCACHE *dcache,struct dcache_block *db));
+
+static struct dcache_block *dcache_alloc PARAMS ((DCACHE *dcache));
+
+static int dcache_writeback PARAMS ((DCACHE *dcache));
+
+static void dcache_info PARAMS ((char *exp, int tty));
+
+int remote_dcache = 0;
 
 DCACHE *last_cache; /* Used by info dcache */
 
@@ -186,11 +203,11 @@ dcache_flush (dcache)
 
 /* If addr is present in the dcache, return the address of the block
    containing it. */
-static
-struct dcache_block *
+
+static struct dcache_block *
 dcache_hit (dcache, addr)
      DCACHE *dcache;
-     unsigned int addr;
+     CORE_ADDR addr;
 {
   register struct dcache_block *db;
 
@@ -230,22 +247,22 @@ dcache_write_line (dcache, db)
              int len = 0;
              for (e = s ; e < LINE_SIZE; e++, len++)
                if (db->state[e] != ENTRY_DIRTY)
-                 {
-                   /* all bytes from s..s+len-1 need to
-                      be written out */
-                   int done = 0;
-                   while (done < len) {
-                     int t = dcache->write_memory (db->addr + s + done,
-                                                   db->data + s + done,
-                                                   len - done);
-                     if (t == 0)
-                       return 0;
-                     done += t;
-                   }
-                   memset (db->state + s, ENTRY_OK, len);
-                   s = e;
-                   break;
-                 }
+                 break;
+             {
+               /* all bytes from s..s+len-1 need to
+                  be written out */
+               int done = 0;
+               while (done < len) {
+                 int t = dcache->write_memory (db->addr + s + done,
+                                               db->data + s + done,
+                                               len - done);
+                 if (t == 0)
+                   return 0;
+                 done += t;
+               }
+               memset (db->state + s, ENTRY_OK, len);
+               s = e;
+             }
            }
        }
       db->anydirty = 0;
@@ -261,8 +278,8 @@ dcache_write_line (dcache, db)
    prevents errors from creeping in if a memory retrieval is
    interrupted (which used to put garbage blocks in the valid
    list...).  */
-static
-struct dcache_block *
+
+static struct dcache_block *
 dcache_alloc (dcache)
      DCACHE *dcache;
 {
@@ -302,7 +319,7 @@ dcache_alloc (dcache)
 
    Returns 0 on error. */
 
-int
+static int
 dcache_peek_byte (dcache, addr, ptr)
      DCACHE *dcache;
      CORE_ADDR addr;
@@ -321,7 +338,7 @@ dcache_peek_byte (dcache, addr, ptr)
     else
       db = dcache_alloc (dcache);
       immediate_quit++;
-           db->addr = MASK (addr);
+      db->addr = MASK (addr);
       while (done < LINE_SIZE) 
        {
          int try =
@@ -342,28 +359,6 @@ dcache_peek_byte (dcache, addr, ptr)
   return ok;
 }
 
-/* Using the data cache DCACHE return the contents of the word at
-   address ADDR in the remote machine.  
-
-   Returns 0 on error. */
-
-int
-dcache_peek (dcache, addr, data)
-     DCACHE *dcache;
-     CORE_ADDR addr;
-     int *data;
-{
-  char *dp = (char *) data;
-  int i;
-  for (i = 0; i < sizeof (int); i++)
-    {
-      if (!dcache_peek_byte (dcache, addr, dp + i))
-       return 0;
-    }
-  return 1;
-}
-
-
 /* Writeback any dirty lines to the remote. */
 static int
 dcache_writeback (dcache)
@@ -391,7 +386,10 @@ dcache_fetch (dcache, addr)
      CORE_ADDR addr;
 {
   int res;
-  dcache_peek (dcache, addr, &res);
+
+  if (dcache_xfer_memory (dcache, addr, (char *)&res, sizeof res, 0) != sizeof res)
+    memory_error (EIO, addr);
+
   return res;
 }
 
@@ -400,7 +398,7 @@ dcache_fetch (dcache, addr)
    Return zero on write error.
  */
 
-int
+static int
 dcache_poke_byte (dcache, addr, ptr)
      DCACHE *dcache;
      CORE_ADDR addr;
@@ -431,15 +429,10 @@ dcache_poke (dcache, addr, data)
      CORE_ADDR addr;
      int data;
 {
-  char *dp = (char *) (&data);
-  int i;
-  for (i = 0; i < sizeof (int); i++)
-    {
-      if (!dcache_poke_byte (dcache, addr, dp + i))
-       return 0;
-    }
-  dcache_writeback (dcache);
-  return 1;
+  if (dcache_xfer_memory (dcache, addr, (char *)&data, sizeof data, 1) != sizeof data)
+    return 0;
+
+  return dcache_writeback (dcache);
 }
 
 
@@ -485,8 +478,8 @@ dcache_xfer_memory (dcache, memaddr, myaddr, len, should_write)
 
   if (remote_dcache) 
     {
-      int (*xfunc) ()
-       = should_write ? dcache_poke_byte : dcache_peek_byte;
+      int (*xfunc) PARAMS ((DCACHE *dcache, CORE_ADDR addr, char *ptr));
+      xfunc = should_write ? dcache_poke_byte : dcache_peek_byte;
 
       for (i = 0; i < len; i++)
        {
@@ -498,8 +491,8 @@ dcache_xfer_memory (dcache, memaddr, myaddr, len, should_write)
     }
   else 
     {
-      int (*xfunc) () 
-       = should_write ? dcache->write_memory : dcache->read_memory;
+      memxferfunc xfunc;
+      xfunc = should_write ? dcache->write_memory : dcache->read_memory;
 
       if (dcache->cache_has_stuff)
        dcache_flush (dcache);