1 /* Low level packing and unpacking of values for GDB, the GNU Debugger. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 5 2009 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 #include "defs.h" 23 #include "arch-utils.h" 24 #include "gdb_string.h" 25 #include "symtab.h" 26 #include "gdbtypes.h" 27 #include "value.h" 28 #include "gdbcore.h" 29 #include "command.h" 30 #include "gdbcmd.h" 31 #include "target.h" 32 #include "language.h" 33 #include "demangle.h" 34 #include "doublest.h" 35 #include "gdb_assert.h" 36 #include "regcache.h" 37 #include "block.h" 38 #include "dfp.h" 39 #include "objfiles.h" 40 #include "valprint.h" 41 #include "cli/cli-decode.h" 42 43 #include "python/python.h" 44 45 /* Prototypes for exported functions. */ 46 47 void _initialize_values (void); 48 49 /* Definition of a user function. */ 50 struct internal_function 51 { 52 /* The name of the function. It is a bit odd to have this in the 53 function itself -- the user might use a differently-named 54 convenience variable to hold the function. */ 55 char *name; 56 57 /* The handler. */ 58 internal_function_fn handler; 59 60 /* User data for the handler. */ 61 void *cookie; 62 }; 63 64 static struct cmd_list_element *functionlist; 65 66 struct value 67 { 68 /* Type of value; either not an lval, or one of the various 69 different possible kinds of lval. */ 70 enum lval_type lval; 71 72 /* Is it modifiable? Only relevant if lval != not_lval. */ 73 int modifiable; 74 75 /* Location of value (if lval). */ 76 union 77 { 78 /* If lval == lval_memory, this is the address in the inferior. 79 If lval == lval_register, this is the byte offset into the 80 registers structure. */ 81 CORE_ADDR address; 82 83 /* Pointer to internal variable. */ 84 struct internalvar *internalvar; 85 86 /* If lval == lval_computed, this is a set of function pointers 87 to use to access and describe the value, and a closure pointer 88 for them to use. */ 89 struct 90 { 91 struct lval_funcs *funcs; /* Functions to call. */ 92 void *closure; /* Closure for those functions to use. */ 93 } computed; 94 } location; 95 96 /* Describes offset of a value within lval of a structure in bytes. 97 If lval == lval_memory, this is an offset to the address. If 98 lval == lval_register, this is a further offset from 99 location.address within the registers structure. Note also the 100 member embedded_offset below. */ 101 int offset; 102 103 /* Only used for bitfields; number of bits contained in them. */ 104 int bitsize; 105 106 /* Only used for bitfields; position of start of field. For 107 gdbarch_bits_big_endian=0 targets, it is the position of the LSB. For 108 gdbarch_bits_big_endian=1 targets, it is the position of the MSB. */ 109 int bitpos; 110 111 /* Only used for bitfields; the containing value. This allows a 112 single read from the target when displaying multiple 113 bitfields. */ 114 struct value *parent; 115 116 /* Frame register value is relative to. This will be described in 117 the lval enum above as "lval_register". */ 118 struct frame_id frame_id; 119 120 /* Type of the value. */ 121 struct type *type; 122 123 /* If a value represents a C++ object, then the `type' field gives 124 the object's compile-time type. If the object actually belongs 125 to some class derived from `type', perhaps with other base 126 classes and additional members, then `type' is just a subobject 127 of the real thing, and the full object is probably larger than 128 `type' would suggest. 129 130 If `type' is a dynamic class (i.e. one with a vtable), then GDB 131 can actually determine the object's run-time type by looking at 132 the run-time type information in the vtable. When this 133 information is available, we may elect to read in the entire 134 object, for several reasons: 135 136 - When printing the value, the user would probably rather see the 137 full object, not just the limited portion apparent from the 138 compile-time type. 139 140 - If `type' has virtual base classes, then even printing `type' 141 alone may require reaching outside the `type' portion of the 142 object to wherever the virtual base class has been stored. 143 144 When we store the entire object, `enclosing_type' is the run-time 145 type -- the complete object -- and `embedded_offset' is the 146 offset of `type' within that larger type, in bytes. The 147 value_contents() macro takes `embedded_offset' into account, so 148 most GDB code continues to see the `type' portion of the value, 149 just as the inferior would. 150 151 If `type' is a pointer to an object, then `enclosing_type' is a 152 pointer to the object's run-time type, and `pointed_to_offset' is 153 the offset in bytes from the full object to the pointed-to object 154 -- that is, the value `embedded_offset' would have if we followed 155 the pointer and fetched the complete object. (I don't really see 156 the point. Why not just determine the run-time type when you 157 indirect, and avoid the special case? The contents don't matter 158 until you indirect anyway.) 159 160 If we're not doing anything fancy, `enclosing_type' is equal to 161 `type', and `embedded_offset' is zero, so everything works 162 normally. */ 163 struct type *enclosing_type; 164 int embedded_offset; 165 int pointed_to_offset; 166 167 /* Values are stored in a chain, so that they can be deleted easily 168 over calls to the inferior. Values assigned to internal 169 variables, put into the value history or exposed to Python are 170 taken off this list. */ 171 struct value *next; 172 173 /* Register number if the value is from a register. */ 174 short regnum; 175 176 /* If zero, contents of this value are in the contents field. If 177 nonzero, contents are in inferior. If the lval field is lval_memory, 178 the contents are in inferior memory at location.address plus offset. 179 The lval field may also be lval_register. 180 181 WARNING: This field is used by the code which handles watchpoints 182 (see breakpoint.c) to decide whether a particular value can be 183 watched by hardware watchpoints. If the lazy flag is set for 184 some member of a value chain, it is assumed that this member of 185 the chain doesn't need to be watched as part of watching the 186 value itself. This is how GDB avoids watching the entire struct 187 or array when the user wants to watch a single struct member or 188 array element. If you ever change the way lazy flag is set and 189 reset, be sure to consider this use as well! */ 190 char lazy; 191 192 /* If nonzero, this is the value of a variable which does not 193 actually exist in the program. */ 194 char optimized_out; 195 196 /* If value is a variable, is it initialized or not. */ 197 int initialized; 198 199 /* If value is from the stack. If this is set, read_stack will be 200 used instead of read_memory to enable extra caching. */ 201 int stack; 202 203 /* Actual contents of the value. Target byte-order. NULL or not 204 valid if lazy is nonzero. */ 205 gdb_byte *contents; 206 207 /* The number of references to this value. When a value is created, 208 the value chain holds a reference, so REFERENCE_COUNT is 1. If 209 release_value is called, this value is removed from the chain but 210 the caller of release_value now has a reference to this value. 211 The caller must arrange for a call to value_free later. */ 212 int reference_count; 213 }; 214 215 /* Prototypes for local functions. */ 216 217 static void show_values (char *, int); 218 219 static void show_convenience (char *, int); 220 221 222 /* The value-history records all the values printed 223 by print commands during this session. Each chunk 224 records 60 consecutive values. The first chunk on 225 the chain records the most recent values. 226 The total number of values is in value_history_count. */ 227 228 #define VALUE_HISTORY_CHUNK 60 229 230 struct value_history_chunk 231 { 232 struct value_history_chunk *next; 233 struct value *values[VALUE_HISTORY_CHUNK]; 234 }; 235 236 /* Chain of chunks now in use. */ 237 238 static struct value_history_chunk *value_history_chain; 239 240 static int value_history_count; /* Abs number of last entry stored */ 241 242 243 /* List of all value objects currently allocated 244 (except for those released by calls to release_value) 245 This is so they can be freed after each command. */ 246 247 static struct value *all_values; 248 249 /* Allocate a lazy value for type TYPE. Its actual content is 250 "lazily" allocated too: the content field of the return value is 251 NULL; it will be allocated when it is fetched from the target. */ 252 253 struct value * 254 allocate_value_lazy (struct type *type) 255 { 256 struct value *val; 257 struct type *atype = check_typedef (type); 258 259 val = (struct value *) xzalloc (sizeof (struct value)); 260 val->contents = NULL; 261 val->next = all_values; 262 all_values = val; 263 val->type = type; 264 val->enclosing_type = type; 265 VALUE_LVAL (val) = not_lval; 266 val->location.address = 0; 267 VALUE_FRAME_ID (val) = null_frame_id; 268 val->offset = 0; 269 val->bitpos = 0; 270 val->bitsize = 0; 271 VALUE_REGNUM (val) = -1; 272 val->lazy = 1; 273 val->optimized_out = 0; 274 val->embedded_offset = 0; 275 val->pointed_to_offset = 0; 276 val->modifiable = 1; 277 val->initialized = 1; /* Default to initialized. */ 278 279 /* Values start out on the all_values chain. */ 280 val->reference_count = 1; 281 282 return val; 283 } 284 285 /* Allocate the contents of VAL if it has not been allocated yet. */ 286 287 void 288 allocate_value_contents (struct value *val) 289 { 290 if (!val->contents) 291 val->contents = (gdb_byte *) xzalloc (TYPE_LENGTH (val->enclosing_type)); 292 } 293 294 /* Allocate a value and its contents for type TYPE. */ 295 296 struct value * 297 allocate_value (struct type *type) 298 { 299 struct value *val = allocate_value_lazy (type); 300 allocate_value_contents (val); 301 val->lazy = 0; 302 return val; 303 } 304 305 /* Allocate a value that has the correct length 306 for COUNT repetitions of type TYPE. */ 307 308 struct value * 309 allocate_repeat_value (struct type *type, int count) 310 { 311 int low_bound = current_language->string_lower_bound; /* ??? */ 312 /* FIXME-type-allocation: need a way to free this type when we are 313 done with it. */ 314 struct type *array_type 315 = lookup_array_range_type (type, low_bound, count + low_bound - 1); 316 return allocate_value (array_type); 317 } 318 319 struct value * 320 allocate_computed_value (struct type *type, 321 struct lval_funcs *funcs, 322 void *closure) 323 { 324 struct value *v = allocate_value (type); 325 VALUE_LVAL (v) = lval_computed; 326 v->location.computed.funcs = funcs; 327 v->location.computed.closure = closure; 328 set_value_lazy (v, 1); 329 330 return v; 331 } 332 333 /* Accessor methods. */ 334 335 struct value * 336 value_next (struct value *value) 337 { 338 return value->next; 339 } 340 341 struct type * 342 value_type (struct value *value) 343 { 344 return value->type; 345 } 346 void 347 deprecated_set_value_type (struct value *value, struct type *type) 348 { 349 value->type = type; 350 } 351 352 int 353 value_offset (struct value *value) 354 { 355 return value->offset; 356 } 357 void 358 set_value_offset (struct value *value, int offset) 359 { 360 value->offset = offset; 361 } 362 363 int 364 value_bitpos (struct value *value) 365 { 366 return value->bitpos; 367 } 368 void 369 set_value_bitpos (struct value *value, int bit) 370 { 371 value->bitpos = bit; 372 } 373 374 int 375 value_bitsize (struct value *value) 376 { 377 return value->bitsize; 378 } 379 void 380 set_value_bitsize (struct value *value, int bit) 381 { 382 value->bitsize = bit; 383 } 384 385 struct value * 386 value_parent (struct value *value) 387 { 388 return value->parent; 389 } 390 391 gdb_byte * 392 value_contents_raw (struct value *value) 393 { 394 allocate_value_contents (value); 395 return value->contents + value->embedded_offset; 396 } 397 398 gdb_byte * 399 value_contents_all_raw (struct value *value) 400 { 401 allocate_value_contents (value); 402 return value->contents; 403 } 404 405 struct type * 406 value_enclosing_type (struct value *value) 407 { 408 return value->enclosing_type; 409 } 410 411 const gdb_byte * 412 value_contents_all (struct value *value) 413 { 414 if (value->lazy) 415 value_fetch_lazy (value); 416 return value->contents; 417 } 418 419 int 420 value_lazy (struct value *value) 421 { 422 return value->lazy; 423 } 424 425 void 426 set_value_lazy (struct value *value, int val) 427 { 428 value->lazy = val; 429 } 430 431 int 432 value_stack (struct value *value) 433 { 434 return value->stack; 435 } 436 437 void 438 set_value_stack (struct value *value, int val) 439 { 440 value->stack = val; 441 } 442 443 const gdb_byte * 444 value_contents (struct value *value) 445 { 446 return value_contents_writeable (value); 447 } 448 449 gdb_byte * 450 value_contents_writeable (struct value *value) 451 { 452 if (value->lazy) 453 value_fetch_lazy (value); 454 return value_contents_raw (value); 455 } 456 457 /* Return non-zero if VAL1 and VAL2 have the same contents. Note that 458 this function is different from value_equal; in C the operator == 459 can return 0 even if the two values being compared are equal. */ 460 461 int 462 value_contents_equal (struct value *val1, struct value *val2) 463 { 464 struct type *type1; 465 struct type *type2; 466 int len; 467 468 type1 = check_typedef (value_type (val1)); 469 type2 = check_typedef (value_type (val2)); 470 len = TYPE_LENGTH (type1); 471 if (len != TYPE_LENGTH (type2)) 472 return 0; 473 474 return (memcmp (value_contents (val1), value_contents (val2), len) == 0); 475 } 476 477 int 478 value_optimized_out (struct value *value) 479 { 480 return value->optimized_out; 481 } 482 483 void 484 set_value_optimized_out (struct value *value, int val) 485 { 486 value->optimized_out = val; 487 } 488 489 int 490 value_embedded_offset (struct value *value) 491 { 492 return value->embedded_offset; 493 } 494 495 void 496 set_value_embedded_offset (struct value *value, int val) 497 { 498 value->embedded_offset = val; 499 } 500 501 int 502 value_pointed_to_offset (struct value *value) 503 { 504 return value->pointed_to_offset; 505 } 506 507 void 508 set_value_pointed_to_offset (struct value *value, int val) 509 { 510 value->pointed_to_offset = val; 511 } 512 513 struct lval_funcs * 514 value_computed_funcs (struct value *v) 515 { 516 gdb_assert (VALUE_LVAL (v) == lval_computed); 517 518 return v->location.computed.funcs; 519 } 520 521 void * 522 value_computed_closure (struct value *v) 523 { 524 gdb_assert (VALUE_LVAL (v) == lval_computed); 525 526 return v->location.computed.closure; 527 } 528 529 enum lval_type * 530 deprecated_value_lval_hack (struct value *value) 531 { 532 return &value->lval; 533 } 534 535 CORE_ADDR 536 value_address (struct value *value) 537 { 538 if (value->lval == lval_internalvar 539 || value->lval == lval_internalvar_component) 540 return 0; 541 return value->location.address + value->offset; 542 } 543 544 CORE_ADDR 545 value_raw_address (struct value *value) 546 { 547 if (value->lval == lval_internalvar 548 || value->lval == lval_internalvar_component) 549 return 0; 550 return value->location.address; 551 } 552 553 void 554 set_value_address (struct value *value, CORE_ADDR addr) 555 { 556 gdb_assert (value->lval != lval_internalvar 557 && value->lval != lval_internalvar_component); 558 value->location.address = addr; 559 } 560 561 struct internalvar ** 562 deprecated_value_internalvar_hack (struct value *value) 563 { 564 return &value->location.internalvar; 565 } 566 567 struct frame_id * 568 deprecated_value_frame_id_hack (struct value *value) 569 { 570 return &value->frame_id; 571 } 572 573 short * 574 deprecated_value_regnum_hack (struct value *value) 575 { 576 return &value->regnum; 577 } 578 579 int 580 deprecated_value_modifiable (struct value *value) 581 { 582 return value->modifiable; 583 } 584 void 585 deprecated_set_value_modifiable (struct value *value, int modifiable) 586 { 587 value->modifiable = modifiable; 588 } 589 590 /* Return a mark in the value chain. All values allocated after the 591 mark is obtained (except for those released) are subject to being freed 592 if a subsequent value_free_to_mark is passed the mark. */ 593 struct value * 594 value_mark (void) 595 { 596 return all_values; 597 } 598 599 /* Take a reference to VAL. VAL will not be deallocated until all 600 references are released. */ 601 602 void 603 value_incref (struct value *val) 604 { 605 val->reference_count++; 606 } 607 608 /* Release a reference to VAL, which was acquired with value_incref. 609 This function is also called to deallocate values from the value 610 chain. */ 611 612 void 613 value_free (struct value *val) 614 { 615 if (val) 616 { 617 gdb_assert (val->reference_count > 0); 618 val->reference_count--; 619 if (val->reference_count > 0) 620 return; 621 622 /* If there's an associated parent value, drop our reference to 623 it. */ 624 if (val->parent != NULL) 625 value_free (val->parent); 626 627 if (VALUE_LVAL (val) == lval_computed) 628 { 629 struct lval_funcs *funcs = val->location.computed.funcs; 630 631 if (funcs->free_closure) 632 funcs->free_closure (val); 633 } 634 635 xfree (val->contents); 636 } 637 xfree (val); 638 } 639 640 /* Free all values allocated since MARK was obtained by value_mark 641 (except for those released). */ 642 void 643 value_free_to_mark (struct value *mark) 644 { 645 struct value *val; 646 struct value *next; 647 648 for (val = all_values; val && val != mark; val = next) 649 { 650 next = val->next; 651 value_free (val); 652 } 653 all_values = val; 654 } 655 656 /* Free all the values that have been allocated (except for those released). 657 Call after each command, successful or not. 658 In practice this is called before each command, which is sufficient. */ 659 660 void 661 free_all_values (void) 662 { 663 struct value *val; 664 struct value *next; 665 666 for (val = all_values; val; val = next) 667 { 668 next = val->next; 669 value_free (val); 670 } 671 672 all_values = 0; 673 } 674 675 /* Remove VAL from the chain all_values 676 so it will not be freed automatically. */ 677 678 void 679 release_value (struct value *val) 680 { 681 struct value *v; 682 683 if (all_values == val) 684 { 685 all_values = val->next; 686 return; 687 } 688 689 for (v = all_values; v; v = v->next) 690 { 691 if (v->next == val) 692 { 693 v->next = val->next; 694 break; 695 } 696 } 697 } 698 699 /* Release all values up to mark */ 700 struct value * 701 value_release_to_mark (struct value *mark) 702 { 703 struct value *val; 704 struct value *next; 705 706 for (val = next = all_values; next; next = next->next) 707 if (next->next == mark) 708 { 709 all_values = next->next; 710 next->next = NULL; 711 return val; 712 } 713 all_values = 0; 714 return val; 715 } 716 717 /* Return a copy of the value ARG. 718 It contains the same contents, for same memory address, 719 but it's a different block of storage. */ 720 721 struct value * 722 value_copy (struct value *arg) 723 { 724 struct type *encl_type = value_enclosing_type (arg); 725 struct value *val; 726 727 if (value_lazy (arg)) 728 val = allocate_value_lazy (encl_type); 729 else 730 val = allocate_value (encl_type); 731 val->type = arg->type; 732 VALUE_LVAL (val) = VALUE_LVAL (arg); 733 val->location = arg->location; 734 val->offset = arg->offset; 735 val->bitpos = arg->bitpos; 736 val->bitsize = arg->bitsize; 737 VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg); 738 VALUE_REGNUM (val) = VALUE_REGNUM (arg); 739 val->lazy = arg->lazy; 740 val->optimized_out = arg->optimized_out; 741 val->embedded_offset = value_embedded_offset (arg); 742 val->pointed_to_offset = arg->pointed_to_offset; 743 val->modifiable = arg->modifiable; 744 if (!value_lazy (val)) 745 { 746 memcpy (value_contents_all_raw (val), value_contents_all_raw (arg), 747 TYPE_LENGTH (value_enclosing_type (arg))); 748 749 } 750 val->parent = arg->parent; 751 if (val->parent) 752 value_incref (val->parent); 753 if (VALUE_LVAL (val) == lval_computed) 754 { 755 struct lval_funcs *funcs = val->location.computed.funcs; 756 757 if (funcs->copy_closure) 758 val->location.computed.closure = funcs->copy_closure (val); 759 } 760 return val; 761 } 762 763 void 764 set_value_component_location (struct value *component, struct value *whole) 765 { 766 if (VALUE_LVAL (whole) == lval_internalvar) 767 VALUE_LVAL (component) = lval_internalvar_component; 768 else 769 VALUE_LVAL (component) = VALUE_LVAL (whole); 770 771 component->location = whole->location; 772 if (VALUE_LVAL (whole) == lval_computed) 773 { 774 struct lval_funcs *funcs = whole->location.computed.funcs; 775 776 if (funcs->copy_closure) 777 component->location.computed.closure = funcs->copy_closure (whole); 778 } 779 } 780 781 782 /* Access to the value history. */ 783 784 /* Record a new value in the value history. 785 Returns the absolute history index of the entry. 786 Result of -1 indicates the value was not saved; otherwise it is the 787 value history index of this new item. */ 788 789 int 790 record_latest_value (struct value *val) 791 { 792 int i; 793 794 /* We don't want this value to have anything to do with the inferior anymore. 795 In particular, "set $1 = 50" should not affect the variable from which 796 the value was taken, and fast watchpoints should be able to assume that 797 a value on the value history never changes. */ 798 if (value_lazy (val)) 799 value_fetch_lazy (val); 800 /* We preserve VALUE_LVAL so that the user can find out where it was fetched 801 from. This is a bit dubious, because then *&$1 does not just return $1 802 but the current contents of that location. c'est la vie... */ 803 val->modifiable = 0; 804 release_value (val); 805 806 /* Here we treat value_history_count as origin-zero 807 and applying to the value being stored now. */ 808 809 i = value_history_count % VALUE_HISTORY_CHUNK; 810 if (i == 0) 811 { 812 struct value_history_chunk *new 813 = (struct value_history_chunk *) 814 xmalloc (sizeof (struct value_history_chunk)); 815 memset (new->values, 0, sizeof new->values); 816 new->next = value_history_chain; 817 value_history_chain = new; 818 } 819 820 value_history_chain->values[i] = val; 821 822 /* Now we regard value_history_count as origin-one 823 and applying to the value just stored. */ 824 825 return ++value_history_count; 826 } 827 828 /* Return a copy of the value in the history with sequence number NUM. */ 829 830 struct value * 831 access_value_history (int num) 832 { 833 struct value_history_chunk *chunk; 834 int i; 835 int absnum = num; 836 837 if (absnum <= 0) 838 absnum += value_history_count; 839 840 if (absnum <= 0) 841 { 842 if (num == 0) 843 error (_("The history is empty.")); 844 else if (num == 1) 845 error (_("There is only one value in the history.")); 846 else 847 error (_("History does not go back to $$%d."), -num); 848 } 849 if (absnum > value_history_count) 850 error (_("History has not yet reached $%d."), absnum); 851 852 absnum--; 853 854 /* Now absnum is always absolute and origin zero. */ 855 856 chunk = value_history_chain; 857 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK; 858 i > 0; i--) 859 chunk = chunk->next; 860 861 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]); 862 } 863 864 static void 865 show_values (char *num_exp, int from_tty) 866 { 867 int i; 868 struct value *val; 869 static int num = 1; 870 871 if (num_exp) 872 { 873 /* "show values +" should print from the stored position. 874 "show values <exp>" should print around value number <exp>. */ 875 if (num_exp[0] != '+' || num_exp[1] != '\0') 876 num = parse_and_eval_long (num_exp) - 5; 877 } 878 else 879 { 880 /* "show values" means print the last 10 values. */ 881 num = value_history_count - 9; 882 } 883 884 if (num <= 0) 885 num = 1; 886 887 for (i = num; i < num + 10 && i <= value_history_count; i++) 888 { 889 struct value_print_options opts; 890 val = access_value_history (i); 891 printf_filtered (("$%d = "), i); 892 get_user_print_options (&opts); 893 value_print (val, gdb_stdout, &opts); 894 printf_filtered (("\n")); 895 } 896 897 /* The next "show values +" should start after what we just printed. */ 898 num += 10; 899 900 /* Hitting just return after this command should do the same thing as 901 "show values +". If num_exp is null, this is unnecessary, since 902 "show values +" is not useful after "show values". */ 903 if (from_tty && num_exp) 904 { 905 num_exp[0] = '+'; 906 num_exp[1] = '\0'; 907 } 908 } 909 910 /* Internal variables. These are variables within the debugger 911 that hold values assigned by debugger commands. 912 The user refers to them with a '$' prefix 913 that does not appear in the variable names stored internally. */ 914 915 struct internalvar 916 { 917 struct internalvar *next; 918 char *name; 919 920 /* We support various different kinds of content of an internal variable. 921 enum internalvar_kind specifies the kind, and union internalvar_data 922 provides the data associated with this particular kind. */ 923 924 enum internalvar_kind 925 { 926 /* The internal variable is empty. */ 927 INTERNALVAR_VOID, 928 929 /* The value of the internal variable is provided directly as 930 a GDB value object. */ 931 INTERNALVAR_VALUE, 932 933 /* A fresh value is computed via a call-back routine on every 934 access to the internal variable. */ 935 INTERNALVAR_MAKE_VALUE, 936 937 /* The internal variable holds a GDB internal convenience function. */ 938 INTERNALVAR_FUNCTION, 939 940 /* The variable holds an integer value. */ 941 INTERNALVAR_INTEGER, 942 943 /* The variable holds a pointer value. */ 944 INTERNALVAR_POINTER, 945 946 /* The variable holds a GDB-provided string. */ 947 INTERNALVAR_STRING, 948 949 } kind; 950 951 union internalvar_data 952 { 953 /* A value object used with INTERNALVAR_VALUE. */ 954 struct value *value; 955 956 /* The call-back routine used with INTERNALVAR_MAKE_VALUE. */ 957 internalvar_make_value make_value; 958 959 /* The internal function used with INTERNALVAR_FUNCTION. */ 960 struct 961 { 962 struct internal_function *function; 963 /* True if this is the canonical name for the function. */ 964 int canonical; 965 } fn; 966 967 /* An integer value used with INTERNALVAR_INTEGER. */ 968 struct 969 { 970 /* If type is non-NULL, it will be used as the type to generate 971 a value for this internal variable. If type is NULL, a default 972 integer type for the architecture is used. */ 973 struct type *type; 974 LONGEST val; 975 } integer; 976 977 /* A pointer value used with INTERNALVAR_POINTER. */ 978 struct 979 { 980 struct type *type; 981 CORE_ADDR val; 982 } pointer; 983 984 /* A string value used with INTERNALVAR_STRING. */ 985 char *string; 986 } u; 987 }; 988 989 static struct internalvar *internalvars; 990 991 /* If the variable does not already exist create it and give it the value given. 992 If no value is given then the default is zero. */ 993 static void 994 init_if_undefined_command (char* args, int from_tty) 995 { 996 struct internalvar* intvar; 997 998 /* Parse the expression - this is taken from set_command(). */ 999 struct expression *expr = parse_expression (args); 1000 register struct cleanup *old_chain = 1001 make_cleanup (free_current_contents, &expr); 1002 1003 /* Validate the expression. 1004 Was the expression an assignment? 1005 Or even an expression at all? */ 1006 if (expr->nelts == 0 || expr->elts[0].opcode != BINOP_ASSIGN) 1007 error (_("Init-if-undefined requires an assignment expression.")); 1008 1009 /* Extract the variable from the parsed expression. 1010 In the case of an assign the lvalue will be in elts[1] and elts[2]. */ 1011 if (expr->elts[1].opcode != OP_INTERNALVAR) 1012 error (_("The first parameter to init-if-undefined should be a GDB variable.")); 1013 intvar = expr->elts[2].internalvar; 1014 1015 /* Only evaluate the expression if the lvalue is void. 1016 This may still fail if the expresssion is invalid. */ 1017 if (intvar->kind == INTERNALVAR_VOID) 1018 evaluate_expression (expr); 1019 1020 do_cleanups (old_chain); 1021 } 1022 1023 1024 /* Look up an internal variable with name NAME. NAME should not 1025 normally include a dollar sign. 1026 1027 If the specified internal variable does not exist, 1028 the return value is NULL. */ 1029 1030 struct internalvar * 1031 lookup_only_internalvar (const char *name) 1032 { 1033 struct internalvar *var; 1034 1035 for (var = internalvars; var; var = var->next) 1036 if (strcmp (var->name, name) == 0) 1037 return var; 1038 1039 return NULL; 1040 } 1041 1042 1043 /* Create an internal variable with name NAME and with a void value. 1044 NAME should not normally include a dollar sign. */ 1045 1046 struct internalvar * 1047 create_internalvar (const char *name) 1048 { 1049 struct internalvar *var; 1050 var = (struct internalvar *) xmalloc (sizeof (struct internalvar)); 1051 var->name = concat (name, (char *)NULL); 1052 var->kind = INTERNALVAR_VOID; 1053 var->next = internalvars; 1054 internalvars = var; 1055 return var; 1056 } 1057 1058 /* Create an internal variable with name NAME and register FUN as the 1059 function that value_of_internalvar uses to create a value whenever 1060 this variable is referenced. NAME should not normally include a 1061 dollar sign. */ 1062 1063 struct internalvar * 1064 create_internalvar_type_lazy (char *name, internalvar_make_value fun) 1065 { 1066 struct internalvar *var = create_internalvar (name); 1067 var->kind = INTERNALVAR_MAKE_VALUE; 1068 var->u.make_value = fun; 1069 return var; 1070 } 1071 1072 /* Look up an internal variable with name NAME. NAME should not 1073 normally include a dollar sign. 1074 1075 If the specified internal variable does not exist, 1076 one is created, with a void value. */ 1077 1078 struct internalvar * 1079 lookup_internalvar (const char *name) 1080 { 1081 struct internalvar *var; 1082 1083 var = lookup_only_internalvar (name); 1084 if (var) 1085 return var; 1086 1087 return create_internalvar (name); 1088 } 1089 1090 /* Return current value of internal variable VAR. For variables that 1091 are not inherently typed, use a value type appropriate for GDBARCH. */ 1092 1093 struct value * 1094 value_of_internalvar (struct gdbarch *gdbarch, struct internalvar *var) 1095 { 1096 struct value *val; 1097 1098 switch (var->kind) 1099 { 1100 case INTERNALVAR_VOID: 1101 val = allocate_value (builtin_type (gdbarch)->builtin_void); 1102 break; 1103 1104 case INTERNALVAR_FUNCTION: 1105 val = allocate_value (builtin_type (gdbarch)->internal_fn); 1106 break; 1107 1108 case INTERNALVAR_INTEGER: 1109 if (!var->u.integer.type) 1110 val = value_from_longest (builtin_type (gdbarch)->builtin_int, 1111 var->u.integer.val); 1112 else 1113 val = value_from_longest (var->u.integer.type, var->u.integer.val); 1114 break; 1115 1116 case INTERNALVAR_POINTER: 1117 val = value_from_pointer (var->u.pointer.type, var->u.pointer.val); 1118 break; 1119 1120 case INTERNALVAR_STRING: 1121 val = value_cstring (var->u.string, strlen (var->u.string), 1122 builtin_type (gdbarch)->builtin_char); 1123 break; 1124 1125 case INTERNALVAR_VALUE: 1126 val = value_copy (var->u.value); 1127 if (value_lazy (val)) 1128 value_fetch_lazy (val); 1129 break; 1130 1131 case INTERNALVAR_MAKE_VALUE: 1132 val = (*var->u.make_value) (gdbarch, var); 1133 break; 1134 1135 default: 1136 internal_error (__FILE__, __LINE__, "bad kind"); 1137 } 1138 1139 /* Change the VALUE_LVAL to lval_internalvar so that future operations 1140 on this value go back to affect the original internal variable. 1141 1142 Do not do this for INTERNALVAR_MAKE_VALUE variables, as those have 1143 no underlying modifyable state in the internal variable. 1144 1145 Likewise, if the variable's value is a computed lvalue, we want 1146 references to it to produce another computed lvalue, where 1147 references and assignments actually operate through the 1148 computed value's functions. 1149 1150 This means that internal variables with computed values 1151 behave a little differently from other internal variables: 1152 assignments to them don't just replace the previous value 1153 altogether. At the moment, this seems like the behavior we 1154 want. */ 1155 1156 if (var->kind != INTERNALVAR_MAKE_VALUE 1157 && val->lval != lval_computed) 1158 { 1159 VALUE_LVAL (val) = lval_internalvar; 1160 VALUE_INTERNALVAR (val) = var; 1161 } 1162 1163 return val; 1164 } 1165 1166 int 1167 get_internalvar_integer (struct internalvar *var, LONGEST *result) 1168 { 1169 switch (var->kind) 1170 { 1171 case INTERNALVAR_INTEGER: 1172 *result = var->u.integer.val; 1173 return 1; 1174 1175 default: 1176 return 0; 1177 } 1178 } 1179 1180 static int 1181 get_internalvar_function (struct internalvar *var, 1182 struct internal_function **result) 1183 { 1184 switch (var->kind) 1185 { 1186 case INTERNALVAR_FUNCTION: 1187 *result = var->u.fn.function; 1188 return 1; 1189 1190 default: 1191 return 0; 1192 } 1193 } 1194 1195 void 1196 set_internalvar_component (struct internalvar *var, int offset, int bitpos, 1197 int bitsize, struct value *newval) 1198 { 1199 gdb_byte *addr; 1200 1201 switch (var->kind) 1202 { 1203 case INTERNALVAR_VALUE: 1204 addr = value_contents_writeable (var->u.value); 1205 1206 if (bitsize) 1207 modify_field (value_type (var->u.value), addr + offset, 1208 value_as_long (newval), bitpos, bitsize); 1209 else 1210 memcpy (addr + offset, value_contents (newval), 1211 TYPE_LENGTH (value_type (newval))); 1212 break; 1213 1214 default: 1215 /* We can never get a component of any other kind. */ 1216 internal_error (__FILE__, __LINE__, "set_internalvar_component"); 1217 } 1218 } 1219 1220 void 1221 set_internalvar (struct internalvar *var, struct value *val) 1222 { 1223 enum internalvar_kind new_kind; 1224 union internalvar_data new_data = { 0 }; 1225 1226 if (var->kind == INTERNALVAR_FUNCTION && var->u.fn.canonical) 1227 error (_("Cannot overwrite convenience function %s"), var->name); 1228 1229 /* Prepare new contents. */ 1230 switch (TYPE_CODE (check_typedef (value_type (val)))) 1231 { 1232 case TYPE_CODE_VOID: 1233 new_kind = INTERNALVAR_VOID; 1234 break; 1235 1236 case TYPE_CODE_INTERNAL_FUNCTION: 1237 gdb_assert (VALUE_LVAL (val) == lval_internalvar); 1238 new_kind = INTERNALVAR_FUNCTION; 1239 get_internalvar_function (VALUE_INTERNALVAR (val), 1240 &new_data.fn.function); 1241 /* Copies created here are never canonical. */ 1242 break; 1243 1244 case TYPE_CODE_INT: 1245 new_kind = INTERNALVAR_INTEGER; 1246 new_data.integer.type = value_type (val); 1247 new_data.integer.val = value_as_long (val); 1248 break; 1249 1250 case TYPE_CODE_PTR: 1251 new_kind = INTERNALVAR_POINTER; 1252 new_data.pointer.type = value_type (val); 1253 new_data.pointer.val = value_as_address (val); 1254 break; 1255 1256 default: 1257 new_kind = INTERNALVAR_VALUE; 1258 new_data.value = value_copy (val); 1259 new_data.value->modifiable = 1; 1260 1261 /* Force the value to be fetched from the target now, to avoid problems 1262 later when this internalvar is referenced and the target is gone or 1263 has changed. */ 1264 if (value_lazy (new_data.value)) 1265 value_fetch_lazy (new_data.value); 1266 1267 /* Release the value from the value chain to prevent it from being 1268 deleted by free_all_values. From here on this function should not 1269 call error () until new_data is installed into the var->u to avoid 1270 leaking memory. */ 1271 release_value (new_data.value); 1272 break; 1273 } 1274 1275 /* Clean up old contents. */ 1276 clear_internalvar (var); 1277 1278 /* Switch over. */ 1279 var->kind = new_kind; 1280 var->u = new_data; 1281 /* End code which must not call error(). */ 1282 } 1283 1284 void 1285 set_internalvar_integer (struct internalvar *var, LONGEST l) 1286 { 1287 /* Clean up old contents. */ 1288 clear_internalvar (var); 1289 1290 var->kind = INTERNALVAR_INTEGER; 1291 var->u.integer.type = NULL; 1292 var->u.integer.val = l; 1293 } 1294 1295 void 1296 set_internalvar_string (struct internalvar *var, const char *string) 1297 { 1298 /* Clean up old contents. */ 1299 clear_internalvar (var); 1300 1301 var->kind = INTERNALVAR_STRING; 1302 var->u.string = xstrdup (string); 1303 } 1304 1305 static void 1306 set_internalvar_function (struct internalvar *var, struct internal_function *f) 1307 { 1308 /* Clean up old contents. */ 1309 clear_internalvar (var); 1310 1311 var->kind = INTERNALVAR_FUNCTION; 1312 var->u.fn.function = f; 1313 var->u.fn.canonical = 1; 1314 /* Variables installed here are always the canonical version. */ 1315 } 1316 1317 void 1318 clear_internalvar (struct internalvar *var) 1319 { 1320 /* Clean up old contents. */ 1321 switch (var->kind) 1322 { 1323 case INTERNALVAR_VALUE: 1324 value_free (var->u.value); 1325 break; 1326 1327 case INTERNALVAR_STRING: 1328 xfree (var->u.string); 1329 break; 1330 1331 default: 1332 break; 1333 } 1334 1335 /* Reset to void kind. */ 1336 var->kind = INTERNALVAR_VOID; 1337 } 1338 1339 char * 1340 internalvar_name (struct internalvar *var) 1341 { 1342 return var->name; 1343 } 1344 1345 static struct internal_function * 1346 create_internal_function (const char *name, 1347 internal_function_fn handler, void *cookie) 1348 { 1349 struct internal_function *ifn = XNEW (struct internal_function); 1350 ifn->name = xstrdup (name); 1351 ifn->handler = handler; 1352 ifn->cookie = cookie; 1353 return ifn; 1354 } 1355 1356 char * 1357 value_internal_function_name (struct value *val) 1358 { 1359 struct internal_function *ifn; 1360 int result; 1361 1362 gdb_assert (VALUE_LVAL (val) == lval_internalvar); 1363 result = get_internalvar_function (VALUE_INTERNALVAR (val), &ifn); 1364 gdb_assert (result); 1365 1366 return ifn->name; 1367 } 1368 1369 struct value * 1370 call_internal_function (struct gdbarch *gdbarch, 1371 const struct language_defn *language, 1372 struct value *func, int argc, struct value **argv) 1373 { 1374 struct internal_function *ifn; 1375 int result; 1376 1377 gdb_assert (VALUE_LVAL (func) == lval_internalvar); 1378 result = get_internalvar_function (VALUE_INTERNALVAR (func), &ifn); 1379 gdb_assert (result); 1380 1381 return (*ifn->handler) (gdbarch, language, ifn->cookie, argc, argv); 1382 } 1383 1384 /* The 'function' command. This does nothing -- it is just a 1385 placeholder to let "help function NAME" work. This is also used as 1386 the implementation of the sub-command that is created when 1387 registering an internal function. */ 1388 static void 1389 function_command (char *command, int from_tty) 1390 { 1391 /* Do nothing. */ 1392 } 1393 1394 /* Clean up if an internal function's command is destroyed. */ 1395 static void 1396 function_destroyer (struct cmd_list_element *self, void *ignore) 1397 { 1398 xfree (self->name); 1399 xfree (self->doc); 1400 } 1401 1402 /* Add a new internal function. NAME is the name of the function; DOC 1403 is a documentation string describing the function. HANDLER is 1404 called when the function is invoked. COOKIE is an arbitrary 1405 pointer which is passed to HANDLER and is intended for "user 1406 data". */ 1407 void 1408 add_internal_function (const char *name, const char *doc, 1409 internal_function_fn handler, void *cookie) 1410 { 1411 struct cmd_list_element *cmd; 1412 struct internal_function *ifn; 1413 struct internalvar *var = lookup_internalvar (name); 1414 1415 ifn = create_internal_function (name, handler, cookie); 1416 set_internalvar_function (var, ifn); 1417 1418 cmd = add_cmd (xstrdup (name), no_class, function_command, (char *) doc, 1419 &functionlist); 1420 cmd->destroyer = function_destroyer; 1421 } 1422 1423 /* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to 1424 prevent cycles / duplicates. */ 1425 1426 void 1427 preserve_one_value (struct value *value, struct objfile *objfile, 1428 htab_t copied_types) 1429 { 1430 if (TYPE_OBJFILE (value->type) == objfile) 1431 value->type = copy_type_recursive (objfile, value->type, copied_types); 1432 1433 if (TYPE_OBJFILE (value->enclosing_type) == objfile) 1434 value->enclosing_type = copy_type_recursive (objfile, 1435 value->enclosing_type, 1436 copied_types); 1437 } 1438 1439 /* Likewise for internal variable VAR. */ 1440 1441 static void 1442 preserve_one_internalvar (struct internalvar *var, struct objfile *objfile, 1443 htab_t copied_types) 1444 { 1445 switch (var->kind) 1446 { 1447 case INTERNALVAR_INTEGER: 1448 if (var->u.integer.type && TYPE_OBJFILE (var->u.integer.type) == objfile) 1449 var->u.integer.type 1450 = copy_type_recursive (objfile, var->u.integer.type, copied_types); 1451 break; 1452 1453 case INTERNALVAR_POINTER: 1454 if (TYPE_OBJFILE (var->u.pointer.type) == objfile) 1455 var->u.pointer.type 1456 = copy_type_recursive (objfile, var->u.pointer.type, copied_types); 1457 break; 1458 1459 case INTERNALVAR_VALUE: 1460 preserve_one_value (var->u.value, objfile, copied_types); 1461 break; 1462 } 1463 } 1464 1465 /* Update the internal variables and value history when OBJFILE is 1466 discarded; we must copy the types out of the objfile. New global types 1467 will be created for every convenience variable which currently points to 1468 this objfile's types, and the convenience variables will be adjusted to 1469 use the new global types. */ 1470 1471 void 1472 preserve_values (struct objfile *objfile) 1473 { 1474 htab_t copied_types; 1475 struct value_history_chunk *cur; 1476 struct internalvar *var; 1477 struct value *val; 1478 int i; 1479 1480 /* Create the hash table. We allocate on the objfile's obstack, since 1481 it is soon to be deleted. */ 1482 copied_types = create_copied_types_hash (objfile); 1483 1484 for (cur = value_history_chain; cur; cur = cur->next) 1485 for (i = 0; i < VALUE_HISTORY_CHUNK; i++) 1486 if (cur->values[i]) 1487 preserve_one_value (cur->values[i], objfile, copied_types); 1488 1489 for (var = internalvars; var; var = var->next) 1490 preserve_one_internalvar (var, objfile, copied_types); 1491 1492 preserve_python_values (objfile, copied_types); 1493 1494 htab_delete (copied_types); 1495 } 1496 1497 static void 1498 show_convenience (char *ignore, int from_tty) 1499 { 1500 struct gdbarch *gdbarch = get_current_arch (); 1501 struct internalvar *var; 1502 int varseen = 0; 1503 struct value_print_options opts; 1504 1505 get_user_print_options (&opts); 1506 for (var = internalvars; var; var = var->next) 1507 { 1508 if (!varseen) 1509 { 1510 varseen = 1; 1511 } 1512 printf_filtered (("$%s = "), var->name); 1513 value_print (value_of_internalvar (gdbarch, var), gdb_stdout, 1514 &opts); 1515 printf_filtered (("\n")); 1516 } 1517 if (!varseen) 1518 printf_unfiltered (_("\ 1519 No debugger convenience variables now defined.\n\ 1520 Convenience variables have names starting with \"$\";\n\ 1521 use \"set\" as in \"set $foo = 5\" to define them.\n")); 1522 } 1523 1524 /* Extract a value as a C number (either long or double). 1525 Knows how to convert fixed values to double, or 1526 floating values to long. 1527 Does not deallocate the value. */ 1528 1529 LONGEST 1530 value_as_long (struct value *val) 1531 { 1532 /* This coerces arrays and functions, which is necessary (e.g. 1533 in disassemble_command). It also dereferences references, which 1534 I suspect is the most logical thing to do. */ 1535 val = coerce_array (val); 1536 return unpack_long (value_type (val), value_contents (val)); 1537 } 1538 1539 DOUBLEST 1540 value_as_double (struct value *val) 1541 { 1542 DOUBLEST foo; 1543 int inv; 1544 1545 foo = unpack_double (value_type (val), value_contents (val), &inv); 1546 if (inv) 1547 error (_("Invalid floating value found in program.")); 1548 return foo; 1549 } 1550 1551 /* Extract a value as a C pointer. Does not deallocate the value. 1552 Note that val's type may not actually be a pointer; value_as_long 1553 handles all the cases. */ 1554 CORE_ADDR 1555 value_as_address (struct value *val) 1556 { 1557 struct gdbarch *gdbarch = get_type_arch (value_type (val)); 1558 1559 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 1560 whether we want this to be true eventually. */ 1561 #if 0 1562 /* gdbarch_addr_bits_remove is wrong if we are being called for a 1563 non-address (e.g. argument to "signal", "info break", etc.), or 1564 for pointers to char, in which the low bits *are* significant. */ 1565 return gdbarch_addr_bits_remove (gdbarch, value_as_long (val)); 1566 #else 1567 1568 /* There are several targets (IA-64, PowerPC, and others) which 1569 don't represent pointers to functions as simply the address of 1570 the function's entry point. For example, on the IA-64, a 1571 function pointer points to a two-word descriptor, generated by 1572 the linker, which contains the function's entry point, and the 1573 value the IA-64 "global pointer" register should have --- to 1574 support position-independent code. The linker generates 1575 descriptors only for those functions whose addresses are taken. 1576 1577 On such targets, it's difficult for GDB to convert an arbitrary 1578 function address into a function pointer; it has to either find 1579 an existing descriptor for that function, or call malloc and 1580 build its own. On some targets, it is impossible for GDB to 1581 build a descriptor at all: the descriptor must contain a jump 1582 instruction; data memory cannot be executed; and code memory 1583 cannot be modified. 1584 1585 Upon entry to this function, if VAL is a value of type `function' 1586 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then 1587 value_address (val) is the address of the function. This is what 1588 you'll get if you evaluate an expression like `main'. The call 1589 to COERCE_ARRAY below actually does all the usual unary 1590 conversions, which includes converting values of type `function' 1591 to `pointer to function'. This is the challenging conversion 1592 discussed above. Then, `unpack_long' will convert that pointer 1593 back into an address. 1594 1595 So, suppose the user types `disassemble foo' on an architecture 1596 with a strange function pointer representation, on which GDB 1597 cannot build its own descriptors, and suppose further that `foo' 1598 has no linker-built descriptor. The address->pointer conversion 1599 will signal an error and prevent the command from running, even 1600 though the next step would have been to convert the pointer 1601 directly back into the same address. 1602 1603 The following shortcut avoids this whole mess. If VAL is a 1604 function, just return its address directly. */ 1605 if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC 1606 || TYPE_CODE (value_type (val)) == TYPE_CODE_METHOD) 1607 return value_address (val); 1608 1609 val = coerce_array (val); 1610 1611 /* Some architectures (e.g. Harvard), map instruction and data 1612 addresses onto a single large unified address space. For 1613 instance: An architecture may consider a large integer in the 1614 range 0x10000000 .. 0x1000ffff to already represent a data 1615 addresses (hence not need a pointer to address conversion) while 1616 a small integer would still need to be converted integer to 1617 pointer to address. Just assume such architectures handle all 1618 integer conversions in a single function. */ 1619 1620 /* JimB writes: 1621 1622 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we 1623 must admonish GDB hackers to make sure its behavior matches the 1624 compiler's, whenever possible. 1625 1626 In general, I think GDB should evaluate expressions the same way 1627 the compiler does. When the user copies an expression out of 1628 their source code and hands it to a `print' command, they should 1629 get the same value the compiler would have computed. Any 1630 deviation from this rule can cause major confusion and annoyance, 1631 and needs to be justified carefully. In other words, GDB doesn't 1632 really have the freedom to do these conversions in clever and 1633 useful ways. 1634 1635 AndrewC pointed out that users aren't complaining about how GDB 1636 casts integers to pointers; they are complaining that they can't 1637 take an address from a disassembly listing and give it to `x/i'. 1638 This is certainly important. 1639 1640 Adding an architecture method like integer_to_address() certainly 1641 makes it possible for GDB to "get it right" in all circumstances 1642 --- the target has complete control over how things get done, so 1643 people can Do The Right Thing for their target without breaking 1644 anyone else. The standard doesn't specify how integers get 1645 converted to pointers; usually, the ABI doesn't either, but 1646 ABI-specific code is a more reasonable place to handle it. */ 1647 1648 if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR 1649 && TYPE_CODE (value_type (val)) != TYPE_CODE_REF 1650 && gdbarch_integer_to_address_p (gdbarch)) 1651 return gdbarch_integer_to_address (gdbarch, value_type (val), 1652 value_contents (val)); 1653 1654 return unpack_long (value_type (val), value_contents (val)); 1655 #endif 1656 } 1657 1658 /* Unpack raw data (copied from debugee, target byte order) at VALADDR 1659 as a long, or as a double, assuming the raw data is described 1660 by type TYPE. Knows how to convert different sizes of values 1661 and can convert between fixed and floating point. We don't assume 1662 any alignment for the raw data. Return value is in host byte order. 1663 1664 If you want functions and arrays to be coerced to pointers, and 1665 references to be dereferenced, call value_as_long() instead. 1666 1667 C++: It is assumed that the front-end has taken care of 1668 all matters concerning pointers to members. A pointer 1669 to member which reaches here is considered to be equivalent 1670 to an INT (or some size). After all, it is only an offset. */ 1671 1672 LONGEST 1673 unpack_long (struct type *type, const gdb_byte *valaddr) 1674 { 1675 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 1676 enum type_code code = TYPE_CODE (type); 1677 int len = TYPE_LENGTH (type); 1678 int nosign = TYPE_UNSIGNED (type); 1679 1680 switch (code) 1681 { 1682 case TYPE_CODE_TYPEDEF: 1683 return unpack_long (check_typedef (type), valaddr); 1684 case TYPE_CODE_ENUM: 1685 case TYPE_CODE_FLAGS: 1686 case TYPE_CODE_BOOL: 1687 case TYPE_CODE_INT: 1688 case TYPE_CODE_CHAR: 1689 case TYPE_CODE_RANGE: 1690 case TYPE_CODE_MEMBERPTR: 1691 if (nosign) 1692 return extract_unsigned_integer (valaddr, len, byte_order); 1693 else 1694 return extract_signed_integer (valaddr, len, byte_order); 1695 1696 case TYPE_CODE_FLT: 1697 return extract_typed_floating (valaddr, type); 1698 1699 case TYPE_CODE_DECFLOAT: 1700 /* libdecnumber has a function to convert from decimal to integer, but 1701 it doesn't work when the decimal number has a fractional part. */ 1702 return decimal_to_doublest (valaddr, len, byte_order); 1703 1704 case TYPE_CODE_PTR: 1705 case TYPE_CODE_REF: 1706 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 1707 whether we want this to be true eventually. */ 1708 return extract_typed_address (valaddr, type); 1709 1710 default: 1711 error (_("Value can't be converted to integer.")); 1712 } 1713 return 0; /* Placate lint. */ 1714 } 1715 1716 /* Return a double value from the specified type and address. 1717 INVP points to an int which is set to 0 for valid value, 1718 1 for invalid value (bad float format). In either case, 1719 the returned double is OK to use. Argument is in target 1720 format, result is in host format. */ 1721 1722 DOUBLEST 1723 unpack_double (struct type *type, const gdb_byte *valaddr, int *invp) 1724 { 1725 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 1726 enum type_code code; 1727 int len; 1728 int nosign; 1729 1730 *invp = 0; /* Assume valid. */ 1731 CHECK_TYPEDEF (type); 1732 code = TYPE_CODE (type); 1733 len = TYPE_LENGTH (type); 1734 nosign = TYPE_UNSIGNED (type); 1735 if (code == TYPE_CODE_FLT) 1736 { 1737 /* NOTE: cagney/2002-02-19: There was a test here to see if the 1738 floating-point value was valid (using the macro 1739 INVALID_FLOAT). That test/macro have been removed. 1740 1741 It turns out that only the VAX defined this macro and then 1742 only in a non-portable way. Fixing the portability problem 1743 wouldn't help since the VAX floating-point code is also badly 1744 bit-rotten. The target needs to add definitions for the 1745 methods gdbarch_float_format and gdbarch_double_format - these 1746 exactly describe the target floating-point format. The 1747 problem here is that the corresponding floatformat_vax_f and 1748 floatformat_vax_d values these methods should be set to are 1749 also not defined either. Oops! 1750 1751 Hopefully someone will add both the missing floatformat 1752 definitions and the new cases for floatformat_is_valid (). */ 1753 1754 if (!floatformat_is_valid (floatformat_from_type (type), valaddr)) 1755 { 1756 *invp = 1; 1757 return 0.0; 1758 } 1759 1760 return extract_typed_floating (valaddr, type); 1761 } 1762 else if (code == TYPE_CODE_DECFLOAT) 1763 return decimal_to_doublest (valaddr, len, byte_order); 1764 else if (nosign) 1765 { 1766 /* Unsigned -- be sure we compensate for signed LONGEST. */ 1767 return (ULONGEST) unpack_long (type, valaddr); 1768 } 1769 else 1770 { 1771 /* Signed -- we are OK with unpack_long. */ 1772 return unpack_long (type, valaddr); 1773 } 1774 } 1775 1776 /* Unpack raw data (copied from debugee, target byte order) at VALADDR 1777 as a CORE_ADDR, assuming the raw data is described by type TYPE. 1778 We don't assume any alignment for the raw data. Return value is in 1779 host byte order. 1780 1781 If you want functions and arrays to be coerced to pointers, and 1782 references to be dereferenced, call value_as_address() instead. 1783 1784 C++: It is assumed that the front-end has taken care of 1785 all matters concerning pointers to members. A pointer 1786 to member which reaches here is considered to be equivalent 1787 to an INT (or some size). After all, it is only an offset. */ 1788 1789 CORE_ADDR 1790 unpack_pointer (struct type *type, const gdb_byte *valaddr) 1791 { 1792 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 1793 whether we want this to be true eventually. */ 1794 return unpack_long (type, valaddr); 1795 } 1796 1797 1798 /* Get the value of the FIELDN'th field (which must be static) of 1799 TYPE. Return NULL if the field doesn't exist or has been 1800 optimized out. */ 1801 1802 struct value * 1803 value_static_field (struct type *type, int fieldno) 1804 { 1805 struct value *retval; 1806 1807 if (TYPE_FIELD_LOC_KIND (type, fieldno) == FIELD_LOC_KIND_PHYSADDR) 1808 { 1809 retval = value_at (TYPE_FIELD_TYPE (type, fieldno), 1810 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno)); 1811 } 1812 else 1813 { 1814 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno); 1815 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0); 1816 if (sym == NULL) 1817 { 1818 /* With some compilers, e.g. HP aCC, static data members are reported 1819 as non-debuggable symbols */ 1820 struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL); 1821 if (!msym) 1822 return NULL; 1823 else 1824 { 1825 retval = value_at (TYPE_FIELD_TYPE (type, fieldno), 1826 SYMBOL_VALUE_ADDRESS (msym)); 1827 } 1828 } 1829 else 1830 { 1831 /* SYM should never have a SYMBOL_CLASS which will require 1832 read_var_value to use the FRAME parameter. */ 1833 if (symbol_read_needs_frame (sym)) 1834 warning (_("static field's value depends on the current " 1835 "frame - bad debug info?")); 1836 retval = read_var_value (sym, NULL); 1837 } 1838 if (retval && VALUE_LVAL (retval) == lval_memory) 1839 SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), 1840 value_address (retval)); 1841 } 1842 return retval; 1843 } 1844 1845 /* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE. 1846 You have to be careful here, since the size of the data area for the value 1847 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger 1848 than the old enclosing type, you have to allocate more space for the data. 1849 The return value is a pointer to the new version of this value structure. */ 1850 1851 struct value * 1852 value_change_enclosing_type (struct value *val, struct type *new_encl_type) 1853 { 1854 if (TYPE_LENGTH (new_encl_type) > TYPE_LENGTH (value_enclosing_type (val))) 1855 val->contents = 1856 (gdb_byte *) xrealloc (val->contents, TYPE_LENGTH (new_encl_type)); 1857 1858 val->enclosing_type = new_encl_type; 1859 return val; 1860 } 1861 1862 /* Given a value ARG1 (offset by OFFSET bytes) 1863 of a struct or union type ARG_TYPE, 1864 extract and return the value of one of its (non-static) fields. 1865 FIELDNO says which field. */ 1866 1867 struct value * 1868 value_primitive_field (struct value *arg1, int offset, 1869 int fieldno, struct type *arg_type) 1870 { 1871 struct value *v; 1872 struct type *type; 1873 1874 CHECK_TYPEDEF (arg_type); 1875 type = TYPE_FIELD_TYPE (arg_type, fieldno); 1876 1877 /* Handle packed fields */ 1878 1879 if (TYPE_FIELD_BITSIZE (arg_type, fieldno)) 1880 { 1881 /* Create a new value for the bitfield, with bitpos and bitsize 1882 set. If possible, arrange offset and bitpos so that we can 1883 do a single aligned read of the size of the containing type. 1884 Otherwise, adjust offset to the byte containing the first 1885 bit. Assume that the address, offset, and embedded offset 1886 are sufficiently aligned. */ 1887 int bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno); 1888 int container_bitsize = TYPE_LENGTH (type) * 8; 1889 1890 v = allocate_value_lazy (type); 1891 v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno); 1892 if ((bitpos % container_bitsize) + v->bitsize <= container_bitsize 1893 && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)) 1894 v->bitpos = bitpos % container_bitsize; 1895 else 1896 v->bitpos = bitpos % 8; 1897 v->offset = value_embedded_offset (arg1) 1898 + (bitpos - v->bitpos) / 8; 1899 v->parent = arg1; 1900 value_incref (v->parent); 1901 if (!value_lazy (arg1)) 1902 value_fetch_lazy (v); 1903 } 1904 else if (fieldno < TYPE_N_BASECLASSES (arg_type)) 1905 { 1906 /* This field is actually a base subobject, so preserve the 1907 entire object's contents for later references to virtual 1908 bases, etc. */ 1909 1910 /* Lazy register values with offsets are not supported. */ 1911 if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1)) 1912 value_fetch_lazy (arg1); 1913 1914 if (value_lazy (arg1)) 1915 v = allocate_value_lazy (value_enclosing_type (arg1)); 1916 else 1917 { 1918 v = allocate_value (value_enclosing_type (arg1)); 1919 memcpy (value_contents_all_raw (v), value_contents_all_raw (arg1), 1920 TYPE_LENGTH (value_enclosing_type (arg1))); 1921 } 1922 v->type = type; 1923 v->offset = value_offset (arg1); 1924 v->embedded_offset = (offset + value_embedded_offset (arg1) 1925 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8); 1926 } 1927 else 1928 { 1929 /* Plain old data member */ 1930 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; 1931 1932 /* Lazy register values with offsets are not supported. */ 1933 if (VALUE_LVAL (arg1) == lval_register && value_lazy (arg1)) 1934 value_fetch_lazy (arg1); 1935 1936 if (value_lazy (arg1)) 1937 v = allocate_value_lazy (type); 1938 else 1939 { 1940 v = allocate_value (type); 1941 memcpy (value_contents_raw (v), 1942 value_contents_raw (arg1) + offset, 1943 TYPE_LENGTH (type)); 1944 } 1945 v->offset = (value_offset (arg1) + offset 1946 + value_embedded_offset (arg1)); 1947 } 1948 set_value_component_location (v, arg1); 1949 VALUE_REGNUM (v) = VALUE_REGNUM (arg1); 1950 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1); 1951 return v; 1952 } 1953 1954 /* Given a value ARG1 of a struct or union type, 1955 extract and return the value of one of its (non-static) fields. 1956 FIELDNO says which field. */ 1957 1958 struct value * 1959 value_field (struct value *arg1, int fieldno) 1960 { 1961 return value_primitive_field (arg1, 0, fieldno, value_type (arg1)); 1962 } 1963 1964 /* Return a non-virtual function as a value. 1965 F is the list of member functions which contains the desired method. 1966 J is an index into F which provides the desired method. 1967 1968 We only use the symbol for its address, so be happy with either a 1969 full symbol or a minimal symbol. 1970 */ 1971 1972 struct value * 1973 value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type, 1974 int offset) 1975 { 1976 struct value *v; 1977 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); 1978 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); 1979 struct symbol *sym; 1980 struct minimal_symbol *msym; 1981 1982 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0); 1983 if (sym != NULL) 1984 { 1985 msym = NULL; 1986 } 1987 else 1988 { 1989 gdb_assert (sym == NULL); 1990 msym = lookup_minimal_symbol (physname, NULL, NULL); 1991 if (msym == NULL) 1992 return NULL; 1993 } 1994 1995 v = allocate_value (ftype); 1996 if (sym) 1997 { 1998 set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))); 1999 } 2000 else 2001 { 2002 /* The minimal symbol might point to a function descriptor; 2003 resolve it to the actual code address instead. */ 2004 struct objfile *objfile = msymbol_objfile (msym); 2005 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2006 2007 set_value_address (v, 2008 gdbarch_convert_from_func_ptr_addr 2009 (gdbarch, SYMBOL_VALUE_ADDRESS (msym), ¤t_target)); 2010 } 2011 2012 if (arg1p) 2013 { 2014 if (type != value_type (*arg1p)) 2015 *arg1p = value_ind (value_cast (lookup_pointer_type (type), 2016 value_addr (*arg1p))); 2017 2018 /* Move the `this' pointer according to the offset. 2019 VALUE_OFFSET (*arg1p) += offset; 2020 */ 2021 } 2022 2023 return v; 2024 } 2025 2026 2027 /* Unpack a bitfield of the specified FIELD_TYPE, from the anonymous 2028 object at VALADDR. The bitfield starts at BITPOS bits and contains 2029 BITSIZE bits. 2030 2031 Extracting bits depends on endianness of the machine. Compute the 2032 number of least significant bits to discard. For big endian machines, 2033 we compute the total number of bits in the anonymous object, subtract 2034 off the bit count from the MSB of the object to the MSB of the 2035 bitfield, then the size of the bitfield, which leaves the LSB discard 2036 count. For little endian machines, the discard count is simply the 2037 number of bits from the LSB of the anonymous object to the LSB of the 2038 bitfield. 2039 2040 If the field is signed, we also do sign extension. */ 2041 2042 LONGEST 2043 unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr, 2044 int bitpos, int bitsize) 2045 { 2046 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type)); 2047 ULONGEST val; 2048 ULONGEST valmask; 2049 int lsbcount; 2050 int bytes_read; 2051 2052 /* Read the minimum number of bytes required; there may not be 2053 enough bytes to read an entire ULONGEST. */ 2054 CHECK_TYPEDEF (field_type); 2055 if (bitsize) 2056 bytes_read = ((bitpos % 8) + bitsize + 7) / 8; 2057 else 2058 bytes_read = TYPE_LENGTH (field_type); 2059 2060 val = extract_unsigned_integer (valaddr + bitpos / 8, 2061 bytes_read, byte_order); 2062 2063 /* Extract bits. See comment above. */ 2064 2065 if (gdbarch_bits_big_endian (get_type_arch (field_type))) 2066 lsbcount = (bytes_read * 8 - bitpos % 8 - bitsize); 2067 else 2068 lsbcount = (bitpos % 8); 2069 val >>= lsbcount; 2070 2071 /* If the field does not entirely fill a LONGEST, then zero the sign bits. 2072 If the field is signed, and is negative, then sign extend. */ 2073 2074 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val))) 2075 { 2076 valmask = (((ULONGEST) 1) << bitsize) - 1; 2077 val &= valmask; 2078 if (!TYPE_UNSIGNED (field_type)) 2079 { 2080 if (val & (valmask ^ (valmask >> 1))) 2081 { 2082 val |= ~valmask; 2083 } 2084 } 2085 } 2086 return (val); 2087 } 2088 2089 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at 2090 VALADDR. See unpack_bits_as_long for more details. */ 2091 2092 LONGEST 2093 unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno) 2094 { 2095 int bitpos = TYPE_FIELD_BITPOS (type, fieldno); 2096 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); 2097 struct type *field_type = TYPE_FIELD_TYPE (type, fieldno); 2098 2099 return unpack_bits_as_long (field_type, valaddr, bitpos, bitsize); 2100 } 2101 2102 /* Modify the value of a bitfield. ADDR points to a block of memory in 2103 target byte order; the bitfield starts in the byte pointed to. FIELDVAL 2104 is the desired value of the field, in host byte order. BITPOS and BITSIZE 2105 indicate which bits (in target bit order) comprise the bitfield. 2106 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and 2107 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */ 2108 2109 void 2110 modify_field (struct type *type, gdb_byte *addr, 2111 LONGEST fieldval, int bitpos, int bitsize) 2112 { 2113 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 2114 ULONGEST oword; 2115 ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize); 2116 2117 /* If a negative fieldval fits in the field in question, chop 2118 off the sign extension bits. */ 2119 if ((~fieldval & ~(mask >> 1)) == 0) 2120 fieldval &= mask; 2121 2122 /* Warn if value is too big to fit in the field in question. */ 2123 if (0 != (fieldval & ~mask)) 2124 { 2125 /* FIXME: would like to include fieldval in the message, but 2126 we don't have a sprintf_longest. */ 2127 warning (_("Value does not fit in %d bits."), bitsize); 2128 2129 /* Truncate it, otherwise adjoining fields may be corrupted. */ 2130 fieldval &= mask; 2131 } 2132 2133 oword = extract_unsigned_integer (addr, sizeof oword, byte_order); 2134 2135 /* Shifting for bit field depends on endianness of the target machine. */ 2136 if (gdbarch_bits_big_endian (get_type_arch (type))) 2137 bitpos = sizeof (oword) * 8 - bitpos - bitsize; 2138 2139 oword &= ~(mask << bitpos); 2140 oword |= fieldval << bitpos; 2141 2142 store_unsigned_integer (addr, sizeof oword, byte_order, oword); 2143 } 2144 2145 /* Pack NUM into BUF using a target format of TYPE. */ 2146 2147 void 2148 pack_long (gdb_byte *buf, struct type *type, LONGEST num) 2149 { 2150 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); 2151 int len; 2152 2153 type = check_typedef (type); 2154 len = TYPE_LENGTH (type); 2155 2156 switch (TYPE_CODE (type)) 2157 { 2158 case TYPE_CODE_INT: 2159 case TYPE_CODE_CHAR: 2160 case TYPE_CODE_ENUM: 2161 case TYPE_CODE_FLAGS: 2162 case TYPE_CODE_BOOL: 2163 case TYPE_CODE_RANGE: 2164 case TYPE_CODE_MEMBERPTR: 2165 store_signed_integer (buf, len, byte_order, num); 2166 break; 2167 2168 case TYPE_CODE_REF: 2169 case TYPE_CODE_PTR: 2170 store_typed_address (buf, type, (CORE_ADDR) num); 2171 break; 2172 2173 default: 2174 error (_("Unexpected type (%d) encountered for integer constant."), 2175 TYPE_CODE (type)); 2176 } 2177 } 2178 2179 2180 /* Convert C numbers into newly allocated values. */ 2181 2182 struct value * 2183 value_from_longest (struct type *type, LONGEST num) 2184 { 2185 struct value *val = allocate_value (type); 2186 2187 pack_long (value_contents_raw (val), type, num); 2188 2189 return val; 2190 } 2191 2192 2193 /* Create a value representing a pointer of type TYPE to the address 2194 ADDR. */ 2195 struct value * 2196 value_from_pointer (struct type *type, CORE_ADDR addr) 2197 { 2198 struct value *val = allocate_value (type); 2199 store_typed_address (value_contents_raw (val), check_typedef (type), addr); 2200 return val; 2201 } 2202 2203 2204 /* Create a value of type TYPE whose contents come from VALADDR, if it 2205 is non-null, and whose memory address (in the inferior) is 2206 ADDRESS. */ 2207 2208 struct value * 2209 value_from_contents_and_address (struct type *type, 2210 const gdb_byte *valaddr, 2211 CORE_ADDR address) 2212 { 2213 struct value *v = allocate_value (type); 2214 if (valaddr == NULL) 2215 set_value_lazy (v, 1); 2216 else 2217 memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type)); 2218 set_value_address (v, address); 2219 VALUE_LVAL (v) = lval_memory; 2220 return v; 2221 } 2222 2223 struct value * 2224 value_from_double (struct type *type, DOUBLEST num) 2225 { 2226 struct value *val = allocate_value (type); 2227 struct type *base_type = check_typedef (type); 2228 enum type_code code = TYPE_CODE (base_type); 2229 int len = TYPE_LENGTH (base_type); 2230 2231 if (code == TYPE_CODE_FLT) 2232 { 2233 store_typed_floating (value_contents_raw (val), base_type, num); 2234 } 2235 else 2236 error (_("Unexpected type encountered for floating constant.")); 2237 2238 return val; 2239 } 2240 2241 struct value * 2242 value_from_decfloat (struct type *type, const gdb_byte *dec) 2243 { 2244 struct value *val = allocate_value (type); 2245 2246 memcpy (value_contents_raw (val), dec, TYPE_LENGTH (type)); 2247 2248 return val; 2249 } 2250 2251 struct value * 2252 coerce_ref (struct value *arg) 2253 { 2254 struct type *value_type_arg_tmp = check_typedef (value_type (arg)); 2255 if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF) 2256 arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp), 2257 unpack_pointer (value_type (arg), 2258 value_contents (arg))); 2259 return arg; 2260 } 2261 2262 struct value * 2263 coerce_array (struct value *arg) 2264 { 2265 struct type *type; 2266 2267 arg = coerce_ref (arg); 2268 type = check_typedef (value_type (arg)); 2269 2270 switch (TYPE_CODE (type)) 2271 { 2272 case TYPE_CODE_ARRAY: 2273 if (current_language->c_style_arrays) 2274 arg = value_coerce_array (arg); 2275 break; 2276 case TYPE_CODE_FUNC: 2277 arg = value_coerce_function (arg); 2278 break; 2279 } 2280 return arg; 2281 } 2282 2283 2284 /* Return true if the function returning the specified type is using 2285 the convention of returning structures in memory (passing in the 2286 address as a hidden first parameter). */ 2287 2288 int 2289 using_struct_return (struct gdbarch *gdbarch, 2290 struct type *func_type, struct type *value_type) 2291 { 2292 enum type_code code = TYPE_CODE (value_type); 2293 2294 if (code == TYPE_CODE_ERROR) 2295 error (_("Function return type unknown.")); 2296 2297 if (code == TYPE_CODE_VOID) 2298 /* A void return value is never in memory. See also corresponding 2299 code in "print_return_value". */ 2300 return 0; 2301 2302 /* Probe the architecture for the return-value convention. */ 2303 return (gdbarch_return_value (gdbarch, func_type, value_type, 2304 NULL, NULL, NULL) 2305 != RETURN_VALUE_REGISTER_CONVENTION); 2306 } 2307 2308 /* Set the initialized field in a value struct. */ 2309 2310 void 2311 set_value_initialized (struct value *val, int status) 2312 { 2313 val->initialized = status; 2314 } 2315 2316 /* Return the initialized field in a value struct. */ 2317 2318 int 2319 value_initialized (struct value *val) 2320 { 2321 return val->initialized; 2322 } 2323 2324 void 2325 _initialize_values (void) 2326 { 2327 add_cmd ("convenience", no_class, show_convenience, _("\ 2328 Debugger convenience (\"$foo\") variables.\n\ 2329 These variables are created when you assign them values;\n\ 2330 thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\ 2331 \n\ 2332 A few convenience variables are given values automatically:\n\ 2333 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\ 2334 \"$__\" holds the contents of the last address examined with \"x\"."), 2335 &showlist); 2336 2337 add_cmd ("values", no_class, show_values, 2338 _("Elements of value history around item number IDX (or last ten)."), 2339 &showlist); 2340 2341 add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\ 2342 Initialize a convenience variable if necessary.\n\ 2343 init-if-undefined VARIABLE = EXPRESSION\n\ 2344 Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\ 2345 exist or does not contain a value. The EXPRESSION is not evaluated if the\n\ 2346 VARIABLE is already initialized.")); 2347 2348 add_prefix_cmd ("function", no_class, function_command, _("\ 2349 Placeholder command for showing help on convenience functions."), 2350 &functionlist, "function ", 0, &cmdlist); 2351 } 2352