/* 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
- Free Software Foundation, Inc.
+ Copyright (C) 1986-2001, 2003-2005, 2007-2012 Free Software
+ Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "user-regs.h"
#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
#endif
LONGEST
-extract_signed_integer (const gdb_byte *addr, int len)
+extract_signed_integer (const gdb_byte *addr, int len,
+ enum bfd_endian byte_order)
{
LONGEST retval;
const unsigned char *p;
/* Start at the most significant end of the integer, and work towards
the least significant. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (byte_order == BFD_ENDIAN_BIG)
{
p = startaddr;
/* Do the sign extension once at the start. */
}
ULONGEST
-extract_unsigned_integer (const gdb_byte *addr, int len)
+extract_unsigned_integer (const gdb_byte *addr, int len,
+ enum bfd_endian byte_order)
{
ULONGEST retval;
const unsigned char *p;
/* Start at the most significant end of the integer, and work towards
the least significant. */
retval = 0;
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (byte_order == BFD_ENDIAN_BIG)
{
for (p = startaddr; p < endaddr; ++p)
retval = (retval << 8) | *p;
int
extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
- LONGEST *pval)
+ enum bfd_endian byte_order, LONGEST *pval)
{
const gdb_byte *p;
const gdb_byte *first_addr;
int len;
len = orig_len;
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (byte_order == BFD_ENDIAN_BIG)
{
for (p = addr;
len > (int) sizeof (LONGEST) && p < addr + orig_len;
if (len <= (int) sizeof (LONGEST))
{
*pval = (LONGEST) extract_unsigned_integer (first_addr,
- sizeof (LONGEST));
+ sizeof (LONGEST),
+ byte_order);
return 1;
}
_("extract_typed_address: "
"type is not a pointer or reference"));
- return gdbarch_pointer_to_address (current_gdbarch, type, buf);
+ 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, LONGEST val)
+store_signed_integer (gdb_byte *addr, int len,
+ enum bfd_endian byte_order, LONGEST val)
{
gdb_byte *p;
gdb_byte *startaddr = addr;
/* Start at the least significant end of the integer, and work towards
the most significant. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (byte_order == BFD_ENDIAN_BIG)
{
for (p = endaddr - 1; p >= startaddr; --p)
{
}
void
-store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val)
+store_unsigned_integer (gdb_byte *addr, int len,
+ enum bfd_endian byte_order, ULONGEST val)
{
unsigned char *p;
unsigned char *startaddr = (unsigned char *) addr;
/* Start at the least significant end of the integer, and work towards
the most significant. */
- if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+ if (byte_order == BFD_ENDIAN_BIG)
{
for (p = endaddr - 1; p >= startaddr; --p)
{
_("store_typed_address: "
"type is not a pointer or reference"));
- gdbarch_address_to_pointer (current_gdbarch, type, buf, addr);
+ gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
}
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;
- VALUE_ADDRESS (reg_val) = addr;
+ 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;
}
/* Given a pointer of type TYPE in target form in BUF, return the
address it represents. */
CORE_ADDR
-unsigned_pointer_to_address (struct type *type, const gdb_byte *buf)
+unsigned_pointer_to_address (struct gdbarch *gdbarch,
+ struct type *type, const gdb_byte *buf)
{
- return extract_unsigned_integer (buf, TYPE_LENGTH (type));
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
}
CORE_ADDR
-signed_pointer_to_address (struct type *type, const gdb_byte *buf)
+signed_pointer_to_address (struct gdbarch *gdbarch,
+ struct type *type, const gdb_byte *buf)
{
- return extract_signed_integer (buf, TYPE_LENGTH (type));
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
}
/* Given an address, store it as a pointer of type TYPE in target
format in BUF. */
void
-unsigned_address_to_pointer (struct type *type, gdb_byte *buf,
- CORE_ADDR addr)
+unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
+ gdb_byte *buf, CORE_ADDR addr)
{
- store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
void
-address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
+address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
+ gdb_byte *buf, CORE_ADDR addr)
{
- store_signed_integer (buf, TYPE_LENGTH (type), addr);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
}
\f
/* Will calling read_var_value or locate_var_value on SYM end
/* All cases listed explicitly so that gcc -Wall will detect it if
we failed to consider one. */
case LOC_COMPUTED:
- case LOC_COMPUTED_ARG:
/* FIXME: cagney/2004-01-26: It should be possible to
- unconditionally call the SYMBOL_OPS method when available.
+ unconditionally call the SYMBOL_COMPUTED_OPS method when available.
Unfortunately DWARF 2 stores the frame-base (instead of the
function) location in a function's symbol. Oops! For the
moment enable this when/where applicable. */
- return SYMBOL_OPS (sym)->read_needs_frame (sym);
+ return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
case LOC_REGISTER:
case LOC_ARG:
case LOC_REF_ARG:
- case LOC_REGPARM:
case LOC_REGPARM_ADDR:
case LOC_LOCAL:
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
return 1;
case LOC_UNDEF:
/* 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.
- If the variable cannot be found, return a zero pointer.
- If FRAME is NULL, use the selected frame. */
+ and return a (pointer to a) struct value containing the value.
+ If the variable cannot be found, throw error. */
struct value *
read_var_value (struct symbol *var, struct frame_info *frame)
CORE_ADDR addr;
int len;
- if (SYMBOL_CLASS (var) == LOC_COMPUTED
- || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
- || SYMBOL_CLASS (var) == LOC_REGISTER
- || SYMBOL_CLASS (var) == LOC_REGPARM)
- /* 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);
- /* FIXME drow/2003-09-06: this call to the selected frame should be
- pushed upwards to the callers. */
- if (frame == NULL)
- frame = deprecated_safe_get_selected_frame ();
+ if (symbol_read_needs_frame (var))
+ gdb_assert (frame);
switch (SYMBOL_CLASS (var))
{
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));
VALUE_LVAL (v) = not_lval;
return v;
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_BFD_SECTION (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_BFD_SECTION (var));
+ SYMBOL_OBJ_SECTION (var));
else
addr = SYMBOL_VALUE_ADDRESS (var);
break;
case LOC_ARG:
- if (frame == NULL)
- return 0;
addr = get_frame_args_address (frame);
if (!addr)
- return 0;
+ error (_("Unknown argument list address for `%s'."),
+ SYMBOL_PRINT_NAME (var));
addr += SYMBOL_VALUE (var);
+ v = allocate_value_lazy (type);
break;
case LOC_REF_ARG:
{
struct value *ref;
CORE_ADDR argref;
- if (frame == NULL)
- return 0;
+
argref = get_frame_args_address (frame);
if (!argref)
- return 0;
+ error (_("Unknown argument list address for `%s'."),
+ SYMBOL_PRINT_NAME (var));
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:
- if (frame == NULL)
- return 0;
addr = get_frame_locals_address (frame);
addr += SYMBOL_VALUE (var);
+ v = allocate_value_lazy (type);
break;
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
- {
- struct value *regval;
-
- regval = value_from_register (lookup_pointer_type (type),
- SYMBOL_BASEREG (var), frame);
- if (regval == NULL)
- error (_("Value of base register not available."));
- addr = value_as_address (regval);
- addr += SYMBOL_VALUE (var);
- break;
- }
-
case LOC_TYPEDEF:
- error (_("Cannot look up value of a typedef"));
+ error (_("Cannot look up value of a typedef `%s'."),
+ SYMBOL_PRINT_NAME (var));
break;
case LOC_BLOCK:
+ v = allocate_value_lazy (type);
if (overlay_debugging)
- VALUE_ADDRESS (v) = symbol_overlayed_address
- (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
+ addr = symbol_overlayed_address
+ (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
else
- 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:
case LOC_REGPARM_ADDR:
{
- struct block *b;
- int regno = SYMBOL_VALUE (var);
+ int regno = SYMBOL_REGISTER_OPS (var)
+ ->register_number (var, get_frame_arch (frame));
struct value *regval;
- if (frame == NULL)
- return 0;
- b = get_frame_block (frame, 0);
-
if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
{
regval = value_from_register (lookup_pointer_type (type),
frame);
if (regval == NULL)
- error (_("Value of register variable not available."));
+ error (_("Value of register variable not available for `%s'."),
+ SYMBOL_PRINT_NAME (var));
addr = value_as_address (regval);
- VALUE_LVAL (v) = lval_memory;
+ v = allocate_value_lazy (type);
}
else
{
regval = value_from_register (type, regno, frame);
if (regval == NULL)
- error (_("Value of register variable not available."));
+ error (_("Value of register variable not available for `%s'."),
+ SYMBOL_PRINT_NAME (var));
return regval;
}
}
break;
case LOC_COMPUTED:
- case LOC_COMPUTED_ARG:
/* FIXME: cagney/2004-01-26: It should be possible to
- unconditionally call the SYMBOL_OPS method when available.
+ unconditionally call the SYMBOL_COMPUTED_OPS method when available.
Unfortunately DWARF 2 stores the frame-base (instead of the
function) location in a function's symbol. Oops! For the
moment enable this when/where applicable. */
- if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
- return 0;
- return SYMBOL_OPS (var)->read_variable (var, frame);
+ return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
case LOC_UNRESOLVED:
{
struct minimal_symbol *msym;
+ struct obj_section *obj_section;
- msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
+ msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
if (msym == NULL)
- return 0;
+ error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
if (overlay_debugging)
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
- SYMBOL_BFD_SECTION (msym));
+ SYMBOL_OBJ_SECTION (msym));
else
addr = SYMBOL_VALUE_ADDRESS (msym);
+
+ obj_section = SYMBOL_OBJ_SECTION (msym);
+ 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:
- VALUE_LVAL (v) = not_lval;
- set_value_optimized_out (v, 1);
- return v;
+ return allocate_optimized_out_value (type);
default:
- error (_("Cannot look up value of a botched symbol."));
+ error (_("Cannot look up value of a botched symbol `%s'."),
+ SYMBOL_PRINT_NAME (var));
break;
}
- VALUE_ADDRESS (v) = addr;
- set_value_lazy (v, 1);
+ VALUE_LVAL (v) = lval_memory;
+ set_value_address (v, addr);
return v;
}
return value;
}
+/* VALUE must be an lval_register value. If regnum is the value's
+ associated register number, and len the length of the values type,
+ read one or more registers in FRAME, starting with register REGNUM,
+ until we've read LEN bytes. */
+
+void
+read_frame_register_value (struct value *value, struct frame_info *frame)
+{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ int offset = 0;
+ int reg_offset = value_offset (value);
+ int regnum = VALUE_REGNUM (value);
+ int len = TYPE_LENGTH (check_typedef (value_type (value)));
+
+ gdb_assert (VALUE_LVAL (value) == lval_register);
+
+ /* Skip registers wholly inside of REG_OFFSET. */
+ while (reg_offset >= register_size (gdbarch, regnum))
+ {
+ reg_offset -= register_size (gdbarch, regnum);
+ regnum++;
+ }
+
+ /* Copy the data. */
+ while (len > 0)
+ {
+ struct value *regval = get_frame_register_value (frame, regnum);
+ int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
+
+ /* If the register length is larger than the number of bytes
+ remaining to copy, then only copy the appropriate bytes. */
+ if (reg_len > len)
+ reg_len = len;
+
+ value_contents_copy (value, offset, regval, reg_offset, reg_len);
+
+ offset += reg_len;
+ len -= reg_len;
+ reg_offset = 0;
+ regnum++;
+ }
+}
+
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
struct value *
if (gdbarch_convert_register_p (gdbarch, regnum, type1))
{
+ int optim, unavail, ok;
+
/* The ISA/ABI need to something weird when obtaining the
specified value from this register. It might need to
re-order non-adjacent, starting with REGNUM (see MIPS and
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);
+
+ if (!ok)
+ {
+ if (optim)
+ set_value_optimized_out (v, 1);
+ if (unavail)
+ mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
+ }
}
else
{
- int len = TYPE_LENGTH (type);
-
/* Construct the value. */
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)))
- set_value_optimized_out (v, 1);
+ read_frame_register_value (v, frame);
}
+
return v;
}
return result;
}
-\f
-/* Given a struct symbol for a variable or function,
- and a stack frame id,
- return a (pointer to a) struct value containing the properly typed
- address. */
-
-struct value *
-locate_var_value (struct symbol *var, struct frame_info *frame)
-{
- struct gdbarch *gdbarch = get_frame_arch (frame);
- CORE_ADDR addr = 0;
- struct type *type = SYMBOL_TYPE (var);
- struct value *lazy_value;
-
- /* Evaluate it first; if the result is a memory address, we're fine.
- Lazy evaluation pays off here. */
-
- lazy_value = read_var_value (var, frame);
- if (lazy_value == 0)
- error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
-
- if ((VALUE_LVAL (lazy_value) == lval_memory && value_lazy (lazy_value))
- || TYPE_CODE (type) == TYPE_CODE_FUNC)
- {
- struct value *val;
-
- addr = VALUE_ADDRESS (lazy_value);
- val = value_from_pointer (lookup_pointer_type (type), addr);
- return val;
- }
-
- /* Not a memory address; check what the problem was. */
- switch (VALUE_LVAL (lazy_value))
- {
- case lval_register:
- gdb_assert (gdbarch_register_name
- (gdbarch, VALUE_REGNUM (lazy_value)) != NULL
- && *gdbarch_register_name
- (gdbarch, VALUE_REGNUM (lazy_value)) != '\0');
- error (_("Address requested for identifier "
- "\"%s\" which is in register $%s"),
- SYMBOL_PRINT_NAME (var),
- gdbarch_register_name (gdbarch, VALUE_REGNUM (lazy_value)));
- break;
-
- default:
- error (_("Can't take address of \"%s\" which isn't an lvalue."),
- SYMBOL_PRINT_NAME (var));
- break;
- }
- return 0; /* For lint -- never reached */
-}
projects / external / binutils.git / blobdiff