1 /* Find a variable's value in memory, for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "symtab.h" 22 #include "gdbtypes.h" 23 #include "frame.h" 24 #include "value.h" 25 #include "gdbcore.h" 26 #include "inferior.h" 27 #include "target.h" 28 #include "gdb_string.h" 29 #include "gdb_assert.h" 30 #include "floatformat.h" 31 #include "symfile.h" /* for overlay functions */ 32 #include "regcache.h" 33 #include "user-regs.h" 34 #include "block.h" 35 #include "objfiles.h" 36 #include "language.h" 37 38 /* Basic byte-swapping routines. All 'extract' functions return a 39 host-format integer from a target-format integer at ADDR which is 40 LEN bytes long. */ 41 42 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8 43 /* 8 bit characters are a pretty safe assumption these days, so we 44 assume it throughout all these swapping routines. If we had to deal with 45 9 bit characters, we would need to make len be in bits and would have 46 to re-write these routines... */ 47 you lose 48 #endif 49 50 LONGEST 51 extract_signed_integer (const gdb_byte *addr, int len, 52 enum bfd_endian byte_order) 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 (_("\ 61 That 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 (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 85 ULONGEST 86 extract_unsigned_integer (const gdb_byte *addr, int len, 87 enum bfd_endian byte_order) 88 { 89 ULONGEST retval; 90 const unsigned char *p; 91 const unsigned char *startaddr = addr; 92 const unsigned char *endaddr = startaddr + len; 93 94 if (len > (int) sizeof (ULONGEST)) 95 error (_("\ 96 That operation is not available on integers of more than %d bytes."), 97 (int) sizeof (ULONGEST)); 98 99 /* Start at the most significant end of the integer, and work towards 100 the least significant. */ 101 retval = 0; 102 if (byte_order == BFD_ENDIAN_BIG) 103 { 104 for (p = startaddr; p < endaddr; ++p) 105 retval = (retval << 8) | *p; 106 } 107 else 108 { 109 for (p = endaddr - 1; p >= startaddr; --p) 110 retval = (retval << 8) | *p; 111 } 112 return retval; 113 } 114 115 /* Sometimes a long long unsigned integer can be extracted as a 116 LONGEST value. This is done so that we can print these values 117 better. If this integer can be converted to a LONGEST, this 118 function returns 1 and sets *PVAL. Otherwise it returns 0. */ 119 120 int 121 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, 122 enum bfd_endian byte_order, LONGEST *pval) 123 { 124 const gdb_byte *p; 125 const gdb_byte *first_addr; 126 int len; 127 128 len = orig_len; 129 if (byte_order == BFD_ENDIAN_BIG) 130 { 131 for (p = addr; 132 len > (int) sizeof (LONGEST) && p < addr + orig_len; 133 p++) 134 { 135 if (*p == 0) 136 len--; 137 else 138 break; 139 } 140 first_addr = p; 141 } 142 else 143 { 144 first_addr = addr; 145 for (p = addr + orig_len - 1; 146 len > (int) sizeof (LONGEST) && p >= addr; 147 p--) 148 { 149 if (*p == 0) 150 len--; 151 else 152 break; 153 } 154 } 155 156 if (len <= (int) sizeof (LONGEST)) 157 { 158 *pval = (LONGEST) extract_unsigned_integer (first_addr, 159 sizeof (LONGEST), 160 byte_order); 161 return 1; 162 } 163 164 return 0; 165 } 166 167 168 /* Treat the bytes at BUF as a pointer of type TYPE, and return the 169 address it represents. */ 170 CORE_ADDR 171 extract_typed_address (const gdb_byte *buf, struct type *type) 172 { 173 if (TYPE_CODE (type) != TYPE_CODE_PTR 174 && TYPE_CODE (type) != TYPE_CODE_REF) 175 internal_error (__FILE__, __LINE__, 176 _("extract_typed_address: " 177 "type is not a pointer or reference")); 178 179 return gdbarch_pointer_to_address (get_type_arch (type), type, buf); 180 } 181 182 /* All 'store' functions accept a host-format integer and store a 183 target-format integer at ADDR which is LEN bytes long. */ 184 185 void 186 store_signed_integer (gdb_byte *addr, int len, 187 enum bfd_endian byte_order, LONGEST val) 188 { 189 gdb_byte *p; 190 gdb_byte *startaddr = addr; 191 gdb_byte *endaddr = startaddr + len; 192 193 /* Start at the least significant end of the integer, and work towards 194 the most significant. */ 195 if (byte_order == BFD_ENDIAN_BIG) 196 { 197 for (p = endaddr - 1; p >= startaddr; --p) 198 { 199 *p = val & 0xff; 200 val >>= 8; 201 } 202 } 203 else 204 { 205 for (p = startaddr; p < endaddr; ++p) 206 { 207 *p = val & 0xff; 208 val >>= 8; 209 } 210 } 211 } 212 213 void 214 store_unsigned_integer (gdb_byte *addr, int len, 215 enum bfd_endian byte_order, ULONGEST val) 216 { 217 unsigned char *p; 218 unsigned char *startaddr = (unsigned char *) addr; 219 unsigned char *endaddr = startaddr + len; 220 221 /* Start at the least significant end of the integer, and work towards 222 the most significant. */ 223 if (byte_order == BFD_ENDIAN_BIG) 224 { 225 for (p = endaddr - 1; p >= startaddr; --p) 226 { 227 *p = val & 0xff; 228 val >>= 8; 229 } 230 } 231 else 232 { 233 for (p = startaddr; p < endaddr; ++p) 234 { 235 *p = val & 0xff; 236 val >>= 8; 237 } 238 } 239 } 240 241 /* Store the address ADDR as a pointer of type TYPE at BUF, in target 242 form. */ 243 void 244 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) 245 { 246 if (TYPE_CODE (type) != TYPE_CODE_PTR 247 && TYPE_CODE (type) != TYPE_CODE_REF) 248 internal_error (__FILE__, __LINE__, 249 _("store_typed_address: " 250 "type is not a pointer or reference")); 251 252 gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr); 253 } 254 255 256 257 /* Return a `value' with the contents of (virtual or cooked) register 258 REGNUM as found in the specified FRAME. The register's type is 259 determined by register_type(). */ 260 261 struct value * 262 value_of_register (int regnum, struct frame_info *frame) 263 { 264 struct gdbarch *gdbarch = get_frame_arch (frame); 265 CORE_ADDR addr; 266 int optim; 267 int unavail; 268 struct value *reg_val; 269 int realnum; 270 gdb_byte raw_buffer[MAX_REGISTER_SIZE]; 271 enum lval_type lval; 272 273 /* User registers lie completely outside of the range of normal 274 registers. Catch them early so that the target never sees them. */ 275 if (regnum >= gdbarch_num_regs (gdbarch) 276 + gdbarch_num_pseudo_regs (gdbarch)) 277 return value_of_user_reg (regnum, frame); 278 279 frame_register (frame, regnum, &optim, &unavail, 280 &lval, &addr, &realnum, raw_buffer); 281 282 reg_val = allocate_value (register_type (gdbarch, regnum)); 283 284 if (!optim && !unavail) 285 memcpy (value_contents_raw (reg_val), raw_buffer, 286 register_size (gdbarch, regnum)); 287 else 288 memset (value_contents_raw (reg_val), 0, 289 register_size (gdbarch, regnum)); 290 291 VALUE_LVAL (reg_val) = lval; 292 set_value_address (reg_val, addr); 293 VALUE_REGNUM (reg_val) = regnum; 294 set_value_optimized_out (reg_val, optim); 295 if (unavail) 296 mark_value_bytes_unavailable (reg_val, 0, register_size (gdbarch, regnum)); 297 VALUE_FRAME_ID (reg_val) = get_frame_id (frame); 298 return reg_val; 299 } 300 301 /* Return a `value' with the contents of (virtual or cooked) register 302 REGNUM as found in the specified FRAME. The register's type is 303 determined by register_type(). The value is not fetched. */ 304 305 struct value * 306 value_of_register_lazy (struct frame_info *frame, int regnum) 307 { 308 struct gdbarch *gdbarch = get_frame_arch (frame); 309 struct value *reg_val; 310 311 gdb_assert (regnum < (gdbarch_num_regs (gdbarch) 312 + gdbarch_num_pseudo_regs (gdbarch))); 313 314 /* We should have a valid (i.e. non-sentinel) frame. */ 315 gdb_assert (frame_id_p (get_frame_id (frame))); 316 317 reg_val = allocate_value_lazy (register_type (gdbarch, regnum)); 318 VALUE_LVAL (reg_val) = lval_register; 319 VALUE_REGNUM (reg_val) = regnum; 320 VALUE_FRAME_ID (reg_val) = get_frame_id (frame); 321 return reg_val; 322 } 323 324 /* Given a pointer of type TYPE in target form in BUF, return the 325 address it represents. */ 326 CORE_ADDR 327 unsigned_pointer_to_address (struct gdbarch *gdbarch, 328 struct type *type, const gdb_byte *buf) 329 { 330 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 331 332 return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); 333 } 334 335 CORE_ADDR 336 signed_pointer_to_address (struct gdbarch *gdbarch, 337 struct type *type, const gdb_byte *buf) 338 { 339 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 340 341 return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order); 342 } 343 344 /* Given an address, store it as a pointer of type TYPE in target 345 format in BUF. */ 346 void 347 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type, 348 gdb_byte *buf, CORE_ADDR addr) 349 { 350 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 351 352 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); 353 } 354 355 void 356 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type, 357 gdb_byte *buf, CORE_ADDR addr) 358 { 359 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 360 361 store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr); 362 } 363 364 /* Will calling read_var_value or locate_var_value on SYM end 365 up caring what frame it is being evaluated relative to? SYM must 366 be non-NULL. */ 367 int 368 symbol_read_needs_frame (struct symbol *sym) 369 { 370 switch (SYMBOL_CLASS (sym)) 371 { 372 /* All cases listed explicitly so that gcc -Wall will detect it if 373 we failed to consider one. */ 374 case LOC_COMPUTED: 375 /* FIXME: cagney/2004-01-26: It should be possible to 376 unconditionally call the SYMBOL_COMPUTED_OPS method when available. 377 Unfortunately DWARF 2 stores the frame-base (instead of the 378 function) location in a function's symbol. Oops! For the 379 moment enable this when/where applicable. */ 380 return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym); 381 382 case LOC_REGISTER: 383 case LOC_ARG: 384 case LOC_REF_ARG: 385 case LOC_REGPARM_ADDR: 386 case LOC_LOCAL: 387 return 1; 388 389 case LOC_UNDEF: 390 case LOC_CONST: 391 case LOC_STATIC: 392 case LOC_TYPEDEF: 393 394 case LOC_LABEL: 395 /* Getting the address of a label can be done independently of the block, 396 even if some *uses* of that address wouldn't work so well without 397 the right frame. */ 398 399 case LOC_BLOCK: 400 case LOC_CONST_BYTES: 401 case LOC_UNRESOLVED: 402 case LOC_OPTIMIZED_OUT: 403 return 0; 404 } 405 return 1; 406 } 407 408 /* Private data to be used with minsym_lookup_iterator_cb. */ 409 410 struct minsym_lookup_data 411 { 412 /* The name of the minimal symbol we are searching for. */ 413 const char *name; 414 415 /* The field where the callback should store the minimal symbol 416 if found. It should be initialized to NULL before the search 417 is started. */ 418 struct minimal_symbol *result; 419 }; 420 421 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order. 422 It searches by name for a minimal symbol within the given OBJFILE. 423 The arguments are passed via CB_DATA, which in reality is a pointer 424 to struct minsym_lookup_data. */ 425 426 static int 427 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data) 428 { 429 struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data; 430 431 gdb_assert (data->result == NULL); 432 433 data->result = lookup_minimal_symbol (data->name, NULL, objfile); 434 435 /* The iterator should stop iff a match was found. */ 436 return (data->result != NULL); 437 } 438 439 /* A default implementation for the "la_read_var_value" hook in 440 the language vector which should work in most situations. */ 441 442 struct value * 443 default_read_var_value (struct symbol *var, struct frame_info *frame) 444 { 445 struct value *v; 446 struct type *type = SYMBOL_TYPE (var); 447 CORE_ADDR addr; 448 449 /* Call check_typedef on our type to make sure that, if TYPE is 450 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type 451 instead of zero. However, we do not replace the typedef type by the 452 target type, because we want to keep the typedef in order to be able to 453 set the returned value type description correctly. */ 454 check_typedef (type); 455 456 if (symbol_read_needs_frame (var)) 457 gdb_assert (frame); 458 459 switch (SYMBOL_CLASS (var)) 460 { 461 case LOC_CONST: 462 /* Put the constant back in target format. */ 463 v = allocate_value (type); 464 store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type), 465 gdbarch_byte_order (get_type_arch (type)), 466 (LONGEST) SYMBOL_VALUE (var)); 467 VALUE_LVAL (v) = not_lval; 468 return v; 469 470 case LOC_LABEL: 471 /* Put the constant back in target format. */ 472 v = allocate_value (type); 473 if (overlay_debugging) 474 { 475 CORE_ADDR addr 476 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 477 SYMBOL_OBJ_SECTION (var)); 478 479 store_typed_address (value_contents_raw (v), type, addr); 480 } 481 else 482 store_typed_address (value_contents_raw (v), type, 483 SYMBOL_VALUE_ADDRESS (var)); 484 VALUE_LVAL (v) = not_lval; 485 return v; 486 487 case LOC_CONST_BYTES: 488 v = allocate_value (type); 489 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), 490 TYPE_LENGTH (type)); 491 VALUE_LVAL (v) = not_lval; 492 return v; 493 494 case LOC_STATIC: 495 v = allocate_value_lazy (type); 496 if (overlay_debugging) 497 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 498 SYMBOL_OBJ_SECTION (var)); 499 else 500 addr = SYMBOL_VALUE_ADDRESS (var); 501 break; 502 503 case LOC_ARG: 504 addr = get_frame_args_address (frame); 505 if (!addr) 506 error (_("Unknown argument list address for `%s'."), 507 SYMBOL_PRINT_NAME (var)); 508 addr += SYMBOL_VALUE (var); 509 v = allocate_value_lazy (type); 510 break; 511 512 case LOC_REF_ARG: 513 { 514 struct value *ref; 515 CORE_ADDR argref; 516 517 argref = get_frame_args_address (frame); 518 if (!argref) 519 error (_("Unknown argument list address for `%s'."), 520 SYMBOL_PRINT_NAME (var)); 521 argref += SYMBOL_VALUE (var); 522 ref = value_at (lookup_pointer_type (type), argref); 523 addr = value_as_address (ref); 524 v = allocate_value_lazy (type); 525 break; 526 } 527 528 case LOC_LOCAL: 529 addr = get_frame_locals_address (frame); 530 addr += SYMBOL_VALUE (var); 531 v = allocate_value_lazy (type); 532 break; 533 534 case LOC_TYPEDEF: 535 error (_("Cannot look up value of a typedef `%s'."), 536 SYMBOL_PRINT_NAME (var)); 537 break; 538 539 case LOC_BLOCK: 540 v = allocate_value_lazy (type); 541 if (overlay_debugging) 542 addr = symbol_overlayed_address 543 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)); 544 else 545 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); 546 break; 547 548 case LOC_REGISTER: 549 case LOC_REGPARM_ADDR: 550 { 551 int regno = SYMBOL_REGISTER_OPS (var) 552 ->register_number (var, get_frame_arch (frame)); 553 struct value *regval; 554 555 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) 556 { 557 regval = value_from_register (lookup_pointer_type (type), 558 regno, 559 frame); 560 561 if (regval == NULL) 562 error (_("Value of register variable not available for `%s'."), 563 SYMBOL_PRINT_NAME (var)); 564 565 addr = value_as_address (regval); 566 v = allocate_value_lazy (type); 567 } 568 else 569 { 570 regval = value_from_register (type, regno, frame); 571 572 if (regval == NULL) 573 error (_("Value of register variable not available for `%s'."), 574 SYMBOL_PRINT_NAME (var)); 575 return regval; 576 } 577 } 578 break; 579 580 case LOC_COMPUTED: 581 /* FIXME: cagney/2004-01-26: It should be possible to 582 unconditionally call the SYMBOL_COMPUTED_OPS method when available. 583 Unfortunately DWARF 2 stores the frame-base (instead of the 584 function) location in a function's symbol. Oops! For the 585 moment enable this when/where applicable. */ 586 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame); 587 588 case LOC_UNRESOLVED: 589 { 590 struct minsym_lookup_data lookup_data; 591 struct minimal_symbol *msym; 592 struct obj_section *obj_section; 593 594 memset (&lookup_data, 0, sizeof (lookup_data)); 595 lookup_data.name = SYMBOL_LINKAGE_NAME (var); 596 597 gdbarch_iterate_over_objfiles_in_search_order 598 (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile), 599 minsym_lookup_iterator_cb, &lookup_data, 600 SYMBOL_SYMTAB (var)->objfile); 601 msym = lookup_data.result; 602 603 if (msym == NULL) 604 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var)); 605 if (overlay_debugging) 606 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), 607 SYMBOL_OBJ_SECTION (msym)); 608 else 609 addr = SYMBOL_VALUE_ADDRESS (msym); 610 611 obj_section = SYMBOL_OBJ_SECTION (msym); 612 if (obj_section 613 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) 614 addr = target_translate_tls_address (obj_section->objfile, addr); 615 v = allocate_value_lazy (type); 616 } 617 break; 618 619 case LOC_OPTIMIZED_OUT: 620 return allocate_optimized_out_value (type); 621 622 default: 623 error (_("Cannot look up value of a botched symbol `%s'."), 624 SYMBOL_PRINT_NAME (var)); 625 break; 626 } 627 628 VALUE_LVAL (v) = lval_memory; 629 set_value_address (v, addr); 630 return v; 631 } 632 633 /* Calls VAR's language la_read_var_value hook with the given arguments. */ 634 635 struct value * 636 read_var_value (struct symbol *var, struct frame_info *frame) 637 { 638 const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var)); 639 640 gdb_assert (lang != NULL); 641 gdb_assert (lang->la_read_var_value != NULL); 642 643 return lang->la_read_var_value (var, frame); 644 } 645 646 /* Install default attributes for register values. */ 647 648 struct value * 649 default_value_from_register (struct type *type, int regnum, 650 struct frame_info *frame) 651 { 652 struct gdbarch *gdbarch = get_frame_arch (frame); 653 int len = TYPE_LENGTH (type); 654 struct value *value = allocate_value (type); 655 656 VALUE_LVAL (value) = lval_register; 657 VALUE_FRAME_ID (value) = get_frame_id (frame); 658 VALUE_REGNUM (value) = regnum; 659 660 /* Any structure stored in more than one register will always be 661 an integral number of registers. Otherwise, you need to do 662 some fiddling with the last register copied here for little 663 endian machines. */ 664 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG 665 && len < register_size (gdbarch, regnum)) 666 /* Big-endian, and we want less than full size. */ 667 set_value_offset (value, register_size (gdbarch, regnum) - len); 668 else 669 set_value_offset (value, 0); 670 671 return value; 672 } 673 674 /* VALUE must be an lval_register value. If regnum is the value's 675 associated register number, and len the length of the values type, 676 read one or more registers in FRAME, starting with register REGNUM, 677 until we've read LEN bytes. 678 679 If any of the registers we try to read are optimized out, then mark the 680 complete resulting value as optimized out. */ 681 682 void 683 read_frame_register_value (struct value *value, struct frame_info *frame) 684 { 685 struct gdbarch *gdbarch = get_frame_arch (frame); 686 int offset = 0; 687 int reg_offset = value_offset (value); 688 int regnum = VALUE_REGNUM (value); 689 int len = TYPE_LENGTH (check_typedef (value_type (value))); 690 691 gdb_assert (VALUE_LVAL (value) == lval_register); 692 693 /* Skip registers wholly inside of REG_OFFSET. */ 694 while (reg_offset >= register_size (gdbarch, regnum)) 695 { 696 reg_offset -= register_size (gdbarch, regnum); 697 regnum++; 698 } 699 700 /* Copy the data. */ 701 while (len > 0) 702 { 703 struct value *regval = get_frame_register_value (frame, regnum); 704 int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset; 705 706 if (value_optimized_out (regval)) 707 { 708 set_value_optimized_out (value, 1); 709 break; 710 } 711 712 /* If the register length is larger than the number of bytes 713 remaining to copy, then only copy the appropriate bytes. */ 714 if (reg_len > len) 715 reg_len = len; 716 717 value_contents_copy (value, offset, regval, reg_offset, reg_len); 718 719 offset += reg_len; 720 len -= reg_len; 721 reg_offset = 0; 722 regnum++; 723 } 724 } 725 726 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */ 727 728 struct value * 729 value_from_register (struct type *type, int regnum, struct frame_info *frame) 730 { 731 struct gdbarch *gdbarch = get_frame_arch (frame); 732 struct type *type1 = check_typedef (type); 733 struct value *v; 734 735 if (gdbarch_convert_register_p (gdbarch, regnum, type1)) 736 { 737 int optim, unavail, ok; 738 739 /* The ISA/ABI need to something weird when obtaining the 740 specified value from this register. It might need to 741 re-order non-adjacent, starting with REGNUM (see MIPS and 742 i386). It might need to convert the [float] register into 743 the corresponding [integer] type (see Alpha). The assumption 744 is that gdbarch_register_to_value populates the entire value 745 including the location. */ 746 v = allocate_value (type); 747 VALUE_LVAL (v) = lval_register; 748 VALUE_FRAME_ID (v) = get_frame_id (frame); 749 VALUE_REGNUM (v) = regnum; 750 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1, 751 value_contents_raw (v), &optim, 752 &unavail); 753 754 if (!ok) 755 { 756 if (optim) 757 set_value_optimized_out (v, 1); 758 if (unavail) 759 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type)); 760 } 761 } 762 else 763 { 764 /* Construct the value. */ 765 v = gdbarch_value_from_register (gdbarch, type, regnum, frame); 766 767 /* Get the data. */ 768 read_frame_register_value (v, frame); 769 } 770 771 return v; 772 } 773 774 /* Return contents of register REGNUM in frame FRAME as address, 775 interpreted as value of type TYPE. Will abort if register 776 value is not available. */ 777 778 CORE_ADDR 779 address_from_register (struct type *type, int regnum, struct frame_info *frame) 780 { 781 struct value *value; 782 CORE_ADDR result; 783 784 value = value_from_register (type, regnum, frame); 785 gdb_assert (value); 786 787 result = value_as_address (value); 788 release_value (value); 789 value_free (value); 790 791 return result; 792 } 793 794