1 /* Find a variable's value in memory, for GDB, the GNU debugger. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009, 5 2010 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "symtab.h" 24 #include "gdbtypes.h" 25 #include "frame.h" 26 #include "value.h" 27 #include "gdbcore.h" 28 #include "inferior.h" 29 #include "target.h" 30 #include "gdb_string.h" 31 #include "gdb_assert.h" 32 #include "floatformat.h" 33 #include "symfile.h" /* for overlay functions */ 34 #include "regcache.h" 35 #include "user-regs.h" 36 #include "block.h" 37 #include "objfiles.h" 38 39 /* Basic byte-swapping routines. All 'extract' functions return a 40 host-format integer from a target-format integer at ADDR which is 41 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... */ 48 you lose 49 #endif 50 51 LONGEST 52 extract_signed_integer (const gdb_byte *addr, int len, 53 enum bfd_endian byte_order) 54 { 55 LONGEST retval; 56 const unsigned char *p; 57 const unsigned char *startaddr = addr; 58 const unsigned char *endaddr = startaddr + len; 59 60 if (len > (int) sizeof (LONGEST)) 61 error (_("\ 62 That operation is not available on integers of more than %d bytes."), 63 (int) sizeof (LONGEST)); 64 65 /* Start at the most significant end of the integer, and work towards 66 the least significant. */ 67 if (byte_order == BFD_ENDIAN_BIG) 68 { 69 p = startaddr; 70 /* Do the sign extension once at the start. */ 71 retval = ((LONGEST) * p ^ 0x80) - 0x80; 72 for (++p; p < endaddr; ++p) 73 retval = (retval << 8) | *p; 74 } 75 else 76 { 77 p = endaddr - 1; 78 /* Do the sign extension once at the start. */ 79 retval = ((LONGEST) * p ^ 0x80) - 0x80; 80 for (--p; p >= startaddr; --p) 81 retval = (retval << 8) | *p; 82 } 83 return retval; 84 } 85 86 ULONGEST 87 extract_unsigned_integer (const gdb_byte *addr, int len, 88 enum bfd_endian byte_order) 89 { 90 ULONGEST retval; 91 const unsigned char *p; 92 const unsigned char *startaddr = addr; 93 const unsigned char *endaddr = startaddr + len; 94 95 if (len > (int) sizeof (ULONGEST)) 96 error (_("\ 97 That operation is not available on integers of more than %d bytes."), 98 (int) sizeof (ULONGEST)); 99 100 /* Start at the most significant end of the integer, and work towards 101 the least significant. */ 102 retval = 0; 103 if (byte_order == BFD_ENDIAN_BIG) 104 { 105 for (p = startaddr; p < endaddr; ++p) 106 retval = (retval << 8) | *p; 107 } 108 else 109 { 110 for (p = endaddr - 1; p >= startaddr; --p) 111 retval = (retval << 8) | *p; 112 } 113 return retval; 114 } 115 116 /* Sometimes a long long unsigned integer can be extracted as a 117 LONGEST value. This is done so that we can print these values 118 better. If this integer can be converted to a LONGEST, this 119 function returns 1 and sets *PVAL. Otherwise it returns 0. */ 120 121 int 122 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len, 123 enum bfd_endian byte_order, LONGEST *pval) 124 { 125 const gdb_byte *p; 126 const gdb_byte *first_addr; 127 int len; 128 129 len = orig_len; 130 if (byte_order == BFD_ENDIAN_BIG) 131 { 132 for (p = addr; 133 len > (int) sizeof (LONGEST) && p < addr + orig_len; 134 p++) 135 { 136 if (*p == 0) 137 len--; 138 else 139 break; 140 } 141 first_addr = p; 142 } 143 else 144 { 145 first_addr = addr; 146 for (p = addr + orig_len - 1; 147 len > (int) sizeof (LONGEST) && p >= addr; 148 p--) 149 { 150 if (*p == 0) 151 len--; 152 else 153 break; 154 } 155 } 156 157 if (len <= (int) sizeof (LONGEST)) 158 { 159 *pval = (LONGEST) extract_unsigned_integer (first_addr, 160 sizeof (LONGEST), 161 byte_order); 162 return 1; 163 } 164 165 return 0; 166 } 167 168 169 /* Treat the bytes at BUF as a pointer of type TYPE, and return the 170 address it represents. */ 171 CORE_ADDR 172 extract_typed_address (const gdb_byte *buf, struct type *type) 173 { 174 if (TYPE_CODE (type) != TYPE_CODE_PTR 175 && TYPE_CODE (type) != TYPE_CODE_REF) 176 internal_error (__FILE__, __LINE__, 177 _("extract_typed_address: " 178 "type is not a pointer or reference")); 179 180 return gdbarch_pointer_to_address (get_type_arch (type), type, buf); 181 } 182 183 /* All 'store' functions accept a host-format integer and store a 184 target-format integer at ADDR which is LEN bytes long. */ 185 186 void 187 store_signed_integer (gdb_byte *addr, int len, 188 enum bfd_endian byte_order, LONGEST val) 189 { 190 gdb_byte *p; 191 gdb_byte *startaddr = addr; 192 gdb_byte *endaddr = startaddr + len; 193 194 /* Start at the least significant end of the integer, and work towards 195 the most significant. */ 196 if (byte_order == BFD_ENDIAN_BIG) 197 { 198 for (p = endaddr - 1; p >= startaddr; --p) 199 { 200 *p = val & 0xff; 201 val >>= 8; 202 } 203 } 204 else 205 { 206 for (p = startaddr; p < endaddr; ++p) 207 { 208 *p = val & 0xff; 209 val >>= 8; 210 } 211 } 212 } 213 214 void 215 store_unsigned_integer (gdb_byte *addr, int len, 216 enum bfd_endian byte_order, ULONGEST val) 217 { 218 unsigned char *p; 219 unsigned char *startaddr = (unsigned char *) addr; 220 unsigned char *endaddr = startaddr + len; 221 222 /* Start at the least significant end of the integer, and work towards 223 the most significant. */ 224 if (byte_order == BFD_ENDIAN_BIG) 225 { 226 for (p = endaddr - 1; p >= startaddr; --p) 227 { 228 *p = val & 0xff; 229 val >>= 8; 230 } 231 } 232 else 233 { 234 for (p = startaddr; p < endaddr; ++p) 235 { 236 *p = val & 0xff; 237 val >>= 8; 238 } 239 } 240 } 241 242 /* Store the address ADDR as a pointer of type TYPE at BUF, in target 243 form. */ 244 void 245 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr) 246 { 247 if (TYPE_CODE (type) != TYPE_CODE_PTR 248 && TYPE_CODE (type) != TYPE_CODE_REF) 249 internal_error (__FILE__, __LINE__, 250 _("store_typed_address: " 251 "type is not a pointer or reference")); 252 253 gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr); 254 } 255 256 257 258 /* Return a `value' with the contents of (virtual or cooked) register 259 REGNUM as found in the specified FRAME. The register's type is 260 determined by register_type(). */ 261 262 struct value * 263 value_of_register (int regnum, struct frame_info *frame) 264 { 265 struct gdbarch *gdbarch = get_frame_arch (frame); 266 CORE_ADDR addr; 267 int optim; 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, &lval, &addr, &realnum, raw_buffer); 280 281 reg_val = allocate_value (register_type (gdbarch, regnum)); 282 283 memcpy (value_contents_raw (reg_val), raw_buffer, 284 register_size (gdbarch, regnum)); 285 VALUE_LVAL (reg_val) = lval; 286 set_value_address (reg_val, addr); 287 VALUE_REGNUM (reg_val) = regnum; 288 set_value_optimized_out (reg_val, optim); 289 VALUE_FRAME_ID (reg_val) = get_frame_id (frame); 290 return reg_val; 291 } 292 293 /* Return a `value' with the contents of (virtual or cooked) register 294 REGNUM as found in the specified FRAME. The register's type is 295 determined by register_type(). The value is not fetched. */ 296 297 struct value * 298 value_of_register_lazy (struct frame_info *frame, int regnum) 299 { 300 struct gdbarch *gdbarch = get_frame_arch (frame); 301 struct value *reg_val; 302 303 gdb_assert (regnum < (gdbarch_num_regs (gdbarch) 304 + gdbarch_num_pseudo_regs (gdbarch))); 305 306 /* We should have a valid (i.e. non-sentinel) frame. */ 307 gdb_assert (frame_id_p (get_frame_id (frame))); 308 309 reg_val = allocate_value (register_type (gdbarch, regnum)); 310 VALUE_LVAL (reg_val) = lval_register; 311 VALUE_REGNUM (reg_val) = regnum; 312 VALUE_FRAME_ID (reg_val) = get_frame_id (frame); 313 set_value_lazy (reg_val, 1); 314 return reg_val; 315 } 316 317 /* Given a pointer of type TYPE in target form in BUF, return the 318 address it represents. */ 319 CORE_ADDR 320 unsigned_pointer_to_address (struct gdbarch *gdbarch, 321 struct type *type, const gdb_byte *buf) 322 { 323 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 324 325 return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); 326 } 327 328 CORE_ADDR 329 signed_pointer_to_address (struct gdbarch *gdbarch, 330 struct type *type, const gdb_byte *buf) 331 { 332 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 333 334 return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order); 335 } 336 337 /* Given an address, store it as a pointer of type TYPE in target 338 format in BUF. */ 339 void 340 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type, 341 gdb_byte *buf, CORE_ADDR addr) 342 { 343 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 344 345 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); 346 } 347 348 void 349 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type, 350 gdb_byte *buf, CORE_ADDR addr) 351 { 352 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 353 354 store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr); 355 } 356 357 /* Will calling read_var_value or locate_var_value on SYM end 358 up caring what frame it is being evaluated relative to? SYM must 359 be non-NULL. */ 360 int 361 symbol_read_needs_frame (struct symbol *sym) 362 { 363 switch (SYMBOL_CLASS (sym)) 364 { 365 /* All cases listed explicitly so that gcc -Wall will detect it if 366 we failed to consider one. */ 367 case LOC_COMPUTED: 368 /* FIXME: cagney/2004-01-26: It should be possible to 369 unconditionally call the SYMBOL_COMPUTED_OPS method when available. 370 Unfortunately DWARF 2 stores the frame-base (instead of the 371 function) location in a function's symbol. Oops! For the 372 moment enable this when/where applicable. */ 373 return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym); 374 375 case LOC_REGISTER: 376 case LOC_ARG: 377 case LOC_REF_ARG: 378 case LOC_REGPARM_ADDR: 379 case LOC_LOCAL: 380 return 1; 381 382 case LOC_UNDEF: 383 case LOC_CONST: 384 case LOC_STATIC: 385 case LOC_TYPEDEF: 386 387 case LOC_LABEL: 388 /* Getting the address of a label can be done independently of the block, 389 even if some *uses* of that address wouldn't work so well without 390 the right frame. */ 391 392 case LOC_BLOCK: 393 case LOC_CONST_BYTES: 394 case LOC_UNRESOLVED: 395 case LOC_OPTIMIZED_OUT: 396 return 0; 397 } 398 return 1; 399 } 400 401 /* Given a struct symbol for a variable, 402 and a stack frame id, read the value of the variable 403 and return a (pointer to a) struct value containing the value. 404 If the variable cannot be found, return a zero pointer. */ 405 406 struct value * 407 read_var_value (struct symbol *var, struct frame_info *frame) 408 { 409 struct value *v; 410 struct type *type = SYMBOL_TYPE (var); 411 CORE_ADDR addr; 412 int len; 413 414 if (SYMBOL_CLASS (var) == LOC_COMPUTED 415 || SYMBOL_CLASS (var) == LOC_REGISTER) 416 /* These cases do not use V. */ 417 v = NULL; 418 else 419 { 420 v = allocate_value (type); 421 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */ 422 } 423 424 len = TYPE_LENGTH (type); 425 426 if (symbol_read_needs_frame (var)) 427 gdb_assert (frame); 428 429 switch (SYMBOL_CLASS (var)) 430 { 431 case LOC_CONST: 432 /* Put the constant back in target format. */ 433 store_signed_integer (value_contents_raw (v), len, 434 gdbarch_byte_order (get_type_arch (type)), 435 (LONGEST) SYMBOL_VALUE (var)); 436 VALUE_LVAL (v) = not_lval; 437 return v; 438 439 case LOC_LABEL: 440 /* Put the constant back in target format. */ 441 if (overlay_debugging) 442 { 443 CORE_ADDR addr 444 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 445 SYMBOL_OBJ_SECTION (var)); 446 447 store_typed_address (value_contents_raw (v), type, addr); 448 } 449 else 450 store_typed_address (value_contents_raw (v), type, 451 SYMBOL_VALUE_ADDRESS (var)); 452 VALUE_LVAL (v) = not_lval; 453 return v; 454 455 case LOC_CONST_BYTES: 456 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len); 457 VALUE_LVAL (v) = not_lval; 458 return v; 459 460 case LOC_STATIC: 461 if (overlay_debugging) 462 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var), 463 SYMBOL_OBJ_SECTION (var)); 464 else 465 addr = SYMBOL_VALUE_ADDRESS (var); 466 break; 467 468 case LOC_ARG: 469 addr = get_frame_args_address (frame); 470 if (!addr) 471 return 0; 472 addr += SYMBOL_VALUE (var); 473 break; 474 475 case LOC_REF_ARG: 476 { 477 struct value *ref; 478 CORE_ADDR argref; 479 480 argref = get_frame_args_address (frame); 481 if (!argref) 482 return 0; 483 argref += SYMBOL_VALUE (var); 484 ref = value_at (lookup_pointer_type (type), argref); 485 addr = value_as_address (ref); 486 break; 487 } 488 489 case LOC_LOCAL: 490 addr = get_frame_locals_address (frame); 491 addr += SYMBOL_VALUE (var); 492 break; 493 494 case LOC_TYPEDEF: 495 error (_("Cannot look up value of a typedef")); 496 break; 497 498 case LOC_BLOCK: 499 if (overlay_debugging) 500 set_value_address (v, symbol_overlayed_address 501 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var))); 502 else 503 set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var))); 504 return v; 505 506 case LOC_REGISTER: 507 case LOC_REGPARM_ADDR: 508 { 509 int regno = SYMBOL_REGISTER_OPS (var) 510 ->register_number (var, get_frame_arch (frame)); 511 struct value *regval; 512 513 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR) 514 { 515 regval = value_from_register (lookup_pointer_type (type), 516 regno, 517 frame); 518 519 if (regval == NULL) 520 error (_("Value of register variable not available.")); 521 522 addr = value_as_address (regval); 523 VALUE_LVAL (v) = lval_memory; 524 } 525 else 526 { 527 regval = value_from_register (type, regno, frame); 528 529 if (regval == NULL) 530 error (_("Value of register variable not available.")); 531 return regval; 532 } 533 } 534 break; 535 536 case LOC_COMPUTED: 537 /* FIXME: cagney/2004-01-26: It should be possible to 538 unconditionally call the SYMBOL_COMPUTED_OPS method when available. 539 Unfortunately DWARF 2 stores the frame-base (instead of the 540 function) location in a function's symbol. Oops! For the 541 moment enable this when/where applicable. */ 542 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame); 543 544 case LOC_UNRESOLVED: 545 { 546 struct minimal_symbol *msym; 547 struct obj_section *obj_section; 548 549 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL); 550 if (msym == NULL) 551 return 0; 552 if (overlay_debugging) 553 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym), 554 SYMBOL_OBJ_SECTION (msym)); 555 else 556 addr = SYMBOL_VALUE_ADDRESS (msym); 557 558 obj_section = SYMBOL_OBJ_SECTION (msym); 559 if (obj_section 560 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0) 561 addr = target_translate_tls_address (obj_section->objfile, addr); 562 } 563 break; 564 565 case LOC_OPTIMIZED_OUT: 566 VALUE_LVAL (v) = not_lval; 567 set_value_optimized_out (v, 1); 568 return v; 569 570 default: 571 error (_("Cannot look up value of a botched symbol.")); 572 break; 573 } 574 575 set_value_address (v, addr); 576 set_value_lazy (v, 1); 577 return v; 578 } 579 580 /* Install default attributes for register values. */ 581 582 struct value * 583 default_value_from_register (struct type *type, int regnum, 584 struct frame_info *frame) 585 { 586 struct gdbarch *gdbarch = get_frame_arch (frame); 587 int len = TYPE_LENGTH (type); 588 struct value *value = allocate_value (type); 589 590 VALUE_LVAL (value) = lval_register; 591 VALUE_FRAME_ID (value) = get_frame_id (frame); 592 VALUE_REGNUM (value) = regnum; 593 594 /* Any structure stored in more than one register will always be 595 an integral number of registers. Otherwise, you need to do 596 some fiddling with the last register copied here for little 597 endian machines. */ 598 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG 599 && len < register_size (gdbarch, regnum)) 600 /* Big-endian, and we want less than full size. */ 601 set_value_offset (value, register_size (gdbarch, regnum) - len); 602 else 603 set_value_offset (value, 0); 604 605 return value; 606 } 607 608 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */ 609 610 struct value * 611 value_from_register (struct type *type, int regnum, struct frame_info *frame) 612 { 613 struct gdbarch *gdbarch = get_frame_arch (frame); 614 struct type *type1 = check_typedef (type); 615 struct value *v; 616 617 if (gdbarch_convert_register_p (gdbarch, regnum, type1)) 618 { 619 /* The ISA/ABI need to something weird when obtaining the 620 specified value from this register. It might need to 621 re-order non-adjacent, starting with REGNUM (see MIPS and 622 i386). It might need to convert the [float] register into 623 the corresponding [integer] type (see Alpha). The assumption 624 is that gdbarch_register_to_value populates the entire value 625 including the location. */ 626 v = allocate_value (type); 627 VALUE_LVAL (v) = lval_register; 628 VALUE_FRAME_ID (v) = get_frame_id (frame); 629 VALUE_REGNUM (v) = regnum; 630 gdbarch_register_to_value (gdbarch, 631 frame, regnum, type1, value_contents_raw (v)); 632 } 633 else 634 { 635 int len = TYPE_LENGTH (type); 636 637 /* Construct the value. */ 638 v = gdbarch_value_from_register (gdbarch, type, regnum, frame); 639 640 /* Get the data. */ 641 if (!get_frame_register_bytes (frame, regnum, value_offset (v), len, 642 value_contents_raw (v))) 643 set_value_optimized_out (v, 1); 644 } 645 return v; 646 } 647 648 /* Return contents of register REGNUM in frame FRAME as address, 649 interpreted as value of type TYPE. Will abort if register 650 value is not available. */ 651 652 CORE_ADDR 653 address_from_register (struct type *type, int regnum, struct frame_info *frame) 654 { 655 struct value *value; 656 CORE_ADDR result; 657 658 value = value_from_register (type, regnum, frame); 659 gdb_assert (value); 660 661 result = value_as_address (value); 662 release_value (value); 663 value_free (value); 664 665 return result; 666 } 667