#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
#endif
-static struct value *value_subscripted_rvalue (struct value *, struct value *, int);
-
void _initialize_valarith (void);
\f
If the pointer type is void *, then return 1.
If the target type is incomplete, then error out.
This isn't a general purpose function, but just a
- helper for value_sub & value_add.
+ helper for value_ptrsub & value_ptradd.
*/
static LONGEST
LONGEST sz = -1;
struct type *ptr_target;
+ gdb_assert (TYPE_CODE (ptr_type) == TYPE_CODE_PTR);
ptr_target = check_typedef (TYPE_TARGET_TYPE (ptr_type));
sz = TYPE_LENGTH (ptr_target);
return sz;
}
+/* Given a pointer ARG1 and an integral value ARG2, return the
+ result of C-style pointer arithmetic ARG1 + ARG2. */
+
struct value *
-value_add (struct value *arg1, struct value *arg2)
+value_ptradd (struct value *arg1, struct value *arg2)
{
- struct value *valint;
- struct value *valptr;
+ struct type *valptrtype;
LONGEST sz;
- struct type *type1, *type2, *valptrtype;
arg1 = coerce_array (arg1);
- arg2 = coerce_array (arg2);
- type1 = check_typedef (value_type (arg1));
- type2 = check_typedef (value_type (arg2));
+ valptrtype = check_typedef (value_type (arg1));
+ sz = find_size_for_pointer_math (valptrtype);
- if ((TYPE_CODE (type1) == TYPE_CODE_PTR
- || TYPE_CODE (type2) == TYPE_CODE_PTR)
- &&
- (is_integral_type (type1) || is_integral_type (type2)))
- /* Exactly one argument is a pointer, and one is an integer. */
- {
- struct value *retval;
+ if (!is_integral_type (value_type (arg2)))
+ error (_("Argument to arithmetic operation not a number or boolean."));
- if (TYPE_CODE (type1) == TYPE_CODE_PTR)
- {
- valptr = arg1;
- valint = arg2;
- valptrtype = type1;
- }
- else
- {
- valptr = arg2;
- valint = arg1;
- valptrtype = type2;
- }
+ return value_from_pointer (valptrtype,
+ value_as_address (arg1)
+ + (sz * value_as_long (arg2)));
+}
- sz = find_size_for_pointer_math (valptrtype);
+/* Given a pointer ARG1 and an integral value ARG2, return the
+ result of C-style pointer arithmetic ARG1 - ARG2. */
- retval = value_from_pointer (valptrtype,
- value_as_address (valptr)
- + (sz * value_as_long (valint)));
- return retval;
- }
+struct value *
+value_ptrsub (struct value *arg1, struct value *arg2)
+{
+ struct type *valptrtype;
+ LONGEST sz;
+
+ arg1 = coerce_array (arg1);
+ valptrtype = check_typedef (value_type (arg1));
+ sz = find_size_for_pointer_math (valptrtype);
- return value_binop (arg1, arg2, BINOP_ADD);
+ if (!is_integral_type (value_type (arg2)))
+ error (_("Argument to arithmetic operation not a number or boolean."));
+
+ return value_from_pointer (valptrtype,
+ value_as_address (arg1)
+ - (sz * value_as_long (arg2)));
}
-struct value *
-value_sub (struct value *arg1, struct value *arg2)
+/* Given two compatible pointer values ARG1 and ARG2, return the
+ result of C-style pointer arithmetic ARG1 - ARG2. */
+
+LONGEST
+value_ptrdiff (struct value *arg1, struct value *arg2)
{
struct type *type1, *type2;
+ LONGEST sz;
+
arg1 = coerce_array (arg1);
arg2 = coerce_array (arg2);
type1 = check_typedef (value_type (arg1));
type2 = check_typedef (value_type (arg2));
- if (TYPE_CODE (type1) == TYPE_CODE_PTR)
- {
- if (is_integral_type (type2))
- {
- /* pointer - integer. */
- LONGEST sz = find_size_for_pointer_math (type1);
+ gdb_assert (TYPE_CODE (type1) == TYPE_CODE_PTR);
+ gdb_assert (TYPE_CODE (type2) == TYPE_CODE_PTR);
- return value_from_pointer (type1,
- (value_as_address (arg1)
- - (sz * value_as_long (arg2))));
- }
- else if (TYPE_CODE (type2) == TYPE_CODE_PTR
- && TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
- == TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
- {
- /* pointer to <type x> - pointer to <type x>. */
- LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
- return value_from_longest
- (builtin_type_long, /* FIXME -- should be ptrdiff_t */
- (value_as_long (arg1) - value_as_long (arg2)) / sz);
- }
- else
- {
- error (_("\
+ if (TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)))
+ != TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type2))))
+ error (_("\
First argument of `-' is a pointer and second argument is neither\n\
an integer nor a pointer of the same type."));
- }
- }
- return value_binop (arg1, arg2, BINOP_SUB);
+ sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
+ return (value_as_long (arg1) - value_as_long (arg2)) / sz;
}
/* Return the value of ARRAY[IDX].
+
+ ARRAY may be of type TYPE_CODE_ARRAY or TYPE_CODE_STRING. If the
+ current language supports C-style arrays, it may also be TYPE_CODE_PTR.
+ To access TYPE_CODE_BITSTRING values, use value_bitstring_subscript.
+
See comments in value_coerce_array() for rationale for reason for
doing lower bounds adjustment here rather than there.
FIXME: Perhaps we should validate that the index is valid and if
if (lowerbound != 0)
{
- bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
- idx = value_sub (idx, bound);
+ bound = value_from_longest (value_type (idx), (LONGEST) lowerbound);
+ idx = value_binop (idx, bound, BINOP_SUB);
}
array = value_coerce_array (array);
}
- if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
- {
- struct type *range_type = TYPE_INDEX_TYPE (tarray);
- LONGEST index = value_as_long (idx);
- struct value *v;
- int offset, byte, bit_index;
- LONGEST lowerbound, upperbound;
- get_discrete_bounds (range_type, &lowerbound, &upperbound);
- if (index < lowerbound || index > upperbound)
- error (_("bitstring index out of range"));
- index -= lowerbound;
- offset = index / TARGET_CHAR_BIT;
- byte = *((char *) value_contents (array) + offset);
- bit_index = index % TARGET_CHAR_BIT;
- byte >>= (gdbarch_bits_big_endian (current_gdbarch) ?
- TARGET_CHAR_BIT - 1 - bit_index : bit_index);
- v = value_from_longest (LA_BOOL_TYPE, byte & 1);
- set_value_bitpos (v, bit_index);
- set_value_bitsize (v, 1);
- VALUE_LVAL (v) = VALUE_LVAL (array);
- if (VALUE_LVAL (array) == lval_internalvar)
- VALUE_LVAL (v) = lval_internalvar_component;
- VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
- VALUE_FRAME_ID (v) = VALUE_FRAME_ID (array);
- set_value_offset (v, offset + value_offset (array));
- return v;
- }
-
if (c_style)
- return value_ind (value_add (array, idx));
+ return value_ind (value_ptradd (array, idx));
else
error (_("not an array or string"));
}
(eg, a vector register). This routine used to promote floats
to doubles, but no longer does. */
-static struct value *
+struct value *
value_subscripted_rvalue (struct value *array, struct value *idx, int lowerbound)
{
struct type *array_type = check_typedef (value_type (array));
error (_("no such vector element"));
v = allocate_value (elt_type);
- if (value_lazy (array))
+ if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
set_value_lazy (v, 1);
else
memcpy (value_contents_writeable (v),
set_value_offset (v, value_offset (array) + elt_offs);
return v;
}
+
+/* Return the value of BITSTRING[IDX] as (boolean) type TYPE. */
+
+struct value *
+value_bitstring_subscript (struct type *type,
+ struct value *bitstring, struct value *idx)
+{
+
+ struct type *bitstring_type, *range_type;
+ LONGEST index = value_as_long (idx);
+ struct value *v;
+ int offset, byte, bit_index;
+ LONGEST lowerbound, upperbound;
+
+ bitstring_type = check_typedef (value_type (bitstring));
+ gdb_assert (TYPE_CODE (bitstring_type) == TYPE_CODE_BITSTRING);
+
+ range_type = TYPE_INDEX_TYPE (bitstring_type);
+ get_discrete_bounds (range_type, &lowerbound, &upperbound);
+ if (index < lowerbound || index > upperbound)
+ error (_("bitstring index out of range"));
+
+ index -= lowerbound;
+ offset = index / TARGET_CHAR_BIT;
+ byte = *((char *) value_contents (bitstring) + offset);
+
+ bit_index = index % TARGET_CHAR_BIT;
+ byte >>= (gdbarch_bits_big_endian (current_gdbarch) ?
+ TARGET_CHAR_BIT - 1 - bit_index : bit_index);
+
+ v = value_from_longest (type, byte & 1);
+
+ set_value_bitpos (v, bit_index);
+ set_value_bitsize (v, 1);
+
+ VALUE_LVAL (v) = VALUE_LVAL (bitstring);
+ if (VALUE_LVAL (bitstring) == lval_internalvar)
+ VALUE_LVAL (v) = lval_internalvar_component;
+ VALUE_ADDRESS (v) = VALUE_ADDRESS (bitstring);
+ VALUE_FRAME_ID (v) = VALUE_FRAME_ID (bitstring);
+
+ set_value_offset (v, offset + value_offset (bitstring));
+
+ return v;
+}
+
\f
/* Check to see if either argument is a structure, or a reference to
one. This is called so we know whether to go ahead with the normal
arg1 = coerce_ref (arg1);
arg2 = coerce_ref (arg2);
- arg1 = coerce_enum (arg1);
- arg2 = coerce_enum (arg2);
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
int static_memfuncp, nargs;
arg1 = coerce_ref (arg1);
- arg1 = coerce_enum (arg1);
/* now we know that what we have to do is construct our
arg vector and find the right function to call it with. */
return (outval);
}
\f
-
/* Integer exponentiation: V1**V2, where both arguments are
integers. Requires V1 != 0 if V2 < 0. Returns 1 for 0 ** 0. */
static LONGEST
representations as integers or floats. This includes booleans,
characters, integers, or floats.
Does not support addition and subtraction on pointers;
- use value_add or value_sub if you want to handle those possibilities. */
+ use value_ptradd, value_ptrsub or value_ptrdiff for those operations. */
struct value *
value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
{
struct value *val;
- struct type *type1, *type2;
+ struct type *type1, *type2, *result_type;
arg1 = coerce_ref (arg1);
arg2 = coerce_ref (arg2);
+
type1 = check_typedef (value_type (arg1));
type2 = check_typedef (value_type (arg2));
if ((TYPE_CODE (type1) != TYPE_CODE_FLT
- && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT && !is_integral_type (type1))
- ||
- (TYPE_CODE (type2) != TYPE_CODE_FLT
- && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT && !is_integral_type (type2)))
+ && TYPE_CODE (type1) != TYPE_CODE_DECFLOAT
+ && !is_integral_type (type1))
+ || (TYPE_CODE (type2) != TYPE_CODE_FLT
+ && TYPE_CODE (type2) != TYPE_CODE_DECFLOAT
+ && !is_integral_type (type2)))
error (_("Argument to arithmetic operation not a number or boolean."));
if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
- ||
- TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
+ || TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
{
struct type *v_type;
int len_v1, len_v2, len_v;
error (_("Operation not valid for decimal floating point number."));
}
+ /* If only one type is decimal float, use its type.
+ Otherwise use the bigger type. */
if (TYPE_CODE (type1) != TYPE_CODE_DECFLOAT)
- /* If arg1 is not a decimal float, the type of the result is the type
- of the decimal float argument, arg2. */
- v_type = type2;
+ result_type = type2;
else if (TYPE_CODE (type2) != TYPE_CODE_DECFLOAT)
- /* Same logic, for the case where arg2 is not a decimal float. */
- v_type = type1;
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
else
- /* len_v is equal either to len_v1 or to len_v2. the type of the
- result is the type of the argument with the same length as v. */
- v_type = (len_v == len_v1)? type1 : type2;
+ result_type = type1;
- val = value_from_decfloat (v_type, v);
+ val = value_from_decfloat (result_type, v);
}
else if (TYPE_CODE (type1) == TYPE_CODE_FLT
- ||
- TYPE_CODE (type2) == TYPE_CODE_FLT)
+ || TYPE_CODE (type2) == TYPE_CODE_FLT)
{
/* FIXME-if-picky-about-floating-accuracy: Should be doing this
in target format. real.c in GCC probably has the necessary
DOUBLEST v1, v2, v = 0;
v1 = value_as_double (arg1);
v2 = value_as_double (arg2);
+
switch (op)
{
case BINOP_ADD:
error (_("Integer-only operation on floating point number."));
}
- /* If either arg was long double, make sure that value is also long
- double. */
-
- if (TYPE_LENGTH (type1) * 8 > gdbarch_double_bit (current_gdbarch)
- || TYPE_LENGTH (type2) * 8 > gdbarch_double_bit (current_gdbarch))
- val = allocate_value (builtin_type_long_double);
+ /* If only one type is float, use its type.
+ Otherwise use the bigger type. */
+ if (TYPE_CODE (type1) != TYPE_CODE_FLT)
+ result_type = type2;
+ else if (TYPE_CODE (type2) != TYPE_CODE_FLT)
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
else
- val = allocate_value (builtin_type_double);
+ result_type = type1;
+ val = allocate_value (result_type);
store_typed_floating (value_contents_raw (val), value_type (val), v);
}
else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
- &&
- TYPE_CODE (type2) == TYPE_CODE_BOOL)
+ || TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
LONGEST v1, v2, v = 0;
v1 = value_as_long (arg1);
error (_("Invalid operation on booleans."));
}
- val = allocate_value (type1);
+ result_type = type1;
+
+ val = allocate_value (result_type);
store_signed_integer (value_contents_raw (val),
- TYPE_LENGTH (type1),
+ TYPE_LENGTH (result_type),
v);
}
else
/* Integral operations here. */
- /* FIXME: Also mixed integral/booleans, with result an integer. */
- /* FIXME: This implements ANSI C rules (also correct for C++).
- What about FORTRAN and (the deleted) chill ? */
{
- unsigned int promoted_len1 = TYPE_LENGTH (type1);
- unsigned int promoted_len2 = TYPE_LENGTH (type2);
- int is_unsigned1 = TYPE_UNSIGNED (type1);
- int is_unsigned2 = TYPE_UNSIGNED (type2);
- unsigned int result_len;
- int unsigned_operation;
-
- /* Determine type length and signedness after promotion for
- both operands. */
- if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
- {
- is_unsigned1 = 0;
- promoted_len1 = TYPE_LENGTH (builtin_type_int);
- }
- if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
- {
- is_unsigned2 = 0;
- promoted_len2 = TYPE_LENGTH (builtin_type_int);
- }
-
/* Determine type length of the result, and if the operation should
- be done unsigned. For exponentiation and shift operators,
- use the length and type of the left operand. Otherwise,
- use the signedness of the operand with the greater length.
- If both operands are of equal length, use unsigned operation
- if one of the operands is unsigned. */
+ be done unsigned. For exponentiation and shift operators,
+ use the length and type of the left operand. Otherwise,
+ use the signedness of the operand with the greater length.
+ If both operands are of equal length, use unsigned operation
+ if one of the operands is unsigned. */
if (op == BINOP_RSH || op == BINOP_LSH || op == BINOP_EXP)
- {
- /* In case of the shift operators and exponentiation the type of
- the result only depends on the type of the left operand. */
- unsigned_operation = is_unsigned1;
- result_len = promoted_len1;
- }
- else if (promoted_len1 > promoted_len2)
- {
- unsigned_operation = is_unsigned1;
- result_len = promoted_len1;
- }
- else if (promoted_len2 > promoted_len1)
- {
- unsigned_operation = is_unsigned2;
- result_len = promoted_len2;
- }
+ result_type = type1;
+ else if (TYPE_LENGTH (type1) > TYPE_LENGTH (type2))
+ result_type = type1;
+ else if (TYPE_LENGTH (type2) > TYPE_LENGTH (type1))
+ result_type = type2;
+ else if (TYPE_UNSIGNED (type1))
+ result_type = type1;
+ else if (TYPE_UNSIGNED (type2))
+ result_type = type2;
else
- {
- unsigned_operation = is_unsigned1 || is_unsigned2;
- result_len = promoted_len1;
- }
+ result_type = type1;
- if (unsigned_operation)
+ if (TYPE_UNSIGNED (result_type))
{
LONGEST v2_signed = value_as_long (arg2);
ULONGEST v1, v2, v = 0;
v1 = (ULONGEST) value_as_long (arg1);
v2 = (ULONGEST) v2_signed;
- /* Truncate values to the type length of the result. */
- if (result_len < sizeof (ULONGEST))
- {
- v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
- v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
- }
-
switch (op)
{
case BINOP_ADD:
break;
case BINOP_REM:
- v = v1 % v2;
+ if (v2 != 0)
+ v = v1 % v2;
+ else
+ error (_("Division by zero"));
break;
case BINOP_MOD:
error (_("Invalid binary operation on numbers."));
}
- /* This is a kludge to get around the fact that we don't
- know how to determine the result type from the types of
- the operands. (I'm not really sure how much we feel the
- need to duplicate the exact rules of the current
- language. They can get really hairy. But not to do so
- makes it hard to document just what we *do* do). */
-
- /* Can't just call init_type because we wouldn't know what
- name to give the type. */
- val = allocate_value
- (result_len > gdbarch_long_bit (current_gdbarch) / HOST_CHAR_BIT
- ? builtin_type_unsigned_long_long
- : builtin_type_unsigned_long);
+ val = allocate_value (result_type);
store_unsigned_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)),
v);
error (_("Invalid binary operation on numbers."));
}
- /* This is a kludge to get around the fact that we don't
- know how to determine the result type from the types of
- the operands. (I'm not really sure how much we feel the
- need to duplicate the exact rules of the current
- language. They can get really hairy. But not to do so
- makes it hard to document just what we *do* do). */
-
- /* Can't just call init_type because we wouldn't know what
- name to give the type. */
- val = allocate_value
- (result_len > gdbarch_long_bit (current_gdbarch) / HOST_CHAR_BIT
- ? builtin_type_long_long
- : builtin_type_long);
+ val = allocate_value (result_type);
store_signed_integer (value_contents_raw (val),
TYPE_LENGTH (value_type (val)),
v);
const gdb_byte *p;
struct type *type1;
- arg1 = coerce_number (arg1);
+ arg1 = coerce_array (arg1);
type1 = check_typedef (value_type (arg1));
if (TYPE_CODE (type1) == TYPE_CODE_FLT)
struct type *type;
arg1 = coerce_ref (arg1);
-
type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_FLT)
return value_from_decfloat (type, value_contents (arg1));
else if (is_integral_type (type))
{
- /* Perform integral promotion for ANSI C/C++. FIXME: What about
- FORTRAN and (the deleted) chill ? */
- if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
- type = builtin_type_int;
-
return value_from_longest (type, value_as_long (arg1));
}
else
value_neg (struct value *arg1)
{
struct type *type;
- struct type *result_type = value_type (arg1);
arg1 = coerce_ref (arg1);
-
type = check_typedef (value_type (arg1));
if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
{
- struct value *val = allocate_value (result_type);
+ struct value *val = allocate_value (type);
int len = TYPE_LENGTH (type);
gdb_byte decbytes[16]; /* a decfloat is at most 128 bits long */
memcpy (value_contents_raw (val), decbytes, len);
return val;
}
-
- if (TYPE_CODE (type) == TYPE_CODE_FLT)
- return value_from_double (result_type, -value_as_double (arg1));
+ else if (TYPE_CODE (type) == TYPE_CODE_FLT)
+ return value_from_double (type, -value_as_double (arg1));
else if (is_integral_type (type))
{
- /* Perform integral promotion for ANSI C/C++. FIXME: What about
- FORTRAN and (the deleted) chill ? */
- if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
- result_type = builtin_type_int;
-
- return value_from_longest (result_type, -value_as_long (arg1));
+ return value_from_longest (type, -value_as_long (arg1));
}
else
{
value_complement (struct value *arg1)
{
struct type *type;
- struct type *result_type = value_type (arg1);
arg1 = coerce_ref (arg1);
-
type = check_typedef (value_type (arg1));
if (!is_integral_type (type))
error (_("Argument to complement operation not an integer or boolean."));
- /* Perform integral promotion for ANSI C/C++.
- FIXME: What about FORTRAN ? */
- if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
- result_type = builtin_type_int;
-
- return value_from_longest (result_type, ~value_as_long (arg1));
+ return value_from_longest (type, ~value_as_long (arg1));
}
\f
/* The INDEX'th bit of SET value whose value_type is TYPE,
return (word >> rel_index) & 1;
}
-struct value *
+int
value_in (struct value *element, struct value *set)
{
int member;
value_as_long (element));
if (member < 0)
error (_("First argument of 'IN' not in range"));
- return value_from_longest (LA_BOOL_TYPE, member);
+ return member;
}
void
projects / deliverable / binutils-gdb.git / blobdiff