gdb/value.h

   1 /* Definitions for values of C expressions, for GDB.
   2
   3    Copyright (C) 1986-2018 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #if !defined (VALUE_H)
  21 #define VALUE_H 1
  22
  23 #include "frame.h"              /* For struct frame_id.  */
  24 #include "extension.h"
  25
  26 struct block;
  27 struct expression;
  28 struct regcache;
  29 struct symbol;
  30 struct type;
  31 struct ui_file;
  32 struct language_defn;
  33 struct value_print_options;
  34
  35 /* Values can be partially 'optimized out' and/or 'unavailable'.
  36    These are distinct states and have different string representations
  37    and related error strings.
  38
  39    'unavailable' has a specific meaning in this context.  It means the
  40    value exists in the program (at the machine level), but GDB has no
  41    means to get to it.  Such a value is normally printed as
  42    <unavailable>.  Examples of how to end up with an unavailable value
  43    would be:
  44
  45     - We're inspecting a traceframe, and the memory or registers the
  46       debug information says the value lives on haven't been collected.
  47
  48     - We're inspecting a core dump, the memory or registers the debug
  49       information says the value lives aren't present in the dump
  50       (that is, we have a partial/trimmed core dump, or we don't fully
  51       understand/handle the core dump's format).
  52
  53     - We're doing live debugging, but the debug API has no means to
  54       get at where the value lives in the machine, like e.g., ptrace
  55       not having access to some register or register set.
  56
  57     - Any other similar scenario.
  58
  59   OTOH, "optimized out" is about what the compiler decided to generate
  60   (or not generate).  A chunk of a value that was optimized out does
  61   not actually exist in the program.  There's no way to get at it
  62   short of compiling the program differently.
  63
  64   A register that has not been saved in a frame is likewise considered
  65   optimized out, except not-saved registers have a different string
  66   representation and related error strings.  E.g., we'll print them as
  67   <not-saved> instead of <optimized out>, as in:
  68
  69     (gdb) p/x $rax
  70     $1 = <not saved>
  71     (gdb) info registers rax
  72     rax            <not saved>
  73
  74   If the debug info describes a variable as being in such a register,
  75   we'll still print the variable as <optimized out>.  IOW, <not saved>
  76   is reserved for inspecting registers at the machine level.
  77
  78   When comparing value contents, optimized out chunks, unavailable
  79   chunks, and valid contents data are all considered different.  See
  80   value_contents_eq for more info.
  81 */
  82
  83 /* The structure which defines the type of a value.  It should never
  84    be possible for a program lval value to survive over a call to the
  85    inferior (i.e. to be put into the history list or an internal
  86    variable).  */
  87
  88 struct value;
  89
  90 /* Values are stored in a chain, so that they can be deleted easily
  91    over calls to the inferior.  Values assigned to internal variables,
  92    put into the value history or exposed to Python are taken off this
  93    list.  */
  94
  95 struct value *value_next (const struct value *);
  96
  97 /* Type of the value.  */
  98
  99 extern struct type *value_type (const struct value *);
 100
 101 /* Return the gdbarch associated with the value. */
 102
 103 extern struct gdbarch *get_value_arch (const struct value *value);
 104
 105 /* This is being used to change the type of an existing value, that
 106    code should instead be creating a new value with the changed type
 107    (but possibly shared content).  */
 108
 109 extern void deprecated_set_value_type (struct value *value,
 110                                        struct type *type);
 111
 112 /* Only used for bitfields; number of bits contained in them.  */
 113
 114 extern LONGEST value_bitsize (const struct value *);
 115 extern void set_value_bitsize (struct value *, LONGEST bit);
 116
 117 /* Only used for bitfields; position of start of field.  For
 118    gdbarch_bits_big_endian=0 targets, it is the position of the LSB.  For
 119    gdbarch_bits_big_endian=1 targets, it is the position of the MSB.  */
 120
 121 extern LONGEST value_bitpos (const struct value *);
 122 extern void set_value_bitpos (struct value *, LONGEST bit);
 123
 124 /* Only used for bitfields; the containing value.  This allows a
 125    single read from the target when displaying multiple
 126    bitfields.  */
 127
 128 struct value *value_parent (const struct value *);
 129 extern void set_value_parent (struct value *value, struct value *parent);
 130
 131 /* Describes offset of a value within lval of a structure in bytes.
 132    If lval == lval_memory, this is an offset to the address.  If lval
 133    == lval_register, this is a further offset from location.address
 134    within the registers structure.  Note also the member
 135    embedded_offset below.  */
 136
 137 extern LONGEST value_offset (const struct value *);
 138 extern void set_value_offset (struct value *, LONGEST offset);
 139
 140 /* The comment from "struct value" reads: ``Is it modifiable?  Only
 141    relevant if lval != not_lval.''.  Shouldn't the value instead be
 142    not_lval and be done with it?  */
 143
 144 extern int deprecated_value_modifiable (const struct value *value);
 145
 146 /* If a value represents a C++ object, then the `type' field gives the
 147    object's compile-time type.  If the object actually belongs to some
 148    class derived from `type', perhaps with other base classes and
 149    additional members, then `type' is just a subobject of the real
 150    thing, and the full object is probably larger than `type' would
 151    suggest.
 152
 153    If `type' is a dynamic class (i.e. one with a vtable), then GDB can
 154    actually determine the object's run-time type by looking at the
 155    run-time type information in the vtable.  When this information is
 156    available, we may elect to read in the entire object, for several
 157    reasons:
 158
 159    - When printing the value, the user would probably rather see the
 160      full object, not just the limited portion apparent from the
 161      compile-time type.
 162
 163    - If `type' has virtual base classes, then even printing `type'
 164      alone may require reaching outside the `type' portion of the
 165      object to wherever the virtual base class has been stored.
 166
 167    When we store the entire object, `enclosing_type' is the run-time
 168    type -- the complete object -- and `embedded_offset' is the offset
 169    of `type' within that larger type, in bytes.  The value_contents()
 170    macro takes `embedded_offset' into account, so most GDB code
 171    continues to see the `type' portion of the value, just as the
 172    inferior would.
 173
 174    If `type' is a pointer to an object, then `enclosing_type' is a
 175    pointer to the object's run-time type, and `pointed_to_offset' is
 176    the offset in bytes from the full object to the pointed-to object
 177    -- that is, the value `embedded_offset' would have if we followed
 178    the pointer and fetched the complete object.  (I don't really see
 179    the point.  Why not just determine the run-time type when you
 180    indirect, and avoid the special case?  The contents don't matter
 181    until you indirect anyway.)
 182
 183    If we're not doing anything fancy, `enclosing_type' is equal to
 184    `type', and `embedded_offset' is zero, so everything works
 185    normally.  */
 186
 187 extern struct type *value_enclosing_type (const struct value *);
 188 extern void set_value_enclosing_type (struct value *val,
 189                                       struct type *new_type);
 190
 191 /* Returns value_type or value_enclosing_type depending on
 192    value_print_options.objectprint.
 193
 194    If RESOLVE_SIMPLE_TYPES is 0 the enclosing type will be resolved
 195    only for pointers and references, else it will be returned
 196    for all the types (e.g. structures).  This option is useful
 197    to prevent retrieving enclosing type for the base classes fields.
 198
 199    REAL_TYPE_FOUND is used to inform whether the real type was found
 200    (or just static type was used).  The NULL may be passed if it is not
 201    necessary. */
 202
 203 extern struct type *value_actual_type (struct value *value,
 204                                        int resolve_simple_types,
 205                                        int *real_type_found);
 206
 207 extern LONGEST value_pointed_to_offset (const struct value *value);
 208 extern void set_value_pointed_to_offset (struct value *value, LONGEST val);
 209 extern LONGEST value_embedded_offset (const struct value *value);
 210 extern void set_value_embedded_offset (struct value *value, LONGEST val);
 211
 212 /* For lval_computed values, this structure holds functions used to
 213    retrieve and set the value (or portions of the value).
 214
 215    For each function, 'V' is the 'this' pointer: an lval_funcs
 216    function F may always assume that the V it receives is an
 217    lval_computed value, and has F in the appropriate slot of its
 218    lval_funcs structure.  */
 219
 220 struct lval_funcs
 221 {
 222   /* Fill in VALUE's contents.  This is used to "un-lazy" values.  If
 223      a problem arises in obtaining VALUE's bits, this function should
 224      call 'error'.  If it is NULL value_fetch_lazy on "un-lazy"
 225      non-optimized-out value is an internal error.  */
 226   void (*read) (struct value *v);
 227
 228   /* Handle an assignment TOVAL = FROMVAL by writing the value of
 229      FROMVAL to TOVAL's location.  The contents of TOVAL have not yet
 230      been updated.  If a problem arises in doing so, this function
 231      should call 'error'.  If it is NULL such TOVAL assignment is an error as
 232      TOVAL is not considered as an lvalue.  */
 233   void (*write) (struct value *toval, struct value *fromval);
 234
 235   /* If non-NULL, this is used to implement pointer indirection for
 236      this value.  This method may return NULL, in which case value_ind
 237      will fall back to ordinary indirection.  */
 238   struct value *(*indirect) (struct value *value);
 239
 240   /* If non-NULL, this is used to implement reference resolving for
 241      this value.  This method may return NULL, in which case coerce_ref
 242      will fall back to ordinary references resolving.  */
 243   struct value *(*coerce_ref) (const struct value *value);
 244
 245   /* If non-NULL, this is used to determine whether the indicated bits
 246      of VALUE are a synthetic pointer.  */
 247   int (*check_synthetic_pointer) (const struct value *value,
 248                                   LONGEST offset, int length);
 249
 250   /* Return a duplicate of VALUE's closure, for use in a new value.
 251      This may simply return the same closure, if VALUE's is
 252      reference-counted or statically allocated.
 253
 254      This may be NULL, in which case VALUE's closure is re-used in the
 255      new value.  */
 256   void *(*copy_closure) (const struct value *v);
 257
 258   /* Drop VALUE's reference to its closure.  Maybe this frees the
 259      closure; maybe this decrements a reference count; maybe the
 260      closure is statically allocated and this does nothing.
 261
 262      This may be NULL, in which case no action is taken to free
 263      VALUE's closure.  */
 264   void (*free_closure) (struct value *v);
 265 };
 266
 267 /* Create a computed lvalue, with type TYPE, function pointers FUNCS,
 268    and closure CLOSURE.  */
 269
 270 extern struct value *allocate_computed_value (struct type *type,
 271                                               const struct lval_funcs *funcs,
 272                                               void *closure);
 273
 274 /* Helper function to check the validity of some bits of a value.
 275
 276    If TYPE represents some aggregate type (e.g., a structure), return 1.
 277
 278    Otherwise, any of the bytes starting at OFFSET and extending for
 279    TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
 280    return 0.  The checking is done using FUNCS.
 281
 282    Otherwise, return 1.  */
 283
 284 extern int valprint_check_validity (struct ui_file *stream, struct type *type,
 285                                     LONGEST embedded_offset,
 286                                     const struct value *val);
 287
 288 extern struct value *allocate_optimized_out_value (struct type *type);
 289
 290 /* If VALUE is lval_computed, return its lval_funcs structure.  */
 291
 292 extern const struct lval_funcs *value_computed_funcs (const struct value *);
 293
 294 /* If VALUE is lval_computed, return its closure.  The meaning of the
 295    returned value depends on the functions VALUE uses.  */
 296
 297 extern void *value_computed_closure (const struct value *value);
 298
 299 /* If zero, contents of this value are in the contents field.  If
 300    nonzero, contents are in inferior.  If the lval field is lval_memory,
 301    the contents are in inferior memory at location.address plus offset.
 302    The lval field may also be lval_register.
 303
 304    WARNING: This field is used by the code which handles watchpoints
 305    (see breakpoint.c) to decide whether a particular value can be
 306    watched by hardware watchpoints.  If the lazy flag is set for some
 307    member of a value chain, it is assumed that this member of the
 308    chain doesn't need to be watched as part of watching the value
 309    itself.  This is how GDB avoids watching the entire struct or array
 310    when the user wants to watch a single struct member or array
 311    element.  If you ever change the way lazy flag is set and reset, be
 312    sure to consider this use as well!  */
 313
 314 extern int value_lazy (const struct value *);
 315 extern void set_value_lazy (struct value *value, int val);
 316
 317 extern int value_stack (const struct value *);
 318 extern void set_value_stack (struct value *value, int val);
 319
 320 /* Throw an error complaining that the value has been optimized
 321    out.  */
 322
 323 extern void error_value_optimized_out (void);
 324
 325 /* value_contents() and value_contents_raw() both return the address
 326    of the gdb buffer used to hold a copy of the contents of the lval.
 327    value_contents() is used when the contents of the buffer are needed
 328    -- it uses value_fetch_lazy() to load the buffer from the process
 329    being debugged if it hasn't already been loaded
 330    (value_contents_writeable() is used when a writeable but fetched
 331    buffer is required)..  value_contents_raw() is used when data is
 332    being stored into the buffer, or when it is certain that the
 333    contents of the buffer are valid.
 334
 335    Note: The contents pointer is adjusted by the offset required to
 336    get to the real subobject, if the value happens to represent
 337    something embedded in a larger run-time object.  */
 338
 339 extern gdb_byte *value_contents_raw (struct value *);
 340
 341 /* Actual contents of the value.  For use of this value; setting it
 342    uses the stuff above.  Not valid if lazy is nonzero.  Target
 343    byte-order.  We force it to be aligned properly for any possible
 344    value.  Note that a value therefore extends beyond what is
 345    declared here.  */
 346
 347 extern const gdb_byte *value_contents (struct value *);
 348 extern gdb_byte *value_contents_writeable (struct value *);
 349
 350 /* The ALL variants of the above two macros do not adjust the returned
 351    pointer by the embedded_offset value.  */
 352
 353 extern gdb_byte *value_contents_all_raw (struct value *);
 354 extern const gdb_byte *value_contents_all (struct value *);
 355
 356 /* Like value_contents_all, but does not require that the returned
 357    bits be valid.  This should only be used in situations where you
 358    plan to check the validity manually.  */
 359 extern const gdb_byte *value_contents_for_printing (struct value *value);
 360
 361 /* Like value_contents_for_printing, but accepts a constant value
 362    pointer.  Unlike value_contents_for_printing however, the pointed
 363    value must _not_ be lazy.  */
 364 extern const gdb_byte *
 365   value_contents_for_printing_const (const struct value *value);
 366
 367 extern void value_fetch_lazy (struct value *val);
 368
 369 /* If nonzero, this is the value of a variable which does not actually
 370    exist in the program, at least partially.  If the value is lazy,
 371    this may fetch it now.  */
 372 extern int value_optimized_out (struct value *value);
 373
 374 /* Given a value, return true if any of the contents bits starting at
 375    OFFSET and extending for LENGTH bits is optimized out, false
 376    otherwise.  */
 377
 378 extern int value_bits_any_optimized_out (const struct value *value,
 379                                          int bit_offset, int bit_length);
 380
 381 /* Like value_optimized_out, but return true iff the whole value is
 382    optimized out.  */
 383 extern int value_entirely_optimized_out (struct value *value);
 384
 385 /* Mark VALUE's content bytes starting at OFFSET and extending for
 386    LENGTH bytes as optimized out.  */
 387
 388 extern void mark_value_bytes_optimized_out (struct value *value,
 389                                             int offset, int length);
 390
 391 /* Mark VALUE's content bits starting at OFFSET and extending for
 392    LENGTH bits as optimized out.  */
 393
 394 extern void mark_value_bits_optimized_out (struct value *value,
 395                                            LONGEST offset, LONGEST length);
 396
 397 /* Set or return field indicating whether a variable is initialized or
 398    not, based on debugging information supplied by the compiler.
 399    1 = initialized; 0 = uninitialized.  */
 400 extern int value_initialized (const struct value *);
 401 extern void set_value_initialized (struct value *, int);
 402
 403 /* Set COMPONENT's location as appropriate for a component of WHOLE
 404    --- regardless of what kind of lvalue WHOLE is.  */
 405 extern void set_value_component_location (struct value *component,
 406                                           const struct value *whole);
 407
 408 /* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a
 409    single value might have multiple LVALs), this hacked interface is
 410    limited to just the first PIECE.  Expect further change.  */
 411 /* Type of value; either not an lval, or one of the various different
 412    possible kinds of lval.  */
 413 extern enum lval_type *deprecated_value_lval_hack (struct value *);
 414 #define VALUE_LVAL(val) (*deprecated_value_lval_hack (val))
 415
 416 /* Like VALUE_LVAL, except the parameter can be const.  */
 417 extern enum lval_type value_lval_const (const struct value *value);
 418
 419 /* If lval == lval_memory, return the address in the inferior.  If
 420    lval == lval_register, return the byte offset into the registers
 421    structure.  Otherwise, return 0.  The returned address
 422    includes the offset, if any.  */
 423 extern CORE_ADDR value_address (const struct value *);
 424
 425 /* Like value_address, except the result does not include value's
 426    offset.  */
 427 extern CORE_ADDR value_raw_address (const struct value *);
 428
 429 /* Set the address of a value.  */
 430 extern void set_value_address (struct value *, CORE_ADDR);
 431
 432 /* Pointer to internal variable.  */
 433 extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
 434 #define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))
 435
 436 /* Frame ID of "next" frame to which a register value is relative.  A
 437    register value is indicated by VALUE_LVAL being set to lval_register.
 438    So, if the register value is found relative to frame F, then the
 439    frame id of F->next will be stored in VALUE_NEXT_FRAME_ID.  */
 440 extern struct frame_id *deprecated_value_next_frame_id_hack (struct value *);
 441 #define VALUE_NEXT_FRAME_ID(val) (*deprecated_value_next_frame_id_hack (val))
 442
 443 /* Frame ID of frame to which a register value is relative.  This is
 444    similar to VALUE_NEXT_FRAME_ID, above, but may not be assigned to.
 445    Note that VALUE_FRAME_ID effectively undoes the "next" operation
 446    that was performed during the assignment to VALUE_NEXT_FRAME_ID.  */
 447 #define VALUE_FRAME_ID(val) (get_prev_frame_id_by_id (VALUE_NEXT_FRAME_ID (val)))
 448
 449 /* Register number if the value is from a register.  */
 450 extern int *deprecated_value_regnum_hack (struct value *);
 451 #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val))
 452
 453 /* Return value after lval_funcs->coerce_ref (after check_typedef).  Return
 454    NULL if lval_funcs->coerce_ref is not applicable for whatever reason.  */
 455
 456 extern struct value *coerce_ref_if_computed (const struct value *arg);
 457
 458 /* Setup a new value type and enclosing value type for dereferenced value VALUE.
 459    ENC_TYPE is the new enclosing type that should be set.  ORIGINAL_TYPE and
 460    ORIGINAL_VAL are the type and value of the original reference or pointer.
 461
 462    Note, that VALUE is modified by this function.
 463
 464    It is a common implementation for coerce_ref and value_ind.  */
 465
 466 extern struct value * readjust_indirect_value_type (struct value *value,
 467                                                     struct type *enc_type,
 468                                                     const struct type *original_type,
 469                                                     const struct value *original_val);
 470
 471 /* Convert a REF to the object referenced.  */
 472
 473 extern struct value *coerce_ref (struct value *value);
 474
 475 /* If ARG is an array, convert it to a pointer.
 476    If ARG is a function, convert it to a function pointer.
 477
 478    References are dereferenced.  */
 479
 480 extern struct value *coerce_array (struct value *value);
 481
 482 /* Given a value, determine whether the bits starting at OFFSET and
 483    extending for LENGTH bits are a synthetic pointer.  */
 484
 485 extern int value_bits_synthetic_pointer (const struct value *value,
 486                                          LONGEST offset, LONGEST length);
 487
 488 /* Given a value, determine whether the contents bytes starting at
 489    OFFSET and extending for LENGTH bytes are available.  This returns
 490    nonzero if all bytes in the given range are available, zero if any
 491    byte is unavailable.  */
 492
 493 extern int value_bytes_available (const struct value *value,
 494                                   LONGEST offset, LONGEST length);
 495
 496 /* Given a value, determine whether the contents bits starting at
 497    OFFSET and extending for LENGTH bits are available.  This returns
 498    nonzero if all bits in the given range are available, zero if any
 499    bit is unavailable.  */
 500
 501 extern int value_bits_available (const struct value *value,
 502                                  LONGEST offset, LONGEST length);
 503
 504 /* Like value_bytes_available, but return false if any byte in the
 505    whole object is unavailable.  */
 506 extern int value_entirely_available (struct value *value);
 507
 508 /* Like value_entirely_available, but return false if any byte in the
 509    whole object is available.  */
 510 extern int value_entirely_unavailable (struct value *value);
 511
 512 /* Mark VALUE's content bytes starting at OFFSET and extending for
 513    LENGTH bytes as unavailable.  */
 514
 515 extern void mark_value_bytes_unavailable (struct value *value,
 516                                           LONGEST offset, LONGEST length);
 517
 518 /* Mark VALUE's content bits starting at OFFSET and extending for
 519    LENGTH bits as unavailable.  */
 520
 521 extern void mark_value_bits_unavailable (struct value *value,
 522                                          LONGEST offset, LONGEST length);
 523
 524 /* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with
 525    LENGTH bytes of VAL2's contents starting at OFFSET2.
 526
 527    Note that "contents" refers to the whole value's contents
 528    (value_contents_all), without any embedded offset adjustment.  For
 529    example, to compare a complete object value with itself, including
 530    its enclosing type chunk, you'd do:
 531
 532      int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
 533      value_contents_eq (val, 0, val, 0, len);
 534
 535    Returns true iff the set of available/valid contents match.
 536
 537    Optimized-out contents are equal to optimized-out contents, and are
 538    not equal to non-optimized-out contents.
 539
 540    Unavailable contente are equal to unavailable contents, and are not
 541    equal to non-unavailable contents.
 542
 543    For example, if 'x's represent an unavailable byte, and 'V' and 'Z'
 544    represent different available/valid bytes, in a value with length
 545    16:
 546
 547      offset:   0   4   8   12  16
 548      contents: xxxxVVVVxxxxVVZZ
 549
 550    then:
 551
 552      value_contents_eq(val, 0, val, 8, 6) => true
 553      value_contents_eq(val, 0, val, 4, 4) => false
 554      value_contents_eq(val, 0, val, 8, 8) => false
 555      value_contents_eq(val, 4, val, 12, 2) => true
 556      value_contents_eq(val, 4, val, 12, 4) => true
 557      value_contents_eq(val, 3, val, 4, 4) => true
 558
 559    If 'x's represent an unavailable byte, 'o' represents an optimized
 560    out byte, in a value with length 8:
 561
 562      offset:   0   4   8
 563      contents: xxxxoooo
 564
 565    then:
 566
 567      value_contents_eq(val, 0, val, 2, 2) => true
 568      value_contents_eq(val, 4, val, 6, 2) => true
 569      value_contents_eq(val, 0, val, 4, 4) => true
 570
 571    We only know whether a value chunk is unavailable or optimized out
 572    if we've tried to read it.  As this routine is used by printing
 573    routines, which may be printing values in the value history, long
 574    after the inferior is gone, it works with const values.  Therefore,
 575    this routine must not be called with lazy values.  */
 576
 577 extern bool value_contents_eq (const struct value *val1, LONGEST offset1,
 578                                const struct value *val2, LONGEST offset2,
 579                                LONGEST length);
 580
 581 /* Read LENGTH addressable memory units starting at MEMADDR into BUFFER,
 582    which is (or will be copied to) VAL's contents buffer offset by
 583    BIT_OFFSET bits.  Marks value contents ranges as unavailable if
 584    the corresponding memory is likewise unavailable.  STACK indicates
 585    whether the memory is known to be stack memory.  */
 586
 587 extern void read_value_memory (struct value *val, LONGEST bit_offset,
 588                                int stack, CORE_ADDR memaddr,
 589                                gdb_byte *buffer, size_t length);
 590
 591 /* Cast SCALAR_VALUE to the element type of VECTOR_TYPE, then replicate
 592    into each element of a new vector value with VECTOR_TYPE.  */
 593
 594 struct value *value_vector_widen (struct value *scalar_value,
 595                                   struct type *vector_type);
 596
 597 \f
 598
 599 #include "symtab.h"
 600 #include "gdbtypes.h"
 601 #include "expression.h"
 602
 603 struct frame_info;
 604 struct fn_field;
 605
 606 extern int print_address_demangle (const struct value_print_options *,
 607                                    struct gdbarch *, CORE_ADDR,
 608                                    struct ui_file *, int);
 609
 610 /* Returns true if VAL is of floating-point type.  In addition,
 611    throws an error if the value is an invalid floating-point value.  */
 612 extern bool is_floating_value (struct value *val);
 613
 614 extern LONGEST value_as_long (struct value *val);
 615 extern CORE_ADDR value_as_address (struct value *val);
 616
 617 extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr);
 618 extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr);
 619
 620 extern LONGEST unpack_field_as_long (struct type *type,
 621                                      const gdb_byte *valaddr,
 622                                      int fieldno);
 623 extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr,
 624                                 LONGEST embedded_offset, int fieldno,
 625                                 const struct value *val, LONGEST *result);
 626
 627 extern void unpack_value_bitfield (struct value *dest_val,
 628                                    LONGEST bitpos, LONGEST bitsize,
 629                                    const gdb_byte *valaddr,
 630                                    LONGEST embedded_offset,
 631                                    const struct value *val);
 632
 633 extern struct value *value_field_bitfield (struct type *type, int fieldno,
 634                                            const gdb_byte *valaddr,
 635                                            LONGEST embedded_offset,
 636                                            const struct value *val);
 637
 638 extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num);
 639
 640 extern struct value *value_from_longest (struct type *type, LONGEST num);
 641 extern struct value *value_from_ulongest (struct type *type, ULONGEST num);
 642 extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr);
 643 extern struct value *value_from_history_ref (const char *, const char **);
 644 extern struct value *value_from_component (struct value *, struct type *,
 645                                            LONGEST);
 646
 647 extern struct value *value_at (struct type *type, CORE_ADDR addr);
 648 extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
 649
 650 extern struct value *value_from_contents_and_address_unresolved
 651      (struct type *, const gdb_byte *, CORE_ADDR);
 652 extern struct value *value_from_contents_and_address (struct type *,
 653                                                       const gdb_byte *,
 654                                                       CORE_ADDR);
 655 extern struct value *value_from_contents (struct type *, const gdb_byte *);
 656
 657 extern struct value *default_value_from_register (struct gdbarch *gdbarch,
 658                                                   struct type *type,
 659                                                   int regnum,
 660                                                   struct frame_id frame_id);
 661
 662 extern void read_frame_register_value (struct value *value,
 663                                        struct frame_info *frame);
 664
 665 extern struct value *value_from_register (struct type *type, int regnum,
 666                                           struct frame_info *frame);
 667
 668 extern CORE_ADDR address_from_register (int regnum,
 669                                         struct frame_info *frame);
 670
 671 extern struct value *value_of_variable (struct symbol *var,
 672                                         const struct block *b);
 673
 674 extern struct value *address_of_variable (struct symbol *var,
 675                                           const struct block *b);
 676
 677 extern struct value *value_of_register (int regnum, struct frame_info *frame);
 678
 679 struct value *value_of_register_lazy (struct frame_info *frame, int regnum);
 680
 681 /* Return the symbol's reading requirement.  */
 682
 683 extern enum symbol_needs_kind symbol_read_needs (struct symbol *);
 684
 685 /* Return true if the symbol needs a frame.  This is a wrapper for
 686    symbol_read_needs that simply checks for SYMBOL_NEEDS_FRAME.  */
 687
 688 extern int symbol_read_needs_frame (struct symbol *);
 689
 690 extern struct value *read_var_value (struct symbol *var,
 691                                      const struct block *var_block,
 692                                      struct frame_info *frame);
 693
 694 extern struct value *default_read_var_value (struct symbol *var,
 695                                              const struct block *var_block,
 696                                              struct frame_info *frame);
 697
 698 extern struct value *allocate_value (struct type *type);
 699 extern struct value *allocate_value_lazy (struct type *type);
 700 extern void value_contents_copy (struct value *dst, LONGEST dst_offset,
 701                                  struct value *src, LONGEST src_offset,
 702                                  LONGEST length);
 703 extern void value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
 704                                      struct value *src, LONGEST src_offset,
 705                                      LONGEST length);
 706
 707 extern struct value *allocate_repeat_value (struct type *type, int count);
 708
 709 extern struct value *value_mark (void);
 710
 711 extern void value_free_to_mark (const struct value *mark);
 712
 713 /* A helper class that uses value_mark at construction time and calls
 714    value_free_to_mark in the destructor.  This is used to clear out
 715    temporary values created during the lifetime of this object.  */
 716 class scoped_value_mark
 717 {
 718  public:
 719
 720   scoped_value_mark ()
 721     : m_value (value_mark ())
 722   {
 723   }
 724
 725   ~scoped_value_mark ()
 726   {
 727     free_to_mark ();
 728   }
 729
 730   scoped_value_mark (scoped_value_mark &&other) = default;
 731
 732   DISABLE_COPY_AND_ASSIGN (scoped_value_mark);
 733
 734   /* Free the values currently on the value stack.  */
 735   void free_to_mark ()
 736   {
 737     if (m_value != NULL)
 738       {
 739         value_free_to_mark (m_value);
 740         m_value = NULL;
 741       }
 742   }
 743
 744  private:
 745
 746   const struct value *m_value;
 747 };
 748
 749 extern struct value *value_cstring (const char *ptr, ssize_t len,
 750                                     struct type *char_type);
 751 extern struct value *value_string (const char *ptr, ssize_t len,
 752                                    struct type *char_type);
 753
 754 extern struct value *value_array (int lowbound, int highbound,
 755                                   struct value **elemvec);
 756
 757 extern struct value *value_concat (struct value *arg1, struct value *arg2);
 758
 759 extern struct value *value_binop (struct value *arg1, struct value *arg2,
 760                                   enum exp_opcode op);
 761
 762 extern struct value *value_ptradd (struct value *arg1, LONGEST arg2);
 763
 764 extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2);
 765
 766 extern int value_must_coerce_to_target (struct value *arg1);
 767
 768 extern struct value *value_coerce_to_target (struct value *arg1);
 769
 770 extern struct value *value_coerce_array (struct value *arg1);
 771
 772 extern struct value *value_coerce_function (struct value *arg1);
 773
 774 extern struct value *value_ind (struct value *arg1);
 775
 776 extern struct value *value_addr (struct value *arg1);
 777
 778 extern struct value *value_ref (struct value *arg1, enum type_code refcode);
 779
 780 extern struct value *value_assign (struct value *toval,
 781                                    struct value *fromval);
 782
 783 extern struct value *value_pos (struct value *arg1);
 784
 785 extern struct value *value_neg (struct value *arg1);
 786
 787 extern struct value *value_complement (struct value *arg1);
 788
 789 extern struct value *value_struct_elt (struct value **argp,
 790                                        struct value **args,
 791                                        const char *name, int *static_memfuncp,
 792                                        const char *err);
 793
 794 extern struct value *value_struct_elt_bitpos (struct value **argp,
 795                                               int bitpos,
 796                                               struct type *field_type,
 797                                               const char *err);
 798
 799 extern struct value *value_aggregate_elt (struct type *curtype,
 800                                           const char *name,
 801                                           struct type *expect_type,
 802                                           int want_address,
 803                                           enum noside noside);
 804
 805 extern struct value *value_static_field (struct type *type, int fieldno);
 806
 807 enum oload_search_type { NON_METHOD, METHOD, BOTH };
 808
 809 extern int find_overload_match (struct value **args, int nargs,
 810                                 const char *name,
 811                                 enum oload_search_type method,
 812                                 struct value **objp, struct symbol *fsym,
 813                                 struct value **valp, struct symbol **symp,
 814                                 int *staticp, const int no_adl,
 815                                 enum noside noside);
 816
 817 extern struct value *value_field (struct value *arg1, int fieldno);
 818
 819 extern struct value *value_primitive_field (struct value *arg1, LONGEST offset,
 820                                             int fieldno,
 821                                             struct type *arg_type);
 822
 823
 824 extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
 825                                               int *);
 826
 827 extern struct value *value_full_object (struct value *, struct type *, int,
 828                                         int, int);
 829
 830 extern struct value *value_cast_pointers (struct type *, struct value *, int);
 831
 832 extern struct value *value_cast (struct type *type, struct value *arg2);
 833
 834 extern struct value *value_reinterpret_cast (struct type *type,
 835                                              struct value *arg);
 836
 837 extern struct value *value_dynamic_cast (struct type *type, struct value *arg);
 838
 839 extern struct value *value_zero (struct type *type, enum lval_type lv);
 840
 841 extern struct value *value_one (struct type *type);
 842
 843 extern struct value *value_repeat (struct value *arg1, int count);
 844
 845 extern struct value *value_subscript (struct value *array, LONGEST index);
 846
 847 extern struct value *value_bitstring_subscript (struct type *type,
 848                                                 struct value *bitstring,
 849                                                 LONGEST index);
 850
 851 extern struct value *register_value_being_returned (struct type *valtype,
 852                                                     struct regcache *retbuf);
 853
 854 extern int value_in (struct value *element, struct value *set);
 855
 856 extern int value_bit_index (struct type *type, const gdb_byte *addr,
 857                             int index);
 858
 859 extern enum return_value_convention
 860 struct_return_convention (struct gdbarch *gdbarch, struct value *function,
 861                           struct type *value_type);
 862
 863 extern int using_struct_return (struct gdbarch *gdbarch,
 864                                 struct value *function,
 865                                 struct type *value_type);
 866
 867 extern struct value *evaluate_expression (struct expression *exp);
 868
 869 extern struct value *evaluate_type (struct expression *exp);
 870
 871 extern struct value *evaluate_subexp (struct type *expect_type,
 872                                       struct expression *exp,
 873                                       int *pos, enum noside noside);
 874
 875 extern struct value *evaluate_subexpression_type (struct expression *exp,
 876                                                   int subexp);
 877
 878 extern value *evaluate_var_value (enum noside noside, const block *blk,
 879                                   symbol *var);
 880
 881 extern value *evaluate_var_msym_value (enum noside noside,
 882                                        struct objfile *objfile,
 883                                        minimal_symbol *msymbol);
 884
 885 extern value *eval_skip_value (expression *exp);
 886
 887 extern void fetch_subexp_value (struct expression *exp, int *pc,
 888                                 struct value **valp, struct value **resultp,
 889                                 struct value **val_chain,
 890                                 int preserve_errors);
 891
 892 extern char *extract_field_op (struct expression *exp, int *subexp);
 893
 894 extern struct value *evaluate_subexp_with_coercion (struct expression *,
 895                                                     int *, enum noside);
 896
 897 extern struct value *parse_and_eval (const char *exp);
 898
 899 extern struct value *parse_to_comma_and_eval (const char **expp);
 900
 901 extern struct type *parse_and_eval_type (char *p, int length);
 902
 903 extern CORE_ADDR parse_and_eval_address (const char *exp);
 904
 905 extern LONGEST parse_and_eval_long (const char *exp);
 906
 907 extern void unop_promote (const struct language_defn *language,
 908                           struct gdbarch *gdbarch,
 909                           struct value **arg1);
 910
 911 extern void binop_promote (const struct language_defn *language,
 912                            struct gdbarch *gdbarch,
 913                            struct value **arg1, struct value **arg2);
 914
 915 extern struct value *access_value_history (int num);
 916
 917 extern struct value *value_of_internalvar (struct gdbarch *gdbarch,
 918                                            struct internalvar *var);
 919
 920 extern int get_internalvar_integer (struct internalvar *var, LONGEST *l);
 921
 922 extern void set_internalvar (struct internalvar *var, struct value *val);
 923
 924 extern void set_internalvar_integer (struct internalvar *var, LONGEST l);
 925
 926 extern void set_internalvar_string (struct internalvar *var,
 927                                     const char *string);
 928
 929 extern void clear_internalvar (struct internalvar *var);
 930
 931 extern void set_internalvar_component (struct internalvar *var,
 932                                        LONGEST offset,
 933                                        LONGEST bitpos, LONGEST bitsize,
 934                                        struct value *newvalue);
 935
 936 extern struct internalvar *lookup_only_internalvar (const char *name);
 937
 938 extern struct internalvar *create_internalvar (const char *name);
 939
 940 extern void complete_internalvar (completion_tracker &tracker,
 941                                   const char *name);
 942
 943 /* An internalvar can be dynamically computed by supplying a vector of
 944    function pointers to perform various operations.  */
 945
 946 struct internalvar_funcs
 947 {
 948   /* Compute the value of the variable.  The DATA argument passed to
 949      the function is the same argument that was passed to
 950      `create_internalvar_type_lazy'.  */
 951
 952   struct value *(*make_value) (struct gdbarch *arch,
 953                                struct internalvar *var,
 954                                void *data);
 955
 956   /* Update the agent expression EXPR with bytecode to compute the
 957      value.  VALUE is the agent value we are updating.  The DATA
 958      argument passed to this function is the same argument that was
 959      passed to `create_internalvar_type_lazy'.  If this pointer is
 960      NULL, then the internalvar cannot be compiled to an agent
 961      expression.  */
 962
 963   void (*compile_to_ax) (struct internalvar *var,
 964                          struct agent_expr *expr,
 965                          struct axs_value *value,
 966                          void *data);
 967
 968   /* If non-NULL, this is called to destroy DATA.  The DATA argument
 969      passed to this function is the same argument that was passed to
 970      `create_internalvar_type_lazy'.  */
 971
 972   void (*destroy) (void *data);
 973 };
 974
 975 extern struct internalvar *create_internalvar_type_lazy (const char *name,
 976                                 const struct internalvar_funcs *funcs,
 977                                 void *data);
 978
 979 /* Compile an internal variable to an agent expression.  VAR is the
 980    variable to compile; EXPR and VALUE are the agent expression we are
 981    updating.  This will return 0 if there is no known way to compile
 982    VAR, and 1 if VAR was successfully compiled.  It may also throw an
 983    exception on error.  */
 984
 985 extern int compile_internalvar_to_ax (struct internalvar *var,
 986                                       struct agent_expr *expr,
 987                                       struct axs_value *value);
 988
 989 extern struct internalvar *lookup_internalvar (const char *name);
 990
 991 extern int value_equal (struct value *arg1, struct value *arg2);
 992
 993 extern int value_equal_contents (struct value *arg1, struct value *arg2);
 994
 995 extern int value_less (struct value *arg1, struct value *arg2);
 996
 997 extern int value_logical_not (struct value *arg1);
 998
 999 /* C++ */
1000
1001 extern struct value *value_of_this (const struct language_defn *lang);
1002
1003 extern struct value *value_of_this_silent (const struct language_defn *lang);
1004
1005 extern struct value *value_x_binop (struct value *arg1, struct value *arg2,
1006                                     enum exp_opcode op,
1007                                     enum exp_opcode otherop,
1008                                     enum noside noside);
1009
1010 extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op,
1011                                    enum noside noside);
1012
1013 extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f,
1014                                      int j, struct type *type, LONGEST offset);
1015
1016 extern int binop_types_user_defined_p (enum exp_opcode op,
1017                                        struct type *type1,
1018                                        struct type *type2);
1019
1020 extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1,
1021                                  struct value *arg2);
1022
1023 extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1);
1024
1025 extern int destructor_name_p (const char *name, struct type *type);
1026
1027 extern void value_incref (struct value *val);
1028
1029 extern void value_free (struct value *val);
1030
1031 /* A free policy class to interface std::unique_ptr with
1032    value_free.  */
1033
1034 struct value_deleter
1035 {
1036   void operator() (struct value *value) const
1037   {
1038     value_free (value);
1039   }
1040 };
1041
1042 /* A unique pointer to a struct value.  */
1043
1044 typedef std::unique_ptr<struct value, value_deleter> gdb_value_up;
1045
1046 extern void free_all_values (void);
1047
1048 extern void free_value_chain (struct value *v);
1049
1050 extern void release_value (struct value *val);
1051
1052 extern void release_value_or_incref (struct value *val);
1053
1054 extern int record_latest_value (struct value *val);
1055
1056 extern void modify_field (struct type *type, gdb_byte *addr,
1057                           LONGEST fieldval, LONGEST bitpos, LONGEST bitsize);
1058
1059 extern void type_print (struct type *type, const char *varstring,
1060                         struct ui_file *stream, int show);
1061
1062 extern std::string type_to_string (struct type *type);
1063
1064 extern gdb_byte *baseclass_addr (struct type *type, int index,
1065                                  gdb_byte *valaddr,
1066                                  struct value **valuep, int *errp);
1067
1068 extern void print_longest (struct ui_file *stream, int format,
1069                            int use_local, LONGEST val);
1070
1071 extern void print_floating (const gdb_byte *valaddr, struct type *type,
1072                             struct ui_file *stream);
1073
1074 extern void value_print (struct value *val, struct ui_file *stream,
1075                          const struct value_print_options *options);
1076
1077 extern void value_print_array_elements (struct value *val,
1078                                         struct ui_file *stream, int format,
1079                                         enum val_prettyformat pretty);
1080
1081 extern struct value *value_release_to_mark (const struct value *mark);
1082
1083 extern void val_print (struct type *type,
1084                        LONGEST embedded_offset, CORE_ADDR address,
1085                        struct ui_file *stream, int recurse,
1086                        struct value *val,
1087                        const struct value_print_options *options,
1088                        const struct language_defn *language);
1089
1090 extern void common_val_print (struct value *val,
1091                               struct ui_file *stream, int recurse,
1092                               const struct value_print_options *options,
1093                               const struct language_defn *language);
1094
1095 extern int val_print_string (struct type *elttype, const char *encoding,
1096                              CORE_ADDR addr, int len,
1097                              struct ui_file *stream,
1098                              const struct value_print_options *options);
1099
1100 extern void print_variable_and_value (const char *name,
1101                                       struct symbol *var,
1102                                       struct frame_info *frame,
1103                                       struct ui_file *stream,
1104                                       int indent);
1105
1106 extern void typedef_print (struct type *type, struct symbol *news,
1107                            struct ui_file *stream);
1108
1109 extern char *internalvar_name (const struct internalvar *var);
1110
1111 extern void preserve_values (struct objfile *);
1112
1113 /* From values.c */
1114
1115 extern struct value *value_copy (struct value *);
1116
1117 extern struct value *value_non_lval (struct value *);
1118
1119 extern void value_force_lval (struct value *, CORE_ADDR);
1120
1121 extern struct value *make_cv_value (int, int, struct value *);
1122
1123 extern void preserve_one_value (struct value *, struct objfile *, htab_t);
1124
1125 /* From valops.c */
1126
1127 extern struct value *varying_to_slice (struct value *);
1128
1129 extern struct value *value_slice (struct value *, int, int);
1130
1131 extern struct value *value_literal_complex (struct value *, struct value *,
1132                                             struct type *);
1133
1134 extern struct value *find_function_in_inferior (const char *,
1135                                                 struct objfile **);
1136
1137 extern struct value *value_allocate_space_in_inferior (int);
1138
1139 extern struct value *value_subscripted_rvalue (struct value *array,
1140                                                LONGEST index, int lowerbound);
1141
1142 /* User function handler.  */
1143
1144 typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch,
1145                                                const struct language_defn *language,
1146                                                void *cookie,
1147                                                int argc,
1148                                                struct value **argv);
1149
1150 void add_internal_function (const char *name, const char *doc,
1151                             internal_function_fn handler,
1152                             void *cookie);
1153
1154 struct value *call_internal_function (struct gdbarch *gdbarch,
1155                                       const struct language_defn *language,
1156                                       struct value *function,
1157                                       int argc, struct value **argv);
1158
1159 char *value_internal_function_name (struct value *);
1160
1161 /* Build a value wrapping and representing WORKER.  The value takes ownership
1162    of the xmethod_worker object.  */
1163
1164 extern struct value *value_from_xmethod (xmethod_worker_up &&worker);
1165
1166 extern struct type *result_type_of_xmethod (struct value *method,
1167                                             int argc, struct value **argv);
1168
1169 extern struct value *call_xmethod (struct value *method,
1170                                    int argc, struct value **argv);
1171
1172 #endif /* !defined (VALUE_H) */