/* 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_),
/* 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 (int val)
+ void set_modifiable (bool val)
{ m_modifiable = val; }
LONGEST pointed_to_offset () const
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 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);
}
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. */
/* 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,
/* 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);
-/* 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);
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);
extern struct value *value_at (struct type *type, CORE_ADDR addr);
-extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
+
+/* 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_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,
/* 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 *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);
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. */