1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4 2001, 2002 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
29 #include "gdb_assert.h"
34 * Here is the actual register cache.
37 /* Per-architecture object describing the layout of a register cache.
38 Computed once when the architecture is created */
40 struct gdbarch_data
*regcache_descr_handle
;
44 /* The architecture this descriptor belongs to. */
45 struct gdbarch
*gdbarch
;
47 /* Is this a ``legacy'' register cache? Such caches reserve space
48 for raw and pseudo registers and allow access to both. */
51 /* The raw register cache. This should contain just [0
52 .. NUM_RAW_REGISTERS). However, for older targets, it contains
53 space for the full [0 .. NUM_RAW_REGISTERS +
54 NUM_PSEUDO_REGISTERS). */
56 long sizeof_raw_registers
;
57 long sizeof_raw_register_valid_p
;
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 regiters) are mapped onto
63 both raw registers and memory by the architecture methods
64 gdbarch_register_read and gdbarch_register_write. */
65 int nr_cooked_registers
;
67 /* Offset and size (in 8 bit bytes), of reach register in the
68 register cache. All registers (including those in the range
69 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
70 Assigning all registers an offset makes it possible to keep
71 legacy code, such as that found in read_register_bytes() and
72 write_register_bytes() working. */
73 long *register_offset
;
74 long *sizeof_register
;
76 /* Useful constant. Largest of all the registers. */
77 long max_register_size
;
81 init_legacy_regcache_descr (struct gdbarch
*gdbarch
)
84 struct regcache_descr
*descr
;
85 /* FIXME: cagney/2002-05-11: gdbarch_data() should take that
86 ``gdbarch'' as a parameter. */
87 gdb_assert (gdbarch
!= NULL
);
89 descr
= XMALLOC (struct regcache_descr
);
90 descr
->gdbarch
= gdbarch
;
93 /* FIXME: cagney/2002-05-11: Shouldn't be including pseudo-registers
94 in the register buffer. Unfortunatly some architectures do. */
95 descr
->nr_cooked_registers
= NUM_REGS
+ NUM_PSEUDO_REGS
;
96 descr
->nr_raw_registers
= descr
->nr_cooked_registers
;
97 descr
->sizeof_raw_register_valid_p
= descr
->nr_cooked_registers
;
99 /* FIXME: cagney/2002-05-11: Instead of using REGISTER_BYTE() this
100 code should compute the offets et.al. at runtime. This currently
101 isn't possible because some targets overlap register locations -
102 see the mess in read_register_bytes() and write_register_bytes()
104 descr
->sizeof_register
= XCALLOC (descr
->nr_cooked_registers
, long);
105 descr
->register_offset
= XCALLOC (descr
->nr_cooked_registers
, long);
106 descr
->max_register_size
= 0;
107 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
109 descr
->register_offset
[i
] = REGISTER_BYTE (i
);
110 descr
->sizeof_register
[i
] = REGISTER_RAW_SIZE (i
);
111 if (descr
->max_register_size
< REGISTER_RAW_SIZE (i
))
112 descr
->max_register_size
= REGISTER_RAW_SIZE (i
);
115 /* Come up with the real size of the registers buffer. */
116 descr
->sizeof_raw_registers
= REGISTER_BYTES
; /* OK use. */
117 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
120 /* Keep extending the buffer so that there is always enough
121 space for all registers. The comparison is necessary since
122 legacy code is free to put registers in random places in the
123 buffer separated by holes. Once REGISTER_BYTE() is killed
124 this can be greatly simplified. */
125 /* FIXME: cagney/2001-12-04: This code shouldn't need to use
126 REGISTER_BYTE(). Unfortunatly, legacy code likes to lay the
127 buffer out so that certain registers just happen to overlap.
128 Ulgh! New targets use gdbarch's register read/write and
129 entirely avoid this uglyness. */
130 regend
= descr
->register_offset
[i
] + descr
->sizeof_register
[i
];
131 if (descr
->sizeof_raw_registers
< regend
)
132 descr
->sizeof_raw_registers
= regend
;
138 init_regcache_descr (struct gdbarch
*gdbarch
)
141 struct regcache_descr
*descr
;
142 gdb_assert (gdbarch
!= NULL
);
144 /* If an old style architecture, construct the register cache
145 description using all the register macros. */
146 if (!gdbarch_pseudo_register_read_p (gdbarch
)
147 && !gdbarch_pseudo_register_write_p (gdbarch
))
148 return init_legacy_regcache_descr (gdbarch
);
150 descr
= XMALLOC (struct regcache_descr
);
151 descr
->gdbarch
= gdbarch
;
154 /* Total size of the register space. The raw registers are mapped
155 directly onto the raw register cache while the pseudo's are
156 either mapped onto raw-registers or memory. */
157 descr
->nr_cooked_registers
= NUM_REGS
+ NUM_PSEUDO_REGS
;
159 /* Construct a strictly RAW register cache. Don't allow pseudo's
160 into the register cache. */
161 descr
->nr_raw_registers
= NUM_REGS
;
162 descr
->sizeof_raw_register_valid_p
= NUM_REGS
;
164 /* Lay out the register cache. The pseud-registers are included in
165 the layout even though their value isn't stored in the register
166 cache. Some code, via read_register_bytes() access a register
167 using an offset/length rather than a register number.
169 NOTE: cagney/2002-05-22: Only REGISTER_VIRTUAL_TYPE() needs to be
170 used when constructing the register cache. It is assumed that
171 register raw size, virtual size and type length of the type are
176 descr
->sizeof_register
= XCALLOC (descr
->nr_cooked_registers
, long);
177 descr
->register_offset
= XCALLOC (descr
->nr_cooked_registers
, long);
178 descr
->max_register_size
= 0;
179 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
181 descr
->sizeof_register
[i
] = TYPE_LENGTH (REGISTER_VIRTUAL_TYPE (i
));
182 descr
->register_offset
[i
] = offset
;
183 offset
+= descr
->sizeof_register
[i
];
184 if (descr
->max_register_size
< descr
->sizeof_register
[i
])
185 descr
->max_register_size
= descr
->sizeof_register
[i
];
187 /* Set the real size of the register cache buffer. */
188 /* FIXME: cagney/2002-05-22: Should only need to allocate space
189 for the raw registers. Unfortunatly some code still accesses
190 the register array directly using the global registers[].
191 Until that code has been purged, play safe and over allocating
192 the register buffer. Ulgh! */
193 descr
->sizeof_raw_registers
= offset
;
194 /* = descr->register_offset[descr->nr_raw_registers]; */
198 /* Sanity check. Confirm that the assumptions about gdbarch are
199 true. The REGCACHE_DESCR_HANDLE is set before doing the checks
200 so that targets using the generic methods supplied by regcache
201 don't go into infinite recursion trying to, again, create the
203 set_gdbarch_data (gdbarch
, regcache_descr_handle
, descr
);
204 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
206 gdb_assert (descr
->sizeof_register
[i
] == REGISTER_RAW_SIZE (i
));
207 gdb_assert (descr
->sizeof_register
[i
] == REGISTER_VIRTUAL_SIZE (i
));
208 gdb_assert (descr
->register_offset
[i
] == REGISTER_BYTE (i
));
210 /* gdb_assert (descr->sizeof_raw_registers == REGISTER_BYTES (i)); */
216 static struct regcache_descr
*
217 regcache_descr (struct gdbarch
*gdbarch
)
219 return gdbarch_data (gdbarch
, regcache_descr_handle
);
223 xfree_regcache_descr (struct gdbarch
*gdbarch
, void *ptr
)
225 struct regcache_descr
*descr
= ptr
;
228 xfree (descr
->register_offset
);
229 xfree (descr
->sizeof_register
);
230 descr
->register_offset
= NULL
;
231 descr
->sizeof_register
= NULL
;
235 /* The register cache for storing raw register values. */
239 struct regcache_descr
*descr
;
241 char *raw_register_valid_p
;
242 /* If a value isn't in the cache should the corresponding target be
243 queried for a value. */
248 regcache_xmalloc (struct gdbarch
*gdbarch
)
250 struct regcache_descr
*descr
;
251 struct regcache
*regcache
;
252 gdb_assert (gdbarch
!= NULL
);
253 descr
= regcache_descr (gdbarch
);
254 regcache
= XMALLOC (struct regcache
);
255 regcache
->descr
= descr
;
256 regcache
->raw_registers
257 = XCALLOC (descr
->sizeof_raw_registers
, char);
258 regcache
->raw_register_valid_p
259 = XCALLOC (descr
->sizeof_raw_register_valid_p
, char);
260 regcache
->passthrough_p
= 0;
265 regcache_xfree (struct regcache
*regcache
)
267 if (regcache
== NULL
)
269 xfree (regcache
->raw_registers
);
270 xfree (regcache
->raw_register_valid_p
);
275 do_regcache_xfree (void *data
)
277 regcache_xfree (data
);
281 make_cleanup_regcache_xfree (struct regcache
*regcache
)
283 return make_cleanup (do_regcache_xfree
, regcache
);
287 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
291 gdb_assert (src
!= NULL
&& dst
!= NULL
);
292 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
293 gdb_assert (src
!= dst
);
294 /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
295 It keeps the existing code working where things rely on going
296 through to the register cache. */
297 if (src
== current_regcache
&& src
->descr
->legacy_p
)
299 /* ULGH!!!! Old way. Use REGISTER bytes and let code below
301 read_register_bytes (0, dst
->raw_registers
, REGISTER_BYTES
);
304 /* FIXME: cagney/2002-05-17: To say this bit is bad is being polite.
305 It keeps the existing code working where things rely on going
306 through to the register cache. */
307 if (dst
== current_regcache
&& dst
->descr
->legacy_p
)
309 /* ULGH!!!! Old way. Use REGISTER bytes and let code below
311 write_register_bytes (0, src
->raw_registers
, REGISTER_BYTES
);
314 buf
= alloca (src
->descr
->max_register_size
);
315 for (i
= 0; i
< src
->descr
->nr_raw_registers
; i
++)
317 /* Should we worry about the valid bit here? */
318 regcache_raw_read (src
, i
, buf
);
319 regcache_raw_write (dst
, i
, buf
);
324 regcache_cpy_no_passthrough (struct regcache
*dst
, struct regcache
*src
)
327 gdb_assert (src
!= NULL
&& dst
!= NULL
);
328 gdb_assert (src
->descr
->gdbarch
== dst
->descr
->gdbarch
);
329 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
330 move of data into the current_regcache(). Doing this would be
331 silly - it would mean that valid_p would be completly invalid. */
332 gdb_assert (dst
!= current_regcache
);
333 memcpy (dst
->raw_registers
, src
->raw_registers
,
334 dst
->descr
->sizeof_raw_registers
);
335 memcpy (dst
->raw_register_valid_p
, src
->raw_register_valid_p
,
336 dst
->descr
->sizeof_raw_register_valid_p
);
340 regcache_dup (struct regcache
*src
)
342 struct regcache
*newbuf
;
343 gdb_assert (current_regcache
!= NULL
);
344 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
345 regcache_cpy (newbuf
, src
);
350 regcache_dup_no_passthrough (struct regcache
*src
)
352 struct regcache
*newbuf
;
353 gdb_assert (current_regcache
!= NULL
);
354 newbuf
= regcache_xmalloc (src
->descr
->gdbarch
);
355 regcache_cpy_no_passthrough (newbuf
, src
);
360 regcache_valid_p (struct regcache
*regcache
, int regnum
)
362 gdb_assert (regcache
!= NULL
);
363 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
364 return regcache
->raw_register_valid_p
[regnum
];
368 regcache_raw_read_as_address (struct regcache
*regcache
, int regnum
)
371 gdb_assert (regcache
!= NULL
);
372 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
373 buf
= alloca (regcache
->descr
->sizeof_register
[regnum
]);
374 regcache_raw_read (regcache
, regnum
, buf
);
375 return extract_address (buf
, regcache
->descr
->sizeof_register
[regnum
]);
379 deprecated_grub_regcache_for_registers (struct regcache
*regcache
)
381 return regcache
->raw_registers
;
385 deprecated_grub_regcache_for_register_valid (struct regcache
*regcache
)
387 return regcache
->raw_register_valid_p
;
390 /* Global structure containing the current regcache. */
391 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
392 register_valid[] currently point into this structure. */
393 struct regcache
*current_regcache
;
395 /* NOTE: this is a write-through cache. There is no "dirty" bit for
396 recording if the register values have been changed (eg. by the
397 user). Therefore all registers must be written back to the
398 target when appropriate. */
400 /* REGISTERS contains the cached register values (in target byte order). */
404 /* REGISTER_VALID is 0 if the register needs to be fetched,
405 1 if it has been fetched, and
406 -1 if the register value was not available.
408 "Not available" indicates that the target is not not able to supply
409 the register at this state. The register may become available at a
410 later time (after the next resume). This often occures when GDB is
411 manipulating a target that contains only a snapshot of the entire
412 system being debugged - some of the registers in such a system may
413 not have been saved. */
415 signed char *register_valid
;
417 /* The thread/process associated with the current set of registers. */
419 static ptid_t registers_ptid
;
427 Returns 0 if the value is not in the cache (needs fetch).
428 >0 if the value is in the cache.
429 <0 if the value is permanently unavailable (don't ask again). */
432 register_cached (int regnum
)
434 return register_valid
[regnum
];
437 /* Record that REGNUM's value is cached if STATE is >0, uncached but
438 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
441 set_register_cached (int regnum
, int state
)
443 register_valid
[regnum
] = state
;
448 invalidate a single register REGNUM in the cache */
450 register_changed (int regnum
)
452 set_register_cached (regnum
, 0);
455 /* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
456 else return a pointer to the start of the cache buffer. */
459 register_buffer (struct regcache
*regcache
, int regnum
)
461 return regcache
->raw_registers
+ regcache
->descr
->register_offset
[regnum
];
464 /* Return whether register REGNUM is a real register. */
467 real_register (int regnum
)
469 return regnum
>= 0 && regnum
< NUM_REGS
;
472 /* Return whether register REGNUM is a pseudo register. */
475 pseudo_register (int regnum
)
477 return regnum
>= NUM_REGS
&& regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
;
480 /* Fetch register REGNUM into the cache. */
483 fetch_register (int regnum
)
485 /* NOTE: cagney/2001-12-04: Legacy targets were using fetch/store
486 pseudo-register as a way of handling registers that needed to be
487 constructed from one or more raw registers. New targets instead
488 use gdbarch register read/write. */
489 if (FETCH_PSEUDO_REGISTER_P ()
490 && pseudo_register (regnum
))
491 FETCH_PSEUDO_REGISTER (regnum
);
493 target_fetch_registers (regnum
);
496 /* Write register REGNUM cached value to the target. */
499 store_register (int regnum
)
501 /* NOTE: cagney/2001-12-04: Legacy targets were using fetch/store
502 pseudo-register as a way of handling registers that needed to be
503 constructed from one or more raw registers. New targets instead
504 use gdbarch register read/write. */
505 if (STORE_PSEUDO_REGISTER_P ()
506 && pseudo_register (regnum
))
507 STORE_PSEUDO_REGISTER (regnum
);
509 target_store_registers (regnum
);
512 /* Low level examining and depositing of registers.
514 The caller is responsible for making sure that the inferior is
515 stopped before calling the fetching routines, or it will get
516 garbage. (a change from GDB version 3, in which the caller got the
517 value from the last stop). */
519 /* REGISTERS_CHANGED ()
521 Indicate that registers may have changed, so invalidate the cache. */
524 registers_changed (void)
528 registers_ptid
= pid_to_ptid (-1);
530 /* Force cleanup of any alloca areas if using C alloca instead of
531 a builtin alloca. This particular call is used to clean up
532 areas allocated by low level target code which may build up
533 during lengthy interactions between gdb and the target before
534 gdb gives control to the user (ie watchpoints). */
537 for (i
= 0; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
538 set_register_cached (i
, 0);
540 if (registers_changed_hook
)
541 registers_changed_hook ();
544 /* REGISTERS_FETCHED ()
546 Indicate that all registers have been fetched, so mark them all valid. */
548 /* NOTE: cagney/2001-12-04: This function does not set valid on the
549 pseudo-register range since pseudo registers are always supplied
550 using supply_register(). */
551 /* FIXME: cagney/2001-12-04: This function is DEPRECATED. The target
552 code was blatting the registers[] array and then calling this.
553 Since targets should only be using supply_register() the need for
554 this function/hack is eliminated. */
557 registers_fetched (void)
561 for (i
= 0; i
< NUM_REGS
; i
++)
562 set_register_cached (i
, 1);
563 /* Do not assume that the pseudo-regs have also been fetched.
564 Fetching all real regs NEVER accounts for pseudo-regs. */
567 /* read_register_bytes and write_register_bytes are generally a *BAD*
568 idea. They are inefficient because they need to check for partial
569 updates, which can only be done by scanning through all of the
570 registers and seeing if the bytes that are being read/written fall
571 inside of an invalid register. [The main reason this is necessary
572 is that register sizes can vary, so a simple index won't suffice.]
573 It is far better to call read_register_gen and write_register_gen
574 if you want to get at the raw register contents, as it only takes a
575 regnum as an argument, and therefore can't do a partial register
578 Prior to the recent fixes to check for partial updates, both read
579 and write_register_bytes always checked to see if any registers
580 were stale, and then called target_fetch_registers (-1) to update
581 the whole set. This caused really slowed things down for remote
584 /* Copy INLEN bytes of consecutive data from registers
585 starting with the INREGBYTE'th byte of register data
586 into memory at MYADDR. */
589 read_register_bytes (int in_start
, char *in_buf
, int in_len
)
591 int in_end
= in_start
+ in_len
;
593 char *reg_buf
= alloca (MAX_REGISTER_RAW_SIZE
);
595 /* See if we are trying to read bytes from out-of-date registers. If so,
596 update just those registers. */
598 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
607 reg_start
= REGISTER_BYTE (regnum
);
608 reg_len
= REGISTER_RAW_SIZE (regnum
);
609 reg_end
= reg_start
+ reg_len
;
611 if (reg_end
<= in_start
|| in_end
<= reg_start
)
612 /* The range the user wants to read doesn't overlap with regnum. */
615 if (REGISTER_NAME (regnum
) != NULL
&& *REGISTER_NAME (regnum
) != '\0')
616 /* Force the cache to fetch the entire register. */
617 read_register_gen (regnum
, reg_buf
);
619 /* Legacy note: even though this register is ``invalid'' we
620 still need to return something. It would appear that some
621 code relies on apparent gaps in the register array also
623 /* FIXME: cagney/2001-08-18: This is just silly. It defeats
624 the entire register read/write flow of control. Must
625 resist temptation to return 0xdeadbeef. */
626 memcpy (reg_buf
, registers
+ reg_start
, reg_len
);
628 /* Legacy note: This function, for some reason, allows a NULL
629 input buffer. If the buffer is NULL, the registers are still
630 fetched, just the final transfer is skipped. */
634 /* start = max (reg_start, in_start) */
635 if (reg_start
> in_start
)
640 /* end = min (reg_end, in_end) */
641 if (reg_end
< in_end
)
646 /* Transfer just the bytes common to both IN_BUF and REG_BUF */
647 for (byte
= start
; byte
< end
; byte
++)
649 in_buf
[byte
- in_start
] = reg_buf
[byte
- reg_start
];
654 /* Read register REGNUM into memory at MYADDR, which must be large
655 enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
656 register is known to be the size of a CORE_ADDR or smaller,
657 read_register can be used instead. */
660 legacy_read_register_gen (int regnum
, char *myaddr
)
662 gdb_assert (regnum
>= 0 && regnum
< (NUM_REGS
+ NUM_PSEUDO_REGS
));
663 if (! ptid_equal (registers_ptid
, inferior_ptid
))
665 registers_changed ();
666 registers_ptid
= inferior_ptid
;
669 if (!register_cached (regnum
))
670 fetch_register (regnum
);
672 memcpy (myaddr
, register_buffer (current_regcache
, regnum
),
673 REGISTER_RAW_SIZE (regnum
));
677 regcache_raw_read (struct regcache
*regcache
, int regnum
, void *buf
)
679 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
680 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
681 if (regcache
->descr
->legacy_p
682 && regcache
->passthrough_p
)
684 gdb_assert (regcache
== current_regcache
);
685 /* For moment, just use underlying legacy code. Ulgh!!! This
686 silently and very indirectly updates the regcache's regcache
687 via the global register_valid[]. */
688 legacy_read_register_gen (regnum
, buf
);
691 /* Make certain that the register cache is up-to-date with respect
692 to the current thread. This switching shouldn't be necessary
693 only there is still only one target side register cache. Sigh!
694 On the bright side, at least there is a regcache object. */
695 if (regcache
->passthrough_p
)
697 gdb_assert (regcache
== current_regcache
);
698 if (! ptid_equal (registers_ptid
, inferior_ptid
))
700 registers_changed ();
701 registers_ptid
= inferior_ptid
;
703 if (!register_cached (regnum
))
704 fetch_register (regnum
);
706 /* Copy the value directly into the register cache. */
707 memcpy (buf
, (regcache
->raw_registers
708 + regcache
->descr
->register_offset
[regnum
]),
709 regcache
->descr
->sizeof_register
[regnum
]);
713 read_register_gen (int regnum
, char *buf
)
715 gdb_assert (current_regcache
!= NULL
);
716 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
717 if (current_regcache
->descr
->legacy_p
)
719 legacy_read_register_gen (regnum
, buf
);
722 regcache_cooked_read (current_regcache
, regnum
, buf
);
726 regcache_cooked_read (struct regcache
*regcache
, int rawnum
, void *buf
)
728 gdb_assert (regnum
>= 0);
729 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
730 if (regnum
< regcache
->descr
->nr_raw_registers
)
731 regcache_raw_read (regcache
, regnum
, buf
);
733 gdbarch_pseudo_register_read (regcache
->descr
->gdbarch
, regcache
,
737 /* Write register REGNUM at MYADDR to the target. MYADDR points at
738 REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
741 legacy_write_register_gen (int regnum
, const void *myaddr
)
744 gdb_assert (regnum
>= 0 && regnum
< (NUM_REGS
+ NUM_PSEUDO_REGS
));
746 /* On the sparc, writing %g0 is a no-op, so we don't even want to
747 change the registers array if something writes to this register. */
748 if (CANNOT_STORE_REGISTER (regnum
))
751 if (! ptid_equal (registers_ptid
, inferior_ptid
))
753 registers_changed ();
754 registers_ptid
= inferior_ptid
;
757 size
= REGISTER_RAW_SIZE (regnum
);
759 if (real_register (regnum
))
761 /* If we have a valid copy of the register, and new value == old
762 value, then don't bother doing the actual store. */
763 if (register_cached (regnum
)
764 && (memcmp (register_buffer (current_regcache
, regnum
), myaddr
, size
)
768 target_prepare_to_store ();
771 memcpy (register_buffer (current_regcache
, regnum
), myaddr
, size
);
773 set_register_cached (regnum
, 1);
774 store_register (regnum
);
778 regcache_raw_write (struct regcache
*regcache
, int regnum
, const void *buf
)
780 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
781 gdb_assert (regnum
>= 0 && regnum
< regcache
->descr
->nr_raw_registers
);
783 if (regcache
->passthrough_p
784 && regcache
->descr
->legacy_p
)
786 /* For moment, just use underlying legacy code. Ulgh!!! This
787 silently and very indirectly updates the regcache's buffers
788 via the globals register_valid[] and registers[]. */
789 gdb_assert (regcache
== current_regcache
);
790 legacy_write_register_gen (regnum
, buf
);
794 /* On the sparc, writing %g0 is a no-op, so we don't even want to
795 change the registers array if something writes to this register. */
796 if (CANNOT_STORE_REGISTER (regnum
))
799 /* Handle the simple case first -> not write through so just store
801 if (!regcache
->passthrough_p
)
803 memcpy ((regcache
->raw_registers
804 + regcache
->descr
->register_offset
[regnum
]), buf
,
805 regcache
->descr
->sizeof_register
[regnum
]);
806 regcache
->raw_register_valid_p
[regnum
] = 1;
810 /* Make certain that the correct cache is selected. */
811 gdb_assert (regcache
== current_regcache
);
812 if (! ptid_equal (registers_ptid
, inferior_ptid
))
814 registers_changed ();
815 registers_ptid
= inferior_ptid
;
818 /* If we have a valid copy of the register, and new value == old
819 value, then don't bother doing the actual store. */
820 if (regcache_valid_p (regcache
, regnum
)
821 && (memcmp (register_buffer (regcache
, regnum
), buf
,
822 regcache
->descr
->sizeof_register
[regnum
]) == 0))
825 target_prepare_to_store ();
826 memcpy (register_buffer (regcache
, regnum
), buf
,
827 regcache
->descr
->sizeof_register
[regnum
]);
828 regcache
->raw_register_valid_p
[regnum
] = 1;
829 store_register (regnum
);
833 write_register_gen (int regnum
, char *buf
)
835 gdb_assert (current_regcache
!= NULL
);
836 gdb_assert (current_regcache
->descr
->gdbarch
== current_gdbarch
);
837 if (current_regcache
->descr
->legacy_p
)
839 legacy_write_register_gen (regnum
, buf
);
842 regcache_cooked_write (current_regcache
, regnum
, buf
);
846 regcache_cooked_write (struct regcache
*regcache
, int rawnum
,
849 gdb_assert (regnum
>= 0);
850 gdb_assert (regnum
< regcache
->descr
->nr_cooked_registers
);
851 if (regnum
< regcache
->descr
->nr_raw_registers
)
852 regcache_raw_write (regcache
, regnum
, buf
);
854 gdbarch_pseudo_register_write (regcache
->descr
->gdbarch
, regcache
,
858 /* Copy INLEN bytes of consecutive data from memory at MYADDR
859 into registers starting with the MYREGSTART'th byte of register data. */
862 write_register_bytes (int myregstart
, char *myaddr
, int inlen
)
864 int myregend
= myregstart
+ inlen
;
867 target_prepare_to_store ();
869 /* Scan through the registers updating any that are covered by the
870 range myregstart<=>myregend using write_register_gen, which does
871 nice things like handling threads, and avoiding updates when the
872 new and old contents are the same. */
874 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
876 int regstart
, regend
;
878 regstart
= REGISTER_BYTE (regnum
);
879 regend
= regstart
+ REGISTER_RAW_SIZE (regnum
);
881 /* Is this register completely outside the range the user is writing? */
882 if (myregend
<= regstart
|| regend
<= myregstart
)
885 /* Is this register completely within the range the user is writing? */
886 else if (myregstart
<= regstart
&& regend
<= myregend
)
887 write_register_gen (regnum
, myaddr
+ (regstart
- myregstart
));
889 /* The register partially overlaps the range being written. */
892 char *regbuf
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
893 /* What's the overlap between this register's bytes and
894 those the caller wants to write? */
895 int overlapstart
= max (regstart
, myregstart
);
896 int overlapend
= min (regend
, myregend
);
898 /* We may be doing a partial update of an invalid register.
899 Update it from the target before scribbling on it. */
900 read_register_gen (regnum
, regbuf
);
902 memcpy (registers
+ overlapstart
,
903 myaddr
+ (overlapstart
- myregstart
),
904 overlapend
- overlapstart
);
906 store_register (regnum
);
912 /* Return the contents of register REGNUM as an unsigned integer. */
915 read_register (int regnum
)
917 char *buf
= alloca (REGISTER_RAW_SIZE (regnum
));
918 read_register_gen (regnum
, buf
);
919 return (extract_unsigned_integer (buf
, REGISTER_RAW_SIZE (regnum
)));
923 read_register_pid (int regnum
, ptid_t ptid
)
929 if (ptid_equal (ptid
, inferior_ptid
))
930 return read_register (regnum
);
932 save_ptid
= inferior_ptid
;
934 inferior_ptid
= ptid
;
936 retval
= read_register (regnum
);
938 inferior_ptid
= save_ptid
;
943 /* Return the contents of register REGNUM as a signed integer. */
946 read_signed_register (int regnum
)
948 void *buf
= alloca (REGISTER_RAW_SIZE (regnum
));
949 read_register_gen (regnum
, buf
);
950 return (extract_signed_integer (buf
, REGISTER_RAW_SIZE (regnum
)));
954 read_signed_register_pid (int regnum
, ptid_t ptid
)
959 if (ptid_equal (ptid
, inferior_ptid
))
960 return read_signed_register (regnum
);
962 save_ptid
= inferior_ptid
;
964 inferior_ptid
= ptid
;
966 retval
= read_signed_register (regnum
);
968 inferior_ptid
= save_ptid
;
973 /* Store VALUE into the raw contents of register number REGNUM. */
976 write_register (int regnum
, LONGEST val
)
980 size
= REGISTER_RAW_SIZE (regnum
);
982 store_signed_integer (buf
, size
, (LONGEST
) val
);
983 write_register_gen (regnum
, buf
);
987 write_register_pid (int regnum
, CORE_ADDR val
, ptid_t ptid
)
991 if (ptid_equal (ptid
, inferior_ptid
))
993 write_register (regnum
, val
);
997 save_ptid
= inferior_ptid
;
999 inferior_ptid
= ptid
;
1001 write_register (regnum
, val
);
1003 inferior_ptid
= save_ptid
;
1006 /* SUPPLY_REGISTER()
1008 Record that register REGNUM contains VAL. This is used when the
1009 value is obtained from the inferior or core dump, so there is no
1010 need to store the value there.
1012 If VAL is a NULL pointer, then it's probably an unsupported register.
1013 We just set its value to all zeros. We might want to record this
1014 fact, and report it to the users of read_register and friends. */
1017 supply_register (int regnum
, const void *val
)
1020 if (! ptid_equal (registers_ptid
, inferior_ptid
))
1022 registers_changed ();
1023 registers_ptid
= inferior_ptid
;
1027 set_register_cached (regnum
, 1);
1029 memcpy (register_buffer (current_regcache
, regnum
), val
,
1030 REGISTER_RAW_SIZE (regnum
));
1032 memset (register_buffer (current_regcache
, regnum
), '\000',
1033 REGISTER_RAW_SIZE (regnum
));
1035 /* On some architectures, e.g. HPPA, there are a few stray bits in
1036 some registers, that the rest of the code would like to ignore. */
1038 /* NOTE: cagney/2001-03-16: The macro CLEAN_UP_REGISTER_VALUE is
1039 going to be deprecated. Instead architectures will leave the raw
1040 register value as is and instead clean things up as they pass
1041 through the method gdbarch_pseudo_register_read() clean up the
1044 #ifdef DEPRECATED_CLEAN_UP_REGISTER_VALUE
1045 DEPRECATED_CLEAN_UP_REGISTER_VALUE \
1046 (regnum
, register_buffer (current_regcache
, regnum
));
1051 regcache_collect (int regnum
, void *buf
)
1053 memcpy (buf
, register_buffer (current_regcache
, regnum
),
1054 REGISTER_RAW_SIZE (regnum
));
1058 /* read_pc, write_pc, read_sp, write_sp, read_fp, etc. Special
1059 handling for registers PC, SP, and FP. */
1061 /* NOTE: cagney/2001-02-18: The functions generic_target_read_pc(),
1062 read_pc_pid(), read_pc(), generic_target_write_pc(),
1063 write_pc_pid(), write_pc(), generic_target_read_sp(), read_sp(),
1064 generic_target_write_sp(), write_sp(), generic_target_read_fp() and
1065 read_fp(), will eventually be moved out of the reg-cache into
1066 either frame.[hc] or to the multi-arch framework. The are not part
1067 of the raw register cache. */
1069 /* This routine is getting awfully cluttered with #if's. It's probably
1070 time to turn this into READ_PC and define it in the tm.h file.
1073 1999-06-08: The following were re-written so that it assumes the
1074 existence of a TARGET_READ_PC et.al. macro. A default generic
1075 version of that macro is made available where needed.
1077 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
1078 by the multi-arch framework, it will eventually be possible to
1079 eliminate the intermediate read_pc_pid(). The client would call
1080 TARGET_READ_PC directly. (cagney). */
1083 generic_target_read_pc (ptid_t ptid
)
1088 CORE_ADDR pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, ptid
));
1092 internal_error (__FILE__
, __LINE__
,
1093 "generic_target_read_pc");
1098 read_pc_pid (ptid_t ptid
)
1100 ptid_t saved_inferior_ptid
;
1103 /* In case ptid != inferior_ptid. */
1104 saved_inferior_ptid
= inferior_ptid
;
1105 inferior_ptid
= ptid
;
1107 pc_val
= TARGET_READ_PC (ptid
);
1109 inferior_ptid
= saved_inferior_ptid
;
1116 return read_pc_pid (inferior_ptid
);
1120 generic_target_write_pc (CORE_ADDR pc
, ptid_t ptid
)
1124 write_register_pid (PC_REGNUM
, pc
, ptid
);
1125 if (NPC_REGNUM
>= 0)
1126 write_register_pid (NPC_REGNUM
, pc
+ 4, ptid
);
1128 internal_error (__FILE__
, __LINE__
,
1129 "generic_target_write_pc");
1134 write_pc_pid (CORE_ADDR pc
, ptid_t ptid
)
1136 ptid_t saved_inferior_ptid
;
1138 /* In case ptid != inferior_ptid. */
1139 saved_inferior_ptid
= inferior_ptid
;
1140 inferior_ptid
= ptid
;
1142 TARGET_WRITE_PC (pc
, ptid
);
1144 inferior_ptid
= saved_inferior_ptid
;
1148 write_pc (CORE_ADDR pc
)
1150 write_pc_pid (pc
, inferior_ptid
);
1153 /* Cope with strage ways of getting to the stack and frame pointers */
1156 generic_target_read_sp (void)
1160 return read_register (SP_REGNUM
);
1162 internal_error (__FILE__
, __LINE__
,
1163 "generic_target_read_sp");
1169 return TARGET_READ_SP ();
1173 generic_target_write_sp (CORE_ADDR val
)
1178 write_register (SP_REGNUM
, val
);
1182 internal_error (__FILE__
, __LINE__
,
1183 "generic_target_write_sp");
1187 write_sp (CORE_ADDR val
)
1189 TARGET_WRITE_SP (val
);
1193 generic_target_read_fp (void)
1197 return read_register (FP_REGNUM
);
1199 internal_error (__FILE__
, __LINE__
,
1200 "generic_target_read_fp");
1206 return TARGET_READ_FP ();
1211 reg_flush_command (char *command
, int from_tty
)
1213 /* Force-flush the register cache. */
1214 registers_changed ();
1216 printf_filtered ("Register cache flushed.\n");
1220 build_regcache (void)
1222 current_regcache
= regcache_xmalloc (current_gdbarch
);
1223 current_regcache
->passthrough_p
= 1;
1224 registers
= deprecated_grub_regcache_for_registers (current_regcache
);
1225 register_valid
= deprecated_grub_regcache_for_register_valid (current_regcache
);
1229 _initialize_regcache (void)
1231 regcache_descr_handle
= register_gdbarch_data (init_regcache_descr
,
1232 xfree_regcache_descr
);
1233 REGISTER_GDBARCH_SWAP (current_regcache
);
1234 register_gdbarch_swap (®isters
, sizeof (registers
), NULL
);
1235 register_gdbarch_swap (®ister_valid
, sizeof (register_valid
), NULL
);
1236 register_gdbarch_swap (NULL
, 0, build_regcache
);
1238 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1239 "Force gdb to flush its register cache (maintainer command)");
1241 /* Initialize the thread/process associated with the current set of
1242 registers. For now, -1 is special, and means `no current process'. */
1243 registers_ptid
= pid_to_ptid (-1);