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, 2011 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. */
32 #include "exceptions.h"
37 * Here is the actual register cache.
40 /* Per-architecture object describing the layout of a register cache.
41 Computed once when the architecture is created. */
43 struct gdbarch_data
*regcache_descr_handle
;
47 /* The architecture this descriptor belongs to. */
48 struct gdbarch
*gdbarch
;
50 /* The raw register cache. Each raw (or hard) register is supplied
51 by the target interface. The raw cache should not contain
52 redundant information - if the PC is constructed from two
53 registers then those registers and not the PC lives in the raw
56 long sizeof_raw_registers
;
57 long sizeof_raw_register_status
;
59 /* The cooked register space. Each cooked register in the range
60 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
61 register. The remaining [NR_RAW_REGISTERS
62 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
63 both raw registers and memory by the architecture methods
64 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
65 int nr_cooked_registers
;
66 long sizeof_cooked_registers
;
67 long sizeof_cooked_register_status
;
69 /* Offset and size (in 8 bit bytes), of reach register in the
70 register cache. All registers (including those in the range
71 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
73 long *register_offset
;
74 long *sizeof_register
;
76 /* Cached table containing the type of each register. */
77 struct type
**register_type
;
81 init_regcache_descr (struct gdbarch
*gdbarch
)
84 struct regcache_descr
*descr
;
85 gdb_assert (gdbarch
!= NULL
);
87 /* Create an initial, zero filled, table. */
88 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
89 descr
->gdbarch
= gdbarch
;
91 /* Total size of the register space. The raw registers are mapped
92 directly onto the raw register cache while the pseudo's are
93 either mapped onto raw-registers or memory. */
94 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
95 + gdbarch_num_pseudo_regs (gdbarch
);
96 descr
->sizeof_cooked_register_status
97 = gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
99 /* Fill in a table of register types. */
101 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
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
= gdbarch_num_regs (gdbarch
);
109 descr
->sizeof_raw_register_status
= gdbarch_num_regs (gdbarch
);
111 /* Lay out the register cache.
113 NOTE: cagney/2002-05-22: Only register_type() is used when
114 constructing the register cache. It is assumed that the
115 register's raw size, virtual size and type length are all the
121 descr
->sizeof_register
122 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
123 descr
->register_offset
124 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
125 for (i
= 0; i
< descr
->nr_raw_registers
; i
++)
127 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
128 descr
->register_offset
[i
] = offset
;
129 offset
+= descr
->sizeof_register
[i
];
130 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
132 /* Set the real size of the raw register cache buffer. */
133 descr
->sizeof_raw_registers
= offset
;
135 for (; i
< descr
->nr_cooked_registers
; i
++)
137 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
138 descr
->register_offset
[i
] = offset
;
139 offset
+= descr
->sizeof_register
[i
];
140 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
142 /* Set the real size of the readonly register cache buffer. */
143 descr
->sizeof_cooked_registers
= offset
;
149 static struct regcache_descr
*
150 regcache_descr (struct gdbarch
*gdbarch
)
152 return gdbarch_data (gdbarch
, regcache_descr_handle
);
155 /* Utility functions returning useful register attributes stored in
156 the regcache descr. */
159 register_type (struct gdbarch
*gdbarch
, int regnum
)
161 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
);
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 signed char *register_status
;
199 /* Is this a read-only cache? A read-only cache is used for saving
200 the target's register state (e.g, across an inferior function
201 call or just before forcing a function return). A read-only
202 cache can only be updated via the methods regcache_dup() and
203 regcache_cpy(). The actual contents are determined by the
204 reggroup_save and reggroup_restore methods. */
206 /* If this is a read-write cache, which thread's registers is
211 static struct regcache
*
212 regcache_xmalloc_1 (struct gdbarch
*gdbarch
, struct address_space
*aspace
,
215 struct regcache_descr
*descr
;
216 struct regcache
*regcache
;
218 gdb_assert (gdbarch
!= NULL
);
219 descr
= regcache_descr (gdbarch
);
220 regcache
= XMALLOC (struct regcache
);
221 regcache
->descr
= descr
;
222 regcache
->readonly_p
= readonly_p
;
226 = XCALLOC (descr
->sizeof_cooked_registers
, gdb_byte
);
227 regcache
->register_status
228 = XCALLOC (descr
->sizeof_cooked_register_status
, gdb_byte
);
233 = XCALLOC (descr
->sizeof_raw_registers
, gdb_byte
);
234 regcache
->register_status
235 = XCALLOC (descr
->sizeof_raw_register_status
, gdb_byte
);
237 regcache
->aspace
= aspace
;
238 regcache
->ptid
= minus_one_ptid
;
243 regcache_xmalloc (struct gdbarch
*gdbarch
, struct address_space
*aspace
)
245 return regcache_xmalloc_1 (gdbarch
, aspace
, 1);
249 regcache_xfree (struct regcache
*regcache
)
251 if (regcache
== NULL
)
253 xfree (regcache
->registers
);
254 xfree (regcache
->register_status
);
259 do_regcache_xfree (void *data
)
261 regcache_xfree (data
);
265 make_cleanup_regcache_xfree (struct regcache
*regcache
)
267 return make_cleanup (do_regcache_xfree
, regcache
);
270 /* Return REGCACHE's architecture. */
273 get_regcache_arch (const struct regcache
*regcache
)
275 return regcache
->descr
->gdbarch
;
278 struct address_space
*
279 get_regcache_aspace (const struct regcache
*regcache
)
281 return regcache
->aspace
;
284 /* Return a pointer to register REGNUM's buffer cache. */
287 register_buffer (const struct regcache
*regcache
, int regnum
)
289 return regcache
->registers
+ regcache
->descr
->register_offset
[regnum
];
293 regcache_save (struct regcache
*dst
, regcache_cooked_read_ftype
*cooked_read
,
296 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
297 gdb_byte buf
[MAX_REGISTER_SIZE
];
300 /* The DST should be `read-only', if it wasn't then the save would
301 end up trying to write the register values back out to the
303 gdb_assert (dst
->readonly_p
);
304 /* Clear the dest. */
305 memset (dst
->registers
, 0, dst
->descr
->sizeof_cooked_registers
);
306 memset (dst
->register_status
, 0,
307 dst
->descr
->sizeof_cooked_register_status
);
308 /* Copy over any registers (identified by their membership in the
309 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
310 gdbarch_num_pseudo_regs) range is checked since some architectures need
311 to save/restore `cooked' registers that live in memory. */
312 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
314 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
316 enum register_status status
= cooked_read (src
, regnum
, buf
);
318 if (status
== REG_VALID
)
319 memcpy (register_buffer (dst
, regnum
), buf
,
320 register_size (gdbarch
, regnum
));
323 gdb_assert (status
!= REG_UNKNOWN
);
325 memset (register_buffer (dst
, regnum
), 0,
326 register_size (gdbarch
, regnum
));
328 dst
->register_status
[regnum
] = status
;
334 regcache_restore (struct regcache
*dst
,
335 regcache_cooked_read_ftype
*cooked_read
,
336 void *cooked_read_context
)
338 struct gdbarch
*gdbarch
= dst
->descr
->gdbarch
;
339 gdb_byte buf
[MAX_REGISTER_SIZE
];
342 /* The dst had better not be read-only. If it is, the `restore'
343 doesn't make much sense. */
344 gdb_assert (!dst
->readonly_p
);
345 /* Copy over any registers, being careful to only restore those that
346 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
347 + gdbarch_num_pseudo_regs) range is checked since some architectures need
348 to save/restore `cooked' registers that live in memory. */
349 for (regnum
= 0; regnum
< dst
->descr
->nr_cooked_registers
; regnum
++)
351 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
353 int valid
= cooked_read (cooked_read_context
, regnum
, buf
);
356 regcache_cooked_write (dst
, regnum
, buf
);
361 static enum register_status
362 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
364 struct regcache
*regcache
= src
;
366 return regcache_cooked_read (regcache
, regnum
, buf
);
370 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
372 gdb_assert (src
!= NULL
&& dst
!= NULL
);
373 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
374 gdb_assert (src
!= dst
);
375 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
377 if (!src
->readonly_p
)
378 regcache_save (dst
, do_cooked_read
, src
);
379 else if (!dst
->readonly_p
)
380 regcache_restore (dst
, do_cooked_read
, src
);
382 regcache_cpy_no_passthrough (dst
, src
);
386 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
388 gdb_assert (src
!= NULL
&& dst
!= NULL
);
389 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
390 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
391 move of data into a thread's regcache. Doing this would be silly
392 - it would mean that regcache->register_status would be
393 completely invalid. */
394 gdb_assert (dst
->readonly_p
&& src
->readonly_p
);
396 memcpy (dst
->registers
, src
->registers
,
397 dst
->descr
->sizeof_cooked_registers
);
398 memcpy (dst
->register_status
, src
->register_status
,
399 dst
->descr
->sizeof_cooked_register_status
);
403 regcache_dup (struct regcache
*src
)
405 struct regcache
*newbuf
;
407 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
408 regcache_cpy (newbuf
, src
);
413 regcache_register_status (const struct regcache
*regcache
, int regnum
)
415 gdb_assert (regcache
!= NULL
);
416 gdb_assert (regnum
>= 0);
417 if (regcache
->readonly_p
)
418 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
420 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
422 return regcache
->register_status
[regnum
];
426 regcache_invalidate (struct regcache
*regcache
, int regnum
)
428 gdb_assert (regcache
!= NULL
);
429 gdb_assert (regnum
>= 0);
430 gdb_assert (!regcache
->readonly_p
);
431 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
432 regcache
->register_status
[regnum
] = REG_UNKNOWN
;
436 /* Global structure containing the current regcache. */
438 /* NOTE: this is a write-through cache. There is no "dirty" bit for
439 recording if the register values have been changed (eg. by the
440 user). Therefore all registers must be written back to the
441 target when appropriate. */
445 struct regcache
*regcache
;
446 struct regcache_list
*next
;
449 static struct regcache_list
*current_regcache
;
452 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
454 struct regcache_list
*list
;
455 struct regcache
*new_regcache
;
457 for (list
= current_regcache
; list
; list
= list
->next
)
458 if (ptid_equal (list
->regcache
->ptid
, ptid
)
459 && get_regcache_arch (list
->regcache
) == gdbarch
)
460 return list
->regcache
;
462 new_regcache
= regcache_xmalloc_1 (gdbarch
,
463 target_thread_address_space (ptid
), 0);
464 new_regcache
->ptid
= ptid
;
465 gdb_assert (new_regcache
->aspace
!= NULL
);
467 list
= xmalloc (sizeof (struct regcache_list
));
468 list
->regcache
= new_regcache
;
469 list
->next
= current_regcache
;
470 current_regcache
= list
;
475 static ptid_t current_thread_ptid
;
476 static struct gdbarch
*current_thread_arch
;
479 get_thread_regcache (ptid_t ptid
)
481 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
483 current_thread_ptid
= ptid
;
484 current_thread_arch
= target_thread_architecture (ptid
);
487 return get_thread_arch_regcache (ptid
, current_thread_arch
);
491 get_current_regcache (void)
493 return get_thread_regcache (inferior_ptid
);
497 /* Observer for the target_changed event. */
500 regcache_observer_target_changed (struct target_ops
*target
)
502 registers_changed ();
505 /* Update global variables old ptids to hold NEW_PTID if they were
508 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
510 struct regcache_list
*list
;
512 for (list
= current_regcache
; list
; list
= list
->next
)
513 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
514 list
->regcache
->ptid
= new_ptid
;
517 /* Low level examining and depositing of registers.
519 The caller is responsible for making sure that the inferior is
520 stopped before calling the fetching routines, or it will get
521 garbage. (a change from GDB version 3, in which the caller got the
522 value from the last stop). */
524 /* REGISTERS_CHANGED ()
526 Indicate that registers may have changed, so invalidate the cache. */
529 registers_changed_ptid (ptid_t ptid
)
531 struct regcache_list
*list
, **list_link
;
532 int wildcard
= ptid_equal (ptid
, minus_one_ptid
);
534 list
= current_regcache
;
535 list_link
= ¤t_regcache
;
538 if (ptid_match (list
->regcache
->ptid
, ptid
))
540 struct regcache_list
*dead
= list
;
542 *list_link
= list
->next
;
543 regcache_xfree (list
->regcache
);
549 list_link
= &list
->next
;
553 if (wildcard
|| ptid_equal (ptid
, current_thread_ptid
))
555 current_thread_ptid
= null_ptid
;
556 current_thread_arch
= NULL
;
559 if (wildcard
|| ptid_equal (ptid
, inferior_ptid
))
561 /* We just deleted the regcache of the current thread. Need to
562 forget about any frames we have cached, too. */
563 reinit_frame_cache ();
568 registers_changed (void)
570 registers_changed_ptid (minus_one_ptid
);
572 /* Force cleanup of any alloca areas if using C alloca instead of
573 a builtin alloca. This particular call is used to clean up
574 areas allocated by low level target code which may build up
575 during lengthy interactions between gdb and the target before
576 gdb gives control to the user (ie watchpoints). */
581 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
583 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
584 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
585 /* Make certain that the register cache is up-to-date with respect
586 to the current thread. This switching shouldn't be necessary
587 only there is still only one target side register cache. Sigh!
588 On the bright side, at least there is a regcache object. */
589 if (!regcache
->readonly_p
)
591 if (regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
593 struct cleanup
*old_chain
= save_inferior_ptid ();
595 inferior_ptid
= regcache
->ptid
;
596 target_fetch_registers (regcache
, regnum
);
597 do_cleanups (old_chain
);
600 /* FIXME: cagney/2004-08-07: At present a number of targets
601 forget (or didn't know that they needed) to set this leading to
602 panics. Also is the problem that targets need to indicate
603 that a register is in one of the possible states: valid,
604 undefined, unknown. The last of which isn't yet
606 gdb_assert (regcache_register_status (regcache
, regnum
) == REG_VALID
);
610 if (regcache
->register_status
[regnum
] != REG_VALID
)
611 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
613 memcpy (buf
, register_buffer (regcache
, regnum
),
614 regcache
->descr
->sizeof_register
[regnum
]);
616 return regcache
->register_status
[regnum
];
620 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
623 enum register_status status
;
625 gdb_assert (regcache
!= NULL
);
626 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
627 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
628 status
= regcache_raw_read (regcache
, regnum
, buf
);
629 if (status
== REG_VALID
)
630 *val
= extract_signed_integer
631 (buf
, regcache
->descr
->sizeof_register
[regnum
],
632 gdbarch_byte_order (regcache
->descr
->gdbarch
));
639 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
643 enum register_status status
;
645 gdb_assert (regcache
!= NULL
);
646 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
647 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
648 status
= regcache_raw_read (regcache
, regnum
, buf
);
649 if (status
== REG_VALID
)
650 *val
= extract_unsigned_integer
651 (buf
, regcache
->descr
->sizeof_register
[regnum
],
652 gdbarch_byte_order (regcache
->descr
->gdbarch
));
659 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
663 gdb_assert (regcache
!= NULL
);
664 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
665 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
666 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
667 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
668 regcache_raw_write (regcache
, regnum
, buf
);
672 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
677 gdb_assert (regcache
!= NULL
);
678 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
679 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
680 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
681 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
682 regcache_raw_write (regcache
, regnum
, buf
);
686 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
688 gdb_assert (regnum
>= 0);
689 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
690 if (regnum
< regcache
->descr
->nr_raw_registers
)
691 return regcache_raw_read (regcache
, regnum
, buf
);
692 else if (regcache
->readonly_p
693 && regcache
->register_status
[regnum
] != REG_UNKNOWN
)
695 /* Read-only register cache, perhaps the cooked value was
697 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
699 if (regcache
->register_status
[regnum
] == REG_VALID
)
700 memcpy (buf
, register_buffer (regcache
, regnum
),
701 regcache
->descr
->sizeof_register
[regnum
]);
703 memset (buf
, 0, regcache
->descr
->sizeof_register
[regnum
]);
705 return regcache
->register_status
[regnum
];
708 return gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
713 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
716 enum register_status status
;
719 gdb_assert (regcache
!= NULL
);
720 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
721 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
722 status
= regcache_cooked_read (regcache
, regnum
, buf
);
723 if (status
== REG_VALID
)
724 *val
= extract_signed_integer
725 (buf
, regcache
->descr
->sizeof_register
[regnum
],
726 gdbarch_byte_order (regcache
->descr
->gdbarch
));
733 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
736 enum register_status status
;
739 gdb_assert (regcache
!= NULL
);
740 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
741 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
742 status
= regcache_cooked_read (regcache
, regnum
, buf
);
743 if (status
== REG_VALID
)
744 *val
= extract_unsigned_integer
745 (buf
, regcache
->descr
->sizeof_register
[regnum
],
746 gdbarch_byte_order (regcache
->descr
->gdbarch
));
753 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
758 gdb_assert (regcache
!= NULL
);
759 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
760 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
761 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
762 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
763 regcache_cooked_write (regcache
, regnum
, buf
);
767 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
772 gdb_assert (regcache
!= NULL
);
773 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
774 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
775 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
776 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
777 regcache_cooked_write (regcache
, regnum
, buf
);
781 regcache_raw_write (struct regcache
*regcache
, int regnum
,
784 struct cleanup
*old_chain
;
786 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
787 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
788 gdb_assert (!regcache
->readonly_p
);
790 /* On the sparc, writing %g0 is a no-op, so we don't even want to
791 change the registers array if something writes to this register. */
792 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
795 /* If we have a valid copy of the register, and new value == old
796 value, then don't bother doing the actual store. */
797 if (regcache_register_status (regcache
, regnum
) == REG_VALID
798 && (memcmp (register_buffer (regcache
, regnum
), buf
,
799 regcache
->descr
->sizeof_register
[regnum
]) == 0))
802 old_chain
= save_inferior_ptid ();
803 inferior_ptid
= regcache
->ptid
;
805 target_prepare_to_store (regcache
);
806 memcpy (register_buffer (regcache
, regnum
), buf
,
807 regcache
->descr
->sizeof_register
[regnum
]);
808 regcache
->register_status
[regnum
] = REG_VALID
;
809 target_store_registers (regcache
, regnum
);
811 do_cleanups (old_chain
);
815 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
818 gdb_assert (regnum
>= 0);
819 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
820 if (regnum
< regcache
->descr
->nr_raw_registers
)
821 regcache_raw_write (regcache
, regnum
, buf
);
823 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
827 /* Perform a partial register transfer using a read, modify, write
830 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
832 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
835 static enum register_status
836 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
837 int offset
, int len
, void *in
, const void *out
,
838 enum register_status (*read
) (struct regcache
*regcache
,
841 void (*write
) (struct regcache
*regcache
, int regnum
,
842 const gdb_byte
*buf
))
844 struct regcache_descr
*descr
= regcache
->descr
;
845 gdb_byte reg
[MAX_REGISTER_SIZE
];
847 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
848 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
849 /* Something to do? */
850 if (offset
+ len
== 0)
852 /* Read (when needed) ... */
855 || offset
+ len
< descr
->sizeof_register
[regnum
])
857 enum register_status status
;
859 gdb_assert (read
!= NULL
);
860 status
= read (regcache
, regnum
, reg
);
861 if (status
!= REG_VALID
)
866 memcpy (in
, reg
+ offset
, len
);
868 memcpy (reg
+ offset
, out
, len
);
869 /* ... write (when needed). */
872 gdb_assert (write
!= NULL
);
873 write (regcache
, regnum
, reg
);
880 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
881 int offset
, int len
, gdb_byte
*buf
)
883 struct regcache_descr
*descr
= regcache
->descr
;
885 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
886 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
887 regcache_raw_read
, regcache_raw_write
);
891 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
892 int offset
, int len
, const gdb_byte
*buf
)
894 struct regcache_descr
*descr
= regcache
->descr
;
896 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
897 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
898 regcache_raw_read
, regcache_raw_write
);
902 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
903 int offset
, int len
, gdb_byte
*buf
)
905 struct regcache_descr
*descr
= regcache
->descr
;
907 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
908 return regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
909 regcache_cooked_read
, regcache_cooked_write
);
913 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
914 int offset
, int len
, const gdb_byte
*buf
)
916 struct regcache_descr
*descr
= regcache
->descr
;
918 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
919 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
920 regcache_cooked_read
, regcache_cooked_write
);
923 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
926 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
931 gdb_assert (regcache
!= NULL
);
932 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
933 gdb_assert (!regcache
->readonly_p
);
935 regbuf
= register_buffer (regcache
, regnum
);
936 size
= regcache
->descr
->sizeof_register
[regnum
];
940 memcpy (regbuf
, buf
, size
);
941 regcache
->register_status
[regnum
] = REG_VALID
;
945 /* This memset not strictly necessary, but better than garbage
946 in case the register value manages to escape somewhere (due
947 to a bug, no less). */
948 memset (regbuf
, 0, size
);
949 regcache
->register_status
[regnum
] = REG_UNAVAILABLE
;
953 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
956 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
961 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
962 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
964 regbuf
= register_buffer (regcache
, regnum
);
965 size
= regcache
->descr
->sizeof_register
[regnum
];
966 memcpy (buf
, regbuf
, size
);
970 /* Special handling for register PC. */
973 regcache_read_pc (struct regcache
*regcache
)
975 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
979 if (gdbarch_read_pc_p (gdbarch
))
980 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
981 /* Else use per-frame method on get_current_frame. */
982 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
986 if (regcache_cooked_read_unsigned (regcache
,
987 gdbarch_pc_regnum (gdbarch
),
988 &raw_val
) == REG_UNAVAILABLE
)
989 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
991 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
994 internal_error (__FILE__
, __LINE__
,
995 _("regcache_read_pc: Unable to find PC"));
1000 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1002 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1004 if (gdbarch_write_pc_p (gdbarch
))
1005 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1006 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1007 regcache_cooked_write_unsigned (regcache
,
1008 gdbarch_pc_regnum (gdbarch
), pc
);
1010 internal_error (__FILE__
, __LINE__
,
1011 _("regcache_write_pc: Unable to update PC"));
1013 /* Writing the PC (for instance, from "load") invalidates the
1015 reinit_frame_cache ();
1020 reg_flush_command (char *command
, int from_tty
)
1022 /* Force-flush the register cache. */
1023 registers_changed ();
1025 printf_filtered (_("Register cache flushed.\n"));
1029 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
1030 const unsigned char *buf
, long len
)
1036 case BFD_ENDIAN_BIG
:
1037 for (i
= 0; i
< len
; i
++)
1038 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1040 case BFD_ENDIAN_LITTLE
:
1041 for (i
= len
- 1; i
>= 0; i
--)
1042 fprintf_unfiltered (file
, "%02x", buf
[i
]);
1045 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
1049 enum regcache_dump_what
1051 regcache_dump_none
, regcache_dump_raw
,
1052 regcache_dump_cooked
, regcache_dump_groups
1056 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
1057 enum regcache_dump_what what_to_dump
)
1059 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1060 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
1062 int footnote_nr
= 0;
1063 int footnote_register_size
= 0;
1064 int footnote_register_offset
= 0;
1065 int footnote_register_type_name_null
= 0;
1066 long register_offset
= 0;
1067 unsigned char buf
[MAX_REGISTER_SIZE
];
1070 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1071 regcache
->descr
->nr_raw_registers
);
1072 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1073 regcache
->descr
->nr_cooked_registers
);
1074 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1075 regcache
->descr
->sizeof_raw_registers
);
1076 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1077 regcache
->descr
->sizeof_raw_register_status
);
1078 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1079 gdbarch_num_regs (gdbarch
));
1080 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1081 gdbarch_num_pseudo_regs (gdbarch
));
1084 gdb_assert (regcache
->descr
->nr_cooked_registers
1085 == (gdbarch_num_regs (gdbarch
)
1086 + gdbarch_num_pseudo_regs (gdbarch
)));
1088 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1092 fprintf_unfiltered (file
, " %-10s", "Name");
1095 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1099 else if (p
[0] == '\0')
1101 fprintf_unfiltered (file
, " %-10s", p
);
1106 fprintf_unfiltered (file
, " %4s", "Nr");
1108 fprintf_unfiltered (file
, " %4d", regnum
);
1110 /* Relative number. */
1112 fprintf_unfiltered (file
, " %4s", "Rel");
1113 else if (regnum
< gdbarch_num_regs (gdbarch
))
1114 fprintf_unfiltered (file
, " %4d", regnum
);
1116 fprintf_unfiltered (file
, " %4d",
1117 (regnum
- gdbarch_num_regs (gdbarch
)));
1121 fprintf_unfiltered (file
, " %6s ", "Offset");
1124 fprintf_unfiltered (file
, " %6ld",
1125 regcache
->descr
->register_offset
[regnum
]);
1126 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1128 && (regcache
->descr
->register_offset
[regnum
]
1129 != (regcache
->descr
->register_offset
[regnum
- 1]
1130 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1133 if (!footnote_register_offset
)
1134 footnote_register_offset
= ++footnote_nr
;
1135 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1138 fprintf_unfiltered (file
, " ");
1139 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1140 + regcache
->descr
->sizeof_register
[regnum
]);
1145 fprintf_unfiltered (file
, " %5s ", "Size");
1147 fprintf_unfiltered (file
, " %5ld",
1148 regcache
->descr
->sizeof_register
[regnum
]);
1158 static const char blt
[] = "builtin_type";
1160 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1165 if (!footnote_register_type_name_null
)
1166 footnote_register_type_name_null
= ++footnote_nr
;
1167 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1168 make_cleanup (xfree
, n
);
1171 /* Chop a leading builtin_type. */
1172 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1175 fprintf_unfiltered (file
, " %-15s", t
);
1178 /* Leading space always present. */
1179 fprintf_unfiltered (file
, " ");
1182 if (what_to_dump
== regcache_dump_raw
)
1185 fprintf_unfiltered (file
, "Raw value");
1186 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1187 fprintf_unfiltered (file
, "<cooked>");
1188 else if (regcache_register_status (regcache
, regnum
) == REG_UNKNOWN
)
1189 fprintf_unfiltered (file
, "<invalid>");
1190 else if (regcache_register_status (regcache
, regnum
) == REG_UNAVAILABLE
)
1191 fprintf_unfiltered (file
, "<unavailable>");
1194 regcache_raw_read (regcache
, regnum
, buf
);
1195 fprintf_unfiltered (file
, "0x");
1196 dump_endian_bytes (file
,
1197 gdbarch_byte_order (gdbarch
), buf
,
1198 regcache
->descr
->sizeof_register
[regnum
]);
1202 /* Value, cooked. */
1203 if (what_to_dump
== regcache_dump_cooked
)
1206 fprintf_unfiltered (file
, "Cooked value");
1209 enum register_status status
;
1211 status
= regcache_cooked_read (regcache
, regnum
, buf
);
1212 if (status
== REG_UNKNOWN
)
1213 fprintf_unfiltered (file
, "<invalid>");
1214 else if (status
== REG_UNAVAILABLE
)
1215 fprintf_unfiltered (file
, "<unavailable>");
1218 fprintf_unfiltered (file
, "0x");
1219 dump_endian_bytes (file
,
1220 gdbarch_byte_order (gdbarch
), buf
,
1221 regcache
->descr
->sizeof_register
[regnum
]);
1226 /* Group members. */
1227 if (what_to_dump
== regcache_dump_groups
)
1230 fprintf_unfiltered (file
, "Groups");
1233 const char *sep
= "";
1234 struct reggroup
*group
;
1236 for (group
= reggroup_next (gdbarch
, NULL
);
1238 group
= reggroup_next (gdbarch
, group
))
1240 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1242 fprintf_unfiltered (file
,
1243 "%s%s", sep
, reggroup_name (group
));
1250 fprintf_unfiltered (file
, "\n");
1253 if (footnote_register_size
)
1254 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1255 footnote_register_size
);
1256 if (footnote_register_offset
)
1257 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1258 footnote_register_offset
);
1259 if (footnote_register_type_name_null
)
1260 fprintf_unfiltered (file
,
1261 "*%d: Register type's name NULL.\n",
1262 footnote_register_type_name_null
);
1263 do_cleanups (cleanups
);
1267 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1270 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1273 struct cleanup
*cleanups
;
1274 struct ui_file
*file
= gdb_fopen (args
, "w");
1277 perror_with_name (_("maintenance print architecture"));
1278 cleanups
= make_cleanup_ui_file_delete (file
);
1279 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1280 do_cleanups (cleanups
);
1285 maintenance_print_registers (char *args
, int from_tty
)
1287 regcache_print (args
, regcache_dump_none
);
1291 maintenance_print_raw_registers (char *args
, int from_tty
)
1293 regcache_print (args
, regcache_dump_raw
);
1297 maintenance_print_cooked_registers (char *args
, int from_tty
)
1299 regcache_print (args
, regcache_dump_cooked
);
1303 maintenance_print_register_groups (char *args
, int from_tty
)
1305 regcache_print (args
, regcache_dump_groups
);
1308 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1311 _initialize_regcache (void)
1313 regcache_descr_handle
1314 = gdbarch_data_register_post_init (init_regcache_descr
);
1316 observer_attach_target_changed (regcache_observer_target_changed
);
1317 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1319 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1320 _("Force gdb to flush its register cache (maintainer command)"));
1322 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1323 _("Print the internal register configuration.\n"
1324 "Takes an optional file parameter."), &maintenanceprintlist
);
1325 add_cmd ("raw-registers", class_maintenance
,
1326 maintenance_print_raw_registers
,
1327 _("Print the internal register configuration "
1328 "including raw values.\n"
1329 "Takes an optional file parameter."), &maintenanceprintlist
);
1330 add_cmd ("cooked-registers", class_maintenance
,
1331 maintenance_print_cooked_registers
,
1332 _("Print the internal register configuration "
1333 "including cooked values.\n"
1334 "Takes an optional file parameter."), &maintenanceprintlist
);
1335 add_cmd ("register-groups", class_maintenance
,
1336 maintenance_print_register_groups
,
1337 _("Print the internal register configuration "
1338 "including each register's group.\n"
1339 "Takes an optional file parameter."),
1340 &maintenanceprintlist
);