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 *default_value_from_register (struct type *type,
 284                                                   int regnum,
 285                                                   struct frame_info *frame);
 286
 287 extern struct value *value_from_register (struct type *type, int regnum,
 288                                           struct frame_info *frame);
 289
 290 extern CORE_ADDR address_from_register (struct type *type, int regnum,
 291                                         struct frame_info *frame);
 292
 293 extern struct value *value_of_variable (struct symbol *var, struct block *b);
 294
 295 extern struct value *value_of_register (int regnum, struct frame_info *frame);
 296
 297 extern int symbol_read_needs_frame (struct symbol *);
 298
 299 extern struct value *read_var_value (struct symbol *var,
 300                                      struct frame_info *frame);
 301
 302 extern struct value *locate_var_value (struct symbol *var,
 303                                        struct frame_info *frame);
 304
 305 extern struct value *allocate_value (struct type *type);
 306
 307 extern struct value *allocate_repeat_value (struct type *type, int count);
 308
 309 extern struct value *value_mark (void);
 310
 311 extern void value_free_to_mark (struct value *mark);
 312
 313 extern struct value *value_string (char *ptr, int len);
 314 extern struct value *value_bitstring (char *ptr, int len);
 315
 316 extern struct value *value_array (int lowbound, int highbound,
 317                                   struct value **elemvec);
 318
 319 extern struct value *value_concat (struct value *arg1, struct value *arg2);
 320
 321 extern struct value *value_binop (struct value *arg1, struct value *arg2,
 322                                   enum exp_opcode op);
 323
 324 extern struct value *value_add (struct value *arg1, struct value *arg2);
 325
 326 extern struct value *value_sub (struct value *arg1, struct value *arg2);
 327
 328 extern struct value *value_coerce_array (struct value *arg1);
 329
 330 extern struct value *value_coerce_function (struct value *arg1);
 331
 332 extern struct value *value_ind (struct value *arg1);
 333
 334 extern struct value *value_addr (struct value *arg1);
 335
 336 extern struct value *value_ref (struct value *arg1);
 337
 338 extern struct value *value_assign (struct value *toval,
 339                                    struct value *fromval);
 340
 341 extern struct value *value_pos (struct value *arg1);
 342
 343 extern struct value *value_neg (struct value *arg1);
 344
 345 extern struct value *value_complement (struct value *arg1);
 346
 347 extern struct value *value_struct_elt (struct value **argp,
 348                                        struct value **args,
 349                                        char *name, int *static_memfuncp,
 350                                        char *err);
 351
 352 extern struct value *value_aggregate_elt (struct type *curtype,
 353                                           char *name,
 354                                           int want_address,
 355                                           enum noside noside);
 356
 357 extern struct value *value_static_field (struct type *type, int fieldno);
 358
 359 extern struct fn_field *value_find_oload_method_list (struct value **, char *,
 360                                                       int, int *,
 361                                                       struct type **, int *);
 362
 363 extern int find_overload_match (struct type **arg_types, int nargs,
 364                                 char *name, int method, int lax,
 365                                 struct value **objp, struct symbol *fsym,
 366                                 struct value **valp, struct symbol **symp,
 367                                 int *staticp);
 368
 369 extern struct value *value_field (struct value *arg1, int fieldno);
 370
 371 extern struct value *value_primitive_field (struct value *arg1, int offset,
 372                                             int fieldno,
 373                                             struct type *arg_type);
 374
 375
 376 extern struct type *value_rtti_target_type (struct value *, int *, int *,
 377                                             int *);
 378
 379 extern struct value *value_full_object (struct value *, struct type *, int,
 380                                         int, int);
 381
 382 extern struct value *value_cast_pointers (struct type *, struct value *);
 383
 384 extern struct value *value_cast (struct type *type, struct value *arg2);
 385
 386 extern struct value *value_zero (struct type *type, enum lval_type lv);
 387
 388 extern struct value *value_repeat (struct value *arg1, int count);
 389
 390 extern struct value *value_subscript (struct value *array, struct value *idx);
 391
 392 extern struct value *register_value_being_returned (struct type *valtype,
 393                                                     struct regcache *retbuf);
 394
 395 extern struct value *value_in (struct value *element, struct value *set);
 396
 397 extern int value_bit_index (struct type *type, const gdb_byte *addr,
 398                             int index);
 399
 400 extern int using_struct_return (struct type *value_type, int gcc_p);
 401
 402 extern struct value *evaluate_expression (struct expression *exp);
 403
 404 extern struct value *evaluate_type (struct expression *exp);
 405
 406 extern struct value *evaluate_subexp_with_coercion (struct expression *,
 407                                                     int *, enum noside);
 408
 409 extern struct value *parse_and_eval (char *exp);
 410
 411 extern struct value *parse_to_comma_and_eval (char **expp);
 412
 413 extern struct type *parse_and_eval_type (char *p, int length);
 414
 415 extern CORE_ADDR parse_and_eval_address (char *exp);
 416
 417 extern CORE_ADDR parse_and_eval_address_1 (char **expptr);
 418
 419 extern LONGEST parse_and_eval_long (char *exp);
 420
 421 extern struct value *access_value_history (int num);
 422
 423 extern struct value *value_of_internalvar (struct internalvar *var);
 424
 425 extern void set_internalvar (struct internalvar *var, struct value *val);
 426
 427 extern void set_internalvar_component (struct internalvar *var,
 428                                        int offset,
 429                                        int bitpos, int bitsize,
 430                                        struct value *newvalue);
 431
 432 extern struct internalvar *lookup_internalvar (char *name);
 433
 434 extern int value_equal (struct value *arg1, struct value *arg2);
 435
 436 extern int value_less (struct value *arg1, struct value *arg2);
 437
 438 extern int value_logical_not (struct value *arg1);
 439
 440 /* C++ */
 441
 442 extern struct value *value_of_this (int complain);
 443
 444 extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
 445                                     enum exp_opcode op,
 446                                     enum exp_opcode otherop,
 447                                     enum noside noside);
 448
 449 extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
 450                                    enum noside noside);
 451
 452 extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
 453                                      int j, struct type *type, int offset);
 454
 455 extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
 456                                  struct value *arg2);
 457
 458 extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
 459
 460 extern int destructor_name_p (const char *name, const struct type *type);
 461
 462 #define value_free(val) xfree (val)
 463
 464 extern void free_all_values (void);
 465
 466 extern void release_value (struct value *val);
 467
 468 extern int record_latest_value (struct value *val);
 469
 470 extern void modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos,
 471                           int bitsize);
 472
 473 extern void type_print (struct type *type, char *varstring,
 474                         struct ui_file *stream, int show);
 475
 476 extern gdb_byte *baseclass_addr (struct type *type, int index,
 477                                  gdb_byte *valaddr,
 478                                  struct value **valuep, int *errp);
 479
 480 extern void print_longest (struct ui_file *stream, int format,
 481                            int use_local, LONGEST val);
 482
 483 extern void print_floating (const gdb_byte *valaddr, struct type *type,
 484                             struct ui_file *stream);
 485
 486 extern int value_print (struct value *val, struct ui_file *stream, int format,
 487                         enum val_prettyprint pretty);
 488
 489 extern void value_print_array_elements (struct value *val,
 490                                         struct ui_file *stream, int format,
 491                                         enum val_prettyprint pretty);
 492
 493 extern struct value *value_release_to_mark (struct value *mark);
 494
 495 extern int val_print (struct type *type, const gdb_byte *valaddr,
 496                       int embedded_offset, CORE_ADDR address,
 497                       struct ui_file *stream, int format,
 498                       int deref_ref, int recurse,
 499                       enum val_prettyprint pretty);
 500
 501 extern int common_val_print (struct value *val,
 502                              struct ui_file *stream, int format,
 503                              int deref_ref, int recurse,
 504                              enum val_prettyprint pretty);
 505
 506 extern int val_print_string (CORE_ADDR addr, int len, int width,
 507                              struct ui_file *stream);
 508
 509 extern void print_variable_value (struct symbol *var,
 510                                   struct frame_info *frame,
 511                                   struct ui_file *stream);
 512
 513 extern int check_field (struct value *, const char *);
 514
 515 extern void typedef_print (struct type *type, struct symbol *news,
 516                            struct ui_file *stream);
 517
 518 extern char *internalvar_name (struct internalvar *var);
 519
 520 extern void preserve_values (struct objfile *);
 521
 522 /* From values.c */
 523
 524 extern struct value *value_copy (struct value *);
 525
 526 /* From valops.c */
 527
 528 extern struct value *varying_to_slice (struct value *);
 529
 530 extern struct value *value_slice (struct value *, int, int);
 531
 532 extern struct value *value_literal_complex (struct value *, struct value *,
 533                                             struct type *);
 534
 535 extern void find_rt_vbase_offset (struct type *, struct type *,
 536                                   const gdb_byte *, int, int *, int *);
 537
 538 extern struct value *find_function_in_inferior (const char *);
 539
 540 extern struct value *value_allocate_space_in_inferior (int);
 541
 542 extern struct value *value_of_local (const char *name, int complain);
 543
 544 #endif /* !defined (VALUE_H) */