gdb/dcache.c

   1 /* Caching code for GDB, the GNU debugger.
   2
   3    Copyright (C) 1992-2017 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
  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 occurance 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
 120 typedef void (block_func) (struct dcache_block *block, void *param);
 121
 122 static struct dcache_block *dcache_hit (DCACHE *dcache, CORE_ADDR addr);
 123
 124 static int dcache_read_line (DCACHE *dcache, struct dcache_block *db);
 125
 126 static struct dcache_block *dcache_alloc (DCACHE *dcache, CORE_ADDR addr);
 127
 128 static void dcache_info (char *exp, int tty);
 129
 130 void _initialize_dcache (void);
 131
 132 static int dcache_enabled_p = 0; /* 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   fprintf_filtered (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
 256   if (dcache->line_size != dcache_line_size)
 257     {
 258       /* We've been asked to use a different line size.
 259          All of our freelist blocks are now the wrong size, so free them.  */
 260
 261       for_each_block (&dcache->freelist, free_block, dcache);
 262       dcache->freelist = NULL;
 263       dcache->line_size = dcache_line_size;
 264     }
 265 }
 266
 267 /* Invalidate the line associated with ADDR.  */
 268
 269 static void
 270 dcache_invalidate_line (DCACHE *dcache, CORE_ADDR addr)
 271 {
 272   struct dcache_block *db = dcache_hit (dcache, addr);
 273
 274   if (db)
 275     {
 276       splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
 277       remove_block (&dcache->oldest, db);
 278       append_block (&dcache->freelist, db);
 279       --dcache->size;
 280     }
 281 }
 282
 283 /* If addr is present in the dcache, return the address of the block
 284    containing it.  Otherwise return NULL.  */
 285
 286 static struct dcache_block *
 287 dcache_hit (DCACHE *dcache, CORE_ADDR addr)
 288 {
 289   struct dcache_block *db;
 290
 291   splay_tree_node node = splay_tree_lookup (dcache->tree,
 292                                             (splay_tree_key) MASK (dcache, addr));
 293
 294   if (!node)
 295     return NULL;
 296
 297   db = (struct dcache_block *) node->value;
 298   db->refs++;
 299   return db;
 300 }
 301
 302 /* Fill a cache line from target memory.
 303    The result is 1 for success, 0 if the (entire) cache line
 304    wasn't readable.  */
 305
 306 static int
 307 dcache_read_line (DCACHE *dcache, struct dcache_block *db)
 308 {
 309   CORE_ADDR memaddr;
 310   gdb_byte *myaddr;
 311   int len;
 312   int res;
 313   int reg_len;
 314   struct mem_region *region;
 315
 316   len = dcache->line_size;
 317   memaddr = db->addr;
 318   myaddr  = db->data;
 319
 320   while (len > 0)
 321     {
 322       /* Don't overrun if this block is right at the end of the region.  */
 323       region = lookup_mem_region (memaddr);
 324       if (region->hi == 0 || memaddr + len < region->hi)
 325         reg_len = len;
 326       else
 327         reg_len = region->hi - memaddr;
 328
 329       /* Skip non-readable regions.  The cache attribute can be ignored,
 330          since we may be loading this for a stack access.  */
 331       if (region->attrib.mode == MEM_WO)
 332         {
 333           memaddr += reg_len;
 334           myaddr  += reg_len;
 335           len     -= reg_len;
 336           continue;
 337         }
 338
 339       res = target_read_raw_memory (memaddr, myaddr, reg_len);
 340       if (res != 0)
 341         return 0;
 342
 343       memaddr += reg_len;
 344       myaddr += reg_len;
 345       len -= reg_len;
 346     }
 347
 348   return 1;
 349 }
 350
 351 /* Get a free cache block, put or keep it on the valid list,
 352    and return its address.  */
 353
 354 static struct dcache_block *
 355 dcache_alloc (DCACHE *dcache, CORE_ADDR addr)
 356 {
 357   struct dcache_block *db;
 358
 359   if (dcache->size >= dcache_size)
 360     {
 361       /* Evict the least recently allocated line.  */
 362       db = dcache->oldest;
 363       remove_block (&dcache->oldest, db);
 364
 365       splay_tree_remove (dcache->tree, (splay_tree_key) db->addr);
 366     }
 367   else
 368     {
 369       db = dcache->freelist;
 370       if (db)
 371         remove_block (&dcache->freelist, db);
 372       else
 373         db = ((struct dcache_block *)
 374               xmalloc (offsetof (struct dcache_block, data)
 375                        + dcache->line_size));
 376
 377       dcache->size++;
 378     }
 379
 380   db->addr = MASK (dcache, addr);
 381   db->refs = 0;
 382
 383   /* Put DB at the end of the list, it's the newest.  */
 384   append_block (&dcache->oldest, db);
 385
 386   splay_tree_insert (dcache->tree, (splay_tree_key) db->addr,
 387                      (splay_tree_value) db);
 388
 389   return db;
 390 }
 391
 392 /* Using the data cache DCACHE, store in *PTR the contents of the byte at
 393    address ADDR in the remote machine.
 394
 395    Returns 1 for success, 0 for error.  */
 396
 397 static int
 398 dcache_peek_byte (DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr)
 399 {
 400   struct dcache_block *db = dcache_hit (dcache, addr);
 401
 402   if (!db)
 403     {
 404       db = dcache_alloc (dcache, addr);
 405
 406       if (!dcache_read_line (dcache, db))
 407          return 0;
 408     }
 409
 410   *ptr = db->data[XFORM (dcache, addr)];
 411   return 1;
 412 }
 413
 414 /* Write the byte at PTR into ADDR in the data cache.
 415
 416    The caller should have written the data through to target memory
 417    already.
 418
 419    If ADDR is not in cache, this function does nothing; writing to an
 420    area of memory which wasn't present in the cache doesn't cause it
 421    to be loaded in.  */
 422
 423 static void
 424 dcache_poke_byte (DCACHE *dcache, CORE_ADDR addr, const gdb_byte *ptr)
 425 {
 426   struct dcache_block *db = dcache_hit (dcache, addr);
 427
 428   if (db)
 429     db->data[XFORM (dcache, addr)] = *ptr;
 430 }
 431
 432 static int
 433 dcache_splay_tree_compare (splay_tree_key a, splay_tree_key b)
 434 {
 435   if (a > b)
 436     return 1;
 437   else if (a == b)
 438     return 0;
 439   else
 440     return -1;
 441 }
 442
 443 /* Allocate and initialize a data cache.  */
 444
 445 DCACHE *
 446 dcache_init (void)
 447 {
 448   DCACHE *dcache = XNEW (DCACHE);
 449
 450   dcache->tree = splay_tree_new (dcache_splay_tree_compare,
 451                                  NULL,
 452                                  NULL);
 453
 454   dcache->oldest = NULL;
 455   dcache->freelist = NULL;
 456   dcache->size = 0;
 457   dcache->line_size = dcache_line_size;
 458   dcache->ptid = null_ptid;
 459
 460   return dcache;
 461 }
 462
 463
 464 /* Read LEN bytes from dcache memory at MEMADDR, transferring to
 465    debugger address MYADDR.  If the data is presently cached, this
 466    fills the cache.  Arguments/return are like the target_xfer_partial
 467    interface.  */
 468
 469 enum target_xfer_status
 470 dcache_read_memory_partial (struct target_ops *ops, DCACHE *dcache,
 471                             CORE_ADDR memaddr, gdb_byte *myaddr,
 472                             ULONGEST len, ULONGEST *xfered_len)
 473 {
 474   ULONGEST i;
 475
 476   /* If this is a different inferior from what we've recorded,
 477      flush the cache.  */
 478
 479   if (! ptid_equal (inferior_ptid, dcache->ptid))
 480     {
 481       dcache_invalidate (dcache);
 482       dcache->ptid = inferior_ptid;
 483     }
 484
 485   for (i = 0; i < len; i++)
 486     {
 487       if (!dcache_peek_byte (dcache, memaddr + i, myaddr + i))
 488         {
 489           /* That failed.  Discard its cache line so we don't have a
 490              partially read line.  */
 491           dcache_invalidate_line (dcache, memaddr + i);
 492           break;
 493         }
 494     }
 495
 496   if (i == 0)
 497     {
 498       /* Even though reading the whole line failed, we may be able to
 499          read a piece starting where the caller wanted.  */
 500       return raw_memory_xfer_partial (ops, myaddr, NULL, memaddr, len,
 501                                       xfered_len);
 502     }
 503   else
 504     {
 505       *xfered_len = i;
 506       return TARGET_XFER_OK;
 507     }
 508 }
 509
 510 /* FIXME: There would be some benefit to making the cache write-back and
 511    moving the writeback operation to a higher layer, as it could occur
 512    after a sequence of smaller writes have been completed (as when a stack
 513    frame is constructed for an inferior function call).  Note that only
 514    moving it up one level to target_xfer_memory[_partial]() is not
 515    sufficient since we want to coalesce memory transfers that are
 516    "logically" connected but not actually a single call to one of the
 517    memory transfer functions.  */
 518
 519 /* Just update any cache lines which are already present.  This is
 520    called by the target_xfer_partial machinery when writing raw
 521    memory.  */
 522
 523 void
 524 dcache_update (DCACHE *dcache, enum target_xfer_status status,
 525                CORE_ADDR memaddr, const gdb_byte *myaddr,
 526                ULONGEST len)
 527 {
 528   ULONGEST i;
 529
 530   for (i = 0; i < len; i++)
 531     if (status == TARGET_XFER_OK)
 532       dcache_poke_byte (dcache, memaddr + i, myaddr + i);
 533     else
 534       {
 535         /* Discard the whole cache line so we don't have a partially
 536            valid line.  */
 537         dcache_invalidate_line (dcache, memaddr + i);
 538       }
 539 }
 540
 541 /* Print DCACHE line INDEX.  */
 542
 543 static void
 544 dcache_print_line (DCACHE *dcache, int index)
 545 {
 546   splay_tree_node n;
 547   struct dcache_block *db;
 548   int i, j;
 549
 550   if (dcache == NULL)
 551     {
 552       printf_filtered (_("No data cache available.\n"));
 553       return;
 554     }
 555
 556   n = splay_tree_min (dcache->tree);
 557
 558   for (i = index; i > 0; --i)
 559     {
 560       if (!n)
 561         break;
 562       n = splay_tree_successor (dcache->tree, n->key);
 563     }
 564
 565   if (!n)
 566     {
 567       printf_filtered (_("No such cache line exists.\n"));
 568       return;
 569     }
 570
 571   db = (struct dcache_block *) n->value;
 572
 573   printf_filtered (_("Line %d: address %s [%d hits]\n"),
 574                    index, paddress (target_gdbarch (), db->addr), db->refs);
 575
 576   for (j = 0; j < dcache->line_size; j++)
 577     {
 578       printf_filtered ("%02x ", db->data[j]);
 579
 580       /* Print a newline every 16 bytes (48 characters).  */
 581       if ((j % 16 == 15) && (j != dcache->line_size - 1))
 582         printf_filtered ("\n");
 583     }
 584   printf_filtered ("\n");
 585 }
 586
 587 /* Parse EXP and show the info about DCACHE.  */
 588
 589 static void
 590 dcache_info_1 (DCACHE *dcache, char *exp)
 591 {
 592   splay_tree_node n;
 593   int i, refcount;
 594
 595   if (exp)
 596     {
 597       char *linestart;
 598
 599       i = strtol (exp, &linestart, 10);
 600       if (linestart == exp || i < 0)
 601         {
 602           printf_filtered (_("Usage: info dcache [linenumber]\n"));
 603           return;
 604         }
 605
 606       dcache_print_line (dcache, i);
 607       return;
 608     }
 609
 610   printf_filtered (_("Dcache %u lines of %u bytes each.\n"),
 611                    dcache_size,
 612                    dcache ? (unsigned) dcache->line_size
 613                    : dcache_line_size);
 614
 615   if (dcache == NULL || ptid_equal (dcache->ptid, null_ptid))
 616     {
 617       printf_filtered (_("No data cache available.\n"));
 618       return;
 619     }
 620
 621   printf_filtered (_("Contains data for %s\n"),
 622                    target_pid_to_str (dcache->ptid));
 623
 624   refcount = 0;
 625
 626   n = splay_tree_min (dcache->tree);
 627   i = 0;
 628
 629   while (n)
 630     {
 631       struct dcache_block *db = (struct dcache_block *) n->value;
 632
 633       printf_filtered (_("Line %d: address %s [%d hits]\n"),
 634                        i, paddress (target_gdbarch (), db->addr), db->refs);
 635       i++;
 636       refcount += db->refs;
 637
 638       n = splay_tree_successor (dcache->tree, n->key);
 639     }
 640
 641   printf_filtered (_("Cache state: %d active lines, %d hits\n"), i, refcount);
 642 }
 643
 644 static void
 645 dcache_info (char *exp, int tty)
 646 {
 647   dcache_info_1 (target_dcache_get (), exp);
 648 }
 649
 650 static void
 651 set_dcache_size (char *args, int from_tty,
 652                  struct cmd_list_element *c)
 653 {
 654   if (dcache_size == 0)
 655     {
 656       dcache_size = DCACHE_DEFAULT_SIZE;
 657       error (_("Dcache size must be greater than 0."));
 658     }
 659   target_dcache_invalidate ();
 660 }
 661
 662 static void
 663 set_dcache_line_size (char *args, int from_tty,
 664                       struct cmd_list_element *c)
 665 {
 666   if (dcache_line_size < 2
 667       || (dcache_line_size & (dcache_line_size - 1)) != 0)
 668     {
 669       unsigned d = dcache_line_size;
 670       dcache_line_size = DCACHE_DEFAULT_LINE_SIZE;
 671       error (_("Invalid dcache line size: %u (must be power of 2)."), d);
 672     }
 673   target_dcache_invalidate ();
 674 }
 675
 676 static void
 677 set_dcache_command (char *arg, int from_tty)
 678 {
 679   printf_unfiltered (
 680      "\"set dcache\" must be followed by the name of a subcommand.\n");
 681   help_list (dcache_set_list, "set dcache ", all_commands, gdb_stdout);
 682 }
 683
 684 static void
 685 show_dcache_command (char *args, int from_tty)
 686 {
 687   cmd_show_list (dcache_show_list, from_tty, "");
 688 }
 689
 690 void
 691 _initialize_dcache (void)
 692 {
 693   add_setshow_boolean_cmd ("remotecache", class_support,
 694                            &dcache_enabled_p, _("\
 695 Set cache use for remote targets."), _("\
 696 Show cache use for remote targets."), _("\
 697 This used to enable the data cache for remote targets.  The cache\n\
 698 functionality is now controlled by the memory region system and the\n\
 699 \"stack-cache\" flag; \"remotecache\" now does nothing and\n\
 700 exists only for compatibility reasons."),
 701                            NULL,
 702                            show_dcache_enabled_p,
 703                            &setlist, &showlist);
 704
 705   add_info ("dcache", dcache_info,
 706             _("\
 707 Print information on the dcache performance.\n\
 708 With no arguments, this command prints the cache configuration and a\n\
 709 summary of each line in the cache.  Use \"info dcache <lineno> to dump\"\n\
 710 the contents of a given line."));
 711
 712   add_prefix_cmd ("dcache", class_obscure, set_dcache_command, _("\
 713 Use this command to set number of lines in dcache and line-size."),
 714                   &dcache_set_list, "set dcache ", /*allow_unknown*/0, &setlist);
 715   add_prefix_cmd ("dcache", class_obscure, show_dcache_command, _("\
 716 Show dcachesettings."),
 717                   &dcache_show_list, "show dcache ", /*allow_unknown*/0, &showlist);
 718
 719   add_setshow_zuinteger_cmd ("line-size", class_obscure,
 720                              &dcache_line_size, _("\
 721 Set dcache line size in bytes (must be power of 2)."), _("\
 722 Show dcache line size."),
 723                              NULL,
 724                              set_dcache_line_size,
 725                              NULL,
 726                              &dcache_set_list, &dcache_show_list);
 727   add_setshow_zuinteger_cmd ("size", class_obscure,
 728                              &dcache_size, _("\
 729 Set number of dcache lines."), _("\
 730 Show number of dcache lines."),
 731                              NULL,
 732                              set_dcache_size,
 733                              NULL,
 734                              &dcache_set_list, &dcache_show_list);
 735 }