1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002 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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
29 #include "gdb_assert.h"
30 #include "gdb_string.h"
31 #include "gdbcmd.h" /* For maintenanceprintlist. */
36 * Here is the actual register cache.
39 /* Per-architecture object describing the layout of a register cache.
40 Computed once when the architecture is created */
42 struct gdbarch_data
*regcache_descr_handle
;
46 /* The architecture this descriptor belongs to. */
47 struct gdbarch
*gdbarch
;
49 /* Is this a ``legacy'' register cache? Such caches reserve space
50 for raw and pseudo registers and allow access to both. */
53 /* The raw register cache. This should contain just [0
54 .. NUM_RAW_REGISTERS). However, for older targets, it contains
55 space for the full [0 .. NUM_RAW_REGISTERS +
56 NUM_PSEUDO_REGISTERS). */
58 long sizeof_raw_registers
;
59 long sizeof_raw_register_valid_p
;
61 /* The cooked register space. Each cooked register in the range
62 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
63 register. The remaining [NR_RAW_REGISTERS
64 .. NR_COOKED_REGISTERS) (a.k.a. pseudo regiters) are mapped onto
65 both raw registers and memory by the architecture methods
66 gdbarch_register_read and gdbarch_register_write. */
67 int nr_cooked_registers
;
69 /* Offset and size (in 8 bit bytes), of reach register in the
70 register cache. All registers (including those in the range
71 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
72 Assigning all registers an offset makes it possible to keep
73 legacy code, such as that found in read_register_bytes() and
74 write_register_bytes() working. */
75 long *register_offset
;
76 long *sizeof_register
;
78 /* Useful constant. Largest of all the registers. */
79 long max_register_size
;
83 init_legacy_regcache_descr (struct gdbarch
*gdbarch
)
86 struct regcache_descr
*descr
;
87 /* FIXME: cagney/2002-05-11: gdbarch_data() should take that
88 ``gdbarch'' as a parameter. */
89 gdb_assert (gdbarch
!= NULL
);
91 descr
= XMALLOC (struct regcache_descr
);
92 descr
->gdbarch
= gdbarch
;
95 /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
96 in the register buffer. Unfortunatly some architectures do. */
97 descr
->nr_cooked_registers
= NUM_REGS
+ NUM_PSEUDO_REGS
;
98 descr
->nr_raw_registers
= descr
->nr_cooked_registers
;
99 descr
->sizeof_raw_register_valid_p
= descr
->nr_cooked_registers
;
101 /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
102 code should compute the offets et.al. at runtime. This currently
103 isn't possible because some targets overlap register locations -
104 see the mess in read_register_bytes() and write_register_bytes()
106 descr
->sizeof_register
= XCALLOC (descr
->nr_cooked_registers
, long);
107 descr
->register_offset
= XCALLOC (descr
->nr_cooked_registers
, long);
108 descr
->max_register_size
= 0;
109 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
111 descr
->register_offset
[i
] = REGISTER_BYTE (i
);
112 descr
->sizeof_register
[i
] = REGISTER_RAW_SIZE (i
);
113 if (descr
->max_register_size
< REGISTER_RAW_SIZE (i
))
114 descr
->max_register_size
= REGISTER_RAW_SIZE (i
);
117 /* Come up with the real size of the registers buffer. */
118 descr
->sizeof_raw_registers
= REGISTER_BYTES
; /* OK use. */
119 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
122 /* Keep extending the buffer so that there is always enough
123 space for all registers. The comparison is necessary since
124 legacy code is free to put registers in random places in the
125 buffer separated by holes. Once REGISTER_BYTE() is killed
126 this can be greatly simplified. */
127 /* FIXME: cagney/2001-12-04: This code shouldn't need to use
128 REGISTER_BYTE(). Unfortunatly, legacy code likes to lay the
129 buffer out so that certain registers just happen to overlap.
130 Ulgh! New targets use gdbarch's register read/write and
131 entirely avoid this uglyness. */
132 regend
= descr
->register_offset
[i
] + descr
->sizeof_register
[i
];
133 if (descr
->sizeof_raw_registers
< regend
)
134 descr
->sizeof_raw_registers
= regend
;
140 init_regcache_descr (struct gdbarch
*gdbarch
)
143 struct regcache_descr
*descr
;
144 gdb_assert (gdbarch
!= NULL
);
146 /* If an old style architecture, construct the register cache
147 description using all the register macros. */
148 if (!gdbarch_pseudo_register_read_p (gdbarch
)
149 && !gdbarch_pseudo_register_write_p (gdbarch
))
150 return init_legacy_regcache_descr (gdbarch
);
152 descr
= XMALLOC (struct regcache_descr
);
153 descr
->gdbarch
= gdbarch
;
156 /* Total size of the register space. The raw registers are mapped
157 directly onto the raw register cache while the pseudo's are
158 either mapped onto raw-registers or memory. */
159 descr
->nr_cooked_registers
= NUM_REGS
+ NUM_PSEUDO_REGS
;
161 /* Construct a strictly RAW register cache. Don't allow pseudo's
162 into the register cache. */
163 descr
->nr_raw_registers
= NUM_REGS
;
164 descr
->sizeof_raw_register_valid_p
= NUM_REGS
;
166 /* Lay out the register cache. The pseud-registers are included in
167 the layout even though their value isn't stored in the register
168 cache. Some code, via read_register_bytes() access a register
169 using an offset/length rather than a register number.
171 NOTE: cagney/2002-05-22: Only REGISTER_VIRTUAL_TYPE() needs to be
172 used when constructing the register cache. It is assumed that
173 register raw size, virtual size and type length of the type are
178 descr
->sizeof_register
= XCALLOC (descr
->nr_cooked_registers
, long);
179 descr
->register_offset
= XCALLOC (descr
->nr_cooked_registers
, long);
180 descr
->max_register_size
= 0;
181 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
183 descr
->sizeof_register
[i
] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i
));
184 descr
->register_offset
[i
] = offset
;
185 offset
+= descr
->sizeof_register
[i
];
186 if (descr
->max_register_size
< descr
->sizeof_register
[i
])
187 descr
->max_register_size
= descr
->sizeof_register
[i
];
189 /* Set the real size of the register cache buffer. */
190 /* FIXME: cagney/2002-05-22: Should only need to allocate space
191 for the raw registers. Unfortunatly some code still accesses
192 the register array directly using the global registers[].
193 Until that code has been purged, play safe and over allocating
194 the register buffer. Ulgh! */
195 descr
->sizeof_raw_registers
= offset
;
196 /* = descr->register_offset[descr->nr_raw_registers]; */
200 /* Sanity check. Confirm that the assumptions about gdbarch are
201 true. The REGCACHE_DESCR_HANDLE is set before doing the checks
202 so that targets using the generic methods supplied by regcache
203 don't go into infinite recursion trying to, again, create the
205 set_gdbarch_data (gdbarch
, regcache_descr_handle
, descr
);
206 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
208 gdb_assert (descr
->sizeof_register
[i
] == REGISTER_RAW_SIZE (i
));
209 gdb_assert (descr
->sizeof_register
[i
] == REGISTER_VIRTUAL_SIZE (i
));
210 gdb_assert (descr
->register_offset
[i
] == REGISTER_BYTE (i
));
212 /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i)); */
218 static struct regcache_descr
*
219 regcache_descr (struct gdbarch
*gdbarch
)
221 return gdbarch_data (gdbarch
, regcache_descr_handle
);
225 xfree_regcache_descr (struct gdbarch
*gdbarch
, void *ptr
)
227 struct regcache_descr
*descr
= ptr
;
230 xfree (descr
->register_offset
);
231 xfree (descr
->sizeof_register
);
232 descr
->register_offset
= NULL
;
233 descr
->sizeof_register
= NULL
;
237 /* The register cache for storing raw register values. */
241 struct regcache_descr
*descr
;
243 char *raw_register_valid_p
;
244 /* If a value isn't in the cache should the corresponding target be
245 queried for a value. */
250 regcache_xmalloc (struct gdbarch
*gdbarch
)
252 struct regcache_descr
*descr
;
253 struct regcache
*regcache
;
254 gdb_assert (gdbarch
!= NULL
);
255 descr
= regcache_descr (gdbarch
);
256 regcache
= XMALLOC (struct regcache
);
257 regcache
->descr
= descr
;
258 regcache
->raw_registers
259 = XCALLOC (descr
->sizeof_raw_registers
, char);
260 regcache
->raw_register_valid_p
261 = XCALLOC (descr
->sizeof_raw_register_valid_p
, char);
262 regcache
->passthrough_p
= 0;
267 regcache_xfree (struct regcache
*regcache
)
269 if (regcache
== NULL
)
271 xfree (regcache
->raw_registers
);
272 xfree (regcache
->raw_register_valid_p
);
277 do_regcache_xfree (void *data
)
279 regcache_xfree (data
);
283 make_cleanup_regcache_xfree (struct regcache
*regcache
)
285 return make_cleanup (do_regcache_xfree
, regcache
);
289 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
293 gdb_assert (src
!= NULL
&& dst
!= NULL
);
294 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
295 gdb_assert (src
!= dst
);
296 /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
297 It keeps the existing code working where things rely on going
298 through to the register cache. */
299 if (src
== current_regcache
&& src
->descr
->legacy_p
)
301 /* ULGH!!!! Old way. Use REGISTER bytes and let code below
303 read_register_bytes (0, dst
->raw_registers
, REGISTER_BYTES
);
306 /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
307 It keeps the existing code working where things rely on going
308 through to the register cache. */
309 if (dst
== current_regcache
&& dst
->descr
->legacy_p
)
311 /* ULGH!!!! Old way. Use REGISTER bytes and let code below
313 write_register_bytes (0, src
->raw_registers
, REGISTER_BYTES
);
316 buf
= alloca (src
->descr
->max_register_size
);
317 for (i
= 0; i
< src
->descr
->nr_raw_registers
; i
++)
319 /* Should we worry about the valid bit here? */
320 regcache_raw_read (src
, i
, buf
);
321 regcache_raw_write (dst
, i
, buf
);
326 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
329 gdb_assert (src
!= NULL
&& dst
!= NULL
);
330 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
331 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
332 move of data into the current_regcache(). Doing this would be
333 silly - it would mean that valid_p would be completly invalid. */
334 gdb_assert (dst
!= current_regcache
);
335 memcpy (dst
->raw_registers
, src
->raw_registers
,
336 dst
->descr
->sizeof_raw_registers
);
337 memcpy (dst
->raw_register_valid_p
, src
->raw_register_valid_p
,
338 dst
->descr
->sizeof_raw_register_valid_p
);
342 regcache_dup (struct regcache
*src
)
344 struct regcache
*newbuf
;
345 gdb_assert (current_regcache
!= NULL
);
346 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
347 regcache_cpy (newbuf
, src
);
352 regcache_dup_no_passthrough (struct regcache
*src
)
354 struct regcache
*newbuf
;
355 gdb_assert (current_regcache
!= NULL
);
356 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
357 regcache_cpy_no_passthrough (newbuf
, src
);
362 regcache_valid_p (struct regcache
*regcache
, int regnum
)
364 gdb_assert (regcache
!= NULL
);
365 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
366 return regcache
->raw_register_valid_p
[regnum
];
370 deprecated_grub_regcache_for_registers (struct regcache
*regcache
)
372 return regcache
->raw_registers
;
376 deprecated_grub_regcache_for_register_valid (struct regcache
*regcache
)
378 return regcache
->raw_register_valid_p
;
381 /* Global structure containing the current regcache. */
382 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
383 register_valid[] currently point into this structure. */
384 struct regcache
*current_regcache
;
386 /* NOTE: this is a write-through cache. There is no "dirty" bit for
387 recording if the register values have been changed (eg. by the
388 user). Therefore all registers must be written back to the
389 target when appropriate. */
391 /* REGISTERS contains the cached register values (in target byte order). */
395 /* REGISTER_VALID is 0 if the register needs to be fetched,
396 1 if it has been fetched, and
397 -1 if the register value was not available.
399 "Not available" indicates that the target is not not able to supply
400 the register at this state. The register may become available at a
401 later time (after the next resume). This often occures when GDB is
402 manipulating a target that contains only a snapshot of the entire
403 system being debugged - some of the registers in such a system may
404 not have been saved. */
406 signed char *register_valid
;
408 /* The thread/process associated with the current set of registers. */
410 static ptid_t registers_ptid
;
418 Returns 0 if the value is not in the cache (needs fetch).
419 >0 if the value is in the cache.
420 <0 if the value is permanently unavailable (don't ask again). */
423 register_cached (int regnum
)
425 return register_valid
[regnum
];
428 /* Record that REGNUM's value is cached if STATE is >0, uncached but
429 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
432 set_register_cached (int regnum
, int state
)
434 register_valid
[regnum
] = state
;
439 invalidate a single register REGNUM in the cache */
441 register_changed (int regnum
)
443 set_register_cached (regnum
, 0);
446 /* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
447 else return a pointer to the start of the cache buffer. */
450 register_buffer (struct regcache
*regcache
, int regnum
)
452 return regcache
->raw_registers
+ regcache
->descr
->register_offset
[regnum
];
455 /* Return whether register REGNUM is a real register. */
458 real_register (int regnum
)
460 return regnum
>= 0 && regnum
< NUM_REGS
;
463 /* Low level examining and depositing of registers.
465 The caller is responsible for making sure that the inferior is
466 stopped before calling the fetching routines, or it will get
467 garbage. (a change from GDB version 3, in which the caller got the
468 value from the last stop). */
470 /* REGISTERS_CHANGED ()
472 Indicate that registers may have changed, so invalidate the cache. */
475 registers_changed (void)
479 registers_ptid
= pid_to_ptid (-1);
481 /* Force cleanup of any alloca areas if using C alloca instead of
482 a builtin alloca. This particular call is used to clean up
483 areas allocated by low level target code which may build up
484 during lengthy interactions between gdb and the target before
485 gdb gives control to the user (ie watchpoints). */
488 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
489 set_register_cached (i
, 0);
491 if (registers_changed_hook
)
492 registers_changed_hook ();
495 /* REGISTERS_FETCHED ()
497 Indicate that all registers have been fetched, so mark them all valid. */
499 /* NOTE: cagney/2001-12-04: This function does not set valid on the
500 pseudo-register range since pseudo registers are always supplied
501 using supply_register(). */
502 /* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
503 code was blatting the registers[] array and then calling this.
504 Since targets should only be using supply_register() the need for
505 this function/hack is eliminated. */
508 registers_fetched (void)
512 for (i
= 0; i
< NUM_REGS
; i
++)
513 set_register_cached (i
, 1);
514 /* Do not assume that the pseudo-regs have also been fetched.
515 Fetching all real regs NEVER accounts for pseudo-regs. */
518 /* read_register_bytes and write_register_bytes are generally a *BAD*
519 idea. They are inefficient because they need to check for partial
520 updates, which can only be done by scanning through all of the
521 registers and seeing if the bytes that are being read/written fall
522 inside of an invalid register. [The main reason this is necessary
523 is that register sizes can vary, so a simple index won't suffice.]
524 It is far better to call read_register_gen and write_register_gen
525 if you want to get at the raw register contents, as it only takes a
526 regnum as an argument, and therefore can't do a partial register
529 Prior to the recent fixes to check for partial updates, both read
530 and write_register_bytes always checked to see if any registers
531 were stale, and then called target_fetch_registers (-1) to update
532 the whole set. This caused really slowed things down for remote
535 /* Copy INLEN bytes of consecutive data from registers
536 starting with the INREGBYTE'th byte of register data
537 into memory at MYADDR. */
540 read_register_bytes (int in_start
, char *in_buf
, int in_len
)
542 int in_end
= in_start
+ in_len
;
544 char *reg_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
546 /* See if we are trying to read bytes from out-of-date registers. If so,
547 update just those registers. */
549 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
558 reg_start
= REGISTER_BYTE (regnum
);
559 reg_len
= REGISTER_RAW_SIZE (regnum
);
560 reg_end
= reg_start
+ reg_len
;
562 if (reg_end
<= in_start
|| in_end
<= reg_start
)
563 /* The range the user wants to read doesn't overlap with regnum. */
566 if (REGISTER_NAME (regnum
) != NULL
&& *REGISTER_NAME (regnum
) != '\0')
567 /* Force the cache to fetch the entire register. */
568 read_register_gen (regnum
, reg_buf
);
570 /* Legacy note: even though this register is ``invalid'' we
571 still need to return something. It would appear that some
572 code relies on apparent gaps in the register array also
574 /* FIXME: cagney/2001-08-18: This is just silly. It defeats
575 the entire register read/write flow of control. Must
576 resist temptation to return 0xdeadbeef. */
577 memcpy (reg_buf
, registers
+ reg_start
, reg_len
);
579 /* Legacy note: This function, for some reason, allows a NULL
580 input buffer. If the buffer is NULL, the registers are still
581 fetched, just the final transfer is skipped. */
585 /* start = max (reg_start, in_start) */
586 if (reg_start
> in_start
)
591 /* end = min (reg_end, in_end) */
592 if (reg_end
< in_end
)
597 /* Transfer just the bytes common to both IN_BUF and REG_BUF */
598 for (byte
= start
; byte
< end
; byte
++)
600 in_buf
[byte
- in_start
] = reg_buf
[byte
- reg_start
];
605 /* Read register REGNUM into memory at MYADDR, which must be large
606 enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
607 register is known to be the size of a CORE_ADDR or smaller,
608 read_register can be used instead. */
611 legacy_read_register_gen (int regnum
, char *myaddr
)
613 gdb_assert (regnum
>= 0 && regnum
< (NUM_REGS
+ NUM_PSEUDO_REGS
));
614 if (! ptid_equal (registers_ptid
, inferior_ptid
))
616 registers_changed ();
617 registers_ptid
= inferior_ptid
;
620 if (!register_cached (regnum
))
621 target_fetch_registers (regnum
);
623 memcpy (myaddr
, register_buffer (current_regcache
, regnum
),
624 REGISTER_RAW_SIZE (regnum
));
628 regcache_raw_read (struct regcache
*regcache
, int regnum
, void *buf
)
630 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
631 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
632 if (regcache
->descr
->legacy_p
633 && regcache
->passthrough_p
)
635 gdb_assert (regcache
== current_regcache
);
636 /* For moment, just use underlying legacy code. Ulgh!!! This
637 silently and very indirectly updates the regcache's regcache
638 via the global register_valid[]. */
639 legacy_read_register_gen (regnum
, buf
);
642 /* Make certain that the register cache is up-to-date with respect
643 to the current thread. This switching shouldn't be necessary
644 only there is still only one target side register cache. Sigh!
645 On the bright side, at least there is a regcache object. */
646 if (regcache
->passthrough_p
)
648 gdb_assert (regcache
== current_regcache
);
649 if (! ptid_equal (registers_ptid
, inferior_ptid
))
651 registers_changed ();
652 registers_ptid
= inferior_ptid
;
654 if (!register_cached (regnum
))
655 target_fetch_registers (regnum
);
657 /* Copy the value directly into the register cache. */
658 memcpy (buf
, (regcache
->raw_registers
659 + regcache
->descr
->register_offset
[regnum
]),
660 regcache
->descr
->sizeof_register
[regnum
]);
664 read_register_gen (int regnum
, char *buf
)
666 gdb_assert (current_regcache
!= NULL
);
667 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
668 if (current_regcache
->descr
->legacy_p
)
670 legacy_read_register_gen (regnum
, buf
);
673 regcache_cooked_read (current_regcache
, regnum
, buf
);
677 regcache_cooked_read (struct regcache
*regcache
, int regnum
, void *buf
)
679 gdb_assert (regnum
>= 0);
680 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
681 if (regnum
< regcache
->descr
->nr_raw_registers
)
682 regcache_raw_read (regcache
, regnum
, buf
);
684 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
689 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
693 gdb_assert (regcache
!= NULL
);
694 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
695 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
696 regcache_cooked_read (regcache
, regnum
, buf
);
697 (*val
) = extract_signed_integer (buf
,
698 regcache
->descr
->sizeof_register
[regnum
]);
702 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
706 gdb_assert (regcache
!= NULL
);
707 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
708 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
709 regcache_cooked_read (regcache
, regnum
, buf
);
710 (*val
) = extract_unsigned_integer (buf
,
711 regcache
->descr
->sizeof_register
[regnum
]);
714 /* Write register REGNUM at MYADDR to the target. MYADDR points at
715 REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
718 legacy_write_register_gen (int regnum
, const void *myaddr
)
721 gdb_assert (regnum
>= 0 && regnum
< (NUM_REGS
+ NUM_PSEUDO_REGS
));
723 /* On the sparc, writing %g0 is a no-op, so we don't even want to
724 change the registers array if something writes to this register. */
725 if (CANNOT_STORE_REGISTER (regnum
))
728 if (! ptid_equal (registers_ptid
, inferior_ptid
))
730 registers_changed ();
731 registers_ptid
= inferior_ptid
;
734 size
= REGISTER_RAW_SIZE (regnum
);
736 if (real_register (regnum
))
738 /* If we have a valid copy of the register, and new value == old
739 value, then don't bother doing the actual store. */
740 if (register_cached (regnum
)
741 && (memcmp (register_buffer (current_regcache
, regnum
), myaddr
, size
)
745 target_prepare_to_store ();
748 memcpy (register_buffer (current_regcache
, regnum
), myaddr
, size
);
750 set_register_cached (regnum
, 1);
751 target_store_registers (regnum
);
755 regcache_raw_write (struct regcache
*regcache
, int regnum
, const void *buf
)
757 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
758 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
760 if (regcache
->passthrough_p
761 && regcache
->descr
->legacy_p
)
763 /* For moment, just use underlying legacy code. Ulgh!!! This
764 silently and very indirectly updates the regcache's buffers
765 via the globals register_valid[] and registers[]. */
766 gdb_assert (regcache
== current_regcache
);
767 legacy_write_register_gen (regnum
, buf
);
771 /* On the sparc, writing %g0 is a no-op, so we don't even want to
772 change the registers array if something writes to this register. */
773 if (CANNOT_STORE_REGISTER (regnum
))
776 /* Handle the simple case first -> not write through so just store
778 if (!regcache
->passthrough_p
)
780 memcpy ((regcache
->raw_registers
781 + regcache
->descr
->register_offset
[regnum
]), buf
,
782 regcache
->descr
->sizeof_register
[regnum
]);
783 regcache
->raw_register_valid_p
[regnum
] = 1;
787 /* Make certain that the correct cache is selected. */
788 gdb_assert (regcache
== current_regcache
);
789 if (! ptid_equal (registers_ptid
, inferior_ptid
))
791 registers_changed ();
792 registers_ptid
= inferior_ptid
;
795 /* If we have a valid copy of the register, and new value == old
796 value, then don't bother doing the actual store. */
797 if (regcache_valid_p (regcache
, regnum
)
798 && (memcmp (register_buffer (regcache
, regnum
), buf
,
799 regcache
->descr
->sizeof_register
[regnum
]) == 0))
802 target_prepare_to_store ();
803 memcpy (register_buffer (regcache
, regnum
), buf
,
804 regcache
->descr
->sizeof_register
[regnum
]);
805 regcache
->raw_register_valid_p
[regnum
] = 1;
806 target_store_registers (regnum
);
810 write_register_gen (int regnum
, char *buf
)
812 gdb_assert (current_regcache
!= NULL
);
813 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
814 if (current_regcache
->descr
->legacy_p
)
816 legacy_write_register_gen (regnum
, buf
);
819 regcache_cooked_write (current_regcache
, regnum
, buf
);
823 regcache_cooked_write (struct regcache
*regcache
, int regnum
, const void *buf
)
825 gdb_assert (regnum
>= 0);
826 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
827 if (regnum
< regcache
->descr
->nr_raw_registers
)
828 regcache_raw_write (regcache
, regnum
, buf
);
830 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
834 /* Copy INLEN bytes of consecutive data from memory at MYADDR
835 into registers starting with the MYREGSTART'th byte of register data. */
838 write_register_bytes (int myregstart
, char *myaddr
, int inlen
)
840 int myregend
= myregstart
+ inlen
;
843 target_prepare_to_store ();
845 /* Scan through the registers updating any that are covered by the
846 range myregstart<=>myregend using write_register_gen, which does
847 nice things like handling threads, and avoiding updates when the
848 new and old contents are the same. */
850 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
852 int regstart
, regend
;
854 regstart
= REGISTER_BYTE (regnum
);
855 regend
= regstart
+ REGISTER_RAW_SIZE (regnum
);
857 /* Is this register completely outside the range the user is writing? */
858 if (myregend
<= regstart
|| regend
<= myregstart
)
861 /* Is this register completely within the range the user is writing? */
862 else if (myregstart
<= regstart
&& regend
<= myregend
)
863 write_register_gen (regnum
, myaddr
+ (regstart
- myregstart
));
865 /* The register partially overlaps the range being written. */
868 char *regbuf
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
869 /* What's the overlap between this register's bytes and
870 those the caller wants to write? */
871 int overlapstart
= max (regstart
, myregstart
);
872 int overlapend
= min (regend
, myregend
);
874 /* We may be doing a partial update of an invalid register.
875 Update it from the target before scribbling on it. */
876 read_register_gen (regnum
, regbuf
);
878 memcpy (registers
+ overlapstart
,
879 myaddr
+ (overlapstart
- myregstart
),
880 overlapend
- overlapstart
);
882 target_store_registers (regnum
);
888 /* Return the contents of register REGNUM as an unsigned integer. */
891 read_register (int regnum
)
893 char *buf
= alloca (REGISTER_RAW_SIZE (regnum
));
894 read_register_gen (regnum
, buf
);
895 return (extract_unsigned_integer (buf
, REGISTER_RAW_SIZE (regnum
)));
899 read_register_pid (int regnum
, ptid_t ptid
)
905 if (ptid_equal (ptid
, inferior_ptid
))
906 return read_register (regnum
);
908 save_ptid
= inferior_ptid
;
910 inferior_ptid
= ptid
;
912 retval
= read_register (regnum
);
914 inferior_ptid
= save_ptid
;
919 /* Return the contents of register REGNUM as a signed integer. */
922 read_signed_register (int regnum
)
924 void *buf
= alloca (REGISTER_RAW_SIZE (regnum
));
925 read_register_gen (regnum
, buf
);
926 return (extract_signed_integer (buf
, REGISTER_RAW_SIZE (regnum
)));
930 read_signed_register_pid (int regnum
, ptid_t ptid
)
935 if (ptid_equal (ptid
, inferior_ptid
))
936 return read_signed_register (regnum
);
938 save_ptid
= inferior_ptid
;
940 inferior_ptid
= ptid
;
942 retval
= read_signed_register (regnum
);
944 inferior_ptid
= save_ptid
;
949 /* Store VALUE into the raw contents of register number REGNUM. */
952 write_register (int regnum
, LONGEST val
)
956 size
= REGISTER_RAW_SIZE (regnum
);
958 store_signed_integer (buf
, size
, (LONGEST
) val
);
959 write_register_gen (regnum
, buf
);
963 write_register_pid (int regnum
, CORE_ADDR val
, ptid_t ptid
)
967 if (ptid_equal (ptid
, inferior_ptid
))
969 write_register (regnum
, val
);
973 save_ptid
= inferior_ptid
;
975 inferior_ptid
= ptid
;
977 write_register (regnum
, val
);
979 inferior_ptid
= save_ptid
;
984 Record that register REGNUM contains VAL. This is used when the
985 value is obtained from the inferior or core dump, so there is no
986 need to store the value there.
988 If VAL is a NULL pointer, then it's probably an unsupported register.
989 We just set its value to all zeros. We might want to record this
990 fact, and report it to the users of read_register and friends. */
993 supply_register (int regnum
, const void *val
)
996 if (! ptid_equal (registers_ptid
, inferior_ptid
))
998 registers_changed ();
999 registers_ptid
= inferior_ptid
;
1003 set_register_cached (regnum
, 1);
1005 memcpy (register_buffer (current_regcache
, regnum
), val
,
1006 REGISTER_RAW_SIZE (regnum
));
1008 memset (register_buffer (current_regcache
, regnum
), '\000',
1009 REGISTER_RAW_SIZE (regnum
));
1011 /* On some architectures, e.g. HPPA, there are a few stray bits in
1012 some registers, that the rest of the code would like to ignore. */
1014 /* NOTE: cagney/2001-03-16: The macro CLEAN_UP_REGISTER_VALUE is
1015 going to be deprecated. Instead architectures will leave the raw
1016 register value as is and instead clean things up as they pass
1017 through the method gdbarch_pseudo_register_read() clean up the
1020 #ifdef DEPRECATED_CLEAN_UP_REGISTER_VALUE
1021 DEPRECATED_CLEAN_UP_REGISTER_VALUE \
1022 (regnum
, register_buffer (current_regcache
, regnum
));
1027 regcache_collect (int regnum
, void *buf
)
1029 memcpy (buf
, register_buffer (current_regcache
, regnum
),
1030 REGISTER_RAW_SIZE (regnum
));
1034 /* read_pc, write_pc, read_sp, write_sp, read_fp, etc. Special
1035 handling for registers PC, SP, and FP. */
1037 /* NOTE: cagney/2001-02-18: The functions generic_target_read_pc(),
1038 read_pc_pid(), read_pc(), generic_target_write_pc(),
1039 write_pc_pid(), write_pc(), generic_target_read_sp(), read_sp(),
1040 generic_target_write_sp(), write_sp(), generic_target_read_fp() and
1041 read_fp(), will eventually be moved out of the reg-cache into
1042 either frame.[hc] or to the multi-arch framework. The are not part
1043 of the raw register cache. */
1045 /* This routine is getting awfully cluttered with #if's. It's probably
1046 time to turn this into READ_PC and define it in the tm.h file.
1049 1999-06-08: The following were re-written so that it assumes the
1050 existence of a TARGET_READ_PC et.al. macro. A default generic
1051 version of that macro is made available where needed.
1053 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
1054 by the multi-arch framework, it will eventually be possible to
1055 eliminate the intermediate read_pc_pid(). The client would call
1056 TARGET_READ_PC directly. (cagney). */
1059 generic_target_read_pc (ptid_t ptid
)
1064 CORE_ADDR pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, ptid
));
1068 internal_error (__FILE__
, __LINE__
,
1069 "generic_target_read_pc");
1074 read_pc_pid (ptid_t ptid
)
1076 ptid_t saved_inferior_ptid
;
1079 /* In case ptid != inferior_ptid. */
1080 saved_inferior_ptid
= inferior_ptid
;
1081 inferior_ptid
= ptid
;
1083 pc_val
= TARGET_READ_PC (ptid
);
1085 inferior_ptid
= saved_inferior_ptid
;
1092 return read_pc_pid (inferior_ptid
);
1096 generic_target_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1100 write_register_pid (PC_REGNUM
, pc
, ptid
);
1101 if (NPC_REGNUM
>= 0)
1102 write_register_pid (NPC_REGNUM
, pc
+ 4, ptid
);
1104 internal_error (__FILE__
, __LINE__
,
1105 "generic_target_write_pc");
1110 write_pc_pid (CORE_ADDR pc
, ptid_t ptid
)
1112 ptid_t saved_inferior_ptid
;
1114 /* In case ptid != inferior_ptid. */
1115 saved_inferior_ptid
= inferior_ptid
;
1116 inferior_ptid
= ptid
;
1118 TARGET_WRITE_PC (pc
, ptid
);
1120 inferior_ptid
= saved_inferior_ptid
;
1124 write_pc (CORE_ADDR pc
)
1126 write_pc_pid (pc
, inferior_ptid
);
1129 /* Cope with strage ways of getting to the stack and frame pointers */
1132 generic_target_read_sp (void)
1136 return read_register (SP_REGNUM
);
1138 internal_error (__FILE__
, __LINE__
,
1139 "generic_target_read_sp");
1145 return TARGET_READ_SP ();
1149 generic_target_write_sp (CORE_ADDR val
)
1154 write_register (SP_REGNUM
, val
);
1158 internal_error (__FILE__
, __LINE__
,
1159 "generic_target_write_sp");
1163 write_sp (CORE_ADDR val
)
1165 TARGET_WRITE_SP (val
);
1169 generic_target_read_fp (void)
1173 return read_register (FP_REGNUM
);
1175 internal_error (__FILE__
, __LINE__
,
1176 "generic_target_read_fp");
1182 return TARGET_READ_FP ();
1187 reg_flush_command (char *command
, int from_tty
)
1189 /* Force-flush the register cache. */
1190 registers_changed ();
1192 printf_filtered ("Register cache flushed.\n");
1196 build_regcache (void)
1198 current_regcache
= regcache_xmalloc (current_gdbarch
);
1199 current_regcache
->passthrough_p
= 1;
1200 registers
= deprecated_grub_regcache_for_registers (current_regcache
);
1201 register_valid
= deprecated_grub_regcache_for_register_valid (current_regcache
);
1205 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
1206 const unsigned char *buf
, long len
)
1211 case BFD_ENDIAN_BIG
:
1212 for (i
= 0; i
< len
; i
++)
1213 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1215 case BFD_ENDIAN_LITTLE
:
1216 for (i
= len
- 1; i
>= 0; i
--)
1217 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1220 internal_error (__FILE__
, __LINE__
, "Bad switch");
1224 enum regcache_dump_what
1226 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
1230 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1231 enum regcache_dump_what what_to_dump
)
1233 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1235 int footnote_nr
= 0;
1236 int footnote_register_size
= 0;
1237 int footnote_register_offset
= 0;
1238 int footnote_register_type_name_null
= 0;
1239 long register_offset
= 0;
1240 unsigned char *buf
= alloca (regcache
->descr
->max_register_size
);
1243 fprintf_unfiltered (file
, "legacy_p %d\n", regcache
->descr
->legacy_p
);
1244 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1245 regcache
->descr
->nr_raw_registers
);
1246 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1247 regcache
->descr
->nr_cooked_registers
);
1248 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1249 regcache
->descr
->sizeof_raw_registers
);
1250 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
1251 regcache
->descr
->sizeof_raw_register_valid_p
);
1252 fprintf_unfiltered (file
, "max_register_size %ld\n",
1253 regcache
->descr
->max_register_size
);
1254 fprintf_unfiltered (file
, "NUM_REGS %d\n", NUM_REGS
);
1255 fprintf_unfiltered (file
, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS
);
1258 gdb_assert (regcache
->descr
->nr_cooked_registers
1259 == (NUM_REGS
+ NUM_PSEUDO_REGS
));
1261 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1265 fprintf_unfiltered (file
, " %-10s", "Name");
1268 const char *p
= REGISTER_NAME (regnum
);
1271 else if (p
[0] == '\0')
1273 fprintf_unfiltered (file
, " %-10s", p
);
1278 fprintf_unfiltered (file
, " %4s", "Nr");
1280 fprintf_unfiltered (file
, " %4d", regnum
);
1282 /* Relative number. */
1284 fprintf_unfiltered (file
, " %4s", "Rel");
1285 else if (regnum
< NUM_REGS
)
1286 fprintf_unfiltered (file
, " %4d", regnum
);
1288 fprintf_unfiltered (file
, " %4d", (regnum
- NUM_REGS
));
1292 fprintf_unfiltered (file
, " %6s ", "Offset");
1295 fprintf_unfiltered (file
, " %6ld",
1296 regcache
->descr
->register_offset
[regnum
]);
1297 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1298 || register_offset
!= REGISTER_BYTE (regnum
))
1300 if (!footnote_register_offset
)
1301 footnote_register_offset
= ++footnote_nr
;
1302 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1305 fprintf_unfiltered (file
, " ");
1306 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1307 + regcache
->descr
->sizeof_register
[regnum
]);
1312 fprintf_unfiltered (file
, " %5s ", "Size");
1315 fprintf_unfiltered (file
, " %5ld",
1316 regcache
->descr
->sizeof_register
[regnum
]);
1317 if ((regcache
->descr
->sizeof_register
[regnum
]
1318 != REGISTER_RAW_SIZE (regnum
))
1319 || (regcache
->descr
->sizeof_register
[regnum
]
1320 != REGISTER_VIRTUAL_SIZE (regnum
))
1321 || (regcache
->descr
->sizeof_register
[regnum
]
1322 != TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (regnum
)))
1325 if (!footnote_register_size
)
1326 footnote_register_size
= ++footnote_nr
;
1327 fprintf_unfiltered (file
, "*%d", footnote_register_size
);
1330 fprintf_unfiltered (file
, " ");
1335 fprintf_unfiltered (file
, " %-20s", "Type");
1338 static const char blt
[] = "builtin_type";
1339 const char *t
= TYPE_NAME (REGISTER_VIRTUAL_TYPE (regnum
));
1343 if (!footnote_register_type_name_null
)
1344 footnote_register_type_name_null
= ++footnote_nr
;
1345 xasprintf (&n
, "*%d", footnote_register_type_name_null
);
1346 make_cleanup (xfree
, n
);
1349 /* Chop a leading builtin_type. */
1350 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1352 fprintf_unfiltered (file
, " %-20s", t
);
1356 if (what_to_dump
== regcache_dump_raw
)
1359 fprintf_unfiltered (file
, "Raw value");
1360 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1361 fprintf_unfiltered (file
, "<cooked>");
1362 else if (!regcache_valid_p (regcache
, regnum
))
1363 fprintf_unfiltered (file
, "<invalid>");
1366 regcache_raw_read (regcache
, regnum
, buf
);
1367 fprintf_unfiltered (file
, "0x");
1368 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1369 REGISTER_RAW_SIZE (regnum
));
1373 /* Value, cooked. */
1374 if (what_to_dump
== regcache_dump_cooked
)
1377 fprintf_unfiltered (file
, "Cooked value");
1380 regcache_cooked_read (regcache
, regnum
, buf
);
1381 fprintf_unfiltered (file
, "0x");
1382 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1383 REGISTER_VIRTUAL_SIZE (regnum
));
1387 fprintf_unfiltered (file
, "\n");
1390 if (footnote_register_size
)
1391 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1392 footnote_register_size
);
1393 if (footnote_register_offset
)
1394 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1395 footnote_register_offset
);
1396 if (footnote_register_type_name_null
)
1397 fprintf_unfiltered (file
,
1398 "*%d: Register type's name NULL.\n",
1399 footnote_register_type_name_null
);
1400 do_cleanups (cleanups
);
1404 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1407 regcache_dump (current_regcache
, gdb_stdout
, what_to_dump
);
1410 struct ui_file
*file
= gdb_fopen (args
, "w");
1412 perror_with_name ("maintenance print architecture");
1413 regcache_dump (current_regcache
, file
, what_to_dump
);
1414 ui_file_delete (file
);
1419 maintenance_print_registers (char *args
, int from_tty
)
1421 regcache_print (args
, regcache_dump_none
);
1425 maintenance_print_raw_registers (char *args
, int from_tty
)
1427 regcache_print (args
, regcache_dump_raw
);
1431 maintenance_print_cooked_registers (char *args
, int from_tty
)
1433 regcache_print (args
, regcache_dump_cooked
);
1437 _initialize_regcache (void)
1439 regcache_descr_handle
= register_gdbarch_data (init_regcache_descr
,
1440 xfree_regcache_descr
);
1441 REGISTER_GDBARCH_SWAP (current_regcache
);
1442 register_gdbarch_swap (®isters
, sizeof (registers
), NULL
);
1443 register_gdbarch_swap (®ister_valid
, sizeof (register_valid
), NULL
);
1444 register_gdbarch_swap (NULL
, 0, build_regcache
);
1446 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1447 "Force gdb to flush its register cache (maintainer command)");
1449 /* Initialize the thread/process associated with the current set of
1450 registers. For now, -1 is special, and means `no current process'. */
1451 registers_ptid
= pid_to_ptid (-1);
1453 add_cmd ("registers", class_maintenance
,
1454 maintenance_print_registers
,
1455 "Print the internal register configuration.\
1456 Takes an optional file parameter.",
1457 &maintenanceprintlist
);
1458 add_cmd ("raw-registers", class_maintenance
,
1459 maintenance_print_raw_registers
,
1460 "Print the internal register configuration including raw values.\
1461 Takes an optional file parameter.",
1462 &maintenanceprintlist
);
1463 add_cmd ("cooked-registers", class_maintenance
,
1464 maintenance_print_cooked_registers
,
1465 "Print the internal register configuration including cooked values.\
1466 Takes an optional file parameter.",
1467 &maintenanceprintlist
);