1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2015 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"
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
);
394 static void regcache_cpy_no_passthrough (struct regcache
*dst
,
395 struct regcache
*src
);
398 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
400 gdb_assert (src
!= NULL
&& dst
!= NULL
);
401 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
402 gdb_assert (src
!= dst
);
403 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
405 if (!src
->readonly_p
)
406 regcache_save (dst
, do_cooked_read
, src
);
407 else if (!dst
->readonly_p
)
408 regcache_restore (dst
, do_cooked_read
, src
);
410 regcache_cpy_no_passthrough (dst
, src
);
413 /* Copy/duplicate the contents of a register cache. Unlike regcache_cpy,
414 which is pass-through, this does not go through to the target.
415 Only values values already in the cache are transferred. The SRC and DST
416 buffers must not overlap. */
419 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
421 gdb_assert (src
!= NULL
&& dst
!= NULL
);
422 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
423 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
424 move of data into a thread's regcache. Doing this would be silly
425 - it would mean that regcache->register_status would be
426 completely invalid. */
427 gdb_assert (dst
->readonly_p
&& src
->readonly_p
);
429 memcpy (dst
->registers
, src
->registers
,
430 dst
->descr
->sizeof_cooked_registers
);
431 memcpy (dst
->register_status
, src
->register_status
,
432 dst
->descr
->sizeof_cooked_register_status
);
436 regcache_dup (struct regcache
*src
)
438 struct regcache
*newbuf
;
440 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
441 regcache_cpy (newbuf
, src
);
446 regcache_register_status (const struct regcache
*regcache
, int regnum
)
448 gdb_assert (regcache
!= NULL
);
449 gdb_assert (regnum
>= 0);
450 if (regcache
->readonly_p
)
451 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
453 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
455 return regcache
->register_status
[regnum
];
459 regcache_invalidate (struct regcache
*regcache
, int regnum
)
461 gdb_assert (regcache
!= NULL
);
462 gdb_assert (regnum
>= 0);
463 gdb_assert (!regcache
->readonly_p
);
464 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
465 regcache
->register_status
[regnum
] = REG_UNKNOWN
;
469 /* Global structure containing the current regcache. */
471 /* NOTE: this is a write-through cache. There is no "dirty" bit for
472 recording if the register values have been changed (eg. by the
473 user). Therefore all registers must be written back to the
474 target when appropriate. */
478 struct regcache
*regcache
;
479 struct regcache_list
*next
;
482 static struct regcache_list
*current_regcache
;
485 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
486 struct address_space
*aspace
)
488 struct regcache_list
*list
;
489 struct regcache
*new_regcache
;
491 for (list
= current_regcache
; list
; list
= list
->next
)
492 if (ptid_equal (list
->regcache
->ptid
, ptid
)
493 && get_regcache_arch (list
->regcache
) == gdbarch
)
494 return list
->regcache
;
496 new_regcache
= regcache_xmalloc_1 (gdbarch
, aspace
, 0);
497 new_regcache
->ptid
= ptid
;
499 list
= xmalloc (sizeof (struct regcache_list
));
500 list
->regcache
= new_regcache
;
501 list
->next
= current_regcache
;
502 current_regcache
= list
;
508 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
510 struct address_space
*aspace
;
512 /* For the benefit of "maint print registers" & co when debugging an
513 executable, allow dumping the regcache even when there is no
514 thread selected (target_thread_address_space internal-errors if
515 no address space is found). Note that normal user commands will
516 fail higher up on the call stack due to no
517 target_has_registers. */
518 aspace
= (ptid_equal (null_ptid
, ptid
)
520 : target_thread_address_space (ptid
));
522 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
525 static ptid_t current_thread_ptid
;
526 static struct gdbarch
*current_thread_arch
;
529 get_thread_regcache (ptid_t ptid
)
531 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
533 current_thread_ptid
= ptid
;
534 current_thread_arch
= target_thread_architecture (ptid
);
537 return get_thread_arch_regcache (ptid
, current_thread_arch
);
541 get_current_regcache (void)
543 return get_thread_regcache (inferior_ptid
);
546 /* See common/common-regcache.h. */
549 get_thread_regcache_for_ptid (ptid_t ptid
)
551 return get_thread_regcache (ptid
);
554 /* Observer for the target_changed event. */
557 regcache_observer_target_changed (struct target_ops
*target
)
559 registers_changed ();
562 /* Update global variables old ptids to hold NEW_PTID if they were
565 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
567 struct regcache_list
*list
;
569 for (list
= current_regcache
; list
; list
= list
->next
)
570 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
571 list
->regcache
->ptid
= new_ptid
;
574 /* Low level examining and depositing of registers.
576 The caller is responsible for making sure that the inferior is
577 stopped before calling the fetching routines, or it will get
578 garbage. (a change from GDB version 3, in which the caller got the
579 value from the last stop). */
581 /* REGISTERS_CHANGED ()
583 Indicate that registers may have changed, so invalidate the cache. */
586 registers_changed_ptid (ptid_t ptid
)
588 struct regcache_list
*list
, **list_link
;
590 list
= current_regcache
;
591 list_link
= ¤t_regcache
;
594 if (ptid_match (list
->regcache
->ptid
, ptid
))
596 struct regcache_list
*dead
= list
;
598 *list_link
= list
->next
;
599 regcache_xfree (list
->regcache
);
605 list_link
= &list
->next
;
609 if (ptid_match (current_thread_ptid
, ptid
))
611 current_thread_ptid
= null_ptid
;
612 current_thread_arch
= NULL
;
615 if (ptid_match (inferior_ptid
, ptid
))
617 /* We just deleted the regcache of the current thread. Need to
618 forget about any frames we have cached, too. */
619 reinit_frame_cache ();
624 registers_changed (void)
626 registers_changed_ptid (minus_one_ptid
);
628 /* Force cleanup of any alloca areas if using C alloca instead of
629 a builtin alloca. This particular call is used to clean up
630 areas allocated by low level target code which may build up
631 during lengthy interactions between gdb and the target before
632 gdb gives control to the user (ie watchpoints). */
637 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
639 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
640 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
641 /* Make certain that the register cache is up-to-date with respect
642 to the current thread. This switching shouldn't be necessary
643 only there is still only one target side register cache. Sigh!
644 On the bright side, at least there is a regcache object. */
645 if (!regcache
->readonly_p
646 && regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
648 struct cleanup
*old_chain
= save_inferior_ptid ();
650 inferior_ptid
= regcache
->ptid
;
651 target_fetch_registers (regcache
, regnum
);
652 do_cleanups (old_chain
);
654 /* A number of targets can't access the whole set of raw
655 registers (because the debug API provides no means to get at
657 if (regcache
->register_status
[regnum
] == REG_UNKNOWN
)
658 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
661 if (regcache
->register_status
[regnum
] != REG_VALID
)
662 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
664 memcpy (buf
, register_buffer (regcache
, regnum
),
665 regcache
->descr
->sizeof_register
[regnum
]);
667 return regcache
->register_status
[regnum
];
671 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
674 enum register_status status
;
676 gdb_assert (regcache
!= NULL
);
677 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
678 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
679 status
= regcache_raw_read (regcache
, regnum
, buf
);
680 if (status
== REG_VALID
)
681 *val
= extract_signed_integer
682 (buf
, regcache
->descr
->sizeof_register
[regnum
],
683 gdbarch_byte_order (regcache
->descr
->gdbarch
));
690 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
694 enum register_status status
;
696 gdb_assert (regcache
!= NULL
);
697 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
698 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
699 status
= regcache_raw_read (regcache
, regnum
, buf
);
700 if (status
== REG_VALID
)
701 *val
= extract_unsigned_integer
702 (buf
, regcache
->descr
->sizeof_register
[regnum
],
703 gdbarch_byte_order (regcache
->descr
->gdbarch
));
710 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
714 gdb_assert (regcache
!= NULL
);
715 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
716 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
717 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
718 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
719 regcache_raw_write (regcache
, regnum
, buf
);
723 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
728 gdb_assert (regcache
!= NULL
);
729 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
730 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
731 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
732 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
733 regcache_raw_write (regcache
, regnum
, buf
);
737 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
739 gdb_assert (regnum
>= 0);
740 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
741 if (regnum
< regcache
->descr
->nr_raw_registers
)
742 return regcache_raw_read (regcache
, regnum
, buf
);
743 else if (regcache
->readonly_p
744 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
746 /* Read-only register cache, perhaps the cooked value was
748 if (regcache
->register_status
[regnum
] == REG_VALID
)
749 memcpy (buf
, register_buffer (regcache
, regnum
),
750 regcache
->descr
->sizeof_register
[regnum
]);
752 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
754 return regcache
->register_status
[regnum
];
756 else if (gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
758 struct value
*mark
, *computed
;
759 enum register_status result
= REG_VALID
;
761 mark
= value_mark ();
763 computed
= gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
765 if (value_entirely_available (computed
))
766 memcpy (buf
, value_contents_raw (computed
),
767 regcache
->descr
->sizeof_register
[regnum
]);
770 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
771 result
= REG_UNAVAILABLE
;
774 value_free_to_mark (mark
);
779 return gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
784 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
786 gdb_assert (regnum
>= 0);
787 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
789 if (regnum
< regcache
->descr
->nr_raw_registers
790 || (regcache
->readonly_p
791 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
792 || !gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
794 struct value
*result
;
796 result
= allocate_value (register_type (regcache
->descr
->gdbarch
,
798 VALUE_LVAL (result
) = lval_register
;
799 VALUE_REGNUM (result
) = regnum
;
801 /* It is more efficient in general to do this delegation in this
802 direction than in the other one, even though the value-based
804 if (regcache_cooked_read (regcache
, regnum
,
805 value_contents_raw (result
)) == REG_UNAVAILABLE
)
806 mark_value_bytes_unavailable (result
, 0,
807 TYPE_LENGTH (value_type (result
)));
812 return gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
817 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
820 enum register_status status
;
823 gdb_assert (regcache
!= NULL
);
824 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
825 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
826 status
= regcache_cooked_read (regcache
, regnum
, buf
);
827 if (status
== REG_VALID
)
828 *val
= extract_signed_integer
829 (buf
, regcache
->descr
->sizeof_register
[regnum
],
830 gdbarch_byte_order (regcache
->descr
->gdbarch
));
837 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
840 enum register_status status
;
843 gdb_assert (regcache
!= NULL
);
844 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
845 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
846 status
= regcache_cooked_read (regcache
, regnum
, buf
);
847 if (status
== REG_VALID
)
848 *val
= extract_unsigned_integer
849 (buf
, regcache
->descr
->sizeof_register
[regnum
],
850 gdbarch_byte_order (regcache
->descr
->gdbarch
));
857 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
862 gdb_assert (regcache
!= NULL
);
863 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
864 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
865 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
866 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
867 regcache_cooked_write (regcache
, regnum
, buf
);
871 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
876 gdb_assert (regcache
!= NULL
);
877 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
878 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
879 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
880 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
881 regcache_cooked_write (regcache
, regnum
, buf
);
885 regcache_raw_write (struct regcache
*regcache
, int regnum
,
888 struct cleanup
*chain_before_save_inferior
;
889 struct cleanup
*chain_before_invalidate_register
;
891 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
892 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
893 gdb_assert (!regcache
->readonly_p
);
895 /* On the sparc, writing %g0 is a no-op, so we don't even want to
896 change the registers array if something writes to this register. */
897 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
900 /* If we have a valid copy of the register, and new value == old
901 value, then don't bother doing the actual store. */
902 if (regcache_register_status (regcache
, regnum
) == REG_VALID
903 && (memcmp (register_buffer (regcache
, regnum
), buf
,
904 regcache
->descr
->sizeof_register
[regnum
]) == 0))
907 chain_before_save_inferior
= save_inferior_ptid ();
908 inferior_ptid
= regcache
->ptid
;
910 target_prepare_to_store (regcache
);
911 memcpy (register_buffer (regcache
, regnum
), buf
,
912 regcache
->descr
->sizeof_register
[regnum
]);
913 regcache
->register_status
[regnum
] = REG_VALID
;
915 /* Register a cleanup function for invalidating the register after it is
916 written, in case of a failure. */
917 chain_before_invalidate_register
918 = make_cleanup_regcache_invalidate (regcache
, regnum
);
920 target_store_registers (regcache
, regnum
);
922 /* The target did not throw an error so we can discard invalidating the
923 register and restore the cleanup chain to what it was. */
924 discard_cleanups (chain_before_invalidate_register
);
926 do_cleanups (chain_before_save_inferior
);
930 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
933 gdb_assert (regnum
>= 0);
934 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
935 if (regnum
< regcache
->descr
->nr_raw_registers
)
936 regcache_raw_write (regcache
, regnum
, buf
);
938 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
942 /* Perform a partial register transfer using a read, modify, write
945 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
947 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
950 static enum register_status
951 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
952 int offset
, int len
, void *in
, const void *out
,
953 enum register_status (*read
) (struct regcache
*regcache
,
956 void (*write
) (struct regcache
*regcache
, int regnum
,
957 const gdb_byte
*buf
))
959 struct regcache_descr
*descr
= regcache
->descr
;
960 gdb_byte reg
[MAX_REGISTER_SIZE
];
962 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
963 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
964 /* Something to do? */
965 if (offset
+ len
== 0)
967 /* Read (when needed) ... */
970 || offset
+ len
< descr
->sizeof_register
[regnum
])
972 enum register_status status
;
974 gdb_assert (read
!= NULL
);
975 status
= read (regcache
, regnum
, reg
);
976 if (status
!= REG_VALID
)
981 memcpy (in
, reg
+ offset
, len
);
983 memcpy (reg
+ offset
, out
, len
);
984 /* ... write (when needed). */
987 gdb_assert (write
!= NULL
);
988 write (regcache
, regnum
, reg
);
995 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
996 int offset
, int len
, gdb_byte
*buf
)
998 struct regcache_descr
*descr
= regcache
->descr
;
1000 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
1001 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
1002 regcache_raw_read
, regcache_raw_write
);
1006 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
1007 int offset
, int len
, const gdb_byte
*buf
)
1009 struct regcache_descr
*descr
= regcache
->descr
;
1011 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
1012 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
1013 regcache_raw_read
, regcache_raw_write
);
1016 enum register_status
1017 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1018 int offset
, int len
, gdb_byte
*buf
)
1020 struct regcache_descr
*descr
= regcache
->descr
;
1022 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
1023 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
1024 regcache_cooked_read
, regcache_cooked_write
);
1028 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1029 int offset
, int len
, const gdb_byte
*buf
)
1031 struct regcache_descr
*descr
= regcache
->descr
;
1033 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
1034 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
1035 regcache_cooked_read
, regcache_cooked_write
);
1038 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1041 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1046 gdb_assert (regcache
!= NULL
);
1047 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1048 gdb_assert (!regcache
->readonly_p
);
1050 regbuf
= register_buffer (regcache
, regnum
);
1051 size
= regcache
->descr
->sizeof_register
[regnum
];
1055 memcpy (regbuf
, buf
, size
);
1056 regcache
->register_status
[regnum
] = REG_VALID
;
1060 /* This memset not strictly necessary, but better than garbage
1061 in case the register value manages to escape somewhere (due
1062 to a bug, no less). */
1063 memset (regbuf
, 0, size
);
1064 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
1068 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1071 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1076 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1077 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1079 regbuf
= register_buffer (regcache
, regnum
);
1080 size
= regcache
->descr
->sizeof_register
[regnum
];
1081 memcpy (buf
, regbuf
, size
);
1084 /* Transfer a single or all registers belonging to a certain register
1085 set to or from a buffer. This is the main worker function for
1086 regcache_supply_regset and regcache_collect_regset. */
1089 regcache_transfer_regset (const struct regset
*regset
,
1090 const struct regcache
*regcache
,
1091 struct regcache
*out_regcache
,
1092 int regnum
, const void *in_buf
,
1093 void *out_buf
, size_t size
)
1095 const struct regcache_map_entry
*map
;
1096 int offs
= 0, count
;
1098 for (map
= regset
->regmap
; (count
= map
->count
) != 0; map
++)
1100 int regno
= map
->regno
;
1101 int slot_size
= map
->size
;
1103 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1104 slot_size
= regcache
->descr
->sizeof_register
[regno
];
1106 if (regno
== REGCACHE_MAP_SKIP
1108 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1109 offs
+= count
* slot_size
;
1111 else if (regnum
== -1)
1112 for (; count
--; regno
++, offs
+= slot_size
)
1114 if (offs
+ slot_size
> size
)
1118 regcache_raw_collect (regcache
, regno
,
1119 (gdb_byte
*) out_buf
+ offs
);
1121 regcache_raw_supply (out_regcache
, regno
, in_buf
1122 ? (const gdb_byte
*) in_buf
+ offs
1127 /* Transfer a single register and return. */
1128 offs
+= (regnum
- regno
) * slot_size
;
1129 if (offs
+ slot_size
> size
)
1133 regcache_raw_collect (regcache
, regnum
,
1134 (gdb_byte
*) out_buf
+ offs
);
1136 regcache_raw_supply (out_regcache
, regnum
, in_buf
1137 ? (const gdb_byte
*) in_buf
+ offs
1144 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1145 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1146 If BUF is NULL, set the register(s) to "unavailable" status. */
1149 regcache_supply_regset (const struct regset
*regset
,
1150 struct regcache
*regcache
,
1151 int regnum
, const void *buf
, size_t size
)
1153 regcache_transfer_regset (regset
, regcache
, regcache
, regnum
,
1157 /* Collect register REGNUM from REGCACHE to BUF, using the register
1158 map in REGSET. If REGNUM is -1, do this for all registers in
1162 regcache_collect_regset (const struct regset
*regset
,
1163 const struct regcache
*regcache
,
1164 int regnum
, void *buf
, size_t size
)
1166 regcache_transfer_regset (regset
, regcache
, NULL
, regnum
,
1171 /* Special handling for register PC. */
1174 regcache_read_pc (struct regcache
*regcache
)
1176 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1180 if (gdbarch_read_pc_p (gdbarch
))
1181 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1182 /* Else use per-frame method on get_current_frame. */
1183 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1187 if (regcache_cooked_read_unsigned (regcache
,
1188 gdbarch_pc_regnum (gdbarch
),
1189 &raw_val
) == REG_UNAVAILABLE
)
1190 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1192 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1195 internal_error (__FILE__
, __LINE__
,
1196 _("regcache_read_pc: Unable to find PC"));
1201 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1203 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1205 if (gdbarch_write_pc_p (gdbarch
))
1206 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1207 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1208 regcache_cooked_write_unsigned (regcache
,
1209 gdbarch_pc_regnum (gdbarch
), pc
);
1211 internal_error (__FILE__
, __LINE__
,
1212 _("regcache_write_pc: Unable to update PC"));
1214 /* Writing the PC (for instance, from "load") invalidates the
1216 reinit_frame_cache ();
1221 reg_flush_command (char *command
, int from_tty
)
1223 /* Force-flush the register cache. */
1224 registers_changed ();
1226 printf_filtered (_("Register cache flushed.\n"));
1229 enum regcache_dump_what
1231 regcache_dump_none
, regcache_dump_raw
,
1232 regcache_dump_cooked
, regcache_dump_groups
,
1233 regcache_dump_remote
1237 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1238 enum regcache_dump_what what_to_dump
)
1240 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1241 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1243 int footnote_nr
= 0;
1244 int footnote_register_size
= 0;
1245 int footnote_register_offset
= 0;
1246 int footnote_register_type_name_null
= 0;
1247 long register_offset
= 0;
1248 gdb_byte buf
[MAX_REGISTER_SIZE
];
1251 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1252 regcache
->descr
->nr_raw_registers
);
1253 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1254 regcache
->descr
->nr_cooked_registers
);
1255 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1256 regcache
->descr
->sizeof_raw_registers
);
1257 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1258 regcache
->descr
->sizeof_raw_register_status
);
1259 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1260 gdbarch_num_regs (gdbarch
));
1261 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1262 gdbarch_num_pseudo_regs (gdbarch
));
1265 gdb_assert (regcache
->descr
->nr_cooked_registers
1266 == (gdbarch_num_regs (gdbarch
)
1267 + gdbarch_num_pseudo_regs (gdbarch
)));
1269 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1273 fprintf_unfiltered (file
, " %-10s", "Name");
1276 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1280 else if (p
[0] == '\0')
1282 fprintf_unfiltered (file
, " %-10s", p
);
1287 fprintf_unfiltered (file
, " %4s", "Nr");
1289 fprintf_unfiltered (file
, " %4d", regnum
);
1291 /* Relative number. */
1293 fprintf_unfiltered (file
, " %4s", "Rel");
1294 else if (regnum
< gdbarch_num_regs (gdbarch
))
1295 fprintf_unfiltered (file
, " %4d", regnum
);
1297 fprintf_unfiltered (file
, " %4d",
1298 (regnum
- gdbarch_num_regs (gdbarch
)));
1302 fprintf_unfiltered (file
, " %6s ", "Offset");
1305 fprintf_unfiltered (file
, " %6ld",
1306 regcache
->descr
->register_offset
[regnum
]);
1307 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1309 && (regcache
->descr
->register_offset
[regnum
]
1310 != (regcache
->descr
->register_offset
[regnum
- 1]
1311 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1314 if (!footnote_register_offset
)
1315 footnote_register_offset
= ++footnote_nr
;
1316 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1319 fprintf_unfiltered (file
, " ");
1320 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1321 + regcache
->descr
->sizeof_register
[regnum
]);
1326 fprintf_unfiltered (file
, " %5s ", "Size");
1328 fprintf_unfiltered (file
, " %5ld",
1329 regcache
->descr
->sizeof_register
[regnum
]);
1339 static const char blt
[] = "builtin_type";
1341 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1346 if (!footnote_register_type_name_null
)
1347 footnote_register_type_name_null
= ++footnote_nr
;
1348 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1349 make_cleanup (xfree
, n
);
1352 /* Chop a leading builtin_type. */
1353 if (startswith (t
, blt
))
1356 fprintf_unfiltered (file
, " %-15s", t
);
1359 /* Leading space always present. */
1360 fprintf_unfiltered (file
, " ");
1363 if (what_to_dump
== regcache_dump_raw
)
1366 fprintf_unfiltered (file
, "Raw value");
1367 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1368 fprintf_unfiltered (file
, "<cooked>");
1369 else if (regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
1370 fprintf_unfiltered (file
, "<invalid>");
1371 else if (regcache_register_status (regcache
, regnum
) == REG_UNAVAILABLE
)
1372 fprintf_unfiltered (file
, "<unavailable>");
1375 regcache_raw_read (regcache
, regnum
, buf
);
1376 print_hex_chars (file
, buf
,
1377 regcache
->descr
->sizeof_register
[regnum
],
1378 gdbarch_byte_order (gdbarch
));
1382 /* Value, cooked. */
1383 if (what_to_dump
== regcache_dump_cooked
)
1386 fprintf_unfiltered (file
, "Cooked value");
1389 enum register_status status
;
1391 status
= regcache_cooked_read (regcache
, regnum
, buf
);
1392 if (status
== REG_UNKNOWN
)
1393 fprintf_unfiltered (file
, "<invalid>");
1394 else if (status
== REG_UNAVAILABLE
)
1395 fprintf_unfiltered (file
, "<unavailable>");
1397 print_hex_chars (file
, buf
,
1398 regcache
->descr
->sizeof_register
[regnum
],
1399 gdbarch_byte_order (gdbarch
));
1403 /* Group members. */
1404 if (what_to_dump
== regcache_dump_groups
)
1407 fprintf_unfiltered (file
, "Groups");
1410 const char *sep
= "";
1411 struct reggroup
*group
;
1413 for (group
= reggroup_next (gdbarch
, NULL
);
1415 group
= reggroup_next (gdbarch
, group
))
1417 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1419 fprintf_unfiltered (file
,
1420 "%s%s", sep
, reggroup_name (group
));
1427 /* Remote packet configuration. */
1428 if (what_to_dump
== regcache_dump_remote
)
1432 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1434 else if (regnum
< regcache
->descr
->nr_raw_registers
)
1438 if (remote_register_number_and_offset (get_regcache_arch (regcache
), regnum
,
1440 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1444 fprintf_unfiltered (file
, "\n");
1447 if (footnote_register_size
)
1448 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1449 footnote_register_size
);
1450 if (footnote_register_offset
)
1451 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1452 footnote_register_offset
);
1453 if (footnote_register_type_name_null
)
1454 fprintf_unfiltered (file
,
1455 "*%d: Register type's name NULL.\n",
1456 footnote_register_type_name_null
);
1457 do_cleanups (cleanups
);
1461 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1464 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1467 struct cleanup
*cleanups
;
1468 struct ui_file
*file
= gdb_fopen (args
, "w");
1471 perror_with_name (_("maintenance print architecture"));
1472 cleanups
= make_cleanup_ui_file_delete (file
);
1473 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1474 do_cleanups (cleanups
);
1479 maintenance_print_registers (char *args
, int from_tty
)
1481 regcache_print (args
, regcache_dump_none
);
1485 maintenance_print_raw_registers (char *args
, int from_tty
)
1487 regcache_print (args
, regcache_dump_raw
);
1491 maintenance_print_cooked_registers (char *args
, int from_tty
)
1493 regcache_print (args
, regcache_dump_cooked
);
1497 maintenance_print_register_groups (char *args
, int from_tty
)
1499 regcache_print (args
, regcache_dump_groups
);
1503 maintenance_print_remote_registers (char *args
, int from_tty
)
1505 regcache_print (args
, regcache_dump_remote
);
1508 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1511 _initialize_regcache (void)
1513 regcache_descr_handle
1514 = gdbarch_data_register_post_init (init_regcache_descr
);
1516 observer_attach_target_changed (regcache_observer_target_changed
);
1517 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1519 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1520 _("Force gdb to flush its register cache (maintainer command)"));
1522 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1523 _("Print the internal register configuration.\n"
1524 "Takes an optional file parameter."), &maintenanceprintlist
);
1525 add_cmd ("raw-registers", class_maintenance
,
1526 maintenance_print_raw_registers
,
1527 _("Print the internal register configuration "
1528 "including raw values.\n"
1529 "Takes an optional file parameter."), &maintenanceprintlist
);
1530 add_cmd ("cooked-registers", class_maintenance
,
1531 maintenance_print_cooked_registers
,
1532 _("Print the internal register configuration "
1533 "including cooked values.\n"
1534 "Takes an optional file parameter."), &maintenanceprintlist
);
1535 add_cmd ("register-groups", class_maintenance
,
1536 maintenance_print_register_groups
,
1537 _("Print the internal register configuration "
1538 "including each register's group.\n"
1539 "Takes an optional file parameter."),
1540 &maintenanceprintlist
);
1541 add_cmd ("remote-registers", class_maintenance
,
1542 maintenance_print_remote_registers
, _("\
1543 Print the internal register configuration including each register's\n\
1544 remote register number and buffer offset in the g/G packets.\n\
1545 Takes an optional file parameter."),
1546 &maintenanceprintlist
);