gdb/dcache.c

   1 /* Caching code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992, 1993, 1995, 1996, 1998, 1999, 2000, 2001, 2003, 2007,
   4    2008, 2009 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "dcache.h"
  23 #include "gdbcmd.h"
  24 #include "gdb_string.h"
  25 #include "gdbcore.h"
  26 #include "target.h"
  27 #include "inferior.h"
  28 #include "splay-tree.h"
  29
  30 /* The data cache could lead to incorrect results because it doesn't
  31    know about volatile variables, thus making it impossible to debug
  32    functions which use memory mapped I/O devices.  Set the nocache
  33    memory region attribute in those cases.
  34
  35    In general the dcache speeds up performance.  Some speed improvement
  36    comes from the actual caching mechanism, but the major gain is in
  37    the reduction of the remote protocol overhead; instead of reading
  38    or writing a large area of memory in 4 byte requests, the cache
  39    bundles up the requests into LINE_SIZE chunks, reducing overhead
  40    significantly.  This is most useful when accessing a large amount
  41    of data, such as when performing a backtrace.
  42
  43    The cache is a splay tree along with a linked list for replacement.
  44    Each block caches a LINE_SIZE area of memory.  Wtihin each line we remember
  45    the address of the line (which must be a multiple of LINE_SIZE) and the
  46    actual data block.
  47
  48    Lines are only allocated as needed, so DCACHE_SIZE really specifies the
  49    *maximum* number of lines in the cache.
  50
  51    At present, the cache is write-through rather than writeback: as soon
  52    as data is written to the cache, it is also immediately written to
  53    the target.  Therefore, cache lines are never "dirty".  Whether a given
  54    line is valid or not depends on where it is stored in the dcache_struct;
  55    there is no per-block valid flag.  */
  56
  57 /* NOTE: Interaction of dcache and memory region attributes
  58
  59    As there is no requirement that memory region attributes be aligned
  60    to or be a multiple of the dcache page size, dcache_read_line() and
  61    dcache_write_line() must break up the page by memory region.  If a
  62    chunk does not have the cache attribute set, an invalid memory type
  63    is set, etc., then the chunk is skipped.  Those chunks are handled
  64    in target_xfer_memory() (or target_xfer_memory_partial()).
  65
  66    This doesn't occur very often.  The most common occurance is when
  67    the last bit of the .text segment and the first bit of the .data
  68    segment fall within the same dcache page with a ro/cacheable memory
  69    region defined for the .text segment and a rw/non-cacheable memory
  70    region defined for the .data segment.  */
  71
  72 /* The maximum number of lines stored.  The total size of the cache is
  73    equal to DCACHE_SIZE times LINE_SIZE.  */
  74 #define DCACHE_SIZE 4096
  75
  76 /* The size of a cache line.  Smaller values reduce the time taken to
  77    read a single byte and make the cache more granular, but increase
  78    overhead and reduce the effectiveness of the cache as a prefetcher.  */
  79 #define LINE_SIZE_POWER 6
  80 #define LINE_SIZE (1 << LINE_SIZE_POWER)
  81
  82 /* Each cache block holds LINE_SIZE bytes of data
  83    starting at a multiple-of-LINE_SIZE address.  */
  84
  85 #define LINE_SIZE_MASK  ((LINE_SIZE - 1))
  86 #define XFORM(x)        ((x) & LINE_SIZE_MASK)
  87 #define MASK(x)         ((x) & ~LINE_SIZE_MASK)
  88
  89 struct dcache_block
  90 {
  91   struct dcache_block *newer;   /* for LRU and free list */
  92   CORE_ADDR addr;               /* address of data */
  93   gdb_byte data[LINE_SIZE];     /* bytes at given address */
  94   int refs;                     /* # hits */
  95 };
  96
  97 struct dcache_struct
  98 {
  99   splay_tree tree;
 100   struct dcache_block *oldest;
 101   struct dcache_block *newest;
 102
 103   struct dcache_block *freelist;
 104
 105   /* The number of in-use lines in the cache.  */
 106   int size;
 107
 108   /* The ptid of last inferior to use cache or null_ptid.  */
 109   ptid_t ptid;
 110 };
 111
 112 static struct dcache_block *dcache_hit (DCACHE *dcache, CORE_ADDR addr);
 113
 114 static int dcache_write_line (DCACHE *dcache, struct dcache_block *db);
 115
 116 static int dcache_read_line (DCACHE *dcache, struct dcache_block *db);
 117
 118 static struct dcache_block *dcache_alloc (DCACHE *dcache, CORE_ADDR addr);
 119
 120 static void dcache_info (char *exp, int tty);
 121
 122 void _initialize_dcache (void);
 123
 124 static int dcache_enabled_p = 0; /* OBSOLETE */
 125
 126 static void
 127 show_dcache_enabled_p (struct ui_file *file, int from_tty,
 128                        struct cmd_list_element *c, const char *value)
 129 {
 130   fprintf_filtered (file, _("Deprecated remotecache flag is %s.\n"), value);
 131 }
 132
 133 static DCACHE *last_cache; /* Used by info dcache */
 134
 135 /* Free all the data cache blocks, thus discarding all cached data.  */
 136
 137 void
 138 dcache_invalidate (DCACHE *dcache)
 139 {
 140   struct dcache_block *block, *next;
 141
 142   block = dcache->oldest;
 143
 144   while (block)
 145     {
 146       splay_tree_remove (dcache->tree, (splay_tree_key) block->addr);
 147       next = block->newer;
 148
 149       block->newer = dcache->freelist;
 150       dcache->freelist = block;
 151
 152       block = next;
 153     }
 154
 155   dcache->oldest = NULL;
 156   dcache->newest = NULL;
 157   dcache->size = 0;
 158   dcache->ptid = null_ptid;
 159 }
 160
 161 /* Invalidate the line associated with ADDR.  */
 162
 163 static void
 164 dcache_invalidate_line (DCACHE *dcache, CORE_ADDR addr)
 165 {
 166   struct dcache_block *db = dcache_hit (dcache, addr);
 167
 168   if (db)
 169     {
 170       splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
 171       db->newer = dcache->freelist;
 172       dcache->freelist = db;
 173       --dcache->size;
 174     }
 175 }
 176
 177 /* If addr is present in the dcache, return the address of the block
 178    containing it.  */
 179
 180 static struct dcache_block *
 181 dcache_hit (DCACHE *dcache, CORE_ADDR addr)
 182 {
 183   struct dcache_block *db;
 184
 185   splay_tree_node node = splay_tree_lookup (dcache->tree,
 186                                             (splay_tree_key) MASK (addr));
 187
 188   if (!node)
 189     return NULL;
 190
 191   db = (struct dcache_block *) node->value;
 192   db->refs++;
 193   return db;
 194 }
 195
 196 /* Fill a cache line from target memory.  */
 197
 198 static int
 199 dcache_read_line (DCACHE *dcache, struct dcache_block *db)
 200 {
 201   CORE_ADDR memaddr;
 202   gdb_byte *myaddr;
 203   int len;
 204   int res;
 205   int reg_len;
 206   struct mem_region *region;
 207
 208   len = LINE_SIZE;
 209   memaddr = db->addr;
 210   myaddr  = db->data;
 211
 212   while (len > 0)
 213     {
 214       /* Don't overrun if this block is right at the end of the region.  */
 215       region = lookup_mem_region (memaddr);
 216       if (region->hi == 0 || memaddr + len < region->hi)
 217         reg_len = len;
 218       else
 219         reg_len = region->hi - memaddr;
 220
 221       /* Skip non-readable regions.  The cache attribute can be ignored,
 222          since we may be loading this for a stack access.  */
 223       if (region->attrib.mode == MEM_WO)
 224         {
 225           memaddr += reg_len;
 226           myaddr  += reg_len;
 227           len     -= reg_len;
 228           continue;
 229         }
 230
 231       res = target_read (&current_target, TARGET_OBJECT_RAW_MEMORY,
 232                          NULL, myaddr, memaddr, reg_len);
 233       if (res < reg_len)
 234         return 0;
 235
 236       memaddr += res;
 237       myaddr += res;
 238       len -= res;
 239     }
 240
 241   return 1;
 242 }
 243
 244 /* Get a free cache block, put or keep it on the valid list,
 245    and return its address.  */
 246
 247 static struct dcache_block *
 248 dcache_alloc (DCACHE *dcache, CORE_ADDR addr)
 249 {
 250   struct dcache_block *db;
 251
 252   if (dcache->size >= DCACHE_SIZE)
 253     {
 254       /* Evict the least recently used line.  */
 255       db = dcache->oldest;
 256       dcache->oldest = db->newer;
 257
 258       splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
 259     }
 260   else
 261     {
 262       db = dcache->freelist;
 263       if (db)
 264         dcache->freelist = db->newer;
 265       else
 266         db = xmalloc (sizeof (struct dcache_block));
 267
 268       dcache->size++;
 269     }
 270
 271   db->addr = MASK (addr);
 272   db->newer = NULL;
 273   db->refs = 0;
 274
 275   if (dcache->newest)
 276     dcache->newest->newer = db;
 277
 278   dcache->newest = db;
 279
 280   if (!dcache->oldest)
 281     dcache->oldest = db;
 282
 283   splay_tree_insert (dcache->tree, (splay_tree_key) db->addr,
 284                      (splay_tree_value) db);
 285
 286   return db;
 287 }
 288
 289 /* Using the data cache DCACHE return the contents of the byte at
 290    address ADDR in the remote machine.
 291
 292    Returns 1 for success, 0 for error.  */
 293
 294 static int
 295 dcache_peek_byte (DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr)
 296 {
 297   struct dcache_block *db = dcache_hit (dcache, addr);
 298
 299   if (!db)
 300     {
 301       db = dcache_alloc (dcache, addr);
 302
 303       if (!dcache_read_line (dcache, db))
 304          return 0;
 305     }
 306
 307   *ptr = db->data[XFORM (addr)];
 308   return 1;
 309 }
 310
 311 /* Write the byte at PTR into ADDR in the data cache.
 312
 313    The caller is responsible for also promptly writing the data
 314    through to target memory.
 315
 316    If addr is not in cache, this function does nothing; writing to
 317    an area of memory which wasn't present in the cache doesn't cause
 318    it to be loaded in.
 319
 320    Always return 1 (meaning success) to simplify dcache_xfer_memory.  */
 321
 322 static int
 323 dcache_poke_byte (DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr)
 324 {
 325   struct dcache_block *db = dcache_hit (dcache, addr);
 326
 327   if (db)
 328     db->data[XFORM (addr)] = *ptr;
 329
 330   return 1;
 331 }
 332
 333 static int
 334 dcache_splay_tree_compare (splay_tree_key a, splay_tree_key b)
 335 {
 336   if (a > b)
 337     return 1;
 338   else if (a == b)
 339     return 0;
 340   else
 341     return -1;
 342 }
 343
 344 /* Initialize the data cache.  */
 345
 346 DCACHE *
 347 dcache_init (void)
 348 {
 349   DCACHE *dcache;
 350   int i;
 351
 352   dcache = (DCACHE *) xmalloc (sizeof (*dcache));
 353
 354   dcache->tree = splay_tree_new (dcache_splay_tree_compare,
 355                                  NULL,
 356                                  NULL);
 357
 358   dcache->oldest = NULL;
 359   dcache->newest = NULL;
 360   dcache->freelist = NULL;
 361   dcache->size = 0;
 362   dcache->ptid = null_ptid;
 363   last_cache = dcache;
 364
 365   return dcache;
 366 }
 367
 368 /* Free a data cache.  */
 369
 370 void
 371 dcache_free (DCACHE *dcache)
 372 {
 373   struct dcache_block *db, *next;
 374
 375   if (last_cache == dcache)
 376     last_cache = NULL;
 377
 378   splay_tree_delete (dcache->tree);
 379   for (db = dcache->freelist; db != NULL; db = next)
 380     {
 381       next = db->newer;
 382       xfree (db);
 383     }
 384   xfree (dcache);
 385 }
 386
 387 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
 388    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
 389    nonzero.
 390
 391    The meaning of the result is the same as for target_write.  */
 392
 393 int
 394 dcache_xfer_memory (struct target_ops *ops, DCACHE *dcache,
 395                     CORE_ADDR memaddr, gdb_byte *myaddr,
 396                     int len, int should_write)
 397 {
 398   int i;
 399   int res;
 400   int (*xfunc) (DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr);
 401   xfunc = should_write ? dcache_poke_byte : dcache_peek_byte;
 402
 403   /* If this is a different inferior from what we've recorded,
 404      flush the cache.  */
 405
 406   if (! ptid_equal (inferior_ptid, dcache->ptid))
 407     {
 408       dcache_invalidate (dcache);
 409       dcache->ptid = inferior_ptid;
 410     }
 411
 412   /* Do write-through first, so that if it fails, we don't write to
 413      the cache at all.  */
 414
 415   if (should_write)
 416     {
 417       res = target_write (ops, TARGET_OBJECT_RAW_MEMORY,
 418                           NULL, myaddr, memaddr, len);
 419       if (res <= 0)
 420         return res;
 421       /* Update LEN to what was actually written.  */
 422       len = res;
 423     }
 424
 425   for (i = 0; i < len; i++)
 426     {
 427       if (!xfunc (dcache, memaddr + i, myaddr + i))
 428         {
 429           /* That failed.  Discard its cache line so we don't have a
 430              partially read line.  */
 431           dcache_invalidate_line (dcache, memaddr + i);
 432           /* If we're writing, we still wrote LEN bytes.  */
 433           if (should_write)
 434             return len;
 435           else
 436             return i;
 437         }
 438     }
 439
 440   return len;
 441 }
 442
 443 /* FIXME: There would be some benefit to making the cache write-back and
 444    moving the writeback operation to a higher layer, as it could occur
 445    after a sequence of smaller writes have been completed (as when a stack
 446    frame is constructed for an inferior function call).  Note that only
 447    moving it up one level to target_xfer_memory[_partial]() is not
 448    sufficient since we want to coalesce memory transfers that are
 449    "logically" connected but not actually a single call to one of the
 450    memory transfer functions.  */
 451
 452 /* Just update any cache lines which are already present.  This is called
 453    by memory_xfer_partial in cases where the access would otherwise not go
 454    through the cache.  */
 455
 456 void
 457 dcache_update (DCACHE *dcache, CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 458 {
 459   int i;
 460   for (i = 0; i < len; i++)
 461     dcache_poke_byte (dcache, memaddr + i, myaddr + i);
 462 }
 463
 464 static void
 465 dcache_print_line (int index)
 466 {
 467   splay_tree_node n;
 468   struct dcache_block *db;
 469   int i, j;
 470
 471   if (!last_cache)
 472     {
 473       printf_filtered (_("No data cache available.\n"));
 474       return;
 475     }
 476
 477   n = splay_tree_min (last_cache->tree);
 478
 479   for (i = index; i > 0; --i)
 480     {
 481       if (!n)
 482         break;
 483       n = splay_tree_successor (last_cache->tree, n->key);
 484     }
 485
 486   if (!n)
 487     {
 488       printf_filtered (_("No such cache line exists.\n"));
 489       return;
 490     }
 491
 492   db = (struct dcache_block *) n->value;
 493
 494   printf_filtered (_("Line %d: address %s [%d hits]\n"),
 495                    index, paddress (target_gdbarch, db->addr), db->refs);
 496
 497   for (j = 0; j < LINE_SIZE; j++)
 498     {
 499       printf_filtered ("%02x ", db->data[j]);
 500
 501       /* Print a newline every 16 bytes (48 characters) */
 502       if ((j % 16 == 15) && (j != LINE_SIZE - 1))
 503         printf_filtered ("\n");
 504     }
 505   printf_filtered ("\n");
 506 }
 507
 508 static void
 509 dcache_info (char *exp, int tty)
 510 {
 511   splay_tree_node n;
 512   int i, refcount, lineno;
 513
 514   if (exp)
 515     {
 516       char *linestart;
 517       i = strtol (exp, &linestart, 10);
 518       if (linestart == exp || i < 0)
 519         {
 520           printf_filtered (_("Usage: info dcache [linenumber]\n"));
 521           return;
 522         }
 523
 524       dcache_print_line (i);
 525       return;
 526     }
 527
 528   printf_filtered (_("Dcache line width %d, maximum size %d\n"),
 529                    LINE_SIZE, DCACHE_SIZE);
 530
 531   if (!last_cache || ptid_equal (last_cache->ptid, null_ptid))
 532     {
 533       printf_filtered (_("No data cache available.\n"));
 534       return;
 535     }
 536
 537   printf_filtered (_("Contains data for %s\n"),
 538                    target_pid_to_str (last_cache->ptid));
 539
 540   refcount = 0;
 541
 542   n = splay_tree_min (last_cache->tree);
 543   i = 0;
 544
 545   while (n)
 546     {
 547       struct dcache_block *db = (struct dcache_block *) n->value;
 548
 549       printf_filtered (_("Line %d: address %s [%d hits]\n"),
 550                        i, paddress (target_gdbarch, db->addr), db->refs);
 551       i++;
 552       refcount += db->refs;
 553
 554       n = splay_tree_successor (last_cache->tree, n->key);
 555     }
 556
 557   printf_filtered (_("Cache state: %d active lines, %d hits\n"), i, refcount);
 558 }
 559
 560 void
 561 _initialize_dcache (void)
 562 {
 563   add_setshow_boolean_cmd ("remotecache", class_support,
 564                            &dcache_enabled_p, _("\
 565 Set cache use for remote targets."), _("\
 566 Show cache use for remote targets."), _("\
 567 This used to enable the data cache for remote targets.  The cache\n\
 568 functionality is now controlled by the memory region system and the\n\
 569 \"stack-cache\" flag; \"remotecache\" now does nothing and\n\
 570 exists only for compatibility reasons."),
 571                            NULL,
 572                            show_dcache_enabled_p,
 573                            &setlist, &showlist);
 574
 575   add_info ("dcache", dcache_info,
 576             _("\
 577 Print information on the dcache performance.\n\
 578 With no arguments, this command prints the cache configuration and a\n\
 579 summary of each line in the cache.  Use \"info dcache <lineno> to dump\"\n\
 580 the contents of a given line."));
 581 }