28  * Typically a value is attached to a single inferior where it was
29  * extracted from, but it is possible to create a detached value.
30  * Each value is typed.  Values support a number of routines, such as
31  * dereferencing if the value is of pointer type, array or structure
34  * A value can be uninitialized, abstract or reified.  Abstract values
37  * or otherwise set to some value.  */
41 	VAL_LOC_INFERIOR,	/* Value is in the inferior process.  */
42 	VAL_LOC_COPY,		/* Value was copied out of the inferior.  */
47 struct value {  struct
50 	struct value *parent;  argument
55 		long value;     /* VAL_LOC_WORD */  member
62 /* Initialize VALUE.  INFERIOR must not be NULL.  PARENT is parental
63  * value, in case of compound types.  It may be NULL.  TYPE is a type  argument
64  * of the value.  It may be NULL if the type is not yet known.  If
65  * OWN_TYPE, the passed-in type is owned and released by value.  */
66 void value_init(struct value *value, struct process *inferior,
67 		struct value *parent, struct arg_type_info *type,
70 /* Initialize VALUE.  This is like value_init, except that inferior is
71  * NULL.  VALP is initialized as a detached value, without assigned
73  * values if the value is detached.  */
74 void value_init_detached(struct value *value, struct value *parent,
79 void value_set_type(struct value *value,
82 /* Transfers the ownership of VALUE's type, if any, to the caller.
83  * This doesn't reset the VALUE's type, but gives up ownership if
85 void value_take_type(struct value *value,
89 void value_release(struct value *valp);
91 /* Value resides in inferior, on given ADDRESS.  */
92 void value_in_inferior(struct value *valp, arch_addr_t address);
94 /* Destroy the value.  This is like value_release, but it additionally
95  * frees the value type, if it's own_type.  It doesn't free the VAL
97 void value_destroy(struct value *val);
99 /* Set the data held by VALP to VALUE.  This also sets the value's
101 void value_set_word(struct value *valp, long value);
105 unsigned char *value_reserve(struct value *valp, size_t size);
107 /* Access ELEMENT-th field of the compound value VALP, and store the
108  * result into the value RET_VAL.  Returns 0 on success, or negative
109  * value on failure.  */
110 int value_init_element(struct value *ret_val, struct value *valp, size_t element);
112 /* De-reference pointer value, and store the result into the value
113  * RET_VAL.  Returns 0 on success, or negative value on failure.  */
114 int value_init_deref(struct value *ret_val, struct value *valp);
116 /* If value is in inferior, copy it over to ltrace.  Return 0 for
117  * success or negative value for failure.  */
118 int value_reify(struct value *val, struct value_dict *arguments);
120 /* Return a pointer to the data of the value.  This copies the data
122 unsigned char *value_get_data(struct value *val, struct value_dict *arguments);
124 /* Return a pointer to the raw data of the value.  This shall not be
125  * called on a VAL_LOC_INFERIOR value.  */
126 unsigned char *value_get_raw_data(struct value *val);
128 /* Copy value VAL into the area pointed-to by RETP.  Return 0 on
129  * success or a negative value on failure.  */
130 int value_clone(struct value *retp, const struct value *val);
132 /* Give a size of given value.  Return (size_t)-1 for error.  This is
133  * a full size of the value.  In particular for arrays, it returns
136 size_t value_size(struct value *val, struct value_dict *arguments);
138 /* Extract at most word-sized datum from the value.  Return 0 on
139  * success or negative value on failure.  */
140 int value_extract_word(struct value *val, long *retp,
145 int value_extract_buf(struct value *val, unsigned char *data,
148 /* Find the most enclosing parental value that is a struct.  Return
149  * NULL when there is no such parental value.  */
150 struct value *value_get_parental_struct(struct value *val);
152 /* Determine whether this is all-zero value.  Returns >0 if it is, ==0
154 int value_is_zero(struct value *val, struct value_dict *arguments);
158 int value_equal(struct value *val1, struct value *val2,
162 int value_pass_by_reference(struct value *value);