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