]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - gdb/value.h
Use new_reference for struct value
[thirdparty/binutils-gdb.git] / gdb / value.h
1 /* Definitions for values of C expressions, for GDB.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #if !defined (VALUE_H)
21 #define VALUE_H 1
22
23 #include "frame.h" /* For struct frame_id. */
24 #include "extension.h"
25 #include "common/gdb_ref_ptr.h"
26
27 struct block;
28 struct expression;
29 struct regcache;
30 struct symbol;
31 struct type;
32 struct ui_file;
33 struct language_defn;
34 struct value_print_options;
35
36 /* Values can be partially 'optimized out' and/or 'unavailable'.
37 These are distinct states and have different string representations
38 and related error strings.
39
40 'unavailable' has a specific meaning in this context. It means the
41 value exists in the program (at the machine level), but GDB has no
42 means to get to it. Such a value is normally printed as
43 <unavailable>. Examples of how to end up with an unavailable value
44 would be:
45
46 - We're inspecting a traceframe, and the memory or registers the
47 debug information says the value lives on haven't been collected.
48
49 - We're inspecting a core dump, the memory or registers the debug
50 information says the value lives aren't present in the dump
51 (that is, we have a partial/trimmed core dump, or we don't fully
52 understand/handle the core dump's format).
53
54 - We're doing live debugging, but the debug API has no means to
55 get at where the value lives in the machine, like e.g., ptrace
56 not having access to some register or register set.
57
58 - Any other similar scenario.
59
60 OTOH, "optimized out" is about what the compiler decided to generate
61 (or not generate). A chunk of a value that was optimized out does
62 not actually exist in the program. There's no way to get at it
63 short of compiling the program differently.
64
65 A register that has not been saved in a frame is likewise considered
66 optimized out, except not-saved registers have a different string
67 representation and related error strings. E.g., we'll print them as
68 <not-saved> instead of <optimized out>, as in:
69
70 (gdb) p/x $rax
71 $1 = <not saved>
72 (gdb) info registers rax
73 rax <not saved>
74
75 If the debug info describes a variable as being in such a register,
76 we'll still print the variable as <optimized out>. IOW, <not saved>
77 is reserved for inspecting registers at the machine level.
78
79 When comparing value contents, optimized out chunks, unavailable
80 chunks, and valid contents data are all considered different. See
81 value_contents_eq for more info.
82 */
83
84 /* The structure which defines the type of a value. It should never
85 be possible for a program lval value to survive over a call to the
86 inferior (i.e. to be put into the history list or an internal
87 variable). */
88
89 struct value;
90
91 /* Increase VAL's reference count. */
92
93 extern void value_incref (struct value *val);
94
95 /* Decrease VAL's reference count. When the reference count drops to
96 0, VAL will be freed. */
97
98 extern void value_decref (struct value *val);
99
100 /* A policy class to interface gdb::ref_ptr with struct value. */
101
102 struct value_ref_policy
103 {
104 static void incref (struct value *ptr)
105 {
106 value_incref (ptr);
107 }
108
109 static void decref (struct value *ptr)
110 {
111 value_decref (ptr);
112 }
113 };
114
115 /* A gdb:;ref_ptr pointer to a struct value. */
116
117 typedef gdb::ref_ptr<struct value, value_ref_policy> value_ref_ptr;
118
119 /* Values are stored in a chain, so that they can be deleted easily
120 over calls to the inferior. Values assigned to internal variables,
121 put into the value history or exposed to Python are taken off this
122 list. */
123
124 struct value *value_next (const struct value *);
125
126 /* Type of the value. */
127
128 extern struct type *value_type (const struct value *);
129
130 /* Return the gdbarch associated with the value. */
131
132 extern struct gdbarch *get_value_arch (const struct value *value);
133
134 /* This is being used to change the type of an existing value, that
135 code should instead be creating a new value with the changed type
136 (but possibly shared content). */
137
138 extern void deprecated_set_value_type (struct value *value,
139 struct type *type);
140
141 /* Only used for bitfields; number of bits contained in them. */
142
143 extern LONGEST value_bitsize (const struct value *);
144 extern void set_value_bitsize (struct value *, LONGEST bit);
145
146 /* Only used for bitfields; position of start of field. For
147 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
148 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
149
150 extern LONGEST value_bitpos (const struct value *);
151 extern void set_value_bitpos (struct value *, LONGEST bit);
152
153 /* Only used for bitfields; the containing value. This allows a
154 single read from the target when displaying multiple
155 bitfields. */
156
157 struct value *value_parent (const struct value *);
158 extern void set_value_parent (struct value *value, struct value *parent);
159
160 /* Describes offset of a value within lval of a structure in bytes.
161 If lval == lval_memory, this is an offset to the address. If lval
162 == lval_register, this is a further offset from location.address
163 within the registers structure. Note also the member
164 embedded_offset below. */
165
166 extern LONGEST value_offset (const struct value *);
167 extern void set_value_offset (struct value *, LONGEST offset);
168
169 /* The comment from "struct value" reads: ``Is it modifiable? Only
170 relevant if lval != not_lval.''. Shouldn't the value instead be
171 not_lval and be done with it? */
172
173 extern int deprecated_value_modifiable (const struct value *value);
174
175 /* If a value represents a C++ object, then the `type' field gives the
176 object's compile-time type. If the object actually belongs to some
177 class derived from `type', perhaps with other base classes and
178 additional members, then `type' is just a subobject of the real
179 thing, and the full object is probably larger than `type' would
180 suggest.
181
182 If `type' is a dynamic class (i.e. one with a vtable), then GDB can
183 actually determine the object's run-time type by looking at the
184 run-time type information in the vtable. When this information is
185 available, we may elect to read in the entire object, for several
186 reasons:
187
188 - When printing the value, the user would probably rather see the
189 full object, not just the limited portion apparent from the
190 compile-time type.
191
192 - If `type' has virtual base classes, then even printing `type'
193 alone may require reaching outside the `type' portion of the
194 object to wherever the virtual base class has been stored.
195
196 When we store the entire object, `enclosing_type' is the run-time
197 type -- the complete object -- and `embedded_offset' is the offset
198 of `type' within that larger type, in bytes. The value_contents()
199 macro takes `embedded_offset' into account, so most GDB code
200 continues to see the `type' portion of the value, just as the
201 inferior would.
202
203 If `type' is a pointer to an object, then `enclosing_type' is a
204 pointer to the object's run-time type, and `pointed_to_offset' is
205 the offset in bytes from the full object to the pointed-to object
206 -- that is, the value `embedded_offset' would have if we followed
207 the pointer and fetched the complete object. (I don't really see
208 the point. Why not just determine the run-time type when you
209 indirect, and avoid the special case? The contents don't matter
210 until you indirect anyway.)
211
212 If we're not doing anything fancy, `enclosing_type' is equal to
213 `type', and `embedded_offset' is zero, so everything works
214 normally. */
215
216 extern struct type *value_enclosing_type (const struct value *);
217 extern void set_value_enclosing_type (struct value *val,
218 struct type *new_type);
219
220 /* Returns value_type or value_enclosing_type depending on
221 value_print_options.objectprint.
222
223 If RESOLVE_SIMPLE_TYPES is 0 the enclosing type will be resolved
224 only for pointers and references, else it will be returned
225 for all the types (e.g. structures). This option is useful
226 to prevent retrieving enclosing type for the base classes fields.
227
228 REAL_TYPE_FOUND is used to inform whether the real type was found
229 (or just static type was used). The NULL may be passed if it is not
230 necessary. */
231
232 extern struct type *value_actual_type (struct value *value,
233 int resolve_simple_types,
234 int *real_type_found);
235
236 extern LONGEST value_pointed_to_offset (const struct value *value);
237 extern void set_value_pointed_to_offset (struct value *value, LONGEST val);
238 extern LONGEST value_embedded_offset (const struct value *value);
239 extern void set_value_embedded_offset (struct value *value, LONGEST val);
240
241 /* For lval_computed values, this structure holds functions used to
242 retrieve and set the value (or portions of the value).
243
244 For each function, 'V' is the 'this' pointer: an lval_funcs
245 function F may always assume that the V it receives is an
246 lval_computed value, and has F in the appropriate slot of its
247 lval_funcs structure. */
248
249 struct lval_funcs
250 {
251 /* Fill in VALUE's contents. This is used to "un-lazy" values. If
252 a problem arises in obtaining VALUE's bits, this function should
253 call 'error'. If it is NULL value_fetch_lazy on "un-lazy"
254 non-optimized-out value is an internal error. */
255 void (*read) (struct value *v);
256
257 /* Handle an assignment TOVAL = FROMVAL by writing the value of
258 FROMVAL to TOVAL's location. The contents of TOVAL have not yet
259 been updated. If a problem arises in doing so, this function
260 should call 'error'. If it is NULL such TOVAL assignment is an error as
261 TOVAL is not considered as an lvalue. */
262 void (*write) (struct value *toval, struct value *fromval);
263
264 /* If non-NULL, this is used to implement pointer indirection for
265 this value. This method may return NULL, in which case value_ind
266 will fall back to ordinary indirection. */
267 struct value *(*indirect) (struct value *value);
268
269 /* If non-NULL, this is used to implement reference resolving for
270 this value. This method may return NULL, in which case coerce_ref
271 will fall back to ordinary references resolving. */
272 struct value *(*coerce_ref) (const struct value *value);
273
274 /* If non-NULL, this is used to determine whether the indicated bits
275 of VALUE are a synthetic pointer. */
276 int (*check_synthetic_pointer) (const struct value *value,
277 LONGEST offset, int length);
278
279 /* Return a duplicate of VALUE's closure, for use in a new value.
280 This may simply return the same closure, if VALUE's is
281 reference-counted or statically allocated.
282
283 This may be NULL, in which case VALUE's closure is re-used in the
284 new value. */
285 void *(*copy_closure) (const struct value *v);
286
287 /* Drop VALUE's reference to its closure. Maybe this frees the
288 closure; maybe this decrements a reference count; maybe the
289 closure is statically allocated and this does nothing.
290
291 This may be NULL, in which case no action is taken to free
292 VALUE's closure. */
293 void (*free_closure) (struct value *v);
294 };
295
296 /* Create a computed lvalue, with type TYPE, function pointers FUNCS,
297 and closure CLOSURE. */
298
299 extern struct value *allocate_computed_value (struct type *type,
300 const struct lval_funcs *funcs,
301 void *closure);
302
303 /* Helper function to check the validity of some bits of a value.
304
305 If TYPE represents some aggregate type (e.g., a structure), return 1.
306
307 Otherwise, any of the bytes starting at OFFSET and extending for
308 TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
309 return 0. The checking is done using FUNCS.
310
311 Otherwise, return 1. */
312
313 extern int valprint_check_validity (struct ui_file *stream, struct type *type,
314 LONGEST embedded_offset,
315 const struct value *val);
316
317 extern struct value *allocate_optimized_out_value (struct type *type);
318
319 /* If VALUE is lval_computed, return its lval_funcs structure. */
320
321 extern const struct lval_funcs *value_computed_funcs (const struct value *);
322
323 /* If VALUE is lval_computed, return its closure. The meaning of the
324 returned value depends on the functions VALUE uses. */
325
326 extern void *value_computed_closure (const struct value *value);
327
328 /* If zero, contents of this value are in the contents field. If
329 nonzero, contents are in inferior. If the lval field is lval_memory,
330 the contents are in inferior memory at location.address plus offset.
331 The lval field may also be lval_register.
332
333 WARNING: This field is used by the code which handles watchpoints
334 (see breakpoint.c) to decide whether a particular value can be
335 watched by hardware watchpoints. If the lazy flag is set for some
336 member of a value chain, it is assumed that this member of the
337 chain doesn't need to be watched as part of watching the value
338 itself. This is how GDB avoids watching the entire struct or array
339 when the user wants to watch a single struct member or array
340 element. If you ever change the way lazy flag is set and reset, be
341 sure to consider this use as well! */
342
343 extern int value_lazy (const struct value *);
344 extern void set_value_lazy (struct value *value, int val);
345
346 extern int value_stack (const struct value *);
347 extern void set_value_stack (struct value *value, int val);
348
349 /* Throw an error complaining that the value has been optimized
350 out. */
351
352 extern void error_value_optimized_out (void);
353
354 /* value_contents() and value_contents_raw() both return the address
355 of the gdb buffer used to hold a copy of the contents of the lval.
356 value_contents() is used when the contents of the buffer are needed
357 -- it uses value_fetch_lazy() to load the buffer from the process
358 being debugged if it hasn't already been loaded
359 (value_contents_writeable() is used when a writeable but fetched
360 buffer is required).. value_contents_raw() is used when data is
361 being stored into the buffer, or when it is certain that the
362 contents of the buffer are valid.
363
364 Note: The contents pointer is adjusted by the offset required to
365 get to the real subobject, if the value happens to represent
366 something embedded in a larger run-time object. */
367
368 extern gdb_byte *value_contents_raw (struct value *);
369
370 /* Actual contents of the value. For use of this value; setting it
371 uses the stuff above. Not valid if lazy is nonzero. Target
372 byte-order. We force it to be aligned properly for any possible
373 value. Note that a value therefore extends beyond what is
374 declared here. */
375
376 extern const gdb_byte *value_contents (struct value *);
377 extern gdb_byte *value_contents_writeable (struct value *);
378
379 /* The ALL variants of the above two macros do not adjust the returned
380 pointer by the embedded_offset value. */
381
382 extern gdb_byte *value_contents_all_raw (struct value *);
383 extern const gdb_byte *value_contents_all (struct value *);
384
385 /* Like value_contents_all, but does not require that the returned
386 bits be valid. This should only be used in situations where you
387 plan to check the validity manually. */
388 extern const gdb_byte *value_contents_for_printing (struct value *value);
389
390 /* Like value_contents_for_printing, but accepts a constant value
391 pointer. Unlike value_contents_for_printing however, the pointed
392 value must _not_ be lazy. */
393 extern const gdb_byte *
394 value_contents_for_printing_const (const struct value *value);
395
396 extern void value_fetch_lazy (struct value *val);
397
398 /* If nonzero, this is the value of a variable which does not actually
399 exist in the program, at least partially. If the value is lazy,
400 this may fetch it now. */
401 extern int value_optimized_out (struct value *value);
402
403 /* Given a value, return true if any of the contents bits starting at
404 OFFSET and extending for LENGTH bits is optimized out, false
405 otherwise. */
406
407 extern int value_bits_any_optimized_out (const struct value *value,
408 int bit_offset, int bit_length);
409
410 /* Like value_optimized_out, but return true iff the whole value is
411 optimized out. */
412 extern int value_entirely_optimized_out (struct value *value);
413
414 /* Mark VALUE's content bytes starting at OFFSET and extending for
415 LENGTH bytes as optimized out. */
416
417 extern void mark_value_bytes_optimized_out (struct value *value,
418 int offset, int length);
419
420 /* Mark VALUE's content bits starting at OFFSET and extending for
421 LENGTH bits as optimized out. */
422
423 extern void mark_value_bits_optimized_out (struct value *value,
424 LONGEST offset, LONGEST length);
425
426 /* Set or return field indicating whether a variable is initialized or
427 not, based on debugging information supplied by the compiler.
428 1 = initialized; 0 = uninitialized. */
429 extern int value_initialized (const struct value *);
430 extern void set_value_initialized (struct value *, int);
431
432 /* Set COMPONENT's location as appropriate for a component of WHOLE
433 --- regardless of what kind of lvalue WHOLE is. */
434 extern void set_value_component_location (struct value *component,
435 const struct value *whole);
436
437 /* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
438 single value might have multiple LVALs), this hacked interface is
439 limited to just the first PIECE. Expect further change. */
440 /* Type of value; either not an lval, or one of the various different
441 possible kinds of lval. */
442 extern enum lval_type *deprecated_value_lval_hack (struct value *);
443 #define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
444
445 /* Like VALUE_LVAL, except the parameter can be const. */
446 extern enum lval_type value_lval_const (const struct value *value);
447
448 /* If lval == lval_memory, return the address in the inferior. If
449 lval == lval_register, return the byte offset into the registers
450 structure. Otherwise, return 0. The returned address
451 includes the offset, if any. */
452 extern CORE_ADDR value_address (const struct value *);
453
454 /* Like value_address, except the result does not include value's
455 offset. */
456 extern CORE_ADDR value_raw_address (const struct value *);
457
458 /* Set the address of a value. */
459 extern void set_value_address (struct value *, CORE_ADDR);
460
461 /* Pointer to internal variable. */
462 extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
463 #define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))
464
465 /* Frame ID of "next" frame to which a register value is relative. A
466 register value is indicated by VALUE_LVAL being set to lval_register.
467 So, if the register value is found relative to frame F, then the
468 frame id of F->next will be stored in VALUE_NEXT_FRAME_ID. */
469 extern struct frame_id *deprecated_value_next_frame_id_hack (struct value *);
470 #define VALUE_NEXT_FRAME_ID(val) (*deprecated_value_next_frame_id_hack (val))
471
472 /* Frame ID of frame to which a register value is relative. This is
473 similar to VALUE_NEXT_FRAME_ID, above, but may not be assigned to.
474 Note that VALUE_FRAME_ID effectively undoes the "next" operation
475 that was performed during the assignment to VALUE_NEXT_FRAME_ID. */
476 #define VALUE_FRAME_ID(val) (get_prev_frame_id_by_id (VALUE_NEXT_FRAME_ID (val)))
477
478 /* Register number if the value is from a register. */
479 extern int *deprecated_value_regnum_hack (struct value *);
480 #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
481
482 /* Return value after lval_funcs->coerce_ref (after check_typedef). Return
483 NULL if lval_funcs->coerce_ref is not applicable for whatever reason. */
484
485 extern struct value *coerce_ref_if_computed (const struct value *arg);
486
487 /* Setup a new value type and enclosing value type for dereferenced value VALUE.
488 ENC_TYPE is the new enclosing type that should be set. ORIGINAL_TYPE and
489 ORIGINAL_VAL are the type and value of the original reference or pointer.
490
491 Note, that VALUE is modified by this function.
492
493 It is a common implementation for coerce_ref and value_ind. */
494
495 extern struct value * readjust_indirect_value_type (struct value *value,
496 struct type *enc_type,
497 const struct type *original_type,
498 const struct value *original_val);
499
500 /* Convert a REF to the object referenced. */
501
502 extern struct value *coerce_ref (struct value *value);
503
504 /* If ARG is an array, convert it to a pointer.
505 If ARG is a function, convert it to a function pointer.
506
507 References are dereferenced. */
508
509 extern struct value *coerce_array (struct value *value);
510
511 /* Given a value, determine whether the bits starting at OFFSET and
512 extending for LENGTH bits are a synthetic pointer. */
513
514 extern int value_bits_synthetic_pointer (const struct value *value,
515 LONGEST offset, LONGEST length);
516
517 /* Given a value, determine whether the contents bytes starting at
518 OFFSET and extending for LENGTH bytes are available. This returns
519 nonzero if all bytes in the given range are available, zero if any
520 byte is unavailable. */
521
522 extern int value_bytes_available (const struct value *value,
523 LONGEST offset, LONGEST length);
524
525 /* Given a value, determine whether the contents bits starting at
526 OFFSET and extending for LENGTH bits are available. This returns
527 nonzero if all bits in the given range are available, zero if any
528 bit is unavailable. */
529
530 extern int value_bits_available (const struct value *value,
531 LONGEST offset, LONGEST length);
532
533 /* Like value_bytes_available, but return false if any byte in the
534 whole object is unavailable. */
535 extern int value_entirely_available (struct value *value);
536
537 /* Like value_entirely_available, but return false if any byte in the
538 whole object is available. */
539 extern int value_entirely_unavailable (struct value *value);
540
541 /* Mark VALUE's content bytes starting at OFFSET and extending for
542 LENGTH bytes as unavailable. */
543
544 extern void mark_value_bytes_unavailable (struct value *value,
545 LONGEST offset, LONGEST length);
546
547 /* Mark VALUE's content bits starting at OFFSET and extending for
548 LENGTH bits as unavailable. */
549
550 extern void mark_value_bits_unavailable (struct value *value,
551 LONGEST offset, LONGEST length);
552
553 /* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
554 LENGTH bytes of VAL2's contents starting at OFFSET2.
555
556 Note that "contents" refers to the whole value's contents
557 (value_contents_all), without any embedded offset adjustment. For
558 example, to compare a complete object value with itself, including
559 its enclosing type chunk, you'd do:
560
561 int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
562 value_contents_eq (val, 0, val, 0, len);
563
564 Returns true iff the set of available/valid contents match.
565
566 Optimized-out contents are equal to optimized-out contents, and are
567 not equal to non-optimized-out contents.
568
569 Unavailable contente are equal to unavailable contents, and are not
570 equal to non-unavailable contents.
571
572 For example, if 'x's represent an unavailable byte, and 'V' and 'Z'
573 represent different available/valid bytes, in a value with length
574 16:
575
576 offset: 0 4 8 12 16
577 contents: xxxxVVVVxxxxVVZZ
578
579 then:
580
581 value_contents_eq(val, 0, val, 8, 6) => true
582 value_contents_eq(val, 0, val, 4, 4) => false
583 value_contents_eq(val, 0, val, 8, 8) => false
584 value_contents_eq(val, 4, val, 12, 2) => true
585 value_contents_eq(val, 4, val, 12, 4) => true
586 value_contents_eq(val, 3, val, 4, 4) => true
587
588 If 'x's represent an unavailable byte, 'o' represents an optimized
589 out byte, in a value with length 8:
590
591 offset: 0 4 8
592 contents: xxxxoooo
593
594 then:
595
596 value_contents_eq(val, 0, val, 2, 2) => true
597 value_contents_eq(val, 4, val, 6, 2) => true
598 value_contents_eq(val, 0, val, 4, 4) => true
599
600 We only know whether a value chunk is unavailable or optimized out
601 if we've tried to read it. As this routine is used by printing
602 routines, which may be printing values in the value history, long
603 after the inferior is gone, it works with const values. Therefore,
604 this routine must not be called with lazy values. */
605
606 extern bool value_contents_eq (const struct value *val1, LONGEST offset1,
607 const struct value *val2, LONGEST offset2,
608 LONGEST length);
609
610 /* Read LENGTH addressable memory units starting at MEMADDR into BUFFER,
611 which is (or will be copied to) VAL's contents buffer offset by
612 BIT_OFFSET bits. Marks value contents ranges as unavailable if
613 the corresponding memory is likewise unavailable. STACK indicates
614 whether the memory is known to be stack memory. */
615
616 extern void read_value_memory (struct value *val, LONGEST bit_offset,
617 int stack, CORE_ADDR memaddr,
618 gdb_byte *buffer, size_t length);
619
620 /* Cast SCALAR_VALUE to the element type of VECTOR_TYPE, then replicate
621 into each element of a new vector value with VECTOR_TYPE. */
622
623 struct value *value_vector_widen (struct value *scalar_value,
624 struct type *vector_type);
625
626 \f
627
628 #include "symtab.h"
629 #include "gdbtypes.h"
630 #include "expression.h"
631
632 struct frame_info;
633 struct fn_field;
634
635 extern int print_address_demangle (const struct value_print_options *,
636 struct gdbarch *, CORE_ADDR,
637 struct ui_file *, int);
638
639 /* Returns true if VAL is of floating-point type. In addition,
640 throws an error if the value is an invalid floating-point value. */
641 extern bool is_floating_value (struct value *val);
642
643 extern LONGEST value_as_long (struct value *val);
644 extern CORE_ADDR value_as_address (struct value *val);
645
646 extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
647 extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
648
649 extern LONGEST unpack_field_as_long (struct type *type,
650 const gdb_byte *valaddr,
651 int fieldno);
652 extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
653 LONGEST embedded_offset, int fieldno,
654 const struct value *val, LONGEST *result);
655
656 extern void unpack_value_bitfield (struct value *dest_val,
657 LONGEST bitpos, LONGEST bitsize,
658 const gdb_byte *valaddr,
659 LONGEST embedded_offset,
660 const struct value *val);
661
662 extern struct value *value_field_bitfield (struct type *type, int fieldno,
663 const gdb_byte *valaddr,
664 LONGEST embedded_offset,
665 const struct value *val);
666
667 extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
668
669 extern struct value *value_from_longest (struct type *type, LONGEST num);
670 extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
671 extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
672 extern struct value *value_from_history_ref (const char *, const char **);
673 extern struct value *value_from_component (struct value *, struct type *,
674 LONGEST);
675
676 extern struct value *value_at (struct type *type, CORE_ADDR addr);
677 extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
678
679 extern struct value *value_from_contents_and_address_unresolved
680 (struct type *, const gdb_byte *, CORE_ADDR);
681 extern struct value *value_from_contents_and_address (struct type *,
682 const gdb_byte *,
683 CORE_ADDR);
684 extern struct value *value_from_contents (struct type *, const gdb_byte *);
685
686 extern struct value *default_value_from_register (struct gdbarch *gdbarch,
687 struct type *type,
688 int regnum,
689 struct frame_id frame_id);
690
691 extern void read_frame_register_value (struct value *value,
692 struct frame_info *frame);
693
694 extern struct value *value_from_register (struct type *type, int regnum,
695 struct frame_info *frame);
696
697 extern CORE_ADDR address_from_register (int regnum,
698 struct frame_info *frame);
699
700 extern struct value *value_of_variable (struct symbol *var,
701 const struct block *b);
702
703 extern struct value *address_of_variable (struct symbol *var,
704 const struct block *b);
705
706 extern struct value *value_of_register (int regnum, struct frame_info *frame);
707
708 struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
709
710 /* Return the symbol's reading requirement. */
711
712 extern enum symbol_needs_kind symbol_read_needs (struct symbol *);
713
714 /* Return true if the symbol needs a frame. This is a wrapper for
715 symbol_read_needs that simply checks for SYMBOL_NEEDS_FRAME. */
716
717 extern int symbol_read_needs_frame (struct symbol *);
718
719 extern struct value *read_var_value (struct symbol *var,
720 const struct block *var_block,
721 struct frame_info *frame);
722
723 extern struct value *default_read_var_value (struct symbol *var,
724 const struct block *var_block,
725 struct frame_info *frame);
726
727 extern struct value *allocate_value (struct type *type);
728 extern struct value *allocate_value_lazy (struct type *type);
729 extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
730 struct value *src, LONGEST src_offset,
731 LONGEST length);
732 extern void value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
733 struct value *src, LONGEST src_offset,
734 LONGEST length);
735
736 extern struct value *allocate_repeat_value (struct type *type, int count);
737
738 extern struct value *value_mark (void);
739
740 extern void value_free_to_mark (const struct value *mark);
741
742 /* A helper class that uses value_mark at construction time and calls
743 value_free_to_mark in the destructor. This is used to clear out
744 temporary values created during the lifetime of this object. */
745 class scoped_value_mark
746 {
747 public:
748
749 scoped_value_mark ()
750 : m_value (value_mark ())
751 {
752 }
753
754 ~scoped_value_mark ()
755 {
756 free_to_mark ();
757 }
758
759 scoped_value_mark (scoped_value_mark &&other) = default;
760
761 DISABLE_COPY_AND_ASSIGN (scoped_value_mark);
762
763 /* Free the values currently on the value stack. */
764 void free_to_mark ()
765 {
766 if (m_value != NULL)
767 {
768 value_free_to_mark (m_value);
769 m_value = NULL;
770 }
771 }
772
773 private:
774
775 const struct value *m_value;
776 };
777
778 extern struct value *value_cstring (const char *ptr, ssize_t len,
779 struct type *char_type);
780 extern struct value *value_string (const char *ptr, ssize_t len,
781 struct type *char_type);
782
783 extern struct value *value_array (int lowbound, int highbound,
784 struct value **elemvec);
785
786 extern struct value *value_concat (struct value *arg1, struct value *arg2);
787
788 extern struct value *value_binop (struct value *arg1, struct value *arg2,
789 enum exp_opcode op);
790
791 extern struct value *value_ptradd (struct value *arg1, LONGEST arg2);
792
793 extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2);
794
795 extern int value_must_coerce_to_target (struct value *arg1);
796
797 extern struct value *value_coerce_to_target (struct value *arg1);
798
799 extern struct value *value_coerce_array (struct value *arg1);
800
801 extern struct value *value_coerce_function (struct value *arg1);
802
803 extern struct value *value_ind (struct value *arg1);
804
805 extern struct value *value_addr (struct value *arg1);
806
807 extern struct value *value_ref (struct value *arg1, enum type_code refcode);
808
809 extern struct value *value_assign (struct value *toval,
810 struct value *fromval);
811
812 extern struct value *value_pos (struct value *arg1);
813
814 extern struct value *value_neg (struct value *arg1);
815
816 extern struct value *value_complement (struct value *arg1);
817
818 extern struct value *value_struct_elt (struct value **argp,
819 struct value **args,
820 const char *name, int *static_memfuncp,
821 const char *err);
822
823 extern struct value *value_struct_elt_bitpos (struct value **argp,
824 int bitpos,
825 struct type *field_type,
826 const char *err);
827
828 extern struct value *value_aggregate_elt (struct type *curtype,
829 const char *name,
830 struct type *expect_type,
831 int want_address,
832 enum noside noside);
833
834 extern struct value *value_static_field (struct type *type, int fieldno);
835
836 enum oload_search_type { NON_METHOD, METHOD, BOTH };
837
838 extern int find_overload_match (struct value **args, int nargs,
839 const char *name,
840 enum oload_search_type method,
841 struct value **objp, struct symbol *fsym,
842 struct value **valp, struct symbol **symp,
843 int *staticp, const int no_adl,
844 enum noside noside);
845
846 extern struct value *value_field (struct value *arg1, int fieldno);
847
848 extern struct value *value_primitive_field (struct value *arg1, LONGEST offset,
849 int fieldno,
850 struct type *arg_type);
851
852
853 extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
854 int *);
855
856 extern struct value *value_full_object (struct value *, struct type *, int,
857 int, int);
858
859 extern struct value *value_cast_pointers (struct type *, struct value *, int);
860
861 extern struct value *value_cast (struct type *type, struct value *arg2);
862
863 extern struct value *value_reinterpret_cast (struct type *type,
864 struct value *arg);
865
866 extern struct value *value_dynamic_cast (struct type *type, struct value *arg);
867
868 extern struct value *value_zero (struct type *type, enum lval_type lv);
869
870 extern struct value *value_one (struct type *type);
871
872 extern struct value *value_repeat (struct value *arg1, int count);
873
874 extern struct value *value_subscript (struct value *array, LONGEST index);
875
876 extern struct value *value_bitstring_subscript (struct type *type,
877 struct value *bitstring,
878 LONGEST index);
879
880 extern struct value *register_value_being_returned (struct type *valtype,
881 struct regcache *retbuf);
882
883 extern int value_in (struct value *element, struct value *set);
884
885 extern int value_bit_index (struct type *type, const gdb_byte *addr,
886 int index);
887
888 extern enum return_value_convention
889 struct_return_convention (struct gdbarch *gdbarch, struct value *function,
890 struct type *value_type);
891
892 extern int using_struct_return (struct gdbarch *gdbarch,
893 struct value *function,
894 struct type *value_type);
895
896 extern struct value *evaluate_expression (struct expression *exp);
897
898 extern struct value *evaluate_type (struct expression *exp);
899
900 extern struct value *evaluate_subexp (struct type *expect_type,
901 struct expression *exp,
902 int *pos, enum noside noside);
903
904 extern struct value *evaluate_subexpression_type (struct expression *exp,
905 int subexp);
906
907 extern value *evaluate_var_value (enum noside noside, const block *blk,
908 symbol *var);
909
910 extern value *evaluate_var_msym_value (enum noside noside,
911 struct objfile *objfile,
912 minimal_symbol *msymbol);
913
914 extern value *eval_skip_value (expression *exp);
915
916 extern void fetch_subexp_value (struct expression *exp, int *pc,
917 struct value **valp, struct value **resultp,
918 std::vector<value_ref_ptr> *val_chain,
919 int preserve_errors);
920
921 extern const char *extract_field_op (struct expression *exp, int *subexp);
922
923 extern struct value *evaluate_subexp_with_coercion (struct expression *,
924 int *, enum noside);
925
926 extern struct value *parse_and_eval (const char *exp);
927
928 extern struct value *parse_to_comma_and_eval (const char **expp);
929
930 extern struct type *parse_and_eval_type (char *p, int length);
931
932 extern CORE_ADDR parse_and_eval_address (const char *exp);
933
934 extern LONGEST parse_and_eval_long (const char *exp);
935
936 extern void unop_promote (const struct language_defn *language,
937 struct gdbarch *gdbarch,
938 struct value **arg1);
939
940 extern void binop_promote (const struct language_defn *language,
941 struct gdbarch *gdbarch,
942 struct value **arg1, struct value **arg2);
943
944 extern struct value *access_value_history (int num);
945
946 extern struct value *value_of_internalvar (struct gdbarch *gdbarch,
947 struct internalvar *var);
948
949 extern int get_internalvar_integer (struct internalvar *var, LONGEST *l);
950
951 extern void set_internalvar (struct internalvar *var, struct value *val);
952
953 extern void set_internalvar_integer (struct internalvar *var, LONGEST l);
954
955 extern void set_internalvar_string (struct internalvar *var,
956 const char *string);
957
958 extern void clear_internalvar (struct internalvar *var);
959
960 extern void set_internalvar_component (struct internalvar *var,
961 LONGEST offset,
962 LONGEST bitpos, LONGEST bitsize,
963 struct value *newvalue);
964
965 extern struct internalvar *lookup_only_internalvar (const char *name);
966
967 extern struct internalvar *create_internalvar (const char *name);
968
969 extern void complete_internalvar (completion_tracker &tracker,
970 const char *name);
971
972 /* An internalvar can be dynamically computed by supplying a vector of
973 function pointers to perform various operations. */
974
975 struct internalvar_funcs
976 {
977 /* Compute the value of the variable. The DATA argument passed to
978 the function is the same argument that was passed to
979 `create_internalvar_type_lazy'. */
980
981 struct value *(*make_value) (struct gdbarch *arch,
982 struct internalvar *var,
983 void *data);
984
985 /* Update the agent expression EXPR with bytecode to compute the
986 value. VALUE is the agent value we are updating. The DATA
987 argument passed to this function is the same argument that was
988 passed to `create_internalvar_type_lazy'. If this pointer is
989 NULL, then the internalvar cannot be compiled to an agent
990 expression. */
991
992 void (*compile_to_ax) (struct internalvar *var,
993 struct agent_expr *expr,
994 struct axs_value *value,
995 void *data);
996
997 /* If non-NULL, this is called to destroy DATA. The DATA argument
998 passed to this function is the same argument that was passed to
999 `create_internalvar_type_lazy'. */
1000
1001 void (*destroy) (void *data);
1002 };
1003
1004 extern struct internalvar *create_internalvar_type_lazy (const char *name,
1005 const struct internalvar_funcs *funcs,
1006 void *data);
1007
1008 /* Compile an internal variable to an agent expression. VAR is the
1009 variable to compile; EXPR and VALUE are the agent expression we are
1010 updating. This will return 0 if there is no known way to compile
1011 VAR, and 1 if VAR was successfully compiled. It may also throw an
1012 exception on error. */
1013
1014 extern int compile_internalvar_to_ax (struct internalvar *var,
1015 struct agent_expr *expr,
1016 struct axs_value *value);
1017
1018 extern struct internalvar *lookup_internalvar (const char *name);
1019
1020 extern int value_equal (struct value *arg1, struct value *arg2);
1021
1022 extern int value_equal_contents (struct value *arg1, struct value *arg2);
1023
1024 extern int value_less (struct value *arg1, struct value *arg2);
1025
1026 extern int value_logical_not (struct value *arg1);
1027
1028 /* C++ */
1029
1030 extern struct value *value_of_this (const struct language_defn *lang);
1031
1032 extern struct value *value_of_this_silent (const struct language_defn *lang);
1033
1034 extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
1035 enum exp_opcode op,
1036 enum exp_opcode otherop,
1037 enum noside noside);
1038
1039 extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
1040 enum noside noside);
1041
1042 extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
1043 int j, struct type *type, LONGEST offset);
1044
1045 extern int binop_types_user_defined_p (enum exp_opcode op,
1046 struct type *type1,
1047 struct type *type2);
1048
1049 extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
1050 struct value *arg2);
1051
1052 extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
1053
1054 extern int destructor_name_p (const char *name, struct type *type);
1055
1056 extern value_ref_ptr release_value (struct value *val);
1057
1058 extern int record_latest_value (struct value *val);
1059
1060 extern void modify_field (struct type *type, gdb_byte *addr,
1061 LONGEST fieldval, LONGEST bitpos, LONGEST bitsize);
1062
1063 extern void type_print (struct type *type, const char *varstring,
1064 struct ui_file *stream, int show);
1065
1066 extern std::string type_to_string (struct type *type);
1067
1068 extern gdb_byte *baseclass_addr (struct type *type, int index,
1069 gdb_byte *valaddr,
1070 struct value **valuep, int *errp);
1071
1072 extern void print_longest (struct ui_file *stream, int format,
1073 int use_local, LONGEST val);
1074
1075 extern void print_floating (const gdb_byte *valaddr, struct type *type,
1076 struct ui_file *stream);
1077
1078 extern void value_print (struct value *val, struct ui_file *stream,
1079 const struct value_print_options *options);
1080
1081 extern void value_print_array_elements (struct value *val,
1082 struct ui_file *stream, int format,
1083 enum val_prettyformat pretty);
1084
1085 /* Release values from the value chain and return them. Values
1086 created after MARK are released. If MARK is nullptr, or if MARK is
1087 not found on the value chain, then all values are released. Values
1088 are returned in reverse order of creation; that is, newest
1089 first. */
1090
1091 extern std::vector<value_ref_ptr> value_release_to_mark
1092 (const struct value *mark);
1093
1094 extern void val_print (struct type *type,
1095 LONGEST embedded_offset, CORE_ADDR address,
1096 struct ui_file *stream, int recurse,
1097 struct value *val,
1098 const struct value_print_options *options,
1099 const struct language_defn *language);
1100
1101 extern void common_val_print (struct value *val,
1102 struct ui_file *stream, int recurse,
1103 const struct value_print_options *options,
1104 const struct language_defn *language);
1105
1106 extern int val_print_string (struct type *elttype, const char *encoding,
1107 CORE_ADDR addr, int len,
1108 struct ui_file *stream,
1109 const struct value_print_options *options);
1110
1111 extern void print_variable_and_value (const char *name,
1112 struct symbol *var,
1113 struct frame_info *frame,
1114 struct ui_file *stream,
1115 int indent);
1116
1117 extern void typedef_print (struct type *type, struct symbol *news,
1118 struct ui_file *stream);
1119
1120 extern char *internalvar_name (const struct internalvar *var);
1121
1122 extern void preserve_values (struct objfile *);
1123
1124 /* From values.c */
1125
1126 extern struct value *value_copy (struct value *);
1127
1128 extern struct value *value_non_lval (struct value *);
1129
1130 extern void value_force_lval (struct value *, CORE_ADDR);
1131
1132 extern struct value *make_cv_value (int, int, struct value *);
1133
1134 extern void preserve_one_value (struct value *, struct objfile *, htab_t);
1135
1136 /* From valops.c */
1137
1138 extern struct value *varying_to_slice (struct value *);
1139
1140 extern struct value *value_slice (struct value *, int, int);
1141
1142 extern struct value *value_literal_complex (struct value *, struct value *,
1143 struct type *);
1144
1145 extern struct value *find_function_in_inferior (const char *,
1146 struct objfile **);
1147
1148 extern struct value *value_allocate_space_in_inferior (int);
1149
1150 extern struct value *value_subscripted_rvalue (struct value *array,
1151 LONGEST index, int lowerbound);
1152
1153 /* User function handler. */
1154
1155 typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
1156 const struct language_defn *language,
1157 void *cookie,
1158 int argc,
1159 struct value **argv);
1160
1161 void add_internal_function (const char *name, const char *doc,
1162 internal_function_fn handler,
1163 void *cookie);
1164
1165 struct value *call_internal_function (struct gdbarch *gdbarch,
1166 const struct language_defn *language,
1167 struct value *function,
1168 int argc, struct value **argv);
1169
1170 char *value_internal_function_name (struct value *);
1171
1172 /* Build a value wrapping and representing WORKER. The value takes ownership
1173 of the xmethod_worker object. */
1174
1175 extern struct value *value_from_xmethod (xmethod_worker_up &&worker);
1176
1177 extern struct type *result_type_of_xmethod (struct value *method,
1178 int argc, struct value **argv);
1179
1180 extern struct value *call_xmethod (struct value *method,
1181 int argc, struct value **argv);
1182
1183 /* Given a discriminated union type and some corresponding value
1184 contents, this will return the field index of the currently active
1185 variant. This will throw an exception if no active variant can be
1186 found. */
1187
1188 extern int value_union_variant (struct type *union_type,
1189 const gdb_byte *contents);
1190
1191 #endif /* !defined (VALUE_H) */