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