projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* defilep.y (def_name, def_library): Combine into...
[deliverable/binutils-gdb.git] / gdb / value.h
... / ...
CommitLineData
1/* Definitions for values of C expressions, for GDB.
2
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
5 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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
23
24#if !defined (VALUE_H)
25#define VALUE_H 1
26
27#include "doublest.h"
28#include "frame.h" /* For struct frame_id. */
29
30struct block;
31struct expression;
32struct regcache;
33struct symbol;
34struct type;
35struct ui_file;
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 /* Type of value; either not an lval, or one of the various
45 different possible kinds of lval. */
46 enum lval_type lval;
47
48 /* Is it modifiable? Only relevant if lval != not_lval. */
49 int modifiable;
50
51 /* Location of value (if lval). */
52 union
53 {
54 /* If lval == lval_memory, this is the address in the inferior.
55 If lval == lval_register, this is the byte offset into the
56 registers structure. */
57 CORE_ADDR address;
58
59 /* Pointer to internal variable. */
60 struct internalvar *internalvar;
61 } location;
62
63 /* Describes offset of a value within lval of a structure in bytes.
64 If lval == lval_memory, this is an offset to the address.
65 If lval == lval_register, this is a further offset from
66 location.address within the registers structure.
67 Note also the member embedded_offset below. */
68 int offset;
69
70 /* Only used for bitfields; number of bits contained in them. */
71 int bitsize;
72
73 /* Only used for bitfields; position of start of field.
74 For BITS_BIG_ENDIAN=0 targets, it is the position of the LSB.
75 For BITS_BIG_ENDIAN=1 targets, it is the position of the MSB. */
76 int bitpos;
77
78 /* Frame register value is relative to. This will be described in
79 the lval enum above as "lval_register". */
80 struct frame_id frame_id;
81
82 /* Type of the value. */
83 struct type *type;
84
85 /* If a value represents a C++ object, then the `type' field gives
86 the object's compile-time type. If the object actually belongs
87 to some class derived from `type', perhaps with other base
88 classes and additional members, then `type' is just a subobject
89 of the real thing, and the full object is probably larger than
90 `type' would suggest.
91
92 If `type' is a dynamic class (i.e. one with a vtable), then GDB
93 can actually determine the object's run-time type by looking at
94 the run-time type information in the vtable. When this
95 information is available, we may elect to read in the entire
96 object, for several reasons:
97
98 - When printing the value, the user would probably rather see the
99 full object, not just the limited portion apparent from the
100 compile-time type.
101
102 - If `type' has virtual base classes, then even printing `type'
103 alone may require reaching outside the `type' portion of the
104 object to wherever the virtual base class has been stored.
105
106 When we store the entire object, `enclosing_type' is the run-time
107 type -- the complete object -- and `embedded_offset' is the
108 offset of `type' within that larger type, in bytes. The
109 VALUE_CONTENTS macro takes `embedded_offset' into account, so
110 most GDB code continues to see the `type' portion of the value,
111 just as the inferior would.
112
113 If `type' is a pointer to an object, then `enclosing_type' is a
114 pointer to the object's run-time type, and `pointed_to_offset' is
115 the offset in bytes from the full object to the pointed-to object
116 -- that is, the value `embedded_offset' would have if we
117 followed the pointer and fetched the complete object. (I don't
118 really see the point. Why not just determine the run-time type
119 when you indirect, and avoid the special case? The contents
120 don't matter until you indirect anyway.)
121
122 If we're not doing anything fancy, `enclosing_type' is equal to
123 `type', and `embedded_offset' is zero, so everything works
124 normally. */
125 struct type *enclosing_type;
126 int embedded_offset;
127 int pointed_to_offset;
128
129 /* Values are stored in a chain, so that they can be deleted
130 easily over calls to the inferior. Values assigned to internal
131 variables or put into the value history are taken off this
132 list. */
133 struct value *next;
134
135 /* Register number if the value is from a register. */
136 short regnum;
137
138 /* If zero, contents of this value are in the contents field. If
139 nonzero, contents are in inferior memory at address in the
140 location.address field plus the offset field (and the lval
141 field should be lval_memory).
142
143 WARNING: This field is used by the code which handles
144 watchpoints (see breakpoint.c) to decide whether a particular
145 value can be watched by hardware watchpoints. If the lazy flag
146 is set for some member of a value chain, it is assumed that
147 this member of the chain doesn't need to be watched as part of
148 watching the value itself. This is how GDB avoids watching the
149 entire struct or array when the user wants to watch a single
150 struct member or array element. If you ever change the way
151 lazy flag is set and reset, be sure to consider this use as
152 well! */
153 char lazy;
154
155 /* If nonzero, this is the value of a variable which does not
156 actually exist in the program. */
157 char optimized_out;
158
159 /* Actual contents of the value. For use of this value; setting
160 it uses the stuff above. Not valid if lazy is nonzero.
161 Target byte-order. We force it to be aligned properly for any
162 possible value. Note that a value therefore extends beyond
163 what is declared here. */
164 union
165 {
166 long contents[1];
167 DOUBLEST force_doublest_align;
168 LONGEST force_longest_align;
169 CORE_ADDR force_core_addr_align;
170 void *force_pointer_align;
171 } aligner;
172 /* Do not add any new members here -- contents above will trash them. */
173};
174
175
176extern struct type *value_type (struct value *);
177extern int value_bitsize (struct value *);
178extern int value_bitpos (struct value *);
179extern int value_offset (struct value *);
180
181#define VALUE_ENCLOSING_TYPE(val) (val)->enclosing_type
182#define VALUE_LAZY(val) (val)->lazy
183
184/* VALUE_CONTENTS and VALUE_CONTENTS_RAW both return the address of
185 the gdb buffer used to hold a copy of the contents of the lval.
186 VALUE_CONTENTS is used when the contents of the buffer are needed
187 -- it uses value_fetch_lazy() to load the buffer from the process
188 being debugged if it hasn't already been loaded.
189 VALUE_CONTENTS_RAW is used when data is being stored into the
190 buffer, or when it is certain that the contents of the buffer are
191 valid.
192
193 Note: The contents pointer is adjusted by the offset required to
194 get to the real subobject, if the value happens to represent
195 something embedded in a larger run-time object. */
196
197#define VALUE_CONTENTS_RAW(val) \
198 ((char *) (val)->aligner.contents + (val)->embedded_offset)
199#define VALUE_CONTENTS(val) \
200 ((void)(VALUE_LAZY(val) && value_fetch_lazy(val)), VALUE_CONTENTS_RAW(val))
201
202/* The ALL variants of the above two macros do not adjust the returned
203 pointer by the embedded_offset value. */
204
205#define VALUE_CONTENTS_ALL_RAW(val) ((char *) (val)->aligner.contents)
206#define VALUE_CONTENTS_ALL(val) \
207 ((void) (VALUE_LAZY(val) && value_fetch_lazy(val)), \
208 VALUE_CONTENTS_ALL_RAW(val))
209
210extern int value_fetch_lazy (struct value *val);
211
212#define VALUE_LVAL(val) (val)->lval
213#define VALUE_ADDRESS(val) (val)->location.address
214#define VALUE_INTERNALVAR(val) (val)->location.internalvar
215#define VALUE_FRAME_ID(val) ((val)->frame_id)
216#define VALUE_REGNUM(val) (val)->regnum
217#define VALUE_OPTIMIZED_OUT(val) ((val)->optimized_out)
218#define VALUE_EMBEDDED_OFFSET(val) ((val)->embedded_offset)
219#define VALUE_POINTED_TO_OFFSET(val) ((val)->pointed_to_offset)
220
221/* Convert a REF to the object referenced. */
222
223extern struct value *coerce_ref (struct value *value);
224
225/* If ARG is an array, convert it to a pointer.
226 If ARG is an enum, convert it to an integer.
227 If ARG is a function, convert it to a function pointer.
228
229 References are dereferenced. */
230
231extern struct value *coerce_array (struct value *value);
232extern struct value *coerce_number (struct value *value);
233
234/* If ARG is an enum, convert it to an integer. */
235
236extern struct value *coerce_enum (struct value *value);
237
238/* Internal variables (variables for convenience of use of debugger)
239 are recorded as a chain of these structures. */
240
241struct internalvar
242{
243 struct internalvar *next;
244 char *name;
245 struct value *value;
246};
247
248/* Pointer to member function. Depends on compiler implementation. */
249
250#define METHOD_PTR_IS_VIRTUAL(ADDR) ((ADDR) & 0x80000000)
251#define METHOD_PTR_FROM_VOFFSET(OFFSET) (0x80000000 + (OFFSET))
252#define METHOD_PTR_TO_VOFFSET(ADDR) (~0x80000000 & (ADDR))
253\f
254
255#include "symtab.h"
256#include "gdbtypes.h"
257#include "expression.h"
258
259struct frame_info;
260struct fn_field;
261
262extern void print_address_demangle (CORE_ADDR, struct ui_file *, int);
263
264extern LONGEST value_as_long (struct value *val);
265extern DOUBLEST value_as_double (struct value *val);
266extern CORE_ADDR value_as_address (struct value *val);
267
268extern LONGEST unpack_long (struct type *type, const char *valaddr);
269extern DOUBLEST unpack_double (struct type *type, const char *valaddr,
270 int *invp);
271extern CORE_ADDR unpack_pointer (struct type *type, const char *valaddr);
272extern LONGEST unpack_field_as_long (struct type *type, const char *valaddr,
273 int fieldno);
274
275extern struct value *value_from_longest (struct type *type, LONGEST num);
276extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
277extern struct value *value_from_double (struct type *type, DOUBLEST num);
278extern struct value *value_from_string (char *string);
279
280extern struct value *value_at (struct type *type, CORE_ADDR addr);
281extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
282
283extern struct value *value_from_register (struct type *type, int regnum,
284 struct frame_info *frame);
285
286extern struct value *value_of_variable (struct symbol *var, struct block *b);
287
288extern struct value *value_of_register (int regnum,
289 struct frame_info *frame);
290
291extern int symbol_read_needs_frame (struct symbol *);
292
293extern struct value *read_var_value (struct symbol *var,
294 struct frame_info *frame);
295
296extern struct value *locate_var_value (struct symbol *var,
297 struct frame_info *frame);
298
299extern struct value *allocate_value (struct type *type);
300
301extern struct value *allocate_repeat_value (struct type *type, int count);
302
303extern struct value *value_change_enclosing_type (struct value *val,
304 struct type *new_type);
305
306extern struct value *value_mark (void);
307
308extern void value_free_to_mark (struct value *mark);
309
310extern struct value *value_string (char *ptr, int len);
311extern struct value *value_bitstring (char *ptr, int len);
312
313extern struct value *value_array (int lowbound, int highbound,
314 struct value ** elemvec);
315
316extern struct value *value_concat (struct value *arg1, struct value *arg2);
317
318extern struct value *value_binop (struct value *arg1, struct value *arg2,
319 enum exp_opcode op);
320
321extern struct value *value_add (struct value *arg1, struct value *arg2);
322
323extern struct value *value_sub (struct value *arg1, struct value *arg2);
324
325extern struct value *value_coerce_array (struct value *arg1);
326
327extern struct value *value_coerce_function (struct value *arg1);
328
329extern struct value *value_ind (struct value *arg1);
330
331extern struct value *value_addr (struct value *arg1);
332
333extern struct value *value_assign (struct value *toval, struct value *fromval);
334
335extern struct value *value_neg (struct value *arg1);
336
337extern struct value *value_complement (struct value *arg1);
338
339extern struct value *value_struct_elt (struct value **argp,
340 struct value **args,
341 char *name, int *static_memfuncp,
342 char *err);
343
344extern struct value *value_aggregate_elt (struct type *curtype,
345 char *name,
346 enum noside noside);
347
348extern struct value *value_static_field (struct type *type, int fieldno);
349
350extern struct fn_field *value_find_oload_method_list (struct value **, char *,
351 int, int *,
352 struct type **, int *);
353
354extern int find_overload_match (struct type **arg_types, int nargs,
355 char *name, int method, int lax,
356 struct value **objp, struct symbol *fsym,
357 struct value **valp, struct symbol **symp,
358 int *staticp);
359
360extern struct value *value_field (struct value *arg1, int fieldno);
361
362extern struct value *value_primitive_field (struct value *arg1, int offset,
363 int fieldno,
364 struct type *arg_type);
365
366
367extern struct type *value_rtti_target_type (struct value *, int *, int *,
368 int *);
369
370extern struct value *value_full_object (struct value *, struct type *, int,
371 int, int);
372
373extern struct value *value_cast (struct type *type, struct value *arg2);
374
375extern struct value *value_zero (struct type *type, enum lval_type lv);
376
377extern struct value *value_repeat (struct value *arg1, int count);
378
379extern struct value *value_subscript (struct value *array, struct value *idx);
380
381extern struct value *register_value_being_returned (struct type *valtype,
382 struct regcache *retbuf);
383
384extern struct value *value_in (struct value *element, struct value *set);
385
386extern int value_bit_index (struct type *type, char *addr, int index);
387
388extern int using_struct_return (struct type *value_type, int gcc_p);
389
390extern struct value *evaluate_expression (struct expression *exp);
391
392extern struct value *evaluate_type (struct expression *exp);
393
394extern struct value *evaluate_subexp_with_coercion (struct expression *,
395 int *, enum noside);
396
397extern struct value *parse_and_eval (char *exp);
398
399extern struct value *parse_to_comma_and_eval (char **expp);
400
401extern struct type *parse_and_eval_type (char *p, int length);
402
403extern CORE_ADDR parse_and_eval_address (char *exp);
404
405extern CORE_ADDR parse_and_eval_address_1 (char **expptr);
406
407extern LONGEST parse_and_eval_long (char *exp);
408
409extern struct value *access_value_history (int num);
410
411extern struct value *value_of_internalvar (struct internalvar *var);
412
413extern void set_internalvar (struct internalvar *var, struct value *val);
414
415extern void set_internalvar_component (struct internalvar *var,
416 int offset,
417 int bitpos, int bitsize,
418 struct value *newvalue);
419
420extern struct internalvar *lookup_internalvar (char *name);
421
422extern int value_equal (struct value *arg1, struct value *arg2);
423
424extern int value_less (struct value *arg1, struct value *arg2);
425
426extern int value_logical_not (struct value *arg1);
427
428/* C++ */
429
430extern struct value *value_of_this (int complain);
431
432extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
433 enum exp_opcode op,
434 enum exp_opcode otherop,
435 enum noside noside);
436
437extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
438 enum noside noside);
439
440extern struct value *value_fn_field (struct value ** arg1p, struct fn_field *f,
441 int j, struct type *type, int offset);
442
443extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
444 struct value *arg2);
445
446extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
447
448extern int destructor_name_p (const char *name, const struct type *type);
449
450#define value_free(val) xfree (val)
451
452extern void free_all_values (void);
453
454extern void release_value (struct value *val);
455
456extern int record_latest_value (struct value *val);
457
458extern void modify_field (char *addr, LONGEST fieldval, int bitpos,
459 int bitsize);
460
461extern void type_print (struct type * type, char *varstring,
462 struct ui_file * stream, int show);
463
464extern char *baseclass_addr (struct type *type, int index, char *valaddr,
465 struct value **valuep, int *errp);
466
467extern void print_longest (struct ui_file * stream, int format,
468 int use_local, LONGEST val);
469
470extern void print_floating (char *valaddr, struct type * type,
471 struct ui_file * stream);
472
473extern int value_print (struct value *val, struct ui_file *stream, int format,
474 enum val_prettyprint pretty);
475
476extern void value_print_array_elements (struct value *val,
477 struct ui_file *stream, int format,
478 enum val_prettyprint pretty);
479
480extern struct value *value_release_to_mark (struct value *mark);
481
482extern int val_print (struct type * type, char *valaddr,
483 int embedded_offset, CORE_ADDR address,
484 struct ui_file * stream, int format,
485 int deref_ref, int recurse,
486 enum val_prettyprint pretty);
487
488extern int val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream);
489
490extern void print_variable_value (struct symbol * var,
491 struct frame_info * frame,
492 struct ui_file *stream);
493
494extern int check_field (struct value *, const char *);
495
496extern void typedef_print (struct type * type, struct symbol * news,
497 struct ui_file * stream);
498
499extern char *internalvar_name (struct internalvar *var);
500
501extern void clear_value_history (void);
502
503extern void clear_internalvars (void);
504
505/* From values.c */
506
507extern struct value *value_copy (struct value *);
508
509/* From valops.c */
510
511extern struct value *varying_to_slice (struct value *);
512
513extern struct value *value_slice (struct value *, int, int);
514
515extern struct value *value_literal_complex (struct value *, struct value *,
516 struct type *);
517
518extern void find_rt_vbase_offset (struct type *, struct type *, char *, int,
519 int *, int *);
520
521extern struct value *find_function_in_inferior (const char *);
522
523extern struct value *value_allocate_space_in_inferior (int);
524
525extern struct value *value_of_local (const char *name, int complain);
526
527#endif /* !defined (VALUE_H) */
GDB Binutils - Deliverables
This page took 0.024042 seconds and 4 git commands to generate.