GDB (xrefs)
Loading...
Searching...
No Matches
dcache.c
Go to the documentation of this file.
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'. */
30static struct cmd_list_element *dcache_set_list = NULL;
31static 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
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
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
94{
95 /* For least-recently-allocated and free lists. */
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
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. */
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. */
123};
124
125typedef void (block_func) (struct dcache_block *block, void *param);
126
127static struct dcache_block *dcache_hit (DCACHE *dcache, CORE_ADDR addr);
128
129static int dcache_read_line (DCACHE *dcache, struct dcache_block *db);
130
131static struct dcache_block *dcache_alloc (DCACHE *dcache, CORE_ADDR addr);
132
133static bool dcache_enabled_p = false; /* OBSOLETE */
134
135static void
136show_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
149static void
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
171static void
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
194static void
195for_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
215static void
216free_block (struct dcache_block *block, void *param)
217{
218 xfree (block);
219}
220
221/* Free a data cache. */
222
223void
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
237static void
238invalidate_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
248void
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
271static void
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
288static struct dcache_block *
289dcache_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
308static int
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
356static struct dcache_block *
357dcache_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
399static int
400dcache_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
425static void
426dcache_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
434static int
435dcache_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
447DCACHE *
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
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
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
528void
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
548static void
549dcache_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 (target_gdbarch (), db->addr), 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
594static void
595dcache_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"),
617 dcache ? (unsigned) 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 (target_gdbarch (), db->addr), db->refs);
640 i++;
641 refcount += db->refs;
642
643 n = splay_tree_successor (dcache->tree, n->key);
644 }
645
646 gdb_printf (_("Cache state: %d active lines, %d hits\n"), i, refcount);
647}
648
649static void
650info_dcache_command (const char *exp, int tty)
651{
653}
654
655static void
656set_dcache_size (const char *args, int from_tty,
657 struct cmd_list_element *c)
658{
659 if (dcache_size == 0)
660 {
662 error (_("Dcache size must be greater than 0."));
663 }
665}
666
667static void
668set_dcache_line_size (const char *args, int from_tty,
669 struct cmd_list_element *c)
670{
671 if (dcache_line_size < 2
672 || (dcache_line_size & (dcache_line_size - 1)) != 0)
673 {
674 unsigned d = dcache_line_size;
676 error (_("Invalid dcache line size: %u (must be power of 2)."), d);
677 }
679}
680
681void _initialize_dcache ();
682void
684{
686 &dcache_enabled_p, _("\
687Set cache use for remote targets."), _("\
688Show cache use for remote targets."), _("\
689This used to enable the data cache for remote targets. The cache\n\
690functionality is now controlled by the memory region system and the\n\
691\"stack-cache\" flag; \"remotecache\" now does nothing and\n\
692exists only for compatibility reasons."),
693 NULL,
695 &setlist, &showlist);
696
697 add_info ("dcache", info_dcache_command,
698 _("\
699Print information on the dcache performance.\n\
700Usage: info dcache [LINENUMBER]\n\
701With no arguments, this command prints the cache configuration and a\n\
702summary of each line in the cache. With an argument, dump\"\n\
703the contents of the given line."));
704
706 _("\
707Use this command to set number of lines in dcache and line-size."),
708 ("Show dcache settings."),
710 &setlist, &showlist);
711
713 &dcache_line_size, _("\
714Set dcache line size in bytes (must be power of 2)."), _("\
715Show dcache line size."),
716 NULL,
718 NULL,
721 &dcache_size, _("\
722Set number of dcache lines."), _("\
723Show number of dcache lines."),
724 NULL,
726 NULL,
728}
void * xmalloc(YYSIZE_T)
void xfree(void *)
struct gdbarch * target_gdbarch(void)
struct process_stratum_target * process_target()
Definition inferior.h:449
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * setlist
Definition cli-cmds.c:119
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
Definition cli-decode.c:428
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
@ class_obscure
Definition command.h:64
@ class_support
Definition command.h:58
static void append_block(struct dcache_block **blist, struct dcache_block *block)
Definition dcache.c:150
static void set_dcache_size(const char *args, int from_tty, struct cmd_list_element *c)
Definition dcache.c:656
static struct dcache_block * dcache_hit(DCACHE *dcache, CORE_ADDR addr)
Definition dcache.c:289
static unsigned dcache_line_size
Definition dcache.c:84
DCACHE * dcache_init(void)
Definition dcache.c:448
static void dcache_poke_byte(DCACHE *dcache, CORE_ADDR addr, const gdb_byte *ptr)
Definition dcache.c:426
static void dcache_invalidate_line(DCACHE *dcache, CORE_ADDR addr)
Definition dcache.c:272
void dcache_invalidate(DCACHE *dcache)
Definition dcache.c:249
static void show_dcache_enabled_p(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition dcache.c:136
void _initialize_dcache()
Definition dcache.c:683
static void info_dcache_command(const char *exp, int tty)
Definition dcache.c:650
#define MASK(dcache, x)
Definition dcache.c:91
static int dcache_splay_tree_compare(splay_tree_key a, splay_tree_key b)
Definition dcache.c:435
static struct cmd_list_element * dcache_show_list
Definition dcache.c:31
static int dcache_read_line(DCACHE *dcache, struct dcache_block *db)
Definition dcache.c:309
#define DCACHE_DEFAULT_SIZE
Definition dcache.c:77
static void for_each_block(struct dcache_block **blist, block_func *func, void *param)
Definition dcache.c:195
static void remove_block(struct dcache_block **blist, struct dcache_block *block)
Definition dcache.c:172
static struct dcache_block * dcache_alloc(DCACHE *dcache, CORE_ADDR addr)
Definition dcache.c:357
static void dcache_info_1(DCACHE *dcache, const char *exp)
Definition dcache.c:595
void dcache_update(DCACHE *dcache, enum target_xfer_status status, CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len)
Definition dcache.c:529
enum target_xfer_status dcache_read_memory_partial(struct target_ops *ops, DCACHE *dcache, CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len, ULONGEST *xfered_len)
Definition dcache.c:473
static void dcache_print_line(DCACHE *dcache, int index)
Definition dcache.c:549
static int dcache_peek_byte(DCACHE *dcache, CORE_ADDR addr, gdb_byte *ptr)
Definition dcache.c:400
static void set_dcache_line_size(const char *args, int from_tty, struct cmd_list_element *c)
Definition dcache.c:668
#define DCACHE_DEFAULT_LINE_SIZE
Definition dcache.c:83
void dcache_free(DCACHE *dcache)
Definition dcache.c:224
static void invalidate_block(struct dcache_block *block, void *param)
Definition dcache.c:238
static bool dcache_enabled_p
Definition dcache.c:133
static void free_block(struct dcache_block *block, void *param)
Definition dcache.c:216
void block_func(struct dcache_block *block, void *param)
Definition dcache.c:125
static struct cmd_list_element * dcache_set_list
Definition dcache.c:30
static unsigned dcache_size
Definition dcache.c:78
#define XFORM(dcache, x)
Definition dcache.c:90
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
ptid_t inferior_ptid
Definition infcmd.c:74
struct inferior * current_inferior(void)
Definition inferior.c:55
struct mem_region * lookup_mem_region(CORE_ADDR addr)
Definition memattr.c:163
@ MEM_WO
Definition memattr.h:28
void(* func)(remote_target *remote, char *)
Definition block.h:109
gdb_byte data[1]
Definition dcache.c:101
CORE_ADDR addr
Definition dcache.c:99
struct dcache_block * next
Definition dcache.c:97
struct dcache_block * prev
Definition dcache.c:96
struct dcache_block * freelist
Definition dcache.c:111
struct dcache_block * oldest
Definition dcache.c:107
ptid_t ptid
Definition dcache.c:118
CORE_ADDR line_size
Definition dcache.c:115
splay_tree tree
Definition dcache.c:106
process_stratum_target * proc_target
Definition dcache.c:122
enum mem_access_mode mode
Definition memattr.h:65
CORE_ADDR hi
Definition memattr.h:115
mem_attrib attrib
Definition memattr.h:125
Definition value.h:130
void target_dcache_invalidate(void)
DCACHE * target_dcache_get(void)
enum target_xfer_status raw_memory_xfer_partial(struct target_ops *ops, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, LONGEST len, ULONGEST *xfered_len)
Definition target.c:1473
int target_read_raw_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1816
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2623
target_xfer_status
Definition target.h:219
@ TARGET_XFER_OK
Definition target.h:221
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886