1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #if !defined (GET_SAVED_REGISTER)
31 /* Return the address in which frame FRAME's value of register REGNUM
32 has been saved in memory. Or return zero if it has not been saved.
33 If REGNUM specifies the SP, the value we return is actually
34 the SP value, not an address where it was saved. */
37 find_saved_register (frame
, regnum
)
41 struct frame_info
*fi
;
42 struct frame_saved_regs saved_regs
;
44 register FRAME frame1
= 0;
45 register CORE_ADDR addr
= 0;
47 if (frame
== 0) /* No regs saved if want current frame */
50 #ifdef HAVE_REGISTER_WINDOWS
51 /* We assume that a register in a register window will only be saved
52 in one place (since the name changes and/or disappears as you go
53 towards inner frames), so we only call get_frame_saved_regs on
54 the current frame. This is directly in contradiction to the
55 usage below, which assumes that registers used in a frame must be
56 saved in a lower (more interior) frame. This change is a result
57 of working on a register window machine; get_frame_saved_regs
58 always returns the registers saved within a frame, within the
59 context (register namespace) of that frame. */
61 /* However, note that we don't want this to return anything if
62 nothing is saved (if there's a frame inside of this one). Also,
63 callers to this routine asking for the stack pointer want the
64 stack pointer saved for *this* frame; this is returned from the
68 if (REGISTER_IN_WINDOW_P(regnum
))
70 frame1
= get_next_frame (frame
);
71 if (!frame1
) return 0; /* Registers of this frame are
74 /* Get the SP from the next frame in; it will be this
76 if (regnum
!= SP_REGNUM
)
79 fi
= get_frame_info (frame1
);
80 get_frame_saved_regs (fi
, &saved_regs
);
81 return saved_regs
.regs
[regnum
]; /* ... which might be zero */
83 #endif /* HAVE_REGISTER_WINDOWS */
85 /* Note that this next routine assumes that registers used in
86 frame x will be saved only in the frame that x calls and
87 frames interior to it. This is not true on the sparc, but the
88 above macro takes care of it, so we should be all right. */
92 frame1
= get_prev_frame (frame1
);
93 if (frame1
== 0 || frame1
== frame
)
95 fi
= get_frame_info (frame1
);
96 get_frame_saved_regs (fi
, &saved_regs
);
97 if (saved_regs
.regs
[regnum
])
98 addr
= saved_regs
.regs
[regnum
];
104 /* Find register number REGNUM relative to FRAME and put its
105 (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable
106 was optimized out (and thus can't be fetched). Set *LVAL to
107 lval_memory, lval_register, or not_lval, depending on whether the
108 value was fetched from memory, from a register, or in a strange
109 and non-modifiable way (e.g. a frame pointer which was calculated
110 rather than fetched). Set *ADDRP to the address, either in memory
111 on as a REGISTER_BYTE offset into the registers array.
113 Note that this implementation never sets *LVAL to not_lval. But
114 it can be replaced by defining GET_SAVED_REGISTER and supplying
117 The argument RAW_BUFFER must point to aligned memory. */
119 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
125 enum lval_type
*lval
;
128 /* Normal systems don't optimize out things with register numbers. */
129 if (optimized
!= NULL
)
131 addr
= find_saved_register (frame
, regnum
);
136 if (regnum
== SP_REGNUM
)
138 if (raw_buffer
!= NULL
)
139 *(CORE_ADDR
*)raw_buffer
= addr
;
144 if (raw_buffer
!= NULL
)
145 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
150 *lval
= lval_register
;
151 addr
= REGISTER_BYTE (regnum
);
152 if (raw_buffer
!= NULL
)
153 read_register_gen (regnum
, raw_buffer
);
158 #endif /* GET_SAVED_REGISTER. */
160 /* Copy the bytes of register REGNUM, relative to the current stack frame,
161 into our memory at MYADDR, in target byte order.
162 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
164 Returns 1 if could not be read, 0 if could. */
167 read_relative_register_raw_bytes (regnum
, myaddr
)
172 if (regnum
== FP_REGNUM
&& selected_frame
)
174 memcpy (myaddr
, &FRAME_FP(selected_frame
), REGISTER_RAW_SIZE(FP_REGNUM
));
175 SWAP_TARGET_AND_HOST (myaddr
, REGISTER_RAW_SIZE(FP_REGNUM
)); /* in target order */
179 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
180 regnum
, (enum lval_type
*)NULL
);
184 /* Return a `value' with the contents of register REGNUM
185 in its virtual format, with the type specified by
186 REGISTER_VIRTUAL_TYPE. */
189 value_of_register (regnum
)
195 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
196 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
199 get_saved_register (raw_buffer
, &optim
, &addr
,
200 selected_frame
, regnum
, &lval
);
202 REGISTER_CONVERT_TO_VIRTUAL (regnum
, raw_buffer
, virtual_buffer
);
203 val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
204 memcpy (VALUE_CONTENTS_RAW (val
), virtual_buffer
,
205 REGISTER_VIRTUAL_SIZE (regnum
));
206 VALUE_LVAL (val
) = lval
;
207 VALUE_ADDRESS (val
) = addr
;
208 VALUE_REGNO (val
) = regnum
;
209 VALUE_OPTIMIZED_OUT (val
) = optim
;
213 /* Low level examining and depositing of registers.
215 The caller is responsible for making
216 sure that the inferior is stopped before calling the fetching routines,
217 or it will get garbage. (a change from GDB version 3, in which
218 the caller got the value from the last stop). */
220 /* Contents of the registers in target byte order.
221 We allocate some extra slop since we do a lot of bcopy's around `registers',
222 and failing-soft is better than failing hard. */
223 char registers
[REGISTER_BYTES
+ /* SLOP */ 256];
225 /* Nonzero if that register has been fetched. */
226 char register_valid
[NUM_REGS
];
228 /* Indicate that registers may have changed, so invalidate the cache. */
233 for (i
= 0; i
< NUM_REGS
; i
++)
234 register_valid
[i
] = 0;
237 /* Indicate that all registers have been fetched, so mark them all valid. */
242 for (i
= 0; i
< NUM_REGS
; i
++)
243 register_valid
[i
] = 1;
246 /* Copy LEN bytes of consecutive data from registers
247 starting with the REGBYTE'th byte of register data
248 into memory at MYADDR. */
251 read_register_bytes (regbyte
, myaddr
, len
)
256 /* Fetch all registers. */
258 for (i
= 0; i
< NUM_REGS
; i
++)
259 if (!register_valid
[i
])
261 target_fetch_registers (-1);
265 memcpy (myaddr
, ®isters
[regbyte
], len
);
268 /* Read register REGNO into memory at MYADDR, which must be large enough
269 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
270 If the register is known to be the size of a CORE_ADDR or smaller,
271 read_register can be used instead. */
273 read_register_gen (regno
, myaddr
)
277 if (!register_valid
[regno
])
278 target_fetch_registers (regno
);
279 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
280 REGISTER_RAW_SIZE (regno
));
283 /* Copy LEN bytes of consecutive data from memory at MYADDR
284 into registers starting with the REGBYTE'th byte of register data. */
287 write_register_bytes (regbyte
, myaddr
, len
)
292 /* Make sure the entire registers array is valid. */
293 read_register_bytes (0, (char *)NULL
, REGISTER_BYTES
);
294 memcpy (®isters
[regbyte
], myaddr
, len
);
295 target_store_registers (-1);
298 /* Return the contents of register REGNO, regarding it as an integer. */
299 /* FIXME, this loses when the REGISTER_VIRTUAL (REGNO) is true. Also,
300 why is the return type CORE_ADDR rather than some integer type? */
303 read_register (regno
)
313 if (!register_valid
[regno
])
314 target_fetch_registers (regno
);
316 size
= REGISTER_RAW_SIZE(regno
);
318 if (size
== sizeof (unsigned char))
319 return registers
[REGISTER_BYTE (regno
)];
320 else if (size
== sizeof (sval
))
322 memcpy (&sval
, ®isters
[REGISTER_BYTE (regno
)], sizeof (sval
));
323 SWAP_TARGET_AND_HOST (&sval
, sizeof (sval
));
326 else if (size
== sizeof (ival
))
328 memcpy (&ival
, ®isters
[REGISTER_BYTE (regno
)], sizeof (ival
));
329 SWAP_TARGET_AND_HOST (&ival
, sizeof (ival
));
332 else if (size
== sizeof (lval
))
334 memcpy (&lval
, ®isters
[REGISTER_BYTE (regno
)], sizeof (lval
));
335 SWAP_TARGET_AND_HOST (&lval
, sizeof (lval
));
338 else if (size
== sizeof (llval
))
340 memcpy (&llval
, ®isters
[REGISTER_BYTE (regno
)], sizeof (llval
));
341 SWAP_TARGET_AND_HOST (&llval
, sizeof (llval
));
346 error ("GDB Internal Error in read_register() for register %d, size %d",
347 regno
, REGISTER_RAW_SIZE(regno
));
351 /* Registers we shouldn't try to store. */
352 #if !defined (CANNOT_STORE_REGISTER)
353 #define CANNOT_STORE_REGISTER(regno) 0
356 /* Store VALUE in the register number REGNO, regarded as an integer. */
357 /* FIXME, this loses when REGISTER_VIRTUAL (REGNO) is true. Also,
358 shouldn't the val arg be a LONGEST or something? */
361 write_register (regno
, val
)
372 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
373 the registers array if something writes to this register. */
374 if (CANNOT_STORE_REGISTER (regno
))
377 /* If we have a valid copy of the register, and new value == old value,
378 then don't bother doing the actual store. */
380 size
= REGISTER_RAW_SIZE(regno
);
382 if (size
== sizeof(cval
))
387 else if (size
== sizeof(sval
))
392 else if (size
== sizeof(ival
))
397 else if (size
== sizeof(lval
))
402 else if (size
== sizeof(llval
))
409 error ("GDB Internal Error in write_register() for register %d, size %d",
413 SWAP_TARGET_AND_HOST (ptr
, size
);
414 if (register_valid
[regno
])
416 if (memcmp (®isters
[REGISTER_BYTE (regno
)],
421 target_prepare_to_store ();
423 memcpy (®isters
[REGISTER_BYTE (regno
)], ptr
, size
);
425 register_valid
[regno
] = 1;
427 target_store_registers (regno
);
430 /* Record that register REGNO contains VAL.
431 This is used when the value is obtained from the inferior or core dump,
432 so there is no need to store the value there. */
435 supply_register (regno
, val
)
439 register_valid
[regno
] = 1;
440 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
442 /* On some architectures, e.g. HPPA, there are a few stray bits in some
443 registers, that the rest of the code would like to ignore. */
444 #ifdef CLEAN_UP_REGISTER_VALUE
445 CLEAN_UP_REGISTER_VALUE(regno
, ®isters
[REGISTER_BYTE(regno
)]);
449 /* Given a struct symbol for a variable,
450 and a stack frame id, read the value of the variable
451 and return a (pointer to a) struct value containing the value.
452 If the variable cannot be found, return a zero pointer.
453 If FRAME is NULL, use the selected_frame. */
456 read_var_value (var
, frame
)
457 register struct symbol
*var
;
461 struct frame_info
*fi
;
462 struct type
*type
= SYMBOL_TYPE (var
);
466 v
= allocate_value (type
);
467 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
468 len
= TYPE_LENGTH (type
);
470 if (frame
== 0) frame
= selected_frame
;
472 switch (SYMBOL_CLASS (var
))
475 memcpy (VALUE_CONTENTS_RAW (v
), &SYMBOL_VALUE (var
), len
);
476 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v
), len
);
477 VALUE_LVAL (v
) = not_lval
;
481 addr
= SYMBOL_VALUE_ADDRESS (var
);
482 memcpy (VALUE_CONTENTS_RAW (v
), &addr
, len
);
483 SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v
), len
);
484 VALUE_LVAL (v
) = not_lval
;
487 case LOC_CONST_BYTES
:
490 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
491 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
492 VALUE_LVAL (v
) = not_lval
;
497 addr
= SYMBOL_VALUE_ADDRESS (var
);
501 if (SYMBOL_BASEREG_VALID (var
))
503 addr
= FRAME_GET_BASEREG_VALUE (frame
, SYMBOL_BASEREG (var
));
507 fi
= get_frame_info (frame
);
510 addr
= FRAME_ARGS_ADDRESS (fi
);
516 addr
+= SYMBOL_VALUE (var
);
520 if (SYMBOL_BASEREG_VALID (var
))
522 addr
= FRAME_GET_BASEREG_VALUE (frame
, SYMBOL_BASEREG (var
));
526 fi
= get_frame_info (frame
);
529 addr
= FRAME_ARGS_ADDRESS (fi
);
535 addr
+= SYMBOL_VALUE (var
);
536 read_memory (addr
, (char *) &addr
, sizeof (CORE_ADDR
));
541 if (SYMBOL_BASEREG_VALID (var
))
543 addr
= FRAME_GET_BASEREG_VALUE (frame
, SYMBOL_BASEREG (var
));
547 fi
= get_frame_info (frame
);
550 addr
= FRAME_LOCALS_ADDRESS (fi
);
552 addr
+= SYMBOL_VALUE (var
);
556 error ("Cannot look up value of a typedef");
560 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
565 case LOC_REGPARM_ADDR
:
571 b
= get_frame_block (frame
);
573 v
= value_from_register (type
, SYMBOL_VALUE (var
), frame
);
575 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
577 addr
= *(CORE_ADDR
*)VALUE_CONTENTS (v
);
578 VALUE_LVAL (v
) = lval_memory
;
585 case LOC_OPTIMIZED_OUT
:
586 VALUE_LVAL (v
) = not_lval
;
587 VALUE_OPTIMIZED_OUT (v
) = 1;
591 error ("Cannot look up value of a botched symbol.");
595 VALUE_ADDRESS (v
) = addr
;
600 /* Return a value of type TYPE, stored in register REGNUM, in frame
604 value_from_register (type
, regnum
, frame
)
609 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
610 char virtual_buffer
[MAX_REGISTER_VIRTUAL_SIZE
];
613 value v
= allocate_value (type
);
614 int len
= TYPE_LENGTH (type
);
615 char *value_bytes
= 0;
616 int value_bytes_copied
= 0;
617 int num_storage_locs
;
620 VALUE_REGNO (v
) = regnum
;
622 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
623 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
626 if (num_storage_locs
> 1
627 #ifdef GDB_TARGET_IS_H8500
628 || TYPE_CODE (type
) == TYPE_CODE_PTR
632 /* Value spread across multiple storage locations. */
635 int mem_stor
= 0, reg_stor
= 0;
636 int mem_tracking
= 1;
637 CORE_ADDR last_addr
= 0;
638 CORE_ADDR first_addr
;
640 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
642 /* Copy all of the data out, whereever it may be. */
644 #ifdef GDB_TARGET_IS_H8500
645 /* This piece of hideosity is required because the H8500 treats registers
646 differently depending upon whether they are used as pointers or not. As a
647 pointer, a register needs to have a page register tacked onto the front.
648 An alternate way to do this would be to have gcc output different register
649 numbers for the pointer & non-pointer form of the register. But, it
650 doesn't, so we're stuck with this. */
652 if (TYPE_CODE (type
) == TYPE_CODE_PTR
659 case R0_REGNUM
: case R1_REGNUM
: case R2_REGNUM
: case R3_REGNUM
:
660 page_regnum
= SEG_D_REGNUM
;
662 case R4_REGNUM
: case R5_REGNUM
:
663 page_regnum
= SEG_E_REGNUM
;
665 case R6_REGNUM
: case R7_REGNUM
:
666 page_regnum
= SEG_T_REGNUM
;
671 get_saved_register (value_bytes
+ 1,
678 if (lval
== lval_register
)
685 get_saved_register (value_bytes
+ 2,
692 if (lval
== lval_register
)
697 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
702 #endif /* GDB_TARGET_IS_H8500 */
703 for (local_regnum
= regnum
;
704 value_bytes_copied
< len
;
705 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
708 get_saved_register (value_bytes
+ value_bytes_copied
,
715 if (regnum
== local_regnum
)
717 if (lval
== lval_register
)
725 && (regnum
== local_regnum
726 || addr
== last_addr
));
731 if ((reg_stor
&& mem_stor
)
732 || (mem_stor
&& !mem_tracking
))
733 /* Mixed storage; all of the hassle we just went through was
734 for some good purpose. */
736 VALUE_LVAL (v
) = lval_reg_frame_relative
;
737 VALUE_FRAME (v
) = FRAME_FP (frame
);
738 VALUE_FRAME_REGNUM (v
) = regnum
;
742 VALUE_LVAL (v
) = lval_memory
;
743 VALUE_ADDRESS (v
) = first_addr
;
747 VALUE_LVAL (v
) = lval_register
;
748 VALUE_ADDRESS (v
) = first_addr
;
751 fatal ("value_from_register: Value not stored anywhere!");
753 VALUE_OPTIMIZED_OUT (v
) = optim
;
755 /* Any structure stored in more than one register will always be
756 an integral number of registers. Otherwise, you'd need to do
757 some fiddling with the last register copied here for little
760 /* Copy into the contents section of the value. */
761 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
763 /* Finally do any conversion necessary when extracting this
764 type from more than one register. */
765 #ifdef REGISTER_CONVERT_TO_TYPE
766 REGISTER_CONVERT_TO_TYPE(regnum
, type
, VALUE_CONTENTS_RAW(v
));
771 /* Data is completely contained within a single register. Locate the
772 register's contents in a real register or in core;
773 read the data in raw format. */
775 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
776 VALUE_OPTIMIZED_OUT (v
) = optim
;
777 VALUE_LVAL (v
) = lval
;
778 VALUE_ADDRESS (v
) = addr
;
780 /* Convert the raw contents to virtual contents.
781 (Just copy them if the formats are the same.) */
783 REGISTER_CONVERT_TO_VIRTUAL (regnum
, raw_buffer
, virtual_buffer
);
785 if (REGISTER_CONVERTIBLE (regnum
))
787 /* When the raw and virtual formats differ, the virtual format
788 corresponds to a specific data type. If we want that type,
789 copy the data into the value.
790 Otherwise, do a type-conversion. */
792 if (type
!= REGISTER_VIRTUAL_TYPE (regnum
))
794 /* eg a variable of type `float' in a 68881 register
795 with raw type `extended' and virtual type `double'.
796 Fetch it as a `double' and then convert to `float'. */
797 v
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
798 memcpy (VALUE_CONTENTS_RAW (v
), virtual_buffer
, len
);
799 v
= value_cast (type
, v
);
802 memcpy (VALUE_CONTENTS_RAW (v
), virtual_buffer
, len
);
806 /* Raw and virtual formats are the same for this register. */
808 #if TARGET_BYTE_ORDER == BIG_ENDIAN
809 if (len
< REGISTER_RAW_SIZE (regnum
))
811 /* Big-endian, and we want less than full size. */
812 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
816 memcpy (VALUE_CONTENTS_RAW (v
), virtual_buffer
+ VALUE_OFFSET (v
), len
);
822 /* Given a struct symbol for a variable or function,
823 and a stack frame id,
824 return a (pointer to a) struct value containing the properly typed
828 locate_var_value (var
, frame
)
829 register struct symbol
*var
;
833 struct type
*type
= SYMBOL_TYPE (var
);
836 /* Evaluate it first; if the result is a memory address, we're fine.
837 Lazy evaluation pays off here. */
839 lazy_value
= read_var_value (var
, frame
);
841 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
843 if (VALUE_LAZY (lazy_value
)
844 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
846 addr
= VALUE_ADDRESS (lazy_value
);
847 return value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
850 /* Not a memory address; check what the problem was. */
851 switch (VALUE_LVAL (lazy_value
))
854 case lval_reg_frame_relative
:
855 error ("Address requested for identifier \"%s\" which is in a register.",
856 SYMBOL_SOURCE_NAME (var
));
860 error ("Can't take address of \"%s\" which isn't an lvalue.",
861 SYMBOL_SOURCE_NAME (var
));
864 return 0; /* For lint -- never reached */