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
= gdbarch_num_regs (current_gdbarch
)
98 + gdbarch_num_pseudo_regs (current_gdbarch
);
99 descr
->sizeof_cooked_register_valid_p
= gdbarch_num_regs (current_gdbarch
)
100 + gdbarch_num_pseudo_regs
103 /* Fill in a table of register types. */
105 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, struct type
*);
106 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
107 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
109 /* Construct a strictly RAW register cache. Don't allow pseudo's
110 into the register cache. */
111 descr
->nr_raw_registers
= gdbarch_num_regs (current_gdbarch
);
113 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
114 array. This pretects GDB from erant code that accesses elements
115 of the global register_valid_p[] array in the range
116 [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs). */
117 descr
->sizeof_raw_register_valid_p
= descr
->sizeof_cooked_register_valid_p
;
119 /* Lay out the register cache.
121 NOTE: cagney/2002-05-22: Only register_type() is used when
122 constructing the register cache. It is assumed that the
123 register's raw size, virtual size and type length are all the
128 descr
->sizeof_register
129 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
130 descr
->register_offset
131 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
132 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
134 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
135 descr
->register_offset
[i
] = offset
;
136 offset
+= descr
->sizeof_register
[i
];
137 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
139 /* Set the real size of the register cache buffer. */
140 descr
->sizeof_cooked_registers
= offset
;
143 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
144 the raw registers. Unfortunately some code still accesses the
145 register array directly using the global registers[]. Until that
146 code has been purged, play safe and over allocating the register
148 descr
->sizeof_raw_registers
= descr
->sizeof_cooked_registers
;
153 static struct regcache_descr
*
154 regcache_descr (struct gdbarch
*gdbarch
)
156 return gdbarch_data (gdbarch
, regcache_descr_handle
);
159 /* Utility functions returning useful register attributes stored in
160 the regcache descr. */
163 register_type (struct gdbarch
*gdbarch
, int regnum
)
165 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
166 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
167 return descr
->register_type
[regnum
];
170 /* Utility functions returning useful register attributes stored in
171 the regcache descr. */
174 register_size (struct gdbarch
*gdbarch
, int regnum
)
176 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
178 gdb_assert (regnum
>= 0
179 && regnum
< (gdbarch_num_regs (current_gdbarch
)
180 + gdbarch_num_pseudo_regs (current_gdbarch
)));
181 size
= descr
->sizeof_register
[regnum
];
185 /* The register cache for storing raw register values. */
189 struct regcache_descr
*descr
;
190 /* The register buffers. A read-only register cache can hold the
191 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
192 register cache can only hold [0 .. gdbarch_num_regs). */
194 /* Register cache status:
195 register_valid_p[REG] == 0 if REG value is not in the cache
196 > 0 if REG value is in the cache
197 < 0 if REG value is permanently unavailable */
198 signed char *register_valid_p
;
199 /* Is this a read-only cache? A read-only cache is used for saving
200 the target's register state (e.g, across an inferior function
201 call or just before forcing a function return). A read-only
202 cache can only be updated via the methods regcache_dup() and
203 regcache_cpy(). The actual contents are determined by the
204 reggroup_save and reggroup_restore methods. */
206 /* If this is a read-write cache, which thread's registers is
212 regcache_xmalloc (struct gdbarch
*gdbarch
)
214 struct regcache_descr
*descr
;
215 struct regcache
*regcache
;
216 gdb_assert (gdbarch
!= NULL
);
217 descr
= regcache_descr (gdbarch
);
218 regcache
= XMALLOC (struct regcache
);
219 regcache
->descr
= descr
;
221 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
222 regcache
->register_valid_p
223 = XCALLOC (descr
->sizeof_raw_register_valid_p
, gdb_byte
);
224 regcache
->readonly_p
= 1;
225 regcache
->ptid
= minus_one_ptid
;
230 regcache_xfree (struct regcache
*regcache
)
232 if (regcache
== NULL
)
234 xfree (regcache
->registers
);
235 xfree (regcache
->register_valid_p
);
240 do_regcache_xfree (void *data
)
242 regcache_xfree (data
);
246 make_cleanup_regcache_xfree (struct regcache
*regcache
)
248 return make_cleanup (do_regcache_xfree
, regcache
);
251 /* Return REGCACHE's architecture. */
254 get_regcache_arch (const struct regcache
*regcache
)
256 return regcache
->descr
->gdbarch
;
259 /* Return a pointer to register REGNUM's buffer cache. */
262 register_buffer (const struct regcache
*regcache
, int regnum
)
264 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
268 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
271 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
272 gdb_byte buf
[MAX_REGISTER_SIZE
];
274 /* The DST should be `read-only', if it wasn't then the save would
275 end up trying to write the register values back out to the
277 gdb_assert (dst
->readonly_p
);
278 /* Clear the dest. */
279 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
280 memset (dst
->register_valid_p
, 0, dst
->descr
->sizeof_cooked_register_valid_p
);
281 /* Copy over any registers (identified by their membership in the
282 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
283 gdbarch_num_pseudo_regs) range is checked since some architectures need
284 to save/restore `cooked' registers that live in memory. */
285 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
287 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
289 int valid
= cooked_read (src
, regnum
, buf
);
292 memcpy (register_buffer (dst
, regnum
), buf
,
293 register_size (gdbarch
, regnum
));
294 dst
->register_valid_p
[regnum
] = 1;
301 regcache_restore (struct regcache
*dst
,
302 regcache_cooked_read_ftype
*cooked_read
,
303 void *cooked_read_context
)
305 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
306 gdb_byte buf
[MAX_REGISTER_SIZE
];
308 /* The dst had better not be read-only. If it is, the `restore'
309 doesn't make much sense. */
310 gdb_assert (!dst
->readonly_p
);
311 /* Copy over any registers, being careful to only restore those that
312 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
313 + gdbarch_num_pseudo_regs) range is checked since some architectures need
314 to save/restore `cooked' registers that live in memory. */
315 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
317 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
319 int valid
= cooked_read (cooked_read_context
, regnum
, buf
);
321 regcache_cooked_write (dst
, regnum
, buf
);
327 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
329 struct regcache
*regcache
= src
;
330 if (!regcache
->register_valid_p
[regnum
] && regcache
->readonly_p
)
331 /* Don't even think about fetching a register from a read-only
332 cache when the register isn't yet valid. There isn't a target
333 from which the register value can be fetched. */
335 regcache_cooked_read (regcache
, regnum
, buf
);
341 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
345 gdb_assert (src
!= NULL
&& dst
!= NULL
);
346 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
347 gdb_assert (src
!= dst
);
348 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
349 if (!src
->readonly_p
)
350 regcache_save (dst
, do_cooked_read
, src
);
351 else if (!dst
->readonly_p
)
352 regcache_restore (dst
, do_cooked_read
, src
);
354 regcache_cpy_no_passthrough (dst
, src
);
358 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
361 gdb_assert (src
!= NULL
&& dst
!= NULL
);
362 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
363 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
364 move of data into the current regcache. Doing this would be
365 silly - it would mean that valid_p would be completely invalid. */
366 gdb_assert (dst
->readonly_p
);
367 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
368 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
369 dst
->descr
->sizeof_raw_register_valid_p
);
373 regcache_dup (struct regcache
*src
)
375 struct regcache
*newbuf
;
376 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
377 regcache_cpy (newbuf
, src
);
382 regcache_dup_no_passthrough (struct regcache
*src
)
384 struct regcache
*newbuf
;
385 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
386 regcache_cpy_no_passthrough (newbuf
, src
);
391 regcache_valid_p (const struct regcache
*regcache
, int regnum
)
393 gdb_assert (regcache
!= NULL
);
394 gdb_assert (regnum
>= 0);
395 if (regcache
->readonly_p
)
396 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
398 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
400 return regcache
->register_valid_p
[regnum
];
404 regcache_invalidate (struct regcache
*regcache
, int regnum
)
406 gdb_assert (regcache
!= NULL
);
407 gdb_assert (regnum
>= 0);
408 gdb_assert (!regcache
->readonly_p
);
409 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
410 regcache
->register_valid_p
[regnum
] = 0;
414 /* Global structure containing the current regcache. */
415 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
416 deprecated_register_valid[] currently point into this structure. */
417 static struct regcache
*current_regcache
;
419 /* NOTE: this is a write-through cache. There is no "dirty" bit for
420 recording if the register values have been changed (eg. by the
421 user). Therefore all registers must be written back to the
422 target when appropriate. */
424 struct regcache
*get_thread_regcache (ptid_t ptid
)
426 /* NOTE: uweigand/2007-05-05: We need to detect the thread's
427 current architecture at this point. */
428 struct gdbarch
*thread_gdbarch
= current_gdbarch
;
430 if (current_regcache
&& ptid_equal (current_regcache
->ptid
, ptid
)
431 && get_regcache_arch (current_regcache
) == thread_gdbarch
)
432 return current_regcache
;
434 if (current_regcache
)
435 regcache_xfree (current_regcache
);
437 current_regcache
= regcache_xmalloc (thread_gdbarch
);
438 current_regcache
->readonly_p
= 0;
439 current_regcache
->ptid
= ptid
;
441 return current_regcache
;
444 struct regcache
*get_current_regcache (void)
446 return get_thread_regcache (inferior_ptid
);
450 /* Observer for the target_changed event. */
453 regcache_observer_target_changed (struct target_ops
*target
)
455 registers_changed ();
458 /* Low level examining and depositing of registers.
460 The caller is responsible for making sure that the inferior is
461 stopped before calling the fetching routines, or it will get
462 garbage. (a change from GDB version 3, in which the caller got the
463 value from the last stop). */
465 /* REGISTERS_CHANGED ()
467 Indicate that registers may have changed, so invalidate the cache. */
470 registers_changed (void)
474 regcache_xfree (current_regcache
);
475 current_regcache
= NULL
;
477 /* Force cleanup of any alloca areas if using C alloca instead of
478 a builtin alloca. This particular call is used to clean up
479 areas allocated by low level target code which may build up
480 during lengthy interactions between gdb and the target before
481 gdb gives control to the user (ie watchpoints). */
487 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
489 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
490 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
491 /* Make certain that the register cache is up-to-date with respect
492 to the current thread. This switching shouldn't be necessary
493 only there is still only one target side register cache. Sigh!
494 On the bright side, at least there is a regcache object. */
495 if (!regcache
->readonly_p
)
497 if (!regcache_valid_p (regcache
, regnum
))
499 struct cleanup
*old_chain
= save_inferior_ptid ();
500 inferior_ptid
= regcache
->ptid
;
501 target_fetch_registers (regcache
, regnum
);
502 do_cleanups (old_chain
);
505 /* FIXME: cagney/2004-08-07: At present a number of targets
506 forget (or didn't know that they needed) to set this leading to
507 panics. Also is the problem that targets need to indicate
508 that a register is in one of the possible states: valid,
509 undefined, unknown. The last of which isn't yet
511 gdb_assert (regcache_valid_p (regcache
, regnum
));
514 /* Copy the value directly into the register cache. */
515 memcpy (buf
, register_buffer (regcache
, regnum
),
516 regcache
->descr
->sizeof_register
[regnum
]);
520 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
523 gdb_assert (regcache
!= NULL
);
524 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
525 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
526 regcache_raw_read (regcache
, regnum
, buf
);
527 (*val
) = extract_signed_integer (buf
,
528 regcache
->descr
->sizeof_register
[regnum
]);
532 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
536 gdb_assert (regcache
!= NULL
);
537 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
538 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
539 regcache_raw_read (regcache
, regnum
, buf
);
540 (*val
) = extract_unsigned_integer (buf
,
541 regcache
->descr
->sizeof_register
[regnum
]);
545 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
548 gdb_assert (regcache
!= NULL
);
549 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
550 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
551 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
552 regcache_raw_write (regcache
, regnum
, buf
);
556 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
560 gdb_assert (regcache
!= NULL
);
561 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
562 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
563 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
564 regcache_raw_write (regcache
, regnum
, buf
);
568 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
570 gdb_assert (regnum
>= 0);
571 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
572 if (regnum
< regcache
->descr
->nr_raw_registers
)
573 regcache_raw_read (regcache
, regnum
, buf
);
574 else if (regcache
->readonly_p
575 && regnum
< regcache
->descr
->nr_cooked_registers
576 && regcache
->register_valid_p
[regnum
])
577 /* Read-only register cache, perhaps the cooked value was cached? */
578 memcpy (buf
, register_buffer (regcache
, regnum
),
579 regcache
->descr
->sizeof_register
[regnum
]);
581 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
586 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
590 gdb_assert (regcache
!= NULL
);
591 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
592 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
593 regcache_cooked_read (regcache
, regnum
, buf
);
594 (*val
) = extract_signed_integer (buf
,
595 regcache
->descr
->sizeof_register
[regnum
]);
599 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
603 gdb_assert (regcache
!= NULL
);
604 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
605 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
606 regcache_cooked_read (regcache
, regnum
, buf
);
607 (*val
) = extract_unsigned_integer (buf
,
608 regcache
->descr
->sizeof_register
[regnum
]);
612 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
616 gdb_assert (regcache
!= NULL
);
617 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
618 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
619 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
620 regcache_cooked_write (regcache
, regnum
, buf
);
624 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
628 gdb_assert (regcache
!= NULL
);
629 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
630 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
631 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
632 regcache_cooked_write (regcache
, regnum
, buf
);
636 regcache_raw_write (struct regcache
*regcache
, int regnum
,
639 struct cleanup
*old_chain
;
641 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
642 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
643 gdb_assert (!regcache
->readonly_p
);
645 /* On the sparc, writing %g0 is a no-op, so we don't even want to
646 change the registers array if something writes to this register. */
647 if (gdbarch_cannot_store_register (current_gdbarch
, regnum
))
650 /* If we have a valid copy of the register, and new value == old
651 value, then don't bother doing the actual store. */
652 if (regcache_valid_p (regcache
, regnum
)
653 && (memcmp (register_buffer (regcache
, regnum
), buf
,
654 regcache
->descr
->sizeof_register
[regnum
]) == 0))
657 old_chain
= save_inferior_ptid ();
658 inferior_ptid
= regcache
->ptid
;
660 target_prepare_to_store (regcache
);
661 memcpy (register_buffer (regcache
, regnum
), buf
,
662 regcache
->descr
->sizeof_register
[regnum
]);
663 regcache
->register_valid_p
[regnum
] = 1;
664 target_store_registers (regcache
, regnum
);
666 do_cleanups (old_chain
);
670 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
673 gdb_assert (regnum
>= 0);
674 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
675 if (regnum
< regcache
->descr
->nr_raw_registers
)
676 regcache_raw_write (regcache
, regnum
, buf
);
678 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
682 /* Perform a partial register transfer using a read, modify, write
685 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
687 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
691 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
692 int offset
, int len
, void *in
, const void *out
,
693 void (*read
) (struct regcache
*regcache
, int regnum
,
695 void (*write
) (struct regcache
*regcache
, int regnum
,
696 const gdb_byte
*buf
))
698 struct regcache_descr
*descr
= regcache
->descr
;
699 gdb_byte reg
[MAX_REGISTER_SIZE
];
700 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
701 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
702 /* Something to do? */
703 if (offset
+ len
== 0)
705 /* Read (when needed) ... */
708 || offset
+ len
< descr
->sizeof_register
[regnum
])
710 gdb_assert (read
!= NULL
);
711 read (regcache
, regnum
, reg
);
715 memcpy (in
, reg
+ offset
, len
);
717 memcpy (reg
+ offset
, out
, len
);
718 /* ... write (when needed). */
721 gdb_assert (write
!= NULL
);
722 write (regcache
, regnum
, reg
);
727 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
728 int offset
, int len
, gdb_byte
*buf
)
730 struct regcache_descr
*descr
= regcache
->descr
;
731 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
732 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
733 regcache_raw_read
, regcache_raw_write
);
737 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
738 int offset
, int len
, const gdb_byte
*buf
)
740 struct regcache_descr
*descr
= regcache
->descr
;
741 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
742 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
743 regcache_raw_read
, regcache_raw_write
);
747 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
748 int offset
, int len
, gdb_byte
*buf
)
750 struct regcache_descr
*descr
= regcache
->descr
;
751 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
752 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
753 regcache_cooked_read
, regcache_cooked_write
);
757 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
758 int offset
, int len
, const gdb_byte
*buf
)
760 struct regcache_descr
*descr
= regcache
->descr
;
761 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
762 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
763 regcache_cooked_read
, regcache_cooked_write
);
766 /* Hack to keep code that view the register buffer as raw bytes
770 register_offset_hack (struct gdbarch
*gdbarch
, int regnum
)
772 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
773 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
774 return descr
->register_offset
[regnum
];
778 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
781 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
786 gdb_assert (regcache
!= NULL
);
787 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
788 gdb_assert (!regcache
->readonly_p
);
790 regbuf
= register_buffer (regcache
, regnum
);
791 size
= regcache
->descr
->sizeof_register
[regnum
];
794 memcpy (regbuf
, buf
, size
);
796 memset (regbuf
, 0, size
);
798 /* Mark the register as cached. */
799 regcache
->register_valid_p
[regnum
] = 1;
802 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
805 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
810 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
811 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
813 regbuf
= register_buffer (regcache
, regnum
);
814 size
= regcache
->descr
->sizeof_register
[regnum
];
815 memcpy (buf
, regbuf
, size
);
819 /* read_pc, write_pc, etc. Special handling for register PC. */
821 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
822 read_sp(), will eventually be replaced by per-frame methods.
823 Instead of relying on the global INFERIOR_PTID, they will use the
824 contextual information provided by the FRAME. These functions do
825 not belong in the register cache. */
827 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
828 write_pc_pid() and write_pc(), all need to be replaced by something
829 that does not rely on global state. But what? */
832 read_pc_pid (ptid_t ptid
)
834 struct regcache
*regcache
= get_thread_regcache (ptid
);
835 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
839 if (gdbarch_read_pc_p (gdbarch
))
840 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
841 /* Else use per-frame method on get_current_frame. */
842 else if (gdbarch_pc_regnum (current_gdbarch
) >= 0)
845 regcache_cooked_read_unsigned (regcache
,
846 gdbarch_pc_regnum (current_gdbarch
),
848 pc_val
= gdbarch_addr_bits_remove (current_gdbarch
, raw_val
);
851 internal_error (__FILE__
, __LINE__
, _("read_pc_pid: Unable to find PC"));
859 return read_pc_pid (inferior_ptid
);
863 write_pc_pid (CORE_ADDR pc
, ptid_t ptid
)
865 struct regcache
*regcache
= get_thread_regcache (ptid
);
866 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
868 if (gdbarch_write_pc_p (gdbarch
))
869 gdbarch_write_pc (gdbarch
, regcache
, pc
);
870 else if (gdbarch_pc_regnum (current_gdbarch
) >= 0)
871 regcache_cooked_write_unsigned (regcache
,
872 gdbarch_pc_regnum (current_gdbarch
), pc
);
874 internal_error (__FILE__
, __LINE__
,
875 _("write_pc_pid: Unable to update PC"));
879 write_pc (CORE_ADDR pc
)
881 write_pc_pid (pc
, inferior_ptid
);
886 reg_flush_command (char *command
, int from_tty
)
888 /* Force-flush the register cache. */
889 registers_changed ();
891 printf_filtered (_("Register cache flushed.\n"));
895 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
896 const unsigned char *buf
, long len
)
902 for (i
= 0; i
< len
; i
++)
903 fprintf_unfiltered (file
, "%02x", buf
[i
]);
905 case BFD_ENDIAN_LITTLE
:
906 for (i
= len
- 1; i
>= 0; i
--)
907 fprintf_unfiltered (file
, "%02x", buf
[i
]);
910 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
914 enum regcache_dump_what
916 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
920 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
921 enum regcache_dump_what what_to_dump
)
923 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
924 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
927 int footnote_register_size
= 0;
928 int footnote_register_offset
= 0;
929 int footnote_register_type_name_null
= 0;
930 long register_offset
= 0;
931 unsigned char buf
[MAX_REGISTER_SIZE
];
934 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
935 regcache
->descr
->nr_raw_registers
);
936 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
937 regcache
->descr
->nr_cooked_registers
);
938 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
939 regcache
->descr
->sizeof_raw_registers
);
940 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
941 regcache
->descr
->sizeof_raw_register_valid_p
);
942 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
943 gdbarch_num_regs (current_gdbarch
));
944 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
945 gdbarch_num_pseudo_regs (current_gdbarch
));
948 gdb_assert (regcache
->descr
->nr_cooked_registers
949 == (gdbarch_num_regs (current_gdbarch
)
950 + gdbarch_num_pseudo_regs (current_gdbarch
)));
952 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
956 fprintf_unfiltered (file
, " %-10s", "Name");
959 const char *p
= gdbarch_register_name (current_gdbarch
, regnum
);
962 else if (p
[0] == '\0')
964 fprintf_unfiltered (file
, " %-10s", p
);
969 fprintf_unfiltered (file
, " %4s", "Nr");
971 fprintf_unfiltered (file
, " %4d", regnum
);
973 /* Relative number. */
975 fprintf_unfiltered (file
, " %4s", "Rel");
976 else if (regnum
< gdbarch_num_regs (current_gdbarch
))
977 fprintf_unfiltered (file
, " %4d", regnum
);
979 fprintf_unfiltered (file
, " %4d",
980 (regnum
- gdbarch_num_regs (current_gdbarch
)));
984 fprintf_unfiltered (file
, " %6s ", "Offset");
987 fprintf_unfiltered (file
, " %6ld",
988 regcache
->descr
->register_offset
[regnum
]);
989 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
991 && (regcache
->descr
->register_offset
[regnum
]
992 != (regcache
->descr
->register_offset
[regnum
- 1]
993 + regcache
->descr
->sizeof_register
[regnum
- 1])))
996 if (!footnote_register_offset
)
997 footnote_register_offset
= ++footnote_nr
;
998 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1001 fprintf_unfiltered (file
, " ");
1002 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1003 + regcache
->descr
->sizeof_register
[regnum
]);
1008 fprintf_unfiltered (file
, " %5s ", "Size");
1010 fprintf_unfiltered (file
, " %5ld",
1011 regcache
->descr
->sizeof_register
[regnum
]);
1020 static const char blt
[] = "builtin_type";
1021 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1025 if (!footnote_register_type_name_null
)
1026 footnote_register_type_name_null
= ++footnote_nr
;
1027 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1028 make_cleanup (xfree
, n
);
1031 /* Chop a leading builtin_type. */
1032 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1035 fprintf_unfiltered (file
, " %-15s", t
);
1038 /* Leading space always present. */
1039 fprintf_unfiltered (file
, " ");
1042 if (what_to_dump
== regcache_dump_raw
)
1045 fprintf_unfiltered (file
, "Raw value");
1046 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1047 fprintf_unfiltered (file
, "<cooked>");
1048 else if (!regcache_valid_p (regcache
, regnum
))
1049 fprintf_unfiltered (file
, "<invalid>");
1052 regcache_raw_read (regcache
, regnum
, buf
);
1053 fprintf_unfiltered (file
, "0x");
1054 dump_endian_bytes (file
,
1055 gdbarch_byte_order (current_gdbarch
), buf
,
1056 regcache
->descr
->sizeof_register
[regnum
]);
1060 /* Value, cooked. */
1061 if (what_to_dump
== regcache_dump_cooked
)
1064 fprintf_unfiltered (file
, "Cooked value");
1067 regcache_cooked_read (regcache
, regnum
, buf
);
1068 fprintf_unfiltered (file
, "0x");
1069 dump_endian_bytes (file
,
1070 gdbarch_byte_order (current_gdbarch
), buf
,
1071 regcache
->descr
->sizeof_register
[regnum
]);
1075 /* Group members. */
1076 if (what_to_dump
== regcache_dump_groups
)
1079 fprintf_unfiltered (file
, "Groups");
1082 const char *sep
= "";
1083 struct reggroup
*group
;
1084 for (group
= reggroup_next (gdbarch
, NULL
);
1086 group
= reggroup_next (gdbarch
, group
))
1088 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1090 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1097 fprintf_unfiltered (file
, "\n");
1100 if (footnote_register_size
)
1101 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1102 footnote_register_size
);
1103 if (footnote_register_offset
)
1104 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1105 footnote_register_offset
);
1106 if (footnote_register_type_name_null
)
1107 fprintf_unfiltered (file
,
1108 "*%d: Register type's name NULL.\n",
1109 footnote_register_type_name_null
);
1110 do_cleanups (cleanups
);
1114 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1117 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1120 struct ui_file
*file
= gdb_fopen (args
, "w");
1122 perror_with_name (_("maintenance print architecture"));
1123 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1124 ui_file_delete (file
);
1129 maintenance_print_registers (char *args
, int from_tty
)
1131 regcache_print (args
, regcache_dump_none
);
1135 maintenance_print_raw_registers (char *args
, int from_tty
)
1137 regcache_print (args
, regcache_dump_raw
);
1141 maintenance_print_cooked_registers (char *args
, int from_tty
)
1143 regcache_print (args
, regcache_dump_cooked
);
1147 maintenance_print_register_groups (char *args
, int from_tty
)
1149 regcache_print (args
, regcache_dump_groups
);
1152 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1155 _initialize_regcache (void)
1157 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1159 observer_attach_target_changed (regcache_observer_target_changed
);
1161 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1162 _("Force gdb to flush its register cache (maintainer command)"));
1164 add_cmd ("registers", class_maintenance
, maintenance_print_registers
, _("\
1165 Print the internal register configuration.\n\
1166 Takes an optional file parameter."), &maintenanceprintlist
);
1167 add_cmd ("raw-registers", class_maintenance
,
1168 maintenance_print_raw_registers
, _("\
1169 Print the internal register configuration including raw values.\n\
1170 Takes an optional file parameter."), &maintenanceprintlist
);
1171 add_cmd ("cooked-registers", class_maintenance
,
1172 maintenance_print_cooked_registers
, _("\
1173 Print the internal register configuration including cooked values.\n\
1174 Takes an optional file parameter."), &maintenanceprintlist
);
1175 add_cmd ("register-groups", class_maintenance
,
1176 maintenance_print_register_groups
, _("\
1177 Print the internal register configuration including each register's group.\n\
1178 Takes an optional file parameter."),
1179 &maintenanceprintlist
);