/* Find a variable's value in memory, for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009,
+ 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include "block.h"
#include "objfiles.h"
-/* Basic byte-swapping routines. GDB has needed these for a long time...
- All extract a target-format integer at ADDR which is LEN bytes long. */
+/* Basic byte-swapping routines. All 'extract' functions return a
+ host-format integer from a target-format integer at ADDR which is
+ LEN bytes long. */
#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
/* 8 bit characters are a pretty safe assumption these days, so we
return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
}
+/* All 'store' functions accept a host-format integer and store a
+ target-format integer at ADDR which is LEN bytes long. */
void
store_signed_integer (gdb_byte *addr, int len,
struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR addr;
int optim;
+ int unavail;
struct value *reg_val;
int realnum;
gdb_byte raw_buffer[MAX_REGISTER_SIZE];
+ gdbarch_num_pseudo_regs (gdbarch))
return value_of_user_reg (regnum, frame);
- frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
+ frame_register (frame, regnum, &optim, &unavail,
+ &lval, &addr, &realnum, raw_buffer);
reg_val = allocate_value (register_type (gdbarch, regnum));
- memcpy (value_contents_raw (reg_val), raw_buffer,
- register_size (gdbarch, regnum));
+ if (!optim && !unavail)
+ memcpy (value_contents_raw (reg_val), raw_buffer,
+ register_size (gdbarch, regnum));
+ else
+ memset (value_contents_raw (reg_val), 0,
+ register_size (gdbarch, regnum));
+
VALUE_LVAL (reg_val) = lval;
set_value_address (reg_val, addr);
VALUE_REGNUM (reg_val) = regnum;
set_value_optimized_out (reg_val, optim);
+ if (unavail)
+ mark_value_bytes_unavailable (reg_val, 0, register_size (gdbarch, regnum));
VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
return reg_val;
}
/* We should have a valid (i.e. non-sentinel) frame. */
gdb_assert (frame_id_p (get_frame_id (frame)));
- reg_val = allocate_value (register_type (gdbarch, regnum));
+ reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
VALUE_LVAL (reg_val) = lval_register;
VALUE_REGNUM (reg_val) = regnum;
VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
- set_value_lazy (reg_val, 1);
return reg_val;
}
struct type *type, const gdb_byte *buf)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
}
struct type *type, const gdb_byte *buf)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
}
gdb_byte *buf, CORE_ADDR addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
gdb_byte *buf, CORE_ADDR addr)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
\f
/* Given a struct symbol for a variable,
and a stack frame id, read the value of the variable
- and return a (pointer to a) struct value containing the value.
+ and return a (pointer to a) struct value containing the value.
If the variable cannot be found, return a zero pointer. */
struct value *
CORE_ADDR addr;
int len;
- if (SYMBOL_CLASS (var) == LOC_COMPUTED
- || SYMBOL_CLASS (var) == LOC_REGISTER)
- /* These cases do not use V. */
- v = NULL;
- else
- {
- v = allocate_value (type);
- VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
- }
+ /* Call check_typedef on our type to make sure that, if TYPE is
+ a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
+ instead of zero. However, we do not replace the typedef type by the
+ target type, because we want to keep the typedef in order to be able to
+ set the returned value type description correctly. */
+ check_typedef (type);
len = TYPE_LENGTH (type);
{
case LOC_CONST:
/* Put the constant back in target format. */
+ v = allocate_value (type);
store_signed_integer (value_contents_raw (v), len,
gdbarch_byte_order (get_type_arch (type)),
(LONGEST) SYMBOL_VALUE (var));
case LOC_LABEL:
/* Put the constant back in target format. */
+ v = allocate_value (type);
if (overlay_debugging)
{
CORE_ADDR addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
SYMBOL_OBJ_SECTION (var));
+
store_typed_address (value_contents_raw (v), type, addr);
}
else
return v;
case LOC_CONST_BYTES:
- {
- memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
- VALUE_LVAL (v) = not_lval;
- return v;
- }
+ v = allocate_value (type);
+ memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
+ VALUE_LVAL (v) = not_lval;
+ return v;
case LOC_STATIC:
+ v = allocate_value_lazy (type);
if (overlay_debugging)
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
SYMBOL_OBJ_SECTION (var));
if (!addr)
return 0;
addr += SYMBOL_VALUE (var);
+ v = allocate_value_lazy (type);
break;
case LOC_REF_ARG:
{
struct value *ref;
CORE_ADDR argref;
+
argref = get_frame_args_address (frame);
if (!argref)
return 0;
argref += SYMBOL_VALUE (var);
ref = value_at (lookup_pointer_type (type), argref);
addr = value_as_address (ref);
+ v = allocate_value_lazy (type);
break;
}
case LOC_LOCAL:
addr = get_frame_locals_address (frame);
addr += SYMBOL_VALUE (var);
+ v = allocate_value_lazy (type);
break;
case LOC_TYPEDEF:
break;
case LOC_BLOCK:
+ v = allocate_value_lazy (type);
if (overlay_debugging)
- set_value_address (v, symbol_overlayed_address
- (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)));
+ addr = symbol_overlayed_address
+ (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
else
- set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
- return v;
+ addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
+ break;
case LOC_REGISTER:
case LOC_REGPARM_ADDR:
error (_("Value of register variable not available."));
addr = value_as_address (regval);
- VALUE_LVAL (v) = lval_memory;
+ v = allocate_value_lazy (type);
}
else
{
if (obj_section
&& (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
addr = target_translate_tls_address (obj_section->objfile, addr);
+ v = allocate_value_lazy (type);
}
break;
case LOC_OPTIMIZED_OUT:
+ v = allocate_value_lazy (type);
VALUE_LVAL (v) = not_lval;
set_value_optimized_out (v, 1);
return v;
break;
}
+ VALUE_LVAL (v) = lval_memory;
set_value_address (v, addr);
- set_value_lazy (v, 1);
return v;
}
struct gdbarch *gdbarch = get_frame_arch (frame);
struct type *type1 = check_typedef (type);
struct value *v;
+ int optim, unavail, ok;
if (gdbarch_convert_register_p (gdbarch, regnum, type1))
{
VALUE_LVAL (v) = lval_register;
VALUE_FRAME_ID (v) = get_frame_id (frame);
VALUE_REGNUM (v) = regnum;
- gdbarch_register_to_value (gdbarch,
- frame, regnum, type1, value_contents_raw (v));
+ ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
+ value_contents_raw (v), &optim,
+ &unavail);
}
else
{
v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
/* Get the data. */
- if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
- value_contents_raw (v)))
+ ok = get_frame_register_bytes (frame, regnum, value_offset (v), len,
+ value_contents_raw (v),
+ &optim, &unavail);
+ }
+
+ if (!ok)
+ {
+ if (optim)
set_value_optimized_out (v, 1);
+ if (unavail)
+ mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
}
+
return v;
}
projects / deliverable / binutils-gdb.git / blobdiff