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"
33 #include "gdb_assert.h"
39 #include "cli/cli-decode.h"
40 #include "exceptions.h"
41 #include "extension.h"
43 #include "tracepoint.h"
45 #include "user-regs.h"
47 /* Prototypes for exported functions. */
49 void _initialize_values (void);
51 /* Definition of a user function. */
52 struct internal_function
54 /* The name of the function. It is a bit odd to have this in the
55 function itself -- the user might use a differently-named
56 convenience variable to hold the function. */
60 internal_function_fn handler
;
62 /* User data for the handler. */
66 /* Defines an [OFFSET, OFFSET + LENGTH) range. */
70 /* Lowest offset in the range. */
73 /* Length of the range. */
77 typedef struct range range_s
;
81 /* Returns true if the ranges defined by [offset1, offset1+len1) and
82 [offset2, offset2+len2) overlap. */
85 ranges_overlap (int offset1
, int len1
,
86 int offset2
, int len2
)
90 l
= max (offset1
, offset2
);
91 h
= min (offset1
+ len1
, offset2
+ len2
);
95 /* Returns true if the first argument is strictly less than the
96 second, useful for VEC_lower_bound. We keep ranges sorted by
97 offset and coalesce overlapping and contiguous ranges, so this just
98 compares the starting offset. */
101 range_lessthan (const range_s
*r1
, const range_s
*r2
)
103 return r1
->offset
< r2
->offset
;
106 /* Returns true if RANGES contains any range that overlaps [OFFSET,
110 ranges_contain (VEC(range_s
) *ranges
, int offset
, int length
)
115 what
.offset
= offset
;
116 what
.length
= length
;
118 /* We keep ranges sorted by offset and coalesce overlapping and
119 contiguous ranges, so to check if a range list contains a given
120 range, we can do a binary search for the position the given range
121 would be inserted if we only considered the starting OFFSET of
122 ranges. We call that position I. Since we also have LENGTH to
123 care for (this is a range afterall), we need to check if the
124 _previous_ range overlaps the I range. E.g.,
128 |---| |---| |------| ... |--|
133 In the case above, the binary search would return `I=1', meaning,
134 this OFFSET should be inserted at position 1, and the current
135 position 1 should be pushed further (and before 2). But, `0'
138 Then we need to check if the I range overlaps the I range itself.
143 |---| |---| |-------| ... |--|
149 i
= VEC_lower_bound (range_s
, ranges
, &what
, range_lessthan
);
153 struct range
*bef
= VEC_index (range_s
, ranges
, i
- 1);
155 if (ranges_overlap (bef
->offset
, bef
->length
, offset
, length
))
159 if (i
< VEC_length (range_s
, ranges
))
161 struct range
*r
= VEC_index (range_s
, ranges
, i
);
163 if (ranges_overlap (r
->offset
, r
->length
, offset
, length
))
170 static struct cmd_list_element
*functionlist
;
172 /* Note that the fields in this structure are arranged to save a bit
177 /* Type of value; either not an lval, or one of the various
178 different possible kinds of lval. */
181 /* Is it modifiable? Only relevant if lval != not_lval. */
182 unsigned int modifiable
: 1;
184 /* If zero, contents of this value are in the contents field. If
185 nonzero, contents are in inferior. If the lval field is lval_memory,
186 the contents are in inferior memory at location.address plus offset.
187 The lval field may also be lval_register.
189 WARNING: This field is used by the code which handles watchpoints
190 (see breakpoint.c) to decide whether a particular value can be
191 watched by hardware watchpoints. If the lazy flag is set for
192 some member of a value chain, it is assumed that this member of
193 the chain doesn't need to be watched as part of watching the
194 value itself. This is how GDB avoids watching the entire struct
195 or array when the user wants to watch a single struct member or
196 array element. If you ever change the way lazy flag is set and
197 reset, be sure to consider this use as well! */
198 unsigned int lazy
: 1;
200 /* If nonzero, this is the value of a variable that does not
201 actually exist in the program. If nonzero, and LVAL is
202 lval_register, this is a register ($pc, $sp, etc., never a
203 program variable) that has not been saved in the frame. All
204 optimized-out values are treated pretty much the same, except
205 registers have a different string representation and related
207 unsigned int optimized_out
: 1;
209 /* If value is a variable, is it initialized or not. */
210 unsigned int initialized
: 1;
212 /* If value is from the stack. If this is set, read_stack will be
213 used instead of read_memory to enable extra caching. */
214 unsigned int stack
: 1;
216 /* If the value has been released. */
217 unsigned int released
: 1;
219 /* Register number if the value is from a register. */
222 /* Location of value (if lval). */
225 /* If lval == lval_memory, this is the address in the inferior.
226 If lval == lval_register, this is the byte offset into the
227 registers structure. */
230 /* Pointer to internal variable. */
231 struct internalvar
*internalvar
;
233 /* Pointer to xmethod worker. */
234 struct xmethod_worker
*xm_worker
;
236 /* If lval == lval_computed, this is a set of function pointers
237 to use to access and describe the value, and a closure pointer
241 /* Functions to call. */
242 const struct lval_funcs
*funcs
;
244 /* Closure for those functions to use. */
249 /* Describes offset of a value within lval of a structure in bytes.
250 If lval == lval_memory, this is an offset to the address. If
251 lval == lval_register, this is a further offset from
252 location.address within the registers structure. Note also the
253 member embedded_offset below. */
256 /* Only used for bitfields; number of bits contained in them. */
259 /* Only used for bitfields; position of start of field. For
260 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
261 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
264 /* The number of references to this value. When a value is created,
265 the value chain holds a reference, so REFERENCE_COUNT is 1. If
266 release_value is called, this value is removed from the chain but
267 the caller of release_value now has a reference to this value.
268 The caller must arrange for a call to value_free later. */
271 /* Only used for bitfields; the containing value. This allows a
272 single read from the target when displaying multiple
274 struct value
*parent
;
276 /* Frame register value is relative to. This will be described in
277 the lval enum above as "lval_register". */
278 struct frame_id frame_id
;
280 /* Type of the value. */
283 /* If a value represents a C++ object, then the `type' field gives
284 the object's compile-time type. If the object actually belongs
285 to some class derived from `type', perhaps with other base
286 classes and additional members, then `type' is just a subobject
287 of the real thing, and the full object is probably larger than
288 `type' would suggest.
290 If `type' is a dynamic class (i.e. one with a vtable), then GDB
291 can actually determine the object's run-time type by looking at
292 the run-time type information in the vtable. When this
293 information is available, we may elect to read in the entire
294 object, for several reasons:
296 - When printing the value, the user would probably rather see the
297 full object, not just the limited portion apparent from the
300 - If `type' has virtual base classes, then even printing `type'
301 alone may require reaching outside the `type' portion of the
302 object to wherever the virtual base class has been stored.
304 When we store the entire object, `enclosing_type' is the run-time
305 type -- the complete object -- and `embedded_offset' is the
306 offset of `type' within that larger type, in bytes. The
307 value_contents() macro takes `embedded_offset' into account, so
308 most GDB code continues to see the `type' portion of the value,
309 just as the inferior would.
311 If `type' is a pointer to an object, then `enclosing_type' is a
312 pointer to the object's run-time type, and `pointed_to_offset' is
313 the offset in bytes from the full object to the pointed-to object
314 -- that is, the value `embedded_offset' would have if we followed
315 the pointer and fetched the complete object. (I don't really see
316 the point. Why not just determine the run-time type when you
317 indirect, and avoid the special case? The contents don't matter
318 until you indirect anyway.)
320 If we're not doing anything fancy, `enclosing_type' is equal to
321 `type', and `embedded_offset' is zero, so everything works
323 struct type
*enclosing_type
;
325 int pointed_to_offset
;
327 /* Values are stored in a chain, so that they can be deleted easily
328 over calls to the inferior. Values assigned to internal
329 variables, put into the value history or exposed to Python are
330 taken off this list. */
333 /* Actual contents of the value. Target byte-order. NULL or not
334 valid if lazy is nonzero. */
337 /* Unavailable ranges in CONTENTS. We mark unavailable ranges,
338 rather than available, since the common and default case is for a
339 value to be available. This is filled in at value read time. The
340 unavailable ranges are tracked in bits. */
341 VEC(range_s
) *unavailable
;
345 value_bits_available (const struct value
*value
, int offset
, int length
)
347 gdb_assert (!value
->lazy
);
349 return !ranges_contain (value
->unavailable
, offset
, length
);
353 value_bytes_available (const struct value
*value
, int offset
, int length
)
355 return value_bits_available (value
,
356 offset
* TARGET_CHAR_BIT
,
357 length
* TARGET_CHAR_BIT
);
361 value_entirely_available (struct value
*value
)
363 /* We can only tell whether the whole value is available when we try
366 value_fetch_lazy (value
);
368 if (VEC_empty (range_s
, value
->unavailable
))
374 value_entirely_unavailable (struct value
*value
)
376 /* We can only tell whether the whole value is available when we try
379 value_fetch_lazy (value
);
381 if (VEC_length (range_s
, value
->unavailable
) == 1)
383 struct range
*t
= VEC_index (range_s
, value
->unavailable
, 0);
386 && t
->length
== (TARGET_CHAR_BIT
387 * TYPE_LENGTH (value_enclosing_type (value
))))
395 mark_value_bits_unavailable (struct value
*value
, int offset
, int length
)
400 /* Insert the range sorted. If there's overlap or the new range
401 would be contiguous with an existing range, merge. */
403 newr
.offset
= offset
;
404 newr
.length
= length
;
406 /* Do a binary search for the position the given range would be
407 inserted if we only considered the starting OFFSET of ranges.
408 Call that position I. Since we also have LENGTH to care for
409 (this is a range afterall), we need to check if the _previous_
410 range overlaps the I range. E.g., calling R the new range:
412 #1 - overlaps with previous
416 |---| |---| |------| ... |--|
421 In the case #1 above, the binary search would return `I=1',
422 meaning, this OFFSET should be inserted at position 1, and the
423 current position 1 should be pushed further (and become 2). But,
424 note that `0' overlaps with R, so we want to merge them.
426 A similar consideration needs to be taken if the new range would
427 be contiguous with the previous range:
429 #2 - contiguous with previous
433 |--| |---| |------| ... |--|
438 If there's no overlap with the previous range, as in:
440 #3 - not overlapping and not contiguous
444 |--| |---| |------| ... |--|
451 #4 - R is the range with lowest offset
455 |--| |---| |------| ... |--|
460 ... we just push the new range to I.
462 All the 4 cases above need to consider that the new range may
463 also overlap several of the ranges that follow, or that R may be
464 contiguous with the following range, and merge. E.g.,
466 #5 - overlapping following ranges
469 |------------------------|
470 |--| |---| |------| ... |--|
479 |--| |---| |------| ... |--|
486 i
= VEC_lower_bound (range_s
, value
->unavailable
, &newr
, range_lessthan
);
489 struct range
*bef
= VEC_index (range_s
, value
->unavailable
, i
- 1);
491 if (ranges_overlap (bef
->offset
, bef
->length
, offset
, length
))
494 ULONGEST l
= min (bef
->offset
, offset
);
495 ULONGEST h
= max (bef
->offset
+ bef
->length
, offset
+ length
);
501 else if (offset
== bef
->offset
+ bef
->length
)
504 bef
->length
+= length
;
510 VEC_safe_insert (range_s
, value
->unavailable
, i
, &newr
);
516 VEC_safe_insert (range_s
, value
->unavailable
, i
, &newr
);
519 /* Check whether the ranges following the one we've just added or
520 touched can be folded in (#5 above). */
521 if (i
+ 1 < VEC_length (range_s
, value
->unavailable
))
528 /* Get the range we just touched. */
529 t
= VEC_index (range_s
, value
->unavailable
, i
);
533 for (; VEC_iterate (range_s
, value
->unavailable
, i
, r
); i
++)
534 if (r
->offset
<= t
->offset
+ t
->length
)
538 l
= min (t
->offset
, r
->offset
);
539 h
= max (t
->offset
+ t
->length
, r
->offset
+ r
->length
);
548 /* If we couldn't merge this one, we won't be able to
549 merge following ones either, since the ranges are
550 always sorted by OFFSET. */
555 VEC_block_remove (range_s
, value
->unavailable
, next
, removed
);
560 mark_value_bytes_unavailable (struct value
*value
, int offset
, int length
)
562 mark_value_bits_unavailable (value
,
563 offset
* TARGET_CHAR_BIT
,
564 length
* TARGET_CHAR_BIT
);
567 /* Find the first range in RANGES that overlaps the range defined by
568 OFFSET and LENGTH, starting at element POS in the RANGES vector,
569 Returns the index into RANGES where such overlapping range was
570 found, or -1 if none was found. */
573 find_first_range_overlap (VEC(range_s
) *ranges
, int pos
,
574 int offset
, int length
)
579 for (i
= pos
; VEC_iterate (range_s
, ranges
, i
, r
); i
++)
580 if (ranges_overlap (r
->offset
, r
->length
, offset
, length
))
586 /* Compare LENGTH_BITS of memory at PTR1 + OFFSET1_BITS with the memory at
587 PTR2 + OFFSET2_BITS. Return 0 if the memory is the same, otherwise
590 It must always be the case that:
591 OFFSET1_BITS % TARGET_CHAR_BIT == OFFSET2_BITS % TARGET_CHAR_BIT
593 It is assumed that memory can be accessed from:
594 PTR + (OFFSET_BITS / TARGET_CHAR_BIT)
596 PTR + ((OFFSET_BITS + LENGTH_BITS + TARGET_CHAR_BIT - 1)
597 / TARGET_CHAR_BIT) */
599 memcmp_with_bit_offsets (const gdb_byte
*ptr1
, size_t offset1_bits
,
600 const gdb_byte
*ptr2
, size_t offset2_bits
,
603 gdb_assert (offset1_bits
% TARGET_CHAR_BIT
604 == offset2_bits
% TARGET_CHAR_BIT
);
606 if (offset1_bits
% TARGET_CHAR_BIT
!= 0)
609 gdb_byte mask
, b1
, b2
;
611 /* The offset from the base pointers PTR1 and PTR2 is not a complete
612 number of bytes. A number of bits up to either the next exact
613 byte boundary, or LENGTH_BITS (which ever is sooner) will be
615 bits
= TARGET_CHAR_BIT
- offset1_bits
% TARGET_CHAR_BIT
;
616 gdb_assert (bits
< sizeof (mask
) * TARGET_CHAR_BIT
);
617 mask
= (1 << bits
) - 1;
619 if (length_bits
< bits
)
621 mask
&= ~(gdb_byte
) ((1 << (bits
- length_bits
)) - 1);
625 /* Now load the two bytes and mask off the bits we care about. */
626 b1
= *(ptr1
+ offset1_bits
/ TARGET_CHAR_BIT
) & mask
;
627 b2
= *(ptr2
+ offset2_bits
/ TARGET_CHAR_BIT
) & mask
;
632 /* Now update the length and offsets to take account of the bits
633 we've just compared. */
635 offset1_bits
+= bits
;
636 offset2_bits
+= bits
;
639 if (length_bits
% TARGET_CHAR_BIT
!= 0)
643 gdb_byte mask
, b1
, b2
;
645 /* The length is not an exact number of bytes. After the previous
646 IF.. block then the offsets are byte aligned, or the
647 length is zero (in which case this code is not reached). Compare
648 a number of bits at the end of the region, starting from an exact
650 bits
= length_bits
% TARGET_CHAR_BIT
;
651 o1
= offset1_bits
+ length_bits
- bits
;
652 o2
= offset2_bits
+ length_bits
- bits
;
654 gdb_assert (bits
< sizeof (mask
) * TARGET_CHAR_BIT
);
655 mask
= ((1 << bits
) - 1) << (TARGET_CHAR_BIT
- bits
);
657 gdb_assert (o1
% TARGET_CHAR_BIT
== 0);
658 gdb_assert (o2
% TARGET_CHAR_BIT
== 0);
660 b1
= *(ptr1
+ o1
/ TARGET_CHAR_BIT
) & mask
;
661 b2
= *(ptr2
+ o2
/ TARGET_CHAR_BIT
) & mask
;
671 /* We've now taken care of any stray "bits" at the start, or end of
672 the region to compare, the remainder can be covered with a simple
674 gdb_assert (offset1_bits
% TARGET_CHAR_BIT
== 0);
675 gdb_assert (offset2_bits
% TARGET_CHAR_BIT
== 0);
676 gdb_assert (length_bits
% TARGET_CHAR_BIT
== 0);
678 return memcmp (ptr1
+ offset1_bits
/ TARGET_CHAR_BIT
,
679 ptr2
+ offset2_bits
/ TARGET_CHAR_BIT
,
680 length_bits
/ TARGET_CHAR_BIT
);
683 /* Length is zero, regions match. */
687 /* Helper function for value_available_contents_eq. The only difference is
688 that this function is bit rather than byte based.
690 Compare LENGTH bits of VAL1's contents starting at OFFSET1 bits with
691 LENGTH bits of VAL2's contents starting at OFFSET2 bits. Return true
692 if the available bits match. */
695 value_available_contents_bits_eq (const struct value
*val1
, int offset1
,
696 const struct value
*val2
, int offset2
,
699 int idx1
= 0, idx2
= 0;
701 /* See function description in value.h. */
702 gdb_assert (!val1
->lazy
&& !val2
->lazy
);
710 idx1
= find_first_range_overlap (val1
->unavailable
, idx1
,
712 idx2
= find_first_range_overlap (val2
->unavailable
, idx2
,
715 /* The usual case is for both values to be completely available. */
716 if (idx1
== -1 && idx2
== -1)
717 return (memcmp_with_bit_offsets (val1
->contents
, offset1
,
718 val2
->contents
, offset2
,
720 /* The contents only match equal if the available set matches as
722 else if (idx1
== -1 || idx2
== -1)
725 gdb_assert (idx1
!= -1 && idx2
!= -1);
727 r1
= VEC_index (range_s
, val1
->unavailable
, idx1
);
728 r2
= VEC_index (range_s
, val2
->unavailable
, idx2
);
730 /* Get the unavailable windows intersected by the incoming
731 ranges. The first and last ranges that overlap the argument
732 range may be wider than said incoming arguments ranges. */
733 l1
= max (offset1
, r1
->offset
);
734 h1
= min (offset1
+ length
, r1
->offset
+ r1
->length
);
736 l2
= max (offset2
, r2
->offset
);
737 h2
= min (offset2
+ length
, r2
->offset
+ r2
->length
);
739 /* Make them relative to the respective start offsets, so we can
740 compare them for equality. */
747 /* Different availability, no match. */
748 if (l1
!= l2
|| h1
!= h2
)
751 /* Compare the _available_ contents. */
752 if (memcmp_with_bit_offsets (val1
->contents
, offset1
,
753 val2
->contents
, offset2
, l1
) != 0)
765 value_available_contents_eq (const struct value
*val1
, int offset1
,
766 const struct value
*val2
, int offset2
,
769 return value_available_contents_bits_eq (val1
, offset1
* TARGET_CHAR_BIT
,
770 val2
, offset2
* TARGET_CHAR_BIT
,
771 length
* TARGET_CHAR_BIT
);
774 /* Prototypes for local functions. */
776 static void show_values (char *, int);
778 static void show_convenience (char *, int);
781 /* The value-history records all the values printed
782 by print commands during this session. Each chunk
783 records 60 consecutive values. The first chunk on
784 the chain records the most recent values.
785 The total number of values is in value_history_count. */
787 #define VALUE_HISTORY_CHUNK 60
789 struct value_history_chunk
791 struct value_history_chunk
*next
;
792 struct value
*values
[VALUE_HISTORY_CHUNK
];
795 /* Chain of chunks now in use. */
797 static struct value_history_chunk
*value_history_chain
;
799 static int value_history_count
; /* Abs number of last entry stored. */
802 /* List of all value objects currently allocated
803 (except for those released by calls to release_value)
804 This is so they can be freed after each command. */
806 static struct value
*all_values
;
808 /* Allocate a lazy value for type TYPE. Its actual content is
809 "lazily" allocated too: the content field of the return value is
810 NULL; it will be allocated when it is fetched from the target. */
813 allocate_value_lazy (struct type
*type
)
817 /* Call check_typedef on our type to make sure that, if TYPE
818 is a TYPE_CODE_TYPEDEF, its length is set to the length
819 of the target type instead of zero. However, we do not
820 replace the typedef type by the target type, because we want
821 to keep the typedef in order to be able to set the VAL's type
822 description correctly. */
823 check_typedef (type
);
825 val
= (struct value
*) xzalloc (sizeof (struct value
));
826 val
->contents
= NULL
;
827 val
->next
= all_values
;
830 val
->enclosing_type
= type
;
831 VALUE_LVAL (val
) = not_lval
;
832 val
->location
.address
= 0;
833 VALUE_FRAME_ID (val
) = null_frame_id
;
837 VALUE_REGNUM (val
) = -1;
839 val
->optimized_out
= 0;
840 val
->embedded_offset
= 0;
841 val
->pointed_to_offset
= 0;
843 val
->initialized
= 1; /* Default to initialized. */
845 /* Values start out on the all_values chain. */
846 val
->reference_count
= 1;
851 /* Allocate the contents of VAL if it has not been allocated yet. */
854 allocate_value_contents (struct value
*val
)
857 val
->contents
= (gdb_byte
*) xzalloc (TYPE_LENGTH (val
->enclosing_type
));
860 /* Allocate a value and its contents for type TYPE. */
863 allocate_value (struct type
*type
)
865 struct value
*val
= allocate_value_lazy (type
);
867 allocate_value_contents (val
);
872 /* Allocate a value that has the correct length
873 for COUNT repetitions of type TYPE. */
876 allocate_repeat_value (struct type
*type
, int count
)
878 int low_bound
= current_language
->string_lower_bound
; /* ??? */
879 /* FIXME-type-allocation: need a way to free this type when we are
881 struct type
*array_type
882 = lookup_array_range_type (type
, low_bound
, count
+ low_bound
- 1);
884 return allocate_value (array_type
);
888 allocate_computed_value (struct type
*type
,
889 const struct lval_funcs
*funcs
,
892 struct value
*v
= allocate_value_lazy (type
);
894 VALUE_LVAL (v
) = lval_computed
;
895 v
->location
.computed
.funcs
= funcs
;
896 v
->location
.computed
.closure
= closure
;
901 /* Allocate NOT_LVAL value for type TYPE being OPTIMIZED_OUT. */
904 allocate_optimized_out_value (struct type
*type
)
906 struct value
*retval
= allocate_value_lazy (type
);
908 set_value_optimized_out (retval
, 1);
909 set_value_lazy (retval
, 0);
913 /* Accessor methods. */
916 value_next (struct value
*value
)
922 value_type (const struct value
*value
)
927 deprecated_set_value_type (struct value
*value
, struct type
*type
)
933 value_offset (const struct value
*value
)
935 return value
->offset
;
938 set_value_offset (struct value
*value
, int offset
)
940 value
->offset
= offset
;
944 value_bitpos (const struct value
*value
)
946 return value
->bitpos
;
949 set_value_bitpos (struct value
*value
, int bit
)
955 value_bitsize (const struct value
*value
)
957 return value
->bitsize
;
960 set_value_bitsize (struct value
*value
, int bit
)
962 value
->bitsize
= bit
;
966 value_parent (struct value
*value
)
968 return value
->parent
;
974 set_value_parent (struct value
*value
, struct value
*parent
)
976 struct value
*old
= value
->parent
;
978 value
->parent
= parent
;
980 value_incref (parent
);
985 value_contents_raw (struct value
*value
)
987 allocate_value_contents (value
);
988 return value
->contents
+ value
->embedded_offset
;
992 value_contents_all_raw (struct value
*value
)
994 allocate_value_contents (value
);
995 return value
->contents
;
999 value_enclosing_type (struct value
*value
)
1001 return value
->enclosing_type
;
1004 /* Look at value.h for description. */
1007 value_actual_type (struct value
*value
, int resolve_simple_types
,
1008 int *real_type_found
)
1010 struct value_print_options opts
;
1011 struct type
*result
;
1013 get_user_print_options (&opts
);
1015 if (real_type_found
)
1016 *real_type_found
= 0;
1017 result
= value_type (value
);
1018 if (opts
.objectprint
)
1020 /* If result's target type is TYPE_CODE_STRUCT, proceed to
1021 fetch its rtti type. */
1022 if ((TYPE_CODE (result
) == TYPE_CODE_PTR
1023 || TYPE_CODE (result
) == TYPE_CODE_REF
)
1024 && TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (result
)))
1025 == TYPE_CODE_STRUCT
)
1027 struct type
*real_type
;
1029 real_type
= value_rtti_indirect_type (value
, NULL
, NULL
, NULL
);
1032 if (real_type_found
)
1033 *real_type_found
= 1;
1037 else if (resolve_simple_types
)
1039 if (real_type_found
)
1040 *real_type_found
= 1;
1041 result
= value_enclosing_type (value
);
1049 error_value_optimized_out (void)
1051 error (_("value has been optimized out"));
1055 require_not_optimized_out (const struct value
*value
)
1057 if (value
->optimized_out
)
1059 if (value
->lval
== lval_register
)
1060 error (_("register has not been saved in frame"));
1062 error_value_optimized_out ();
1067 require_available (const struct value
*value
)
1069 if (!VEC_empty (range_s
, value
->unavailable
))
1070 throw_error (NOT_AVAILABLE_ERROR
, _("value is not available"));
1074 value_contents_for_printing (struct value
*value
)
1077 value_fetch_lazy (value
);
1078 return value
->contents
;
1082 value_contents_for_printing_const (const struct value
*value
)
1084 gdb_assert (!value
->lazy
);
1085 return value
->contents
;
1089 value_contents_all (struct value
*value
)
1091 const gdb_byte
*result
= value_contents_for_printing (value
);
1092 require_not_optimized_out (value
);
1093 require_available (value
);
1097 /* Copy LENGTH bytes of SRC value's (all) contents
1098 (value_contents_all) starting at SRC_OFFSET, into DST value's (all)
1099 contents, starting at DST_OFFSET. If unavailable contents are
1100 being copied from SRC, the corresponding DST contents are marked
1101 unavailable accordingly. Neither DST nor SRC may be lazy
1104 It is assumed the contents of DST in the [DST_OFFSET,
1105 DST_OFFSET+LENGTH) range are wholly available. */
1108 value_contents_copy_raw (struct value
*dst
, int dst_offset
,
1109 struct value
*src
, int src_offset
, int length
)
1113 int src_bit_offset
, dst_bit_offset
, bit_length
;
1115 /* A lazy DST would make that this copy operation useless, since as
1116 soon as DST's contents were un-lazied (by a later value_contents
1117 call, say), the contents would be overwritten. A lazy SRC would
1118 mean we'd be copying garbage. */
1119 gdb_assert (!dst
->lazy
&& !src
->lazy
);
1121 /* The overwritten DST range gets unavailability ORed in, not
1122 replaced. Make sure to remember to implement replacing if it
1123 turns out actually necessary. */
1124 gdb_assert (value_bytes_available (dst
, dst_offset
, length
));
1126 /* Copy the data. */
1127 memcpy (value_contents_all_raw (dst
) + dst_offset
,
1128 value_contents_all_raw (src
) + src_offset
,
1131 /* Copy the meta-data, adjusted. */
1132 src_bit_offset
= src_offset
* TARGET_CHAR_BIT
;
1133 dst_bit_offset
= dst_offset
* TARGET_CHAR_BIT
;
1134 bit_length
= length
* TARGET_CHAR_BIT
;
1135 for (i
= 0; VEC_iterate (range_s
, src
->unavailable
, i
, r
); i
++)
1139 l
= max (r
->offset
, src_bit_offset
);
1140 h
= min (r
->offset
+ r
->length
, src_bit_offset
+ bit_length
);
1143 mark_value_bits_unavailable (dst
,
1144 dst_bit_offset
+ (l
- src_bit_offset
),
1149 /* Copy LENGTH bytes of SRC value's (all) contents
1150 (value_contents_all) starting at SRC_OFFSET byte, into DST value's
1151 (all) contents, starting at DST_OFFSET. If unavailable contents
1152 are being copied from SRC, the corresponding DST contents are
1153 marked unavailable accordingly. DST must not be lazy. If SRC is
1154 lazy, it will be fetched now. If SRC is not valid (is optimized
1155 out), an error is thrown.
1157 It is assumed the contents of DST in the [DST_OFFSET,
1158 DST_OFFSET+LENGTH) range are wholly available. */
1161 value_contents_copy (struct value
*dst
, int dst_offset
,
1162 struct value
*src
, int src_offset
, int length
)
1164 require_not_optimized_out (src
);
1167 value_fetch_lazy (src
);
1169 value_contents_copy_raw (dst
, dst_offset
, src
, src_offset
, length
);
1173 value_lazy (struct value
*value
)
1179 set_value_lazy (struct value
*value
, int val
)
1185 value_stack (struct value
*value
)
1187 return value
->stack
;
1191 set_value_stack (struct value
*value
, int val
)
1197 value_contents (struct value
*value
)
1199 const gdb_byte
*result
= value_contents_writeable (value
);
1200 require_not_optimized_out (value
);
1201 require_available (value
);
1206 value_contents_writeable (struct value
*value
)
1209 value_fetch_lazy (value
);
1210 return value_contents_raw (value
);
1213 /* Return non-zero if VAL1 and VAL2 have the same contents. Note that
1214 this function is different from value_equal; in C the operator ==
1215 can return 0 even if the two values being compared are equal. */
1218 value_contents_equal (struct value
*val1
, struct value
*val2
)
1223 type1
= check_typedef (value_type (val1
));
1224 type2
= check_typedef (value_type (val2
));
1225 if (TYPE_LENGTH (type1
) != TYPE_LENGTH (type2
))
1228 return (memcmp (value_contents (val1
), value_contents (val2
),
1229 TYPE_LENGTH (type1
)) == 0);
1233 value_optimized_out (struct value
*value
)
1235 /* We can only know if a value is optimized out once we have tried to
1237 if (!value
->optimized_out
&& value
->lazy
)
1238 value_fetch_lazy (value
);
1240 return value
->optimized_out
;
1244 value_optimized_out_const (const struct value
*value
)
1246 return value
->optimized_out
;
1250 set_value_optimized_out (struct value
*value
, int val
)
1252 value
->optimized_out
= val
;
1256 value_entirely_optimized_out (const struct value
*value
)
1258 if (!value
->optimized_out
)
1260 if (value
->lval
!= lval_computed
1261 || !value
->location
.computed
.funcs
->check_any_valid
)
1263 return !value
->location
.computed
.funcs
->check_any_valid (value
);
1267 value_bits_valid (const struct value
*value
, int offset
, int length
)
1269 if (!value
->optimized_out
)
1271 if (value
->lval
!= lval_computed
1272 || !value
->location
.computed
.funcs
->check_validity
)
1274 return value
->location
.computed
.funcs
->check_validity (value
, offset
,
1279 value_bits_synthetic_pointer (const struct value
*value
,
1280 int offset
, int length
)
1282 if (value
->lval
!= lval_computed
1283 || !value
->location
.computed
.funcs
->check_synthetic_pointer
)
1285 return value
->location
.computed
.funcs
->check_synthetic_pointer (value
,
1291 value_embedded_offset (struct value
*value
)
1293 return value
->embedded_offset
;
1297 set_value_embedded_offset (struct value
*value
, int val
)
1299 value
->embedded_offset
= val
;
1303 value_pointed_to_offset (struct value
*value
)
1305 return value
->pointed_to_offset
;
1309 set_value_pointed_to_offset (struct value
*value
, int val
)
1311 value
->pointed_to_offset
= val
;
1314 const struct lval_funcs
*
1315 value_computed_funcs (const struct value
*v
)
1317 gdb_assert (value_lval_const (v
) == lval_computed
);
1319 return v
->location
.computed
.funcs
;
1323 value_computed_closure (const struct value
*v
)
1325 gdb_assert (v
->lval
== lval_computed
);
1327 return v
->location
.computed
.closure
;
1331 deprecated_value_lval_hack (struct value
*value
)
1333 return &value
->lval
;
1337 value_lval_const (const struct value
*value
)
1343 value_address (const struct value
*value
)
1345 if (value
->lval
== lval_internalvar
1346 || value
->lval
== lval_internalvar_component
1347 || value
->lval
== lval_xcallable
)
1349 if (value
->parent
!= NULL
)
1350 return value_address (value
->parent
) + value
->offset
;
1352 return value
->location
.address
+ value
->offset
;
1356 value_raw_address (struct value
*value
)
1358 if (value
->lval
== lval_internalvar
1359 || value
->lval
== lval_internalvar_component
1360 || value
->lval
== lval_xcallable
)
1362 return value
->location
.address
;
1366 set_value_address (struct value
*value
, CORE_ADDR addr
)
1368 gdb_assert (value
->lval
!= lval_internalvar
1369 && value
->lval
!= lval_internalvar_component
1370 && value
->lval
!= lval_xcallable
);
1371 value
->location
.address
= addr
;
1374 struct internalvar
**
1375 deprecated_value_internalvar_hack (struct value
*value
)
1377 return &value
->location
.internalvar
;
1381 deprecated_value_frame_id_hack (struct value
*value
)
1383 return &value
->frame_id
;
1387 deprecated_value_regnum_hack (struct value
*value
)
1389 return &value
->regnum
;
1393 deprecated_value_modifiable (struct value
*value
)
1395 return value
->modifiable
;
1398 /* Return a mark in the value chain. All values allocated after the
1399 mark is obtained (except for those released) are subject to being freed
1400 if a subsequent value_free_to_mark is passed the mark. */
1407 /* Take a reference to VAL. VAL will not be deallocated until all
1408 references are released. */
1411 value_incref (struct value
*val
)
1413 val
->reference_count
++;
1416 /* Release a reference to VAL, which was acquired with value_incref.
1417 This function is also called to deallocate values from the value
1421 value_free (struct value
*val
)
1425 gdb_assert (val
->reference_count
> 0);
1426 val
->reference_count
--;
1427 if (val
->reference_count
> 0)
1430 /* If there's an associated parent value, drop our reference to
1432 if (val
->parent
!= NULL
)
1433 value_free (val
->parent
);
1435 if (VALUE_LVAL (val
) == lval_computed
)
1437 const struct lval_funcs
*funcs
= val
->location
.computed
.funcs
;
1439 if (funcs
->free_closure
)
1440 funcs
->free_closure (val
);
1442 else if (VALUE_LVAL (val
) == lval_xcallable
)
1443 free_xmethod_worker (val
->location
.xm_worker
);
1445 xfree (val
->contents
);
1446 VEC_free (range_s
, val
->unavailable
);
1451 /* Free all values allocated since MARK was obtained by value_mark
1452 (except for those released). */
1454 value_free_to_mark (struct value
*mark
)
1459 for (val
= all_values
; val
&& val
!= mark
; val
= next
)
1468 /* Free all the values that have been allocated (except for those released).
1469 Call after each command, successful or not.
1470 In practice this is called before each command, which is sufficient. */
1473 free_all_values (void)
1478 for (val
= all_values
; val
; val
= next
)
1488 /* Frees all the elements in a chain of values. */
1491 free_value_chain (struct value
*v
)
1497 next
= value_next (v
);
1502 /* Remove VAL from the chain all_values
1503 so it will not be freed automatically. */
1506 release_value (struct value
*val
)
1510 if (all_values
== val
)
1512 all_values
= val
->next
;
1518 for (v
= all_values
; v
; v
= v
->next
)
1522 v
->next
= val
->next
;
1530 /* If the value is not already released, release it.
1531 If the value is already released, increment its reference count.
1532 That is, this function ensures that the value is released from the
1533 value chain and that the caller owns a reference to it. */
1536 release_value_or_incref (struct value
*val
)
1541 release_value (val
);
1544 /* Release all values up to mark */
1546 value_release_to_mark (struct value
*mark
)
1551 for (val
= next
= all_values
; next
; next
= next
->next
)
1553 if (next
->next
== mark
)
1555 all_values
= next
->next
;
1565 /* Return a copy of the value ARG.
1566 It contains the same contents, for same memory address,
1567 but it's a different block of storage. */
1570 value_copy (struct value
*arg
)
1572 struct type
*encl_type
= value_enclosing_type (arg
);
1575 if (value_lazy (arg
))
1576 val
= allocate_value_lazy (encl_type
);
1578 val
= allocate_value (encl_type
);
1579 val
->type
= arg
->type
;
1580 VALUE_LVAL (val
) = VALUE_LVAL (arg
);
1581 val
->location
= arg
->location
;
1582 val
->offset
= arg
->offset
;
1583 val
->bitpos
= arg
->bitpos
;
1584 val
->bitsize
= arg
->bitsize
;
1585 VALUE_FRAME_ID (val
) = VALUE_FRAME_ID (arg
);
1586 VALUE_REGNUM (val
) = VALUE_REGNUM (arg
);
1587 val
->lazy
= arg
->lazy
;
1588 val
->optimized_out
= arg
->optimized_out
;
1589 val
->embedded_offset
= value_embedded_offset (arg
);
1590 val
->pointed_to_offset
= arg
->pointed_to_offset
;
1591 val
->modifiable
= arg
->modifiable
;
1592 if (!value_lazy (val
))
1594 memcpy (value_contents_all_raw (val
), value_contents_all_raw (arg
),
1595 TYPE_LENGTH (value_enclosing_type (arg
)));
1598 val
->unavailable
= VEC_copy (range_s
, arg
->unavailable
);
1599 set_value_parent (val
, arg
->parent
);
1600 if (VALUE_LVAL (val
) == lval_computed
)
1602 const struct lval_funcs
*funcs
= val
->location
.computed
.funcs
;
1604 if (funcs
->copy_closure
)
1605 val
->location
.computed
.closure
= funcs
->copy_closure (val
);
1610 /* Return a version of ARG that is non-lvalue. */
1613 value_non_lval (struct value
*arg
)
1615 if (VALUE_LVAL (arg
) != not_lval
)
1617 struct type
*enc_type
= value_enclosing_type (arg
);
1618 struct value
*val
= allocate_value (enc_type
);
1620 memcpy (value_contents_all_raw (val
), value_contents_all (arg
),
1621 TYPE_LENGTH (enc_type
));
1622 val
->type
= arg
->type
;
1623 set_value_embedded_offset (val
, value_embedded_offset (arg
));
1624 set_value_pointed_to_offset (val
, value_pointed_to_offset (arg
));
1631 set_value_component_location (struct value
*component
,
1632 const struct value
*whole
)
1634 gdb_assert (whole
->lval
!= lval_xcallable
);
1636 if (whole
->lval
== lval_internalvar
)
1637 VALUE_LVAL (component
) = lval_internalvar_component
;
1639 VALUE_LVAL (component
) = whole
->lval
;
1641 component
->location
= whole
->location
;
1642 if (whole
->lval
== lval_computed
)
1644 const struct lval_funcs
*funcs
= whole
->location
.computed
.funcs
;
1646 if (funcs
->copy_closure
)
1647 component
->location
.computed
.closure
= funcs
->copy_closure (whole
);
1652 /* Access to the value history. */
1654 /* Record a new value in the value history.
1655 Returns the absolute history index of the entry. */
1658 record_latest_value (struct value
*val
)
1662 /* We don't want this value to have anything to do with the inferior anymore.
1663 In particular, "set $1 = 50" should not affect the variable from which
1664 the value was taken, and fast watchpoints should be able to assume that
1665 a value on the value history never changes. */
1666 if (value_lazy (val
))
1667 value_fetch_lazy (val
);
1668 /* We preserve VALUE_LVAL so that the user can find out where it was fetched
1669 from. This is a bit dubious, because then *&$1 does not just return $1
1670 but the current contents of that location. c'est la vie... */
1671 val
->modifiable
= 0;
1673 /* The value may have already been released, in which case we're adding a
1674 new reference for its entry in the history. That is why we call
1675 release_value_or_incref here instead of release_value. */
1676 release_value_or_incref (val
);
1678 /* Here we treat value_history_count as origin-zero
1679 and applying to the value being stored now. */
1681 i
= value_history_count
% VALUE_HISTORY_CHUNK
;
1684 struct value_history_chunk
*new
1685 = (struct value_history_chunk
*)
1687 xmalloc (sizeof (struct value_history_chunk
));
1688 memset (new->values
, 0, sizeof new->values
);
1689 new->next
= value_history_chain
;
1690 value_history_chain
= new;
1693 value_history_chain
->values
[i
] = val
;
1695 /* Now we regard value_history_count as origin-one
1696 and applying to the value just stored. */
1698 return ++value_history_count
;
1701 /* Return a copy of the value in the history with sequence number NUM. */
1704 access_value_history (int num
)
1706 struct value_history_chunk
*chunk
;
1711 absnum
+= value_history_count
;
1716 error (_("The history is empty."));
1718 error (_("There is only one value in the history."));
1720 error (_("History does not go back to $$%d."), -num
);
1722 if (absnum
> value_history_count
)
1723 error (_("History has not yet reached $%d."), absnum
);
1727 /* Now absnum is always absolute and origin zero. */
1729 chunk
= value_history_chain
;
1730 for (i
= (value_history_count
- 1) / VALUE_HISTORY_CHUNK
1731 - absnum
/ VALUE_HISTORY_CHUNK
;
1733 chunk
= chunk
->next
;
1735 return value_copy (chunk
->values
[absnum
% VALUE_HISTORY_CHUNK
]);
1739 show_values (char *num_exp
, int from_tty
)
1747 /* "show values +" should print from the stored position.
1748 "show values <exp>" should print around value number <exp>. */
1749 if (num_exp
[0] != '+' || num_exp
[1] != '\0')
1750 num
= parse_and_eval_long (num_exp
) - 5;
1754 /* "show values" means print the last 10 values. */
1755 num
= value_history_count
- 9;
1761 for (i
= num
; i
< num
+ 10 && i
<= value_history_count
; i
++)
1763 struct value_print_options opts
;
1765 val
= access_value_history (i
);
1766 printf_filtered (("$%d = "), i
);
1767 get_user_print_options (&opts
);
1768 value_print (val
, gdb_stdout
, &opts
);
1769 printf_filtered (("\n"));
1772 /* The next "show values +" should start after what we just printed. */
1775 /* Hitting just return after this command should do the same thing as
1776 "show values +". If num_exp is null, this is unnecessary, since
1777 "show values +" is not useful after "show values". */
1778 if (from_tty
&& num_exp
)
1785 /* Internal variables. These are variables within the debugger
1786 that hold values assigned by debugger commands.
1787 The user refers to them with a '$' prefix
1788 that does not appear in the variable names stored internally. */
1792 struct internalvar
*next
;
1795 /* We support various different kinds of content of an internal variable.
1796 enum internalvar_kind specifies the kind, and union internalvar_data
1797 provides the data associated with this particular kind. */
1799 enum internalvar_kind
1801 /* The internal variable is empty. */
1804 /* The value of the internal variable is provided directly as
1805 a GDB value object. */
1808 /* A fresh value is computed via a call-back routine on every
1809 access to the internal variable. */
1810 INTERNALVAR_MAKE_VALUE
,
1812 /* The internal variable holds a GDB internal convenience function. */
1813 INTERNALVAR_FUNCTION
,
1815 /* The variable holds an integer value. */
1816 INTERNALVAR_INTEGER
,
1818 /* The variable holds a GDB-provided string. */
1823 union internalvar_data
1825 /* A value object used with INTERNALVAR_VALUE. */
1826 struct value
*value
;
1828 /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */
1831 /* The functions to call. */
1832 const struct internalvar_funcs
*functions
;
1834 /* The function's user-data. */
1838 /* The internal function used with INTERNALVAR_FUNCTION. */
1841 struct internal_function
*function
;
1842 /* True if this is the canonical name for the function. */
1846 /* An integer value used with INTERNALVAR_INTEGER. */
1849 /* If type is non-NULL, it will be used as the type to generate
1850 a value for this internal variable. If type is NULL, a default
1851 integer type for the architecture is used. */
1856 /* A string value used with INTERNALVAR_STRING. */
1861 static struct internalvar
*internalvars
;
1863 /* If the variable does not already exist create it and give it the
1864 value given. If no value is given then the default is zero. */
1866 init_if_undefined_command (char* args
, int from_tty
)
1868 struct internalvar
* intvar
;
1870 /* Parse the expression - this is taken from set_command(). */
1871 struct expression
*expr
= parse_expression (args
);
1872 register struct cleanup
*old_chain
=
1873 make_cleanup (free_current_contents
, &expr
);
1875 /* Validate the expression.
1876 Was the expression an assignment?
1877 Or even an expression at all? */
1878 if (expr
->nelts
== 0 || expr
->elts
[0].opcode
!= BINOP_ASSIGN
)
1879 error (_("Init-if-undefined requires an assignment expression."));
1881 /* Extract the variable from the parsed expression.
1882 In the case of an assign the lvalue will be in elts[1] and elts[2]. */
1883 if (expr
->elts
[1].opcode
!= OP_INTERNALVAR
)
1884 error (_("The first parameter to init-if-undefined "
1885 "should be a GDB variable."));
1886 intvar
= expr
->elts
[2].internalvar
;
1888 /* Only evaluate the expression if the lvalue is void.
1889 This may still fail if the expresssion is invalid. */
1890 if (intvar
->kind
== INTERNALVAR_VOID
)
1891 evaluate_expression (expr
);
1893 do_cleanups (old_chain
);
1897 /* Look up an internal variable with name NAME. NAME should not
1898 normally include a dollar sign.
1900 If the specified internal variable does not exist,
1901 the return value is NULL. */
1903 struct internalvar
*
1904 lookup_only_internalvar (const char *name
)
1906 struct internalvar
*var
;
1908 for (var
= internalvars
; var
; var
= var
->next
)
1909 if (strcmp (var
->name
, name
) == 0)
1915 /* Complete NAME by comparing it to the names of internal variables.
1916 Returns a vector of newly allocated strings, or NULL if no matches
1920 complete_internalvar (const char *name
)
1922 VEC (char_ptr
) *result
= NULL
;
1923 struct internalvar
*var
;
1926 len
= strlen (name
);
1928 for (var
= internalvars
; var
; var
= var
->next
)
1929 if (strncmp (var
->name
, name
, len
) == 0)
1931 char *r
= xstrdup (var
->name
);
1933 VEC_safe_push (char_ptr
, result
, r
);
1939 /* Create an internal variable with name NAME and with a void value.
1940 NAME should not normally include a dollar sign. */
1942 struct internalvar
*
1943 create_internalvar (const char *name
)
1945 struct internalvar
*var
;
1947 var
= (struct internalvar
*) xmalloc (sizeof (struct internalvar
));
1948 var
->name
= concat (name
, (char *)NULL
);
1949 var
->kind
= INTERNALVAR_VOID
;
1950 var
->next
= internalvars
;
1955 /* Create an internal variable with name NAME and register FUN as the
1956 function that value_of_internalvar uses to create a value whenever
1957 this variable is referenced. NAME should not normally include a
1958 dollar sign. DATA is passed uninterpreted to FUN when it is
1959 called. CLEANUP, if not NULL, is called when the internal variable
1960 is destroyed. It is passed DATA as its only argument. */
1962 struct internalvar
*
1963 create_internalvar_type_lazy (const char *name
,
1964 const struct internalvar_funcs
*funcs
,
1967 struct internalvar
*var
= create_internalvar (name
);
1969 var
->kind
= INTERNALVAR_MAKE_VALUE
;
1970 var
->u
.make_value
.functions
= funcs
;
1971 var
->u
.make_value
.data
= data
;
1975 /* See documentation in value.h. */
1978 compile_internalvar_to_ax (struct internalvar
*var
,
1979 struct agent_expr
*expr
,
1980 struct axs_value
*value
)
1982 if (var
->kind
!= INTERNALVAR_MAKE_VALUE
1983 || var
->u
.make_value
.functions
->compile_to_ax
== NULL
)
1986 var
->u
.make_value
.functions
->compile_to_ax (var
, expr
, value
,
1987 var
->u
.make_value
.data
);
1991 /* Look up an internal variable with name NAME. NAME should not
1992 normally include a dollar sign.
1994 If the specified internal variable does not exist,
1995 one is created, with a void value. */
1997 struct internalvar
*
1998 lookup_internalvar (const char *name
)
2000 struct internalvar
*var
;
2002 var
= lookup_only_internalvar (name
);
2006 return create_internalvar (name
);
2009 /* Return current value of internal variable VAR. For variables that
2010 are not inherently typed, use a value type appropriate for GDBARCH. */
2013 value_of_internalvar (struct gdbarch
*gdbarch
, struct internalvar
*var
)
2016 struct trace_state_variable
*tsv
;
2018 /* If there is a trace state variable of the same name, assume that
2019 is what we really want to see. */
2020 tsv
= find_trace_state_variable (var
->name
);
2023 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2025 if (tsv
->value_known
)
2026 val
= value_from_longest (builtin_type (gdbarch
)->builtin_int64
,
2029 val
= allocate_value (builtin_type (gdbarch
)->builtin_void
);
2035 case INTERNALVAR_VOID
:
2036 val
= allocate_value (builtin_type (gdbarch
)->builtin_void
);
2039 case INTERNALVAR_FUNCTION
:
2040 val
= allocate_value (builtin_type (gdbarch
)->internal_fn
);
2043 case INTERNALVAR_INTEGER
:
2044 if (!var
->u
.integer
.type
)
2045 val
= value_from_longest (builtin_type (gdbarch
)->builtin_int
,
2046 var
->u
.integer
.val
);
2048 val
= value_from_longest (var
->u
.integer
.type
, var
->u
.integer
.val
);
2051 case INTERNALVAR_STRING
:
2052 val
= value_cstring (var
->u
.string
, strlen (var
->u
.string
),
2053 builtin_type (gdbarch
)->builtin_char
);
2056 case INTERNALVAR_VALUE
:
2057 val
= value_copy (var
->u
.value
);
2058 if (value_lazy (val
))
2059 value_fetch_lazy (val
);
2062 case INTERNALVAR_MAKE_VALUE
:
2063 val
= (*var
->u
.make_value
.functions
->make_value
) (gdbarch
, var
,
2064 var
->u
.make_value
.data
);
2068 internal_error (__FILE__
, __LINE__
, _("bad kind"));
2071 /* Change the VALUE_LVAL to lval_internalvar so that future operations
2072 on this value go back to affect the original internal variable.
2074 Do not do this for INTERNALVAR_MAKE_VALUE variables, as those have
2075 no underlying modifyable state in the internal variable.
2077 Likewise, if the variable's value is a computed lvalue, we want
2078 references to it to produce another computed lvalue, where
2079 references and assignments actually operate through the
2080 computed value's functions.
2082 This means that internal variables with computed values
2083 behave a little differently from other internal variables:
2084 assignments to them don't just replace the previous value
2085 altogether. At the moment, this seems like the behavior we
2088 if (var
->kind
!= INTERNALVAR_MAKE_VALUE
2089 && val
->lval
!= lval_computed
)
2091 VALUE_LVAL (val
) = lval_internalvar
;
2092 VALUE_INTERNALVAR (val
) = var
;
2099 get_internalvar_integer (struct internalvar
*var
, LONGEST
*result
)
2101 if (var
->kind
== INTERNALVAR_INTEGER
)
2103 *result
= var
->u
.integer
.val
;
2107 if (var
->kind
== INTERNALVAR_VALUE
)
2109 struct type
*type
= check_typedef (value_type (var
->u
.value
));
2111 if (TYPE_CODE (type
) == TYPE_CODE_INT
)
2113 *result
= value_as_long (var
->u
.value
);
2122 get_internalvar_function (struct internalvar
*var
,
2123 struct internal_function
**result
)
2127 case INTERNALVAR_FUNCTION
:
2128 *result
= var
->u
.fn
.function
;
2137 set_internalvar_component (struct internalvar
*var
, int offset
, int bitpos
,
2138 int bitsize
, struct value
*newval
)
2144 case INTERNALVAR_VALUE
:
2145 addr
= value_contents_writeable (var
->u
.value
);
2148 modify_field (value_type (var
->u
.value
), addr
+ offset
,
2149 value_as_long (newval
), bitpos
, bitsize
);
2151 memcpy (addr
+ offset
, value_contents (newval
),
2152 TYPE_LENGTH (value_type (newval
)));
2156 /* We can never get a component of any other kind. */
2157 internal_error (__FILE__
, __LINE__
, _("set_internalvar_component"));
2162 set_internalvar (struct internalvar
*var
, struct value
*val
)
2164 enum internalvar_kind new_kind
;
2165 union internalvar_data new_data
= { 0 };
2167 if (var
->kind
== INTERNALVAR_FUNCTION
&& var
->u
.fn
.canonical
)
2168 error (_("Cannot overwrite convenience function %s"), var
->name
);
2170 /* Prepare new contents. */
2171 switch (TYPE_CODE (check_typedef (value_type (val
))))
2173 case TYPE_CODE_VOID
:
2174 new_kind
= INTERNALVAR_VOID
;
2177 case TYPE_CODE_INTERNAL_FUNCTION
:
2178 gdb_assert (VALUE_LVAL (val
) == lval_internalvar
);
2179 new_kind
= INTERNALVAR_FUNCTION
;
2180 get_internalvar_function (VALUE_INTERNALVAR (val
),
2181 &new_data
.fn
.function
);
2182 /* Copies created here are never canonical. */
2186 new_kind
= INTERNALVAR_VALUE
;
2187 new_data
.value
= value_copy (val
);
2188 new_data
.value
->modifiable
= 1;
2190 /* Force the value to be fetched from the target now, to avoid problems
2191 later when this internalvar is referenced and the target is gone or
2193 if (value_lazy (new_data
.value
))
2194 value_fetch_lazy (new_data
.value
);
2196 /* Release the value from the value chain to prevent it from being
2197 deleted by free_all_values. From here on this function should not
2198 call error () until new_data is installed into the var->u to avoid
2200 release_value (new_data
.value
);
2204 /* Clean up old contents. */
2205 clear_internalvar (var
);
2208 var
->kind
= new_kind
;
2210 /* End code which must not call error(). */
2214 set_internalvar_integer (struct internalvar
*var
, LONGEST l
)
2216 /* Clean up old contents. */
2217 clear_internalvar (var
);
2219 var
->kind
= INTERNALVAR_INTEGER
;
2220 var
->u
.integer
.type
= NULL
;
2221 var
->u
.integer
.val
= l
;
2225 set_internalvar_string (struct internalvar
*var
, const char *string
)
2227 /* Clean up old contents. */
2228 clear_internalvar (var
);
2230 var
->kind
= INTERNALVAR_STRING
;
2231 var
->u
.string
= xstrdup (string
);
2235 set_internalvar_function (struct internalvar
*var
, struct internal_function
*f
)
2237 /* Clean up old contents. */
2238 clear_internalvar (var
);
2240 var
->kind
= INTERNALVAR_FUNCTION
;
2241 var
->u
.fn
.function
= f
;
2242 var
->u
.fn
.canonical
= 1;
2243 /* Variables installed here are always the canonical version. */
2247 clear_internalvar (struct internalvar
*var
)
2249 /* Clean up old contents. */
2252 case INTERNALVAR_VALUE
:
2253 value_free (var
->u
.value
);
2256 case INTERNALVAR_STRING
:
2257 xfree (var
->u
.string
);
2260 case INTERNALVAR_MAKE_VALUE
:
2261 if (var
->u
.make_value
.functions
->destroy
!= NULL
)
2262 var
->u
.make_value
.functions
->destroy (var
->u
.make_value
.data
);
2269 /* Reset to void kind. */
2270 var
->kind
= INTERNALVAR_VOID
;
2274 internalvar_name (struct internalvar
*var
)
2279 static struct internal_function
*
2280 create_internal_function (const char *name
,
2281 internal_function_fn handler
, void *cookie
)
2283 struct internal_function
*ifn
= XNEW (struct internal_function
);
2285 ifn
->name
= xstrdup (name
);
2286 ifn
->handler
= handler
;
2287 ifn
->cookie
= cookie
;
2292 value_internal_function_name (struct value
*val
)
2294 struct internal_function
*ifn
;
2297 gdb_assert (VALUE_LVAL (val
) == lval_internalvar
);
2298 result
= get_internalvar_function (VALUE_INTERNALVAR (val
), &ifn
);
2299 gdb_assert (result
);
2305 call_internal_function (struct gdbarch
*gdbarch
,
2306 const struct language_defn
*language
,
2307 struct value
*func
, int argc
, struct value
**argv
)
2309 struct internal_function
*ifn
;
2312 gdb_assert (VALUE_LVAL (func
) == lval_internalvar
);
2313 result
= get_internalvar_function (VALUE_INTERNALVAR (func
), &ifn
);
2314 gdb_assert (result
);
2316 return (*ifn
->handler
) (gdbarch
, language
, ifn
->cookie
, argc
, argv
);
2319 /* The 'function' command. This does nothing -- it is just a
2320 placeholder to let "help function NAME" work. This is also used as
2321 the implementation of the sub-command that is created when
2322 registering an internal function. */
2324 function_command (char *command
, int from_tty
)
2329 /* Clean up if an internal function's command is destroyed. */
2331 function_destroyer (struct cmd_list_element
*self
, void *ignore
)
2333 xfree ((char *) self
->name
);
2337 /* Add a new internal function. NAME is the name of the function; DOC
2338 is a documentation string describing the function. HANDLER is
2339 called when the function is invoked. COOKIE is an arbitrary
2340 pointer which is passed to HANDLER and is intended for "user
2343 add_internal_function (const char *name
, const char *doc
,
2344 internal_function_fn handler
, void *cookie
)
2346 struct cmd_list_element
*cmd
;
2347 struct internal_function
*ifn
;
2348 struct internalvar
*var
= lookup_internalvar (name
);
2350 ifn
= create_internal_function (name
, handler
, cookie
);
2351 set_internalvar_function (var
, ifn
);
2353 cmd
= add_cmd (xstrdup (name
), no_class
, function_command
, (char *) doc
,
2355 cmd
->destroyer
= function_destroyer
;
2358 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to
2359 prevent cycles / duplicates. */
2362 preserve_one_value (struct value
*value
, struct objfile
*objfile
,
2363 htab_t copied_types
)
2365 if (TYPE_OBJFILE (value
->type
) == objfile
)
2366 value
->type
= copy_type_recursive (objfile
, value
->type
, copied_types
);
2368 if (TYPE_OBJFILE (value
->enclosing_type
) == objfile
)
2369 value
->enclosing_type
= copy_type_recursive (objfile
,
2370 value
->enclosing_type
,
2374 /* Likewise for internal variable VAR. */
2377 preserve_one_internalvar (struct internalvar
*var
, struct objfile
*objfile
,
2378 htab_t copied_types
)
2382 case INTERNALVAR_INTEGER
:
2383 if (var
->u
.integer
.type
&& TYPE_OBJFILE (var
->u
.integer
.type
) == objfile
)
2385 = copy_type_recursive (objfile
, var
->u
.integer
.type
, copied_types
);
2388 case INTERNALVAR_VALUE
:
2389 preserve_one_value (var
->u
.value
, objfile
, copied_types
);
2394 /* Update the internal variables and value history when OBJFILE is
2395 discarded; we must copy the types out of the objfile. New global types
2396 will be created for every convenience variable which currently points to
2397 this objfile's types, and the convenience variables will be adjusted to
2398 use the new global types. */
2401 preserve_values (struct objfile
*objfile
)
2403 htab_t copied_types
;
2404 struct value_history_chunk
*cur
;
2405 struct internalvar
*var
;
2408 /* Create the hash table. We allocate on the objfile's obstack, since
2409 it is soon to be deleted. */
2410 copied_types
= create_copied_types_hash (objfile
);
2412 for (cur
= value_history_chain
; cur
; cur
= cur
->next
)
2413 for (i
= 0; i
< VALUE_HISTORY_CHUNK
; i
++)
2415 preserve_one_value (cur
->values
[i
], objfile
, copied_types
);
2417 for (var
= internalvars
; var
; var
= var
->next
)
2418 preserve_one_internalvar (var
, objfile
, copied_types
);
2420 preserve_ext_lang_values (objfile
, copied_types
);
2422 htab_delete (copied_types
);
2426 show_convenience (char *ignore
, int from_tty
)
2428 struct gdbarch
*gdbarch
= get_current_arch ();
2429 struct internalvar
*var
;
2431 struct value_print_options opts
;
2433 get_user_print_options (&opts
);
2434 for (var
= internalvars
; var
; var
= var
->next
)
2436 volatile struct gdb_exception ex
;
2442 printf_filtered (("$%s = "), var
->name
);
2444 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2448 val
= value_of_internalvar (gdbarch
, var
);
2449 value_print (val
, gdb_stdout
, &opts
);
2452 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
2453 printf_filtered (("\n"));
2457 /* This text does not mention convenience functions on purpose.
2458 The user can't create them except via Python, and if Python support
2459 is installed this message will never be printed ($_streq will
2461 printf_unfiltered (_("No debugger convenience variables now defined.\n"
2462 "Convenience variables have "
2463 "names starting with \"$\";\n"
2464 "use \"set\" as in \"set "
2465 "$foo = 5\" to define them.\n"));
2469 /* Return the TYPE_CODE_XMETHOD value corresponding to WORKER. */
2472 value_of_xmethod (struct xmethod_worker
*worker
)
2474 if (worker
->value
== NULL
)
2478 v
= allocate_value (builtin_type (target_gdbarch ())->xmethod
);
2479 v
->lval
= lval_xcallable
;
2480 v
->location
.xm_worker
= worker
;
2485 return worker
->value
;
2488 /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value METHOD. */
2491 call_xmethod (struct value
*method
, int argc
, struct value
**argv
)
2493 gdb_assert (TYPE_CODE (value_type (method
)) == TYPE_CODE_XMETHOD
2494 && method
->lval
== lval_xcallable
&& argc
> 0);
2496 return invoke_xmethod (method
->location
.xm_worker
,
2497 argv
[0], argv
+ 1, argc
- 1);
2500 /* Extract a value as a C number (either long or double).
2501 Knows how to convert fixed values to double, or
2502 floating values to long.
2503 Does not deallocate the value. */
2506 value_as_long (struct value
*val
)
2508 /* This coerces arrays and functions, which is necessary (e.g.
2509 in disassemble_command). It also dereferences references, which
2510 I suspect is the most logical thing to do. */
2511 val
= coerce_array (val
);
2512 return unpack_long (value_type (val
), value_contents (val
));
2516 value_as_double (struct value
*val
)
2521 foo
= unpack_double (value_type (val
), value_contents (val
), &inv
);
2523 error (_("Invalid floating value found in program."));
2527 /* Extract a value as a C pointer. Does not deallocate the value.
2528 Note that val's type may not actually be a pointer; value_as_long
2529 handles all the cases. */
2531 value_as_address (struct value
*val
)
2533 struct gdbarch
*gdbarch
= get_type_arch (value_type (val
));
2535 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2536 whether we want this to be true eventually. */
2538 /* gdbarch_addr_bits_remove is wrong if we are being called for a
2539 non-address (e.g. argument to "signal", "info break", etc.), or
2540 for pointers to char, in which the low bits *are* significant. */
2541 return gdbarch_addr_bits_remove (gdbarch
, value_as_long (val
));
2544 /* There are several targets (IA-64, PowerPC, and others) which
2545 don't represent pointers to functions as simply the address of
2546 the function's entry point. For example, on the IA-64, a
2547 function pointer points to a two-word descriptor, generated by
2548 the linker, which contains the function's entry point, and the
2549 value the IA-64 "global pointer" register should have --- to
2550 support position-independent code. The linker generates
2551 descriptors only for those functions whose addresses are taken.
2553 On such targets, it's difficult for GDB to convert an arbitrary
2554 function address into a function pointer; it has to either find
2555 an existing descriptor for that function, or call malloc and
2556 build its own. On some targets, it is impossible for GDB to
2557 build a descriptor at all: the descriptor must contain a jump
2558 instruction; data memory cannot be executed; and code memory
2561 Upon entry to this function, if VAL is a value of type `function'
2562 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then
2563 value_address (val) is the address of the function. This is what
2564 you'll get if you evaluate an expression like `main'. The call
2565 to COERCE_ARRAY below actually does all the usual unary
2566 conversions, which includes converting values of type `function'
2567 to `pointer to function'. This is the challenging conversion
2568 discussed above. Then, `unpack_long' will convert that pointer
2569 back into an address.
2571 So, suppose the user types `disassemble foo' on an architecture
2572 with a strange function pointer representation, on which GDB
2573 cannot build its own descriptors, and suppose further that `foo'
2574 has no linker-built descriptor. The address->pointer conversion
2575 will signal an error and prevent the command from running, even
2576 though the next step would have been to convert the pointer
2577 directly back into the same address.
2579 The following shortcut avoids this whole mess. If VAL is a
2580 function, just return its address directly. */
2581 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_FUNC
2582 || TYPE_CODE (value_type (val
)) == TYPE_CODE_METHOD
)
2583 return value_address (val
);
2585 val
= coerce_array (val
);
2587 /* Some architectures (e.g. Harvard), map instruction and data
2588 addresses onto a single large unified address space. For
2589 instance: An architecture may consider a large integer in the
2590 range 0x10000000 .. 0x1000ffff to already represent a data
2591 addresses (hence not need a pointer to address conversion) while
2592 a small integer would still need to be converted integer to
2593 pointer to address. Just assume such architectures handle all
2594 integer conversions in a single function. */
2598 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we
2599 must admonish GDB hackers to make sure its behavior matches the
2600 compiler's, whenever possible.
2602 In general, I think GDB should evaluate expressions the same way
2603 the compiler does. When the user copies an expression out of
2604 their source code and hands it to a `print' command, they should
2605 get the same value the compiler would have computed. Any
2606 deviation from this rule can cause major confusion and annoyance,
2607 and needs to be justified carefully. In other words, GDB doesn't
2608 really have the freedom to do these conversions in clever and
2611 AndrewC pointed out that users aren't complaining about how GDB
2612 casts integers to pointers; they are complaining that they can't
2613 take an address from a disassembly listing and give it to `x/i'.
2614 This is certainly important.
2616 Adding an architecture method like integer_to_address() certainly
2617 makes it possible for GDB to "get it right" in all circumstances
2618 --- the target has complete control over how things get done, so
2619 people can Do The Right Thing for their target without breaking
2620 anyone else. The standard doesn't specify how integers get
2621 converted to pointers; usually, the ABI doesn't either, but
2622 ABI-specific code is a more reasonable place to handle it. */
2624 if (TYPE_CODE (value_type (val
)) != TYPE_CODE_PTR
2625 && TYPE_CODE (value_type (val
)) != TYPE_CODE_REF
2626 && gdbarch_integer_to_address_p (gdbarch
))
2627 return gdbarch_integer_to_address (gdbarch
, value_type (val
),
2628 value_contents (val
));
2630 return unpack_long (value_type (val
), value_contents (val
));
2634 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2635 as a long, or as a double, assuming the raw data is described
2636 by type TYPE. Knows how to convert different sizes of values
2637 and can convert between fixed and floating point. We don't assume
2638 any alignment for the raw data. Return value is in host byte order.
2640 If you want functions and arrays to be coerced to pointers, and
2641 references to be dereferenced, call value_as_long() instead.
2643 C++: It is assumed that the front-end has taken care of
2644 all matters concerning pointers to members. A pointer
2645 to member which reaches here is considered to be equivalent
2646 to an INT (or some size). After all, it is only an offset. */
2649 unpack_long (struct type
*type
, const gdb_byte
*valaddr
)
2651 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2652 enum type_code code
= TYPE_CODE (type
);
2653 int len
= TYPE_LENGTH (type
);
2654 int nosign
= TYPE_UNSIGNED (type
);
2658 case TYPE_CODE_TYPEDEF
:
2659 return unpack_long (check_typedef (type
), valaddr
);
2660 case TYPE_CODE_ENUM
:
2661 case TYPE_CODE_FLAGS
:
2662 case TYPE_CODE_BOOL
:
2664 case TYPE_CODE_CHAR
:
2665 case TYPE_CODE_RANGE
:
2666 case TYPE_CODE_MEMBERPTR
:
2668 return extract_unsigned_integer (valaddr
, len
, byte_order
);
2670 return extract_signed_integer (valaddr
, len
, byte_order
);
2673 return extract_typed_floating (valaddr
, type
);
2675 case TYPE_CODE_DECFLOAT
:
2676 /* libdecnumber has a function to convert from decimal to integer, but
2677 it doesn't work when the decimal number has a fractional part. */
2678 return decimal_to_doublest (valaddr
, len
, byte_order
);
2682 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2683 whether we want this to be true eventually. */
2684 return extract_typed_address (valaddr
, type
);
2687 error (_("Value can't be converted to integer."));
2689 return 0; /* Placate lint. */
2692 /* Return a double value from the specified type and address.
2693 INVP points to an int which is set to 0 for valid value,
2694 1 for invalid value (bad float format). In either case,
2695 the returned double is OK to use. Argument is in target
2696 format, result is in host format. */
2699 unpack_double (struct type
*type
, const gdb_byte
*valaddr
, int *invp
)
2701 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2702 enum type_code code
;
2706 *invp
= 0; /* Assume valid. */
2707 CHECK_TYPEDEF (type
);
2708 code
= TYPE_CODE (type
);
2709 len
= TYPE_LENGTH (type
);
2710 nosign
= TYPE_UNSIGNED (type
);
2711 if (code
== TYPE_CODE_FLT
)
2713 /* NOTE: cagney/2002-02-19: There was a test here to see if the
2714 floating-point value was valid (using the macro
2715 INVALID_FLOAT). That test/macro have been removed.
2717 It turns out that only the VAX defined this macro and then
2718 only in a non-portable way. Fixing the portability problem
2719 wouldn't help since the VAX floating-point code is also badly
2720 bit-rotten. The target needs to add definitions for the
2721 methods gdbarch_float_format and gdbarch_double_format - these
2722 exactly describe the target floating-point format. The
2723 problem here is that the corresponding floatformat_vax_f and
2724 floatformat_vax_d values these methods should be set to are
2725 also not defined either. Oops!
2727 Hopefully someone will add both the missing floatformat
2728 definitions and the new cases for floatformat_is_valid (). */
2730 if (!floatformat_is_valid (floatformat_from_type (type
), valaddr
))
2736 return extract_typed_floating (valaddr
, type
);
2738 else if (code
== TYPE_CODE_DECFLOAT
)
2739 return decimal_to_doublest (valaddr
, len
, byte_order
);
2742 /* Unsigned -- be sure we compensate for signed LONGEST. */
2743 return (ULONGEST
) unpack_long (type
, valaddr
);
2747 /* Signed -- we are OK with unpack_long. */
2748 return unpack_long (type
, valaddr
);
2752 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
2753 as a CORE_ADDR, assuming the raw data is described by type TYPE.
2754 We don't assume any alignment for the raw data. Return value is in
2757 If you want functions and arrays to be coerced to pointers, and
2758 references to be dereferenced, call value_as_address() instead.
2760 C++: It is assumed that the front-end has taken care of
2761 all matters concerning pointers to members. A pointer
2762 to member which reaches here is considered to be equivalent
2763 to an INT (or some size). After all, it is only an offset. */
2766 unpack_pointer (struct type
*type
, const gdb_byte
*valaddr
)
2768 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
2769 whether we want this to be true eventually. */
2770 return unpack_long (type
, valaddr
);
2774 /* Get the value of the FIELDNO'th field (which must be static) of
2778 value_static_field (struct type
*type
, int fieldno
)
2780 struct value
*retval
;
2782 switch (TYPE_FIELD_LOC_KIND (type
, fieldno
))
2784 case FIELD_LOC_KIND_PHYSADDR
:
2785 retval
= value_at_lazy (TYPE_FIELD_TYPE (type
, fieldno
),
2786 TYPE_FIELD_STATIC_PHYSADDR (type
, fieldno
));
2788 case FIELD_LOC_KIND_PHYSNAME
:
2790 const char *phys_name
= TYPE_FIELD_STATIC_PHYSNAME (type
, fieldno
);
2791 /* TYPE_FIELD_NAME (type, fieldno); */
2792 struct symbol
*sym
= lookup_symbol (phys_name
, 0, VAR_DOMAIN
, 0);
2796 /* With some compilers, e.g. HP aCC, static data members are
2797 reported as non-debuggable symbols. */
2798 struct bound_minimal_symbol msym
2799 = lookup_minimal_symbol (phys_name
, NULL
, NULL
);
2802 return allocate_optimized_out_value (type
);
2805 retval
= value_at_lazy (TYPE_FIELD_TYPE (type
, fieldno
),
2806 BMSYMBOL_VALUE_ADDRESS (msym
));
2810 retval
= value_of_variable (sym
, NULL
);
2814 gdb_assert_not_reached ("unexpected field location kind");
2820 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE.
2821 You have to be careful here, since the size of the data area for the value
2822 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger
2823 than the old enclosing type, you have to allocate more space for the
2827 set_value_enclosing_type (struct value
*val
, struct type
*new_encl_type
)
2829 if (TYPE_LENGTH (new_encl_type
) > TYPE_LENGTH (value_enclosing_type (val
)))
2831 (gdb_byte
*) xrealloc (val
->contents
, TYPE_LENGTH (new_encl_type
));
2833 val
->enclosing_type
= new_encl_type
;
2836 /* Given a value ARG1 (offset by OFFSET bytes)
2837 of a struct or union type ARG_TYPE,
2838 extract and return the value of one of its (non-static) fields.
2839 FIELDNO says which field. */
2842 value_primitive_field (struct value
*arg1
, int offset
,
2843 int fieldno
, struct type
*arg_type
)
2848 CHECK_TYPEDEF (arg_type
);
2849 type
= TYPE_FIELD_TYPE (arg_type
, fieldno
);
2851 /* Call check_typedef on our type to make sure that, if TYPE
2852 is a TYPE_CODE_TYPEDEF, its length is set to the length
2853 of the target type instead of zero. However, we do not
2854 replace the typedef type by the target type, because we want
2855 to keep the typedef in order to be able to print the type
2856 description correctly. */
2857 check_typedef (type
);
2859 if (TYPE_FIELD_BITSIZE (arg_type
, fieldno
))
2861 /* Handle packed fields.
2863 Create a new value for the bitfield, with bitpos and bitsize
2864 set. If possible, arrange offset and bitpos so that we can
2865 do a single aligned read of the size of the containing type.
2866 Otherwise, adjust offset to the byte containing the first
2867 bit. Assume that the address, offset, and embedded offset
2868 are sufficiently aligned. */
2870 int bitpos
= TYPE_FIELD_BITPOS (arg_type
, fieldno
);
2871 int container_bitsize
= TYPE_LENGTH (type
) * 8;
2873 if (arg1
->optimized_out
)
2874 v
= allocate_optimized_out_value (type
);
2877 v
= allocate_value_lazy (type
);
2878 v
->bitsize
= TYPE_FIELD_BITSIZE (arg_type
, fieldno
);
2879 if ((bitpos
% container_bitsize
) + v
->bitsize
<= container_bitsize
2880 && TYPE_LENGTH (type
) <= (int) sizeof (LONGEST
))
2881 v
->bitpos
= bitpos
% container_bitsize
;
2883 v
->bitpos
= bitpos
% 8;
2884 v
->offset
= (value_embedded_offset (arg1
)
2886 + (bitpos
- v
->bitpos
) / 8);
2887 set_value_parent (v
, arg1
);
2888 if (!value_lazy (arg1
))
2889 value_fetch_lazy (v
);
2892 else if (fieldno
< TYPE_N_BASECLASSES (arg_type
))
2894 /* This field is actually a base subobject, so preserve the
2895 entire object's contents for later references to virtual
2899 /* Lazy register values with offsets are not supported. */
2900 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
2901 value_fetch_lazy (arg1
);
2903 /* The optimized_out flag is only set correctly once a lazy value is
2904 loaded, having just loaded some lazy values we should check the
2905 optimized out case now. */
2906 if (arg1
->optimized_out
)
2907 v
= allocate_optimized_out_value (type
);
2910 /* We special case virtual inheritance here because this
2911 requires access to the contents, which we would rather avoid
2912 for references to ordinary fields of unavailable values. */
2913 if (BASETYPE_VIA_VIRTUAL (arg_type
, fieldno
))
2914 boffset
= baseclass_offset (arg_type
, fieldno
,
2915 value_contents (arg1
),
2916 value_embedded_offset (arg1
),
2917 value_address (arg1
),
2920 boffset
= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
2922 if (value_lazy (arg1
))
2923 v
= allocate_value_lazy (value_enclosing_type (arg1
));
2926 v
= allocate_value (value_enclosing_type (arg1
));
2927 value_contents_copy_raw (v
, 0, arg1
, 0,
2928 TYPE_LENGTH (value_enclosing_type (arg1
)));
2931 v
->offset
= value_offset (arg1
);
2932 v
->embedded_offset
= offset
+ value_embedded_offset (arg1
) + boffset
;
2937 /* Plain old data member */
2938 offset
+= TYPE_FIELD_BITPOS (arg_type
, fieldno
) / 8;
2940 /* Lazy register values with offsets are not supported. */
2941 if (VALUE_LVAL (arg1
) == lval_register
&& value_lazy (arg1
))
2942 value_fetch_lazy (arg1
);
2944 /* The optimized_out flag is only set correctly once a lazy value is
2945 loaded, having just loaded some lazy values we should check for
2946 the optimized out case now. */
2947 if (arg1
->optimized_out
)
2948 v
= allocate_optimized_out_value (type
);
2949 else if (value_lazy (arg1
))
2950 v
= allocate_value_lazy (type
);
2953 v
= allocate_value (type
);
2954 value_contents_copy_raw (v
, value_embedded_offset (v
),
2955 arg1
, value_embedded_offset (arg1
) + offset
,
2956 TYPE_LENGTH (type
));
2958 v
->offset
= (value_offset (arg1
) + offset
2959 + value_embedded_offset (arg1
));
2961 set_value_component_location (v
, arg1
);
2962 VALUE_REGNUM (v
) = VALUE_REGNUM (arg1
);
2963 VALUE_FRAME_ID (v
) = VALUE_FRAME_ID (arg1
);
2967 /* Given a value ARG1 of a struct or union type,
2968 extract and return the value of one of its (non-static) fields.
2969 FIELDNO says which field. */
2972 value_field (struct value
*arg1
, int fieldno
)
2974 return value_primitive_field (arg1
, 0, fieldno
, value_type (arg1
));
2977 /* Return a non-virtual function as a value.
2978 F is the list of member functions which contains the desired method.
2979 J is an index into F which provides the desired method.
2981 We only use the symbol for its address, so be happy with either a
2982 full symbol or a minimal symbol. */
2985 value_fn_field (struct value
**arg1p
, struct fn_field
*f
,
2986 int j
, struct type
*type
,
2990 struct type
*ftype
= TYPE_FN_FIELD_TYPE (f
, j
);
2991 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
2993 struct bound_minimal_symbol msym
;
2995 sym
= lookup_symbol (physname
, 0, VAR_DOMAIN
, 0);
2998 memset (&msym
, 0, sizeof (msym
));
3002 gdb_assert (sym
== NULL
);
3003 msym
= lookup_bound_minimal_symbol (physname
);
3004 if (msym
.minsym
== NULL
)
3008 v
= allocate_value (ftype
);
3011 set_value_address (v
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)));
3015 /* The minimal symbol might point to a function descriptor;
3016 resolve it to the actual code address instead. */
3017 struct objfile
*objfile
= msym
.objfile
;
3018 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
3020 set_value_address (v
,
3021 gdbarch_convert_from_func_ptr_addr
3022 (gdbarch
, BMSYMBOL_VALUE_ADDRESS (msym
), ¤t_target
));
3027 if (type
!= value_type (*arg1p
))
3028 *arg1p
= value_ind (value_cast (lookup_pointer_type (type
),
3029 value_addr (*arg1p
)));
3031 /* Move the `this' pointer according to the offset.
3032 VALUE_OFFSET (*arg1p) += offset; */
3040 /* Helper function for both unpack_value_bits_as_long and
3041 unpack_bits_as_long. See those functions for more details on the
3042 interface; the only difference is that this function accepts either
3043 a NULL or a non-NULL ORIGINAL_VALUE. */
3046 unpack_value_bits_as_long_1 (struct type
*field_type
, const gdb_byte
*valaddr
,
3047 int embedded_offset
, int bitpos
, int bitsize
,
3048 const struct value
*original_value
,
3051 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (field_type
));
3058 /* Read the minimum number of bytes required; there may not be
3059 enough bytes to read an entire ULONGEST. */
3060 CHECK_TYPEDEF (field_type
);
3062 bytes_read
= ((bitpos
% 8) + bitsize
+ 7) / 8;
3064 bytes_read
= TYPE_LENGTH (field_type
);
3066 read_offset
= bitpos
/ 8;
3068 if (original_value
!= NULL
3069 && !value_bits_available (original_value
, embedded_offset
+ bitpos
,
3073 val
= extract_unsigned_integer (valaddr
+ embedded_offset
+ read_offset
,
3074 bytes_read
, byte_order
);
3076 /* Extract bits. See comment above. */
3078 if (gdbarch_bits_big_endian (get_type_arch (field_type
)))
3079 lsbcount
= (bytes_read
* 8 - bitpos
% 8 - bitsize
);
3081 lsbcount
= (bitpos
% 8);
3084 /* If the field does not entirely fill a LONGEST, then zero the sign bits.
3085 If the field is signed, and is negative, then sign extend. */
3087 if ((bitsize
> 0) && (bitsize
< 8 * (int) sizeof (val
)))
3089 valmask
= (((ULONGEST
) 1) << bitsize
) - 1;
3091 if (!TYPE_UNSIGNED (field_type
))
3093 if (val
& (valmask
^ (valmask
>> 1)))
3104 /* Unpack a bitfield of the specified FIELD_TYPE, from the object at
3105 VALADDR + EMBEDDED_OFFSET, and store the result in *RESULT.
3106 VALADDR points to the contents of ORIGINAL_VALUE, which must not be
3107 NULL. The bitfield starts at BITPOS bits and contains BITSIZE
3110 Returns false if the value contents are unavailable, otherwise
3111 returns true, indicating a valid value has been stored in *RESULT.
3113 Extracting bits depends on endianness of the machine. Compute the
3114 number of least significant bits to discard. For big endian machines,
3115 we compute the total number of bits in the anonymous object, subtract
3116 off the bit count from the MSB of the object to the MSB of the
3117 bitfield, then the size of the bitfield, which leaves the LSB discard
3118 count. For little endian machines, the discard count is simply the
3119 number of bits from the LSB of the anonymous object to the LSB of the
3122 If the field is signed, we also do sign extension. */
3125 unpack_value_bits_as_long (struct type
*field_type
, const gdb_byte
*valaddr
,
3126 int embedded_offset
, int bitpos
, int bitsize
,
3127 const struct value
*original_value
,
3130 gdb_assert (original_value
!= NULL
);
3132 return unpack_value_bits_as_long_1 (field_type
, valaddr
, embedded_offset
,
3133 bitpos
, bitsize
, original_value
, result
);
3137 /* Unpack a field FIELDNO of the specified TYPE, from the object at
3138 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
3139 ORIGINAL_VALUE. See unpack_value_bits_as_long for more
3143 unpack_value_field_as_long_1 (struct type
*type
, const gdb_byte
*valaddr
,
3144 int embedded_offset
, int fieldno
,
3145 const struct value
*val
, LONGEST
*result
)
3147 int bitpos
= TYPE_FIELD_BITPOS (type
, fieldno
);
3148 int bitsize
= TYPE_FIELD_BITSIZE (type
, fieldno
);
3149 struct type
*field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
3151 return unpack_value_bits_as_long_1 (field_type
, valaddr
, embedded_offset
,
3152 bitpos
, bitsize
, val
,
3156 /* Unpack a field FIELDNO of the specified TYPE, from the object at
3157 VALADDR + EMBEDDED_OFFSET. VALADDR points to the contents of
3158 ORIGINAL_VALUE, which must not be NULL. See
3159 unpack_value_bits_as_long for more details. */
3162 unpack_value_field_as_long (struct type
*type
, const gdb_byte
*valaddr
,
3163 int embedded_offset
, int fieldno
,
3164 const struct value
*val
, LONGEST
*result
)
3166 gdb_assert (val
!= NULL
);
3168 return unpack_value_field_as_long_1 (type
, valaddr
, embedded_offset
,
3169 fieldno
, val
, result
);
3172 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous
3173 object at VALADDR. See unpack_value_bits_as_long for more details.
3174 This function differs from unpack_value_field_as_long in that it
3175 operates without a struct value object. */
3178 unpack_field_as_long (struct type
*type
, const gdb_byte
*valaddr
, int fieldno
)
3182 unpack_value_field_as_long_1 (type
, valaddr
, 0, fieldno
, NULL
, &result
);
3186 /* Return a new value with type TYPE, which is FIELDNO field of the
3187 object at VALADDR + EMBEDDEDOFFSET. VALADDR points to the contents
3188 of VAL. If the VAL's contents required to extract the bitfield
3189 from are unavailable, the new value is correspondingly marked as
3193 value_field_bitfield (struct type
*type
, int fieldno
,
3194 const gdb_byte
*valaddr
,
3195 int embedded_offset
, const struct value
*val
)
3199 if (!unpack_value_field_as_long (type
, valaddr
, embedded_offset
, fieldno
,
3202 struct type
*field_type
= TYPE_FIELD_TYPE (type
, fieldno
);
3203 struct value
*retval
= allocate_value (field_type
);
3204 mark_value_bytes_unavailable (retval
, 0, TYPE_LENGTH (field_type
));
3209 return value_from_longest (TYPE_FIELD_TYPE (type
, fieldno
), l
);
3213 /* Modify the value of a bitfield. ADDR points to a block of memory in
3214 target byte order; the bitfield starts in the byte pointed to. FIELDVAL
3215 is the desired value of the field, in host byte order. BITPOS and BITSIZE
3216 indicate which bits (in target bit order) comprise the bitfield.
3217 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS % 8 + BITSIZE <= lbits, and
3218 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */
3221 modify_field (struct type
*type
, gdb_byte
*addr
,
3222 LONGEST fieldval
, int bitpos
, int bitsize
)
3224 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
3226 ULONGEST mask
= (ULONGEST
) -1 >> (8 * sizeof (ULONGEST
) - bitsize
);
3229 /* Normalize BITPOS. */
3233 /* If a negative fieldval fits in the field in question, chop
3234 off the sign extension bits. */
3235 if ((~fieldval
& ~(mask
>> 1)) == 0)
3238 /* Warn if value is too big to fit in the field in question. */
3239 if (0 != (fieldval
& ~mask
))
3241 /* FIXME: would like to include fieldval in the message, but
3242 we don't have a sprintf_longest. */
3243 warning (_("Value does not fit in %d bits."), bitsize
);
3245 /* Truncate it, otherwise adjoining fields may be corrupted. */
3249 /* Ensure no bytes outside of the modified ones get accessed as it may cause
3250 false valgrind reports. */
3252 bytesize
= (bitpos
+ bitsize
+ 7) / 8;
3253 oword
= extract_unsigned_integer (addr
, bytesize
, byte_order
);
3255 /* Shifting for bit field depends on endianness of the target machine. */
3256 if (gdbarch_bits_big_endian (get_type_arch (type
)))
3257 bitpos
= bytesize
* 8 - bitpos
- bitsize
;
3259 oword
&= ~(mask
<< bitpos
);
3260 oword
|= fieldval
<< bitpos
;
3262 store_unsigned_integer (addr
, bytesize
, byte_order
, oword
);
3265 /* Pack NUM into BUF using a target format of TYPE. */
3268 pack_long (gdb_byte
*buf
, struct type
*type
, LONGEST num
)
3270 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
3273 type
= check_typedef (type
);
3274 len
= TYPE_LENGTH (type
);
3276 switch (TYPE_CODE (type
))
3279 case TYPE_CODE_CHAR
:
3280 case TYPE_CODE_ENUM
:
3281 case TYPE_CODE_FLAGS
:
3282 case TYPE_CODE_BOOL
:
3283 case TYPE_CODE_RANGE
:
3284 case TYPE_CODE_MEMBERPTR
:
3285 store_signed_integer (buf
, len
, byte_order
, num
);
3290 store_typed_address (buf
, type
, (CORE_ADDR
) num
);
3294 error (_("Unexpected type (%d) encountered for integer constant."),
3300 /* Pack NUM into BUF using a target format of TYPE. */
3303 pack_unsigned_long (gdb_byte
*buf
, struct type
*type
, ULONGEST num
)
3306 enum bfd_endian byte_order
;
3308 type
= check_typedef (type
);
3309 len
= TYPE_LENGTH (type
);
3310 byte_order
= gdbarch_byte_order (get_type_arch (type
));
3312 switch (TYPE_CODE (type
))
3315 case TYPE_CODE_CHAR
:
3316 case TYPE_CODE_ENUM
:
3317 case TYPE_CODE_FLAGS
:
3318 case TYPE_CODE_BOOL
:
3319 case TYPE_CODE_RANGE
:
3320 case TYPE_CODE_MEMBERPTR
:
3321 store_unsigned_integer (buf
, len
, byte_order
, num
);
3326 store_typed_address (buf
, type
, (CORE_ADDR
) num
);
3330 error (_("Unexpected type (%d) encountered "
3331 "for unsigned integer constant."),
3337 /* Convert C numbers into newly allocated values. */
3340 value_from_longest (struct type
*type
, LONGEST num
)
3342 struct value
*val
= allocate_value (type
);
3344 pack_long (value_contents_raw (val
), type
, num
);
3349 /* Convert C unsigned numbers into newly allocated values. */
3352 value_from_ulongest (struct type
*type
, ULONGEST num
)
3354 struct value
*val
= allocate_value (type
);
3356 pack_unsigned_long (value_contents_raw (val
), type
, num
);
3362 /* Create a value representing a pointer of type TYPE to the address
3363 ADDR. The type of the created value may differ from the passed
3364 type TYPE. Make sure to retrieve the returned values's new type
3365 after this call e.g. in case of an variable length array. */
3368 value_from_pointer (struct type
*type
, CORE_ADDR addr
)
3370 struct type
*resolved_type
= resolve_dynamic_type (type
, addr
);
3371 struct value
*val
= allocate_value (resolved_type
);
3373 store_typed_address (value_contents_raw (val
),
3374 check_typedef (resolved_type
), addr
);
3379 /* Create a value of type TYPE whose contents come from VALADDR, if it
3380 is non-null, and whose memory address (in the inferior) is
3381 ADDRESS. The type of the created value may differ from the passed
3382 type TYPE. Make sure to retrieve values new type after this call.
3383 Note that TYPE is not passed through resolve_dynamic_type; this is
3384 a special API intended for use only by Ada. */
3387 value_from_contents_and_address_unresolved (struct type
*type
,
3388 const gdb_byte
*valaddr
,
3393 if (valaddr
== NULL
)
3394 v
= allocate_value_lazy (type
);
3396 v
= value_from_contents (type
, valaddr
);
3397 set_value_address (v
, address
);
3398 VALUE_LVAL (v
) = lval_memory
;
3402 /* Create a value of type TYPE whose contents come from VALADDR, if it
3403 is non-null, and whose memory address (in the inferior) is
3404 ADDRESS. The type of the created value may differ from the passed
3405 type TYPE. Make sure to retrieve values new type after this call. */
3408 value_from_contents_and_address (struct type
*type
,
3409 const gdb_byte
*valaddr
,
3412 struct type
*resolved_type
= resolve_dynamic_type (type
, address
);
3415 if (valaddr
== NULL
)
3416 v
= allocate_value_lazy (resolved_type
);
3418 v
= value_from_contents (resolved_type
, valaddr
);
3419 set_value_address (v
, address
);
3420 VALUE_LVAL (v
) = lval_memory
;
3424 /* Create a value of type TYPE holding the contents CONTENTS.
3425 The new value is `not_lval'. */
3428 value_from_contents (struct type
*type
, const gdb_byte
*contents
)
3430 struct value
*result
;
3432 result
= allocate_value (type
);
3433 memcpy (value_contents_raw (result
), contents
, TYPE_LENGTH (type
));
3438 value_from_double (struct type
*type
, DOUBLEST num
)
3440 struct value
*val
= allocate_value (type
);
3441 struct type
*base_type
= check_typedef (type
);
3442 enum type_code code
= TYPE_CODE (base_type
);
3444 if (code
== TYPE_CODE_FLT
)
3446 store_typed_floating (value_contents_raw (val
), base_type
, num
);
3449 error (_("Unexpected type encountered for floating constant."));
3455 value_from_decfloat (struct type
*type
, const gdb_byte
*dec
)
3457 struct value
*val
= allocate_value (type
);
3459 memcpy (value_contents_raw (val
), dec
, TYPE_LENGTH (type
));
3463 /* Extract a value from the history file. Input will be of the form
3464 $digits or $$digits. See block comment above 'write_dollar_variable'
3468 value_from_history_ref (char *h
, char **endp
)
3480 /* Find length of numeral string. */
3481 for (; isdigit (h
[len
]); len
++)
3484 /* Make sure numeral string is not part of an identifier. */
3485 if (h
[len
] == '_' || isalpha (h
[len
]))
3488 /* Now collect the index value. */
3493 /* For some bizarre reason, "$$" is equivalent to "$$1",
3494 rather than to "$$0" as it ought to be! */
3499 index
= -strtol (&h
[2], endp
, 10);
3505 /* "$" is equivalent to "$0". */
3510 index
= strtol (&h
[1], endp
, 10);
3513 return access_value_history (index
);
3517 coerce_ref_if_computed (const struct value
*arg
)
3519 const struct lval_funcs
*funcs
;
3521 if (TYPE_CODE (check_typedef (value_type (arg
))) != TYPE_CODE_REF
)
3524 if (value_lval_const (arg
) != lval_computed
)
3527 funcs
= value_computed_funcs (arg
);
3528 if (funcs
->coerce_ref
== NULL
)
3531 return funcs
->coerce_ref (arg
);
3534 /* Look at value.h for description. */
3537 readjust_indirect_value_type (struct value
*value
, struct type
*enc_type
,
3538 struct type
*original_type
,
3539 struct value
*original_value
)
3541 /* Re-adjust type. */
3542 deprecated_set_value_type (value
, TYPE_TARGET_TYPE (original_type
));
3544 /* Add embedding info. */
3545 set_value_enclosing_type (value
, enc_type
);
3546 set_value_embedded_offset (value
, value_pointed_to_offset (original_value
));
3548 /* We may be pointing to an object of some derived type. */
3549 return value_full_object (value
, NULL
, 0, 0, 0);
3553 coerce_ref (struct value
*arg
)
3555 struct type
*value_type_arg_tmp
= check_typedef (value_type (arg
));
3556 struct value
*retval
;
3557 struct type
*enc_type
;
3559 retval
= coerce_ref_if_computed (arg
);
3563 if (TYPE_CODE (value_type_arg_tmp
) != TYPE_CODE_REF
)
3566 enc_type
= check_typedef (value_enclosing_type (arg
));
3567 enc_type
= TYPE_TARGET_TYPE (enc_type
);
3569 retval
= value_at_lazy (enc_type
,
3570 unpack_pointer (value_type (arg
),
3571 value_contents (arg
)));
3572 enc_type
= value_type (retval
);
3573 return readjust_indirect_value_type (retval
, enc_type
,
3574 value_type_arg_tmp
, arg
);
3578 coerce_array (struct value
*arg
)
3582 arg
= coerce_ref (arg
);
3583 type
= check_typedef (value_type (arg
));
3585 switch (TYPE_CODE (type
))
3587 case TYPE_CODE_ARRAY
:
3588 if (!TYPE_VECTOR (type
) && current_language
->c_style_arrays
)
3589 arg
= value_coerce_array (arg
);
3591 case TYPE_CODE_FUNC
:
3592 arg
= value_coerce_function (arg
);
3599 /* Return the return value convention that will be used for the
3602 enum return_value_convention
3603 struct_return_convention (struct gdbarch
*gdbarch
,
3604 struct value
*function
, struct type
*value_type
)
3606 enum type_code code
= TYPE_CODE (value_type
);
3608 if (code
== TYPE_CODE_ERROR
)
3609 error (_("Function return type unknown."));
3611 /* Probe the architecture for the return-value convention. */
3612 return gdbarch_return_value (gdbarch
, function
, value_type
,
3616 /* Return true if the function returning the specified type is using
3617 the convention of returning structures in memory (passing in the
3618 address as a hidden first parameter). */
3621 using_struct_return (struct gdbarch
*gdbarch
,
3622 struct value
*function
, struct type
*value_type
)
3624 if (TYPE_CODE (value_type
) == TYPE_CODE_VOID
)
3625 /* A void return value is never in memory. See also corresponding
3626 code in "print_return_value". */
3629 return (struct_return_convention (gdbarch
, function
, value_type
)
3630 != RETURN_VALUE_REGISTER_CONVENTION
);
3633 /* Set the initialized field in a value struct. */
3636 set_value_initialized (struct value
*val
, int status
)
3638 val
->initialized
= status
;
3641 /* Return the initialized field in a value struct. */
3644 value_initialized (struct value
*val
)
3646 return val
->initialized
;
3649 /* Called only from the value_contents and value_contents_all()
3650 macros, if the current data for a variable needs to be loaded into
3651 value_contents(VAL). Fetches the data from the user's process, and
3652 clears the lazy flag to indicate that the data in the buffer is
3655 If the value is zero-length, we avoid calling read_memory, which
3656 would abort. We mark the value as fetched anyway -- all 0 bytes of
3659 This function returns a value because it is used in the
3660 value_contents macro as part of an expression, where a void would
3661 not work. The value is ignored. */
3664 value_fetch_lazy (struct value
*val
)
3666 gdb_assert (value_lazy (val
));
3667 allocate_value_contents (val
);
3668 if (value_bitsize (val
))
3670 /* To read a lazy bitfield, read the entire enclosing value. This
3671 prevents reading the same block of (possibly volatile) memory once
3672 per bitfield. It would be even better to read only the containing
3673 word, but we have no way to record that just specific bits of a
3674 value have been fetched. */
3675 struct type
*type
= check_typedef (value_type (val
));
3676 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
3677 struct value
*parent
= value_parent (val
);
3678 LONGEST offset
= value_offset (val
);
3681 if (value_lazy (parent
))
3682 value_fetch_lazy (parent
);
3684 if (!value_bits_valid (parent
,
3685 TARGET_CHAR_BIT
* offset
+ value_bitpos (val
),
3686 value_bitsize (val
)))
3687 set_value_optimized_out (val
, 1);
3688 else if (!unpack_value_bits_as_long (value_type (val
),
3689 value_contents_for_printing (parent
),
3692 value_bitsize (val
), parent
, &num
))
3693 mark_value_bytes_unavailable (val
,
3694 value_embedded_offset (val
),
3695 TYPE_LENGTH (type
));
3697 store_signed_integer (value_contents_raw (val
), TYPE_LENGTH (type
),
3700 else if (VALUE_LVAL (val
) == lval_memory
)
3702 CORE_ADDR addr
= value_address (val
);
3703 struct type
*type
= check_typedef (value_enclosing_type (val
));
3705 if (TYPE_LENGTH (type
))
3706 read_value_memory (val
, 0, value_stack (val
),
3707 addr
, value_contents_all_raw (val
),
3708 TYPE_LENGTH (type
));
3710 else if (VALUE_LVAL (val
) == lval_register
)
3712 struct frame_info
*frame
;
3714 struct type
*type
= check_typedef (value_type (val
));
3715 struct value
*new_val
= val
, *mark
= value_mark ();
3717 /* Offsets are not supported here; lazy register values must
3718 refer to the entire register. */
3719 gdb_assert (value_offset (val
) == 0);
3721 while (VALUE_LVAL (new_val
) == lval_register
&& value_lazy (new_val
))
3723 struct frame_id frame_id
= VALUE_FRAME_ID (new_val
);
3725 frame
= frame_find_by_id (frame_id
);
3726 regnum
= VALUE_REGNUM (new_val
);
3728 gdb_assert (frame
!= NULL
);
3730 /* Convertible register routines are used for multi-register
3731 values and for interpretation in different types
3732 (e.g. float or int from a double register). Lazy
3733 register values should have the register's natural type,
3734 so they do not apply. */
3735 gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame
),
3738 new_val
= get_frame_register_value (frame
, regnum
);
3740 /* If we get another lazy lval_register value, it means the
3741 register is found by reading it from the next frame.
3742 get_frame_register_value should never return a value with
3743 the frame id pointing to FRAME. If it does, it means we
3744 either have two consecutive frames with the same frame id
3745 in the frame chain, or some code is trying to unwind
3746 behind get_prev_frame's back (e.g., a frame unwind
3747 sniffer trying to unwind), bypassing its validations. In
3748 any case, it should always be an internal error to end up
3749 in this situation. */
3750 if (VALUE_LVAL (new_val
) == lval_register
3751 && value_lazy (new_val
)
3752 && frame_id_eq (VALUE_FRAME_ID (new_val
), frame_id
))
3753 internal_error (__FILE__
, __LINE__
,
3754 _("infinite loop while fetching a register"));
3757 /* If it's still lazy (for instance, a saved register on the
3758 stack), fetch it. */
3759 if (value_lazy (new_val
))
3760 value_fetch_lazy (new_val
);
3762 /* If the register was not saved, mark it optimized out. */
3763 if (value_optimized_out (new_val
))
3764 set_value_optimized_out (val
, 1);
3767 set_value_lazy (val
, 0);
3768 value_contents_copy (val
, value_embedded_offset (val
),
3769 new_val
, value_embedded_offset (new_val
),
3770 TYPE_LENGTH (type
));
3775 struct gdbarch
*gdbarch
;
3776 frame
= frame_find_by_id (VALUE_FRAME_ID (val
));
3777 regnum
= VALUE_REGNUM (val
);
3778 gdbarch
= get_frame_arch (frame
);
3780 fprintf_unfiltered (gdb_stdlog
,
3781 "{ value_fetch_lazy "
3782 "(frame=%d,regnum=%d(%s),...) ",
3783 frame_relative_level (frame
), regnum
,
3784 user_reg_map_regnum_to_name (gdbarch
, regnum
));
3786 fprintf_unfiltered (gdb_stdlog
, "->");
3787 if (value_optimized_out (new_val
))
3789 fprintf_unfiltered (gdb_stdlog
, " ");
3790 val_print_optimized_out (new_val
, gdb_stdlog
);
3795 const gdb_byte
*buf
= value_contents (new_val
);
3797 if (VALUE_LVAL (new_val
) == lval_register
)
3798 fprintf_unfiltered (gdb_stdlog
, " register=%d",
3799 VALUE_REGNUM (new_val
));
3800 else if (VALUE_LVAL (new_val
) == lval_memory
)
3801 fprintf_unfiltered (gdb_stdlog
, " address=%s",
3803 value_address (new_val
)));
3805 fprintf_unfiltered (gdb_stdlog
, " computed");
3807 fprintf_unfiltered (gdb_stdlog
, " bytes=");
3808 fprintf_unfiltered (gdb_stdlog
, "[");
3809 for (i
= 0; i
< register_size (gdbarch
, regnum
); i
++)
3810 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
3811 fprintf_unfiltered (gdb_stdlog
, "]");
3814 fprintf_unfiltered (gdb_stdlog
, " }\n");
3817 /* Dispose of the intermediate values. This prevents
3818 watchpoints from trying to watch the saved frame pointer. */
3819 value_free_to_mark (mark
);
3821 else if (VALUE_LVAL (val
) == lval_computed
3822 && value_computed_funcs (val
)->read
!= NULL
)
3823 value_computed_funcs (val
)->read (val
);
3824 /* Don't call value_optimized_out on val, doing so would result in a
3825 recursive call back to value_fetch_lazy, instead check the
3826 optimized_out flag directly. */
3827 else if (val
->optimized_out
)
3828 /* Keep it optimized out. */;
3830 internal_error (__FILE__
, __LINE__
, _("Unexpected lazy value type."));
3832 set_value_lazy (val
, 0);
3836 /* Implementation of the convenience function $_isvoid. */
3838 static struct value
*
3839 isvoid_internal_fn (struct gdbarch
*gdbarch
,
3840 const struct language_defn
*language
,
3841 void *cookie
, int argc
, struct value
**argv
)
3846 error (_("You must provide one argument for $_isvoid."));
3848 ret
= TYPE_CODE (value_type (argv
[0])) == TYPE_CODE_VOID
;
3850 return value_from_longest (builtin_type (gdbarch
)->builtin_int
, ret
);
3854 _initialize_values (void)
3856 add_cmd ("convenience", no_class
, show_convenience
, _("\
3857 Debugger convenience (\"$foo\") variables and functions.\n\
3858 Convenience variables are created when you assign them values;\n\
3859 thus, \"set $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\
3861 A few convenience variables are given values automatically:\n\
3862 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
3863 \"$__\" holds the contents of the last address examined with \"x\"."
3866 Convenience functions are defined via the Python API."
3869 add_alias_cmd ("conv", "convenience", no_class
, 1, &showlist
);
3871 add_cmd ("values", no_set_class
, show_values
, _("\
3872 Elements of value history around item number IDX (or last ten)."),
3875 add_com ("init-if-undefined", class_vars
, init_if_undefined_command
, _("\
3876 Initialize a convenience variable if necessary.\n\
3877 init-if-undefined VARIABLE = EXPRESSION\n\
3878 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\
3879 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\
3880 VARIABLE is already initialized."));
3882 add_prefix_cmd ("function", no_class
, function_command
, _("\
3883 Placeholder command for showing help on convenience functions."),
3884 &functionlist
, "function ", 0, &cmdlist
);
3886 add_internal_function ("_isvoid", _("\
3887 Check whether an expression is void.\n\
3888 Usage: $_isvoid (expression)\n\
3889 Return 1 if the expression is void, zero otherwise."),
3890 isvoid_internal_fn
, NULL
);