/* Perform non-arithmetic operations on values, for GDB.
+
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
Free Software Foundation, Inc.
This file is part of GDB.
int convert_to_boolean = 0;
- if (VALUE_TYPE (arg2) == type)
+ if (value_type (arg2) == type)
return arg2;
CHECK_TYPEDEF (type);
code1 = TYPE_CODE (type);
- COERCE_REF (arg2);
- type2 = check_typedef (VALUE_TYPE (arg2));
+ arg2 = coerce_ref (arg2);
+ type2 = check_typedef (value_type (arg2));
/* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
is treated like a cast to (TYPE [N])OBJECT,
TYPE_TARGET_TYPE (range_type),
low_bound,
new_length + low_bound - 1);
- VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
- element_type, range_type);
+ arg2->type = create_array_type ((struct type *) NULL,
+ element_type, range_type);
return arg2;
}
}
if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
arg2 = value_coerce_function (arg2);
- type2 = check_typedef (VALUE_TYPE (arg2));
+ type2 = check_typedef (value_type (arg2));
code2 = TYPE_CODE (type2);
if (code1 == TYPE_CODE_COMPLEX)
arg2, 0, type2, 1);
if (v)
{
- VALUE_TYPE (v) = type;
+ v->type = type;
return v;
}
}
if (v)
{
v = value_addr (v);
- VALUE_TYPE (v) = type;
+ v->type = type;
return v;
}
}
{
CORE_ADDR addr2 = value_as_address (arg2);
addr2 -= (VALUE_ADDRESS (v)
- + VALUE_OFFSET (v)
+ + value_offset (v)
+ VALUE_EMBEDDED_OFFSET (v));
return value_from_pointer (type, addr2);
}
}
/* No superclass found, just fall through to change ptr type. */
}
- VALUE_TYPE (arg2) = type;
+ arg2->type = type;
arg2 = value_change_enclosing_type (arg2, type);
VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */
return arg2;
}
else if (VALUE_LVAL (arg2) == lval_memory)
- {
- return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
- VALUE_BFD_SECTION (arg2));
- }
+ return value_at_lazy (type, VALUE_ADDRESS (arg2) + value_offset (arg2));
else if (code1 == TYPE_CODE_VOID)
{
return value_zero (builtin_type_void, not_lval);
adjustments before or after calling it. */
struct value *
-value_at (struct type *type, CORE_ADDR addr, asection *sect)
+value_at (struct type *type, CORE_ADDR addr)
{
struct value *val;
val = allocate_value (type);
- read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
+ read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
- VALUE_BFD_SECTION (val) = sect;
return val;
}
/* Return a lazy value with type TYPE located at ADDR (cf. value_at). */
struct value *
-value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
+value_at_lazy (struct type *type, CORE_ADDR addr)
{
struct value *val;
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
VALUE_LAZY (val) = 1;
- VALUE_BFD_SECTION (val) = sect;
return val;
}
-/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
- if the current data for a variable needs to be loaded into
+/* Called only from the VALUE_CONTENTS and value_contents_all()
+ macros, if the current data for a variable needs to be loaded into
VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
- clears the lazy flag to indicate that the data in the buffer is valid.
+ clears the lazy flag to indicate that the data in the buffer is
+ valid.
If the value is zero-length, we avoid calling read_memory, which would
abort. We mark the value as fetched anyway -- all 0 bytes of it.
int
value_fetch_lazy (struct value *val)
{
- CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
- int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
+ CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
+ int length = TYPE_LENGTH (value_enclosing_type (val));
- struct type *type = VALUE_TYPE (val);
+ struct type *type = value_type (val);
if (length)
- read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
+ read_memory (addr, value_contents_all_raw (val), length);
VALUE_LAZY (val) = 0;
return 0;
if (!toval->modifiable)
error ("Left operand of assignment is not a modifiable lvalue.");
- COERCE_REF (toval);
+ toval = coerce_ref (toval);
- type = VALUE_TYPE (toval);
+ type = value_type (toval);
if (VALUE_LVAL (toval) != lval_internalvar)
fromval = value_cast (type, fromval);
else
- COERCE_ARRAY (fromval);
+ fromval = coerce_array (fromval);
CHECK_TYPEDEF (type);
/* Since modifying a register can trash the frame chain, and modifying memory
case lval_internalvar:
set_internalvar (VALUE_INTERNALVAR (toval), fromval);
val = value_copy (VALUE_INTERNALVAR (toval)->value);
- val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
+ val = value_change_enclosing_type (val, value_enclosing_type (fromval));
VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
return val;
case lval_internalvar_component:
set_internalvar_component (VALUE_INTERNALVAR (toval),
- VALUE_OFFSET (toval),
- VALUE_BITPOS (toval),
- VALUE_BITSIZE (toval),
+ value_offset (toval),
+ value_bitpos (toval),
+ value_bitsize (toval),
fromval);
break;
int changed_len;
char buffer[sizeof (LONGEST)];
- if (VALUE_BITSIZE (toval))
+ if (value_bitsize (toval))
{
/* We assume that the argument to read_memory is in units of
host chars. FIXME: Is that correct? */
- changed_len = (VALUE_BITPOS (toval)
- + VALUE_BITSIZE (toval)
+ changed_len = (value_bitpos (toval)
+ + value_bitsize (toval)
+ HOST_CHAR_BIT - 1)
/ HOST_CHAR_BIT;
error ("Can't handle bitfields which don't fit in a %d bit word.",
(int) sizeof (LONGEST) * HOST_CHAR_BIT);
- read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
+ read_memory (VALUE_ADDRESS (toval) + value_offset (toval),
buffer, changed_len);
modify_field (buffer, value_as_long (fromval),
- VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
- changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+ value_bitpos (toval), value_bitsize (toval));
+ changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
dest_buffer = buffer;
}
else
{
- changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
+ changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
changed_len = TYPE_LENGTH (type);
dest_buffer = VALUE_CONTENTS (fromval);
}
}
break;
- case lval_reg_frame_relative:
case lval_register:
{
struct frame_info *frame;
int value_reg;
/* Figure out which frame this is in currently. */
- if (VALUE_LVAL (toval) == lval_register)
- {
- frame = get_current_frame ();
- value_reg = VALUE_REGNO (toval);
- }
- else
- {
- frame = frame_find_by_id (VALUE_FRAME_ID (toval));
- value_reg = VALUE_FRAME_REGNUM (toval);
- }
+ frame = frame_find_by_id (VALUE_FRAME_ID (toval));
+ value_reg = VALUE_REGNUM (toval);
if (!frame)
error ("Value being assigned to is no longer active.");
- if (VALUE_LVAL (toval) == lval_reg_frame_relative
- && CONVERT_REGISTER_P (VALUE_FRAME_REGNUM (toval), type))
+ if (VALUE_LVAL (toval) == lval_register
+ && CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
{
/* If TOVAL is a special machine register requiring
conversion of program values to a special raw format. */
- VALUE_TO_REGISTER (frame, VALUE_FRAME_REGNUM (toval),
+ VALUE_TO_REGISTER (frame, VALUE_REGNUM (toval),
type, VALUE_CONTENTS (fromval));
}
else
{
int offset;
for (reg_offset = value_reg, offset = 0;
- offset + register_size (current_gdbarch, reg_offset) <= VALUE_OFFSET (toval);
+ offset + register_size (current_gdbarch, reg_offset) <= value_offset (toval);
reg_offset++);
- byte_offset = VALUE_OFFSET (toval) - offset;
+ byte_offset = value_offset (toval) - offset;
}
/* Compute the number of register aligned values that need
to be copied. */
- if (VALUE_BITSIZE (toval))
+ if (value_bitsize (toval))
amount_to_copy = byte_offset + 1;
else
amount_to_copy = byte_offset + TYPE_LENGTH (type);
frame_register_read (frame, regno, buffer + amount_copied);
/* Modify what needs to be modified. */
- if (VALUE_BITSIZE (toval))
+ if (value_bitsize (toval))
modify_field (buffer + byte_offset,
value_as_long (fromval),
- VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
+ value_bitpos (toval), value_bitsize (toval));
else
memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
TYPE_LENGTH (type));
{
case lval_memory:
case lval_register:
- case lval_reg_frame_relative:
reinit_frame_cache ();
/* If the field does not entirely fill a LONGEST, then zero the sign bits.
If the field is signed, and is negative, then sign extend. */
- if ((VALUE_BITSIZE (toval) > 0)
- && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
+ if ((value_bitsize (toval) > 0)
+ && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
{
LONGEST fieldval = value_as_long (fromval);
- LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
+ LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
fieldval &= valmask;
if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
}
val = value_copy (toval);
- memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
+ memcpy (value_contents_raw (val), VALUE_CONTENTS (fromval),
TYPE_LENGTH (type));
- VALUE_TYPE (val) = type;
- val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
+ val->type = type;
+ val = value_change_enclosing_type (val, value_enclosing_type (fromval));
VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
if (count < 1)
error ("Invalid number %d of repetitions.", count);
- val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
+ val = allocate_repeat_value (value_enclosing_type (arg1), count);
- read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
- VALUE_CONTENTS_ALL_RAW (val),
- TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
+ read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1),
+ value_contents_all_raw (val),
+ TYPE_LENGTH (value_enclosing_type (val)));
VALUE_LVAL (val) = lval_memory;
- VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
+ VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1);
return val;
}
struct value *
value_coerce_array (struct value *arg1)
{
- struct type *type = check_typedef (VALUE_TYPE (arg1));
+ struct type *type = check_typedef (value_type (arg1));
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
- (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
+ (VALUE_ADDRESS (arg1) + value_offset (arg1)));
}
/* Given a value which is a function, return a value which is a pointer
if (VALUE_LVAL (arg1) != lval_memory)
error ("Attempt to take address of value not located in memory.");
- retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
- (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
- VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
+ retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
+ (VALUE_ADDRESS (arg1) + value_offset (arg1)));
return retval;
}
{
struct value *arg2;
- struct type *type = check_typedef (VALUE_TYPE (arg1));
+ struct type *type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_REF)
{
/* Copy the value, but change the type from (T&) to (T*).
We keep the same location information, which is efficient,
and allows &(&X) to get the location containing the reference. */
arg2 = value_copy (arg1);
- VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+ arg2->type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
return arg2;
}
if (TYPE_CODE (type) == TYPE_CODE_FUNC)
error ("Attempt to take address of value not located in memory.");
/* Get target memory address */
- arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
+ arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(VALUE_ADDRESS (arg1)
- + VALUE_OFFSET (arg1)
+ + value_offset (arg1)
+ VALUE_EMBEDDED_OFFSET (arg1)));
/* This may be a pointer to a base subobject; so remember the
full derived object's type ... */
- arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
+ arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
/* ... and also the relative position of the subobject in the full object */
VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
- VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
return arg2;
}
struct type *base_type;
struct value *arg2;
- COERCE_ARRAY (arg1);
+ arg1 = coerce_array (arg1);
- base_type = check_typedef (VALUE_TYPE (arg1));
+ base_type = check_typedef (value_type (arg1));
if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
error ("not implemented: member types in value_ind");
BUILTIN_TYPE_LONGEST would seem to be a mistake. */
if (TYPE_CODE (base_type) == TYPE_CODE_INT)
return value_at_lazy (builtin_type_int,
- (CORE_ADDR) value_as_long (arg1),
- VALUE_BFD_SECTION (arg1));
+ (CORE_ADDR) value_as_long (arg1));
else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
{
struct type *enc_type;
/* We may be pointing to something embedded in a larger object */
/* Get the real type of the enclosing object */
- enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
+ enc_type = check_typedef (value_enclosing_type (arg1));
enc_type = TYPE_TARGET_TYPE (enc_type);
/* Retrieve the enclosing object pointed to */
- arg2 = value_at_lazy (enc_type,
- value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
- VALUE_BFD_SECTION (arg1));
+ arg2 = value_at_lazy (enc_type, (value_as_address (arg1)
+ - VALUE_POINTED_TO_OFFSET (arg1)));
/* Re-adjust type */
- VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
+ arg2->type = TYPE_TARGET_TYPE (base_type);
/* Add embedding info */
arg2 = value_change_enclosing_type (arg2, enc_type);
VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
{
error ("bad array bounds (%d, %d)", lowbound, highbound);
}
- typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
+ typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
for (idx = 1; idx < nelem; idx++)
{
- if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
+ if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
{
error ("array elements must all be the same size");
}
rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
lowbound, highbound);
arraytype = create_array_type ((struct type *) NULL,
- VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
+ value_enclosing_type (elemvec[0]), rangetype);
if (!current_language->c_style_arrays)
{
val = allocate_value (arraytype);
for (idx = 0; idx < nelem; idx++)
{
- memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
- VALUE_CONTENTS_ALL (elemvec[idx]),
+ memcpy (value_contents_all_raw (val) + (idx * typelength),
+ value_contents_all (elemvec[idx]),
typelength);
}
- VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
return val;
}
addr = allocate_space_in_inferior (nelem * typelength);
for (idx = 0; idx < nelem; idx++)
{
- write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
+ write_memory (addr + (idx * typelength),
+ value_contents_all (elemvec[idx]),
typelength);
}
/* Create the array type and set up an array value to be evaluated lazily. */
- val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
+ val = value_at_lazy (arraytype, addr);
return (val);
}
if (current_language->c_style_arrays == 0)
{
val = allocate_value (stringtype);
- memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
+ memcpy (value_contents_raw (val), ptr, len);
return val;
}
addr = allocate_space_in_inferior (len);
write_memory (addr, ptr, len);
- val = value_at_lazy (stringtype, addr, NULL);
+ val = value_at_lazy (stringtype, addr);
return (val);
}
struct type *type = create_set_type ((struct type *) NULL, domain_type);
TYPE_CODE (type) = TYPE_CODE_BITSTRING;
val = allocate_value (type);
- memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
+ memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
return val;
}
\f
return i + 1;
tt1 = check_typedef (t1[i].type);
- tt2 = check_typedef (VALUE_TYPE (t2[i]));
+ tt2 = check_typedef (value_type (t2[i]));
if (TYPE_CODE (tt1) == TYPE_CODE_REF
/* We should be doing hairy argument matching, as below. */
/* We should be doing much hairier argument matching (see section 13.2
of the ARM), but as a quick kludge, just check for the same type
code. */
- if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i])))
+ if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
return i + 1;
}
if (varargs || t2[i] == NULL)
boffset = baseclass_offset (type, i,
VALUE_CONTENTS (arg1) + offset,
VALUE_ADDRESS (arg1)
- + VALUE_OFFSET (arg1) + offset);
+ + value_offset (arg1) + offset);
if (boffset == -1)
error ("virtual baseclass botch");
{
CORE_ADDR base_addr;
- base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
- if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
+ base_addr = VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
+ if (target_read_memory (base_addr, value_contents_raw (v2),
TYPE_LENGTH (basetype)) != 0)
error ("virtual baseclass botch");
VALUE_LVAL (v2) = lval_memory;
{
VALUE_LVAL (v2) = VALUE_LVAL (arg1);
VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
- VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
- if (VALUE_LAZY (arg1))
+ VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
+ v2->offset = value_offset (arg1) + boffset;
+ if (value_lazy (arg1))
VALUE_LAZY (v2) = 1;
else
- memcpy (VALUE_CONTENTS_RAW (v2),
- VALUE_CONTENTS_RAW (arg1) + boffset,
+ memcpy (value_contents_raw (v2),
+ value_contents_raw (arg1) + boffset,
TYPE_LENGTH (basetype));
}
* conventions. */
void
-find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
- int offset, int *boffset_p, int *skip_p)
+find_rt_vbase_offset (struct type *type, struct type *basetype,
+ const bfd_byte *valaddr, int offset, int *boffset_p,
+ int *skip_p)
{
int boffset; /* offset of virtual base */
int index; /* displacement to use in virtual table */
& use long type */
/* epstein : FIXME -- added param for overlay section. May not be correct */
- vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
+ vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START));
boffset = value_as_long (vp);
*skip_p = -1;
*boffset_p = boffset;
according to HP/Taligent runtime spec. */
int skip;
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
- VALUE_CONTENTS_ALL (*arg1p),
+ value_contents_all (*arg1p),
offset + VALUE_EMBEDDED_OFFSET (*arg1p),
&base_offset, &skip);
if (skip >= 0)
{
base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
if (target_read_memory (VALUE_ADDRESS (*arg1p)
- + VALUE_OFFSET (*arg1p) + offset,
+ + value_offset (*arg1p) + offset,
base_valaddr,
TYPE_LENGTH (baseclass)) != 0)
error ("virtual baseclass botch");
base_offset =
baseclass_offset (type, i, base_valaddr,
VALUE_ADDRESS (*arg1p)
- + VALUE_OFFSET (*arg1p) + offset);
+ + value_offset (*arg1p) + offset);
if (base_offset == -1)
error ("virtual baseclass botch");
}
struct type *t;
struct value *v;
- COERCE_ARRAY (*argp);
+ *argp = coerce_array (*argp);
- t = check_typedef (VALUE_TYPE (*argp));
+ t = check_typedef (value_type (*argp));
/* Follow pointers until we get to a non-pointer. */
{
*argp = value_ind (*argp);
/* Don't coerce fn pointer to fn and then back again! */
- if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
- COERCE_ARRAY (*argp);
- t = check_typedef (VALUE_TYPE (*argp));
+ if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
+ *argp = coerce_array (*argp);
+ t = check_typedef (value_type (*argp));
}
if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
* according to HP/Taligent runtime spec. */
int skip;
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
- VALUE_CONTENTS_ALL (*argp),
+ value_contents_all (*argp),
offset + VALUE_EMBEDDED_OFFSET (*argp),
&base_offset, &skip);
if (skip >= 0)
else
{
/* probably g++ runtime model */
- base_offset = VALUE_OFFSET (*argp) + offset;
+ base_offset = value_offset (*argp) + offset;
base_offset =
baseclass_offset (type, i,
VALUE_CONTENTS (*argp) + base_offset,
{
struct type *t;
- t = check_typedef (VALUE_TYPE (*argp));
+ t = check_typedef (value_type (*argp));
/* code snarfed from value_struct_elt */
while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
{
*argp = value_ind (*argp);
/* Don't coerce fn pointer to fn and then back again! */
- if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
- COERCE_ARRAY (*argp);
- t = check_typedef (VALUE_TYPE (*argp));
+ if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
+ *argp = coerce_array (*argp);
+ t = check_typedef (value_type (*argp));
}
if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
/* Get the list of overloaded methods or functions */
if (method)
{
- obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
+ obj_type_name = TYPE_NAME (value_type (obj));
/* Hack: evaluate_subexp_standard often passes in a pointer
value rather than the object itself, so try again */
if ((!obj_type_name || !*obj_type_name) &&
- (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
- obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
+ (TYPE_CODE (value_type (obj)) == TYPE_CODE_PTR))
+ obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (value_type (obj)));
fns_ptr = value_find_oload_method_list (&temp, name, 0,
&num_fns,
if (objp)
{
- if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
- && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
+ if (TYPE_CODE (value_type (temp)) != TYPE_CODE_PTR
+ && TYPE_CODE (value_type (*objp)) == TYPE_CODE_PTR)
{
temp = value_addr (temp);
}
{
struct type *t;
- COERCE_ARRAY (arg1);
+ arg1 = coerce_array (arg1);
- t = VALUE_TYPE (arg1);
+ t = value_type (arg1);
/* Follow pointers until we get to a non-pointer. */
real_type = value_rtti_type (argp, &full, &top, &using_enc);
/* If no RTTI data, or if object is already complete, do nothing */
- if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
+ if (!real_type || real_type == value_enclosing_type (argp))
return argp;
/* If we have the full object, but for some reason the enclosing
adjusting for the embedded offset of argp if that's what value_rtti_type
used for its computation. */
new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
- (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
- VALUE_BFD_SECTION (argp));
- VALUE_TYPE (new_val) = VALUE_TYPE (argp);
+ (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)));
+ new_val->type = value_type (argp);
VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
return new_val;
}
LONGEST lowerbound, upperbound;
struct value *slice;
struct type *array_type;
- array_type = check_typedef (VALUE_TYPE (array));
+ array_type = check_typedef (value_type (array));
if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
&& TYPE_CODE (array_type) != TYPE_CODE_STRING
&& TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
int j = i % TARGET_CHAR_BIT;
if (BITS_BIG_ENDIAN)
j = TARGET_CHAR_BIT - 1 - j;
- VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
+ value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
}
}
/* We should set the address, bitssize, and bitspos, so the clice
slice_range_type);
TYPE_CODE (slice_type) = TYPE_CODE (array_type);
slice = allocate_value (slice_type);
- if (VALUE_LAZY (array))
+ if (value_lazy (array))
VALUE_LAZY (slice) = 1;
else
memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
else
VALUE_LVAL (slice) = VALUE_LVAL (array);
VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
- VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
+ VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
+ slice->offset = value_offset (array) + offset;
}
return slice;
}
arg1 = value_cast (real_type, arg1);
arg2 = value_cast (real_type, arg2);
- memcpy (VALUE_CONTENTS_RAW (val),
+ memcpy (value_contents_raw (val),
VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
- memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
+ memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
return val;
}
cast_into_complex (struct type *type, struct value *val)
{
struct type *real_type = TYPE_TARGET_TYPE (type);
- if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
+ if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
{
- struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
+ struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
struct value *re_val = allocate_value (val_real_type);
struct value *im_val = allocate_value (val_real_type);
- memcpy (VALUE_CONTENTS_RAW (re_val),
+ memcpy (value_contents_raw (re_val),
VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
- memcpy (VALUE_CONTENTS_RAW (im_val),
+ memcpy (value_contents_raw (im_val),
VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
TYPE_LENGTH (val_real_type));
return value_literal_complex (re_val, im_val, type);
}
- else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
- || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
+ else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
+ || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
return value_literal_complex (val, value_zero (real_type, not_lval), type);
else
error ("cannot cast non-number to complex");
projects / deliverable / binutils-gdb.git / blobdiff