X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fvalue.h;h=21baa32442bb197bb0851353198ff011d0533e56;hb=9f04ac5f92a1efc97b38cb6560fc10146fad64b6;hp=c10c3ecf163ab8f36b5f1a72c5e26b4fae3767d7;hpb=bbfdfe1c572ca7710cf08607db4935e8c8db174c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/value.h b/gdb/value.h index c10c3ecf16..21baa32442 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -1,6 +1,6 @@ /* Definitions for values of C expressions, for GDB. - Copyright (C) 1986-2013 Free Software Foundation, Inc. + Copyright (C) 1986-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -31,6 +31,55 @@ 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 + 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 + . 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 + instead of , as in: + + (gdb) p/x $rax + $1 = + (gdb) info registers rax + rax + + If the debug info describes a variable as being in such a register, + we'll still print the variable as . IOW, + 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 @@ -180,14 +229,6 @@ struct lval_funcs 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. */ @@ -273,6 +314,11 @@ extern void set_value_lazy (struct value *value, int val); 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 @@ -316,16 +362,34 @@ 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); /* If nonzero, this is the value of a variable which does not actually - exist in the program. */ + 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 return false if any bit in the object - is valid. */ -extern int value_entirely_optimized_out (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); + +/* 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. @@ -404,13 +468,6 @@ extern struct value *coerce_ref (struct value *value); 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. */ @@ -425,16 +482,34 @@ extern int value_bits_synthetic_pointer (const struct value *value, 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); +/* Like value_entirely_available, but return false if any byte in the + whole object is available. */ +extern int value_entirely_unavailable (struct value *value); + /* Mark VALUE's content bytes starting at OFFSET and extending for LENGTH bytes as unavailable. */ 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. @@ -444,30 +519,53 @@ extern void mark_value_bytes_unavailable (struct value *value, 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. + + 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 + equal to non-unavailable contents. - 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: + 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 + 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 -*/ + 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_available_contents_eq (const struct value *val1, int offset1, - const struct value *val2, int offset2, - int length); +extern int value_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 @@ -508,13 +606,6 @@ 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 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); @@ -522,6 +613,11 @@ extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valadd 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, @@ -535,19 +631,22 @@ 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_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); @@ -555,7 +654,7 @@ extern void read_frame_register_value (struct value *value, 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, @@ -578,7 +677,6 @@ extern struct value *default_read_var_value (struct symbol *var, extern struct value *allocate_value (struct type *type); extern struct value *allocate_value_lazy (struct type *type); -extern void allocate_value_contents (struct value *value); extern void value_contents_copy (struct value *dst, int dst_offset, struct value *src, int src_offset, int length); @@ -637,8 +735,13 @@ extern struct value *value_struct_elt (struct value **argp, 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); @@ -652,7 +755,8 @@ extern int find_overload_match (struct value **args, int nargs, 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); @@ -717,22 +821,23 @@ extern struct value *evaluate_subexpression_type (struct expression *exp, extern void fetch_subexp_value (struct expression *exp, int *pc, struct value **valp, struct value **resultp, - struct value **val_chain); + struct value **val_chain, + int preserve_errors); extern char *extract_field_op (struct expression *exp, int *subexp); extern struct value *evaluate_subexp_with_coercion (struct expression *, int *, enum noside); -extern struct value *parse_and_eval (char *exp); +extern struct value *parse_and_eval (const char *exp); -extern struct value *parse_to_comma_and_eval (char **expp); +extern struct value *parse_to_comma_and_eval (const char **expp); extern struct type *parse_and_eval_type (char *p, int length); -extern CORE_ADDR parse_and_eval_address (char *exp); +extern CORE_ADDR parse_and_eval_address (const char *exp); -extern LONGEST parse_and_eval_long (char *exp); +extern LONGEST parse_and_eval_long (const char *exp); extern void unop_promote (const struct language_defn *language, struct gdbarch *gdbarch, @@ -801,10 +906,9 @@ struct internalvar_funcs void (*destroy) (void *data); }; -extern struct internalvar * -create_internalvar_type_lazy (const char *name, - const struct internalvar_funcs *funcs, - void *data); +extern struct internalvar *create_internalvar_type_lazy (const char *name, + const struct internalvar_funcs *funcs, + void *data); /* Compile an internal variable to an agent expression. VAR is the variable to compile; EXPR and VALUE are the agent expression we are @@ -894,7 +998,7 @@ extern void value_print (struct value *val, struct ui_file *stream, extern void value_print_array_elements (struct value *val, struct ui_file *stream, int format, - enum val_prettyprint pretty); + enum val_prettyformat pretty); extern struct value *value_release_to_mark (struct value *mark); @@ -934,6 +1038,8 @@ extern struct value *value_copy (struct value *); extern struct value *value_non_lval (struct value *); +extern void value_force_lval (struct value *, CORE_ADDR); + extern void preserve_one_value (struct value *, struct objfile *, htab_t); /* From valops.c */ @@ -972,4 +1078,9 @@ struct value *call_internal_function (struct gdbarch *gdbarch, char *value_internal_function_name (struct value *); +extern struct value *value_of_xmethod (struct xmethod_worker *); + +struct value *call_xmethod (struct value *function, + int argc, struct value **argv); + #endif /* !defined (VALUE_H) */