1 /* Caching code. Typically used by remote back ends for
4 Copyright 1992, 1993 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #if defined(__STDC__) && defined(__linux__)
27 /* In case the system header files define a prototype for insque and
28 remque that uses a pointer to a struct qelem, silence the warnings */
30 #define insque(a,b) (insque)((struct qelem *)(a), (struct qelem *)(b))
31 #define remque(a) (remque)((struct qelem *)(a))
34 int remote_dcache = 0;
36 /* The data cache records all the data read from the remote machine
37 since the last time it stopped.
39 Each cache block holds LINE_SIZE bytes of data
40 starting at a multiple-of-LINE_SIZE address. */
42 #define LINE_SIZE_MASK ((LINE_SIZE - 1)) /* eg 7*2+1= 111*/
43 #define XFORM(x) (((x) & LINE_SIZE_MASK) >> 2)
45 /* Free all the data cache blocks, thus discarding all cached data. */
50 register struct dcache_block *db;
52 if (remote_dcache > 0)
53 while ((db = dcache->dcache_valid.next) != &dcache->dcache_valid)
56 insque (db, &dcache->dcache_free);
63 * If addr is present in the dcache, return the address of the block
68 dcache_hit (dcache, addr)
72 register struct dcache_block *db;
75 || remote_dcache == 0)
78 /* Search all cache blocks for one that is at this address. */
79 db = dcache->dcache_valid.next;
80 while (db != &dcache->dcache_valid)
82 if ((addr & ~LINE_SIZE_MASK) == db->addr)
90 /* Return the int data at address ADDR in dcache block DC. */
93 dcache_value (db, addr)
94 struct dcache_block *db;
98 || remote_dcache == 0)
100 return (db->data[XFORM (addr)]);
103 /* Get a free cache block, put or keep it on the valid list,
104 and return its address. The caller should store into the block
105 the address and data that it describes, then remque it from the
106 free list and insert it into the valid list. This procedure
107 prevents errors from creeping in if a memory retrieval is
108 interrupted (which used to put garbage blocks in the valid
111 struct dcache_block *
112 dcache_alloc (dcache)
115 register struct dcache_block *db;
117 if (remote_dcache == 0)
120 if ((db = dcache->dcache_free.next) == &dcache->dcache_free)
122 /* If we can't get one from the free list, take last valid and put
123 it on the free list. */
124 db = dcache->dcache_valid.last;
126 insque (db, &dcache->dcache_free);
130 insque (db, &dcache->dcache_valid);
134 /* Using the data cache DCACHE return the contents of the word at
135 address ADDR in the remote machine. */
137 dcache_fetch (dcache, addr)
141 register struct dcache_block *db;
143 if (remote_dcache == 0)
147 (*dcache->read_memory) (addr, (unsigned char *) &i, 4);
151 db = dcache_hit (dcache, addr);
154 db = dcache_alloc (dcache);
156 (*dcache->read_memory) (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
158 db->addr = addr & ~LINE_SIZE_MASK;
159 remque (db); /* Off the free list */
160 insque (db, &dcache->dcache_valid); /* On the valid list */
162 return (dcache_value (db, addr));
165 /* Write the word at ADDR both in the data cache and in the remote machine. */
167 dcache_poke (dcache, addr, data)
172 register struct dcache_block *db;
174 if (remote_dcache == 0)
176 (*dcache->write_memory) (addr, (unsigned char *) &data, 4);
180 /* First make sure the word is IN the cache. DB is its cache block. */
181 db = dcache_hit (dcache, addr);
184 db = dcache_alloc (dcache);
186 (*dcache->write_memory) (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
188 db->addr = addr & ~LINE_SIZE_MASK;
189 remque (db); /* Off the free list */
190 insque (db, &dcache->dcache_valid); /* On the valid list */
193 /* Modify the word in the cache. */
194 db->data[XFORM (addr)] = data;
196 /* Send the changed word. */
198 (*dcache->write_memory) (addr, (unsigned char *) &data, 4);
202 /* Initialize the data cache. */
204 dcache_init (reading, writing)
209 register struct dcache_block *db;
212 dcache = (DCACHE *) xmalloc (sizeof (*dcache));
213 dcache->read_memory = reading;
214 dcache->write_memory = writing;
215 dcache->the_cache = (struct dcache_block *)
216 xmalloc (sizeof (*dcache->the_cache) * DCACHE_SIZE);
218 dcache->dcache_free.next = dcache->dcache_free.last = &dcache->dcache_free;
219 dcache->dcache_valid.next = dcache->dcache_valid.last = &dcache->dcache_valid;
220 for (db = dcache->the_cache, i = 0; i < DCACHE_SIZE; i++, db++)
221 insque (db, &dcache->dcache_free);
227 _initialitize_dcache ()
230 (add_set_cmd ("remotecache", class_support, var_boolean,
231 (char *) &remote_dcache,
233 Set cache use for remote targets.\n\
234 When on, use data caching for remote targets. For many remote targets\n\
235 this option can offer better throughput for reading target memory.\n\
236 Unfortunately, gdb does not currently know anything about volatile\n\
237 registers and thus data caching will produce incorrect results with\n\
238 volatile registers are in use. By default, this option is off.",