/* 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 Free
- Software Foundation, Inc.
+ 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.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "symtab.h"
/* Start at the most significant end of the integer, and work towards
the least significant. */
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
p = startaddr;
/* Do the sign extension once at the start. */
/* Start at the most significant end of the integer, and work towards
the least significant. */
retval = 0;
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
for (p = startaddr; p < endaddr; ++p)
retval = (retval << 8) | *p;
int len;
len = orig_len;
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
for (p = addr;
len > (int) sizeof (LONGEST) && p < addr + orig_len;
_("extract_typed_address: "
"type is not a pointer or reference"));
- return POINTER_TO_ADDRESS (type, buf);
+ return gdbarch_pointer_to_address (current_gdbarch, type, buf);
}
/* Start at the least significant end of the integer, and work towards
the most significant. */
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
for (p = endaddr - 1; p >= startaddr; --p)
{
/* Start at the least significant end of the integer, and work towards
the most significant. */
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
{
for (p = endaddr - 1; p >= startaddr; --p)
{
_("store_typed_address: "
"type is not a pointer or reference"));
- ADDRESS_TO_POINTER (type, buf, addr);
+ gdbarch_address_to_pointer (current_gdbarch, type, buf, addr);
}
/* Return a `value' with the contents of (virtual or cooked) register
REGNUM as found in the specified FRAME. The register's type is
- determined by register_type().
-
- NOTE: returns NULL if register value is not available. Caller will
- check return value or die! */
+ determined by register_type(). */
struct value *
value_of_register (int regnum, struct frame_info *frame)
{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR addr;
int optim;
struct value *reg_val;
/* User registers lie completely outside of the range of normal
registers. Catch them early so that the target never sees them. */
- if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
+ if (regnum >= gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch))
return value_of_user_reg (regnum, frame);
frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
- /* FIXME: cagney/2002-05-15: This test is just bogus.
-
- It indicates that the target failed to supply a value for a
- register because it was "not available" at this time. Problem
- is, the target still has the register and so get saved_register()
- may be returning a value saved on the stack. */
-
- if (register_cached (regnum) < 0)
- return NULL; /* register value not available */
-
- reg_val = allocate_value (register_type (current_gdbarch, regnum));
+ reg_val = allocate_value (register_type (gdbarch, regnum));
memcpy (value_contents_raw (reg_val), raw_buffer,
- register_size (current_gdbarch, regnum));
+ register_size (gdbarch, regnum));
VALUE_LVAL (reg_val) = lval;
VALUE_ADDRESS (reg_val) = addr;
VALUE_REGNUM (reg_val) = regnum;
return reg_val;
}
+/* Return a `value' with the contents of (virtual or cooked) register
+ REGNUM as found in the specified FRAME. The register's type is
+ determined by register_type(). The value is not fetched. */
+
+struct value *
+value_of_register_lazy (struct frame_info *frame, int regnum)
+{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ struct value *reg_val;
+
+ gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
+ + gdbarch_num_pseudo_regs (gdbarch)));
+
+ /* 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));
+ 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
/* 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.
Unfortunately DWARF 2 stores the frame-base (instead of the
case LOC_REGISTER:
case LOC_ARG:
case LOC_REF_ARG:
- case LOC_REGPARM:
case LOC_REGPARM_ADDR:
case LOC_LOCAL:
- case LOC_LOCAL_ARG:
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
- case LOC_HP_THREAD_LOCAL_STATIC:
return 1;
case LOC_UNDEF:
case LOC_CONST:
case LOC_STATIC:
- case LOC_INDIRECT:
case LOC_TYPEDEF:
case LOC_LABEL:
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 deprecated_selected_frame. */
+ If FRAME is NULL, use the selected frame. */
struct value *
read_var_value (struct symbol *var, struct frame_info *frame)
int len;
if (SYMBOL_CLASS (var) == LOC_COMPUTED
- || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
- || SYMBOL_CLASS (var) == LOC_REGISTER
- || SYMBOL_CLASS (var) == LOC_REGPARM)
+ || SYMBOL_CLASS (var) == LOC_REGISTER)
/* These cases do not use V. */
v = NULL;
else
{
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
case LOC_STATIC:
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_INDIRECT:
- {
- /* The import slot does not have a real address in it from the
- dynamic loader (dld.sl on HP-UX), if the target hasn't
- begun execution yet, so check for that. */
- CORE_ADDR locaddr;
- struct value *loc;
- if (!target_has_execution)
- error (_("\
-Attempt to access variable defined in different shared object or load module when\n\
-addresses have not been bound by the dynamic loader. Try again when executable is running."));
-
- locaddr = SYMBOL_VALUE_ADDRESS (var);
- loc = value_at (lookup_pointer_type (type), locaddr);
- addr = value_as_address (loc);
- break;
- }
-
case LOC_ARG:
if (frame == NULL)
return 0;
}
case LOC_LOCAL:
- case LOC_LOCAL_ARG:
if (frame == NULL)
return 0;
addr = get_frame_locals_address (frame);
addr += SYMBOL_VALUE (var);
break;
- case LOC_BASEREG:
- case LOC_BASEREG_ARG:
- case LOC_HP_THREAD_LOCAL_STATIC:
- {
- 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"));
break;
case LOC_BLOCK:
if (overlay_debugging)
VALUE_ADDRESS (v) = symbol_overlayed_address
- (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
+ (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
else
VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
return v;
case LOC_REGISTER:
- case LOC_REGPARM:
case LOC_REGPARM_ADDR:
{
- struct block *b;
int regno = SYMBOL_VALUE (var);
struct value *regval;
if (frame == NULL)
return 0;
- b = get_frame_block (frame, 0);
if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
{
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.
Unfortunately DWARF 2 stores the frame-base (instead of the
{
struct minimal_symbol *msym;
- 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;
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);
}
return v;
}
+/* Install default attributes for register values. */
+
+struct value *
+default_value_from_register (struct type *type, int regnum,
+ struct frame_info *frame)
+{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
+ int len = TYPE_LENGTH (type);
+ struct value *value = allocate_value (type);
+
+ VALUE_LVAL (value) = lval_register;
+ VALUE_FRAME_ID (value) = get_frame_id (frame);
+ VALUE_REGNUM (value) = regnum;
+
+ /* Any structure stored in more than one register will always be
+ an integral number of registers. Otherwise, you need to do
+ some fiddling with the last register copied here for little
+ endian machines. */
+ if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
+ && len < register_size (gdbarch, regnum))
+ /* Big-endian, and we want less than full size. */
+ set_value_offset (value, register_size (gdbarch, regnum) - len);
+ else
+ set_value_offset (value, 0);
+
+ return value;
+}
+
/* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
struct value *
value_from_register (struct type *type, int regnum, struct frame_info *frame)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
- struct value *v = allocate_value (type);
- CHECK_TYPEDEF (type);
-
- VALUE_LVAL (v) = lval_register;
- VALUE_FRAME_ID (v) = get_frame_id (frame);
- VALUE_REGNUM (v) = regnum;
-
- if (CONVERT_REGISTER_P (regnum, type))
+ struct type *type1 = check_typedef (type);
+ struct value *v;
+
+ if (gdbarch_convert_register_p (gdbarch, regnum, type1))
{
/* 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
i386). It might need to convert the [float] register into
the corresponding [integer] type (see Alpha). The assumption
- is that REGISTER_TO_VALUE populates the entire value
+ is that gdbarch_register_to_value populates the entire value
including the location. */
- REGISTER_TO_VALUE (frame, regnum, type, value_contents_raw (v));
+ v = allocate_value (type);
+ 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));
}
else
{
int len = TYPE_LENGTH (type);
- /* Any structure stored in more than one register will always be
- an integral number of registers. Otherwise, you need to do
- some fiddling with the last register copied here for little
- endian machines. */
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
- && len < register_size (gdbarch, regnum))
- /* Big-endian, and we want less than full size. */
- set_value_offset (v, register_size (gdbarch, regnum) - len);
- else
- set_value_offset (v, 0);
+ /* 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,
struct value *
locate_var_value (struct symbol *var, struct frame_info *frame)
{
+ struct gdbarch *gdbarch;
CORE_ADDR addr = 0;
struct type *type = SYMBOL_TYPE (var);
struct value *lazy_value;
if (lazy_value == 0)
error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
- if (value_lazy (lazy_value)
+ if ((VALUE_LVAL (lazy_value) == lval_memory && value_lazy (lazy_value))
|| TYPE_CODE (type) == TYPE_CODE_FUNC)
{
struct value *val;
switch (VALUE_LVAL (lazy_value))
{
case lval_register:
- gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
- && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
+ gdb_assert (frame);
+ gdbarch = get_frame_arch (frame);
+ 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),
- REGISTER_NAME (VALUE_REGNUM (lazy_value)));
+ gdbarch_register_name (gdbarch, VALUE_REGNUM (lazy_value)));
break;
default:
projects / deliverable / binutils-gdb.git / blobdiff