gdb/value.h

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