/* 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_modifiable (true),
+ m_lazy (true),
+ m_initialized (true),
+ m_stack (false),
m_is_zero (false),
m_in_history (false),
m_type (type_),
{
}
+ /* Values can only be destroyed via the reference-counting
+ mechanism. */
+ ~value ();
+
+ DISABLE_COPY_AND_ASSIGN (value);
+
public:
/* Allocate a lazy value for type TYPE. Its actual content is
storage. */
struct value *copy () const;
- ~value ();
-
- DISABLE_COPY_AND_ASSIGN (value);
-
/* Type of the value. */
struct type *type () const
{ return m_type; }
/* 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
+ bool deprecated_modifiable () const
{ return m_modifiable; }
+ /* Set or clear the modifiable flag. */
+ void set_modifiable (bool val)
+ { m_modifiable = val; }
+
LONGEST pointed_to_offset () const
{ return m_pointed_to_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,
+ /* If false, contents of this value are in the contents field. If
+ true, 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.
element. If you ever change the way lazy flag is set and reset, be
sure to consider this use as well! */
- int lazy () const
+ bool lazy () const
{ return m_lazy; }
- void set_lazy (int val)
+ void set_lazy (bool val)
{ m_lazy = val; }
/* If a value represents a C++ object, then the `type' field gives the
void set_enclosing_type (struct type *new_type);
- int stack () const
+ bool stack () const
{ return m_stack; }
- void set_stack (int val)
+ void set_stack (bool val)
{ m_stack = val; }
/* If this value is lval_computed, return its lval_funcs
uses. */
void *computed_closure () const;
- enum lval_type *deprecated_lval_hack ()
- { return &m_lval; }
-
enum lval_type lval () const
{ return m_lval; }
+ /* Set the 'lval' of this value. */
+ void set_lval (lval_type val)
+ { m_lval = val; }
+
/* 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
+ true = initialized; false = uninitialized. */
+ bool initialized () const
{ return m_initialized; }
- void set_initialized (int value)
+ void set_initialized (bool value)
{ m_initialized = value; }
/* If lval == lval_memory, return the address in the inferior. If
/* Given a value, determine whether the bits starting at OFFSET and
extending for LENGTH bits are a synthetic pointer. */
- int bits_synthetic_pointer (LONGEST offset, LONGEST length) const;
+ bool bits_synthetic_pointer (LONGEST offset, LONGEST length) const;
/* Increase this value's reference count. */
void incref ()
/* Given a value, determine whether the contents bytes starting at
OFFSET and extending for LENGTH bytes are available. This returns
- nonzero if all bytes in the given range are available, zero if any
+ true if all bytes in the given range are available, false if any
byte is unavailable. */
- int bytes_available (LONGEST offset, ULONGEST length) const;
+ bool bytes_available (LONGEST offset, ULONGEST length) const;
/* Given a value, determine whether the contents bits starting at
OFFSET and extending for LENGTH bits are available. This returns
- nonzero if all bits in the given range are available, zero if any
+ true if all bits in the given range are available, false if any
bit is unavailable. */
- int bits_available (LONGEST offset, ULONGEST length) const;
+ bool bits_available (LONGEST offset, ULONGEST length) const;
/* Like bytes_available, but return false if any byte in the
whole object is unavailable. */
- int entirely_available ();
+ bool entirely_available ();
/* Like entirely_available, but return false if any byte in the
whole object is available. */
- int entirely_unavailable ()
+ bool entirely_unavailable ()
{ return entirely_covered_by_range_vector (m_unavailable); }
/* Mark this value's content bytes starting at OFFSET and extending
for LENGTH bits as unavailable. */
void mark_bits_unavailable (LONGEST offset, ULONGEST length);
- /* If nonzero, this is the value of a variable which does not actually
+ /* If true, this is the value of a variable which does not actually
exist in the program, at least partially. If the value is lazy,
this may fetch it now. */
- int optimized_out ();
+ bool optimized_out ();
/* Given a value, return true if any of the contents bits starting at
OFFSET and extending for LENGTH bits is optimized out, false
otherwise. */
- int bits_any_optimized_out (int bit_offset, int bit_length) const;
+ bool bits_any_optimized_out (int bit_offset, int bit_length) const;
/* Like optimized_out, but return true iff the whole value is
optimized out. */
- int entirely_optimized_out ()
+ bool entirely_optimized_out ()
{
return entirely_covered_by_range_vector (m_optimized_out);
}
for LENGTH bits as optimized out. */
void mark_bits_optimized_out (LONGEST offset, LONGEST length);
+ /* Return a version of this that is non-lvalue. */
+ struct value *non_lval ();
+
+ /* Write contents of this value at ADDR and set its lval type to be
+ LVAL_MEMORY. */
+ void force_lval (CORE_ADDR);
+
+ /* Set this values's location as appropriate for a component of
+ WHOLE --- regardless of what kind of lvalue WHOLE is. */
+ void set_component_location (const struct value *whole);
+
+ /* Build a value wrapping and representing WORKER. The value takes
+ ownership of the xmethod_worker object. */
+ static struct value *from_xmethod (xmethod_worker_up &&worker);
+
+ /* Return the type of the result of TYPE_CODE_XMETHOD value METHOD. */
+ struct type *result_type_of_xmethod (gdb::array_view<value *> argv);
+
+ /* Call the xmethod corresponding to the TYPE_CODE_XMETHOD value
+ METHOD. */
+ struct value *call_xmethod (gdb::array_view<value *> argv);
+
+ /* Update this value before discarding OBJFILE. COPIED_TYPES is
+ used to prevent cycles / duplicates. */
+ void preserve (struct objfile *objfile, htab_t copied_types);
+
+ /* Unpack a bitfield of BITSIZE bits found at BITPOS in the object
+ at VALADDR + EMBEDDEDOFFSET that has the type of DEST_VAL and
+ store the contents in DEST_VAL, zero or sign extending if the
+ type of DEST_VAL is wider than BITSIZE. VALADDR points to the
+ contents of this value. If this value's contents required to
+ extract the bitfield from are unavailable/optimized out, DEST_VAL
+ is correspondingly marked unavailable/optimized out. */
+ void unpack_bitfield (struct value *dest_val,
+ LONGEST bitpos, LONGEST bitsize,
+ const gdb_byte *valaddr, LONGEST embedded_offset)
+ const;
+
+ /* Copy LENGTH bytes of this value's (all) contents
+ (value_contents_all) starting at SRC_OFFSET byte, into DST
+ value's (all) contents, starting at DST_OFFSET. If unavailable
+ contents are being copied from this value, the corresponding DST
+ contents are marked unavailable accordingly. DST must not be
+ lazy. If this value is lazy, it will be fetched now.
+
+ It is assumed the contents of DST in the [DST_OFFSET,
+ DST_OFFSET+LENGTH) range are wholly available. */
+ void contents_copy (struct value *dst, LONGEST dst_offset,
+ LONGEST src_offset, LONGEST length);
+
+ /* Given a value (offset by OFFSET bytes)
+ of a struct or union type ARG_TYPE,
+ extract and return the value of one of its (non-static) fields.
+ FIELDNO says which field. */
+ struct value *primitive_field (LONGEST offset, int fieldno,
+ struct type *arg_type);
+
+ /* Create a new value by extracting it from this value. TYPE is the
+ type of the new value. BIT_OFFSET and BIT_LENGTH describe the
+ offset and field width of the value to extract from this value --
+ BIT_LENGTH may differ from TYPE's length in the case where this
+ value's type is packed.
+
+ When the value does come from a non-byte-aligned offset or field
+ width, it will be marked non_lval. */
+ struct value *from_component_bitsize (struct type *type,
+ LONGEST bit_offset,
+ LONGEST bit_length);
+
+ /* Record this value on the value history, and return its location
+ in the history. The value is removed from the value chain. */
+ int record_latest ();
+
+private:
/* Type of value; either not an lval, or one of the various
different possible kinds of lval. */
enum lval_type m_lval = not_lval;
/* Is it modifiable? Only relevant if lval != not_lval. */
- unsigned int m_modifiable : 1;
+ bool m_modifiable : 1;
- /* If zero, contents of this value are in the contents field. If
- nonzero, contents are in inferior. If the lval field is lval_memory,
+ /* If false, contents of this value are in the contents field. If
+ true, 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.
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;
+ bool m_lazy : 1;
/* If value is a variable, is it initialized or not. */
- unsigned int m_initialized : 1;
+ bool m_initialized : 1;
/* 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;
+ bool m_stack : 1;
/* True if this is a zero value, created by 'value::zero'; false
otherwise. */
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);
return failure here, which will ultimately throw an error. */
bool set_limited_array_length ();
-public: /* Temporary */
-
/* Allocate the contents of this value if it has not been allocated
yet. If CHECK_SIZE is true, then apply the usual max-value-size
checks. */
void allocate_contents (bool check_size);
-private:
-
/* Helper function for value_contents_eq. The only difference is that
this function is bit rather than byte based.
/* Returns true if this value is entirely covered by RANGES. If the
value is lazy, it'll be read now. Note that RANGE is a pointer
to pointer because reading the value might change *RANGE. */
- int entirely_covered_by_range_vector (const std::vector<range> &ranges);
+ bool entirely_covered_by_range_vector (const std::vector<range> &ranges);
+
+ /* Copy the ranges metadata from this value that overlaps
+ [SRC_BIT_OFFSET, SRC_BIT_OFFSET+BIT_LENGTH) into DST,
+ adjusted. */
+ void ranges_copy_adjusted (struct value *dst, int dst_bit_offset,
+ int src_bit_offset, int bit_length) const;
+
+ /* Copy LENGTH target addressable memory units of this value's (all)
+ contents (value_contents_all) starting at SRC_OFFSET, into DST
+ value's (all) contents, starting at DST_OFFSET. If unavailable
+ contents are being copied from this, the corresponding DST
+ contents are marked unavailable accordingly. Neither DST nor
+ this value may be lazy values.
+
+ It is assumed the contents of DST in the [DST_OFFSET,
+ DST_OFFSET+LENGTH) range are wholly available. */
+ void contents_copy_raw (struct value *dst, LONGEST dst_offset,
+ LONGEST src_offset, LONGEST length);
+
+ /* A helper for value_from_component_bitsize that copies bits from
+ this value to DEST. */
+ void contents_copy_raw_bitwise (struct value *dst, LONGEST dst_bit_offset,
+ LONGEST src_bit_offset, LONGEST bit_length);
};
inline void
/* If non-NULL, this is used to determine whether the indicated bits
of VALUE are a synthetic pointer. */
- int (*check_synthetic_pointer) (const struct value *value,
- LONGEST offset, int length);
+ bool (*check_synthetic_pointer) (const struct value *value,
+ LONGEST offset, int length);
/* Return a duplicate of VALUE's closure, for use in a new value.
This may simply return the same closure, if VALUE's is
extern void error_value_optimized_out (void);
-/* 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,
- const struct value *whole);
-
-/* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
- single value might have multiple LVALs), this hacked interface is
- 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. */
-#define VALUE_LVAL(val) (*((val)->deprecated_lval_hack ()))
-
/* Pointer to internal variable. */
#define VALUE_INTERNALVAR(val) (*((val)->deprecated_internalvar_hack ()))
whether the memory is known to be stack memory. */
extern void read_value_memory (struct value *val, LONGEST bit_offset,
- int stack, CORE_ADDR memaddr,
+ bool stack, CORE_ADDR memaddr,
gdb_byte *buffer, size_t length);
/* Cast SCALAR_VALUE to the element type of VECTOR_TYPE, then replicate
extern LONGEST value_as_long (struct value *val);
extern CORE_ADDR value_as_address (struct value *val);
+/* Extract the value from VAL as a MPZ. This coerces arrays and
+ handles various integer-like types as well. */
+
+extern gdb_mpz value_as_mpz (struct value *val);
+
extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
LONGEST embedded_offset, int fieldno,
const struct value *val, LONGEST *result);
-extern void unpack_value_bitfield (struct value *dest_val,
- LONGEST bitpos, LONGEST bitsize,
- const gdb_byte *valaddr,
- LONGEST embedded_offset,
- const struct value *val);
-
extern struct value *value_field_bitfield (struct type *type, int fieldno,
const gdb_byte *valaddr,
LONGEST embedded_offset,
extern struct value *value_from_component (struct value *, struct type *,
LONGEST);
+/* Convert the value V into a newly allocated value. */
+extern struct value *value_from_mpz (struct type *type, const gdb_mpz &v);
-/* Create a new value by extracting it from WHOLE. TYPE is the type
- of the new value. BIT_OFFSET and BIT_LENGTH describe the offset
- and field width of the value to extract from WHOLE -- BIT_LENGTH
- may differ from TYPE's length in the case where WHOLE's type is
- packed.
-
- When the value does come from a non-byte-aligned offset or field
- width, it will be marked non_lval. */
+extern struct value *value_at (struct type *type, CORE_ADDR addr);
-extern struct value *value_from_component_bitsize (struct value *whole,
- struct type *type,
- LONGEST bit_offset,
- LONGEST bit_length);
+/* Return a new value given a type and an address. The new value is
+ lazy. If FRAME is given, it is used when resolving dynamic
+ properties. */
-extern struct value *value_at (struct type *type, CORE_ADDR addr);
-extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
+extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr,
+ frame_info_ptr frame = nullptr);
/* 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_from_contents_and_address_unresolved
(struct type *, const gdb_byte *, CORE_ADDR);
-extern struct value *value_from_contents_and_address (struct type *,
- const gdb_byte *,
- CORE_ADDR);
+extern struct value *value_from_contents_and_address
+ (struct type *, const gdb_byte *, CORE_ADDR,
+ frame_info_ptr frame = nullptr);
extern struct value *value_from_contents (struct type *, const gdb_byte *);
extern struct value *default_value_from_register (struct gdbarch *gdbarch,
const struct block *var_block,
frame_info_ptr frame);
-extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
- struct value *src, LONGEST src_offset,
- LONGEST length);
-
extern struct value *allocate_repeat_value (struct type *type, int count);
extern struct value *value_mark (void);
/* Free the values currently on the value stack. */
void free_to_mark ()
{
- if (m_value != NULL)
+ if (!m_freed)
{
value_free_to_mark (m_value);
- m_value = NULL;
+ m_freed = true;
}
}
private:
const struct value *m_value;
+ bool m_freed = false;
};
-extern struct value *value_cstring (const char *ptr, ssize_t len,
+/* Create not_lval value representing a NULL-terminated C string. The
+ resulting value has type TYPE_CODE_ARRAY. The string passed in should
+ not include embedded null characters.
+
+ PTR points to the string data; COUNT is number of characters (does
+ not include the NULL terminator) pointed to by PTR, each character is of
+ type (and size of) CHAR_TYPE. */
+
+extern struct value *value_cstring (const gdb_byte *ptr, ssize_t count,
struct type *char_type);
-extern struct value *value_string (const char *ptr, ssize_t len,
+
+/* Specialisation of value_cstring above. In this case PTR points to
+ single byte characters. CHAR_TYPE must have a length of 1. */
+inline struct value *value_cstring (const char *ptr, ssize_t count,
+ struct type *char_type)
+{
+ gdb_assert (char_type->length () == 1);
+ return value_cstring ((const gdb_byte *) ptr, count, char_type);
+}
+
+/* Create a not_lval value with type TYPE_CODE_STRING, the resulting value
+ has type TYPE_CODE_STRING.
+
+ PTR points to the string data; COUNT is number of characters pointed to
+ by PTR, each character has the type (and size of) CHAR_TYPE.
+
+ Note that string types are like array of char types with a lower bound
+ defined by the language (usually zero or one). Also the string may
+ contain embedded null characters. */
+
+extern struct value *value_string (const gdb_byte *ptr, ssize_t count,
struct type *char_type);
+/* Specialisation of value_string above. In this case PTR points to
+ single byte characters. CHAR_TYPE must have a length of 1. */
+inline struct value *value_string (const char *ptr, ssize_t count,
+ struct type *char_type)
+{
+ gdb_assert (char_type->length () == 1);
+ return value_string ((const gdb_byte *) ptr, count, char_type);
+}
+
extern struct value *value_array (int lowbound, int highbound,
struct value **elemvec);
extern struct value *value_assign (struct value *toval,
struct value *fromval);
+/* The unary + operation. */
extern struct value *value_pos (struct value *arg1);
+/* The unary - operation. */
extern struct value *value_neg (struct value *arg1);
+/* The unary ~ operation -- but note that it also implements the GCC
+ extension, where ~ of a complex number is the complex
+ conjugate. */
extern struct value *value_complement (struct value *arg1);
extern struct value *value_struct_elt (struct value **argp,
extern struct value *value_field (struct value *arg1, int fieldno);
-extern struct value *value_primitive_field (struct value *arg1, LONGEST offset,
- int fieldno,
- struct type *arg_type);
-
-
extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
int *);
extern struct value *register_value_being_returned (struct type *valtype,
struct regcache *retbuf);
-extern int value_in (struct value *element, struct value *set);
-
extern int value_bit_index (struct type *type, const gdb_byte *addr,
int index);
struct value *function,
struct type *value_type);
-/* Evaluate the expression EXP. If set, EXPECT_TYPE is passed to the
- outermost operation's evaluation. This is ignored by most
- operations, but may be used, e.g., to determine the type of an
- otherwise untyped symbol. The caller should not assume that the
- returned value has this type. */
-
-extern struct value *evaluate_expression (struct expression *exp,
- struct type *expect_type = nullptr);
-
-extern struct value *evaluate_type (struct expression *exp);
-
extern value *evaluate_var_value (enum noside noside, const block *blk,
symbol *var);
std::vector<value_ref_ptr> *val_chain,
bool preserve_errors);
-extern struct value *parse_and_eval (const char *exp);
+extern struct value *parse_and_eval (const char *exp, parser_flags flags = 0);
extern struct value *parse_to_comma_and_eval (const char **expp);
extern value_ref_ptr release_value (struct value *val);
-extern int record_latest_value (struct value *val);
-
extern void modify_field (struct type *type, gdb_byte *addr,
LONGEST fieldval, LONGEST bitpos, LONGEST bitsize);
/* From values.c */
-extern struct value *value_non_lval (struct value *);
-
-extern void value_force_lval (struct value *, CORE_ADDR);
-
extern struct value *make_cv_value (int, int, struct value *);
-extern void preserve_one_value (struct value *, struct objfile *, htab_t);
-
/* From valops.c */
extern struct value *varying_to_slice (struct value *);
const char *value_internal_function_name (struct value *);
-/* Build a value wrapping and representing WORKER. The value takes ownership
- of the xmethod_worker object. */
-
-extern struct value *value_from_xmethod (xmethod_worker_up &&worker);
-
-extern struct type *result_type_of_xmethod (struct value *method,
- gdb::array_view<value *> argv);
-
-extern struct value *call_xmethod (struct value *method,
- gdb::array_view<value *> argv);
-
/* Destroy the values currently allocated. This is called when GDB is
exiting (e.g., on quit_force). */
extern void finalize_values ();
of floating-point, fixed-point, or integer type. */
extern gdb_mpq value_to_gdb_mpq (struct value *value);
+/* Return true if LEN (in bytes) exceeds the max-value-size setting,
+ otherwise, return false. If the user has disabled (set to unlimited)
+ the max-value-size setting then this function will always return false. */
+extern bool exceeds_max_value_size (ULONGEST length);
+
/* 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. */