1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2004, 2007 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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
29 #include "reggroups.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
32 #include "gdbcmd.h" /* For maintenanceprintlist. */
38 * Here is the actual register cache.
41 /* Per-architecture object describing the layout of a register cache.
42 Computed once when the architecture is created */
44 struct gdbarch_data
*regcache_descr_handle
;
48 /* The architecture this descriptor belongs to. */
49 struct gdbarch
*gdbarch
;
51 /* The raw register cache. Each raw (or hard) register is supplied
52 by the target interface. The raw cache should not contain
53 redundant information - if the PC is constructed from two
54 registers then those registers and not the PC lives in the raw
57 long sizeof_raw_registers
;
58 long sizeof_raw_register_valid_p
;
60 /* The cooked register space. Each cooked register in the range
61 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
62 register. The remaining [NR_RAW_REGISTERS
63 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
64 both raw registers and memory by the architecture methods
65 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
66 int nr_cooked_registers
;
67 long sizeof_cooked_registers
;
68 long sizeof_cooked_register_valid_p
;
70 /* Offset and size (in 8 bit bytes), of reach register in the
71 register cache. All registers (including those in the range
72 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
73 Assigning all registers an offset makes it possible to keep
74 legacy code, such as that found in read_register_bytes() and
75 write_register_bytes() working. */
76 long *register_offset
;
77 long *sizeof_register
;
79 /* Cached table containing the type of each register. */
80 struct type
**register_type
;
84 init_regcache_descr (struct gdbarch
*gdbarch
)
87 struct regcache_descr
*descr
;
88 gdb_assert (gdbarch
!= NULL
);
90 /* Create an initial, zero filled, table. */
91 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
92 descr
->gdbarch
= gdbarch
;
94 /* Total size of the register space. The raw registers are mapped
95 directly onto the raw register cache while the pseudo's are
96 either mapped onto raw-registers or memory. */
97 descr
->nr_cooked_registers
= NUM_REGS
+ NUM_PSEUDO_REGS
;
98 descr
->sizeof_cooked_register_valid_p
= NUM_REGS
+ NUM_PSEUDO_REGS
;
100 /* Fill in a table of register types. */
102 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, struct type
*);
103 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
104 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
106 /* Construct a strictly RAW register cache. Don't allow pseudo's
107 into the register cache. */
108 descr
->nr_raw_registers
= NUM_REGS
;
110 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
111 array. This pretects GDB from erant code that accesses elements
112 of the global register_valid_p[] array in the range [NUM_REGS
113 .. NUM_REGS + NUM_PSEUDO_REGS). */
114 descr
->sizeof_raw_register_valid_p
= descr
->sizeof_cooked_register_valid_p
;
116 /* Lay out the register cache.
118 NOTE: cagney/2002-05-22: Only register_type() is used when
119 constructing the register cache. It is assumed that the
120 register's raw size, virtual size and type length are all the
125 descr
->sizeof_register
126 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
127 descr
->register_offset
128 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
129 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
131 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
132 descr
->register_offset
[i
] = offset
;
133 offset
+= descr
->sizeof_register
[i
];
134 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
136 /* Set the real size of the register cache buffer. */
137 descr
->sizeof_cooked_registers
= offset
;
140 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
141 the raw registers. Unfortunately some code still accesses the
142 register array directly using the global registers[]. Until that
143 code has been purged, play safe and over allocating the register
145 descr
->sizeof_raw_registers
= descr
->sizeof_cooked_registers
;
150 static struct regcache_descr
*
151 regcache_descr (struct gdbarch
*gdbarch
)
153 return gdbarch_data (gdbarch
, regcache_descr_handle
);
156 /* Utility functions returning useful register attributes stored in
157 the regcache descr. */
160 register_type (struct gdbarch
*gdbarch
, int regnum
)
162 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
163 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
164 return descr
->register_type
[regnum
];
167 /* Utility functions returning useful register attributes stored in
168 the regcache descr. */
171 register_size (struct gdbarch
*gdbarch
, int regnum
)
173 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
175 gdb_assert (regnum
>= 0 && regnum
< (NUM_REGS
+ NUM_PSEUDO_REGS
));
176 size
= descr
->sizeof_register
[regnum
];
180 /* The register cache for storing raw register values. */
184 struct regcache_descr
*descr
;
185 /* The register buffers. A read-only register cache can hold the
186 full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
187 register cache can only hold [0 .. NUM_REGS). */
189 /* Register cache status:
190 register_valid_p[REG] == 0 if REG value is not in the cache
191 > 0 if REG value is in the cache
192 < 0 if REG value is permanently unavailable */
193 signed char *register_valid_p
;
194 /* Is this a read-only cache? A read-only cache is used for saving
195 the target's register state (e.g, across an inferior function
196 call or just before forcing a function return). A read-only
197 cache can only be updated via the methods regcache_dup() and
198 regcache_cpy(). The actual contents are determined by the
199 reggroup_save and reggroup_restore methods. */
204 regcache_xmalloc (struct gdbarch
*gdbarch
)
206 struct regcache_descr
*descr
;
207 struct regcache
*regcache
;
208 gdb_assert (gdbarch
!= NULL
);
209 descr
= regcache_descr (gdbarch
);
210 regcache
= XMALLOC (struct regcache
);
211 regcache
->descr
= descr
;
213 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
214 regcache
->register_valid_p
215 = XCALLOC (descr
->sizeof_raw_register_valid_p
, gdb_byte
);
216 regcache
->readonly_p
= 1;
221 regcache_xfree (struct regcache
*regcache
)
223 if (regcache
== NULL
)
225 xfree (regcache
->registers
);
226 xfree (regcache
->register_valid_p
);
231 do_regcache_xfree (void *data
)
233 regcache_xfree (data
);
237 make_cleanup_regcache_xfree (struct regcache
*regcache
)
239 return make_cleanup (do_regcache_xfree
, regcache
);
242 /* Return REGCACHE's architecture. */
245 get_regcache_arch (const struct regcache
*regcache
)
247 return regcache
->descr
->gdbarch
;
250 /* Return a pointer to register REGNUM's buffer cache. */
253 register_buffer (const struct regcache
*regcache
, int regnum
)
255 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
259 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
262 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
263 gdb_byte buf
[MAX_REGISTER_SIZE
];
265 /* The DST should be `read-only', if it wasn't then the save would
266 end up trying to write the register values back out to the
268 gdb_assert (dst
->readonly_p
);
269 /* Clear the dest. */
270 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
271 memset (dst
->register_valid_p
, 0, dst
->descr
->sizeof_cooked_register_valid_p
);
272 /* Copy over any registers (identified by their membership in the
273 save_reggroup) and mark them as valid. The full [0 .. NUM_REGS +
274 NUM_PSEUDO_REGS) range is checked since some architectures need
275 to save/restore `cooked' registers that live in memory. */
276 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
278 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
280 int valid
= cooked_read (src
, regnum
, buf
);
283 memcpy (register_buffer (dst
, regnum
), buf
,
284 register_size (gdbarch
, regnum
));
285 dst
->register_valid_p
[regnum
] = 1;
292 regcache_restore (struct regcache
*dst
,
293 regcache_cooked_read_ftype
*cooked_read
,
294 void *cooked_read_context
)
296 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
297 gdb_byte buf
[MAX_REGISTER_SIZE
];
299 /* The dst had better not be read-only. If it is, the `restore'
300 doesn't make much sense. */
301 gdb_assert (!dst
->readonly_p
);
302 /* Copy over any registers, being careful to only restore those that
303 were both saved and need to be restored. The full [0 .. NUM_REGS
304 + NUM_PSEUDO_REGS) range is checked since some architectures need
305 to save/restore `cooked' registers that live in memory. */
306 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
308 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
310 int valid
= cooked_read (cooked_read_context
, regnum
, buf
);
312 regcache_cooked_write (dst
, regnum
, buf
);
318 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
320 struct regcache
*regcache
= src
;
321 if (!regcache
->register_valid_p
[regnum
] && regcache
->readonly_p
)
322 /* Don't even think about fetching a register from a read-only
323 cache when the register isn't yet valid. There isn't a target
324 from which the register value can be fetched. */
326 regcache_cooked_read (regcache
, regnum
, buf
);
332 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
336 gdb_assert (src
!= NULL
&& dst
!= NULL
);
337 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
338 gdb_assert (src
!= dst
);
339 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
340 if (!src
->readonly_p
)
341 regcache_save (dst
, do_cooked_read
, src
);
342 else if (!dst
->readonly_p
)
343 regcache_restore (dst
, do_cooked_read
, src
);
345 regcache_cpy_no_passthrough (dst
, src
);
349 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
352 gdb_assert (src
!= NULL
&& dst
!= NULL
);
353 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
354 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
355 move of data into the current_regcache(). Doing this would be
356 silly - it would mean that valid_p would be completely invalid. */
357 gdb_assert (dst
!= current_regcache
);
358 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
359 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
360 dst
->descr
->sizeof_raw_register_valid_p
);
364 regcache_dup (struct regcache
*src
)
366 struct regcache
*newbuf
;
367 gdb_assert (current_regcache
!= NULL
);
368 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
369 regcache_cpy (newbuf
, src
);
374 regcache_dup_no_passthrough (struct regcache
*src
)
376 struct regcache
*newbuf
;
377 gdb_assert (current_regcache
!= NULL
);
378 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
379 regcache_cpy_no_passthrough (newbuf
, src
);
384 regcache_valid_p (struct regcache
*regcache
, int regnum
)
386 gdb_assert (regcache
!= NULL
);
387 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
388 return regcache
->register_valid_p
[regnum
];
391 /* Global structure containing the current regcache. */
392 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
393 deprecated_register_valid[] currently point into this structure. */
394 struct regcache
*current_regcache
;
396 /* NOTE: this is a write-through cache. There is no "dirty" bit for
397 recording if the register values have been changed (eg. by the
398 user). Therefore all registers must be written back to the
399 target when appropriate. */
401 /* The thread/process associated with the current set of registers. */
403 static ptid_t registers_ptid
;
411 Returns 0 if the value is not in the cache (needs fetch).
412 >0 if the value is in the cache.
413 <0 if the value is permanently unavailable (don't ask again). */
416 register_cached (int regnum
)
418 return current_regcache
->register_valid_p
[regnum
];
421 /* Record that REGNUM's value is cached if STATE is >0, uncached but
422 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
425 set_register_cached (int regnum
, int state
)
427 gdb_assert (regnum
>= 0);
428 gdb_assert (regnum
< current_regcache
->descr
->nr_raw_registers
);
429 current_regcache
->register_valid_p
[regnum
] = state
;
432 /* Observer for the target_changed event. */
435 regcache_observer_target_changed (struct target_ops
*target
)
437 registers_changed ();
440 /* Low level examining and depositing of registers.
442 The caller is responsible for making sure that the inferior is
443 stopped before calling the fetching routines, or it will get
444 garbage. (a change from GDB version 3, in which the caller got the
445 value from the last stop). */
447 /* REGISTERS_CHANGED ()
449 Indicate that registers may have changed, so invalidate the cache. */
452 registers_changed (void)
456 registers_ptid
= pid_to_ptid (-1);
458 /* Force cleanup of any alloca areas if using C alloca instead of
459 a builtin alloca. This particular call is used to clean up
460 areas allocated by low level target code which may build up
461 during lengthy interactions between gdb and the target before
462 gdb gives control to the user (ie watchpoints). */
465 for (i
= 0; i
< current_regcache
->descr
->nr_raw_registers
; i
++)
466 set_register_cached (i
, 0);
468 if (deprecated_registers_changed_hook
)
469 deprecated_registers_changed_hook ();
472 /* DEPRECATED_REGISTERS_FETCHED ()
474 Indicate that all registers have been fetched, so mark them all valid. */
476 /* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
477 code was blatting the registers[] array and then calling this.
478 Since targets should only be using regcache_raw_supply() the need for
479 this function/hack is eliminated. */
482 deprecated_registers_fetched (void)
486 for (i
= 0; i
< NUM_REGS
; i
++)
487 set_register_cached (i
, 1);
488 /* Do not assume that the pseudo-regs have also been fetched.
489 Fetching all real regs NEVER accounts for pseudo-regs. */
493 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
495 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
496 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
497 /* Make certain that the register cache is up-to-date with respect
498 to the current thread. This switching shouldn't be necessary
499 only there is still only one target side register cache. Sigh!
500 On the bright side, at least there is a regcache object. */
501 if (!regcache
->readonly_p
)
503 gdb_assert (regcache
== current_regcache
);
504 if (! ptid_equal (registers_ptid
, inferior_ptid
))
506 registers_changed ();
507 registers_ptid
= inferior_ptid
;
509 if (!register_cached (regnum
))
510 target_fetch_registers (regnum
);
512 /* FIXME: cagney/2004-08-07: At present a number of targets
513 forget (or didn't know that they needed) to set this leading to
514 panics. Also is the problem that targets need to indicate
515 that a register is in one of the possible states: valid,
516 undefined, unknown. The last of which isn't yet
518 gdb_assert (register_cached (regnum
));
521 /* Copy the value directly into the register cache. */
522 memcpy (buf
, register_buffer (regcache
, regnum
),
523 regcache
->descr
->sizeof_register
[regnum
]);
527 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
530 gdb_assert (regcache
!= NULL
);
531 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
532 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
533 regcache_raw_read (regcache
, regnum
, buf
);
534 (*val
) = extract_signed_integer (buf
,
535 regcache
->descr
->sizeof_register
[regnum
]);
539 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
543 gdb_assert (regcache
!= NULL
);
544 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
545 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
546 regcache_raw_read (regcache
, regnum
, buf
);
547 (*val
) = extract_unsigned_integer (buf
,
548 regcache
->descr
->sizeof_register
[regnum
]);
552 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
555 gdb_assert (regcache
!= NULL
);
556 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
557 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
558 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
559 regcache_raw_write (regcache
, regnum
, buf
);
563 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
567 gdb_assert (regcache
!= NULL
);
568 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
569 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
570 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
571 regcache_raw_write (regcache
, regnum
, buf
);
575 deprecated_read_register_gen (int regnum
, gdb_byte
*buf
)
577 gdb_assert (current_regcache
!= NULL
);
578 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
579 regcache_cooked_read (current_regcache
, regnum
, buf
);
583 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
585 gdb_assert (regnum
>= 0);
586 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
587 if (regnum
< regcache
->descr
->nr_raw_registers
)
588 regcache_raw_read (regcache
, regnum
, buf
);
589 else if (regcache
->readonly_p
590 && regnum
< regcache
->descr
->nr_cooked_registers
591 && regcache
->register_valid_p
[regnum
])
592 /* Read-only register cache, perhaps the cooked value was cached? */
593 memcpy (buf
, register_buffer (regcache
, regnum
),
594 regcache
->descr
->sizeof_register
[regnum
]);
596 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
601 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
605 gdb_assert (regcache
!= NULL
);
606 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
607 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
608 regcache_cooked_read (regcache
, regnum
, buf
);
609 (*val
) = extract_signed_integer (buf
,
610 regcache
->descr
->sizeof_register
[regnum
]);
614 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
618 gdb_assert (regcache
!= NULL
);
619 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
620 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
621 regcache_cooked_read (regcache
, regnum
, buf
);
622 (*val
) = extract_unsigned_integer (buf
,
623 regcache
->descr
->sizeof_register
[regnum
]);
627 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
631 gdb_assert (regcache
!= NULL
);
632 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
633 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
634 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
635 regcache_cooked_write (regcache
, regnum
, buf
);
639 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
643 gdb_assert (regcache
!= NULL
);
644 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
645 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
646 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
647 regcache_cooked_write (regcache
, regnum
, buf
);
651 regcache_raw_write (struct regcache
*regcache
, int regnum
,
654 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
655 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
656 gdb_assert (!regcache
->readonly_p
);
658 /* On the sparc, writing %g0 is a no-op, so we don't even want to
659 change the registers array if something writes to this register. */
660 if (CANNOT_STORE_REGISTER (regnum
))
663 /* Make certain that the correct cache is selected. */
664 gdb_assert (regcache
== current_regcache
);
665 if (! ptid_equal (registers_ptid
, inferior_ptid
))
667 registers_changed ();
668 registers_ptid
= inferior_ptid
;
671 /* If we have a valid copy of the register, and new value == old
672 value, then don't bother doing the actual store. */
673 if (regcache_valid_p (regcache
, regnum
)
674 && (memcmp (register_buffer (regcache
, regnum
), buf
,
675 regcache
->descr
->sizeof_register
[regnum
]) == 0))
678 target_prepare_to_store ();
679 memcpy (register_buffer (regcache
, regnum
), buf
,
680 regcache
->descr
->sizeof_register
[regnum
]);
681 regcache
->register_valid_p
[regnum
] = 1;
682 target_store_registers (regnum
);
686 deprecated_write_register_gen (int regnum
, gdb_byte
*buf
)
688 gdb_assert (current_regcache
!= NULL
);
689 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
690 regcache_cooked_write (current_regcache
, regnum
, buf
);
694 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
697 gdb_assert (regnum
>= 0);
698 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
699 if (regnum
< regcache
->descr
->nr_raw_registers
)
700 regcache_raw_write (regcache
, regnum
, buf
);
702 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
706 /* Perform a partial register transfer using a read, modify, write
709 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
711 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
715 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
716 int offset
, int len
, void *in
, const void *out
,
717 void (*read
) (struct regcache
*regcache
, int regnum
,
719 void (*write
) (struct regcache
*regcache
, int regnum
,
720 const gdb_byte
*buf
))
722 struct regcache_descr
*descr
= regcache
->descr
;
723 gdb_byte reg
[MAX_REGISTER_SIZE
];
724 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
725 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
726 /* Something to do? */
727 if (offset
+ len
== 0)
729 /* Read (when needed) ... */
732 || offset
+ len
< descr
->sizeof_register
[regnum
])
734 gdb_assert (read
!= NULL
);
735 read (regcache
, regnum
, reg
);
739 memcpy (in
, reg
+ offset
, len
);
741 memcpy (reg
+ offset
, out
, len
);
742 /* ... write (when needed). */
745 gdb_assert (write
!= NULL
);
746 write (regcache
, regnum
, reg
);
751 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
752 int offset
, int len
, gdb_byte
*buf
)
754 struct regcache_descr
*descr
= regcache
->descr
;
755 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
756 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
757 regcache_raw_read
, regcache_raw_write
);
761 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
762 int offset
, int len
, const gdb_byte
*buf
)
764 struct regcache_descr
*descr
= regcache
->descr
;
765 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
766 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
767 regcache_raw_read
, regcache_raw_write
);
771 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
772 int offset
, int len
, gdb_byte
*buf
)
774 struct regcache_descr
*descr
= regcache
->descr
;
775 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
776 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
777 regcache_cooked_read
, regcache_cooked_write
);
781 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
782 int offset
, int len
, const gdb_byte
*buf
)
784 struct regcache_descr
*descr
= regcache
->descr
;
785 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
786 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
787 regcache_cooked_read
, regcache_cooked_write
);
790 /* Hack to keep code that view the register buffer as raw bytes
794 register_offset_hack (struct gdbarch
*gdbarch
, int regnum
)
796 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
797 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
798 return descr
->register_offset
[regnum
];
801 /* Return the contents of register REGNUM as an unsigned integer. */
804 read_register (int regnum
)
806 gdb_byte
*buf
= alloca (register_size (current_gdbarch
, regnum
));
807 deprecated_read_register_gen (regnum
, buf
);
808 return (extract_unsigned_integer (buf
, register_size (current_gdbarch
, regnum
)));
812 read_register_pid (int regnum
, ptid_t ptid
)
818 if (ptid_equal (ptid
, inferior_ptid
))
819 return read_register (regnum
);
821 save_ptid
= inferior_ptid
;
823 inferior_ptid
= ptid
;
825 retval
= read_register (regnum
);
827 inferior_ptid
= save_ptid
;
832 /* Store VALUE into the raw contents of register number REGNUM. */
835 write_register (int regnum
, LONGEST val
)
839 size
= register_size (current_gdbarch
, regnum
);
841 store_signed_integer (buf
, size
, (LONGEST
) val
);
842 deprecated_write_register_gen (regnum
, buf
);
846 write_register_pid (int regnum
, CORE_ADDR val
, ptid_t ptid
)
850 if (ptid_equal (ptid
, inferior_ptid
))
852 write_register (regnum
, val
);
856 save_ptid
= inferior_ptid
;
858 inferior_ptid
= ptid
;
860 write_register (regnum
, val
);
862 inferior_ptid
= save_ptid
;
865 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
868 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
873 gdb_assert (regcache
!= NULL
);
874 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
875 gdb_assert (!regcache
->readonly_p
);
877 /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
878 CURRENT_REGCACHE specially here. */
879 if (regcache
== current_regcache
880 && !ptid_equal (registers_ptid
, inferior_ptid
))
882 registers_changed ();
883 registers_ptid
= inferior_ptid
;
886 regbuf
= register_buffer (regcache
, regnum
);
887 size
= regcache
->descr
->sizeof_register
[regnum
];
890 memcpy (regbuf
, buf
, size
);
892 memset (regbuf
, 0, size
);
894 /* Mark the register as cached. */
895 regcache
->register_valid_p
[regnum
] = 1;
898 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
901 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
906 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
907 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
909 regbuf
= register_buffer (regcache
, regnum
);
910 size
= regcache
->descr
->sizeof_register
[regnum
];
911 memcpy (buf
, regbuf
, size
);
915 /* read_pc, write_pc, read_sp, etc. Special handling for registers
918 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
919 read_sp(), will eventually be replaced by per-frame methods.
920 Instead of relying on the global INFERIOR_PTID, they will use the
921 contextual information provided by the FRAME. These functions do
922 not belong in the register cache. */
924 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
925 write_pc_pid() and write_pc(), all need to be replaced by something
926 that does not rely on global state. But what? */
929 read_pc_pid (ptid_t ptid
)
931 ptid_t saved_inferior_ptid
;
934 /* In case ptid != inferior_ptid. */
935 saved_inferior_ptid
= inferior_ptid
;
936 inferior_ptid
= ptid
;
938 if (TARGET_READ_PC_P ())
939 pc_val
= TARGET_READ_PC (ptid
);
940 /* Else use per-frame method on get_current_frame. */
941 else if (PC_REGNUM
>= 0)
943 CORE_ADDR raw_val
= read_register_pid (PC_REGNUM
, ptid
);
944 pc_val
= ADDR_BITS_REMOVE (raw_val
);
947 internal_error (__FILE__
, __LINE__
, _("read_pc_pid: Unable to find PC"));
949 inferior_ptid
= saved_inferior_ptid
;
956 return read_pc_pid (inferior_ptid
);
960 generic_target_write_pc (CORE_ADDR pc
, ptid_t ptid
)
963 write_register_pid (PC_REGNUM
, pc
, ptid
);
965 internal_error (__FILE__
, __LINE__
,
966 _("generic_target_write_pc"));
970 write_pc_pid (CORE_ADDR pc
, ptid_t ptid
)
972 ptid_t saved_inferior_ptid
;
974 /* In case ptid != inferior_ptid. */
975 saved_inferior_ptid
= inferior_ptid
;
976 inferior_ptid
= ptid
;
978 TARGET_WRITE_PC (pc
, ptid
);
980 inferior_ptid
= saved_inferior_ptid
;
984 write_pc (CORE_ADDR pc
)
986 write_pc_pid (pc
, inferior_ptid
);
989 /* Cope with strage ways of getting to the stack and frame pointers */
994 if (TARGET_READ_SP_P ())
995 return TARGET_READ_SP ();
996 else if (gdbarch_unwind_sp_p (current_gdbarch
))
997 return get_frame_sp (get_current_frame ());
998 else if (SP_REGNUM
>= 0)
999 /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1000 about the architecture so put it at the end. */
1001 return read_register (SP_REGNUM
);
1002 internal_error (__FILE__
, __LINE__
, _("read_sp: Unable to find SP"));
1006 reg_flush_command (char *command
, int from_tty
)
1008 /* Force-flush the register cache. */
1009 registers_changed ();
1011 printf_filtered (_("Register cache flushed.\n"));
1015 build_regcache (void)
1017 current_regcache
= regcache_xmalloc (current_gdbarch
);
1018 current_regcache
->readonly_p
= 0;
1022 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
1023 const unsigned char *buf
, long len
)
1028 case BFD_ENDIAN_BIG
:
1029 for (i
= 0; i
< len
; i
++)
1030 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1032 case BFD_ENDIAN_LITTLE
:
1033 for (i
= len
- 1; i
>= 0; i
--)
1034 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1037 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
1041 enum regcache_dump_what
1043 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
1047 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1048 enum regcache_dump_what what_to_dump
)
1050 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1051 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1053 int footnote_nr
= 0;
1054 int footnote_register_size
= 0;
1055 int footnote_register_offset
= 0;
1056 int footnote_register_type_name_null
= 0;
1057 long register_offset
= 0;
1058 unsigned char buf
[MAX_REGISTER_SIZE
];
1061 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1062 regcache
->descr
->nr_raw_registers
);
1063 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1064 regcache
->descr
->nr_cooked_registers
);
1065 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1066 regcache
->descr
->sizeof_raw_registers
);
1067 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
1068 regcache
->descr
->sizeof_raw_register_valid_p
);
1069 fprintf_unfiltered (file
, "NUM_REGS %d\n", NUM_REGS
);
1070 fprintf_unfiltered (file
, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS
);
1073 gdb_assert (regcache
->descr
->nr_cooked_registers
1074 == (NUM_REGS
+ NUM_PSEUDO_REGS
));
1076 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1080 fprintf_unfiltered (file
, " %-10s", "Name");
1083 const char *p
= REGISTER_NAME (regnum
);
1086 else if (p
[0] == '\0')
1088 fprintf_unfiltered (file
, " %-10s", p
);
1093 fprintf_unfiltered (file
, " %4s", "Nr");
1095 fprintf_unfiltered (file
, " %4d", regnum
);
1097 /* Relative number. */
1099 fprintf_unfiltered (file
, " %4s", "Rel");
1100 else if (regnum
< NUM_REGS
)
1101 fprintf_unfiltered (file
, " %4d", regnum
);
1103 fprintf_unfiltered (file
, " %4d", (regnum
- NUM_REGS
));
1107 fprintf_unfiltered (file
, " %6s ", "Offset");
1110 fprintf_unfiltered (file
, " %6ld",
1111 regcache
->descr
->register_offset
[regnum
]);
1112 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1113 || register_offset
!= DEPRECATED_REGISTER_BYTE (regnum
)
1115 && (regcache
->descr
->register_offset
[regnum
]
1116 != (regcache
->descr
->register_offset
[regnum
- 1]
1117 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1120 if (!footnote_register_offset
)
1121 footnote_register_offset
= ++footnote_nr
;
1122 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1125 fprintf_unfiltered (file
, " ");
1126 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1127 + regcache
->descr
->sizeof_register
[regnum
]);
1132 fprintf_unfiltered (file
, " %5s ", "Size");
1134 fprintf_unfiltered (file
, " %5ld",
1135 regcache
->descr
->sizeof_register
[regnum
]);
1144 static const char blt
[] = "builtin_type";
1145 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1149 if (!footnote_register_type_name_null
)
1150 footnote_register_type_name_null
= ++footnote_nr
;
1151 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1152 make_cleanup (xfree
, n
);
1155 /* Chop a leading builtin_type. */
1156 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1159 fprintf_unfiltered (file
, " %-15s", t
);
1162 /* Leading space always present. */
1163 fprintf_unfiltered (file
, " ");
1166 if (what_to_dump
== regcache_dump_raw
)
1169 fprintf_unfiltered (file
, "Raw value");
1170 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1171 fprintf_unfiltered (file
, "<cooked>");
1172 else if (!regcache_valid_p (regcache
, regnum
))
1173 fprintf_unfiltered (file
, "<invalid>");
1176 regcache_raw_read (regcache
, regnum
, buf
);
1177 fprintf_unfiltered (file
, "0x");
1178 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1179 regcache
->descr
->sizeof_register
[regnum
]);
1183 /* Value, cooked. */
1184 if (what_to_dump
== regcache_dump_cooked
)
1187 fprintf_unfiltered (file
, "Cooked value");
1190 regcache_cooked_read (regcache
, regnum
, buf
);
1191 fprintf_unfiltered (file
, "0x");
1192 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1193 regcache
->descr
->sizeof_register
[regnum
]);
1197 /* Group members. */
1198 if (what_to_dump
== regcache_dump_groups
)
1201 fprintf_unfiltered (file
, "Groups");
1204 const char *sep
= "";
1205 struct reggroup
*group
;
1206 for (group
= reggroup_next (gdbarch
, NULL
);
1208 group
= reggroup_next (gdbarch
, group
))
1210 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1212 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1219 fprintf_unfiltered (file
, "\n");
1222 if (footnote_register_size
)
1223 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1224 footnote_register_size
);
1225 if (footnote_register_offset
)
1226 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1227 footnote_register_offset
);
1228 if (footnote_register_type_name_null
)
1229 fprintf_unfiltered (file
,
1230 "*%d: Register type's name NULL.\n",
1231 footnote_register_type_name_null
);
1232 do_cleanups (cleanups
);
1236 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1239 regcache_dump (current_regcache
, gdb_stdout
, what_to_dump
);
1242 struct ui_file
*file
= gdb_fopen (args
, "w");
1244 perror_with_name (_("maintenance print architecture"));
1245 regcache_dump (current_regcache
, file
, what_to_dump
);
1246 ui_file_delete (file
);
1251 maintenance_print_registers (char *args
, int from_tty
)
1253 regcache_print (args
, regcache_dump_none
);
1257 maintenance_print_raw_registers (char *args
, int from_tty
)
1259 regcache_print (args
, regcache_dump_raw
);
1263 maintenance_print_cooked_registers (char *args
, int from_tty
)
1265 regcache_print (args
, regcache_dump_cooked
);
1269 maintenance_print_register_groups (char *args
, int from_tty
)
1271 regcache_print (args
, regcache_dump_groups
);
1274 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1277 _initialize_regcache (void)
1279 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1280 DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache
);
1281 deprecated_register_gdbarch_swap (NULL
, 0, build_regcache
);
1283 observer_attach_target_changed (regcache_observer_target_changed
);
1285 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1286 _("Force gdb to flush its register cache (maintainer command)"));
1288 /* Initialize the thread/process associated with the current set of
1289 registers. For now, -1 is special, and means `no current process'. */
1290 registers_ptid
= pid_to_ptid (-1);
1292 add_cmd ("registers", class_maintenance
, maintenance_print_registers
, _("\
1293 Print the internal register configuration.\n\
1294 Takes an optional file parameter."), &maintenanceprintlist
);
1295 add_cmd ("raw-registers", class_maintenance
,
1296 maintenance_print_raw_registers
, _("\
1297 Print the internal register configuration including raw values.\n\
1298 Takes an optional file parameter."), &maintenanceprintlist
);
1299 add_cmd ("cooked-registers", class_maintenance
,
1300 maintenance_print_cooked_registers
, _("\
1301 Print the internal register configuration including cooked values.\n\
1302 Takes an optional file parameter."), &maintenanceprintlist
);
1303 add_cmd ("register-groups", class_maintenance
,
1304 maintenance_print_register_groups
, _("\
1305 Print the internal register configuration including each register's group.\n\
1306 Takes an optional file parameter."),
1307 &maintenanceprintlist
);