gdb/value.h

   1 /* Definitions for values of C expressions, for GDB.
   2    Copyright 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 2000, 2001
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #if !defined (VALUE_H)
  23 #define VALUE_H 1
  24
  25 /*
  26  * The structure which defines the type of a value.  It should never
  27  * be possible for a program lval value to survive over a call to the inferior
  28  * (ie to be put into the history list or an internal variable).
  29  */
  30
  31 struct value
  32   {
  33     /* Type of value; either not an lval, or one of the various
  34        different possible kinds of lval.  */
  35     enum lval_type lval;
  36     /* Is it modifiable?  Only relevant if lval != not_lval.  */
  37     int modifiable;
  38     /* Location of value (if lval).  */
  39     union
  40       {
  41         /* If lval == lval_memory, this is the address in the inferior.
  42            If lval == lval_register, this is the byte offset into the
  43            registers structure.  */
  44         CORE_ADDR address;
  45         /* Pointer to internal variable.  */
  46         struct internalvar *internalvar;
  47         /* Number of register.  Only used with
  48            lval_reg_frame_relative.  */
  49         int regnum;
  50       }
  51     location;
  52     /* Describes offset of a value within lval of a structure in bytes.
  53        If lval == lval_memory, this is an offset to the address.
  54        If lval == lval_register, this is a further offset from
  55           location.address within the registers structure.
  56        Note also the member embedded_offset below.  */
  57     int offset;
  58     /* Only used for bitfields; number of bits contained in them.  */
  59     int bitsize;
  60     /* Only used for bitfields; position of start of field.
  61        For BITS_BIG_ENDIAN=0 targets, it is the position of the LSB.
  62        For BITS_BIG_ENDIAN=1 targets, it is the position of the MSB. */
  63     int bitpos;
  64     /* Frame value is relative to.  In practice, this address is only
  65        used if the value is stored in several registers in other than
  66        the current frame, and these registers have not all been saved
  67        at the same place in memory.  This will be described in the
  68        lval enum above as "lval_reg_frame_relative".  */
  69     CORE_ADDR frame_addr;
  70     /* Type of the value.  */
  71     struct type *type;
  72     /* Type of the enclosing object if this is an embedded subobject.
  73        The member embedded_offset gives the real position of the subobject
  74        if type is not the same as enclosing_type.
  75
  76        If the type field is a pointer type, then enclosing_type is
  77        a pointer type pointing to the real (enclosing) type of the target
  78        object. */
  79     struct type *enclosing_type;
  80     /* Values are stored in a chain, so that they can be deleted
  81        easily over calls to the inferior.  Values assigned to internal
  82        variables or put into the value history are taken off this
  83        list.  */
  84     struct value *next;
  85
  86     /* ??? When is this used?  */
  87     union
  88       {
  89         CORE_ADDR memaddr;
  90         char *myaddr;
  91       }
  92     substring_addr;
  93
  94     /* Register number if the value is from a register.  Is not kept
  95        if you take a field of a structure that is stored in a
  96        register.  Shouldn't it be?  */
  97     short regno;
  98     /* If zero, contents of this value are in the contents field.
  99        If nonzero, contents are in inferior memory at address
 100        in the location.address field plus the offset field
 101        (and the lval field should be lval_memory).
 102
 103        WARNING: This field is used by the code which handles
 104        watchpoints (see breakpoint.c) to decide whether a particular
 105        value can be watched by hardware watchpoints.  If the lazy flag
 106        is set for some member of a value chain, it is assumed that
 107        this member of the chain doesn't need to be watched as part of
 108        watching the value itself.  This is how GDB avoids watching the
 109        entire struct or array when the user wants to watch a single
 110        struct member or array element.  If you ever change the way
 111        lazy flag is set and reset, be sure to consider this use as
 112        well!  */
 113     char lazy;
 114     /* If nonzero, this is the value of a variable which does not
 115        actually exist in the program.  */
 116     char optimized_out;
 117     /* If this value represents an object that is embedded inside a
 118        larger object (e.g., a base subobject in C++), this gives the
 119        offset (in bytes) from the start of the contents buffer where
 120        the embedded object begins. This is required because some C++
 121        runtime implementations lay out objects (especially virtual bases
 122        with possibly negative offsets to ancestors).
 123        Note: This may be positive or negative! Also note that this offset
 124        is not used when retrieving contents from target memory; the entire
 125        enclosing object has to be retrieved always, and the offset for
 126        that is given by the member offset above. */
 127     int embedded_offset;
 128     /* If this value represents a pointer to an object that is embedded
 129        in another object, this gives the embedded_offset of the object
 130        that is pointed to. */
 131     int pointed_to_offset;
 132     /* The BFD section associated with this value.  */
 133     asection *bfd_section;
 134     /* Actual contents of the value.  For use of this value; setting
 135        it uses the stuff above.  Not valid if lazy is nonzero.
 136        Target byte-order.  We force it to be aligned properly for any
 137        possible value.  Note that a value therefore extends beyond
 138        what is declared here.  */
 139     union
 140       {
 141         long contents[1];
 142         double force_double_align;
 143         LONGEST force_longlong_align;
 144         char *literal_data;
 145       }
 146     aligner;
 147     /* Do not add any new members here -- contents above will trash them */
 148   };
 149
 150 typedef struct value *value_ptr;
 151
 152 #define VALUE_TYPE(val) (val)->type
 153 #define VALUE_ENCLOSING_TYPE(val) (val)->enclosing_type
 154 #define VALUE_LAZY(val) (val)->lazy
 155 /* VALUE_CONTENTS and VALUE_CONTENTS_RAW both return the address of
 156    the gdb buffer used to hold a copy of the contents of the lval.
 157    VALUE_CONTENTS is used when the contents of the buffer are needed --
 158    it uses value_fetch_lazy() to load the buffer from the process being
 159    debugged if it hasn't already been loaded.  VALUE_CONTENTS_RAW is
 160    used when data is being stored into the buffer, or when it is
 161    certain that the contents of the buffer are valid.
 162    Note: The contents pointer is adjusted by the offset required to
 163    get to the real subobject, if the value happens to represent
 164    something embedded in a larger run-time object. */
 165
 166 #define VALUE_CONTENTS_RAW(val) ((char *) (val)->aligner.contents + (val)->embedded_offset)
 167 #define VALUE_CONTENTS(val) ((void)(VALUE_LAZY(val) && value_fetch_lazy(val)),\
 168                              VALUE_CONTENTS_RAW(val))
 169
 170 /* The ALL variants of the above two macros do not adjust the returned
 171    pointer by the embedded_offset value. */
 172
 173 #define VALUE_CONTENTS_ALL_RAW(val) ((char *) (val)->aligner.contents)
 174 #define VALUE_CONTENTS_ALL(val) ((void) (VALUE_LAZY(val) && value_fetch_lazy(val)),\
 175                                  VALUE_CONTENTS_ALL_RAW(val))
 176
 177
 178 extern int value_fetch_lazy (value_ptr val);
 179
 180 #define VALUE_LVAL(val) (val)->lval
 181 #define VALUE_ADDRESS(val) (val)->location.address
 182 #define VALUE_INTERNALVAR(val) (val)->location.internalvar
 183 #define VALUE_FRAME_REGNUM(val) ((val)->location.regnum)
 184 #define VALUE_FRAME(val) ((val)->frame_addr)
 185 #define VALUE_OFFSET(val) (val)->offset
 186 #define VALUE_BITSIZE(val) (val)->bitsize
 187 #define VALUE_BITPOS(val) (val)->bitpos
 188 #define VALUE_NEXT(val) (val)->next
 189 #define VALUE_REGNO(val) (val)->regno
 190 #define VALUE_OPTIMIZED_OUT(val) ((val)->optimized_out)
 191 #define VALUE_EMBEDDED_OFFSET(val) ((val)->embedded_offset)
 192 #define VALUE_POINTED_TO_OFFSET(val) ((val)->pointed_to_offset)
 193 #define VALUE_BFD_SECTION(val) ((val)->bfd_section)
 194
 195 /* Convert a REF to the object referenced. */
 196
 197 #define COERCE_REF(arg)    \
 198 do { struct type *value_type_arg_tmp = check_typedef (VALUE_TYPE (arg));\
 199      if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF)               \
 200          arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp),    \
 201                               unpack_pointer (VALUE_TYPE (arg),         \
 202                                               VALUE_CONTENTS (arg)),    \
 203                               VALUE_BFD_SECTION (arg));                 \
 204     } while (0)
 205
 206 /* If ARG is an array, convert it to a pointer.
 207    If ARG is an enum, convert it to an integer.
 208    If ARG is a function, convert it to a function pointer.
 209
 210    References are dereferenced.  */
 211
 212 #define COERCE_ARRAY(arg)    \
 213 do { COERCE_REF(arg);                                                   \
 214   if (current_language->c_style_arrays                                  \
 215       && TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_ARRAY)               \
 216     arg = value_coerce_array (arg);                                     \
 217   if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_FUNC)                   \
 218     arg = value_coerce_function (arg);                                  \
 219 } while (0)
 220
 221 #define COERCE_NUMBER(arg)  \
 222   do { COERCE_ARRAY(arg);  COERCE_ENUM(arg); } while (0)
 223
 224 #define COERCE_VARYING_ARRAY(arg, real_arg_type)        \
 225 { if (chill_varying_type (real_arg_type))  \
 226     arg = varying_to_slice (arg), real_arg_type = VALUE_TYPE (arg); }
 227
 228 /* If ARG is an enum, convert it to an integer.  */
 229
 230 #define COERCE_ENUM(arg)   { \
 231   if (TYPE_CODE (check_typedef (VALUE_TYPE (arg))) == TYPE_CODE_ENUM)   \
 232     arg = value_cast (builtin_type_unsigned_int, arg);                  \
 233 }
 234
 235 /* Internal variables (variables for convenience of use of debugger)
 236    are recorded as a chain of these structures.  */
 237
 238 struct internalvar
 239   {
 240     struct internalvar *next;
 241     char *name;
 242     value_ptr value;
 243   };
 244
 245 /* Pointer to member function.  Depends on compiler implementation. */
 246
 247 #define METHOD_PTR_IS_VIRTUAL(ADDR)  ((ADDR) & 0x80000000)
 248 #define METHOD_PTR_FROM_VOFFSET(OFFSET) (0x80000000 + (OFFSET))
 249 #define METHOD_PTR_TO_VOFFSET(ADDR) (~0x80000000 & (ADDR))
 250 \f
 251
 252 #include "symtab.h"
 253 #include "gdbtypes.h"
 254 #include "expression.h"
 255
 256 struct frame_info;
 257 struct fn_field;
 258
 259 extern void print_address_demangle (CORE_ADDR, struct ui_file *, int);
 260
 261 extern LONGEST value_as_long (value_ptr val);
 262
 263 extern DOUBLEST value_as_double (value_ptr val);
 264
 265 extern CORE_ADDR value_as_pointer (value_ptr val);
 266
 267 extern LONGEST unpack_long (struct type *type, char *valaddr);
 268
 269 extern DOUBLEST unpack_double (struct type *type, char *valaddr, int *invp);
 270
 271 extern CORE_ADDR unpack_pointer (struct type *type, char *valaddr);
 272
 273 extern LONGEST unpack_field_as_long (struct type *type, char *valaddr,
 274                                      int fieldno);
 275
 276 extern value_ptr value_from_longest (struct type *type, LONGEST num);
 277
 278 extern value_ptr value_from_pointer (struct type *type, CORE_ADDR addr);
 279
 280 extern value_ptr value_from_double (struct type *type, DOUBLEST num);
 281
 282 extern value_ptr value_from_string (char *string);
 283
 284 extern value_ptr value_at (struct type *type, CORE_ADDR addr,
 285                            asection * sect);
 286
 287 extern value_ptr value_at_lazy (struct type *type, CORE_ADDR addr,
 288                                 asection * sect);
 289
 290 extern value_ptr value_from_register (struct type *type, int regnum,
 291                                       struct frame_info *frame);
 292
 293 extern value_ptr value_of_variable (struct symbol *var, struct block *b);
 294
 295 extern value_ptr value_of_register (int regnum);
 296
 297 extern int symbol_read_needs_frame (struct symbol *);
 298
 299 extern value_ptr read_var_value (struct symbol *var,
 300                                  struct frame_info *frame);
 301
 302 extern value_ptr locate_var_value (struct symbol *var,
 303                                    struct frame_info *frame);
 304
 305 extern value_ptr allocate_value (struct type *type);
 306
 307 extern value_ptr allocate_repeat_value (struct type *type, int count);
 308
 309 extern value_ptr value_mark (void);
 310
 311 extern void value_free_to_mark (value_ptr mark);
 312
 313 extern value_ptr value_string (char *ptr, int len);
 314 extern value_ptr value_bitstring (char *ptr, int len);
 315
 316 extern value_ptr value_array (int lowbound, int highbound,
 317                               value_ptr * elemvec);
 318
 319 extern value_ptr value_concat (value_ptr arg1, value_ptr arg2);
 320
 321 extern value_ptr value_binop (value_ptr arg1, value_ptr arg2,
 322                               enum exp_opcode op);
 323
 324 extern value_ptr value_add (value_ptr arg1, value_ptr arg2);
 325
 326 extern value_ptr value_sub (value_ptr arg1, value_ptr arg2);
 327
 328 extern value_ptr value_coerce_array (value_ptr arg1);
 329
 330 extern value_ptr value_coerce_function (value_ptr arg1);
 331
 332 extern value_ptr value_ind (value_ptr arg1);
 333
 334 extern value_ptr value_addr (value_ptr arg1);
 335
 336 extern value_ptr value_assign (value_ptr toval, value_ptr fromval);
 337
 338 extern value_ptr value_neg (value_ptr arg1);
 339
 340 extern value_ptr value_complement (value_ptr arg1);
 341
 342 extern value_ptr value_struct_elt (value_ptr * argp, value_ptr * args,
 343                                    char *name,
 344                                    int *static_memfuncp, char *err);
 345
 346 extern value_ptr value_struct_elt_for_reference (struct type *domain,
 347                                                  int offset,
 348                                                  struct type *curtype,
 349                                                  char *name,
 350                                                  struct type *intype);
 351
 352 extern value_ptr value_static_field (struct type *type, int fieldno);
 353
 354 extern struct fn_field *value_find_oload_method_list (value_ptr *, char *,
 355                                                       int, int *, int *,
 356                                                       struct type **, int *);
 357
 358 extern int find_overload_match (struct type **arg_types, int nargs,
 359                                 char *name, int method, int lax,
 360                                 value_ptr obj, struct symbol *fsym,
 361                                 value_ptr * valp, struct symbol **symp,
 362                                 int *staticp);
 363
 364 extern value_ptr value_field (value_ptr arg1, int fieldno);
 365
 366 extern value_ptr value_primitive_field (value_ptr arg1, int offset,
 367                                         int fieldno, struct type *arg_type);
 368
 369 extern struct type *value_rtti_type (value_ptr, int *, int *, int *);
 370
 371 extern struct type *value_rtti_target_type (value_ptr, int *, int *, int *);
 372
 373 extern value_ptr value_full_object (value_ptr, struct type *, int, int, int);
 374
 375 extern value_ptr value_cast (struct type *type, value_ptr arg2);
 376
 377 extern value_ptr value_zero (struct type *type, enum lval_type lv);
 378
 379 extern value_ptr value_repeat (value_ptr arg1, int count);
 380
 381 extern value_ptr value_subscript (value_ptr array, value_ptr idx);
 382
 383 extern value_ptr value_from_vtable_info (value_ptr arg, struct type *type);
 384
 385 extern value_ptr value_being_returned (struct type *valtype,
 386                                        char *retbuf, int struct_return);
 387
 388 extern value_ptr value_in (value_ptr element, value_ptr set);
 389
 390 extern int value_bit_index (struct type *type, char *addr, int index);
 391
 392 extern int using_struct_return (value_ptr function, CORE_ADDR funcaddr,
 393                                 struct type *value_type, int gcc_p);
 394
 395 extern void set_return_value (value_ptr val);
 396
 397 extern value_ptr evaluate_expression (struct expression *exp);
 398
 399 extern value_ptr evaluate_type (struct expression *exp);
 400
 401 extern value_ptr evaluate_subexp_with_coercion (struct expression *,
 402                                                 int *, enum noside);
 403
 404 extern value_ptr parse_and_eval (char *exp);
 405
 406 extern value_ptr parse_to_comma_and_eval (char **expp);
 407
 408 extern struct type *parse_and_eval_type (char *p, int length);
 409
 410 extern CORE_ADDR parse_and_eval_address (char *exp);
 411
 412 extern CORE_ADDR parse_and_eval_address_1 (char **expptr);
 413
 414 extern LONGEST parse_and_eval_long (char *exp);
 415
 416 extern value_ptr access_value_history (int num);
 417
 418 extern value_ptr value_of_internalvar (struct internalvar *var);
 419
 420 extern void set_internalvar (struct internalvar *var, value_ptr val);
 421
 422 extern void set_internalvar_component (struct internalvar *var,
 423                                        int offset,
 424                                        int bitpos, int bitsize,
 425                                        value_ptr newvalue);
 426
 427 extern struct internalvar *lookup_internalvar (char *name);
 428
 429 extern int value_equal (value_ptr arg1, value_ptr arg2);
 430
 431 extern int value_less (value_ptr arg1, value_ptr arg2);
 432
 433 extern int value_logical_not (value_ptr arg1);
 434
 435 /* C++ */
 436
 437 extern value_ptr value_of_this (int complain);
 438
 439 extern value_ptr value_x_binop (value_ptr arg1, value_ptr arg2,
 440                                 enum exp_opcode op,
 441                                 enum exp_opcode otherop, enum noside noside);
 442
 443 extern value_ptr value_x_unop (value_ptr arg1, enum exp_opcode op,
 444                                enum noside noside);
 445
 446 extern value_ptr value_fn_field (value_ptr * arg1p, struct fn_field *f,
 447                                  int j, struct type *type, int offset);
 448
 449 extern value_ptr value_virtual_fn_field (value_ptr * arg1p,
 450                                          struct fn_field *f, int j,
 451                                          struct type *type, int offset);
 452
 453 extern int binop_user_defined_p (enum exp_opcode op,
 454                                  value_ptr arg1, value_ptr arg2);
 455
 456 extern int unop_user_defined_p (enum exp_opcode op, value_ptr arg1);
 457
 458 extern int destructor_name_p (const char *name, const struct type *type);
 459
 460 #define value_free(val) xfree (val)
 461
 462 extern void free_all_values (void);
 463
 464 extern void release_value (value_ptr val);
 465
 466 extern int record_latest_value (value_ptr val);
 467
 468 extern void
 469 modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize);
 470
 471 extern void type_print (struct type * type, char *varstring,
 472                         struct ui_file * stream, int show);
 473
 474 extern char *baseclass_addr (struct type *type, int index,
 475                              char *valaddr, value_ptr * valuep, int *errp);
 476
 477 extern void print_longest (struct ui_file * stream, int format,
 478                            int use_local, LONGEST val);
 479
 480 extern void print_floating (char *valaddr, struct type * type,
 481                             struct ui_file * stream);
 482
 483 extern int value_print (value_ptr val, struct ui_file *stream, int format,
 484                         enum val_prettyprint pretty);
 485
 486 extern void value_print_array_elements (value_ptr val,
 487                                         struct ui_file *stream,
 488                                         int format,
 489                                         enum val_prettyprint pretty);
 490
 491 extern value_ptr value_release_to_mark (value_ptr mark);
 492
 493 extern int val_print (struct type * type, char *valaddr,
 494                       int embedded_offset, CORE_ADDR address,
 495                       struct ui_file * stream, int format,
 496                       int deref_ref, int recurse,
 497                       enum val_prettyprint pretty);
 498
 499 extern int val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream);
 500
 501 extern void print_variable_value (struct symbol * var,
 502                                   struct frame_info * frame,
 503                                   struct ui_file *stream);
 504
 505 extern int check_field (value_ptr, const char *);
 506
 507 extern void typedef_print (struct type * type, struct symbol * news,
 508                              struct ui_file * stream);
 509
 510 extern char *internalvar_name (struct internalvar *var);
 511
 512 extern void clear_value_history (void);
 513
 514 extern void clear_internalvars (void);
 515
 516 /* From values.c */
 517
 518 extern value_ptr value_copy (value_ptr);
 519
 520 extern int baseclass_offset (struct type *, int, char *, CORE_ADDR);
 521
 522 /* From valops.c */
 523
 524 extern value_ptr varying_to_slice (value_ptr);
 525
 526 extern value_ptr value_slice (value_ptr, int, int);
 527
 528 extern value_ptr call_function_by_hand (value_ptr, int, value_ptr *);
 529
 530 extern int default_coerce_float_to_double (struct type *, struct type *);
 531
 532 extern int standard_coerce_float_to_double (struct type *, struct type *);
 533
 534 extern value_ptr value_literal_complex (value_ptr, value_ptr, struct type *);
 535
 536 extern void find_rt_vbase_offset (struct type *, struct type *, char *, int,
 537                                   int *, int *);
 538
 539 extern value_ptr find_function_in_inferior (char *);
 540
 541 extern value_ptr value_allocate_space_in_inferior (int);
 542
 543 extern CORE_ADDR default_push_arguments (int nargs, value_ptr * args,
 544                                          CORE_ADDR sp,
 545                                          int struct_return,
 546                                          CORE_ADDR struct_addr);
 547
 548 #endif /* !defined (VALUE_H) */