gdb/dcache.c

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