/* Definitions for values of C expressions, for GDB.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame.h" /* For struct frame_id. */
#include "extension.h"
#include "gdbsupport/gdb_ref_ptr.h"
+#include "gmp-utils.h"
struct block;
struct expression;
TOVAL is not considered as an lvalue. */
void (*write) (struct value *toval, struct value *fromval);
+ /* Return true if any part of V is optimized out, false otherwise.
+ This will only be called for lazy values -- if the value has been
+ fetched, then the value's optimized-out bits are consulted
+ instead. */
+ bool (*is_optimized_out) (struct value *v);
+
/* If non-NULL, this is used to implement pointer indirection for
this value. This method may return NULL, in which case value_ind
will fall back to ordinary indirection. */
const struct lval_funcs *funcs,
void *closure);
-/* Helper function to check the validity of some bits of a value.
-
- If TYPE represents some aggregate type (e.g., a structure), return 1.
-
- Otherwise, any of the bytes starting at OFFSET and extending for
- TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
- return 0. The checking is done using FUNCS.
-
- Otherwise, return 1. */
-
-extern int valprint_check_validity (struct ui_file *stream, struct type *type,
- LONGEST embedded_offset,
- const struct value *val);
-
extern struct value *allocate_optimized_out_value (struct type *type);
/* If VALUE is lval_computed, return its lval_funcs structure. */
get to the real subobject, if the value happens to represent
something embedded in a larger run-time object. */
-extern gdb_byte *value_contents_raw (struct value *);
+extern gdb::array_view<gdb_byte> value_contents_raw (struct value *);
/* Actual contents of the value. For use of this value; setting it
uses the stuff above. Not valid if lazy is nonzero. Target
value. Note that a value therefore extends beyond what is
declared here. */
-extern const gdb_byte *value_contents (struct value *);
-extern gdb_byte *value_contents_writeable (struct value *);
+extern gdb::array_view<const gdb_byte> value_contents (struct value *);
+extern gdb::array_view<gdb_byte> value_contents_writeable (struct value *);
/* The ALL variants of the above two macros do not adjust the returned
pointer by the embedded_offset value. */
-extern gdb_byte *value_contents_all_raw (struct value *);
-extern const gdb_byte *value_contents_all (struct value *);
+extern gdb::array_view<gdb_byte> value_contents_all_raw (struct value *);
+extern gdb::array_view<const gdb_byte> value_contents_all (struct value *);
/* Like value_contents_all, but does not require that the returned
bits be valid. This should only be used in situations where you
plan to check the validity manually. */
-extern const gdb_byte *value_contents_for_printing (struct value *value);
+extern gdb::array_view<const gdb_byte> value_contents_for_printing (struct value *value);
/* Like value_contents_for_printing, but accepts a constant value
pointer. Unlike value_contents_for_printing however, the pointed
value must _not_ be lazy. */
-extern const gdb_byte *
+extern gdb::array_view<const gdb_byte>
value_contents_for_printing_const (const struct value *value);
extern void value_fetch_lazy (struct value *val);
/* 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);
+ 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
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))
-/* Frame ID of frame to which a register value is relative. This is
- similar to VALUE_NEXT_FRAME_ID, above, but may not be assigned to.
- Note that VALUE_FRAME_ID effectively undoes the "next" operation
- that was performed during the assignment to VALUE_NEXT_FRAME_ID. */
-#define VALUE_FRAME_ID(val) (get_prev_frame_id_by_id (VALUE_NEXT_FRAME_ID (val)))
-
/* 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))
/* Setup a new value type and enclosing value type for dereferenced value VALUE.
ENC_TYPE is the new enclosing type that should be set. ORIGINAL_TYPE and
- ORIGINAL_VAL are the type and value of the original reference or pointer.
+ ORIGINAL_VAL are the type and value of the original reference or
+ pointer. ORIGINAL_VALUE_ADDRESS is the address within VALUE, that is
+ the address that was dereferenced.
Note, that VALUE is modified by this function.
extern struct value * readjust_indirect_value_type (struct value *value,
struct type *enc_type,
const struct type *original_type,
- const struct value *original_val);
+ struct value *original_val,
+ CORE_ADDR original_value_address);
/* Convert a REF to the object referenced. */
extern LONGEST unpack_field_as_long (struct type *type,
const gdb_byte *valaddr,
int fieldno);
+
+/* Unpack a bitfield of the specified FIELD_TYPE, from the object at
+ VALADDR, and store the result in *RESULT.
+ The bitfield starts at BITPOS bits and contains BITSIZE bits; if
+ BITSIZE is zero, then the length is taken from FIELD_TYPE.
+
+ Extracting bits depends on endianness of the machine. Compute the
+ number of least significant bits to discard. For big endian machines,
+ we compute the total number of bits in the anonymous object, subtract
+ off the bit count from the MSB of the object to the MSB of the
+ bitfield, then the size of the bitfield, which leaves the LSB discard
+ count. For little endian machines, the discard count is simply the
+ number of bits from the LSB of the anonymous object to the LSB of the
+ bitfield.
+
+ If the field is signed, we also do sign extension. */
+
+extern LONGEST unpack_bits_as_long (struct type *field_type,
+ const gdb_byte *valaddr,
+ LONGEST bitpos, LONGEST bitsize);
+
extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
LONGEST embedded_offset, int fieldno,
const struct value *val, LONGEST *result);
const struct block *var_block,
struct frame_info *frame);
-extern struct value *default_read_var_value (struct symbol *var,
- const struct block *var_block,
- struct frame_info *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);
-extern void value_contents_copy_raw (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_complement (struct value *arg1);
extern struct value *value_struct_elt (struct value **argp,
- struct value **args,
+ gdb::optional<gdb::array_view <value *>> args,
const char *name, int *static_memfuncp,
const char *err);
struct value *function,
struct type *value_type);
-extern struct value *evaluate_expression (struct expression *exp);
+/* 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_type (struct expression *exp);
+extern struct value *evaluate_expression (struct expression *exp,
+ struct type *expect_type = nullptr);
-extern struct value *evaluate_subexp (struct type *expect_type,
- struct expression *exp,
- int *pos, enum noside noside);
-
-extern struct value *evaluate_subexpression_type (struct expression *exp,
- int subexp);
+extern struct value *evaluate_type (struct expression *exp);
extern value *evaluate_var_value (enum noside noside, const block *blk,
symbol *var);
struct objfile *objfile,
minimal_symbol *msymbol);
-extern value *eval_skip_value (expression *exp);
-
-extern void fetch_subexp_value (struct expression *exp, int *pc,
+namespace expr { class operation; };
+extern void fetch_subexp_value (struct expression *exp,
+ expr::operation *op,
struct value **valp, struct value **resultp,
std::vector<value_ref_ptr> *val_chain,
- int preserve_errors);
-
-extern const char *extract_field_op (struct expression *exp, int *subexp);
-
-extern struct value *evaluate_subexp_with_coercion (struct expression *,
- int *, enum noside);
+ bool preserve_errors);
extern struct value *parse_and_eval (const char *exp);
extern struct value *parse_to_comma_and_eval (const char **expp);
-extern struct type *parse_and_eval_type (char *p, int length);
+extern struct type *parse_and_eval_type (const char *p, int length);
extern CORE_ADDR parse_and_eval_address (const char *exp);
extern struct value *access_value_history (int num);
+/* Return the number of items in the value history. */
+
+extern ULONGEST value_history_count ();
+
extern struct value *value_of_internalvar (struct gdbarch *gdbarch,
struct internalvar *var);
struct agent_expr *expr,
struct axs_value *value,
void *data);
-
- /* If non-NULL, this is called to destroy DATA. The DATA argument
- passed to this function is the same argument that was passed to
- `create_internalvar_type_lazy'. */
-
- void (*destroy) (void *data);
};
extern struct internalvar *create_internalvar_type_lazy (const char *name,
extern int value_less (struct value *arg1, struct value *arg2);
-extern int value_logical_not (struct value *arg1);
+/* Simulate the C operator ! -- return true if ARG1 contains zero. */
+extern bool value_logical_not (struct value *arg1);
+
+/* Returns true if the value VAL represents a true value. */
+static inline bool
+value_true (struct value *val)
+{
+ return !value_logical_not (val);
+}
/* C++ */
extern void value_print (struct value *val, struct ui_file *stream,
const struct value_print_options *options);
-extern void value_print_array_elements (struct value *val,
- struct ui_file *stream, int format,
- enum val_prettyformat pretty);
-
/* Release values from the value chain and return them. Values
created after MARK are released. If MARK is nullptr, or if MARK is
not found on the value chain, then all values are released. Values
extern void typedef_print (struct type *type, struct symbol *news,
struct ui_file *stream);
-extern char *internalvar_name (const struct internalvar *var);
+extern const char *internalvar_name (const struct internalvar *var);
extern void preserve_values (struct objfile *);
/* From values.c */
-extern struct value *value_copy (struct value *);
+extern struct value *value_copy (const value *);
extern struct value *value_non_lval (struct value *);
extern struct value *value_slice (struct value *, int, int);
+/* Create a complex number. The type is the complex type; the values
+ are cast to the underlying scalar type before the complex number is
+ created. */
+
extern struct value *value_literal_complex (struct value *, struct value *,
struct type *);
extern struct value *value_allocate_space_in_inferior (int);
-extern struct value *value_subscripted_rvalue (struct value *array,
- LONGEST index,
- LONGEST lowerbound);
-
/* User function handler. */
typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
struct value *function,
int argc, struct value **argv);
-char *value_internal_function_name (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 *call_xmethod (struct value *method,
gdb::array_view<value *> argv);
-/* Given a discriminated union type and some corresponding value
- contents, this will return the field index of the currently active
- variant. This will throw an exception if no active variant can be
- found. */
-
-extern int value_union_variant (struct type *union_type,
- const gdb_byte *contents);
-
/* Destroy the values currently allocated. This is called when GDB is
exiting (e.g., on quit_force). */
extern void finalize_values ();
+/* Convert VALUE to a gdb_mpq. The caller must ensure that VALUE is
+ of floating-point, fixed-point, or integer type. */
+extern gdb_mpq value_to_gdb_mpq (struct value *value);
+
#endif /* !defined (VALUE_H) */
projects / binutils-gdb.git / blobdiff