2004-07-23 Andrew Cagney <cagney@gnu.org>
[deliverable/binutils-gdb.git] / gdb / regcache.c
1 /* Cache and manage the values of registers for GDB, the GNU debugger.
2
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2004 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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.
12
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.
17
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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 #include "defs.h"
24 #include "inferior.h"
25 #include "target.h"
26 #include "gdbarch.h"
27 #include "gdbcmd.h"
28 #include "regcache.h"
29 #include "reggroups.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
32 #include "gdbcmd.h" /* For maintenanceprintlist. */
33 #include "observer.h"
34
35 /*
36 * DATA STRUCTURE
37 *
38 * Here is the actual register cache.
39 */
40
41 /* Per-architecture object describing the layout of a register cache.
42 Computed once when the architecture is created */
43
44 struct gdbarch_data *regcache_descr_handle;
45
46 struct regcache_descr
47 {
48 /* The architecture this descriptor belongs to. */
49 struct gdbarch *gdbarch;
50
51 /* Is this a ``legacy'' register cache? Such caches reserve space
52 for raw and pseudo registers and allow access to both. */
53 int legacy_p;
54
55 /* The raw register cache. Each raw (or hard) register is supplied
56 by the target interface. The raw cache should not contain
57 redundant information - if the PC is constructed from two
58 registers then those regigisters and not the PC lives in the raw
59 cache. */
60 int nr_raw_registers;
61 long sizeof_raw_registers;
62 long sizeof_raw_register_valid_p;
63
64 /* The cooked register space. Each cooked register in the range
65 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
66 register. The remaining [NR_RAW_REGISTERS
67 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
68 both raw registers and memory by the architecture methods
69 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
70 int nr_cooked_registers;
71 long sizeof_cooked_registers;
72 long sizeof_cooked_register_valid_p;
73
74 /* Offset and size (in 8 bit bytes), of reach register in the
75 register cache. All registers (including those in the range
76 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
77 Assigning all registers an offset makes it possible to keep
78 legacy code, such as that found in read_register_bytes() and
79 write_register_bytes() working. */
80 long *register_offset;
81 long *sizeof_register;
82
83 /* Cached table containing the type of each register. */
84 struct type **register_type;
85 };
86
87 static void
88 init_legacy_regcache_descr (struct gdbarch *gdbarch,
89 struct regcache_descr *descr)
90 {
91 int i;
92 /* FIXME: cagney/2002-05-11: gdbarch_data() should take that
93 ``gdbarch'' as a parameter. */
94 gdb_assert (gdbarch != NULL);
95
96 /* Compute the offset of each register. Legacy architectures define
97 DEPRECATED_REGISTER_BYTE() so use that. */
98 /* FIXME: cagney/2002-11-07: Instead of using
99 DEPRECATED_REGISTER_BYTE() this code should, as is done in
100 init_regcache_descr(), compute the offets at runtime. This
101 currently isn't possible as some ISAs define overlapping register
102 regions - see the mess in read_register_bytes() and
103 write_register_bytes() registers. */
104 descr->sizeof_register
105 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
106 descr->register_offset
107 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
108 for (i = 0; i < descr->nr_cooked_registers; i++)
109 {
110 /* FIXME: cagney/2001-12-04: This code shouldn't need to use
111 DEPRECATED_REGISTER_BYTE(). Unfortunately, legacy code likes
112 to lay the buffer out so that certain registers just happen
113 to overlap. Ulgh! New targets use gdbarch's register
114 read/write and entirely avoid this uglyness. */
115 descr->register_offset[i] = DEPRECATED_REGISTER_BYTE (i);
116 descr->sizeof_register[i] = DEPRECATED_REGISTER_RAW_SIZE (i);
117 gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_RAW_SIZE (i));
118 gdb_assert (MAX_REGISTER_SIZE >= DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
119 }
120
121 /* Compute the real size of the register buffer. Start out by
122 trusting DEPRECATED_REGISTER_BYTES, but then adjust it upwards
123 should that be found to not be sufficient. */
124 /* FIXME: cagney/2002-11-05: Instead of using the macro
125 DEPRECATED_REGISTER_BYTES, this code should, as is done in
126 init_regcache_descr(), compute the total number of register bytes
127 using the accumulated offsets. */
128 descr->sizeof_cooked_registers = DEPRECATED_REGISTER_BYTES; /* OK */
129 for (i = 0; i < descr->nr_cooked_registers; i++)
130 {
131 long regend;
132 /* Keep extending the buffer so that there is always enough
133 space for all registers. The comparison is necessary since
134 legacy code is free to put registers in random places in the
135 buffer separated by holes. Once DEPRECATED_REGISTER_BYTE()
136 is killed this can be greatly simplified. */
137 regend = descr->register_offset[i] + descr->sizeof_register[i];
138 if (descr->sizeof_cooked_registers < regend)
139 descr->sizeof_cooked_registers = regend;
140 }
141 /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
142 in the register cache. Unfortunately some architectures still
143 rely on this and the pseudo_register_write() method. */
144 descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
145 }
146
147 static void *
148 init_regcache_descr (struct gdbarch *gdbarch)
149 {
150 int i;
151 struct regcache_descr *descr;
152 gdb_assert (gdbarch != NULL);
153
154 /* Create an initial, zero filled, table. */
155 descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
156 descr->gdbarch = gdbarch;
157
158 /* Total size of the register space. The raw registers are mapped
159 directly onto the raw register cache while the pseudo's are
160 either mapped onto raw-registers or memory. */
161 descr->nr_cooked_registers = NUM_REGS + NUM_PSEUDO_REGS;
162 descr->sizeof_cooked_register_valid_p = NUM_REGS + NUM_PSEUDO_REGS;
163
164 /* Fill in a table of register types. */
165 descr->register_type
166 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
167 for (i = 0; i < descr->nr_cooked_registers; i++)
168 {
169 if (gdbarch_register_type_p (gdbarch))
170 {
171 gdb_assert (!DEPRECATED_REGISTER_VIRTUAL_TYPE_P ()); /* OK */
172 descr->register_type[i] = gdbarch_register_type (gdbarch, i);
173 }
174 else
175 descr->register_type[i] = DEPRECATED_REGISTER_VIRTUAL_TYPE (i); /* OK */
176 }
177
178 /* Construct a strictly RAW register cache. Don't allow pseudo's
179 into the register cache. */
180 descr->nr_raw_registers = NUM_REGS;
181
182 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
183 array. This pretects GDB from erant code that accesses elements
184 of the global register_valid_p[] array in the range [NUM_REGS
185 .. NUM_REGS + NUM_PSEUDO_REGS). */
186 descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
187
188 /* If an old style architecture, fill in the remainder of the
189 register cache descriptor using the register macros. */
190 /* NOTE: cagney/2003-06-29: If either of DEPRECATED_REGISTER_BYTE or
191 DEPRECATED_REGISTER_RAW_SIZE are still present, things are most likely
192 totally screwed. Ex: an architecture with raw register sizes
193 smaller than what DEPRECATED_REGISTER_BYTE indicates; non
194 monotonic DEPRECATED_REGISTER_BYTE values. For GDB 6 check for
195 these nasty methods and fall back to legacy code when present.
196 Sigh! */
197 if ((!gdbarch_pseudo_register_read_p (gdbarch)
198 && !gdbarch_pseudo_register_write_p (gdbarch)
199 && !gdbarch_register_type_p (gdbarch))
200 || DEPRECATED_REGISTER_BYTE_P ()
201 || DEPRECATED_REGISTER_RAW_SIZE_P ())
202 {
203 descr->legacy_p = 1;
204 init_legacy_regcache_descr (gdbarch, descr);
205 return descr;
206 }
207
208 /* Lay out the register cache.
209
210 NOTE: cagney/2002-05-22: Only register_type() is used when
211 constructing the register cache. It is assumed that the
212 register's raw size, virtual size and type length are all the
213 same. */
214
215 {
216 long offset = 0;
217 descr->sizeof_register
218 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
219 descr->register_offset
220 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
221 for (i = 0; i < descr->nr_cooked_registers; i++)
222 {
223 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
224 descr->register_offset[i] = offset;
225 offset += descr->sizeof_register[i];
226 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
227 }
228 /* Set the real size of the register cache buffer. */
229 descr->sizeof_cooked_registers = offset;
230 }
231
232 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
233 the raw registers. Unfortunately some code still accesses the
234 register array directly using the global registers[]. Until that
235 code has been purged, play safe and over allocating the register
236 buffer. Ulgh! */
237 descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
238
239 /* Sanity check. Confirm that there is agreement between the
240 regcache and the target's redundant DEPRECATED_REGISTER_BYTE (new
241 targets should not even be defining it). */
242 for (i = 0; i < descr->nr_cooked_registers; i++)
243 {
244 if (DEPRECATED_REGISTER_BYTE_P ())
245 gdb_assert (descr->register_offset[i] == DEPRECATED_REGISTER_BYTE (i));
246 #if 0
247 gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_RAW_SIZE (i));
248 gdb_assert (descr->sizeof_register[i] == DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
249 #endif
250 }
251 /* gdb_assert (descr->sizeof_raw_registers == DEPRECATED_REGISTER_BYTES (i)); */
252
253 return descr;
254 }
255
256 static struct regcache_descr *
257 regcache_descr (struct gdbarch *gdbarch)
258 {
259 return gdbarch_data (gdbarch, regcache_descr_handle);
260 }
261
262 /* Utility functions returning useful register attributes stored in
263 the regcache descr. */
264
265 struct type *
266 register_type (struct gdbarch *gdbarch, int regnum)
267 {
268 struct regcache_descr *descr = regcache_descr (gdbarch);
269 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
270 return descr->register_type[regnum];
271 }
272
273 /* Utility functions returning useful register attributes stored in
274 the regcache descr. */
275
276 int
277 register_size (struct gdbarch *gdbarch, int regnum)
278 {
279 struct regcache_descr *descr = regcache_descr (gdbarch);
280 int size;
281 gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
282 size = descr->sizeof_register[regnum];
283 /* NB: The deprecated DEPRECATED_REGISTER_RAW_SIZE, if not provided, defaults
284 to the size of the register's type. */
285 gdb_assert (size == DEPRECATED_REGISTER_RAW_SIZE (regnum)); /* OK */
286 /* NB: Don't check the register's virtual size. It, in say the case
287 of the MIPS, may not match the raw size! */
288 return size;
289 }
290
291 /* The register cache for storing raw register values. */
292
293 struct regcache
294 {
295 struct regcache_descr *descr;
296 /* The register buffers. A read-only register cache can hold the
297 full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
298 register cache can only hold [0 .. NUM_REGS). */
299 char *registers;
300 char *register_valid_p;
301 /* Is this a read-only cache? A read-only cache is used for saving
302 the target's register state (e.g, across an inferior function
303 call or just before forcing a function return). A read-only
304 cache can only be updated via the methods regcache_dup() and
305 regcache_cpy(). The actual contents are determined by the
306 reggroup_save and reggroup_restore methods. */
307 int readonly_p;
308 };
309
310 struct regcache *
311 regcache_xmalloc (struct gdbarch *gdbarch)
312 {
313 struct regcache_descr *descr;
314 struct regcache *regcache;
315 gdb_assert (gdbarch != NULL);
316 descr = regcache_descr (gdbarch);
317 regcache = XMALLOC (struct regcache);
318 regcache->descr = descr;
319 regcache->registers
320 = XCALLOC (descr->sizeof_raw_registers, char);
321 regcache->register_valid_p
322 = XCALLOC (descr->sizeof_raw_register_valid_p, char);
323 regcache->readonly_p = 1;
324 return regcache;
325 }
326
327 void
328 regcache_xfree (struct regcache *regcache)
329 {
330 if (regcache == NULL)
331 return;
332 xfree (regcache->registers);
333 xfree (regcache->register_valid_p);
334 xfree (regcache);
335 }
336
337 static void
338 do_regcache_xfree (void *data)
339 {
340 regcache_xfree (data);
341 }
342
343 struct cleanup *
344 make_cleanup_regcache_xfree (struct regcache *regcache)
345 {
346 return make_cleanup (do_regcache_xfree, regcache);
347 }
348
349 /* Return REGCACHE's architecture. */
350
351 struct gdbarch *
352 get_regcache_arch (const struct regcache *regcache)
353 {
354 return regcache->descr->gdbarch;
355 }
356
357 /* Return a pointer to register REGNUM's buffer cache. */
358
359 static char *
360 register_buffer (const struct regcache *regcache, int regnum)
361 {
362 return regcache->registers + regcache->descr->register_offset[regnum];
363 }
364
365 void
366 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
367 void *src)
368 {
369 struct gdbarch *gdbarch = dst->descr->gdbarch;
370 char buf[MAX_REGISTER_SIZE];
371 int regnum;
372 /* The DST should be `read-only', if it wasn't then the save would
373 end up trying to write the register values back out to the
374 target. */
375 gdb_assert (dst->readonly_p);
376 /* Clear the dest. */
377 memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
378 memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
379 /* Copy over any registers (identified by their membership in the
380 save_reggroup) and mark them as valid. The full [0 .. NUM_REGS +
381 NUM_PSEUDO_REGS) range is checked since some architectures need
382 to save/restore `cooked' registers that live in memory. */
383 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
384 {
385 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
386 {
387 int valid = cooked_read (src, regnum, buf);
388 if (valid)
389 {
390 memcpy (register_buffer (dst, regnum), buf,
391 register_size (gdbarch, regnum));
392 dst->register_valid_p[regnum] = 1;
393 }
394 }
395 }
396 }
397
398 void
399 regcache_restore (struct regcache *dst,
400 regcache_cooked_read_ftype *cooked_read,
401 void *src)
402 {
403 struct gdbarch *gdbarch = dst->descr->gdbarch;
404 char buf[MAX_REGISTER_SIZE];
405 int regnum;
406 /* The dst had better not be read-only. If it is, the `restore'
407 doesn't make much sense. */
408 gdb_assert (!dst->readonly_p);
409 /* Copy over any registers, being careful to only restore those that
410 were both saved and need to be restored. The full [0 .. NUM_REGS
411 + NUM_PSEUDO_REGS) range is checked since some architectures need
412 to save/restore `cooked' registers that live in memory. */
413 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
414 {
415 if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
416 {
417 int valid = cooked_read (src, regnum, buf);
418 if (valid)
419 regcache_cooked_write (dst, regnum, buf);
420 }
421 }
422 }
423
424 static int
425 do_cooked_read (void *src, int regnum, void *buf)
426 {
427 struct regcache *regcache = src;
428 if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
429 /* Don't even think about fetching a register from a read-only
430 cache when the register isn't yet valid. There isn't a target
431 from which the register value can be fetched. */
432 return 0;
433 regcache_cooked_read (regcache, regnum, buf);
434 return 1;
435 }
436
437
438 void
439 regcache_cpy (struct regcache *dst, struct regcache *src)
440 {
441 int i;
442 char *buf;
443 gdb_assert (src != NULL && dst != NULL);
444 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
445 gdb_assert (src != dst);
446 gdb_assert (src->readonly_p || dst->readonly_p);
447 if (!src->readonly_p)
448 regcache_save (dst, do_cooked_read, src);
449 else if (!dst->readonly_p)
450 regcache_restore (dst, do_cooked_read, src);
451 else
452 regcache_cpy_no_passthrough (dst, src);
453 }
454
455 void
456 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
457 {
458 int i;
459 gdb_assert (src != NULL && dst != NULL);
460 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
461 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
462 move of data into the current_regcache(). Doing this would be
463 silly - it would mean that valid_p would be completely invalid. */
464 gdb_assert (dst != current_regcache);
465 memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
466 memcpy (dst->register_valid_p, src->register_valid_p,
467 dst->descr->sizeof_raw_register_valid_p);
468 }
469
470 struct regcache *
471 regcache_dup (struct regcache *src)
472 {
473 struct regcache *newbuf;
474 gdb_assert (current_regcache != NULL);
475 newbuf = regcache_xmalloc (src->descr->gdbarch);
476 regcache_cpy (newbuf, src);
477 return newbuf;
478 }
479
480 struct regcache *
481 regcache_dup_no_passthrough (struct regcache *src)
482 {
483 struct regcache *newbuf;
484 gdb_assert (current_regcache != NULL);
485 newbuf = regcache_xmalloc (src->descr->gdbarch);
486 regcache_cpy_no_passthrough (newbuf, src);
487 return newbuf;
488 }
489
490 int
491 regcache_valid_p (struct regcache *regcache, int regnum)
492 {
493 gdb_assert (regcache != NULL);
494 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
495 return regcache->register_valid_p[regnum];
496 }
497
498 char *
499 deprecated_grub_regcache_for_registers (struct regcache *regcache)
500 {
501 return regcache->registers;
502 }
503
504 /* Global structure containing the current regcache. */
505 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
506 deprecated_register_valid[] currently point into this structure. */
507 struct regcache *current_regcache;
508
509 /* NOTE: this is a write-through cache. There is no "dirty" bit for
510 recording if the register values have been changed (eg. by the
511 user). Therefore all registers must be written back to the
512 target when appropriate. */
513
514 /* REGISTERS contains the cached register values (in target byte order). */
515
516 char *deprecated_registers;
517
518 /* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
519 1 if it has been fetched, and
520 -1 if the register value was not available.
521
522 "Not available" indicates that the target is not not able to supply
523 the register at this state. The register may become available at a
524 later time (after the next resume). This often occures when GDB is
525 manipulating a target that contains only a snapshot of the entire
526 system being debugged - some of the registers in such a system may
527 not have been saved. */
528
529 signed char *deprecated_register_valid;
530
531 /* The thread/process associated with the current set of registers. */
532
533 static ptid_t registers_ptid;
534
535 /*
536 * FUNCTIONS:
537 */
538
539 /* REGISTER_CACHED()
540
541 Returns 0 if the value is not in the cache (needs fetch).
542 >0 if the value is in the cache.
543 <0 if the value is permanently unavailable (don't ask again). */
544
545 int
546 register_cached (int regnum)
547 {
548 return deprecated_register_valid[regnum];
549 }
550
551 /* Record that REGNUM's value is cached if STATE is >0, uncached but
552 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
553
554 void
555 set_register_cached (int regnum, int state)
556 {
557 gdb_assert (regnum >= 0);
558 gdb_assert (regnum < current_regcache->descr->nr_raw_registers);
559 current_regcache->register_valid_p[regnum] = state;
560 }
561
562 /* Return whether register REGNUM is a real register. */
563
564 static int
565 real_register (int regnum)
566 {
567 return regnum >= 0 && regnum < NUM_REGS;
568 }
569
570 /* Observer for the target_changed event. */
571
572 void
573 regcache_observer_target_changed (struct target_ops *target)
574 {
575 registers_changed ();
576 }
577
578 /* Low level examining and depositing of registers.
579
580 The caller is responsible for making sure that the inferior is
581 stopped before calling the fetching routines, or it will get
582 garbage. (a change from GDB version 3, in which the caller got the
583 value from the last stop). */
584
585 /* REGISTERS_CHANGED ()
586
587 Indicate that registers may have changed, so invalidate the cache. */
588
589 void
590 registers_changed (void)
591 {
592 int i;
593
594 registers_ptid = pid_to_ptid (-1);
595
596 /* Force cleanup of any alloca areas if using C alloca instead of
597 a builtin alloca. This particular call is used to clean up
598 areas allocated by low level target code which may build up
599 during lengthy interactions between gdb and the target before
600 gdb gives control to the user (ie watchpoints). */
601 alloca (0);
602
603 for (i = 0; i < current_regcache->descr->nr_raw_registers; i++)
604 set_register_cached (i, 0);
605
606 if (deprecated_registers_changed_hook)
607 deprecated_registers_changed_hook ();
608 }
609
610 /* DEPRECATED_REGISTERS_FETCHED ()
611
612 Indicate that all registers have been fetched, so mark them all valid. */
613
614 /* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
615 code was blatting the registers[] array and then calling this.
616 Since targets should only be using regcache_raw_supply() the need for
617 this function/hack is eliminated. */
618
619 void
620 deprecated_registers_fetched (void)
621 {
622 int i;
623
624 for (i = 0; i < NUM_REGS; i++)
625 set_register_cached (i, 1);
626 /* Do not assume that the pseudo-regs have also been fetched.
627 Fetching all real regs NEVER accounts for pseudo-regs. */
628 }
629
630 /* deprecated_read_register_bytes and deprecated_write_register_bytes
631 are generally a *BAD* idea. They are inefficient because they need
632 to check for partial updates, which can only be done by scanning
633 through all of the registers and seeing if the bytes that are being
634 read/written fall inside of an invalid register. [The main reason
635 this is necessary is that register sizes can vary, so a simple
636 index won't suffice.] It is far better to call read_register_gen
637 and write_register_gen if you want to get at the raw register
638 contents, as it only takes a regnum as an argument, and therefore
639 can't do a partial register update.
640
641 Prior to the recent fixes to check for partial updates, both read
642 and deprecated_write_register_bytes always checked to see if any
643 registers were stale, and then called target_fetch_registers (-1)
644 to update the whole set. This caused really slowed things down for
645 remote targets. */
646
647 /* Copy INLEN bytes of consecutive data from registers
648 starting with the INREGBYTE'th byte of register data
649 into memory at MYADDR. */
650
651 void
652 deprecated_read_register_bytes (int in_start, char *in_buf, int in_len)
653 {
654 int in_end = in_start + in_len;
655 int regnum;
656 char reg_buf[MAX_REGISTER_SIZE];
657
658 /* See if we are trying to read bytes from out-of-date registers. If so,
659 update just those registers. */
660
661 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
662 {
663 int reg_start;
664 int reg_end;
665 int reg_len;
666 int start;
667 int end;
668 int byte;
669
670 reg_start = DEPRECATED_REGISTER_BYTE (regnum);
671 reg_len = DEPRECATED_REGISTER_RAW_SIZE (regnum);
672 reg_end = reg_start + reg_len;
673
674 if (reg_end <= in_start || in_end <= reg_start)
675 /* The range the user wants to read doesn't overlap with regnum. */
676 continue;
677
678 if (REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\0')
679 /* Force the cache to fetch the entire register. */
680 deprecated_read_register_gen (regnum, reg_buf);
681 else
682 /* Legacy note: even though this register is ``invalid'' we
683 still need to return something. It would appear that some
684 code relies on apparent gaps in the register array also
685 being returned. */
686 /* FIXME: cagney/2001-08-18: This is just silly. It defeats
687 the entire register read/write flow of control. Must
688 resist temptation to return 0xdeadbeef. */
689 memcpy (reg_buf, &deprecated_registers[reg_start], reg_len);
690
691 /* Legacy note: This function, for some reason, allows a NULL
692 input buffer. If the buffer is NULL, the registers are still
693 fetched, just the final transfer is skipped. */
694 if (in_buf == NULL)
695 continue;
696
697 /* start = max (reg_start, in_start) */
698 if (reg_start > in_start)
699 start = reg_start;
700 else
701 start = in_start;
702
703 /* end = min (reg_end, in_end) */
704 if (reg_end < in_end)
705 end = reg_end;
706 else
707 end = in_end;
708
709 /* Transfer just the bytes common to both IN_BUF and REG_BUF */
710 for (byte = start; byte < end; byte++)
711 {
712 in_buf[byte - in_start] = reg_buf[byte - reg_start];
713 }
714 }
715 }
716
717 /* Read register REGNUM into memory at MYADDR, which must be large
718 enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
719 register is known to be the size of a CORE_ADDR or smaller,
720 read_register can be used instead. */
721
722 static void
723 legacy_read_register_gen (int regnum, char *myaddr)
724 {
725 gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
726 if (! ptid_equal (registers_ptid, inferior_ptid))
727 {
728 registers_changed ();
729 registers_ptid = inferior_ptid;
730 }
731
732 if (!register_cached (regnum))
733 target_fetch_registers (regnum);
734
735 memcpy (myaddr, register_buffer (current_regcache, regnum),
736 DEPRECATED_REGISTER_RAW_SIZE (regnum));
737 }
738
739 void
740 regcache_raw_read (struct regcache *regcache, int regnum, void *buf)
741 {
742 gdb_assert (regcache != NULL && buf != NULL);
743 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
744 if (regcache->descr->legacy_p
745 && !regcache->readonly_p)
746 {
747 gdb_assert (regcache == current_regcache);
748 /* For moment, just use underlying legacy code. Ulgh!!! This
749 silently and very indirectly updates the regcache's regcache
750 via the global deprecated_register_valid[]. */
751 legacy_read_register_gen (regnum, buf);
752 return;
753 }
754 /* Make certain that the register cache is up-to-date with respect
755 to the current thread. This switching shouldn't be necessary
756 only there is still only one target side register cache. Sigh!
757 On the bright side, at least there is a regcache object. */
758 if (!regcache->readonly_p)
759 {
760 gdb_assert (regcache == current_regcache);
761 if (! ptid_equal (registers_ptid, inferior_ptid))
762 {
763 registers_changed ();
764 registers_ptid = inferior_ptid;
765 }
766 if (!register_cached (regnum))
767 target_fetch_registers (regnum);
768 }
769 /* Copy the value directly into the register cache. */
770 memcpy (buf, register_buffer (regcache, regnum),
771 regcache->descr->sizeof_register[regnum]);
772 }
773
774 void
775 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
776 {
777 char *buf;
778 gdb_assert (regcache != NULL);
779 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
780 buf = alloca (regcache->descr->sizeof_register[regnum]);
781 regcache_raw_read (regcache, regnum, buf);
782 (*val) = extract_signed_integer (buf,
783 regcache->descr->sizeof_register[regnum]);
784 }
785
786 void
787 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
788 ULONGEST *val)
789 {
790 char *buf;
791 gdb_assert (regcache != NULL);
792 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
793 buf = alloca (regcache->descr->sizeof_register[regnum]);
794 regcache_raw_read (regcache, regnum, buf);
795 (*val) = extract_unsigned_integer (buf,
796 regcache->descr->sizeof_register[regnum]);
797 }
798
799 void
800 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
801 {
802 void *buf;
803 gdb_assert (regcache != NULL);
804 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
805 buf = alloca (regcache->descr->sizeof_register[regnum]);
806 store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
807 regcache_raw_write (regcache, regnum, buf);
808 }
809
810 void
811 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
812 ULONGEST val)
813 {
814 void *buf;
815 gdb_assert (regcache != NULL);
816 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
817 buf = alloca (regcache->descr->sizeof_register[regnum]);
818 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
819 regcache_raw_write (regcache, regnum, buf);
820 }
821
822 void
823 deprecated_read_register_gen (int regnum, char *buf)
824 {
825 gdb_assert (current_regcache != NULL);
826 gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
827 if (current_regcache->descr->legacy_p)
828 {
829 legacy_read_register_gen (regnum, buf);
830 return;
831 }
832 regcache_cooked_read (current_regcache, regnum, buf);
833 }
834
835 void
836 regcache_cooked_read (struct regcache *regcache, int regnum, void *buf)
837 {
838 gdb_assert (regnum >= 0);
839 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
840 if (regnum < regcache->descr->nr_raw_registers)
841 regcache_raw_read (regcache, regnum, buf);
842 else if (regcache->readonly_p
843 && regnum < regcache->descr->nr_cooked_registers
844 && regcache->register_valid_p[regnum])
845 /* Read-only register cache, perhaps the cooked value was cached? */
846 memcpy (buf, register_buffer (regcache, regnum),
847 regcache->descr->sizeof_register[regnum]);
848 else
849 gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
850 regnum, buf);
851 }
852
853 void
854 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
855 LONGEST *val)
856 {
857 char *buf;
858 gdb_assert (regcache != NULL);
859 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
860 buf = alloca (regcache->descr->sizeof_register[regnum]);
861 regcache_cooked_read (regcache, regnum, buf);
862 (*val) = extract_signed_integer (buf,
863 regcache->descr->sizeof_register[regnum]);
864 }
865
866 void
867 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
868 ULONGEST *val)
869 {
870 char *buf;
871 gdb_assert (regcache != NULL);
872 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
873 buf = alloca (regcache->descr->sizeof_register[regnum]);
874 regcache_cooked_read (regcache, regnum, buf);
875 (*val) = extract_unsigned_integer (buf,
876 regcache->descr->sizeof_register[regnum]);
877 }
878
879 void
880 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
881 LONGEST val)
882 {
883 void *buf;
884 gdb_assert (regcache != NULL);
885 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
886 buf = alloca (regcache->descr->sizeof_register[regnum]);
887 store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
888 regcache_cooked_write (regcache, regnum, buf);
889 }
890
891 void
892 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
893 ULONGEST val)
894 {
895 void *buf;
896 gdb_assert (regcache != NULL);
897 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
898 buf = alloca (regcache->descr->sizeof_register[regnum]);
899 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
900 regcache_cooked_write (regcache, regnum, buf);
901 }
902
903 /* Write register REGNUM at MYADDR to the target. MYADDR points at
904 REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
905
906 static void
907 legacy_write_register_gen (int regnum, const void *myaddr)
908 {
909 int size;
910 gdb_assert (regnum >= 0 && regnum < (NUM_REGS + NUM_PSEUDO_REGS));
911
912 /* On the sparc, writing %g0 is a no-op, so we don't even want to
913 change the registers array if something writes to this register. */
914 if (CANNOT_STORE_REGISTER (regnum))
915 return;
916
917 if (! ptid_equal (registers_ptid, inferior_ptid))
918 {
919 registers_changed ();
920 registers_ptid = inferior_ptid;
921 }
922
923 size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
924
925 if (real_register (regnum))
926 {
927 /* If we have a valid copy of the register, and new value == old
928 value, then don't bother doing the actual store. */
929 if (register_cached (regnum)
930 && (memcmp (register_buffer (current_regcache, regnum), myaddr, size)
931 == 0))
932 return;
933 else
934 target_prepare_to_store ();
935 }
936
937 memcpy (register_buffer (current_regcache, regnum), myaddr, size);
938
939 set_register_cached (regnum, 1);
940 target_store_registers (regnum);
941 }
942
943 void
944 regcache_raw_write (struct regcache *regcache, int regnum, const void *buf)
945 {
946 gdb_assert (regcache != NULL && buf != NULL);
947 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
948 gdb_assert (!regcache->readonly_p);
949
950 if (regcache->descr->legacy_p)
951 {
952 /* For moment, just use underlying legacy code. Ulgh!!! This
953 silently and very indirectly updates the regcache's buffers
954 via the globals deprecated_register_valid[] and registers[]. */
955 gdb_assert (regcache == current_regcache);
956 legacy_write_register_gen (regnum, buf);
957 return;
958 }
959
960 /* On the sparc, writing %g0 is a no-op, so we don't even want to
961 change the registers array if something writes to this register. */
962 if (CANNOT_STORE_REGISTER (regnum))
963 return;
964
965 /* Make certain that the correct cache is selected. */
966 gdb_assert (regcache == current_regcache);
967 if (! ptid_equal (registers_ptid, inferior_ptid))
968 {
969 registers_changed ();
970 registers_ptid = inferior_ptid;
971 }
972
973 /* If we have a valid copy of the register, and new value == old
974 value, then don't bother doing the actual store. */
975 if (regcache_valid_p (regcache, regnum)
976 && (memcmp (register_buffer (regcache, regnum), buf,
977 regcache->descr->sizeof_register[regnum]) == 0))
978 return;
979
980 target_prepare_to_store ();
981 memcpy (register_buffer (regcache, regnum), buf,
982 regcache->descr->sizeof_register[regnum]);
983 regcache->register_valid_p[regnum] = 1;
984 target_store_registers (regnum);
985 }
986
987 void
988 deprecated_write_register_gen (int regnum, char *buf)
989 {
990 gdb_assert (current_regcache != NULL);
991 gdb_assert (current_regcache->descr->gdbarch == current_gdbarch);
992 if (current_regcache->descr->legacy_p)
993 {
994 legacy_write_register_gen (regnum, buf);
995 return;
996 }
997 regcache_cooked_write (current_regcache, regnum, buf);
998 }
999
1000 void
1001 regcache_cooked_write (struct regcache *regcache, int regnum, const void *buf)
1002 {
1003 gdb_assert (regnum >= 0);
1004 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
1005 if (regnum < regcache->descr->nr_raw_registers)
1006 regcache_raw_write (regcache, regnum, buf);
1007 else
1008 gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
1009 regnum, buf);
1010 }
1011
1012 /* Copy INLEN bytes of consecutive data from memory at MYADDR
1013 into registers starting with the MYREGSTART'th byte of register data. */
1014
1015 void
1016 deprecated_write_register_bytes (int myregstart, char *myaddr, int inlen)
1017 {
1018 int myregend = myregstart + inlen;
1019 int regnum;
1020
1021 target_prepare_to_store ();
1022
1023 /* Scan through the registers updating any that are covered by the
1024 range myregstart<=>myregend using write_register_gen, which does
1025 nice things like handling threads, and avoiding updates when the
1026 new and old contents are the same. */
1027
1028 for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
1029 {
1030 int regstart, regend;
1031
1032 regstart = DEPRECATED_REGISTER_BYTE (regnum);
1033 regend = regstart + DEPRECATED_REGISTER_RAW_SIZE (regnum);
1034
1035 /* Is this register completely outside the range the user is writing? */
1036 if (myregend <= regstart || regend <= myregstart)
1037 /* do nothing */ ;
1038
1039 /* Is this register completely within the range the user is writing? */
1040 else if (myregstart <= regstart && regend <= myregend)
1041 deprecated_write_register_gen (regnum, myaddr + (regstart - myregstart));
1042
1043 /* The register partially overlaps the range being written. */
1044 else
1045 {
1046 char regbuf[MAX_REGISTER_SIZE];
1047 /* What's the overlap between this register's bytes and
1048 those the caller wants to write? */
1049 int overlapstart = max (regstart, myregstart);
1050 int overlapend = min (regend, myregend);
1051
1052 /* We may be doing a partial update of an invalid register.
1053 Update it from the target before scribbling on it. */
1054 deprecated_read_register_gen (regnum, regbuf);
1055
1056 memcpy (&deprecated_registers[overlapstart],
1057 myaddr + (overlapstart - myregstart),
1058 overlapend - overlapstart);
1059
1060 target_store_registers (regnum);
1061 }
1062 }
1063 }
1064
1065 /* Perform a partial register transfer using a read, modify, write
1066 operation. */
1067
1068 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
1069 void *buf);
1070 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
1071 const void *buf);
1072
1073 static void
1074 regcache_xfer_part (struct regcache *regcache, int regnum,
1075 int offset, int len, void *in, const void *out,
1076 regcache_read_ftype *read, regcache_write_ftype *write)
1077 {
1078 struct regcache_descr *descr = regcache->descr;
1079 bfd_byte reg[MAX_REGISTER_SIZE];
1080 gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
1081 gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
1082 /* Something to do? */
1083 if (offset + len == 0)
1084 return;
1085 /* Read (when needed) ... */
1086 if (in != NULL
1087 || offset > 0
1088 || offset + len < descr->sizeof_register[regnum])
1089 {
1090 gdb_assert (read != NULL);
1091 read (regcache, regnum, reg);
1092 }
1093 /* ... modify ... */
1094 if (in != NULL)
1095 memcpy (in, reg + offset, len);
1096 if (out != NULL)
1097 memcpy (reg + offset, out, len);
1098 /* ... write (when needed). */
1099 if (out != NULL)
1100 {
1101 gdb_assert (write != NULL);
1102 write (regcache, regnum, reg);
1103 }
1104 }
1105
1106 void
1107 regcache_raw_read_part (struct regcache *regcache, int regnum,
1108 int offset, int len, void *buf)
1109 {
1110 struct regcache_descr *descr = regcache->descr;
1111 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
1112 regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
1113 regcache_raw_read, regcache_raw_write);
1114 }
1115
1116 void
1117 regcache_raw_write_part (struct regcache *regcache, int regnum,
1118 int offset, int len, const void *buf)
1119 {
1120 struct regcache_descr *descr = regcache->descr;
1121 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
1122 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
1123 regcache_raw_read, regcache_raw_write);
1124 }
1125
1126 void
1127 regcache_cooked_read_part (struct regcache *regcache, int regnum,
1128 int offset, int len, void *buf)
1129 {
1130 struct regcache_descr *descr = regcache->descr;
1131 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1132 regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
1133 regcache_cooked_read, regcache_cooked_write);
1134 }
1135
1136 void
1137 regcache_cooked_write_part (struct regcache *regcache, int regnum,
1138 int offset, int len, const void *buf)
1139 {
1140 struct regcache_descr *descr = regcache->descr;
1141 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1142 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
1143 regcache_cooked_read, regcache_cooked_write);
1144 }
1145
1146 /* Hack to keep code that view the register buffer as raw bytes
1147 working. */
1148
1149 int
1150 register_offset_hack (struct gdbarch *gdbarch, int regnum)
1151 {
1152 struct regcache_descr *descr = regcache_descr (gdbarch);
1153 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1154 return descr->register_offset[regnum];
1155 }
1156
1157 /* Return the contents of register REGNUM as an unsigned integer. */
1158
1159 ULONGEST
1160 read_register (int regnum)
1161 {
1162 char *buf = alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum));
1163 deprecated_read_register_gen (regnum, buf);
1164 return (extract_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regnum)));
1165 }
1166
1167 ULONGEST
1168 read_register_pid (int regnum, ptid_t ptid)
1169 {
1170 ptid_t save_ptid;
1171 int save_pid;
1172 CORE_ADDR retval;
1173
1174 if (ptid_equal (ptid, inferior_ptid))
1175 return read_register (regnum);
1176
1177 save_ptid = inferior_ptid;
1178
1179 inferior_ptid = ptid;
1180
1181 retval = read_register (regnum);
1182
1183 inferior_ptid = save_ptid;
1184
1185 return retval;
1186 }
1187
1188 /* Store VALUE into the raw contents of register number REGNUM. */
1189
1190 void
1191 write_register (int regnum, LONGEST val)
1192 {
1193 void *buf;
1194 int size;
1195 size = DEPRECATED_REGISTER_RAW_SIZE (regnum);
1196 buf = alloca (size);
1197 store_signed_integer (buf, size, (LONGEST) val);
1198 deprecated_write_register_gen (regnum, buf);
1199 }
1200
1201 void
1202 write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid)
1203 {
1204 ptid_t save_ptid;
1205
1206 if (ptid_equal (ptid, inferior_ptid))
1207 {
1208 write_register (regnum, val);
1209 return;
1210 }
1211
1212 save_ptid = inferior_ptid;
1213
1214 inferior_ptid = ptid;
1215
1216 write_register (regnum, val);
1217
1218 inferior_ptid = save_ptid;
1219 }
1220
1221 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1222
1223 void
1224 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
1225 {
1226 void *regbuf;
1227 size_t size;
1228
1229 gdb_assert (regcache != NULL);
1230 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1231 gdb_assert (!regcache->readonly_p);
1232
1233 /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
1234 CURRENT_REGCACHE specially here. */
1235 if (regcache == current_regcache
1236 && !ptid_equal (registers_ptid, inferior_ptid))
1237 {
1238 registers_changed ();
1239 registers_ptid = inferior_ptid;
1240 }
1241
1242 regbuf = register_buffer (regcache, regnum);
1243 size = regcache->descr->sizeof_register[regnum];
1244
1245 if (buf)
1246 memcpy (regbuf, buf, size);
1247 else
1248 memset (regbuf, 0, size);
1249
1250 /* Mark the register as cached. */
1251 regcache->register_valid_p[regnum] = 1;
1252 }
1253
1254 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1255
1256 void
1257 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1258 {
1259 const void *regbuf;
1260 size_t size;
1261
1262 gdb_assert (regcache != NULL && buf != NULL);
1263 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1264
1265 regbuf = register_buffer (regcache, regnum);
1266 size = regcache->descr->sizeof_register[regnum];
1267 memcpy (buf, regbuf, size);
1268 }
1269
1270
1271 /* read_pc, write_pc, read_sp, deprecated_read_fp, etc. Special
1272 handling for registers PC, SP, and FP. */
1273
1274 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(),
1275 read_sp(), and deprecated_read_fp(), will eventually be replaced by
1276 per-frame methods. Instead of relying on the global INFERIOR_PTID,
1277 they will use the contextual information provided by the FRAME.
1278 These functions do not belong in the register cache. */
1279
1280 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
1281 write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to
1282 be replaced by something that does not rely on global state. But
1283 what? */
1284
1285 CORE_ADDR
1286 read_pc_pid (ptid_t ptid)
1287 {
1288 ptid_t saved_inferior_ptid;
1289 CORE_ADDR pc_val;
1290
1291 /* In case ptid != inferior_ptid. */
1292 saved_inferior_ptid = inferior_ptid;
1293 inferior_ptid = ptid;
1294
1295 if (TARGET_READ_PC_P ())
1296 pc_val = TARGET_READ_PC (ptid);
1297 /* Else use per-frame method on get_current_frame. */
1298 else if (PC_REGNUM >= 0)
1299 {
1300 CORE_ADDR raw_val = read_register_pid (PC_REGNUM, ptid);
1301 pc_val = ADDR_BITS_REMOVE (raw_val);
1302 }
1303 else
1304 internal_error (__FILE__, __LINE__, "read_pc_pid: Unable to find PC");
1305
1306 inferior_ptid = saved_inferior_ptid;
1307 return pc_val;
1308 }
1309
1310 CORE_ADDR
1311 read_pc (void)
1312 {
1313 return read_pc_pid (inferior_ptid);
1314 }
1315
1316 void
1317 generic_target_write_pc (CORE_ADDR pc, ptid_t ptid)
1318 {
1319 if (PC_REGNUM >= 0)
1320 write_register_pid (PC_REGNUM, pc, ptid);
1321 else
1322 internal_error (__FILE__, __LINE__,
1323 "generic_target_write_pc");
1324 }
1325
1326 void
1327 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
1328 {
1329 ptid_t saved_inferior_ptid;
1330
1331 /* In case ptid != inferior_ptid. */
1332 saved_inferior_ptid = inferior_ptid;
1333 inferior_ptid = ptid;
1334
1335 TARGET_WRITE_PC (pc, ptid);
1336
1337 inferior_ptid = saved_inferior_ptid;
1338 }
1339
1340 void
1341 write_pc (CORE_ADDR pc)
1342 {
1343 write_pc_pid (pc, inferior_ptid);
1344 }
1345
1346 /* Cope with strage ways of getting to the stack and frame pointers */
1347
1348 CORE_ADDR
1349 read_sp (void)
1350 {
1351 if (TARGET_READ_SP_P ())
1352 return TARGET_READ_SP ();
1353 else if (gdbarch_unwind_sp_p (current_gdbarch))
1354 return get_frame_sp (get_current_frame ());
1355 else if (SP_REGNUM >= 0)
1356 /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1357 about the architecture so put it at the end. */
1358 return read_register (SP_REGNUM);
1359 internal_error (__FILE__, __LINE__, "read_sp: Unable to find SP");
1360 }
1361
1362 void
1363 deprecated_write_sp (CORE_ADDR val)
1364 {
1365 gdb_assert (SP_REGNUM >= 0);
1366 write_register (SP_REGNUM, val);
1367 }
1368
1369 CORE_ADDR
1370 deprecated_read_fp (void)
1371 {
1372 if (DEPRECATED_TARGET_READ_FP_P ())
1373 return DEPRECATED_TARGET_READ_FP ();
1374 else if (DEPRECATED_FP_REGNUM >= 0)
1375 return read_register (DEPRECATED_FP_REGNUM);
1376 else
1377 internal_error (__FILE__, __LINE__, "deprecated_read_fp");
1378 }
1379
1380 static void
1381 reg_flush_command (char *command, int from_tty)
1382 {
1383 /* Force-flush the register cache. */
1384 registers_changed ();
1385 if (from_tty)
1386 printf_filtered ("Register cache flushed.\n");
1387 }
1388
1389 static void
1390 build_regcache (void)
1391 {
1392 current_regcache = regcache_xmalloc (current_gdbarch);
1393 current_regcache->readonly_p = 0;
1394 deprecated_registers = deprecated_grub_regcache_for_registers (current_regcache);
1395 deprecated_register_valid = current_regcache->register_valid_p;
1396 }
1397
1398 static void
1399 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1400 const unsigned char *buf, long len)
1401 {
1402 int i;
1403 switch (endian)
1404 {
1405 case BFD_ENDIAN_BIG:
1406 for (i = 0; i < len; i++)
1407 fprintf_unfiltered (file, "%02x", buf[i]);
1408 break;
1409 case BFD_ENDIAN_LITTLE:
1410 for (i = len - 1; i >= 0; i--)
1411 fprintf_unfiltered (file, "%02x", buf[i]);
1412 break;
1413 default:
1414 internal_error (__FILE__, __LINE__, "Bad switch");
1415 }
1416 }
1417
1418 enum regcache_dump_what
1419 {
1420 regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
1421 };
1422
1423 static void
1424 regcache_dump (struct regcache *regcache, struct ui_file *file,
1425 enum regcache_dump_what what_to_dump)
1426 {
1427 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1428 struct gdbarch *gdbarch = regcache->descr->gdbarch;
1429 int regnum;
1430 int footnote_nr = 0;
1431 int footnote_register_size = 0;
1432 int footnote_register_offset = 0;
1433 int footnote_register_type_name_null = 0;
1434 long register_offset = 0;
1435 unsigned char buf[MAX_REGISTER_SIZE];
1436
1437 #if 0
1438 fprintf_unfiltered (file, "legacy_p %d\n", regcache->descr->legacy_p);
1439 fprintf_unfiltered (file, "nr_raw_registers %d\n",
1440 regcache->descr->nr_raw_registers);
1441 fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1442 regcache->descr->nr_cooked_registers);
1443 fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1444 regcache->descr->sizeof_raw_registers);
1445 fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
1446 regcache->descr->sizeof_raw_register_valid_p);
1447 fprintf_unfiltered (file, "NUM_REGS %d\n", NUM_REGS);
1448 fprintf_unfiltered (file, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS);
1449 #endif
1450
1451 gdb_assert (regcache->descr->nr_cooked_registers
1452 == (NUM_REGS + NUM_PSEUDO_REGS));
1453
1454 for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1455 {
1456 /* Name. */
1457 if (regnum < 0)
1458 fprintf_unfiltered (file, " %-10s", "Name");
1459 else
1460 {
1461 const char *p = REGISTER_NAME (regnum);
1462 if (p == NULL)
1463 p = "";
1464 else if (p[0] == '\0')
1465 p = "''";
1466 fprintf_unfiltered (file, " %-10s", p);
1467 }
1468
1469 /* Number. */
1470 if (regnum < 0)
1471 fprintf_unfiltered (file, " %4s", "Nr");
1472 else
1473 fprintf_unfiltered (file, " %4d", regnum);
1474
1475 /* Relative number. */
1476 if (regnum < 0)
1477 fprintf_unfiltered (file, " %4s", "Rel");
1478 else if (regnum < NUM_REGS)
1479 fprintf_unfiltered (file, " %4d", regnum);
1480 else
1481 fprintf_unfiltered (file, " %4d", (regnum - NUM_REGS));
1482
1483 /* Offset. */
1484 if (regnum < 0)
1485 fprintf_unfiltered (file, " %6s ", "Offset");
1486 else
1487 {
1488 fprintf_unfiltered (file, " %6ld",
1489 regcache->descr->register_offset[regnum]);
1490 if (register_offset != regcache->descr->register_offset[regnum]
1491 || register_offset != DEPRECATED_REGISTER_BYTE (regnum)
1492 || (regnum > 0
1493 && (regcache->descr->register_offset[regnum]
1494 != (regcache->descr->register_offset[regnum - 1]
1495 + regcache->descr->sizeof_register[regnum - 1])))
1496 )
1497 {
1498 if (!footnote_register_offset)
1499 footnote_register_offset = ++footnote_nr;
1500 fprintf_unfiltered (file, "*%d", footnote_register_offset);
1501 }
1502 else
1503 fprintf_unfiltered (file, " ");
1504 register_offset = (regcache->descr->register_offset[regnum]
1505 + regcache->descr->sizeof_register[regnum]);
1506 }
1507
1508 /* Size. */
1509 if (regnum < 0)
1510 fprintf_unfiltered (file, " %5s ", "Size");
1511 else
1512 {
1513 fprintf_unfiltered (file, " %5ld",
1514 regcache->descr->sizeof_register[regnum]);
1515 if ((regcache->descr->sizeof_register[regnum]
1516 != DEPRECATED_REGISTER_RAW_SIZE (regnum))
1517 || (regcache->descr->sizeof_register[regnum]
1518 != DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
1519 || (regcache->descr->sizeof_register[regnum]
1520 != TYPE_LENGTH (register_type (regcache->descr->gdbarch,
1521 regnum)))
1522 )
1523 {
1524 if (!footnote_register_size)
1525 footnote_register_size = ++footnote_nr;
1526 fprintf_unfiltered (file, "*%d", footnote_register_size);
1527 }
1528 else
1529 fprintf_unfiltered (file, " ");
1530 }
1531
1532 /* Type. */
1533 {
1534 const char *t;
1535 if (regnum < 0)
1536 t = "Type";
1537 else
1538 {
1539 static const char blt[] = "builtin_type";
1540 t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1541 if (t == NULL)
1542 {
1543 char *n;
1544 if (!footnote_register_type_name_null)
1545 footnote_register_type_name_null = ++footnote_nr;
1546 n = xstrprintf ("*%d", footnote_register_type_name_null);
1547 make_cleanup (xfree, n);
1548 t = n;
1549 }
1550 /* Chop a leading builtin_type. */
1551 if (strncmp (t, blt, strlen (blt)) == 0)
1552 t += strlen (blt);
1553 }
1554 fprintf_unfiltered (file, " %-15s", t);
1555 }
1556
1557 /* Leading space always present. */
1558 fprintf_unfiltered (file, " ");
1559
1560 /* Value, raw. */
1561 if (what_to_dump == regcache_dump_raw)
1562 {
1563 if (regnum < 0)
1564 fprintf_unfiltered (file, "Raw value");
1565 else if (regnum >= regcache->descr->nr_raw_registers)
1566 fprintf_unfiltered (file, "<cooked>");
1567 else if (!regcache_valid_p (regcache, regnum))
1568 fprintf_unfiltered (file, "<invalid>");
1569 else
1570 {
1571 regcache_raw_read (regcache, regnum, buf);
1572 fprintf_unfiltered (file, "0x");
1573 dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1574 DEPRECATED_REGISTER_RAW_SIZE (regnum));
1575 }
1576 }
1577
1578 /* Value, cooked. */
1579 if (what_to_dump == regcache_dump_cooked)
1580 {
1581 if (regnum < 0)
1582 fprintf_unfiltered (file, "Cooked value");
1583 else
1584 {
1585 regcache_cooked_read (regcache, regnum, buf);
1586 fprintf_unfiltered (file, "0x");
1587 dump_endian_bytes (file, TARGET_BYTE_ORDER, buf,
1588 DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
1589 }
1590 }
1591
1592 /* Group members. */
1593 if (what_to_dump == regcache_dump_groups)
1594 {
1595 if (regnum < 0)
1596 fprintf_unfiltered (file, "Groups");
1597 else
1598 {
1599 const char *sep = "";
1600 struct reggroup *group;
1601 for (group = reggroup_next (gdbarch, NULL);
1602 group != NULL;
1603 group = reggroup_next (gdbarch, group))
1604 {
1605 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1606 {
1607 fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1608 sep = ",";
1609 }
1610 }
1611 }
1612 }
1613
1614 fprintf_unfiltered (file, "\n");
1615 }
1616
1617 if (footnote_register_size)
1618 fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1619 footnote_register_size);
1620 if (footnote_register_offset)
1621 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1622 footnote_register_offset);
1623 if (footnote_register_type_name_null)
1624 fprintf_unfiltered (file,
1625 "*%d: Register type's name NULL.\n",
1626 footnote_register_type_name_null);
1627 do_cleanups (cleanups);
1628 }
1629
1630 static void
1631 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1632 {
1633 if (args == NULL)
1634 regcache_dump (current_regcache, gdb_stdout, what_to_dump);
1635 else
1636 {
1637 struct ui_file *file = gdb_fopen (args, "w");
1638 if (file == NULL)
1639 perror_with_name ("maintenance print architecture");
1640 regcache_dump (current_regcache, file, what_to_dump);
1641 ui_file_delete (file);
1642 }
1643 }
1644
1645 static void
1646 maintenance_print_registers (char *args, int from_tty)
1647 {
1648 regcache_print (args, regcache_dump_none);
1649 }
1650
1651 static void
1652 maintenance_print_raw_registers (char *args, int from_tty)
1653 {
1654 regcache_print (args, regcache_dump_raw);
1655 }
1656
1657 static void
1658 maintenance_print_cooked_registers (char *args, int from_tty)
1659 {
1660 regcache_print (args, regcache_dump_cooked);
1661 }
1662
1663 static void
1664 maintenance_print_register_groups (char *args, int from_tty)
1665 {
1666 regcache_print (args, regcache_dump_groups);
1667 }
1668
1669 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1670
1671 void
1672 _initialize_regcache (void)
1673 {
1674 regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1675 DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache);
1676 DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers);
1677 DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid);
1678 deprecated_register_gdbarch_swap (NULL, 0, build_regcache);
1679
1680 observer_attach_target_changed (regcache_observer_target_changed);
1681
1682 add_com ("flushregs", class_maintenance, reg_flush_command,
1683 "Force gdb to flush its register cache (maintainer command)");
1684
1685 /* Initialize the thread/process associated with the current set of
1686 registers. For now, -1 is special, and means `no current process'. */
1687 registers_ptid = pid_to_ptid (-1);
1688
1689 add_cmd ("registers", class_maintenance,
1690 maintenance_print_registers,
1691 "Print the internal register configuration.\
1692 Takes an optional file parameter.",
1693 &maintenanceprintlist);
1694 add_cmd ("raw-registers", class_maintenance,
1695 maintenance_print_raw_registers,
1696 "Print the internal register configuration including raw values.\
1697 Takes an optional file parameter.",
1698 &maintenanceprintlist);
1699 add_cmd ("cooked-registers", class_maintenance,
1700 maintenance_print_cooked_registers,
1701 "Print the internal register configuration including cooked values.\
1702 Takes an optional file parameter.",
1703 &maintenanceprintlist);
1704 add_cmd ("register-groups", class_maintenance,
1705 maintenance_print_register_groups,
1706 "Print the internal register configuration including each register's group.\
1707 Takes an optional file parameter.",
1708 &maintenanceprintlist);
1709
1710 }
This page took 0.074458 seconds and 4 git commands to generate.