value.h revision 1.1.1.6
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 629 #include "symtab.h" 630 #include "gdbtypes.h" 631 #include "expression.h" 632 633 struct frame_info; 634 struct fn_field; 635 636 extern int print_address_demangle (const struct value_print_options *, 637 struct gdbarch *, CORE_ADDR, 638 struct ui_file *, int); 639 640 /* Returns true if VAL is of floating-point type. In addition, 641 throws an error if the value is an invalid floating-point value. */ 642 extern bool is_floating_value (struct value *val); 643 644 extern LONGEST value_as_long (struct value *val); 645 extern CORE_ADDR value_as_address (struct value *val); 646 647 extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr); 648 extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr); 649 650 extern LONGEST unpack_field_as_long (struct type *type, 651 const gdb_byte *valaddr, 652 int fieldno); 653 extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr, 654 LONGEST embedded_offset, int fieldno, 655 const struct value *val, LONGEST *result); 656 657 extern void unpack_value_bitfield (struct value *dest_val, 658 LONGEST bitpos, LONGEST bitsize, 659 const gdb_byte *valaddr, 660 LONGEST embedded_offset, 661 const struct value *val); 662 663 extern struct value *value_field_bitfield (struct type *type, int fieldno, 664 const gdb_byte *valaddr, 665 LONGEST embedded_offset, 666 const struct value *val); 667 668 extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num); 669 670 extern struct value *value_from_longest (struct type *type, LONGEST num); 671 extern struct value *value_from_ulongest (struct type *type, ULONGEST num); 672 extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr); 673 extern struct value *value_from_history_ref (const char *, const char **); 674 extern struct value *value_from_component (struct value *, struct type *, 675 LONGEST); 676 677 extern struct value *value_at (struct type *type, CORE_ADDR addr); 678 extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr); 679 680 extern struct value *value_from_contents_and_address_unresolved 681 (struct type *, const gdb_byte *, CORE_ADDR); 682 extern struct value *value_from_contents_and_address (struct type *, 683 const gdb_byte *, 684 CORE_ADDR); 685 extern struct value *value_from_contents (struct type *, const gdb_byte *); 686 687 extern struct value *default_value_from_register (struct gdbarch *gdbarch, 688 struct type *type, 689 int regnum, 690 struct frame_id frame_id); 691 692 extern void read_frame_register_value (struct value *value, 693 struct frame_info *frame); 694 695 extern struct value *value_from_register (struct type *type, int regnum, 696 struct frame_info *frame); 697 698 extern CORE_ADDR address_from_register (int regnum, 699 struct frame_info *frame); 700 701 extern struct value *value_of_variable (struct symbol *var, 702 const struct block *b); 703 704 extern struct value *address_of_variable (struct symbol *var, 705 const struct block *b); 706 707 extern struct value *value_of_register (int regnum, struct frame_info *frame); 708 709 struct value *value_of_register_lazy (struct frame_info *frame, int regnum); 710 711 /* Return the symbol's reading requirement. */ 712 713 extern enum symbol_needs_kind symbol_read_needs (struct symbol *); 714 715 /* Return true if the symbol needs a frame. This is a wrapper for 716 symbol_read_needs that simply checks for SYMBOL_NEEDS_FRAME. */ 717 718 extern int symbol_read_needs_frame (struct symbol *); 719 720 extern struct value *read_var_value (struct symbol *var, 721 const struct block *var_block, 722 struct frame_info *frame); 723 724 extern struct value *default_read_var_value (struct symbol *var, 725 const struct block *var_block, 726 struct frame_info *frame); 727 728 extern struct value *allocate_value (struct type *type); 729 extern struct value *allocate_value_lazy (struct type *type); 730 extern void value_contents_copy (struct value *dst, LONGEST dst_offset, 731 struct value *src, LONGEST src_offset, 732 LONGEST length); 733 extern void value_contents_copy_raw (struct value *dst, LONGEST dst_offset, 734 struct value *src, LONGEST src_offset, 735 LONGEST length); 736 737 extern struct value *allocate_repeat_value (struct type *type, int count); 738 739 extern struct value *value_mark (void); 740 741 extern void value_free_to_mark (const struct value *mark); 742 743 /* A helper class that uses value_mark at construction time and calls 744 value_free_to_mark in the destructor. This is used to clear out 745 temporary values created during the lifetime of this object. */ 746 class scoped_value_mark 747 { 748 public: 749 750 scoped_value_mark () 751 : m_value (value_mark ()) 752 { 753 } 754 755 ~scoped_value_mark () 756 { 757 free_to_mark (); 758 } 759 760 scoped_value_mark (scoped_value_mark &&other) = default; 761 762 DISABLE_COPY_AND_ASSIGN (scoped_value_mark); 763 764 /* Free the values currently on the value stack. */ 765 void free_to_mark () 766 { 767 if (m_value != NULL) 768 { 769 value_free_to_mark (m_value); 770 m_value = NULL; 771 } 772 } 773 774 private: 775 776 const struct value *m_value; 777 }; 778 779 extern struct value *value_cstring (const char *ptr, ssize_t len, 780 struct type *char_type); 781 extern struct value *value_string (const char *ptr, ssize_t len, 782 struct type *char_type); 783 784 extern struct value *value_array (int lowbound, int highbound, 785 struct value **elemvec); 786 787 extern struct value *value_concat (struct value *arg1, struct value *arg2); 788 789 extern struct value *value_binop (struct value *arg1, struct value *arg2, 790 enum exp_opcode op); 791 792 extern struct value *value_ptradd (struct value *arg1, LONGEST arg2); 793 794 extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2); 795 796 extern int value_must_coerce_to_target (struct value *arg1); 797 798 extern struct value *value_coerce_to_target (struct value *arg1); 799 800 extern struct value *value_coerce_array (struct value *arg1); 801 802 extern struct value *value_coerce_function (struct value *arg1); 803 804 extern struct value *value_ind (struct value *arg1); 805 806 extern struct value *value_addr (struct value *arg1); 807 808 extern struct value *value_ref (struct value *arg1, enum type_code refcode); 809 810 extern struct value *value_assign (struct value *toval, 811 struct value *fromval); 812 813 extern struct value *value_pos (struct value *arg1); 814 815 extern struct value *value_neg (struct value *arg1); 816 817 extern struct value *value_complement (struct value *arg1); 818 819 extern struct value *value_struct_elt (struct value **argp, 820 struct value **args, 821 const char *name, int *static_memfuncp, 822 const char *err); 823 824 extern struct value *value_struct_elt_bitpos (struct value **argp, 825 int bitpos, 826 struct type *field_type, 827 const char *err); 828 829 extern struct value *value_aggregate_elt (struct type *curtype, 830 const char *name, 831 struct type *expect_type, 832 int want_address, 833 enum noside noside); 834 835 extern struct value *value_static_field (struct type *type, int fieldno); 836 837 enum oload_search_type { NON_METHOD, METHOD, BOTH }; 838 839 extern int find_overload_match (gdb::array_view<value *> args, 840 const char *name, 841 enum oload_search_type method, 842 struct value **objp, struct symbol *fsym, 843 struct value **valp, struct symbol **symp, 844 int *staticp, const int no_adl, 845 enum noside noside); 846 847 extern struct value *value_field (struct value *arg1, int fieldno); 848 849 extern struct value *value_primitive_field (struct value *arg1, LONGEST offset, 850 int fieldno, 851 struct type *arg_type); 852 853 854 extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *, 855 int *); 856 857 extern struct value *value_full_object (struct value *, struct type *, int, 858 int, int); 859 860 extern struct value *value_cast_pointers (struct type *, struct value *, int); 861 862 extern struct value *value_cast (struct type *type, struct value *arg2); 863 864 extern struct value *value_reinterpret_cast (struct type *type, 865 struct value *arg); 866 867 extern struct value *value_dynamic_cast (struct type *type, struct value *arg); 868 869 extern struct value *value_zero (struct type *type, enum lval_type lv); 870 871 extern struct value *value_one (struct type *type); 872 873 extern struct value *value_repeat (struct value *arg1, int count); 874 875 extern struct value *value_subscript (struct value *array, LONGEST index); 876 877 extern struct value *value_bitstring_subscript (struct type *type, 878 struct value *bitstring, 879 LONGEST index); 880 881 extern struct value *register_value_being_returned (struct type *valtype, 882 struct regcache *retbuf); 883 884 extern int value_in (struct value *element, struct value *set); 885 886 extern int value_bit_index (struct type *type, const gdb_byte *addr, 887 int index); 888 889 extern enum return_value_convention 890 struct_return_convention (struct gdbarch *gdbarch, struct value *function, 891 struct type *value_type); 892 893 extern int using_struct_return (struct gdbarch *gdbarch, 894 struct value *function, 895 struct type *value_type); 896 897 extern struct value *evaluate_expression (struct expression *exp); 898 899 extern struct value *evaluate_type (struct expression *exp); 900 901 extern struct value *evaluate_subexp (struct type *expect_type, 902 struct expression *exp, 903 int *pos, enum noside noside); 904 905 extern struct value *evaluate_subexpression_type (struct expression *exp, 906 int subexp); 907 908 extern value *evaluate_var_value (enum noside noside, const block *blk, 909 symbol *var); 910 911 extern value *evaluate_var_msym_value (enum noside noside, 912 struct objfile *objfile, 913 minimal_symbol *msymbol); 914 915 extern value *eval_skip_value (expression *exp); 916 917 extern void fetch_subexp_value (struct expression *exp, int *pc, 918 struct value **valp, struct value **resultp, 919 std::vector<value_ref_ptr> *val_chain, 920 int preserve_errors); 921 922 extern const char *extract_field_op (struct expression *exp, int *subexp); 923 924 extern struct value *evaluate_subexp_with_coercion (struct expression *, 925 int *, enum noside); 926 927 extern struct value *parse_and_eval (const char *exp); 928 929 extern struct value *parse_to_comma_and_eval (const char **expp); 930 931 extern struct type *parse_and_eval_type (char *p, int length); 932 933 extern CORE_ADDR parse_and_eval_address (const char *exp); 934 935 extern LONGEST parse_and_eval_long (const char *exp); 936 937 extern void unop_promote (const struct language_defn *language, 938 struct gdbarch *gdbarch, 939 struct value **arg1); 940 941 extern void binop_promote (const struct language_defn *language, 942 struct gdbarch *gdbarch, 943 struct value **arg1, struct value **arg2); 944 945 extern struct value *access_value_history (int num); 946 947 extern struct value *value_of_internalvar (struct gdbarch *gdbarch, 948 struct internalvar *var); 949 950 extern int get_internalvar_integer (struct internalvar *var, LONGEST *l); 951 952 extern void set_internalvar (struct internalvar *var, struct value *val); 953 954 extern void set_internalvar_integer (struct internalvar *var, LONGEST l); 955 956 extern void set_internalvar_string (struct internalvar *var, 957 const char *string); 958 959 extern void clear_internalvar (struct internalvar *var); 960 961 extern void set_internalvar_component (struct internalvar *var, 962 LONGEST offset, 963 LONGEST bitpos, LONGEST bitsize, 964 struct value *newvalue); 965 966 extern struct internalvar *lookup_only_internalvar (const char *name); 967 968 extern struct internalvar *create_internalvar (const char *name); 969 970 extern void complete_internalvar (completion_tracker &tracker, 971 const char *name); 972 973 /* An internalvar can be dynamically computed by supplying a vector of 974 function pointers to perform various operations. */ 975 976 struct internalvar_funcs 977 { 978 /* Compute the value of the variable. The DATA argument passed to 979 the function is the same argument that was passed to 980 `create_internalvar_type_lazy'. */ 981 982 struct value *(*make_value) (struct gdbarch *arch, 983 struct internalvar *var, 984 void *data); 985 986 /* Update the agent expression EXPR with bytecode to compute the 987 value. VALUE is the agent value we are updating. The DATA 988 argument passed to this function is the same argument that was 989 passed to `create_internalvar_type_lazy'. If this pointer is 990 NULL, then the internalvar cannot be compiled to an agent 991 expression. */ 992 993 void (*compile_to_ax) (struct internalvar *var, 994 struct agent_expr *expr, 995 struct axs_value *value, 996 void *data); 997 998 /* If non-NULL, this is called to destroy DATA. The DATA argument 999 passed to this function is the same argument that was passed to 1000 `create_internalvar_type_lazy'. */ 1001 1002 void (*destroy) (void *data); 1003 }; 1004 1005 extern struct internalvar *create_internalvar_type_lazy (const char *name, 1006 const struct internalvar_funcs *funcs, 1007 void *data); 1008 1009 /* Compile an internal variable to an agent expression. VAR is the 1010 variable to compile; EXPR and VALUE are the agent expression we are 1011 updating. This will return 0 if there is no known way to compile 1012 VAR, and 1 if VAR was successfully compiled. It may also throw an 1013 exception on error. */ 1014 1015 extern int compile_internalvar_to_ax (struct internalvar *var, 1016 struct agent_expr *expr, 1017 struct axs_value *value); 1018 1019 extern struct internalvar *lookup_internalvar (const char *name); 1020 1021 extern int value_equal (struct value *arg1, struct value *arg2); 1022 1023 extern int value_equal_contents (struct value *arg1, struct value *arg2); 1024 1025 extern int value_less (struct value *arg1, struct value *arg2); 1026 1027 extern int value_logical_not (struct value *arg1); 1028 1029 /* C++ */ 1030 1031 extern struct value *value_of_this (const struct language_defn *lang); 1032 1033 extern struct value *value_of_this_silent (const struct language_defn *lang); 1034 1035 extern struct value *value_x_binop (struct value *arg1, struct value *arg2, 1036 enum exp_opcode op, 1037 enum exp_opcode otherop, 1038 enum noside noside); 1039 1040 extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op, 1041 enum noside noside); 1042 1043 extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f, 1044 int j, struct type *type, LONGEST offset); 1045 1046 extern int binop_types_user_defined_p (enum exp_opcode op, 1047 struct type *type1, 1048 struct type *type2); 1049 1050 extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1, 1051 struct value *arg2); 1052 1053 extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1); 1054 1055 extern int destructor_name_p (const char *name, struct type *type); 1056 1057 extern value_ref_ptr release_value (struct value *val); 1058 1059 extern int record_latest_value (struct value *val); 1060 1061 extern void modify_field (struct type *type, gdb_byte *addr, 1062 LONGEST fieldval, LONGEST bitpos, LONGEST bitsize); 1063 1064 extern void type_print (struct type *type, const char *varstring, 1065 struct ui_file *stream, int show); 1066 1067 extern std::string type_to_string (struct type *type); 1068 1069 extern gdb_byte *baseclass_addr (struct type *type, int index, 1070 gdb_byte *valaddr, 1071 struct value **valuep, int *errp); 1072 1073 extern void print_longest (struct ui_file *stream, int format, 1074 int use_local, LONGEST val); 1075 1076 extern void print_floating (const gdb_byte *valaddr, struct type *type, 1077 struct ui_file *stream); 1078 1079 extern void value_print (struct value *val, struct ui_file *stream, 1080 const struct value_print_options *options); 1081 1082 extern void value_print_array_elements (struct value *val, 1083 struct ui_file *stream, int format, 1084 enum val_prettyformat pretty); 1085 1086 /* Release values from the value chain and return them. Values 1087 created after MARK are released. If MARK is nullptr, or if MARK is 1088 not found on the value chain, then all values are released. Values 1089 are returned in reverse order of creation; that is, newest 1090 first. */ 1091 1092 extern std::vector<value_ref_ptr> value_release_to_mark 1093 (const struct value *mark); 1094 1095 extern void val_print (struct type *type, 1096 LONGEST embedded_offset, CORE_ADDR address, 1097 struct ui_file *stream, int recurse, 1098 struct value *val, 1099 const struct value_print_options *options, 1100 const struct language_defn *language); 1101 1102 extern void common_val_print (struct value *val, 1103 struct ui_file *stream, int recurse, 1104 const struct value_print_options *options, 1105 const struct language_defn *language); 1106 1107 extern int val_print_string (struct type *elttype, const char *encoding, 1108 CORE_ADDR addr, int len, 1109 struct ui_file *stream, 1110 const struct value_print_options *options); 1111 1112 extern void print_variable_and_value (const char *name, 1113 struct symbol *var, 1114 struct frame_info *frame, 1115 struct ui_file *stream, 1116 int indent); 1117 1118 extern void typedef_print (struct type *type, struct symbol *news, 1119 struct ui_file *stream); 1120 1121 extern char *internalvar_name (const struct internalvar *var); 1122 1123 extern void preserve_values (struct objfile *); 1124 1125 /* From values.c */ 1126 1127 extern struct value *value_copy (struct value *); 1128 1129 extern struct value *value_non_lval (struct value *); 1130 1131 extern void value_force_lval (struct value *, CORE_ADDR); 1132 1133 extern struct value *make_cv_value (int, int, struct value *); 1134 1135 extern void preserve_one_value (struct value *, struct objfile *, htab_t); 1136 1137 /* From valops.c */ 1138 1139 extern struct value *varying_to_slice (struct value *); 1140 1141 extern struct value *value_slice (struct value *, int, int); 1142 1143 extern struct value *value_literal_complex (struct value *, struct value *, 1144 struct type *); 1145 1146 extern struct value *find_function_in_inferior (const char *, 1147 struct objfile **); 1148 1149 extern struct value *value_allocate_space_in_inferior (int); 1150 1151 extern struct value *value_subscripted_rvalue (struct value *array, 1152 LONGEST index, int lowerbound); 1153 1154 /* User function handler. */ 1155 1156 typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch, 1157 const struct language_defn *language, 1158 void *cookie, 1159 int argc, 1160 struct value **argv); 1161 1162 void add_internal_function (const char *name, const char *doc, 1163 internal_function_fn handler, 1164 void *cookie); 1165 1166 struct value *call_internal_function (struct gdbarch *gdbarch, 1167 const struct language_defn *language, 1168 struct value *function, 1169 int argc, struct value **argv); 1170 1171 char *value_internal_function_name (struct value *); 1172 1173 /* Build a value wrapping and representing WORKER. The value takes ownership 1174 of the xmethod_worker object. */ 1175 1176 extern struct value *value_from_xmethod (xmethod_worker_up &&worker); 1177 1178 extern struct type *result_type_of_xmethod (struct value *method, 1179 gdb::array_view<value *> argv); 1180 1181 extern struct value *call_xmethod (struct value *method, 1182 gdb::array_view<value *> argv); 1183 1184 /* Given a discriminated union type and some corresponding value 1185 contents, this will return the field index of the currently active 1186 variant. This will throw an exception if no active variant can be 1187 found. */ 1188 1189 extern int value_union_variant (struct type *union_type, 1190 const gdb_byte *contents); 1191 1192 #endif /* !defined (VALUE_H) */ 1193
Indexes created Sun Mar 01 05:31:48 UTC 2026