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
);
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
);
538 /* See common/common-regcache.h. */
541 get_thread_regcache_for_ptid (ptid_t ptid
)
543 return get_thread_regcache (ptid
);
546 /* Observer for the target_changed event. */
549 regcache_observer_target_changed (struct target_ops
*target
)
551 registers_changed ();
554 /* Update global variables old ptids to hold NEW_PTID if they were
557 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
559 struct regcache_list
*list
;
561 for (list
= current_regcache
; list
; list
= list
->next
)
562 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
563 list
->regcache
->ptid
= new_ptid
;
566 /* Low level examining and depositing of registers.
568 The caller is responsible for making sure that the inferior is
569 stopped before calling the fetching routines, or it will get
570 garbage. (a change from GDB version 3, in which the caller got the
571 value from the last stop). */
573 /* REGISTERS_CHANGED ()
575 Indicate that registers may have changed, so invalidate the cache. */
578 registers_changed_ptid (ptid_t ptid
)
580 struct regcache_list
*list
, **list_link
;
582 list
= current_regcache
;
583 list_link
= ¤t_regcache
;
586 if (ptid_match (list
->regcache
->ptid
, ptid
))
588 struct regcache_list
*dead
= list
;
590 *list_link
= list
->next
;
591 regcache_xfree (list
->regcache
);
597 list_link
= &list
->next
;
601 if (ptid_match (current_thread_ptid
, ptid
))
603 current_thread_ptid
= null_ptid
;
604 current_thread_arch
= NULL
;
607 if (ptid_match (inferior_ptid
, ptid
))
609 /* We just deleted the regcache of the current thread. Need to
610 forget about any frames we have cached, too. */
611 reinit_frame_cache ();
616 registers_changed (void)
618 registers_changed_ptid (minus_one_ptid
);
620 /* Force cleanup of any alloca areas if using C alloca instead of
621 a builtin alloca. This particular call is used to clean up
622 areas allocated by low level target code which may build up
623 during lengthy interactions between gdb and the target before
624 gdb gives control to the user (ie watchpoints). */
629 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
631 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
632 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
633 /* Make certain that the register cache is up-to-date with respect
634 to the current thread. This switching shouldn't be necessary
635 only there is still only one target side register cache. Sigh!
636 On the bright side, at least there is a regcache object. */
637 if (!regcache
->readonly_p
638 && regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
640 struct cleanup
*old_chain
= save_inferior_ptid ();
642 inferior_ptid
= regcache
->ptid
;
643 target_fetch_registers (regcache
, regnum
);
644 do_cleanups (old_chain
);
646 /* A number of targets can't access the whole set of raw
647 registers (because the debug API provides no means to get at
649 if (regcache
->register_status
[regnum
] == REG_UNKNOWN
)
650 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
653 if (regcache
->register_status
[regnum
] != REG_VALID
)
654 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
656 memcpy (buf
, register_buffer (regcache
, regnum
),
657 regcache
->descr
->sizeof_register
[regnum
]);
659 return regcache
->register_status
[regnum
];
663 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
666 enum register_status status
;
668 gdb_assert (regcache
!= NULL
);
669 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
670 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
671 status
= regcache_raw_read (regcache
, regnum
, buf
);
672 if (status
== REG_VALID
)
673 *val
= extract_signed_integer
674 (buf
, regcache
->descr
->sizeof_register
[regnum
],
675 gdbarch_byte_order (regcache
->descr
->gdbarch
));
682 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
686 enum register_status status
;
688 gdb_assert (regcache
!= NULL
);
689 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
690 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
691 status
= regcache_raw_read (regcache
, regnum
, buf
);
692 if (status
== REG_VALID
)
693 *val
= extract_unsigned_integer
694 (buf
, regcache
->descr
->sizeof_register
[regnum
],
695 gdbarch_byte_order (regcache
->descr
->gdbarch
));
702 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
706 gdb_assert (regcache
!= NULL
);
707 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
708 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
709 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
710 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
711 regcache_raw_write (regcache
, regnum
, buf
);
715 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
720 gdb_assert (regcache
!= NULL
);
721 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
722 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
723 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
724 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
725 regcache_raw_write (regcache
, regnum
, buf
);
729 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
731 gdb_assert (regnum
>= 0);
732 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
733 if (regnum
< regcache
->descr
->nr_raw_registers
)
734 return regcache_raw_read (regcache
, regnum
, buf
);
735 else if (regcache
->readonly_p
736 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
738 /* Read-only register cache, perhaps the cooked value was
740 if (regcache
->register_status
[regnum
] == REG_VALID
)
741 memcpy (buf
, register_buffer (regcache
, regnum
),
742 regcache
->descr
->sizeof_register
[regnum
]);
744 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
746 return regcache
->register_status
[regnum
];
748 else if (gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
750 struct value
*mark
, *computed
;
751 enum register_status result
= REG_VALID
;
753 mark
= value_mark ();
755 computed
= gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
757 if (value_entirely_available (computed
))
758 memcpy (buf
, value_contents_raw (computed
),
759 regcache
->descr
->sizeof_register
[regnum
]);
762 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
763 result
= REG_UNAVAILABLE
;
766 value_free_to_mark (mark
);
771 return gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
776 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
778 gdb_assert (regnum
>= 0);
779 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
781 if (regnum
< regcache
->descr
->nr_raw_registers
782 || (regcache
->readonly_p
783 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
784 || !gdbarch_pseudo_register_read_value_p (regcache
->descr
->gdbarch
))
786 struct value
*result
;
788 result
= allocate_value (register_type (regcache
->descr
->gdbarch
,
790 VALUE_LVAL (result
) = lval_register
;
791 VALUE_REGNUM (result
) = regnum
;
793 /* It is more efficient in general to do this delegation in this
794 direction than in the other one, even though the value-based
796 if (regcache_cooked_read (regcache
, regnum
,
797 value_contents_raw (result
)) == REG_UNAVAILABLE
)
798 mark_value_bytes_unavailable (result
, 0,
799 TYPE_LENGTH (value_type (result
)));
804 return gdbarch_pseudo_register_read_value (regcache
->descr
->gdbarch
,
809 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
812 enum register_status status
;
815 gdb_assert (regcache
!= NULL
);
816 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
817 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
818 status
= regcache_cooked_read (regcache
, regnum
, buf
);
819 if (status
== REG_VALID
)
820 *val
= extract_signed_integer
821 (buf
, regcache
->descr
->sizeof_register
[regnum
],
822 gdbarch_byte_order (regcache
->descr
->gdbarch
));
829 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
832 enum register_status status
;
835 gdb_assert (regcache
!= NULL
);
836 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
837 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
838 status
= regcache_cooked_read (regcache
, regnum
, buf
);
839 if (status
== REG_VALID
)
840 *val
= extract_unsigned_integer
841 (buf
, regcache
->descr
->sizeof_register
[regnum
],
842 gdbarch_byte_order (regcache
->descr
->gdbarch
));
849 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
854 gdb_assert (regcache
!= NULL
);
855 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
856 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
857 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
858 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
859 regcache_cooked_write (regcache
, regnum
, buf
);
863 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
868 gdb_assert (regcache
!= NULL
);
869 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
870 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
871 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
872 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
873 regcache_cooked_write (regcache
, regnum
, buf
);
877 regcache_raw_write (struct regcache
*regcache
, int regnum
,
880 struct cleanup
*chain_before_save_inferior
;
881 struct cleanup
*chain_before_invalidate_register
;
883 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
884 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
885 gdb_assert (!regcache
->readonly_p
);
887 /* On the sparc, writing %g0 is a no-op, so we don't even want to
888 change the registers array if something writes to this register. */
889 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
892 /* If we have a valid copy of the register, and new value == old
893 value, then don't bother doing the actual store. */
894 if (regcache_register_status (regcache
, regnum
) == REG_VALID
895 && (memcmp (register_buffer (regcache
, regnum
), buf
,
896 regcache
->descr
->sizeof_register
[regnum
]) == 0))
899 chain_before_save_inferior
= save_inferior_ptid ();
900 inferior_ptid
= regcache
->ptid
;
902 target_prepare_to_store (regcache
);
903 memcpy (register_buffer (regcache
, regnum
), buf
,
904 regcache
->descr
->sizeof_register
[regnum
]);
905 regcache
->register_status
[regnum
] = REG_VALID
;
907 /* Register a cleanup function for invalidating the register after it is
908 written, in case of a failure. */
909 chain_before_invalidate_register
910 = make_cleanup_regcache_invalidate (regcache
, regnum
);
912 target_store_registers (regcache
, regnum
);
914 /* The target did not throw an error so we can discard invalidating the
915 register and restore the cleanup chain to what it was. */
916 discard_cleanups (chain_before_invalidate_register
);
918 do_cleanups (chain_before_save_inferior
);
922 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
925 gdb_assert (regnum
>= 0);
926 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
927 if (regnum
< regcache
->descr
->nr_raw_registers
)
928 regcache_raw_write (regcache
, regnum
, buf
);
930 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
934 /* Perform a partial register transfer using a read, modify, write
937 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
939 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
942 static enum register_status
943 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
944 int offset
, int len
, void *in
, const void *out
,
945 enum register_status (*read
) (struct regcache
*regcache
,
948 void (*write
) (struct regcache
*regcache
, int regnum
,
949 const gdb_byte
*buf
))
951 struct regcache_descr
*descr
= regcache
->descr
;
952 gdb_byte reg
[MAX_REGISTER_SIZE
];
954 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
955 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
956 /* Something to do? */
957 if (offset
+ len
== 0)
959 /* Read (when needed) ... */
962 || offset
+ len
< descr
->sizeof_register
[regnum
])
964 enum register_status status
;
966 gdb_assert (read
!= NULL
);
967 status
= read (regcache
, regnum
, reg
);
968 if (status
!= REG_VALID
)
973 memcpy (in
, reg
+ offset
, len
);
975 memcpy (reg
+ offset
, out
, len
);
976 /* ... write (when needed). */
979 gdb_assert (write
!= NULL
);
980 write (regcache
, regnum
, reg
);
987 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
988 int offset
, int len
, gdb_byte
*buf
)
990 struct regcache_descr
*descr
= regcache
->descr
;
992 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
993 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
994 regcache_raw_read
, regcache_raw_write
);
998 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
999 int offset
, int len
, const gdb_byte
*buf
)
1001 struct regcache_descr
*descr
= regcache
->descr
;
1003 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
1004 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
1005 regcache_raw_read
, regcache_raw_write
);
1008 enum register_status
1009 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1010 int offset
, int len
, gdb_byte
*buf
)
1012 struct regcache_descr
*descr
= regcache
->descr
;
1014 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
1015 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
1016 regcache_cooked_read
, regcache_cooked_write
);
1020 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1021 int offset
, int len
, const gdb_byte
*buf
)
1023 struct regcache_descr
*descr
= regcache
->descr
;
1025 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
1026 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
1027 regcache_cooked_read
, regcache_cooked_write
);
1030 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1033 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1038 gdb_assert (regcache
!= NULL
);
1039 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1040 gdb_assert (!regcache
->readonly_p
);
1042 regbuf
= register_buffer (regcache
, regnum
);
1043 size
= regcache
->descr
->sizeof_register
[regnum
];
1047 memcpy (regbuf
, buf
, size
);
1048 regcache
->register_status
[regnum
] = REG_VALID
;
1052 /* This memset not strictly necessary, but better than garbage
1053 in case the register value manages to escape somewhere (due
1054 to a bug, no less). */
1055 memset (regbuf
, 0, size
);
1056 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
1060 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1063 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1068 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1069 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1071 regbuf
= register_buffer (regcache
, regnum
);
1072 size
= regcache
->descr
->sizeof_register
[regnum
];
1073 memcpy (buf
, regbuf
, size
);
1076 /* Transfer a single or all registers belonging to a certain register
1077 set to or from a buffer. This is the main worker function for
1078 regcache_supply_regset and regcache_collect_regset. */
1081 regcache_transfer_regset (const struct regset
*regset
,
1082 const struct regcache
*regcache
,
1083 struct regcache
*out_regcache
,
1084 int regnum
, const void *in_buf
,
1085 void *out_buf
, size_t size
)
1087 const struct regcache_map_entry
*map
;
1088 int offs
= 0, count
;
1090 for (map
= regset
->regmap
; (count
= map
->count
) != 0; map
++)
1092 int regno
= map
->regno
;
1093 int slot_size
= map
->size
;
1095 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1096 slot_size
= regcache
->descr
->sizeof_register
[regno
];
1098 if (regno
== REGCACHE_MAP_SKIP
1100 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1101 offs
+= count
* slot_size
;
1103 else if (regnum
== -1)
1104 for (; count
--; regno
++, offs
+= slot_size
)
1106 if (offs
+ slot_size
> size
)
1110 regcache_raw_collect (regcache
, regno
,
1111 (gdb_byte
*) out_buf
+ offs
);
1113 regcache_raw_supply (out_regcache
, regno
, in_buf
1114 ? (const gdb_byte
*) in_buf
+ offs
1119 /* Transfer a single register and return. */
1120 offs
+= (regnum
- regno
) * slot_size
;
1121 if (offs
+ slot_size
> size
)
1125 regcache_raw_collect (regcache
, regnum
,
1126 (gdb_byte
*) out_buf
+ offs
);
1128 regcache_raw_supply (out_regcache
, regnum
, in_buf
1129 ? (const gdb_byte
*) in_buf
+ offs
1136 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1137 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1138 If BUF is NULL, set the register(s) to "unavailable" status. */
1141 regcache_supply_regset (const struct regset
*regset
,
1142 struct regcache
*regcache
,
1143 int regnum
, const void *buf
, size_t size
)
1145 regcache_transfer_regset (regset
, regcache
, regcache
, regnum
,
1149 /* Collect register REGNUM from REGCACHE to BUF, using the register
1150 map in REGSET. If REGNUM is -1, do this for all registers in
1154 regcache_collect_regset (const struct regset
*regset
,
1155 const struct regcache
*regcache
,
1156 int regnum
, void *buf
, size_t size
)
1158 regcache_transfer_regset (regset
, regcache
, NULL
, regnum
,
1163 /* Special handling for register PC. */
1166 regcache_read_pc (struct regcache
*regcache
)
1168 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1172 if (gdbarch_read_pc_p (gdbarch
))
1173 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1174 /* Else use per-frame method on get_current_frame. */
1175 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1179 if (regcache_cooked_read_unsigned (regcache
,
1180 gdbarch_pc_regnum (gdbarch
),
1181 &raw_val
) == REG_UNAVAILABLE
)
1182 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1184 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1187 internal_error (__FILE__
, __LINE__
,
1188 _("regcache_read_pc: Unable to find PC"));
1193 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1195 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1197 if (gdbarch_write_pc_p (gdbarch
))
1198 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1199 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1200 regcache_cooked_write_unsigned (regcache
,
1201 gdbarch_pc_regnum (gdbarch
), pc
);
1203 internal_error (__FILE__
, __LINE__
,
1204 _("regcache_write_pc: Unable to update PC"));
1206 /* Writing the PC (for instance, from "load") invalidates the
1208 reinit_frame_cache ();
1213 reg_flush_command (char *command
, int from_tty
)
1215 /* Force-flush the register cache. */
1216 registers_changed ();
1218 printf_filtered (_("Register cache flushed.\n"));
1221 enum regcache_dump_what
1223 regcache_dump_none
, regcache_dump_raw
,
1224 regcache_dump_cooked
, regcache_dump_groups
,
1225 regcache_dump_remote
1229 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1230 enum regcache_dump_what what_to_dump
)
1232 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1233 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1235 int footnote_nr
= 0;
1236 int footnote_register_size
= 0;
1237 int footnote_register_offset
= 0;
1238 int footnote_register_type_name_null
= 0;
1239 long register_offset
= 0;
1240 gdb_byte buf
[MAX_REGISTER_SIZE
];
1243 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1244 regcache
->descr
->nr_raw_registers
);
1245 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1246 regcache
->descr
->nr_cooked_registers
);
1247 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1248 regcache
->descr
->sizeof_raw_registers
);
1249 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1250 regcache
->descr
->sizeof_raw_register_status
);
1251 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1252 gdbarch_num_regs (gdbarch
));
1253 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1254 gdbarch_num_pseudo_regs (gdbarch
));
1257 gdb_assert (regcache
->descr
->nr_cooked_registers
1258 == (gdbarch_num_regs (gdbarch
)
1259 + gdbarch_num_pseudo_regs (gdbarch
)));
1261 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1265 fprintf_unfiltered (file
, " %-10s", "Name");
1268 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1272 else if (p
[0] == '\0')
1274 fprintf_unfiltered (file
, " %-10s", p
);
1279 fprintf_unfiltered (file
, " %4s", "Nr");
1281 fprintf_unfiltered (file
, " %4d", regnum
);
1283 /* Relative number. */
1285 fprintf_unfiltered (file
, " %4s", "Rel");
1286 else if (regnum
< gdbarch_num_regs (gdbarch
))
1287 fprintf_unfiltered (file
, " %4d", regnum
);
1289 fprintf_unfiltered (file
, " %4d",
1290 (regnum
- gdbarch_num_regs (gdbarch
)));
1294 fprintf_unfiltered (file
, " %6s ", "Offset");
1297 fprintf_unfiltered (file
, " %6ld",
1298 regcache
->descr
->register_offset
[regnum
]);
1299 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1301 && (regcache
->descr
->register_offset
[regnum
]
1302 != (regcache
->descr
->register_offset
[regnum
- 1]
1303 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1306 if (!footnote_register_offset
)
1307 footnote_register_offset
= ++footnote_nr
;
1308 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1311 fprintf_unfiltered (file
, " ");
1312 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1313 + regcache
->descr
->sizeof_register
[regnum
]);
1318 fprintf_unfiltered (file
, " %5s ", "Size");
1320 fprintf_unfiltered (file
, " %5ld",
1321 regcache
->descr
->sizeof_register
[regnum
]);
1331 static const char blt
[] = "builtin_type";
1333 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1338 if (!footnote_register_type_name_null
)
1339 footnote_register_type_name_null
= ++footnote_nr
;
1340 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1341 make_cleanup (xfree
, n
);
1344 /* Chop a leading builtin_type. */
1345 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1348 fprintf_unfiltered (file
, " %-15s", t
);
1351 /* Leading space always present. */
1352 fprintf_unfiltered (file
, " ");
1355 if (what_to_dump
== regcache_dump_raw
)
1358 fprintf_unfiltered (file
, "Raw value");
1359 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1360 fprintf_unfiltered (file
, "<cooked>");
1361 else if (regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
1362 fprintf_unfiltered (file
, "<invalid>");
1363 else if (regcache_register_status (regcache
, regnum
) == REG_UNAVAILABLE
)
1364 fprintf_unfiltered (file
, "<unavailable>");
1367 regcache_raw_read (regcache
, regnum
, buf
);
1368 print_hex_chars (file
, buf
,
1369 regcache
->descr
->sizeof_register
[regnum
],
1370 gdbarch_byte_order (gdbarch
));
1374 /* Value, cooked. */
1375 if (what_to_dump
== regcache_dump_cooked
)
1378 fprintf_unfiltered (file
, "Cooked value");
1381 enum register_status status
;
1383 status
= regcache_cooked_read (regcache
, regnum
, buf
);
1384 if (status
== REG_UNKNOWN
)
1385 fprintf_unfiltered (file
, "<invalid>");
1386 else if (status
== REG_UNAVAILABLE
)
1387 fprintf_unfiltered (file
, "<unavailable>");
1389 print_hex_chars (file
, buf
,
1390 regcache
->descr
->sizeof_register
[regnum
],
1391 gdbarch_byte_order (gdbarch
));
1395 /* Group members. */
1396 if (what_to_dump
== regcache_dump_groups
)
1399 fprintf_unfiltered (file
, "Groups");
1402 const char *sep
= "";
1403 struct reggroup
*group
;
1405 for (group
= reggroup_next (gdbarch
, NULL
);
1407 group
= reggroup_next (gdbarch
, group
))
1409 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1411 fprintf_unfiltered (file
,
1412 "%s%s", sep
, reggroup_name (group
));
1419 /* Remote packet configuration. */
1420 if (what_to_dump
== regcache_dump_remote
)
1424 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1426 else if (regnum
< regcache
->descr
->nr_raw_registers
)
1430 if (remote_register_number_and_offset (get_regcache_arch (regcache
), regnum
,
1432 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1436 fprintf_unfiltered (file
, "\n");
1439 if (footnote_register_size
)
1440 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1441 footnote_register_size
);
1442 if (footnote_register_offset
)
1443 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1444 footnote_register_offset
);
1445 if (footnote_register_type_name_null
)
1446 fprintf_unfiltered (file
,
1447 "*%d: Register type's name NULL.\n",
1448 footnote_register_type_name_null
);
1449 do_cleanups (cleanups
);
1453 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1456 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1459 struct cleanup
*cleanups
;
1460 struct ui_file
*file
= gdb_fopen (args
, "w");
1463 perror_with_name (_("maintenance print architecture"));
1464 cleanups
= make_cleanup_ui_file_delete (file
);
1465 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1466 do_cleanups (cleanups
);
1471 maintenance_print_registers (char *args
, int from_tty
)
1473 regcache_print (args
, regcache_dump_none
);
1477 maintenance_print_raw_registers (char *args
, int from_tty
)
1479 regcache_print (args
, regcache_dump_raw
);
1483 maintenance_print_cooked_registers (char *args
, int from_tty
)
1485 regcache_print (args
, regcache_dump_cooked
);
1489 maintenance_print_register_groups (char *args
, int from_tty
)
1491 regcache_print (args
, regcache_dump_groups
);
1495 maintenance_print_remote_registers (char *args
, int from_tty
)
1497 regcache_print (args
, regcache_dump_remote
);
1500 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1503 _initialize_regcache (void)
1505 regcache_descr_handle
1506 = gdbarch_data_register_post_init (init_regcache_descr
);
1508 observer_attach_target_changed (regcache_observer_target_changed
);
1509 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1511 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1512 _("Force gdb to flush its register cache (maintainer command)"));
1514 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1515 _("Print the internal register configuration.\n"
1516 "Takes an optional file parameter."), &maintenanceprintlist
);
1517 add_cmd ("raw-registers", class_maintenance
,
1518 maintenance_print_raw_registers
,
1519 _("Print the internal register configuration "
1520 "including raw values.\n"
1521 "Takes an optional file parameter."), &maintenanceprintlist
);
1522 add_cmd ("cooked-registers", class_maintenance
,
1523 maintenance_print_cooked_registers
,
1524 _("Print the internal register configuration "
1525 "including cooked values.\n"
1526 "Takes an optional file parameter."), &maintenanceprintlist
);
1527 add_cmd ("register-groups", class_maintenance
,
1528 maintenance_print_register_groups
,
1529 _("Print the internal register configuration "
1530 "including each register's group.\n"
1531 "Takes an optional file parameter."),
1532 &maintenanceprintlist
);
1533 add_cmd ("remote-registers", class_maintenance
,
1534 maintenance_print_remote_registers
, _("\
1535 Print the internal register configuration including each register's\n\
1536 remote register number and buffer offset in the g/G packets.\n\
1537 Takes an optional file parameter."),
1538 &maintenanceprintlist
);