projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Also check ignored "-z relro".
[deliverable/binutils-gdb.git] / gdb / value.h
... / ...
CommitLineData
1/* Definitions for values of C expressions, for GDB.
2
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22#if !defined (VALUE_H)
23#define VALUE_H 1
24
25#include "doublest.h"
26#include "frame.h" /* For struct frame_id. */
27
28struct block;
29struct expression;
30struct regcache;
31struct symbol;
32struct type;
33struct ui_file;
34struct language_defn;
35struct value_print_options;
36
37/* The structure which defines the type of a value. It should never
38 be possible for a program lval value to survive over a call to the
39 inferior (i.e. to be put into the history list or an internal
40 variable). */
41
42struct value;
43
44/* Values are stored in a chain, so that they can be deleted easily
45 over calls to the inferior. Values assigned to internal variables,
46 put into the value history or exposed to Python are taken off this
47 list. */
48
49struct value *value_next (struct value *);
50
51/* Type of the value. */
52
53extern struct type *value_type (const struct value *);
54
55/* This is being used to change the type of an existing value, that
56 code should instead be creating a new value with the changed type
57 (but possibly shared content). */
58
59extern void deprecated_set_value_type (struct value *value,
60 struct type *type);
61
62/* Only used for bitfields; number of bits contained in them. */
63
64extern int value_bitsize (const struct value *);
65extern void set_value_bitsize (struct value *, int bit);
66
67/* Only used for bitfields; position of start of field. For
68 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For
69 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */
70
71extern int value_bitpos (const struct value *);
72extern void set_value_bitpos (struct value *, int bit);
73
74/* Only used for bitfields; the containing value. This allows a
75 single read from the target when displaying multiple
76 bitfields. */
77
78struct value *value_parent (struct value *);
79
80/* Describes offset of a value within lval of a structure in bytes.
81 If lval == lval_memory, this is an offset to the address. If lval
82 == lval_register, this is a further offset from location.address
83 within the registers structure. Note also the member
84 embedded_offset below. */
85
86extern int value_offset (const struct value *);
87extern void set_value_offset (struct value *, int offset);
88
89/* The comment from "struct value" reads: ``Is it modifiable? Only
90 relevant if lval != not_lval.''. Shouldn't the value instead be
91 not_lval and be done with it? */
92
93extern int deprecated_value_modifiable (struct value *value);
94extern void deprecated_set_value_modifiable (struct value *value,
95 int modifiable);
96
97/* If a value represents a C++ object, then the `type' field gives the
98 object's compile-time type. If the object actually belongs to some
99 class derived from `type', perhaps with other base classes and
100 additional members, then `type' is just a subobject of the real
101 thing, and the full object is probably larger than `type' would
102 suggest.
103
104 If `type' is a dynamic class (i.e. one with a vtable), then GDB can
105 actually determine the object's run-time type by looking at the
106 run-time type information in the vtable. When this information is
107 available, we may elect to read in the entire object, for several
108 reasons:
109
110 - When printing the value, the user would probably rather see the
111 full object, not just the limited portion apparent from the
112 compile-time type.
113
114 - If `type' has virtual base classes, then even printing `type'
115 alone may require reaching outside the `type' portion of the
116 object to wherever the virtual base class has been stored.
117
118 When we store the entire object, `enclosing_type' is the run-time
119 type -- the complete object -- and `embedded_offset' is the offset
120 of `type' within that larger type, in bytes. The value_contents()
121 macro takes `embedded_offset' into account, so most GDB code
122 continues to see the `type' portion of the value, just as the
123 inferior would.
124
125 If `type' is a pointer to an object, then `enclosing_type' is a
126 pointer to the object's run-time type, and `pointed_to_offset' is
127 the offset in bytes from the full object to the pointed-to object
128 -- that is, the value `embedded_offset' would have if we followed
129 the pointer and fetched the complete object. (I don't really see
130 the point. Why not just determine the run-time type when you
131 indirect, and avoid the special case? The contents don't matter
132 until you indirect anyway.)
133
134 If we're not doing anything fancy, `enclosing_type' is equal to
135 `type', and `embedded_offset' is zero, so everything works
136 normally. */
137
138extern struct type *value_enclosing_type (struct value *);
139extern void set_value_enclosing_type (struct value *val,
140 struct type *new_type);
141
142extern int value_pointed_to_offset (struct value *value);
143extern void set_value_pointed_to_offset (struct value *value, int val);
144extern int value_embedded_offset (struct value *value);
145extern void set_value_embedded_offset (struct value *value, int val);
146
147/* For lval_computed values, this structure holds functions used to
148 retrieve and set the value (or portions of the value).
149
150 For each function, 'V' is the 'this' pointer: an lval_funcs
151 function F may always assume that the V it receives is an
152 lval_computed value, and has F in the appropriate slot of its
153 lval_funcs structure. */
154
155struct lval_funcs
156{
157 /* Fill in VALUE's contents. This is used to "un-lazy" values. If
158 a problem arises in obtaining VALUE's bits, this function should
159 call 'error'. */
160 void (*read) (struct value *v);
161
162 /* Handle an assignment TOVAL = FROMVAL by writing the value of
163 FROMVAL to TOVAL's location. The contents of TOVAL have not yet
164 been updated. If a problem arises in doing so, this function
165 should call 'error'. */
166 void (*write) (struct value *toval, struct value *fromval);
167
168 /* Check the validity of some bits in VALUE. This should return 1
169 if all the bits starting at OFFSET and extending for LENGTH bits
170 are valid, or 0 if any bit is invalid. */
171 int (*check_validity) (const struct value *value, int offset, int length);
172
173 /* Return 1 if any bit in VALUE is valid, 0 if they are all invalid. */
174 int (*check_any_valid) (const struct value *value);
175
176 /* If non-NULL, this is used to implement pointer indirection for
177 this value. This method may return NULL, in which case value_ind
178 will fall back to ordinary indirection. */
179 struct value *(*indirect) (struct value *value);
180
181 /* If non-NULL, this is used to determine whether the indicated bits
182 of VALUE are a synthetic pointer. */
183 int (*check_synthetic_pointer) (const struct value *value,
184 int offset, int length);
185
186 /* Return a duplicate of VALUE's closure, for use in a new value.
187 This may simply return the same closure, if VALUE's is
188 reference-counted or statically allocated.
189
190 This may be NULL, in which case VALUE's closure is re-used in the
191 new value. */
192 void *(*copy_closure) (const struct value *v);
193
194 /* Drop VALUE's reference to its closure. Maybe this frees the
195 closure; maybe this decrements a reference count; maybe the
196 closure is statically allocated and this does nothing.
197
198 This may be NULL, in which case no action is taken to free
199 VALUE's closure. */
200 void (*free_closure) (struct value *v);
201};
202
203/* Create a computed lvalue, with type TYPE, function pointers FUNCS,
204 and closure CLOSURE. */
205
206extern struct value *allocate_computed_value (struct type *type,
207 struct lval_funcs *funcs,
208 void *closure);
209
210extern struct value *allocate_optimized_out_value (struct type *type);
211
212/* If VALUE is lval_computed, return its lval_funcs structure. */
213
214extern struct lval_funcs *value_computed_funcs (struct value *value);
215
216/* If VALUE is lval_computed, return its closure. The meaning of the
217 returned value depends on the functions VALUE uses. */
218
219extern void *value_computed_closure (const struct value *value);
220
221/* If zero, contents of this value are in the contents field. If
222 nonzero, contents are in inferior. If the lval field is lval_memory,
223 the contents are in inferior memory at location.address plus offset.
224 The lval field may also be lval_register.
225
226 WARNING: This field is used by the code which handles watchpoints
227 (see breakpoint.c) to decide whether a particular value can be
228 watched by hardware watchpoints. If the lazy flag is set for some
229 member of a value chain, it is assumed that this member of the
230 chain doesn't need to be watched as part of watching the value
231 itself. This is how GDB avoids watching the entire struct or array
232 when the user wants to watch a single struct member or array
233 element. If you ever change the way lazy flag is set and reset, be
234 sure to consider this use as well! */
235
236extern int value_lazy (struct value *);
237extern void set_value_lazy (struct value *value, int val);
238
239extern int value_stack (struct value *);
240extern void set_value_stack (struct value *value, int val);
241
242/* value_contents() and value_contents_raw() both return the address
243 of the gdb buffer used to hold a copy of the contents of the lval.
244 value_contents() is used when the contents of the buffer are needed
245 -- it uses value_fetch_lazy() to load the buffer from the process
246 being debugged if it hasn't already been loaded
247 (value_contents_writeable() is used when a writeable but fetched
248 buffer is required).. value_contents_raw() is used when data is
249 being stored into the buffer, or when it is certain that the
250 contents of the buffer are valid.
251
252 Note: The contents pointer is adjusted by the offset required to
253 get to the real subobject, if the value happens to represent
254 something embedded in a larger run-time object. */
255
256extern gdb_byte *value_contents_raw (struct value *);
257
258/* Actual contents of the value. For use of this value; setting it
259 uses the stuff above. Not valid if lazy is nonzero. Target
260 byte-order. We force it to be aligned properly for any possible
261 value. Note that a value therefore extends beyond what is
262 declared here. */
263
264extern const gdb_byte *value_contents (struct value *);
265extern gdb_byte *value_contents_writeable (struct value *);
266
267/* The ALL variants of the above two macros do not adjust the returned
268 pointer by the embedded_offset value. */
269
270extern gdb_byte *value_contents_all_raw (struct value *);
271extern const gdb_byte *value_contents_all (struct value *);
272
273/* Like value_contents_all, but does not require that the returned
274 bits be valid. This should only be used in situations where you
275 plan to check the validity manually. */
276extern const gdb_byte *value_contents_for_printing (struct value *value);
277
278/* Like value_contents_for_printing, but accepts a constant value
279 pointer. Unlike value_contents_for_printing however, the pointed
280 value must _not_ be lazy. */
281extern const gdb_byte *
282 value_contents_for_printing_const (const struct value *value);
283
284extern int value_fetch_lazy (struct value *val);
285extern int value_contents_equal (struct value *val1, struct value *val2);
286
287/* If nonzero, this is the value of a variable which does not actually
288 exist in the program. */
289extern int value_optimized_out (struct value *value);
290extern void set_value_optimized_out (struct value *value, int val);
291
292/* Like value_optimized_out, but return false if any bit in the object
293 is valid. */
294extern int value_entirely_optimized_out (const struct value *value);
295
296/* Set or return field indicating whether a variable is initialized or
297 not, based on debugging information supplied by the compiler.
298 1 = initialized; 0 = uninitialized. */
299extern int value_initialized (struct value *);
300extern void set_value_initialized (struct value *, int);
301
302/* Set COMPONENT's location as appropriate for a component of WHOLE
303 --- regardless of what kind of lvalue WHOLE is. */
304extern void set_value_component_location (struct value *component,
305 const struct value *whole);
306
307/* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
308 single value might have multiple LVALs), this hacked interface is
309 limited to just the first PIECE. Expect further change. */
310/* Type of value; either not an lval, or one of the various different
311 possible kinds of lval. */
312extern enum lval_type *deprecated_value_lval_hack (struct value *);
313#define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
314
315/* If lval == lval_memory, return the address in the inferior. If
316 lval == lval_register, return the byte offset into the registers
317 structure. Otherwise, return 0. The returned address
318 includes the offset, if any. */
319extern CORE_ADDR value_address (const struct value *);
320
321/* Like value_address, except the result does not include value's
322 offset. */
323extern CORE_ADDR value_raw_address (struct value *);
324
325/* Set the address of a value. */
326extern void set_value_address (struct value *, CORE_ADDR);
327
328/* Pointer to internal variable. */
329extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
330#define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))
331
332/* Frame register value is relative to. This will be described in the
333 lval enum above as "lval_register". */
334extern struct frame_id *deprecated_value_frame_id_hack (struct value *);
335#define VALUE_FRAME_ID(val) (*deprecated_value_frame_id_hack (val))
336
337/* Register number if the value is from a register. */
338extern short *deprecated_value_regnum_hack (struct value *);
339#define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
340
341/* Convert a REF to the object referenced. */
342
343extern struct value *coerce_ref (struct value *value);
344
345/* If ARG is an array, convert it to a pointer.
346 If ARG is a function, convert it to a function pointer.
347
348 References are dereferenced. */
349
350extern struct value *coerce_array (struct value *value);
351
352/* Given a value, determine whether the bits starting at OFFSET and
353 extending for LENGTH bits are valid. This returns nonzero if all
354 bits in the given range are valid, zero if any bit is invalid. */
355
356extern int value_bits_valid (const struct value *value,
357 int offset, int length);
358
359/* Given a value, determine whether the bits starting at OFFSET and
360 extending for LENGTH bits are a synthetic pointer. */
361
362extern int value_bits_synthetic_pointer (const struct value *value,
363 int offset, int length);
364
365/* Given a value, determine whether the contents bytes starting at
366 OFFSET and extending for LENGTH bytes are available. This returns
367 nonzero if all bytes in the given range are available, zero if any
368 byte is unavailable. */
369
370extern int value_bytes_available (const struct value *value,
371 int offset, int length);
372
373/* Like value_bytes_available, but return false if any byte in the
374 whole object is unavailable. */
375extern int value_entirely_available (struct value *value);
376
377/* Mark VALUE's content bytes starting at OFFSET and extending for
378 LENGTH bytes as unavailable. */
379
380extern void mark_value_bytes_unavailable (struct value *value,
381 int offset, int length);
382
383/* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
384 LENGTH bytes of VAL2's contents starting at OFFSET2.
385
386 Note that "contents" refers to the whole value's contents
387 (value_contents_all), without any embedded offset adjustment. For
388 example, to compare a complete object value with itself, including
389 its enclosing type chunk, you'd do:
390
391 int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
392 value_available_contents (val, 0, val, 0, len);
393
394 Returns true iff the set of available contents match. Unavailable
395 contents compare equal with unavailable contents, and different
396 with any available byte. For example, if 'x's represent an
397 unavailable byte, and 'V' and 'Z' represent different available
398 bytes, in a value with length 16:
399
400 offset: 0 4 8 12 16
401 contents: xxxxVVVVxxxxVVZZ
402
403 then:
404
405 value_available_contents_eq(val, 0, val, 8, 6) => 1
406 value_available_contents_eq(val, 0, val, 4, 4) => 1
407 value_available_contents_eq(val, 0, val, 8, 8) => 0
408 value_available_contents_eq(val, 4, val, 12, 2) => 1
409 value_available_contents_eq(val, 4, val, 12, 4) => 0
410 value_available_contents_eq(val, 3, val, 4, 4) => 0
411*/
412
413extern int value_available_contents_eq (const struct value *val1, int offset1,
414 const struct value *val2, int offset2,
415 int length);
416
417/* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which
418 is (or will be copied to) VAL's contents buffer offset by
419 EMBEDDED_OFFSET (that is, to &VAL->contents[EMBEDDED_OFFSET]).
420 Marks value contents ranges as unavailable if the corresponding
421 memory is likewise unavailable. STACK indicates whether the memory
422 is known to be stack memory. */
423
424extern void read_value_memory (struct value *val, int embedded_offset,
425 int stack, CORE_ADDR memaddr,
426 gdb_byte *buffer, size_t length);
427
428\f
429
430#include "symtab.h"
431#include "gdbtypes.h"
432#include "expression.h"
433
434struct frame_info;
435struct fn_field;
436
437extern void print_address_demangle (struct gdbarch *, CORE_ADDR,
438 struct ui_file *, int);
439
440extern LONGEST value_as_long (struct value *val);
441extern DOUBLEST value_as_double (struct value *val);
442extern CORE_ADDR value_as_address (struct value *val);
443
444extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
445extern DOUBLEST unpack_double (struct type *type, const gdb_byte *valaddr,
446 int *invp);
447extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
448
449extern int unpack_value_bits_as_long (struct type *field_type,
450 const gdb_byte *valaddr,
451 int embedded_offset, int bitpos,
452 int bitsize,
453 const struct value *original_value,
454 LONGEST *result);
455
456extern LONGEST unpack_field_as_long (struct type *type,
457 const gdb_byte *valaddr,
458 int fieldno);
459extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
460 int embedded_offset, int fieldno,
461 const struct value *val, LONGEST *result);
462
463extern struct value *value_field_bitfield (struct type *type, int fieldno,
464 const gdb_byte *valaddr,
465 int embedded_offset,
466 const struct value *val);
467
468extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
469
470extern struct value *value_from_longest (struct type *type, LONGEST num);
471extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
472extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
473extern struct value *value_from_double (struct type *type, DOUBLEST num);
474extern struct value *value_from_decfloat (struct type *type,
475 const gdb_byte *decbytes);
476extern struct value *value_from_history_ref (char *, char **);
477
478extern struct value *value_at (struct type *type, CORE_ADDR addr);
479extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
480
481extern struct value *value_from_contents_and_address (struct type *,
482 const gdb_byte *,
483 CORE_ADDR);
484extern struct value *value_from_contents (struct type *, const gdb_byte *);
485
486extern struct value *default_value_from_register (struct type *type,
487 int regnum,
488 struct frame_info *frame);
489
490extern struct value *value_from_register (struct type *type, int regnum,
491 struct frame_info *frame);
492
493extern CORE_ADDR address_from_register (struct type *type, int regnum,
494 struct frame_info *frame);
495
496extern struct value *value_of_variable (struct symbol *var, struct block *b);
497
498extern struct value *address_of_variable (struct symbol *var, struct block *b);
499
500extern struct value *value_of_register (int regnum, struct frame_info *frame);
501
502struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
503
504extern int symbol_read_needs_frame (struct symbol *);
505
506extern struct value *read_var_value (struct symbol *var,
507 struct frame_info *frame);
508
509extern struct value *allocate_value (struct type *type);
510extern struct value *allocate_value_lazy (struct type *type);
511extern void allocate_value_contents (struct value *value);
512extern void value_contents_copy (struct value *dst, int dst_offset,
513 struct value *src, int src_offset,
514 int length);
515extern void value_contents_copy_raw (struct value *dst, int dst_offset,
516 struct value *src, int src_offset,
517 int length);
518
519extern struct value *allocate_repeat_value (struct type *type, int count);
520
521extern struct value *value_mark (void);
522
523extern void value_free_to_mark (struct value *mark);
524
525extern struct value *value_cstring (char *ptr, int len,
526 struct type *char_type);
527extern struct value *value_string (char *ptr, int len,
528 struct type *char_type);
529extern struct value *value_bitstring (char *ptr, int len,
530 struct type *index_type);
531
532extern struct value *value_array (int lowbound, int highbound,
533 struct value **elemvec);
534
535extern struct value *value_concat (struct value *arg1, struct value *arg2);
536
537extern struct value *value_binop (struct value *arg1, struct value *arg2,
538 enum exp_opcode op);
539
540extern struct value *value_ptradd (struct value *arg1, LONGEST arg2);
541
542extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2);
543
544extern int value_must_coerce_to_target (struct value *arg1);
545
546extern struct value *value_coerce_to_target (struct value *arg1);
547
548extern struct value *value_coerce_array (struct value *arg1);
549
550extern struct value *value_coerce_function (struct value *arg1);
551
552extern struct value *value_ind (struct value *arg1);
553
554extern struct value *value_addr (struct value *arg1);
555
556extern struct value *value_ref (struct value *arg1);
557
558extern struct value *value_assign (struct value *toval,
559 struct value *fromval);
560
561extern struct value *value_pos (struct value *arg1);
562
563extern struct value *value_neg (struct value *arg1);
564
565extern struct value *value_complement (struct value *arg1);
566
567extern struct value *value_struct_elt (struct value **argp,
568 struct value **args,
569 const char *name, int *static_memfuncp,
570 const char *err);
571
572extern struct value *value_aggregate_elt (struct type *curtype,
573 char *name,
574 struct type *expect_type,
575 int want_address,
576 enum noside noside);
577
578extern struct value *value_static_field (struct type *type, int fieldno);
579
580extern struct fn_field *value_find_oload_method_list (struct value **,
581 const char *,
582 int, int *,
583 struct type **, int *);
584
585enum oload_search_type { NON_METHOD, METHOD, BOTH };
586
587extern int find_overload_match (struct type **arg_types, int nargs,
588 const char *name,
589 enum oload_search_type method, int lax,
590 struct value **objp, struct symbol *fsym,
591 struct value **valp, struct symbol **symp,
592 int *staticp, const int no_adl);
593
594extern struct value *value_field (struct value *arg1, int fieldno);
595
596extern struct value *value_primitive_field (struct value *arg1, int offset,
597 int fieldno,
598 struct type *arg_type);
599
600
601extern struct type *value_rtti_target_type (struct value *, int *, int *,
602 int *);
603
604extern struct value *value_full_object (struct value *, struct type *, int,
605 int, int);
606
607extern struct value *value_cast_pointers (struct type *, struct value *);
608
609extern struct value *value_cast (struct type *type, struct value *arg2);
610
611extern struct value *value_reinterpret_cast (struct type *type,
612 struct value *arg);
613
614extern struct value *value_dynamic_cast (struct type *type, struct value *arg);
615
616extern struct value *value_zero (struct type *type, enum lval_type lv);
617
618extern struct value *value_one (struct type *type, enum lval_type lv);
619
620extern struct value *value_repeat (struct value *arg1, int count);
621
622extern struct value *value_subscript (struct value *array, LONGEST index);
623
624extern struct value *value_bitstring_subscript (struct type *type,
625 struct value *bitstring,
626 LONGEST index);
627
628extern struct value *register_value_being_returned (struct type *valtype,
629 struct regcache *retbuf);
630
631extern int value_in (struct value *element, struct value *set);
632
633extern int value_bit_index (struct type *type, const gdb_byte *addr,
634 int index);
635
636extern int using_struct_return (struct gdbarch *gdbarch,
637 struct type *func_type,
638 struct type *value_type);
639
640extern struct value *evaluate_expression (struct expression *exp);
641
642extern struct value *evaluate_type (struct expression *exp);
643
644extern struct value *evaluate_subexp (struct type *expect_type,
645 struct expression *exp,
646 int *pos, enum noside noside);
647
648extern struct value *evaluate_subexpression_type (struct expression *exp,
649 int subexp);
650
651extern void fetch_subexp_value (struct expression *exp, int *pc,
652 struct value **valp, struct value **resultp,
653 struct value **val_chain);
654
655extern char *extract_field_op (struct expression *exp, int *subexp);
656
657extern struct value *evaluate_subexp_with_coercion (struct expression *,
658 int *, enum noside);
659
660extern struct value *parse_and_eval (char *exp);
661
662extern struct value *parse_to_comma_and_eval (char **expp);
663
664extern struct type *parse_and_eval_type (char *p, int length);
665
666extern CORE_ADDR parse_and_eval_address (char *exp);
667
668extern LONGEST parse_and_eval_long (char *exp);
669
670extern void unop_promote (const struct language_defn *language,
671 struct gdbarch *gdbarch,
672 struct value **arg1);
673
674extern void binop_promote (const struct language_defn *language,
675 struct gdbarch *gdbarch,
676 struct value **arg1, struct value **arg2);
677
678extern struct value *access_value_history (int num);
679
680extern struct value *value_of_internalvar (struct gdbarch *gdbarch,
681 struct internalvar *var);
682
683extern int get_internalvar_integer (struct internalvar *var, LONGEST *l);
684
685extern void set_internalvar (struct internalvar *var, struct value *val);
686
687extern void set_internalvar_integer (struct internalvar *var, LONGEST l);
688
689extern void set_internalvar_string (struct internalvar *var,
690 const char *string);
691
692extern void clear_internalvar (struct internalvar *var);
693
694extern void set_internalvar_component (struct internalvar *var,
695 int offset,
696 int bitpos, int bitsize,
697 struct value *newvalue);
698
699extern struct internalvar *lookup_only_internalvar (const char *name);
700
701extern struct internalvar *create_internalvar (const char *name);
702
703typedef struct value * (*internalvar_make_value) (struct gdbarch *,
704 struct internalvar *);
705extern struct internalvar *
706 create_internalvar_type_lazy (char *name, internalvar_make_value fun);
707
708extern struct internalvar *lookup_internalvar (const char *name);
709
710extern int value_equal (struct value *arg1, struct value *arg2);
711
712extern int value_equal_contents (struct value *arg1, struct value *arg2);
713
714extern int value_less (struct value *arg1, struct value *arg2);
715
716extern int value_logical_not (struct value *arg1);
717
718/* C++ */
719
720extern struct value *value_of_this (const struct language_defn *lang,
721 int complain);
722
723extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
724 enum exp_opcode op,
725 enum exp_opcode otherop,
726 enum noside noside);
727
728extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
729 enum noside noside);
730
731extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
732 int j, struct type *type, int offset);
733
734extern int binop_types_user_defined_p (enum exp_opcode op,
735 struct type *type1,
736 struct type *type2);
737
738extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
739 struct value *arg2);
740
741extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
742
743extern int destructor_name_p (const char *name, struct type *type);
744
745extern void value_incref (struct value *val);
746
747extern void value_free (struct value *val);
748
749extern void free_all_values (void);
750
751extern void free_value_chain (struct value *v);
752
753extern void release_value (struct value *val);
754
755extern int record_latest_value (struct value *val);
756
757extern void modify_field (struct type *type, gdb_byte *addr,
758 LONGEST fieldval, int bitpos, int bitsize);
759
760extern void type_print (struct type *type, char *varstring,
761 struct ui_file *stream, int show);
762
763extern char *type_to_string (struct type *type);
764
765extern gdb_byte *baseclass_addr (struct type *type, int index,
766 gdb_byte *valaddr,
767 struct value **valuep, int *errp);
768
769extern void print_longest (struct ui_file *stream, int format,
770 int use_local, LONGEST val);
771
772extern void print_floating (const gdb_byte *valaddr, struct type *type,
773 struct ui_file *stream);
774
775extern void print_decimal_floating (const gdb_byte *valaddr, struct type *type,
776 struct ui_file *stream);
777
778extern int value_print (struct value *val, struct ui_file *stream,
779 const struct value_print_options *options);
780
781extern void value_print_array_elements (struct value *val,
782 struct ui_file *stream, int format,
783 enum val_prettyprint pretty);
784
785extern struct value *value_release_to_mark (struct value *mark);
786
787extern int val_print (struct type *type, const gdb_byte *valaddr,
788 int embedded_offset, CORE_ADDR address,
789 struct ui_file *stream, int recurse,
790 const struct value *val,
791 const struct value_print_options *options,
792 const struct language_defn *language);
793
794extern int common_val_print (struct value *val,
795 struct ui_file *stream, int recurse,
796 const struct value_print_options *options,
797 const struct language_defn *language);
798
799extern int val_print_string (struct type *elttype, const char *encoding,
800 CORE_ADDR addr, int len,
801 struct ui_file *stream,
802 const struct value_print_options *options);
803
804extern void print_variable_and_value (const char *name,
805 struct symbol *var,
806 struct frame_info *frame,
807 struct ui_file *stream,
808 int indent);
809
810extern int check_field (struct type *, const char *);
811
812extern void typedef_print (struct type *type, struct symbol *news,
813 struct ui_file *stream);
814
815extern char *internalvar_name (struct internalvar *var);
816
817extern void preserve_values (struct objfile *);
818
819/* From values.c */
820
821extern struct value *value_copy (struct value *);
822
823extern struct value *value_non_lval (struct value *);
824
825extern void preserve_one_value (struct value *, struct objfile *, htab_t);
826
827/* From valops.c */
828
829extern struct value *varying_to_slice (struct value *);
830
831extern struct value *value_slice (struct value *, int, int);
832
833extern struct value *value_literal_complex (struct value *, struct value *,
834 struct type *);
835
836extern struct value *find_function_in_inferior (const char *,
837 struct objfile **);
838
839extern struct value *value_allocate_space_in_inferior (int);
840
841extern struct value *value_subscripted_rvalue (struct value *array,
842 LONGEST index, int lowerbound);
843
844/* User function handler. */
845
846typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
847 const struct language_defn *language,
848 void *cookie,
849 int argc,
850 struct value **argv);
851
852void add_internal_function (const char *name, const char *doc,
853 internal_function_fn handler,
854 void *cookie);
855
856struct value *call_internal_function (struct gdbarch *gdbarch,
857 const struct language_defn *language,
858 struct value *function,
859 int argc, struct value **argv);
860
861char *value_internal_function_name (struct value *);
862
863#endif /* !defined (VALUE_H) */
GDB Binutils - Deliverables
This page took 0.02814 seconds and 4 git commands to generate.