X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalue.h;h=df6d80c2a7051bb3a76c0a5f1595d3be4e0976d5;hb=301a9420d947da145884261ac31a7a52438c2894;hp=f776323c4a822158fdc88d8a820cb5a2ad80333c;hpb=7dc54575d91a2b41f6c3e838eec44a7017a24436;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/value.h b/gdb/value.h index f776323c4a..df6d80c2a7 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -1,6 +1,6 @@ /* Definitions for values of C expressions, for GDB. - Copyright (C) 1986-2016 Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -20,8 +20,9 @@ #if !defined (VALUE_H) #define VALUE_H 1 -#include "doublest.h" #include "frame.h" /* For struct frame_id. */ +#include "extension.h" +#include "gdbsupport/gdb_ref_ptr.h" struct block; struct expression; @@ -31,7 +32,6 @@ struct type; struct ui_file; struct language_defn; struct value_print_options; -struct xmethod_worker; /* Values can be partially 'optimized out' and/or 'unavailable'. These are distinct states and have different string representations @@ -81,6 +81,8 @@ struct xmethod_worker; 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 @@ -88,6 +90,34 @@ struct xmethod_worker; struct value; +/* Increase VAL's reference count. */ + +extern void value_incref (struct value *val); + +/* Decrease VAL's reference count. When the reference count drops to + 0, VAL will be freed. */ + +extern void value_decref (struct value *val); + +/* A policy class to interface gdb::ref_ptr with struct value. */ + +struct value_ref_policy +{ + static void incref (struct value *ptr) + { + value_incref (ptr); + } + + static void decref (struct value *ptr) + { + value_decref (ptr); + } +}; + +/* A gdb:;ref_ptr pointer to a struct value. */ + +typedef gdb::ref_ptr 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 @@ -116,8 +146,8 @@ extern LONGEST value_bitsize (const struct value *); 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); @@ -538,7 +568,7 @@ extern void mark_value_bits_unavailable (struct value *value, 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' @@ -550,12 +580,12 @@ extern void mark_value_bits_unavailable (struct value *value, then: - value_contents_eq(val, 0, val, 8, 6) => 1 - value_contents_eq(val, 0, val, 4, 4) => 0 - value_contents_eq(val, 0, val, 8, 8) => 0 - value_contents_eq(val, 4, val, 12, 2) => 1 - value_contents_eq(val, 4, val, 12, 4) => 0 - value_contents_eq(val, 3, val, 4, 4) => 0 + value_contents_eq(val, 0, val, 8, 6) => true + value_contents_eq(val, 0, val, 4, 4) => false + value_contents_eq(val, 0, val, 8, 8) => false + value_contents_eq(val, 4, val, 12, 2) => true + value_contents_eq(val, 4, val, 12, 4) => true + value_contents_eq(val, 3, val, 4, 4) => true If 'x's represent an unavailable byte, 'o' represents an optimized out byte, in a value with length 8: @@ -565,9 +595,9 @@ extern void mark_value_bits_unavailable (struct value *value, then: - value_contents_eq(val, 0, val, 2, 2) => 1 - value_contents_eq(val, 4, val, 6, 2) => 1 - value_contents_eq(val, 0, val, 4, 4) => 0 + value_contents_eq(val, 0, val, 2, 2) => true + value_contents_eq(val, 4, val, 6, 2) => true + value_contents_eq(val, 0, val, 4, 4) => true We only know whether a value chunk is unavailable or optimized out if we've tried to read it. As this routine is used by printing @@ -575,18 +605,17 @@ extern void mark_value_bits_unavailable (struct value *value, after the inferior is gone, it works with const values. Therefore, this routine must not be called with lazy values. */ -extern int value_contents_eq (const struct value *val1, LONGEST offset1, - const struct value *val2, LONGEST offset2, - LONGEST length); +extern bool value_contents_eq (const struct value *val1, LONGEST offset1, + const struct value *val2, LONGEST offset2, + LONGEST length); /* Read LENGTH addressable memory units starting at MEMADDR into BUFFER, which is (or will be copied to) VAL's contents buffer offset by - EMBEDDED_OFFSET (that is, to &VAL->contents[EMBEDDED_OFFSET]). - Marks value contents ranges as unavailable if the corresponding - memory is likewise unavailable. STACK indicates whether the memory - is known to be stack memory. */ + BIT_OFFSET bits. Marks value contents ranges as unavailable if + the corresponding memory is likewise unavailable. STACK indicates + whether the memory is known to be stack memory. */ -extern void read_value_memory (struct value *val, LONGEST embedded_offset, +extern void read_value_memory (struct value *val, LONGEST bit_offset, int stack, CORE_ADDR memaddr, gdb_byte *buffer, size_t length); @@ -609,13 +638,14 @@ extern int print_address_demangle (const struct value_print_options *, struct gdbarch *, CORE_ADDR, struct ui_file *, int); +/* Returns true if VAL is of floating-point type. In addition, + throws an error if the value is an invalid floating-point value. */ +extern bool is_floating_value (struct value *val); + extern LONGEST value_as_long (struct value *val); -extern DOUBLEST value_as_double (struct value *val); extern CORE_ADDR value_as_address (struct value *val); extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr); -extern DOUBLEST unpack_double (struct type *type, const gdb_byte *valaddr, - int *invp); extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr); extern LONGEST unpack_field_as_long (struct type *type, @@ -641,9 +671,7 @@ extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num); extern struct value *value_from_longest (struct type *type, LONGEST num); extern struct value *value_from_ulongest (struct type *type, ULONGEST num); extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr); -extern struct value *value_from_double (struct type *type, DOUBLEST num); -extern struct value *value_from_decfloat (struct type *type, - const gdb_byte *decbytes); +extern struct value *value_from_host_double (struct type *type, double d); extern struct value *value_from_history_ref (const char *, const char **); extern struct value *value_from_component (struct value *, struct type *, LONGEST); @@ -714,6 +742,42 @@ extern struct value *value_mark (void); extern void value_free_to_mark (const struct value *mark); +/* A helper class that uses value_mark at construction time and calls + value_free_to_mark in the destructor. This is used to clear out + temporary values created during the lifetime of this object. */ +class scoped_value_mark +{ + public: + + scoped_value_mark () + : m_value (value_mark ()) + { + } + + ~scoped_value_mark () + { + free_to_mark (); + } + + scoped_value_mark (scoped_value_mark &&other) = default; + + DISABLE_COPY_AND_ASSIGN (scoped_value_mark); + + /* Free the values currently on the value stack. */ + void free_to_mark () + { + if (m_value != NULL) + { + value_free_to_mark (m_value); + m_value = NULL; + } + } + + private: + + const struct value *m_value; +}; + extern struct value *value_cstring (const char *ptr, ssize_t len, struct type *char_type); extern struct value *value_string (const char *ptr, ssize_t len, @@ -731,7 +795,10 @@ extern struct value *value_ptradd (struct value *arg1, LONGEST arg2); extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2); -extern int value_must_coerce_to_target (struct value *arg1); +/* Return true if VAL does not live in target memory, but should in order + to operate on it. Otherwise return false. */ + +extern bool value_must_coerce_to_target (struct value *arg1); extern struct value *value_coerce_to_target (struct value *arg1); @@ -743,7 +810,7 @@ extern struct value *value_ind (struct value *arg1); extern struct value *value_addr (struct value *arg1); -extern struct value *value_ref (struct value *arg1); +extern struct value *value_ref (struct value *arg1, enum type_code refcode); extern struct value *value_assign (struct value *toval, struct value *fromval); @@ -774,7 +841,7 @@ extern struct value *value_static_field (struct type *type, int fieldno); enum oload_search_type { NON_METHOD, METHOD, BOTH }; -extern int find_overload_match (struct value **args, int nargs, +extern int find_overload_match (gdb::array_view args, const char *name, enum oload_search_type method, struct value **objp, struct symbol *fsym, @@ -843,12 +910,21 @@ extern struct value *evaluate_subexp (struct type *expect_type, extern struct value *evaluate_subexpression_type (struct expression *exp, int subexp); +extern value *evaluate_var_value (enum noside noside, const block *blk, + symbol *var); + +extern value *evaluate_var_msym_value (enum noside noside, + struct objfile *objfile, + minimal_symbol *msymbol); + +extern value *eval_skip_value (expression *exp); + extern void fetch_subexp_value (struct expression *exp, int *pc, struct value **valp, struct value **resultp, - struct value **val_chain, + std::vector *val_chain, int preserve_errors); -extern char *extract_field_op (struct expression *exp, int *subexp); +extern const char *extract_field_op (struct expression *exp, int *subexp); extern struct value *evaluate_subexp_with_coercion (struct expression *, int *, enum noside); @@ -896,7 +972,8 @@ extern struct internalvar *lookup_only_internalvar (const char *name); extern struct internalvar *create_internalvar (const char *name); -extern VEC (char_ptr) *complete_internalvar (const char *name); +extern void complete_internalvar (completion_tracker &tracker, + const char *name); /* An internalvar can be dynamically computed by supplying a vector of function pointers to perform various operations. */ @@ -982,17 +1059,7 @@ extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1); extern int destructor_name_p (const char *name, struct type *type); -extern void value_incref (struct value *val); - -extern void value_free (struct value *val); - -extern void free_all_values (void); - -extern void free_value_chain (struct value *v); - -extern void release_value (struct value *val); - -extern void release_value_or_incref (struct value *val); +extern value_ref_ptr release_value (struct value *val); extern int record_latest_value (struct value *val); @@ -1014,9 +1081,6 @@ extern void print_longest (struct ui_file *stream, int format, extern void print_floating (const gdb_byte *valaddr, struct type *type, struct ui_file *stream); -extern void print_decimal_floating (const gdb_byte *valaddr, struct type *type, - struct ui_file *stream); - extern void value_print (struct value *val, struct ui_file *stream, const struct value_print_options *options); @@ -1024,7 +1088,14 @@ extern void value_print_array_elements (struct value *val, struct ui_file *stream, int format, enum val_prettyformat pretty); -extern struct value *value_release_to_mark (const struct value *mark); +/* 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 + are returned in reverse order of creation; that is, newest + first. */ + +extern std::vector value_release_to_mark + (const struct value *mark); extern void val_print (struct type *type, LONGEST embedded_offset, CORE_ADDR address, @@ -1083,7 +1154,8 @@ extern struct value *find_function_in_inferior (const char *, extern struct value *value_allocate_space_in_inferior (int); extern struct value *value_subscripted_rvalue (struct value *array, - LONGEST index, int lowerbound); + LONGEST index, + LONGEST lowerbound); /* User function handler. */ @@ -1093,9 +1165,22 @@ 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 &&name, + gdb::unique_xmalloc_ptr &&doc, + internal_function_fn handler, + void *cookie); struct value *call_internal_function (struct gdbarch *gdbarch, const struct language_defn *language, @@ -1104,12 +1189,27 @@ struct value *call_internal_function (struct gdbarch *gdbarch, char *value_internal_function_name (struct value *); -extern struct value *value_of_xmethod (struct xmethod_worker *); +/* 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, - int argc, struct value **argv); + gdb::array_view argv); extern struct value *call_xmethod (struct value *method, - int argc, struct value **argv); + gdb::array_view 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 (); #endif /* !defined (VALUE_H) */