1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 87, 89, 91, 94, 95, 96, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 #include "gdb_string.h"
30 #include "floatformat.h"
31 #include "symfile.h" /* for overlay functions */
33 /* This is used to indicate that we don't know the format of the floating point
34 number. Typically, this is useful for native ports, where the actual format
35 is irrelevant, since no conversions will be taking place. */
37 const struct floatformat floatformat_unknown
;
39 /* Registers we shouldn't try to store. */
40 #if !defined (CANNOT_STORE_REGISTER)
41 #define CANNOT_STORE_REGISTER(regno) 0
45 write_register_gen
PARAMS ((int, char *));
47 /* Basic byte-swapping routines. GDB has needed these for a long time...
48 All extract a target-format integer at ADDR which is LEN bytes long. */
50 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
51 /* 8 bit characters are a pretty safe assumption these days, so we
52 assume it throughout all these swapping routines. If we had to deal with
53 9 bit characters, we would need to make len be in bits and would have
54 to re-write these routines... */
59 extract_signed_integer (addr
, len
)
65 unsigned char *startaddr
= (unsigned char *)addr
;
66 unsigned char *endaddr
= startaddr
+ len
;
68 if (len
> (int) sizeof (LONGEST
))
70 That operation is not available on integers of more than %d bytes.",
73 /* Start at the most significant end of the integer, and work towards
74 the least significant. */
75 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
78 /* Do the sign extension once at the start. */
79 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
80 for (++p
; p
< endaddr
; ++p
)
81 retval
= (retval
<< 8) | *p
;
86 /* Do the sign extension once at the start. */
87 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
88 for (--p
; p
>= startaddr
; --p
)
89 retval
= (retval
<< 8) | *p
;
95 extract_unsigned_integer (addr
, len
)
101 unsigned char *startaddr
= (unsigned char *)addr
;
102 unsigned char *endaddr
= startaddr
+ len
;
104 if (len
> (int) sizeof (ULONGEST
))
106 That operation is not available on integers of more than %d bytes.",
109 /* Start at the most significant end of the integer, and work towards
110 the least significant. */
112 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
114 for (p
= startaddr
; p
< endaddr
; ++p
)
115 retval
= (retval
<< 8) | *p
;
119 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
120 retval
= (retval
<< 8) | *p
;
125 /* Sometimes a long long unsigned integer can be extracted as a
126 LONGEST value. This is done so that we can print these values
127 better. If this integer can be converted to a LONGEST, this
128 function returns 1 and sets *PVAL. Otherwise it returns 0. */
131 extract_long_unsigned_integer (addr
, orig_len
, pval
)
136 char *p
, *first_addr
;
140 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
142 for (p
= (char *) addr
;
143 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
155 first_addr
= (char *) addr
;
156 for (p
= (char *) addr
+ orig_len
- 1;
157 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
167 if (len
<= (int) sizeof (LONGEST
))
169 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
178 extract_address (addr
, len
)
182 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
183 whether we want this to be true eventually. */
184 return extract_unsigned_integer (addr
, len
);
188 store_signed_integer (addr
, len
, val
)
194 unsigned char *startaddr
= (unsigned char *)addr
;
195 unsigned char *endaddr
= startaddr
+ len
;
197 /* Start at the least significant end of the integer, and work towards
198 the most significant. */
199 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
201 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
209 for (p
= startaddr
; p
< endaddr
; ++p
)
218 store_unsigned_integer (addr
, len
, val
)
224 unsigned char *startaddr
= (unsigned char *)addr
;
225 unsigned char *endaddr
= startaddr
+ len
;
227 /* Start at the least significant end of the integer, and work towards
228 the most significant. */
229 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
231 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
239 for (p
= startaddr
; p
< endaddr
; ++p
)
248 store_address (addr
, len
, val
)
253 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
254 whether we want this to be true eventually. */
255 store_unsigned_integer (addr
, len
, (LONGEST
)val
);
258 /* Swap LEN bytes at BUFFER between target and host byte-order. */
259 #define SWAP_FLOATING(buffer,len) \
262 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
265 char *p = (char *)(buffer); \
266 char *q = ((char *)(buffer)) + len - 1; \
267 for (; p < q; p++, q--) \
277 /* Extract a floating-point number from a target-order byte-stream at ADDR.
278 Returns the value as type DOUBLEST.
280 If the host and target formats agree, we just copy the raw data into the
281 appropriate type of variable and return, letting the host increase precision
282 as necessary. Otherwise, we call the conversion routine and let it do the
286 extract_floating (addr
, len
)
292 if (len
== sizeof (float))
294 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
298 memcpy (&retval
, addr
, sizeof (retval
));
302 floatformat_to_doublest (TARGET_FLOAT_FORMAT
, addr
, &dretval
);
304 else if (len
== sizeof (double))
306 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
310 memcpy (&retval
, addr
, sizeof (retval
));
314 floatformat_to_doublest (TARGET_DOUBLE_FORMAT
, addr
, &dretval
);
316 else if (len
== sizeof (DOUBLEST
))
318 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
322 memcpy (&retval
, addr
, sizeof (retval
));
326 floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT
, addr
, &dretval
);
330 error ("Can't deal with a floating point number of %d bytes.", len
);
337 store_floating (addr
, len
, val
)
342 if (len
== sizeof (float))
344 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
346 float floatval
= val
;
348 memcpy (addr
, &floatval
, sizeof (floatval
));
351 floatformat_from_doublest (TARGET_FLOAT_FORMAT
, &val
, addr
);
353 else if (len
== sizeof (double))
355 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
357 double doubleval
= val
;
359 memcpy (addr
, &doubleval
, sizeof (doubleval
));
362 floatformat_from_doublest (TARGET_DOUBLE_FORMAT
, &val
, addr
);
364 else if (len
== sizeof (DOUBLEST
))
366 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
367 memcpy (addr
, &val
, sizeof (val
));
369 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT
, &val
, addr
);
373 error ("Can't deal with a floating point number of %d bytes.", len
);
377 #if !defined (GET_SAVED_REGISTER)
379 /* Return the address in which frame FRAME's value of register REGNUM
380 has been saved in memory. Or return zero if it has not been saved.
381 If REGNUM specifies the SP, the value we return is actually
382 the SP value, not an address where it was saved. */
385 find_saved_register (frame
, regnum
)
386 struct frame_info
*frame
;
389 struct frame_saved_regs saved_regs
;
391 register struct frame_info
*frame1
= NULL
;
392 register CORE_ADDR addr
= 0;
394 if (frame
== NULL
) /* No regs saved if want current frame */
397 #ifdef HAVE_REGISTER_WINDOWS
398 /* We assume that a register in a register window will only be saved
399 in one place (since the name changes and/or disappears as you go
400 towards inner frames), so we only call get_frame_saved_regs on
401 the current frame. This is directly in contradiction to the
402 usage below, which assumes that registers used in a frame must be
403 saved in a lower (more interior) frame. This change is a result
404 of working on a register window machine; get_frame_saved_regs
405 always returns the registers saved within a frame, within the
406 context (register namespace) of that frame. */
408 /* However, note that we don't want this to return anything if
409 nothing is saved (if there's a frame inside of this one). Also,
410 callers to this routine asking for the stack pointer want the
411 stack pointer saved for *this* frame; this is returned from the
414 if (REGISTER_IN_WINDOW_P(regnum
))
416 frame1
= get_next_frame (frame
);
417 if (!frame1
) return 0; /* Registers of this frame are active. */
419 /* Get the SP from the next frame in; it will be this
421 if (regnum
!= SP_REGNUM
)
424 get_frame_saved_regs (frame1
, &saved_regs
);
425 return saved_regs
.regs
[regnum
]; /* ... which might be zero */
427 #endif /* HAVE_REGISTER_WINDOWS */
429 /* Note that this next routine assumes that registers used in
430 frame x will be saved only in the frame that x calls and
431 frames interior to it. This is not true on the sparc, but the
432 above macro takes care of it, so we should be all right. */
436 frame1
= get_prev_frame (frame1
);
437 if (frame1
== 0 || frame1
== frame
)
439 get_frame_saved_regs (frame1
, &saved_regs
);
440 if (saved_regs
.regs
[regnum
])
441 addr
= saved_regs
.regs
[regnum
];
447 /* Find register number REGNUM relative to FRAME and put its (raw,
448 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
449 variable was optimized out (and thus can't be fetched). Set *LVAL
450 to lval_memory, lval_register, or not_lval, depending on whether
451 the value was fetched from memory, from a register, or in a strange
452 and non-modifiable way (e.g. a frame pointer which was calculated
453 rather than fetched). Set *ADDRP to the address, either in memory
454 on as a REGISTER_BYTE offset into the registers array.
456 Note that this implementation never sets *LVAL to not_lval. But
457 it can be replaced by defining GET_SAVED_REGISTER and supplying
460 The argument RAW_BUFFER must point to aligned memory. */
463 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
467 struct frame_info
*frame
;
469 enum lval_type
*lval
;
473 if (!target_has_registers
)
474 error ("No registers.");
476 /* Normal systems don't optimize out things with register numbers. */
477 if (optimized
!= NULL
)
479 addr
= find_saved_register (frame
, regnum
);
484 if (regnum
== SP_REGNUM
)
486 if (raw_buffer
!= NULL
)
488 /* Put it back in target format. */
489 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), addr
);
495 if (raw_buffer
!= NULL
)
496 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
501 *lval
= lval_register
;
502 addr
= REGISTER_BYTE (regnum
);
503 if (raw_buffer
!= NULL
)
504 read_register_gen (regnum
, raw_buffer
);
509 #endif /* GET_SAVED_REGISTER. */
511 /* Copy the bytes of register REGNUM, relative to the current stack frame,
512 into our memory at MYADDR, in target byte order.
513 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
515 Returns 1 if could not be read, 0 if could. */
518 read_relative_register_raw_bytes (regnum
, myaddr
)
523 if (regnum
== FP_REGNUM
&& selected_frame
)
525 /* Put it back in target format. */
526 store_address (myaddr
, REGISTER_RAW_SIZE(FP_REGNUM
),
527 FRAME_FP(selected_frame
));
531 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
532 regnum
, (enum lval_type
*)NULL
);
534 if (register_valid
[regnum
] < 0)
535 return 1; /* register value not available */
540 /* Return a `value' with the contents of register REGNUM
541 in its virtual format, with the type specified by
542 REGISTER_VIRTUAL_TYPE.
544 NOTE: returns NULL if register value is not available.
545 Caller will check return value or die! */
548 value_of_register (regnum
)
553 register value_ptr reg_val
;
554 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
557 get_saved_register (raw_buffer
, &optim
, &addr
,
558 selected_frame
, regnum
, &lval
);
560 if (register_valid
[regnum
] < 0)
561 return NULL
; /* register value not available */
563 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
565 /* Convert raw data to virtual format if necessary. */
567 #ifdef REGISTER_CONVERTIBLE
568 if (REGISTER_CONVERTIBLE (regnum
))
570 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
571 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
575 if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
576 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
577 REGISTER_RAW_SIZE (regnum
));
579 fatal ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
580 REGISTER_NAME (regnum
), regnum
,
581 REGISTER_RAW_SIZE (regnum
), REGISTER_VIRTUAL_SIZE (regnum
));
582 VALUE_LVAL (reg_val
) = lval
;
583 VALUE_ADDRESS (reg_val
) = addr
;
584 VALUE_REGNO (reg_val
) = regnum
;
585 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
589 /* Low level examining and depositing of registers.
591 The caller is responsible for making
592 sure that the inferior is stopped before calling the fetching routines,
593 or it will get garbage. (a change from GDB version 3, in which
594 the caller got the value from the last stop). */
596 /* Contents of the registers in target byte order.
597 We allocate some extra slop since we do a lot of memcpy's around
598 `registers', and failing-soft is better than failing hard. */
600 char registers
[REGISTER_BYTES
+ /* SLOP */ 256];
602 /* Nonzero if that register has been fetched,
603 -1 if register value not available. */
604 SIGNED
char register_valid
[NUM_REGS
];
606 /* The thread/process associated with the current set of registers. For now,
607 -1 is special, and means `no current process'. */
608 int registers_pid
= -1;
610 /* Indicate that registers may have changed, so invalidate the cache. */
616 int numregs
= ARCH_NUM_REGS
;
620 /* Force cleanup of any alloca areas if using C alloca instead of
621 a builtin alloca. This particular call is used to clean up
622 areas allocated by low level target code which may build up
623 during lengthy interactions between gdb and the target before
624 gdb gives control to the user (ie watchpoints). */
627 for (i
= 0; i
< numregs
; i
++)
628 register_valid
[i
] = 0;
630 if (registers_changed_hook
)
631 registers_changed_hook ();
634 /* Indicate that all registers have been fetched, so mark them all valid. */
639 int numregs
= ARCH_NUM_REGS
;
640 for (i
= 0; i
< numregs
; i
++)
641 register_valid
[i
] = 1;
644 /* read_register_bytes and write_register_bytes are generally a *BAD* idea.
645 They are inefficient because they need to check for partial updates, which
646 can only be done by scanning through all of the registers and seeing if the
647 bytes that are being read/written fall inside of an invalid register. [The
648 main reason this is necessary is that register sizes can vary, so a simple
649 index won't suffice.] It is far better to call read_register_gen if you
650 want to get at the raw register contents, as it only takes a regno as an
651 argument, and therefore can't do a partial register update. It would also
652 be good to have a write_register_gen for similar reasons.
654 Prior to the recent fixes to check for partial updates, both read and
655 write_register_bytes always checked to see if any registers were stale, and
656 then called target_fetch_registers (-1) to update the whole set. This
657 caused really slowed things down for remote targets. */
659 /* Copy INLEN bytes of consecutive data from registers
660 starting with the INREGBYTE'th byte of register data
661 into memory at MYADDR. */
664 read_register_bytes (inregbyte
, myaddr
, inlen
)
669 int inregend
= inregbyte
+ inlen
;
672 if (registers_pid
!= inferior_pid
)
674 registers_changed ();
675 registers_pid
= inferior_pid
;
678 /* See if we are trying to read bytes from out-of-date registers. If so,
679 update just those registers. */
681 for (regno
= 0; regno
< NUM_REGS
; regno
++)
683 int regstart
, regend
;
686 if (register_valid
[regno
])
689 if (REGISTER_NAME (regno
) == NULL
|| *REGISTER_NAME (regno
) == '\0')
692 regstart
= REGISTER_BYTE (regno
);
693 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
695 startin
= regstart
>= inregbyte
&& regstart
< inregend
;
696 endin
= regend
> inregbyte
&& regend
<= inregend
;
698 if (!startin
&& !endin
)
701 /* We've found an invalid register where at least one byte will be read.
702 Update it from the target. */
704 target_fetch_registers (regno
);
706 if (!register_valid
[regno
])
707 error ("read_register_bytes: Couldn't update register %d.", regno
);
711 memcpy (myaddr
, ®isters
[inregbyte
], inlen
);
714 /* Read register REGNO into memory at MYADDR, which must be large enough
715 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
716 If the register is known to be the size of a CORE_ADDR or smaller,
717 read_register can be used instead. */
719 read_register_gen (regno
, myaddr
)
723 if (registers_pid
!= inferior_pid
)
725 registers_changed ();
726 registers_pid
= inferior_pid
;
729 if (!register_valid
[regno
])
730 target_fetch_registers (regno
);
731 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
732 REGISTER_RAW_SIZE (regno
));
735 /* Write register REGNO at MYADDR to the target. MYADDR points at
736 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
739 write_register_gen (regno
, myaddr
)
745 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
746 the registers array if something writes to this register. */
747 if (CANNOT_STORE_REGISTER (regno
))
750 if (registers_pid
!= inferior_pid
)
752 registers_changed ();
753 registers_pid
= inferior_pid
;
756 size
= REGISTER_RAW_SIZE(regno
);
758 /* If we have a valid copy of the register, and new value == old value,
759 then don't bother doing the actual store. */
761 if (register_valid
[regno
]
762 && memcmp (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
) == 0)
765 target_prepare_to_store ();
767 memcpy (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
);
769 register_valid
[regno
] = 1;
771 target_store_registers (regno
);
773 if (regno
== PC_REGNUM
&& pc_changed_hook
)
777 /* Copy INLEN bytes of consecutive data from memory at MYADDR
778 into registers starting with the MYREGSTART'th byte of register data. */
781 write_register_bytes (myregstart
, myaddr
, inlen
)
786 int myregend
= myregstart
+ inlen
;
789 target_prepare_to_store ();
791 /* Scan through the registers updating any that are covered by the range
792 myregstart<=>myregend using write_register_gen, which does nice things
793 like handling threads, and avoiding updates when the new and old contents
796 for (regno
= 0; regno
< NUM_REGS
; regno
++)
798 int regstart
, regend
;
800 char regbuf
[MAX_REGISTER_RAW_SIZE
];
802 regstart
= REGISTER_BYTE (regno
);
803 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
805 startin
= regstart
>= myregstart
&& regstart
< myregend
;
806 endin
= regend
> myregstart
&& regend
<= myregend
;
808 if (!startin
&& !endin
)
809 continue; /* Register is completely out of range */
811 if (startin
&& endin
) /* register is completely in range */
813 write_register_gen (regno
, myaddr
+ (regstart
- myregstart
));
817 /* We may be doing a partial update of an invalid register. Update it
818 from the target before scribbling on it. */
819 read_register_gen (regno
, regbuf
);
822 memcpy (registers
+ regstart
,
823 myaddr
+ regstart
- myregstart
,
824 myregend
- regstart
);
826 memcpy (registers
+ myregstart
,
828 regend
- myregstart
);
829 target_store_registers (regno
);
833 /* Return the raw contents of register REGNO, regarding it as an integer. */
834 /* This probably should be returning LONGEST rather than CORE_ADDR. */
837 read_register (regno
)
840 if (registers_pid
!= inferior_pid
)
842 registers_changed ();
843 registers_pid
= inferior_pid
;
846 if (!register_valid
[regno
])
847 target_fetch_registers (regno
);
849 return extract_address (®isters
[REGISTER_BYTE (regno
)],
850 REGISTER_RAW_SIZE(regno
));
854 read_register_pid (regno
, pid
)
860 if (pid
== inferior_pid
)
861 return read_register (regno
);
863 save_pid
= inferior_pid
;
867 retval
= read_register (regno
);
869 inferior_pid
= save_pid
;
874 /* Store VALUE, into the raw contents of register number REGNO. */
877 write_register (regno
, val
)
884 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
885 the registers array if something writes to this register. */
886 if (CANNOT_STORE_REGISTER (regno
))
889 if (registers_pid
!= inferior_pid
)
891 registers_changed ();
892 registers_pid
= inferior_pid
;
895 size
= REGISTER_RAW_SIZE(regno
);
897 store_signed_integer (buf
, size
, (LONGEST
) val
);
899 /* If we have a valid copy of the register, and new value == old value,
900 then don't bother doing the actual store. */
902 if (register_valid
[regno
]
903 && memcmp (®isters
[REGISTER_BYTE (regno
)], buf
, size
) == 0)
906 target_prepare_to_store ();
908 memcpy (®isters
[REGISTER_BYTE (regno
)], buf
, size
);
910 register_valid
[regno
] = 1;
912 target_store_registers (regno
);
916 write_register_pid (regno
, val
, pid
)
923 if (pid
== inferior_pid
)
925 write_register (regno
, val
);
929 save_pid
= inferior_pid
;
933 write_register (regno
, val
);
935 inferior_pid
= save_pid
;
938 /* Record that register REGNO contains VAL.
939 This is used when the value is obtained from the inferior or core dump,
940 so there is no need to store the value there.
942 If VAL is a NULL pointer, then it's probably an unsupported register. We
943 just set it's value to all zeros. We might want to record this fact, and
944 report it to the users of read_register and friends.
948 supply_register (regno
, val
)
953 if (registers_pid
!= inferior_pid
)
955 registers_changed ();
956 registers_pid
= inferior_pid
;
960 register_valid
[regno
] = 1;
962 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
964 memset (®isters
[REGISTER_BYTE (regno
)], '\000', REGISTER_RAW_SIZE (regno
));
966 /* On some architectures, e.g. HPPA, there are a few stray bits in some
967 registers, that the rest of the code would like to ignore. */
968 #ifdef CLEAN_UP_REGISTER_VALUE
969 CLEAN_UP_REGISTER_VALUE(regno
, ®isters
[REGISTER_BYTE(regno
)]);
974 /* This routine is getting awfully cluttered with #if's. It's probably
975 time to turn this into READ_PC and define it in the tm.h file.
976 Ditto for write_pc. */
982 #ifdef TARGET_READ_PC
983 return TARGET_READ_PC (pid
);
985 return ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
992 return read_pc_pid (inferior_pid
);
996 write_pc_pid (pc
, pid
)
1000 #ifdef TARGET_WRITE_PC
1001 TARGET_WRITE_PC (pc
, pid
);
1003 write_register_pid (PC_REGNUM
, pc
, pid
);
1005 write_register_pid (NPC_REGNUM
, pc
+ 4, pid
);
1007 write_register_pid (NNPC_REGNUM
, pc
+ 8, pid
);
1017 write_pc_pid (pc
, inferior_pid
);
1020 /* Cope with strage ways of getting to the stack and frame pointers */
1025 #ifdef TARGET_READ_SP
1026 return TARGET_READ_SP ();
1028 return read_register (SP_REGNUM
);
1036 #ifdef TARGET_WRITE_SP
1037 TARGET_WRITE_SP (val
);
1039 write_register (SP_REGNUM
, val
);
1046 #ifdef TARGET_READ_FP
1047 return TARGET_READ_FP ();
1049 return read_register (FP_REGNUM
);
1057 #ifdef TARGET_WRITE_FP
1058 TARGET_WRITE_FP (val
);
1060 write_register (FP_REGNUM
, val
);
1064 /* Will calling read_var_value or locate_var_value on SYM end
1065 up caring what frame it is being evaluated relative to? SYM must
1068 symbol_read_needs_frame (sym
)
1071 switch (SYMBOL_CLASS (sym
))
1073 /* All cases listed explicitly so that gcc -Wall will detect it if
1074 we failed to consider one. */
1079 case LOC_REGPARM_ADDR
:
1083 case LOC_BASEREG_ARG
:
1092 /* Getting the address of a label can be done independently of the block,
1093 even if some *uses* of that address wouldn't work so well without
1097 case LOC_CONST_BYTES
:
1098 case LOC_UNRESOLVED
:
1099 case LOC_OPTIMIZED_OUT
:
1105 /* Given a struct symbol for a variable,
1106 and a stack frame id, read the value of the variable
1107 and return a (pointer to a) struct value containing the value.
1108 If the variable cannot be found, return a zero pointer.
1109 If FRAME is NULL, use the selected_frame. */
1112 read_var_value (var
, frame
)
1113 register struct symbol
*var
;
1114 struct frame_info
*frame
;
1116 register value_ptr v
;
1117 struct type
*type
= SYMBOL_TYPE (var
);
1121 v
= allocate_value (type
);
1122 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
1123 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
1125 len
= TYPE_LENGTH (type
);
1127 if (frame
== NULL
) frame
= selected_frame
;
1129 switch (SYMBOL_CLASS (var
))
1132 /* Put the constant back in target format. */
1133 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
1134 (LONGEST
) SYMBOL_VALUE (var
));
1135 VALUE_LVAL (v
) = not_lval
;
1139 /* Put the constant back in target format. */
1140 if (overlay_debugging
)
1141 store_address (VALUE_CONTENTS_RAW (v
), len
,
1142 symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1143 SYMBOL_BFD_SECTION (var
)));
1145 store_address (VALUE_CONTENTS_RAW (v
), len
,
1146 SYMBOL_VALUE_ADDRESS (var
));
1147 VALUE_LVAL (v
) = not_lval
;
1150 case LOC_CONST_BYTES
:
1153 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
1154 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
1155 VALUE_LVAL (v
) = not_lval
;
1160 if (overlay_debugging
)
1161 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1162 SYMBOL_BFD_SECTION (var
));
1164 addr
= SYMBOL_VALUE_ADDRESS (var
);
1170 addr
= FRAME_ARGS_ADDRESS (frame
);
1173 addr
+= SYMBOL_VALUE (var
);
1179 addr
= FRAME_ARGS_ADDRESS (frame
);
1182 addr
+= SYMBOL_VALUE (var
);
1183 addr
= read_memory_unsigned_integer
1184 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1191 addr
= FRAME_LOCALS_ADDRESS (frame
);
1192 addr
+= SYMBOL_VALUE (var
);
1196 case LOC_BASEREG_ARG
:
1198 char buf
[MAX_REGISTER_RAW_SIZE
];
1199 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1201 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1202 addr
+= SYMBOL_VALUE (var
);
1207 error ("Cannot look up value of a typedef");
1211 if (overlay_debugging
)
1212 VALUE_ADDRESS (v
) = symbol_overlayed_address
1213 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
1215 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
1220 case LOC_REGPARM_ADDR
:
1223 int regno
= SYMBOL_VALUE (var
);
1228 b
= get_frame_block (frame
);
1230 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
1232 regval
= value_from_register (lookup_pointer_type (type
),
1237 error ("Value of register variable not available.");
1239 addr
= value_as_pointer (regval
);
1240 VALUE_LVAL (v
) = lval_memory
;
1244 regval
= value_from_register (type
, regno
, frame
);
1247 error ("Value of register variable not available.");
1253 case LOC_UNRESOLVED
:
1255 struct minimal_symbol
*msym
;
1257 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
1260 if (overlay_debugging
)
1261 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
1262 SYMBOL_BFD_SECTION (msym
));
1264 addr
= SYMBOL_VALUE_ADDRESS (msym
);
1268 case LOC_OPTIMIZED_OUT
:
1269 VALUE_LVAL (v
) = not_lval
;
1270 VALUE_OPTIMIZED_OUT (v
) = 1;
1274 error ("Cannot look up value of a botched symbol.");
1278 VALUE_ADDRESS (v
) = addr
;
1283 /* Return a value of type TYPE, stored in register REGNUM, in frame
1286 NOTE: returns NULL if register value is not available.
1287 Caller will check return value or die! */
1290 value_from_register (type
, regnum
, frame
)
1293 struct frame_info
*frame
;
1295 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1298 value_ptr v
= allocate_value (type
);
1299 char *value_bytes
= 0;
1300 int value_bytes_copied
= 0;
1301 int num_storage_locs
;
1302 enum lval_type lval
;
1305 CHECK_TYPEDEF (type
);
1306 len
= TYPE_LENGTH (type
);
1308 VALUE_REGNO (v
) = regnum
;
1310 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
1311 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
1314 if (num_storage_locs
> 1
1315 #ifdef GDB_TARGET_IS_H8500
1316 || TYPE_CODE (type
) == TYPE_CODE_PTR
1320 /* Value spread across multiple storage locations. */
1323 int mem_stor
= 0, reg_stor
= 0;
1324 int mem_tracking
= 1;
1325 CORE_ADDR last_addr
= 0;
1326 CORE_ADDR first_addr
= 0;
1328 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
1330 /* Copy all of the data out, whereever it may be. */
1332 #ifdef GDB_TARGET_IS_H8500
1333 /* This piece of hideosity is required because the H8500 treats registers
1334 differently depending upon whether they are used as pointers or not. As a
1335 pointer, a register needs to have a page register tacked onto the front.
1336 An alternate way to do this would be to have gcc output different register
1337 numbers for the pointer & non-pointer form of the register. But, it
1338 doesn't, so we're stuck with this. */
1340 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1347 case R0_REGNUM
: case R1_REGNUM
: case R2_REGNUM
: case R3_REGNUM
:
1348 page_regnum
= SEG_D_REGNUM
;
1350 case R4_REGNUM
: case R5_REGNUM
:
1351 page_regnum
= SEG_E_REGNUM
;
1353 case R6_REGNUM
: case R7_REGNUM
:
1354 page_regnum
= SEG_T_REGNUM
;
1359 get_saved_register (value_bytes
+ 1,
1366 if (register_valid
[page_regnum
] == -1)
1367 return NULL
; /* register value not available */
1369 if (lval
== lval_register
)
1376 get_saved_register (value_bytes
+ 2,
1383 if (register_valid
[regnum
] == -1)
1384 return NULL
; /* register value not available */
1386 if (lval
== lval_register
)
1391 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
1396 #endif /* GDB_TARGET_IS_H8500 */
1397 for (local_regnum
= regnum
;
1398 value_bytes_copied
< len
;
1399 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
1402 get_saved_register (value_bytes
+ value_bytes_copied
,
1409 if (register_valid
[local_regnum
] == -1)
1410 return NULL
; /* register value not available */
1412 if (regnum
== local_regnum
)
1414 if (lval
== lval_register
)
1422 && (regnum
== local_regnum
1423 || addr
== last_addr
));
1428 if ((reg_stor
&& mem_stor
)
1429 || (mem_stor
&& !mem_tracking
))
1430 /* Mixed storage; all of the hassle we just went through was
1431 for some good purpose. */
1433 VALUE_LVAL (v
) = lval_reg_frame_relative
;
1434 VALUE_FRAME (v
) = FRAME_FP (frame
);
1435 VALUE_FRAME_REGNUM (v
) = regnum
;
1439 VALUE_LVAL (v
) = lval_memory
;
1440 VALUE_ADDRESS (v
) = first_addr
;
1444 VALUE_LVAL (v
) = lval_register
;
1445 VALUE_ADDRESS (v
) = first_addr
;
1448 fatal ("value_from_register: Value not stored anywhere!");
1450 VALUE_OPTIMIZED_OUT (v
) = optim
;
1452 /* Any structure stored in more than one register will always be
1453 an integral number of registers. Otherwise, you'd need to do
1454 some fiddling with the last register copied here for little
1457 /* Copy into the contents section of the value. */
1458 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
1460 /* Finally do any conversion necessary when extracting this
1461 type from more than one register. */
1462 #ifdef REGISTER_CONVERT_TO_TYPE
1463 REGISTER_CONVERT_TO_TYPE(regnum
, type
, VALUE_CONTENTS_RAW(v
));
1468 /* Data is completely contained within a single register. Locate the
1469 register's contents in a real register or in core;
1470 read the data in raw format. */
1472 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
1474 if (register_valid
[regnum
] == -1)
1475 return NULL
; /* register value not available */
1477 VALUE_OPTIMIZED_OUT (v
) = optim
;
1478 VALUE_LVAL (v
) = lval
;
1479 VALUE_ADDRESS (v
) = addr
;
1481 /* Convert raw data to virtual format if necessary. */
1483 #ifdef REGISTER_CONVERTIBLE
1484 if (REGISTER_CONVERTIBLE (regnum
))
1486 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
1487 raw_buffer
, VALUE_CONTENTS_RAW (v
));
1492 /* Raw and virtual formats are the same for this register. */
1494 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
1496 /* Big-endian, and we want less than full size. */
1497 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
1500 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
1506 /* Given a struct symbol for a variable or function,
1507 and a stack frame id,
1508 return a (pointer to a) struct value containing the properly typed
1512 locate_var_value (var
, frame
)
1513 register struct symbol
*var
;
1514 struct frame_info
*frame
;
1517 struct type
*type
= SYMBOL_TYPE (var
);
1518 value_ptr lazy_value
;
1520 /* Evaluate it first; if the result is a memory address, we're fine.
1521 Lazy evaluation pays off here. */
1523 lazy_value
= read_var_value (var
, frame
);
1524 if (lazy_value
== 0)
1525 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
1527 if (VALUE_LAZY (lazy_value
)
1528 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1532 addr
= VALUE_ADDRESS (lazy_value
);
1533 val
= value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
1534 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
1538 /* Not a memory address; check what the problem was. */
1539 switch (VALUE_LVAL (lazy_value
))
1542 case lval_reg_frame_relative
:
1543 error ("Address requested for identifier \"%s\" which is in a register.",
1544 SYMBOL_SOURCE_NAME (var
));
1548 error ("Can't take address of \"%s\" which isn't an lvalue.",
1549 SYMBOL_SOURCE_NAME (var
));
1552 return 0; /* For lint -- never reached */