[pushed/v2 8/9] Add support for fixed-point type arithmetic

[Joel Brobecker <brobecker@adacore.com>]

This patch adds support for binary operations on fixed-point values,
as well as for the negative unary operator.

gdb/ChangeLog:

        * 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.

gdb/testsuite/ChangeLog:

        * gdb.dwarf2/dw2-fixed-point.exp: Add arithmetic tests.
---
 gdb/ChangeLog                                |  9 +++
 gdb/eval.c                                   |  3 +
 gdb/testsuite/ChangeLog                      |  4 ++
 gdb/testsuite/gdb.dwarf2/dw2-fixed-point.exp | 18 ++++++
 gdb/valarith.c                               | 91 +++++++++++++++++++++++++++-
 gdb/valops.c                                 | 74 +++++++++++++++++++++-
 6 files changed, 196 insertions(+), 3 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 56e54d3..e9f0afd 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,14 @@
 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
 	range types.
 	* c-typeprint.c (c_type_print_varspec_prefix)
diff --git a/gdb/eval.c b/gdb/eval.c
index 8d0c574..308f477 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -430,6 +430,9 @@ binop_promote (const struct language_defn *language, struct gdbarch *gdbarch,
 	  && !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)
     {
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 2c7b5c5..3c53f6c 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,5 +1,9 @@
 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.dwarf2/dw2-fixed-point.exp: Likewise.
 
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-fixed-point.exp b/gdb/testsuite/gdb.dwarf2/dw2-fixed-point.exp
index 33a7e74..0252195 100644
--- a/gdb/testsuite/gdb.dwarf2/dw2-fixed-point.exp
+++ b/gdb/testsuite/gdb.dwarf2/dw2-fixed-point.exp
@@ -143,6 +143,24 @@ gdb_test "print pck.fp1_range_var" \
 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.).
diff --git a/gdb/valarith.c b/gdb/valarith.c
index f6caf3d..65a6f13 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -881,6 +881,84 @@ value_args_as_target_float (struct value *arg1, struct value *arg2,
 	     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.  */
 
@@ -1054,10 +1132,17 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
       || 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);
@@ -1753,6 +1838,8 @@ value_neg (struct value *arg1)
 
   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);
diff --git a/gdb/valops.c b/gdb/valops.c
index 4df2538..0f84a70 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -331,6 +331,60 @@ value_cast_pointers (struct type *type, struct value *arg2,
   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.  */
@@ -349,6 +403,9 @@ value_cast (struct type *type, struct value *arg2)
   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)))
     {
@@ -439,7 +496,8 @@ value_cast (struct type *type, struct value *arg2)
 
   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)
@@ -460,6 +518,20 @@ value_cast (struct type *type, struct value *arg2)
 				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 ())
-- 
2.1.4