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 5 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 "gdb_string.h" 24#include "symtab.h" 25#include "gdbtypes.h" 26#include "value.h" 27#include "gdbcore.h" 28#include "command.h" 29#include "gdbcmd.h" 30#include "target.h" 31#include "language.h" 32#include "demangle.h" 33#include "doublest.h" 34#include "gdb_assert.h" 35#include "regcache.h" 36#include "block.h" 37 38/* Prototypes for exported functions. */ 39 40void _initialize_values (void); 41 42struct value 43{ 44 /* Type of value; either not an lval, or one of the various 45 different possible kinds of lval. */ 46 enum lval_type lval; 47 48 /* Is it modifiable? Only relevant if lval != not_lval. */ 49 int modifiable; 50 51 /* Location of value (if lval). */ 52 union 53 { 54 /* If lval == lval_memory, this is the address in the inferior. 55 If lval == lval_register, this is the byte offset into the 56 registers structure. */ 57 CORE_ADDR address; 58 59 /* Pointer to internal variable. */ 60 struct internalvar *internalvar; 61 } location; 62 63 /* Describes offset of a value within lval of a structure in bytes. 64 If lval == lval_memory, this is an offset to the address. If 65 lval == lval_register, this is a further offset from 66 location.address within the registers structure. Note also the 67 member embedded_offset below. */ 68 int offset; 69 70 /* Only used for bitfields; number of bits contained in them. */ 71 int bitsize; 72 73 /* Only used for bitfields; position of start of field. For 74 BITS_BIG_ENDIAN=0 targets, it is the position of the LSB. For 75 BITS_BIG_ENDIAN=1 targets, it is the position of the MSB. */ 76 int bitpos; 77 78 /* Frame register value is relative to. This will be described in 79 the lval enum above as "lval_register". */ 80 struct frame_id frame_id; 81 82 /* Type of the value. */ 83 struct type *type; 84 85 /* If a value represents a C++ object, then the `type' field gives 86 the object's compile-time type. If the object actually belongs 87 to some class derived from `type', perhaps with other base 88 classes and additional members, then `type' is just a subobject 89 of the real thing, and the full object is probably larger than 90 `type' would suggest. 91 92 If `type' is a dynamic class (i.e. one with a vtable), then GDB 93 can actually determine the object's run-time type by looking at 94 the run-time type information in the vtable. When this 95 information is available, we may elect to read in the entire 96 object, for several reasons: 97 98 - When printing the value, the user would probably rather see the 99 full object, not just the limited portion apparent from the 100 compile-time type. 101 102 - If `type' has virtual base classes, then even printing `type' 103 alone may require reaching outside the `type' portion of the 104 object to wherever the virtual base class has been stored. 105 106 When we store the entire object, `enclosing_type' is the run-time 107 type -- the complete object -- and `embedded_offset' is the 108 offset of `type' within that larger type, in bytes. The 109 value_contents() macro takes `embedded_offset' into account, so 110 most GDB code continues to see the `type' portion of the value, 111 just as the inferior would. 112 113 If `type' is a pointer to an object, then `enclosing_type' is a 114 pointer to the object's run-time type, and `pointed_to_offset' is 115 the offset in bytes from the full object to the pointed-to object 116 -- that is, the value `embedded_offset' would have if we followed 117 the pointer and fetched the complete object. (I don't really see 118 the point. Why not just determine the run-time type when you 119 indirect, and avoid the special case? The contents don't matter 120 until you indirect anyway.) 121 122 If we're not doing anything fancy, `enclosing_type' is equal to 123 `type', and `embedded_offset' is zero, so everything works 124 normally. */ 125 struct type *enclosing_type; 126 int embedded_offset; 127 int pointed_to_offset; 128 129 /* Values are stored in a chain, so that they can be deleted easily 130 over calls to the inferior. Values assigned to internal 131 variables or put into the value history are taken off this 132 list. */ 133 struct value *next; 134 135 /* Register number if the value is from a register. */ 136 short regnum; 137 138 /* If zero, contents of this value are in the contents field. If 139 nonzero, contents are in inferior memory at address in the 140 location.address field plus the offset field (and the lval field 141 should be lval_memory). 142 143 WARNING: This field is used by the code which handles watchpoints 144 (see breakpoint.c) to decide whether a particular value can be 145 watched by hardware watchpoints. If the lazy flag is set for 146 some member of a value chain, it is assumed that this member of 147 the chain doesn't need to be watched as part of watching the 148 value itself. This is how GDB avoids watching the entire struct 149 or array when the user wants to watch a single struct member or 150 array element. If you ever change the way lazy flag is set and 151 reset, be sure to consider this use as well! */ 152 char lazy; 153 154 /* If nonzero, this is the value of a variable which does not 155 actually exist in the program. */ 156 char optimized_out; 157 158 /* If value is a variable, is it initialized or not. */ 159 int initialized; 160 161 /* Actual contents of the value. For use of this value; setting it 162 uses the stuff above. Not valid if lazy is nonzero. Target 163 byte-order. We force it to be aligned properly for any possible 164 value. Note that a value therefore extends beyond what is 165 declared here. */ 166 union 167 { 168 gdb_byte contents[1]; 169 DOUBLEST force_doublest_align; 170 LONGEST force_longest_align; 171 CORE_ADDR force_core_addr_align; 172 void *force_pointer_align; 173 } aligner; 174 /* Do not add any new members here -- contents above will trash 175 them. */ 176}; 177 178/* Prototypes for local functions. */ 179 180static void show_values (char *, int); 181 182static void show_convenience (char *, int); 183 184 185/* The value-history records all the values printed 186 by print commands during this session. Each chunk 187 records 60 consecutive values. The first chunk on 188 the chain records the most recent values. 189 The total number of values is in value_history_count. */ 190 191#define VALUE_HISTORY_CHUNK 60 192 193struct value_history_chunk 194 { 195 struct value_history_chunk *next; 196 struct value *values[VALUE_HISTORY_CHUNK]; 197 }; 198 199/* Chain of chunks now in use. */ 200 201static struct value_history_chunk *value_history_chain; 202 203static int value_history_count; /* Abs number of last entry stored */ 204 205/* List of all value objects currently allocated 206 (except for those released by calls to release_value) 207 This is so they can be freed after each command. */ 208 209static struct value *all_values; 210 211/* Allocate a value that has the correct length for type TYPE. */ 212 213struct value * 214allocate_value (struct type *type) 215{ 216 struct value *val; 217 struct type *atype = check_typedef (type); 218 219 val = (struct value *) xzalloc (sizeof (struct value) + TYPE_LENGTH (atype)); 220 val->next = all_values; 221 all_values = val; 222 val->type = type; 223 val->enclosing_type = type; 224 VALUE_LVAL (val) = not_lval; 225 VALUE_ADDRESS (val) = 0; 226 VALUE_FRAME_ID (val) = null_frame_id; 227 val->offset = 0; 228 val->bitpos = 0; 229 val->bitsize = 0; 230 VALUE_REGNUM (val) = -1; 231 val->lazy = 0; 232 val->optimized_out = 0; 233 val->embedded_offset = 0; 234 val->pointed_to_offset = 0; 235 val->modifiable = 1; 236 val->initialized = 1; /* Default to initialized. */ 237 return val; 238} 239 240/* Allocate a value that has the correct length 241 for COUNT repetitions type TYPE. */ 242 243struct value * 244allocate_repeat_value (struct type *type, int count) 245{ 246 int low_bound = current_language->string_lower_bound; /* ??? */ 247 /* FIXME-type-allocation: need a way to free this type when we are 248 done with it. */ 249 struct type *range_type 250 = create_range_type ((struct type *) NULL, builtin_type_int, 251 low_bound, count + low_bound - 1); 252 /* FIXME-type-allocation: need a way to free this type when we are 253 done with it. */ 254 return allocate_value (create_array_type ((struct type *) NULL, 255 type, range_type)); 256} 257 258/* Accessor methods. */ 259 260struct value * 261value_next (struct value *value) 262{ 263 return value->next; 264} 265 266struct type * 267value_type (struct value *value) 268{ 269 return value->type; 270} 271void 272deprecated_set_value_type (struct value *value, struct type *type) 273{ 274 value->type = type; 275} 276 277int 278value_offset (struct value *value) 279{ 280 return value->offset; 281} 282void 283set_value_offset (struct value *value, int offset) 284{ 285 value->offset = offset; 286} 287 288int 289value_bitpos (struct value *value) 290{ 291 return value->bitpos; 292} 293void 294set_value_bitpos (struct value *value, int bit) 295{ 296 value->bitpos = bit; 297} 298 299int 300value_bitsize (struct value *value) 301{ 302 return value->bitsize; 303} 304void 305set_value_bitsize (struct value *value, int bit) 306{ 307 value->bitsize = bit; 308} 309 310gdb_byte * 311value_contents_raw (struct value *value) 312{ 313 return value->aligner.contents + value->embedded_offset; 314} 315 316gdb_byte * 317value_contents_all_raw (struct value *value) 318{ 319 return value->aligner.contents; 320} 321 322struct type * 323value_enclosing_type (struct value *value) 324{ 325 return value->enclosing_type; 326} 327 328const gdb_byte * 329value_contents_all (struct value *value) 330{ 331 if (value->lazy) 332 value_fetch_lazy (value); 333 return value->aligner.contents; 334} 335 336int 337value_lazy (struct value *value) 338{ 339 return value->lazy; 340} 341 342void 343set_value_lazy (struct value *value, int val) 344{ 345 value->lazy = val; 346} 347 348const gdb_byte * 349value_contents (struct value *value) 350{ 351 return value_contents_writeable (value); 352} 353 354gdb_byte * 355value_contents_writeable (struct value *value) 356{ 357 if (value->lazy) 358 value_fetch_lazy (value); 359 return value_contents_raw (value); 360} 361 362/* Return non-zero if VAL1 and VAL2 have the same contents. Note that 363 this function is different from value_equal; in C the operator == 364 can return 0 even if the two values being compared are equal. */ 365 366int 367value_contents_equal (struct value *val1, struct value *val2) 368{ 369 struct type *type1; 370 struct type *type2; 371 int len; 372 373 type1 = check_typedef (value_type (val1)); 374 type2 = check_typedef (value_type (val2)); 375 len = TYPE_LENGTH (type1); 376 if (len != TYPE_LENGTH (type2)) 377 return 0; 378 379 return (memcmp (value_contents (val1), value_contents (val2), len) == 0); 380} 381 382int 383value_optimized_out (struct value *value) 384{ 385 return value->optimized_out; 386} 387 388void 389set_value_optimized_out (struct value *value, int val) 390{ 391 value->optimized_out = val; 392} 393 394int 395value_embedded_offset (struct value *value) 396{ 397 return value->embedded_offset; 398} 399 400void 401set_value_embedded_offset (struct value *value, int val) 402{ 403 value->embedded_offset = val; 404} 405 406int 407value_pointed_to_offset (struct value *value) 408{ 409 return value->pointed_to_offset; 410} 411 412void 413set_value_pointed_to_offset (struct value *value, int val) 414{ 415 value->pointed_to_offset = val; 416} 417 418enum lval_type * 419deprecated_value_lval_hack (struct value *value) 420{ 421 return &value->lval; 422} 423 424CORE_ADDR * 425deprecated_value_address_hack (struct value *value) 426{ 427 return &value->location.address; 428} 429 430struct internalvar ** 431deprecated_value_internalvar_hack (struct value *value) 432{ 433 return &value->location.internalvar; 434} 435 436struct frame_id * 437deprecated_value_frame_id_hack (struct value *value) 438{ 439 return &value->frame_id; 440} 441 442short * 443deprecated_value_regnum_hack (struct value *value) 444{ 445 return &value->regnum; 446} 447 448int 449deprecated_value_modifiable (struct value *value) 450{ 451 return value->modifiable; 452} 453void 454deprecated_set_value_modifiable (struct value *value, int modifiable) 455{ 456 value->modifiable = modifiable; 457} 458 459/* Return a mark in the value chain. All values allocated after the 460 mark is obtained (except for those released) are subject to being freed 461 if a subsequent value_free_to_mark is passed the mark. */ 462struct value * 463value_mark (void) 464{ 465 return all_values; 466} 467 468/* Free all values allocated since MARK was obtained by value_mark 469 (except for those released). */ 470void 471value_free_to_mark (struct value *mark) 472{ 473 struct value *val; 474 struct value *next; 475 476 for (val = all_values; val && val != mark; val = next) 477 { 478 next = val->next; 479 value_free (val); 480 } 481 all_values = val; 482} 483 484/* Free all the values that have been allocated (except for those released). 485 Called after each command, successful or not. */ 486 487void 488free_all_values (void) 489{ 490 struct value *val; 491 struct value *next; 492 493 for (val = all_values; val; val = next) 494 { 495 next = val->next; 496 value_free (val); 497 } 498 499 all_values = 0; 500} 501 502/* Remove VAL from the chain all_values 503 so it will not be freed automatically. */ 504 505void 506release_value (struct value *val) 507{ 508 struct value *v; 509 510 if (all_values == val) 511 { 512 all_values = val->next; 513 return; 514 } 515 516 for (v = all_values; v; v = v->next) 517 { 518 if (v->next == val) 519 { 520 v->next = val->next; 521 break; 522 } 523 } 524} 525 526/* Release all values up to mark */ 527struct value * 528value_release_to_mark (struct value *mark) 529{ 530 struct value *val; 531 struct value *next; 532 533 for (val = next = all_values; next; next = next->next) 534 if (next->next == mark) 535 { 536 all_values = next->next; 537 next->next = NULL; 538 return val; 539 } 540 all_values = 0; 541 return val; 542} 543 544/* Return a copy of the value ARG. 545 It contains the same contents, for same memory address, 546 but it's a different block of storage. */ 547 548struct value * 549value_copy (struct value *arg) 550{ 551 struct type *encl_type = value_enclosing_type (arg); 552 struct value *val = allocate_value (encl_type); 553 val->type = arg->type; 554 VALUE_LVAL (val) = VALUE_LVAL (arg); 555 val->location = arg->location; 556 val->offset = arg->offset; 557 val->bitpos = arg->bitpos; 558 val->bitsize = arg->bitsize; 559 VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg); 560 VALUE_REGNUM (val) = VALUE_REGNUM (arg); 561 val->lazy = arg->lazy; 562 val->optimized_out = arg->optimized_out; 563 val->embedded_offset = value_embedded_offset (arg); 564 val->pointed_to_offset = arg->pointed_to_offset; 565 val->modifiable = arg->modifiable; 566 if (!value_lazy (val)) 567 { 568 memcpy (value_contents_all_raw (val), value_contents_all_raw (arg), 569 TYPE_LENGTH (value_enclosing_type (arg))); 570 571 } 572 return val; 573} 574 575/* Access to the value history. */ 576 577/* Record a new value in the value history. 578 Returns the absolute history index of the entry. 579 Result of -1 indicates the value was not saved; otherwise it is the 580 value history index of this new item. */ 581 582int 583record_latest_value (struct value *val) 584{ 585 int i; 586 587 /* We don't want this value to have anything to do with the inferior anymore. 588 In particular, "set $1 = 50" should not affect the variable from which 589 the value was taken, and fast watchpoints should be able to assume that 590 a value on the value history never changes. */ 591 if (value_lazy (val)) 592 value_fetch_lazy (val); 593 /* We preserve VALUE_LVAL so that the user can find out where it was fetched 594 from. This is a bit dubious, because then *&$1 does not just return $1 595 but the current contents of that location. c'est la vie... */ 596 val->modifiable = 0; 597 release_value (val); 598 599 /* Here we treat value_history_count as origin-zero 600 and applying to the value being stored now. */ 601 602 i = value_history_count % VALUE_HISTORY_CHUNK; 603 if (i == 0) 604 { 605 struct value_history_chunk *new 606 = (struct value_history_chunk *) 607 xmalloc (sizeof (struct value_history_chunk)); 608 memset (new->values, 0, sizeof new->values); 609 new->next = value_history_chain; 610 value_history_chain = new; 611 } 612 613 value_history_chain->values[i] = val; 614 615 /* Now we regard value_history_count as origin-one 616 and applying to the value just stored. */ 617 618 return ++value_history_count; 619} 620 621/* Return a copy of the value in the history with sequence number NUM. */ 622 623struct value * 624access_value_history (int num) 625{ 626 struct value_history_chunk *chunk; 627 int i; 628 int absnum = num; 629 630 if (absnum <= 0) 631 absnum += value_history_count; 632 633 if (absnum <= 0) 634 { 635 if (num == 0) 636 error (_("The history is empty.")); 637 else if (num == 1) 638 error (_("There is only one value in the history.")); 639 else 640 error (_("History does not go back to $$%d."), -num); 641 } 642 if (absnum > value_history_count) 643 error (_("History has not yet reached $%d."), absnum); 644 645 absnum--; 646 647 /* Now absnum is always absolute and origin zero. */ 648 649 chunk = value_history_chain; 650 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK; 651 i > 0; i--) 652 chunk = chunk->next; 653 654 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]); 655} 656 657static void 658show_values (char *num_exp, int from_tty) 659{ 660 int i; 661 struct value *val; 662 static int num = 1; 663 664 if (num_exp) 665 { 666 /* "info history +" should print from the stored position. 667 "info history <exp>" should print around value number <exp>. */ 668 if (num_exp[0] != '+' || num_exp[1] != '\0') 669 num = parse_and_eval_long (num_exp) - 5; 670 } 671 else 672 { 673 /* "info history" means print the last 10 values. */ 674 num = value_history_count - 9; 675 } 676 677 if (num <= 0) 678 num = 1; 679 680 for (i = num; i < num + 10 && i <= value_history_count; i++) 681 { 682 val = access_value_history (i); 683 printf_filtered (("$%d = "), i); 684 value_print (val, gdb_stdout, 0, Val_pretty_default); 685 printf_filtered (("\n")); 686 } 687 688 /* The next "info history +" should start after what we just printed. */ 689 num += 10; 690 691 /* Hitting just return after this command should do the same thing as 692 "info history +". If num_exp is null, this is unnecessary, since 693 "info history +" is not useful after "info history". */ 694 if (from_tty && num_exp) 695 { 696 num_exp[0] = '+'; 697 num_exp[1] = '\0'; 698 } 699} 700 701/* Internal variables. These are variables within the debugger 702 that hold values assigned by debugger commands. 703 The user refers to them with a '$' prefix 704 that does not appear in the variable names stored internally. */ 705 706static struct internalvar *internalvars; 707 708/* If the variable does not already exist create it and give it the value given. 709 If no value is given then the default is zero. */ 710static void 711init_if_undefined_command (char* args, int from_tty) 712{ 713 struct internalvar* intvar; 714 715 /* Parse the expression - this is taken from set_command(). */ 716 struct expression *expr = parse_expression (args); 717 register struct cleanup *old_chain = 718 make_cleanup (free_current_contents, &expr); 719 720 /* Validate the expression. 721 Was the expression an assignment? 722 Or even an expression at all? */ 723 if (expr->nelts == 0 || expr->elts[0].opcode != BINOP_ASSIGN) 724 error (_("Init-if-undefined requires an assignment expression.")); 725 726 /* Extract the variable from the parsed expression. 727 In the case of an assign the lvalue will be in elts[1] and elts[2]. */ 728 if (expr->elts[1].opcode != OP_INTERNALVAR) 729 error (_("The first parameter to init-if-undefined should be a GDB variable.")); 730 intvar = expr->elts[2].internalvar; 731 732 /* Only evaluate the expression if the lvalue is void. 733 This may still fail if the expresssion is invalid. */ 734 if (TYPE_CODE (value_type (intvar->value)) == TYPE_CODE_VOID) 735 evaluate_expression (expr); 736 737 do_cleanups (old_chain); 738} 739 740 741/* Look up an internal variable with name NAME. NAME should not 742 normally include a dollar sign. 743 744 If the specified internal variable does not exist, 745 one is created, with a void value. */ 746 747struct internalvar * 748lookup_internalvar (char *name) 749{ 750 struct internalvar *var; 751 752 for (var = internalvars; var; var = var->next) 753 if (strcmp (var->name, name) == 0) 754 return var; 755 756 var = (struct internalvar *) xmalloc (sizeof (struct internalvar)); 757 var->name = concat (name, (char *)NULL); 758 var->value = allocate_value (builtin_type_void); 759 var->endian = gdbarch_byte_order (current_gdbarch); 760 release_value (var->value); 761 var->next = internalvars; 762 internalvars = var; 763 return var; 764} 765 766struct value * 767value_of_internalvar (struct internalvar *var) 768{ 769 struct value *val; 770 int i, j; 771 gdb_byte temp; 772 773 val = value_copy (var->value); 774 if (value_lazy (val)) 775 value_fetch_lazy (val); 776 VALUE_LVAL (val) = lval_internalvar; 777 VALUE_INTERNALVAR (val) = var; 778 779 /* Values are always stored in the target's byte order. When connected to a 780 target this will most likely always be correct, so there's normally no 781 need to worry about it. 782 783 However, internal variables can be set up before the target endian is 784 known and so may become out of date. Fix it up before anybody sees. 785 786 Internal variables usually hold simple scalar values, and we can 787 correct those. More complex values (e.g. structures and floating 788 point types) are left alone, because they would be too complicated 789 to correct. */ 790 791 if (var->endian != gdbarch_byte_order (current_gdbarch)) 792 { 793 gdb_byte *array = value_contents_raw (val); 794 struct type *type = check_typedef (value_enclosing_type (val)); 795 switch (TYPE_CODE (type)) 796 { 797 case TYPE_CODE_INT: 798 case TYPE_CODE_PTR: 799 /* Reverse the bytes. */ 800 for (i = 0, j = TYPE_LENGTH (type) - 1; i < j; i++, j--) 801 { 802 temp = array[j]; 803 array[j] = array[i]; 804 array[i] = temp; 805 } 806 break; 807 } 808 } 809 810 return val; 811} 812 813void 814set_internalvar_component (struct internalvar *var, int offset, int bitpos, 815 int bitsize, struct value *newval) 816{ 817 gdb_byte *addr = value_contents_writeable (var->value) + offset; 818 819 if (bitsize) 820 modify_field (addr, value_as_long (newval), 821 bitpos, bitsize); 822 else 823 memcpy (addr, value_contents (newval), TYPE_LENGTH (value_type (newval))); 824} 825 826void 827set_internalvar (struct internalvar *var, struct value *val) 828{ 829 struct value *newval; 830 831 newval = value_copy (val); 832 newval->modifiable = 1; 833 834 /* Force the value to be fetched from the target now, to avoid problems 835 later when this internalvar is referenced and the target is gone or 836 has changed. */ 837 if (value_lazy (newval)) 838 value_fetch_lazy (newval); 839 840 /* Begin code which must not call error(). If var->value points to 841 something free'd, an error() obviously leaves a dangling pointer. 842 But we also get a danling pointer if var->value points to 843 something in the value chain (i.e., before release_value is 844 called), because after the error free_all_values will get called before 845 long. */ 846 xfree (var->value); 847 var->value = newval; 848 var->endian = gdbarch_byte_order (current_gdbarch); 849 release_value (newval); 850 /* End code which must not call error(). */ 851} 852 853char * 854internalvar_name (struct internalvar *var) 855{ 856 return var->name; 857} 858 859/* Update VALUE before discarding OBJFILE. COPIED_TYPES is used to 860 prevent cycles / duplicates. */ 861 862static void 863preserve_one_value (struct value *value, struct objfile *objfile, 864 htab_t copied_types) 865{ 866 if (TYPE_OBJFILE (value->type) == objfile) 867 value->type = copy_type_recursive (objfile, value->type, copied_types); 868 869 if (TYPE_OBJFILE (value->enclosing_type) == objfile) 870 value->enclosing_type = copy_type_recursive (objfile, 871 value->enclosing_type, 872 copied_types); 873} 874 875/* Update the internal variables and value history when OBJFILE is 876 discarded; we must copy the types out of the objfile. New global types 877 will be created for every convenience variable which currently points to 878 this objfile's types, and the convenience variables will be adjusted to 879 use the new global types. */ 880 881void 882preserve_values (struct objfile *objfile) 883{ 884 htab_t copied_types; 885 struct value_history_chunk *cur; 886 struct internalvar *var; 887 int i; 888 889 /* Create the hash table. We allocate on the objfile's obstack, since 890 it is soon to be deleted. */ 891 copied_types = create_copied_types_hash (objfile); 892 893 for (cur = value_history_chain; cur; cur = cur->next) 894 for (i = 0; i < VALUE_HISTORY_CHUNK; i++) 895 if (cur->values[i]) 896 preserve_one_value (cur->values[i], objfile, copied_types); 897 898 for (var = internalvars; var; var = var->next) 899 preserve_one_value (var->value, objfile, copied_types); 900 901 htab_delete (copied_types); 902} 903 904static void 905show_convenience (char *ignore, int from_tty) 906{ 907 struct internalvar *var; 908 int varseen = 0; 909 910 for (var = internalvars; var; var = var->next) 911 { 912 if (!varseen) 913 { 914 varseen = 1; 915 } 916 printf_filtered (("$%s = "), var->name); 917 value_print (value_of_internalvar (var), gdb_stdout, 918 0, Val_pretty_default); 919 printf_filtered (("\n")); 920 } 921 if (!varseen) 922 printf_unfiltered (_("\ 923No debugger convenience variables now defined.\n\ 924Convenience variables have names starting with \"$\";\n\ 925use \"set\" as in \"set $foo = 5\" to define them.\n")); 926} 927 928/* Extract a value as a C number (either long or double). 929 Knows how to convert fixed values to double, or 930 floating values to long. 931 Does not deallocate the value. */ 932 933LONGEST 934value_as_long (struct value *val) 935{ 936 /* This coerces arrays and functions, which is necessary (e.g. 937 in disassemble_command). It also dereferences references, which 938 I suspect is the most logical thing to do. */ 939 val = coerce_array (val); 940 return unpack_long (value_type (val), value_contents (val)); 941} 942 943DOUBLEST 944value_as_double (struct value *val) 945{ 946 DOUBLEST foo; 947 int inv; 948 949 foo = unpack_double (value_type (val), value_contents (val), &inv); 950 if (inv) 951 error (_("Invalid floating value found in program.")); 952 return foo; 953} 954/* Extract a value as a C pointer. Does not deallocate the value. 955 Note that val's type may not actually be a pointer; value_as_long 956 handles all the cases. */ 957CORE_ADDR 958value_as_address (struct value *val) 959{ 960 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 961 whether we want this to be true eventually. */ 962#if 0 963 /* gdbarch_addr_bits_remove is wrong if we are being called for a 964 non-address (e.g. argument to "signal", "info break", etc.), or 965 for pointers to char, in which the low bits *are* significant. */ 966 return gdbarch_addr_bits_remove (current_gdbarch, value_as_long (val)); 967#else 968 969 /* There are several targets (IA-64, PowerPC, and others) which 970 don't represent pointers to functions as simply the address of 971 the function's entry point. For example, on the IA-64, a 972 function pointer points to a two-word descriptor, generated by 973 the linker, which contains the function's entry point, and the 974 value the IA-64 "global pointer" register should have --- to 975 support position-independent code. The linker generates 976 descriptors only for those functions whose addresses are taken. 977 978 On such targets, it's difficult for GDB to convert an arbitrary 979 function address into a function pointer; it has to either find 980 an existing descriptor for that function, or call malloc and 981 build its own. On some targets, it is impossible for GDB to 982 build a descriptor at all: the descriptor must contain a jump 983 instruction; data memory cannot be executed; and code memory 984 cannot be modified. 985 986 Upon entry to this function, if VAL is a value of type `function' 987 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then 988 VALUE_ADDRESS (val) is the address of the function. This is what 989 you'll get if you evaluate an expression like `main'. The call 990 to COERCE_ARRAY below actually does all the usual unary 991 conversions, which includes converting values of type `function' 992 to `pointer to function'. This is the challenging conversion 993 discussed above. Then, `unpack_long' will convert that pointer 994 back into an address. 995 996 So, suppose the user types `disassemble foo' on an architecture 997 with a strange function pointer representation, on which GDB 998 cannot build its own descriptors, and suppose further that `foo' 999 has no linker-built descriptor. The address->pointer conversion 1000 will signal an error and prevent the command from running, even 1001 though the next step would have been to convert the pointer 1002 directly back into the same address. 1003 1004 The following shortcut avoids this whole mess. If VAL is a 1005 function, just return its address directly. */ 1006 if (TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC 1007 || TYPE_CODE (value_type (val)) == TYPE_CODE_METHOD) 1008 return VALUE_ADDRESS (val); 1009 1010 val = coerce_array (val); 1011 1012 /* Some architectures (e.g. Harvard), map instruction and data 1013 addresses onto a single large unified address space. For 1014 instance: An architecture may consider a large integer in the 1015 range 0x10000000 .. 0x1000ffff to already represent a data 1016 addresses (hence not need a pointer to address conversion) while 1017 a small integer would still need to be converted integer to 1018 pointer to address. Just assume such architectures handle all 1019 integer conversions in a single function. */ 1020 1021 /* JimB writes: 1022 1023 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we 1024 must admonish GDB hackers to make sure its behavior matches the 1025 compiler's, whenever possible. 1026 1027 In general, I think GDB should evaluate expressions the same way 1028 the compiler does. When the user copies an expression out of 1029 their source code and hands it to a `print' command, they should 1030 get the same value the compiler would have computed. Any 1031 deviation from this rule can cause major confusion and annoyance, 1032 and needs to be justified carefully. In other words, GDB doesn't 1033 really have the freedom to do these conversions in clever and 1034 useful ways. 1035 1036 AndrewC pointed out that users aren't complaining about how GDB 1037 casts integers to pointers; they are complaining that they can't 1038 take an address from a disassembly listing and give it to `x/i'. 1039 This is certainly important. 1040 1041 Adding an architecture method like integer_to_address() certainly 1042 makes it possible for GDB to "get it right" in all circumstances 1043 --- the target has complete control over how things get done, so 1044 people can Do The Right Thing for their target without breaking 1045 anyone else. The standard doesn't specify how integers get 1046 converted to pointers; usually, the ABI doesn't either, but 1047 ABI-specific code is a more reasonable place to handle it. */ 1048 1049 if (TYPE_CODE (value_type (val)) != TYPE_CODE_PTR 1050 && TYPE_CODE (value_type (val)) != TYPE_CODE_REF 1051 && gdbarch_integer_to_address_p (current_gdbarch)) 1052 return gdbarch_integer_to_address (current_gdbarch, value_type (val), 1053 value_contents (val)); 1054 1055 return unpack_long (value_type (val), value_contents (val)); 1056#endif 1057} 1058 1059/* Unpack raw data (copied from debugee, target byte order) at VALADDR 1060 as a long, or as a double, assuming the raw data is described 1061 by type TYPE. Knows how to convert different sizes of values 1062 and can convert between fixed and floating point. We don't assume 1063 any alignment for the raw data. Return value is in host byte order. 1064 1065 If you want functions and arrays to be coerced to pointers, and 1066 references to be dereferenced, call value_as_long() instead. 1067 1068 C++: It is assumed that the front-end has taken care of 1069 all matters concerning pointers to members. A pointer 1070 to member which reaches here is considered to be equivalent 1071 to an INT (or some size). After all, it is only an offset. */ 1072 1073LONGEST 1074unpack_long (struct type *type, const gdb_byte *valaddr) 1075{ 1076 enum type_code code = TYPE_CODE (type); 1077 int len = TYPE_LENGTH (type); 1078 int nosign = TYPE_UNSIGNED (type); 1079 1080 switch (code) 1081 { 1082 case TYPE_CODE_TYPEDEF: 1083 return unpack_long (check_typedef (type), valaddr); 1084 case TYPE_CODE_ENUM: 1085 case TYPE_CODE_FLAGS: 1086 case TYPE_CODE_BOOL: 1087 case TYPE_CODE_INT: 1088 case TYPE_CODE_CHAR: 1089 case TYPE_CODE_RANGE: 1090 case TYPE_CODE_MEMBERPTR: 1091 if (nosign) 1092 return extract_unsigned_integer (valaddr, len); 1093 else 1094 return extract_signed_integer (valaddr, len); 1095 1096 case TYPE_CODE_FLT: 1097 return extract_typed_floating (valaddr, type); 1098 1099 case TYPE_CODE_PTR: 1100 case TYPE_CODE_REF: 1101 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 1102 whether we want this to be true eventually. */ 1103 return extract_typed_address (valaddr, type); 1104 1105 default: 1106 error (_("Value can't be converted to integer.")); 1107 } 1108 return 0; /* Placate lint. */ 1109} 1110 1111/* Return a double value from the specified type and address. 1112 INVP points to an int which is set to 0 for valid value, 1113 1 for invalid value (bad float format). In either case, 1114 the returned double is OK to use. Argument is in target 1115 format, result is in host format. */ 1116 1117DOUBLEST 1118unpack_double (struct type *type, const gdb_byte *valaddr, int *invp) 1119{ 1120 enum type_code code; 1121 int len; 1122 int nosign; 1123 1124 *invp = 0; /* Assume valid. */ 1125 CHECK_TYPEDEF (type); 1126 code = TYPE_CODE (type); 1127 len = TYPE_LENGTH (type); 1128 nosign = TYPE_UNSIGNED (type); 1129 if (code == TYPE_CODE_FLT) 1130 { 1131 /* NOTE: cagney/2002-02-19: There was a test here to see if the 1132 floating-point value was valid (using the macro 1133 INVALID_FLOAT). That test/macro have been removed. 1134 1135 It turns out that only the VAX defined this macro and then 1136 only in a non-portable way. Fixing the portability problem 1137 wouldn't help since the VAX floating-point code is also badly 1138 bit-rotten. The target needs to add definitions for the 1139 methods gdbarch_float_format and gdbarch_double_format - these 1140 exactly describe the target floating-point format. The 1141 problem here is that the corresponding floatformat_vax_f and 1142 floatformat_vax_d values these methods should be set to are 1143 also not defined either. Oops! 1144 1145 Hopefully someone will add both the missing floatformat 1146 definitions and the new cases for floatformat_is_valid (). */ 1147 1148 if (!floatformat_is_valid (floatformat_from_type (type), valaddr)) 1149 { 1150 *invp = 1; 1151 return 0.0; 1152 } 1153 1154 return extract_typed_floating (valaddr, type); 1155 } 1156 else if (nosign) 1157 { 1158 /* Unsigned -- be sure we compensate for signed LONGEST. */ 1159 return (ULONGEST) unpack_long (type, valaddr); 1160 } 1161 else 1162 { 1163 /* Signed -- we are OK with unpack_long. */ 1164 return unpack_long (type, valaddr); 1165 } 1166} 1167 1168/* Unpack raw data (copied from debugee, target byte order) at VALADDR 1169 as a CORE_ADDR, assuming the raw data is described by type TYPE. 1170 We don't assume any alignment for the raw data. Return value is in 1171 host byte order. 1172 1173 If you want functions and arrays to be coerced to pointers, and 1174 references to be dereferenced, call value_as_address() instead. 1175 1176 C++: It is assumed that the front-end has taken care of 1177 all matters concerning pointers to members. A pointer 1178 to member which reaches here is considered to be equivalent 1179 to an INT (or some size). After all, it is only an offset. */ 1180 1181CORE_ADDR 1182unpack_pointer (struct type *type, const gdb_byte *valaddr) 1183{ 1184 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 1185 whether we want this to be true eventually. */ 1186 return unpack_long (type, valaddr); 1187} 1188 1189 1190/* Get the value of the FIELDN'th field (which must be static) of 1191 TYPE. Return NULL if the field doesn't exist or has been 1192 optimized out. */ 1193 1194struct value * 1195value_static_field (struct type *type, int fieldno) 1196{ 1197 struct value *retval; 1198 1199 if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno)) 1200 { 1201 retval = value_at (TYPE_FIELD_TYPE (type, fieldno), 1202 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno)); 1203 } 1204 else 1205 { 1206 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno); 1207 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0, NULL); 1208 if (sym == NULL) 1209 { 1210 /* With some compilers, e.g. HP aCC, static data members are reported 1211 as non-debuggable symbols */ 1212 struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL); 1213 if (!msym) 1214 return NULL; 1215 else 1216 { 1217 retval = value_at (TYPE_FIELD_TYPE (type, fieldno), 1218 SYMBOL_VALUE_ADDRESS (msym)); 1219 } 1220 } 1221 else 1222 { 1223 /* SYM should never have a SYMBOL_CLASS which will require 1224 read_var_value to use the FRAME parameter. */ 1225 if (symbol_read_needs_frame (sym)) 1226 warning (_("static field's value depends on the current " 1227 "frame - bad debug info?")); 1228 retval = read_var_value (sym, NULL); 1229 } 1230 if (retval && VALUE_LVAL (retval) == lval_memory) 1231 SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), 1232 VALUE_ADDRESS (retval)); 1233 } 1234 return retval; 1235} 1236 1237/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE. 1238 You have to be careful here, since the size of the data area for the value 1239 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger 1240 than the old enclosing type, you have to allocate more space for the data. 1241 The return value is a pointer to the new version of this value structure. */ 1242 1243struct value * 1244value_change_enclosing_type (struct value *val, struct type *new_encl_type) 1245{ 1246 if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (value_enclosing_type (val))) 1247 { 1248 val->enclosing_type = new_encl_type; 1249 return val; 1250 } 1251 else 1252 { 1253 struct value *new_val; 1254 struct value *prev; 1255 1256 new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type)); 1257 1258 new_val->enclosing_type = new_encl_type; 1259 1260 /* We have to make sure this ends up in the same place in the value 1261 chain as the original copy, so it's clean-up behavior is the same. 1262 If the value has been released, this is a waste of time, but there 1263 is no way to tell that in advance, so... */ 1264 1265 if (val != all_values) 1266 { 1267 for (prev = all_values; prev != NULL; prev = prev->next) 1268 { 1269 if (prev->next == val) 1270 { 1271 prev->next = new_val; 1272 break; 1273 } 1274 } 1275 } 1276 1277 return new_val; 1278 } 1279} 1280 1281/* Given a value ARG1 (offset by OFFSET bytes) 1282 of a struct or union type ARG_TYPE, 1283 extract and return the value of one of its (non-static) fields. 1284 FIELDNO says which field. */ 1285 1286struct value * 1287value_primitive_field (struct value *arg1, int offset, 1288 int fieldno, struct type *arg_type) 1289{ 1290 struct value *v; 1291 struct type *type; 1292 1293 CHECK_TYPEDEF (arg_type); 1294 type = TYPE_FIELD_TYPE (arg_type, fieldno); 1295 1296 /* Handle packed fields */ 1297 1298 if (TYPE_FIELD_BITSIZE (arg_type, fieldno)) 1299 { 1300 v = value_from_longest (type, 1301 unpack_field_as_long (arg_type, 1302 value_contents (arg1) 1303 + offset, 1304 fieldno)); 1305 v->bitpos = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8; 1306 v->bitsize = TYPE_FIELD_BITSIZE (arg_type, fieldno); 1307 v->offset = value_offset (arg1) + offset 1308 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; 1309 } 1310 else if (fieldno < TYPE_N_BASECLASSES (arg_type)) 1311 { 1312 /* This field is actually a base subobject, so preserve the 1313 entire object's contents for later references to virtual 1314 bases, etc. */ 1315 v = allocate_value (value_enclosing_type (arg1)); 1316 v->type = type; 1317 if (value_lazy (arg1)) 1318 set_value_lazy (v, 1); 1319 else 1320 memcpy (value_contents_all_raw (v), value_contents_all_raw (arg1), 1321 TYPE_LENGTH (value_enclosing_type (arg1))); 1322 v->offset = value_offset (arg1); 1323 v->embedded_offset = (offset + value_embedded_offset (arg1) 1324 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8); 1325 } 1326 else 1327 { 1328 /* Plain old data member */ 1329 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; 1330 v = allocate_value (type); 1331 if (value_lazy (arg1)) 1332 set_value_lazy (v, 1); 1333 else 1334 memcpy (value_contents_raw (v), 1335 value_contents_raw (arg1) + offset, 1336 TYPE_LENGTH (type)); 1337 v->offset = (value_offset (arg1) + offset 1338 + value_embedded_offset (arg1)); 1339 } 1340 VALUE_LVAL (v) = VALUE_LVAL (arg1); 1341 if (VALUE_LVAL (arg1) == lval_internalvar) 1342 VALUE_LVAL (v) = lval_internalvar_component; 1343 v->location = arg1->location; 1344 VALUE_REGNUM (v) = VALUE_REGNUM (arg1); 1345 VALUE_FRAME_ID (v) = VALUE_FRAME_ID (arg1); 1346 return v; 1347} 1348 1349/* Given a value ARG1 of a struct or union type, 1350 extract and return the value of one of its (non-static) fields. 1351 FIELDNO says which field. */ 1352 1353struct value * 1354value_field (struct value *arg1, int fieldno) 1355{ 1356 return value_primitive_field (arg1, 0, fieldno, value_type (arg1)); 1357} 1358 1359/* Return a non-virtual function as a value. 1360 F is the list of member functions which contains the desired method. 1361 J is an index into F which provides the desired method. 1362 1363 We only use the symbol for its address, so be happy with either a 1364 full symbol or a minimal symbol. 1365 */ 1366 1367struct value * 1368value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type, 1369 int offset) 1370{ 1371 struct value *v; 1372 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); 1373 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); 1374 struct symbol *sym; 1375 struct minimal_symbol *msym; 1376 1377 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0, NULL); 1378 if (sym != NULL) 1379 { 1380 msym = NULL; 1381 } 1382 else 1383 { 1384 gdb_assert (sym == NULL); 1385 msym = lookup_minimal_symbol (physname, NULL, NULL); 1386 if (msym == NULL) 1387 return NULL; 1388 } 1389 1390 v = allocate_value (ftype); 1391 if (sym) 1392 { 1393 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); 1394 } 1395 else 1396 { 1397 VALUE_ADDRESS (v) = SYMBOL_VALUE_ADDRESS (msym); 1398 } 1399 1400 if (arg1p) 1401 { 1402 if (type != value_type (*arg1p)) 1403 *arg1p = value_ind (value_cast (lookup_pointer_type (type), 1404 value_addr (*arg1p))); 1405 1406 /* Move the `this' pointer according to the offset. 1407 VALUE_OFFSET (*arg1p) += offset; 1408 */ 1409 } 1410 1411 return v; 1412} 1413 1414 1415/* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at 1416 VALADDR. 1417 1418 Extracting bits depends on endianness of the machine. Compute the 1419 number of least significant bits to discard. For big endian machines, 1420 we compute the total number of bits in the anonymous object, subtract 1421 off the bit count from the MSB of the object to the MSB of the 1422 bitfield, then the size of the bitfield, which leaves the LSB discard 1423 count. For little endian machines, the discard count is simply the 1424 number of bits from the LSB of the anonymous object to the LSB of the 1425 bitfield. 1426 1427 If the field is signed, we also do sign extension. */ 1428 1429LONGEST 1430unpack_field_as_long (struct type *type, const gdb_byte *valaddr, int fieldno) 1431{ 1432 ULONGEST val; 1433 ULONGEST valmask; 1434 int bitpos = TYPE_FIELD_BITPOS (type, fieldno); 1435 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); 1436 int lsbcount; 1437 struct type *field_type; 1438 1439 val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val)); 1440 field_type = TYPE_FIELD_TYPE (type, fieldno); 1441 CHECK_TYPEDEF (field_type); 1442 1443 /* Extract bits. See comment above. */ 1444 1445 if (BITS_BIG_ENDIAN) 1446 lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize); 1447 else 1448 lsbcount = (bitpos % 8); 1449 val >>= lsbcount; 1450 1451 /* If the field does not entirely fill a LONGEST, then zero the sign bits. 1452 If the field is signed, and is negative, then sign extend. */ 1453 1454 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val))) 1455 { 1456 valmask = (((ULONGEST) 1) << bitsize) - 1; 1457 val &= valmask; 1458 if (!TYPE_UNSIGNED (field_type)) 1459 { 1460 if (val & (valmask ^ (valmask >> 1))) 1461 { 1462 val |= ~valmask; 1463 } 1464 } 1465 } 1466 return (val); 1467} 1468 1469/* Modify the value of a bitfield. ADDR points to a block of memory in 1470 target byte order; the bitfield starts in the byte pointed to. FIELDVAL 1471 is the desired value of the field, in host byte order. BITPOS and BITSIZE 1472 indicate which bits (in target bit order) comprise the bitfield. 1473 Requires 0 < BITSIZE <= lbits, 0 <= BITPOS+BITSIZE <= lbits, and 1474 0 <= BITPOS, where lbits is the size of a LONGEST in bits. */ 1475 1476void 1477modify_field (gdb_byte *addr, LONGEST fieldval, int bitpos, int bitsize) 1478{ 1479 ULONGEST oword; 1480 ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize); 1481 1482 /* If a negative fieldval fits in the field in question, chop 1483 off the sign extension bits. */ 1484 if ((~fieldval & ~(mask >> 1)) == 0) 1485 fieldval &= mask; 1486 1487 /* Warn if value is too big to fit in the field in question. */ 1488 if (0 != (fieldval & ~mask)) 1489 { 1490 /* FIXME: would like to include fieldval in the message, but 1491 we don't have a sprintf_longest. */ 1492 warning (_("Value does not fit in %d bits."), bitsize); 1493 1494 /* Truncate it, otherwise adjoining fields may be corrupted. */ 1495 fieldval &= mask; 1496 } 1497 1498 oword = extract_unsigned_integer (addr, sizeof oword); 1499 1500 /* Shifting for bit field depends on endianness of the target machine. */ 1501 if (BITS_BIG_ENDIAN) 1502 bitpos = sizeof (oword) * 8 - bitpos - bitsize; 1503 1504 oword &= ~(mask << bitpos); 1505 oword |= fieldval << bitpos; 1506 1507 store_unsigned_integer (addr, sizeof oword, oword); 1508} 1509 1510/* Pack NUM into BUF using a target format of TYPE. */ 1511 1512void 1513pack_long (gdb_byte *buf, struct type *type, LONGEST num) 1514{ 1515 int len; 1516 1517 type = check_typedef (type); 1518 len = TYPE_LENGTH (type); 1519 1520 switch (TYPE_CODE (type)) 1521 { 1522 case TYPE_CODE_INT: 1523 case TYPE_CODE_CHAR: 1524 case TYPE_CODE_ENUM: 1525 case TYPE_CODE_FLAGS: 1526 case TYPE_CODE_BOOL: 1527 case TYPE_CODE_RANGE: 1528 case TYPE_CODE_MEMBERPTR: 1529 store_signed_integer (buf, len, num); 1530 break; 1531 1532 case TYPE_CODE_REF: 1533 case TYPE_CODE_PTR: 1534 store_typed_address (buf, type, (CORE_ADDR) num); 1535 break; 1536 1537 default: 1538 error (_("Unexpected type (%d) encountered for integer constant."), 1539 TYPE_CODE (type)); 1540 } 1541} 1542 1543 1544/* Convert C numbers into newly allocated values. */ 1545 1546struct value * 1547value_from_longest (struct type *type, LONGEST num) 1548{ 1549 struct value *val = allocate_value (type); 1550 1551 pack_long (value_contents_raw (val), type, num); 1552 1553 return val; 1554} 1555 1556 1557/* Create a value representing a pointer of type TYPE to the address 1558 ADDR. */ 1559struct value * 1560value_from_pointer (struct type *type, CORE_ADDR addr) 1561{ 1562 struct value *val = allocate_value (type); 1563 store_typed_address (value_contents_raw (val), type, addr); 1564 return val; 1565} 1566 1567 1568/* Create a value for a string constant to be stored locally 1569 (not in the inferior's memory space, but in GDB memory). 1570 This is analogous to value_from_longest, which also does not 1571 use inferior memory. String shall NOT contain embedded nulls. */ 1572 1573struct value * 1574value_from_string (char *ptr) 1575{ 1576 struct value *val; 1577 int len = strlen (ptr); 1578 int lowbound = current_language->string_lower_bound; 1579 struct type *string_char_type; 1580 struct type *rangetype; 1581 struct type *stringtype; 1582 1583 rangetype = create_range_type ((struct type *) NULL, 1584 builtin_type_int, 1585 lowbound, len + lowbound - 1); 1586 string_char_type = language_string_char_type (current_language, 1587 current_gdbarch); 1588 stringtype = create_array_type ((struct type *) NULL, 1589 string_char_type, 1590 rangetype); 1591 val = allocate_value (stringtype); 1592 memcpy (value_contents_raw (val), ptr, len); 1593 return val; 1594} 1595 1596struct value * 1597value_from_double (struct type *type, DOUBLEST num) 1598{ 1599 struct value *val = allocate_value (type); 1600 struct type *base_type = check_typedef (type); 1601 enum type_code code = TYPE_CODE (base_type); 1602 int len = TYPE_LENGTH (base_type); 1603 1604 if (code == TYPE_CODE_FLT) 1605 { 1606 store_typed_floating (value_contents_raw (val), base_type, num); 1607 } 1608 else 1609 error (_("Unexpected type encountered for floating constant.")); 1610 1611 return val; 1612} 1613 1614struct value * 1615coerce_ref (struct value *arg) 1616{ 1617 struct type *value_type_arg_tmp = check_typedef (value_type (arg)); 1618 if (TYPE_CODE (value_type_arg_tmp) == TYPE_CODE_REF) 1619 arg = value_at_lazy (TYPE_TARGET_TYPE (value_type_arg_tmp), 1620 unpack_pointer (value_type (arg), 1621 value_contents (arg))); 1622 return arg; 1623} 1624 1625struct value * 1626coerce_array (struct value *arg) 1627{ 1628 arg = coerce_ref (arg); 1629 if (current_language->c_style_arrays 1630 && TYPE_CODE (value_type (arg)) == TYPE_CODE_ARRAY) 1631 arg = value_coerce_array (arg); 1632 if (TYPE_CODE (value_type (arg)) == TYPE_CODE_FUNC) 1633 arg = value_coerce_function (arg); 1634 return arg; 1635} 1636 1637struct value * 1638coerce_number (struct value *arg) 1639{ 1640 arg = coerce_array (arg); 1641 arg = coerce_enum (arg); 1642 return arg; 1643} 1644 1645struct value * 1646coerce_enum (struct value *arg) 1647{ 1648 if (TYPE_CODE (check_typedef (value_type (arg))) == TYPE_CODE_ENUM) 1649 arg = value_cast (builtin_type_unsigned_int, arg); 1650 return arg; 1651} 1652 1653 1654/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of 1655 gdbarch_extract_return_value? GCC_P is true if compiled with gcc and TYPE 1656 is the type (which is known to be struct, union or array). 1657 1658 On most machines, the struct convention is used unless we are 1659 using gcc and the type is of a special size. */ 1660/* As of about 31 Mar 93, GCC was changed to be compatible with the 1661 native compiler. GCC 2.3.3 was the last release that did it the 1662 old way. Since gcc2_compiled was not changed, we have no 1663 way to correctly win in all cases, so we just do the right thing 1664 for gcc1 and for gcc2 after this change. Thus it loses for gcc 1665 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled 1666 would cause more chaos than dealing with some struct returns being 1667 handled wrong. */ 1668/* NOTE: cagney/2004-06-13: Deleted check for "gcc_p". GCC 1.x is 1669 dead. */ 1670 1671int 1672generic_use_struct_convention (int gcc_p, struct type *value_type) 1673{ 1674 return !(TYPE_LENGTH (value_type) == 1 1675 || TYPE_LENGTH (value_type) == 2 1676 || TYPE_LENGTH (value_type) == 4 1677 || TYPE_LENGTH (value_type) == 8); 1678} 1679 1680/* Return true if the function returning the specified type is using 1681 the convention of returning structures in memory (passing in the 1682 address as a hidden first parameter). GCC_P is nonzero if compiled 1683 with GCC. */ 1684 1685int 1686using_struct_return (struct type *value_type, int gcc_p) 1687{ 1688 enum type_code code = TYPE_CODE (value_type); 1689 1690 if (code == TYPE_CODE_ERROR) 1691 error (_("Function return type unknown.")); 1692 1693 if (code == TYPE_CODE_VOID) 1694 /* A void return value is never in memory. See also corresponding 1695 code in "print_return_value". */ 1696 return 0; 1697 1698 /* Probe the architecture for the return-value convention. */ 1699 return (gdbarch_return_value (current_gdbarch, value_type, 1700 NULL, NULL, NULL) 1701 != RETURN_VALUE_REGISTER_CONVENTION); 1702} 1703 1704/* Set the initialized field in a value struct. */ 1705 1706void 1707set_value_initialized (struct value *val, int status) 1708{ 1709 val->initialized = status; 1710} 1711 1712/* Return the initialized field in a value struct. */ 1713 1714int 1715value_initialized (struct value *val) 1716{ 1717 return val->initialized; 1718} 1719 1720void 1721_initialize_values (void) 1722{ 1723 add_cmd ("convenience", no_class, show_convenience, _("\ 1724Debugger convenience (\"$foo\") variables.\n\ 1725These variables are created when you assign them values;\n\ 1726thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\ 1727\n\ 1728A few convenience variables are given values automatically:\n\ 1729\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\ 1730\"$__\" holds the contents of the last address examined with \"x\"."), 1731 &showlist); 1732 1733 add_cmd ("values", no_class, show_values, 1734 _("Elements of value history around item number IDX (or last ten)."), 1735 &showlist); 1736 1737 add_com ("init-if-undefined", class_vars, init_if_undefined_command, _("\ 1738Initialize a convenience variable if necessary.\n\ 1739init-if-undefined VARIABLE = EXPRESSION\n\ 1740Set an internal VARIABLE to the result of the EXPRESSION if it does not\n\ 1741exist or does not contain a value. The EXPRESSION is not evaluated if the\n\ 1742VARIABLE is already initialized.")); 1743} 1744