/* Find a variable's value in memory, for GDB, the GNU debugger.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software
- Foundation, Inc.
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005 Free
+ Software Foundation, Inc.
This file is part of GDB.
const unsigned char *endaddr = startaddr + len;
if (len > (int) sizeof (LONGEST))
- error ("\
-That operation is not available on integers of more than %d bytes.",
+ error (_("\
+That operation is not available on integers of more than %d bytes."),
(int) sizeof (LONGEST));
/* Start at the most significant end of the integer, and work towards
const unsigned char *endaddr = startaddr + len;
if (len > (int) sizeof (ULONGEST))
- error ("\
-That operation is not available on integers of more than %d bytes.",
+ error (_("\
+That operation is not available on integers of more than %d bytes."),
(int) sizeof (ULONGEST));
/* Start at the most significant end of the integer, and work towards
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
internal_error (__FILE__, __LINE__,
- "extract_typed_address: "
- "type is not a pointer or reference");
+ _("extract_typed_address: "
+ "type is not a pointer or reference"));
return POINTER_TO_ADDRESS (type, buf);
}
if (TYPE_CODE (type) != TYPE_CODE_PTR
&& TYPE_CODE (type) != TYPE_CODE_REF)
internal_error (__FILE__, __LINE__,
- "store_typed_address: "
- "type is not a pointer or reference");
+ _("store_typed_address: "
+ "type is not a pointer or reference"));
ADDRESS_TO_POINTER (type, buf, addr);
}
reg_val = allocate_value (register_type (current_gdbarch, regnum));
- /* Convert raw data to virtual format if necessary. */
-
- if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
- memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
- DEPRECATED_REGISTER_RAW_SIZE (regnum));
- else
- internal_error (__FILE__, __LINE__,
- "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
- REGISTER_NAME (regnum),
- regnum,
- DEPRECATED_REGISTER_RAW_SIZE (regnum),
- DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
+ memcpy (value_contents_raw (reg_val), raw_buffer,
+ register_size (current_gdbarch, regnum));
VALUE_LVAL (reg_val) = lval;
VALUE_ADDRESS (reg_val) = addr;
- VALUE_REGNO (reg_val) = regnum;
- VALUE_OPTIMIZED_OUT (reg_val) = optim;
+ VALUE_REGNUM (reg_val) = regnum;
+ set_value_optimized_out (reg_val, optim);
+ VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
return reg_val;
}
CORE_ADDR addr;
int len;
- v = allocate_value (type);
- VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
- VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
+ 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. */
+ }
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)
{
case LOC_CONST:
/* Put the constant back in target format. */
- store_signed_integer (VALUE_CONTENTS_RAW (v), len,
+ store_signed_integer (value_contents_raw (v), len,
(LONGEST) SYMBOL_VALUE (var));
VALUE_LVAL (v) = not_lval;
return v;
CORE_ADDR addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
SYMBOL_BFD_SECTION (var));
- store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
+ store_typed_address (value_contents_raw (v), type, addr);
}
else
- store_typed_address (VALUE_CONTENTS_RAW (v), type,
+ store_typed_address (value_contents_raw (v), type,
SYMBOL_VALUE_ADDRESS (var));
VALUE_LVAL (v) = not_lval;
return v;
{
char *bytes_addr;
bytes_addr = SYMBOL_VALUE_BYTES (var);
- memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
+ memcpy (value_contents_raw (v), bytes_addr, len);
VALUE_LVAL (v) = not_lval;
return v;
}
CORE_ADDR locaddr;
struct value *loc;
if (!target_has_execution)
- error ("\
+ 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.");
+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, NULL);
+ loc = value_at (lookup_pointer_type (type), locaddr);
addr = value_as_address (loc);
+ break;
}
case LOC_ARG:
if (!argref)
return 0;
argref += SYMBOL_VALUE (var);
- ref = value_at (lookup_pointer_type (type), argref, NULL);
+ ref = value_at (lookup_pointer_type (type), argref);
addr = value_as_address (ref);
break;
}
regval = value_from_register (lookup_pointer_type (type),
SYMBOL_BASEREG (var), frame);
if (regval == NULL)
- error ("Value of base register not available.");
+ 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"));
break;
case LOC_BLOCK:
frame);
if (regval == NULL)
- error ("Value of register variable not available.");
+ error (_("Value of register variable not available."));
addr = value_as_address (regval);
VALUE_LVAL (v) = lval_memory;
regval = value_from_register (type, regno, frame);
if (regval == NULL)
- error ("Value of register variable not available.");
+ error (_("Value of register variable not available."));
return regval;
}
}
case LOC_OPTIMIZED_OUT:
VALUE_LVAL (v) = not_lval;
- VALUE_OPTIMIZED_OUT (v) = 1;
+ set_value_optimized_out (v, 1);
return v;
default:
- error ("Cannot look up value of a botched symbol.");
+ error (_("Cannot look up value of a botched symbol."));
break;
}
VALUE_ADDRESS (v) = addr;
- VALUE_LAZY (v) = 1;
+ set_value_lazy (v, 1);
return v;
}
We'll just attribute the value to the original register. */
VALUE_LVAL (v) = lval_register;
VALUE_ADDRESS (v) = regnum;
- VALUE_REGNO (v) = regnum;
+ VALUE_REGNUM (v) = regnum;
}
else if (CONVERT_REGISTER_P (regnum, type))
{
the corresponding [integer] type (see Alpha). The assumption
is that REGISTER_TO_VALUE populates the entire value
including the location. */
- REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v));
- VALUE_LVAL (v) = lval_reg_frame_relative;
+ REGISTER_TO_VALUE (frame, regnum, type, value_contents_raw (v));
+ VALUE_LVAL (v) = lval_register;
VALUE_FRAME_ID (v) = get_frame_id (frame);
- VALUE_FRAME_REGNUM (v) = regnum;
+ VALUE_REGNUM (v) = regnum;
}
else
{
/* Copy all of the data out, whereever it may be. */
for (local_regnum = regnum, value_bytes_copied = 0;
value_bytes_copied < len;
- (value_bytes_copied += DEPRECATED_REGISTER_RAW_SIZE (local_regnum),
+ (value_bytes_copied += register_size (current_gdbarch, local_regnum),
++local_regnum))
{
int realnum;
{
mem_stor++;
+ /* FIXME: cagney/2004-11-12: I think this is trying to
+ check that the stored registers are adjacent in
+ memory. It isn't doing a good job? */
mem_tracking = (mem_tracking
&& (regnum == local_regnum
|| addr == last_addr));
last_addr = addr;
}
- /* FIXME: cagney/2003-06-04: Shouldn't this always use
- lval_reg_frame_relative? If it doesn't and the register's
- location changes (say after a resume) then this value is
- going to have wrong information. */
- if ((reg_stor && mem_stor)
- || (mem_stor && !mem_tracking))
- /* Mixed storage; all of the hassle we just went through was
- for some good purpose. */
- {
- VALUE_LVAL (v) = lval_reg_frame_relative;
- VALUE_FRAME_ID (v) = get_frame_id (frame);
- VALUE_FRAME_REGNUM (v) = regnum;
- }
- else if (mem_stor)
+ if (mem_tracking && mem_stor && !reg_stor)
{
VALUE_LVAL (v) = lval_memory;
VALUE_ADDRESS (v) = first_addr;
}
- else if (reg_stor)
+ else
{
VALUE_LVAL (v) = lval_register;
- VALUE_ADDRESS (v) = first_addr;
- VALUE_REGNO (v) = first_realnum;
+ VALUE_FRAME_ID (v) = get_frame_id (frame);
+ VALUE_REGNUM (v) = regnum;
}
- else
- internal_error (__FILE__, __LINE__,
- "value_from_register: Value not stored anywhere!");
- VALUE_OPTIMIZED_OUT (v) = optimized;
+ set_value_optimized_out (v, optimized);
/* 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 < DEPRECATED_REGISTER_RAW_SIZE (regnum))
+ && len < register_size (current_gdbarch, regnum))
/* Big-endian, and we want less than full size. */
- VALUE_OFFSET (v) = DEPRECATED_REGISTER_RAW_SIZE (regnum) - len;
+ set_value_offset (v, register_size (current_gdbarch, regnum) - len);
else
- VALUE_OFFSET (v) = 0;
- memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len);
+ set_value_offset (v, 0);
+ memcpy (value_contents_raw (v), value_bytes + value_offset (v), len);
}
return v;
}
lazy_value = read_var_value (var, frame);
if (lazy_value == 0)
- error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
+ error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
- if (VALUE_LAZY (lazy_value)
+ if (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);
- VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
return val;
}
switch (VALUE_LVAL (lazy_value))
{
case lval_register:
- gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
- && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
- error("Address requested for identifier "
- "\"%s\" which is in register $%s",
- SYMBOL_PRINT_NAME (var),
- REGISTER_NAME (VALUE_REGNO (lazy_value)));
- break;
-
- case lval_reg_frame_relative:
- gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
- && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
- error("Address requested for identifier "
- "\"%s\" which is in frame register $%s",
+ gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
+ && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
+ error (_("Address requested for identifier "
+ "\"%s\" which is in register $%s"),
SYMBOL_PRINT_NAME (var),
- REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
+ REGISTER_NAME (VALUE_REGNUM (lazy_value)));
break;
default:
- error ("Can't take address of \"%s\" which isn't an lvalue.",
+ error (_("Can't take address of \"%s\" which isn't an lvalue."),
SYMBOL_PRINT_NAME (var));
break;
}
projects / deliverable / binutils-gdb.git / blobdiff