1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2004, 2007 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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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 registers 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 /* Register cache status:
190 register_valid_p[REG] == 0 if REG value is not in the cache
191 > 0 if REG value is in the cache
192 < 0 if REG value is permanently unavailable */
193 signed char *register_valid_p
;
194 /* Is this a read-only cache? A read-only cache is used for saving
195 the target's register state (e.g, across an inferior function
196 call or just before forcing a function return). A read-only
197 cache can only be updated via the methods regcache_dup() and
198 regcache_cpy(). The actual contents are determined by the
199 reggroup_save and reggroup_restore methods. */
204 regcache_xmalloc (struct gdbarch
*gdbarch
)
206 struct regcache_descr
*descr
;
207 struct regcache
*regcache
;
208 gdb_assert (gdbarch
!= NULL
);
209 descr
= regcache_descr (gdbarch
);
210 regcache
= XMALLOC (struct regcache
);
211 regcache
->descr
= descr
;
213 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
214 regcache
->register_valid_p
215 = XCALLOC (descr
->sizeof_raw_register_valid_p
, gdb_byte
);
216 regcache
->readonly_p
= 1;
221 regcache_xfree (struct regcache
*regcache
)
223 if (regcache
== NULL
)
225 xfree (regcache
->registers
);
226 xfree (regcache
->register_valid_p
);
231 do_regcache_xfree (void *data
)
233 regcache_xfree (data
);
237 make_cleanup_regcache_xfree (struct regcache
*regcache
)
239 return make_cleanup (do_regcache_xfree
, regcache
);
242 /* Return REGCACHE's architecture. */
245 get_regcache_arch (const struct regcache
*regcache
)
247 return regcache
->descr
->gdbarch
;
250 /* Return a pointer to register REGNUM's buffer cache. */
253 register_buffer (const struct regcache
*regcache
, int regnum
)
255 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
259 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
262 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
263 gdb_byte buf
[MAX_REGISTER_SIZE
];
265 /* The DST should be `read-only', if it wasn't then the save would
266 end up trying to write the register values back out to the
268 gdb_assert (dst
->readonly_p
);
269 /* Clear the dest. */
270 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
271 memset (dst
->register_valid_p
, 0, dst
->descr
->sizeof_cooked_register_valid_p
);
272 /* Copy over any registers (identified by their membership in the
273 save_reggroup) and mark them as valid. The full [0 .. NUM_REGS +
274 NUM_PSEUDO_REGS) range is checked since some architectures need
275 to save/restore `cooked' registers that live in memory. */
276 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
278 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
280 int valid
= cooked_read (src
, regnum
, buf
);
283 memcpy (register_buffer (dst
, regnum
), buf
,
284 register_size (gdbarch
, regnum
));
285 dst
->register_valid_p
[regnum
] = 1;
292 regcache_restore (struct regcache
*dst
,
293 regcache_cooked_read_ftype
*cooked_read
,
294 void *cooked_read_context
)
296 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
297 gdb_byte buf
[MAX_REGISTER_SIZE
];
299 /* The dst had better not be read-only. If it is, the `restore'
300 doesn't make much sense. */
301 gdb_assert (!dst
->readonly_p
);
302 /* Copy over any registers, being careful to only restore those that
303 were both saved and need to be restored. The full [0 .. NUM_REGS
304 + NUM_PSEUDO_REGS) range is checked since some architectures need
305 to save/restore `cooked' registers that live in memory. */
306 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
308 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
310 int valid
= cooked_read (cooked_read_context
, regnum
, buf
);
312 regcache_cooked_write (dst
, regnum
, buf
);
318 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
320 struct regcache
*regcache
= src
;
321 if (!regcache
->register_valid_p
[regnum
] && regcache
->readonly_p
)
322 /* Don't even think about fetching a register from a read-only
323 cache when the register isn't yet valid. There isn't a target
324 from which the register value can be fetched. */
326 regcache_cooked_read (regcache
, regnum
, buf
);
332 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
336 gdb_assert (src
!= NULL
&& dst
!= NULL
);
337 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
338 gdb_assert (src
!= dst
);
339 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
340 if (!src
->readonly_p
)
341 regcache_save (dst
, do_cooked_read
, src
);
342 else if (!dst
->readonly_p
)
343 regcache_restore (dst
, do_cooked_read
, src
);
345 regcache_cpy_no_passthrough (dst
, src
);
349 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
352 gdb_assert (src
!= NULL
&& dst
!= NULL
);
353 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
354 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
355 move of data into the current_regcache(). Doing this would be
356 silly - it would mean that valid_p would be completely invalid. */
357 gdb_assert (dst
!= current_regcache
);
358 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
359 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
360 dst
->descr
->sizeof_raw_register_valid_p
);
364 regcache_dup (struct regcache
*src
)
366 struct regcache
*newbuf
;
367 gdb_assert (current_regcache
!= NULL
);
368 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
369 regcache_cpy (newbuf
, src
);
374 regcache_dup_no_passthrough (struct regcache
*src
)
376 struct regcache
*newbuf
;
377 gdb_assert (current_regcache
!= NULL
);
378 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
379 regcache_cpy_no_passthrough (newbuf
, src
);
384 regcache_valid_p (const struct regcache
*regcache
, int regnum
)
386 gdb_assert (regcache
!= NULL
);
387 gdb_assert (regnum
>= 0);
388 if (regcache
->readonly_p
)
389 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
391 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
393 return regcache
->register_valid_p
[regnum
];
396 /* Global structure containing the current regcache. */
397 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
398 deprecated_register_valid[] currently point into this structure. */
399 struct regcache
*current_regcache
;
401 /* NOTE: this is a write-through cache. There is no "dirty" bit for
402 recording if the register values have been changed (eg. by the
403 user). Therefore all registers must be written back to the
404 target when appropriate. */
406 /* The thread/process associated with the current set of registers. */
408 static ptid_t registers_ptid
;
416 Returns 0 if the value is not in the cache (needs fetch).
417 >0 if the value is in the cache.
418 <0 if the value is permanently unavailable (don't ask again). */
421 register_cached (int regnum
)
423 return current_regcache
->register_valid_p
[regnum
];
426 /* Record that REGNUM's value is cached if STATE is >0, uncached but
427 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
430 set_register_cached (int regnum
, int state
)
432 gdb_assert (regnum
>= 0);
433 gdb_assert (regnum
< current_regcache
->descr
->nr_raw_registers
);
434 current_regcache
->register_valid_p
[regnum
] = state
;
437 /* Observer for the target_changed event. */
440 regcache_observer_target_changed (struct target_ops
*target
)
442 registers_changed ();
445 /* Low level examining and depositing of registers.
447 The caller is responsible for making sure that the inferior is
448 stopped before calling the fetching routines, or it will get
449 garbage. (a change from GDB version 3, in which the caller got the
450 value from the last stop). */
452 /* REGISTERS_CHANGED ()
454 Indicate that registers may have changed, so invalidate the cache. */
457 registers_changed (void)
461 registers_ptid
= pid_to_ptid (-1);
463 /* Force cleanup of any alloca areas if using C alloca instead of
464 a builtin alloca. This particular call is used to clean up
465 areas allocated by low level target code which may build up
466 during lengthy interactions between gdb and the target before
467 gdb gives control to the user (ie watchpoints). */
470 for (i
= 0; i
< current_regcache
->descr
->nr_raw_registers
; i
++)
471 set_register_cached (i
, 0);
474 /* DEPRECATED_REGISTERS_FETCHED ()
476 Indicate that all registers have been fetched, so mark them all valid. */
478 /* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
479 code was blatting the registers[] array and then calling this.
480 Since targets should only be using regcache_raw_supply() the need for
481 this function/hack is eliminated. */
484 deprecated_registers_fetched (void)
488 for (i
= 0; i
< NUM_REGS
; i
++)
489 set_register_cached (i
, 1);
490 /* Do not assume that the pseudo-regs have also been fetched.
491 Fetching all real regs NEVER accounts for pseudo-regs. */
495 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
497 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
498 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
499 /* Make certain that the register cache is up-to-date with respect
500 to the current thread. This switching shouldn't be necessary
501 only there is still only one target side register cache. Sigh!
502 On the bright side, at least there is a regcache object. */
503 if (!regcache
->readonly_p
)
505 gdb_assert (regcache
== current_regcache
);
506 if (! ptid_equal (registers_ptid
, inferior_ptid
))
508 registers_changed ();
509 registers_ptid
= inferior_ptid
;
511 if (!regcache_valid_p (regcache
, regnum
))
512 target_fetch_registers (regcache
, regnum
);
514 /* FIXME: cagney/2004-08-07: At present a number of targets
515 forget (or didn't know that they needed) to set this leading to
516 panics. Also is the problem that targets need to indicate
517 that a register is in one of the possible states: valid,
518 undefined, unknown. The last of which isn't yet
520 gdb_assert (register_cached (regnum
));
523 /* Copy the value directly into the register cache. */
524 memcpy (buf
, register_buffer (regcache
, regnum
),
525 regcache
->descr
->sizeof_register
[regnum
]);
529 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
532 gdb_assert (regcache
!= NULL
);
533 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
534 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
535 regcache_raw_read (regcache
, regnum
, buf
);
536 (*val
) = extract_signed_integer (buf
,
537 regcache
->descr
->sizeof_register
[regnum
]);
541 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
545 gdb_assert (regcache
!= NULL
);
546 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
547 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
548 regcache_raw_read (regcache
, regnum
, buf
);
549 (*val
) = extract_unsigned_integer (buf
,
550 regcache
->descr
->sizeof_register
[regnum
]);
554 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
557 gdb_assert (regcache
!= NULL
);
558 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
559 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
560 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
561 regcache_raw_write (regcache
, regnum
, buf
);
565 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
569 gdb_assert (regcache
!= NULL
);
570 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
571 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
572 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
573 regcache_raw_write (regcache
, regnum
, buf
);
577 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
579 gdb_assert (regnum
>= 0);
580 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
581 if (regnum
< regcache
->descr
->nr_raw_registers
)
582 regcache_raw_read (regcache
, regnum
, buf
);
583 else if (regcache
->readonly_p
584 && regnum
< regcache
->descr
->nr_cooked_registers
585 && regcache
->register_valid_p
[regnum
])
586 /* Read-only register cache, perhaps the cooked value was cached? */
587 memcpy (buf
, register_buffer (regcache
, regnum
),
588 regcache
->descr
->sizeof_register
[regnum
]);
590 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
595 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
599 gdb_assert (regcache
!= NULL
);
600 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
601 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
602 regcache_cooked_read (regcache
, regnum
, buf
);
603 (*val
) = extract_signed_integer (buf
,
604 regcache
->descr
->sizeof_register
[regnum
]);
608 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
612 gdb_assert (regcache
!= NULL
);
613 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
614 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
615 regcache_cooked_read (regcache
, regnum
, buf
);
616 (*val
) = extract_unsigned_integer (buf
,
617 regcache
->descr
->sizeof_register
[regnum
]);
621 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
625 gdb_assert (regcache
!= NULL
);
626 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
627 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
628 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
629 regcache_cooked_write (regcache
, regnum
, buf
);
633 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
637 gdb_assert (regcache
!= NULL
);
638 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
639 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
640 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
], val
);
641 regcache_cooked_write (regcache
, regnum
, buf
);
645 regcache_raw_write (struct regcache
*regcache
, int regnum
,
648 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
649 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
650 gdb_assert (!regcache
->readonly_p
);
652 /* On the sparc, writing %g0 is a no-op, so we don't even want to
653 change the registers array if something writes to this register. */
654 if (CANNOT_STORE_REGISTER (regnum
))
657 /* Make certain that the correct cache is selected. */
658 gdb_assert (regcache
== current_regcache
);
659 if (! ptid_equal (registers_ptid
, inferior_ptid
))
661 registers_changed ();
662 registers_ptid
= inferior_ptid
;
665 /* If we have a valid copy of the register, and new value == old
666 value, then don't bother doing the actual store. */
667 if (regcache_valid_p (regcache
, regnum
)
668 && (memcmp (register_buffer (regcache
, regnum
), buf
,
669 regcache
->descr
->sizeof_register
[regnum
]) == 0))
672 target_prepare_to_store ();
673 memcpy (register_buffer (regcache
, regnum
), buf
,
674 regcache
->descr
->sizeof_register
[regnum
]);
675 regcache
->register_valid_p
[regnum
] = 1;
676 target_store_registers (regcache
, regnum
);
680 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
683 gdb_assert (regnum
>= 0);
684 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
685 if (regnum
< regcache
->descr
->nr_raw_registers
)
686 regcache_raw_write (regcache
, regnum
, buf
);
688 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
692 /* Perform a partial register transfer using a read, modify, write
695 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
697 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
701 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
702 int offset
, int len
, void *in
, const void *out
,
703 void (*read
) (struct regcache
*regcache
, int regnum
,
705 void (*write
) (struct regcache
*regcache
, int regnum
,
706 const gdb_byte
*buf
))
708 struct regcache_descr
*descr
= regcache
->descr
;
709 gdb_byte reg
[MAX_REGISTER_SIZE
];
710 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
711 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
712 /* Something to do? */
713 if (offset
+ len
== 0)
715 /* Read (when needed) ... */
718 || offset
+ len
< descr
->sizeof_register
[regnum
])
720 gdb_assert (read
!= NULL
);
721 read (regcache
, regnum
, reg
);
725 memcpy (in
, reg
+ offset
, len
);
727 memcpy (reg
+ offset
, out
, len
);
728 /* ... write (when needed). */
731 gdb_assert (write
!= NULL
);
732 write (regcache
, regnum
, reg
);
737 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
738 int offset
, int len
, gdb_byte
*buf
)
740 struct regcache_descr
*descr
= regcache
->descr
;
741 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
742 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
743 regcache_raw_read
, regcache_raw_write
);
747 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
748 int offset
, int len
, const gdb_byte
*buf
)
750 struct regcache_descr
*descr
= regcache
->descr
;
751 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
752 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
753 regcache_raw_read
, regcache_raw_write
);
757 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
758 int offset
, int len
, gdb_byte
*buf
)
760 struct regcache_descr
*descr
= regcache
->descr
;
761 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
762 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
763 regcache_cooked_read
, regcache_cooked_write
);
767 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
768 int offset
, int len
, const gdb_byte
*buf
)
770 struct regcache_descr
*descr
= regcache
->descr
;
771 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
772 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
773 regcache_cooked_read
, regcache_cooked_write
);
776 /* Hack to keep code that view the register buffer as raw bytes
780 register_offset_hack (struct gdbarch
*gdbarch
, int regnum
)
782 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
783 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
784 return descr
->register_offset
[regnum
];
787 /* Return the contents of register REGNUM as an unsigned integer. */
790 read_register (int regnum
)
792 gdb_byte
*buf
= alloca (register_size (current_gdbarch
, regnum
));
793 gdb_assert (current_regcache
!= NULL
);
794 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
795 regcache_cooked_read (current_regcache
, regnum
, buf
);
796 return (extract_unsigned_integer (buf
, register_size (current_gdbarch
, regnum
)));
800 read_register_pid (int regnum
, ptid_t ptid
)
806 if (ptid_equal (ptid
, inferior_ptid
))
807 return read_register (regnum
);
809 save_ptid
= inferior_ptid
;
811 inferior_ptid
= ptid
;
813 retval
= read_register (regnum
);
815 inferior_ptid
= save_ptid
;
820 /* Store VALUE into the raw contents of register number REGNUM. */
823 write_register (int regnum
, LONGEST val
)
827 size
= register_size (current_gdbarch
, regnum
);
829 store_signed_integer (buf
, size
, (LONGEST
) val
);
830 gdb_assert (current_regcache
!= NULL
);
831 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
832 regcache_cooked_write (current_regcache
, regnum
, buf
);
836 write_register_pid (int regnum
, CORE_ADDR val
, ptid_t ptid
)
840 if (ptid_equal (ptid
, inferior_ptid
))
842 write_register (regnum
, val
);
846 save_ptid
= inferior_ptid
;
848 inferior_ptid
= ptid
;
850 write_register (regnum
, val
);
852 inferior_ptid
= save_ptid
;
855 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
858 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
863 gdb_assert (regcache
!= NULL
);
864 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
865 gdb_assert (!regcache
->readonly_p
);
867 /* FIXME: kettenis/20030828: It shouldn't be necessary to handle
868 CURRENT_REGCACHE specially here. */
869 if (regcache
== current_regcache
870 && !ptid_equal (registers_ptid
, inferior_ptid
))
872 registers_changed ();
873 registers_ptid
= inferior_ptid
;
876 regbuf
= register_buffer (regcache
, regnum
);
877 size
= regcache
->descr
->sizeof_register
[regnum
];
880 memcpy (regbuf
, buf
, size
);
882 memset (regbuf
, 0, size
);
884 /* Mark the register as cached. */
885 regcache
->register_valid_p
[regnum
] = 1;
888 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
891 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
896 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
897 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
899 regbuf
= register_buffer (regcache
, regnum
);
900 size
= regcache
->descr
->sizeof_register
[regnum
];
901 memcpy (buf
, regbuf
, size
);
905 /* read_pc, write_pc, read_sp, etc. Special handling for registers
908 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
909 read_sp(), will eventually be replaced by per-frame methods.
910 Instead of relying on the global INFERIOR_PTID, they will use the
911 contextual information provided by the FRAME. These functions do
912 not belong in the register cache. */
914 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
915 write_pc_pid() and write_pc(), all need to be replaced by something
916 that does not rely on global state. But what? */
919 read_pc_pid (ptid_t ptid
)
921 ptid_t saved_inferior_ptid
;
924 /* In case ptid != inferior_ptid. */
925 saved_inferior_ptid
= inferior_ptid
;
926 inferior_ptid
= ptid
;
928 if (TARGET_READ_PC_P ())
929 pc_val
= TARGET_READ_PC (ptid
);
930 /* Else use per-frame method on get_current_frame. */
931 else if (PC_REGNUM
>= 0)
933 CORE_ADDR raw_val
= read_register_pid (PC_REGNUM
, ptid
);
934 pc_val
= ADDR_BITS_REMOVE (raw_val
);
937 internal_error (__FILE__
, __LINE__
, _("read_pc_pid: Unable to find PC"));
939 inferior_ptid
= saved_inferior_ptid
;
946 return read_pc_pid (inferior_ptid
);
950 generic_target_write_pc (CORE_ADDR pc
, ptid_t ptid
)
953 write_register_pid (PC_REGNUM
, pc
, ptid
);
955 internal_error (__FILE__
, __LINE__
,
956 _("generic_target_write_pc"));
960 write_pc_pid (CORE_ADDR pc
, ptid_t ptid
)
962 ptid_t saved_inferior_ptid
;
964 /* In case ptid != inferior_ptid. */
965 saved_inferior_ptid
= inferior_ptid
;
966 inferior_ptid
= ptid
;
968 TARGET_WRITE_PC (pc
, ptid
);
970 inferior_ptid
= saved_inferior_ptid
;
974 write_pc (CORE_ADDR pc
)
976 write_pc_pid (pc
, inferior_ptid
);
979 /* Cope with strage ways of getting to the stack and frame pointers */
984 if (TARGET_READ_SP_P ())
985 return TARGET_READ_SP ();
986 else if (gdbarch_unwind_sp_p (current_gdbarch
))
987 return get_frame_sp (get_current_frame ());
988 else if (SP_REGNUM
>= 0)
989 /* Try SP_REGNUM last: this makes all sorts of [wrong] assumptions
990 about the architecture so put it at the end. */
991 return read_register (SP_REGNUM
);
992 internal_error (__FILE__
, __LINE__
, _("read_sp: Unable to find SP"));
996 reg_flush_command (char *command
, int from_tty
)
998 /* Force-flush the register cache. */
999 registers_changed ();
1001 printf_filtered (_("Register cache flushed.\n"));
1005 build_regcache (void)
1007 current_regcache
= regcache_xmalloc (current_gdbarch
);
1008 current_regcache
->readonly_p
= 0;
1012 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
1013 const unsigned char *buf
, long len
)
1018 case BFD_ENDIAN_BIG
:
1019 for (i
= 0; i
< len
; i
++)
1020 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1022 case BFD_ENDIAN_LITTLE
:
1023 for (i
= len
- 1; i
>= 0; i
--)
1024 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1027 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
1031 enum regcache_dump_what
1033 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
1037 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1038 enum regcache_dump_what what_to_dump
)
1040 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1041 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1043 int footnote_nr
= 0;
1044 int footnote_register_size
= 0;
1045 int footnote_register_offset
= 0;
1046 int footnote_register_type_name_null
= 0;
1047 long register_offset
= 0;
1048 unsigned char buf
[MAX_REGISTER_SIZE
];
1051 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1052 regcache
->descr
->nr_raw_registers
);
1053 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1054 regcache
->descr
->nr_cooked_registers
);
1055 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1056 regcache
->descr
->sizeof_raw_registers
);
1057 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
1058 regcache
->descr
->sizeof_raw_register_valid_p
);
1059 fprintf_unfiltered (file
, "NUM_REGS %d\n", NUM_REGS
);
1060 fprintf_unfiltered (file
, "NUM_PSEUDO_REGS %d\n", NUM_PSEUDO_REGS
);
1063 gdb_assert (regcache
->descr
->nr_cooked_registers
1064 == (NUM_REGS
+ NUM_PSEUDO_REGS
));
1066 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1070 fprintf_unfiltered (file
, " %-10s", "Name");
1073 const char *p
= REGISTER_NAME (regnum
);
1076 else if (p
[0] == '\0')
1078 fprintf_unfiltered (file
, " %-10s", p
);
1083 fprintf_unfiltered (file
, " %4s", "Nr");
1085 fprintf_unfiltered (file
, " %4d", regnum
);
1087 /* Relative number. */
1089 fprintf_unfiltered (file
, " %4s", "Rel");
1090 else if (regnum
< NUM_REGS
)
1091 fprintf_unfiltered (file
, " %4d", regnum
);
1093 fprintf_unfiltered (file
, " %4d", (regnum
- NUM_REGS
));
1097 fprintf_unfiltered (file
, " %6s ", "Offset");
1100 fprintf_unfiltered (file
, " %6ld",
1101 regcache
->descr
->register_offset
[regnum
]);
1102 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1104 && (regcache
->descr
->register_offset
[regnum
]
1105 != (regcache
->descr
->register_offset
[regnum
- 1]
1106 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1109 if (!footnote_register_offset
)
1110 footnote_register_offset
= ++footnote_nr
;
1111 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1114 fprintf_unfiltered (file
, " ");
1115 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1116 + regcache
->descr
->sizeof_register
[regnum
]);
1121 fprintf_unfiltered (file
, " %5s ", "Size");
1123 fprintf_unfiltered (file
, " %5ld",
1124 regcache
->descr
->sizeof_register
[regnum
]);
1133 static const char blt
[] = "builtin_type";
1134 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1138 if (!footnote_register_type_name_null
)
1139 footnote_register_type_name_null
= ++footnote_nr
;
1140 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1141 make_cleanup (xfree
, n
);
1144 /* Chop a leading builtin_type. */
1145 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1148 fprintf_unfiltered (file
, " %-15s", t
);
1151 /* Leading space always present. */
1152 fprintf_unfiltered (file
, " ");
1155 if (what_to_dump
== regcache_dump_raw
)
1158 fprintf_unfiltered (file
, "Raw value");
1159 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1160 fprintf_unfiltered (file
, "<cooked>");
1161 else if (!regcache_valid_p (regcache
, regnum
))
1162 fprintf_unfiltered (file
, "<invalid>");
1165 regcache_raw_read (regcache
, regnum
, buf
);
1166 fprintf_unfiltered (file
, "0x");
1167 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1168 regcache
->descr
->sizeof_register
[regnum
]);
1172 /* Value, cooked. */
1173 if (what_to_dump
== regcache_dump_cooked
)
1176 fprintf_unfiltered (file
, "Cooked value");
1179 regcache_cooked_read (regcache
, regnum
, buf
);
1180 fprintf_unfiltered (file
, "0x");
1181 dump_endian_bytes (file
, TARGET_BYTE_ORDER
, buf
,
1182 regcache
->descr
->sizeof_register
[regnum
]);
1186 /* Group members. */
1187 if (what_to_dump
== regcache_dump_groups
)
1190 fprintf_unfiltered (file
, "Groups");
1193 const char *sep
= "";
1194 struct reggroup
*group
;
1195 for (group
= reggroup_next (gdbarch
, NULL
);
1197 group
= reggroup_next (gdbarch
, group
))
1199 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1201 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1208 fprintf_unfiltered (file
, "\n");
1211 if (footnote_register_size
)
1212 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1213 footnote_register_size
);
1214 if (footnote_register_offset
)
1215 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1216 footnote_register_offset
);
1217 if (footnote_register_type_name_null
)
1218 fprintf_unfiltered (file
,
1219 "*%d: Register type's name NULL.\n",
1220 footnote_register_type_name_null
);
1221 do_cleanups (cleanups
);
1225 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1228 regcache_dump (current_regcache
, gdb_stdout
, what_to_dump
);
1231 struct ui_file
*file
= gdb_fopen (args
, "w");
1233 perror_with_name (_("maintenance print architecture"));
1234 regcache_dump (current_regcache
, file
, what_to_dump
);
1235 ui_file_delete (file
);
1240 maintenance_print_registers (char *args
, int from_tty
)
1242 regcache_print (args
, regcache_dump_none
);
1246 maintenance_print_raw_registers (char *args
, int from_tty
)
1248 regcache_print (args
, regcache_dump_raw
);
1252 maintenance_print_cooked_registers (char *args
, int from_tty
)
1254 regcache_print (args
, regcache_dump_cooked
);
1258 maintenance_print_register_groups (char *args
, int from_tty
)
1260 regcache_print (args
, regcache_dump_groups
);
1263 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1266 _initialize_regcache (void)
1268 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1269 DEPRECATED_REGISTER_GDBARCH_SWAP (current_regcache
);
1270 deprecated_register_gdbarch_swap (NULL
, 0, build_regcache
);
1272 observer_attach_target_changed (regcache_observer_target_changed
);
1274 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1275 _("Force gdb to flush its register cache (maintainer command)"));
1277 /* Initialize the thread/process associated with the current set of
1278 registers. For now, -1 is special, and means `no current process'. */
1279 registers_ptid
= pid_to_ptid (-1);
1281 add_cmd ("registers", class_maintenance
, maintenance_print_registers
, _("\
1282 Print the internal register configuration.\n\
1283 Takes an optional file parameter."), &maintenanceprintlist
);
1284 add_cmd ("raw-registers", class_maintenance
,
1285 maintenance_print_raw_registers
, _("\
1286 Print the internal register configuration including raw values.\n\
1287 Takes an optional file parameter."), &maintenanceprintlist
);
1288 add_cmd ("cooked-registers", class_maintenance
,
1289 maintenance_print_cooked_registers
, _("\
1290 Print the internal register configuration including cooked values.\n\
1291 Takes an optional file parameter."), &maintenanceprintlist
);
1292 add_cmd ("register-groups", class_maintenance
,
1293 maintenance_print_register_groups
, _("\
1294 Print the internal register configuration including each register's group.\n\
1295 Takes an optional file parameter."),
1296 &maintenanceprintlist
);