1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002, 2004 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
29 #include "reggroups.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
32 #include "gdbcmd.h" /* For maintenanceprintlist. */
38 * Here is the actual register cache.
41 /* Per-architecture object describing the layout of a register cache.
42 Computed once when the architecture is created */
44 struct gdbarch_data
*regcache_descr_handle
;
48 /* The architecture this descriptor belongs to. */
49 struct gdbarch
*gdbarch
;
51 /* The raw register cache. Each raw (or hard) register is supplied
52 by the target interface. The raw cache should not contain
53 redundant information - if the PC is constructed from two
54 registers then those regigisters and not the PC lives in the raw
57 long sizeof_raw_registers
;
58 long sizeof_raw_register_valid_p
;
60 /* The cooked register space. Each cooked register in the range
61 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
62 register. The remaining [NR_RAW_REGISTERS
63 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
64 both raw registers and memory by the architecture methods
65 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
66 int nr_cooked_registers
;
67 long sizeof_cooked_registers
;
68 long sizeof_cooked_register_valid_p
;
70 /* Offset and size (in 8 bit bytes), of reach register in the
71 register cache. All registers (including those in the range
72 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
73 Assigning all registers an offset makes it possible to keep
74 legacy code, such as that found in read_register_bytes() and
75 write_register_bytes() working. */
76 long *register_offset
;
77 long *sizeof_register
;
79 /* Cached table containing the type of each register. */
80 struct type
**register_type
;
84 init_regcache_descr (struct gdbarch
*gdbarch
)
87 struct regcache_descr
*descr
;
88 gdb_assert (gdbarch
!= NULL
);
90 /* Create an initial, zero filled, table. */
91 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
92 descr
->gdbarch
= gdbarch
;
94 /* Total size of the register space. The raw registers are mapped
95 directly onto the raw register cache while the pseudo's are
96 either mapped onto raw-registers or memory. */
97 descr
->nr_cooked_registers
= NUM_REGS
+ NUM_PSEUDO_REGS
;
98 descr
->sizeof_cooked_register_valid_p
= NUM_REGS
+ NUM_PSEUDO_REGS
;
100 /* Fill in a table of register types. */
102 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, struct type
*);
103 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
104 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
106 /* Construct a strictly RAW register cache. Don't allow pseudo's
107 into the register cache. */
108 descr
->nr_raw_registers
= NUM_REGS
;
110 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
111 array. This pretects GDB from erant code that accesses elements
112 of the global register_valid_p[] array in the range [NUM_REGS
113 .. NUM_REGS + NUM_PSEUDO_REGS). */
114 descr
->sizeof_raw_register_valid_p
= descr
->sizeof_cooked_register_valid_p
;
116 /* Lay out the register cache.
118 NOTE: cagney/2002-05-22: Only register_type() is used when
119 constructing the register cache. It is assumed that the
120 register's raw size, virtual size and type length are all the
125 descr
->sizeof_register
126 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
127 descr
->register_offset
128 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
129 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
131 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
132 descr
->register_offset
[i
] = offset
;
133 offset
+= descr
->sizeof_register
[i
];
134 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
136 /* Set the real size of the register cache buffer. */
137 descr
->sizeof_cooked_registers
= offset
;
140 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
141 the raw registers. Unfortunately some code still accesses the
142 register array directly using the global registers[]. Until that
143 code has been purged, play safe and over allocating the register
145 descr
->sizeof_raw_registers
= descr
->sizeof_cooked_registers
;
150 static struct regcache_descr
*
151 regcache_descr (struct gdbarch
*gdbarch
)
153 return gdbarch_data (gdbarch
, regcache_descr_handle
);
156 /* Utility functions returning useful register attributes stored in
157 the regcache descr. */
160 register_type (struct gdbarch
*gdbarch
, int regnum
)
162 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
163 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
164 return descr
->register_type
[regnum
];
167 /* Utility functions returning useful register attributes stored in
168 the regcache descr. */
171 register_size (struct gdbarch
*gdbarch
, int regnum
)
173 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
175 gdb_assert (regnum
>= 0 && regnum
< (NUM_REGS
+ NUM_PSEUDO_REGS
));
176 size
= descr
->sizeof_register
[regnum
];
180 /* The register cache for storing raw register values. */
184 struct regcache_descr
*descr
;
185 /* The register buffers. A read-only register cache can hold the
186 full [0 .. NUM_REGS + NUM_PSEUDO_REGS) while a read/write
187 register cache can only hold [0 .. NUM_REGS). */
189 char *register_valid_p
;
190 /* Is this a read-only cache? A read-only cache is used for saving
191 the target's register state (e.g, across an inferior function
192 call or just before forcing a function return). A read-only
193 cache can only be updated via the methods regcache_dup() and
194 regcache_cpy(). The actual contents are determined by the
195 reggroup_save and reggroup_restore methods. */
200 regcache_xmalloc (struct gdbarch
*gdbarch
)
202 struct regcache_descr
*descr
;
203 struct regcache
*regcache
;
204 gdb_assert (gdbarch
!= NULL
);
205 descr
= regcache_descr (gdbarch
);
206 regcache
= XMALLOC (struct regcache
);
207 regcache
->descr
= descr
;
209 = XCALLOC (descr
->sizeof_raw_registers
, char);
210 regcache
->register_valid_p
211 = XCALLOC (descr
->sizeof_raw_register_valid_p
, char);
212 regcache
->readonly_p
= 1;
217 regcache_xfree (struct regcache
*regcache
)
219 if (regcache
== NULL
)
221 xfree (regcache
->registers
);
222 xfree (regcache
->register_valid_p
);
227 do_regcache_xfree (void *data
)
229 regcache_xfree (data
);
233 make_cleanup_regcache_xfree (struct regcache
*regcache
)
235 return make_cleanup (do_regcache_xfree
, regcache
);
238 /* Return REGCACHE's architecture. */
241 get_regcache_arch (const struct regcache
*regcache
)
243 return regcache
->descr
->gdbarch
;
246 /* Return a pointer to register REGNUM's buffer cache. */
249 register_buffer (const struct regcache
*regcache
, int regnum
)
251 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
255 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
258 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
259 char buf
[MAX_REGISTER_SIZE
];
261 /* The DST should be `read-only', if it wasn't then the save would
262 end up trying to write the register values back out to the
264 gdb_assert (dst
->readonly_p
);
265 /* Clear the dest. */
266 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
267 memset (dst
->register_valid_p
, 0, dst
->descr
->sizeof_cooked_register_valid_p
);
268 /* Copy over any registers (identified by their membership in the
269 save_reggroup) and mark them as valid. The full [0 .. NUM_REGS +
270 NUM_PSEUDO_REGS) range is checked since some architectures need
271 to save/restore `cooked' registers that live in memory. */
272 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
274 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
276 int valid
= cooked_read (src
, regnum
, buf
);
279 memcpy (register_buffer (dst
, regnum
), buf
,
280 register_size (gdbarch
, regnum
));
281 dst
->register_valid_p
[regnum
] = 1;
288 regcache_restore (struct regcache
*dst
,
289 regcache_cooked_read_ftype
*cooked_read
,
292 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
293 char buf
[MAX_REGISTER_SIZE
];
295 /* The dst had better not be read-only. If it is, the `restore'
296 doesn't make much sense. */
297 gdb_assert (!dst
->readonly_p
);
298 /* Copy over any registers, being careful to only restore those that
299 were both saved and need to be restored. The full [0 .. NUM_REGS
300 + NUM_PSEUDO_REGS) range is checked since some architectures need
301 to save/restore `cooked' registers that live in memory. */
302 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
304 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
306 int valid
= cooked_read (src
, regnum
, buf
);
308 regcache_cooked_write (dst
, regnum
, buf
);
314 do_cooked_read (void *src
, int regnum
, void *buf
)
316 struct regcache
*regcache
= src
;
317 if (!regcache
->register_valid_p
[regnum
] && regcache
->readonly_p
)
318 /* Don't even think about fetching a register from a read-only
319 cache when the register isn't yet valid. There isn't a target
320 from which the register value can be fetched. */
322 regcache_cooked_read (regcache
, regnum
, buf
);
328 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
332 gdb_assert (src
!= NULL
&& dst
!= NULL
);
333 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
334 gdb_assert (src
!= dst
);
335 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
336 if (!src
->readonly_p
)
337 regcache_save (dst
, do_cooked_read
, src
);
338 else if (!dst
->readonly_p
)
339 regcache_restore (dst
, do_cooked_read
, src
);
341 regcache_cpy_no_passthrough (dst
, src
);
345 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
348 gdb_assert (src
!= NULL
&& dst
!= NULL
);
349 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
350 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
351 move of data into the current_regcache(). Doing this would be
352 silly - it would mean that valid_p would be completely invalid. */
353 gdb_assert (dst
!= current_regcache
);
354 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
355 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
356 dst
->descr
->sizeof_raw_register_valid_p
);
360 regcache_dup (struct regcache
*src
)
362 struct regcache
*newbuf
;
363 gdb_assert (current_regcache
!= NULL
);
364 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
365 regcache_cpy (newbuf
, src
);
370 regcache_dup_no_passthrough (struct regcache
*src
)
372 struct regcache
*newbuf
;
373 gdb_assert (current_regcache
!= NULL
);
374 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
375 regcache_cpy_no_passthrough (newbuf
, src
);
380 regcache_valid_p (struct regcache
*regcache
, int regnum
)
382 gdb_assert (regcache
!= NULL
);
383 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
384 return regcache
->register_valid_p
[regnum
];
388 deprecated_grub_regcache_for_registers (struct regcache
*regcache
)
390 return regcache
->registers
;
393 /* Global structure containing the current regcache. */
394 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
395 deprecated_register_valid[] currently point into this structure. */
396 struct regcache
*current_regcache
;
398 /* NOTE: this is a write-through cache. There is no "dirty" bit for
399 recording if the register values have been changed (eg. by the
400 user). Therefore all registers must be written back to the
401 target when appropriate. */
403 /* REGISTERS contains the cached register values (in target byte order). */
405 char *deprecated_registers
;
407 /* DEPRECATED_REGISTER_VALID is 0 if the register needs to be fetched,
408 1 if it has been fetched, and
409 -1 if the register value was not available.
411 "Not available" indicates that the target is not not able to supply
412 the register at this state. The register may become available at a
413 later time (after the next resume). This often occures when GDB is
414 manipulating a target that contains only a snapshot of the entire
415 system being debugged - some of the registers in such a system may
416 not have been saved. */
418 signed char *deprecated_register_valid
;
420 /* The thread/process associated with the current set of registers. */
422 static ptid_t registers_ptid
;
430 Returns 0 if the value is not in the cache (needs fetch).
431 >0 if the value is in the cache.
432 <0 if the value is permanently unavailable (don't ask again). */
435 register_cached (int regnum
)
437 return deprecated_register_valid
[regnum
];
440 /* Record that REGNUM's value is cached if STATE is >0, uncached but
441 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
444 set_register_cached (int regnum
, int state
)
446 gdb_assert (regnum
>= 0);
447 gdb_assert (regnum
< current_regcache
->descr
->nr_raw_registers
);
448 current_regcache
->register_valid_p
[regnum
] = state
;
451 /* Observer for the target_changed event. */
454 regcache_observer_target_changed (struct target_ops
*target
)
456 registers_changed ();
459 /* Low level examining and depositing of registers.
461 The caller is responsible for making sure that the inferior is
462 stopped before calling the fetching routines, or it will get
463 garbage. (a change from GDB version 3, in which the caller got the
464 value from the last stop). */
466 /* REGISTERS_CHANGED ()
468 Indicate that registers may have changed, so invalidate the cache. */
471 registers_changed (void)
475 registers_ptid
= pid_to_ptid (-1);
477 /* Force cleanup of any alloca areas if using C alloca instead of
478 a builtin alloca. This particular call is used to clean up
479 areas allocated by low level target code which may build up
480 during lengthy interactions between gdb and the target before
481 gdb gives control to the user (ie watchpoints). */
484 for (i
= 0; i
< current_regcache
->descr
->nr_raw_registers
; i
++)
485 set_register_cached (i
, 0);
487 if (deprecated_registers_changed_hook
)
488 deprecated_registers_changed_hook ();
491 /* DEPRECATED_REGISTERS_FETCHED ()
493 Indicate that all registers have been fetched, so mark them all valid. */
495 /* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
496 code was blatting the registers[] array and then calling this.
497 Since targets should only be using regcache_raw_supply() the need for
498 this function/hack is eliminated. */
501 deprecated_registers_fetched (void)
505 for (i
= 0; i
< NUM_REGS
; i
++)
506 set_register_cached (i
, 1);
507 /* Do not assume that the pseudo-regs have also been fetched.
508 Fetching all real regs NEVER accounts for pseudo-regs. */
511 /* deprecated_read_register_bytes and deprecated_write_register_bytes
512 are generally a *BAD* idea. They are inefficient because they need
513 to check for partial updates, which can only be done by scanning
514 through all of the registers and seeing if the bytes that are being
515 read/written fall inside of an invalid register. [The main reason
516 this is necessary is that register sizes can vary, so a simple
517 index won't suffice.] It is far better to call read_register_gen
518 and write_register_gen if you want to get at the raw register
519 contents, as it only takes a regnum as an argument, and therefore
520 can't do a partial register update.
522 Prior to the recent fixes to check for partial updates, both read
523 and deprecated_write_register_bytes always checked to see if any
524 registers were stale, and then called target_fetch_registers (-1)
525 to update the whole set. This caused really slowed things down for
528 /* Copy INLEN bytes of consecutive data from registers
529 starting with the INREGBYTE'th byte of register data
530 into memory at MYADDR. */
533 deprecated_read_register_bytes (int in_start
, char *in_buf
, int in_len
)
535 int in_end
= in_start
+ in_len
;
537 char reg_buf
[MAX_REGISTER_SIZE
];
539 /* See if we are trying to read bytes from out-of-date registers. If so,
540 update just those registers. */
542 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
551 reg_start
= DEPRECATED_REGISTER_BYTE (regnum
);
552 reg_len
= DEPRECATED_REGISTER_RAW_SIZE (regnum
);
553 reg_end
= reg_start
+ reg_len
;
555 if (reg_end
<= in_start
|| in_end
<= reg_start
)
556 /* The range the user wants to read doesn't overlap with regnum. */
559 if (REGISTER_NAME (regnum
) != NULL
&& *REGISTER_NAME (regnum
) != '\0')
560 /* Force the cache to fetch the entire register. */
561 deprecated_read_register_gen (regnum
, reg_buf
);
563 /* Legacy note: even though this register is ``invalid'' we
564 still need to return something. It would appear that some
565 code relies on apparent gaps in the register array also
567 /* FIXME: cagney/2001-08-18: This is just silly. It defeats
568 the entire register read/write flow of control. Must
569 resist temptation to return 0xdeadbeef. */
570 memcpy (reg_buf
, &deprecated_registers
[reg_start
], reg_len
);
572 /* Legacy note: This function, for some reason, allows a NULL
573 input buffer. If the buffer is NULL, the registers are still
574 fetched, just the final transfer is skipped. */
578 /* start = max (reg_start, in_start) */
579 if (reg_start
> in_start
)
584 /* end = min (reg_end, in_end) */
585 if (reg_end
< in_end
)
590 /* Transfer just the bytes common to both IN_BUF and REG_BUF */
591 for (byte
= start
; byte
< end
; byte
++)
593 in_buf
[byte
- in_start
] = reg_buf
[byte
- reg_start
];
599 regcache_raw_read (struct regcache
*regcache
, int regnum
, void *buf
)
601 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
602 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
603 /* Make certain that the register cache is up-to-date with respect
604 to the current thread. This switching shouldn't be necessary
605 only there is still only one target side register cache. Sigh!
606 On the bright side, at least there is a regcache object. */
607 if (!regcache
->readonly_p
)
609 gdb_assert (regcache
== current_regcache
);
610 if (! ptid_equal (registers_ptid
, inferior_ptid
))
612 registers_changed ();
613 registers_ptid
= inferior_ptid
;
615 if (!register_cached (regnum
))
616 target_fetch_registers (regnum
);
618 /* Copy the value directly into the register cache. */
619 memcpy (buf
, register_buffer (regcache
, regnum
),
620 regcache
->descr
->sizeof_register
[regnum
]);
624 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
627 gdb_assert (regcache
!= NULL
);
628 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
629 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
630 regcache_raw_read (regcache
, regnum
, buf
);
631 (*val
) = extract_signed_integer (buf
,
632 regcache
->descr
->sizeof_register
[regnum
]);
636 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
640 gdb_assert (regcache
!= NULL
);
641 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
642 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
643 regcache_raw_read (regcache
, regnum
, buf
);
644 (*val
) = extract_unsigned_integer (buf
,
645 regcache
->descr
->sizeof_register
[regnum
]);
649 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
652 gdb_assert (regcache
!= NULL
);
653 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
654 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
655 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
656 regcache_raw_write (regcache
, regnum
, buf
);
660 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
664 gdb_assert (regcache
!= NULL
);
665 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
666 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
667 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
668 regcache_raw_write (regcache
, regnum
, buf
);
672 deprecated_read_register_gen (int regnum
, char *buf
)
674 gdb_assert (current_regcache
!= NULL
);
675 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
676 regcache_cooked_read (current_regcache
, regnum
, buf
);
680 regcache_cooked_read (struct regcache
*regcache
, int regnum
, void *buf
)
682 gdb_assert (regnum
>= 0);
683 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
684 if (regnum
< regcache
->descr
->nr_raw_registers
)
685 regcache_raw_read (regcache
, regnum
, buf
);
686 else if (regcache
->readonly_p
687 && regnum
< regcache
->descr
->nr_cooked_registers
688 && regcache
->register_valid_p
[regnum
])
689 /* Read-only register cache, perhaps the cooked value was cached? */
690 memcpy (buf
, register_buffer (regcache
, regnum
),
691 regcache
->descr
->sizeof_register
[regnum
]);
693 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
698 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
702 gdb_assert (regcache
!= NULL
);
703 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
704 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
705 regcache_cooked_read (regcache
, regnum
, buf
);
706 (*val
) = extract_signed_integer (buf
,
707 regcache
->descr
->sizeof_register
[regnum
]);
711 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
715 gdb_assert (regcache
!= NULL
);
716 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
717 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
718 regcache_cooked_read (regcache
, regnum
, buf
);
719 (*val
) = extract_unsigned_integer (buf
,
720 regcache
->descr
->sizeof_register
[regnum
]);
724 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
728 gdb_assert (regcache
!= NULL
);
729 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
730 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
731 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
732 regcache_cooked_write (regcache
, regnum
, buf
);
736 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
740 gdb_assert (regcache
!= NULL
);
741 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
742 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
743 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
744 regcache_cooked_write (regcache
, regnum
, buf
);
748 regcache_raw_write (struct regcache
*regcache
, int regnum
, const void *buf
)
750 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
751 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
752 gdb_assert (!regcache
->readonly_p
);
754 /* On the sparc, writing %g0 is a no-op, so we don't even want to
755 change the registers array if something writes to this register. */
756 if (CANNOT_STORE_REGISTER (regnum
))
759 /* Make certain that the correct cache is selected. */
760 gdb_assert (regcache
== current_regcache
);
761 if (! ptid_equal (registers_ptid
, inferior_ptid
))
763 registers_changed ();
764 registers_ptid
= inferior_ptid
;
767 /* If we have a valid copy of the register, and new value == old
768 value, then don't bother doing the actual store. */
769 if (regcache_valid_p (regcache
, regnum
)
770 && (memcmp (register_buffer (regcache
, regnum
), buf
,
771 regcache
->descr
->sizeof_register
[regnum
]) == 0))
774 target_prepare_to_store ();
775 memcpy (register_buffer (regcache
, regnum
), buf
,
776 regcache
->descr
->sizeof_register
[regnum
]);
777 regcache
->register_valid_p
[regnum
] = 1;
778 target_store_registers (regnum
);
782 deprecated_write_register_gen (int regnum
, char *buf
)
784 gdb_assert (current_regcache
!= NULL
);
785 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
786 regcache_cooked_write (current_regcache
, regnum
, buf
);
790 regcache_cooked_write (struct regcache
*regcache
, int regnum
, const void *buf
)
792 gdb_assert (regnum
>= 0);
793 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
794 if (regnum
< regcache
->descr
->nr_raw_registers
)
795 regcache_raw_write (regcache
, regnum
, buf
);
797 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
801 /* Copy INLEN bytes of consecutive data from memory at MYADDR
802 into registers starting with the MYREGSTART'th byte of register data. */
805 deprecated_write_register_bytes (int myregstart
, char *myaddr
, int inlen
)
807 int myregend
= myregstart
+ inlen
;
810 target_prepare_to_store ();
812 /* Scan through the registers updating any that are covered by the
813 range myregstart<=>myregend using write_register_gen, which does
814 nice things like handling threads, and avoiding updates when the
815 new and old contents are the same. */
817 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
819 int regstart
, regend
;
821 regstart
= DEPRECATED_REGISTER_BYTE (regnum
);
822 regend
= regstart
+ DEPRECATED_REGISTER_RAW_SIZE (regnum
);
824 /* Is this register completely outside the range the user is writing? */
825 if (myregend
<= regstart
|| regend
<= myregstart
)
828 /* Is this register completely within the range the user is writing? */
829 else if (myregstart
<= regstart
&& regend
<= myregend
)
830 deprecated_write_register_gen (regnum
, myaddr
+ (regstart
- myregstart
));
832 /* The register partially overlaps the range being written. */
835 char regbuf
[MAX_REGISTER_SIZE
];
836 /* What's the overlap between this register's bytes and
837 those the caller wants to write? */
838 int overlapstart
= max (regstart
, myregstart
);
839 int overlapend
= min (regend
, myregend
);
841 /* We may be doing a partial update of an invalid register.
842 Update it from the target before scribbling on it. */
843 deprecated_read_register_gen (regnum
, regbuf
);
845 memcpy (&deprecated_registers
[overlapstart
],
846 myaddr
+ (overlapstart
- myregstart
),
847 overlapend
- overlapstart
);
849 target_store_registers (regnum
);
854 /* Perform a partial register transfer using a read, modify, write
857 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
859 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
863 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
864 int offset
, int len
, void *in
, const void *out
,
865 regcache_read_ftype
*read
, regcache_write_ftype
*write
)
867 struct regcache_descr
*descr
= regcache
->descr
;
868 bfd_byte reg
[MAX_REGISTER_SIZE
];
869 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
870 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
871 /* Something to do? */
872 if (offset
+ len
== 0)
874 /* Read (when needed) ... */
877 || offset
+ len
< descr
->sizeof_register
[regnum
])
879 gdb_assert (read
!= NULL
);
880 read (regcache
, regnum
, reg
);
884 memcpy (in
, reg
+ offset
, len
);
886 memcpy (reg
+ offset
, out
, len
);
887 /* ... write (when needed). */
890 gdb_assert (write
!= NULL
);
891 write (regcache
, regnum
, reg
);
896 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
897 int offset
, int len
, void *buf
)
899 struct regcache_descr
*descr
= regcache
->descr
;
900 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
901 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
902 regcache_raw_read
, regcache_raw_write
);
906 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
907 int offset
, int len
, const void *buf
)
909 struct regcache_descr
*descr
= regcache
->descr
;
910 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
911 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
912 regcache_raw_read
, regcache_raw_write
);
916 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
917 int offset
, int len
, void *buf
)
919 struct regcache_descr
*descr
= regcache
->descr
;
920 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
921 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
922 regcache_cooked_read
, regcache_cooked_write
);
926 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
927 int offset
, int len
, const void *buf
)
929 struct regcache_descr
*descr
= regcache
->descr
;
930 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
931 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
932 regcache_cooked_read
, regcache_cooked_write
);
935 /* Hack to keep code that view the register buffer as raw bytes
939 register_offset_hack (struct gdbarch
*gdbarch
, int regnum
)
941 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
942 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
943 return descr
->register_offset
[regnum
];
946 /* Return the contents of register REGNUM as an unsigned integer. */
949 read_register (int regnum
)
951 char *buf
= alloca (DEPRECATED_REGISTER_RAW_SIZE (regnum
));
952 deprecated_read_register_gen (regnum
, buf
);
953 return (extract_unsigned_integer (buf
, DEPRECATED_REGISTER_RAW_SIZE (regnum
)));
957 read_register_pid (int regnum
, ptid_t ptid
)
963 if (ptid_equal (ptid
, inferior_ptid
))
964 return read_register (regnum
);
966 save_ptid
= inferior_ptid
;
968 inferior_ptid
= ptid
;
970 retval
= read_register (regnum
);
972 inferior_ptid
= save_ptid
;
977 /* Store VALUE into the raw contents of register number REGNUM. */
980 write_register (int regnum
, LONGEST val
)
984 size
= DEPRECATED_REGISTER_RAW_SIZE (regnum
);
986 store_signed_integer (buf
, size
, (LONGEST
) val
);
987 deprecated_write_register_gen (regnum
, buf
);
991 write_register_pid (int regnum
, CORE_ADDR val
, ptid_t ptid
)
995 if (ptid_equal (ptid
, inferior_ptid
))
997 write_register (regnum
, val
);
1001 save_ptid
= inferior_ptid
;
1003 inferior_ptid
= ptid
;
1005 write_register (regnum
, val
);
1007 inferior_ptid
= save_ptid
;
1010 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1013 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1018 gdb_assert (regcache
!= NULL
);
1019 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1020 gdb_assert (!regcache
->readonly_p
);
1022 /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
1023 CURRENT_REGCACHE specially here. */
1024 if (regcache
== current_regcache
1025 && !ptid_equal (registers_ptid
, inferior_ptid
))
1027 registers_changed ();
1028 registers_ptid
= inferior_ptid
;
1031 regbuf
= register_buffer (regcache
, regnum
);
1032 size
= regcache
->descr
->sizeof_register
[regnum
];
1035 memcpy (regbuf
, buf
, size
);
1037 memset (regbuf
, 0, size
);
1039 /* Mark the register as cached. */
1040 regcache
->register_valid_p
[regnum
] = 1;
1043 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1046 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1051 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1052 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
1054 regbuf
= register_buffer (regcache
, regnum
);
1055 size
= regcache
->descr
->sizeof_register
[regnum
];
1056 memcpy (buf
, regbuf
, size
);
1060 /* read_pc, write_pc, read_sp, deprecated_read_fp, etc. Special
1061 handling for registers PC, SP, and FP. */
1063 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc(),
1064 read_sp(), and deprecated_read_fp(), will eventually be replaced by
1065 per-frame methods. Instead of relying on the global INFERIOR_PTID,
1066 they will use the contextual information provided by the FRAME.
1067 These functions do not belong in the register cache. */
1069 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
1070 write_pc_pid(), write_pc(), and deprecated_read_fp(), all need to
1071 be replaced by something that does not rely on global state. But
1075 read_pc_pid (ptid_t ptid
)
1077 ptid_t saved_inferior_ptid
;
1080 /* In case ptid != inferior_ptid. */
1081 saved_inferior_ptid
= inferior_ptid
;
1082 inferior_ptid
= ptid
;
1084 if (TARGET_READ_PC_P ())
1085 pc_val
= TARGET_READ_PC (ptid
);
1086 /* Else use per-frame method on get_current_frame. */
1087 else if (PC_REGNUM
>= 0)
1089 CORE_ADDR raw_val
= read_register_pid (PC_REGNUM
, ptid
);
1090 pc_val
= ADDR_BITS_REMOVE (raw_val
);
1093 internal_error (__FILE__
, __LINE__
, "read_pc_pid: Unable to find PC");
1095 inferior_ptid
= saved_inferior_ptid
;
1102 return read_pc_pid (inferior_ptid
);
1106 generic_target_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1109 write_register_pid (PC_REGNUM
, pc
, ptid
);
1111 internal_error (__FILE__
, __LINE__
,
1112 "generic_target_write_pc");
1116 write_pc_pid (CORE_ADDR pc
, ptid_t ptid
)
1118 ptid_t saved_inferior_ptid
;
1120 /* In case ptid != inferior_ptid. */
1121 saved_inferior_ptid
= inferior_ptid
;
1122 inferior_ptid
= ptid
;
1124 TARGET_WRITE_PC (pc
, ptid
);
1126 inferior_ptid
= saved_inferior_ptid
;
1130 write_pc (CORE_ADDR pc
)
1132 write_pc_pid (pc
, inferior_ptid
);
1135 /* Cope with strage ways of getting to the stack and frame pointers */
1140 if (TARGET_READ_SP_P ())
1141 return TARGET_READ_SP ();
1142 else if (gdbarch_unwind_sp_p (current_gdbarch
))
1143 return get_frame_sp (get_current_frame ());
1144 else if (SP_REGNUM
>= 0)
1145 /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
1146 about the architecture so put it at the end. */
1147 return read_register (SP_REGNUM
);
1148 internal_error (__FILE__
, __LINE__
, "read_sp: Unable to find SP");
1152 deprecated_write_sp (CORE_ADDR val
)
1154 gdb_assert (SP_REGNUM
>= 0);
1155 write_register (SP_REGNUM
, val
);
1159 deprecated_read_fp (void)
1161 if (DEPRECATED_TARGET_READ_FP_P ())
1162 return DEPRECATED_TARGET_READ_FP ();
1163 else if (DEPRECATED_FP_REGNUM
>= 0)
1164 return read_register (DEPRECATED_FP_REGNUM
);
1166 internal_error (__FILE__
, __LINE__
, "deprecated_read_fp");
1170 reg_flush_command (char *command
, int from_tty
)
1172 /* Force-flush the register cache. */
1173 registers_changed ();
1175 printf_filtered ("Register cache flushed.\n");
1179 build_regcache (void)
1181 current_regcache
= regcache_xmalloc (current_gdbarch
);
1182 current_regcache
->readonly_p
= 0;
1183 deprecated_registers
= deprecated_grub_regcache_for_registers (current_regcache
);
1184 deprecated_register_valid
= current_regcache
->register_valid_p
;
1188 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
1189 const unsigned char *buf
, long len
)
1194 case BFD_ENDIAN_BIG
:
1195 for (i
= 0; i
< len
; i
++)
1196 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1198 case BFD_ENDIAN_LITTLE
:
1199 for (i
= len
- 1; i
>= 0; i
--)
1200 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1203 internal_error (__FILE__
, __LINE__
, "Bad switch");
1207 enum regcache_dump_what
1209 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
1213 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1214 enum regcache_dump_what what_to_dump
)
1216 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1217 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1219 int footnote_nr
= 0;
1220 int footnote_register_size
= 0;
1221 int footnote_register_offset
= 0;
1222 int footnote_register_type_name_null
= 0;
1223 long register_offset
= 0;
1224 unsigned char buf
[MAX_REGISTER_SIZE
];
1227 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1228 regcache
->descr
->nr_raw_registers
);
1229 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1230 regcache
->descr
->nr_cooked_registers
);
1231 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1232 regcache
->descr
->sizeof_raw_registers
);
1233 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
1234 regcache
->descr
->sizeof_raw_register_valid_p
);
1235 fprintf_unfiltered (file
, "NUM_REGS %d\n", NUM_REGS
);
1236 fprintf_unfiltered (file
, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS
);
1239 gdb_assert (regcache
->descr
->nr_cooked_registers
1240 == (NUM_REGS
+ NUM_PSEUDO_REGS
));
1242 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1246 fprintf_unfiltered (file
, " %-10s", "Name");
1249 const char *p
= REGISTER_NAME (regnum
);
1252 else if (p
[0] == '\0')
1254 fprintf_unfiltered (file
, " %-10s", p
);
1259 fprintf_unfiltered (file
, " %4s", "Nr");
1261 fprintf_unfiltered (file
, " %4d", regnum
);
1263 /* Relative number. */
1265 fprintf_unfiltered (file
, " %4s", "Rel");
1266 else if (regnum
< NUM_REGS
)
1267 fprintf_unfiltered (file
, " %4d", regnum
);
1269 fprintf_unfiltered (file
, " %4d", (regnum
- NUM_REGS
));
1273 fprintf_unfiltered (file
, " %6s ", "Offset");
1276 fprintf_unfiltered (file
, " %6ld",
1277 regcache
->descr
->register_offset
[regnum
]);
1278 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1279 || register_offset
!= DEPRECATED_REGISTER_BYTE (regnum
)
1281 && (regcache
->descr
->register_offset
[regnum
]
1282 != (regcache
->descr
->register_offset
[regnum
- 1]
1283 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1286 if (!footnote_register_offset
)
1287 footnote_register_offset
= ++footnote_nr
;
1288 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1291 fprintf_unfiltered (file
, " ");
1292 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1293 + regcache
->descr
->sizeof_register
[regnum
]);
1298 fprintf_unfiltered (file
, " %5s ", "Size");
1300 fprintf_unfiltered (file
, " %5ld",
1301 regcache
->descr
->sizeof_register
[regnum
]);
1310 static const char blt
[] = "builtin_type";
1311 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1315 if (!footnote_register_type_name_null
)
1316 footnote_register_type_name_null
= ++footnote_nr
;
1317 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1318 make_cleanup (xfree
, n
);
1321 /* Chop a leading builtin_type. */
1322 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1325 fprintf_unfiltered (file
, " %-15s", t
);
1328 /* Leading space always present. */
1329 fprintf_unfiltered (file
, " ");
1332 if (what_to_dump
== regcache_dump_raw
)
1335 fprintf_unfiltered (file
, "Raw value");
1336 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1337 fprintf_unfiltered (file
, "<cooked>");
1338 else if (!regcache_valid_p (regcache
, regnum
))
1339 fprintf_unfiltered (file
, "<invalid>");
1342 regcache_raw_read (regcache
, regnum
, buf
);
1343 fprintf_unfiltered (file
, "0x");
1344 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1345 regcache
->descr
->sizeof_register
[regnum
]);
1349 /* Value, cooked. */
1350 if (what_to_dump
== regcache_dump_cooked
)
1353 fprintf_unfiltered (file
, "Cooked value");
1356 regcache_cooked_read (regcache
, regnum
, buf
);
1357 fprintf_unfiltered (file
, "0x");
1358 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1359 regcache
->descr
->sizeof_register
[regnum
]);
1363 /* Group members. */
1364 if (what_to_dump
== regcache_dump_groups
)
1367 fprintf_unfiltered (file
, "Groups");
1370 const char *sep
= "";
1371 struct reggroup
*group
;
1372 for (group
= reggroup_next (gdbarch
, NULL
);
1374 group
= reggroup_next (gdbarch
, group
))
1376 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1378 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1385 fprintf_unfiltered (file
, "\n");
1388 if (footnote_register_size
)
1389 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1390 footnote_register_size
);
1391 if (footnote_register_offset
)
1392 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1393 footnote_register_offset
);
1394 if (footnote_register_type_name_null
)
1395 fprintf_unfiltered (file
,
1396 "*%d: Register type's name NULL.\n",
1397 footnote_register_type_name_null
);
1398 do_cleanups (cleanups
);
1402 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1405 regcache_dump (current_regcache
, gdb_stdout
, what_to_dump
);
1408 struct ui_file
*file
= gdb_fopen (args
, "w");
1410 perror_with_name ("maintenance print architecture");
1411 regcache_dump (current_regcache
, file
, what_to_dump
);
1412 ui_file_delete (file
);
1417 maintenance_print_registers (char *args
, int from_tty
)
1419 regcache_print (args
, regcache_dump_none
);
1423 maintenance_print_raw_registers (char *args
, int from_tty
)
1425 regcache_print (args
, regcache_dump_raw
);
1429 maintenance_print_cooked_registers (char *args
, int from_tty
)
1431 regcache_print (args
, regcache_dump_cooked
);
1435 maintenance_print_register_groups (char *args
, int from_tty
)
1437 regcache_print (args
, regcache_dump_groups
);
1440 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1443 _initialize_regcache (void)
1445 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1446 DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache
);
1447 DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_registers
);
1448 DEPRECATED_REGISTER_GDBARCH_SWAP (deprecated_register_valid
);
1449 deprecated_register_gdbarch_swap (NULL
, 0, build_regcache
);
1451 observer_attach_target_changed (regcache_observer_target_changed
);
1453 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1454 "Force gdb to flush its register cache (maintainer command)");
1456 /* Initialize the thread/process associated with the current set of
1457 registers. For now, -1 is special, and means `no current process'. */
1458 registers_ptid
= pid_to_ptid (-1);
1460 add_cmd ("registers", class_maintenance
,
1461 maintenance_print_registers
,
1462 "Print the internal register configuration.\
1463 Takes an optional file parameter.",
1464 &maintenanceprintlist
);
1465 add_cmd ("raw-registers", class_maintenance
,
1466 maintenance_print_raw_registers
,
1467 "Print the internal register configuration including raw values.\
1468 Takes an optional file parameter.",
1469 &maintenanceprintlist
);
1470 add_cmd ("cooked-registers", class_maintenance
,
1471 maintenance_print_cooked_registers
,
1472 "Print the internal register configuration including cooked values.\
1473 Takes an optional file parameter.",
1474 &maintenanceprintlist
);
1475 add_cmd ("register-groups", class_maintenance
,
1476 maintenance_print_register_groups
,
1477 "Print the internal register configuration including each register's group.\
1478 Takes an optional file parameter.",
1479 &maintenanceprintlist
);