1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "reggroups.h"
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "gdbcmd.h" /* For maintenanceprintlist. */
31 #include "exceptions.h"
37 * Here is the actual register cache.
40 /* Per-architecture object describing the layout of a register cache.
41 Computed once when the architecture is created. */
43 struct gdbarch_data
*regcache_descr_handle
;
47 /* The architecture this descriptor belongs to. */
48 struct gdbarch
*gdbarch
;
50 /* The raw register cache. Each raw (or hard) register is supplied
51 by the target interface. The raw cache should not contain
52 redundant information - if the PC is constructed from two
53 registers then those registers and not the PC lives in the raw
56 long sizeof_raw_registers
;
57 long sizeof_raw_register_status
;
59 /* The cooked register space. Each cooked register in the range
60 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
61 register. The remaining [NR_RAW_REGISTERS
62 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
63 both raw registers and memory by the architecture methods
64 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
65 int nr_cooked_registers
;
66 long sizeof_cooked_registers
;
67 long sizeof_cooked_register_status
;
69 /* Offset and size (in 8 bit bytes), of each register in the
70 register cache. All registers (including those in the range
71 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
73 long *register_offset
;
74 long *sizeof_register
;
76 /* Cached table containing the type of each register. */
77 struct type
**register_type
;
81 init_regcache_descr (struct gdbarch
*gdbarch
)
84 struct regcache_descr
*descr
;
85 gdb_assert (gdbarch
!= NULL
);
87 /* Create an initial, zero filled, table. */
88 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
89 descr
->gdbarch
= gdbarch
;
91 /* Total size of the register space. The raw registers are mapped
92 directly onto the raw register cache while the pseudo's are
93 either mapped onto raw-registers or memory. */
94 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
95 + gdbarch_num_pseudo_regs (gdbarch
);
96 descr
->sizeof_cooked_register_status
97 = gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
99 /* Fill in a table of register types. */
101 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
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
= gdbarch_num_regs (gdbarch
);
109 descr
->sizeof_raw_register_status
= gdbarch_num_regs (gdbarch
);
111 /* Lay out the register cache.
113 NOTE: cagney/2002-05-22: Only register_type() is used when
114 constructing the register cache. It is assumed that the
115 register's raw size, virtual size and type length are all the
121 descr
->sizeof_register
122 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
123 descr
->register_offset
124 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
125 for (i
= 0; i
< descr
->nr_raw_registers
; i
++)
127 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
128 descr
->register_offset
[i
] = offset
;
129 offset
+= descr
->sizeof_register
[i
];
130 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
132 /* Set the real size of the raw register cache buffer. */
133 descr
->sizeof_raw_registers
= offset
;
135 for (; i
< descr
->nr_cooked_registers
; i
++)
137 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
138 descr
->register_offset
[i
] = offset
;
139 offset
+= descr
->sizeof_register
[i
];
140 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
142 /* Set the real size of the readonly register cache buffer. */
143 descr
->sizeof_cooked_registers
= offset
;
149 static struct regcache_descr
*
150 regcache_descr (struct gdbarch
*gdbarch
)
152 return gdbarch_data (gdbarch
, regcache_descr_handle
);
155 /* Utility functions returning useful register attributes stored in
156 the regcache descr. */
159 register_type (struct gdbarch
*gdbarch
, int regnum
)
161 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
);
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
;
189 /* The address space of this register cache (for registers where it
190 makes sense, like PC or SP). */
191 struct address_space
*aspace
;
193 /* The register buffers. A read-only register cache can hold the
194 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
195 register cache can only hold [0 .. gdbarch_num_regs). */
197 /* Register cache status. */
198 signed char *register_status
;
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
211 static struct regcache
*
212 regcache_xmalloc_1 (struct gdbarch
*gdbarch
, struct address_space
*aspace
,
215 struct regcache_descr
*descr
;
216 struct regcache
*regcache
;
218 gdb_assert (gdbarch
!= NULL
);
219 descr
= regcache_descr (gdbarch
);
220 regcache
= XMALLOC (struct regcache
);
221 regcache
->descr
= descr
;
222 regcache
->readonly_p
= readonly_p
;
226 = XCALLOC (descr
->sizeof_cooked_registers
, gdb_byte
);
227 regcache
->register_status
228 = XCALLOC (descr
->sizeof_cooked_register_status
, gdb_byte
);
233 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
234 regcache
->register_status
235 = XCALLOC (descr
->sizeof_raw_register_status
, gdb_byte
);
237 regcache
->aspace
= aspace
;
238 regcache
->ptid
= minus_one_ptid
;
243 regcache_xmalloc (struct gdbarch
*gdbarch
, struct address_space
*aspace
)
245 return regcache_xmalloc_1 (gdbarch
, aspace
, 1);
249 regcache_xfree (struct regcache
*regcache
)
251 if (regcache
== NULL
)
253 xfree (regcache
->registers
);
254 xfree (regcache
->register_status
);
259 do_regcache_xfree (void *data
)
261 regcache_xfree (data
);
265 make_cleanup_regcache_xfree (struct regcache
*regcache
)
267 return make_cleanup (do_regcache_xfree
, regcache
);
270 /* Return REGCACHE's architecture. */
273 get_regcache_arch (const struct regcache
*regcache
)
275 return regcache
->descr
->gdbarch
;
278 struct address_space
*
279 get_regcache_aspace (const struct regcache
*regcache
)
281 return regcache
->aspace
;
284 /* Return a pointer to register REGNUM's buffer cache. */
287 register_buffer (const struct regcache
*regcache
, int regnum
)
289 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
293 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
296 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
297 gdb_byte buf
[MAX_REGISTER_SIZE
];
300 /* The DST should be `read-only', if it wasn't then the save would
301 end up trying to write the register values back out to the
303 gdb_assert (dst
->readonly_p
);
304 /* Clear the dest. */
305 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
306 memset (dst
->register_status
, 0,
307 dst
->descr
->sizeof_cooked_register_status
);
308 /* Copy over any registers (identified by their membership in the
309 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
310 gdbarch_num_pseudo_regs) range is checked since some architectures need
311 to save/restore `cooked' registers that live in memory. */
312 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
314 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
316 enum register_status status
= cooked_read (src
, regnum
, buf
);
318 if (status
== REG_VALID
)
319 memcpy (register_buffer (dst
, regnum
), buf
,
320 register_size (gdbarch
, regnum
));
323 gdb_assert (status
!= REG_UNKNOWN
);
325 memset (register_buffer (dst
, regnum
), 0,
326 register_size (gdbarch
, regnum
));
328 dst
->register_status
[regnum
] = status
;
334 regcache_restore (struct regcache
*dst
,
335 regcache_cooked_read_ftype
*cooked_read
,
336 void *cooked_read_context
)
338 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
339 gdb_byte buf
[MAX_REGISTER_SIZE
];
342 /* The dst had better not be read-only. If it is, the `restore'
343 doesn't make much sense. */
344 gdb_assert (!dst
->readonly_p
);
345 /* Copy over any registers, being careful to only restore those that
346 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
347 + gdbarch_num_pseudo_regs) range is checked since some architectures need
348 to save/restore `cooked' registers that live in memory. */
349 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
351 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
353 enum register_status status
;
355 status
= cooked_read (cooked_read_context
, regnum
, buf
);
356 if (status
== REG_VALID
)
357 regcache_cooked_write (dst
, regnum
, buf
);
362 static enum register_status
363 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
365 struct regcache
*regcache
= src
;
367 return regcache_cooked_read (regcache
, regnum
, buf
);
371 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
373 gdb_assert (src
!= NULL
&& dst
!= NULL
);
374 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
375 gdb_assert (src
!= dst
);
376 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
378 if (!src
->readonly_p
)
379 regcache_save (dst
, do_cooked_read
, src
);
380 else if (!dst
->readonly_p
)
381 regcache_restore (dst
, do_cooked_read
, src
);
383 regcache_cpy_no_passthrough (dst
, src
);
387 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
389 gdb_assert (src
!= NULL
&& dst
!= NULL
);
390 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
391 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
392 move of data into a thread's regcache. Doing this would be silly
393 - it would mean that regcache->register_status would be
394 completely invalid. */
395 gdb_assert (dst
->readonly_p
&& src
->readonly_p
);
397 memcpy (dst
->registers
, src
->registers
,
398 dst
->descr
->sizeof_cooked_registers
);
399 memcpy (dst
->register_status
, src
->register_status
,
400 dst
->descr
->sizeof_cooked_register_status
);
404 regcache_dup (struct regcache
*src
)
406 struct regcache
*newbuf
;
408 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
409 regcache_cpy (newbuf
, src
);
414 regcache_register_status (const struct regcache
*regcache
, int regnum
)
416 gdb_assert (regcache
!= NULL
);
417 gdb_assert (regnum
>= 0);
418 if (regcache
->readonly_p
)
419 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
421 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
423 return regcache
->register_status
[regnum
];
427 regcache_invalidate (struct regcache
*regcache
, int regnum
)
429 gdb_assert (regcache
!= NULL
);
430 gdb_assert (regnum
>= 0);
431 gdb_assert (!regcache
->readonly_p
);
432 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
433 regcache
->register_status
[regnum
] = REG_UNKNOWN
;
437 /* Global structure containing the current regcache. */
439 /* NOTE: this is a write-through cache. There is no "dirty" bit for
440 recording if the register values have been changed (eg. by the
441 user). Therefore all registers must be written back to the
442 target when appropriate. */
446 struct regcache
*regcache
;
447 struct regcache_list
*next
;
450 static struct regcache_list
*current_regcache
;
453 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
454 struct address_space
*aspace
)
456 struct regcache_list
*list
;
457 struct regcache
*new_regcache
;
459 for (list
= current_regcache
; list
; list
= list
->next
)
460 if (ptid_equal (list
->regcache
->ptid
, ptid
)
461 && get_regcache_arch (list
->regcache
) == gdbarch
)
462 return list
->regcache
;
464 new_regcache
= regcache_xmalloc_1 (gdbarch
, aspace
, 0);
465 new_regcache
->ptid
= ptid
;
467 list
= xmalloc (sizeof (struct regcache_list
));
468 list
->regcache
= new_regcache
;
469 list
->next
= current_regcache
;
470 current_regcache
= list
;
476 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
478 struct address_space
*aspace
;
480 /* For the benefit of "maint print registers" & co when debugging an
481 executable, allow dumping the regcache even when there is no
482 thread selected (target_thread_address_space internal-errors if
483 no address space is found). Note that normal user commands will
484 fail higher up on the call stack due to no
485 target_has_registers. */
486 aspace
= (ptid_equal (null_ptid
, ptid
)
488 : target_thread_address_space (ptid
));
490 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
493 static ptid_t current_thread_ptid
;
494 static struct gdbarch
*current_thread_arch
;
497 get_thread_regcache (ptid_t ptid
)
499 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
501 current_thread_ptid
= ptid
;
502 current_thread_arch
= target_thread_architecture (ptid
);
505 return get_thread_arch_regcache (ptid
, current_thread_arch
);
509 get_current_regcache (void)
511 return get_thread_regcache (inferior_ptid
);
515 /* Observer for the target_changed event. */
518 regcache_observer_target_changed (struct target_ops
*target
)
520 registers_changed ();
523 /* Update global variables old ptids to hold NEW_PTID if they were
526 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
528 struct regcache_list
*list
;
530 for (list
= current_regcache
; list
; list
= list
->next
)
531 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
532 list
->regcache
->ptid
= new_ptid
;
535 /* Low level examining and depositing of registers.
537 The caller is responsible for making sure that the inferior is
538 stopped before calling the fetching routines, or it will get
539 garbage. (a change from GDB version 3, in which the caller got the
540 value from the last stop). */
542 /* REGISTERS_CHANGED ()
544 Indicate that registers may have changed, so invalidate the cache. */
547 registers_changed_ptid (ptid_t ptid
)
549 struct regcache_list
*list
, **list_link
;
551 list
= current_regcache
;
552 list_link
= ¤t_regcache
;
555 if (ptid_match (list
->regcache
->ptid
, ptid
))
557 struct regcache_list
*dead
= list
;
559 *list_link
= list
->next
;
560 regcache_xfree (list
->regcache
);
566 list_link
= &list
->next
;
570 if (ptid_match (current_thread_ptid
, ptid
))
572 current_thread_ptid
= null_ptid
;
573 current_thread_arch
= NULL
;
576 if (ptid_match (inferior_ptid
, ptid
))
578 /* We just deleted the regcache of the current thread. Need to
579 forget about any frames we have cached, too. */
580 reinit_frame_cache ();
585 registers_changed (void)
587 registers_changed_ptid (minus_one_ptid
);
589 /* Force cleanup of any alloca areas if using C alloca instead of
590 a builtin alloca. This particular call is used to clean up
591 areas allocated by low level target code which may build up
592 during lengthy interactions between gdb and the target before
593 gdb gives control to the user (ie watchpoints). */
598 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
600 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
601 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
602 /* Make certain that the register cache is up-to-date with respect
603 to the current thread. This switching shouldn't be necessary
604 only there is still only one target side register cache. Sigh!
605 On the bright side, at least there is a regcache object. */
606 if (!regcache
->readonly_p
607 && regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
609 struct cleanup
*old_chain
= save_inferior_ptid ();
611 inferior_ptid
= regcache
->ptid
;
612 target_fetch_registers (regcache
, regnum
);
613 do_cleanups (old_chain
);
615 /* A number of targets can't access the whole set of raw
616 registers (because the debug API provides no means to get at
618 if (regcache
->register_status
[regnum
] == REG_UNKNOWN
)
619 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
622 if (regcache
->register_status
[regnum
] != REG_VALID
)
623 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
625 memcpy (buf
, register_buffer (regcache
, regnum
),
626 regcache
->descr
->sizeof_register
[regnum
]);
628 return regcache
->register_status
[regnum
];
632 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
635 enum register_status status
;
637 gdb_assert (regcache
!= NULL
);
638 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
639 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
640 status
= regcache_raw_read (regcache
, regnum
, buf
);
641 if (status
== REG_VALID
)
642 *val
= extract_signed_integer
643 (buf
, regcache
->descr
->sizeof_register
[regnum
],
644 gdbarch_byte_order (regcache
->descr
->gdbarch
));
651 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
655 enum register_status status
;
657 gdb_assert (regcache
!= NULL
);
658 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
659 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
660 status
= regcache_raw_read (regcache
, regnum
, buf
);
661 if (status
== REG_VALID
)
662 *val
= extract_unsigned_integer
663 (buf
, regcache
->descr
->sizeof_register
[regnum
],
664 gdbarch_byte_order (regcache
->descr
->gdbarch
));
671 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
675 gdb_assert (regcache
!= NULL
);
676 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
677 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
678 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
679 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
680 regcache_raw_write (regcache
, regnum
, buf
);
684 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
689 gdb_assert (regcache
!= NULL
);
690 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
691 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
692 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
693 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
694 regcache_raw_write (regcache
, regnum
, buf
);
698 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
700 gdb_assert (regnum
>= 0);
701 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
702 if (regnum
< regcache
->descr
->nr_raw_registers
)
703 return regcache_raw_read (regcache
, regnum
, buf
);
704 else if (regcache
->readonly_p
705 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
707 /* Read-only register cache, perhaps the cooked value was
709 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
711 if (regcache
->register_status
[regnum
] == REG_VALID
)
712 memcpy (buf
, register_buffer (regcache
, regnum
),
713 regcache
->descr
->sizeof_register
[regnum
]);
715 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
717 return regcache
->register_status
[regnum
];
719 else if (gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
721 struct value
*mark
, *computed
;
722 enum register_status result
= REG_VALID
;
724 mark
= value_mark ();
726 computed
= gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
728 if (value_entirely_available (computed
))
729 memcpy (buf
, value_contents_raw (computed
),
730 regcache
->descr
->sizeof_register
[regnum
]);
733 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
734 result
= REG_UNAVAILABLE
;
737 value_free_to_mark (mark
);
742 return gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
747 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
749 gdb_assert (regnum
>= 0);
750 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
752 if (regnum
< regcache
->descr
->nr_raw_registers
753 || (regcache
->readonly_p
754 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
755 || !gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
757 struct value
*result
;
759 result
= allocate_value (register_type (regcache
->descr
->gdbarch
,
761 VALUE_LVAL (result
) = lval_register
;
762 VALUE_REGNUM (result
) = regnum
;
764 /* It is more efficient in general to do this delegation in this
765 direction than in the other one, even though the value-based
767 if (regcache_cooked_read (regcache
, regnum
,
768 value_contents_raw (result
)) == REG_UNAVAILABLE
)
769 mark_value_bytes_unavailable (result
, 0,
770 TYPE_LENGTH (value_type (result
)));
775 return gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
780 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
783 enum register_status status
;
786 gdb_assert (regcache
!= NULL
);
787 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
788 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
789 status
= regcache_cooked_read (regcache
, regnum
, buf
);
790 if (status
== REG_VALID
)
791 *val
= extract_signed_integer
792 (buf
, regcache
->descr
->sizeof_register
[regnum
],
793 gdbarch_byte_order (regcache
->descr
->gdbarch
));
800 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
803 enum register_status status
;
806 gdb_assert (regcache
!= NULL
);
807 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
808 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
809 status
= regcache_cooked_read (regcache
, regnum
, buf
);
810 if (status
== REG_VALID
)
811 *val
= extract_unsigned_integer
812 (buf
, regcache
->descr
->sizeof_register
[regnum
],
813 gdbarch_byte_order (regcache
->descr
->gdbarch
));
820 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
825 gdb_assert (regcache
!= NULL
);
826 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
827 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
828 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
829 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
830 regcache_cooked_write (regcache
, regnum
, buf
);
834 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
839 gdb_assert (regcache
!= NULL
);
840 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
841 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
842 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
843 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
844 regcache_cooked_write (regcache
, regnum
, buf
);
848 regcache_raw_write (struct regcache
*regcache
, int regnum
,
851 struct cleanup
*old_chain
;
853 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
854 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
855 gdb_assert (!regcache
->readonly_p
);
857 /* On the sparc, writing %g0 is a no-op, so we don't even want to
858 change the registers array if something writes to this register. */
859 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
862 /* If we have a valid copy of the register, and new value == old
863 value, then don't bother doing the actual store. */
864 if (regcache_register_status (regcache
, regnum
) == REG_VALID
865 && (memcmp (register_buffer (regcache
, regnum
), buf
,
866 regcache
->descr
->sizeof_register
[regnum
]) == 0))
869 old_chain
= save_inferior_ptid ();
870 inferior_ptid
= regcache
->ptid
;
872 target_prepare_to_store (regcache
);
873 memcpy (register_buffer (regcache
, regnum
), buf
,
874 regcache
->descr
->sizeof_register
[regnum
]);
875 regcache
->register_status
[regnum
] = REG_VALID
;
876 target_store_registers (regcache
, regnum
);
878 do_cleanups (old_chain
);
882 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
885 gdb_assert (regnum
>= 0);
886 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
887 if (regnum
< regcache
->descr
->nr_raw_registers
)
888 regcache_raw_write (regcache
, regnum
, buf
);
890 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
894 /* Perform a partial register transfer using a read, modify, write
897 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
899 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
902 static enum register_status
903 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
904 int offset
, int len
, void *in
, const void *out
,
905 enum register_status (*read
) (struct regcache
*regcache
,
908 void (*write
) (struct regcache
*regcache
, int regnum
,
909 const gdb_byte
*buf
))
911 struct regcache_descr
*descr
= regcache
->descr
;
912 gdb_byte reg
[MAX_REGISTER_SIZE
];
914 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
915 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
916 /* Something to do? */
917 if (offset
+ len
== 0)
919 /* Read (when needed) ... */
922 || offset
+ len
< descr
->sizeof_register
[regnum
])
924 enum register_status status
;
926 gdb_assert (read
!= NULL
);
927 status
= read (regcache
, regnum
, reg
);
928 if (status
!= REG_VALID
)
933 memcpy (in
, reg
+ offset
, len
);
935 memcpy (reg
+ offset
, out
, len
);
936 /* ... write (when needed). */
939 gdb_assert (write
!= NULL
);
940 write (regcache
, regnum
, reg
);
947 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
948 int offset
, int len
, gdb_byte
*buf
)
950 struct regcache_descr
*descr
= regcache
->descr
;
952 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
953 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
954 regcache_raw_read
, regcache_raw_write
);
958 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
959 int offset
, int len
, const gdb_byte
*buf
)
961 struct regcache_descr
*descr
= regcache
->descr
;
963 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
964 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
965 regcache_raw_read
, regcache_raw_write
);
969 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
970 int offset
, int len
, gdb_byte
*buf
)
972 struct regcache_descr
*descr
= regcache
->descr
;
974 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
975 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
976 regcache_cooked_read
, regcache_cooked_write
);
980 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
981 int offset
, int len
, const gdb_byte
*buf
)
983 struct regcache_descr
*descr
= regcache
->descr
;
985 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
986 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
987 regcache_cooked_read
, regcache_cooked_write
);
990 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
993 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
998 gdb_assert (regcache
!= NULL
);
999 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1000 gdb_assert (!regcache
->readonly_p
);
1002 regbuf
= register_buffer (regcache
, regnum
);
1003 size
= regcache
->descr
->sizeof_register
[regnum
];
1007 memcpy (regbuf
, buf
, size
);
1008 regcache
->register_status
[regnum
] = REG_VALID
;
1012 /* This memset not strictly necessary, but better than garbage
1013 in case the register value manages to escape somewhere (due
1014 to a bug, no less). */
1015 memset (regbuf
, 0, size
);
1016 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
1020 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1023 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1028 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1029 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1031 regbuf
= register_buffer (regcache
, regnum
);
1032 size
= regcache
->descr
->sizeof_register
[regnum
];
1033 memcpy (buf
, regbuf
, size
);
1037 /* Special handling for register PC. */
1040 regcache_read_pc (struct regcache
*regcache
)
1042 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1046 if (gdbarch_read_pc_p (gdbarch
))
1047 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1048 /* Else use per-frame method on get_current_frame. */
1049 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1053 if (regcache_cooked_read_unsigned (regcache
,
1054 gdbarch_pc_regnum (gdbarch
),
1055 &raw_val
) == REG_UNAVAILABLE
)
1056 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1058 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1061 internal_error (__FILE__
, __LINE__
,
1062 _("regcache_read_pc: Unable to find PC"));
1067 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1069 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1071 if (gdbarch_write_pc_p (gdbarch
))
1072 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1073 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1074 regcache_cooked_write_unsigned (regcache
,
1075 gdbarch_pc_regnum (gdbarch
), pc
);
1077 internal_error (__FILE__
, __LINE__
,
1078 _("regcache_write_pc: Unable to update PC"));
1080 /* Writing the PC (for instance, from "load") invalidates the
1082 reinit_frame_cache ();
1087 reg_flush_command (char *command
, int from_tty
)
1089 /* Force-flush the register cache. */
1090 registers_changed ();
1092 printf_filtered (_("Register cache flushed.\n"));
1096 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
1097 const unsigned char *buf
, long len
)
1103 case BFD_ENDIAN_BIG
:
1104 for (i
= 0; i
< len
; i
++)
1105 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1107 case BFD_ENDIAN_LITTLE
:
1108 for (i
= len
- 1; i
>= 0; i
--)
1109 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1112 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
1116 enum regcache_dump_what
1118 regcache_dump_none
, regcache_dump_raw
,
1119 regcache_dump_cooked
, regcache_dump_groups
,
1120 regcache_dump_remote
1124 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1125 enum regcache_dump_what what_to_dump
)
1127 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1128 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1130 int footnote_nr
= 0;
1131 int footnote_register_size
= 0;
1132 int footnote_register_offset
= 0;
1133 int footnote_register_type_name_null
= 0;
1134 long register_offset
= 0;
1135 unsigned char buf
[MAX_REGISTER_SIZE
];
1138 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1139 regcache
->descr
->nr_raw_registers
);
1140 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1141 regcache
->descr
->nr_cooked_registers
);
1142 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1143 regcache
->descr
->sizeof_raw_registers
);
1144 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1145 regcache
->descr
->sizeof_raw_register_status
);
1146 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1147 gdbarch_num_regs (gdbarch
));
1148 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1149 gdbarch_num_pseudo_regs (gdbarch
));
1152 gdb_assert (regcache
->descr
->nr_cooked_registers
1153 == (gdbarch_num_regs (gdbarch
)
1154 + gdbarch_num_pseudo_regs (gdbarch
)));
1156 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1160 fprintf_unfiltered (file
, " %-10s", "Name");
1163 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1167 else if (p
[0] == '\0')
1169 fprintf_unfiltered (file
, " %-10s", p
);
1174 fprintf_unfiltered (file
, " %4s", "Nr");
1176 fprintf_unfiltered (file
, " %4d", regnum
);
1178 /* Relative number. */
1180 fprintf_unfiltered (file
, " %4s", "Rel");
1181 else if (regnum
< gdbarch_num_regs (gdbarch
))
1182 fprintf_unfiltered (file
, " %4d", regnum
);
1184 fprintf_unfiltered (file
, " %4d",
1185 (regnum
- gdbarch_num_regs (gdbarch
)));
1189 fprintf_unfiltered (file
, " %6s ", "Offset");
1192 fprintf_unfiltered (file
, " %6ld",
1193 regcache
->descr
->register_offset
[regnum
]);
1194 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1196 && (regcache
->descr
->register_offset
[regnum
]
1197 != (regcache
->descr
->register_offset
[regnum
- 1]
1198 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1201 if (!footnote_register_offset
)
1202 footnote_register_offset
= ++footnote_nr
;
1203 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1206 fprintf_unfiltered (file
, " ");
1207 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1208 + regcache
->descr
->sizeof_register
[regnum
]);
1213 fprintf_unfiltered (file
, " %5s ", "Size");
1215 fprintf_unfiltered (file
, " %5ld",
1216 regcache
->descr
->sizeof_register
[regnum
]);
1226 static const char blt
[] = "builtin_type";
1228 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1233 if (!footnote_register_type_name_null
)
1234 footnote_register_type_name_null
= ++footnote_nr
;
1235 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1236 make_cleanup (xfree
, n
);
1239 /* Chop a leading builtin_type. */
1240 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1243 fprintf_unfiltered (file
, " %-15s", t
);
1246 /* Leading space always present. */
1247 fprintf_unfiltered (file
, " ");
1250 if (what_to_dump
== regcache_dump_raw
)
1253 fprintf_unfiltered (file
, "Raw value");
1254 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1255 fprintf_unfiltered (file
, "<cooked>");
1256 else if (regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
1257 fprintf_unfiltered (file
, "<invalid>");
1258 else if (regcache_register_status (regcache
, regnum
) == REG_UNAVAILABLE
)
1259 fprintf_unfiltered (file
, "<unavailable>");
1262 regcache_raw_read (regcache
, regnum
, buf
);
1263 fprintf_unfiltered (file
, "0x");
1264 dump_endian_bytes (file
,
1265 gdbarch_byte_order (gdbarch
), buf
,
1266 regcache
->descr
->sizeof_register
[regnum
]);
1270 /* Value, cooked. */
1271 if (what_to_dump
== regcache_dump_cooked
)
1274 fprintf_unfiltered (file
, "Cooked value");
1277 enum register_status status
;
1279 status
= regcache_cooked_read (regcache
, regnum
, buf
);
1280 if (status
== REG_UNKNOWN
)
1281 fprintf_unfiltered (file
, "<invalid>");
1282 else if (status
== REG_UNAVAILABLE
)
1283 fprintf_unfiltered (file
, "<unavailable>");
1286 fprintf_unfiltered (file
, "0x");
1287 dump_endian_bytes (file
,
1288 gdbarch_byte_order (gdbarch
), buf
,
1289 regcache
->descr
->sizeof_register
[regnum
]);
1294 /* Group members. */
1295 if (what_to_dump
== regcache_dump_groups
)
1298 fprintf_unfiltered (file
, "Groups");
1301 const char *sep
= "";
1302 struct reggroup
*group
;
1304 for (group
= reggroup_next (gdbarch
, NULL
);
1306 group
= reggroup_next (gdbarch
, group
))
1308 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1310 fprintf_unfiltered (file
,
1311 "%s%s", sep
, reggroup_name (group
));
1318 /* Remote packet configuration. */
1319 if (what_to_dump
== regcache_dump_remote
)
1323 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1325 else if (regnum
< regcache
->descr
->nr_raw_registers
)
1329 if (remote_register_number_and_offset (get_regcache_arch (regcache
), regnum
,
1331 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1335 fprintf_unfiltered (file
, "\n");
1338 if (footnote_register_size
)
1339 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1340 footnote_register_size
);
1341 if (footnote_register_offset
)
1342 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1343 footnote_register_offset
);
1344 if (footnote_register_type_name_null
)
1345 fprintf_unfiltered (file
,
1346 "*%d: Register type's name NULL.\n",
1347 footnote_register_type_name_null
);
1348 do_cleanups (cleanups
);
1352 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1355 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1358 struct cleanup
*cleanups
;
1359 struct ui_file
*file
= gdb_fopen (args
, "w");
1362 perror_with_name (_("maintenance print architecture"));
1363 cleanups
= make_cleanup_ui_file_delete (file
);
1364 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1365 do_cleanups (cleanups
);
1370 maintenance_print_registers (char *args
, int from_tty
)
1372 regcache_print (args
, regcache_dump_none
);
1376 maintenance_print_raw_registers (char *args
, int from_tty
)
1378 regcache_print (args
, regcache_dump_raw
);
1382 maintenance_print_cooked_registers (char *args
, int from_tty
)
1384 regcache_print (args
, regcache_dump_cooked
);
1388 maintenance_print_register_groups (char *args
, int from_tty
)
1390 regcache_print (args
, regcache_dump_groups
);
1394 maintenance_print_remote_registers (char *args
, int from_tty
)
1396 regcache_print (args
, regcache_dump_remote
);
1399 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1402 _initialize_regcache (void)
1404 regcache_descr_handle
1405 = gdbarch_data_register_post_init (init_regcache_descr
);
1407 observer_attach_target_changed (regcache_observer_target_changed
);
1408 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1410 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1411 _("Force gdb to flush its register cache (maintainer command)"));
1413 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1414 _("Print the internal register configuration.\n"
1415 "Takes an optional file parameter."), &maintenanceprintlist
);
1416 add_cmd ("raw-registers", class_maintenance
,
1417 maintenance_print_raw_registers
,
1418 _("Print the internal register configuration "
1419 "including raw values.\n"
1420 "Takes an optional file parameter."), &maintenanceprintlist
);
1421 add_cmd ("cooked-registers", class_maintenance
,
1422 maintenance_print_cooked_registers
,
1423 _("Print the internal register configuration "
1424 "including cooked values.\n"
1425 "Takes an optional file parameter."), &maintenanceprintlist
);
1426 add_cmd ("register-groups", class_maintenance
,
1427 maintenance_print_register_groups
,
1428 _("Print the internal register configuration "
1429 "including each register's group.\n"
1430 "Takes an optional file parameter."),
1431 &maintenanceprintlist
);
1432 add_cmd ("remote-registers", class_maintenance
,
1433 maintenance_print_remote_registers
, _("\
1434 Print the internal register configuration including each register's\n\
1435 remote register number and buffer offset in the g/G packets.\n\
1436 Takes an optional file parameter."),
1437 &maintenanceprintlist
);