Unify NEGATE_EXPR range operator

Move the declaration of the class to the range-op-mixed header, add the
floating point prototypes as well, and use it in the new unified table.

	* range-op-float.cc (foperator_negate): Remove.  Move prototypes
	to range-op-mixed.h
	(operator_negate::fold_range): Rename from foperator_negate.
	(operator_negate::op1_range): Ditto.
	(float_table::float_table): Remove NEGATE_EXPR.
	* range-op-mixed.h (class operator_negate): Combined from integer
	and float files.
	* range-op.cc (op_negate): New object.
	(unified_table::unified_table): Add NEGATE_EXPR.
	(class operator_negate): Move to range-op-mixed.h.
	(integral_table::integral_table): Remove NEGATE_EXPR.
	(pointer_table::pointer_table): Remove NEGATE_EXPR.

1 files changed, 41 insertions, 45 deletions

diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index db76dd5..20b4b9f 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -1295,51 +1295,48 @@ foperator_ordered::op1_range (frange &r, tree type,
   return true;
 }
 
-class foperator_negate : public range_operator
+bool
+operator_negate::fold_range (frange &r, tree type,
+			     const frange &op1, const frange &op2,
+			     relation_trio) const
 {
-  using range_operator::fold_range;
-  using range_operator::op1_range;
-public:
-  bool fold_range (frange &r, tree type,
-		   const frange &op1, const frange &op2,
-		   relation_trio = TRIO_VARYING) const final override
-  {
-    if (empty_range_varying (r, type, op1, op2))
+  if (empty_range_varying (r, type, op1, op2))
+    return true;
+  if (op1.known_isnan ())
+    {
+      bool sign;
+      if (op1.nan_signbit_p (sign))
+	r.set_nan (type, !sign);
+      else
+	r.set_nan (type);
       return true;
-    if (op1.known_isnan ())
-      {
-	bool sign;
-	if (op1.nan_signbit_p (sign))
-	  r.set_nan (type, !sign);
-	else
-	  r.set_nan (type);
-	return true;
-      }
+    }
 
-    REAL_VALUE_TYPE lh_lb = op1.lower_bound ();
-    REAL_VALUE_TYPE lh_ub = op1.upper_bound ();
-    lh_lb = real_value_negate (&lh_lb);
-    lh_ub = real_value_negate (&lh_ub);
-    r.set (type, lh_ub, lh_lb);
-    if (op1.maybe_isnan ())
-      {
-	bool sign;
-	if (op1.nan_signbit_p (sign))
-	  r.update_nan (!sign);
-	else
-	  r.update_nan ();
-      }
-    else
-      r.clear_nan ();
-    return true;
-  }
-  bool op1_range (frange &r, tree type,
-		  const frange &lhs, const frange &op2,
-		  relation_trio rel = TRIO_VARYING) const final override
-  {
-    return fold_range (r, type, lhs, op2, rel);
-  }
-} fop_negate;
+  REAL_VALUE_TYPE lh_lb = op1.lower_bound ();
+  REAL_VALUE_TYPE lh_ub = op1.upper_bound ();
+  lh_lb = real_value_negate (&lh_lb);
+  lh_ub = real_value_negate (&lh_ub);
+  r.set (type, lh_ub, lh_lb);
+  if (op1.maybe_isnan ())
+    {
+      bool sign;
+      if (op1.nan_signbit_p (sign))
+	r.update_nan (!sign);
+      else
+	r.update_nan ();
+    }
+  else
+    r.clear_nan ();
+  return true;
+}
+
+bool
+operator_negate::op1_range (frange &r, tree type,
+			    const frange &lhs, const frange &op2,
+			    relation_trio rel) const
+{
+  return fold_range (r, type, lhs, op2, rel);
+}
 
 bool
 operator_abs::fold_range (frange &r, tree type,
@@ -2674,7 +2671,6 @@ private:
 
 float_table::float_table ()
 {
-  set (NEGATE_EXPR, fop_negate);
   set (MULT_EXPR, fop_mult);
 }
 
@@ -2719,13 +2715,13 @@ range_op_float_tests ()
 
   // negate([-5, +10]) => [-10, 5]
   r0 = frange_float ("-5", "10");
-  fop_negate.fold_range (r, float_type_node, r0, trange);
+  range_op_handler (NEGATE_EXPR).fold_range (r, float_type_node, r0, trange);
   ASSERT_EQ (r, frange_float ("-10", "5"));
 
   // negate([0, 1] -NAN) => [-1, -0] +NAN
   r0 = frange_float ("0", "1");
   r0.update_nan (true);
-  fop_negate.fold_range (r, float_type_node, r0, trange);
+  range_op_handler (NEGATE_EXPR).fold_range (r, float_type_node, r0, trange);
   r1 = frange_float ("-1", "-0");
   r1.update_nan (false);
   ASSERT_EQ (r, r1);