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
)
356 gdb_assert (src
!= NULL
&& dst
!= NULL
);
357 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
358 gdb_assert (src
!= dst
);
359 gdb_assert (src
->readonly_p
|| dst
->readonly_p
);
361 if (!src
->readonly_p
)
362 regcache_save (dst
, do_cooked_read
, src
);
363 else if (!dst
->readonly_p
)
364 regcache_restore (dst
, do_cooked_read
, src
);
366 regcache_cpy_no_passthrough (dst
, src
);
370 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
373 gdb_assert (src
!= NULL
&& dst
!= NULL
);
374 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
375 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
376 move of data into the current regcache. Doing this would be
377 silly - it would mean that valid_p would be completely invalid. */
378 gdb_assert (dst
->readonly_p
);
380 memcpy (dst
->registers
, src
->registers
, dst
->descr
->sizeof_raw_registers
);
381 memcpy (dst
->register_valid_p
, src
->register_valid_p
,
382 dst
->descr
->sizeof_raw_register_valid_p
);
386 regcache_dup (struct regcache
*src
)
388 struct regcache
*newbuf
;
389 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
390 regcache_cpy (newbuf
, src
);
395 regcache_dup_no_passthrough (struct regcache
*src
)
397 struct regcache
*newbuf
;
398 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
, get_regcache_aspace (src
));
399 regcache_cpy_no_passthrough (newbuf
, src
);
404 regcache_valid_p (const struct regcache
*regcache
, int regnum
)
406 gdb_assert (regcache
!= NULL
);
407 gdb_assert (regnum
>= 0);
408 if (regcache
->readonly_p
)
409 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
411 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
413 return regcache
->register_valid_p
[regnum
];
417 regcache_invalidate (struct regcache
*regcache
, int regnum
)
419 gdb_assert (regcache
!= NULL
);
420 gdb_assert (regnum
>= 0);
421 gdb_assert (!regcache
->readonly_p
);
422 gdb_assert (regnum
< regcache
->descr
->nr_raw_registers
);
423 regcache
->register_valid_p
[regnum
] = 0;
427 /* Global structure containing the current regcache. */
429 /* NOTE: this is a write-through cache. There is no "dirty" bit for
430 recording if the register values have been changed (eg. by the
431 user). Therefore all registers must be written back to the
432 target when appropriate. */
436 struct regcache
*regcache
;
437 struct regcache_list
*next
;
440 static struct regcache_list
*current_regcache
;
443 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
445 struct regcache_list
*list
;
446 struct regcache
*new_regcache
;
448 for (list
= current_regcache
; list
; list
= list
->next
)
449 if (ptid_equal (list
->regcache
->ptid
, ptid
)
450 && get_regcache_arch (list
->regcache
) == gdbarch
)
451 return list
->regcache
;
453 new_regcache
= regcache_xmalloc (gdbarch
,
454 target_thread_address_space (ptid
));
455 new_regcache
->readonly_p
= 0;
456 new_regcache
->ptid
= ptid
;
457 gdb_assert (new_regcache
->aspace
!= NULL
);
459 list
= xmalloc (sizeof (struct regcache_list
));
460 list
->regcache
= new_regcache
;
461 list
->next
= current_regcache
;
462 current_regcache
= list
;
467 static ptid_t current_thread_ptid
;
468 static struct gdbarch
*current_thread_arch
;
471 get_thread_regcache (ptid_t ptid
)
473 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
475 current_thread_ptid
= ptid
;
476 current_thread_arch
= target_thread_architecture (ptid
);
479 return get_thread_arch_regcache (ptid
, current_thread_arch
);
483 get_current_regcache (void)
485 return get_thread_regcache (inferior_ptid
);
489 /* Observer for the target_changed event. */
492 regcache_observer_target_changed (struct target_ops
*target
)
494 registers_changed ();
497 /* Update global variables old ptids to hold NEW_PTID if they were
500 regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
502 struct regcache_list
*list
;
504 for (list
= current_regcache
; list
; list
= list
->next
)
505 if (ptid_equal (list
->regcache
->ptid
, old_ptid
))
506 list
->regcache
->ptid
= new_ptid
;
509 /* Low level examining and depositing of registers.
511 The caller is responsible for making sure that the inferior is
512 stopped before calling the fetching routines, or it will get
513 garbage. (a change from GDB version 3, in which the caller got the
514 value from the last stop). */
516 /* REGISTERS_CHANGED ()
518 Indicate that registers may have changed, so invalidate the cache. */
521 registers_changed_ptid (ptid_t ptid
)
523 struct regcache_list
*list
, **list_link
;
525 list
= current_regcache
;
526 list_link
= ¤t_regcache
;
529 if (ptid_match (list
->regcache
->ptid
, ptid
))
531 struct regcache_list
*dead
= list
;
533 *list_link
= list
->next
;
534 regcache_xfree (list
->regcache
);
540 list_link
= &list
->next
;
544 current_regcache
= NULL
;
546 current_thread_ptid
= null_ptid
;
547 current_thread_arch
= NULL
;
549 /* Need to forget about any frames we have cached, too. */
550 reinit_frame_cache ();
552 /* Force cleanup of any alloca areas if using C alloca instead of
553 a builtin alloca. This particular call is used to clean up
554 areas allocated by low level target code which may build up
555 during lengthy interactions between gdb and the target before
556 gdb gives control to the user (ie watchpoints). */
561 registers_changed (void)
563 registers_changed_ptid (minus_one_ptid
);
567 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
569 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
570 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
571 /* Make certain that the register cache is up-to-date with respect
572 to the current thread. This switching shouldn't be necessary
573 only there is still only one target side register cache. Sigh!
574 On the bright side, at least there is a regcache object. */
575 if (!regcache
->readonly_p
)
577 if (!regcache_valid_p (regcache
, regnum
))
579 struct cleanup
*old_chain
= save_inferior_ptid ();
580 inferior_ptid
= regcache
->ptid
;
581 target_fetch_registers (regcache
, regnum
);
582 do_cleanups (old_chain
);
585 /* FIXME: cagney/2004-08-07: At present a number of targets
586 forget (or didn't know that they needed) to set this leading to
587 panics. Also is the problem that targets need to indicate
588 that a register is in one of the possible states: valid,
589 undefined, unknown. The last of which isn't yet
591 gdb_assert (regcache_valid_p (regcache
, regnum
));
594 /* Copy the value directly into the register cache. */
595 memcpy (buf
, register_buffer (regcache
, regnum
),
596 regcache
->descr
->sizeof_register
[regnum
]);
600 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
603 gdb_assert (regcache
!= NULL
);
604 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
605 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
606 regcache_raw_read (regcache
, regnum
, buf
);
607 (*val
) = extract_signed_integer
608 (buf
, regcache
->descr
->sizeof_register
[regnum
],
609 gdbarch_byte_order (regcache
->descr
->gdbarch
));
613 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
617 gdb_assert (regcache
!= NULL
);
618 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
619 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
620 regcache_raw_read (regcache
, regnum
, buf
);
621 (*val
) = extract_unsigned_integer
622 (buf
, regcache
->descr
->sizeof_register
[regnum
],
623 gdbarch_byte_order (regcache
->descr
->gdbarch
));
627 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
630 gdb_assert (regcache
!= NULL
);
631 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
632 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
633 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
634 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
635 regcache_raw_write (regcache
, regnum
, buf
);
639 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
643 gdb_assert (regcache
!= NULL
);
644 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_raw_registers
);
645 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
646 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
647 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
648 regcache_raw_write (regcache
, regnum
, buf
);
652 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
654 gdb_assert (regnum
>= 0);
655 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
656 if (regnum
< regcache
->descr
->nr_raw_registers
)
657 regcache_raw_read (regcache
, regnum
, buf
);
658 else if (regcache
->readonly_p
659 && regnum
< regcache
->descr
->nr_cooked_registers
660 && regcache
->register_valid_p
[regnum
])
661 /* Read-only register cache, perhaps the cooked value was cached? */
662 memcpy (buf
, register_buffer (regcache
, regnum
),
663 regcache
->descr
->sizeof_register
[regnum
]);
665 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
670 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
674 gdb_assert (regcache
!= NULL
);
675 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
676 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
677 regcache_cooked_read (regcache
, regnum
, buf
);
678 (*val
) = extract_signed_integer
679 (buf
, regcache
->descr
->sizeof_register
[regnum
],
680 gdbarch_byte_order (regcache
->descr
->gdbarch
));
684 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
688 gdb_assert (regcache
!= NULL
);
689 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_cooked_registers
);
690 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
691 regcache_cooked_read (regcache
, regnum
, buf
);
692 (*val
) = extract_unsigned_integer
693 (buf
, regcache
->descr
->sizeof_register
[regnum
],
694 gdbarch_byte_order (regcache
->descr
->gdbarch
));
698 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
702 gdb_assert (regcache
!= NULL
);
703 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
704 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
705 store_signed_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
706 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
707 regcache_cooked_write (regcache
, regnum
, buf
);
711 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
715 gdb_assert (regcache
!= NULL
);
716 gdb_assert (regnum
>=0 && regnum
< regcache
->descr
->nr_cooked_registers
);
717 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
718 store_unsigned_integer (buf
, regcache
->descr
->sizeof_register
[regnum
],
719 gdbarch_byte_order (regcache
->descr
->gdbarch
), val
);
720 regcache_cooked_write (regcache
, regnum
, buf
);
724 regcache_raw_write (struct regcache
*regcache
, int regnum
,
727 struct cleanup
*old_chain
;
729 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
730 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
731 gdb_assert (!regcache
->readonly_p
);
733 /* On the sparc, writing %g0 is a no-op, so we don't even want to
734 change the registers array if something writes to this register. */
735 if (gdbarch_cannot_store_register (get_regcache_arch (regcache
), regnum
))
738 /* If we have a valid copy of the register, and new value == old
739 value, then don't bother doing the actual store. */
740 if (regcache_valid_p (regcache
, regnum
)
741 && (memcmp (register_buffer (regcache
, regnum
), buf
,
742 regcache
->descr
->sizeof_register
[regnum
]) == 0))
745 old_chain
= save_inferior_ptid ();
746 inferior_ptid
= regcache
->ptid
;
748 target_prepare_to_store (regcache
);
749 memcpy (register_buffer (regcache
, regnum
), buf
,
750 regcache
->descr
->sizeof_register
[regnum
]);
751 regcache
->register_valid_p
[regnum
] = 1;
752 target_store_registers (regcache
, regnum
);
754 do_cleanups (old_chain
);
758 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
761 gdb_assert (regnum
>= 0);
762 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
763 if (regnum
< regcache
->descr
->nr_raw_registers
)
764 regcache_raw_write (regcache
, regnum
, buf
);
766 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
770 /* Perform a partial register transfer using a read, modify, write
773 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
775 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
779 regcache_xfer_part (struct regcache
*regcache
, int regnum
,
780 int offset
, int len
, void *in
, const void *out
,
781 void (*read
) (struct regcache
*regcache
, int regnum
,
783 void (*write
) (struct regcache
*regcache
, int regnum
,
784 const gdb_byte
*buf
))
786 struct regcache_descr
*descr
= regcache
->descr
;
787 gdb_byte reg
[MAX_REGISTER_SIZE
];
788 gdb_assert (offset
>= 0 && offset
<= descr
->sizeof_register
[regnum
]);
789 gdb_assert (len
>= 0 && offset
+ len
<= descr
->sizeof_register
[regnum
]);
790 /* Something to do? */
791 if (offset
+ len
== 0)
793 /* Read (when needed) ... */
796 || offset
+ len
< descr
->sizeof_register
[regnum
])
798 gdb_assert (read
!= NULL
);
799 read (regcache
, regnum
, reg
);
803 memcpy (in
, reg
+ offset
, len
);
805 memcpy (reg
+ offset
, out
, len
);
806 /* ... write (when needed). */
809 gdb_assert (write
!= NULL
);
810 write (regcache
, regnum
, reg
);
815 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
816 int offset
, int len
, gdb_byte
*buf
)
818 struct regcache_descr
*descr
= regcache
->descr
;
819 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
820 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
821 regcache_raw_read
, regcache_raw_write
);
825 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
826 int offset
, int len
, const gdb_byte
*buf
)
828 struct regcache_descr
*descr
= regcache
->descr
;
829 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_raw_registers
);
830 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
831 regcache_raw_read
, regcache_raw_write
);
835 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
836 int offset
, int len
, gdb_byte
*buf
)
838 struct regcache_descr
*descr
= regcache
->descr
;
839 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
840 regcache_xfer_part (regcache
, regnum
, offset
, len
, buf
, NULL
,
841 regcache_cooked_read
, regcache_cooked_write
);
845 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
846 int offset
, int len
, const gdb_byte
*buf
)
848 struct regcache_descr
*descr
= regcache
->descr
;
849 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
850 regcache_xfer_part (regcache
, regnum
, offset
, len
, NULL
, buf
,
851 regcache_cooked_read
, regcache_cooked_write
);
854 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
857 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
862 gdb_assert (regcache
!= NULL
);
863 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
864 gdb_assert (!regcache
->readonly_p
);
866 regbuf
= register_buffer (regcache
, regnum
);
867 size
= regcache
->descr
->sizeof_register
[regnum
];
870 memcpy (regbuf
, buf
, size
);
872 memset (regbuf
, 0, size
);
874 /* Mark the register as cached. */
875 regcache
->register_valid_p
[regnum
] = 1;
878 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
881 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
886 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
887 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
889 regbuf
= register_buffer (regcache
, regnum
);
890 size
= regcache
->descr
->sizeof_register
[regnum
];
891 memcpy (buf
, regbuf
, size
);
895 /* Special handling for register PC. */
898 regcache_read_pc (struct regcache
*regcache
)
900 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
904 if (gdbarch_read_pc_p (gdbarch
))
905 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
906 /* Else use per-frame method on get_current_frame. */
907 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
910 regcache_cooked_read_unsigned (regcache
,
911 gdbarch_pc_regnum (gdbarch
),
913 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
916 internal_error (__FILE__
, __LINE__
,
917 _("regcache_read_pc: Unable to find PC"));
922 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
924 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
926 if (gdbarch_write_pc_p (gdbarch
))
927 gdbarch_write_pc (gdbarch
, regcache
, pc
);
928 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
929 regcache_cooked_write_unsigned (regcache
,
930 gdbarch_pc_regnum (gdbarch
), pc
);
932 internal_error (__FILE__
, __LINE__
,
933 _("regcache_write_pc: Unable to update PC"));
935 /* Writing the PC (for instance, from "load") invalidates the
937 reinit_frame_cache ();
942 reg_flush_command (char *command
, int from_tty
)
944 /* Force-flush the register cache. */
945 registers_changed ();
947 printf_filtered (_("Register cache flushed.\n"));
951 dump_endian_bytes (struct ui_file
*file
, enum bfd_endian endian
,
952 const unsigned char *buf
, long len
)
958 for (i
= 0; i
< len
; i
++)
959 fprintf_unfiltered (file
, "%02x", buf
[i
]);
961 case BFD_ENDIAN_LITTLE
:
962 for (i
= len
- 1; i
>= 0; i
--)
963 fprintf_unfiltered (file
, "%02x", buf
[i
]);
966 internal_error (__FILE__
, __LINE__
, _("Bad switch"));
970 enum regcache_dump_what
972 regcache_dump_none
, regcache_dump_raw
, regcache_dump_cooked
, regcache_dump_groups
976 regcache_dump (struct regcache
*regcache
, struct ui_file
*file
,
977 enum regcache_dump_what what_to_dump
)
979 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
980 struct gdbarch
*gdbarch
= regcache
->descr
->gdbarch
;
983 int footnote_register_size
= 0;
984 int footnote_register_offset
= 0;
985 int footnote_register_type_name_null
= 0;
986 long register_offset
= 0;
987 unsigned char buf
[MAX_REGISTER_SIZE
];
990 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
991 regcache
->descr
->nr_raw_registers
);
992 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
993 regcache
->descr
->nr_cooked_registers
);
994 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
995 regcache
->descr
->sizeof_raw_registers
);
996 fprintf_unfiltered (file
, "sizeof_raw_register_valid_p %ld\n",
997 regcache
->descr
->sizeof_raw_register_valid_p
);
998 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
999 gdbarch_num_regs (gdbarch
));
1000 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1001 gdbarch_num_pseudo_regs (gdbarch
));
1004 gdb_assert (regcache
->descr
->nr_cooked_registers
1005 == (gdbarch_num_regs (gdbarch
)
1006 + gdbarch_num_pseudo_regs (gdbarch
)));
1008 for (regnum
= -1; regnum
< regcache
->descr
->nr_cooked_registers
; regnum
++)
1012 fprintf_unfiltered (file
, " %-10s", "Name");
1015 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1018 else if (p
[0] == '\0')
1020 fprintf_unfiltered (file
, " %-10s", p
);
1025 fprintf_unfiltered (file
, " %4s", "Nr");
1027 fprintf_unfiltered (file
, " %4d", regnum
);
1029 /* Relative number. */
1031 fprintf_unfiltered (file
, " %4s", "Rel");
1032 else if (regnum
< gdbarch_num_regs (gdbarch
))
1033 fprintf_unfiltered (file
, " %4d", regnum
);
1035 fprintf_unfiltered (file
, " %4d",
1036 (regnum
- gdbarch_num_regs (gdbarch
)));
1040 fprintf_unfiltered (file
, " %6s ", "Offset");
1043 fprintf_unfiltered (file
, " %6ld",
1044 regcache
->descr
->register_offset
[regnum
]);
1045 if (register_offset
!= regcache
->descr
->register_offset
[regnum
]
1047 && (regcache
->descr
->register_offset
[regnum
]
1048 != (regcache
->descr
->register_offset
[regnum
- 1]
1049 + regcache
->descr
->sizeof_register
[regnum
- 1])))
1052 if (!footnote_register_offset
)
1053 footnote_register_offset
= ++footnote_nr
;
1054 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1057 fprintf_unfiltered (file
, " ");
1058 register_offset
= (regcache
->descr
->register_offset
[regnum
]
1059 + regcache
->descr
->sizeof_register
[regnum
]);
1064 fprintf_unfiltered (file
, " %5s ", "Size");
1066 fprintf_unfiltered (file
, " %5ld",
1067 regcache
->descr
->sizeof_register
[regnum
]);
1076 static const char blt
[] = "builtin_type";
1077 t
= TYPE_NAME (register_type (regcache
->descr
->gdbarch
, regnum
));
1081 if (!footnote_register_type_name_null
)
1082 footnote_register_type_name_null
= ++footnote_nr
;
1083 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1084 make_cleanup (xfree
, n
);
1087 /* Chop a leading builtin_type. */
1088 if (strncmp (t
, blt
, strlen (blt
)) == 0)
1091 fprintf_unfiltered (file
, " %-15s", t
);
1094 /* Leading space always present. */
1095 fprintf_unfiltered (file
, " ");
1098 if (what_to_dump
== regcache_dump_raw
)
1101 fprintf_unfiltered (file
, "Raw value");
1102 else if (regnum
>= regcache
->descr
->nr_raw_registers
)
1103 fprintf_unfiltered (file
, "<cooked>");
1104 else if (!regcache_valid_p (regcache
, regnum
))
1105 fprintf_unfiltered (file
, "<invalid>");
1108 regcache_raw_read (regcache
, regnum
, buf
);
1109 fprintf_unfiltered (file
, "0x");
1110 dump_endian_bytes (file
,
1111 gdbarch_byte_order (gdbarch
), buf
,
1112 regcache
->descr
->sizeof_register
[regnum
]);
1116 /* Value, cooked. */
1117 if (what_to_dump
== regcache_dump_cooked
)
1120 fprintf_unfiltered (file
, "Cooked value");
1123 regcache_cooked_read (regcache
, regnum
, buf
);
1124 fprintf_unfiltered (file
, "0x");
1125 dump_endian_bytes (file
,
1126 gdbarch_byte_order (gdbarch
), buf
,
1127 regcache
->descr
->sizeof_register
[regnum
]);
1131 /* Group members. */
1132 if (what_to_dump
== regcache_dump_groups
)
1135 fprintf_unfiltered (file
, "Groups");
1138 const char *sep
= "";
1139 struct reggroup
*group
;
1140 for (group
= reggroup_next (gdbarch
, NULL
);
1142 group
= reggroup_next (gdbarch
, group
))
1144 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1146 fprintf_unfiltered (file
, "%s%s", sep
, reggroup_name (group
));
1153 fprintf_unfiltered (file
, "\n");
1156 if (footnote_register_size
)
1157 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1158 footnote_register_size
);
1159 if (footnote_register_offset
)
1160 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1161 footnote_register_offset
);
1162 if (footnote_register_type_name_null
)
1163 fprintf_unfiltered (file
,
1164 "*%d: Register type's name NULL.\n",
1165 footnote_register_type_name_null
);
1166 do_cleanups (cleanups
);
1170 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1173 regcache_dump (get_current_regcache (), gdb_stdout
, what_to_dump
);
1176 struct cleanup
*cleanups
;
1177 struct ui_file
*file
= gdb_fopen (args
, "w");
1179 perror_with_name (_("maintenance print architecture"));
1180 cleanups
= make_cleanup_ui_file_delete (file
);
1181 regcache_dump (get_current_regcache (), file
, what_to_dump
);
1182 do_cleanups (cleanups
);
1187 maintenance_print_registers (char *args
, int from_tty
)
1189 regcache_print (args
, regcache_dump_none
);
1193 maintenance_print_raw_registers (char *args
, int from_tty
)
1195 regcache_print (args
, regcache_dump_raw
);
1199 maintenance_print_cooked_registers (char *args
, int from_tty
)
1201 regcache_print (args
, regcache_dump_cooked
);
1205 maintenance_print_register_groups (char *args
, int from_tty
)
1207 regcache_print (args
, regcache_dump_groups
);
1210 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1213 _initialize_regcache (void)
1215 regcache_descr_handle
= gdbarch_data_register_post_init (init_regcache_descr
);
1217 observer_attach_target_changed (regcache_observer_target_changed
);
1218 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed
);
1220 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1221 _("Force gdb to flush its register cache (maintainer command)"));
1223 add_cmd ("registers", class_maintenance
, maintenance_print_registers
, _("\
1224 Print the internal register configuration.\n\
1225 Takes an optional file parameter."), &maintenanceprintlist
);
1226 add_cmd ("raw-registers", class_maintenance
,
1227 maintenance_print_raw_registers
, _("\
1228 Print the internal register configuration including raw values.\n\
1229 Takes an optional file parameter."), &maintenanceprintlist
);
1230 add_cmd ("cooked-registers", class_maintenance
,
1231 maintenance_print_cooked_registers
, _("\
1232 Print the internal register configuration including cooked values.\n\
1233 Takes an optional file parameter."), &maintenanceprintlist
);
1234 add_cmd ("register-groups", class_maintenance
,
1235 maintenance_print_register_groups
, _("\
1236 Print the internal register configuration including each register's group.\n\
1237 Takes an optional file parameter."),
1238 &maintenanceprintlist
);