X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fvalue.h;h=2eac5efa05ff4b88677a876bf80edc8491061aeb;hb=38899f16e1560ce3020bab8a6a0b3a0c017d7925;hp=ef2cb4fa1dd2c5b1587fde4c9f3a7942a056e15e;hpb=4dfea5604987eeb861eccccafbfa29e38002ea25;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/value.h b/gdb/value.h index ef2cb4fa1d..2eac5efa05 100644 --- a/gdb/value.h +++ b/gdb/value.h @@ -1,8 +1,6 @@ /* Definitions for values of C expressions, for GDB. - Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008, 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 1986-2016 Free Software Foundation, Inc. This file is part of GDB. @@ -33,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 @@ -52,6 +99,10 @@ struct value *value_next (struct value *); 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). */ @@ -76,6 +127,7 @@ extern void set_value_bitpos (struct value *, int bit); bitfields. */ struct value *value_parent (struct value *); +extern void set_value_parent (struct value *value, struct value *parent); /* Describes offset of a value within lval of a structure in bytes. If lval == lval_memory, this is an offset to the address. If lval @@ -91,8 +143,6 @@ extern void set_value_offset (struct value *, int offset); not_lval and be done with it? */ extern int deprecated_value_modifiable (struct value *value); -extern void deprecated_set_value_modifiable (struct value *value, - int modifiable); /* If a value represents a C++ object, then the `type' field gives the object's compile-time type. If the object actually belongs to some @@ -139,6 +189,22 @@ extern struct type *value_enclosing_type (struct value *); extern void set_value_enclosing_type (struct value *val, struct type *new_type); +/* Returns value_type or value_enclosing_type depending on + value_print_options.objectprint. + + If RESOLVE_SIMPLE_TYPES is 0 the enclosing type will be resolved + only for pointers and references, else it will be returned + for all the types (e.g. structures). This option is useful + to prevent retrieving enclosing type for the base classes fields. + + REAL_TYPE_FOUND is used to inform whether the real type was found + (or just static type was used). The NULL may be passed if it is not + necessary. */ + +extern struct type *value_actual_type (struct value *value, + int resolve_simple_types, + int *real_type_found); + extern int value_pointed_to_offset (struct value *value); extern void set_value_pointed_to_offset (struct value *value, int val); extern int value_embedded_offset (struct value *value); @@ -156,22 +222,31 @@ struct lval_funcs { /* Fill in VALUE's contents. This is used to "un-lazy" values. If a problem arises in obtaining VALUE's bits, this function should - call 'error'. */ + call 'error'. If it is NULL value_fetch_lazy on "un-lazy" + non-optimized-out value is an internal error. */ void (*read) (struct value *v); /* Handle an assignment TOVAL = FROMVAL by writing the value of FROMVAL to TOVAL's location. The contents of TOVAL have not yet been updated. If a problem arises in doing so, this function - should call 'error'. */ + should call 'error'. If it is NULL such TOVAL assignment is an error as + 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); + /* 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. */ + struct value *(*indirect) (struct value *value); + + /* If non-NULL, this is used to implement reference resolving for + this value. This method may return NULL, in which case coerce_ref + will fall back to ordinary references resolving. */ + struct value *(*coerce_ref) (const struct value *value); - /* 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 determine whether the indicated bits + of VALUE are a synthetic pointer. */ + int (*check_synthetic_pointer) (const struct value *value, + int offset, int length); /* Return a duplicate of VALUE's closure, for use in a new value. This may simply return the same closure, if VALUE's is @@ -194,12 +269,28 @@ struct lval_funcs and closure CLOSURE. */ extern struct value *allocate_computed_value (struct type *type, - struct lval_funcs *funcs, - void *closure); + 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, + int 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. */ -extern struct lval_funcs *value_computed_funcs (struct value *value); +extern const struct lval_funcs *value_computed_funcs (const struct value *); /* If VALUE is lval_computed, return its closure. The meaning of the returned value depends on the functions VALUE uses. */ @@ -227,6 +318,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 @@ -263,20 +359,44 @@ extern const gdb_byte *value_contents_all (struct value *); plan to check the validity manually. */ extern const gdb_byte *value_contents_for_printing (struct value *value); -extern int value_fetch_lazy (struct value *val); -extern int value_contents_equal (struct value *val1, struct value *val2); +/* 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 * + value_contents_for_printing_const (const struct value *value); + +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. */ + 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. + not, based on debugging information supplied by the compiler. 1 = initialized; 0 = uninitialized. */ extern int value_initialized (struct value *); extern void set_value_initialized (struct value *, int); @@ -294,11 +414,14 @@ extern void set_value_component_location (struct value *component, extern enum lval_type *deprecated_value_lval_hack (struct value *); #define VALUE_LVAL(val) (*deprecated_value_lval_hack (val)) +/* Like VALUE_LVAL, except the parameter can be const. */ +extern enum lval_type value_lval_const (const struct value *value); + /* If lval == lval_memory, return the address in the inferior. If lval == lval_register, return the byte offset into the registers structure. Otherwise, return 0. The returned address includes the offset, if any. */ -extern CORE_ADDR value_address (struct value *); +extern CORE_ADDR value_address (const struct value *); /* Like value_address, except the result does not include value's offset. */ @@ -320,6 +443,24 @@ extern struct frame_id *deprecated_value_frame_id_hack (struct value *); extern short *deprecated_value_regnum_hack (struct value *); #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val)) +/* Return value after lval_funcs->coerce_ref (after check_typedef). Return + NULL if lval_funcs->coerce_ref is not applicable for whatever reason. */ + +extern struct value *coerce_ref_if_computed (const struct value *arg); + +/* 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. + + Note, that VALUE is modified by this function. + + It is a common implementation for coerce_ref and value_ind. */ + +extern struct value * readjust_indirect_value_type (struct value *value, + struct type *enc_type, + struct type *original_type, + struct value *original_val); + /* Convert a REF to the object referenced. */ extern struct value *coerce_ref (struct value *value); @@ -332,11 +473,120 @@ 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. */ + extending for LENGTH bits are a synthetic pointer. */ + +extern int value_bits_synthetic_pointer (const struct value *value, + int offset, int length); + +/* Given a value, determine whether the contents bytes starting at + OFFSET and extending for LENGTH bytes are available. This returns + nonzero if all bytes in the given range are available, zero if any + byte is unavailable. */ + +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); -extern int value_bits_valid (const 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. + + Note that "contents" refers to the whole value's contents + (value_contents_all), without any embedded offset adjustment. For + 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))); + 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. + + 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_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 + is known to be stack memory. */ + +extern void read_value_memory (struct value *val, int embedded_offset, + int stack, CORE_ADDR memaddr, + gdb_byte *buffer, size_t length); + +/* Cast SCALAR_VALUE to the element type of VECTOR_TYPE, then replicate + into each element of a new vector value with VECTOR_TYPE. */ + +struct value *value_vector_widen (struct value *scalar_value, + struct type *vector_type); @@ -347,8 +597,9 @@ extern int value_bits_valid (const struct value *value, struct frame_info; struct fn_field; -extern void print_address_demangle (struct gdbarch *, CORE_ADDR, - struct ui_file *, int); +extern int print_address_demangle (const struct value_print_options *, + struct gdbarch *, CORE_ADDR, + struct ui_file *, int); extern LONGEST value_as_long (struct value *val); extern DOUBLEST value_as_double (struct value *val); @@ -358,11 +609,23 @@ 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); -LONGEST unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr, - int bitpos, int bitsize); + extern LONGEST unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno); +extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr, + 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, + const struct value *val); extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num); @@ -372,27 +635,37 @@ 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 (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, struct block *b); +extern struct value *value_of_variable (struct symbol *var, + const struct block *b); -extern struct value *address_of_variable (struct symbol *var, 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); @@ -401,11 +674,21 @@ struct value *value_of_register_lazy (struct frame_info *frame, int regnum); 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 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); +extern void value_contents_copy_raw (struct value *dst, int dst_offset, + struct value *src, int src_offset, + int length); extern struct value *allocate_repeat_value (struct type *type, int count); @@ -413,12 +696,10 @@ extern struct value *value_mark (void); extern void value_free_to_mark (struct value *mark); -extern struct value *value_cstring (char *ptr, int len, +extern struct value *value_cstring (const char *ptr, ssize_t len, struct type *char_type); -extern struct value *value_string (char *ptr, int len, +extern struct value *value_string (const char *ptr, ssize_t len, struct type *char_type); -extern struct value *value_bitstring (char *ptr, int len, - struct type *index_type); extern struct value *value_array (int lowbound, int highbound, struct value **elemvec); @@ -460,27 +741,28 @@ 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); extern struct value *value_static_field (struct type *type, int fieldno); -extern struct fn_field *value_find_oload_method_list (struct value **, - const char *, - int, int *, - struct type **, int *); - enum oload_search_type { NON_METHOD, METHOD, BOTH }; -extern int find_overload_match (struct type **arg_types, int nargs, +extern int find_overload_match (struct value **args, int nargs, const char *name, - enum oload_search_type method, int lax, + 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); @@ -489,13 +771,13 @@ extern struct value *value_primitive_field (struct value *arg1, int offset, struct type *arg_type); -extern struct type *value_rtti_target_type (struct value *, int *, int *, - int *); +extern struct type *value_rtti_indirect_type (struct value *, int *, int *, + int *); extern struct value *value_full_object (struct value *, struct type *, int, int, int); -extern struct value *value_cast_pointers (struct type *, struct value *); +extern struct value *value_cast_pointers (struct type *, struct value *, int); extern struct value *value_cast (struct type *type, struct value *arg2); @@ -506,7 +788,7 @@ extern struct value *value_dynamic_cast (struct type *type, struct value *arg); extern struct value *value_zero (struct type *type, enum lval_type lv); -extern struct value *value_one (struct type *type, enum lval_type lv); +extern struct value *value_one (struct type *type); extern struct value *value_repeat (struct value *arg1, int count); @@ -524,8 +806,12 @@ extern int value_in (struct value *element, struct value *set); extern int value_bit_index (struct type *type, const gdb_byte *addr, int index); +extern enum return_value_convention +struct_return_convention (struct gdbarch *gdbarch, struct value *function, + struct type *value_type); + extern int using_struct_return (struct gdbarch *gdbarch, - struct type *func_type, + struct value *function, struct type *value_type); extern struct value *evaluate_expression (struct expression *exp); @@ -541,24 +827,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 CORE_ADDR parse_and_eval_address_1 (char **expptr); - -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, @@ -593,10 +878,53 @@ extern struct internalvar *lookup_only_internalvar (const char *name); extern struct internalvar *create_internalvar (const char *name); -typedef struct value * (*internalvar_make_value) (struct gdbarch *, - struct internalvar *); -extern struct internalvar * - create_internalvar_type_lazy (char *name, internalvar_make_value fun); +extern VEC (char_ptr) *complete_internalvar (const char *name); + +/* An internalvar can be dynamically computed by supplying a vector of + function pointers to perform various operations. */ + +struct internalvar_funcs +{ + /* Compute the value of the variable. The DATA argument passed to + the function is the same argument that was passed to + `create_internalvar_type_lazy'. */ + + struct value *(*make_value) (struct gdbarch *arch, + struct internalvar *var, + void *data); + + /* Update the agent expression EXPR with bytecode to compute the + value. VALUE is the agent value we are updating. The DATA + argument passed to this function is the same argument that was + passed to `create_internalvar_type_lazy'. If this pointer is + NULL, then the internalvar cannot be compiled to an agent + expression. */ + + void (*compile_to_ax) (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, + 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 + updating. This will return 0 if there is no known way to compile + VAR, and 1 if VAR was successfully compiled. It may also throw an + exception on error. */ + +extern int compile_internalvar_to_ax (struct internalvar *var, + struct agent_expr *expr, + struct axs_value *value); extern struct internalvar *lookup_internalvar (const char *name); @@ -610,7 +938,9 @@ extern int value_logical_not (struct value *arg1); /* C++ */ -extern struct value *value_of_this (int complain); +extern struct value *value_of_this (const struct language_defn *lang); + +extern struct value *value_of_this_silent (const struct language_defn *lang); extern struct value *value_x_binop (struct value *arg1, struct value *arg2, enum exp_opcode op, @@ -632,7 +962,7 @@ extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1, extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1); -extern int destructor_name_p (const char *name, const struct type *type); +extern int destructor_name_p (const char *name, struct type *type); extern void value_incref (struct value *val); @@ -644,12 +974,14 @@ 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 int record_latest_value (struct value *val); extern void modify_field (struct type *type, gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize); -extern void type_print (struct type *type, char *varstring, +extern void type_print (struct type *type, const char *varstring, struct ui_file *stream, int show); extern char *type_to_string (struct type *type); @@ -667,26 +999,26 @@ extern void print_floating (const gdb_byte *valaddr, struct type *type, extern void print_decimal_floating (const gdb_byte *valaddr, struct type *type, struct ui_file *stream); -extern int value_print (struct value *val, struct ui_file *stream, - const struct value_print_options *options); +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_prettyprint pretty); + enum val_prettyformat pretty); extern struct value *value_release_to_mark (struct value *mark); -extern int val_print (struct type *type, const gdb_byte *valaddr, - int embedded_offset, CORE_ADDR address, - struct ui_file *stream, int recurse, - const struct value *val, - const struct value_print_options *options, - const struct language_defn *language); +extern void val_print (struct type *type, const gdb_byte *valaddr, + int embedded_offset, CORE_ADDR address, + struct ui_file *stream, int recurse, + const struct value *val, + const struct value_print_options *options, + const struct language_defn *language); -extern int common_val_print (struct value *val, - struct ui_file *stream, int recurse, - 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, + const struct language_defn *language); extern int val_print_string (struct type *elttype, const char *encoding, CORE_ADDR addr, int len, @@ -699,8 +1031,6 @@ extern void print_variable_and_value (const char *name, struct ui_file *stream, int indent); -extern int check_field (struct type *, const char *); - extern void typedef_print (struct type *type, struct symbol *news, struct ui_file *stream); @@ -714,6 +1044,10 @@ 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 struct value *make_cv_value (int, int, struct value *); + extern void preserve_one_value (struct value *, struct objfile *, htab_t); /* From valops.c */ @@ -730,8 +1064,6 @@ extern struct value *find_function_in_inferior (const char *, extern struct value *value_allocate_space_in_inferior (int); -extern struct value *value_of_local (const char *name, int complain); - extern struct value *value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound); @@ -754,4 +1086,12 @@ struct value *call_internal_function (struct gdbarch *gdbarch, 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) */