1 /* Low level packing and unpacking of values for GDB, the GNU Debugger.
3 Copyright (C) 1986-2014 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 3 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, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
38 #include "cli/cli-decode.h"
39 #include "exceptions.h"
40 #include "extension.h"
42 #include "tracepoint.h"
44 #include "user-regs.h"
46 /* Prototypes for exported functions. */
48 void _initialize_values (void);
50 /* Definition of a user function. */
51 struct internal_function
53 /* The name of the function. It is a bit odd to have this in the
54 function itself -- the user might use a differently-named
55 convenience variable to hold the function. */
59 internal_function_fn handler
;
61 /* User data for the handler. */
65 /* Defines an [OFFSET, OFFSET + LENGTH) range. */
69 /* Lowest offset in the range. */
72 /* Length of the range. */
76 typedef struct range range_s
;
80 /* Returns true if the ranges defined by [offset1, offset1+len1) and
81 [offset2, offset2+len2) overlap. */
84 ranges_overlap (int offset1
, int len1
,
85 int offset2
, int len2
)
89 l
= max (offset1
, offset2
);
90 h
= min (offset1
+ len1
, offset2
+ len2
);
94 /* Returns true if the first argument is strictly less than the
95 second, useful for VEC_lower_bound. We keep ranges sorted by
96 offset and coalesce overlapping and contiguous ranges, so this just
97 compares the starting offset. */
100 range_lessthan (const range_s
*r1
, const range_s
*r2
)
102 return r1
->offset
< r2
->offset
;
105 /* Returns true if RANGES contains any range that overlaps [OFFSET,
109 ranges_contain (VEC(range_s
) *ranges
, int offset
, int length
)
114 what
.offset
= offset
;
115 what
.length
= length
;
117 /* We keep ranges sorted by offset and coalesce overlapping and
118 contiguous ranges, so to check if a range list contains a given
119 range, we can do a binary search for the position the given range
120 would be inserted if we only considered the starting OFFSET of
121 ranges. We call that position I. Since we also have LENGTH to
122 care for (this is a range afterall), we need to check if the
123 _previous_ range overlaps the I range. E.g.,
127 |---| |---| |------| ... |--|
132 In the case above, the binary search would return `I=1', meaning,
133 this OFFSET should be inserted at position 1, and the current
134 position 1 should be pushed further (and before 2). But, `0'
137 Then we need to check if the I range overlaps the I range itself.
142 |---| |---| |-------| ... |--|
148 i
= VEC_lower_bound (range_s
, ranges
, &what
, range_lessthan
);
152 struct range
*bef
= VEC_index (range_s
, ranges
, i
- 1);
154 if (ranges_overlap (bef
->offset
, bef
->length
, offset
, length
))
158 if (i
< VEC_length (range_s
, ranges
))
160 struct range
*r
= VEC_index (range_s
, ranges
, i
);
162 if (ranges_overlap (r
->offset
, r
->length
, offset
, length
))
169 static struct cmd_list_element
*functionlist
;
171 /* Note that the fields in this structure are arranged to save a bit
176 /* Type of value; either not an lval, or one of the various
177 different possible kinds of lval. */
180 /* Is it modifiable? Only relevant if lval != not_lval. */
181 unsigned int modifiable
: 1;
183 /* If zero, contents of this value are in the contents field. If
184 nonzero, contents are in inferior. If the lval field is lval_memory,
185 the contents are in inferior memory at location.address plus offset.
186 The lval field may also be lval_register.
188 WARNING: This field is used by the code which handles watchpoints
189 (see breakpoint.c) to decide whether a particular value can be
190 watched by hardware watchpoints. If the lazy flag is set for
191 some member of a value chain, it is assumed that this member of
192 the chain doesn't need to be watched as part of watching the
193 value itself. This is how GDB avoids watching the entire struct
194 or array when the user wants to watch a single struct member or
195 array element. If you ever change the way lazy flag is set and
196 reset, be sure to consider this use as well! */
197 unsigned int lazy
: 1;
199 /* If nonzero, this is the value of a variable that does not
200 actually exist in the program. If nonzero, and LVAL is
201 lval_register, this is a register ($pc, $sp, etc., never a
202 program variable) that has not been saved in the frame. All
203 optimized-out values are treated pretty much the same, except
204 registers have a different string representation and related
206 unsigned int optimized_out
: 1;
208 /* If value is a variable, is it initialized or not. */
209 unsigned int initialized
: 1;
211 /* If value is from the stack. If this is set, read_stack will be
212 used instead of read_memory to enable extra caching. */
213 unsigned int stack
: 1;
215 /* If the value has been released. */
216 unsigned int released
: 1;
218 /* Register number if the value is from a register. */
221 /* Location of value (if lval). */
224 /* If lval == lval_memory, this is the address in the inferior.
225 If lval == lval_register, this is the byte offset into the
226 registers structure. */
229 /* Pointer to internal variable. */
230 struct internalvar
*internalvar
;
232 /* Pointer to xmethod worker. */
233 struct xmethod_worker
*xm_worker
;
235 /* If lval == lval_computed, this is a set of function pointers
236 to use to access and describe the value, and a closure pointer
240 /* Functions to call. */
241 const struct lval_funcs
*funcs
;
243 /* Closure for those functions to use. */
248 /* Describes offset of a value within lval of a structure in bytes.
249 If lval == lval_memory, this is an offset to the address. If
250 lval == lval_register, this is a further offset from
251 location.address within the registers structure. Note also the
252 member embedded_offset below. */
255 /* Only used for bitfields; number of bits contained in them. */
258 /* Only used for bitfields; position of start of field. For
259 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
260 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
263 /* The number of references to this value. When a value is created,
264 the value chain holds a reference, so REFERENCE_COUNT is 1. If
265 release_value is called, this value is removed from the chain but
266 the caller of release_value now has a reference to this value.
267 The caller must arrange for a call to value_free later. */
270 /* Only used for bitfields; the containing value. This allows a
271 single read from the target when displaying multiple
273 struct value
*parent
;
275 /* Frame register value is relative to. This will be described in
276 the lval enum above as "lval_register". */
277 struct frame_id frame_id
;
279 /* Type of the value. */
282 /* If a value represents a C++ object, then the `type' field gives
283 the object's compile-time type. If the object actually belongs
284 to some class derived from `type', perhaps with other base
285 classes and additional members, then `type' is just a subobject
286 of the real thing, and the full object is probably larger than
287 `type' would suggest.
289 If `type' is a dynamic class (i.e. one with a vtable), then GDB
290 can actually determine the object's run-time type by looking at
291 the run-time type information in the vtable. When this
292 information is available, we may elect to read in the entire
293 object, for several reasons:
295 - When printing the value, the user would probably rather see the
296 full object, not just the limited portion apparent from the
299 - If `type' has virtual base classes, then even printing `type'
300 alone may require reaching outside the `type' portion of the
301 object to wherever the virtual base class has been stored.
303 When we store the entire object, `enclosing_type' is the run-time
304 type -- the complete object -- and `embedded_offset' is the
305 offset of `type' within that larger type, in bytes. The
306 value_contents() macro takes `embedded_offset' into account, so
307 most GDB code continues to see the `type' portion of the value,
308 just as the inferior would.
310 If `type' is a pointer to an object, then `enclosing_type' is a
311 pointer to the object's run-time type, and `pointed_to_offset' is
312 the offset in bytes from the full object to the pointed-to object
313 -- that is, the value `embedded_offset' would have if we followed
314 the pointer and fetched the complete object. (I don't really see
315 the point. Why not just determine the run-time type when you
316 indirect, and avoid the special case? The contents don't matter
317 until you indirect anyway.)
319 If we're not doing anything fancy, `enclosing_type' is equal to
320 `type', and `embedded_offset' is zero, so everything works
322 struct type
*enclosing_type
;
324 int pointed_to_offset
;
326 /* Values are stored in a chain, so that they can be deleted easily
327 over calls to the inferior. Values assigned to internal
328 variables, put into the value history or exposed to Python are
329 taken off this list. */
332 /* Actual contents of the value. Target byte-order. NULL or not
333 valid if lazy is nonzero. */
336 /* Unavailable ranges in CONTENTS. We mark unavailable ranges,
337 rather than available, since the common and default case is for a
338 value to be available. This is filled in at value read time. The
339 unavailable ranges are tracked in bits. */
340 VEC(range_s
) *unavailable
;
344 value_bits_available (const struct value
*value
, int offset
, int length
)
346 gdb_assert (!value
->lazy
);
348 return !ranges_contain (value
->unavailable
, offset
, length
);
352 value_bytes_available (const struct value
*value
, int offset
, int length
)
354 return value_bits_available (value
,
355 offset
* TARGET_CHAR_BIT
,
356 length
* TARGET_CHAR_BIT
);
360 value_entirely_available (struct value
*value
)
362 /* We can only tell whether the whole value is available when we try
365 value_fetch_lazy (value
);
367 if (VEC_empty (range_s
, value
->unavailable
))
373 value_entirely_unavailable (struct value
*value
)
375 /* We can only tell whether the whole value is available when we try
378 value_fetch_lazy (value
);
380 if (VEC_length (range_s
, value
->unavailable
) == 1)
382 struct range
*t
= VEC_index (range_s
, value
->unavailable
, 0);
385 && t
->length
== (TARGET_CHAR_BIT
386 * TYPE_LENGTH (value_enclosing_type (value
))))
394 mark_value_bits_unavailable (struct value
*value
, int offset
, int length
)
399 /* Insert the range sorted. If there's overlap or the new range
400 would be contiguous with an existing range, merge. */
402 newr
.offset
= offset
;
403 newr
.length
= length
;
405 /* Do a binary search for the position the given range would be
406 inserted if we only considered the starting OFFSET of ranges.
407 Call that position I. Since we also have LENGTH to care for
408 (this is a range afterall), we need to check if the _previous_
409 range overlaps the I range. E.g., calling R the new range:
411 #1 - overlaps with previous
415 |---| |---| |------| ... |--|
420 In the case #1 above, the binary search would return `I=1',
421 meaning, this OFFSET should be inserted at position 1, and the
422 current position 1 should be pushed further (and become 2). But,
423 note that `0' overlaps with R, so we want to merge them.
425 A similar consideration needs to be taken if the new range would
426 be contiguous with the previous range:
428 #2 - contiguous with previous
432 |--| |---| |------| ... |--|
437 If there's no overlap with the previous range, as in:
439 #3 - not overlapping and not contiguous
443 |--| |---| |------| ... |--|
450 #4 - R is the range with lowest offset
454 |--| |---| |------| ... |--|
459 ... we just push the new range to I.
461 All the 4 cases above need to consider that the new range may
462 also overlap several of the ranges that follow, or that R may be
463 contiguous with the following range, and merge. E.g.,
465 #5 - overlapping following ranges
468 |------------------------|
469 |--| |---| |------| ... |--|
478 |--| |---| |------| ... |--|
485 i
= VEC_lower_bound (range_s
, value
->unavailable
, &newr
, range_lessthan
);
488 struct range
*bef
= VEC_index (range_s
, value
->unavailable
, i
- 1);
490 if (ranges_overlap (bef
->offset
, bef
->length
, offset
, length
))
493 ULONGEST l
= min (bef
->offset
, offset
);
494 ULONGEST h
= max (bef
->offset
+ bef
->length
, offset
+ length
);
500 else if (offset
== bef
->offset
+ bef
->length
)
503 bef
->length
+= length
;
509 VEC_safe_insert (range_s
, value
->unavailable
, i
, &newr
);
515 VEC_safe_insert (range_s
, value
->unavailable
, i
, &newr
);
518 /* Check whether the ranges following the one we've just added or
519 touched can be folded in (#5 above). */
520 if (i
+ 1 < VEC_length (range_s
, value
->unavailable
))
527 /* Get the range we just touched. */
528 t
= VEC_index (range_s
, value
->unavailable
, i
);
532 for (; VEC_iterate (range_s
, value
->unavailable
, i
, r
); i
++)
533 if (r
->offset
<= t
->offset
+ t
->length
)
537 l
= min (t
->offset
, r
->offset
);
538 h
= max (t
->offset
+ t
->length
, r
->offset
+ r
->length
);
547 /* If we couldn't merge this one, we won't be able to
548 merge following ones either, since the ranges are
549 always sorted by OFFSET. */
554 VEC_block_remove (range_s
, value
->unavailable
, next
, removed
);
559 mark_value_bytes_unavailable (struct value
*value
, int offset
, int length
)
561 mark_value_bits_unavailable (value
,
562 offset
* TARGET_CHAR_BIT
,
563 length
* TARGET_CHAR_BIT
);
566 /* Find the first range in RANGES that overlaps the range defined by
567 OFFSET and LENGTH, starting at element POS in the RANGES vector,
568 Returns the index into RANGES where such overlapping range was
569 found, or -1 if none was found. */
572 find_first_range_overlap (VEC(range_s
) *ranges
, int pos
,
573 int offset
, int length
)
578 for (i
= pos
; VEC_iterate (range_s
, ranges
, i
, r
); i
++)
579 if (ranges_overlap (r
->offset
, r
->length
, offset
, length
))
585 /* Compare LENGTH_BITS of memory at PTR1 + OFFSET1_BITS with the memory at
586 PTR2 + OFFSET2_BITS. Return 0 if the memory is the same, otherwise
589 It must always be the case that:
590 OFFSET1_BITS % TARGET_CHAR_BIT == OFFSET2_BITS % TARGET_CHAR_BIT
592 It is assumed that memory can be accessed from:
593 PTR + (OFFSET_BITS / TARGET_CHAR_BIT)
595 PTR + ((OFFSET_BITS + LENGTH_BITS + TARGET_CHAR_BIT - 1)
596 / TARGET_CHAR_BIT) */
598 memcmp_with_bit_offsets (const gdb_byte
*ptr1
, size_t offset1_bits
,
599 const gdb_byte
*ptr2
, size_t offset2_bits
,
602 gdb_assert (offset1_bits
% TARGET_CHAR_BIT
603 == offset2_bits
% TARGET_CHAR_BIT
);
605 if (offset1_bits
% TARGET_CHAR_BIT
!= 0)
608 gdb_byte mask
, b1
, b2
;
610 /* The offset from the base pointers PTR1 and PTR2 is not a complete
611 number of bytes. A number of bits up to either the next exact
612 byte boundary, or LENGTH_BITS (which ever is sooner) will be
614 bits
= TARGET_CHAR_BIT
- offset1_bits
% TARGET_CHAR_BIT
;
615 gdb_assert (bits
< sizeof (mask
) * TARGET_CHAR_BIT
);
616 mask
= (1 << bits
) - 1;
618 if (length_bits
< bits
)
620 mask
&= ~(gdb_byte
) ((1 << (bits
- length_bits
)) - 1);
624 /* Now load the two bytes and mask off the bits we care about. */
625 b1
= *(ptr1
+ offset1_bits
/ TARGET_CHAR_BIT
) & mask
;
626 b2
= *(ptr2
+ offset2_bits
/ TARGET_CHAR_BIT
) & mask
;
631 /* Now update the length and offsets to take account of the bits
632 we've just compared. */
634 offset1_bits
+= bits
;
635 offset2_bits
+= bits
;
638 if (length_bits
% TARGET_CHAR_BIT
!= 0)
642 gdb_byte mask
, b1
, b2
;
644 /* The length is not an exact number of bytes. After the previous
645 IF.. block then the offsets are byte aligned, or the
646 length is zero (in which case this code is not reached). Compare
647 a number of bits at the end of the region, starting from an exact
649 bits
= length_bits
% TARGET_CHAR_BIT
;
650 o1
= offset1_bits
+ length_bits
- bits
;
651 o2
= offset2_bits
+ length_bits
- bits
;
653 gdb_assert (bits
< sizeof (mask
) * TARGET_CHAR_BIT
);
654 mask
= ((1 << bits
) - 1) << (TARGET_CHAR_BIT
- bits
);
656 gdb_assert (o1
% TARGET_CHAR_BIT
== 0);
657 gdb_assert (o2
% TARGET_CHAR_BIT
== 0);
659 b1
= *(ptr1
+ o1
/ TARGET_CHAR_BIT
) & mask
;
660 b2
= *(ptr2
+ o2
/ TARGET_CHAR_BIT
) & mask
;
670 /* We've now taken care of any stray "bits" at the start, or end of
671 the region to compare, the remainder can be covered with a simple
673 gdb_assert (offset1_bits
% TARGET_CHAR_BIT
== 0);
674 gdb_assert (offset2_bits
% TARGET_CHAR_BIT
== 0);
675 gdb_assert (length_bits
% TARGET_CHAR_BIT
== 0);
677 return memcmp (ptr1
+ offset1_bits
/ TARGET_CHAR_BIT
,
678 ptr2
+ offset2_bits
/ TARGET_CHAR_BIT
,
679 length_bits
/ TARGET_CHAR_BIT
);
682 /* Length is zero, regions match. */
686 /* Helper function for value_available_contents_eq. The only difference is
687 that this function is bit rather than byte based.
689 Compare LENGTH bits of VAL1's contents starting at OFFSET1 bits with
690 LENGTH bits of VAL2's contents starting at OFFSET2 bits. Return true
691 if the available bits match. */
694 value_available_contents_bits_eq (const struct value
*val1
, int offset1
,
695 const struct value
*val2
, int offset2
,
698 int idx1
= 0, idx2
= 0;
700 /* See function description in value.h. */
701 gdb_assert (!val1
->lazy
&& !val2
->lazy
);
709 idx1
= find_first_range_overlap (val1
->unavailable
, idx1
,
711 idx2
= find_first_range_overlap (val2
->unavailable
, idx2
,
714 /* The usual case is for both values to be completely available. */
715 if (idx1
== -1 && idx2
== -1)
716 return (memcmp_with_bit_offsets (val1
->contents
, offset1
,
717 val2
->contents
, offset2
,
719 /* The contents only match equal if the available set matches as
721 else if (idx1
== -1 || idx2
== -1)
724 gdb_assert (idx1
!= -1 && idx2
!= -1);
726 r1
= VEC_index (range_s
, val1
->unavailable
, idx1
);
727 r2
= VEC_index (range_s
, val2
->unavailable
, idx2
);
729 /* Get the unavailable windows intersected by the incoming
730 ranges. The first and last ranges that overlap the argument
731 range may be wider than said incoming arguments ranges. */
732 l1
= max (offset1
, r1
->offset
);
733 h1
= min (offset1
+ length
, r1
->offset
+ r1
->length
);
735 l2
= max (offset2
, r2
->offset
);
736 h2
= min (offset2
+ length
, r2
->offset
+ r2
->length
);
738 /* Make them relative to the respective start offsets, so we can
739 compare them for equality. */
746 /* Different availability, no match. */
747 if (l1
!= l2
|| h1
!= h2
)
750 /* Compare the _available_ contents. */
751 if (memcmp_with_bit_offsets (val1
->contents
, offset1
,
752 val2
->contents
, offset2
, l1
) != 0)
764 value_available_contents_eq (const struct value
*val1
, int offset1
,
765 const struct value
*val2
, int offset2
,
768 return value_available_contents_bits_eq (val1
, offset1
* TARGET_CHAR_BIT
,
769 val2
, offset2
* TARGET_CHAR_BIT
,
770 length
* TARGET_CHAR_BIT
);
773 /* Prototypes for local functions. */
775 static void show_values (char *, int);
777 static void show_convenience (char *, int);
780 /* The value-history records all the values printed
781 by print commands during this session. Each chunk
782 records 60 consecutive values. The first chunk on
783 the chain records the most recent values.
784 The total number of values is in value_history_count. */
786 #define VALUE_HISTORY_CHUNK 60
788 struct value_history_chunk
790 struct value_history_chunk
*next
;
791 struct value
*values
[VALUE_HISTORY_CHUNK
];
794 /* Chain of chunks now in use. */
796 static struct value_history_chunk
*value_history_chain
;
798 static int value_history_count
; /* Abs number of last entry stored. */
801 /* List of all value objects currently allocated
802 (except for those released by calls to release_value)
803 This is so they can be freed after each command. */
805 static struct value
*all_values
;
807 /* Allocate a lazy value for type TYPE. Its actual content is
808 "lazily" allocated too: the content field of the return value is
809 NULL; it will be allocated when it is fetched from the target. */
812 allocate_value_lazy (struct type
*type
)
816 /* Call check_typedef on our type to make sure that, if TYPE
817 is a TYPE_CODE_TYPEDEF, its length is set to the length
818 of the target type instead of zero. However, we do not
819 replace the typedef type by the target type, because we want
820 to keep the typedef in order to be able to set the VAL's type
821 description correctly. */
822 check_typedef (type
);
824 val
= (struct value
*) xzalloc (sizeof (struct value
));
825 val
->contents
= NULL
;
826 val
->next
= all_values
;
829 val
->enclosing_type
= type
;
830 VALUE_LVAL (val
) = not_lval
;
831 val
->location
.address
= 0;
832 VALUE_FRAME_ID (val
) = null_frame_id
;
836 VALUE_REGNUM (val
) = -1;
838 val
->optimized_out
= 0;
839 val
->embedded_offset
= 0;
840 val
->pointed_to_offset
= 0;
842 val
->initialized
= 1; /* Default to initialized. */
844 /* Values start out on the all_values chain. */
845 val
->reference_count
= 1;
850 /* Allocate the contents of VAL if it has not been allocated yet. */
853 allocate_value_contents (struct value
*val
)
856 val
->contents
= (gdb_byte
*) xzalloc (TYPE_LENGTH (val
->enclosing_type
));
859 /* Allocate a value and its contents for type TYPE. */
862 allocate_value (struct type
*type
)
864 struct value
*val
= allocate_value_lazy (type
);
866 allocate_value_contents (val
);
871 /* Allocate a value that has the correct length
872 for COUNT repetitions of type TYPE. */
875 allocate_repeat_value (struct type
*type
, int count
)
877 int low_bound
= current_language
->string_lower_bound
; /* ??? */
878 /* FIXME-type-allocation: need a way to free this type when we are
880 struct type
*array_type
881 = lookup_array_range_type (type
, low_bound
, count
+ low_bound
- 1);
883 return allocate_value (array_type
);
887 allocate_computed_value (struct type
*type
,
888 const struct lval_funcs
*funcs
,
891 struct value
*v
= allocate_value_lazy (type
);
893 VALUE_LVAL (v
) = lval_computed
;
894 v
->location
.computed
.funcs
= funcs
;
895 v
->location
.computed
.closure
= closure
;
900 /* Allocate NOT_LVAL value for type TYPE being OPTIMIZED_OUT. */
903 allocate_optimized_out_value (struct type
*type
)
905 struct value
*retval
= allocate_value_lazy (type
);
907 set_value_optimized_out (retval
, 1);
908 /* FIXME: we should be able to avoid allocating the value's contents
909 buffer, but value_available_contents_bits_eq can't handle
911 /* set_value_lazy (retval, 0); */
915 /* Accessor methods. */
918 value_next (struct value
*value
)
924 value_type (const struct value
*value
)
929 deprecated_set_value_type (struct value
*value
, struct type
*type
)
935 value_offset (const struct value
*value
)
937 return value
->offset
;
940 set_value_offset (struct value
*value
, int offset
)
942 value
->offset
= offset
;
946 value_bitpos (const struct value
*value
)
948 return value
->bitpos
;
951 set_value_bitpos (struct value
*value
, int bit
)
957 value_bitsize (const struct value
*value
)
959 return value
->bitsize
;
962 set_value_bitsize (struct value
*value
, int bit
)
964 value
->bitsize
= bit
;
968 value_parent (struct value
*value
)
970 return value
->parent
;
976 set_value_parent (struct value
*value
, struct value
*parent
)
978 struct value
*old
= value
->parent
;
980 value
->parent
= parent
;
982 value_incref (parent
);
987 value_contents_raw (struct value
*value
)
989 allocate_value_contents (value
);
990 return value
->contents
+ value
->embedded_offset
;
994 value_contents_all_raw (struct value
*value
)
996 allocate_value_contents (value
);
997 return value
->contents
;
1001 value_enclosing_type (struct value
*value
)
1003 return value
->enclosing_type
;
1006 /* Look at value.h for description. */
1009 value_actual_type (struct value
*value
, int resolve_simple_types
,
1010 int *real_type_found
)
1012 struct value_print_options opts
;
1013 struct type
*result
;
1015 get_user_print_options (&opts
);
1017 if (real_type_found
)
1018 *real_type_found
= 0;
1019 result
= value_type (value
);
1020 if (opts
.objectprint
)
1022 /* If result's target type is TYPE_CODE_STRUCT, proceed to
1023 fetch its rtti type. */
1024 if ((TYPE_CODE (result
) == TYPE_CODE_PTR
1025 || TYPE_CODE (result
) == TYPE_CODE_REF
)
1026 && TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result
)))
1027 == TYPE_CODE_STRUCT
)
1029 struct type
*real_type
;
1031 real_type
= value_rtti_indirect_type (value
, NULL
, NULL
, NULL
);
1034 if (real_type_found
)
1035 *real_type_found
= 1;
1039 else if (resolve_simple_types
)
1041 if (real_type_found
)
1042 *real_type_found
= 1;
1043 result
= value_enclosing_type (value
);
1051 error_value_optimized_out (void)
1053 error (_("value has been optimized out"));
1057 require_not_optimized_out (const struct value
*value
)
1059 if (value
->optimized_out
)
1061 if (value
->lval
== lval_register
)
1062 error (_("register has not been saved in frame"));
1064 error_value_optimized_out ();
1069 require_available (const struct value
*value
)
1071 if (!VEC_empty (range_s
, value
->unavailable
))
1072 throw_error (NOT_AVAILABLE_ERROR
, _("value is not available"));
1076 value_contents_for_printing (struct value
*value
)
1079 value_fetch_lazy (value
);
1080 return value
->contents
;
1084 value_contents_for_printing_const (const struct value
*value
)
1086 gdb_assert (!value
->lazy
);
1087 return value
->contents
;
1091 value_contents_all (struct value
*value
)
1093 const gdb_byte
*result
= value_contents_for_printing (value
);
1094 require_not_optimized_out (value
);
1095 require_available (value
);
1099 /* Copy LENGTH bytes of SRC value's (all) contents
1100 (value_contents_all) starting at SRC_OFFSET, into DST value's (all)
1101 contents, starting at DST_OFFSET. If unavailable contents are
1102 being copied from SRC, the corresponding DST contents are marked
1103 unavailable accordingly. Neither DST nor SRC may be lazy
1106 It is assumed the contents of DST in the [DST_OFFSET,
1107 DST_OFFSET+LENGTH) range are wholly available. */
1110 value_contents_copy_raw (struct value
*dst
, int dst_offset
,
1111 struct value
*src
, int src_offset
, int length
)
1115 int src_bit_offset
, dst_bit_offset
, bit_length
;
1117 /* A lazy DST would make that this copy operation useless, since as
1118 soon as DST's contents were un-lazied (by a later value_contents
1119 call, say), the contents would be overwritten. A lazy SRC would
1120 mean we'd be copying garbage. */
1121 gdb_assert (!dst
->lazy
&& !src
->lazy
);
1123 /* The overwritten DST range gets unavailability ORed in, not
1124 replaced. Make sure to remember to implement replacing if it
1125 turns out actually necessary. */
1126 gdb_assert (value_bytes_available (dst
, dst_offset
, length
));
1128 /* Copy the data. */
1129 memcpy (value_contents_all_raw (dst
) + dst_offset
,
1130 value_contents_all_raw (src
) + src_offset
,
1133 /* Copy the meta-data, adjusted. */
1134 src_bit_offset
= src_offset
* TARGET_CHAR_BIT
;
1135 dst_bit_offset
= dst_offset
* TARGET_CHAR_BIT
;
1136 bit_length
= length
* TARGET_CHAR_BIT
;
1137 for (i
= 0; VEC_iterate (range_s
, src
->unavailable
, i
, r
); i
++)
1141 l
= max (r
->offset
, src_bit_offset
);
1142 h
= min (r
->offset
+ r
->length
, src_bit_offset
+ bit_length
);
1145 mark_value_bits_unavailable (dst
,
1146 dst_bit_offset
+ (l
- src_bit_offset
),
1151 /* Copy LENGTH bytes of SRC value's (all) contents
1152 (value_contents_all) starting at SRC_OFFSET byte, into DST value's
1153 (all) contents, starting at DST_OFFSET. If unavailable contents
1154 are being copied from SRC, the corresponding DST contents are
1155 marked unavailable accordingly. DST must not be lazy. If SRC is
1156 lazy, it will be fetched now. If SRC is not valid (is optimized
1157 out), an error is thrown.
1159 It is assumed the contents of DST in the [DST_OFFSET,
1160 DST_OFFSET+LENGTH) range are wholly available. */
1163 value_contents_copy (struct value
*dst
, int dst_offset
,
1164 struct value
*src
, int src_offset
, int length
)
1166 require_not_optimized_out (src
);
1169 value_fetch_lazy (src
);
1171 value_contents_copy_raw (dst
, dst_offset
, src
, src_offset
, length
);
1175 value_lazy (struct value
*value
)
1181 set_value_lazy (struct value
*value
, int val
)
1187 value_stack (struct value
*value
)
1189 return value
->stack
;
1193 set_value_stack (struct value
*value
, int val
)
1199 value_contents (struct value
*value
)
1201 const gdb_byte
*result
= value_contents_writeable (value
);
1202 require_not_optimized_out (value
);
1203 require_available (value
);
1208 value_contents_writeable (struct value
*value
)
1211 value_fetch_lazy (value
);
1212 return value_contents_raw (value
);
1216 value_optimized_out (struct value
*value
)
1218 /* We can only know if a value is optimized out once we have tried to
1220 if (!value
->optimized_out
&& value
->lazy
)
1221 value_fetch_lazy (value
);
1223 return value
->optimized_out
;
1227 value_optimized_out_const (const struct value
*value
)
1229 return value
->optimized_out
;
1233 set_value_optimized_out (struct value
*value
, int val
)
1235 value
->optimized_out
= val
;
1239 value_entirely_optimized_out (const struct value
*value
)
1241 if (!value
->optimized_out
)
1243 if (value
->lval
!= lval_computed
1244 || !value
->location
.computed
.funcs
->check_any_valid
)
1246 return !value
->location
.computed
.funcs
->check_any_valid (value
);
1250 value_bits_valid (const struct value
*value
, int offset
, int length
)
1252 if (!value
->optimized_out
)
1254 if (value
->lval
!= lval_computed
1255 || !value
->location
.computed
.funcs
->check_validity
)
1257 return value
->location
.computed
.funcs
->check_validity (value
, offset
,
1262 value_bits_synthetic_pointer (const struct value
*value
,
1263 int offset
, int length
)
1265 if (value
->lval
!= lval_computed
1266 || !value
->location
.computed
.funcs
->check_synthetic_pointer
)
1268 return value
->location
.computed
.funcs
->check_synthetic_pointer (value
,
1274 value_embedded_offset (struct value
*value
)
1276 return value
->embedded_offset
;
1280 set_value_embedded_offset (struct value
*value
, int val
)
1282 value
->embedded_offset
= val
;
1286 value_pointed_to_offset (struct value
*value
)
1288 return value
->pointed_to_offset
;
1292 set_value_pointed_to_offset (struct value
*value
, int val
)
1294 value
->pointed_to_offset
= val
;
1297 const struct lval_funcs
*
1298 value_computed_funcs (const struct value
*v
)
1300 gdb_assert (value_lval_const (v
) == lval_computed
);
1302 return v
->location
.computed
.funcs
;
1306 value_computed_closure (const struct value
*v
)
1308 gdb_assert (v
->lval
== lval_computed
);
1310 return v
->location
.computed
.closure
;
1314 deprecated_value_lval_hack (struct value
*value
)
1316 return &value
->lval
;
1320 value_lval_const (const struct value
*value
)
1326 value_address (const struct value
*value
)
1328 if (value
->lval
== lval_internalvar
1329 || value
->lval
== lval_internalvar_component
1330 || value
->lval
== lval_xcallable
)
1332 if (value
->parent
!= NULL
)
1333 return value_address (value
->parent
) + value
->offset
;
1335 return value
->location
.address
+ value
->offset
;
1339 value_raw_address (struct value
*value
)
1341 if (value
->lval
== lval_internalvar
1342 || value
->lval
== lval_internalvar_component
1343 || value
->lval
== lval_xcallable
)
1345 return value
->location
.address
;
1349 set_value_address (struct value
*value
, CORE_ADDR addr
)
1351 gdb_assert (value
->lval
!= lval_internalvar
1352 && value
->lval
!= lval_internalvar_component
1353 && value
->lval
!= lval_xcallable
);
1354 value
->location
.address
= addr
;
1357 struct internalvar
**
1358 deprecated_value_internalvar_hack (struct value
*value
)
1360 return &value
->location
.internalvar
;
1364 deprecated_value_frame_id_hack (struct value
*value
)
1366 return &value
->frame_id
;
1370 deprecated_value_regnum_hack (struct value
*value
)
1372 return &value
->regnum
;
1376 deprecated_value_modifiable (struct value
*value
)
1378 return value
->modifiable
;
1381 /* Return a mark in the value chain. All values allocated after the
1382 mark is obtained (except for those released) are subject to being freed
1383 if a subsequent value_free_to_mark is passed the mark. */
1390 /* Take a reference to VAL. VAL will not be deallocated until all
1391 references are released. */
1394 value_incref (struct value
*val
)
1396 val
->reference_count
++;
1399 /* Release a reference to VAL, which was acquired with value_incref.
1400 This function is also called to deallocate values from the value
1404 value_free (struct value
*val
)
1408 gdb_assert (val
->reference_count
> 0);
1409 val
->reference_count
--;
1410 if (val
->reference_count
> 0)
1413 /* If there's an associated parent value, drop our reference to
1415 if (val
->parent
!= NULL
)
1416 value_free (val
->parent
);
1418 if (VALUE_LVAL (val
) == lval_computed
)
1420 const struct lval_funcs
*funcs
= val
->location
.computed
.funcs
;
1422 if (funcs
->free_closure
)
1423 funcs
->free_closure (val
);
1425 else if (VALUE_LVAL (val
) == lval_xcallable
)
1426 free_xmethod_worker (val
->location
.xm_worker
);
1428 xfree (val
->contents
);
1429 VEC_free (range_s
, val
->unavailable
);
1434 /* Free all values allocated since MARK was obtained by value_mark
1435 (except for those released). */
1437 value_free_to_mark (struct value
*mark
)
1442 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
1451 /* Free all the values that have been allocated (except for those released).
1452 Call after each command, successful or not.
1453 In practice this is called before each command, which is sufficient. */
1456 free_all_values (void)
1461 for (val
= all_values
; val
; val
= next
)
1471 /* Frees all the elements in a chain of values. */
1474 free_value_chain (struct value
*v
)
1480 next
= value_next (v
);
1485 /* Remove VAL from the chain all_values
1486 so it will not be freed automatically. */
1489 release_value (struct value
*val
)
1493 if (all_values
== val
)
1495 all_values
= val
->next
;
1501 for (v
= all_values
; v
; v
= v
->next
)
1505 v
->next
= val
->next
;
1513 /* If the value is not already released, release it.
1514 If the value is already released, increment its reference count.
1515 That is, this function ensures that the value is released from the
1516 value chain and that the caller owns a reference to it. */
1519 release_value_or_incref (struct value
*val
)
1524 release_value (val
);
1527 /* Release all values up to mark */
1529 value_release_to_mark (struct value
*mark
)
1534 for (val
= next
= all_values
; next
; next
= next
->next
)
1536 if (next
->next
== mark
)
1538 all_values
= next
->next
;
1548 /* Return a copy of the value ARG.
1549 It contains the same contents, for same memory address,
1550 but it's a different block of storage. */
1553 value_copy (struct value
*arg
)
1555 struct type
*encl_type
= value_enclosing_type (arg
);
1558 if (value_lazy (arg
))
1559 val
= allocate_value_lazy (encl_type
);
1561 val
= allocate_value (encl_type
);
1562 val
->type
= arg
->type
;
1563 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
1564 val
->location
= arg
->location
;
1565 val
->offset
= arg
->offset
;
1566 val
->bitpos
= arg
->bitpos
;
1567 val
->bitsize
= arg
->bitsize
;
1568 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
1569 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
1570 val
->lazy
= arg
->lazy
;
1571 val
->optimized_out
= arg
->optimized_out
;
1572 val
->embedded_offset
= value_embedded_offset (arg
);
1573 val
->pointed_to_offset
= arg
->pointed_to_offset
;
1574 val
->modifiable
= arg
->modifiable
;
1575 if (!value_lazy (val
))
1577 memcpy (value_contents_all_raw (val
), value_contents_all_raw (arg
),
1578 TYPE_LENGTH (value_enclosing_type (arg
)));
1581 val
->unavailable
= VEC_copy (range_s
, arg
->unavailable
);
1582 set_value_parent (val
, arg
->parent
);
1583 if (VALUE_LVAL (val
) == lval_computed
)
1585 const struct lval_funcs
*funcs
= val
->location
.computed
.funcs
;
1587 if (funcs
->copy_closure
)
1588 val
->location
.computed
.closure
= funcs
->copy_closure (val
);
1593 /* Return a version of ARG that is non-lvalue. */
1596 value_non_lval (struct value
*arg
)
1598 if (VALUE_LVAL (arg
) != not_lval
)
1600 struct type
*enc_type
= value_enclosing_type (arg
);
1601 struct value
*val
= allocate_value (enc_type
);
1603 memcpy (value_contents_all_raw (val
), value_contents_all (arg
),
1604 TYPE_LENGTH (enc_type
));
1605 val
->type
= arg
->type
;
1606 set_value_embedded_offset (val
, value_embedded_offset (arg
));
1607 set_value_pointed_to_offset (val
, value_pointed_to_offset (arg
));
1614 set_value_component_location (struct value
*component
,
1615 const struct value
*whole
)
1617 gdb_assert (whole
->lval
!= lval_xcallable
);
1619 if (whole
->lval
== lval_internalvar
)
1620 VALUE_LVAL (component
) = lval_internalvar_component
;
1622 VALUE_LVAL (component
) = whole
->lval
;
1624 component
->location
= whole
->location
;
1625 if (whole
->lval
== lval_computed
)
1627 const struct lval_funcs
*funcs
= whole
->location
.computed
.funcs
;
1629 if (funcs
->copy_closure
)
1630 component
->location
.computed
.closure
= funcs
->copy_closure (whole
);
1635 /* Access to the value history. */
1637 /* Record a new value in the value history.
1638 Returns the absolute history index of the entry. */
1641 record_latest_value (struct value
*val
)
1645 /* We don't want this value to have anything to do with the inferior anymore.
1646 In particular, "set $1 = 50" should not affect the variable from which
1647 the value was taken, and fast watchpoints should be able to assume that
1648 a value on the value history never changes. */
1649 if (value_lazy (val
))
1650 value_fetch_lazy (val
);
1651 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
1652 from. This is a bit dubious, because then *&$1 does not just return $1
1653 but the current contents of that location. c'est la vie... */
1654 val
->modifiable
= 0;
1656 /* The value may have already been released, in which case we're adding a
1657 new reference for its entry in the history. That is why we call
1658 release_value_or_incref here instead of release_value. */
1659 release_value_or_incref (val
);
1661 /* Here we treat value_history_count as origin-zero
1662 and applying to the value being stored now. */
1664 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
1667 struct value_history_chunk
*new
1668 = (struct value_history_chunk
*)
1670 xmalloc (sizeof (struct value_history_chunk
));
1671 memset (new->values
, 0, sizeof new->values
);
1672 new->next
= value_history_chain
;
1673 value_history_chain
= new;
1676 value_history_chain
->values
[i
] = val
;
1678 /* Now we regard value_history_count as origin-one
1679 and applying to the value just stored. */
1681 return ++value_history_count
;
1684 /* Return a copy of the value in the history with sequence number NUM. */
1687 access_value_history (int num
)
1689 struct value_history_chunk
*chunk
;
1694 absnum
+= value_history_count
;
1699 error (_("The history is empty."));
1701 error (_("There is only one value in the history."));
1703 error (_("History does not go back to $$%d."), -num
);
1705 if (absnum
> value_history_count
)
1706 error (_("History has not yet reached $%d."), absnum
);
1710 /* Now absnum is always absolute and origin zero. */
1712 chunk
= value_history_chain
;
1713 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
1714 - absnum
/ VALUE_HISTORY_CHUNK
;
1716 chunk
= chunk
->next
;
1718 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
1722 show_values (char *num_exp
, int from_tty
)
1730 /* "show values +" should print from the stored position.
1731 "show values <exp>" should print around value number <exp>. */
1732 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
1733 num
= parse_and_eval_long (num_exp
) - 5;
1737 /* "show values" means print the last 10 values. */
1738 num
= value_history_count
- 9;
1744 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
1746 struct value_print_options opts
;
1748 val
= access_value_history (i
);
1749 printf_filtered (("$%d = "), i
);
1750 get_user_print_options (&opts
);
1751 value_print (val
, gdb_stdout
, &opts
);
1752 printf_filtered (("\n"));
1755 /* The next "show values +" should start after what we just printed. */
1758 /* Hitting just return after this command should do the same thing as
1759 "show values +". If num_exp is null, this is unnecessary, since
1760 "show values +" is not useful after "show values". */
1761 if (from_tty
&& num_exp
)
1768 /* Internal variables. These are variables within the debugger
1769 that hold values assigned by debugger commands.
1770 The user refers to them with a '$' prefix
1771 that does not appear in the variable names stored internally. */
1775 struct internalvar
*next
;
1778 /* We support various different kinds of content of an internal variable.
1779 enum internalvar_kind specifies the kind, and union internalvar_data
1780 provides the data associated with this particular kind. */
1782 enum internalvar_kind
1784 /* The internal variable is empty. */
1787 /* The value of the internal variable is provided directly as
1788 a GDB value object. */
1791 /* A fresh value is computed via a call-back routine on every
1792 access to the internal variable. */
1793 INTERNALVAR_MAKE_VALUE
,
1795 /* The internal variable holds a GDB internal convenience function. */
1796 INTERNALVAR_FUNCTION
,
1798 /* The variable holds an integer value. */
1799 INTERNALVAR_INTEGER
,
1801 /* The variable holds a GDB-provided string. */
1806 union internalvar_data
1808 /* A value object used with INTERNALVAR_VALUE. */
1809 struct value
*value
;
1811 /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
1814 /* The functions to call. */
1815 const struct internalvar_funcs
*functions
;
1817 /* The function's user-data. */
1821 /* The internal function used with INTERNALVAR_FUNCTION. */
1824 struct internal_function
*function
;
1825 /* True if this is the canonical name for the function. */
1829 /* An integer value used with INTERNALVAR_INTEGER. */
1832 /* If type is non-NULL, it will be used as the type to generate
1833 a value for this internal variable. If type is NULL, a default
1834 integer type for the architecture is used. */
1839 /* A string value used with INTERNALVAR_STRING. */
1844 static struct internalvar
*internalvars
;
1846 /* If the variable does not already exist create it and give it the
1847 value given. If no value is given then the default is zero. */
1849 init_if_undefined_command (char* args
, int from_tty
)
1851 struct internalvar
* intvar
;
1853 /* Parse the expression - this is taken from set_command(). */
1854 struct expression
*expr
= parse_expression (args
);
1855 register struct cleanup
*old_chain
=
1856 make_cleanup (free_current_contents
, &expr
);
1858 /* Validate the expression.
1859 Was the expression an assignment?
1860 Or even an expression at all? */
1861 if (expr
->nelts
== 0 || expr
->elts
[0].opcode
!= BINOP_ASSIGN
)
1862 error (_("Init-if-undefined requires an assignment expression."));
1864 /* Extract the variable from the parsed expression.
1865 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
1866 if (expr
->elts
[1].opcode
!= OP_INTERNALVAR
)
1867 error (_("The first parameter to init-if-undefined "
1868 "should be a GDB variable."));
1869 intvar
= expr
->elts
[2].internalvar
;
1871 /* Only evaluate the expression if the lvalue is void.
1872 This may still fail if the expresssion is invalid. */
1873 if (intvar
->kind
== INTERNALVAR_VOID
)
1874 evaluate_expression (expr
);
1876 do_cleanups (old_chain
);
1880 /* Look up an internal variable with name NAME. NAME should not
1881 normally include a dollar sign.
1883 If the specified internal variable does not exist,
1884 the return value is NULL. */
1886 struct internalvar
*
1887 lookup_only_internalvar (const char *name
)
1889 struct internalvar
*var
;
1891 for (var
= internalvars
; var
; var
= var
->next
)
1892 if (strcmp (var
->name
, name
) == 0)
1898 /* Complete NAME by comparing it to the names of internal variables.
1899 Returns a vector of newly allocated strings, or NULL if no matches
1903 complete_internalvar (const char *name
)
1905 VEC (char_ptr
) *result
= NULL
;
1906 struct internalvar
*var
;
1909 len
= strlen (name
);
1911 for (var
= internalvars
; var
; var
= var
->next
)
1912 if (strncmp (var
->name
, name
, len
) == 0)
1914 char *r
= xstrdup (var
->name
);
1916 VEC_safe_push (char_ptr
, result
, r
);
1922 /* Create an internal variable with name NAME and with a void value.
1923 NAME should not normally include a dollar sign. */
1925 struct internalvar
*
1926 create_internalvar (const char *name
)
1928 struct internalvar
*var
;
1930 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
1931 var
->name
= concat (name
, (char *)NULL
);
1932 var
->kind
= INTERNALVAR_VOID
;
1933 var
->next
= internalvars
;
1938 /* Create an internal variable with name NAME and register FUN as the
1939 function that value_of_internalvar uses to create a value whenever
1940 this variable is referenced. NAME should not normally include a
1941 dollar sign. DATA is passed uninterpreted to FUN when it is
1942 called. CLEANUP, if not NULL, is called when the internal variable
1943 is destroyed. It is passed DATA as its only argument. */
1945 struct internalvar
*
1946 create_internalvar_type_lazy (const char *name
,
1947 const struct internalvar_funcs
*funcs
,
1950 struct internalvar
*var
= create_internalvar (name
);
1952 var
->kind
= INTERNALVAR_MAKE_VALUE
;
1953 var
->u
.make_value
.functions
= funcs
;
1954 var
->u
.make_value
.data
= data
;
1958 /* See documentation in value.h. */
1961 compile_internalvar_to_ax (struct internalvar
*var
,
1962 struct agent_expr
*expr
,
1963 struct axs_value
*value
)
1965 if (var
->kind
!= INTERNALVAR_MAKE_VALUE
1966 || var
->u
.make_value
.functions
->compile_to_ax
== NULL
)
1969 var
->u
.make_value
.functions
->compile_to_ax (var
, expr
, value
,
1970 var
->u
.make_value
.data
);
1974 /* Look up an internal variable with name NAME. NAME should not
1975 normally include a dollar sign.
1977 If the specified internal variable does not exist,
1978 one is created, with a void value. */
1980 struct internalvar
*
1981 lookup_internalvar (const char *name
)
1983 struct internalvar
*var
;
1985 var
= lookup_only_internalvar (name
);
1989 return create_internalvar (name
);
1992 /* Return current value of internal variable VAR. For variables that
1993 are not inherently typed, use a value type appropriate for GDBARCH. */
1996 value_of_internalvar (struct gdbarch
*gdbarch
, struct internalvar
*var
)
1999 struct trace_state_variable
*tsv
;
2001 /* If there is a trace state variable of the same name, assume that
2002 is what we really want to see. */
2003 tsv
= find_trace_state_variable (var
->name
);
2006 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2008 if (tsv
->value_known
)
2009 val
= value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2012 val
= allocate_value (builtin_type (gdbarch
)->builtin_void
);
2018 case INTERNALVAR_VOID
:
2019 val
= allocate_value (builtin_type (gdbarch
)->builtin_void
);
2022 case INTERNALVAR_FUNCTION
:
2023 val
= allocate_value (builtin_type (gdbarch
)->internal_fn
);
2026 case INTERNALVAR_INTEGER
:
2027 if (!var
->u
.integer
.type
)
2028 val
= value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2029 var
->u
.integer
.val
);
2031 val
= value_from_longest (var
->u
.integer
.type
, var
->u
.integer
.val
);
2034 case INTERNALVAR_STRING
:
2035 val
= value_cstring (var
->u
.string
, strlen (var
->u
.string
),
2036 builtin_type (gdbarch
)->builtin_char
);
2039 case INTERNALVAR_VALUE
:
2040 val
= value_copy (var
->u
.value
);
2041 if (value_lazy (val
))
2042 value_fetch_lazy (val
);
2045 case INTERNALVAR_MAKE_VALUE
:
2046 val
= (*var
->u
.make_value
.functions
->make_value
) (gdbarch
, var
,
2047 var
->u
.make_value
.data
);
2051 internal_error (__FILE__
, __LINE__
, _("bad kind"));
2054 /* Change the VALUE_LVAL to lval_internalvar so that future operations
2055 on this value go back to affect the original internal variable.
2057 Do not do this for INTERNALVAR_MAKE_VALUE variables, as those have
2058 no underlying modifyable state in the internal variable.
2060 Likewise, if the variable's value is a computed lvalue, we want
2061 references to it to produce another computed lvalue, where
2062 references and assignments actually operate through the
2063 computed value's functions.
2065 This means that internal variables with computed values
2066 behave a little differently from other internal variables:
2067 assignments to them don't just replace the previous value
2068 altogether. At the moment, this seems like the behavior we
2071 if (var
->kind
!= INTERNALVAR_MAKE_VALUE
2072 && val
->lval
!= lval_computed
)
2074 VALUE_LVAL (val
) = lval_internalvar
;
2075 VALUE_INTERNALVAR (val
) = var
;
2082 get_internalvar_integer (struct internalvar
*var
, LONGEST
*result
)
2084 if (var
->kind
== INTERNALVAR_INTEGER
)
2086 *result
= var
->u
.integer
.val
;
2090 if (var
->kind
== INTERNALVAR_VALUE
)
2092 struct type
*type
= check_typedef (value_type (var
->u
.value
));
2094 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2096 *result
= value_as_long (var
->u
.value
);
2105 get_internalvar_function (struct internalvar
*var
,
2106 struct internal_function
**result
)
2110 case INTERNALVAR_FUNCTION
:
2111 *result
= var
->u
.fn
.function
;
2120 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
2121 int bitsize
, struct value
*newval
)
2127 case INTERNALVAR_VALUE
:
2128 addr
= value_contents_writeable (var
->u
.value
);
2131 modify_field (value_type (var
->u
.value
), addr
+ offset
,
2132 value_as_long (newval
), bitpos
, bitsize
);
2134 memcpy (addr
+ offset
, value_contents (newval
),
2135 TYPE_LENGTH (value_type (newval
)));
2139 /* We can never get a component of any other kind. */
2140 internal_error (__FILE__
, __LINE__
, _("set_internalvar_component"));
2145 set_internalvar (struct internalvar
*var
, struct value
*val
)
2147 enum internalvar_kind new_kind
;
2148 union internalvar_data new_data
= { 0 };
2150 if (var
->kind
== INTERNALVAR_FUNCTION
&& var
->u
.fn
.canonical
)
2151 error (_("Cannot overwrite convenience function %s"), var
->name
);
2153 /* Prepare new contents. */
2154 switch (TYPE_CODE (check_typedef (value_type (val
))))
2156 case TYPE_CODE_VOID
:
2157 new_kind
= INTERNALVAR_VOID
;
2160 case TYPE_CODE_INTERNAL_FUNCTION
:
2161 gdb_assert (VALUE_LVAL (val
) == lval_internalvar
);
2162 new_kind
= INTERNALVAR_FUNCTION
;
2163 get_internalvar_function (VALUE_INTERNALVAR (val
),
2164 &new_data
.fn
.function
);
2165 /* Copies created here are never canonical. */
2169 new_kind
= INTERNALVAR_VALUE
;
2170 new_data
.value
= value_copy (val
);
2171 new_data
.value
->modifiable
= 1;
2173 /* Force the value to be fetched from the target now, to avoid problems
2174 later when this internalvar is referenced and the target is gone or
2176 if (value_lazy (new_data
.value
))
2177 value_fetch_lazy (new_data
.value
);
2179 /* Release the value from the value chain to prevent it from being
2180 deleted by free_all_values. From here on this function should not
2181 call error () until new_data is installed into the var->u to avoid
2183 release_value (new_data
.value
);
2187 /* Clean up old contents. */
2188 clear_internalvar (var
);
2191 var
->kind
= new_kind
;
2193 /* End code which must not call error(). */
2197 set_internalvar_integer (struct internalvar
*var
, LONGEST l
)
2199 /* Clean up old contents. */
2200 clear_internalvar (var
);
2202 var
->kind
= INTERNALVAR_INTEGER
;
2203 var
->u
.integer
.type
= NULL
;
2204 var
->u
.integer
.val
= l
;
2208 set_internalvar_string (struct internalvar
*var
, const char *string
)
2210 /* Clean up old contents. */
2211 clear_internalvar (var
);
2213 var
->kind
= INTERNALVAR_STRING
;
2214 var
->u
.string
= xstrdup (string
);
2218 set_internalvar_function (struct internalvar
*var
, struct internal_function
*f
)
2220 /* Clean up old contents. */
2221 clear_internalvar (var
);
2223 var
->kind
= INTERNALVAR_FUNCTION
;
2224 var
->u
.fn
.function
= f
;
2225 var
->u
.fn
.canonical
= 1;
2226 /* Variables installed here are always the canonical version. */
2230 clear_internalvar (struct internalvar
*var
)
2232 /* Clean up old contents. */
2235 case INTERNALVAR_VALUE
:
2236 value_free (var
->u
.value
);
2239 case INTERNALVAR_STRING
:
2240 xfree (var
->u
.string
);
2243 case INTERNALVAR_MAKE_VALUE
:
2244 if (var
->u
.make_value
.functions
->destroy
!= NULL
)
2245 var
->u
.make_value
.functions
->destroy (var
->u
.make_value
.data
);
2252 /* Reset to void kind. */
2253 var
->kind
= INTERNALVAR_VOID
;
2257 internalvar_name (struct internalvar
*var
)
2262 static struct internal_function
*
2263 create_internal_function (const char *name
,
2264 internal_function_fn handler
, void *cookie
)
2266 struct internal_function
*ifn
= XNEW (struct internal_function
);
2268 ifn
->name
= xstrdup (name
);
2269 ifn
->handler
= handler
;
2270 ifn
->cookie
= cookie
;
2275 value_internal_function_name (struct value
*val
)
2277 struct internal_function
*ifn
;
2280 gdb_assert (VALUE_LVAL (val
) == lval_internalvar
);
2281 result
= get_internalvar_function (VALUE_INTERNALVAR (val
), &ifn
);
2282 gdb_assert (result
);
2288 call_internal_function (struct gdbarch
*gdbarch
,
2289 const struct language_defn
*language
,
2290 struct value
*func
, int argc
, struct value
**argv
)
2292 struct internal_function
*ifn
;
2295 gdb_assert (VALUE_LVAL (func
) == lval_internalvar
);
2296 result
= get_internalvar_function (VALUE_INTERNALVAR (func
), &ifn
);
2297 gdb_assert (result
);
2299 return (*ifn
->handler
) (gdbarch
, language
, ifn
->cookie
, argc
, argv
);
2302 /* The 'function' command. This does nothing -- it is just a
2303 placeholder to let "help function NAME" work. This is also used as
2304 the implementation of the sub-command that is created when
2305 registering an internal function. */
2307 function_command (char *command
, int from_tty
)
2312 /* Clean up if an internal function's command is destroyed. */
2314 function_destroyer (struct cmd_list_element
*self
, void *ignore
)
2316 xfree ((char *) self
->name
);
2317 xfree ((char *) self
->doc
);
2320 /* Add a new internal function. NAME is the name of the function; DOC
2321 is a documentation string describing the function. HANDLER is
2322 called when the function is invoked. COOKIE is an arbitrary
2323 pointer which is passed to HANDLER and is intended for "user
2326 add_internal_function (const char *name
, const char *doc
,
2327 internal_function_fn handler
, void *cookie
)
2329 struct cmd_list_element
*cmd
;
2330 struct internal_function
*ifn
;
2331 struct internalvar
*var
= lookup_internalvar (name
);
2333 ifn
= create_internal_function (name
, handler
, cookie
);
2334 set_internalvar_function (var
, ifn
);
2336 cmd
= add_cmd (xstrdup (name
), no_class
, function_command
, (char *) doc
,
2338 cmd
->destroyer
= function_destroyer
;
2341 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
2342 prevent cycles / duplicates. */
2345 preserve_one_value (struct value
*value
, struct objfile
*objfile
,
2346 htab_t copied_types
)
2348 if (TYPE_OBJFILE (value
->type
) == objfile
)
2349 value
->type
= copy_type_recursive (objfile
, value
->type
, copied_types
);
2351 if (TYPE_OBJFILE (value
->enclosing_type
) == objfile
)
2352 value
->enclosing_type
= copy_type_recursive (objfile
,
2353 value
->enclosing_type
,
2357 /* Likewise for internal variable VAR. */
2360 preserve_one_internalvar (struct internalvar
*var
, struct objfile
*objfile
,
2361 htab_t copied_types
)
2365 case INTERNALVAR_INTEGER
:
2366 if (var
->u
.integer
.type
&& TYPE_OBJFILE (var
->u
.integer
.type
) == objfile
)
2368 = copy_type_recursive (objfile
, var
->u
.integer
.type
, copied_types
);
2371 case INTERNALVAR_VALUE
:
2372 preserve_one_value (var
->u
.value
, objfile
, copied_types
);
2377 /* Update the internal variables and value history when OBJFILE is
2378 discarded; we must copy the types out of the objfile. New global types
2379 will be created for every convenience variable which currently points to
2380 this objfile's types, and the convenience variables will be adjusted to
2381 use the new global types. */
2384 preserve_values (struct objfile
*objfile
)
2386 htab_t copied_types
;
2387 struct value_history_chunk
*cur
;
2388 struct internalvar
*var
;
2391 /* Create the hash table. We allocate on the objfile's obstack, since
2392 it is soon to be deleted. */
2393 copied_types
= create_copied_types_hash (objfile
);
2395 for (cur
= value_history_chain
; cur
; cur
= cur
->next
)
2396 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
2398 preserve_one_value (cur
->values
[i
], objfile
, copied_types
);
2400 for (var
= internalvars
; var
; var
= var
->next
)
2401 preserve_one_internalvar (var
, objfile
, copied_types
);
2403 preserve_ext_lang_values (objfile
, copied_types
);
2405 htab_delete (copied_types
);
2409 show_convenience (char *ignore
, int from_tty
)
2411 struct gdbarch
*gdbarch
= get_current_arch ();
2412 struct internalvar
*var
;
2414 struct value_print_options opts
;
2416 get_user_print_options (&opts
);
2417 for (var
= internalvars
; var
; var
= var
->next
)
2419 volatile struct gdb_exception ex
;
2425 printf_filtered (("$%s = "), var
->name
);
2427 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2431 val
= value_of_internalvar (gdbarch
, var
);
2432 value_print (val
, gdb_stdout
, &opts
);
2435 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
2436 printf_filtered (("\n"));
2440 /* This text does not mention convenience functions on purpose.
2441 The user can't create them except via Python, and if Python support
2442 is installed this message will never be printed ($_streq will
2444 printf_unfiltered (_("No debugger convenience variables now defined.\n"
2445 "Convenience variables have "
2446 "names starting with \"$\";\n"
2447 "use \"set\" as in \"set "
2448 "$foo = 5\" to define them.\n"));
2452 /* Return the TYPE_CODE_XMETHOD value corresponding to WORKER. */
2455 value_of_xmethod (struct xmethod_worker
*worker
)
2457 if (worker
->value
== NULL
)
2461 v
= allocate_value (builtin_type (target_gdbarch ())->xmethod
);
2462 v
->lval
= lval_xcallable
;
2463 v
->location
.xm_worker
= worker
;
2468 return worker
->value
;
2471 /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD. */
2474 call_xmethod (struct value
*method
, int argc
, struct value
**argv
)
2476 gdb_assert (TYPE_CODE (value_type (method
)) == TYPE_CODE_XMETHOD
2477 && method
->lval
== lval_xcallable
&& argc
> 0);
2479 return invoke_xmethod (method
->location
.xm_worker
,
2480 argv
[0], argv
+ 1, argc
- 1);
2483 /* Extract a value as a C number (either long or double).
2484 Knows how to convert fixed values to double, or
2485 floating values to long.
2486 Does not deallocate the value. */
2489 value_as_long (struct value
*val
)
2491 /* This coerces arrays and functions, which is necessary (e.g.
2492 in disassemble_command). It also dereferences references, which
2493 I suspect is the most logical thing to do. */
2494 val
= coerce_array (val
);
2495 return unpack_long (value_type (val
), value_contents (val
));
2499 value_as_double (struct value
*val
)
2504 foo
= unpack_double (value_type (val
), value_contents (val
), &inv
);
2506 error (_("Invalid floating value found in program."));
2510 /* Extract a value as a C pointer. Does not deallocate the value.
2511 Note that val's type may not actually be a pointer; value_as_long
2512 handles all the cases. */
2514 value_as_address (struct value
*val
)
2516 struct gdbarch
*gdbarch
= get_type_arch (value_type (val
));
2518 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2519 whether we want this to be true eventually. */
2521 /* gdbarch_addr_bits_remove is wrong if we are being called for a
2522 non-address (e.g. argument to "signal", "info break", etc.), or
2523 for pointers to char, in which the low bits *are* significant. */
2524 return gdbarch_addr_bits_remove (gdbarch
, value_as_long (val
));
2527 /* There are several targets (IA-64, PowerPC, and others) which
2528 don't represent pointers to functions as simply the address of
2529 the function's entry point. For example, on the IA-64, a
2530 function pointer points to a two-word descriptor, generated by
2531 the linker, which contains the function's entry point, and the
2532 value the IA-64 "global pointer" register should have --- to
2533 support position-independent code. The linker generates
2534 descriptors only for those functions whose addresses are taken.
2536 On such targets, it's difficult for GDB to convert an arbitrary
2537 function address into a function pointer; it has to either find
2538 an existing descriptor for that function, or call malloc and
2539 build its own. On some targets, it is impossible for GDB to
2540 build a descriptor at all: the descriptor must contain a jump
2541 instruction; data memory cannot be executed; and code memory
2544 Upon entry to this function, if VAL is a value of type `function'
2545 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
2546 value_address (val) is the address of the function. This is what
2547 you'll get if you evaluate an expression like `main'. The call
2548 to COERCE_ARRAY below actually does all the usual unary
2549 conversions, which includes converting values of type `function'
2550 to `pointer to function'. This is the challenging conversion
2551 discussed above. Then, `unpack_long' will convert that pointer
2552 back into an address.
2554 So, suppose the user types `disassemble foo' on an architecture
2555 with a strange function pointer representation, on which GDB
2556 cannot build its own descriptors, and suppose further that `foo'
2557 has no linker-built descriptor. The address->pointer conversion
2558 will signal an error and prevent the command from running, even
2559 though the next step would have been to convert the pointer
2560 directly back into the same address.
2562 The following shortcut avoids this whole mess. If VAL is a
2563 function, just return its address directly. */
2564 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
2565 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
2566 return value_address (val
);
2568 val
= coerce_array (val
);
2570 /* Some architectures (e.g. Harvard), map instruction and data
2571 addresses onto a single large unified address space. For
2572 instance: An architecture may consider a large integer in the
2573 range 0x10000000 .. 0x1000ffff to already represent a data
2574 addresses (hence not need a pointer to address conversion) while
2575 a small integer would still need to be converted integer to
2576 pointer to address. Just assume such architectures handle all
2577 integer conversions in a single function. */
2581 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
2582 must admonish GDB hackers to make sure its behavior matches the
2583 compiler's, whenever possible.
2585 In general, I think GDB should evaluate expressions the same way
2586 the compiler does. When the user copies an expression out of
2587 their source code and hands it to a `print' command, they should
2588 get the same value the compiler would have computed. Any
2589 deviation from this rule can cause major confusion and annoyance,
2590 and needs to be justified carefully. In other words, GDB doesn't
2591 really have the freedom to do these conversions in clever and
2594 AndrewC pointed out that users aren't complaining about how GDB
2595 casts integers to pointers; they are complaining that they can't
2596 take an address from a disassembly listing and give it to `x/i'.
2597 This is certainly important.
2599 Adding an architecture method like integer_to_address() certainly
2600 makes it possible for GDB to "get it right" in all circumstances
2601 --- the target has complete control over how things get done, so
2602 people can Do The Right Thing for their target without breaking
2603 anyone else. The standard doesn't specify how integers get
2604 converted to pointers; usually, the ABI doesn't either, but
2605 ABI-specific code is a more reasonable place to handle it. */
2607 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
2608 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
2609 && gdbarch_integer_to_address_p (gdbarch
))
2610 return gdbarch_integer_to_address (gdbarch
, value_type (val
),
2611 value_contents (val
));
2613 return unpack_long (value_type (val
), value_contents (val
));
2617 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2618 as a long, or as a double, assuming the raw data is described
2619 by type TYPE. Knows how to convert different sizes of values
2620 and can convert between fixed and floating point. We don't assume
2621 any alignment for the raw data. Return value is in host byte order.
2623 If you want functions and arrays to be coerced to pointers, and
2624 references to be dereferenced, call value_as_long() instead.
2626 C++: It is assumed that the front-end has taken care of
2627 all matters concerning pointers to members. A pointer
2628 to member which reaches here is considered to be equivalent
2629 to an INT (or some size). After all, it is only an offset. */
2632 unpack_long (struct type
*type
, const gdb_byte
*valaddr
)
2634 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2635 enum type_code code
= TYPE_CODE (type
);
2636 int len
= TYPE_LENGTH (type
);
2637 int nosign
= TYPE_UNSIGNED (type
);
2641 case TYPE_CODE_TYPEDEF
:
2642 return unpack_long (check_typedef (type
), valaddr
);
2643 case TYPE_CODE_ENUM
:
2644 case TYPE_CODE_FLAGS
:
2645 case TYPE_CODE_BOOL
:
2647 case TYPE_CODE_CHAR
:
2648 case TYPE_CODE_RANGE
:
2649 case TYPE_CODE_MEMBERPTR
:
2651 return extract_unsigned_integer (valaddr
, len
, byte_order
);
2653 return extract_signed_integer (valaddr
, len
, byte_order
);
2656 return extract_typed_floating (valaddr
, type
);
2658 case TYPE_CODE_DECFLOAT
:
2659 /* libdecnumber has a function to convert from decimal to integer, but
2660 it doesn't work when the decimal number has a fractional part. */
2661 return decimal_to_doublest (valaddr
, len
, byte_order
);
2665 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2666 whether we want this to be true eventually. */
2667 return extract_typed_address (valaddr
, type
);
2670 error (_("Value can't be converted to integer."));
2672 return 0; /* Placate lint. */
2675 /* Return a double value from the specified type and address.
2676 INVP points to an int which is set to 0 for valid value,
2677 1 for invalid value (bad float format). In either case,
2678 the returned double is OK to use. Argument is in target
2679 format, result is in host format. */
2682 unpack_double (struct type
*type
, const gdb_byte
*valaddr
, int *invp
)
2684 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2685 enum type_code code
;
2689 *invp
= 0; /* Assume valid. */
2690 CHECK_TYPEDEF (type
);
2691 code
= TYPE_CODE (type
);
2692 len
= TYPE_LENGTH (type
);
2693 nosign
= TYPE_UNSIGNED (type
);
2694 if (code
== TYPE_CODE_FLT
)
2696 /* NOTE: cagney/2002-02-19: There was a test here to see if the
2697 floating-point value was valid (using the macro
2698 INVALID_FLOAT). That test/macro have been removed.
2700 It turns out that only the VAX defined this macro and then
2701 only in a non-portable way. Fixing the portability problem
2702 wouldn't help since the VAX floating-point code is also badly
2703 bit-rotten. The target needs to add definitions for the
2704 methods gdbarch_float_format and gdbarch_double_format - these
2705 exactly describe the target floating-point format. The
2706 problem here is that the corresponding floatformat_vax_f and
2707 floatformat_vax_d values these methods should be set to are
2708 also not defined either. Oops!
2710 Hopefully someone will add both the missing floatformat
2711 definitions and the new cases for floatformat_is_valid (). */
2713 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
2719 return extract_typed_floating (valaddr
, type
);
2721 else if (code
== TYPE_CODE_DECFLOAT
)
2722 return decimal_to_doublest (valaddr
, len
, byte_order
);
2725 /* Unsigned -- be sure we compensate for signed LONGEST. */
2726 return (ULONGEST
) unpack_long (type
, valaddr
);
2730 /* Signed -- we are OK with unpack_long. */
2731 return unpack_long (type
, valaddr
);
2735 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2736 as a CORE_ADDR, assuming the raw data is described by type TYPE.
2737 We don't assume any alignment for the raw data. Return value is in
2740 If you want functions and arrays to be coerced to pointers, and
2741 references to be dereferenced, call value_as_address() instead.
2743 C++: It is assumed that the front-end has taken care of
2744 all matters concerning pointers to members. A pointer
2745 to member which reaches here is considered to be equivalent
2746 to an INT (or some size). After all, it is only an offset. */
2749 unpack_pointer (struct type
*type
, const gdb_byte
*valaddr
)
2751 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2752 whether we want this to be true eventually. */
2753 return unpack_long (type
, valaddr
);
2757 /* Get the value of the FIELDNO'th field (which must be static) of
2761 value_static_field (struct type
*type
, int fieldno
)
2763 struct value
*retval
;
2765 switch (TYPE_FIELD_LOC_KIND (type
, fieldno
))
2767 case FIELD_LOC_KIND_PHYSADDR
:
2768 retval
= value_at_lazy (TYPE_FIELD_TYPE (type
, fieldno
),
2769 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
2771 case FIELD_LOC_KIND_PHYSNAME
:
2773 const char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
2774 /* TYPE_FIELD_NAME (type, fieldno); */
2775 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
2779 /* With some compilers, e.g. HP aCC, static data members are
2780 reported as non-debuggable symbols. */
2781 struct bound_minimal_symbol msym
2782 = lookup_minimal_symbol (phys_name
, NULL
, NULL
);
2785 return allocate_optimized_out_value (type
);
2788 retval
= value_at_lazy (TYPE_FIELD_TYPE (type
, fieldno
),
2789 BMSYMBOL_VALUE_ADDRESS (msym
));
2793 retval
= value_of_variable (sym
, NULL
);
2797 gdb_assert_not_reached ("unexpected field location kind");
2803 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
2804 You have to be careful here, since the size of the data area for the value
2805 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
2806 than the old enclosing type, you have to allocate more space for the
2810 set_value_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
2812 if (TYPE_LENGTH (new_encl_type
) > TYPE_LENGTH (value_enclosing_type (val
)))
2814 (gdb_byte
*) xrealloc (val
->contents
, TYPE_LENGTH (new_encl_type
));
2816 val
->enclosing_type
= new_encl_type
;
2819 /* Given a value ARG1 (offset by OFFSET bytes)
2820 of a struct or union type ARG_TYPE,
2821 extract and return the value of one of its (non-static) fields.
2822 FIELDNO says which field. */
2825 value_primitive_field (struct value
*arg1
, int offset
,
2826 int fieldno
, struct type
*arg_type
)
2831 CHECK_TYPEDEF (arg_type
);
2832 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
2834 /* Call check_typedef on our type to make sure that, if TYPE
2835 is a TYPE_CODE_TYPEDEF, its length is set to the length
2836 of the target type instead of zero. However, we do not
2837 replace the typedef type by the target type, because we want
2838 to keep the typedef in order to be able to print the type
2839 description correctly. */
2840 check_typedef (type
);
2842 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
2844 /* Handle packed fields.
2846 Create a new value for the bitfield, with bitpos and bitsize
2847 set. If possible, arrange offset and bitpos so that we can
2848 do a single aligned read of the size of the containing type.
2849 Otherwise, adjust offset to the byte containing the first
2850 bit. Assume that the address, offset, and embedded offset
2851 are sufficiently aligned. */
2853 int bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
);
2854 int container_bitsize
= TYPE_LENGTH (type
) * 8;
2856 if (arg1
->optimized_out
)
2857 v
= allocate_optimized_out_value (type
);
2860 v
= allocate_value_lazy (type
);
2861 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
2862 if ((bitpos
% container_bitsize
) + v
->bitsize
<= container_bitsize
2863 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
))
2864 v
->bitpos
= bitpos
% container_bitsize
;
2866 v
->bitpos
= bitpos
% 8;
2867 v
->offset
= (value_embedded_offset (arg1
)
2869 + (bitpos
- v
->bitpos
) / 8);
2870 set_value_parent (v
, arg1
);
2871 if (!value_lazy (arg1
))
2872 value_fetch_lazy (v
);
2875 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
2877 /* This field is actually a base subobject, so preserve the
2878 entire object's contents for later references to virtual
2882 /* Lazy register values with offsets are not supported. */
2883 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
2884 value_fetch_lazy (arg1
);
2886 /* The optimized_out flag is only set correctly once a lazy value is
2887 loaded, having just loaded some lazy values we should check the
2888 optimized out case now. */
2889 if (arg1
->optimized_out
)
2890 v
= allocate_optimized_out_value (type
);
2893 /* We special case virtual inheritance here because this
2894 requires access to the contents, which we would rather avoid
2895 for references to ordinary fields of unavailable values. */
2896 if (BASETYPE_VIA_VIRTUAL (arg_type
, fieldno
))
2897 boffset
= baseclass_offset (arg_type
, fieldno
,
2898 value_contents (arg1
),
2899 value_embedded_offset (arg1
),
2900 value_address (arg1
),
2903 boffset
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
2905 if (value_lazy (arg1
))
2906 v
= allocate_value_lazy (value_enclosing_type (arg1
));
2909 v
= allocate_value (value_enclosing_type (arg1
));
2910 value_contents_copy_raw (v
, 0, arg1
, 0,
2911 TYPE_LENGTH (value_enclosing_type (arg1
)));
2914 v
->offset
= value_offset (arg1
);
2915 v
->embedded_offset
= offset
+ value_embedded_offset (arg1
) + boffset
;
2920 /* Plain old data member */
2921 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
2923 /* Lazy register values with offsets are not supported. */
2924 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
2925 value_fetch_lazy (arg1
);
2927 /* The optimized_out flag is only set correctly once a lazy value is
2928 loaded, having just loaded some lazy values we should check for
2929 the optimized out case now. */
2930 if (arg1
->optimized_out
)
2931 v
= allocate_optimized_out_value (type
);
2932 else if (value_lazy (arg1
))
2933 v
= allocate_value_lazy (type
);
2936 v
= allocate_value (type
);
2937 value_contents_copy_raw (v
, value_embedded_offset (v
),
2938 arg1
, value_embedded_offset (arg1
) + offset
,
2939 TYPE_LENGTH (type
));
2941 v
->offset
= (value_offset (arg1
) + offset
2942 + value_embedded_offset (arg1
));
2944 set_value_component_location (v
, arg1
);
2945 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
2946 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
2950 /* Given a value ARG1 of a struct or union type,
2951 extract and return the value of one of its (non-static) fields.
2952 FIELDNO says which field. */
2955 value_field (struct value
*arg1
, int fieldno
)
2957 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
2960 /* Return a non-virtual function as a value.
2961 F is the list of member functions which contains the desired method.
2962 J is an index into F which provides the desired method.
2964 We only use the symbol for its address, so be happy with either a
2965 full symbol or a minimal symbol. */
2968 value_fn_field (struct value
**arg1p
, struct fn_field
*f
,
2969 int j
, struct type
*type
,
2973 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
2974 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
2976 struct bound_minimal_symbol msym
;
2978 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0);
2981 memset (&msym
, 0, sizeof (msym
));
2985 gdb_assert (sym
== NULL
);
2986 msym
= lookup_bound_minimal_symbol (physname
);
2987 if (msym
.minsym
== NULL
)
2991 v
= allocate_value (ftype
);
2994 set_value_address (v
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)));
2998 /* The minimal symbol might point to a function descriptor;
2999 resolve it to the actual code address instead. */
3000 struct objfile
*objfile
= msym
.objfile
;
3001 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3003 set_value_address (v
,
3004 gdbarch_convert_from_func_ptr_addr
3005 (gdbarch
, BMSYMBOL_VALUE_ADDRESS (msym
), ¤t_target
));
3010 if (type
!= value_type (*arg1p
))
3011 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
3012 value_addr (*arg1p
)));
3014 /* Move the `this' pointer according to the offset.
3015 VALUE_OFFSET (*arg1p) += offset; */
3023 /* Helper function for both unpack_value_bits_as_long and
3024 unpack_bits_as_long. See those functions for more details on the
3025 interface; the only difference is that this function accepts either
3026 a NULL or a non-NULL ORIGINAL_VALUE. */
3029 unpack_value_bits_as_long_1 (struct type
*field_type
, const gdb_byte
*valaddr
,
3030 int embedded_offset
, int bitpos
, int bitsize
,
3031 const struct value
*original_value
,
3034 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (field_type
));
3041 /* Read the minimum number of bytes required; there may not be
3042 enough bytes to read an entire ULONGEST. */
3043 CHECK_TYPEDEF (field_type
);
3045 bytes_read
= ((bitpos
% 8) + bitsize
+ 7) / 8;
3047 bytes_read
= TYPE_LENGTH (field_type
);
3049 read_offset
= bitpos
/ 8;
3051 if (original_value
!= NULL
3052 && !value_bits_available (original_value
, embedded_offset
+ bitpos
,
3056 val
= extract_unsigned_integer (valaddr
+ embedded_offset
+ read_offset
,
3057 bytes_read
, byte_order
);
3059 /* Extract bits. See comment above. */
3061 if (gdbarch_bits_big_endian (get_type_arch (field_type
)))
3062 lsbcount
= (bytes_read
* 8 - bitpos
% 8 - bitsize
);
3064 lsbcount
= (bitpos
% 8);
3067 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
3068 If the field is signed, and is negative, then sign extend. */
3070 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
3072 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
3074 if (!TYPE_UNSIGNED (field_type
))
3076 if (val
& (valmask
^ (valmask
>> 1)))
3087 /* Unpack a bitfield of the specified FIELD_TYPE, from the object at
3088 VALADDR + EMBEDDED_OFFSET, and store the result in *RESULT.
3089 VALADDR points to the contents of ORIGINAL_VALUE, which must not be
3090 NULL. The bitfield starts at BITPOS bits and contains BITSIZE
3093 Returns false if the value contents are unavailable, otherwise
3094 returns true, indicating a valid value has been stored in *RESULT.
3096 Extracting bits depends on endianness of the machine. Compute the
3097 number of least significant bits to discard. For big endian machines,
3098 we compute the total number of bits in the anonymous object, subtract
3099 off the bit count from the MSB of the object to the MSB of the
3100 bitfield, then the size of the bitfield, which leaves the LSB discard
3101 count. For little endian machines, the discard count is simply the
3102 number of bits from the LSB of the anonymous object to the LSB of the
3105 If the field is signed, we also do sign extension. */
3108 unpack_value_bits_as_long (struct type
*field_type
, const gdb_byte
*valaddr
,
3109 int embedded_offset
, int bitpos
, int bitsize
,
3110 const struct value
*original_value
,
3113 gdb_assert (original_value
!= NULL
);
3115 return unpack_value_bits_as_long_1 (field_type
, valaddr
, embedded_offset
,
3116 bitpos
, bitsize
, original_value
, result
);
3120 /* Unpack a field FIELDNO of the specified TYPE, from the object at
3121 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
3122 ORIGINAL_VALUE. See unpack_value_bits_as_long for more
3126 unpack_value_field_as_long_1 (struct type
*type
, const gdb_byte
*valaddr
,
3127 int embedded_offset
, int fieldno
,
3128 const struct value
*val
, LONGEST
*result
)
3130 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
3131 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
3132 struct type
*field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
3134 return unpack_value_bits_as_long_1 (field_type
, valaddr
, embedded_offset
,
3135 bitpos
, bitsize
, val
,
3139 /* Unpack a field FIELDNO of the specified TYPE, from the object at
3140 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
3141 ORIGINAL_VALUE, which must not be NULL. See
3142 unpack_value_bits_as_long for more details. */
3145 unpack_value_field_as_long (struct type
*type
, const gdb_byte
*valaddr
,
3146 int embedded_offset
, int fieldno
,
3147 const struct value
*val
, LONGEST
*result
)
3149 gdb_assert (val
!= NULL
);
3151 return unpack_value_field_as_long_1 (type
, valaddr
, embedded_offset
,
3152 fieldno
, val
, result
);
3155 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous
3156 object at VALADDR. See unpack_value_bits_as_long for more details.
3157 This function differs from unpack_value_field_as_long in that it
3158 operates without a struct value object. */
3161 unpack_field_as_long (struct type
*type
, const gdb_byte
*valaddr
, int fieldno
)
3165 unpack_value_field_as_long_1 (type
, valaddr
, 0, fieldno
, NULL
, &result
);
3169 /* Return a new value with type TYPE, which is FIELDNO field of the
3170 object at VALADDR + EMBEDDEDOFFSET. VALADDR points to the contents
3171 of VAL. If the VAL's contents required to extract the bitfield
3172 from are unavailable, the new value is correspondingly marked as
3176 value_field_bitfield (struct type
*type
, int fieldno
,
3177 const gdb_byte
*valaddr
,
3178 int embedded_offset
, const struct value
*val
)
3182 if (!unpack_value_field_as_long (type
, valaddr
, embedded_offset
, fieldno
,
3185 struct type
*field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
3186 struct value
*retval
= allocate_value (field_type
);
3187 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (field_type
));
3192 return value_from_longest (TYPE_FIELD_TYPE (type
, fieldno
), l
);
3196 /* Modify the value of a bitfield. ADDR points to a block of memory in
3197 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
3198 is the desired value of the field, in host byte order. BITPOS and BITSIZE
3199 indicate which bits (in target bit order) comprise the bitfield.
3200 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS % 8 + BITSIZE <= lbits, and
3201 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
3204 modify_field (struct type
*type
, gdb_byte
*addr
,
3205 LONGEST fieldval
, int bitpos
, int bitsize
)
3207 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
3209 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
3212 /* Normalize BITPOS. */
3216 /* If a negative fieldval fits in the field in question, chop
3217 off the sign extension bits. */
3218 if ((~fieldval
& ~(mask
>> 1)) == 0)
3221 /* Warn if value is too big to fit in the field in question. */
3222 if (0 != (fieldval
& ~mask
))
3224 /* FIXME: would like to include fieldval in the message, but
3225 we don't have a sprintf_longest. */
3226 warning (_("Value does not fit in %d bits."), bitsize
);
3228 /* Truncate it, otherwise adjoining fields may be corrupted. */
3232 /* Ensure no bytes outside of the modified ones get accessed as it may cause
3233 false valgrind reports. */
3235 bytesize
= (bitpos
+ bitsize
+ 7) / 8;
3236 oword
= extract_unsigned_integer (addr
, bytesize
, byte_order
);
3238 /* Shifting for bit field depends on endianness of the target machine. */
3239 if (gdbarch_bits_big_endian (get_type_arch (type
)))
3240 bitpos
= bytesize
* 8 - bitpos
- bitsize
;
3242 oword
&= ~(mask
<< bitpos
);
3243 oword
|= fieldval
<< bitpos
;
3245 store_unsigned_integer (addr
, bytesize
, byte_order
, oword
);
3248 /* Pack NUM into BUF using a target format of TYPE. */
3251 pack_long (gdb_byte
*buf
, struct type
*type
, LONGEST num
)
3253 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
3256 type
= check_typedef (type
);
3257 len
= TYPE_LENGTH (type
);
3259 switch (TYPE_CODE (type
))
3262 case TYPE_CODE_CHAR
:
3263 case TYPE_CODE_ENUM
:
3264 case TYPE_CODE_FLAGS
:
3265 case TYPE_CODE_BOOL
:
3266 case TYPE_CODE_RANGE
:
3267 case TYPE_CODE_MEMBERPTR
:
3268 store_signed_integer (buf
, len
, byte_order
, num
);
3273 store_typed_address (buf
, type
, (CORE_ADDR
) num
);
3277 error (_("Unexpected type (%d) encountered for integer constant."),
3283 /* Pack NUM into BUF using a target format of TYPE. */
3286 pack_unsigned_long (gdb_byte
*buf
, struct type
*type
, ULONGEST num
)
3289 enum bfd_endian byte_order
;
3291 type
= check_typedef (type
);
3292 len
= TYPE_LENGTH (type
);
3293 byte_order
= gdbarch_byte_order (get_type_arch (type
));
3295 switch (TYPE_CODE (type
))
3298 case TYPE_CODE_CHAR
:
3299 case TYPE_CODE_ENUM
:
3300 case TYPE_CODE_FLAGS
:
3301 case TYPE_CODE_BOOL
:
3302 case TYPE_CODE_RANGE
:
3303 case TYPE_CODE_MEMBERPTR
:
3304 store_unsigned_integer (buf
, len
, byte_order
, num
);
3309 store_typed_address (buf
, type
, (CORE_ADDR
) num
);
3313 error (_("Unexpected type (%d) encountered "
3314 "for unsigned integer constant."),
3320 /* Convert C numbers into newly allocated values. */
3323 value_from_longest (struct type
*type
, LONGEST num
)
3325 struct value
*val
= allocate_value (type
);
3327 pack_long (value_contents_raw (val
), type
, num
);
3332 /* Convert C unsigned numbers into newly allocated values. */
3335 value_from_ulongest (struct type
*type
, ULONGEST num
)
3337 struct value
*val
= allocate_value (type
);
3339 pack_unsigned_long (value_contents_raw (val
), type
, num
);
3345 /* Create a value representing a pointer of type TYPE to the address
3346 ADDR. The type of the created value may differ from the passed
3347 type TYPE. Make sure to retrieve the returned values's new type
3348 after this call e.g. in case of an variable length array. */
3351 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
3353 struct type
*resolved_type
= resolve_dynamic_type (type
, addr
);
3354 struct value
*val
= allocate_value (resolved_type
);
3356 store_typed_address (value_contents_raw (val
),
3357 check_typedef (resolved_type
), addr
);
3362 /* Create a value of type TYPE whose contents come from VALADDR, if it
3363 is non-null, and whose memory address (in the inferior) is
3364 ADDRESS. The type of the created value may differ from the passed
3365 type TYPE. Make sure to retrieve values new type after this call.
3366 Note that TYPE is not passed through resolve_dynamic_type; this is
3367 a special API intended for use only by Ada. */
3370 value_from_contents_and_address_unresolved (struct type
*type
,
3371 const gdb_byte
*valaddr
,
3376 if (valaddr
== NULL
)
3377 v
= allocate_value_lazy (type
);
3379 v
= value_from_contents (type
, valaddr
);
3380 set_value_address (v
, address
);
3381 VALUE_LVAL (v
) = lval_memory
;
3385 /* Create a value of type TYPE whose contents come from VALADDR, if it
3386 is non-null, and whose memory address (in the inferior) is
3387 ADDRESS. The type of the created value may differ from the passed
3388 type TYPE. Make sure to retrieve values new type after this call. */
3391 value_from_contents_and_address (struct type
*type
,
3392 const gdb_byte
*valaddr
,
3395 struct type
*resolved_type
= resolve_dynamic_type (type
, address
);
3398 if (valaddr
== NULL
)
3399 v
= allocate_value_lazy (resolved_type
);
3401 v
= value_from_contents (resolved_type
, valaddr
);
3402 set_value_address (v
, address
);
3403 VALUE_LVAL (v
) = lval_memory
;
3407 /* Create a value of type TYPE holding the contents CONTENTS.
3408 The new value is `not_lval'. */
3411 value_from_contents (struct type
*type
, const gdb_byte
*contents
)
3413 struct value
*result
;
3415 result
= allocate_value (type
);
3416 memcpy (value_contents_raw (result
), contents
, TYPE_LENGTH (type
));
3421 value_from_double (struct type
*type
, DOUBLEST num
)
3423 struct value
*val
= allocate_value (type
);
3424 struct type
*base_type
= check_typedef (type
);
3425 enum type_code code
= TYPE_CODE (base_type
);
3427 if (code
== TYPE_CODE_FLT
)
3429 store_typed_floating (value_contents_raw (val
), base_type
, num
);
3432 error (_("Unexpected type encountered for floating constant."));
3438 value_from_decfloat (struct type
*type
, const gdb_byte
*dec
)
3440 struct value
*val
= allocate_value (type
);
3442 memcpy (value_contents_raw (val
), dec
, TYPE_LENGTH (type
));
3446 /* Extract a value from the history file. Input will be of the form
3447 $digits or $$digits. See block comment above 'write_dollar_variable'
3451 value_from_history_ref (const char *h
, const char **endp
)
3463 /* Find length of numeral string. */
3464 for (; isdigit (h
[len
]); len
++)
3467 /* Make sure numeral string is not part of an identifier. */
3468 if (h
[len
] == '_' || isalpha (h
[len
]))
3471 /* Now collect the index value. */
3476 /* For some bizarre reason, "$$" is equivalent to "$$1",
3477 rather than to "$$0" as it ought to be! */
3485 index
= -strtol (&h
[2], &local_end
, 10);
3493 /* "$" is equivalent to "$0". */
3501 index
= strtol (&h
[1], &local_end
, 10);
3506 return access_value_history (index
);
3510 coerce_ref_if_computed (const struct value
*arg
)
3512 const struct lval_funcs
*funcs
;
3514 if (TYPE_CODE (check_typedef (value_type (arg
))) != TYPE_CODE_REF
)
3517 if (value_lval_const (arg
) != lval_computed
)
3520 funcs
= value_computed_funcs (arg
);
3521 if (funcs
->coerce_ref
== NULL
)
3524 return funcs
->coerce_ref (arg
);
3527 /* Look at value.h for description. */
3530 readjust_indirect_value_type (struct value
*value
, struct type
*enc_type
,
3531 struct type
*original_type
,
3532 struct value
*original_value
)
3534 /* Re-adjust type. */
3535 deprecated_set_value_type (value
, TYPE_TARGET_TYPE (original_type
));
3537 /* Add embedding info. */
3538 set_value_enclosing_type (value
, enc_type
);
3539 set_value_embedded_offset (value
, value_pointed_to_offset (original_value
));
3541 /* We may be pointing to an object of some derived type. */
3542 return value_full_object (value
, NULL
, 0, 0, 0);
3546 coerce_ref (struct value
*arg
)
3548 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
3549 struct value
*retval
;
3550 struct type
*enc_type
;
3552 retval
= coerce_ref_if_computed (arg
);
3556 if (TYPE_CODE (value_type_arg_tmp
) != TYPE_CODE_REF
)
3559 enc_type
= check_typedef (value_enclosing_type (arg
));
3560 enc_type
= TYPE_TARGET_TYPE (enc_type
);
3562 retval
= value_at_lazy (enc_type
,
3563 unpack_pointer (value_type (arg
),
3564 value_contents (arg
)));
3565 enc_type
= value_type (retval
);
3566 return readjust_indirect_value_type (retval
, enc_type
,
3567 value_type_arg_tmp
, arg
);
3571 coerce_array (struct value
*arg
)
3575 arg
= coerce_ref (arg
);
3576 type
= check_typedef (value_type (arg
));
3578 switch (TYPE_CODE (type
))
3580 case TYPE_CODE_ARRAY
:
3581 if (!TYPE_VECTOR (type
) && current_language
->c_style_arrays
)
3582 arg
= value_coerce_array (arg
);
3584 case TYPE_CODE_FUNC
:
3585 arg
= value_coerce_function (arg
);
3592 /* Return the return value convention that will be used for the
3595 enum return_value_convention
3596 struct_return_convention (struct gdbarch
*gdbarch
,
3597 struct value
*function
, struct type
*value_type
)
3599 enum type_code code
= TYPE_CODE (value_type
);
3601 if (code
== TYPE_CODE_ERROR
)
3602 error (_("Function return type unknown."));
3604 /* Probe the architecture for the return-value convention. */
3605 return gdbarch_return_value (gdbarch
, function
, value_type
,
3609 /* Return true if the function returning the specified type is using
3610 the convention of returning structures in memory (passing in the
3611 address as a hidden first parameter). */
3614 using_struct_return (struct gdbarch
*gdbarch
,
3615 struct value
*function
, struct type
*value_type
)
3617 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
3618 /* A void return value is never in memory. See also corresponding
3619 code in "print_return_value". */
3622 return (struct_return_convention (gdbarch
, function
, value_type
)
3623 != RETURN_VALUE_REGISTER_CONVENTION
);
3626 /* Set the initialized field in a value struct. */
3629 set_value_initialized (struct value
*val
, int status
)
3631 val
->initialized
= status
;
3634 /* Return the initialized field in a value struct. */
3637 value_initialized (struct value
*val
)
3639 return val
->initialized
;
3642 /* Called only from the value_contents and value_contents_all()
3643 macros, if the current data for a variable needs to be loaded into
3644 value_contents(VAL). Fetches the data from the user's process, and
3645 clears the lazy flag to indicate that the data in the buffer is
3648 If the value is zero-length, we avoid calling read_memory, which
3649 would abort. We mark the value as fetched anyway -- all 0 bytes of
3652 This function returns a value because it is used in the
3653 value_contents macro as part of an expression, where a void would
3654 not work. The value is ignored. */
3657 value_fetch_lazy (struct value
*val
)
3659 gdb_assert (value_lazy (val
));
3660 allocate_value_contents (val
);
3661 if (value_bitsize (val
))
3663 /* To read a lazy bitfield, read the entire enclosing value. This
3664 prevents reading the same block of (possibly volatile) memory once
3665 per bitfield. It would be even better to read only the containing
3666 word, but we have no way to record that just specific bits of a
3667 value have been fetched. */
3668 struct type
*type
= check_typedef (value_type (val
));
3669 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
3670 struct value
*parent
= value_parent (val
);
3671 LONGEST offset
= value_offset (val
);
3674 if (value_lazy (parent
))
3675 value_fetch_lazy (parent
);
3677 if (!value_bits_valid (parent
,
3678 TARGET_CHAR_BIT
* offset
+ value_bitpos (val
),
3679 value_bitsize (val
)))
3680 set_value_optimized_out (val
, 1);
3681 else if (!unpack_value_bits_as_long (value_type (val
),
3682 value_contents_for_printing (parent
),
3685 value_bitsize (val
), parent
, &num
))
3686 mark_value_bytes_unavailable (val
,
3687 value_embedded_offset (val
),
3688 TYPE_LENGTH (type
));
3690 store_signed_integer (value_contents_raw (val
), TYPE_LENGTH (type
),
3693 else if (VALUE_LVAL (val
) == lval_memory
)
3695 CORE_ADDR addr
= value_address (val
);
3696 struct type
*type
= check_typedef (value_enclosing_type (val
));
3698 if (TYPE_LENGTH (type
))
3699 read_value_memory (val
, 0, value_stack (val
),
3700 addr
, value_contents_all_raw (val
),
3701 TYPE_LENGTH (type
));
3703 else if (VALUE_LVAL (val
) == lval_register
)
3705 struct frame_info
*frame
;
3707 struct type
*type
= check_typedef (value_type (val
));
3708 struct value
*new_val
= val
, *mark
= value_mark ();
3710 /* Offsets are not supported here; lazy register values must
3711 refer to the entire register. */
3712 gdb_assert (value_offset (val
) == 0);
3714 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
3716 struct frame_id frame_id
= VALUE_FRAME_ID (new_val
);
3718 frame
= frame_find_by_id (frame_id
);
3719 regnum
= VALUE_REGNUM (new_val
);
3721 gdb_assert (frame
!= NULL
);
3723 /* Convertible register routines are used for multi-register
3724 values and for interpretation in different types
3725 (e.g. float or int from a double register). Lazy
3726 register values should have the register's natural type,
3727 so they do not apply. */
3728 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
3731 new_val
= get_frame_register_value (frame
, regnum
);
3733 /* If we get another lazy lval_register value, it means the
3734 register is found by reading it from the next frame.
3735 get_frame_register_value should never return a value with
3736 the frame id pointing to FRAME. If it does, it means we
3737 either have two consecutive frames with the same frame id
3738 in the frame chain, or some code is trying to unwind
3739 behind get_prev_frame's back (e.g., a frame unwind
3740 sniffer trying to unwind), bypassing its validations. In
3741 any case, it should always be an internal error to end up
3742 in this situation. */
3743 if (VALUE_LVAL (new_val
) == lval_register
3744 && value_lazy (new_val
)
3745 && frame_id_eq (VALUE_FRAME_ID (new_val
), frame_id
))
3746 internal_error (__FILE__
, __LINE__
,
3747 _("infinite loop while fetching a register"));
3750 /* If it's still lazy (for instance, a saved register on the
3751 stack), fetch it. */
3752 if (value_lazy (new_val
))
3753 value_fetch_lazy (new_val
);
3755 /* If the register was not saved, mark it optimized out. */
3756 if (value_optimized_out (new_val
))
3757 set_value_optimized_out (val
, 1);
3760 set_value_lazy (val
, 0);
3761 value_contents_copy (val
, value_embedded_offset (val
),
3762 new_val
, value_embedded_offset (new_val
),
3763 TYPE_LENGTH (type
));
3768 struct gdbarch
*gdbarch
;
3769 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
3770 regnum
= VALUE_REGNUM (val
);
3771 gdbarch
= get_frame_arch (frame
);
3773 fprintf_unfiltered (gdb_stdlog
,
3774 "{ value_fetch_lazy "
3775 "(frame=%d,regnum=%d(%s),...) ",
3776 frame_relative_level (frame
), regnum
,
3777 user_reg_map_regnum_to_name (gdbarch
, regnum
));
3779 fprintf_unfiltered (gdb_stdlog
, "->");
3780 if (value_optimized_out (new_val
))
3782 fprintf_unfiltered (gdb_stdlog
, " ");
3783 val_print_optimized_out (new_val
, gdb_stdlog
);
3788 const gdb_byte
*buf
= value_contents (new_val
);
3790 if (VALUE_LVAL (new_val
) == lval_register
)
3791 fprintf_unfiltered (gdb_stdlog
, " register=%d",
3792 VALUE_REGNUM (new_val
));
3793 else if (VALUE_LVAL (new_val
) == lval_memory
)
3794 fprintf_unfiltered (gdb_stdlog
, " address=%s",
3796 value_address (new_val
)));
3798 fprintf_unfiltered (gdb_stdlog
, " computed");
3800 fprintf_unfiltered (gdb_stdlog
, " bytes=");
3801 fprintf_unfiltered (gdb_stdlog
, "[");
3802 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
3803 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3804 fprintf_unfiltered (gdb_stdlog
, "]");
3807 fprintf_unfiltered (gdb_stdlog
, " }\n");
3810 /* Dispose of the intermediate values. This prevents
3811 watchpoints from trying to watch the saved frame pointer. */
3812 value_free_to_mark (mark
);
3814 else if (VALUE_LVAL (val
) == lval_computed
3815 && value_computed_funcs (val
)->read
!= NULL
)
3816 value_computed_funcs (val
)->read (val
);
3817 /* Don't call value_optimized_out on val, doing so would result in a
3818 recursive call back to value_fetch_lazy, instead check the
3819 optimized_out flag directly. */
3820 else if (val
->optimized_out
)
3821 /* Keep it optimized out. */;
3823 internal_error (__FILE__
, __LINE__
, _("Unexpected lazy value type."));
3825 set_value_lazy (val
, 0);
3829 /* Implementation of the convenience function $_isvoid. */
3831 static struct value
*
3832 isvoid_internal_fn (struct gdbarch
*gdbarch
,
3833 const struct language_defn
*language
,
3834 void *cookie
, int argc
, struct value
**argv
)
3839 error (_("You must provide one argument for $_isvoid."));
3841 ret
= TYPE_CODE (value_type (argv
[0])) == TYPE_CODE_VOID
;
3843 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, ret
);
3847 _initialize_values (void)
3849 add_cmd ("convenience", no_class
, show_convenience
, _("\
3850 Debugger convenience (\"$foo\") variables and functions.\n\
3851 Convenience variables are created when you assign them values;\n\
3852 thus, \"set $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
3854 A few convenience variables are given values automatically:\n\
3855 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
3856 \"$__\" holds the contents of the last address examined with \"x\"."
3859 Convenience functions are defined via the Python API."
3862 add_alias_cmd ("conv", "convenience", no_class
, 1, &showlist
);
3864 add_cmd ("values", no_set_class
, show_values
, _("\
3865 Elements of value history around item number IDX (or last ten)."),
3868 add_com ("init-if-undefined", class_vars
, init_if_undefined_command
, _("\
3869 Initialize a convenience variable if necessary.\n\
3870 init-if-undefined VARIABLE = EXPRESSION\n\
3871 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
3872 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
3873 VARIABLE is already initialized."));
3875 add_prefix_cmd ("function", no_class
, function_command
, _("\
3876 Placeholder command for showing help on convenience functions."),
3877 &functionlist
, "function ", 0, &cmdlist
);
3879 add_internal_function ("_isvoid", _("\
3880 Check whether an expression is void.\n\
3881 Usage: $_isvoid (expression)\n\
3882 Return 1 if the expression is void, zero otherwise."),
3883 isvoid_internal_fn
, NULL
);