1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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"
28 #include "exceptions.h"
35 * Here is the actual register cache.
38 /* Per-architecture object describing the layout of a register cache.
39 Computed once when the architecture is created. */
41 struct gdbarch_data
*regcache_descr_handle
;
45 /* The architecture this descriptor belongs to. */
46 struct gdbarch
*gdbarch
;
48 /* The raw register cache. Each raw (or hard) register is supplied
49 by the target interface. The raw cache should not contain
50 redundant information - if the PC is constructed from two
51 registers then those registers and not the PC lives in the raw
54 long sizeof_raw_registers
;
55 long sizeof_raw_register_status
;
57 /* The cooked register space. Each cooked register in the range
58 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
59 register. The remaining [NR_RAW_REGISTERS
60 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
61 both raw registers and memory by the architecture methods
62 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
63 int nr_cooked_registers
;
64 long sizeof_cooked_registers
;
65 long sizeof_cooked_register_status
;
67 /* Offset and size (in 8 bit bytes), of each register in the
68 register cache. All registers (including those in the range
69 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
71 long *register_offset
;
72 long *sizeof_register
;
74 /* Cached table containing the type of each register. */
75 struct type
**register_type
;
79 init_regcache_descr (struct gdbarch
*gdbarch
)
82 struct regcache_descr
*descr
;
83 gdb_assert (gdbarch
!= NULL
);
85 /* Create an initial, zero filled, table. */
86 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
87 descr
->gdbarch
= gdbarch
;
89 /* Total size of the register space. The raw registers are mapped
90 directly onto the raw register cache while the pseudo's are
91 either mapped onto raw-registers or memory. */
92 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
93 + gdbarch_num_pseudo_regs (gdbarch
);
94 descr
->sizeof_cooked_register_status
95 = gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
97 /* Fill in a table of register types. */
99 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
101 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
102 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
104 /* Construct a strictly RAW register cache. Don't allow pseudo's
105 into the register cache. */
106 descr
->nr_raw_registers
= gdbarch_num_regs (gdbarch
);
107 descr
->sizeof_raw_register_status
= gdbarch_num_regs (gdbarch
);
109 /* Lay out the register cache.
111 NOTE: cagney/2002-05-22: Only register_type() is used when
112 constructing the register cache. It is assumed that the
113 register's raw size, virtual size and type length are all the
119 descr
->sizeof_register
120 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
121 descr
->register_offset
122 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
123 for (i
= 0; i
< descr
->nr_raw_registers
; i
++)
125 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
126 descr
->register_offset
[i
] = offset
;
127 offset
+= descr
->sizeof_register
[i
];
128 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
130 /* Set the real size of the raw register cache buffer. */
131 descr
->sizeof_raw_registers
= offset
;
133 for (; i
< descr
->nr_cooked_registers
; i
++)
135 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
136 descr
->register_offset
[i
] = offset
;
137 offset
+= descr
->sizeof_register
[i
];
138 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
140 /* Set the real size of the readonly register cache buffer. */
141 descr
->sizeof_cooked_registers
= offset
;
147 static struct regcache_descr
*
148 regcache_descr (struct gdbarch
*gdbarch
)
150 return gdbarch_data (gdbarch
, regcache_descr_handle
);
153 /* Utility functions returning useful register attributes stored in
154 the regcache descr. */
157 register_type (struct gdbarch
*gdbarch
, int regnum
)
159 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
161 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
162 return descr
->register_type
[regnum
];
165 /* Utility functions returning useful register attributes stored in
166 the regcache descr. */
169 register_size (struct gdbarch
*gdbarch
, int regnum
)
171 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
174 gdb_assert (regnum
>= 0
175 && regnum
< (gdbarch_num_regs (gdbarch
)
176 + gdbarch_num_pseudo_regs (gdbarch
)));
177 size
= descr
->sizeof_register
[regnum
];
181 /* The register cache for storing raw register values. */
185 struct regcache_descr
*descr
;
187 /* The address space of this register cache (for registers where it
188 makes sense, like PC or SP). */
189 struct address_space
*aspace
;
191 /* The register buffers. A read-only register cache can hold the
192 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
193 register cache can only hold [0 .. gdbarch_num_regs). */
195 /* Register cache status. */
196 signed char *register_status
;
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
209 static struct regcache
*
210 regcache_xmalloc_1 (struct gdbarch
*gdbarch
, struct address_space
*aspace
,
213 struct regcache_descr
*descr
;
214 struct regcache
*regcache
;
216 gdb_assert (gdbarch
!= NULL
);
217 descr
= regcache_descr (gdbarch
);
218 regcache
= XNEW (struct regcache
);
219 regcache
->descr
= descr
;
220 regcache
->readonly_p
= readonly_p
;
224 = XCNEWVEC (gdb_byte
, descr
->sizeof_cooked_registers
);
225 regcache
->register_status
226 = XCNEWVEC (signed char, descr
->sizeof_cooked_register_status
);
231 = XCNEWVEC (gdb_byte
, descr
->sizeof_raw_registers
);
232 regcache
->register_status
233 = XCNEWVEC (signed char, descr
->sizeof_raw_register_status
);
235 regcache
->aspace
= aspace
;
236 regcache
->ptid
= minus_one_ptid
;
241 regcache_xmalloc (struct gdbarch
*gdbarch
, struct address_space
*aspace
)
243 return regcache_xmalloc_1 (gdbarch
, aspace
, 1);
247 regcache_xfree (struct regcache
*regcache
)
249 if (regcache
== NULL
)
251 xfree (regcache
->registers
);
252 xfree (regcache
->register_status
);
257 do_regcache_xfree (void *data
)
259 regcache_xfree (data
);
263 make_cleanup_regcache_xfree (struct regcache
*regcache
)
265 return make_cleanup (do_regcache_xfree
, regcache
);
268 /* Cleanup routines for invalidating a register. */
270 struct register_to_invalidate
272 struct regcache
*regcache
;
277 do_regcache_invalidate (void *data
)
279 struct register_to_invalidate
*reg
= data
;
281 regcache_invalidate (reg
->regcache
, reg
->regnum
);
284 static struct cleanup
*
285 make_cleanup_regcache_invalidate (struct regcache
*regcache
, int regnum
)
287 struct register_to_invalidate
* reg
= XNEW (struct register_to_invalidate
);
289 reg
->regcache
= regcache
;
290 reg
->regnum
= regnum
;
291 return make_cleanup_dtor (do_regcache_invalidate
, (void *) reg
, xfree
);
294 /* Return REGCACHE's architecture. */
297 get_regcache_arch (const struct regcache
*regcache
)
299 return regcache
->descr
->gdbarch
;
302 struct address_space
*
303 get_regcache_aspace (const struct regcache
*regcache
)
305 return regcache
->aspace
;
308 /* Return a pointer to register REGNUM's buffer cache. */
311 register_buffer (const struct regcache
*regcache
, int regnum
)
313 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
317 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
320 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
321 gdb_byte buf
[MAX_REGISTER_SIZE
];
324 /* The DST should be `read-only', if it wasn't then the save would
325 end up trying to write the register values back out to the
327 gdb_assert (dst
->readonly_p
);
328 /* Clear the dest. */
329 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
330 memset (dst
->register_status
, 0,
331 dst
->descr
->sizeof_cooked_register_status
);
332 /* Copy over any registers (identified by their membership in the
333 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
334 gdbarch_num_pseudo_regs) range is checked since some architectures need
335 to save/restore `cooked' registers that live in memory. */
336 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
338 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
340 enum register_status status
= cooked_read (src
, regnum
, buf
);
342 if (status
== REG_VALID
)
343 memcpy (register_buffer (dst
, regnum
), buf
,
344 register_size (gdbarch
, regnum
));
347 gdb_assert (status
!= REG_UNKNOWN
);
349 memset (register_buffer (dst
, regnum
), 0,
350 register_size (gdbarch
, regnum
));
352 dst
->register_status
[regnum
] = status
;
358 regcache_restore (struct regcache
*dst
,
359 regcache_cooked_read_ftype
*cooked_read
,
360 void *cooked_read_context
)
362 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
363 gdb_byte buf
[MAX_REGISTER_SIZE
];
366 /* The dst had better not be read-only. If it is, the `restore'
367 doesn't make much sense. */
368 gdb_assert (!dst
->readonly_p
);
369 /* Copy over any registers, being careful to only restore those that
370 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
371 + gdbarch_num_pseudo_regs) range is checked since some architectures need
372 to save/restore `cooked' registers that live in memory. */
373 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
375 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
377 enum register_status status
;
379 status
= cooked_read (cooked_read_context
, regnum
, buf
);
380 if (status
== REG_VALID
)
381 regcache_cooked_write (dst
, regnum
, buf
);
386 static enum register_status
387 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
389 struct regcache
*regcache
= src
;
391 return regcache_cooked_read (regcache
, regnum
, buf
);
395 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
397 gdb_assert (src
!= NULL
&& dst
!= NULL
);
398 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
399 gdb_assert (src
!= dst
);
400 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
402 if (!src
->readonly_p
)
403 regcache_save (dst
, do_cooked_read
, src
);
404 else if (!dst
->readonly_p
)
405 regcache_restore (dst
, do_cooked_read
, src
);
407 regcache_cpy_no_passthrough (dst
, src
);
411 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
413 gdb_assert (src
!= NULL
&& dst
!= NULL
);
414 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
415 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
416 move of data into a thread's regcache. Doing this would be silly
417 - it would mean that regcache->register_status would be
418 completely invalid. */
419 gdb_assert (dst
->readonly_p
&& src
->readonly_p
);
421 memcpy (dst
->registers
, src
->registers
,
422 dst
->descr
->sizeof_cooked_registers
);
423 memcpy (dst
->register_status
, src
->register_status
,
424 dst
->descr
->sizeof_cooked_register_status
);
428 regcache_dup (struct regcache
*src
)
430 struct regcache
*newbuf
;
432 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
433 regcache_cpy (newbuf
, src
);
438 regcache_register_status (const struct regcache
*regcache
, int regnum
)
440 gdb_assert (regcache
!= NULL
);
441 gdb_assert (regnum
>= 0);
442 if (regcache
->readonly_p
)
443 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
445 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
447 return regcache
->register_status
[regnum
];
451 regcache_invalidate (struct regcache
*regcache
, int regnum
)
453 gdb_assert (regcache
!= NULL
);
454 gdb_assert (regnum
>= 0);
455 gdb_assert (!regcache
->readonly_p
);
456 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
457 regcache
->register_status
[regnum
] = REG_UNKNOWN
;
461 /* Global structure containing the current regcache. */
463 /* NOTE: this is a write-through cache. There is no "dirty" bit for
464 recording if the register values have been changed (eg. by the
465 user). Therefore all registers must be written back to the
466 target when appropriate. */
470 struct regcache
*regcache
;
471 struct regcache_list
*next
;
474 static struct regcache_list
*current_regcache
;
477 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
478 struct address_space
*aspace
)
480 struct regcache_list
*list
;
481 struct regcache
*new_regcache
;
483 for (list
= current_regcache
; list
; list
= list
->next
)
484 if (ptid_equal (list
->regcache
->ptid
, ptid
)
485 && get_regcache_arch (list
->regcache
) == gdbarch
)
486 return list
->regcache
;
488 new_regcache
= regcache_xmalloc_1 (gdbarch
, aspace
, 0);
489 new_regcache
->ptid
= ptid
;
491 list
= xmalloc (sizeof (struct regcache_list
));
492 list
->regcache
= new_regcache
;
493 list
->next
= current_regcache
;
494 current_regcache
= list
;
500 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
502 struct address_space
*aspace
;
504 /* For the benefit of "maint print registers" & co when debugging an
505 executable, allow dumping the regcache even when there is no
506 thread selected (target_thread_address_space internal-errors if
507 no address space is found). Note that normal user commands will
508 fail higher up on the call stack due to no
509 target_has_registers. */
510 aspace
= (ptid_equal (null_ptid
, ptid
)
512 : target_thread_address_space (ptid
));
514 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
517 static ptid_t current_thread_ptid
;
518 static struct gdbarch
*current_thread_arch
;
521 get_thread_regcache (ptid_t ptid
)
523 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
525 current_thread_ptid
= ptid
;
526 current_thread_arch
= target_thread_architecture (ptid
);
529 return get_thread_arch_regcache (ptid
, current_thread_arch
);
533 get_current_regcache (void)
535 return get_thread_regcache (inferior_ptid
);
539 /* Observer for the target_changed event. */
542 regcache_observer_target_changed (struct target_ops
*target
)
544 registers_changed ();
547 /* Update global variables old ptids to hold NEW_PTID if they were
550 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
552 struct regcache_list
*list
;
554 for (list
= current_regcache
; list
; list
= list
->next
)
555 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
556 list
->regcache
->ptid
= new_ptid
;
559 /* Low level examining and depositing of registers.
561 The caller is responsible for making sure that the inferior is
562 stopped before calling the fetching routines, or it will get
563 garbage. (a change from GDB version 3, in which the caller got the
564 value from the last stop). */
566 /* REGISTERS_CHANGED ()
568 Indicate that registers may have changed, so invalidate the cache. */
571 registers_changed_ptid (ptid_t ptid
)
573 struct regcache_list
*list
, **list_link
;
575 list
= current_regcache
;
576 list_link
= ¤t_regcache
;
579 if (ptid_match (list
->regcache
->ptid
, ptid
))
581 struct regcache_list
*dead
= list
;
583 *list_link
= list
->next
;
584 regcache_xfree (list
->regcache
);
590 list_link
= &list
->next
;
594 if (ptid_match (current_thread_ptid
, ptid
))
596 current_thread_ptid
= null_ptid
;
597 current_thread_arch
= NULL
;
600 if (ptid_match (inferior_ptid
, ptid
))
602 /* We just deleted the regcache of the current thread. Need to
603 forget about any frames we have cached, too. */
604 reinit_frame_cache ();
609 registers_changed (void)
611 registers_changed_ptid (minus_one_ptid
);
613 /* Force cleanup of any alloca areas if using C alloca instead of
614 a builtin alloca. This particular call is used to clean up
615 areas allocated by low level target code which may build up
616 during lengthy interactions between gdb and the target before
617 gdb gives control to the user (ie watchpoints). */
622 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
624 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
625 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
626 /* Make certain that the register cache is up-to-date with respect
627 to the current thread. This switching shouldn't be necessary
628 only there is still only one target side register cache. Sigh!
629 On the bright side, at least there is a regcache object. */
630 if (!regcache
->readonly_p
631 && regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
633 struct cleanup
*old_chain
= save_inferior_ptid ();
635 inferior_ptid
= regcache
->ptid
;
636 target_fetch_registers (regcache
, regnum
);
637 do_cleanups (old_chain
);
639 /* A number of targets can't access the whole set of raw
640 registers (because the debug API provides no means to get at
642 if (regcache
->register_status
[regnum
] == REG_UNKNOWN
)
643 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
646 if (regcache
->register_status
[regnum
] != REG_VALID
)
647 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
649 memcpy (buf
, register_buffer (regcache
, regnum
),
650 regcache
->descr
->sizeof_register
[regnum
]);
652 return regcache
->register_status
[regnum
];
656 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
659 enum register_status status
;
661 gdb_assert (regcache
!= NULL
);
662 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
663 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
664 status
= regcache_raw_read (regcache
, regnum
, buf
);
665 if (status
== REG_VALID
)
666 *val
= extract_signed_integer
667 (buf
, regcache
->descr
->sizeof_register
[regnum
],
668 gdbarch_byte_order (regcache
->descr
->gdbarch
));
675 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
679 enum register_status status
;
681 gdb_assert (regcache
!= NULL
);
682 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
683 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
684 status
= regcache_raw_read (regcache
, regnum
, buf
);
685 if (status
== REG_VALID
)
686 *val
= extract_unsigned_integer
687 (buf
, regcache
->descr
->sizeof_register
[regnum
],
688 gdbarch_byte_order (regcache
->descr
->gdbarch
));
695 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
699 gdb_assert (regcache
!= NULL
);
700 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
701 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
702 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
703 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
704 regcache_raw_write (regcache
, regnum
, buf
);
708 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
713 gdb_assert (regcache
!= NULL
);
714 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
715 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
716 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
717 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
718 regcache_raw_write (regcache
, regnum
, buf
);
722 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
724 gdb_assert (regnum
>= 0);
725 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
726 if (regnum
< regcache
->descr
->nr_raw_registers
)
727 return regcache_raw_read (regcache
, regnum
, buf
);
728 else if (regcache
->readonly_p
729 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
731 /* Read-only register cache, perhaps the cooked value was
733 if (regcache
->register_status
[regnum
] == REG_VALID
)
734 memcpy (buf
, register_buffer (regcache
, regnum
),
735 regcache
->descr
->sizeof_register
[regnum
]);
737 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
739 return regcache
->register_status
[regnum
];
741 else if (gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
743 struct value
*mark
, *computed
;
744 enum register_status result
= REG_VALID
;
746 mark
= value_mark ();
748 computed
= gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
750 if (value_entirely_available (computed
))
751 memcpy (buf
, value_contents_raw (computed
),
752 regcache
->descr
->sizeof_register
[regnum
]);
755 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
756 result
= REG_UNAVAILABLE
;
759 value_free_to_mark (mark
);
764 return gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
769 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
771 gdb_assert (regnum
>= 0);
772 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
774 if (regnum
< regcache
->descr
->nr_raw_registers
775 || (regcache
->readonly_p
776 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
777 || !gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
779 struct value
*result
;
781 result
= allocate_value (register_type (regcache
->descr
->gdbarch
,
783 VALUE_LVAL (result
) = lval_register
;
784 VALUE_REGNUM (result
) = regnum
;
786 /* It is more efficient in general to do this delegation in this
787 direction than in the other one, even though the value-based
789 if (regcache_cooked_read (regcache
, regnum
,
790 value_contents_raw (result
)) == REG_UNAVAILABLE
)
791 mark_value_bytes_unavailable (result
, 0,
792 TYPE_LENGTH (value_type (result
)));
797 return gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
802 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
805 enum register_status status
;
808 gdb_assert (regcache
!= NULL
);
809 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
810 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
811 status
= regcache_cooked_read (regcache
, regnum
, buf
);
812 if (status
== REG_VALID
)
813 *val
= extract_signed_integer
814 (buf
, regcache
->descr
->sizeof_register
[regnum
],
815 gdbarch_byte_order (regcache
->descr
->gdbarch
));
822 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
825 enum register_status status
;
828 gdb_assert (regcache
!= NULL
);
829 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
830 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
831 status
= regcache_cooked_read (regcache
, regnum
, buf
);
832 if (status
== REG_VALID
)
833 *val
= extract_unsigned_integer
834 (buf
, regcache
->descr
->sizeof_register
[regnum
],
835 gdbarch_byte_order (regcache
->descr
->gdbarch
));
842 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
847 gdb_assert (regcache
!= NULL
);
848 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
849 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
850 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
851 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
852 regcache_cooked_write (regcache
, regnum
, buf
);
856 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
861 gdb_assert (regcache
!= NULL
);
862 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
863 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
864 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
865 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
866 regcache_cooked_write (regcache
, regnum
, buf
);
870 regcache_raw_write (struct regcache
*regcache
, int regnum
,
873 struct cleanup
*chain_before_save_inferior
;
874 struct cleanup
*chain_before_invalidate_register
;
876 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
877 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
878 gdb_assert (!regcache
->readonly_p
);
880 /* On the sparc, writing %g0 is a no-op, so we don't even want to
881 change the registers array if something writes to this register. */
882 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
885 /* If we have a valid copy of the register, and new value == old
886 value, then don't bother doing the actual store. */
887 if (regcache_register_status (regcache
, regnum
) == REG_VALID
888 && (memcmp (register_buffer (regcache
, regnum
), buf
,
889 regcache
->descr
->sizeof_register
[regnum
]) == 0))
892 chain_before_save_inferior
= save_inferior_ptid ();
893 inferior_ptid
= regcache
->ptid
;
895 target_prepare_to_store (regcache
);
896 memcpy (register_buffer (regcache
, regnum
), buf
,
897 regcache
->descr
->sizeof_register
[regnum
]);
898 regcache
->register_status
[regnum
] = REG_VALID
;
900 /* Register a cleanup function for invalidating the register after it is
901 written, in case of a failure. */
902 chain_before_invalidate_register
903 = make_cleanup_regcache_invalidate (regcache
, regnum
);
905 target_store_registers (regcache
, regnum
);
907 /* The target did not throw an error so we can discard invalidating the
908 register and restore the cleanup chain to what it was. */
909 discard_cleanups (chain_before_invalidate_register
);
911 do_cleanups (chain_before_save_inferior
);
915 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
918 gdb_assert (regnum
>= 0);
919 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
920 if (regnum
< regcache
->descr
->nr_raw_registers
)
921 regcache_raw_write (regcache
, regnum
, buf
);
923 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
927 /* Perform a partial register transfer using a read, modify, write
930 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
932 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
935 static enum register_status
936 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
937 int offset
, int len
, void *in
, const void *out
,
938 enum register_status (*read
) (struct regcache
*regcache
,
941 void (*write
) (struct regcache
*regcache
, int regnum
,
942 const gdb_byte
*buf
))
944 struct regcache_descr
*descr
= regcache
->descr
;
945 gdb_byte reg
[MAX_REGISTER_SIZE
];
947 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
948 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
949 /* Something to do? */
950 if (offset
+ len
== 0)
952 /* Read (when needed) ... */
955 || offset
+ len
< descr
->sizeof_register
[regnum
])
957 enum register_status status
;
959 gdb_assert (read
!= NULL
);
960 status
= read (regcache
, regnum
, reg
);
961 if (status
!= REG_VALID
)
966 memcpy (in
, reg
+ offset
, len
);
968 memcpy (reg
+ offset
, out
, len
);
969 /* ... write (when needed). */
972 gdb_assert (write
!= NULL
);
973 write (regcache
, regnum
, reg
);
980 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
981 int offset
, int len
, gdb_byte
*buf
)
983 struct regcache_descr
*descr
= regcache
->descr
;
985 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
986 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
987 regcache_raw_read
, regcache_raw_write
);
991 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
992 int offset
, int len
, const gdb_byte
*buf
)
994 struct regcache_descr
*descr
= regcache
->descr
;
996 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
997 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
998 regcache_raw_read
, regcache_raw_write
);
1001 enum register_status
1002 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1003 int offset
, int len
, gdb_byte
*buf
)
1005 struct regcache_descr
*descr
= regcache
->descr
;
1007 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
1008 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
1009 regcache_cooked_read
, regcache_cooked_write
);
1013 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1014 int offset
, int len
, const gdb_byte
*buf
)
1016 struct regcache_descr
*descr
= regcache
->descr
;
1018 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
1019 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
1020 regcache_cooked_read
, regcache_cooked_write
);
1023 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1026 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1031 gdb_assert (regcache
!= NULL
);
1032 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1033 gdb_assert (!regcache
->readonly_p
);
1035 regbuf
= register_buffer (regcache
, regnum
);
1036 size
= regcache
->descr
->sizeof_register
[regnum
];
1040 memcpy (regbuf
, buf
, size
);
1041 regcache
->register_status
[regnum
] = REG_VALID
;
1045 /* This memset not strictly necessary, but better than garbage
1046 in case the register value manages to escape somewhere (due
1047 to a bug, no less). */
1048 memset (regbuf
, 0, size
);
1049 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
1053 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1056 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1061 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1062 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1064 regbuf
= register_buffer (regcache
, regnum
);
1065 size
= regcache
->descr
->sizeof_register
[regnum
];
1066 memcpy (buf
, regbuf
, size
);
1070 /* Special handling for register PC. */
1073 regcache_read_pc (struct regcache
*regcache
)
1075 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1079 if (gdbarch_read_pc_p (gdbarch
))
1080 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1081 /* Else use per-frame method on get_current_frame. */
1082 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1086 if (regcache_cooked_read_unsigned (regcache
,
1087 gdbarch_pc_regnum (gdbarch
),
1088 &raw_val
) == REG_UNAVAILABLE
)
1089 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1091 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1094 internal_error (__FILE__
, __LINE__
,
1095 _("regcache_read_pc: Unable to find PC"));
1100 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1102 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1104 if (gdbarch_write_pc_p (gdbarch
))
1105 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1106 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1107 regcache_cooked_write_unsigned (regcache
,
1108 gdbarch_pc_regnum (gdbarch
), pc
);
1110 internal_error (__FILE__
, __LINE__
,
1111 _("regcache_write_pc: Unable to update PC"));
1113 /* Writing the PC (for instance, from "load") invalidates the
1115 reinit_frame_cache ();
1120 reg_flush_command (char *command
, int from_tty
)
1122 /* Force-flush the register cache. */
1123 registers_changed ();
1125 printf_filtered (_("Register cache flushed.\n"));
1128 enum regcache_dump_what
1130 regcache_dump_none
, regcache_dump_raw
,
1131 regcache_dump_cooked
, regcache_dump_groups
,
1132 regcache_dump_remote
1136 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1137 enum regcache_dump_what what_to_dump
)
1139 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1140 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1142 int footnote_nr
= 0;
1143 int footnote_register_size
= 0;
1144 int footnote_register_offset
= 0;
1145 int footnote_register_type_name_null
= 0;
1146 long register_offset
= 0;
1147 gdb_byte buf
[MAX_REGISTER_SIZE
];
1150 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1151 regcache
->descr
->nr_raw_registers
);
1152 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1153 regcache
->descr
->nr_cooked_registers
);
1154 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1155 regcache
->descr
->sizeof_raw_registers
);
1156 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1157 regcache
->descr
->sizeof_raw_register_status
);
1158 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1159 gdbarch_num_regs (gdbarch
));
1160 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1161 gdbarch_num_pseudo_regs (gdbarch
));
1164 gdb_assert (regcache
->descr
->nr_cooked_registers
1165 == (gdbarch_num_regs (gdbarch
)
1166 + gdbarch_num_pseudo_regs (gdbarch
)));
1168 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1172 fprintf_unfiltered (file
, " %-10s", "Name");
1175 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1179 else if (p
[0] == '\0')
1181 fprintf_unfiltered (file
, " %-10s", p
);
1186 fprintf_unfiltered (file
, " %4s", "Nr");
1188 fprintf_unfiltered (file
, " %4d", regnum
);
1190 /* Relative number. */
1192 fprintf_unfiltered (file
, " %4s", "Rel");
1193 else if (regnum
< gdbarch_num_regs (gdbarch
))
1194 fprintf_unfiltered (file
, " %4d", regnum
);
1196 fprintf_unfiltered (file
, " %4d",
1197 (regnum
- gdbarch_num_regs (gdbarch
)));
1201 fprintf_unfiltered (file
, " %6s ", "Offset");
1204 fprintf_unfiltered (file
, " %6ld",
1205 regcache
->descr
->register_offset
[regnum
]);
1206 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1208 && (regcache
->descr
->register_offset
[regnum
]
1209 != (regcache
->descr
->register_offset
[regnum
- 1]
1210 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1213 if (!footnote_register_offset
)
1214 footnote_register_offset
= ++footnote_nr
;
1215 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1218 fprintf_unfiltered (file
, " ");
1219 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1220 + regcache
->descr
->sizeof_register
[regnum
]);
1225 fprintf_unfiltered (file
, " %5s ", "Size");
1227 fprintf_unfiltered (file
, " %5ld",
1228 regcache
->descr
->sizeof_register
[regnum
]);
1238 static const char blt
[] = "builtin_type";
1240 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1245 if (!footnote_register_type_name_null
)
1246 footnote_register_type_name_null
= ++footnote_nr
;
1247 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1248 make_cleanup (xfree
, n
);
1251 /* Chop a leading builtin_type. */
1252 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1255 fprintf_unfiltered (file
, " %-15s", t
);
1258 /* Leading space always present. */
1259 fprintf_unfiltered (file
, " ");
1262 if (what_to_dump
== regcache_dump_raw
)
1265 fprintf_unfiltered (file
, "Raw value");
1266 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1267 fprintf_unfiltered (file
, "<cooked>");
1268 else if (regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
1269 fprintf_unfiltered (file
, "<invalid>");
1270 else if (regcache_register_status (regcache
, regnum
) == REG_UNAVAILABLE
)
1271 fprintf_unfiltered (file
, "<unavailable>");
1274 regcache_raw_read (regcache
, regnum
, buf
);
1275 print_hex_chars (file
, buf
,
1276 regcache
->descr
->sizeof_register
[regnum
],
1277 gdbarch_byte_order (gdbarch
));
1281 /* Value, cooked. */
1282 if (what_to_dump
== regcache_dump_cooked
)
1285 fprintf_unfiltered (file
, "Cooked value");
1288 enum register_status status
;
1290 status
= regcache_cooked_read (regcache
, regnum
, buf
);
1291 if (status
== REG_UNKNOWN
)
1292 fprintf_unfiltered (file
, "<invalid>");
1293 else if (status
== REG_UNAVAILABLE
)
1294 fprintf_unfiltered (file
, "<unavailable>");
1296 print_hex_chars (file
, buf
,
1297 regcache
->descr
->sizeof_register
[regnum
],
1298 gdbarch_byte_order (gdbarch
));
1302 /* Group members. */
1303 if (what_to_dump
== regcache_dump_groups
)
1306 fprintf_unfiltered (file
, "Groups");
1309 const char *sep
= "";
1310 struct reggroup
*group
;
1312 for (group
= reggroup_next (gdbarch
, NULL
);
1314 group
= reggroup_next (gdbarch
, group
))
1316 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1318 fprintf_unfiltered (file
,
1319 "%s%s", sep
, reggroup_name (group
));
1326 /* Remote packet configuration. */
1327 if (what_to_dump
== regcache_dump_remote
)
1331 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1333 else if (regnum
< regcache
->descr
->nr_raw_registers
)
1337 if (remote_register_number_and_offset (get_regcache_arch (regcache
), regnum
,
1339 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1343 fprintf_unfiltered (file
, "\n");
1346 if (footnote_register_size
)
1347 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1348 footnote_register_size
);
1349 if (footnote_register_offset
)
1350 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1351 footnote_register_offset
);
1352 if (footnote_register_type_name_null
)
1353 fprintf_unfiltered (file
,
1354 "*%d: Register type's name NULL.\n",
1355 footnote_register_type_name_null
);
1356 do_cleanups (cleanups
);
1360 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1363 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1366 struct cleanup
*cleanups
;
1367 struct ui_file
*file
= gdb_fopen (args
, "w");
1370 perror_with_name (_("maintenance print architecture"));
1371 cleanups
= make_cleanup_ui_file_delete (file
);
1372 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1373 do_cleanups (cleanups
);
1378 maintenance_print_registers (char *args
, int from_tty
)
1380 regcache_print (args
, regcache_dump_none
);
1384 maintenance_print_raw_registers (char *args
, int from_tty
)
1386 regcache_print (args
, regcache_dump_raw
);
1390 maintenance_print_cooked_registers (char *args
, int from_tty
)
1392 regcache_print (args
, regcache_dump_cooked
);
1396 maintenance_print_register_groups (char *args
, int from_tty
)
1398 regcache_print (args
, regcache_dump_groups
);
1402 maintenance_print_remote_registers (char *args
, int from_tty
)
1404 regcache_print (args
, regcache_dump_remote
);
1407 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1410 _initialize_regcache (void)
1412 regcache_descr_handle
1413 = gdbarch_data_register_post_init (init_regcache_descr
);
1415 observer_attach_target_changed (regcache_observer_target_changed
);
1416 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1418 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1419 _("Force gdb to flush its register cache (maintainer command)"));
1421 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1422 _("Print the internal register configuration.\n"
1423 "Takes an optional file parameter."), &maintenanceprintlist
);
1424 add_cmd ("raw-registers", class_maintenance
,
1425 maintenance_print_raw_registers
,
1426 _("Print the internal register configuration "
1427 "including raw values.\n"
1428 "Takes an optional file parameter."), &maintenanceprintlist
);
1429 add_cmd ("cooked-registers", class_maintenance
,
1430 maintenance_print_cooked_registers
,
1431 _("Print the internal register configuration "
1432 "including cooked values.\n"
1433 "Takes an optional file parameter."), &maintenanceprintlist
);
1434 add_cmd ("register-groups", class_maintenance
,
1435 maintenance_print_register_groups
,
1436 _("Print the internal register configuration "
1437 "including each register's group.\n"
1438 "Takes an optional file parameter."),
1439 &maintenanceprintlist
);
1440 add_cmd ("remote-registers", class_maintenance
,
1441 maintenance_print_remote_registers
, _("\
1442 Print the internal register configuration including each register's\n\
1443 remote register number and buffer offset in the g/G packets.\n\
1444 Takes an optional file parameter."),
1445 &maintenanceprintlist
);