1 /* Caching code for GDB, the GNU debugger.
3 Copyright (C) 1992-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
24 #include "target-dcache.h"
26 #include "splay-tree.h"
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
;
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.
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.
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.
50 Lines are only allocated as needed, so DCACHE_SIZE really specifies the
51 *maximum* number of lines in the cache.
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. */
59 /* NOTE: Interaction of dcache and memory region attributes
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()).
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. */
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
;
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
;
85 /* Each cache block holds LINE_SIZE bytes of data
86 starting at a multiple-of-LINE_SIZE address. */
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))
94 /* For least-recently-allocated and free lists. */
95 struct dcache_block
*prev
;
96 struct dcache_block
*next
;
98 CORE_ADDR addr
; /* address of data */
99 int refs
; /* # hits */
100 gdb_byte data
[1]; /* line_size bytes at given address */
106 struct dcache_block
*oldest
; /* least-recently-allocated list. */
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
;
112 /* The number of in-use lines in the cache. */
114 CORE_ADDR line_size
; /* current line_size. */
116 /* The ptid of last inferior to use cache or null_ptid. */
120 typedef void (block_func
) (struct dcache_block
*block
, void *param
);
122 static struct dcache_block
*dcache_hit (DCACHE
*dcache
, CORE_ADDR addr
);
124 static int dcache_read_line (DCACHE
*dcache
, struct dcache_block
*db
);
126 static struct dcache_block
*dcache_alloc (DCACHE
*dcache
, CORE_ADDR addr
);
128 static void dcache_info (char *exp
, int tty
);
130 void _initialize_dcache (void);
132 static int dcache_enabled_p
= 0; /* OBSOLETE */
135 show_dcache_enabled_p (struct ui_file
*file
, int from_tty
,
136 struct cmd_list_element
*c
, const char *value
)
138 fprintf_filtered (file
, _("Deprecated remotecache flag is %s.\n"), value
);
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? */
149 append_block (struct dcache_block
**blist
, struct dcache_block
*block
)
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. */
168 /* Remove BLOCK from circular block list BLIST. */
171 remove_block (struct dcache_block
**blist
, struct dcache_block
*block
)
173 if (block
->next
== block
)
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. */
185 *blist
= block
->next
;
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. */
194 for_each_block (struct dcache_block
**blist
, block_func
*func
, void *param
)
196 struct dcache_block
*db
;
204 struct dcache_block
*next
= db
->next
;
209 while (*blist
&& db
!= *blist
);
212 /* BLOCK_FUNC routine for dcache_free. */
215 free_block (struct dcache_block
*block
, void *param
)
220 /* Free a data cache. */
223 dcache_free (DCACHE
*dcache
)
225 splay_tree_delete (dcache
->tree
);
226 for_each_block (&dcache
->oldest
, free_block
, NULL
);
227 for_each_block (&dcache
->freelist
, free_block
, NULL
);
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. */
237 invalidate_block (struct dcache_block
*block
, void *param
)
239 DCACHE
*dcache
= (DCACHE
*) param
;
241 splay_tree_remove (dcache
->tree
, (splay_tree_key
) block
->addr
);
242 append_block (&dcache
->freelist
, block
);
245 /* Free all the data cache blocks, thus discarding all cached data. */
248 dcache_invalidate (DCACHE
*dcache
)
250 for_each_block (&dcache
->oldest
, invalidate_block
, dcache
);
252 dcache
->oldest
= NULL
;
254 dcache
->ptid
= null_ptid
;
256 if (dcache
->line_size
!= dcache_line_size
)
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. */
261 for_each_block (&dcache
->freelist
, free_block
, dcache
);
262 dcache
->freelist
= NULL
;
263 dcache
->line_size
= dcache_line_size
;
267 /* Invalidate the line associated with ADDR. */
270 dcache_invalidate_line (DCACHE
*dcache
, CORE_ADDR addr
)
272 struct dcache_block
*db
= dcache_hit (dcache
, addr
);
276 splay_tree_remove (dcache
->tree
, (splay_tree_key
) db
->addr
);
277 remove_block (&dcache
->oldest
, db
);
278 append_block (&dcache
->freelist
, db
);
283 /* If addr is present in the dcache, return the address of the block
284 containing it. Otherwise return NULL. */
286 static struct dcache_block
*
287 dcache_hit (DCACHE
*dcache
, CORE_ADDR addr
)
289 struct dcache_block
*db
;
291 splay_tree_node node
= splay_tree_lookup (dcache
->tree
,
292 (splay_tree_key
) MASK (dcache
, addr
));
297 db
= (struct dcache_block
*) node
->value
;
302 /* Fill a cache line from target memory.
303 The result is 1 for success, 0 if the (entire) cache line
307 dcache_read_line (DCACHE
*dcache
, struct dcache_block
*db
)
314 struct mem_region
*region
;
316 len
= dcache
->line_size
;
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
)
327 reg_len
= region
->hi
- memaddr
;
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
)
339 res
= target_read_raw_memory (memaddr
, myaddr
, reg_len
);
351 /* Get a free cache block, put or keep it on the valid list,
352 and return its address. */
354 static struct dcache_block
*
355 dcache_alloc (DCACHE
*dcache
, CORE_ADDR addr
)
357 struct dcache_block
*db
;
359 if (dcache
->size
>= dcache_size
)
361 /* Evict the least recently allocated line. */
363 remove_block (&dcache
->oldest
, db
);
365 splay_tree_remove (dcache
->tree
, (splay_tree_key
) db
->addr
);
369 db
= dcache
->freelist
;
371 remove_block (&dcache
->freelist
, db
);
373 db
= xmalloc (offsetof (struct dcache_block
, data
) +
379 db
->addr
= MASK (dcache
, addr
);
382 /* Put DB at the end of the list, it's the newest. */
383 append_block (&dcache
->oldest
, db
);
385 splay_tree_insert (dcache
->tree
, (splay_tree_key
) db
->addr
,
386 (splay_tree_value
) db
);
391 /* Using the data cache DCACHE, store in *PTR the contents of the byte at
392 address ADDR in the remote machine.
394 Returns 1 for success, 0 for error. */
397 dcache_peek_byte (DCACHE
*dcache
, CORE_ADDR addr
, gdb_byte
*ptr
)
399 struct dcache_block
*db
= dcache_hit (dcache
, addr
);
403 db
= dcache_alloc (dcache
, addr
);
405 if (!dcache_read_line (dcache
, db
))
409 *ptr
= db
->data
[XFORM (dcache
, addr
)];
413 /* Write the byte at PTR into ADDR in the data cache.
415 The caller should have written the data through to target memory
418 If ADDR is not in cache, this function does nothing; writing to an
419 area of memory which wasn't present in the cache doesn't cause it
423 dcache_poke_byte (DCACHE
*dcache
, CORE_ADDR addr
, const gdb_byte
*ptr
)
425 struct dcache_block
*db
= dcache_hit (dcache
, addr
);
428 db
->data
[XFORM (dcache
, addr
)] = *ptr
;
432 dcache_splay_tree_compare (splay_tree_key a
, splay_tree_key b
)
442 /* Allocate and initialize a data cache. */
447 DCACHE
*dcache
= XNEW (DCACHE
);
449 dcache
->tree
= splay_tree_new (dcache_splay_tree_compare
,
453 dcache
->oldest
= NULL
;
454 dcache
->freelist
= NULL
;
456 dcache
->line_size
= dcache_line_size
;
457 dcache
->ptid
= null_ptid
;
463 /* Read LEN bytes from dcache memory at MEMADDR, transferring to
464 debugger address MYADDR. If the data is presently cached, this
465 fills the cache. Arguments/return are like the target_xfer_partial
468 enum target_xfer_status
469 dcache_read_memory_partial (struct target_ops
*ops
, DCACHE
*dcache
,
470 CORE_ADDR memaddr
, gdb_byte
*myaddr
,
471 ULONGEST len
, ULONGEST
*xfered_len
)
475 /* If this is a different inferior from what we've recorded,
478 if (! ptid_equal (inferior_ptid
, dcache
->ptid
))
480 dcache_invalidate (dcache
);
481 dcache
->ptid
= inferior_ptid
;
484 for (i
= 0; i
< len
; i
++)
486 if (!dcache_peek_byte (dcache
, memaddr
+ i
, myaddr
+ i
))
488 /* That failed. Discard its cache line so we don't have a
489 partially read line. */
490 dcache_invalidate_line (dcache
, memaddr
+ i
);
497 /* Even though reading the whole line failed, we may be able to
498 read a piece starting where the caller wanted. */
499 return raw_memory_xfer_partial (ops
, myaddr
, NULL
, memaddr
, len
,
505 return TARGET_XFER_OK
;
509 /* FIXME: There would be some benefit to making the cache write-back and
510 moving the writeback operation to a higher layer, as it could occur
511 after a sequence of smaller writes have been completed (as when a stack
512 frame is constructed for an inferior function call). Note that only
513 moving it up one level to target_xfer_memory[_partial]() is not
514 sufficient since we want to coalesce memory transfers that are
515 "logically" connected but not actually a single call to one of the
516 memory transfer functions. */
518 /* Just update any cache lines which are already present. This is
519 called by the target_xfer_partial machinery when writing raw
523 dcache_update (DCACHE
*dcache
, enum target_xfer_status status
,
524 CORE_ADDR memaddr
, const gdb_byte
*myaddr
,
529 for (i
= 0; i
< len
; i
++)
530 if (status
== TARGET_XFER_OK
)
531 dcache_poke_byte (dcache
, memaddr
+ i
, myaddr
+ i
);
534 /* Discard the whole cache line so we don't have a partially
536 dcache_invalidate_line (dcache
, memaddr
+ i
);
540 /* Print DCACHE line INDEX. */
543 dcache_print_line (DCACHE
*dcache
, int index
)
546 struct dcache_block
*db
;
551 printf_filtered (_("No data cache available.\n"));
555 n
= splay_tree_min (dcache
->tree
);
557 for (i
= index
; i
> 0; --i
)
561 n
= splay_tree_successor (dcache
->tree
, n
->key
);
566 printf_filtered (_("No such cache line exists.\n"));
570 db
= (struct dcache_block
*) n
->value
;
572 printf_filtered (_("Line %d: address %s [%d hits]\n"),
573 index
, paddress (target_gdbarch (), db
->addr
), db
->refs
);
575 for (j
= 0; j
< dcache
->line_size
; j
++)
577 printf_filtered ("%02x ", db
->data
[j
]);
579 /* Print a newline every 16 bytes (48 characters). */
580 if ((j
% 16 == 15) && (j
!= dcache
->line_size
- 1))
581 printf_filtered ("\n");
583 printf_filtered ("\n");
586 /* Parse EXP and show the info about DCACHE. */
589 dcache_info_1 (DCACHE
*dcache
, char *exp
)
598 i
= strtol (exp
, &linestart
, 10);
599 if (linestart
== exp
|| i
< 0)
601 printf_filtered (_("Usage: info dcache [linenumber]\n"));
605 dcache_print_line (dcache
, i
);
609 printf_filtered (_("Dcache %u lines of %u bytes each.\n"),
611 dcache
? (unsigned) dcache
->line_size
614 if (dcache
== NULL
|| ptid_equal (dcache
->ptid
, null_ptid
))
616 printf_filtered (_("No data cache available.\n"));
620 printf_filtered (_("Contains data for %s\n"),
621 target_pid_to_str (dcache
->ptid
));
625 n
= splay_tree_min (dcache
->tree
);
630 struct dcache_block
*db
= (struct dcache_block
*) n
->value
;
632 printf_filtered (_("Line %d: address %s [%d hits]\n"),
633 i
, paddress (target_gdbarch (), db
->addr
), db
->refs
);
635 refcount
+= db
->refs
;
637 n
= splay_tree_successor (dcache
->tree
, n
->key
);
640 printf_filtered (_("Cache state: %d active lines, %d hits\n"), i
, refcount
);
644 dcache_info (char *exp
, int tty
)
646 dcache_info_1 (target_dcache_get (), exp
);
650 set_dcache_size (char *args
, int from_tty
,
651 struct cmd_list_element
*c
)
653 if (dcache_size
== 0)
655 dcache_size
= DCACHE_DEFAULT_SIZE
;
656 error (_("Dcache size must be greater than 0."));
658 target_dcache_invalidate ();
662 set_dcache_line_size (char *args
, int from_tty
,
663 struct cmd_list_element
*c
)
665 if (dcache_line_size
< 2
666 || (dcache_line_size
& (dcache_line_size
- 1)) != 0)
668 unsigned d
= dcache_line_size
;
669 dcache_line_size
= DCACHE_DEFAULT_LINE_SIZE
;
670 error (_("Invalid dcache line size: %u (must be power of 2)."), d
);
672 target_dcache_invalidate ();
676 set_dcache_command (char *arg
, int from_tty
)
679 "\"set dcache\" must be followed by the name of a subcommand.\n");
680 help_list (dcache_set_list
, "set dcache ", all_commands
, gdb_stdout
);
684 show_dcache_command (char *args
, int from_tty
)
686 cmd_show_list (dcache_show_list
, from_tty
, "");
690 _initialize_dcache (void)
692 add_setshow_boolean_cmd ("remotecache", class_support
,
693 &dcache_enabled_p
, _("\
694 Set cache use for remote targets."), _("\
695 Show cache use for remote targets."), _("\
696 This used to enable the data cache for remote targets. The cache\n\
697 functionality is now controlled by the memory region system and the\n\
698 \"stack-cache\" flag; \"remotecache\" now does nothing and\n\
699 exists only for compatibility reasons."),
701 show_dcache_enabled_p
,
702 &setlist
, &showlist
);
704 add_info ("dcache", dcache_info
,
706 Print information on the dcache performance.\n\
707 With no arguments, this command prints the cache configuration and a\n\
708 summary of each line in the cache. Use \"info dcache <lineno> to dump\"\n\
709 the contents of a given line."));
711 add_prefix_cmd ("dcache", class_obscure
, set_dcache_command
, _("\
712 Use this command to set number of lines in dcache and line-size."),
713 &dcache_set_list
, "set dcache ", /*allow_unknown*/0, &setlist
);
714 add_prefix_cmd ("dcache", class_obscure
, show_dcache_command
, _("\
715 Show dcachesettings."),
716 &dcache_show_list
, "show dcache ", /*allow_unknown*/0, &showlist
);
718 add_setshow_zuinteger_cmd ("line-size", class_obscure
,
719 &dcache_line_size
, _("\
720 Set dcache line size in bytes (must be power of 2)."), _("\
721 Show dcache line size."),
723 set_dcache_line_size
,
725 &dcache_set_list
, &dcache_show_list
);
726 add_setshow_zuinteger_cmd ("size", class_obscure
,
728 Set number of dcache lines."), _("\
729 Show number of dcache lines."),
733 &dcache_set_list
, &dcache_show_list
);