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, 2008, 2009 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 3 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, see <http://www.gnu.org/licenses/>. */
27 #include "reggroups.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #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 /* The raw register cache. Each raw (or hard) register is supplied
50 by the target interface. The raw cache should not contain
51 redundant information - if the PC is constructed from two
52 registers then those registers and not the PC lives in the raw
55 long sizeof_raw_registers
;
56 long sizeof_raw_register_valid_p
;
58 /* The cooked register space. Each cooked register in the range
59 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
60 register. The remaining [NR_RAW_REGISTERS
61 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
62 both raw registers and memory by the architecture methods
63 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
64 int nr_cooked_registers
;
65 long sizeof_cooked_registers
;
66 long sizeof_cooked_register_valid_p
;
68 /* Offset and size (in 8 bit bytes), of reach register in the
69 register cache. All registers (including those in the range
70 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
71 Assigning all registers an offset makes it possible to keep
72 legacy code, such as that found in read_register_bytes() and
73 write_register_bytes() working. */
74 long *register_offset
;
75 long *sizeof_register
;
77 /* Cached table containing the type of each register. */
78 struct type
**register_type
;
82 init_regcache_descr (struct gdbarch
*gdbarch
)
85 struct regcache_descr
*descr
;
86 gdb_assert (gdbarch
!= NULL
);
88 /* Create an initial, zero filled, table. */
89 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
90 descr
->gdbarch
= gdbarch
;
92 /* Total size of the register space. The raw registers are mapped
93 directly onto the raw register cache while the pseudo's are
94 either mapped onto raw-registers or memory. */
95 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
96 + gdbarch_num_pseudo_regs (gdbarch
);
97 descr
->sizeof_cooked_register_valid_p
= gdbarch_num_regs (gdbarch
)
98 + gdbarch_num_pseudo_regs
101 /* Fill in a table of register types. */
103 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, struct type
*);
104 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
105 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
107 /* Construct a strictly RAW register cache. Don't allow pseudo's
108 into the register cache. */
109 descr
->nr_raw_registers
= gdbarch_num_regs (gdbarch
);
111 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
112 array. This pretects GDB from erant code that accesses elements
113 of the global register_valid_p[] array in the range
114 [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs). */
115 descr
->sizeof_raw_register_valid_p
= descr
->sizeof_cooked_register_valid_p
;
117 /* Lay out the register cache.
119 NOTE: cagney/2002-05-22: Only register_type() is used when
120 constructing the register cache. It is assumed that the
121 register's raw size, virtual size and type length are all the
126 descr
->sizeof_register
127 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
128 descr
->register_offset
129 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
130 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
132 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
133 descr
->register_offset
[i
] = offset
;
134 offset
+= descr
->sizeof_register
[i
];
135 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
137 /* Set the real size of the register cache buffer. */
138 descr
->sizeof_cooked_registers
= offset
;
141 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
142 the raw registers. Unfortunately some code still accesses the
143 register array directly using the global registers[]. Until that
144 code has been purged, play safe and over allocating the register
146 descr
->sizeof_raw_registers
= descr
->sizeof_cooked_registers
;
151 static struct regcache_descr
*
152 regcache_descr (struct gdbarch
*gdbarch
)
154 return gdbarch_data (gdbarch
, regcache_descr_handle
);
157 /* Utility functions returning useful register attributes stored in
158 the regcache descr. */
161 register_type (struct gdbarch
*gdbarch
, int regnum
)
163 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
164 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
165 return descr
->register_type
[regnum
];
168 /* Utility functions returning useful register attributes stored in
169 the regcache descr. */
172 register_size (struct gdbarch
*gdbarch
, int regnum
)
174 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
176 gdb_assert (regnum
>= 0
177 && regnum
< (gdbarch_num_regs (gdbarch
)
178 + gdbarch_num_pseudo_regs (gdbarch
)));
179 size
= descr
->sizeof_register
[regnum
];
183 /* The register cache for storing raw register values. */
187 struct regcache_descr
*descr
;
188 /* The register buffers. A read-only register cache can hold the
189 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
190 register cache can only hold [0 .. gdbarch_num_regs). */
192 /* Register cache status:
193 register_valid_p[REG] == 0 if REG value is not in the cache
194 > 0 if REG value is in the cache
195 < 0 if REG value is permanently unavailable */
196 signed char *register_valid_p
;
197 /* Is this a read-only cache? A read-only cache is used for saving
198 the target's register state (e.g, across an inferior function
199 call or just before forcing a function return). A read-only
200 cache can only be updated via the methods regcache_dup() and
201 regcache_cpy(). The actual contents are determined by the
202 reggroup_save and reggroup_restore methods. */
204 /* If this is a read-write cache, which thread's registers is
210 regcache_xmalloc (struct gdbarch
*gdbarch
)
212 struct regcache_descr
*descr
;
213 struct regcache
*regcache
;
214 gdb_assert (gdbarch
!= NULL
);
215 descr
= regcache_descr (gdbarch
);
216 regcache
= XMALLOC (struct regcache
);
217 regcache
->descr
= descr
;
219 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
220 regcache
->register_valid_p
221 = XCALLOC (descr
->sizeof_raw_register_valid_p
, gdb_byte
);
222 regcache
->readonly_p
= 1;
223 regcache
->ptid
= minus_one_ptid
;
228 regcache_xfree (struct regcache
*regcache
)
230 if (regcache
== NULL
)
232 xfree (regcache
->registers
);
233 xfree (regcache
->register_valid_p
);
238 do_regcache_xfree (void *data
)
240 regcache_xfree (data
);
244 make_cleanup_regcache_xfree (struct regcache
*regcache
)
246 return make_cleanup (do_regcache_xfree
, regcache
);
249 /* Return REGCACHE's architecture. */
252 get_regcache_arch (const struct regcache
*regcache
)
254 return regcache
->descr
->gdbarch
;
257 /* Return a pointer to register REGNUM's buffer cache. */
260 register_buffer (const struct regcache
*regcache
, int regnum
)
262 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
266 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
269 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
270 gdb_byte buf
[MAX_REGISTER_SIZE
];
272 /* The DST should be `read-only', if it wasn't then the save would
273 end up trying to write the register values back out to the
275 gdb_assert (dst
->readonly_p
);
276 /* Clear the dest. */
277 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
278 memset (dst
->register_valid_p
, 0, dst
->descr
->sizeof_cooked_register_valid_p
);
279 /* Copy over any registers (identified by their membership in the
280 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
281 gdbarch_num_pseudo_regs) range is checked since some architectures need
282 to save/restore `cooked' registers that live in memory. */
283 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
285 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
287 int valid
= cooked_read (src
, regnum
, buf
);
290 memcpy (register_buffer (dst
, regnum
), buf
,
291 register_size (gdbarch
, regnum
));
292 dst
->register_valid_p
[regnum
] = 1;
299 regcache_restore (struct regcache
*dst
,
300 regcache_cooked_read_ftype
*cooked_read
,
301 void *cooked_read_context
)
303 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
304 gdb_byte buf
[MAX_REGISTER_SIZE
];
306 /* The dst had better not be read-only. If it is, the `restore'
307 doesn't make much sense. */
308 gdb_assert (!dst
->readonly_p
);
309 /* Copy over any registers, being careful to only restore those that
310 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
311 + gdbarch_num_pseudo_regs) range is checked since some architectures need
312 to save/restore `cooked' registers that live in memory. */
313 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
315 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
317 int valid
= cooked_read (cooked_read_context
, regnum
, buf
);
319 regcache_cooked_write (dst
, regnum
, buf
);
325 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
327 struct regcache
*regcache
= src
;
328 if (!regcache
->register_valid_p
[regnum
] && regcache
->readonly_p
)
329 /* Don't even think about fetching a register from a read-only
330 cache when the register isn't yet valid. There isn't a target
331 from which the register value can be fetched. */
333 regcache_cooked_read (regcache
, regnum
, buf
);
339 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
343 gdb_assert (src
!= NULL
&& dst
!= NULL
);
344 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
345 gdb_assert (src
!= dst
);
346 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
347 if (!src
->readonly_p
)
348 regcache_save (dst
, do_cooked_read
, src
);
349 else if (!dst
->readonly_p
)
350 regcache_restore (dst
, do_cooked_read
, src
);
352 regcache_cpy_no_passthrough (dst
, src
);
356 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
359 gdb_assert (src
!= NULL
&& dst
!= NULL
);
360 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
361 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
362 move of data into the current regcache. Doing this would be
363 silly - it would mean that valid_p would be completely invalid. */
364 gdb_assert (dst
->readonly_p
);
365 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
366 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
367 dst
->descr
->sizeof_raw_register_valid_p
);
371 regcache_dup (struct regcache
*src
)
373 struct regcache
*newbuf
;
374 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
375 regcache_cpy (newbuf
, src
);
380 regcache_dup_no_passthrough (struct regcache
*src
)
382 struct regcache
*newbuf
;
383 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
384 regcache_cpy_no_passthrough (newbuf
, src
);
389 regcache_valid_p (const struct regcache
*regcache
, int regnum
)
391 gdb_assert (regcache
!= NULL
);
392 gdb_assert (regnum
>= 0);
393 if (regcache
->readonly_p
)
394 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
396 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
398 return regcache
->register_valid_p
[regnum
];
402 regcache_invalidate (struct regcache
*regcache
, int regnum
)
404 gdb_assert (regcache
!= NULL
);
405 gdb_assert (regnum
>= 0);
406 gdb_assert (!regcache
->readonly_p
);
407 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
408 regcache
->register_valid_p
[regnum
] = 0;
412 /* Global structure containing the current regcache. */
414 /* NOTE: this is a write-through cache. There is no "dirty" bit for
415 recording if the register values have been changed (eg. by the
416 user). Therefore all registers must be written back to the
417 target when appropriate. */
421 struct regcache
*regcache
;
422 struct regcache_list
*next
;
425 static struct regcache_list
*current_regcache
;
428 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
430 struct regcache_list
*list
;
431 struct regcache
*new_regcache
;
433 for (list
= current_regcache
; list
; list
= list
->next
)
434 if (ptid_equal (list
->regcache
->ptid
, ptid
)
435 && get_regcache_arch (list
->regcache
) == gdbarch
)
436 return list
->regcache
;
438 new_regcache
= regcache_xmalloc (gdbarch
);
439 new_regcache
->readonly_p
= 0;
440 new_regcache
->ptid
= ptid
;
442 list
= xmalloc (sizeof (struct regcache_list
));
443 list
->regcache
= new_regcache
;
444 list
->next
= current_regcache
;
445 current_regcache
= list
;
450 static ptid_t current_thread_ptid
;
451 static struct gdbarch
*current_thread_arch
;
454 get_thread_regcache (ptid_t ptid
)
456 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
458 current_thread_ptid
= ptid
;
459 current_thread_arch
= target_thread_architecture (ptid
);
462 return get_thread_arch_regcache (ptid
, current_thread_arch
);
466 get_current_regcache (void)
468 return get_thread_regcache (inferior_ptid
);
472 /* Observer for the target_changed event. */
475 regcache_observer_target_changed (struct target_ops
*target
)
477 registers_changed ();
480 /* Update global variables old ptids to hold NEW_PTID if they were
483 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
485 struct regcache_list
*list
;
487 for (list
= current_regcache
; list
; list
= list
->next
)
488 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
489 list
->regcache
->ptid
= new_ptid
;
492 /* Low level examining and depositing of registers.
494 The caller is responsible for making sure that the inferior is
495 stopped before calling the fetching routines, or it will get
496 garbage. (a change from GDB version 3, in which the caller got the
497 value from the last stop). */
499 /* REGISTERS_CHANGED ()
501 Indicate that registers may have changed, so invalidate the cache. */
504 registers_changed (void)
506 struct regcache_list
*list
, *next
;
508 for (list
= current_regcache
; list
; list
= next
)
511 regcache_xfree (list
->regcache
);
515 current_regcache
= NULL
;
517 current_thread_ptid
= null_ptid
;
518 current_thread_arch
= NULL
;
520 /* Need to forget about any frames we have cached, too. */
521 reinit_frame_cache ();
523 /* Force cleanup of any alloca areas if using C alloca instead of
524 a builtin alloca. This particular call is used to clean up
525 areas allocated by low level target code which may build up
526 during lengthy interactions between gdb and the target before
527 gdb gives control to the user (ie watchpoints). */
533 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
535 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
536 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
537 /* Make certain that the register cache is up-to-date with respect
538 to the current thread. This switching shouldn't be necessary
539 only there is still only one target side register cache. Sigh!
540 On the bright side, at least there is a regcache object. */
541 if (!regcache
->readonly_p
)
543 if (!regcache_valid_p (regcache
, regnum
))
545 struct cleanup
*old_chain
= save_inferior_ptid ();
546 inferior_ptid
= regcache
->ptid
;
547 target_fetch_registers (regcache
, regnum
);
548 do_cleanups (old_chain
);
551 /* FIXME: cagney/2004-08-07: At present a number of targets
552 forget (or didn't know that they needed) to set this leading to
553 panics. Also is the problem that targets need to indicate
554 that a register is in one of the possible states: valid,
555 undefined, unknown. The last of which isn't yet
557 gdb_assert (regcache_valid_p (regcache
, regnum
));
560 /* Copy the value directly into the register cache. */
561 memcpy (buf
, register_buffer (regcache
, regnum
),
562 regcache
->descr
->sizeof_register
[regnum
]);
566 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
569 gdb_assert (regcache
!= NULL
);
570 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
571 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
572 regcache_raw_read (regcache
, regnum
, buf
);
573 (*val
) = extract_signed_integer (buf
,
574 regcache
->descr
->sizeof_register
[regnum
]);
578 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
582 gdb_assert (regcache
!= NULL
);
583 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
584 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
585 regcache_raw_read (regcache
, regnum
, buf
);
586 (*val
) = extract_unsigned_integer (buf
,
587 regcache
->descr
->sizeof_register
[regnum
]);
591 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
594 gdb_assert (regcache
!= NULL
);
595 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
596 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
597 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
598 regcache_raw_write (regcache
, regnum
, buf
);
602 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
606 gdb_assert (regcache
!= NULL
);
607 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
608 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
609 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
610 regcache_raw_write (regcache
, regnum
, buf
);
614 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
616 gdb_assert (regnum
>= 0);
617 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
618 if (regnum
< regcache
->descr
->nr_raw_registers
)
619 regcache_raw_read (regcache
, regnum
, buf
);
620 else if (regcache
->readonly_p
621 && regnum
< regcache
->descr
->nr_cooked_registers
622 && regcache
->register_valid_p
[regnum
])
623 /* Read-only register cache, perhaps the cooked value was cached? */
624 memcpy (buf
, register_buffer (regcache
, regnum
),
625 regcache
->descr
->sizeof_register
[regnum
]);
627 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
632 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
636 gdb_assert (regcache
!= NULL
);
637 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
638 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
639 regcache_cooked_read (regcache
, regnum
, buf
);
640 (*val
) = extract_signed_integer (buf
,
641 regcache
->descr
->sizeof_register
[regnum
]);
645 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
649 gdb_assert (regcache
!= NULL
);
650 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
651 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
652 regcache_cooked_read (regcache
, regnum
, buf
);
653 (*val
) = extract_unsigned_integer (buf
,
654 regcache
->descr
->sizeof_register
[regnum
]);
658 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
662 gdb_assert (regcache
!= NULL
);
663 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
664 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
665 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
666 regcache_cooked_write (regcache
, regnum
, buf
);
670 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
674 gdb_assert (regcache
!= NULL
);
675 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
676 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
677 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
678 regcache_cooked_write (regcache
, regnum
, buf
);
682 regcache_raw_write (struct regcache
*regcache
, int regnum
,
685 struct cleanup
*old_chain
;
687 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
688 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
689 gdb_assert (!regcache
->readonly_p
);
691 /* On the sparc, writing %g0 is a no-op, so we don't even want to
692 change the registers array if something writes to this register. */
693 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
696 /* If we have a valid copy of the register, and new value == old
697 value, then don't bother doing the actual store. */
698 if (regcache_valid_p (regcache
, regnum
)
699 && (memcmp (register_buffer (regcache
, regnum
), buf
,
700 regcache
->descr
->sizeof_register
[regnum
]) == 0))
703 old_chain
= save_inferior_ptid ();
704 inferior_ptid
= regcache
->ptid
;
706 target_prepare_to_store (regcache
);
707 memcpy (register_buffer (regcache
, regnum
), buf
,
708 regcache
->descr
->sizeof_register
[regnum
]);
709 regcache
->register_valid_p
[regnum
] = 1;
710 target_store_registers (regcache
, regnum
);
712 do_cleanups (old_chain
);
716 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
719 gdb_assert (regnum
>= 0);
720 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
721 if (regnum
< regcache
->descr
->nr_raw_registers
)
722 regcache_raw_write (regcache
, regnum
, buf
);
724 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
728 /* Perform a partial register transfer using a read, modify, write
731 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
733 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
737 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
738 int offset
, int len
, void *in
, const void *out
,
739 void (*read
) (struct regcache
*regcache
, int regnum
,
741 void (*write
) (struct regcache
*regcache
, int regnum
,
742 const gdb_byte
*buf
))
744 struct regcache_descr
*descr
= regcache
->descr
;
745 gdb_byte reg
[MAX_REGISTER_SIZE
];
746 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
747 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
748 /* Something to do? */
749 if (offset
+ len
== 0)
751 /* Read (when needed) ... */
754 || offset
+ len
< descr
->sizeof_register
[regnum
])
756 gdb_assert (read
!= NULL
);
757 read (regcache
, regnum
, reg
);
761 memcpy (in
, reg
+ offset
, len
);
763 memcpy (reg
+ offset
, out
, len
);
764 /* ... write (when needed). */
767 gdb_assert (write
!= NULL
);
768 write (regcache
, regnum
, reg
);
773 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
774 int offset
, int len
, gdb_byte
*buf
)
776 struct regcache_descr
*descr
= regcache
->descr
;
777 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
778 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
779 regcache_raw_read
, regcache_raw_write
);
783 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
784 int offset
, int len
, const gdb_byte
*buf
)
786 struct regcache_descr
*descr
= regcache
->descr
;
787 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
788 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
789 regcache_raw_read
, regcache_raw_write
);
793 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
794 int offset
, int len
, gdb_byte
*buf
)
796 struct regcache_descr
*descr
= regcache
->descr
;
797 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
798 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
799 regcache_cooked_read
, regcache_cooked_write
);
803 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
804 int offset
, int len
, const gdb_byte
*buf
)
806 struct regcache_descr
*descr
= regcache
->descr
;
807 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
808 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
809 regcache_cooked_read
, regcache_cooked_write
);
812 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
815 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
820 gdb_assert (regcache
!= NULL
);
821 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
822 gdb_assert (!regcache
->readonly_p
);
824 regbuf
= register_buffer (regcache
, regnum
);
825 size
= regcache
->descr
->sizeof_register
[regnum
];
828 memcpy (regbuf
, buf
, size
);
830 memset (regbuf
, 0, size
);
832 /* Mark the register as cached. */
833 regcache
->register_valid_p
[regnum
] = 1;
836 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
839 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
844 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
845 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
847 regbuf
= register_buffer (regcache
, regnum
);
848 size
= regcache
->descr
->sizeof_register
[regnum
];
849 memcpy (buf
, regbuf
, size
);
853 /* Special handling for register PC. */
856 regcache_read_pc (struct regcache
*regcache
)
858 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
862 if (gdbarch_read_pc_p (gdbarch
))
863 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
864 /* Else use per-frame method on get_current_frame. */
865 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
868 regcache_cooked_read_unsigned (regcache
,
869 gdbarch_pc_regnum (gdbarch
),
871 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
874 internal_error (__FILE__
, __LINE__
,
875 _("regcache_read_pc: Unable to find PC"));
880 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
882 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
884 if (gdbarch_write_pc_p (gdbarch
))
885 gdbarch_write_pc (gdbarch
, regcache
, pc
);
886 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
887 regcache_cooked_write_unsigned (regcache
,
888 gdbarch_pc_regnum (gdbarch
), pc
);
890 internal_error (__FILE__
, __LINE__
,
891 _("regcache_write_pc: Unable to update PC"));
893 /* Writing the PC (for instance, from "load") invalidates the
895 reinit_frame_cache ();
900 reg_flush_command (char *command
, int from_tty
)
902 /* Force-flush the register cache. */
903 registers_changed ();
905 printf_filtered (_("Register cache flushed.\n"));
909 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
910 const unsigned char *buf
, long len
)
916 for (i
= 0; i
< len
; i
++)
917 fprintf_unfiltered (file
, "%02x", buf
[i
]);
919 case BFD_ENDIAN_LITTLE
:
920 for (i
= len
- 1; i
>= 0; i
--)
921 fprintf_unfiltered (file
, "%02x", buf
[i
]);
924 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
928 enum regcache_dump_what
930 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
934 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
935 enum regcache_dump_what what_to_dump
)
937 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
938 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
941 int footnote_register_size
= 0;
942 int footnote_register_offset
= 0;
943 int footnote_register_type_name_null
= 0;
944 long register_offset
= 0;
945 unsigned char buf
[MAX_REGISTER_SIZE
];
948 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
949 regcache
->descr
->nr_raw_registers
);
950 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
951 regcache
->descr
->nr_cooked_registers
);
952 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
953 regcache
->descr
->sizeof_raw_registers
);
954 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
955 regcache
->descr
->sizeof_raw_register_valid_p
);
956 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
957 gdbarch_num_regs (gdbarch
));
958 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
959 gdbarch_num_pseudo_regs (gdbarch
));
962 gdb_assert (regcache
->descr
->nr_cooked_registers
963 == (gdbarch_num_regs (gdbarch
)
964 + gdbarch_num_pseudo_regs (gdbarch
)));
966 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
970 fprintf_unfiltered (file
, " %-10s", "Name");
973 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
976 else if (p
[0] == '\0')
978 fprintf_unfiltered (file
, " %-10s", p
);
983 fprintf_unfiltered (file
, " %4s", "Nr");
985 fprintf_unfiltered (file
, " %4d", regnum
);
987 /* Relative number. */
989 fprintf_unfiltered (file
, " %4s", "Rel");
990 else if (regnum
< gdbarch_num_regs (gdbarch
))
991 fprintf_unfiltered (file
, " %4d", regnum
);
993 fprintf_unfiltered (file
, " %4d",
994 (regnum
- gdbarch_num_regs (gdbarch
)));
998 fprintf_unfiltered (file
, " %6s ", "Offset");
1001 fprintf_unfiltered (file
, " %6ld",
1002 regcache
->descr
->register_offset
[regnum
]);
1003 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1005 && (regcache
->descr
->register_offset
[regnum
]
1006 != (regcache
->descr
->register_offset
[regnum
- 1]
1007 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1010 if (!footnote_register_offset
)
1011 footnote_register_offset
= ++footnote_nr
;
1012 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1015 fprintf_unfiltered (file
, " ");
1016 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1017 + regcache
->descr
->sizeof_register
[regnum
]);
1022 fprintf_unfiltered (file
, " %5s ", "Size");
1024 fprintf_unfiltered (file
, " %5ld",
1025 regcache
->descr
->sizeof_register
[regnum
]);
1034 static const char blt
[] = "builtin_type";
1035 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1039 if (!footnote_register_type_name_null
)
1040 footnote_register_type_name_null
= ++footnote_nr
;
1041 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1042 make_cleanup (xfree
, n
);
1045 /* Chop a leading builtin_type. */
1046 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1049 fprintf_unfiltered (file
, " %-15s", t
);
1052 /* Leading space always present. */
1053 fprintf_unfiltered (file
, " ");
1056 if (what_to_dump
== regcache_dump_raw
)
1059 fprintf_unfiltered (file
, "Raw value");
1060 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1061 fprintf_unfiltered (file
, "<cooked>");
1062 else if (!regcache_valid_p (regcache
, regnum
))
1063 fprintf_unfiltered (file
, "<invalid>");
1066 regcache_raw_read (regcache
, regnum
, buf
);
1067 fprintf_unfiltered (file
, "0x");
1068 dump_endian_bytes (file
,
1069 gdbarch_byte_order (gdbarch
), buf
,
1070 regcache
->descr
->sizeof_register
[regnum
]);
1074 /* Value, cooked. */
1075 if (what_to_dump
== regcache_dump_cooked
)
1078 fprintf_unfiltered (file
, "Cooked value");
1081 regcache_cooked_read (regcache
, regnum
, buf
);
1082 fprintf_unfiltered (file
, "0x");
1083 dump_endian_bytes (file
,
1084 gdbarch_byte_order (gdbarch
), buf
,
1085 regcache
->descr
->sizeof_register
[regnum
]);
1089 /* Group members. */
1090 if (what_to_dump
== regcache_dump_groups
)
1093 fprintf_unfiltered (file
, "Groups");
1096 const char *sep
= "";
1097 struct reggroup
*group
;
1098 for (group
= reggroup_next (gdbarch
, NULL
);
1100 group
= reggroup_next (gdbarch
, group
))
1102 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1104 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1111 fprintf_unfiltered (file
, "\n");
1114 if (footnote_register_size
)
1115 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1116 footnote_register_size
);
1117 if (footnote_register_offset
)
1118 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1119 footnote_register_offset
);
1120 if (footnote_register_type_name_null
)
1121 fprintf_unfiltered (file
,
1122 "*%d: Register type's name NULL.\n",
1123 footnote_register_type_name_null
);
1124 do_cleanups (cleanups
);
1128 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1131 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1134 struct cleanup
*cleanups
;
1135 struct ui_file
*file
= gdb_fopen (args
, "w");
1137 perror_with_name (_("maintenance print architecture"));
1138 cleanups
= make_cleanup_ui_file_delete (file
);
1139 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1140 do_cleanups (cleanups
);
1145 maintenance_print_registers (char *args
, int from_tty
)
1147 regcache_print (args
, regcache_dump_none
);
1151 maintenance_print_raw_registers (char *args
, int from_tty
)
1153 regcache_print (args
, regcache_dump_raw
);
1157 maintenance_print_cooked_registers (char *args
, int from_tty
)
1159 regcache_print (args
, regcache_dump_cooked
);
1163 maintenance_print_register_groups (char *args
, int from_tty
)
1165 regcache_print (args
, regcache_dump_groups
);
1168 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1171 _initialize_regcache (void)
1173 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1175 observer_attach_target_changed (regcache_observer_target_changed
);
1176 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1178 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1179 _("Force gdb to flush its register cache (maintainer command)"));
1181 add_cmd ("registers", class_maintenance
, maintenance_print_registers
, _("\
1182 Print the internal register configuration.\n\
1183 Takes an optional file parameter."), &maintenanceprintlist
);
1184 add_cmd ("raw-registers", class_maintenance
,
1185 maintenance_print_raw_registers
, _("\
1186 Print the internal register configuration including raw values.\n\
1187 Takes an optional file parameter."), &maintenanceprintlist
);
1188 add_cmd ("cooked-registers", class_maintenance
,
1189 maintenance_print_cooked_registers
, _("\
1190 Print the internal register configuration including cooked values.\n\
1191 Takes an optional file parameter."), &maintenanceprintlist
);
1192 add_cmd ("register-groups", class_maintenance
,
1193 maintenance_print_register_groups
, _("\
1194 Print the internal register configuration including each register's group.\n\
1195 Takes an optional file parameter."),
1196 &maintenanceprintlist
);