extern bool overload_resolution;
-/* The structure which defines the type of a value. It should never
- be possible for a program lval value to survive over a call to the
- inferior (i.e. to be put into the history list or an internal
- variable). */
+/* Defines an [OFFSET, OFFSET + LENGTH) range. */
-struct value;
+struct range
+{
+ /* Lowest offset in the range. */
+ LONGEST offset;
+
+ /* Length of the range. */
+ ULONGEST length;
+
+ /* Returns true if THIS is strictly less than OTHER, useful for
+ searching. We keep ranges sorted by offset and coalesce
+ overlapping and contiguous ranges, so this just compares the
+ starting offset. */
+
+ bool operator< (const range &other) const
+ {
+ return offset < other.offset;
+ }
+
+ /* Returns true if THIS is equal to OTHER. */
+ bool operator== (const range &other) const
+ {
+ return offset == other.offset && length == other.length;
+ }
+};
/* Increase VAL's reference count. */
typedef gdb::ref_ptr<struct value, value_ref_policy> value_ref_ptr;
-/* Values are stored in a chain, so that they can be deleted easily
- over calls to the inferior. Values assigned to internal variables,
- put into the value history or exposed to Python are taken off this
- list. */
+/* Note that the fields in this structure are arranged to save a bit
+ of memory. */
+
+struct value
+{
+private:
+
+ /* Values can only be created via "static constructors". */
+ explicit value (struct type *type_)
+ : m_modifiable (1),
+ m_lazy (1),
+ m_initialized (1),
+ m_stack (0),
+ m_is_zero (false),
+ m_in_history (false),
+ m_type (type_),
+ m_enclosing_type (type_)
+ {
+ }
+
+public:
+
+ /* Allocate a lazy value for type TYPE. Its actual content is
+ "lazily" allocated too: the content field of the return value is
+ NULL; it will be allocated when it is fetched from the target. */
+ static struct value *allocate_lazy (struct type *type);
+
+ /* Allocate a value and its contents for type TYPE. */
+ static struct value *allocate (struct type *type);
+
+ /* Create a computed lvalue, with type TYPE, function pointers
+ FUNCS, and closure CLOSURE. */
+ static struct value *allocate_computed (struct type *type,
+ const struct lval_funcs *funcs,
+ void *closure);
+
+ ~value ();
+
+ DISABLE_COPY_AND_ASSIGN (value);
+
+ /* Type of the value. */
+ struct type *type () const
+ { return m_type; }
+
+ /* This is being used to change the type of an existing value, that
+ code should instead be creating a new value with the changed type
+ (but possibly shared content). */
+ void deprecated_set_type (struct type *type)
+ { m_type = type; }
+
+ /* Return the gdbarch associated with the value. */
+ struct gdbarch *arch () const;
+
+ /* Only used for bitfields; number of bits contained in them. */
+ LONGEST bitsize () const
+ { return m_bitsize; }
+
+ void set_bitsize (LONGEST bit)
+ { m_bitsize = bit; }
+
+ /* Only used for bitfields; position of start of field. For
+ little-endian targets, it is the position of the LSB. For
+ big-endian targets, it is the position of the MSB. */
+ LONGEST bitpos () const
+ { return m_bitpos; }
+
+ void set_bitpos (LONGEST bit)
+ { m_bitpos = bit; }
+
+ /* Only used for bitfields; the containing value. This allows a
+ single read from the target when displaying multiple
+ bitfields. */
+ value *parent () const
+ { return m_parent.get (); }
+
+ void set_parent (struct value *parent)
+ { m_parent = value_ref_ptr::new_reference (parent); }
+
+ /* Describes offset of a value within lval of a structure in bytes.
+ If lval == lval_memory, this is an offset to the address. If
+ lval == lval_register, this is a further offset from
+ location.address within the registers structure. Note also the
+ member embedded_offset below. */
+ LONGEST offset () const
+ { return m_offset; }
+
+ void set_offset (LONGEST offset)
+ { m_offset = offset; }
+
+ /* The comment from "struct value" reads: ``Is it modifiable? Only
+ relevant if lval != not_lval.''. Shouldn't the value instead be
+ not_lval and be done with it? */
+ int deprecated_modifiable () const
+ { return m_modifiable; }
+
+ LONGEST pointed_to_offset () const
+ { return m_pointed_to_offset; }
+
+ void set_pointed_to_offset (LONGEST val)
+ { m_pointed_to_offset = val; }
+
+ LONGEST embedded_offset () const
+ { return m_embedded_offset; }
+
+ void set_embedded_offset (LONGEST val)
+ { m_embedded_offset = val; }
+
+ /* If zero, contents of this value are in the contents field. If
+ nonzero, contents are in inferior. If the lval field is lval_memory,
+ the contents are in inferior memory at location.address plus offset.
+ The lval field may also be lval_register.
+
+ WARNING: This field is used by the code which handles watchpoints
+ (see breakpoint.c) to decide whether a particular value can be
+ watched by hardware watchpoints. If the lazy flag is set for some
+ member of a value chain, it is assumed that this member of the
+ chain doesn't need to be watched as part of watching the value
+ itself. This is how GDB avoids watching the entire struct or array
+ when the user wants to watch a single struct member or array
+ element. If you ever change the way lazy flag is set and reset, be
+ sure to consider this use as well! */
+
+ int lazy () const
+ { return m_lazy; }
+
+ void set_lazy (int val)
+ { m_lazy = val; }
+
+
+ /* If a value represents a C++ object, then the `type' field gives the
+ object's compile-time type. If the object actually belongs to some
+ class derived from `type', perhaps with other base classes and
+ additional members, then `type' is just a subobject of the real
+ thing, and the full object is probably larger than `type' would
+ suggest.
+
+ If `type' is a dynamic class (i.e. one with a vtable), then GDB can
+ actually determine the object's run-time type by looking at the
+ run-time type information in the vtable. When this information is
+ available, we may elect to read in the entire object, for several
+ reasons:
+
+ - When printing the value, the user would probably rather see the
+ full object, not just the limited portion apparent from the
+ compile-time type.
+
+ - If `type' has virtual base classes, then even printing `type'
+ alone may require reaching outside the `type' portion of the
+ object to wherever the virtual base class has been stored.
+
+ When we store the entire object, `enclosing_type' is the run-time
+ type -- the complete object -- and `embedded_offset' is the offset
+ of `type' within that larger type, in bytes. The value_contents()
+ macro takes `embedded_offset' into account, so most GDB code
+ continues to see the `type' portion of the value, just as the
+ inferior would.
+
+ If `type' is a pointer to an object, then `enclosing_type' is a
+ pointer to the object's run-time type, and `pointed_to_offset' is
+ the offset in bytes from the full object to the pointed-to object
+ -- that is, the value `embedded_offset' would have if we followed
+ the pointer and fetched the complete object. (I don't really see
+ the point. Why not just determine the run-time type when you
+ indirect, and avoid the special case? The contents don't matter
+ until you indirect anyway.)
+
+ If we're not doing anything fancy, `enclosing_type' is equal to
+ `type', and `embedded_offset' is zero, so everything works
+ normally. */
+
+ struct type *enclosing_type () const
+ { return m_enclosing_type; }
+
+ void set_enclosing_type (struct type *new_type);
+
+ int stack () const
+ { return m_stack; }
-struct value *value_next (const struct value *);
+ void set_stack (int val)
+ { m_stack = val; }
-/* Type of the value. */
+ /* If this value is lval_computed, return its lval_funcs
+ structure. */
+ const struct lval_funcs *computed_funcs () const;
-extern struct type *value_type (const struct value *);
+ /* If this value is lval_computed, return its closure. The meaning
+ of the returned value depends on the functions this value
+ uses. */
+ void *computed_closure () const;
-/* Return the gdbarch associated with the value. */
+ enum lval_type *deprecated_lval_hack ()
+ { return &m_lval; }
-extern struct gdbarch *get_value_arch (const struct value *value);
+ enum lval_type lval () const
+ { return m_lval; }
-/* This is being used to change the type of an existing value, that
- code should instead be creating a new value with the changed type
- (but possibly shared content). */
+ /* Set or return field indicating whether a variable is initialized or
+ not, based on debugging information supplied by the compiler.
+ 1 = initialized; 0 = uninitialized. */
+ int initialized () const
+ { return m_initialized; }
-extern void deprecated_set_value_type (struct value *value,
- struct type *type);
+ void set_initialized (int value)
+ { m_initialized = value; }
-/* Only used for bitfields; number of bits contained in them. */
+ /* If lval == lval_memory, return the address in the inferior. If
+ lval == lval_register, return the byte offset into the registers
+ structure. Otherwise, return 0. The returned address
+ includes the offset, if any. */
+ CORE_ADDR address () const;
-extern LONGEST value_bitsize (const struct value *);
-extern void set_value_bitsize (struct value *, LONGEST bit);
+ /* Like address, except the result does not include value's
+ offset. */
+ CORE_ADDR raw_address () const;
-/* Only used for bitfields; position of start of field. For
- little-endian targets, it is the position of the LSB. For
- big-endian targets, it is the position of the MSB. */
+ /* Set the address of a value. */
+ void set_address (CORE_ADDR);
-extern LONGEST value_bitpos (const struct value *);
-extern void set_value_bitpos (struct value *, LONGEST bit);
+ struct internalvar **deprecated_internalvar_hack ()
+ { return &m_location.internalvar; }
-/* Only used for bitfields; the containing value. This allows a
- single read from the target when displaying multiple
- bitfields. */
+ struct frame_id *deprecated_next_frame_id_hack ();
-struct value *value_parent (const struct value *);
-extern void set_value_parent (struct value *value, struct value *parent);
+ int *deprecated_regnum_hack ();
-/* Describes offset of a value within lval of a structure in bytes.
- If lval == lval_memory, this is an offset to the address. If lval
- == lval_register, this is a further offset from location.address
- within the registers structure. Note also the member
- embedded_offset below. */
-extern LONGEST value_offset (const struct value *);
-extern void set_value_offset (struct value *, LONGEST offset);
+ /* Type of value; either not an lval, or one of the various
+ different possible kinds of lval. */
+ enum lval_type m_lval = not_lval;
-/* The comment from "struct value" reads: ``Is it modifiable? Only
- relevant if lval != not_lval.''. Shouldn't the value instead be
- not_lval and be done with it? */
+ /* Is it modifiable? Only relevant if lval != not_lval. */
+ unsigned int m_modifiable : 1;
-extern int deprecated_value_modifiable (const struct value *value);
+ /* If zero, contents of this value are in the contents field. If
+ nonzero, contents are in inferior. If the lval field is lval_memory,
+ the contents are in inferior memory at location.address plus offset.
+ The lval field may also be lval_register.
-/* If a value represents a C++ object, then the `type' field gives the
- object's compile-time type. If the object actually belongs to some
- class derived from `type', perhaps with other base classes and
- additional members, then `type' is just a subobject of the real
- thing, and the full object is probably larger than `type' would
- suggest.
+ WARNING: This field is used by the code which handles watchpoints
+ (see breakpoint.c) to decide whether a particular value can be
+ watched by hardware watchpoints. If the lazy flag is set for
+ some member of a value chain, it is assumed that this member of
+ the chain doesn't need to be watched as part of watching the
+ value itself. This is how GDB avoids watching the entire struct
+ or array when the user wants to watch a single struct member or
+ array element. If you ever change the way lazy flag is set and
+ reset, be sure to consider this use as well! */
+ unsigned int m_lazy : 1;
- If `type' is a dynamic class (i.e. one with a vtable), then GDB can
- actually determine the object's run-time type by looking at the
- run-time type information in the vtable. When this information is
- available, we may elect to read in the entire object, for several
- reasons:
+ /* If value is a variable, is it initialized or not. */
+ unsigned int m_initialized : 1;
- - When printing the value, the user would probably rather see the
+ /* If value is from the stack. If this is set, read_stack will be
+ used instead of read_memory to enable extra caching. */
+ unsigned int m_stack : 1;
+
+ /* True if this is a zero value, created by 'value_zero'; false
+ otherwise. */
+ bool m_is_zero : 1;
+
+ /* True if this a value recorded in value history; false otherwise. */
+ bool m_in_history : 1;
+
+ /* Location of value (if lval). */
+ union
+ {
+ /* If lval == lval_memory, this is the address in the inferior */
+ CORE_ADDR address;
+
+ /*If lval == lval_register, the value is from a register. */
+ struct
+ {
+ /* Register number. */
+ int regnum;
+ /* Frame ID of "next" frame to which a register value is relative.
+ If the register value is found relative to frame F, then the
+ frame id of F->next will be stored in next_frame_id. */
+ struct frame_id next_frame_id;
+ } reg;
+
+ /* Pointer to internal variable. */
+ struct internalvar *internalvar;
+
+ /* Pointer to xmethod worker. */
+ struct xmethod_worker *xm_worker;
+
+ /* If lval == lval_computed, this is a set of function pointers
+ to use to access and describe the value, and a closure pointer
+ for them to use. */
+ struct
+ {
+ /* Functions to call. */
+ const struct lval_funcs *funcs;
+
+ /* Closure for those functions to use. */
+ void *closure;
+ } computed;
+ } m_location {};
+
+ /* Describes offset of a value within lval of a structure in target
+ addressable memory units. Note also the member embedded_offset
+ below. */
+ LONGEST m_offset = 0;
+
+ /* Only used for bitfields; number of bits contained in them. */
+ LONGEST m_bitsize = 0;
+
+ /* Only used for bitfields; position of start of field. For
+ little-endian targets, it is the position of the LSB. For
+ big-endian targets, it is the position of the MSB. */
+ LONGEST m_bitpos = 0;
+
+ /* The number of references to this value. When a value is created,
+ the value chain holds a reference, so REFERENCE_COUNT is 1. If
+ release_value is called, this value is removed from the chain but
+ the caller of release_value now has a reference to this value.
+ The caller must arrange for a call to value_free later. */
+ int m_reference_count = 1;
+
+ /* Only used for bitfields; the containing value. This allows a
+ single read from the target when displaying multiple
+ bitfields. */
+ value_ref_ptr m_parent;
+
+ /* Type of the value. */
+ struct type *m_type;
+
+ /* If a value represents a C++ object, then the `type' field gives
+ the object's compile-time type. If the object actually belongs
+ to some class derived from `type', perhaps with other base
+ classes and additional members, then `type' is just a subobject
+ of the real thing, and the full object is probably larger than
+ `type' would suggest.
+
+ If `type' is a dynamic class (i.e. one with a vtable), then GDB
+ can actually determine the object's run-time type by looking at
+ the run-time type information in the vtable. When this
+ information is available, we may elect to read in the entire
+ object, for several reasons:
+
+ - When printing the value, the user would probably rather see the
full object, not just the limited portion apparent from the
compile-time type.
- - If `type' has virtual base classes, then even printing `type'
+ - If `type' has virtual base classes, then even printing `type'
alone may require reaching outside the `type' portion of the
object to wherever the virtual base class has been stored.
- When we store the entire object, `enclosing_type' is the run-time
- type -- the complete object -- and `embedded_offset' is the offset
- of `type' within that larger type, in bytes. The value_contents()
- macro takes `embedded_offset' into account, so most GDB code
- continues to see the `type' portion of the value, just as the
- inferior would.
-
- If `type' is a pointer to an object, then `enclosing_type' is a
- pointer to the object's run-time type, and `pointed_to_offset' is
- the offset in bytes from the full object to the pointed-to object
- -- that is, the value `embedded_offset' would have if we followed
- the pointer and fetched the complete object. (I don't really see
- the point. Why not just determine the run-time type when you
- indirect, and avoid the special case? The contents don't matter
- until you indirect anyway.)
-
- If we're not doing anything fancy, `enclosing_type' is equal to
- `type', and `embedded_offset' is zero, so everything works
- normally. */
-
-extern struct type *value_enclosing_type (const struct value *);
-extern void set_value_enclosing_type (struct value *val,
- struct type *new_type);
+ When we store the entire object, `enclosing_type' is the run-time
+ type -- the complete object -- and `embedded_offset' is the
+ offset of `type' within that larger type, in target addressable memory
+ units. The value_contents() macro takes `embedded_offset' into account,
+ so most GDB code continues to see the `type' portion of the value, just
+ as the inferior would.
+
+ If `type' is a pointer to an object, then `enclosing_type' is a
+ pointer to the object's run-time type, and `pointed_to_offset' is
+ the offset in target addressable memory units from the full object
+ to the pointed-to object -- that is, the value `embedded_offset' would
+ have if we followed the pointer and fetched the complete object.
+ (I don't really see the point. Why not just determine the
+ run-time type when you indirect, and avoid the special case? The
+ contents don't matter until you indirect anyway.)
+
+ If we're not doing anything fancy, `enclosing_type' is equal to
+ `type', and `embedded_offset' is zero, so everything works
+ normally. */
+ struct type *m_enclosing_type;
+ LONGEST m_embedded_offset = 0;
+ LONGEST m_pointed_to_offset = 0;
+
+ /* Actual contents of the value. Target byte-order.
+
+ May be nullptr if the value is lazy or is entirely optimized out.
+ Guaranteed to be non-nullptr otherwise. */
+ gdb::unique_xmalloc_ptr<gdb_byte> m_contents;
+
+ /* Unavailable ranges in CONTENTS. We mark unavailable ranges,
+ rather than available, since the common and default case is for a
+ value to be available. This is filled in at value read time.
+ The unavailable ranges are tracked in bits. Note that a contents
+ bit that has been optimized out doesn't really exist in the
+ program, so it can't be marked unavailable either. */
+ std::vector<range> m_unavailable;
+
+ /* Likewise, but for optimized out contents (a chunk of the value of
+ a variable that does not actually exist in the program). If LVAL
+ is lval_register, this is a register ($pc, $sp, etc., never a
+ program variable) that has not been saved in the frame. Not
+ saved registers and optimized-out program variables values are
+ treated pretty much the same, except not-saved registers have a
+ different string representation and related error strings. */
+ std::vector<range> m_optimized_out;
+
+ /* This is only non-zero for values of TYPE_CODE_ARRAY and if the size of
+ the array in inferior memory is greater than max_value_size. If these
+ conditions are met then, when the value is loaded from the inferior
+ GDB will only load a portion of the array into memory, and
+ limited_length will be set to indicate the length in octets that were
+ loaded from the inferior. */
+ ULONGEST m_limited_length = 0;
+
+private:
+
+ /* Allocate a value and its contents for type TYPE. If CHECK_SIZE
+ is true, then apply the usual max-value-size checks. */
+ static struct value *allocate (struct type *type, bool check_size);
+};
/* Returns value_type or value_enclosing_type depending on
value_print_options.objectprint.
int resolve_simple_types,
int *real_type_found);
-extern LONGEST value_pointed_to_offset (const struct value *value);
-extern void set_value_pointed_to_offset (struct value *value, LONGEST val);
-extern LONGEST value_embedded_offset (const struct value *value);
-extern void set_value_embedded_offset (struct value *value, LONGEST val);
-
/* For lval_computed values, this structure holds functions used to
retrieve and set the value (or portions of the value).
void (*free_closure) (struct value *v);
};
-/* Create a computed lvalue, with type TYPE, function pointers FUNCS,
- and closure CLOSURE. */
-
-extern struct value *allocate_computed_value (struct type *type,
- const struct lval_funcs *funcs,
- void *closure);
-
extern struct value *allocate_optimized_out_value (struct type *type);
-/* If VALUE is lval_computed, return its lval_funcs structure. */
-
-extern const struct lval_funcs *value_computed_funcs (const struct value *);
-
-/* If VALUE is lval_computed, return its closure. The meaning of the
- returned value depends on the functions VALUE uses. */
-
-extern void *value_computed_closure (const struct value *value);
-
-/* If zero, contents of this value are in the contents field. If
- nonzero, contents are in inferior. If the lval field is lval_memory,
- the contents are in inferior memory at location.address plus offset.
- The lval field may also be lval_register.
-
- WARNING: This field is used by the code which handles watchpoints
- (see breakpoint.c) to decide whether a particular value can be
- watched by hardware watchpoints. If the lazy flag is set for some
- member of a value chain, it is assumed that this member of the
- chain doesn't need to be watched as part of watching the value
- itself. This is how GDB avoids watching the entire struct or array
- when the user wants to watch a single struct member or array
- element. If you ever change the way lazy flag is set and reset, be
- sure to consider this use as well! */
-
-extern int value_lazy (const struct value *);
-extern void set_value_lazy (struct value *value, int val);
-
-extern int value_stack (const struct value *);
-extern void set_value_stack (struct value *value, int val);
-
/* Throw an error complaining that the value has been optimized
out. */
extern void mark_value_bits_optimized_out (struct value *value,
LONGEST offset, LONGEST length);
-/* Set or return field indicating whether a variable is initialized or
- not, based on debugging information supplied by the compiler.
- 1 = initialized; 0 = uninitialized. */
-extern int value_initialized (const struct value *);
-extern void set_value_initialized (struct value *, int);
-
/* Set COMPONENT's location as appropriate for a component of WHOLE
--- regardless of what kind of lvalue WHOLE is. */
extern void set_value_component_location (struct value *component,
limited to just the first PIECE. Expect further change. */
/* Type of value; either not an lval, or one of the various different
possible kinds of lval. */
-extern enum lval_type *deprecated_value_lval_hack (struct value *);
-#define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
-
-/* Like VALUE_LVAL, except the parameter can be const. */
-extern enum lval_type value_lval_const (const struct value *value);
-
-/* If lval == lval_memory, return the address in the inferior. If
- lval == lval_register, return the byte offset into the registers
- structure. Otherwise, return 0. The returned address
- includes the offset, if any. */
-extern CORE_ADDR value_address (const struct value *);
-
-/* Like value_address, except the result does not include value's
- offset. */
-extern CORE_ADDR value_raw_address (const struct value *);
-
-/* Set the address of a value. */
-extern void set_value_address (struct value *, CORE_ADDR);
+#define VALUE_LVAL(val) (*((val)->deprecated_lval_hack ()))
/* Pointer to internal variable. */
-extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
-#define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))
+#define VALUE_INTERNALVAR(val) (*((val)->deprecated_internalvar_hack ()))
/* Frame ID of "next" frame to which a register value is relative. A
register value is indicated by VALUE_LVAL being set to lval_register.
So, if the register value is found relative to frame F, then the
frame id of F->next will be stored in VALUE_NEXT_FRAME_ID. */
-extern struct frame_id *deprecated_value_next_frame_id_hack (struct value *);
-#define VALUE_NEXT_FRAME_ID(val) (*deprecated_value_next_frame_id_hack (val))
+#define VALUE_NEXT_FRAME_ID(val) (*((val)->deprecated_next_frame_id_hack ()))
/* Register number if the value is from a register. */
-extern int *deprecated_value_regnum_hack (struct value *);
-#define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
+#define VALUE_REGNUM(val) (*((val)->deprecated_regnum_hack ()))
/* Return value after lval_funcs->coerce_ref (after check_typedef). Return
NULL if lval_funcs->coerce_ref is not applicable for whatever reason. */
byte is unavailable. */
extern int value_bytes_available (const struct value *value,
- LONGEST offset, LONGEST length);
+ LONGEST offset, ULONGEST length);
/* Given a value, determine whether the contents bits starting at
OFFSET and extending for LENGTH bits are available. This returns
bit is unavailable. */
extern int value_bits_available (const struct value *value,
- LONGEST offset, LONGEST length);
+ LONGEST offset, ULONGEST length);
/* Like value_bytes_available, but return false if any byte in the
whole object is unavailable. */
LENGTH bytes as unavailable. */
extern void mark_value_bytes_unavailable (struct value *value,
- LONGEST offset, LONGEST length);
+ LONGEST offset, ULONGEST length);
/* Mark VALUE's content bits starting at OFFSET and extending for
LENGTH bits as unavailable. */
extern void mark_value_bits_unavailable (struct value *value,
- LONGEST offset, LONGEST length);
+ LONGEST offset, ULONGEST length);
/* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
LENGTH bytes of VAL2's contents starting at OFFSET2.
example, to compare a complete object value with itself, including
its enclosing type chunk, you'd do:
- int len = check_typedef (value_enclosing_type (val))->length ();
+ int len = check_typedef (val->enclosing_type ())->length ();
value_contents_eq (val, 0, val, 0, len);
Returns true iff the set of available/valid contents match.
extern struct value *value_at (struct type *type, CORE_ADDR addr);
extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
+/* Like value_at, but ensures that the result is marked not_lval.
+ This can be important if the memory is "volatile". */
+extern struct value *value_at_non_lval (struct type *type, CORE_ADDR addr);
+
extern struct value *value_from_contents_and_address_unresolved
(struct type *, const gdb_byte *, CORE_ADDR);
extern struct value *value_from_contents_and_address (struct type *,
const struct block *var_block,
frame_info_ptr frame);
-extern struct value *allocate_value (struct type *type);
-extern struct value *allocate_value_lazy (struct type *type);
extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
struct value *src, LONGEST src_offset,
LONGEST length);
of floating-point, fixed-point, or integer type. */
extern gdb_mpq value_to_gdb_mpq (struct value *value);
+/* While an instance of this class is live, and array values that are
+ created, that are larger than max_value_size, will be restricted in size
+ to a particular number of elements. */
+
+struct scoped_array_length_limiting
+{
+ /* Limit any large array values to only contain ELEMENTS elements. */
+ scoped_array_length_limiting (int elements);
+
+ /* Restore the previous array value limit. */
+ ~scoped_array_length_limiting ();
+
+private:
+ /* Used to hold the previous array value element limit. */
+ gdb::optional<int> m_old_value;
+};
+
#endif /* !defined (VALUE_H) */