1/* Low level packing and unpacking of values for GDB, the GNU Debugger. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003 Free Software 5 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 2 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, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, 22 Boston, MA 02111-1307, USA. */ 23 24#include "defs.h" 25#include "gdb_string.h" 26#include "symtab.h" 27#include "gdbtypes.h" 28#include "value.h" 29#include "gdbcore.h" 30#include "command.h" 31#include "gdbcmd.h" 32#include "target.h" 33#include "language.h" 34#include "scm-lang.h" 35#include "demangle.h" 36#include "doublest.h" 37#include "gdb_assert.h" 38#include "regcache.h" 39#include "block.h" 40 41/* Prototypes for exported functions. */ 42 43void _initialize_values (void); 44 45/* Prototypes for local functions. */ 46 47static void show_values (char *, int); 48 49static void show_convenience (char *, int); 50 51 52/* The value-history records all the values printed 53 by print commands during this session. Each chunk 54 records 60 consecutive values. The first chunk on 55 the chain records the most recent values. 56 The total number of values is in value_history_count. */ 57 58#define VALUE_HISTORY_CHUNK 60 59 60struct value_history_chunk 61 { 62 struct value_history_chunk *next; 63 struct value *values[VALUE_HISTORY_CHUNK]; 64 }; 65 66/* Chain of chunks now in use. */ 67 68static struct value_history_chunk *value_history_chain; 69 70static int value_history_count; /* Abs number of last entry stored */ 71 72/* List of all value objects currently allocated 73 (except for those released by calls to release_value) 74 This is so they can be freed after each command. */ 75 76static struct value *all_values; 77 78/* Allocate a value that has the correct length for type TYPE. */ 79 80struct value * 81allocate_value (struct type *type) 82{ 83 struct value *val; 84 struct type *atype = check_typedef (type); 85 86 val = (struct value *) xmalloc (sizeof (struct value) + TYPE_LENGTH (atype)); 87 VALUE_NEXT (val) = all_values; 88 all_values = val; 89 VALUE_TYPE (val) = type; 90 VALUE_ENCLOSING_TYPE (val) = type; 91 VALUE_LVAL (val) = not_lval; 92 VALUE_ADDRESS (val) = 0; 93 VALUE_FRAME_ID (val) = null_frame_id; 94 VALUE_OFFSET (val) = 0; 95 VALUE_BITPOS (val) = 0; 96 VALUE_BITSIZE (val) = 0; 97 VALUE_REGNO (val) = -1; 98 VALUE_LAZY (val) = 0; 99 VALUE_OPTIMIZED_OUT (val) = 0; 100 VALUE_BFD_SECTION (val) = NULL; 101 VALUE_EMBEDDED_OFFSET (val) = 0; 102 VALUE_POINTED_TO_OFFSET (val) = 0; 103 val->modifiable = 1; 104 val->initialized = 1; /* Default to initialized. */ 105 return val; 106} 107 108/* Allocate a value that has the correct length 109 for COUNT repetitions type TYPE. */ 110 111struct value * 112allocate_repeat_value (struct type *type, int count) 113{ 114 int low_bound = current_language->string_lower_bound; /* ??? */ 115 /* FIXME-type-allocation: need a way to free this type when we are 116 done with it. */ 117 struct type *range_type 118 = create_range_type ((struct type *) NULL, builtin_type_int, 119 low_bound, count + low_bound - 1); 120 /* FIXME-type-allocation: need a way to free this type when we are 121 done with it. */ 122 return allocate_value (create_array_type ((struct type *) NULL, 123 type, range_type)); 124} 125 126/* Return a mark in the value chain. All values allocated after the 127 mark is obtained (except for those released) are subject to being freed 128 if a subsequent value_free_to_mark is passed the mark. */ 129struct value * 130value_mark (void) 131{ 132 return all_values; 133} 134 135/* Free all values allocated since MARK was obtained by value_mark 136 (except for those released). */ 137void 138value_free_to_mark (struct value *mark) 139{ 140 struct value *val; 141 struct value *next; 142 143 for (val = all_values; val && val != mark; val = next) 144 { 145 next = VALUE_NEXT (val); 146 value_free (val); 147 } 148 all_values = val; 149} 150 151/* Free all the values that have been allocated (except for those released). 152 Called after each command, successful or not. */ 153 154void 155free_all_values (void) 156{ 157 struct value *val; 158 struct value *next; 159 160 for (val = all_values; val; val = next) 161 { 162 next = VALUE_NEXT (val); 163 value_free (val); 164 } 165 166 all_values = 0; 167} 168 169/* Remove VAL from the chain all_values 170 so it will not be freed automatically. */ 171 172void 173release_value (struct value *val) 174{ 175 struct value *v; 176 177 if (all_values == val) 178 { 179 all_values = val->next; 180 return; 181 } 182 183 for (v = all_values; v; v = v->next) 184 { 185 if (v->next == val) 186 { 187 v->next = val->next; 188 break; 189 } 190 } 191} 192 193/* Release all values up to mark */ 194struct value * 195value_release_to_mark (struct value *mark) 196{ 197 struct value *val; 198 struct value *next; 199 200 for (val = next = all_values; next; next = VALUE_NEXT (next)) 201 if (VALUE_NEXT (next) == mark) 202 { 203 all_values = VALUE_NEXT (next); 204 VALUE_NEXT (next) = 0; 205 return val; 206 } 207 all_values = 0; 208 return val; 209} 210 211/* Return a copy of the value ARG. 212 It contains the same contents, for same memory address, 213 but it's a different block of storage. */ 214 215struct value * 216value_copy (struct value *arg) 217{ 218 struct type *encl_type = VALUE_ENCLOSING_TYPE (arg); 219 struct value *val = allocate_value (encl_type); 220 VALUE_TYPE (val) = VALUE_TYPE (arg); 221 VALUE_LVAL (val) = VALUE_LVAL (arg); 222 VALUE_ADDRESS (val) = VALUE_ADDRESS (arg); 223 VALUE_OFFSET (val) = VALUE_OFFSET (arg); 224 VALUE_BITPOS (val) = VALUE_BITPOS (arg); 225 VALUE_BITSIZE (val) = VALUE_BITSIZE (arg); 226 VALUE_FRAME_ID (val) = VALUE_FRAME_ID (arg); 227 VALUE_REGNO (val) = VALUE_REGNO (arg); 228 VALUE_LAZY (val) = VALUE_LAZY (arg); 229 VALUE_OPTIMIZED_OUT (val) = VALUE_OPTIMIZED_OUT (arg); 230 VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (arg); 231 VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (arg); 232 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (arg); 233 val->modifiable = arg->modifiable; 234 if (!VALUE_LAZY (val)) 235 { 236 memcpy (VALUE_CONTENTS_ALL_RAW (val), VALUE_CONTENTS_ALL_RAW (arg), 237 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg))); 238 239 } 240 return val; 241} 242 243/* Access to the value history. */ 244 245/* Record a new value in the value history. 246 Returns the absolute history index of the entry. 247 Result of -1 indicates the value was not saved; otherwise it is the 248 value history index of this new item. */ 249 250int 251record_latest_value (struct value *val) 252{ 253 int i; 254 255 /* We don't want this value to have anything to do with the inferior anymore. 256 In particular, "set $1 = 50" should not affect the variable from which 257 the value was taken, and fast watchpoints should be able to assume that 258 a value on the value history never changes. */ 259 if (VALUE_LAZY (val)) 260 value_fetch_lazy (val); 261 /* We preserve VALUE_LVAL so that the user can find out where it was fetched 262 from. This is a bit dubious, because then *&$1 does not just return $1 263 but the current contents of that location. c'est la vie... */ 264 val->modifiable = 0; 265 release_value (val); 266 267 /* Here we treat value_history_count as origin-zero 268 and applying to the value being stored now. */ 269 270 i = value_history_count % VALUE_HISTORY_CHUNK; 271 if (i == 0) 272 { 273 struct value_history_chunk *new 274 = (struct value_history_chunk *) 275 xmalloc (sizeof (struct value_history_chunk)); 276 memset (new->values, 0, sizeof new->values); 277 new->next = value_history_chain; 278 value_history_chain = new; 279 } 280 281 value_history_chain->values[i] = val; 282 283 /* Now we regard value_history_count as origin-one 284 and applying to the value just stored. */ 285 286 return ++value_history_count; 287} 288 289/* Return a copy of the value in the history with sequence number NUM. */ 290 291struct value * 292access_value_history (int num) 293{ 294 struct value_history_chunk *chunk; 295 int i; 296 int absnum = num; 297 298 if (absnum <= 0) 299 absnum += value_history_count; 300 301 if (absnum <= 0) 302 { 303 if (num == 0) 304 error ("The history is empty."); 305 else if (num == 1) 306 error ("There is only one value in the history."); 307 else 308 error ("History does not go back to $$%d.", -num); 309 } 310 if (absnum > value_history_count) 311 error ("History has not yet reached $%d.", absnum); 312 313 absnum--; 314 315 /* Now absnum is always absolute and origin zero. */ 316 317 chunk = value_history_chain; 318 for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK; 319 i > 0; i--) 320 chunk = chunk->next; 321 322 return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]); 323} 324 325/* Clear the value history entirely. 326 Must be done when new symbol tables are loaded, 327 because the type pointers become invalid. */ 328 329void 330clear_value_history (void) 331{ 332 struct value_history_chunk *next; 333 int i; 334 struct value *val; 335 336 while (value_history_chain) 337 { 338 for (i = 0; i < VALUE_HISTORY_CHUNK; i++) 339 if ((val = value_history_chain->values[i]) != NULL) 340 xfree (val); 341 next = value_history_chain->next; 342 xfree (value_history_chain); 343 value_history_chain = next; 344 } 345 value_history_count = 0; 346} 347 348static void 349show_values (char *num_exp, int from_tty) 350{ 351 int i; 352 struct value *val; 353 static int num = 1; 354 355 if (num_exp) 356 { 357 /* "info history +" should print from the stored position. 358 "info history <exp>" should print around value number <exp>. */ 359 if (num_exp[0] != '+' || num_exp[1] != '\0') 360 num = parse_and_eval_long (num_exp) - 5; 361 } 362 else 363 { 364 /* "info history" means print the last 10 values. */ 365 num = value_history_count - 9; 366 } 367 368 if (num <= 0) 369 num = 1; 370 371 for (i = num; i < num + 10 && i <= value_history_count; i++) 372 { 373 val = access_value_history (i); 374 printf_filtered ("$%d = ", i); 375 value_print (val, gdb_stdout, 0, Val_pretty_default); 376 printf_filtered ("\n"); 377 } 378 379 /* The next "info history +" should start after what we just printed. */ 380 num += 10; 381 382 /* Hitting just return after this command should do the same thing as 383 "info history +". If num_exp is null, this is unnecessary, since 384 "info history +" is not useful after "info history". */ 385 if (from_tty && num_exp) 386 { 387 num_exp[0] = '+'; 388 num_exp[1] = '\0'; 389 } 390} 391 392/* Internal variables. These are variables within the debugger 393 that hold values assigned by debugger commands. 394 The user refers to them with a '$' prefix 395 that does not appear in the variable names stored internally. */ 396 397static struct internalvar *internalvars; 398 399/* Look up an internal variable with name NAME. NAME should not 400 normally include a dollar sign. 401 402 If the specified internal variable does not exist, 403 one is created, with a void value. */ 404 405struct internalvar * 406lookup_internalvar (char *name) 407{ 408 struct internalvar *var; 409 410 for (var = internalvars; var; var = var->next) 411 if (strcmp (var->name, name) == 0) 412 return var; 413 414 var = (struct internalvar *) xmalloc (sizeof (struct internalvar)); 415 var->name = concat (name, NULL); 416 var->value = allocate_value (builtin_type_void); 417 release_value (var->value); 418 var->next = internalvars; 419 internalvars = var; 420 return var; 421} 422 423struct value * 424value_of_internalvar (struct internalvar *var) 425{ 426 struct value *val; 427 428 val = value_copy (var->value); 429 if (VALUE_LAZY (val)) 430 value_fetch_lazy (val); 431 VALUE_LVAL (val) = lval_internalvar; 432 VALUE_INTERNALVAR (val) = var; 433 return val; 434} 435 436void 437set_internalvar_component (struct internalvar *var, int offset, int bitpos, 438 int bitsize, struct value *newval) 439{ 440 char *addr = VALUE_CONTENTS (var->value) + offset; 441 442 if (bitsize) 443 modify_field (addr, value_as_long (newval), 444 bitpos, bitsize); 445 else 446 memcpy (addr, VALUE_CONTENTS (newval), TYPE_LENGTH (VALUE_TYPE (newval))); 447} 448 449void 450set_internalvar (struct internalvar *var, struct value *val) 451{ 452 struct value *newval; 453 454 newval = value_copy (val); 455 newval->modifiable = 1; 456 457 /* Force the value to be fetched from the target now, to avoid problems 458 later when this internalvar is referenced and the target is gone or 459 has changed. */ 460 if (VALUE_LAZY (newval)) 461 value_fetch_lazy (newval); 462 463 /* Begin code which must not call error(). If var->value points to 464 something free'd, an error() obviously leaves a dangling pointer. 465 But we also get a danling pointer if var->value points to 466 something in the value chain (i.e., before release_value is 467 called), because after the error free_all_values will get called before 468 long. */ 469 xfree (var->value); 470 var->value = newval; 471 release_value (newval); 472 /* End code which must not call error(). */ 473} 474 475char * 476internalvar_name (struct internalvar *var) 477{ 478 return var->name; 479} 480 481/* Free all internalvars. Done when new symtabs are loaded, 482 because that makes the values invalid. */ 483 484void 485clear_internalvars (void) 486{ 487 struct internalvar *var; 488 489 while (internalvars) 490 { 491 var = internalvars; 492 internalvars = var->next; 493 xfree (var->name); 494 xfree (var->value); 495 xfree (var); 496 } 497} 498 499static void 500show_convenience (char *ignore, int from_tty) 501{ 502 struct internalvar *var; 503 int varseen = 0; 504 505 for (var = internalvars; var; var = var->next) 506 { 507 if (!varseen) 508 { 509 varseen = 1; 510 } 511 printf_filtered ("$%s = ", var->name); 512 value_print (var->value, gdb_stdout, 0, Val_pretty_default); 513 printf_filtered ("\n"); 514 } 515 if (!varseen) 516 printf_unfiltered ("No debugger convenience variables now defined.\n\ 517Convenience variables have names starting with \"$\";\n\ 518use \"set\" as in \"set $foo = 5\" to define them.\n"); 519} 520 521/* Extract a value as a C number (either long or double). 522 Knows how to convert fixed values to double, or 523 floating values to long. 524 Does not deallocate the value. */ 525 526LONGEST 527value_as_long (struct value *val) 528{ 529 /* This coerces arrays and functions, which is necessary (e.g. 530 in disassemble_command). It also dereferences references, which 531 I suspect is the most logical thing to do. */ 532 COERCE_ARRAY (val); 533 return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val)); 534} 535 536DOUBLEST 537value_as_double (struct value *val) 538{ 539 DOUBLEST foo; 540 int inv; 541 542 foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv); 543 if (inv) 544 error ("Invalid floating value found in program."); 545 return foo; 546} 547/* Extract a value as a C pointer. Does not deallocate the value. 548 Note that val's type may not actually be a pointer; value_as_long 549 handles all the cases. */ 550CORE_ADDR 551value_as_address (struct value *val) 552{ 553 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 554 whether we want this to be true eventually. */ 555#if 0 556 /* ADDR_BITS_REMOVE is wrong if we are being called for a 557 non-address (e.g. argument to "signal", "info break", etc.), or 558 for pointers to char, in which the low bits *are* significant. */ 559 return ADDR_BITS_REMOVE (value_as_long (val)); 560#else 561 562 /* There are several targets (IA-64, PowerPC, and others) which 563 don't represent pointers to functions as simply the address of 564 the function's entry point. For example, on the IA-64, a 565 function pointer points to a two-word descriptor, generated by 566 the linker, which contains the function's entry point, and the 567 value the IA-64 "global pointer" register should have --- to 568 support position-independent code. The linker generates 569 descriptors only for those functions whose addresses are taken. 570 571 On such targets, it's difficult for GDB to convert an arbitrary 572 function address into a function pointer; it has to either find 573 an existing descriptor for that function, or call malloc and 574 build its own. On some targets, it is impossible for GDB to 575 build a descriptor at all: the descriptor must contain a jump 576 instruction; data memory cannot be executed; and code memory 577 cannot be modified. 578 579 Upon entry to this function, if VAL is a value of type `function' 580 (that is, TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC), then 581 VALUE_ADDRESS (val) is the address of the function. This is what 582 you'll get if you evaluate an expression like `main'. The call 583 to COERCE_ARRAY below actually does all the usual unary 584 conversions, which includes converting values of type `function' 585 to `pointer to function'. This is the challenging conversion 586 discussed above. Then, `unpack_long' will convert that pointer 587 back into an address. 588 589 So, suppose the user types `disassemble foo' on an architecture 590 with a strange function pointer representation, on which GDB 591 cannot build its own descriptors, and suppose further that `foo' 592 has no linker-built descriptor. The address->pointer conversion 593 will signal an error and prevent the command from running, even 594 though the next step would have been to convert the pointer 595 directly back into the same address. 596 597 The following shortcut avoids this whole mess. If VAL is a 598 function, just return its address directly. */ 599 if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC 600 || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_METHOD) 601 return VALUE_ADDRESS (val); 602 603 COERCE_ARRAY (val); 604 605 /* Some architectures (e.g. Harvard), map instruction and data 606 addresses onto a single large unified address space. For 607 instance: An architecture may consider a large integer in the 608 range 0x10000000 .. 0x1000ffff to already represent a data 609 addresses (hence not need a pointer to address conversion) while 610 a small integer would still need to be converted integer to 611 pointer to address. Just assume such architectures handle all 612 integer conversions in a single function. */ 613 614 /* JimB writes: 615 616 I think INTEGER_TO_ADDRESS is a good idea as proposed --- but we 617 must admonish GDB hackers to make sure its behavior matches the 618 compiler's, whenever possible. 619 620 In general, I think GDB should evaluate expressions the same way 621 the compiler does. When the user copies an expression out of 622 their source code and hands it to a `print' command, they should 623 get the same value the compiler would have computed. Any 624 deviation from this rule can cause major confusion and annoyance, 625 and needs to be justified carefully. In other words, GDB doesn't 626 really have the freedom to do these conversions in clever and 627 useful ways. 628 629 AndrewC pointed out that users aren't complaining about how GDB 630 casts integers to pointers; they are complaining that they can't 631 take an address from a disassembly listing and give it to `x/i'. 632 This is certainly important. 633 634 Adding an architecture method like INTEGER_TO_ADDRESS certainly 635 makes it possible for GDB to "get it right" in all circumstances 636 --- the target has complete control over how things get done, so 637 people can Do The Right Thing for their target without breaking 638 anyone else. The standard doesn't specify how integers get 639 converted to pointers; usually, the ABI doesn't either, but 640 ABI-specific code is a more reasonable place to handle it. */ 641 642 if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_PTR 643 && TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_REF 644 && INTEGER_TO_ADDRESS_P ()) 645 return INTEGER_TO_ADDRESS (VALUE_TYPE (val), VALUE_CONTENTS (val)); 646 647 return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val)); 648#endif 649} 650 651/* Unpack raw data (copied from debugee, target byte order) at VALADDR 652 as a long, or as a double, assuming the raw data is described 653 by type TYPE. Knows how to convert different sizes of values 654 and can convert between fixed and floating point. We don't assume 655 any alignment for the raw data. Return value is in host byte order. 656 657 If you want functions and arrays to be coerced to pointers, and 658 references to be dereferenced, call value_as_long() instead. 659 660 C++: It is assumed that the front-end has taken care of 661 all matters concerning pointers to members. A pointer 662 to member which reaches here is considered to be equivalent 663 to an INT (or some size). After all, it is only an offset. */ 664 665LONGEST 666unpack_long (struct type *type, const char *valaddr) 667{ 668 enum type_code code = TYPE_CODE (type); 669 int len = TYPE_LENGTH (type); 670 int nosign = TYPE_UNSIGNED (type); 671 672 if (current_language->la_language == language_scm 673 && is_scmvalue_type (type)) 674 return scm_unpack (type, valaddr, TYPE_CODE_INT); 675 676 switch (code) 677 { 678 case TYPE_CODE_TYPEDEF: 679 return unpack_long (check_typedef (type), valaddr); 680 case TYPE_CODE_ENUM: 681 case TYPE_CODE_BOOL: 682 case TYPE_CODE_INT: 683 case TYPE_CODE_CHAR: 684 case TYPE_CODE_RANGE: 685 if (nosign) 686 return extract_unsigned_integer (valaddr, len); 687 else 688 return extract_signed_integer (valaddr, len); 689 690 case TYPE_CODE_FLT: 691 return extract_typed_floating (valaddr, type); 692 693 case TYPE_CODE_PTR: 694 case TYPE_CODE_REF: 695 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 696 whether we want this to be true eventually. */ 697 return extract_typed_address (valaddr, type); 698 699 case TYPE_CODE_MEMBER: 700 error ("not implemented: member types in unpack_long"); 701 702 default: 703 error ("Value can't be converted to integer."); 704 } 705 return 0; /* Placate lint. */ 706} 707 708/* Return a double value from the specified type and address. 709 INVP points to an int which is set to 0 for valid value, 710 1 for invalid value (bad float format). In either case, 711 the returned double is OK to use. Argument is in target 712 format, result is in host format. */ 713 714DOUBLEST 715unpack_double (struct type *type, const char *valaddr, int *invp) 716{ 717 enum type_code code; 718 int len; 719 int nosign; 720 721 *invp = 0; /* Assume valid. */ 722 CHECK_TYPEDEF (type); 723 code = TYPE_CODE (type); 724 len = TYPE_LENGTH (type); 725 nosign = TYPE_UNSIGNED (type); 726 if (code == TYPE_CODE_FLT) 727 { 728 /* NOTE: cagney/2002-02-19: There was a test here to see if the 729 floating-point value was valid (using the macro 730 INVALID_FLOAT). That test/macro have been removed. 731 732 It turns out that only the VAX defined this macro and then 733 only in a non-portable way. Fixing the portability problem 734 wouldn't help since the VAX floating-point code is also badly 735 bit-rotten. The target needs to add definitions for the 736 methods TARGET_FLOAT_FORMAT and TARGET_DOUBLE_FORMAT - these 737 exactly describe the target floating-point format. The 738 problem here is that the corresponding floatformat_vax_f and 739 floatformat_vax_d values these methods should be set to are 740 also not defined either. Oops! 741 742 Hopefully someone will add both the missing floatformat 743 definitions and the new cases for floatformat_is_valid (). */ 744 745 if (!floatformat_is_valid (floatformat_from_type (type), valaddr)) 746 { 747 *invp = 1; 748 return 0.0; 749 } 750 751 return extract_typed_floating (valaddr, type); 752 } 753 else if (nosign) 754 { 755 /* Unsigned -- be sure we compensate for signed LONGEST. */ 756 return (ULONGEST) unpack_long (type, valaddr); 757 } 758 else 759 { 760 /* Signed -- we are OK with unpack_long. */ 761 return unpack_long (type, valaddr); 762 } 763} 764 765/* Unpack raw data (copied from debugee, target byte order) at VALADDR 766 as a CORE_ADDR, assuming the raw data is described by type TYPE. 767 We don't assume any alignment for the raw data. Return value is in 768 host byte order. 769 770 If you want functions and arrays to be coerced to pointers, and 771 references to be dereferenced, call value_as_address() instead. 772 773 C++: It is assumed that the front-end has taken care of 774 all matters concerning pointers to members. A pointer 775 to member which reaches here is considered to be equivalent 776 to an INT (or some size). After all, it is only an offset. */ 777 778CORE_ADDR 779unpack_pointer (struct type *type, const char *valaddr) 780{ 781 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure 782 whether we want this to be true eventually. */ 783 return unpack_long (type, valaddr); 784} 785 786 787/* Get the value of the FIELDN'th field (which must be static) of 788 TYPE. Return NULL if the field doesn't exist or has been 789 optimized out. */ 790 791struct value * 792value_static_field (struct type *type, int fieldno) 793{ 794 struct value *retval; 795 796 if (TYPE_FIELD_STATIC_HAS_ADDR (type, fieldno)) 797 { 798 retval = value_at (TYPE_FIELD_TYPE (type, fieldno), 799 TYPE_FIELD_STATIC_PHYSADDR (type, fieldno), 800 NULL); 801 } 802 else 803 { 804 char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno); 805 struct symbol *sym = lookup_symbol (phys_name, 0, VAR_DOMAIN, 0, NULL); 806 if (sym == NULL) 807 { 808 /* With some compilers, e.g. HP aCC, static data members are reported 809 as non-debuggable symbols */ 810 struct minimal_symbol *msym = lookup_minimal_symbol (phys_name, NULL, NULL); 811 if (!msym) 812 return NULL; 813 else 814 { 815 retval = value_at (TYPE_FIELD_TYPE (type, fieldno), 816 SYMBOL_VALUE_ADDRESS (msym), 817 SYMBOL_BFD_SECTION (msym)); 818 } 819 } 820 else 821 { 822 /* SYM should never have a SYMBOL_CLASS which will require 823 read_var_value to use the FRAME parameter. */ 824 if (symbol_read_needs_frame (sym)) 825 warning ("static field's value depends on the current " 826 "frame - bad debug info?"); 827 retval = read_var_value (sym, NULL); 828 } 829 if (retval && VALUE_LVAL (retval) == lval_memory) 830 SET_FIELD_PHYSADDR (TYPE_FIELD (type, fieldno), 831 VALUE_ADDRESS (retval)); 832 } 833 return retval; 834} 835 836/* Change the enclosing type of a value object VAL to NEW_ENCL_TYPE. 837 You have to be careful here, since the size of the data area for the value 838 is set by the length of the enclosing type. So if NEW_ENCL_TYPE is bigger 839 than the old enclosing type, you have to allocate more space for the data. 840 The return value is a pointer to the new version of this value structure. */ 841 842struct value * 843value_change_enclosing_type (struct value *val, struct type *new_encl_type) 844{ 845 if (TYPE_LENGTH (new_encl_type) <= TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val))) 846 { 847 VALUE_ENCLOSING_TYPE (val) = new_encl_type; 848 return val; 849 } 850 else 851 { 852 struct value *new_val; 853 struct value *prev; 854 855 new_val = (struct value *) xrealloc (val, sizeof (struct value) + TYPE_LENGTH (new_encl_type)); 856 857 VALUE_ENCLOSING_TYPE (new_val) = new_encl_type; 858 859 /* We have to make sure this ends up in the same place in the value 860 chain as the original copy, so it's clean-up behavior is the same. 861 If the value has been released, this is a waste of time, but there 862 is no way to tell that in advance, so... */ 863 864 if (val != all_values) 865 { 866 for (prev = all_values; prev != NULL; prev = prev->next) 867 { 868 if (prev->next == val) 869 { 870 prev->next = new_val; 871 break; 872 } 873 } 874 } 875 876 return new_val; 877 } 878} 879 880/* Given a value ARG1 (offset by OFFSET bytes) 881 of a struct or union type ARG_TYPE, 882 extract and return the value of one of its (non-static) fields. 883 FIELDNO says which field. */ 884 885struct value * 886value_primitive_field (struct value *arg1, int offset, 887 int fieldno, struct type *arg_type) 888{ 889 struct value *v; 890 struct type *type; 891 892 CHECK_TYPEDEF (arg_type); 893 type = TYPE_FIELD_TYPE (arg_type, fieldno); 894 895 /* Handle packed fields */ 896 897 if (TYPE_FIELD_BITSIZE (arg_type, fieldno)) 898 { 899 v = value_from_longest (type, 900 unpack_field_as_long (arg_type, 901 VALUE_CONTENTS (arg1) 902 + offset, 903 fieldno)); 904 VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8; 905 VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno); 906 VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset 907 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; 908 } 909 else if (fieldno < TYPE_N_BASECLASSES (arg_type)) 910 { 911 /* This field is actually a base subobject, so preserve the 912 entire object's contents for later references to virtual 913 bases, etc. */ 914 v = allocate_value (VALUE_ENCLOSING_TYPE (arg1)); 915 VALUE_TYPE (v) = type; 916 if (VALUE_LAZY (arg1)) 917 VALUE_LAZY (v) = 1; 918 else 919 memcpy (VALUE_CONTENTS_ALL_RAW (v), VALUE_CONTENTS_ALL_RAW (arg1), 920 TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg1))); 921 VALUE_OFFSET (v) = VALUE_OFFSET (arg1); 922 VALUE_EMBEDDED_OFFSET (v) 923 = offset + 924 VALUE_EMBEDDED_OFFSET (arg1) + 925 TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; 926 } 927 else 928 { 929 /* Plain old data member */ 930 offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; 931 v = allocate_value (type); 932 if (VALUE_LAZY (arg1)) 933 VALUE_LAZY (v) = 1; 934 else 935 memcpy (VALUE_CONTENTS_RAW (v), 936 VALUE_CONTENTS_RAW (arg1) + offset, 937 TYPE_LENGTH (type)); 938 VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset 939 + VALUE_EMBEDDED_OFFSET (arg1); 940 } 941 VALUE_LVAL (v) = VALUE_LVAL (arg1); 942 if (VALUE_LVAL (arg1) == lval_internalvar) 943 VALUE_LVAL (v) = lval_internalvar_component; 944 VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1); 945 VALUE_REGNO (v) = VALUE_REGNO (arg1); 946/* VALUE_OFFSET (v) = VALUE_OFFSET (arg1) + offset 947 + TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; */ 948 return v; 949} 950 951/* Given a value ARG1 of a struct or union type, 952 extract and return the value of one of its (non-static) fields. 953 FIELDNO says which field. */ 954 955struct value * 956value_field (struct value *arg1, int fieldno) 957{ 958 return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1)); 959} 960 961/* Return a non-virtual function as a value. 962 F is the list of member functions which contains the desired method. 963 J is an index into F which provides the desired method. 964 965 We only use the symbol for its address, so be happy with either a 966 full symbol or a minimal symbol. 967 */ 968 969struct value * 970value_fn_field (struct value **arg1p, struct fn_field *f, int j, struct type *type, 971 int offset) 972{ 973 struct value *v; 974 struct type *ftype = TYPE_FN_FIELD_TYPE (f, j); 975 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j); 976 struct symbol *sym; 977 struct minimal_symbol *msym; 978 979 sym = lookup_symbol (physname, 0, VAR_DOMAIN, 0, NULL); 980 if (sym != NULL) 981 { 982 msym = NULL; 983 } 984 else 985 { 986 gdb_assert (sym == NULL); 987 msym = lookup_minimal_symbol (physname, NULL, NULL); 988 if (msym == NULL) 989 return NULL; 990 } 991 992 v = allocate_value (ftype); 993 if (sym) 994 { 995 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); 996 } 997 else 998 { 999 VALUE_ADDRESS (v) = SYMBOL_VALUE_ADDRESS (msym); 1000 } 1001 1002 if (arg1p) 1003 { 1004 if (type != VALUE_TYPE (*arg1p)) 1005 *arg1p = value_ind (value_cast (lookup_pointer_type (type), 1006 value_addr (*arg1p))); 1007 1008 /* Move the `this' pointer according to the offset. 1009 VALUE_OFFSET (*arg1p) += offset; 1010 */ 1011 } 1012 1013 return v; 1014} 1015 1016 1017/* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at 1018 VALADDR. 1019 1020 Extracting bits depends on endianness of the machine. Compute the 1021 number of least significant bits to discard. For big endian machines, 1022 we compute the total number of bits in the anonymous object, subtract 1023 off the bit count from the MSB of the object to the MSB of the 1024 bitfield, then the size of the bitfield, which leaves the LSB discard 1025 count. For little endian machines, the discard count is simply the 1026 number of bits from the LSB of the anonymous object to the LSB of the 1027 bitfield. 1028 1029 If the field is signed, we also do sign extension. */ 1030 1031LONGEST 1032unpack_field_as_long (struct type *type, const char *valaddr, int fieldno) 1033{ 1034 ULONGEST val; 1035 ULONGEST valmask; 1036 int bitpos = TYPE_FIELD_BITPOS (type, fieldno); 1037 int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); 1038 int lsbcount; 1039 struct type *field_type; 1040 1041 val = extract_unsigned_integer (valaddr + bitpos / 8, sizeof (val)); 1042 field_type = TYPE_FIELD_TYPE (type, fieldno); 1043 CHECK_TYPEDEF (field_type); 1044 1045 /* Extract bits. See comment above. */ 1046 1047 if (BITS_BIG_ENDIAN) 1048 lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize); 1049 else 1050 lsbcount = (bitpos % 8); 1051 val >>= lsbcount; 1052 1053 /* If the field does not entirely fill a LONGEST, then zero the sign bits. 1054 If the field is signed, and is negative, then sign extend. */ 1055 1056 if ((bitsize > 0) && (bitsize < 8 * (int) sizeof (val))) 1057 { 1058 valmask = (((ULONGEST) 1) << bitsize) - 1; 1059 val &= valmask; 1060 if (!TYPE_UNSIGNED (field_type)) 1061 { 1062 if (val & (valmask ^ (valmask >> 1))) 1063 { 1064 val |= ~valmask; 1065 } 1066 } 1067 } 1068 return (val); 1069} 1070 1071/* Modify the value of a bitfield. ADDR points to a block of memory in 1072 target byte order; the bitfield starts in the byte pointed to. FIELDVAL 1073 is the desired value of the field, in host byte order. BITPOS and BITSIZE 1074 indicate which bits (in target bit order) comprise the bitfield. */ 1075 1076void 1077modify_field (char *addr, LONGEST fieldval, int bitpos, int bitsize) 1078{ 1079 LONGEST oword; 1080 1081 /* If a negative fieldval fits in the field in question, chop 1082 off the sign extension bits. */ 1083 if (bitsize < (8 * (int) sizeof (fieldval)) 1084 && (~fieldval & ~((1 << (bitsize - 1)) - 1)) == 0) 1085 fieldval = fieldval & ((1 << bitsize) - 1); 1086 1087 /* Warn if value is too big to fit in the field in question. */ 1088 if (bitsize < (8 * (int) sizeof (fieldval)) 1089 && 0 != (fieldval & ~((1 << bitsize) - 1))) 1090 { 1091 /* FIXME: would like to include fieldval in the message, but 1092 we don't have a sprintf_longest. */ 1093 warning ("Value does not fit in %d bits.", bitsize); 1094 1095 /* Truncate it, otherwise adjoining fields may be corrupted. */ 1096 fieldval = fieldval & ((1 << bitsize) - 1); 1097 } 1098 1099 oword = extract_signed_integer (addr, sizeof oword); 1100 1101 /* Shifting for bit field depends on endianness of the target machine. */ 1102 if (BITS_BIG_ENDIAN) 1103 bitpos = sizeof (oword) * 8 - bitpos - bitsize; 1104 1105 /* Mask out old value, while avoiding shifts >= size of oword */ 1106 if (bitsize < 8 * (int) sizeof (oword)) 1107 oword &= ~(((((ULONGEST) 1) << bitsize) - 1) << bitpos); 1108 else 1109 oword &= ~((~(ULONGEST) 0) << bitpos); 1110 oword |= fieldval << bitpos; 1111 1112 store_signed_integer (addr, sizeof oword, oword); 1113} 1114 1115/* Convert C numbers into newly allocated values */ 1116 1117struct value * 1118value_from_longest (struct type *type, LONGEST num) 1119{ 1120 struct value *val = allocate_value (type); 1121 enum type_code code; 1122 int len; 1123retry: 1124 code = TYPE_CODE (type); 1125 len = TYPE_LENGTH (type); 1126 1127 switch (code) 1128 { 1129 case TYPE_CODE_TYPEDEF: 1130 type = check_typedef (type); 1131 goto retry; 1132 case TYPE_CODE_INT: 1133 case TYPE_CODE_CHAR: 1134 case TYPE_CODE_ENUM: 1135 case TYPE_CODE_BOOL: 1136 case TYPE_CODE_RANGE: 1137 store_signed_integer (VALUE_CONTENTS_RAW (val), len, num); 1138 break; 1139 1140 case TYPE_CODE_REF: 1141 case TYPE_CODE_PTR: 1142 store_typed_address (VALUE_CONTENTS_RAW (val), type, (CORE_ADDR) num); 1143 break; 1144 1145 default: 1146 error ("Unexpected type (%d) encountered for integer constant.", code); 1147 } 1148 return val; 1149} 1150 1151 1152/* Create a value representing a pointer of type TYPE to the address 1153 ADDR. */ 1154struct value * 1155value_from_pointer (struct type *type, CORE_ADDR addr) 1156{ 1157 struct value *val = allocate_value (type); 1158 store_typed_address (VALUE_CONTENTS_RAW (val), type, addr); 1159 return val; 1160} 1161 1162 1163/* Create a value for a string constant to be stored locally 1164 (not in the inferior's memory space, but in GDB memory). 1165 This is analogous to value_from_longest, which also does not 1166 use inferior memory. String shall NOT contain embedded nulls. */ 1167 1168struct value * 1169value_from_string (char *ptr) 1170{ 1171 struct value *val; 1172 int len = strlen (ptr); 1173 int lowbound = current_language->string_lower_bound; 1174 struct type *rangetype = 1175 create_range_type ((struct type *) NULL, 1176 builtin_type_int, 1177 lowbound, len + lowbound - 1); 1178 struct type *stringtype = 1179 create_array_type ((struct type *) NULL, 1180 *current_language->string_char_type, 1181 rangetype); 1182 1183 val = allocate_value (stringtype); 1184 memcpy (VALUE_CONTENTS_RAW (val), ptr, len); 1185 return val; 1186} 1187 1188struct value * 1189value_from_double (struct type *type, DOUBLEST num) 1190{ 1191 struct value *val = allocate_value (type); 1192 struct type *base_type = check_typedef (type); 1193 enum type_code code = TYPE_CODE (base_type); 1194 int len = TYPE_LENGTH (base_type); 1195 1196 if (code == TYPE_CODE_FLT) 1197 { 1198 store_typed_floating (VALUE_CONTENTS_RAW (val), base_type, num); 1199 } 1200 else 1201 error ("Unexpected type encountered for floating constant."); 1202 1203 return val; 1204} 1205 1206/* Deal with the return-value of a function that has "just returned". 1207 1208 Extract the return-value (as a "struct value") that a function, 1209 using register convention, has just returned to its caller. Assume 1210 that the type of the function is VALTYPE, and that the "just 1211 returned" register state is found in RETBUF. 1212 1213 The function has "just returned" because GDB halts a returning 1214 function by setting a breakpoint at the return address (in the 1215 caller), and not the return instruction (in the callee). 1216 1217 Because, in the case of a return from an inferior function call, 1218 GDB needs to restore the inferiors registers, RETBUF is normally a 1219 copy of the inferior's registers. */ 1220 1221struct value * 1222register_value_being_returned (struct type *valtype, struct regcache *retbuf) 1223{ 1224 struct value *val = allocate_value (valtype); 1225 1226 /* If the function returns void, don't bother fetching the return 1227 value. See also "using_struct_return". */ 1228 if (TYPE_CODE (valtype) == TYPE_CODE_VOID) 1229 return val; 1230 1231 if (!gdbarch_return_value_p (current_gdbarch)) 1232 { 1233 /* NOTE: cagney/2003-10-20: Unlike "gdbarch_return_value", the 1234 EXTRACT_RETURN_VALUE and USE_STRUCT_CONVENTION methods do not 1235 handle the edge case of a function returning a small 1236 structure / union in registers. */ 1237 CHECK_TYPEDEF (valtype); 1238 EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val)); 1239 return val; 1240 } 1241 1242 /* This function only handles "register convention". */ 1243 gdb_assert (gdbarch_return_value (current_gdbarch, valtype, 1244 NULL, NULL, NULL) 1245 == RETURN_VALUE_REGISTER_CONVENTION); 1246 gdbarch_return_value (current_gdbarch, valtype, retbuf, 1247 VALUE_CONTENTS_RAW (val) /*read*/, NULL /*write*/); 1248 return val; 1249} 1250 1251/* Should we use DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS instead of 1252 EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc and TYPE 1253 is the type (which is known to be struct, union or array). 1254 1255 On most machines, the struct convention is used unless we are 1256 using gcc and the type is of a special size. */ 1257/* As of about 31 Mar 93, GCC was changed to be compatible with the 1258 native compiler. GCC 2.3.3 was the last release that did it the 1259 old way. Since gcc2_compiled was not changed, we have no 1260 way to correctly win in all cases, so we just do the right thing 1261 for gcc1 and for gcc2 after this change. Thus it loses for gcc 1262 2.0-2.3.3. This is somewhat unfortunate, but changing gcc2_compiled 1263 would cause more chaos than dealing with some struct returns being 1264 handled wrong. */ 1265 1266int 1267generic_use_struct_convention (int gcc_p, struct type *value_type) 1268{ 1269 return !((gcc_p == 1) 1270 && (TYPE_LENGTH (value_type) == 1 1271 || TYPE_LENGTH (value_type) == 2 1272 || TYPE_LENGTH (value_type) == 4 1273 || TYPE_LENGTH (value_type) == 8)); 1274} 1275 1276/* Return true if the function returning the specified type is using 1277 the convention of returning structures in memory (passing in the 1278 address as a hidden first parameter). GCC_P is nonzero if compiled 1279 with GCC. */ 1280 1281int 1282using_struct_return (struct type *value_type, int gcc_p) 1283{ 1284 enum type_code code = TYPE_CODE (value_type); 1285 1286 if (code == TYPE_CODE_ERROR) 1287 error ("Function return type unknown."); 1288 1289 if (code == TYPE_CODE_VOID) 1290 /* A void return value is never in memory. See also corresponding 1291 code in "register_value_being_returned". */ 1292 return 0; 1293 1294 if (!gdbarch_return_value_p (current_gdbarch)) 1295 { 1296 /* FIXME: cagney/2003-10-01: The below is dead. Instead an 1297 architecture should implement "gdbarch_return_value". Using 1298 that new function it is possible to exactly specify the ABIs 1299 "struct return" vs "register return" conventions. */ 1300 if (code == TYPE_CODE_STRUCT 1301 || code == TYPE_CODE_UNION 1302 || code == TYPE_CODE_ARRAY 1303 || RETURN_VALUE_ON_STACK (value_type)) 1304 return USE_STRUCT_CONVENTION (gcc_p, value_type); 1305 else 1306 return 0; 1307 } 1308 1309 /* Probe the architecture for the return-value convention. */ 1310 return (gdbarch_return_value (current_gdbarch, value_type, 1311 NULL, NULL, NULL) 1312 == RETURN_VALUE_STRUCT_CONVENTION); 1313} 1314 1315/* Set the initialized field in a value struct. */ 1316 1317void 1318set_value_initialized (struct value *val, int status) 1319{ 1320 val->initialized = status; 1321} 1322 1323/* Return the initialized field in a value struct. */ 1324 1325int 1326value_initialized (struct value *val) 1327{ 1328 return val->initialized; 1329} 1330 1331void 1332_initialize_values (void) 1333{ 1334 add_cmd ("convenience", no_class, show_convenience, 1335 "Debugger convenience (\"$foo\") variables.\n\ 1336These variables are created when you assign them values;\n\ 1337thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\ 1338A few convenience variables are given values automatically:\n\ 1339\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\ 1340\"$__\" holds the contents of the last address examined with \"x\".", 1341 &showlist); 1342 1343 add_cmd ("values", no_class, show_values, 1344 "Elements of value history around item number IDX (or last ten).", 1345 &showlist); 1346} 1347