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, 2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>. */
27 #include "reggroups.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "gdbcmd.h" /* For maintenanceprintlist. */
36 * Here is the actual register cache.
39 /* Per-architecture object describing the layout of a register cache.
40 Computed once when the architecture is created */
42 struct gdbarch_data
*regcache_descr_handle
;
46 /* The architecture this descriptor belongs to. */
47 struct gdbarch
*gdbarch
;
49 /* The raw register cache. Each raw (or hard) register is supplied
50 by the target interface. The raw cache should not contain
51 redundant information - if the PC is constructed from two
52 registers then those registers and not the PC lives in the raw
55 long sizeof_raw_registers
;
56 long sizeof_raw_register_valid_p
;
58 /* The cooked register space. Each cooked register in the range
59 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
60 register. The remaining [NR_RAW_REGISTERS
61 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
62 both raw registers and memory by the architecture methods
63 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
64 int nr_cooked_registers
;
65 long sizeof_cooked_registers
;
66 long sizeof_cooked_register_valid_p
;
68 /* Offset and size (in 8 bit bytes), of reach register in the
69 register cache. All registers (including those in the range
70 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
71 Assigning all registers an offset makes it possible to keep
72 legacy code, such as that found in read_register_bytes() and
73 write_register_bytes() working. */
74 long *register_offset
;
75 long *sizeof_register
;
77 /* Cached table containing the type of each register. */
78 struct type
**register_type
;
82 init_regcache_descr (struct gdbarch
*gdbarch
)
85 struct regcache_descr
*descr
;
86 gdb_assert (gdbarch
!= NULL
);
88 /* Create an initial, zero filled, table. */
89 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
90 descr
->gdbarch
= gdbarch
;
92 /* Total size of the register space. The raw registers are mapped
93 directly onto the raw register cache while the pseudo's are
94 either mapped onto raw-registers or memory. */
95 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
96 + gdbarch_num_pseudo_regs (gdbarch
);
97 descr
->sizeof_cooked_register_valid_p
= gdbarch_num_regs (gdbarch
)
98 + gdbarch_num_pseudo_regs
101 /* Fill in a table of register types. */
103 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, struct type
*);
104 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
105 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
107 /* Construct a strictly RAW register cache. Don't allow pseudo's
108 into the register cache. */
109 descr
->nr_raw_registers
= gdbarch_num_regs (gdbarch
);
111 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
112 array. This pretects GDB from erant code that accesses elements
113 of the global register_valid_p[] array in the range
114 [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs). */
115 descr
->sizeof_raw_register_valid_p
= descr
->sizeof_cooked_register_valid_p
;
117 /* Lay out the register cache.
119 NOTE: cagney/2002-05-22: Only register_type() is used when
120 constructing the register cache. It is assumed that the
121 register's raw size, virtual size and type length are all the
126 descr
->sizeof_register
127 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
128 descr
->register_offset
129 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
130 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
132 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
133 descr
->register_offset
[i
] = offset
;
134 offset
+= descr
->sizeof_register
[i
];
135 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
137 /* Set the real size of the register cache buffer. */
138 descr
->sizeof_cooked_registers
= offset
;
141 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
142 the raw registers. Unfortunately some code still accesses the
143 register array directly using the global registers[]. Until that
144 code has been purged, play safe and over allocating the register
146 descr
->sizeof_raw_registers
= descr
->sizeof_cooked_registers
;
151 static struct regcache_descr
*
152 regcache_descr (struct gdbarch
*gdbarch
)
154 return gdbarch_data (gdbarch
, regcache_descr_handle
);
157 /* Utility functions returning useful register attributes stored in
158 the regcache descr. */
161 register_type (struct gdbarch
*gdbarch
, int regnum
)
163 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
164 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
165 return descr
->register_type
[regnum
];
168 /* Utility functions returning useful register attributes stored in
169 the regcache descr. */
172 register_size (struct gdbarch
*gdbarch
, int regnum
)
174 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
176 gdb_assert (regnum
>= 0
177 && regnum
< (gdbarch_num_regs (gdbarch
)
178 + gdbarch_num_pseudo_regs (gdbarch
)));
179 size
= descr
->sizeof_register
[regnum
];
183 /* The register cache for storing raw register values. */
187 struct regcache_descr
*descr
;
189 /* The address space of this register cache (for registers where it
190 makes sense, like PC or SP). */
191 struct address_space
*aspace
;
193 /* The register buffers. A read-only register cache can hold the
194 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
195 register cache can only hold [0 .. gdbarch_num_regs). */
197 /* Register cache status:
198 register_valid_p[REG] == 0 if REG value is not in the cache
199 > 0 if REG value is in the cache
200 < 0 if REG value is permanently unavailable */
201 signed char *register_valid_p
;
202 /* Is this a read-only cache? A read-only cache is used for saving
203 the target's register state (e.g, across an inferior function
204 call or just before forcing a function return). A read-only
205 cache can only be updated via the methods regcache_dup() and
206 regcache_cpy(). The actual contents are determined by the
207 reggroup_save and reggroup_restore methods. */
209 /* If this is a read-write cache, which thread's registers is
215 regcache_xmalloc (struct gdbarch
*gdbarch
, struct address_space
*aspace
)
217 struct regcache_descr
*descr
;
218 struct regcache
*regcache
;
219 gdb_assert (gdbarch
!= NULL
);
220 descr
= regcache_descr (gdbarch
);
221 regcache
= XMALLOC (struct regcache
);
222 regcache
->descr
= descr
;
224 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
225 regcache
->register_valid_p
226 = XCALLOC (descr
->sizeof_raw_register_valid_p
, gdb_byte
);
227 regcache
->aspace
= aspace
;
228 regcache
->readonly_p
= 1;
229 regcache
->ptid
= minus_one_ptid
;
234 regcache_xfree (struct regcache
*regcache
)
236 if (regcache
== NULL
)
238 xfree (regcache
->registers
);
239 xfree (regcache
->register_valid_p
);
244 do_regcache_xfree (void *data
)
246 regcache_xfree (data
);
250 make_cleanup_regcache_xfree (struct regcache
*regcache
)
252 return make_cleanup (do_regcache_xfree
, regcache
);
255 /* Return REGCACHE's architecture. */
258 get_regcache_arch (const struct regcache
*regcache
)
260 return regcache
->descr
->gdbarch
;
263 struct address_space
*
264 get_regcache_aspace (const struct regcache
*regcache
)
266 return regcache
->aspace
;
269 /* Return a pointer to register REGNUM's buffer cache. */
272 register_buffer (const struct regcache
*regcache
, int regnum
)
274 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
278 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
281 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
282 gdb_byte buf
[MAX_REGISTER_SIZE
];
284 /* The DST should be `read-only', if it wasn't then the save would
285 end up trying to write the register values back out to the
287 gdb_assert (dst
->readonly_p
);
288 /* Clear the dest. */
289 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
290 memset (dst
->register_valid_p
, 0, dst
->descr
->sizeof_cooked_register_valid_p
);
291 /* Copy over any registers (identified by their membership in the
292 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
293 gdbarch_num_pseudo_regs) range is checked since some architectures need
294 to save/restore `cooked' registers that live in memory. */
295 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
297 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
299 int valid
= cooked_read (src
, regnum
, buf
);
302 memcpy (register_buffer (dst
, regnum
), buf
,
303 register_size (gdbarch
, regnum
));
304 dst
->register_valid_p
[regnum
] = 1;
311 regcache_restore (struct regcache
*dst
,
312 regcache_cooked_read_ftype
*cooked_read
,
313 void *cooked_read_context
)
315 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
316 gdb_byte buf
[MAX_REGISTER_SIZE
];
318 /* The dst had better not be read-only. If it is, the `restore'
319 doesn't make much sense. */
320 gdb_assert (!dst
->readonly_p
);
321 /* Copy over any registers, being careful to only restore those that
322 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
323 + gdbarch_num_pseudo_regs) range is checked since some architectures need
324 to save/restore `cooked' registers that live in memory. */
325 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
327 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
329 int valid
= cooked_read (cooked_read_context
, regnum
, buf
);
331 regcache_cooked_write (dst
, regnum
, buf
);
337 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
339 struct regcache
*regcache
= src
;
340 if (!regcache
->register_valid_p
[regnum
] && regcache
->readonly_p
)
341 /* Don't even think about fetching a register from a read-only
342 cache when the register isn't yet valid. There isn't a target
343 from which the register value can be fetched. */
345 regcache_cooked_read (regcache
, regnum
, buf
);
351 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
353 gdb_assert (src
!= NULL
&& dst
!= NULL
);
354 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
355 gdb_assert (src
!= dst
);
356 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
358 if (!src
->readonly_p
)
359 regcache_save (dst
, do_cooked_read
, src
);
360 else if (!dst
->readonly_p
)
361 regcache_restore (dst
, do_cooked_read
, src
);
363 regcache_cpy_no_passthrough (dst
, src
);
367 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
369 gdb_assert (src
!= NULL
&& dst
!= NULL
);
370 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
371 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
372 move of data into the current regcache. Doing this would be
373 silly - it would mean that valid_p would be completely invalid. */
374 gdb_assert (dst
->readonly_p
);
376 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
377 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
378 dst
->descr
->sizeof_raw_register_valid_p
);
382 regcache_dup (struct regcache
*src
)
384 struct regcache
*newbuf
;
385 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
386 regcache_cpy (newbuf
, src
);
391 regcache_dup_no_passthrough (struct regcache
*src
)
393 struct regcache
*newbuf
;
394 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
395 regcache_cpy_no_passthrough (newbuf
, src
);
400 regcache_valid_p (const struct regcache
*regcache
, int regnum
)
402 gdb_assert (regcache
!= NULL
);
403 gdb_assert (regnum
>= 0);
404 if (regcache
->readonly_p
)
405 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
407 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
409 return regcache
->register_valid_p
[regnum
];
413 regcache_invalidate (struct regcache
*regcache
, int regnum
)
415 gdb_assert (regcache
!= NULL
);
416 gdb_assert (regnum
>= 0);
417 gdb_assert (!regcache
->readonly_p
);
418 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
419 regcache
->register_valid_p
[regnum
] = 0;
423 /* Global structure containing the current regcache. */
425 /* NOTE: this is a write-through cache. There is no "dirty" bit for
426 recording if the register values have been changed (eg. by the
427 user). Therefore all registers must be written back to the
428 target when appropriate. */
432 struct regcache
*regcache
;
433 struct regcache_list
*next
;
436 static struct regcache_list
*current_regcache
;
439 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
441 struct regcache_list
*list
;
442 struct regcache
*new_regcache
;
444 for (list
= current_regcache
; list
; list
= list
->next
)
445 if (ptid_equal (list
->regcache
->ptid
, ptid
)
446 && get_regcache_arch (list
->regcache
) == gdbarch
)
447 return list
->regcache
;
449 new_regcache
= regcache_xmalloc (gdbarch
,
450 target_thread_address_space (ptid
));
451 new_regcache
->readonly_p
= 0;
452 new_regcache
->ptid
= ptid
;
453 gdb_assert (new_regcache
->aspace
!= NULL
);
455 list
= xmalloc (sizeof (struct regcache_list
));
456 list
->regcache
= new_regcache
;
457 list
->next
= current_regcache
;
458 current_regcache
= list
;
463 static ptid_t current_thread_ptid
;
464 static struct gdbarch
*current_thread_arch
;
467 get_thread_regcache (ptid_t ptid
)
469 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
471 current_thread_ptid
= ptid
;
472 current_thread_arch
= target_thread_architecture (ptid
);
475 return get_thread_arch_regcache (ptid
, current_thread_arch
);
479 get_current_regcache (void)
481 return get_thread_regcache (inferior_ptid
);
485 /* Observer for the target_changed event. */
488 regcache_observer_target_changed (struct target_ops
*target
)
490 registers_changed ();
493 /* Update global variables old ptids to hold NEW_PTID if they were
496 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
498 struct regcache_list
*list
;
500 for (list
= current_regcache
; list
; list
= list
->next
)
501 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
502 list
->regcache
->ptid
= new_ptid
;
505 /* Low level examining and depositing of registers.
507 The caller is responsible for making sure that the inferior is
508 stopped before calling the fetching routines, or it will get
509 garbage. (a change from GDB version 3, in which the caller got the
510 value from the last stop). */
512 /* REGISTERS_CHANGED ()
514 Indicate that registers may have changed, so invalidate the cache. */
517 registers_changed_ptid (ptid_t ptid
)
519 struct regcache_list
*list
, **list_link
;
521 list
= current_regcache
;
522 list_link
= ¤t_regcache
;
525 if (ptid_match (list
->regcache
->ptid
, ptid
))
527 struct regcache_list
*dead
= list
;
529 *list_link
= list
->next
;
530 regcache_xfree (list
->regcache
);
536 list_link
= &list
->next
;
540 current_regcache
= NULL
;
542 current_thread_ptid
= null_ptid
;
543 current_thread_arch
= NULL
;
545 /* Need to forget about any frames we have cached, too. */
546 reinit_frame_cache ();
548 /* Force cleanup of any alloca areas if using C alloca instead of
549 a builtin alloca. This particular call is used to clean up
550 areas allocated by low level target code which may build up
551 during lengthy interactions between gdb and the target before
552 gdb gives control to the user (ie watchpoints). */
557 registers_changed (void)
559 registers_changed_ptid (minus_one_ptid
);
563 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
565 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
566 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
567 /* Make certain that the register cache is up-to-date with respect
568 to the current thread. This switching shouldn't be necessary
569 only there is still only one target side register cache. Sigh!
570 On the bright side, at least there is a regcache object. */
571 if (!regcache
->readonly_p
)
573 if (!regcache_valid_p (regcache
, regnum
))
575 struct cleanup
*old_chain
= save_inferior_ptid ();
576 inferior_ptid
= regcache
->ptid
;
577 target_fetch_registers (regcache
, regnum
);
578 do_cleanups (old_chain
);
581 /* FIXME: cagney/2004-08-07: At present a number of targets
582 forget (or didn't know that they needed) to set this leading to
583 panics. Also is the problem that targets need to indicate
584 that a register is in one of the possible states: valid,
585 undefined, unknown. The last of which isn't yet
587 gdb_assert (regcache_valid_p (regcache
, regnum
));
590 /* Copy the value directly into the register cache. */
591 memcpy (buf
, register_buffer (regcache
, regnum
),
592 regcache
->descr
->sizeof_register
[regnum
]);
596 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
599 gdb_assert (regcache
!= NULL
);
600 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
601 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
602 regcache_raw_read (regcache
, regnum
, buf
);
603 (*val
) = extract_signed_integer
604 (buf
, regcache
->descr
->sizeof_register
[regnum
],
605 gdbarch_byte_order (regcache
->descr
->gdbarch
));
609 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
613 gdb_assert (regcache
!= NULL
);
614 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
615 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
616 regcache_raw_read (regcache
, regnum
, buf
);
617 (*val
) = extract_unsigned_integer
618 (buf
, regcache
->descr
->sizeof_register
[regnum
],
619 gdbarch_byte_order (regcache
->descr
->gdbarch
));
623 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
626 gdb_assert (regcache
!= NULL
);
627 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
628 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
629 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
630 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
631 regcache_raw_write (regcache
, regnum
, buf
);
635 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
639 gdb_assert (regcache
!= NULL
);
640 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
641 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
642 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
643 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
644 regcache_raw_write (regcache
, regnum
, buf
);
648 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
650 gdb_assert (regnum
>= 0);
651 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
652 if (regnum
< regcache
->descr
->nr_raw_registers
)
653 regcache_raw_read (regcache
, regnum
, buf
);
654 else if (regcache
->readonly_p
655 && regnum
< regcache
->descr
->nr_cooked_registers
656 && regcache
->register_valid_p
[regnum
])
657 /* Read-only register cache, perhaps the cooked value was cached? */
658 memcpy (buf
, register_buffer (regcache
, regnum
),
659 regcache
->descr
->sizeof_register
[regnum
]);
661 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
666 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
670 gdb_assert (regcache
!= NULL
);
671 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
672 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
673 regcache_cooked_read (regcache
, regnum
, buf
);
674 (*val
) = extract_signed_integer
675 (buf
, regcache
->descr
->sizeof_register
[regnum
],
676 gdbarch_byte_order (regcache
->descr
->gdbarch
));
680 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
684 gdb_assert (regcache
!= NULL
);
685 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
686 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
687 regcache_cooked_read (regcache
, regnum
, buf
);
688 (*val
) = extract_unsigned_integer
689 (buf
, regcache
->descr
->sizeof_register
[regnum
],
690 gdbarch_byte_order (regcache
->descr
->gdbarch
));
694 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
698 gdb_assert (regcache
!= NULL
);
699 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
700 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
701 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
702 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
703 regcache_cooked_write (regcache
, regnum
, buf
);
707 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
711 gdb_assert (regcache
!= NULL
);
712 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
713 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
714 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
715 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
716 regcache_cooked_write (regcache
, regnum
, buf
);
720 regcache_raw_write (struct regcache
*regcache
, int regnum
,
723 struct cleanup
*old_chain
;
725 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
726 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
727 gdb_assert (!regcache
->readonly_p
);
729 /* On the sparc, writing %g0 is a no-op, so we don't even want to
730 change the registers array if something writes to this register. */
731 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
734 /* If we have a valid copy of the register, and new value == old
735 value, then don't bother doing the actual store. */
736 if (regcache_valid_p (regcache
, regnum
)
737 && (memcmp (register_buffer (regcache
, regnum
), buf
,
738 regcache
->descr
->sizeof_register
[regnum
]) == 0))
741 old_chain
= save_inferior_ptid ();
742 inferior_ptid
= regcache
->ptid
;
744 target_prepare_to_store (regcache
);
745 memcpy (register_buffer (regcache
, regnum
), buf
,
746 regcache
->descr
->sizeof_register
[regnum
]);
747 regcache
->register_valid_p
[regnum
] = 1;
748 target_store_registers (regcache
, regnum
);
750 do_cleanups (old_chain
);
754 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
757 gdb_assert (regnum
>= 0);
758 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
759 if (regnum
< regcache
->descr
->nr_raw_registers
)
760 regcache_raw_write (regcache
, regnum
, buf
);
762 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
766 /* Perform a partial register transfer using a read, modify, write
769 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
771 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
775 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
776 int offset
, int len
, void *in
, const void *out
,
777 void (*read
) (struct regcache
*regcache
, int regnum
,
779 void (*write
) (struct regcache
*regcache
, int regnum
,
780 const gdb_byte
*buf
))
782 struct regcache_descr
*descr
= regcache
->descr
;
783 gdb_byte reg
[MAX_REGISTER_SIZE
];
784 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
785 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
786 /* Something to do? */
787 if (offset
+ len
== 0)
789 /* Read (when needed) ... */
792 || offset
+ len
< descr
->sizeof_register
[regnum
])
794 gdb_assert (read
!= NULL
);
795 read (regcache
, regnum
, reg
);
799 memcpy (in
, reg
+ offset
, len
);
801 memcpy (reg
+ offset
, out
, len
);
802 /* ... write (when needed). */
805 gdb_assert (write
!= NULL
);
806 write (regcache
, regnum
, reg
);
811 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
812 int offset
, int len
, gdb_byte
*buf
)
814 struct regcache_descr
*descr
= regcache
->descr
;
815 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
816 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
817 regcache_raw_read
, regcache_raw_write
);
821 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
822 int offset
, int len
, const gdb_byte
*buf
)
824 struct regcache_descr
*descr
= regcache
->descr
;
825 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
826 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
827 regcache_raw_read
, regcache_raw_write
);
831 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
832 int offset
, int len
, gdb_byte
*buf
)
834 struct regcache_descr
*descr
= regcache
->descr
;
835 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
836 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
837 regcache_cooked_read
, regcache_cooked_write
);
841 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
842 int offset
, int len
, const gdb_byte
*buf
)
844 struct regcache_descr
*descr
= regcache
->descr
;
845 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
846 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
847 regcache_cooked_read
, regcache_cooked_write
);
850 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
853 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
858 gdb_assert (regcache
!= NULL
);
859 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
860 gdb_assert (!regcache
->readonly_p
);
862 regbuf
= register_buffer (regcache
, regnum
);
863 size
= regcache
->descr
->sizeof_register
[regnum
];
866 memcpy (regbuf
, buf
, size
);
868 memset (regbuf
, 0, size
);
870 /* Mark the register as cached. */
871 regcache
->register_valid_p
[regnum
] = 1;
874 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
877 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
882 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
883 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
885 regbuf
= register_buffer (regcache
, regnum
);
886 size
= regcache
->descr
->sizeof_register
[regnum
];
887 memcpy (buf
, regbuf
, size
);
891 /* Special handling for register PC. */
894 regcache_read_pc (struct regcache
*regcache
)
896 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
900 if (gdbarch_read_pc_p (gdbarch
))
901 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
902 /* Else use per-frame method on get_current_frame. */
903 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
906 regcache_cooked_read_unsigned (regcache
,
907 gdbarch_pc_regnum (gdbarch
),
909 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
912 internal_error (__FILE__
, __LINE__
,
913 _("regcache_read_pc: Unable to find PC"));
918 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
920 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
922 if (gdbarch_write_pc_p (gdbarch
))
923 gdbarch_write_pc (gdbarch
, regcache
, pc
);
924 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
925 regcache_cooked_write_unsigned (regcache
,
926 gdbarch_pc_regnum (gdbarch
), pc
);
928 internal_error (__FILE__
, __LINE__
,
929 _("regcache_write_pc: Unable to update PC"));
931 /* Writing the PC (for instance, from "load") invalidates the
933 reinit_frame_cache ();
938 reg_flush_command (char *command
, int from_tty
)
940 /* Force-flush the register cache. */
941 registers_changed ();
943 printf_filtered (_("Register cache flushed.\n"));
947 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
948 const unsigned char *buf
, long len
)
954 for (i
= 0; i
< len
; i
++)
955 fprintf_unfiltered (file
, "%02x", buf
[i
]);
957 case BFD_ENDIAN_LITTLE
:
958 for (i
= len
- 1; i
>= 0; i
--)
959 fprintf_unfiltered (file
, "%02x", buf
[i
]);
962 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
966 enum regcache_dump_what
968 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
972 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
973 enum regcache_dump_what what_to_dump
)
975 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
976 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
979 int footnote_register_size
= 0;
980 int footnote_register_offset
= 0;
981 int footnote_register_type_name_null
= 0;
982 long register_offset
= 0;
983 unsigned char buf
[MAX_REGISTER_SIZE
];
986 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
987 regcache
->descr
->nr_raw_registers
);
988 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
989 regcache
->descr
->nr_cooked_registers
);
990 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
991 regcache
->descr
->sizeof_raw_registers
);
992 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
993 regcache
->descr
->sizeof_raw_register_valid_p
);
994 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
995 gdbarch_num_regs (gdbarch
));
996 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
997 gdbarch_num_pseudo_regs (gdbarch
));
1000 gdb_assert (regcache
->descr
->nr_cooked_registers
1001 == (gdbarch_num_regs (gdbarch
)
1002 + gdbarch_num_pseudo_regs (gdbarch
)));
1004 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1008 fprintf_unfiltered (file
, " %-10s", "Name");
1011 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1014 else if (p
[0] == '\0')
1016 fprintf_unfiltered (file
, " %-10s", p
);
1021 fprintf_unfiltered (file
, " %4s", "Nr");
1023 fprintf_unfiltered (file
, " %4d", regnum
);
1025 /* Relative number. */
1027 fprintf_unfiltered (file
, " %4s", "Rel");
1028 else if (regnum
< gdbarch_num_regs (gdbarch
))
1029 fprintf_unfiltered (file
, " %4d", regnum
);
1031 fprintf_unfiltered (file
, " %4d",
1032 (regnum
- gdbarch_num_regs (gdbarch
)));
1036 fprintf_unfiltered (file
, " %6s ", "Offset");
1039 fprintf_unfiltered (file
, " %6ld",
1040 regcache
->descr
->register_offset
[regnum
]);
1041 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1043 && (regcache
->descr
->register_offset
[regnum
]
1044 != (regcache
->descr
->register_offset
[regnum
- 1]
1045 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1048 if (!footnote_register_offset
)
1049 footnote_register_offset
= ++footnote_nr
;
1050 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1053 fprintf_unfiltered (file
, " ");
1054 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1055 + regcache
->descr
->sizeof_register
[regnum
]);
1060 fprintf_unfiltered (file
, " %5s ", "Size");
1062 fprintf_unfiltered (file
, " %5ld",
1063 regcache
->descr
->sizeof_register
[regnum
]);
1072 static const char blt
[] = "builtin_type";
1073 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1077 if (!footnote_register_type_name_null
)
1078 footnote_register_type_name_null
= ++footnote_nr
;
1079 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1080 make_cleanup (xfree
, n
);
1083 /* Chop a leading builtin_type. */
1084 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1087 fprintf_unfiltered (file
, " %-15s", t
);
1090 /* Leading space always present. */
1091 fprintf_unfiltered (file
, " ");
1094 if (what_to_dump
== regcache_dump_raw
)
1097 fprintf_unfiltered (file
, "Raw value");
1098 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1099 fprintf_unfiltered (file
, "<cooked>");
1100 else if (!regcache_valid_p (regcache
, regnum
))
1101 fprintf_unfiltered (file
, "<invalid>");
1104 regcache_raw_read (regcache
, regnum
, buf
);
1105 fprintf_unfiltered (file
, "0x");
1106 dump_endian_bytes (file
,
1107 gdbarch_byte_order (gdbarch
), buf
,
1108 regcache
->descr
->sizeof_register
[regnum
]);
1112 /* Value, cooked. */
1113 if (what_to_dump
== regcache_dump_cooked
)
1116 fprintf_unfiltered (file
, "Cooked value");
1119 regcache_cooked_read (regcache
, regnum
, buf
);
1120 fprintf_unfiltered (file
, "0x");
1121 dump_endian_bytes (file
,
1122 gdbarch_byte_order (gdbarch
), buf
,
1123 regcache
->descr
->sizeof_register
[regnum
]);
1127 /* Group members. */
1128 if (what_to_dump
== regcache_dump_groups
)
1131 fprintf_unfiltered (file
, "Groups");
1134 const char *sep
= "";
1135 struct reggroup
*group
;
1136 for (group
= reggroup_next (gdbarch
, NULL
);
1138 group
= reggroup_next (gdbarch
, group
))
1140 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1142 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1149 fprintf_unfiltered (file
, "\n");
1152 if (footnote_register_size
)
1153 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1154 footnote_register_size
);
1155 if (footnote_register_offset
)
1156 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1157 footnote_register_offset
);
1158 if (footnote_register_type_name_null
)
1159 fprintf_unfiltered (file
,
1160 "*%d: Register type's name NULL.\n",
1161 footnote_register_type_name_null
);
1162 do_cleanups (cleanups
);
1166 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1169 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1172 struct cleanup
*cleanups
;
1173 struct ui_file
*file
= gdb_fopen (args
, "w");
1175 perror_with_name (_("maintenance print architecture"));
1176 cleanups
= make_cleanup_ui_file_delete (file
);
1177 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1178 do_cleanups (cleanups
);
1183 maintenance_print_registers (char *args
, int from_tty
)
1185 regcache_print (args
, regcache_dump_none
);
1189 maintenance_print_raw_registers (char *args
, int from_tty
)
1191 regcache_print (args
, regcache_dump_raw
);
1195 maintenance_print_cooked_registers (char *args
, int from_tty
)
1197 regcache_print (args
, regcache_dump_cooked
);
1201 maintenance_print_register_groups (char *args
, int from_tty
)
1203 regcache_print (args
, regcache_dump_groups
);
1206 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1209 _initialize_regcache (void)
1211 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1213 observer_attach_target_changed (regcache_observer_target_changed
);
1214 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1216 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1217 _("Force gdb to flush its register cache (maintainer command)"));
1219 add_cmd ("registers", class_maintenance
, maintenance_print_registers
, _("\
1220 Print the internal register configuration.\n\
1221 Takes an optional file parameter."), &maintenanceprintlist
);
1222 add_cmd ("raw-registers", class_maintenance
,
1223 maintenance_print_raw_registers
, _("\
1224 Print the internal register configuration including raw values.\n\
1225 Takes an optional file parameter."), &maintenanceprintlist
);
1226 add_cmd ("cooked-registers", class_maintenance
,
1227 maintenance_print_cooked_registers
, _("\
1228 Print the internal register configuration including cooked values.\n\
1229 Takes an optional file parameter."), &maintenanceprintlist
);
1230 add_cmd ("register-groups", class_maintenance
,
1231 maintenance_print_register_groups
, _("\
1232 Print the internal register configuration including each register's group.\n\
1233 Takes an optional file parameter."),
1234 &maintenanceprintlist
);