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