gdb/dcache.c

   1 /* Caching code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "dcache.h"
  21 #include "cli/cli-cmds.h"
  22 #include "gdbcore.h"
  23 #include "target-dcache.h"
  24 #include "inferior.h"
  25 #include "splay-tree.h"
  26 #include "gdbarch.h"
  27
  28 /* Commands with a prefix of `{set,show} dcache'.  */
  29 static struct cmd_list_element *dcache_set_list = NULL;
  30 static struct cmd_list_element *dcache_show_list = NULL;
  31
  32 /* The data cache could lead to incorrect results because it doesn't
  33    know about volatile variables, thus making it impossible to debug
  34    functions which use memory mapped I/O devices.  Set the nocache
  35    memory region attribute in those cases.
  36
  37    In general the dcache speeds up performance.  Some speed improvement
  38    comes from the actual caching mechanism, but the major gain is in
  39    the reduction of the remote protocol overhead; instead of reading
  40    or writing a large area of memory in 4 byte requests, the cache
  41    bundles up the requests into LINE_SIZE chunks, reducing overhead
  42    significantly.  This is most useful when accessing a large amount
  43    of data, such as when performing a backtrace.
  44
  45    The cache is a splay tree along with a linked list for replacement.
  46    Each block caches a LINE_SIZE area of memory.  Within each line we
  47    remember the address of the line (which must be a multiple of
  48    LINE_SIZE) and the actual data block.
  49
  50    Lines are only allocated as needed, so DCACHE_SIZE really specifies the
  51    *maximum* number of lines in the cache.
  52
  53    At present, the cache is write-through rather than writeback: as soon
  54    as data is written to the cache, it is also immediately written to
  55    the target.  Therefore, cache lines are never "dirty".  Whether a given
  56    line is valid or not depends on where it is stored in the dcache_struct;
  57    there is no per-block valid flag.  */
  58
  59 /* NOTE: Interaction of dcache and memory region attributes
  60
  61    As there is no requirement that memory region attributes be aligned
  62    to or be a multiple of the dcache page size, dcache_read_line() and
  63    dcache_write_line() must break up the page by memory region.  If a
  64    chunk does not have the cache attribute set, an invalid memory type
  65    is set, etc., then the chunk is skipped.  Those chunks are handled
  66    in target_xfer_memory() (or target_xfer_memory_partial()).
  67
  68    This doesn't occur very often.  The most common occurrence is when
  69    the last bit of the .text segment and the first bit of the .data
  70    segment fall within the same dcache page with a ro/cacheable memory
  71    region defined for the .text segment and a rw/non-cacheable memory
  72    region defined for the .data segment.  */
  73
  74 /* The maximum number of lines stored.  The total size of the cache is
  75    equal to DCACHE_SIZE times LINE_SIZE.  */
  76 #define DCACHE_DEFAULT_SIZE 4096
  77 static unsigned dcache_size = DCACHE_DEFAULT_SIZE;
  78
  79 /* The default size of a cache line.  Smaller values reduce the time taken to
  80    read a single byte and make the cache more granular, but increase
  81    overhead and reduce the effectiveness of the cache as a prefetcher.  */
  82 #define DCACHE_DEFAULT_LINE_SIZE 64
  83 static unsigned dcache_line_size = DCACHE_DEFAULT_LINE_SIZE;
  84
  85 /* Each cache block holds LINE_SIZE bytes of data
  86    starting at a multiple-of-LINE_SIZE address.  */
  87
  88 #define LINE_SIZE_MASK(dcache)  ((dcache->line_size - 1))
  89 #define XFORM(dcache, x)        ((x) & LINE_SIZE_MASK (dcache))
  90 #define MASK(dcache, x)         ((x) & ~LINE_SIZE_MASK (dcache))
  91
  92 struct dcache_block
  93 {
  94   /* For least-recently-allocated and free lists.  */
  95   struct dcache_block *prev;
  96   struct dcache_block *next;
  97
  98   CORE_ADDR addr;               /* address of data */
  99   int refs;                     /* # hits */
 100   gdb_byte data[1];             /* line_size bytes at given address */
 101 };
 102
 103 struct dcache_struct
 104 {
 105   splay_tree tree;
 106   struct dcache_block *oldest; /* least-recently-allocated list.  */
 107
 108   /* The free list is maintained identically to OLDEST to simplify
 109      the code: we only need one set of accessors.  */
 110   struct dcache_block *freelist;
 111
 112   /* The number of in-use lines in the cache.  */
 113   int size;
 114   CORE_ADDR line_size;  /* current line_size.  */
 115
 116   /* The ptid of last inferior to use cache or null_ptid.  */
 117   ptid_t ptid;
 118
 119   /* The process target of last inferior to use the cache or
 120      nullptr.  */
 121   process_stratum_target *proc_target;
 122 };
 123
 124 typedef void (block_func) (struct dcache_block *block, void *param);
 125
 126 static struct dcache_block *dcache_hit (DCACHE *dcache, CORE_ADDR addr);
 127
 128 static int dcache_read_line (DCACHE *dcache, struct dcache_block *db);
 129
 130 static struct dcache_block *dcache_alloc (DCACHE *dcache, CORE_ADDR addr);
 131
 132 static bool dcache_enabled_p = false; /* OBSOLETE */
 133
 134 static void
 135 show_dcache_enabled_p (struct ui_file *file, int from_tty,
 136                        struct cmd_list_element *c, const char *value)
 137 {
 138   gdb_printf (file, _("Deprecated remotecache flag is %s.\n"), value);
 139 }
 140
 141 /* Add BLOCK to circular block list BLIST, behind the block at *BLIST.
 142    *BLIST is not updated (unless it was previously NULL of course).
 143    This is for the least-recently-allocated list's sake:
 144    BLIST points to the oldest block.
 145    ??? This makes for poor cache usage of the free list,
 146    but is it measurable?  */
 147
 148 static void
 149 append_block (struct dcache_block **blist, struct dcache_block *block)
 150 {
 151   if (*blist)
 152     {
 153       block->next = *blist;
 154       block->prev = (*blist)->prev;
 155       block->prev->next = block;
 156       (*blist)->prev = block;
 157       /* We don't update *BLIST here to maintain the invariant that for the
 158          least-recently-allocated list *BLIST points to the oldest block.  */
 159     }
 160   else
 161     {
 162       block->next = block;
 163       block->prev = block;
 164       *blist = block;
 165     }
 166 }
 167
 168 /* Remove BLOCK from circular block list BLIST.  */
 169
 170 static void
 171 remove_block (struct dcache_block **blist, struct dcache_block *block)
 172 {
 173   if (block->next == block)
 174     {
 175       *blist = NULL;
 176     }
 177   else
 178     {
 179       block->next->prev = block->prev;
 180       block->prev->next = block->next;
 181       /* If we removed the block *BLIST points to, shift it to the next block
 182          to maintain the invariant that for the least-recently-allocated list
 183          *BLIST points to the oldest block.  */
 184       if (*blist == block)
 185         *blist = block->next;
 186     }
 187 }
 188
 189 /* Iterate over all elements in BLIST, calling FUNC.
 190    PARAM is passed to FUNC.
 191    FUNC may remove the block it's passed, but only that block.  */
 192
 193 static void
 194 for_each_block (struct dcache_block **blist, block_func *func, void *param)
 195 {
 196   struct dcache_block *db;
 197
 198   if (*blist == NULL)
 199     return;
 200
 201   db = *blist;
 202   do
 203     {
 204       struct dcache_block *next = db->next;
 205
 206       func (db, param);
 207       db = next;
 208     }
 209   while (*blist && db != *blist);
 210 }
 211
 212 /* BLOCK_FUNC routine for dcache_free.  */
 213
 214 static void
 215 free_block (struct dcache_block *block, void *param)
 216 {
 217   xfree (block);
 218 }
 219
 220 /* Free a data cache.  */
 221
 222 void
 223 dcache_free (DCACHE *dcache)
 224 {
 225   splay_tree_delete (dcache->tree);
 226   for_each_block (&dcache->oldest, free_block, NULL);
 227   for_each_block (&dcache->freelist, free_block, NULL);
 228   xfree (dcache);
 229 }
 230
 231
 232 /* BLOCK_FUNC function for dcache_invalidate.
 233    This doesn't remove the block from the oldest list on purpose.
 234    dcache_invalidate will do it later.  */
 235
 236 static void
 237 invalidate_block (struct dcache_block *block, void *param)
 238 {
 239   DCACHE *dcache = (DCACHE *) param;
 240
 241   splay_tree_remove (dcache->tree, (splay_tree_key) block->addr);
 242   append_block (&dcache->freelist, block);
 243 }
 244
 245 /* Free all the data cache blocks, thus discarding all cached data.  */
 246
 247 void
 248 dcache_invalidate (DCACHE *dcache)
 249 {
 250   for_each_block (&dcache->oldest, invalidate_block, dcache);
 251
 252   dcache->oldest = NULL;
 253   dcache->size = 0;
 254   dcache->ptid = null_ptid;
 255   dcache->proc_target = nullptr;
 256
 257   if (dcache->line_size != dcache_line_size)
 258     {
 259       /* We've been asked to use a different line size.
 260          All of our freelist blocks are now the wrong size, so free them.  */
 261
 262       for_each_block (&dcache->freelist, free_block, dcache);
 263       dcache->freelist = NULL;
 264       dcache->line_size = dcache_line_size;
 265     }
 266 }
 267
 268 /* Invalidate the line associated with ADDR.  */
 269
 270 static void
 271 dcache_invalidate_line (DCACHE *dcache, CORE_ADDR addr)
 272 {
 273   struct dcache_block *db = dcache_hit (dcache, addr);
 274
 275   if (db)
 276     {
 277       splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
 278       remove_block (&dcache->oldest, db);
 279       append_block (&dcache->freelist, db);
 280       --dcache->size;
 281     }
 282 }
 283
 284 /* If addr is present in the dcache, return the address of the block
 285    containing it.  Otherwise return NULL.  */
 286
 287 static struct dcache_block *
 288 dcache_hit (DCACHE *dcache, CORE_ADDR addr)
 289 {
 290   struct dcache_block *db;
 291
 292   splay_tree_node node = splay_tree_lookup (dcache->tree,
 293                                             (splay_tree_key) MASK (dcache, addr));
 294
 295   if (!node)
 296     return NULL;
 297
 298   db = (struct dcache_block *) node->value;
 299   db->refs++;
 300   return db;
 301 }
 302
 303 /* Fill a cache line from target memory.
 304    The result is 1 for success, 0 if the (entire) cache line
 305    wasn't readable.  */
 306
 307 static int
 308 dcache_read_line (DCACHE *dcache, struct dcache_block *db)
 309 {
 310   CORE_ADDR memaddr;
 311   gdb_byte *myaddr;
 312   int len;
 313   int res;
 314   int reg_len;
 315   struct mem_region *region;
 316
 317   len = dcache->line_size;
 318   memaddr = db->addr;
 319   myaddr  = db->data;
 320
 321   while (len > 0)
 322     {
 323       /* Don't overrun if this block is right at the end of the region.  */
 324       region = lookup_mem_region (memaddr);
 325       if (region->hi == 0 || memaddr + len < region->hi)
 326         reg_len = len;
 327       else
 328         reg_len = region->hi - memaddr;
 329
 330       /* Skip non-readable regions.  The cache attribute can be ignored,
 331          since we may be loading this for a stack access.  */
 332       if (region->attrib.mode == MEM_WO)
 333         {
 334           memaddr += reg_len;
 335           myaddr  += reg_len;
 336           len     -= reg_len;
 337           continue;
 338         }
 339
 340       res = target_read_raw_memory (memaddr, myaddr, reg_len);
 341       if (res != 0)
 342         return 0;
 343
 344       memaddr += reg_len;
 345       myaddr += reg_len;
 346       len -= reg_len;
 347     }
 348
 349   return 1;
 350 }
 351
 352 /* Get a free cache block, put or keep it on the valid list,
 353    and return its address.  */
 354
 355 static struct dcache_block *
 356 dcache_alloc (DCACHE *dcache, CORE_ADDR addr)
 357 {
 358   struct dcache_block *db;
 359
 360   if (dcache->size >= dcache_size)
 361     {
 362       /* Evict the least recently allocated line.  */
 363       db = dcache->oldest;
 364       remove_block (&dcache->oldest, db);
 365
 366       splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
 367     }
 368   else
 369     {
 370       db = dcache->freelist;
 371       if (db)
 372         remove_block (&dcache->freelist, db);
 373       else
 374         db = ((struct dcache_block *)
 375               xmalloc (offsetof (struct dcache_block, data)
 376                        + dcache->line_size));
 377
 378       dcache->size++;
 379     }
 380
 381   db->addr = MASK (dcache, addr);
 382   db->refs = 0;
 383
 384   /* Put DB at the end of the list, it's the newest.  */
 385   append_block (&dcache->oldest, db);
 386
 387   splay_tree_insert (dcache->tree, (splay_tree_key) db->addr,
 388                      (splay_tree_value) db);
 389
 390   return db;
 391 }
 392
 393 /* Using the data cache DCACHE, store in *PTR the contents of the byte at
 394    address ADDR in the remote machine.
 395
 396    Returns 1 for success, 0 for error.  */
 397
 398 static int
 399 dcache_peek_byte (DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr)
 400 {
 401   struct dcache_block *db = dcache_hit (dcache, addr);
 402
 403   if (!db)
 404     {
 405       db = dcache_alloc (dcache, addr);
 406
 407       if (!dcache_read_line (dcache, db))
 408          return 0;
 409     }
 410
 411   *ptr = db->data[XFORM (dcache, addr)];
 412   return 1;
 413 }
 414
 415 /* Write the byte at PTR into ADDR in the data cache.
 416
 417    The caller should have written the data through to target memory
 418    already.
 419
 420    If ADDR is not in cache, this function does nothing; writing to an
 421    area of memory which wasn't present in the cache doesn't cause it
 422    to be loaded in.  */
 423
 424 static void
 425 dcache_poke_byte (DCACHE *dcache, CORE_ADDR addr, const gdb_byte *ptr)
 426 {
 427   struct dcache_block *db = dcache_hit (dcache, addr);
 428
 429   if (db)
 430     db->data[XFORM (dcache, addr)] = *ptr;
 431 }
 432
 433 static int
 434 dcache_splay_tree_compare (splay_tree_key a, splay_tree_key b)
 435 {
 436   if (a > b)
 437     return 1;
 438   else if (a == b)
 439     return 0;
 440   else
 441     return -1;
 442 }
 443
 444 /* Allocate and initialize a data cache.  */
 445
 446 DCACHE *
 447 dcache_init (void)
 448 {
 449   DCACHE *dcache = XNEW (DCACHE);
 450
 451   dcache->tree = splay_tree_new (dcache_splay_tree_compare,
 452                                  NULL,
 453                                  NULL);
 454
 455   dcache->oldest = NULL;
 456   dcache->freelist = NULL;
 457   dcache->size = 0;
 458   dcache->line_size = dcache_line_size;
 459   dcache->ptid = null_ptid;
 460   dcache->proc_target = nullptr;
 461
 462   return dcache;
 463 }
 464
 465
 466 /* Read LEN bytes from dcache memory at MEMADDR, transferring to
 467    debugger address MYADDR.  If the data is presently cached, this
 468    fills the cache.  Arguments/return are like the target_xfer_partial
 469    interface.  */
 470
 471 enum target_xfer_status
 472 dcache_read_memory_partial (struct target_ops *ops, DCACHE *dcache,
 473                             CORE_ADDR memaddr, gdb_byte *myaddr,
 474                             ULONGEST len, ULONGEST *xfered_len)
 475 {
 476   ULONGEST i;
 477
 478   /* If this is a different thread from what we've recorded, flush the
 479      cache.  */
 480
 481   process_stratum_target *proc_target = current_inferior ()->process_target ();
 482   if (proc_target != dcache->proc_target || inferior_ptid != dcache->ptid)
 483     {
 484       dcache_invalidate (dcache);
 485       dcache->ptid = inferior_ptid;
 486       dcache->proc_target = proc_target;
 487     }
 488
 489   for (i = 0; i < len; i++)
 490     {
 491       if (!dcache_peek_byte (dcache, memaddr + i, myaddr + i))
 492         {
 493           /* That failed.  Discard its cache line so we don't have a
 494              partially read line.  */
 495           dcache_invalidate_line (dcache, memaddr + i);
 496           break;
 497         }
 498     }
 499
 500   if (i == 0)
 501     {
 502       /* Even though reading the whole line failed, we may be able to
 503          read a piece starting where the caller wanted.  */
 504       return raw_memory_xfer_partial (ops, myaddr, NULL, memaddr, len,
 505                                       xfered_len);
 506     }
 507   else
 508     {
 509       *xfered_len = i;
 510       return TARGET_XFER_OK;
 511     }
 512 }
 513
 514 /* FIXME: There would be some benefit to making the cache write-back and
 515    moving the writeback operation to a higher layer, as it could occur
 516    after a sequence of smaller writes have been completed (as when a stack
 517    frame is constructed for an inferior function call).  Note that only
 518    moving it up one level to target_xfer_memory[_partial]() is not
 519    sufficient since we want to coalesce memory transfers that are
 520    "logically" connected but not actually a single call to one of the
 521    memory transfer functions.  */
 522
 523 /* Just update any cache lines which are already present.  This is
 524    called by the target_xfer_partial machinery when writing raw
 525    memory.  */
 526
 527 void
 528 dcache_update (DCACHE *dcache, enum target_xfer_status status,
 529                CORE_ADDR memaddr, const gdb_byte *myaddr,
 530                ULONGEST len)
 531 {
 532   ULONGEST i;
 533
 534   for (i = 0; i < len; i++)
 535     if (status == TARGET_XFER_OK)
 536       dcache_poke_byte (dcache, memaddr + i, myaddr + i);
 537     else
 538       {
 539         /* Discard the whole cache line so we don't have a partially
 540            valid line.  */
 541         dcache_invalidate_line (dcache, memaddr + i);
 542       }
 543 }
 544
 545 /* Print DCACHE line INDEX.  */
 546
 547 static void
 548 dcache_print_line (DCACHE *dcache, int index)
 549 {
 550   splay_tree_node n;
 551   struct dcache_block *db;
 552   int i, j;
 553
 554   if (dcache == NULL)
 555     {
 556       gdb_printf (_("No data cache available.\n"));
 557       return;
 558     }
 559
 560   n = splay_tree_min (dcache->tree);
 561
 562   for (i = index; i > 0; --i)
 563     {
 564       if (!n)
 565         break;
 566       n = splay_tree_successor (dcache->tree, n->key);
 567     }
 568
 569   if (!n)
 570     {
 571       gdb_printf (_("No such cache line exists.\n"));
 572       return;
 573     }
 574
 575   db = (struct dcache_block *) n->value;
 576
 577   gdb_printf (_("Line %d: address %s [%d hits]\n"),
 578               index, paddress (current_inferior ()->arch (), db->addr),
 579               db->refs);
 580
 581   for (j = 0; j < dcache->line_size; j++)
 582     {
 583       gdb_printf ("%02x ", db->data[j]);
 584
 585       /* Print a newline every 16 bytes (48 characters).  */
 586       if ((j % 16 == 15) && (j != dcache->line_size - 1))
 587         gdb_printf ("\n");
 588     }
 589   gdb_printf ("\n");
 590 }
 591
 592 /* Parse EXP and show the info about DCACHE.  */
 593
 594 static void
 595 dcache_info_1 (DCACHE *dcache, const char *exp)
 596 {
 597   splay_tree_node n;
 598   int i, refcount;
 599
 600   if (exp)
 601     {
 602       char *linestart;
 603
 604       i = strtol (exp, &linestart, 10);
 605       if (linestart == exp || i < 0)
 606         {
 607           gdb_printf (_("Usage: info dcache [LINENUMBER]\n"));
 608           return;
 609         }
 610
 611       dcache_print_line (dcache, i);
 612       return;
 613     }
 614
 615   gdb_printf (_("Dcache %u lines of %u bytes each.\n"),
 616               dcache_size,
 617               dcache ? (unsigned) dcache->line_size
 618               : dcache_line_size);
 619
 620   if (dcache == NULL || dcache->ptid == null_ptid)
 621     {
 622       gdb_printf (_("No data cache available.\n"));
 623       return;
 624     }
 625
 626   gdb_printf (_("Contains data for %s\n"),
 627               target_pid_to_str (dcache->ptid).c_str ());
 628
 629   refcount = 0;
 630
 631   n = splay_tree_min (dcache->tree);
 632   i = 0;
 633
 634   while (n)
 635     {
 636       struct dcache_block *db = (struct dcache_block *) n->value;
 637
 638       gdb_printf (_("Line %d: address %s [%d hits]\n"),
 639                   i, paddress (current_inferior ()->arch (), db->addr),
 640                   db->refs);
 641       i++;
 642       refcount += db->refs;
 643
 644       n = splay_tree_successor (dcache->tree, n->key);
 645     }
 646
 647   gdb_printf (_("Cache state: %d active lines, %d hits\n"), i, refcount);
 648 }
 649
 650 static void
 651 info_dcache_command (const char *exp, int tty)
 652 {
 653   dcache_info_1 (target_dcache_get (current_program_space->aspace), exp);
 654 }
 655
 656 static void
 657 set_dcache_size (const char *args, int from_tty,
 658                  struct cmd_list_element *c)
 659 {
 660   if (dcache_size == 0)
 661     {
 662       dcache_size = DCACHE_DEFAULT_SIZE;
 663       error (_("Dcache size must be greater than 0."));
 664     }
 665   target_dcache_invalidate (current_program_space->aspace);
 666 }
 667
 668 static void
 669 set_dcache_line_size (const char *args, int from_tty,
 670                       struct cmd_list_element *c)
 671 {
 672   if (dcache_line_size < 2
 673       || (dcache_line_size & (dcache_line_size - 1)) != 0)
 674     {
 675       unsigned d = dcache_line_size;
 676       dcache_line_size = DCACHE_DEFAULT_LINE_SIZE;
 677       error (_("Invalid dcache line size: %u (must be power of 2)."), d);
 678     }
 679   target_dcache_invalidate (current_program_space->aspace);
 680 }
 681
 682 void _initialize_dcache ();
 683 void
 684 _initialize_dcache ()
 685 {
 686   add_setshow_boolean_cmd ("remotecache", class_support,
 687                            &dcache_enabled_p, _("\
 688 Set cache use for remote targets."), _("\
 689 Show cache use for remote targets."), _("\
 690 This used to enable the data cache for remote targets.  The cache\n\
 691 functionality is now controlled by the memory region system and the\n\
 692 \"stack-cache\" flag; \"remotecache\" now does nothing and\n\
 693 exists only for compatibility reasons."),
 694                            NULL,
 695                            show_dcache_enabled_p,
 696                            &setlist, &showlist);
 697
 698   add_info ("dcache", info_dcache_command,
 699             _("\
 700 Print information on the dcache performance.\n\
 701 Usage: info dcache [LINENUMBER]\n\
 702 With no arguments, this command prints the cache configuration and a\n\
 703 summary of each line in the cache.  With an argument, dump\"\n\
 704 the contents of the given line."));
 705
 706   add_setshow_prefix_cmd ("dcache", class_obscure,
 707                           _("\
 708 Use this command to set number of lines in dcache and line-size."),
 709                           ("Show dcache settings."),
 710                           &dcache_set_list, &dcache_show_list,
 711                           &setlist, &showlist);
 712
 713   add_setshow_zuinteger_cmd ("line-size", class_obscure,
 714                              &dcache_line_size, _("\
 715 Set dcache line size in bytes (must be power of 2)."), _("\
 716 Show dcache line size."),
 717                              NULL,
 718                              set_dcache_line_size,
 719                              NULL,
 720                              &dcache_set_list, &dcache_show_list);
 721   add_setshow_zuinteger_cmd ("size", class_obscure,
 722                              &dcache_size, _("\
 723 Set number of dcache lines."), _("\
 724 Show number of dcache lines."),
 725                              NULL,
 726                              set_dcache_size,
 727                              NULL,
 728                              &dcache_set_list, &dcache_show_list);
 729 }