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 internal 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        For BITS_BIG_ENDIAN=0 targets, it is the position of the LSB.
  67        For BITS_BIG_ENDIAN=1 targets, it is the position of the MSB. */
  68     int bitpos;
  69     /* Frame value is relative to.  In practice, this address is only
  70        used if the value is stored in several registers in other than
  71        the current frame, and these registers have not all been saved
  72        at the same place in memory.  This will be described in the
  73        lval enum above as "lval_reg_frame_relative".  */
  74     CORE_ADDR frame_addr;
  75     /* Type of the value.  */
  76     struct type *type;
  77     /* Values are stored in a chain, so that they can be deleted
  78        easily over calls to the inferior.  Values assigned to internal
  79        variables or put into the value history are taken off this
  80        list.  */
  81     struct value *next;
  82     /* If an lval is forced to repeat, a new value is created with
  83        these fields set.  The new value is not an lval.  */
  84     short repeated;
  85     short repetitions;
  86     /* Register number if the value is from a register.  Is not kept
  87        if you take a field of a structure that is stored in a
  88        register.  Shouldn't it be?  */
  89     short regno;
  90     /* If zero, contents of this value are in the contents field.
  91        If nonzero, contents are in inferior memory at address
  92        in the location.address field plus the offset field
  93        (and the lval field should be lval_memory).  */
  94     char lazy;
  95     /* If nonzero, this is the value of a variable which does not
  96        actually exist in the program.  */
  97     char optimized_out;
  98     /* Actual contents of the value.  For use of this value; setting
  99        it uses the stuff above.  Not valid if lazy is nonzero.
 100        Target byte-order.  We force it to be aligned properly for any
 101        possible value.  */
 102     union {
 103       long contents[1];
 104       double force_double_align;
 105 #ifdef CC_HAS_LONG_LONG
 106       long long force_longlong_align;
 107 #endif
 108     } aligner;
 109
 110   };
 111
 112 typedef struct value *value;
 113
 114 #define VALUE_TYPE(val) (val)->type
 115 #define VALUE_LAZY(val) (val)->lazy
 116 /* VALUE_CONTENTS and VALUE_CONTENTS_RAW both return the address of
 117    the gdb buffer used to hold a copy of the contents of the lval.
 118    VALUE_CONTENTS is used when the contents of the buffer are needed --
 119    it uses value_fetch_lazy() to load the buffer from the process being
 120    debugged if it hasn't already been loaded.  VALUE_CONTENTS_RAW is
 121    used when data is being stored into the buffer, or when it is
 122    certain that the contents of the buffer are valid.  */
 123 #define VALUE_CONTENTS_RAW(val) ((char *) (val)->aligner.contents)
 124 #define VALUE_CONTENTS(val) ((void)(VALUE_LAZY(val) && value_fetch_lazy(val)),\
 125                              VALUE_CONTENTS_RAW(val))
 126 extern int
 127 value_fetch_lazy PARAMS ((value val));
 128
 129 #define VALUE_LVAL(val) (val)->lval
 130 #define VALUE_ADDRESS(val) (val)->location.address
 131 #define VALUE_INTERNALVAR(val) (val)->location.internalvar
 132 #define VALUE_FRAME_REGNUM(val) ((val)->location.regnum)
 133 #define VALUE_FRAME(val) ((val)->frame_addr)
 134 #define VALUE_OFFSET(val) (val)->offset
 135 #define VALUE_BITSIZE(val) (val)->bitsize
 136 #define VALUE_BITPOS(val) (val)->bitpos
 137 #define VALUE_NEXT(val) (val)->next
 138 #define VALUE_REPEATED(val) (val)->repeated
 139 #define VALUE_REPETITIONS(val) (val)->repetitions
 140 #define VALUE_REGNO(val) (val)->regno
 141 #define VALUE_OPTIMIZED_OUT(val) ((val)->optimized_out)
 142
 143 /* Convert a REF to the object referenced. */
 144
 145 #define COERCE_REF(arg)    \
 146 { if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_REF)                    \
 147     arg = value_at_lazy (TYPE_TARGET_TYPE (VALUE_TYPE (arg)),           \
 148                          unpack_long (VALUE_TYPE (arg),                 \
 149                                       VALUE_CONTENTS (arg)));}
 150
 151 /* If ARG is an array, convert it to a pointer.
 152    If ARG is an enum, convert it to an integer.
 153    If ARG is a function, convert it to a function pointer.
 154
 155    References are dereferenced.  */
 156
 157 #define COERCE_ARRAY(arg)    \
 158 { COERCE_REF(arg);                                                      \
 159   if (VALUE_REPEATED (arg)                                              \
 160       || TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY)               \
 161     arg = value_coerce_array (arg);                                     \
 162   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FUNC)                   \
 163     arg = value_coerce_function (arg);                                  \
 164   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)                   \
 165     arg = value_cast (builtin_type_unsigned_int, arg);                  \
 166 }
 167
 168 /* If ARG is an enum, convert it to an integer.  */
 169
 170 #define COERCE_ENUM(arg)    \
 171 { if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_REF)                    \
 172     arg = value_ind (arg);                                              \
 173   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ENUM)                   \
 174     arg = value_cast (builtin_type_unsigned_int, arg);                  \
 175 }
 176
 177 /* Internal variables (variables for convenience of use of debugger)
 178    are recorded as a chain of these structures.  */
 179
 180 struct internalvar
 181 {
 182   struct internalvar *next;
 183   char *name;
 184   value value;
 185 };
 186
 187 /* Pointer to member function.  Depends on compiler implementation. */
 188
 189 #define METHOD_PTR_IS_VIRTUAL(ADDR)  ((ADDR) & 0x80000000)
 190 #define METHOD_PTR_FROM_VOFFSET(OFFSET) (0x80000000 + (OFFSET))
 191 #define METHOD_PTR_TO_VOFFSET(ADDR) (~0x80000000 & (ADDR))
 192
 193 \f
 194 #include "symtab.h"
 195 #include "gdbtypes.h"
 196 #include "expression.h"
 197
 198 #ifdef __STDC__
 199 struct frame_info;
 200 struct fn_field;
 201 #endif
 202
 203 extern void
 204 print_address_demangle PARAMS ((CORE_ADDR, FILE *, int));
 205
 206 extern LONGEST
 207 value_as_long PARAMS ((value val));
 208
 209 extern double
 210 value_as_double PARAMS ((value val));
 211
 212 extern CORE_ADDR
 213 value_as_pointer PARAMS ((value val));
 214
 215 extern LONGEST
 216 unpack_long PARAMS ((struct type *type, char *valaddr));
 217
 218 extern double
 219 unpack_double PARAMS ((struct type *type, char *valaddr, int *invp));
 220
 221 extern CORE_ADDR
 222 unpack_pointer PARAMS ((struct type *type, char *valaddr));
 223
 224 extern LONGEST
 225 unpack_field_as_long PARAMS ((struct type *type, char *valaddr,
 226                               int fieldno));
 227
 228 extern value
 229 value_from_longest PARAMS ((struct type *type, LONGEST num));
 230
 231 extern value
 232 value_from_double PARAMS ((struct type *type, double num));
 233
 234 extern value
 235 value_at PARAMS ((struct type *type, CORE_ADDR addr));
 236
 237 extern value
 238 value_at_lazy PARAMS ((struct type *type, CORE_ADDR addr));
 239
 240 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 241 extern value
 242 value_from_register PARAMS ((struct type *type, int regnum,
 243                              struct frame_info * frame));
 244
 245 extern value
 246 value_of_variable PARAMS ((struct symbol *var));
 247
 248 extern value
 249 value_of_register PARAMS ((int regnum));
 250
 251 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 252 extern value
 253 read_var_value PARAMS ((struct symbol *var, struct frame_info *frame));
 254
 255 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 256 extern value
 257 locate_var_value PARAMS ((struct symbol *var, struct frame_info *frame));
 258
 259 extern value
 260 allocate_value PARAMS ((struct type *type));
 261
 262 extern value
 263 allocate_repeat_value PARAMS ((struct type *type, int count));
 264
 265 extern value
 266 value_mark PARAMS ((void));
 267
 268 extern void
 269 value_free_to_mark PARAMS ((value mark));
 270
 271 extern value
 272 value_string PARAMS ((char *ptr, int len));
 273
 274 extern value
 275 value_array PARAMS ((int lowbound, int highbound, value *elemvec));
 276
 277 extern value
 278 value_concat PARAMS ((value arg1, value arg2));
 279
 280 extern value
 281 value_binop PARAMS ((value arg1, value arg2, enum exp_opcode op));
 282
 283 extern value
 284 value_add PARAMS ((value arg1, value arg2));
 285
 286 extern value
 287 value_sub PARAMS ((value arg1, value arg2));
 288
 289 extern value
 290 value_coerce_array PARAMS ((value arg1));
 291
 292 extern value
 293 value_coerce_function PARAMS ((value arg1));
 294
 295 extern value
 296 value_ind PARAMS ((value arg1));
 297
 298 extern value
 299 value_addr PARAMS ((value arg1));
 300
 301 extern value
 302 value_assign PARAMS ((value toval, value fromval));
 303
 304 extern value
 305 value_neg PARAMS ((value arg1));
 306
 307 extern value
 308 value_complement PARAMS ((value arg1));
 309
 310 extern value
 311 value_struct_elt PARAMS ((value *argp, value *args, char *name,
 312                           int *static_memfuncp, char *err));
 313
 314 extern value
 315 value_struct_elt_for_reference PARAMS ((struct type *domain,
 316                                         int offset,
 317                                         struct type *curtype,
 318                                         char *name,
 319                                         struct type *intype));
 320
 321 extern value
 322 value_field PARAMS ((value arg1, int fieldno));
 323
 324 extern value
 325 value_primitive_field PARAMS ((value arg1, int offset, int fieldno,
 326                                struct type *arg_type));
 327
 328 extern value
 329 value_cast PARAMS ((struct type *type, value arg2));
 330
 331 extern value
 332 value_zero PARAMS ((struct type *type, enum lval_type lv));
 333
 334 extern value
 335 value_repeat PARAMS ((value arg1, int count));
 336
 337 extern value
 338 value_subscript PARAMS ((value array, value idx));
 339
 340 extern value
 341 value_from_vtable_info PARAMS ((value arg, struct type *type));
 342
 343 extern value
 344 value_being_returned PARAMS ((struct type *valtype,
 345                               char retbuf[REGISTER_BYTES],
 346                               int struct_return));
 347
 348 extern int
 349 using_struct_return PARAMS ((value function, CORE_ADDR funcaddr,
 350                              struct type *value_type, int gcc_p));
 351
 352 extern void
 353 set_return_value PARAMS ((value val));
 354
 355 extern value
 356 evaluate_expression PARAMS ((struct expression *exp));
 357
 358 extern value
 359 evaluate_type PARAMS ((struct expression *exp));
 360
 361 extern value
 362 parse_and_eval PARAMS ((char *exp));
 363
 364 extern value
 365 parse_to_comma_and_eval PARAMS ((char **expp));
 366
 367 extern struct type *
 368 parse_and_eval_type PARAMS ((char *p, int length));
 369
 370 extern CORE_ADDR
 371 parse_and_eval_address PARAMS ((char *exp));
 372
 373 extern CORE_ADDR
 374 parse_and_eval_address_1 PARAMS ((char **expptr));
 375
 376 extern value
 377 access_value_history PARAMS ((int num));
 378
 379 extern value
 380 value_of_internalvar PARAMS ((struct internalvar *var));
 381
 382 extern void
 383 set_internalvar PARAMS ((struct internalvar *var, value val));
 384
 385 extern void
 386 set_internalvar_component PARAMS ((struct internalvar *var, int offset,
 387                                    int bitpos, int bitsize,
 388                                    value newvalue));
 389
 390 extern struct internalvar *
 391 lookup_internalvar PARAMS ((char *name));
 392
 393 extern int
 394 value_equal PARAMS ((value arg1, value arg2));
 395
 396 extern int
 397 value_less PARAMS ((value arg1, value arg2));
 398
 399 extern int
 400 value_logical_not PARAMS ((value arg1));
 401
 402 /* C++ */
 403
 404 extern value
 405 value_of_this PARAMS ((int complain));
 406
 407 extern value
 408 value_x_binop PARAMS ((value arg1, value arg2, enum exp_opcode op,
 409                        enum exp_opcode otherop));
 410
 411 extern value
 412 value_x_unop PARAMS ((value arg1, enum exp_opcode op));
 413
 414 extern value
 415 value_fn_field PARAMS ((value *arg1p, struct fn_field *f, int j,
 416                         struct type* type, int offset));
 417
 418 extern value
 419 value_virtual_fn_field PARAMS ((value *arg1p, struct fn_field *f, int j,
 420                                 struct type *type, int offset));
 421
 422 extern int
 423 binop_user_defined_p PARAMS ((enum exp_opcode op, value arg1, value arg2));
 424
 425 extern int
 426 unop_user_defined_p PARAMS ((enum exp_opcode op, value arg1));
 427
 428 extern int
 429 destructor_name_p PARAMS ((const char *name, const struct type *type));
 430
 431 #define value_free(val) free ((PTR)val)
 432
 433 extern void
 434 free_all_values PARAMS ((void));
 435
 436 extern void
 437 release_value PARAMS ((value val));
 438
 439 extern int
 440 record_latest_value PARAMS ((value val));
 441
 442 extern void
 443 registers_changed PARAMS ((void));
 444
 445 extern void
 446 read_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
 447
 448 extern void
 449 write_register_bytes PARAMS ((int regbyte, char *myaddr, int len));
 450
 451 extern void
 452 read_register_gen PARAMS ((int regno, char *myaddr));
 453
 454 extern CORE_ADDR
 455 read_register PARAMS ((int regno));
 456
 457 extern void
 458 write_register PARAMS ((int regno, int val));
 459
 460 extern void
 461 supply_register PARAMS ((int regno, char *val));
 462
 463 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 464 extern void
 465 get_saved_register PARAMS ((char *raw_buffer, int *optimized,
 466                             CORE_ADDR *addrp, struct frame_info *frame,
 467                             int regnum, enum lval_type *lval));
 468
 469 extern void
 470 modify_field PARAMS ((char *addr, int fieldval, int bitpos, int bitsize));
 471
 472 extern void
 473 type_print PARAMS ((struct type *type, char *varstring, FILE *stream,
 474                     int show));
 475
 476 extern char *
 477 baseclass_addr PARAMS ((struct type *type, int index, char *valaddr,
 478                         value *valuep, int *errp));
 479
 480 extern void
 481 print_longest PARAMS ((FILE *stream, char format, int use_local,
 482                        LONGEST value));
 483
 484 extern void
 485 print_floating PARAMS ((char *valaddr, struct type *type, FILE *stream));
 486
 487 extern int
 488 value_print PARAMS ((value val, FILE *stream, int format,
 489                      enum val_prettyprint pretty));
 490
 491 extern int
 492 val_print PARAMS ((struct type *type, char *valaddr, CORE_ADDR address,
 493                    FILE *stream, int format, int deref_ref,
 494                    int recurse, enum val_prettyprint pretty));
 495
 496 extern int
 497 val_print_string PARAMS ((CORE_ADDR addr, unsigned int len, FILE *stream));
 498
 499 /* FIXME:  Assumes equivalence of "struct frame_info *" and "FRAME" */
 500 extern void
 501 print_variable_value PARAMS ((struct symbol *var, struct frame_info *frame,
 502                               FILE *stream));
 503
 504 extern value
 505 value_arg_coerce PARAMS ((value));
 506
 507 extern int
 508 check_field PARAMS ((value, const char *));
 509
 510 extern void
 511 c_typedef_print PARAMS ((struct type *type, struct symbol *new, FILE *stream));
 512
 513 extern char *
 514 internalvar_name PARAMS ((struct internalvar *var));
 515
 516 extern void
 517 clear_value_history PARAMS ((void));
 518
 519 extern void
 520 clear_internalvars PARAMS ((void));
 521
 522 /* From values.c */
 523
 524 extern value
 525 value_copy PARAMS ((value));
 526
 527 extern int
 528 baseclass_offset PARAMS ((struct type *, int, value, int));
 529
 530 /* From valops.c */
 531
 532 extern value
 533 call_function_by_hand PARAMS ((value, int, value *));
 534
 535 #endif  /* !defined (VALUE_H) */