gdb/value.h

   1 /* Definitions for values of C expressions, for GDB.
   2    Copyright 1986, 1987, 1989, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #if !defined (VALUE_H)
  21 #define VALUE_H 1
  22
  23 /*
  24  * The structure which defines the type of a value.  It should never
  25  * be possible for a program lval value to survive over a call to the inferior
  26  * (ie to be put into the history list or an internal variable).
  27  */
  28 enum lval_type {
  29   /* Not an lval.  */
  30   not_lval,
  31   /* In memory.  Could be a saved register.  */
  32   lval_memory,
  33   /* In a register.  */
  34   lval_register,
  35   /* In a gdb internal variable.  */
  36   lval_internalvar,
  37   /* Part of a gdb internal variable (structure field).  */
  38   lval_internalvar_component,
  39   /* In a register series in a frame not the current one, which may have been
  40      partially saved or saved in different places (otherwise would be
  41      lval_register or lval_memory).  */
  42   lval_reg_frame_relative
  43 };
  44
  45 struct value
  46   {
  47     /* Type of value; either not an lval, or one of the various
  48        different possible kinds of lval.  */
  49     enum lval_type lval;
  50     /* Location of value (if lval).  */
  51     union
  52       {
  53         /* Address in inferior or byte of registers structure.  */
  54         CORE_ADDR address;
  55         /* Pointer to interrnal variable.  */
  56         struct internalvar *internalvar;
  57         /* Number of register.  Only used with
  58            lval_reg_frame_relative.  */
  59         int regnum;
  60       } location;
  61     /* Describes offset of a value within lval a structure in bytes.  */
  62     int offset;
  63     /* Only used for bitfields; number of bits contained in them.  */
  64     int bitsize;
  65     /* Only used for bitfields; position of start of field.  */
  66     int bitpos;
  67     /* Frame value is relative to.  In practice, this address is only
  68        used if the value is stored in several registers in other than
  69        the current frame, and these registers have not all been saved
  70        at the same place in memory.  This will be described in the
  71        lval enum above as "lval_reg_frame_relative".  */
  72     CORE_ADDR frame_addr;
  73     /* Type of the value.  */
  74     struct type *type;
  75     /* Values are stored in a chain, so that they can be deleted
  76        easily over calls to the inferior.  Values assigned to internal
  77        variables or put into the value history are taken off this
  78        list.  */
  79     struct value *next;
  80     /* If an lval is forced to repeat, a new value is created with
  81        these fields set.  The new value is not an lval.  */
  82     short repeated;
  83     short repetitions;
  84     /* Register number if the value is from a register.  Is not kept
  85        if you take a field of a structure that is stored in a
  86        register.  Shouldn't it be?  */
  87     short regno;
  88     /* If zero, contents of this value are in the contents field.
  89        If nonzero, contents are in inferior memory at address
  90        in the location.address field plus the offset field
  91        (and the lval field should be lval_memory).  */
  92     char lazy;
  93     /* If nonzero, this is the value of a variable which does not
  94        actually exist in the program.  */
  95     char optimized_out;
  96     /* Actual contents of the value.  For use of this value; setting
  97        it uses the stuff above.  Not valid if lazy is nonzero.
  98        Target byte-order.  We force it to be aligned properly for any
  99        possible value.  */
 100     union {
 101       long contents[1];
 102       double force_double_align;
 103 #ifdef LONG_LONG
 104       long long force_longlong_align;
 105 #endif
 106     } aligner;
 107
 108   };
 109
 110 typedef struct value *value;
 111
 112 #define VALUE_TYPE(val) (val)->type
 113 #define VALUE_LAZY(val) (val)->lazy
 114 /* VALUE_CONTENTS and VALUE_CONTENTS_RAW both return the address of
 115    the gdb buffer used to hold a copy of the contents of the lval.
 116    VALUE_CONTENTS is used when the contents of the buffer are needed --
 117    it uses value_fetch_lazy() to load the buffer from the process being
 118    debugged if it hasn't already been loaded.  VALUE_CONTENTS_RAW is
 119    used when data is being stored into the buffer, or when it is
 120    certain that the contents of the buffer are valid.  */
 121 #define VALUE_CONTENTS_RAW(val) ((char *) (val)->aligner.contents)
 122 #define VALUE_CONTENTS(val) ((void)(VALUE_LAZY(val) && value_fetch_lazy(val)),\
 123                              VALUE_CONTENTS_RAW(val))
 124 extern int
 125 value_fetch_lazy PARAMS ((value val));
 126
 127 #define VALUE_LVAL(val) (val)->lval
 128 #define VALUE_ADDRESS(val) (val)->location.address
 129 #define VALUE_INTERNALVAR(val) (val)->location.internalvar
 130 #define VALUE_FRAME_REGNUM(val) ((val)->location.regnum)
 131 #define VALUE_FRAME(val) ((val)->frame_addr)
 132 #define VALUE_OFFSET(val) (val)->offset
 133 #define VALUE_BITSIZE(val) (val)->bitsize
 134 #define VALUE_BITPOS(val) (val)->bitpos
 135 #define VALUE_NEXT(val) (val)->next
 136 #define VALUE_REPEATED(val) (val)->repeated
 137 #define VALUE_REPETITIONS(val) (val)->repetitions
 138 #define VALUE_REGNO(val) (val)->regno
 139 #define VALUE_OPTIMIZED_OUT(val) ((val)->optimized_out)
 140
 141 /* Convert a REF to the object referenced. */
 142
 143 #define COERCE_REF(arg)    \
 144 { if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_REF)                    \
 145     arg = value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg)),           \
 146                          unpack_long (VALUE_TYPE (arg),                 \
 147                                       VALUE_CONTENTS (arg)));}
 148
 149 /* If ARG is an array, convert it to a pointer.
 150    If ARG is an enum, convert it to an integer.
 151    If ARG is a function, convert it to a function pointer.
 152
 153    References are dereferenced.  */
 154
 155 #define COERCE_ARRAY(arg)    \
 156 { COERCE_REF(arg);                                                      \
 157   if (VALUE_REPEATED (arg)                                              \
 158       || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY)               \
 159     arg = value_coerce_array (arg);                                     \
 160   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FUNC)                   \
 161     arg = value_coerce_function (arg);                                  \
 162   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)                   \
 163     arg = value_cast (builtin_type_unsigned_int, arg);                  \
 164 }
 165
 166 /* If ARG is an enum, convert it to an integer.  */
 167
 168 #define COERCE_ENUM(arg)    \
 169 { if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_REF)                    \
 170     arg = value_ind (arg);                                              \
 171   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)                   \
 172     arg = value_cast (builtin_type_unsigned_int, arg);                  \
 173 }
 174
 175 /* Internal variables (variables for convenience of use of debugger)
 176    are recorded as a chain of these structures.  */
 177
 178 struct internalvar
 179 {
 180   struct internalvar *next;
 181   char *name;
 182   value value;
 183 };
 184
 185 \f
 186 #include "symtab.h"
 187 #include "gdbtypes.h"
 188 #include "expression.h"
 189
 190 #ifdef __STDC__
 191 struct frame_info;
 192 #endif
 193
 194 extern void
 195 print_address_demangle PARAMS ((CORE_ADDR, FILE *, int));
 196
 197 extern LONGEST
 198 value_as_long PARAMS ((value val));
 199
 200 extern double
 201 value_as_double PARAMS ((value val));
 202
 203 extern CORE_ADDR
 204 value_as_pointer PARAMS ((value val));
 205
 206 extern LONGEST
 207 unpack_long PARAMS ((struct type *type, char *valaddr));
 208
 209 extern double
 210 unpack_double PARAMS ((struct type *type, char *valaddr, int *invp));
 211
 212 extern CORE_ADDR
 213 unpack_pointer PARAMS ((struct type *type, char *valaddr));
 214
 215 extern long
 216 unpack_field_as_long PARAMS ((struct type *type, char *valaddr,
 217                               int fieldno));
 218
 219 extern value
 220 value_from_longest PARAMS ((struct type *type, LONGEST num));
 221
 222 extern value
 223 value_from_double PARAMS ((struct type *type, double num));
 224
 225 extern value
 226 value_at PARAMS ((struct type *type, CORE_ADDR addr));
 227
 228 extern value
 229 value_at_lazy PARAMS ((struct type *type, CORE_ADDR addr));
 230
 231 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 232 extern value
 233 value_from_register PARAMS ((struct type *type, int regnum,
 234                              struct frame_info * frame));
 235
 236 extern value
 237 value_of_variable PARAMS ((struct symbol *var));
 238
 239 extern value
 240 value_of_register PARAMS ((int regnum));
 241
 242 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 243 extern value
 244 read_var_value PARAMS ((struct symbol *var, struct frame_info *frame));
 245
 246 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 247 extern value
 248 locate_var_value PARAMS ((struct symbol *var, struct frame_info *frame));
 249
 250 extern value
 251 allocate_value PARAMS ((struct type *type));
 252
 253 extern value
 254 allocate_repeat_value PARAMS ((struct type *type, int count));
 255
 256 extern value
 257 value_mark PARAMS ((void));
 258
 259 extern void
 260 value_free_to_mark PARAMS ((value mark));
 261
 262 extern value
 263 value_string PARAMS ((char *ptr, int len));
 264
 265 extern value
 266 value_binop PARAMS ((value arg1, value arg2, enum exp_opcode op));
 267
 268 extern value
 269 value_add PARAMS ((value arg1, value arg2));
 270
 271 extern value
 272 value_sub PARAMS ((value arg1, value arg2));
 273
 274 extern value
 275 value_coerce_array PARAMS ((value arg1));
 276
 277 extern value
 278 value_coerce_function PARAMS ((value arg1));
 279
 280 extern value
 281 value_ind PARAMS ((value arg1));
 282
 283 extern value
 284 value_addr PARAMS ((value arg1));
 285
 286 extern value
 287 value_assign PARAMS ((value toval, value fromval));
 288
 289 extern value
 290 value_neg PARAMS ((value arg1));
 291
 292 extern value
 293 value_lognot PARAMS ((value arg1));
 294
 295 extern value
 296 value_struct_elt PARAMS ((value *argp, value *args, char *name,
 297                           int *static_memfuncp, char *err));
 298
 299 extern value
 300 value_struct_elt_for_reference PARAMS ((struct type *domain,
 301                                         struct type *curtype,
 302                                         char *name,
 303                                         struct type *intype));
 304
 305 extern value
 306 value_field PARAMS ((value arg1, int fieldno));
 307
 308 extern value
 309 value_primitive_field PARAMS ((value arg1, int offset, int fieldno,
 310                                struct type *arg_type));
 311
 312 extern value
 313 value_cast PARAMS ((struct type *type, value arg2));
 314
 315 extern value
 316 value_zero PARAMS ((struct type *type, enum lval_type lv));
 317
 318 extern value
 319 value_repeat PARAMS ((value arg1, int count));
 320
 321 extern value
 322 value_subscript PARAMS ((value array, value idx));
 323
 324 extern value
 325 value_from_vtable_info PARAMS ((value arg, struct type *type));
 326
 327 extern value
 328 value_being_returned PARAMS ((struct type *valtype,
 329                               char retbuf[REGISTER_BYTES],
 330                               int struct_return));
 331
 332 extern int
 333 using_struct_return PARAMS ((value function, CORE_ADDR funcaddr,
 334                              struct type *value_type, int gcc_p));
 335
 336 extern void
 337 set_return_value PARAMS ((value val));
 338
 339 extern value
 340 evaluate_expression PARAMS ((struct expression *exp));
 341
 342 extern value
 343 evaluate_type PARAMS ((struct expression *exp));
 344
 345 extern value
 346 parse_and_eval PARAMS ((char *exp));
 347
 348 extern value
 349 parse_to_comma_and_eval PARAMS ((char **expp));
 350
 351 extern struct type *
 352 parse_and_eval_type PARAMS ((char *p, int length));
 353
 354 extern CORE_ADDR
 355 parse_and_eval_address PARAMS ((char *exp));
 356
 357 extern CORE_ADDR
 358 parse_and_eval_address_1 PARAMS ((char **expptr));
 359
 360 extern value
 361 access_value_history PARAMS ((int num));
 362
 363 extern value
 364 value_of_internalvar PARAMS ((struct internalvar *var));
 365
 366 extern void
 367 set_internalvar PARAMS ((struct internalvar *var, value val));
 368
 369 extern void
 370 set_internalvar_component PARAMS ((struct internalvar *var, int offset,
 371                                    int bitpos, int bitsize,
 372                                    value newvalue));
 373
 374 extern struct internalvar *
 375 lookup_internalvar PARAMS ((char *name));
 376
 377 extern int
 378 value_equal PARAMS ((value arg1, value arg2));
 379
 380 extern int
 381 value_less PARAMS ((value arg1, value arg2));
 382
 383 extern int
 384 value_zerop PARAMS ((value arg1));
 385
 386 /* C++ */
 387
 388 extern value
 389 value_of_this PARAMS ((int complain));
 390
 391 extern value
 392 value_x_binop PARAMS ((value arg1, value arg2, enum exp_opcode op,
 393                        enum exp_opcode otherop));
 394
 395 extern value
 396 value_x_unop PARAMS ((value arg1, enum exp_opcode op));
 397
 398 extern value
 399 value_fn_field PARAMS ((struct fn_field *f, int j));
 400
 401 extern value
 402 value_virtual_fn_field PARAMS ((value arg1, struct fn_field *f, int j,
 403                                 struct type *type));
 404
 405 extern int
 406 binop_user_defined_p PARAMS ((enum exp_opcode op, value arg1, value arg2));
 407
 408 extern int
 409 unop_user_defined_p PARAMS ((enum exp_opcode op, value arg1));
 410
 411 extern int
 412 typecmp PARAMS ((int staticp, struct type *t1[], value t2[]));
 413
 414 extern int
 415 destructor_name_p PARAMS ((const char *name, const struct type *type));
 416
 417 #define value_free(val) free (val)
 418
 419 extern void
 420 free_all_values PARAMS ((void));
 421
 422 extern void
 423 release_value PARAMS ((value val));
 424
 425 extern int
 426 record_latest_value PARAMS ((value val));
 427
 428 extern void
 429 registers_changed PARAMS ((void));
 430
 431 extern void
 432 read_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
 433
 434 extern void
 435 write_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
 436
 437 extern void
 438 read_register_gen PARAMS ((int regno, char *myaddr));
 439
 440 extern CORE_ADDR
 441 read_register PARAMS ((int regno));
 442
 443 extern void
 444 write_register PARAMS ((int regno, int val));
 445
 446 extern void
 447 supply_register PARAMS ((int regno, char *val));
 448
 449 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 450 extern void
 451 get_saved_register PARAMS ((char *raw_buffer, int *optimized,
 452                             CORE_ADDR *addrp, struct frame_info *frame,
 453                             int regnum, enum lval_type *lval));
 454
 455 extern void
 456 modify_field PARAMS ((char *addr, int fieldval, int bitpos, int bitsize));
 457
 458 extern void
 459 type_print PARAMS ((struct type *type, char *varstring, FILE *stream,
 460                     int show));
 461
 462 extern void
 463 type_print_1 PARAMS ((struct type *type, char *varstring, FILE *stream,
 464                       int show, int level));
 465
 466 /* Possibilities for prettyprint parameters to routines which print
 467    things.  */
 468 enum val_prettyprint {
 469   Val_no_prettyprint = 0,
 470   Val_prettyprint,
 471   /* Use the default setting which the user has specified.  */
 472   Val_pretty_default
 473   };
 474
 475 extern char *
 476 baseclass_addr PARAMS ((struct type *type, int index, char *valaddr,
 477                         value *valuep, int *errp));
 478
 479 extern void
 480 print_floating PARAMS ((char *valaddr, struct type *type, FILE *stream));
 481
 482 extern int
 483 value_print PARAMS ((value val, FILE *stream, int format,
 484                      enum val_prettyprint pretty));
 485
 486 extern int
 487 val_print PARAMS ((struct type *type, char *valaddr, CORE_ADDR address,
 488                    FILE *stream, int format, int deref_ref,
 489                    int recurse, enum val_prettyprint pretty));
 490
 491 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 492 extern void
 493 print_variable_value PARAMS ((struct symbol *var, struct frame_info *frame,
 494                               FILE *stream));
 495
 496 extern value
 497 value_arg_coerce PARAMS ((value));
 498
 499 extern int
 500 check_field PARAMS ((value, const char *));
 501
 502 extern void
 503 typedef_print PARAMS ((struct type *type, struct symbol *new, FILE *stream));
 504
 505 extern char *
 506 internalvar_name PARAMS ((struct internalvar *var));
 507
 508 extern void
 509 clear_value_history PARAMS ((void));
 510
 511 extern void
 512 clear_internalvars PARAMS ((void));
 513
 514 /* From values.c */
 515
 516 extern value
 517 value_copy PARAMS ((value));
 518
 519 /* From valops.c */
 520
 521 extern value
 522 call_function_by_hand PARAMS ((value, int, value *));
 523
 524 #endif  /* !defined (VALUE_H) */