}
-class foperator_mult_div_base : public range_operator
-{
-protected:
- // Given CP[0] to CP[3] floating point values rounded to -INF,
- // set LB to the smallest of them (treating -0 as smaller to +0).
- // Given CP[4] to CP[7] floating point values rounded to +INF,
- // set UB to the largest of them (treating -0 as smaller to +0).
- static void find_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
- const REAL_VALUE_TYPE (&cp)[8])
- {
- lb = cp[0];
- ub = cp[4];
- for (int i = 1; i < 4; ++i)
- {
- if (real_less (&cp[i], &lb)
- || (real_iszero (&lb) && real_isnegzero (&cp[i])))
- lb = cp[i];
- if (real_less (&ub, &cp[i + 4])
- || (real_isnegzero (&ub) && real_iszero (&cp[i + 4])))
- ub = cp[i + 4];
- }
- }
-};
+// Given CP[0] to CP[3] floating point values rounded to -INF,
+// set LB to the smallest of them (treating -0 as smaller to +0).
+// Given CP[4] to CP[7] floating point values rounded to +INF,
+// set UB to the largest of them (treating -0 as smaller to +0).
+
+static void
+find_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
+ const REAL_VALUE_TYPE (&cp)[8])
+{
+ lb = cp[0];
+ ub = cp[4];
+ for (int i = 1; i < 4; ++i)
+ {
+ if (real_less (&cp[i], &lb)
+ || (real_iszero (&lb) && real_isnegzero (&cp[i])))
+ lb = cp[i];
+ if (real_less (&ub, &cp[i + 4])
+ || (real_isnegzero (&ub) && real_iszero (&cp[i + 4])))
+ ub = cp[i + 4];
+ }
+}
-class foperator_mult : public foperator_mult_div_base
+bool
+operator_mult::op1_range (frange &r, tree type,
+ const frange &lhs, const frange &op2,
+ relation_trio) const
{
- using range_operator::op1_range;
- using range_operator::op2_range;
-public:
- virtual bool op1_range (frange &r, tree type,
- const frange &lhs,
- const frange &op2,
- relation_trio = TRIO_VARYING) const final override
- {
- if (lhs.undefined_p ())
- return false;
- range_op_handler rdiv (RDIV_EXPR, type);
- if (!rdiv)
- return false;
- frange wlhs = float_widen_lhs_range (type, lhs);
- bool ret = rdiv.fold_range (r, type, wlhs, op2);
- if (ret == false)
- return false;
- if (wlhs.known_isnan () || op2.known_isnan () || op2.undefined_p ())
- return float_binary_op_range_finish (ret, r, type, wlhs);
- const REAL_VALUE_TYPE &lhs_lb = wlhs.lower_bound ();
- const REAL_VALUE_TYPE &lhs_ub = wlhs.upper_bound ();
- const REAL_VALUE_TYPE &op2_lb = op2.lower_bound ();
- const REAL_VALUE_TYPE &op2_ub = op2.upper_bound ();
- if ((contains_zero_p (lhs_lb, lhs_ub) && contains_zero_p (op2_lb, op2_ub))
- || ((real_isinf (&lhs_lb) || real_isinf (&lhs_ub))
- && (real_isinf (&op2_lb) || real_isinf (&op2_ub))))
- {
- // If both lhs and op2 could be zeros or both could be infinities,
- // we don't know anything about op1 except maybe for the sign
- // and perhaps if it can be NAN or not.
- REAL_VALUE_TYPE lb, ub;
- int signbit_known = signbit_known_p (lhs_lb, lhs_ub, op2_lb, op2_ub);
- zero_to_inf_range (lb, ub, signbit_known);
- r.set (type, lb, ub);
- }
- // Otherwise, if op2 is a singleton INF and lhs doesn't include INF,
- // or if lhs must be zero and op2 doesn't include zero, it would be
- // UNDEFINED, while rdiv.fold_range computes a zero or singleton INF
- // range. Those are supersets of UNDEFINED, so let's keep that way.
+ if (lhs.undefined_p ())
+ return false;
+ range_op_handler rdiv (RDIV_EXPR, type);
+ if (!rdiv)
+ return false;
+ frange wlhs = float_widen_lhs_range (type, lhs);
+ bool ret = rdiv.fold_range (r, type, wlhs, op2);
+ if (ret == false)
+ return false;
+ if (wlhs.known_isnan () || op2.known_isnan () || op2.undefined_p ())
return float_binary_op_range_finish (ret, r, type, wlhs);
- }
- virtual bool op2_range (frange &r, tree type,
- const frange &lhs,
- const frange &op1,
- relation_trio = TRIO_VARYING) const final override
- {
- return op1_range (r, type, lhs, op1);
- }
-private:
- void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, bool &maybe_nan,
- tree type,
- const REAL_VALUE_TYPE &lh_lb,
- const REAL_VALUE_TYPE &lh_ub,
- const REAL_VALUE_TYPE &rh_lb,
- const REAL_VALUE_TYPE &rh_ub,
- relation_kind kind) const final override
- {
- bool is_square
- = (kind == VREL_EQ
- && real_equal (&lh_lb, &rh_lb)
- && real_equal (&lh_ub, &rh_ub)
- && real_isneg (&lh_lb) == real_isneg (&rh_lb)
- && real_isneg (&lh_ub) == real_isneg (&rh_ub));
+ const REAL_VALUE_TYPE &lhs_lb = wlhs.lower_bound ();
+ const REAL_VALUE_TYPE &lhs_ub = wlhs.upper_bound ();
+ const REAL_VALUE_TYPE &op2_lb = op2.lower_bound ();
+ const REAL_VALUE_TYPE &op2_ub = op2.upper_bound ();
+ if ((contains_zero_p (lhs_lb, lhs_ub) && contains_zero_p (op2_lb, op2_ub))
+ || ((real_isinf (&lhs_lb) || real_isinf (&lhs_ub))
+ && (real_isinf (&op2_lb) || real_isinf (&op2_ub))))
+ {
+ // If both lhs and op2 could be zeros or both could be infinities,
+ // we don't know anything about op1 except maybe for the sign
+ // and perhaps if it can be NAN or not.
+ REAL_VALUE_TYPE lb, ub;
+ int signbit_known = signbit_known_p (lhs_lb, lhs_ub, op2_lb, op2_ub);
+ zero_to_inf_range (lb, ub, signbit_known);
+ r.set (type, lb, ub);
+ }
+ // Otherwise, if op2 is a singleton INF and lhs doesn't include INF,
+ // or if lhs must be zero and op2 doesn't include zero, it would be
+ // UNDEFINED, while rdiv.fold_range computes a zero or singleton INF
+ // range. Those are supersets of UNDEFINED, so let's keep that way.
+ return float_binary_op_range_finish (ret, r, type, wlhs);
+}
- maybe_nan = false;
- // x * x never produces a new NAN and we only multiply the same
- // values, so the 0 * INF problematic cases never appear there.
- if (!is_square)
- {
- // [+-0, +-0] * [+INF,+INF] (or [-INF,-INF] or swapped is a known NAN.
- if ((zero_p (lh_lb, lh_ub) && singleton_inf_p (rh_lb, rh_ub))
- || (zero_p (rh_lb, rh_ub) && singleton_inf_p (lh_lb, lh_ub)))
- {
- real_nan (&lb, "", 0, TYPE_MODE (type));
- ub = lb;
- maybe_nan = true;
- return;
- }
-
- // Otherwise, if one range includes zero and the other ends with +-INF,
- // it is a maybe NAN.
- if ((contains_zero_p (lh_lb, lh_ub)
- && (real_isinf (&rh_lb) || real_isinf (&rh_ub)))
- || (contains_zero_p (rh_lb, rh_ub)
- && (real_isinf (&lh_lb) || real_isinf (&lh_ub))))
- {
- maybe_nan = true;
-
- int signbit_known = signbit_known_p (lh_lb, lh_ub, rh_lb, rh_ub);
-
- // If one of the ranges that includes INF is singleton
- // and the other range includes zero, the resulting
- // range is INF and NAN, because the 0 * INF boundary
- // case will be NAN, but already nextafter (0, 1) * INF
- // is INF.
- if (singleton_inf_p (lh_lb, lh_ub)
- || singleton_inf_p (rh_lb, rh_ub))
- return inf_range (lb, ub, signbit_known);
-
- // If one of the multiplicands must be zero, the resulting
- // range is +-0 and NAN.
- if (zero_p (lh_lb, lh_ub) || zero_p (rh_lb, rh_ub))
- return zero_range (lb, ub, signbit_known);
-
- // Otherwise one of the multiplicands could be
- // [0.0, nextafter (0.0, 1.0)] and the [DBL_MAX, INF]
- // or similarly with different signs. 0.0 * DBL_MAX
- // is still 0.0, nextafter (0.0, 1.0) * INF is still INF,
- // so if the signs are always the same or always different,
- // result is [+0.0, +INF] or [-INF, -0.0], otherwise VARYING.
- return zero_to_inf_range (lb, ub, signbit_known);
- }
- }
+bool
+operator_mult::op2_range (frange &r, tree type,
+ const frange &lhs, const frange &op1,
+ relation_trio) const
+{
+ return op1_range (r, type, lhs, op1);
+}
- REAL_VALUE_TYPE cp[8];
- // Do a cross-product. At this point none of the multiplications
- // should produce a NAN.
- frange_arithmetic (MULT_EXPR, type, cp[0], lh_lb, rh_lb, dconstninf);
- frange_arithmetic (MULT_EXPR, type, cp[4], lh_lb, rh_lb, dconstinf);
- if (is_square)
- {
- // For x * x we can just do max (lh_lb * lh_lb, lh_ub * lh_ub)
- // as maximum and -0.0 as minimum if 0.0 is in the range,
- // otherwise min (lh_lb * lh_lb, lh_ub * lh_ub).
- // -0.0 rather than 0.0 because VREL_EQ doesn't prove that
- // x and y are bitwise equal, just that they compare equal.
- if (contains_zero_p (lh_lb, lh_ub))
- {
- if (real_isneg (&lh_lb) == real_isneg (&lh_ub))
- cp[1] = dconst0;
- else
- cp[1] = dconstm0;
- }
- else
- cp[1] = cp[0];
- cp[2] = cp[0];
- cp[5] = cp[4];
- cp[6] = cp[4];
- }
- else
- {
- frange_arithmetic (MULT_EXPR, type, cp[1], lh_lb, rh_ub, dconstninf);
- frange_arithmetic (MULT_EXPR, type, cp[5], lh_lb, rh_ub, dconstinf);
- frange_arithmetic (MULT_EXPR, type, cp[2], lh_ub, rh_lb, dconstninf);
- frange_arithmetic (MULT_EXPR, type, cp[6], lh_ub, rh_lb, dconstinf);
- }
- frange_arithmetic (MULT_EXPR, type, cp[3], lh_ub, rh_ub, dconstninf);
- frange_arithmetic (MULT_EXPR, type, cp[7], lh_ub, rh_ub, dconstinf);
+void
+operator_mult::rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
+ bool &maybe_nan, tree type,
+ const REAL_VALUE_TYPE &lh_lb,
+ const REAL_VALUE_TYPE &lh_ub,
+ const REAL_VALUE_TYPE &rh_lb,
+ const REAL_VALUE_TYPE &rh_ub,
+ relation_kind kind) const
+{
+ bool is_square
+ = (kind == VREL_EQ
+ && real_equal (&lh_lb, &rh_lb)
+ && real_equal (&lh_ub, &rh_ub)
+ && real_isneg (&lh_lb) == real_isneg (&rh_lb)
+ && real_isneg (&lh_ub) == real_isneg (&rh_ub));
+
+ maybe_nan = false;
+ // x * x never produces a new NAN and we only multiply the same
+ // values, so the 0 * INF problematic cases never appear there.
+ if (!is_square)
+ {
+ // [+-0, +-0] * [+INF,+INF] (or [-INF,-INF] or swapped is a known NAN.
+ if ((zero_p (lh_lb, lh_ub) && singleton_inf_p (rh_lb, rh_ub))
+ || (zero_p (rh_lb, rh_ub) && singleton_inf_p (lh_lb, lh_ub)))
+ {
+ real_nan (&lb, "", 0, TYPE_MODE (type));
+ ub = lb;
+ maybe_nan = true;
+ return;
+ }
- find_range (lb, ub, cp);
- }
-} fop_mult;
+ // Otherwise, if one range includes zero and the other ends with +-INF,
+ // it is a maybe NAN.
+ if ((contains_zero_p (lh_lb, lh_ub)
+ && (real_isinf (&rh_lb) || real_isinf (&rh_ub)))
+ || (contains_zero_p (rh_lb, rh_ub)
+ && (real_isinf (&lh_lb) || real_isinf (&lh_ub))))
+ {
+ maybe_nan = true;
+
+ int signbit_known = signbit_known_p (lh_lb, lh_ub, rh_lb, rh_ub);
+
+ // If one of the ranges that includes INF is singleton
+ // and the other range includes zero, the resulting
+ // range is INF and NAN, because the 0 * INF boundary
+ // case will be NAN, but already nextafter (0, 1) * INF
+ // is INF.
+ if (singleton_inf_p (lh_lb, lh_ub)
+ || singleton_inf_p (rh_lb, rh_ub))
+ return inf_range (lb, ub, signbit_known);
+
+ // If one of the multiplicands must be zero, the resulting
+ // range is +-0 and NAN.
+ if (zero_p (lh_lb, lh_ub) || zero_p (rh_lb, rh_ub))
+ return zero_range (lb, ub, signbit_known);
+
+ // Otherwise one of the multiplicands could be
+ // [0.0, nextafter (0.0, 1.0)] and the [DBL_MAX, INF]
+ // or similarly with different signs. 0.0 * DBL_MAX
+ // is still 0.0, nextafter (0.0, 1.0) * INF is still INF,
+ // so if the signs are always the same or always different,
+ // result is [+0.0, +INF] or [-INF, -0.0], otherwise VARYING.
+ return zero_to_inf_range (lb, ub, signbit_known);
+ }
+ }
+ REAL_VALUE_TYPE cp[8];
+ // Do a cross-product. At this point none of the multiplications
+ // should produce a NAN.
+ frange_arithmetic (MULT_EXPR, type, cp[0], lh_lb, rh_lb, dconstninf);
+ frange_arithmetic (MULT_EXPR, type, cp[4], lh_lb, rh_lb, dconstinf);
+ if (is_square)
+ {
+ // For x * x we can just do max (lh_lb * lh_lb, lh_ub * lh_ub)
+ // as maximum and -0.0 as minimum if 0.0 is in the range,
+ // otherwise min (lh_lb * lh_lb, lh_ub * lh_ub).
+ // -0.0 rather than 0.0 because VREL_EQ doesn't prove that
+ // x and y are bitwise equal, just that they compare equal.
+ if (contains_zero_p (lh_lb, lh_ub))
+ {
+ if (real_isneg (&lh_lb) == real_isneg (&lh_ub))
+ cp[1] = dconst0;
+ else
+ cp[1] = dconstm0;
+ }
+ else
+ cp[1] = cp[0];
+ cp[2] = cp[0];
+ cp[5] = cp[4];
+ cp[6] = cp[4];
+ }
+ else
+ {
+ frange_arithmetic (MULT_EXPR, type, cp[1], lh_lb, rh_ub, dconstninf);
+ frange_arithmetic (MULT_EXPR, type, cp[5], lh_lb, rh_ub, dconstinf);
+ frange_arithmetic (MULT_EXPR, type, cp[2], lh_ub, rh_lb, dconstninf);
+ frange_arithmetic (MULT_EXPR, type, cp[6], lh_ub, rh_lb, dconstinf);
+ }
+ frange_arithmetic (MULT_EXPR, type, cp[3], lh_ub, rh_ub, dconstninf);
+ frange_arithmetic (MULT_EXPR, type, cp[7], lh_ub, rh_ub, dconstinf);
-class foperator_div : public foperator_mult_div_base
+ find_range (lb, ub, cp);
+}
+
+
+class foperator_div : public range_operator
{
using range_operator::op1_range;
using range_operator::op2_range;
if (lhs.undefined_p ())
return false;
frange wlhs = float_widen_lhs_range (type, lhs);
- bool ret = fop_mult.fold_range (r, type, wlhs, op2);
+ bool ret = range_op_handler (MULT_EXPR).fold_range (r, type, wlhs, op2);
if (!ret)
return ret;
if (wlhs.known_isnan () || op2.known_isnan () || op2.undefined_p ())
} fop_div;
-float_table::float_table ()
-{
- set (MULT_EXPR, fop_mult);
-}
-
-// Initialize any pointer operators to the primary table
+// Initialize any float operators to the primary table
void
range_op_table::initialize_float_ops ()
projects / thirdparty / gcc.git / commitdiff
