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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 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, 2009, 2010 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
struct language_defn;
35
struct 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
 
42
struct 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
 
49
struct value *value_next (struct value *);
50
 
51
/* Type of the value.  */
52
 
53
extern 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
 
59
extern 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
 
64
extern int value_bitsize (const struct value *);
65
extern 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
 
71
extern int value_bitpos (const struct value *);
72
extern 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
 
78
struct 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
 
86
extern int value_offset (const struct value *);
87
extern 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
 
93
extern int deprecated_value_modifiable (struct value *value);
94
extern 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
 
138
extern struct type *value_enclosing_type (struct value *);
139
extern struct value *value_change_enclosing_type (struct value *val,
140
                                                  struct type *new_type);
141
extern int value_pointed_to_offset (struct value *value);
142
extern void set_value_pointed_to_offset (struct value *value, int val);
143
extern int value_embedded_offset (struct value *value);
144
extern void set_value_embedded_offset (struct value *value, int val);
145
 
146
/* For lval_computed values, this structure holds functions used to
147
   retrieve and set the value (or portions of the value).
148
 
149
   For each function, 'V' is the 'this' pointer: an lval_funcs
150
   function F may always assume that the V it receives is an
151
   lval_computed value, and has F in the appropriate slot of its
152
   lval_funcs structure.  */
153
 
154
struct lval_funcs
155
{
156
  /* Fill in VALUE's contents.  This is used to "un-lazy" values.  If
157
     a problem arises in obtaining VALUE's bits, this function should
158
     call 'error'.  */
159
  void (*read) (struct value *v);
160
 
161
  /* Handle an assignment TOVAL = FROMVAL by writing the value of
162
     FROMVAL to TOVAL's location.  The contents of TOVAL have not yet
163
     been updated.  If a problem arises in doing so, this function
164
     should call 'error'.  */
165
  void (*write) (struct value *toval, struct value *fromval);
166
 
167
  /* Check the validity of some bits in VALUE.  This should return 1
168
     if all the bits starting at OFFSET and extending for LENGTH bits
169
     are valid, or 0 if any bit is invalid.  */
170
  int (*check_validity) (const struct value *value, int offset, int length);
171
 
172
  /* Return 1 if any bit in VALUE is valid, 0 if they are all invalid.  */
173
  int (*check_any_valid) (const struct value *value);
174
 
175
  /* Return a duplicate of VALUE's closure, for use in a new value.
176
     This may simply return the same closure, if VALUE's is
177
     reference-counted or statically allocated.
178
 
179
     This may be NULL, in which case VALUE's closure is re-used in the
180
     new value.  */
181
  void *(*copy_closure) (const struct value *v);
182
 
183
  /* Drop VALUE's reference to its closure.  Maybe this frees the
184
     closure; maybe this decrements a reference count; maybe the
185
     closure is statically allocated and this does nothing.
186
 
187
     This may be NULL, in which case no action is taken to free
188
     VALUE's closure.  */
189
  void (*free_closure) (struct value *v);
190
};
191
 
192
/* Create a computed lvalue, with type TYPE, function pointers FUNCS,
193
   and closure CLOSURE.  */
194
 
195
extern struct value *allocate_computed_value (struct type *type,
196
                                              struct lval_funcs *funcs,
197
                                              void *closure);
198
 
199
/* If VALUE is lval_computed, return its lval_funcs structure.  */
200
 
201
extern struct lval_funcs *value_computed_funcs (struct value *value);
202
 
203
/* If VALUE is lval_computed, return its closure.  The meaning of the
204
   returned value depends on the functions VALUE uses.  */
205
 
206
extern void *value_computed_closure (const struct value *value);
207
 
208
/* If zero, contents of this value are in the contents field.  If
209
   nonzero, contents are in inferior.  If the lval field is lval_memory,
210
   the contents are in inferior memory at location.address plus offset.
211
   The lval field may also be lval_register.
212
 
213
   WARNING: This field is used by the code which handles watchpoints
214
   (see breakpoint.c) to decide whether a particular value can be
215
   watched by hardware watchpoints.  If the lazy flag is set for some
216
   member of a value chain, it is assumed that this member of the
217
   chain doesn't need to be watched as part of watching the value
218
   itself.  This is how GDB avoids watching the entire struct or array
219
   when the user wants to watch a single struct member or array
220
   element.  If you ever change the way lazy flag is set and reset, be
221
   sure to consider this use as well!  */
222
 
223
extern int value_lazy (struct value *);
224
extern void set_value_lazy (struct value *value, int val);
225
 
226
extern int value_stack (struct value *);
227
extern void set_value_stack (struct value *value, int val);
228
 
229
/* value_contents() and value_contents_raw() both return the address
230
   of the gdb buffer used to hold a copy of the contents of the lval.
231
   value_contents() is used when the contents of the buffer are needed
232
   -- it uses value_fetch_lazy() to load the buffer from the process
233
   being debugged if it hasn't already been loaded
234
   (value_contents_writeable() is used when a writeable but fetched
235
   buffer is required)..  value_contents_raw() is used when data is
236
   being stored into the buffer, or when it is certain that the
237
   contents of the buffer are valid.
238
 
239
   Note: The contents pointer is adjusted by the offset required to
240
   get to the real subobject, if the value happens to represent
241
   something embedded in a larger run-time object.  */
242
 
243
extern gdb_byte *value_contents_raw (struct value *);
244
 
245
/* Actual contents of the value.  For use of this value; setting it
246
   uses the stuff above.  Not valid if lazy is nonzero.  Target
247
   byte-order.  We force it to be aligned properly for any possible
248
   value.  Note that a value therefore extends beyond what is
249
   declared here.  */
250
 
251
extern const gdb_byte *value_contents (struct value *);
252
extern gdb_byte *value_contents_writeable (struct value *);
253
 
254
/* The ALL variants of the above two macros do not adjust the returned
255
   pointer by the embedded_offset value.  */
256
 
257
extern gdb_byte *value_contents_all_raw (struct value *);
258
extern const gdb_byte *value_contents_all (struct value *);
259
 
260
/* Like value_contents_all, but does not require that the returned
261
   bits be valid.  This should only be used in situations where you
262
   plan to check the validity manually.  */
263
extern const gdb_byte *value_contents_for_printing (struct value *value);
264
 
265
extern int value_fetch_lazy (struct value *val);
266
extern int value_contents_equal (struct value *val1, struct value *val2);
267
 
268
/* If nonzero, this is the value of a variable which does not actually
269
   exist in the program.  */
270
extern int value_optimized_out (struct value *value);
271
extern void set_value_optimized_out (struct value *value, int val);
272
 
273
/* Like value_optimized_out, but return false if any bit in the object
274
   is valid.  */
275
extern int value_entirely_optimized_out (const struct value *value);
276
 
277
/* Set or return field indicating whether a variable is initialized or
278
   not, based on debugging information supplied by the compiler.
279
   1 = initialized; 0 = uninitialized.  */
280
extern int value_initialized (struct value *);
281
extern void set_value_initialized (struct value *, int);
282
 
283
/* Set COMPONENT's location as appropriate for a component of WHOLE
284
   --- regardless of what kind of lvalue WHOLE is.  */
285
extern void set_value_component_location (struct value *component,
286
                                          const struct value *whole);
287
 
288
/* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
289
   single value might have multiple LVALs), this hacked interface is
290
   limited to just the first PIECE.  Expect further change.  */
291
/* Type of value; either not an lval, or one of the various different
292
   possible kinds of lval.  */
293
extern enum lval_type *deprecated_value_lval_hack (struct value *);
294
#define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
295
 
296
/* If lval == lval_memory, return the address in the inferior.  If
297
   lval == lval_register, return the byte offset into the registers
298
   structure.  Otherwise, return 0.  The returned address
299
   includes the offset, if any.  */
300
extern CORE_ADDR value_address (struct value *);
301
 
302
/* Like value_address, except the result does not include value's
303
   offset.  */
304
extern CORE_ADDR value_raw_address (struct value *);
305
 
306
/* Set the address of a value.  */
307
extern void set_value_address (struct value *, CORE_ADDR);
308
 
309
/* Pointer to internal variable.  */
310
extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
311
#define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))
312
 
313
/* Frame register value is relative to.  This will be described in the
314
   lval enum above as "lval_register".  */
315
extern struct frame_id *deprecated_value_frame_id_hack (struct value *);
316
#define VALUE_FRAME_ID(val) (*deprecated_value_frame_id_hack (val))
317
 
318
/* Register number if the value is from a register.  */
319
extern short *deprecated_value_regnum_hack (struct value *);
320
#define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
321
 
322
/* Convert a REF to the object referenced.  */
323
 
324
extern struct value *coerce_ref (struct value *value);
325
 
326
/* If ARG is an array, convert it to a pointer.
327
   If ARG is a function, convert it to a function pointer.
328
 
329
   References are dereferenced.  */
330
 
331
extern struct value *coerce_array (struct value *value);
332
 
333
/* Given a value, determine whether the bits starting at OFFSET and
334
   extending for LENGTH bits are valid.  This returns nonzero if all
335
   bits in the given range are valid, zero if any bit is invalid.  */
336
 
337
extern int value_bits_valid (const struct value *value,
338
                             int offset, int length);
339
 
340
 
341
 
342
#include "symtab.h"
343
#include "gdbtypes.h"
344
#include "expression.h"
345
 
346
struct frame_info;
347
struct fn_field;
348
 
349
extern void print_address_demangle (struct gdbarch *, CORE_ADDR,
350
                                    struct ui_file *, int);
351
 
352
extern LONGEST value_as_long (struct value *val);
353
extern DOUBLEST value_as_double (struct value *val);
354
extern CORE_ADDR value_as_address (struct value *val);
355
 
356
extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
357
extern DOUBLEST unpack_double (struct type *type, const gdb_byte *valaddr,
358
                               int *invp);
359
extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
360
LONGEST unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr,
361
                             int bitpos, int bitsize);
362
extern LONGEST unpack_field_as_long (struct type *type,
363
                                     const gdb_byte *valaddr,
364
                                     int fieldno);
365
 
366
extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
367
 
368
extern struct value *value_from_longest (struct type *type, LONGEST num);
369
extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
370
extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
371
extern struct value *value_from_double (struct type *type, DOUBLEST num);
372
extern struct value *value_from_decfloat (struct type *type,
373
                                          const gdb_byte *decbytes);
374
 
375
extern struct value *value_at (struct type *type, CORE_ADDR addr);
376
extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
377
 
378
extern struct value *value_from_contents_and_address (struct type *,
379
                                                      const gdb_byte *,
380
                                                      CORE_ADDR);
381
 
382
extern struct value *default_value_from_register (struct type *type,
383
                                                  int regnum,
384
                                                  struct frame_info *frame);
385
 
386
extern struct value *value_from_register (struct type *type, int regnum,
387
                                          struct frame_info *frame);
388
 
389
extern CORE_ADDR address_from_register (struct type *type, int regnum,
390
                                        struct frame_info *frame);
391
 
392
extern struct value *value_of_variable (struct symbol *var, struct block *b);
393
 
394
extern struct value *address_of_variable (struct symbol *var, struct block *b);
395
 
396
extern struct value *value_of_register (int regnum, struct frame_info *frame);
397
 
398
struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
399
 
400
extern int symbol_read_needs_frame (struct symbol *);
401
 
402
extern struct value *read_var_value (struct symbol *var,
403
                                     struct frame_info *frame);
404
 
405
extern struct value *allocate_value (struct type *type);
406
extern struct value *allocate_value_lazy (struct type *type);
407
extern void allocate_value_contents (struct value *value);
408
 
409
extern struct value *allocate_repeat_value (struct type *type, int count);
410
 
411
extern struct value *value_mark (void);
412
 
413
extern void value_free_to_mark (struct value *mark);
414
 
415
extern struct value *value_cstring (char *ptr, int len,
416
                                    struct type *char_type);
417
extern struct value *value_string (char *ptr, int len,
418
                                   struct type *char_type);
419
extern struct value *value_bitstring (char *ptr, int len,
420
                                      struct type *index_type);
421
 
422
extern struct value *value_array (int lowbound, int highbound,
423
                                  struct value **elemvec);
424
 
425
extern struct value *value_concat (struct value *arg1, struct value *arg2);
426
 
427
extern struct value *value_binop (struct value *arg1, struct value *arg2,
428
                                  enum exp_opcode op);
429
 
430
extern struct value *value_ptradd (struct value *arg1, LONGEST arg2);
431
 
432
extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2);
433
 
434
extern int value_must_coerce_to_target (struct value *arg1);
435
 
436
extern struct value *value_coerce_to_target (struct value *arg1);
437
 
438
extern struct value *value_coerce_array (struct value *arg1);
439
 
440
extern struct value *value_coerce_function (struct value *arg1);
441
 
442
extern struct value *value_ind (struct value *arg1);
443
 
444
extern struct value *value_addr (struct value *arg1);
445
 
446
extern struct value *value_ref (struct value *arg1);
447
 
448
extern struct value *value_assign (struct value *toval,
449
                                   struct value *fromval);
450
 
451
extern struct value *value_pos (struct value *arg1);
452
 
453
extern struct value *value_neg (struct value *arg1);
454
 
455
extern struct value *value_complement (struct value *arg1);
456
 
457
extern struct value *value_struct_elt (struct value **argp,
458
                                       struct value **args,
459
                                       const char *name, int *static_memfuncp,
460
                                       const char *err);
461
 
462
extern struct value *value_aggregate_elt (struct type *curtype,
463
                                          char *name,
464
                                          struct type *expect_type,
465
                                          int want_address,
466
                                          enum noside noside);
467
 
468
extern struct value *value_static_field (struct type *type, int fieldno);
469
 
470
extern struct fn_field *value_find_oload_method_list (struct value **,
471
                                                      const char *,
472
                                                      int, int *,
473
                                                      struct type **, int *);
474
 
475
enum oload_search_type { NON_METHOD, METHOD, BOTH };
476
 
477
extern int find_overload_match (struct type **arg_types, int nargs,
478
                                const char *name,
479
                                enum oload_search_type method, int lax,
480
                                struct value **objp, struct symbol *fsym,
481
                                struct value **valp, struct symbol **symp,
482
                                int *staticp, const int no_adl);
483
 
484
extern struct value *value_field (struct value *arg1, int fieldno);
485
 
486
extern struct value *value_primitive_field (struct value *arg1, int offset,
487
                                            int fieldno,
488
                                            struct type *arg_type);
489
 
490
 
491
extern struct type *value_rtti_target_type (struct value *, int *, int *,
492
                                            int *);
493
 
494
extern struct value *value_full_object (struct value *, struct type *, int,
495
                                        int, int);
496
 
497
extern struct value *value_cast_pointers (struct type *, struct value *);
498
 
499
extern struct value *value_cast (struct type *type, struct value *arg2);
500
 
501
extern struct value *value_reinterpret_cast (struct type *type,
502
                                             struct value *arg);
503
 
504
extern struct value *value_dynamic_cast (struct type *type, struct value *arg);
505
 
506
extern struct value *value_zero (struct type *type, enum lval_type lv);
507
 
508
extern struct value *value_one (struct type *type, enum lval_type lv);
509
 
510
extern struct value *value_repeat (struct value *arg1, int count);
511
 
512
extern struct value *value_subscript (struct value *array, LONGEST index);
513
 
514
extern struct value *value_bitstring_subscript (struct type *type,
515
                                                struct value *bitstring,
516
                                                LONGEST index);
517
 
518
extern struct value *register_value_being_returned (struct type *valtype,
519
                                                    struct regcache *retbuf);
520
 
521
extern int value_in (struct value *element, struct value *set);
522
 
523
extern int value_bit_index (struct type *type, const gdb_byte *addr,
524
                            int index);
525
 
526
extern int using_struct_return (struct gdbarch *gdbarch,
527
                                struct type *func_type,
528
                                struct type *value_type);
529
 
530
extern struct value *evaluate_expression (struct expression *exp);
531
 
532
extern struct value *evaluate_type (struct expression *exp);
533
 
534
extern struct value *evaluate_subexp (struct type *expect_type,
535
                                      struct expression *exp,
536
                                      int *pos, enum noside noside);
537
 
538
extern struct value *evaluate_subexpression_type (struct expression *exp,
539
                                                  int subexp);
540
 
541
extern void fetch_subexp_value (struct expression *exp, int *pc,
542
                                struct value **valp, struct value **resultp,
543
                                struct value **val_chain);
544
 
545
extern char *extract_field_op (struct expression *exp, int *subexp);
546
 
547
extern struct value *evaluate_subexp_with_coercion (struct expression *,
548
                                                    int *, enum noside);
549
 
550
extern struct value *parse_and_eval (char *exp);
551
 
552
extern struct value *parse_to_comma_and_eval (char **expp);
553
 
554
extern struct type *parse_and_eval_type (char *p, int length);
555
 
556
extern CORE_ADDR parse_and_eval_address (char *exp);
557
 
558
extern CORE_ADDR parse_and_eval_address_1 (char **expptr);
559
 
560
extern LONGEST parse_and_eval_long (char *exp);
561
 
562
extern void unop_promote (const struct language_defn *language,
563
                          struct gdbarch *gdbarch,
564
                          struct value **arg1);
565
 
566
extern void binop_promote (const struct language_defn *language,
567
                           struct gdbarch *gdbarch,
568
                           struct value **arg1, struct value **arg2);
569
 
570
extern struct value *access_value_history (int num);
571
 
572
extern struct value *value_of_internalvar (struct gdbarch *gdbarch,
573
                                           struct internalvar *var);
574
 
575
extern int get_internalvar_integer (struct internalvar *var, LONGEST *l);
576
 
577
extern void set_internalvar (struct internalvar *var, struct value *val);
578
 
579
extern void set_internalvar_integer (struct internalvar *var, LONGEST l);
580
 
581
extern void set_internalvar_string (struct internalvar *var,
582
                                    const char *string);
583
 
584
extern void clear_internalvar (struct internalvar *var);
585
 
586
extern void set_internalvar_component (struct internalvar *var,
587
                                       int offset,
588
                                       int bitpos, int bitsize,
589
                                       struct value *newvalue);
590
 
591
extern struct internalvar *lookup_only_internalvar (const char *name);
592
 
593
extern struct internalvar *create_internalvar (const char *name);
594
 
595
typedef struct value * (*internalvar_make_value) (struct gdbarch *,
596
                                                  struct internalvar *);
597
extern struct internalvar *
598
  create_internalvar_type_lazy (char *name, internalvar_make_value fun);
599
 
600
extern struct internalvar *lookup_internalvar (const char *name);
601
 
602
extern int value_equal (struct value *arg1, struct value *arg2);
603
 
604
extern int value_equal_contents (struct value *arg1, struct value *arg2);
605
 
606
extern int value_less (struct value *arg1, struct value *arg2);
607
 
608
extern int value_logical_not (struct value *arg1);
609
 
610
/* C++ */
611
 
612
extern struct value *value_of_this (int complain);
613
 
614
extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
615
                                    enum exp_opcode op,
616
                                    enum exp_opcode otherop,
617
                                    enum noside noside);
618
 
619
extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
620
                                   enum noside noside);
621
 
622
extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
623
                                     int j, struct type *type, int offset);
624
 
625
extern int binop_types_user_defined_p (enum exp_opcode op,
626
                                       struct type *type1,
627
                                       struct type *type2);
628
 
629
extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
630
                                 struct value *arg2);
631
 
632
extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
633
 
634
extern int destructor_name_p (const char *name, const struct type *type);
635
 
636
extern void value_incref (struct value *val);
637
 
638
extern void value_free (struct value *val);
639
 
640
extern void free_all_values (void);
641
 
642
extern void free_value_chain (struct value *v);
643
 
644
extern void release_value (struct value *val);
645
 
646
extern int record_latest_value (struct value *val);
647
 
648
extern void modify_field (struct type *type, gdb_byte *addr,
649
                          LONGEST fieldval, int bitpos, int bitsize);
650
 
651
extern void type_print (struct type *type, char *varstring,
652
                        struct ui_file *stream, int show);
653
 
654
extern char *type_to_string (struct type *type);
655
 
656
extern gdb_byte *baseclass_addr (struct type *type, int index,
657
                                 gdb_byte *valaddr,
658
                                 struct value **valuep, int *errp);
659
 
660
extern void print_longest (struct ui_file *stream, int format,
661
                           int use_local, LONGEST val);
662
 
663
extern void print_floating (const gdb_byte *valaddr, struct type *type,
664
                            struct ui_file *stream);
665
 
666
extern void print_decimal_floating (const gdb_byte *valaddr, struct type *type,
667
                                    struct ui_file *stream);
668
 
669
extern int value_print (struct value *val, struct ui_file *stream,
670
                        const struct value_print_options *options);
671
 
672
extern void value_print_array_elements (struct value *val,
673
                                        struct ui_file *stream, int format,
674
                                        enum val_prettyprint pretty);
675
 
676
extern struct value *value_release_to_mark (struct value *mark);
677
 
678
extern int val_print (struct type *type, const gdb_byte *valaddr,
679
                      int embedded_offset, CORE_ADDR address,
680
                      struct ui_file *stream, int recurse,
681
                      const struct value *val,
682
                      const struct value_print_options *options,
683
                      const struct language_defn *language);
684
 
685
extern int common_val_print (struct value *val,
686
                             struct ui_file *stream, int recurse,
687
                             const struct value_print_options *options,
688
                             const struct language_defn *language);
689
 
690
extern int val_print_string (struct type *elttype, CORE_ADDR addr, int len,
691
                             struct ui_file *stream,
692
                             const struct value_print_options *options);
693
 
694
extern void print_variable_and_value (const char *name,
695
                                      struct symbol *var,
696
                                      struct frame_info *frame,
697
                                      struct ui_file *stream,
698
                                      int indent);
699
 
700
extern int check_field (struct type *, const char *);
701
 
702
extern void typedef_print (struct type *type, struct symbol *news,
703
                           struct ui_file *stream);
704
 
705
extern char *internalvar_name (struct internalvar *var);
706
 
707
extern void preserve_values (struct objfile *);
708
 
709
/* From values.c */
710
 
711
extern struct value *value_copy (struct value *);
712
 
713
extern void preserve_one_value (struct value *, struct objfile *, htab_t);
714
 
715
/* From valops.c */
716
 
717
extern struct value *varying_to_slice (struct value *);
718
 
719
extern struct value *value_slice (struct value *, int, int);
720
 
721
extern struct value *value_literal_complex (struct value *, struct value *,
722
                                            struct type *);
723
 
724
extern struct value *find_function_in_inferior (const char *,
725
                                                struct objfile **);
726
 
727
extern struct value *value_allocate_space_in_inferior (int);
728
 
729
extern struct value *value_of_local (const char *name, int complain);
730
 
731
extern struct value *value_subscripted_rvalue (struct value *array,
732
                                               LONGEST index, int lowerbound);
733
 
734
/* User function handler.  */
735
 
736
typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
737
                                               const struct language_defn *language,
738
                                               void *cookie,
739
                                               int argc,
740
                                               struct value **argv);
741
 
742
void add_internal_function (const char *name, const char *doc,
743
                            internal_function_fn handler,
744
                            void *cookie);
745
 
746
struct value *call_internal_function (struct gdbarch *gdbarch,
747
                                      const struct language_defn *language,
748
                                      struct value *function,
749
                                      int argc, struct value **argv);
750
 
751
char *value_internal_function_name (struct value *);
752
 
753
#endif /* !defined (VALUE_H) */

powered by: WebSVN 2.1.0

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