1 /* Find a variable's value in memory, for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2001, 2003-2005, 2007-2012 Free Software 4 Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "frame.h" 25 #include "value.h" 26 #include "gdbcore.h" 27 #include "inferior.h" 28 #include "target.h" 29 #include "gdb_string.h" 30 #include "gdb_assert.h" 31 #include "floatformat.h" 32 #include "symfile.h" /* for overlay functions */ 33 #include "regcache.h" 34 #include "user-regs.h" 35 #include "block.h" 36 #include "objfiles.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 /* Given a struct symbol for a variable, 409 and a stack frame id, read the value of the variable 410 and return a (pointer to a) struct value containing the value. 411 If the variable cannot be found, throw error. */ 412 413 struct value * 414 read_var_value (struct symbol *var, struct frame_info *frame) 415 { 416 struct value *v; 417 struct type *type = SYMBOL_TYPE (var); 418 CORE_ADDR addr; 419 int len; 420 421 /* Call check_typedef on our type to make sure that, if TYPE is 422 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type 423 instead of zero. However, we do not replace the typedef type by the 424 target type, because we want to keep the typedef in order to be able to 425 set the returned value type description correctly. */ 426 check_typedef (type); 427 428 len = TYPE_LENGTH (type); 429 430 if (symbol_read_needs_frame (var)) 431 gdb_assert (frame); 432 433 switch (SYMBOL_CLASS (var)) 434 { 435 case LOC_CONST: 436 /* Put the constant back in target format. */ 437 v = allocate_value (type); 438 store_signed_integer (value_contents_raw (v), len, 439 gdbarch_byte_order (get_type_arch (type)), 440 (LONGEST) SYMBOL_VALUE (var)); 441 VALUE_LVAL (v) = not_lval; 442 return v; 443 444 case LOC_LABEL: 445 /* Put the constant back in target format. */ 446 v = allocate_value (type); 447 if (overlay_debugging) 448 { 449 CORE_ADDR addr 450 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 451 SYMBOL_OBJ_SECTION (var)); 452 453 store_typed_address (value_contents_raw (v), type, addr); 454 } 455 else 456 store_typed_address (value_contents_raw (v), type, 457 SYMBOL_VALUE_ADDRESS (var)); 458 VALUE_LVAL (v) = not_lval; 459 return v; 460 461 case LOC_CONST_BYTES: 462 v = allocate_value (type); 463 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len); 464 VALUE_LVAL (v) = not_lval; 465 return v; 466 467 case LOC_STATIC: 468 v = allocate_value_lazy (type); 469 if (overlay_debugging) 470 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 471 SYMBOL_OBJ_SECTION (var)); 472 else 473 addr = SYMBOL_VALUE_ADDRESS (var); 474 break; 475 476 case LOC_ARG: 477 addr = get_frame_args_address (frame); 478 if (!addr) 479 error (_("Unknown argument list address for `%s'."), 480 SYMBOL_PRINT_NAME (var)); 481 addr += SYMBOL_VALUE (var); 482 v = allocate_value_lazy (type); 483 break; 484 485 case LOC_REF_ARG: 486 { 487 struct value *ref; 488 CORE_ADDR argref; 489 490 argref = get_frame_args_address (frame); 491 if (!argref) 492 error (_("Unknown argument list address for `%s'."), 493 SYMBOL_PRINT_NAME (var)); 494 argref += SYMBOL_VALUE (var); 495 ref = value_at (lookup_pointer_type (type), argref); 496 addr = value_as_address (ref); 497 v = allocate_value_lazy (type); 498 break; 499 } 500 501 case LOC_LOCAL: 502 addr = get_frame_locals_address (frame); 503 addr += SYMBOL_VALUE (var); 504 v = allocate_value_lazy (type); 505 break; 506 507 case LOC_TYPEDEF: 508 error (_("Cannot look up value of a typedef `%s'."), 509 SYMBOL_PRINT_NAME (var)); 510 break; 511 512 case LOC_BLOCK: 513 v = allocate_value_lazy (type); 514 if (overlay_debugging) 515 addr = symbol_overlayed_address 516 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)); 517 else 518 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var)); 519 break; 520 521 case LOC_REGISTER: 522 case LOC_REGPARM_ADDR: 523 { 524 int regno = SYMBOL_REGISTER_OPS (var) 525 ->register_number (var, get_frame_arch (frame)); 526 struct value *regval; 527 528 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) 529 { 530 regval = value_from_register (lookup_pointer_type (type), 531 regno, 532 frame); 533 534 if (regval == NULL) 535 error (_("Value of register variable not available for `%s'."), 536 SYMBOL_PRINT_NAME (var)); 537 538 addr = value_as_address (regval); 539 v = allocate_value_lazy (type); 540 } 541 else 542 { 543 regval = value_from_register (type, regno, frame); 544 545 if (regval == NULL) 546 error (_("Value of register variable not available for `%s'."), 547 SYMBOL_PRINT_NAME (var)); 548 return regval; 549 } 550 } 551 break; 552 553 case LOC_COMPUTED: 554 /* FIXME: cagney/2004-01-26: It should be possible to 555 unconditionally call the SYMBOL_COMPUTED_OPS method when available. 556 Unfortunately DWARF 2 stores the frame-base (instead of the 557 function) location in a function's symbol. Oops! For the 558 moment enable this when/where applicable. */ 559 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame); 560 561 case LOC_UNRESOLVED: 562 { 563 struct minimal_symbol *msym; 564 struct obj_section *obj_section; 565 566 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL); 567 if (msym == NULL) 568 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var)); 569 if (overlay_debugging) 570 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), 571 SYMBOL_OBJ_SECTION (msym)); 572 else 573 addr = SYMBOL_VALUE_ADDRESS (msym); 574 575 obj_section = SYMBOL_OBJ_SECTION (msym); 576 if (obj_section 577 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) 578 addr = target_translate_tls_address (obj_section->objfile, addr); 579 v = allocate_value_lazy (type); 580 } 581 break; 582 583 case LOC_OPTIMIZED_OUT: 584 return allocate_optimized_out_value (type); 585 586 default: 587 error (_("Cannot look up value of a botched symbol `%s'."), 588 SYMBOL_PRINT_NAME (var)); 589 break; 590 } 591 592 VALUE_LVAL (v) = lval_memory; 593 set_value_address (v, addr); 594 return v; 595 } 596 597 /* Install default attributes for register values. */ 598 599 struct value * 600 default_value_from_register (struct type *type, int regnum, 601 struct frame_info *frame) 602 { 603 struct gdbarch *gdbarch = get_frame_arch (frame); 604 int len = TYPE_LENGTH (type); 605 struct value *value = allocate_value (type); 606 607 VALUE_LVAL (value) = lval_register; 608 VALUE_FRAME_ID (value) = get_frame_id (frame); 609 VALUE_REGNUM (value) = regnum; 610 611 /* Any structure stored in more than one register will always be 612 an integral number of registers. Otherwise, you need to do 613 some fiddling with the last register copied here for little 614 endian machines. */ 615 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG 616 && len < register_size (gdbarch, regnum)) 617 /* Big-endian, and we want less than full size. */ 618 set_value_offset (value, register_size (gdbarch, regnum) - len); 619 else 620 set_value_offset (value, 0); 621 622 return value; 623 } 624 625 /* VALUE must be an lval_register value. If regnum is the value's 626 associated register number, and len the length of the values type, 627 read one or more registers in FRAME, starting with register REGNUM, 628 until we've read LEN bytes. */ 629 630 void 631 read_frame_register_value (struct value *value, struct frame_info *frame) 632 { 633 struct gdbarch *gdbarch = get_frame_arch (frame); 634 int offset = 0; 635 int reg_offset = value_offset (value); 636 int regnum = VALUE_REGNUM (value); 637 int len = TYPE_LENGTH (check_typedef (value_type (value))); 638 639 gdb_assert (VALUE_LVAL (value) == lval_register); 640 641 /* Skip registers wholly inside of REG_OFFSET. */ 642 while (reg_offset >= register_size (gdbarch, regnum)) 643 { 644 reg_offset -= register_size (gdbarch, regnum); 645 regnum++; 646 } 647 648 /* Copy the data. */ 649 while (len > 0) 650 { 651 struct value *regval = get_frame_register_value (frame, regnum); 652 int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset; 653 654 /* If the register length is larger than the number of bytes 655 remaining to copy, then only copy the appropriate bytes. */ 656 if (reg_len > len) 657 reg_len = len; 658 659 value_contents_copy (value, offset, regval, reg_offset, reg_len); 660 661 offset += reg_len; 662 len -= reg_len; 663 reg_offset = 0; 664 regnum++; 665 } 666 } 667 668 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */ 669 670 struct value * 671 value_from_register (struct type *type, int regnum, struct frame_info *frame) 672 { 673 struct gdbarch *gdbarch = get_frame_arch (frame); 674 struct type *type1 = check_typedef (type); 675 struct value *v; 676 677 if (gdbarch_convert_register_p (gdbarch, regnum, type1)) 678 { 679 int optim, unavail, ok; 680 681 /* The ISA/ABI need to something weird when obtaining the 682 specified value from this register. It might need to 683 re-order non-adjacent, starting with REGNUM (see MIPS and 684 i386). It might need to convert the [float] register into 685 the corresponding [integer] type (see Alpha). The assumption 686 is that gdbarch_register_to_value populates the entire value 687 including the location. */ 688 v = allocate_value (type); 689 VALUE_LVAL (v) = lval_register; 690 VALUE_FRAME_ID (v) = get_frame_id (frame); 691 VALUE_REGNUM (v) = regnum; 692 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1, 693 value_contents_raw (v), &optim, 694 &unavail); 695 696 if (!ok) 697 { 698 if (optim) 699 set_value_optimized_out (v, 1); 700 if (unavail) 701 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type)); 702 } 703 } 704 else 705 { 706 /* Construct the value. */ 707 v = gdbarch_value_from_register (gdbarch, type, regnum, frame); 708 709 /* Get the data. */ 710 read_frame_register_value (v, frame); 711 } 712 713 return v; 714 } 715 716 /* Return contents of register REGNUM in frame FRAME as address, 717 interpreted as value of type TYPE. Will abort if register 718 value is not available. */ 719 720 CORE_ADDR 721 address_from_register (struct type *type, int regnum, struct frame_info *frame) 722 { 723 struct value *value; 724 CORE_ADDR result; 725 726 value = value_from_register (type, regnum, frame); 727 gdb_assert (value); 728 729 result = value_as_address (value); 730 release_value (value); 731 value_free (value); 732 733 return result; 734 } 735 736