1/* Find a variable's value in memory, for GDB, the GNU debugger. 2 3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 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 "symtab.h" 26#include "gdbtypes.h" 27#include "frame.h" 28#include "value.h" 29#include "gdbcore.h" 30#include "inferior.h" 31#include "target.h" 32#include "gdb_string.h" 33#include "gdb_assert.h" 34#include "floatformat.h" 35#include "symfile.h" /* for overlay functions */ 36#include "regcache.h" 37#include "user-regs.h" 38#include "block.h" 39 40/* Basic byte-swapping routines. GDB has needed these for a long time... 41 All extract a target-format integer at ADDR which is LEN bytes long. */ 42 43#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8 44 /* 8 bit characters are a pretty safe assumption these days, so we 45 assume it throughout all these swapping routines. If we had to deal with 46 9 bit characters, we would need to make len be in bits and would have 47 to re-write these routines... */ 48you lose 49#endif 50 51LONGEST 52extract_signed_integer (const void *addr, int len) 53{ 54 LONGEST retval; 55 const unsigned char *p; 56 const unsigned char *startaddr = addr; 57 const unsigned char *endaddr = startaddr + len; 58 59 if (len > (int) sizeof (LONGEST)) 60 error ("\ 61That operation is not available on integers of more than %d bytes.", 62 (int) sizeof (LONGEST)); 63 64 /* Start at the most significant end of the integer, and work towards 65 the least significant. */ 66 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 67 { 68 p = startaddr; 69 /* Do the sign extension once at the start. */ 70 retval = ((LONGEST) * p ^ 0x80) - 0x80; 71 for (++p; p < endaddr; ++p) 72 retval = (retval << 8) | *p; 73 } 74 else 75 { 76 p = endaddr - 1; 77 /* Do the sign extension once at the start. */ 78 retval = ((LONGEST) * p ^ 0x80) - 0x80; 79 for (--p; p >= startaddr; --p) 80 retval = (retval << 8) | *p; 81 } 82 return retval; 83} 84 85ULONGEST 86extract_unsigned_integer (const void *addr, int len) 87{ 88 ULONGEST retval; 89 const unsigned char *p; 90 const unsigned char *startaddr = addr; 91 const unsigned char *endaddr = startaddr + len; 92 93 if (len > (int) sizeof (ULONGEST)) 94 error ("\ 95That operation is not available on integers of more than %d bytes.", 96 (int) sizeof (ULONGEST)); 97 98 /* Start at the most significant end of the integer, and work towards 99 the least significant. */ 100 retval = 0; 101 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 102 { 103 for (p = startaddr; p < endaddr; ++p) 104 retval = (retval << 8) | *p; 105 } 106 else 107 { 108 for (p = endaddr - 1; p >= startaddr; --p) 109 retval = (retval << 8) | *p; 110 } 111 return retval; 112} 113 114/* Sometimes a long long unsigned integer can be extracted as a 115 LONGEST value. This is done so that we can print these values 116 better. If this integer can be converted to a LONGEST, this 117 function returns 1 and sets *PVAL. Otherwise it returns 0. */ 118 119int 120extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval) 121{ 122 char *p, *first_addr; 123 int len; 124 125 len = orig_len; 126 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 127 { 128 for (p = (char *) addr; 129 len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len; 130 p++) 131 { 132 if (*p == 0) 133 len--; 134 else 135 break; 136 } 137 first_addr = p; 138 } 139 else 140 { 141 first_addr = (char *) addr; 142 for (p = (char *) addr + orig_len - 1; 143 len > (int) sizeof (LONGEST) && p >= (char *) addr; 144 p--) 145 { 146 if (*p == 0) 147 len--; 148 else 149 break; 150 } 151 } 152 153 if (len <= (int) sizeof (LONGEST)) 154 { 155 *pval = (LONGEST) extract_unsigned_integer (first_addr, 156 sizeof (LONGEST)); 157 return 1; 158 } 159 160 return 0; 161} 162 163 164/* Treat the bytes at BUF as a pointer of type TYPE, and return the 165 address it represents. */ 166CORE_ADDR 167extract_typed_address (const void *buf, struct type *type) 168{ 169 if (TYPE_CODE (type) != TYPE_CODE_PTR 170 && TYPE_CODE (type) != TYPE_CODE_REF) 171 internal_error (__FILE__, __LINE__, 172 "extract_typed_address: " 173 "type is not a pointer or reference"); 174 175 return POINTER_TO_ADDRESS (type, buf); 176} 177 178 179void 180store_signed_integer (void *addr, int len, LONGEST val) 181{ 182 unsigned char *p; 183 unsigned char *startaddr = (unsigned char *) addr; 184 unsigned char *endaddr = startaddr + len; 185 186 /* Start at the least significant end of the integer, and work towards 187 the most significant. */ 188 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 189 { 190 for (p = endaddr - 1; p >= startaddr; --p) 191 { 192 *p = val & 0xff; 193 val >>= 8; 194 } 195 } 196 else 197 { 198 for (p = startaddr; p < endaddr; ++p) 199 { 200 *p = val & 0xff; 201 val >>= 8; 202 } 203 } 204} 205 206void 207store_unsigned_integer (void *addr, int len, ULONGEST val) 208{ 209 unsigned char *p; 210 unsigned char *startaddr = (unsigned char *) addr; 211 unsigned char *endaddr = startaddr + len; 212 213 /* Start at the least significant end of the integer, and work towards 214 the most significant. */ 215 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) 216 { 217 for (p = endaddr - 1; p >= startaddr; --p) 218 { 219 *p = val & 0xff; 220 val >>= 8; 221 } 222 } 223 else 224 { 225 for (p = startaddr; p < endaddr; ++p) 226 { 227 *p = val & 0xff; 228 val >>= 8; 229 } 230 } 231} 232 233/* Store the address ADDR as a pointer of type TYPE at BUF, in target 234 form. */ 235void 236store_typed_address (void *buf, struct type *type, CORE_ADDR addr) 237{ 238 if (TYPE_CODE (type) != TYPE_CODE_PTR 239 && TYPE_CODE (type) != TYPE_CODE_REF) 240 internal_error (__FILE__, __LINE__, 241 "store_typed_address: " 242 "type is not a pointer or reference"); 243 244 ADDRESS_TO_POINTER (type, buf, addr); 245} 246 247 248 249/* Return a `value' with the contents of (virtual or cooked) register 250 REGNUM as found in the specified FRAME. The register's type is 251 determined by register_type(). 252 253 NOTE: returns NULL if register value is not available. Caller will 254 check return value or die! */ 255 256struct value * 257value_of_register (int regnum, struct frame_info *frame) 258{ 259 CORE_ADDR addr; 260 int optim; 261 struct value *reg_val; 262 int realnum; 263 char raw_buffer[MAX_REGISTER_SIZE]; 264 enum lval_type lval; 265 266 /* User registers lie completely outside of the range of normal 267 registers. Catch them early so that the target never sees them. */ 268 if (regnum >= NUM_REGS + NUM_PSEUDO_REGS) 269 return value_of_user_reg (regnum, frame); 270 271 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer); 272 273 /* FIXME: cagney/2002-05-15: This test is just bogus. 274 275 It indicates that the target failed to supply a value for a 276 register because it was "not available" at this time. Problem 277 is, the target still has the register and so get saved_register() 278 may be returning a value saved on the stack. */ 279 280 if (register_cached (regnum) < 0) 281 return NULL; /* register value not available */ 282 283 reg_val = allocate_value (register_type (current_gdbarch, regnum)); 284 285 /* Convert raw data to virtual format if necessary. */ 286 287 if (DEPRECATED_REGISTER_CONVERTIBLE_P () 288 && DEPRECATED_REGISTER_CONVERTIBLE (regnum)) 289 { 290 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum), 291 raw_buffer, VALUE_CONTENTS_RAW (reg_val)); 292 } 293 else if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)) 294 memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer, 295 DEPRECATED_REGISTER_RAW_SIZE (regnum)); 296 else 297 internal_error (__FILE__, __LINE__, 298 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size", 299 REGISTER_NAME (regnum), 300 regnum, 301 DEPRECATED_REGISTER_RAW_SIZE (regnum), 302 DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum)); 303 VALUE_LVAL (reg_val) = lval; 304 VALUE_ADDRESS (reg_val) = addr; 305 VALUE_REGNO (reg_val) = regnum; 306 VALUE_OPTIMIZED_OUT (reg_val) = optim; 307 return reg_val; 308} 309 310/* Given a pointer of type TYPE in target form in BUF, return the 311 address it represents. */ 312CORE_ADDR 313unsigned_pointer_to_address (struct type *type, const void *buf) 314{ 315 return extract_unsigned_integer (buf, TYPE_LENGTH (type)); 316} 317 318CORE_ADDR 319signed_pointer_to_address (struct type *type, const void *buf) 320{ 321 return extract_signed_integer (buf, TYPE_LENGTH (type)); 322} 323 324/* Given an address, store it as a pointer of type TYPE in target 325 format in BUF. */ 326void 327unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr) 328{ 329 store_unsigned_integer (buf, TYPE_LENGTH (type), addr); 330} 331 332void 333address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr) 334{ 335 store_signed_integer (buf, TYPE_LENGTH (type), addr); 336} 337 338/* Will calling read_var_value or locate_var_value on SYM end 339 up caring what frame it is being evaluated relative to? SYM must 340 be non-NULL. */ 341int 342symbol_read_needs_frame (struct symbol *sym) 343{ 344 switch (SYMBOL_CLASS (sym)) 345 { 346 /* All cases listed explicitly so that gcc -Wall will detect it if 347 we failed to consider one. */ 348 case LOC_COMPUTED: 349 case LOC_COMPUTED_ARG: 350 /* FIXME: cagney/2004-01-26: It should be possible to 351 unconditionally call the SYMBOL_OPS method when available. 352 Unfortunately DWARF 2 stores the frame-base (instead of the 353 function) location in a function's symbol. Oops! For the 354 moment enable this when/where applicable. */ 355 return SYMBOL_OPS (sym)->read_needs_frame (sym); 356 357 case LOC_REGISTER: 358 case LOC_ARG: 359 case LOC_REF_ARG: 360 case LOC_REGPARM: 361 case LOC_REGPARM_ADDR: 362 case LOC_LOCAL: 363 case LOC_LOCAL_ARG: 364 case LOC_BASEREG: 365 case LOC_BASEREG_ARG: 366 case LOC_HP_THREAD_LOCAL_STATIC: 367 return 1; 368 369 case LOC_UNDEF: 370 case LOC_CONST: 371 case LOC_STATIC: 372 case LOC_INDIRECT: 373 case LOC_TYPEDEF: 374 375 case LOC_LABEL: 376 /* Getting the address of a label can be done independently of the block, 377 even if some *uses* of that address wouldn't work so well without 378 the right frame. */ 379 380 case LOC_BLOCK: 381 case LOC_CONST_BYTES: 382 case LOC_UNRESOLVED: 383 case LOC_OPTIMIZED_OUT: 384 return 0; 385 } 386 return 1; 387} 388 389/* Given a struct symbol for a variable, 390 and a stack frame id, read the value of the variable 391 and return a (pointer to a) struct value containing the value. 392 If the variable cannot be found, return a zero pointer. 393 If FRAME is NULL, use the deprecated_selected_frame. */ 394 395struct value * 396read_var_value (struct symbol *var, struct frame_info *frame) 397{ 398 struct value *v; 399 struct type *type = SYMBOL_TYPE (var); 400 CORE_ADDR addr; 401 int len; 402 403 v = allocate_value (type); 404 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */ 405 VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var); 406 407 len = TYPE_LENGTH (type); 408 409 410 /* FIXME drow/2003-09-06: this call to the selected frame should be 411 pushed upwards to the callers. */ 412 if (frame == NULL) 413 frame = deprecated_safe_get_selected_frame (); 414 415 switch (SYMBOL_CLASS (var)) 416 { 417 case LOC_CONST: 418 /* Put the constant back in target format. */ 419 store_signed_integer (VALUE_CONTENTS_RAW (v), len, 420 (LONGEST) SYMBOL_VALUE (var)); 421 VALUE_LVAL (v) = not_lval; 422 return v; 423 424 case LOC_LABEL: 425 /* Put the constant back in target format. */ 426 if (overlay_debugging) 427 { 428 CORE_ADDR addr 429 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 430 SYMBOL_BFD_SECTION (var)); 431 store_typed_address (VALUE_CONTENTS_RAW (v), type, addr); 432 } 433 else 434 store_typed_address (VALUE_CONTENTS_RAW (v), type, 435 SYMBOL_VALUE_ADDRESS (var)); 436 VALUE_LVAL (v) = not_lval; 437 return v; 438 439 case LOC_CONST_BYTES: 440 { 441 char *bytes_addr; 442 bytes_addr = SYMBOL_VALUE_BYTES (var); 443 memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len); 444 VALUE_LVAL (v) = not_lval; 445 return v; 446 } 447 448 case LOC_STATIC: 449 if (overlay_debugging) 450 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 451 SYMBOL_BFD_SECTION (var)); 452 else 453 addr = SYMBOL_VALUE_ADDRESS (var); 454 break; 455 456 case LOC_INDIRECT: 457 { 458 /* The import slot does not have a real address in it from the 459 dynamic loader (dld.sl on HP-UX), if the target hasn't 460 begun execution yet, so check for that. */ 461 CORE_ADDR locaddr; 462 struct value *loc; 463 if (!target_has_execution) 464 error ("\ 465Attempt to access variable defined in different shared object or load module when\n\ 466addresses have not been bound by the dynamic loader. Try again when executable is running."); 467 468 locaddr = SYMBOL_VALUE_ADDRESS (var); 469 loc = value_at (lookup_pointer_type (type), locaddr, NULL); 470 addr = value_as_address (loc); 471 } 472 473 case LOC_ARG: 474 if (frame == NULL) 475 return 0; 476 addr = get_frame_args_address (frame); 477 if (!addr) 478 return 0; 479 addr += SYMBOL_VALUE (var); 480 break; 481 482 case LOC_REF_ARG: 483 { 484 struct value *ref; 485 CORE_ADDR argref; 486 if (frame == NULL) 487 return 0; 488 argref = get_frame_args_address (frame); 489 if (!argref) 490 return 0; 491 argref += SYMBOL_VALUE (var); 492 ref = value_at (lookup_pointer_type (type), argref, NULL); 493 addr = value_as_address (ref); 494 break; 495 } 496 497 case LOC_LOCAL: 498 case LOC_LOCAL_ARG: 499 if (frame == NULL) 500 return 0; 501 addr = get_frame_locals_address (frame); 502 addr += SYMBOL_VALUE (var); 503 break; 504 505 case LOC_BASEREG: 506 case LOC_BASEREG_ARG: 507 case LOC_HP_THREAD_LOCAL_STATIC: 508 { 509 struct value *regval; 510 511 regval = value_from_register (lookup_pointer_type (type), 512 SYMBOL_BASEREG (var), frame); 513 if (regval == NULL) 514 error ("Value of base register not available."); 515 addr = value_as_address (regval); 516 addr += SYMBOL_VALUE (var); 517 break; 518 } 519 520 case LOC_TYPEDEF: 521 error ("Cannot look up value of a typedef"); 522 break; 523 524 case LOC_BLOCK: 525 if (overlay_debugging) 526 VALUE_ADDRESS (v) = symbol_overlayed_address 527 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var)); 528 else 529 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); 530 return v; 531 532 case LOC_REGISTER: 533 case LOC_REGPARM: 534 case LOC_REGPARM_ADDR: 535 { 536 struct block *b; 537 int regno = SYMBOL_VALUE (var); 538 struct value *regval; 539 540 if (frame == NULL) 541 return 0; 542 b = get_frame_block (frame, 0); 543 544 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) 545 { 546 regval = value_from_register (lookup_pointer_type (type), 547 regno, 548 frame); 549 550 if (regval == NULL) 551 error ("Value of register variable not available."); 552 553 addr = value_as_address (regval); 554 VALUE_LVAL (v) = lval_memory; 555 } 556 else 557 { 558 regval = value_from_register (type, regno, frame); 559 560 if (regval == NULL) 561 error ("Value of register variable not available."); 562 return regval; 563 } 564 } 565 break; 566 567 case LOC_COMPUTED: 568 case LOC_COMPUTED_ARG: 569 /* FIXME: cagney/2004-01-26: It should be possible to 570 unconditionally call the SYMBOL_OPS method when available. 571 Unfortunately DWARF 2 stores the frame-base (instead of the 572 function) location in a function's symbol. Oops! For the 573 moment enable this when/where applicable. */ 574 if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var)) 575 return 0; 576 return SYMBOL_OPS (var)->read_variable (var, frame); 577 578 case LOC_UNRESOLVED: 579 { 580 struct minimal_symbol *msym; 581 582 msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL); 583 if (msym == NULL) 584 return 0; 585 if (overlay_debugging) 586 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), 587 SYMBOL_BFD_SECTION (msym)); 588 else 589 addr = SYMBOL_VALUE_ADDRESS (msym); 590 } 591 break; 592 593 case LOC_OPTIMIZED_OUT: 594 VALUE_LVAL (v) = not_lval; 595 VALUE_OPTIMIZED_OUT (v) = 1; 596 return v; 597 598 default: 599 error ("Cannot look up value of a botched symbol."); 600 break; 601 } 602 603 VALUE_ADDRESS (v) = addr; 604 VALUE_LAZY (v) = 1; 605 return v; 606} 607 608/* Return a value of type TYPE, stored in register REGNUM, in frame 609 FRAME. 610 611 NOTE: returns NULL if register value is not available. 612 Caller will check return value or die! */ 613 614struct value * 615value_from_register (struct type *type, int regnum, struct frame_info *frame) 616{ 617 struct gdbarch *gdbarch = get_frame_arch (frame); 618 struct value *v = allocate_value (type); 619 CHECK_TYPEDEF (type); 620 621 if (TYPE_LENGTH (type) == 0) 622 { 623 /* It doesn't matter much what we return for this: since the 624 length is zero, it could be anything. But if allowed to see 625 a zero-length type, the register-finding loop below will set 626 neither mem_stor nor reg_stor, and then report an internal 627 error. 628 629 Zero-length types can legitimately arise from declarations 630 like 'struct {}' (a GCC extension, not valid ISO C). GDB may 631 also create them when it finds bogus debugging information; 632 for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the 633 STABS BINCL->EXCL compression process can create bad type 634 numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero 635 length. (That bug is actually the only known way to get a 636 zero-length value allocated to a register --- which is what 637 it takes to make it here.) 638 639 We'll just attribute the value to the original register. */ 640 VALUE_LVAL (v) = lval_register; 641 VALUE_ADDRESS (v) = regnum; 642 VALUE_REGNO (v) = regnum; 643 } 644 else if (CONVERT_REGISTER_P (regnum, type)) 645 { 646 /* The ISA/ABI need to something weird when obtaining the 647 specified value from this register. It might need to 648 re-order non-adjacent, starting with REGNUM (see MIPS and 649 i386). It might need to convert the [float] register into 650 the corresponding [integer] type (see Alpha). The assumption 651 is that REGISTER_TO_VALUE populates the entire value 652 including the location. */ 653 REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v)); 654 VALUE_LVAL (v) = lval_reg_frame_relative; 655 VALUE_FRAME_ID (v) = get_frame_id (frame); 656 VALUE_FRAME_REGNUM (v) = regnum; 657 } 658 else 659 { 660 int local_regnum; 661 int mem_stor = 0, reg_stor = 0; 662 int mem_tracking = 1; 663 CORE_ADDR last_addr = 0; 664 CORE_ADDR first_addr = 0; 665 int first_realnum = regnum; 666 int len = TYPE_LENGTH (type); 667 int value_bytes_copied; 668 int optimized = 0; 669 char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE); 670 671 /* Copy all of the data out, whereever it may be. */ 672 for (local_regnum = regnum, value_bytes_copied = 0; 673 value_bytes_copied < len; 674 (value_bytes_copied += DEPRECATED_REGISTER_RAW_SIZE (local_regnum), 675 ++local_regnum)) 676 { 677 int realnum; 678 int optim; 679 enum lval_type lval; 680 CORE_ADDR addr; 681 frame_register (frame, local_regnum, &optim, &lval, &addr, 682 &realnum, value_bytes + value_bytes_copied); 683 optimized += optim; 684 if (register_cached (local_regnum) == -1) 685 return NULL; /* register value not available */ 686 687 if (regnum == local_regnum) 688 { 689 first_addr = addr; 690 first_realnum = realnum; 691 } 692 if (lval == lval_register) 693 reg_stor++; 694 else 695 { 696 mem_stor++; 697 698 mem_tracking = (mem_tracking 699 && (regnum == local_regnum 700 || addr == last_addr)); 701 } 702 last_addr = addr; 703 } 704 705 /* FIXME: cagney/2003-06-04: Shouldn't this always use 706 lval_reg_frame_relative? If it doesn't and the register's 707 location changes (say after a resume) then this value is 708 going to have wrong information. */ 709 if ((reg_stor && mem_stor) 710 || (mem_stor && !mem_tracking)) 711 /* Mixed storage; all of the hassle we just went through was 712 for some good purpose. */ 713 { 714 VALUE_LVAL (v) = lval_reg_frame_relative; 715 VALUE_FRAME_ID (v) = get_frame_id (frame); 716 VALUE_FRAME_REGNUM (v) = regnum; 717 } 718 else if (mem_stor) 719 { 720 VALUE_LVAL (v) = lval_memory; 721 VALUE_ADDRESS (v) = first_addr; 722 } 723 else if (reg_stor) 724 { 725 VALUE_LVAL (v) = lval_register; 726 VALUE_ADDRESS (v) = first_addr; 727 VALUE_REGNO (v) = first_realnum; 728 } 729 else 730 internal_error (__FILE__, __LINE__, 731 "value_from_register: Value not stored anywhere!"); 732 733 VALUE_OPTIMIZED_OUT (v) = optimized; 734 735 /* Any structure stored in more than one register will always be 736 an integral number of registers. Otherwise, you need to do 737 some fiddling with the last register copied here for little 738 endian machines. */ 739 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG 740 && len < DEPRECATED_REGISTER_RAW_SIZE (regnum)) 741 /* Big-endian, and we want less than full size. */ 742 VALUE_OFFSET (v) = DEPRECATED_REGISTER_RAW_SIZE (regnum) - len; 743 else 744 VALUE_OFFSET (v) = 0; 745 memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len); 746 } 747 return v; 748} 749 750 751/* Given a struct symbol for a variable or function, 752 and a stack frame id, 753 return a (pointer to a) struct value containing the properly typed 754 address. */ 755 756struct value * 757locate_var_value (struct symbol *var, struct frame_info *frame) 758{ 759 CORE_ADDR addr = 0; 760 struct type *type = SYMBOL_TYPE (var); 761 struct value *lazy_value; 762 763 /* Evaluate it first; if the result is a memory address, we're fine. 764 Lazy evaluation pays off here. */ 765 766 lazy_value = read_var_value (var, frame); 767 if (lazy_value == 0) 768 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var)); 769 770 if (VALUE_LAZY (lazy_value) 771 || TYPE_CODE (type) == TYPE_CODE_FUNC) 772 { 773 struct value *val; 774 775 addr = VALUE_ADDRESS (lazy_value); 776 val = value_from_pointer (lookup_pointer_type (type), addr); 777 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value); 778 return val; 779 } 780 781 /* Not a memory address; check what the problem was. */ 782 switch (VALUE_LVAL (lazy_value)) 783 { 784 case lval_register: 785 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL 786 && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0'); 787 error("Address requested for identifier " 788 "\"%s\" which is in register $%s", 789 SYMBOL_PRINT_NAME (var), 790 REGISTER_NAME (VALUE_REGNO (lazy_value))); 791 break; 792 793 case lval_reg_frame_relative: 794 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL 795 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0'); 796 error("Address requested for identifier " 797 "\"%s\" which is in frame register $%s", 798 SYMBOL_PRINT_NAME (var), 799 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value))); 800 break; 801 802 default: 803 error ("Can't take address of \"%s\" which isn't an lvalue.", 804 SYMBOL_PRINT_NAME (var)); 805 break; 806 } 807 return 0; /* For lint -- never reached */ 808} 809