1 /* Definitions for values of C expressions, for GDB. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 5 2008, 2009, 2010, 2011 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #if !defined (VALUE_H) 23 #define VALUE_H 1 24 25 #include "doublest.h" 26 #include "frame.h" /* For struct frame_id. */ 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 /* The structure which defines the type of a value. It should never 38 be possible for a program lval value to survive over a call to the 39 inferior (i.e. to be put into the history list or an internal 40 variable). */ 41 42 struct value; 43 44 /* Values are stored in a chain, so that they can be deleted easily 45 over calls to the inferior. Values assigned to internal variables, 46 put into the value history or exposed to Python are taken off this 47 list. */ 48 49 struct value *value_next (struct value *); 50 51 /* Type of the value. */ 52 53 extern struct type *value_type (const struct value *); 54 55 /* This is being used to change the type of an existing value, that 56 code should instead be creating a new value with the changed type 57 (but possibly shared content). */ 58 59 extern void deprecated_set_value_type (struct value *value, 60 struct type *type); 61 62 /* Only used for bitfields; number of bits contained in them. */ 63 64 extern int value_bitsize (const struct value *); 65 extern void set_value_bitsize (struct value *, int bit); 66 67 /* Only used for bitfields; position of start of field. For 68 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For 69 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */ 70 71 extern int value_bitpos (const struct value *); 72 extern void set_value_bitpos (struct value *, int bit); 73 74 /* Only used for bitfields; the containing value. This allows a 75 single read from the target when displaying multiple 76 bitfields. */ 77 78 struct value *value_parent (struct value *); 79 80 /* Describes offset of a value within lval of a structure in bytes. 81 If lval == lval_memory, this is an offset to the address. If lval 82 == lval_register, this is a further offset from location.address 83 within the registers structure. Note also the member 84 embedded_offset below. */ 85 86 extern int value_offset (const struct value *); 87 extern void set_value_offset (struct value *, int offset); 88 89 /* The comment from "struct value" reads: ``Is it modifiable? Only 90 relevant if lval != not_lval.''. Shouldn't the value instead be 91 not_lval and be done with it? */ 92 93 extern int deprecated_value_modifiable (struct value *value); 94 extern void deprecated_set_value_modifiable (struct value *value, 95 int modifiable); 96 97 /* If a value represents a C++ object, then the `type' field gives the 98 object's compile-time type. If the object actually belongs to some 99 class derived from `type', perhaps with other base classes and 100 additional members, then `type' is just a subobject of the real 101 thing, and the full object is probably larger than `type' would 102 suggest. 103 104 If `type' is a dynamic class (i.e. one with a vtable), then GDB can 105 actually determine the object's run-time type by looking at the 106 run-time type information in the vtable. When this information is 107 available, we may elect to read in the entire object, for several 108 reasons: 109 110 - When printing the value, the user would probably rather see the 111 full object, not just the limited portion apparent from the 112 compile-time type. 113 114 - If `type' has virtual base classes, then even printing `type' 115 alone may require reaching outside the `type' portion of the 116 object to wherever the virtual base class has been stored. 117 118 When we store the entire object, `enclosing_type' is the run-time 119 type -- the complete object -- and `embedded_offset' is the offset 120 of `type' within that larger type, in bytes. The value_contents() 121 macro takes `embedded_offset' into account, so most GDB code 122 continues to see the `type' portion of the value, just as the 123 inferior would. 124 125 If `type' is a pointer to an object, then `enclosing_type' is a 126 pointer to the object's run-time type, and `pointed_to_offset' is 127 the offset in bytes from the full object to the pointed-to object 128 -- that is, the value `embedded_offset' would have if we followed 129 the pointer and fetched the complete object. (I don't really see 130 the point. Why not just determine the run-time type when you 131 indirect, and avoid the special case? The contents don't matter 132 until you indirect anyway.) 133 134 If we're not doing anything fancy, `enclosing_type' is equal to 135 `type', and `embedded_offset' is zero, so everything works 136 normally. */ 137 138 extern struct type *value_enclosing_type (struct value *); 139 extern void set_value_enclosing_type (struct value *val, 140 struct type *new_type); 141 142 extern int value_pointed_to_offset (struct value *value); 143 extern void set_value_pointed_to_offset (struct value *value, int val); 144 extern int value_embedded_offset (struct value *value); 145 extern void set_value_embedded_offset (struct value *value, int val); 146 147 /* For lval_computed values, this structure holds functions used to 148 retrieve and set the value (or portions of the value). 149 150 For each function, 'V' is the 'this' pointer: an lval_funcs 151 function F may always assume that the V it receives is an 152 lval_computed value, and has F in the appropriate slot of its 153 lval_funcs structure. */ 154 155 struct lval_funcs 156 { 157 /* Fill in VALUE's contents. This is used to "un-lazy" values. If 158 a problem arises in obtaining VALUE's bits, this function should 159 call 'error'. */ 160 void (*read) (struct value *v); 161 162 /* Handle an assignment TOVAL = FROMVAL by writing the value of 163 FROMVAL to TOVAL's location. The contents of TOVAL have not yet 164 been updated. If a problem arises in doing so, this function 165 should call 'error'. */ 166 void (*write) (struct value *toval, struct value *fromval); 167 168 /* Check the validity of some bits in VALUE. This should return 1 169 if all the bits starting at OFFSET and extending for LENGTH bits 170 are valid, or 0 if any bit is invalid. */ 171 int (*check_validity) (const struct value *value, int offset, int length); 172 173 /* Return 1 if any bit in VALUE is valid, 0 if they are all invalid. */ 174 int (*check_any_valid) (const struct value *value); 175 176 /* If non-NULL, this is used to implement pointer indirection for 177 this value. This method may return NULL, in which case value_ind 178 will fall back to ordinary indirection. */ 179 struct value *(*indirect) (struct value *value); 180 181 /* If non-NULL, this is used to determine whether the indicated bits 182 of VALUE are a synthetic pointer. */ 183 int (*check_synthetic_pointer) (const struct value *value, 184 int offset, int length); 185 186 /* Return a duplicate of VALUE's closure, for use in a new value. 187 This may simply return the same closure, if VALUE's is 188 reference-counted or statically allocated. 189 190 This may be NULL, in which case VALUE's closure is re-used in the 191 new value. */ 192 void *(*copy_closure) (const struct value *v); 193 194 /* Drop VALUE's reference to its closure. Maybe this frees the 195 closure; maybe this decrements a reference count; maybe the 196 closure is statically allocated and this does nothing. 197 198 This may be NULL, in which case no action is taken to free 199 VALUE's closure. */ 200 void (*free_closure) (struct value *v); 201 }; 202 203 /* Create a computed lvalue, with type TYPE, function pointers FUNCS, 204 and closure CLOSURE. */ 205 206 extern struct value *allocate_computed_value (struct type *type, 207 struct lval_funcs *funcs, 208 void *closure); 209 210 /* If VALUE is lval_computed, return its lval_funcs structure. */ 211 212 extern struct lval_funcs *value_computed_funcs (struct value *value); 213 214 /* If VALUE is lval_computed, return its closure. The meaning of the 215 returned value depends on the functions VALUE uses. */ 216 217 extern void *value_computed_closure (const struct value *value); 218 219 /* If zero, contents of this value are in the contents field. If 220 nonzero, contents are in inferior. If the lval field is lval_memory, 221 the contents are in inferior memory at location.address plus offset. 222 The lval field may also be lval_register. 223 224 WARNING: This field is used by the code which handles watchpoints 225 (see breakpoint.c) to decide whether a particular value can be 226 watched by hardware watchpoints. If the lazy flag is set for some 227 member of a value chain, it is assumed that this member of the 228 chain doesn't need to be watched as part of watching the value 229 itself. This is how GDB avoids watching the entire struct or array 230 when the user wants to watch a single struct member or array 231 element. If you ever change the way lazy flag is set and reset, be 232 sure to consider this use as well! */ 233 234 extern int value_lazy (struct value *); 235 extern void set_value_lazy (struct value *value, int val); 236 237 extern int value_stack (struct value *); 238 extern void set_value_stack (struct value *value, int val); 239 240 /* value_contents() and value_contents_raw() both return the address 241 of the gdb buffer used to hold a copy of the contents of the lval. 242 value_contents() is used when the contents of the buffer are needed 243 -- it uses value_fetch_lazy() to load the buffer from the process 244 being debugged if it hasn't already been loaded 245 (value_contents_writeable() is used when a writeable but fetched 246 buffer is required).. value_contents_raw() is used when data is 247 being stored into the buffer, or when it is certain that the 248 contents of the buffer are valid. 249 250 Note: The contents pointer is adjusted by the offset required to 251 get to the real subobject, if the value happens to represent 252 something embedded in a larger run-time object. */ 253 254 extern gdb_byte *value_contents_raw (struct value *); 255 256 /* Actual contents of the value. For use of this value; setting it 257 uses the stuff above. Not valid if lazy is nonzero. Target 258 byte-order. We force it to be aligned properly for any possible 259 value. Note that a value therefore extends beyond what is 260 declared here. */ 261 262 extern const gdb_byte *value_contents (struct value *); 263 extern gdb_byte *value_contents_writeable (struct value *); 264 265 /* The ALL variants of the above two macros do not adjust the returned 266 pointer by the embedded_offset value. */ 267 268 extern gdb_byte *value_contents_all_raw (struct value *); 269 extern const gdb_byte *value_contents_all (struct value *); 270 271 /* Like value_contents_all, but does not require that the returned 272 bits be valid. This should only be used in situations where you 273 plan to check the validity manually. */ 274 extern const gdb_byte *value_contents_for_printing (struct value *value); 275 276 /* Like value_contents_for_printing, but accepts a constant value 277 pointer. Unlike value_contents_for_printing however, the pointed 278 value must _not_ be lazy. */ 279 extern const gdb_byte * 280 value_contents_for_printing_const (const struct value *value); 281 282 extern int value_fetch_lazy (struct value *val); 283 extern int value_contents_equal (struct value *val1, struct value *val2); 284 285 /* If nonzero, this is the value of a variable which does not actually 286 exist in the program. */ 287 extern int value_optimized_out (struct value *value); 288 extern void set_value_optimized_out (struct value *value, int val); 289 290 /* Like value_optimized_out, but return false if any bit in the object 291 is valid. */ 292 extern int value_entirely_optimized_out (const struct value *value); 293 294 /* Set or return field indicating whether a variable is initialized or 295 not, based on debugging information supplied by the compiler. 296 1 = initialized; 0 = uninitialized. */ 297 extern int value_initialized (struct value *); 298 extern void set_value_initialized (struct value *, int); 299 300 /* Set COMPONENT's location as appropriate for a component of WHOLE 301 --- regardless of what kind of lvalue WHOLE is. */ 302 extern void set_value_component_location (struct value *component, 303 const struct value *whole); 304 305 /* While the following fields are per- VALUE .CONTENT .PIECE (i.e., a 306 single value might have multiple LVALs), this hacked interface is 307 limited to just the first PIECE. Expect further change. */ 308 /* Type of value; either not an lval, or one of the various different 309 possible kinds of lval. */ 310 extern enum lval_type *deprecated_value_lval_hack (struct value *); 311 #define VALUE_LVAL(val) (*deprecated_value_lval_hack (val)) 312 313 /* If lval == lval_memory, return the address in the inferior. If 314 lval == lval_register, return the byte offset into the registers 315 structure. Otherwise, return 0. The returned address 316 includes the offset, if any. */ 317 extern CORE_ADDR value_address (const struct value *); 318 319 /* Like value_address, except the result does not include value's 320 offset. */ 321 extern CORE_ADDR value_raw_address (struct value *); 322 323 /* Set the address of a value. */ 324 extern void set_value_address (struct value *, CORE_ADDR); 325 326 /* Pointer to internal variable. */ 327 extern struct internalvar **deprecated_value_internalvar_hack (struct value *); 328 #define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val)) 329 330 /* Frame register value is relative to. This will be described in the 331 lval enum above as "lval_register". */ 332 extern struct frame_id *deprecated_value_frame_id_hack (struct value *); 333 #define VALUE_FRAME_ID(val) (*deprecated_value_frame_id_hack (val)) 334 335 /* Register number if the value is from a register. */ 336 extern short *deprecated_value_regnum_hack (struct value *); 337 #define VALUE_REGNUM(val) (*deprecated_value_regnum_hack (val)) 338 339 /* Convert a REF to the object referenced. */ 340 341 extern struct value *coerce_ref (struct value *value); 342 343 /* If ARG is an array, convert it to a pointer. 344 If ARG is a function, convert it to a function pointer. 345 346 References are dereferenced. */ 347 348 extern struct value *coerce_array (struct value *value); 349 350 /* Given a value, determine whether the bits starting at OFFSET and 351 extending for LENGTH bits are valid. This returns nonzero if all 352 bits in the given range are valid, zero if any bit is invalid. */ 353 354 extern int value_bits_valid (const struct value *value, 355 int offset, int length); 356 357 /* Given a value, determine whether the bits starting at OFFSET and 358 extending for LENGTH bits are a synthetic pointer. */ 359 360 extern int value_bits_synthetic_pointer (const struct value *value, 361 int offset, int length); 362 363 /* Given a value, determine whether the contents bytes starting at 364 OFFSET and extending for LENGTH bytes are available. This returns 365 nonzero if all bytes in the given range are available, zero if any 366 byte is unavailable. */ 367 368 extern int value_bytes_available (const struct value *value, 369 int offset, int length); 370 371 /* Like value_bytes_available, but return false if any byte in the 372 whole object is unavailable. */ 373 extern int value_entirely_available (struct value *value); 374 375 /* Mark VALUE's content bytes starting at OFFSET and extending for 376 LENGTH bytes as unavailable. */ 377 378 extern void mark_value_bytes_unavailable (struct value *value, 379 int offset, int length); 380 381 /* Compare LENGTH bytes of VAL1's contents starting at OFFSET1 with 382 LENGTH bytes of VAL2's contents starting at OFFSET2. 383 384 Note that "contents" refers to the whole value's contents 385 (value_contents_all), without any embedded offset adjustment. For 386 example, to compare a complete object value with itself, including 387 its enclosing type chunk, you'd do: 388 389 int len = TYPE_LENGTH (check_typedef (value_enclosing_type (val))); 390 value_available_contents (val, 0, val, 0, len); 391 392 Returns true iff the set of available contents match. Unavailable 393 contents compare equal with unavailable contents, and different 394 with any available byte. For example, if 'x's represent an 395 unavailable byte, and 'V' and 'Z' represent different available 396 bytes, in a value with length 16: 397 398 offset: 0 4 8 12 16 399 contents: xxxxVVVVxxxxVVZZ 400 401 then: 402 403 value_available_contents_eq(val, 0, val, 8, 6) => 1 404 value_available_contents_eq(val, 0, val, 4, 4) => 1 405 value_available_contents_eq(val, 0, val, 8, 8) => 0 406 value_available_contents_eq(val, 4, val, 12, 2) => 1 407 value_available_contents_eq(val, 4, val, 12, 4) => 0 408 value_available_contents_eq(val, 3, val, 4, 4) => 0 409 */ 410 411 extern int value_available_contents_eq (const struct value *val1, int offset1, 412 const struct value *val2, int offset2, 413 int length); 414 415 /* Read LENGTH bytes of memory starting at MEMADDR into BUFFER, which 416 is (or will be copied to) VAL's contents buffer offset by 417 EMBEDDED_OFFSET (that is, to &VAL->contents[EMBEDDED_OFFSET]). 418 Marks value contents ranges as unavailable if the corresponding 419 memory is likewise unavailable. STACK indicates whether the memory 420 is known to be stack memory. */ 421 422 extern void read_value_memory (struct value *val, int embedded_offset, 423 int stack, CORE_ADDR memaddr, 424 gdb_byte *buffer, size_t length); 425 426 427 428 #include "symtab.h" 429 #include "gdbtypes.h" 430 #include "expression.h" 431 432 struct frame_info; 433 struct fn_field; 434 435 extern void print_address_demangle (struct gdbarch *, CORE_ADDR, 436 struct ui_file *, int); 437 438 extern LONGEST value_as_long (struct value *val); 439 extern DOUBLEST value_as_double (struct value *val); 440 extern CORE_ADDR value_as_address (struct value *val); 441 442 extern LONGEST unpack_long (struct type *type, const gdb_byte *valaddr); 443 extern DOUBLEST unpack_double (struct type *type, const gdb_byte *valaddr, 444 int *invp); 445 extern CORE_ADDR unpack_pointer (struct type *type, const gdb_byte *valaddr); 446 447 extern int unpack_value_bits_as_long (struct type *field_type, 448 const gdb_byte *valaddr, 449 int embedded_offset, int bitpos, 450 int bitsize, 451 const struct value *original_value, 452 LONGEST *result); 453 454 extern LONGEST unpack_field_as_long (struct type *type, 455 const gdb_byte *valaddr, 456 int fieldno); 457 extern int unpack_value_field_as_long (struct type *type, const gdb_byte *valaddr, 458 int embedded_offset, int fieldno, 459 const struct value *val, LONGEST *result); 460 461 extern struct value *value_field_bitfield (struct type *type, int fieldno, 462 const gdb_byte *valaddr, 463 int embedded_offset, 464 const struct value *val); 465 466 extern void pack_long (gdb_byte *buf, struct type *type, LONGEST num); 467 468 extern struct value *value_from_longest (struct type *type, LONGEST num); 469 extern struct value *value_from_ulongest (struct type *type, ULONGEST num); 470 extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr); 471 extern struct value *value_from_double (struct type *type, DOUBLEST num); 472 extern struct value *value_from_decfloat (struct type *type, 473 const gdb_byte *decbytes); 474 extern struct value *value_from_history_ref (char *, char **); 475 476 extern struct value *value_at (struct type *type, CORE_ADDR addr); 477 extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr); 478 479 extern struct value *value_from_contents_and_address (struct type *, 480 const gdb_byte *, 481 CORE_ADDR); 482 483 extern struct value *default_value_from_register (struct type *type, 484 int regnum, 485 struct frame_info *frame); 486 487 extern struct value *value_from_register (struct type *type, int regnum, 488 struct frame_info *frame); 489 490 extern CORE_ADDR address_from_register (struct type *type, int regnum, 491 struct frame_info *frame); 492 493 extern struct value *value_of_variable (struct symbol *var, struct block *b); 494 495 extern struct value *address_of_variable (struct symbol *var, struct block *b); 496 497 extern struct value *value_of_register (int regnum, struct frame_info *frame); 498 499 struct value *value_of_register_lazy (struct frame_info *frame, int regnum); 500 501 extern int symbol_read_needs_frame (struct symbol *); 502 503 extern struct value *read_var_value (struct symbol *var, 504 struct frame_info *frame); 505 506 extern struct value *allocate_value (struct type *type); 507 extern struct value *allocate_value_lazy (struct type *type); 508 extern void allocate_value_contents (struct value *value); 509 extern void value_contents_copy (struct value *dst, int dst_offset, 510 struct value *src, int src_offset, 511 int length); 512 extern void value_contents_copy_raw (struct value *dst, int dst_offset, 513 struct value *src, int src_offset, 514 int length); 515 516 extern struct value *allocate_repeat_value (struct type *type, int count); 517 518 extern struct value *value_mark (void); 519 520 extern void value_free_to_mark (struct value *mark); 521 522 extern struct value *value_cstring (char *ptr, int len, 523 struct type *char_type); 524 extern struct value *value_string (char *ptr, int len, 525 struct type *char_type); 526 extern struct value *value_bitstring (char *ptr, int len, 527 struct type *index_type); 528 529 extern struct value *value_array (int lowbound, int highbound, 530 struct value **elemvec); 531 532 extern struct value *value_concat (struct value *arg1, struct value *arg2); 533 534 extern struct value *value_binop (struct value *arg1, struct value *arg2, 535 enum exp_opcode op); 536 537 extern struct value *value_ptradd (struct value *arg1, LONGEST arg2); 538 539 extern LONGEST value_ptrdiff (struct value *arg1, struct value *arg2); 540 541 extern int value_must_coerce_to_target (struct value *arg1); 542 543 extern struct value *value_coerce_to_target (struct value *arg1); 544 545 extern struct value *value_coerce_array (struct value *arg1); 546 547 extern struct value *value_coerce_function (struct value *arg1); 548 549 extern struct value *value_ind (struct value *arg1); 550 551 extern struct value *value_addr (struct value *arg1); 552 553 extern struct value *value_ref (struct value *arg1); 554 555 extern struct value *value_assign (struct value *toval, 556 struct value *fromval); 557 558 extern struct value *value_pos (struct value *arg1); 559 560 extern struct value *value_neg (struct value *arg1); 561 562 extern struct value *value_complement (struct value *arg1); 563 564 extern struct value *value_struct_elt (struct value **argp, 565 struct value **args, 566 const char *name, int *static_memfuncp, 567 const char *err); 568 569 extern struct value *value_aggregate_elt (struct type *curtype, 570 char *name, 571 struct type *expect_type, 572 int want_address, 573 enum noside noside); 574 575 extern struct value *value_static_field (struct type *type, int fieldno); 576 577 extern struct fn_field *value_find_oload_method_list (struct value **, 578 const char *, 579 int, int *, 580 struct type **, int *); 581 582 enum oload_search_type { NON_METHOD, METHOD, BOTH }; 583 584 extern int find_overload_match (struct type **arg_types, int nargs, 585 const char *name, 586 enum oload_search_type method, int lax, 587 struct value **objp, struct symbol *fsym, 588 struct value **valp, struct symbol **symp, 589 int *staticp, const int no_adl); 590 591 extern struct value *value_field (struct value *arg1, int fieldno); 592 593 extern struct value *value_primitive_field (struct value *arg1, int offset, 594 int fieldno, 595 struct type *arg_type); 596 597 598 extern struct type *value_rtti_target_type (struct value *, int *, int *, 599 int *); 600 601 extern struct value *value_full_object (struct value *, struct type *, int, 602 int, int); 603 604 extern struct value *value_cast_pointers (struct type *, struct value *); 605 606 extern struct value *value_cast (struct type *type, struct value *arg2); 607 608 extern struct value *value_reinterpret_cast (struct type *type, 609 struct value *arg); 610 611 extern struct value *value_dynamic_cast (struct type *type, struct value *arg); 612 613 extern struct value *value_zero (struct type *type, enum lval_type lv); 614 615 extern struct value *value_one (struct type *type, enum lval_type lv); 616 617 extern struct value *value_repeat (struct value *arg1, int count); 618 619 extern struct value *value_subscript (struct value *array, LONGEST index); 620 621 extern struct value *value_bitstring_subscript (struct type *type, 622 struct value *bitstring, 623 LONGEST index); 624 625 extern struct value *register_value_being_returned (struct type *valtype, 626 struct regcache *retbuf); 627 628 extern int value_in (struct value *element, struct value *set); 629 630 extern int value_bit_index (struct type *type, const gdb_byte *addr, 631 int index); 632 633 extern int using_struct_return (struct gdbarch *gdbarch, 634 struct type *func_type, 635 struct type *value_type); 636 637 extern struct value *evaluate_expression (struct expression *exp); 638 639 extern struct value *evaluate_type (struct expression *exp); 640 641 extern struct value *evaluate_subexp (struct type *expect_type, 642 struct expression *exp, 643 int *pos, enum noside noside); 644 645 extern struct value *evaluate_subexpression_type (struct expression *exp, 646 int subexp); 647 648 extern void fetch_subexp_value (struct expression *exp, int *pc, 649 struct value **valp, struct value **resultp, 650 struct value **val_chain); 651 652 extern char *extract_field_op (struct expression *exp, int *subexp); 653 654 extern struct value *evaluate_subexp_with_coercion (struct expression *, 655 int *, enum noside); 656 657 extern struct value *parse_and_eval (char *exp); 658 659 extern struct value *parse_to_comma_and_eval (char **expp); 660 661 extern struct type *parse_and_eval_type (char *p, int length); 662 663 extern CORE_ADDR parse_and_eval_address (char *exp); 664 665 extern LONGEST parse_and_eval_long (char *exp); 666 667 extern void unop_promote (const struct language_defn *language, 668 struct gdbarch *gdbarch, 669 struct value **arg1); 670 671 extern void binop_promote (const struct language_defn *language, 672 struct gdbarch *gdbarch, 673 struct value **arg1, struct value **arg2); 674 675 extern struct value *access_value_history (int num); 676 677 extern struct value *value_of_internalvar (struct gdbarch *gdbarch, 678 struct internalvar *var); 679 680 extern int get_internalvar_integer (struct internalvar *var, LONGEST *l); 681 682 extern void set_internalvar (struct internalvar *var, struct value *val); 683 684 extern void set_internalvar_integer (struct internalvar *var, LONGEST l); 685 686 extern void set_internalvar_string (struct internalvar *var, 687 const char *string); 688 689 extern void clear_internalvar (struct internalvar *var); 690 691 extern void set_internalvar_component (struct internalvar *var, 692 int offset, 693 int bitpos, int bitsize, 694 struct value *newvalue); 695 696 extern struct internalvar *lookup_only_internalvar (const char *name); 697 698 extern struct internalvar *create_internalvar (const char *name); 699 700 typedef struct value * (*internalvar_make_value) (struct gdbarch *, 701 struct internalvar *); 702 extern struct internalvar * 703 create_internalvar_type_lazy (char *name, internalvar_make_value fun); 704 705 extern struct internalvar *lookup_internalvar (const char *name); 706 707 extern int value_equal (struct value *arg1, struct value *arg2); 708 709 extern int value_equal_contents (struct value *arg1, struct value *arg2); 710 711 extern int value_less (struct value *arg1, struct value *arg2); 712 713 extern int value_logical_not (struct value *arg1); 714 715 /* C++ */ 716 717 extern struct value *value_of_this (int complain); 718 719 extern struct value *value_x_binop (struct value *arg1, struct value *arg2, 720 enum exp_opcode op, 721 enum exp_opcode otherop, 722 enum noside noside); 723 724 extern struct value *value_x_unop (struct value *arg1, enum exp_opcode op, 725 enum noside noside); 726 727 extern struct value *value_fn_field (struct value **arg1p, struct fn_field *f, 728 int j, struct type *type, int offset); 729 730 extern int binop_types_user_defined_p (enum exp_opcode op, 731 struct type *type1, 732 struct type *type2); 733 734 extern int binop_user_defined_p (enum exp_opcode op, struct value *arg1, 735 struct value *arg2); 736 737 extern int unop_user_defined_p (enum exp_opcode op, struct value *arg1); 738 739 extern int destructor_name_p (const char *name, const struct type *type); 740 741 extern void value_incref (struct value *val); 742 743 extern void value_free (struct value *val); 744 745 extern void free_all_values (void); 746 747 extern void free_value_chain (struct value *v); 748 749 extern void release_value (struct value *val); 750 751 extern int record_latest_value (struct value *val); 752 753 extern void modify_field (struct type *type, gdb_byte *addr, 754 LONGEST fieldval, int bitpos, int bitsize); 755 756 extern void type_print (struct type *type, char *varstring, 757 struct ui_file *stream, int show); 758 759 extern char *type_to_string (struct type *type); 760 761 extern gdb_byte *baseclass_addr (struct type *type, int index, 762 gdb_byte *valaddr, 763 struct value **valuep, int *errp); 764 765 extern void print_longest (struct ui_file *stream, int format, 766 int use_local, LONGEST val); 767 768 extern void print_floating (const gdb_byte *valaddr, struct type *type, 769 struct ui_file *stream); 770 771 extern void print_decimal_floating (const gdb_byte *valaddr, struct type *type, 772 struct ui_file *stream); 773 774 extern int value_print (struct value *val, struct ui_file *stream, 775 const struct value_print_options *options); 776 777 extern void value_print_array_elements (struct value *val, 778 struct ui_file *stream, int format, 779 enum val_prettyprint pretty); 780 781 extern struct value *value_release_to_mark (struct value *mark); 782 783 extern int val_print (struct type *type, const gdb_byte *valaddr, 784 int embedded_offset, CORE_ADDR address, 785 struct ui_file *stream, int recurse, 786 const struct value *val, 787 const struct value_print_options *options, 788 const struct language_defn *language); 789 790 extern int common_val_print (struct value *val, 791 struct ui_file *stream, int recurse, 792 const struct value_print_options *options, 793 const struct language_defn *language); 794 795 extern int val_print_string (struct type *elttype, const char *encoding, 796 CORE_ADDR addr, int len, 797 struct ui_file *stream, 798 const struct value_print_options *options); 799 800 extern void print_variable_and_value (const char *name, 801 struct symbol *var, 802 struct frame_info *frame, 803 struct ui_file *stream, 804 int indent); 805 806 extern int check_field (struct type *, const char *); 807 808 extern void typedef_print (struct type *type, struct symbol *news, 809 struct ui_file *stream); 810 811 extern char *internalvar_name (struct internalvar *var); 812 813 extern void preserve_values (struct objfile *); 814 815 /* From values.c */ 816 817 extern struct value *value_copy (struct value *); 818 819 extern struct value *value_non_lval (struct value *); 820 821 extern void preserve_one_value (struct value *, struct objfile *, htab_t); 822 823 /* From valops.c */ 824 825 extern struct value *varying_to_slice (struct value *); 826 827 extern struct value *value_slice (struct value *, int, int); 828 829 extern struct value *value_literal_complex (struct value *, struct value *, 830 struct type *); 831 832 extern struct value *find_function_in_inferior (const char *, 833 struct objfile **); 834 835 extern struct value *value_allocate_space_in_inferior (int); 836 837 extern struct value *value_of_local (const char *name, int complain); 838 839 extern struct value *value_subscripted_rvalue (struct value *array, 840 LONGEST index, int lowerbound); 841 842 /* User function handler. */ 843 844 typedef struct value *(*internal_function_fn) (struct gdbarch *gdbarch, 845 const struct language_defn *language, 846 void *cookie, 847 int argc, 848 struct value **argv); 849 850 void add_internal_function (const char *name, const char *doc, 851 internal_function_fn handler, 852 void *cookie); 853 854 struct value *call_internal_function (struct gdbarch *gdbarch, 855 const struct language_defn *language, 856 struct value *function, 857 int argc, struct value **argv); 858 859 char *value_internal_function_name (struct value *); 860 861 #endif /* !defined (VALUE_H) */ 862