/* Definitions for values of C expressions, for GDB.
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2023 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;
value_contents_eq for more info.
*/
+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
extern void set_value_bitsize (struct value *, LONGEST bit);
/* Only used for bitfields; position of start of field. For
- gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
- gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
+ little-endian targets, it is the position of the LSB. For
+ big-endian targets, it is the position of the MSB. */
extern LONGEST value_bitpos (const struct value *);
extern void set_value_bitpos (struct value *, LONGEST bit);
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. */
example, to compare a complete object value with itself, including
its enclosing type chunk, you'd do:
- int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
+ int len = check_typedef (value_enclosing_type (val))->length ();
value_contents_eq (val, 0, val, 0, len);
Returns true iff the set of available/valid contents match.
Optimized-out contents are equal to optimized-out contents, and are
not equal to non-optimized-out contents.
- Unavailable contente are equal to unavailable contents, and are not
+ Unavailable contents are equal to unavailable contents, and are not
equal to non-unavailable contents.
For example, if 'x's represent an unavailable byte, and 'V' and 'Z'
const struct value *val2, LONGEST offset2,
LONGEST length);
+/* An overload of value_contents_eq that compares the entirety of both
+ values. */
+
+extern bool value_contents_eq (const struct value *val1,
+ const struct value *val2);
+
/* Read LENGTH addressable memory units starting at MEMADDR into BUFFER,
which is (or will be copied to) VAL's contents buffer offset by
BIT_OFFSET bits. Marks value contents ranges as unavailable if
#include "gdbtypes.h"
#include "expression.h"
-struct frame_info;
+class frame_info_ptr;
struct fn_field;
extern int print_address_demangle (const struct value_print_options *,
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);
extern struct value *value_from_component (struct value *, struct type *,
LONGEST);
+
+/* 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_from_component_bitsize (struct value *whole,
+ struct type *type,
+ LONGEST bit_offset,
+ LONGEST bit_length);
+
extern struct value *value_at (struct type *type, CORE_ADDR addr);
extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
struct frame_id frame_id);
extern void read_frame_register_value (struct value *value,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern struct value *value_from_register (struct type *type, int regnum,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern CORE_ADDR address_from_register (int regnum,
- struct frame_info *frame);
+ frame_info_ptr frame);
extern struct value *value_of_variable (struct symbol *var,
const struct block *b);
extern struct value *address_of_variable (struct symbol *var,
const struct block *b);
-extern struct value *value_of_register (int regnum, struct frame_info *frame);
+extern struct value *value_of_register (int regnum, frame_info_ptr frame);
-struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
+struct value *value_of_register_lazy (frame_info_ptr frame, int regnum);
/* Return the symbol's reading requirement. */
extern struct value *read_var_value (struct symbol *var,
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);
+ 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);
-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_subexp (struct type *expect_type,
- struct expression *exp,
- int *pos, enum noside noside);
+extern struct value *evaluate_expression (struct expression *exp,
+ struct type *expect_type = nullptr);
-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 std::vector<value_ref_ptr> value_release_to_mark
(const struct value *mark);
-extern void val_print (struct type *type,
- LONGEST embedded_offset, CORE_ADDR address,
- struct ui_file *stream, int recurse,
- struct value *val,
- const struct value_print_options *options,
- const struct language_defn *language);
-
extern void common_val_print (struct value *val,
struct ui_file *stream, int recurse,
const struct value_print_options *options,
extern void print_variable_and_value (const char *name,
struct symbol *var,
- struct frame_info *frame,
+ frame_info_ptr frame,
struct ui_file *stream,
int indent);
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 *);
+/* Return the real part of a complex value. */
+
+extern struct value *value_real_part (struct value *value);
+
+/* Return the imaginary part of a complex value. */
+
+extern struct value *value_imaginary_part (struct value *value);
+
extern struct value *find_function_in_inferior (const char *,
struct objfile **);
extern struct value *value_allocate_space_in_inferior (int);
-extern struct value *value_subscripted_rvalue (struct value *array,
- LONGEST index, int lowerbound);
-
/* User function handler. */
typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
int argc,
struct value **argv);
-void add_internal_function (const char *name, const char *doc,
- internal_function_fn handler,
- void *cookie);
+/* Add a new internal function. NAME is the name of the function; DOC
+ is a documentation string describing the function. HANDLER is
+ called when the function is invoked. COOKIE is an arbitrary
+ pointer which is passed to HANDLER and is intended for "user
+ data". */
+
+extern void add_internal_function (const char *name, const char *doc,
+ internal_function_fn handler,
+ void *cookie);
+
+/* This overload takes an allocated documentation string. */
+
+extern void add_internal_function (gdb::unique_xmalloc_ptr<char> &&name,
+ gdb::unique_xmalloc_ptr<char> &&doc,
+ internal_function_fn handler,
+ void *cookie);
struct value *call_internal_function (struct gdbarch *gdbarch,
const struct language_defn *language,
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