/* Definitions for values of C expressions, for GDB.
- Copyright (C) 1986-2013 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
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
+ and related error strings.
+
+ 'unavailable' has a specific meaning in this context. It means the
+ value exists in the program (at the machine level), but GDB has no
+ means to get to it. Such a value is normally printed as
+ <unavailable>. Examples of how to end up with an unavailable value
+ would be:
+
+ - We're inspecting a traceframe, and the memory or registers the
+ debug information says the value lives on haven't been collected.
+
+ - We're inspecting a core dump, the memory or registers the debug
+ information says the value lives aren't present in the dump
+ (that is, we have a partial/trimmed core dump, or we don't fully
+ understand/handle the core dump's format).
+
+ - We're doing live debugging, but the debug API has no means to
+ get at where the value lives in the machine, like e.g., ptrace
+ not having access to some register or register set.
+
+ - Any other similar scenario.
+
+ OTOH, "optimized out" is about what the compiler decided to generate
+ (or not generate). A chunk of a value that was optimized out does
+ not actually exist in the program. There's no way to get at it
+ short of compiling the program differently.
+
+ A register that has not been saved in a frame is likewise considered
+ optimized out, except not-saved registers have a different string
+ representation and related error strings. E.g., we'll print them as
+ <not-saved> instead of <optimized out>, as in:
+
+ (gdb) p/x $rax
+ $1 = <not saved>
+ (gdb) info registers rax
+ rax <not saved>
+
+ If the debug info describes a variable as being in such a register,
+ we'll still print the variable as <optimized out>. IOW, <not saved>
+ is reserved for inspecting registers at the machine level.
+
+ When comparing value contents, optimized out chunks, unavailable
+ chunks, and valid contents data are all considered different. See
+ value_contents_eq for more info.
+*/
/* 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
extern struct type *value_type (const struct value *);
+/* Return the gdbarch associated with the value. */
+
+extern struct gdbarch *get_value_arch (const struct value *value);
+
/* This is being used to change the type of an existing value, that
code should instead be creating a new value with the changed type
(but possibly shared content). */
TOVAL is not considered as an lvalue. */
void (*write) (struct value *toval, struct value *fromval);
- /* Check the validity of some bits in VALUE. This should return 1
- if all the bits starting at OFFSET and extending for LENGTH bits
- are valid, or 0 if any bit is invalid. */
- int (*check_validity) (const struct value *value, int offset, int length);
-
- /* Return 1 if any bit in VALUE is valid, 0 if they are all invalid. */
- int (*check_any_valid) (const struct value *value);
-
/* 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. */
extern int value_stack (struct value *);
extern void set_value_stack (struct value *value, int val);
+/* Throw an error complaining that the value has been optimized
+ out. */
+
+extern void error_value_optimized_out (void);
+
/* value_contents() and value_contents_raw() both return the address
of the gdb buffer used to hold a copy of the contents of the lval.
value_contents() is used when the contents of the buffer are needed
extern const gdb_byte *
value_contents_for_printing_const (const struct value *value);
-extern int value_fetch_lazy (struct value *val);
-extern int value_contents_equal (struct value *val1, struct value *val2);
+extern void value_fetch_lazy (struct value *val);
/* If nonzero, 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. */
extern int value_optimized_out (struct value *value);
-extern void set_value_optimized_out (struct value *value, int val);
-/* Like value_optimized_out, but don't fetch the value even if it is
- lazy. Mainly useful for constructing other values using VALUE as
- template. */
-extern int value_optimized_out_const (const struct value *value);
+/* Given a value, return true if any of the contents bits starting at
+ OFFSET and extending for LENGTH bits is optimized out, false
+ otherwise. */
+
+extern int value_bits_any_optimized_out (const struct value *value,
+ int bit_offset, int bit_length);
+
+/* Like value_optimized_out, but return true iff the whole value is
+ optimized out. */
+extern int value_entirely_optimized_out (struct value *value);
-/* Like value_optimized_out, but return false if any bit in the object
- is valid. */
-extern int value_entirely_optimized_out (const struct value *value);
+/* Mark VALUE's content bytes starting at OFFSET and extending for
+ LENGTH bytes as optimized out. */
+
+extern void mark_value_bytes_optimized_out (struct value *value,
+ int offset, int length);
+
+/* Mark VALUE's content bits starting at OFFSET and extending for
+ LENGTH bits as optimized out. */
+
+extern void mark_value_bits_optimized_out (struct value *value,
+ int offset, int length);
/* Set or return field indicating whether a variable is initialized or
not, based on debugging information supplied by the compiler.
extern struct value *coerce_array (struct value *value);
-/* Given a value, determine whether the bits starting at OFFSET and
- extending for LENGTH bits are valid. This returns nonzero if all
- bits in the given range are valid, zero if any bit is invalid. */
-
-extern int value_bits_valid (const struct value *value,
- int offset, int length);
-
/* Given a value, determine whether the bits starting at OFFSET and
extending for LENGTH bits are a synthetic pointer. */
extern int value_bytes_available (const struct value *value,
int offset, int length);
+/* 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
+ bit is unavailable. */
+
+extern int value_bits_available (const struct value *value,
+ int offset, int length);
+
/* Like value_bytes_available, but return false if any byte in the
whole object is unavailable. */
extern int value_entirely_available (struct value *value);
extern void mark_value_bytes_unavailable (struct value *value,
int offset, int length);
+/* Mark VALUE's content bits starting at OFFSET and extending for
+ LENGTH bits as unavailable. */
+
+extern void mark_value_bits_unavailable (struct value *value,
+ int offset, int length);
+
/* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
LENGTH bytes of VAL2's contents starting at OFFSET2.
its enclosing type chunk, you'd do:
int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
- value_available_contents (val, 0, val, 0, len);
+ value_contents_eq (val, 0, val, 0, len);
+
+ Returns true iff the set of available/valid contents match.
- Returns true iff the set of available contents match. Unavailable
- contents compare equal with unavailable contents, and different
- with any available byte. For example, if 'x's represent an
- unavailable byte, and 'V' and 'Z' represent different available
- bytes, in a value with length 16:
+ Optimized-out contents are equal to optimized-out contents, and are
+ not equal to non-optimized-out contents.
- offset: 0 4 8 12 16
- contents: xxxxVVVVxxxxVVZZ
+ Unavailable contente 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'
+ represent different available/valid bytes, in a value with length
+ 16:
+
+ offset: 0 4 8 12 16
+ contents: xxxxVVVVxxxxVVZZ
then:
- value_available_contents_eq(val, 0, val, 8, 6) => 1
- value_available_contents_eq(val, 0, val, 4, 4) => 1
- value_available_contents_eq(val, 0, val, 8, 8) => 0
- value_available_contents_eq(val, 4, val, 12, 2) => 1
- value_available_contents_eq(val, 4, val, 12, 4) => 0
- value_available_contents_eq(val, 3, val, 4, 4) => 0
-
- We only know whether a value chunk is available if we've tried to
- read it. As this routine is used by printing routines, which may
- be printing values in the value history, long after the inferior is
- gone, it works with const values. Therefore, this routine must not
- be called with lazy values. */
-
-extern int value_available_contents_eq (const struct value *val1, int offset1,
- const struct value *val2, int offset2,
- int length);
-
-/* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which
- is (or will be copied to) VAL's contents buffer offset by
+ 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
+
+ If 'x's represent an unavailable byte, 'o' represents an optimized
+ out byte, in a value with length 8:
+
+ offset: 0 4 8
+ contents: xxxxoooo
+
+ 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
+
+ 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
+ routines, which may be printing values in the value history, long
+ 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, int offset1,
+ const struct value *val2, int offset2,
+ int 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
int *invp);
extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
-extern int unpack_value_bits_as_long (struct type *field_type,
- const gdb_byte *valaddr,
- int embedded_offset, int bitpos,
- int bitsize,
- const struct value *original_value,
- LONGEST *result);
-
extern LONGEST unpack_field_as_long (struct type *type,
const gdb_byte *valaddr,
int fieldno);
int embedded_offset, int fieldno,
const struct value *val, LONGEST *result);
+extern void unpack_value_bitfield (struct value *dest_val,
+ int bitpos, int bitsize,
+ const gdb_byte *valaddr, int embedded_offset,
+ const struct value *val);
+
extern struct value *value_field_bitfield (struct type *type, int fieldno,
const gdb_byte *valaddr,
int embedded_offset,
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_history_ref (char *, char **);
+extern struct value *value_from_history_ref (const char *, const char **);
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_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 (struct type *, const gdb_byte *);
-extern struct value *default_value_from_register (struct type *type,
+extern struct value *default_value_from_register (struct gdbarch *gdbarch,
+ struct type *type,
int regnum,
- struct frame_info *frame);
+ struct frame_id frame_id);
extern void read_frame_register_value (struct value *value,
struct frame_info *frame);
extern struct value *value_from_register (struct type *type, int regnum,
struct frame_info *frame);
-extern CORE_ADDR address_from_register (struct type *type, int regnum,
+extern CORE_ADDR address_from_register (int regnum,
struct frame_info *frame);
extern struct value *value_of_variable (struct symbol *var,
extern int symbol_read_needs_frame (struct symbol *);
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);
extern struct value *allocate_value (struct type *type);
extern void value_free_to_mark (struct value *mark);
-extern struct value *value_cstring (char *ptr, ssize_t len,
+extern struct value *value_cstring (const char *ptr, ssize_t len,
struct type *char_type);
-extern struct value *value_string (char *ptr, ssize_t len,
+extern struct value *value_string (const char *ptr, ssize_t len,
struct type *char_type);
extern struct value *value_array (int lowbound, int highbound,
const char *name, int *static_memfuncp,
const char *err);
+extern struct value *value_struct_elt_bitpos (struct value **argp,
+ int bitpos,
+ struct type *field_type,
+ const char *err);
+
extern struct value *value_aggregate_elt (struct type *curtype,
- char *name,
+ const char *name,
struct type *expect_type,
int want_address,
enum noside noside);
enum oload_search_type method,
struct value **objp, struct symbol *fsym,
struct value **valp, struct symbol **symp,
- int *staticp, const int no_adl);
+ int *staticp, const int no_adl,
+ enum noside noside);
extern struct value *value_field (struct value *arg1, int fieldno);
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 */
char *value_internal_function_name (struct value *);
+extern struct value *value_of_xmethod (struct xmethod_worker *);
+
+extern struct type *result_type_of_xmethod (struct value *method,
+ int argc, struct value **argv);
+
+extern struct value *call_xmethod (struct value *method,
+ int argc, struct value **argv);
+
#endif /* !defined (VALUE_H) */