1 /* Definitions for values of C expressions, for GDB.
3 Copyright (C) 1986-2018 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/>. */
20 #if !defined (VALUE_H)
23 #include "frame.h" /* For struct frame_id. */
24 #include "extension.h"
25 #include "common/gdb_ref_ptr.h"
34 struct value_print_options;
36 /* Values can be partially 'optimized out' and/or 'unavailable'.
37 These are distinct states and have different string representations
38 and related error strings.
40 'unavailable' has a specific meaning in this context. It means the
41 value exists in the program (at the machine level), but GDB has no
42 means to get to it. Such a value is normally printed as
43 <unavailable>. Examples of how to end up with an unavailable value
46 - We're inspecting a traceframe, and the memory or registers the
47 debug information says the value lives on haven't been collected.
49 - We're inspecting a core dump, the memory or registers the debug
50 information says the value lives aren't present in the dump
51 (that is, we have a partial/trimmed core dump, or we don't fully
52 understand/handle the core dump's format).
54 - We're doing live debugging, but the debug API has no means to
55 get at where the value lives in the machine, like e.g., ptrace
56 not having access to some register or register set.
58 - Any other similar scenario.
60 OTOH, "optimized out" is about what the compiler decided to generate
61 (or not generate). A chunk of a value that was optimized out does
62 not actually exist in the program. There's no way to get at it
63 short of compiling the program differently.
65 A register that has not been saved in a frame is likewise considered
66 optimized out, except not-saved registers have a different string
67 representation and related error strings. E.g., we'll print them as
68 <not-saved> instead of <optimized out>, as in:
72 (gdb) info registers rax
75 If the debug info describes a variable as being in such a register,
76 we'll still print the variable as <optimized out>. IOW, <not saved>
77 is reserved for inspecting registers at the machine level.
79 When comparing value contents, optimized out chunks, unavailable
80 chunks, and valid contents data are all considered different. See
81 value_contents_eq for more info.
84 /* The structure which defines the type of a value. It should never
85 be possible for a program lval value to survive over a call to the
86 inferior (i.e. to be put into the history list or an internal
91 /* Decrease VAL's reference count. When the reference count drops to
92 0, VAL will be freed. */
94 extern struct value *value_incref (struct value *val);
96 /* Increate VAL's reference count. VAL is returned. */
98 extern void value_decref (struct value *val);
100 /* A policy class to interface gdb::ref_ptr with struct value. */
102 struct value_ref_policy
104 static void incref (struct value *ptr)
109 static void decref (struct value *ptr)
115 /* A gdb:;ref_ptr pointer to a struct value. */
117 typedef gdb::ref_ptr<struct value, value_ref_policy> value_ref_ptr;
119 /* Values are stored in a chain, so that they can be deleted easily
120 over calls to the inferior. Values assigned to internal variables,
121 put into the value history or exposed to Python are taken off this
124 struct value *value_next (const struct value *);
126 /* Type of the value. */
128 extern struct type *value_type (const struct value *);
130 /* Return the gdbarch associated with the value. */
132 extern struct gdbarch *get_value_arch (const struct value *value);
134 /* This is being used to change the type of an existing value, that
135 code should instead be creating a new value with the changed type
136 (but possibly shared content). */
138 extern void deprecated_set_value_type (struct value *value,
141 /* Only used for bitfields; number of bits contained in them. */
143 extern LONGEST value_bitsize (const struct value *);
144 extern void set_value_bitsize (struct value *, LONGEST bit);
146 /* Only used for bitfields; position of start of field. For
147 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
148 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
150 extern LONGEST value_bitpos (const struct value *);
151 extern void set_value_bitpos (struct value *, LONGEST bit);
153 /* Only used for bitfields; the containing value. This allows a
154 single read from the target when displaying multiple
157 struct value *value_parent (const struct value *);
158 extern void set_value_parent (struct value *value, struct value *parent);
160 /* Describes offset of a value within lval of a structure in bytes.
161 If lval == lval_memory, this is an offset to the address. If lval
162 == lval_register, this is a further offset from location.address
163 within the registers structure. Note also the member
164 embedded_offset below. */
166 extern LONGEST value_offset (const struct value *);
167 extern void set_value_offset (struct value *, LONGEST offset);
169 /* The comment from "struct value" reads: ``Is it modifiable? Only
170 relevant if lval != not_lval.''. Shouldn't the value instead be
171 not_lval and be done with it? */
173 extern int deprecated_value_modifiable (const struct value *value);
175 /* If a value represents a C++ object, then the `type' field gives the
176 object's compile-time type. If the object actually belongs to some
177 class derived from `type', perhaps with other base classes and
178 additional members, then `type' is just a subobject of the real
179 thing, and the full object is probably larger than `type' would
182 If `type' is a dynamic class (i.e. one with a vtable), then GDB can
183 actually determine the object's run-time type by looking at the
184 run-time type information in the vtable. When this information is
185 available, we may elect to read in the entire object, for several
188 - When printing the value, the user would probably rather see the
189 full object, not just the limited portion apparent from the
192 - If `type' has virtual base classes, then even printing `type'
193 alone may require reaching outside the `type' portion of the
194 object to wherever the virtual base class has been stored.
196 When we store the entire object, `enclosing_type' is the run-time
197 type -- the complete object -- and `embedded_offset' is the offset
198 of `type' within that larger type, in bytes. The value_contents()
199 macro takes `embedded_offset' into account, so most GDB code
200 continues to see the `type' portion of the value, just as the
203 If `type' is a pointer to an object, then `enclosing_type' is a
204 pointer to the object's run-time type, and `pointed_to_offset' is
205 the offset in bytes from the full object to the pointed-to object
206 -- that is, the value `embedded_offset' would have if we followed
207 the pointer and fetched the complete object. (I don't really see
208 the point. Why not just determine the run-time type when you
209 indirect, and avoid the special case? The contents don't matter
210 until you indirect anyway.)
212 If we're not doing anything fancy, `enclosing_type' is equal to
213 `type', and `embedded_offset' is zero, so everything works
216 extern struct type *value_enclosing_type (const struct value *);
217 extern void set_value_enclosing_type (struct value *val,
218 struct type *new_type);
220 /* Returns value_type or value_enclosing_type depending on
221 value_print_options.objectprint.
223 If RESOLVE_SIMPLE_TYPES is 0 the enclosing type will be resolved
224 only for pointers and references, else it will be returned
225 for all the types (e.g. structures). This option is useful
226 to prevent retrieving enclosing type for the base classes fields.
228 REAL_TYPE_FOUND is used to inform whether the real type was found
229 (or just static type was used). The NULL may be passed if it is not
232 extern struct type *value_actual_type (struct value *value,
233 int resolve_simple_types,
234 int *real_type_found);
236 extern LONGEST value_pointed_to_offset (const struct value *value);
237 extern void set_value_pointed_to_offset (struct value *value, LONGEST val);
238 extern LONGEST value_embedded_offset (const struct value *value);
239 extern void set_value_embedded_offset (struct value *value, LONGEST val);
241 /* For lval_computed values, this structure holds functions used to
242 retrieve and set the value (or portions of the value).
244 For each function, 'V' is the 'this' pointer: an lval_funcs
245 function F may always assume that the V it receives is an
246 lval_computed value, and has F in the appropriate slot of its
247 lval_funcs structure. */
251 /* Fill in VALUE's contents. This is used to "un-lazy" values. If
252 a problem arises in obtaining VALUE's bits, this function should
253 call 'error'. If it is NULL value_fetch_lazy on "un-lazy"
254 non-optimized-out value is an internal error. */
255 void (*read) (struct value *v);
257 /* Handle an assignment TOVAL = FROMVAL by writing the value of
258 FROMVAL to TOVAL's location. The contents of TOVAL have not yet
259 been updated. If a problem arises in doing so, this function
260 should call 'error'. If it is NULL such TOVAL assignment is an error as
261 TOVAL is not considered as an lvalue. */
262 void (*write) (struct value *toval, struct value *fromval);
264 /* If non-NULL, this is used to implement pointer indirection for
265 this value. This method may return NULL, in which case value_ind
266 will fall back to ordinary indirection. */
267 struct value *(*indirect) (struct value *value);
269 /* If non-NULL, this is used to implement reference resolving for
270 this value. This method may return NULL, in which case coerce_ref
271 will fall back to ordinary references resolving. */
272 struct value *(*coerce_ref) (const struct value *value);
274 /* If non-NULL, this is used to determine whether the indicated bits
275 of VALUE are a synthetic pointer. */
276 int (*check_synthetic_pointer) (const struct value *value,
277 LONGEST offset, int length);
279 /* Return a duplicate of VALUE's closure, for use in a new value.
280 This may simply return the same closure, if VALUE's is
281 reference-counted or statically allocated.
283 This may be NULL, in which case VALUE's closure is re-used in the
285 void *(*copy_closure) (const struct value *v);
287 /* Drop VALUE's reference to its closure. Maybe this frees the
288 closure; maybe this decrements a reference count; maybe the
289 closure is statically allocated and this does nothing.
291 This may be NULL, in which case no action is taken to free
293 void (*free_closure) (struct value *v);
296 /* Create a computed lvalue, with type TYPE, function pointers FUNCS,
297 and closure CLOSURE. */
299 extern struct value *allocate_computed_value (struct type *type,
300 const struct lval_funcs *funcs,
303 /* Helper function to check the validity of some bits of a value.
305 If TYPE represents some aggregate type (e.g., a structure), return 1.
307 Otherwise, any of the bytes starting at OFFSET and extending for
308 TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
309 return 0. The checking is done using FUNCS.
311 Otherwise, return 1. */
313 extern int valprint_check_validity (struct ui_file *stream, struct type *type,
314 LONGEST embedded_offset,
315 const struct value *val);
317 extern struct value *allocate_optimized_out_value (struct type *type);
319 /* If VALUE is lval_computed, return its lval_funcs structure. */
321 extern const struct lval_funcs *value_computed_funcs (const struct value *);
323 /* If VALUE is lval_computed, return its closure. The meaning of the
324 returned value depends on the functions VALUE uses. */
326 extern void *value_computed_closure (const struct value *value);
328 /* If zero, contents of this value are in the contents field. If
329 nonzero, contents are in inferior. If the lval field is lval_memory,
330 the contents are in inferior memory at location.address plus offset.
331 The lval field may also be lval_register.
333 WARNING: This field is used by the code which handles watchpoints
334 (see breakpoint.c) to decide whether a particular value can be
335 watched by hardware watchpoints. If the lazy flag is set for some
336 member of a value chain, it is assumed that this member of the
337 chain doesn't need to be watched as part of watching the value
338 itself. This is how GDB avoids watching the entire struct or array
339 when the user wants to watch a single struct member or array
340 element. If you ever change the way lazy flag is set and reset, be
341 sure to consider this use as well! */
343 extern int value_lazy (const struct value *);
344 extern void set_value_lazy (struct value *value, int val);
346 extern int value_stack (const struct value *);
347 extern void set_value_stack (struct value *value, int val);
349 /* Throw an error complaining that the value has been optimized
352 extern void error_value_optimized_out (void);
354 /* value_contents() and value_contents_raw() both return the address
355 of the gdb buffer used to hold a copy of the contents of the lval.
356 value_contents() is used when the contents of the buffer are needed
357 -- it uses value_fetch_lazy() to load the buffer from the process
358 being debugged if it hasn't already been loaded
359 (value_contents_writeable() is used when a writeable but fetched
360 buffer is required).. value_contents_raw() is used when data is
361 being stored into the buffer, or when it is certain that the
362 contents of the buffer are valid.
364 Note: The contents pointer is adjusted by the offset required to
365 get to the real subobject, if the value happens to represent
366 something embedded in a larger run-time object. */
368 extern gdb_byte *value_contents_raw (struct value *);
370 /* Actual contents of the value. For use of this value; setting it
371 uses the stuff above. Not valid if lazy is nonzero. Target
372 byte-order. We force it to be aligned properly for any possible
373 value. Note that a value therefore extends beyond what is
376 extern const gdb_byte *value_contents (struct value *);
377 extern gdb_byte *value_contents_writeable (struct value *);
379 /* The ALL variants of the above two macros do not adjust the returned
380 pointer by the embedded_offset value. */
382 extern gdb_byte *value_contents_all_raw (struct value *);
383 extern const gdb_byte *value_contents_all (struct value *);
385 /* Like value_contents_all, but does not require that the returned
386 bits be valid. This should only be used in situations where you
387 plan to check the validity manually. */
388 extern const gdb_byte *value_contents_for_printing (struct value *value);
390 /* Like value_contents_for_printing, but accepts a constant value
391 pointer. Unlike value_contents_for_printing however, the pointed
392 value must _not_ be lazy. */
393 extern const gdb_byte *
394 value_contents_for_printing_const (const struct value *value);
396 extern void value_fetch_lazy (struct value *val);
398 /* If nonzero, this is the value of a variable which does not actually
399 exist in the program, at least partially. If the value is lazy,
400 this may fetch it now. */
401 extern int value_optimized_out (struct value *value);
403 /* Given a value, return true if any of the contents bits starting at
404 OFFSET and extending for LENGTH bits is optimized out, false
407 extern int value_bits_any_optimized_out (const struct value *value,
408 int bit_offset, int bit_length);
410 /* Like value_optimized_out, but return true iff the whole value is
412 extern int value_entirely_optimized_out (struct value *value);
414 /* Mark VALUE's content bytes starting at OFFSET and extending for
415 LENGTH bytes as optimized out. */
417 extern void mark_value_bytes_optimized_out (struct value *value,
418 int offset, int length);
420 /* Mark VALUE's content bits starting at OFFSET and extending for
421 LENGTH bits as optimized out. */
423 extern void mark_value_bits_optimized_out (struct value *value,
424 LONGEST offset, LONGEST length);
426 /* Set or return field indicating whether a variable is initialized or
427 not, based on debugging information supplied by the compiler.
428 1 = initialized; 0 = uninitialized. */
429 extern int value_initialized (const struct value *);
430 extern void set_value_initialized (struct value *, int);
432 /* Set COMPONENT's location as appropriate for a component of WHOLE
433 --- regardless of what kind of lvalue WHOLE is. */
434 extern void set_value_component_location (struct value *component,
435 const struct value *whole);
437 /* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
438 single value might have multiple LVALs), this hacked interface is
439 limited to just the first PIECE. Expect further change. */
440 /* Type of value; either not an lval, or one of the various different
441 possible kinds of lval. */
442 extern enum lval_type *deprecated_value_lval_hack (struct value *);
443 #define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
445 /* Like VALUE_LVAL, except the parameter can be const. */
446 extern enum lval_type value_lval_const (const struct value *value);
448 /* If lval == lval_memory, return the address in the inferior. If
449 lval == lval_register, return the byte offset into the registers
450 structure. Otherwise, return 0. The returned address
451 includes the offset, if any. */
452 extern CORE_ADDR value_address (const struct value *);
454 /* Like value_address, except the result does not include value's
456 extern CORE_ADDR value_raw_address (const struct value *);
458 /* Set the address of a value. */
459 extern void set_value_address (struct value *, CORE_ADDR);
461 /* Pointer to internal variable. */
462 extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
463 #define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))
465 /* Frame ID of "next" frame to which a register value is relative. A
466 register value is indicated by VALUE_LVAL being set to lval_register.
467 So, if the register value is found relative to frame F, then the
468 frame id of F->next will be stored in VALUE_NEXT_FRAME_ID. */
469 extern struct frame_id *deprecated_value_next_frame_id_hack (struct value *);
470 #define VALUE_NEXT_FRAME_ID(val) (*deprecated_value_next_frame_id_hack (val))
472 /* Frame ID of frame to which a register value is relative. This is
473 similar to VALUE_NEXT_FRAME_ID, above, but may not be assigned to.
474 Note that VALUE_FRAME_ID effectively undoes the "next" operation
475 that was performed during the assignment to VALUE_NEXT_FRAME_ID. */
476 #define VALUE_FRAME_ID(val) (get_prev_frame_id_by_id (VALUE_NEXT_FRAME_ID (val)))
478 /* Register number if the value is from a register. */
479 extern int *deprecated_value_regnum_hack (struct value *);
480 #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
482 /* Return value after lval_funcs->coerce_ref (after check_typedef). Return
483 NULL if lval_funcs->coerce_ref is not applicable for whatever reason. */
485 extern struct value *coerce_ref_if_computed (const struct value *arg);
487 /* Setup a new value type and enclosing value type for dereferenced value VALUE.
488 ENC_TYPE is the new enclosing type that should be set. ORIGINAL_TYPE and
489 ORIGINAL_VAL are the type and value of the original reference or pointer.
491 Note, that VALUE is modified by this function.
493 It is a common implementation for coerce_ref and value_ind. */
495 extern struct value * readjust_indirect_value_type (struct value *value,
496 struct type *enc_type,
497 const struct type *original_type,
498 const struct value *original_val);
500 /* Convert a REF to the object referenced. */
502 extern struct value *coerce_ref (struct value *value);
504 /* If ARG is an array, convert it to a pointer.
505 If ARG is a function, convert it to a function pointer.
507 References are dereferenced. */
509 extern struct value *coerce_array (struct value *value);
511 /* Given a value, determine whether the bits starting at OFFSET and
512 extending for LENGTH bits are a synthetic pointer. */
514 extern int value_bits_synthetic_pointer (const struct value *value,
515 LONGEST offset, LONGEST length);
517 /* Given a value, determine whether the contents bytes starting at
518 OFFSET and extending for LENGTH bytes are available. This returns
519 nonzero if all bytes in the given range are available, zero if any
520 byte is unavailable. */
522 extern int value_bytes_available (const struct value *value,
523 LONGEST offset, LONGEST length);
525 /* Given a value, determine whether the contents bits starting at
526 OFFSET and extending for LENGTH bits are available. This returns
527 nonzero if all bits in the given range are available, zero if any
528 bit is unavailable. */
530 extern int value_bits_available (const struct value *value,
531 LONGEST offset, LONGEST length);
533 /* Like value_bytes_available, but return false if any byte in the
534 whole object is unavailable. */
535 extern int value_entirely_available (struct value *value);
537 /* Like value_entirely_available, but return false if any byte in the
538 whole object is available. */
539 extern int value_entirely_unavailable (struct value *value);
541 /* Mark VALUE's content bytes starting at OFFSET and extending for
542 LENGTH bytes as unavailable. */
544 extern void mark_value_bytes_unavailable (struct value *value,
545 LONGEST offset, LONGEST length);
547 /* Mark VALUE's content bits starting at OFFSET and extending for
548 LENGTH bits as unavailable. */
550 extern void mark_value_bits_unavailable (struct value *value,
551 LONGEST offset, LONGEST length);
553 /* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
554 LENGTH bytes of VAL2's contents starting at OFFSET2.
556 Note that "contents" refers to the whole value's contents
557 (value_contents_all), without any embedded offset adjustment. For
558 example, to compare a complete object value with itself, including
559 its enclosing type chunk, you'd do:
561 int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
562 value_contents_eq (val, 0, val, 0, len);
564 Returns true iff the set of available/valid contents match.
566 Optimized-out contents are equal to optimized-out contents, and are
567 not equal to non-optimized-out contents.
569 Unavailable contente are equal to unavailable contents, and are not
570 equal to non-unavailable contents.
572 For example, if 'x's represent an unavailable byte, and 'V' and 'Z'
573 represent different available/valid bytes, in a value with length
577 contents: xxxxVVVVxxxxVVZZ
581 value_contents_eq(val, 0, val, 8, 6) => true
582 value_contents_eq(val, 0, val, 4, 4) => false
583 value_contents_eq(val, 0, val, 8, 8) => false
584 value_contents_eq(val, 4, val, 12, 2) => true
585 value_contents_eq(val, 4, val, 12, 4) => true
586 value_contents_eq(val, 3, val, 4, 4) => true
588 If 'x's represent an unavailable byte, 'o' represents an optimized
589 out byte, in a value with length 8:
596 value_contents_eq(val, 0, val, 2, 2) => true
597 value_contents_eq(val, 4, val, 6, 2) => true
598 value_contents_eq(val, 0, val, 4, 4) => true
600 We only know whether a value chunk is unavailable or optimized out
601 if we've tried to read it. As this routine is used by printing
602 routines, which may be printing values in the value history, long
603 after the inferior is gone, it works with const values. Therefore,
604 this routine must not be called with lazy values. */
606 extern bool value_contents_eq (const struct value *val1, LONGEST offset1,
607 const struct value *val2, LONGEST offset2,
610 /* Read LENGTH addressable memory units starting at MEMADDR into BUFFER,
611 which is (or will be copied to) VAL's contents buffer offset by
612 BIT_OFFSET bits. Marks value contents ranges as unavailable if
613 the corresponding memory is likewise unavailable. STACK indicates
614 whether the memory is known to be stack memory. */
616 extern void read_value_memory (struct value *val, LONGEST bit_offset,
617 int stack, CORE_ADDR memaddr,
618 gdb_byte *buffer, size_t length);
620 /* Cast SCALAR_VALUE to the element type of VECTOR_TYPE, then replicate
621 into each element of a new vector value with VECTOR_TYPE. */
623 struct value *value_vector_widen (struct value *scalar_value,
624 struct type *vector_type);
629 #include "gdbtypes.h"
630 #include "expression.h"
635 extern int print_address_demangle (const struct value_print_options *,
636 struct gdbarch *, CORE_ADDR,
637 struct ui_file *, int);
639 /* Returns true if VAL is of floating-point type. In addition,
640 throws an error if the value is an invalid floating-point value. */
641 extern bool is_floating_value (struct value *val);
643 extern LONGEST value_as_long (struct value *val);
644 extern CORE_ADDR value_as_address (struct value *val);
646 extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
647 extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
649 extern LONGEST unpack_field_as_long (struct type *type,
650 const gdb_byte *valaddr,
652 extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
653 LONGEST embedded_offset, int fieldno,
654 const struct value *val, LONGEST *result);
656 extern void unpack_value_bitfield (struct value *dest_val,
657 LONGEST bitpos, LONGEST bitsize,
658 const gdb_byte *valaddr,
659 LONGEST embedded_offset,
660 const struct value *val);
662 extern struct value *value_field_bitfield (struct type *type, int fieldno,
663 const gdb_byte *valaddr,
664 LONGEST embedded_offset,
665 const struct value *val);
667 extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
669 extern struct value *value_from_longest (struct type *type, LONGEST num);
670 extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
671 extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
672 extern struct value *value_from_history_ref (const char *, const char **);
673 extern struct value *value_from_component (struct value *, struct type *,
676 extern struct value *value_at (struct type *type, CORE_ADDR addr);
677 extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
679 extern struct value *value_from_contents_and_address_unresolved
680 (struct type *, const gdb_byte *, CORE_ADDR);
681 extern struct value *value_from_contents_and_address (struct type *,
684 extern struct value *value_from_contents (struct type *, const gdb_byte *);
686 extern struct value *default_value_from_register (struct gdbarch *gdbarch,
689 struct frame_id frame_id);
691 extern void read_frame_register_value (struct value *value,
692 struct frame_info *frame);
694 extern struct value *value_from_register (struct type *type, int regnum,
695 struct frame_info *frame);
697 extern CORE_ADDR address_from_register (int regnum,
698 struct frame_info *frame);
700 extern struct value *value_of_variable (struct symbol *var,
701 const struct block *b);
703 extern struct value *address_of_variable (struct symbol *var,
704 const struct block *b);
706 extern struct value *value_of_register (int regnum, struct frame_info *frame);
708 struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
710 /* Return the symbol's reading requirement. */
712 extern enum symbol_needs_kind symbol_read_needs (struct symbol *);
714 /* Return true if the symbol needs a frame. This is a wrapper for
715 symbol_read_needs that simply checks for SYMBOL_NEEDS_FRAME. */
717 extern int symbol_read_needs_frame (struct symbol *);
719 extern struct value *read_var_value (struct symbol *var,
720 const struct block *var_block,
721 struct frame_info *frame);
723 extern struct value *default_read_var_value (struct symbol *var,
724 const struct block *var_block,
725 struct frame_info *frame);
727 extern struct value *allocate_value (struct type *type);
728 extern struct value *allocate_value_lazy (struct type *type);
729 extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
730 struct value *src, LONGEST src_offset,
732 extern void value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
733 struct value *src, LONGEST src_offset,
736 extern struct value *allocate_repeat_value (struct type *type, int count);
738 extern struct value *value_mark (void);
740 extern void value_free_to_mark (const struct value *mark);
742 /* A helper class that uses value_mark at construction time and calls
743 value_free_to_mark in the destructor. This is used to clear out
744 temporary values created during the lifetime of this object. */
745 class scoped_value_mark
750 : m_value (value_mark ())
754 ~scoped_value_mark ()
759 scoped_value_mark (scoped_value_mark &&other) = default;
761 DISABLE_COPY_AND_ASSIGN (scoped_value_mark);
763 /* Free the values currently on the value stack. */
768 value_free_to_mark (m_value);
775 const struct value *m_value;
778 extern struct value *value_cstring (const char *ptr, ssize_t len,
779 struct type *char_type);
780 extern struct value *value_string (const char *ptr, ssize_t len,
781 struct type *char_type);
783 extern struct value *value_array (int lowbound, int highbound,
784 struct value **elemvec);
786 extern struct value *value_concat (struct value *arg1, struct value *arg2);
788 extern struct value *value_binop (struct value *arg1, struct value *arg2,
791 extern struct value *value_ptradd (struct value *arg1, LONGEST arg2);
793 extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2);
795 extern int value_must_coerce_to_target (struct value *arg1);
797 extern struct value *value_coerce_to_target (struct value *arg1);
799 extern struct value *value_coerce_array (struct value *arg1);
801 extern struct value *value_coerce_function (struct value *arg1);
803 extern struct value *value_ind (struct value *arg1);
805 extern struct value *value_addr (struct value *arg1);
807 extern struct value *value_ref (struct value *arg1, enum type_code refcode);
809 extern struct value *value_assign (struct value *toval,
810 struct value *fromval);
812 extern struct value *value_pos (struct value *arg1);
814 extern struct value *value_neg (struct value *arg1);
816 extern struct value *value_complement (struct value *arg1);
818 extern struct value *value_struct_elt (struct value **argp,
820 const char *name, int *static_memfuncp,
823 extern struct value *value_struct_elt_bitpos (struct value **argp,
825 struct type *field_type,
828 extern struct value *value_aggregate_elt (struct type *curtype,
830 struct type *expect_type,
834 extern struct value *value_static_field (struct type *type, int fieldno);
836 enum oload_search_type { NON_METHOD, METHOD, BOTH };
838 extern int find_overload_match (struct value **args, int nargs,
840 enum oload_search_type method,
841 struct value **objp, struct symbol *fsym,
842 struct value **valp, struct symbol **symp,
843 int *staticp, const int no_adl,
846 extern struct value *value_field (struct value *arg1, int fieldno);
848 extern struct value *value_primitive_field (struct value *arg1, LONGEST offset,
850 struct type *arg_type);
853 extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
856 extern struct value *value_full_object (struct value *, struct type *, int,
859 extern struct value *value_cast_pointers (struct type *, struct value *, int);
861 extern struct value *value_cast (struct type *type, struct value *arg2);
863 extern struct value *value_reinterpret_cast (struct type *type,
866 extern struct value *value_dynamic_cast (struct type *type, struct value *arg);
868 extern struct value *value_zero (struct type *type, enum lval_type lv);
870 extern struct value *value_one (struct type *type);
872 extern struct value *value_repeat (struct value *arg1, int count);
874 extern struct value *value_subscript (struct value *array, LONGEST index);
876 extern struct value *value_bitstring_subscript (struct type *type,
877 struct value *bitstring,
880 extern struct value *register_value_being_returned (struct type *valtype,
881 struct regcache *retbuf);
883 extern int value_in (struct value *element, struct value *set);
885 extern int value_bit_index (struct type *type, const gdb_byte *addr,
888 extern enum return_value_convention
889 struct_return_convention (struct gdbarch *gdbarch, struct value *function,
890 struct type *value_type);
892 extern int using_struct_return (struct gdbarch *gdbarch,
893 struct value *function,
894 struct type *value_type);
896 extern struct value *evaluate_expression (struct expression *exp);
898 extern struct value *evaluate_type (struct expression *exp);
900 extern struct value *evaluate_subexp (struct type *expect_type,
901 struct expression *exp,
902 int *pos, enum noside noside);
904 extern struct value *evaluate_subexpression_type (struct expression *exp,
907 extern value *evaluate_var_value (enum noside noside, const block *blk,
910 extern value *evaluate_var_msym_value (enum noside noside,
911 struct objfile *objfile,
912 minimal_symbol *msymbol);
914 extern value *eval_skip_value (expression *exp);
916 extern void fetch_subexp_value (struct expression *exp, int *pc,
917 struct value **valp, struct value **resultp,
918 struct value **val_chain,
919 int preserve_errors);
921 extern const char *extract_field_op (struct expression *exp, int *subexp);
923 extern struct value *evaluate_subexp_with_coercion (struct expression *,
926 extern struct value *parse_and_eval (const char *exp);
928 extern struct value *parse_to_comma_and_eval (const char **expp);
930 extern struct type *parse_and_eval_type (char *p, int length);
932 extern CORE_ADDR parse_and_eval_address (const char *exp);
934 extern LONGEST parse_and_eval_long (const char *exp);
936 extern void unop_promote (const struct language_defn *language,
937 struct gdbarch *gdbarch,
938 struct value **arg1);
940 extern void binop_promote (const struct language_defn *language,
941 struct gdbarch *gdbarch,
942 struct value **arg1, struct value **arg2);
944 extern struct value *access_value_history (int num);
946 extern struct value *value_of_internalvar (struct gdbarch *gdbarch,
947 struct internalvar *var);
949 extern int get_internalvar_integer (struct internalvar *var, LONGEST *l);
951 extern void set_internalvar (struct internalvar *var, struct value *val);
953 extern void set_internalvar_integer (struct internalvar *var, LONGEST l);
955 extern void set_internalvar_string (struct internalvar *var,
958 extern void clear_internalvar (struct internalvar *var);
960 extern void set_internalvar_component (struct internalvar *var,
962 LONGEST bitpos, LONGEST bitsize,
963 struct value *newvalue);
965 extern struct internalvar *lookup_only_internalvar (const char *name);
967 extern struct internalvar *create_internalvar (const char *name);
969 extern void complete_internalvar (completion_tracker &tracker,
972 /* An internalvar can be dynamically computed by supplying a vector of
973 function pointers to perform various operations. */
975 struct internalvar_funcs
977 /* Compute the value of the variable. The DATA argument passed to
978 the function is the same argument that was passed to
979 `create_internalvar_type_lazy'. */
981 struct value *(*make_value) (struct gdbarch *arch,
982 struct internalvar *var,
985 /* Update the agent expression EXPR with bytecode to compute the
986 value. VALUE is the agent value we are updating. The DATA
987 argument passed to this function is the same argument that was
988 passed to `create_internalvar_type_lazy'. If this pointer is
989 NULL, then the internalvar cannot be compiled to an agent
992 void (*compile_to_ax) (struct internalvar *var,
993 struct agent_expr *expr,
994 struct axs_value *value,
997 /* If non-NULL, this is called to destroy DATA. The DATA argument
998 passed to this function is the same argument that was passed to
999 `create_internalvar_type_lazy'. */
1001 void (*destroy) (void *data);
1004 extern struct internalvar *create_internalvar_type_lazy (const char *name,
1005 const struct internalvar_funcs *funcs,
1008 /* Compile an internal variable to an agent expression. VAR is the
1009 variable to compile; EXPR and VALUE are the agent expression we are
1010 updating. This will return 0 if there is no known way to compile
1011 VAR, and 1 if VAR was successfully compiled. It may also throw an
1012 exception on error. */
1014 extern int compile_internalvar_to_ax (struct internalvar *var,
1015 struct agent_expr *expr,
1016 struct axs_value *value);
1018 extern struct internalvar *lookup_internalvar (const char *name);
1020 extern int value_equal (struct value *arg1, struct value *arg2);
1022 extern int value_equal_contents (struct value *arg1, struct value *arg2);
1024 extern int value_less (struct value *arg1, struct value *arg2);
1026 extern int value_logical_not (struct value *arg1);
1030 extern struct value *value_of_this (const struct language_defn *lang);
1032 extern struct value *value_of_this_silent (const struct language_defn *lang);
1034 extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
1036 enum exp_opcode otherop,
1037 enum noside noside);
1039 extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
1040 enum noside noside);
1042 extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
1043 int j, struct type *type, LONGEST offset);
1045 extern int binop_types_user_defined_p (enum exp_opcode op,
1047 struct type *type2);
1049 extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
1050 struct value *arg2);
1052 extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
1054 extern int destructor_name_p (const char *name, struct type *type);
1056 extern void free_value_chain (struct value *v);
1058 extern value_ref_ptr release_value (struct value *val);
1060 extern int record_latest_value (struct value *val);
1062 extern void modify_field (struct type *type, gdb_byte *addr,
1063 LONGEST fieldval, LONGEST bitpos, LONGEST bitsize);
1065 extern void type_print (struct type *type, const char *varstring,
1066 struct ui_file *stream, int show);
1068 extern std::string type_to_string (struct type *type);
1070 extern gdb_byte *baseclass_addr (struct type *type, int index,
1072 struct value **valuep, int *errp);
1074 extern void print_longest (struct ui_file *stream, int format,
1075 int use_local, LONGEST val);
1077 extern void print_floating (const gdb_byte *valaddr, struct type *type,
1078 struct ui_file *stream);
1080 extern void value_print (struct value *val, struct ui_file *stream,
1081 const struct value_print_options *options);
1083 extern void value_print_array_elements (struct value *val,
1084 struct ui_file *stream, int format,
1085 enum val_prettyformat pretty);
1087 extern struct value *value_release_to_mark (const struct value *mark);
1089 extern void val_print (struct type *type,
1090 LONGEST embedded_offset, CORE_ADDR address,
1091 struct ui_file *stream, int recurse,
1093 const struct value_print_options *options,
1094 const struct language_defn *language);
1096 extern void common_val_print (struct value *val,
1097 struct ui_file *stream, int recurse,
1098 const struct value_print_options *options,
1099 const struct language_defn *language);
1101 extern int val_print_string (struct type *elttype, const char *encoding,
1102 CORE_ADDR addr, int len,
1103 struct ui_file *stream,
1104 const struct value_print_options *options);
1106 extern void print_variable_and_value (const char *name,
1108 struct frame_info *frame,
1109 struct ui_file *stream,
1112 extern void typedef_print (struct type *type, struct symbol *news,
1113 struct ui_file *stream);
1115 extern char *internalvar_name (const struct internalvar *var);
1117 extern void preserve_values (struct objfile *);
1121 extern struct value *value_copy (struct value *);
1123 extern struct value *value_non_lval (struct value *);
1125 extern void value_force_lval (struct value *, CORE_ADDR);
1127 extern struct value *make_cv_value (int, int, struct value *);
1129 extern void preserve_one_value (struct value *, struct objfile *, htab_t);
1133 extern struct value *varying_to_slice (struct value *);
1135 extern struct value *value_slice (struct value *, int, int);
1137 extern struct value *value_literal_complex (struct value *, struct value *,
1140 extern struct value *find_function_in_inferior (const char *,
1143 extern struct value *value_allocate_space_in_inferior (int);
1145 extern struct value *value_subscripted_rvalue (struct value *array,
1146 LONGEST index, int lowerbound);
1148 /* User function handler. */
1150 typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
1151 const struct language_defn *language,
1154 struct value **argv);
1156 void add_internal_function (const char *name, const char *doc,
1157 internal_function_fn handler,
1160 struct value *call_internal_function (struct gdbarch *gdbarch,
1161 const struct language_defn *language,
1162 struct value *function,
1163 int argc, struct value **argv);
1165 char *value_internal_function_name (struct value *);
1167 /* Build a value wrapping and representing WORKER. The value takes ownership
1168 of the xmethod_worker object. */
1170 extern struct value *value_from_xmethod (xmethod_worker_up &&worker);
1172 extern struct type *result_type_of_xmethod (struct value *method,
1173 int argc, struct value **argv);
1175 extern struct value *call_xmethod (struct value *method,
1176 int argc, struct value **argv);
1178 /* Given a discriminated union type and some corresponding value
1179 contents, this will return the field index of the currently active
1180 variant. This will throw an exception if no active variant can be
1183 extern int value_union_variant (struct type *union_type,
1184 const gdb_byte *contents);
1186 #endif /* !defined (VALUE_H) */