GDB 7.6.50

gdb/dcache.c

 /* Caching code for GDB, the GNU debugger.
 
-   Copyright (C) 1992-1993, 1995-1996, 1998-2001, 2003, 2007-2012 Free
-   Software Foundation, Inc.
+   Copyright (C) 1992-2013 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 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    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, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "dcache.h"
 #include "gdbcmd.h"
-#include "gdb_string.h"
+#include <string.h>
 #include "gdbcore.h"
-#include "target.h"
+#include "target-dcache.h"
 #include "inferior.h"
 #include "splay-tree.h"
 
 /* Commands with a prefix of `{set,show} dcache'.  */
 static struct cmd_list_element *dcache_set_list = NULL;
 static struct cmd_list_element *dcache_show_list = NULL;
 
 /* The data cache could lead to incorrect results because it doesn't
    know about volatile variables, thus making it impossible to debug
    functions which use memory mapped I/O devices.  Set the nocache
@@ skipping 96 matching lines @@
 
 static int dcache_enabled_p = 0; /* OBSOLETE */
 
 static void
 show_dcache_enabled_p (struct ui_file *file, int from_tty,
                        struct cmd_list_element *c, const char *value)
 {
   fprintf_filtered (file, _("Deprecated remotecache flag is %s.\n"), value);
 }
 
-static DCACHE *last_cache; /* Used by info dcache.  */
-
 /* Add BLOCK to circular block list BLIST, behind the block at *BLIST.
    *BLIST is not updated (unless it was previously NULL of course).
    This is for the least-recently-allocated list's sake:
    BLIST points to the oldest block.
    ??? This makes for poor cache usage of the free list,
    but is it measurable?  */
 
 static void
 append_block (struct dcache_block **blist, struct dcache_block *block)
 {
@@ skipping 64 matching lines @@
 free_block (struct dcache_block *block, void *param)
 {
   xfree (block);
 }
 
 /* Free a data cache.  */
 
 void
 dcache_free (DCACHE *dcache)
 {
-  if (last_cache == dcache)
-    last_cache = NULL;
-
   splay_tree_delete (dcache->tree);
   for_each_block (&dcache->oldest, free_block, NULL);
   for_each_block (&dcache->freelist, free_block, NULL);
   xfree (dcache);
 }
 
 
 /* BLOCK_FUNC function for dcache_invalidate.
    This doesn't remove the block from the oldest list on purpose.
    dcache_invalidate will do it later.  */
@@ skipping 93 matching lines @@
 
       /* Skip non-readable regions.  The cache attribute can be ignored,
          since we may be loading this for a stack access.  */
       if (region->attrib.mode == MEM_WO)
         {
           memaddr += reg_len;
           myaddr  += reg_len;
           len     -= reg_len;
           continue;
         }
-      
-      res = target_read (&current_target, TARGET_OBJECT_RAW_MEMORY,
-                         NULL, myaddr, memaddr, reg_len);
-      if (res < reg_len)
+
+      res = target_read_raw_memory (memaddr, myaddr, reg_len);
+      if (res != 0)
         return 0;
 
-      memaddr += res;
-      myaddr += res;
-      len -= res;
+      memaddr += reg_len;
+      myaddr += reg_len;
+      len -= reg_len;
     }
 
   return 1;
 }
 
 /* Get a free cache block, put or keep it on the valid list,
    and return its address.  */
 
 static struct dcache_block *
 dcache_alloc (DCACHE *dcache, CORE_ADDR addr)
@@ skipping 98 matching lines @@
 
   dcache->tree = splay_tree_new (dcache_splay_tree_compare,
                                  NULL,
                                  NULL);
 
   dcache->oldest = NULL;
   dcache->freelist = NULL;
   dcache->size = 0;
   dcache->line_size = dcache_line_size;
   dcache->ptid = null_ptid;
-  last_cache = dcache;
 
   return dcache;
 }
 
 
 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
    nonzero. 
 
    Return the number of bytes actually transfered, or -1 if the
@@ skipping 68 matching lines @@
 
 void
 dcache_update (DCACHE *dcache, CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 {
   int i;
 
   for (i = 0; i < len; i++)
     dcache_poke_byte (dcache, memaddr + i, myaddr + i);
 }
 
+/* Print DCACHE line INDEX.  */
+
 static void
-dcache_print_line (int index)
+dcache_print_line (DCACHE *dcache, int index)
 {
   splay_tree_node n;
   struct dcache_block *db;
   int i, j;
 
-  if (!last_cache)
+  if (dcache == NULL)
     {
       printf_filtered (_("No data cache available.\n"));
       return;
     }
 
-  n = splay_tree_min (last_cache->tree);
+  n = splay_tree_min (dcache->tree);
 
   for (i = index; i > 0; --i)
     {
       if (!n)
         break;
-      n = splay_tree_successor (last_cache->tree, n->key);
+      n = splay_tree_successor (dcache->tree, n->key);
     }
 
   if (!n)
     {
       printf_filtered (_("No such cache line exists.\n"));
       return;
     }
     
   db = (struct dcache_block *) n->value;
 
   printf_filtered (_("Line %d: address %s [%d hits]\n"),
-                   index, paddress (target_gdbarch, db->addr), db->refs);
+                   index, paddress (target_gdbarch (), db->addr), db->refs);
 
-  for (j = 0; j < last_cache->line_size; j++)
+  for (j = 0; j < dcache->line_size; j++)
     {
       printf_filtered ("%02x ", db->data[j]);
 
       /* Print a newline every 16 bytes (48 characters).  */
-      if ((j % 16 == 15) && (j != last_cache->line_size - 1))
+      if ((j % 16 == 15) && (j != dcache->line_size - 1))
         printf_filtered ("\n");
     }
   printf_filtered ("\n");
 }
 
+/* Parse EXP and show the info about DCACHE.  */
+
 static void
-dcache_info (char *exp, int tty)
+dcache_info_1 (DCACHE *dcache, char *exp)
 {
   splay_tree_node n;
   int i, refcount;
 
   if (exp)
     {
       char *linestart;
 
       i = strtol (exp, &linestart, 10);
       if (linestart == exp || i < 0)
         {
           printf_filtered (_("Usage: info dcache [linenumber]\n"));
           return;
         }
 
-      dcache_print_line (i);
+      dcache_print_line (dcache, i);
       return;
     }
 
   printf_filtered (_("Dcache %u lines of %u bytes each.\n"),
                    dcache_size,
-                   last_cache ? (unsigned) last_cache->line_size
+                   dcache ? (unsigned) dcache->line_size
                    : dcache_line_size);
 
-  if (!last_cache || ptid_equal (last_cache->ptid, null_ptid))
+  if (dcache == NULL || ptid_equal (dcache->ptid, null_ptid))
     {
       printf_filtered (_("No data cache available.\n"));
       return;
     }
 
   printf_filtered (_("Contains data for %s\n"),
-                   target_pid_to_str (last_cache->ptid));
+                   target_pid_to_str (dcache->ptid));
 
   refcount = 0;
 
-  n = splay_tree_min (last_cache->tree);
+  n = splay_tree_min (dcache->tree);
   i = 0;
 
   while (n)
     {
       struct dcache_block *db = (struct dcache_block *) n->value;
 
       printf_filtered (_("Line %d: address %s [%d hits]\n"),
-                       i, paddress (target_gdbarch, db->addr), db->refs);
+                       i, paddress (target_gdbarch (), db->addr), db->refs);
       i++;
       refcount += db->refs;
 
-      n = splay_tree_successor (last_cache->tree, n->key);
+      n = splay_tree_successor (dcache->tree, n->key);
     }
 
   printf_filtered (_("Cache state: %d active lines, %d hits\n"), i, refcount);
 }
 
 static void
+dcache_info (char *exp, int tty)
+{
+  dcache_info_1 (target_dcache_get (), exp);
+}
+
+static void
 set_dcache_size (char *args, int from_tty,
                  struct cmd_list_element *c)
 {
   if (dcache_size == 0)
     {
       dcache_size = DCACHE_DEFAULT_SIZE;
       error (_("Dcache size must be greater than 0."));
     }
-  if (last_cache)
-    dcache_invalidate (last_cache);
+  target_dcache_invalidate ();
 }
 
 static void
 set_dcache_line_size (char *args, int from_tty,
                       struct cmd_list_element *c)
 {
   if (dcache_line_size < 2
       || (dcache_line_size & (dcache_line_size - 1)) != 0)
     {
       unsigned d = dcache_line_size;
       dcache_line_size = DCACHE_DEFAULT_LINE_SIZE;
       error (_("Invalid dcache line size: %u (must be power of 2)."), d);
     }
-  if (last_cache)
-    dcache_invalidate (last_cache);
+  target_dcache_invalidate ();
 }
 
 static void
 set_dcache_command (char *arg, int from_tty)
 {
   printf_unfiltered (
      "\"set dcache\" must be followed by the name of a subcommand.\n");
   help_list (dcache_set_list, "set dcache ", -1, gdb_stdout);
 }
 
@@ skipping 25 matching lines @@
 summary of each line in the cache.  Use \"info dcache <lineno> to dump\"\n\
 the contents of a given line."));
 
   add_prefix_cmd ("dcache", class_obscure, set_dcache_command, _("\
 Use this command to set number of lines in dcache and line-size."),
                   &dcache_set_list, "set dcache ", /*allow_unknown*/0, &setlist);
   add_prefix_cmd ("dcache", class_obscure, show_dcache_command, _("\
 Show dcachesettings."),
                   &dcache_show_list, "show dcache ", /*allow_unknown*/0, &showlist);
 
-  add_setshow_uinteger_cmd ("line-size", class_obscure,
-                            &dcache_line_size, _("\
+  add_setshow_zuinteger_cmd ("line-size", class_obscure,
+                             &dcache_line_size, _("\
 Set dcache line size in bytes (must be power of 2)."), _("\
 Show dcache line size."),
-                            NULL,
-                            set_dcache_line_size,
-                            NULL,
-                            &dcache_set_list, &dcache_show_list);
-  add_setshow_uinteger_cmd ("size", class_obscure,
-                            &dcache_size, _("\
+                             NULL,
+                             set_dcache_line_size,
+                             NULL,
+                             &dcache_set_list, &dcache_show_list);
+  add_setshow_zuinteger_cmd ("size", class_obscure,
+                             &dcache_size, _("\
 Set number of dcache lines."), _("\
 Show number of dcache lines."),
-                            NULL,
-                            set_dcache_size,
-                            NULL,
-                            &dcache_set_list, &dcache_show_list);
+                             NULL,
+                             set_dcache_size,
+                             NULL,
+                             &dcache_set_list, &dcache_show_list);
 }