OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [value.h] - Blame information for rev 157

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.