+2020-11-15 Joel Brobecker <brobecker@adacore.com>
+
+ * eval.c (binop_promote): Add fixed-point type handling.
+ * valarith.c (fixed_point_binop): New function.
+ (scalar_binop): Add fixed-point type handling.
+ (value_neg): Add fixed-point type handling.
+ * valops.c (value_cast_to_fixed_point): New function.
+ (value_cast): Add fixed-point type handling.
+
2020-11-15 Joel Brobecker <brobecker@adacore.com>
* ada-typeprint.c (ada_print_type): Add handing of fixed-point
&& !is_integral_type (type2)))
return;
+ if (is_fixed_point_type (type1) || is_fixed_point_type (type2))
+ return;
+
if (type1->code () == TYPE_CODE_DECFLOAT
|| type2->code () == TYPE_CODE_DECFLOAT)
{
+2020-11-15 Joel Brobecker <brobecker@adacore.com>
+
+ * gdb.dwarf2/dw2-fixed-point.exp: Add arithmetic tests.
+
2020-11-15 Joel Brobecker <brobecker@adacore.com>
* gdb.ada/fixed_points.exp: Add ptype tests.
gdb_test "print /x pck.fp1_range_var" \
" = 0x1"
+gdb_test "print pck.fp1_var + 0.25" \
+ " = 0.5"
+
+gdb_test "print pck.fp2_var - pck.fp2_var" \
+ " = 0"
+
+gdb_test "print pck.fp3_var * 1" \
+ " = 0.1"
+
+gdb_test "print pck.fp3_var / pck.fp3_var" \
+ " = 1"
+
+gdb_test "print pck.fp1_range_var - 0.5" \
+ " = 0.5"
+
+gdb_test "print -pck.fp1_var" \
+ " = -0.25"
+
# Set the language to LANG and do a ptype test on pck__fp1_var,
# pck__fp2_var and pck__fp3_var, verifying that the output matches
# FP1_RE, FP2_RE, FP2_RE (resp.).
type2->name ());
}
+/* Assuming at last one of ARG1 or ARG2 is a fixed point value,
+ perform the binary operation OP on these two operands, and return
+ the resulting value (also as a fixed point). */
+
+static struct value *
+fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
+{
+ struct type *type1 = check_typedef (value_type (arg1));
+ struct type *type2 = check_typedef (value_type (arg2));
+
+ struct value *val;
+
+ gdb_assert (is_fixed_point_type (type1) || is_fixed_point_type (type2));
+ if (!is_fixed_point_type (type1))
+ {
+ arg1 = value_cast (type2, arg1);
+ type1 = type2;
+ }
+ if (!is_fixed_point_type (type2))
+ {
+ arg2 = value_cast (type1, arg2);
+ type2 = type1;
+ }
+
+ gdb_mpq v1, v2, res;
+ v1.read_fixed_point (value_contents (arg1), TYPE_LENGTH (type1),
+ type_byte_order (type1), type1->is_unsigned (),
+ fixed_point_scaling_factor (type1));
+ v2.read_fixed_point (value_contents (arg2), TYPE_LENGTH (type2),
+ type_byte_order (type2), type2->is_unsigned (),
+ fixed_point_scaling_factor (type2));
+
+#define INIT_VAL_WITH_FIXED_POINT_VAL(RESULT) \
+ do { \
+ val = allocate_value (type1); \
+ (RESULT).write_fixed_point \
+ (value_contents_raw (val), TYPE_LENGTH (type1), \
+ type_byte_order (type1), type1->is_unsigned (), \
+ fixed_point_scaling_factor (type1)); \
+ } while (0)
+
+ switch (op)
+ {
+ case BINOP_ADD:
+ mpq_add (res.val, v1.val, v2.val);
+ INIT_VAL_WITH_FIXED_POINT_VAL (res);
+ break;
+
+ case BINOP_SUB:
+ mpq_sub (res.val, v1.val, v2.val);
+ INIT_VAL_WITH_FIXED_POINT_VAL (res);
+ break;
+
+ case BINOP_MIN:
+ INIT_VAL_WITH_FIXED_POINT_VAL (mpq_cmp (v1.val, v2.val) < 0 ? v1 : v2);
+ break;
+
+ case BINOP_MAX:
+ INIT_VAL_WITH_FIXED_POINT_VAL (mpq_cmp (v1.val, v2.val) > 0 ? v1 : v2);
+ break;
+
+ case BINOP_MUL:
+ mpq_mul (res.val, v1.val, v2.val);
+ INIT_VAL_WITH_FIXED_POINT_VAL (res);
+ break;
+
+ case BINOP_DIV:
+ mpq_div (res.val, v1.val, v2.val);
+ INIT_VAL_WITH_FIXED_POINT_VAL (res);
+ break;
+
+ default:
+ error (_("Integer-only operation on fixed point number."));
+ }
+
+ return val;
+}
+
/* A helper function that finds the type to use for a binary operation
involving TYPE1 and TYPE2. */
|| type2->code () == TYPE_CODE_COMPLEX)
return complex_binop (arg1, arg2, op);
- if ((!is_floating_value (arg1) && !is_integral_type (type1))
- || (!is_floating_value (arg2) && !is_integral_type (type2)))
+ if ((!is_floating_value (arg1)
+ && !is_integral_type (type1)
+ && !is_fixed_point_type (type1))
+ || (!is_floating_value (arg2)
+ && !is_integral_type (type2)
+ && !is_fixed_point_type (type2)))
error (_("Argument to arithmetic operation not a number or boolean."));
+ if (is_fixed_point_type (type1) || is_fixed_point_type (type2))
+ return fixed_point_binop (arg1, arg2, op);
+
if (is_floating_type (type1) || is_floating_type (type2))
{
result_type = promotion_type (type1, type2);
if (is_integral_type (type) || is_floating_type (type))
return value_binop (value_from_longest (type, 0), arg1, BINOP_SUB);
+ else if (is_fixed_point_type (type))
+ return value_binop (value_zero (type, not_lval), arg1, BINOP_SUB);
else if (type->code () == TYPE_CODE_ARRAY && type->is_vector ())
{
struct value *tmp, *val = allocate_value (type);
return arg2;
}
+/* Assuming that TO_TYPE is a fixed point type, return a value
+ corresponding to the cast of FROM_VAL to that type. */
+
+static struct value *
+value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
+{
+ struct type *from_type = value_type (from_val);
+
+ if (from_type == to_type)
+ return from_val;
+
+ gdb_mpq vq;
+
+ /* Extract the value as a rational number. */
+
+ if (is_floating_type (from_type))
+ {
+ double d = target_float_to_host_double (value_contents (from_val),
+ from_type);
+ mpq_set_d (vq.val, d);
+ }
+
+ else if (is_integral_type (from_type) || is_fixed_point_type (from_type))
+ {
+ gdb_mpz vz;
+
+ vz.read (value_contents (from_val), TYPE_LENGTH (from_type),
+ type_byte_order (from_type), from_type->is_unsigned ());
+ mpq_set_z (vq.val, vz.val);
+
+ if (is_fixed_point_type (from_type))
+ mpq_mul (vq.val, vq.val, fixed_point_scaling_factor (from_type).val);
+ }
+
+ else
+ error (_("Invalid conversion from type %s to fixed point type %s"),
+ from_type->name (), to_type->name ());
+
+ /* Divide that value by the scaling factor to obtain the unscaled
+ value, first in rational form, and then in integer form. */
+
+ mpq_div (vq.val, vq.val, fixed_point_scaling_factor (to_type).val);
+ gdb_mpz unscaled = vq.get_rounded ();
+
+ /* Finally, create the result value, and pack the unscaled value
+ in it. */
+ struct value *result = allocate_value (to_type);
+ unscaled.write (value_contents_raw (result),
+ TYPE_LENGTH (to_type), type_byte_order (to_type),
+ to_type->is_unsigned ());
+
+ return result;
+}
+
/* Cast value ARG2 to type TYPE and return as a value.
More general than a C cast: accepts any two types of the same length,
and if ARG2 is an lvalue it can be cast into anything at all. */
if (value_type (arg2) == type)
return arg2;
+ if (is_fixed_point_type (type))
+ return value_cast_to_fixed_point (type, arg2);
+
/* Check if we are casting struct reference to struct reference. */
if (TYPE_IS_REFERENCE (check_typedef (type)))
{
scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
|| code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
- || code2 == TYPE_CODE_RANGE);
+ || code2 == TYPE_CODE_RANGE
+ || is_fixed_point_type (type2));
if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
&& (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
value_contents_raw (v), type);
return v;
}
+ else if (is_fixed_point_type (type2))
+ {
+ gdb_mpq fp_val;
+
+ fp_val.read_fixed_point
+ (value_contents (arg2), TYPE_LENGTH (type2),
+ type_byte_order (type2), type2->is_unsigned (),
+ fixed_point_scaling_factor (type2));
+
+ struct value *v = allocate_value (to_type);
+ target_float_from_host_double (value_contents_raw (v),
+ to_type, mpq_get_d (fp_val.val));
+ return v;
+ }
/* The only option left is an integral type. */
if (type2->is_unsigned ())
projects / binutils-gdb.git / commitdiff