return false;
}
+/* Try to evaluate:
+
+ *RESULT = nextafter (*ARG0, *ARG1)
+
+ or
+
+ *RESULT = nexttoward (*ARG0, *ARG1)
+
+ in format FORMAT. Return true on success. */
+
+static bool
+fold_const_nextafter (real_value *result, const real_value *arg0,
+ const real_value *arg1, const real_format *format)
+{
+ if (REAL_VALUE_ISSIGNALING_NAN (*arg0)
+ || REAL_VALUE_ISSIGNALING_NAN (*arg1))
+ return false;
+
+ /* Don't handle composite modes, nor decimal, nor modes without
+ inf or denorm at least for now. */
+ if (format->pnan < format->p
+ || format->b == 10
+ || !format->has_inf
+ || !format->has_denorm)
+ return false;
+
+ if (real_nextafter (result, format, arg0, arg1)
+ /* If raising underflow or overflow and setting errno to ERANGE,
+ fail if we care about those side-effects. */
+ && (flag_trapping_math || flag_errno_math))
+ return false;
+ /* Similarly for nextafter (0, 1) raising underflow. */
+ else if (flag_trapping_math
+ && arg0->cl == rvc_zero
+ && result->cl != rvc_zero)
+ return false;
+
+ real_convert (result, format, result);
+
+ return true;
+}
+
/* Try to evaluate:
*RESULT = ldexp (*ARG0, ARG1)
CASE_CFN_POW:
return fold_const_pow (result, arg0, arg1, format);
+ CASE_CFN_NEXTAFTER:
+ CASE_CFN_NEXTTOWARD:
+ return fold_const_nextafter (result, arg0, arg1, format);
+
default:
return false;
}
machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
- if (arg0_mode == arg1_mode
+ if (mode == arg0_mode
&& real_cst_p (arg0)
&& real_cst_p (arg1))
{
gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
- if (mode == arg0_mode)
+ REAL_VALUE_TYPE result;
+ if (arg0_mode == arg1_mode)
{
/* real, real -> real. */
- REAL_VALUE_TYPE result;
if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
TREE_REAL_CST_PTR (arg1),
REAL_MODE_FORMAT (mode)))
return build_real (type, result);
}
+ else if (arg1_mode == TYPE_MODE (long_double_type_node))
+ switch (fn)
+ {
+ CASE_CFN_NEXTTOWARD:
+ /* real, long double -> real. */
+ if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
+ TREE_REAL_CST_PTR (arg1),
+ REAL_MODE_FORMAT (mode)))
+ return build_real (type, result);
+ break;
+ default:
+ break;
+ }
return NULL_TREE;
}
return false;
}
+/* Calculate nextafter (X, Y) or nexttoward (X, Y). Return true if
+ underflow or overflow needs to be raised. */
+
+bool
+real_nextafter (REAL_VALUE_TYPE *r, format_helper fmt,
+ const REAL_VALUE_TYPE *x, const REAL_VALUE_TYPE *y)
+{
+ int cmp = do_compare (x, y, 2);
+ /* If either operand is NaN, return qNaN. */
+ if (cmp == 2)
+ {
+ get_canonical_qnan (r, 0);
+ return false;
+ }
+ /* If x == y, return y cast to target type. */
+ if (cmp == 0)
+ {
+ real_convert (r, fmt, y);
+ return false;
+ }
+
+ if (x->cl == rvc_zero)
+ {
+ get_zero (r, y->sign);
+ r->cl = rvc_normal;
+ SET_REAL_EXP (r, fmt->emin - fmt->p + 1);
+ r->sig[SIGSZ - 1] = SIG_MSB;
+ return false;
+ }
+
+ int np2 = SIGNIFICAND_BITS - fmt->p;
+ /* For denormals adjust np2 correspondingly. */
+ if (x->cl == rvc_normal && REAL_EXP (x) < fmt->emin)
+ np2 += fmt->emin - REAL_EXP (x);
+
+ REAL_VALUE_TYPE u;
+ get_zero (r, x->sign);
+ get_zero (&u, 0);
+ set_significand_bit (&u, np2);
+ r->cl = rvc_normal;
+ SET_REAL_EXP (r, REAL_EXP (x));
+
+ if (x->cl == rvc_inf)
+ {
+ bool borrow = sub_significands (r, r, &u, 0);
+ gcc_assert (borrow);
+ SET_REAL_EXP (r, fmt->emax);
+ }
+ else if (cmp == (x->sign ? 1 : -1))
+ {
+ if (add_significands (r, x, &u))
+ {
+ /* Overflow. Means the significand had been all ones, and
+ is now all zeros. Need to increase the exponent, and
+ possibly re-normalize it. */
+ SET_REAL_EXP (r, REAL_EXP (r) + 1);
+ if (REAL_EXP (r) > fmt->emax)
+ {
+ get_inf (r, x->sign);
+ return true;
+ }
+ r->sig[SIGSZ - 1] = SIG_MSB;
+ }
+ }
+ else
+ {
+ if (REAL_EXP (x) > fmt->emin && x->sig[SIGSZ - 1] == SIG_MSB)
+ {
+ int i;
+ for (i = SIGSZ - 2; i >= 0; i--)
+ if (x->sig[i])
+ break;
+ if (i < 0)
+ {
+ /* When mantissa is 1.0, we need to subtract only
+ half of u: nextafter (1.0, 0.0) is 1.0 - __DBL_EPSILON__ / 2
+ rather than 1.0 - __DBL_EPSILON__. */
+ clear_significand_bit (&u, np2);
+ np2--;
+ set_significand_bit (&u, np2);
+ }
+ }
+ sub_significands (r, x, &u, 0);
+ }
+
+ /* Clear out trailing garbage. */
+ clear_significand_below (r, np2);
+ normalize (r);
+ if (REAL_EXP (r) <= fmt->emin - fmt->p)
+ {
+ get_zero (r, x->sign);
+ return true;
+ }
+ return r->cl == rvc_zero;
+}
+
/* Write into BUF the maximum representable finite floating-point
number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
float string. LEN is the size of BUF, and the buffer must be large
--- /dev/null
+/* PR libstdc++/85466 */
+/* { dg-do run } */
+/* { dg-options "-O2 -fno-math-errno -fno-trapping-math -fdump-tree-optimized" } */
+/* { dg-add-options ieee } */
+/* { dg-final { scan-tree-dump-not "nextafter" "optimized" } } */
+/* { dg-final { scan-tree-dump-not "nexttoward" "optimized" } } */
+
+float nextafterf (float, float);
+double nextafter (double, double);
+long double nextafterl (long double, long double);
+float nexttowardf (float, long double);
+double nexttoward (double, long double);
+long double nexttowardl (long double, long double);
+
+#define CHECK(x) if (!(x)) __builtin_abort ()
+
+#ifndef NEED_ERRNO
+#define NEED_ERRNO 0
+#endif
+#ifndef NEED_EXC
+#define NEED_EXC 0
+#endif
+
+#define TEST(name, fn, type, L1, L2, l1, l2, MIN1, \
+ MAX1, DENORM_MIN1, EPSILON1, MIN2, MAX2, DENORM_MIN2) \
+void \
+name (void) \
+{ \
+ const type a = fn (0.0##L1, 0.0##L2); \
+ CHECK (a == 0.0##L1 && !__builtin_signbit (a)); \
+ const type b = fn (0.0##L1, -0.0##L2); \
+ CHECK (b == 0.0##L1 && __builtin_signbit (b)); \
+ const type c = fn (__builtin_nan##l1 (""), 0.0##L2); \
+ CHECK (__builtin_isnan##l1 (c)); \
+ const type d = fn (2.0##L1, __builtin_nan##l2 ("")); \
+ CHECK (__builtin_isnan##l1 (d)); \
+ const type e = NEED_EXC ? DENORM_MIN1 : fn (0.0##L1, 8.0##L2); \
+ CHECK (e == DENORM_MIN1); \
+ const type f = fn (1.0##L1, 8.0##L2); \
+ CHECK (f == 1.0##L1 + EPSILON1); \
+ const type g = fn (1.0##L1, -8.0##L2); \
+ CHECK (g == 1.0##L1 - EPSILON1 / 2.0##L1); \
+ const type h = fn (__builtin_inf (), 0.0##L2); \
+ CHECK (h == MAX1); \
+ const type i = fn (-1.0##L1, -__builtin_inf ()); \
+ CHECK (i == -1.0##L1 - EPSILON1); \
+ const type j = fn (1.5##L1, __builtin_inf ()); \
+ CHECK (j == 1.5##L1 + EPSILON1); \
+ const type k = fn (1.5##L1 - EPSILON1, 100.0##L2); \
+ CHECK (k == 1.5##L1); \
+ const type l \
+ = (NEED_EXC || NEED_ERRNO) ? 0.0##L1 : fn (DENORM_MIN1, 0.0##L2); \
+ CHECK (l == 0.0##L1 && !__builtin_signbit (l)); \
+ const type m \
+ = (NEED_EXC || NEED_ERRNO) ? __builtin_inf##l1 () \
+ : fn (MAX1, __builtin_inf ()); \
+ CHECK (__builtin_isinf##l1 (m) && !__builtin_signbit (m)); \
+ const type n = fn (DENORM_MIN1, 12.0##L2); \
+ CHECK (n == 2.0##L1 * DENORM_MIN1); \
+ const type o = fn (n, 24.0##L2); \
+ CHECK (o == 3.0##L1 * DENORM_MIN1); \
+ const type p = fn (o, 132.0##L2); \
+ CHECK (p == 4.0##L1 * DENORM_MIN1); \
+ const type q = fn (2.0##L1 * DENORM_MIN1, -__builtin_inf ()); \
+ CHECK (q == DENORM_MIN1); \
+ const type r = fn (3.0##L1 * DENORM_MIN1, DENORM_MIN2); \
+ CHECK (r == 2.0##L1 * DENORM_MIN1); \
+ const type s = fn (4.0##L1 * DENORM_MIN1, 2.0##L2 * DENORM_MIN2); \
+ CHECK (s == 3.0##L1 * DENORM_MIN1); \
+ const type t = fn (MIN1, 0.0##L2); \
+ CHECK (t == MIN1 - DENORM_MIN1); \
+ const type u = fn (MIN1 - DENORM_MIN1, -MIN2); \
+ CHECK (u == MIN1 - 2.0##L1 * DENORM_MIN1); \
+ const type v = fn (MIN1 - 2.0##L1 * DENORM_MIN1, 100.0##L2); \
+ CHECK (v == MIN1 - DENORM_MIN1); \
+ const type w = fn (MIN1 - DENORM_MIN1, MAX2); \
+ CHECK (w == MIN1); \
+ const type x = fn (MIN1, 17.0##L2); \
+ CHECK (x == MIN1 + DENORM_MIN1); \
+ const type y = fn (MIN1 + DENORM_MIN1, __builtin_inf##l2 ()); \
+ CHECK (y == MIN1 + 2.0##L1 * DENORM_MIN1); \
+ const type z = fn (MIN1 / 2.0##L1, -MIN2); \
+ CHECK (z == MIN1 / 2.0##L1 - DENORM_MIN1); \
+ const type aa = fn (-MIN1 / 4.0##L1, MIN2); \
+ CHECK (aa == -MIN1 / 4.0##L1 + DENORM_MIN1); \
+ const type ab = fn (MIN1 * 2.0##L1, -MIN2); \
+ CHECK (ab == MIN1 * 2.0##L1 - DENORM_MIN1); \
+ const type ac = fn (MIN1 * 4.0##L1, MIN2); \
+ CHECK (ac == MIN1 * 4.0##L1 - DENORM_MIN1 * 2.0##L1); \
+ const type ad = fn (MIN1 * 64.0##L1, MIN2); \
+ CHECK (ad == MIN1 * 64.0##L1 - DENORM_MIN1 * 32.0##L1); \
+ const type ae = fn (MIN1 / 2.0##L1 - DENORM_MIN1, 100.0##L2); \
+ CHECK (ae == MIN1 / 2.0##L1); \
+ const type af = fn (-MIN1 / 4 + DENORM_MIN1, -100.0##L2); \
+ CHECK (af == -MIN1 / 4.0##L1); \
+ const type ag = fn (MIN1 * 2.0##L1 - DENORM_MIN1, 100.0##L2); \
+ CHECK (ag == MIN1 * 2.0##L1); \
+ const type ah = fn (MIN1 * 4.0##L1 - 2.0##L1 * DENORM_MIN1, 100.0##L2); \
+ CHECK (ah == MIN1 * 4.0##L1); \
+ const type ai = fn (MIN1 * 64.0##L1 - 32.0##L1 * DENORM_MIN1, 100.0##L2); \
+ CHECK (ai == MIN1 * 64.0##L1); \
+ const type aj = fn (MIN1 * 64.0##L1, 100.0##L2); \
+ CHECK (aj == MIN1 * 64.0##L1 + 64.0##L1 * DENORM_MIN1); \
+ const type ak = fn (MIN1 * 64.0##L1 + DENORM_MIN1 * 64.0##L1, 1024.0##L2); \
+ CHECK (ak == MIN1 * 64.0##L1 + 128.0##L1 * DENORM_MIN1); \
+ const type al = fn (128.0##L1, 128.0##L2); \
+ CHECK (al == 128.0##L1); \
+ const type am = fn (128.0##L1, 129.0##L2); \
+ CHECK (am == 128.0##L1 + 128.0##L1 * EPSILON1); \
+ const type an = fn (-128.0##L1 + -128.0##L1 * EPSILON1, -130.0##L2); \
+ CHECK (an == -128.0##L1 - 256.0##L1 * EPSILON1); \
+ const type ao = fn (128.0##L1 + 256.0##L1 * EPSILON1, 256.0##L2); \
+ CHECK (ao == 128.0##L1 + 384.0##L1 * EPSILON1); \
+ const type ap = fn (128.0##L1 + 384.0##L1 * EPSILON1, -0.0##L2); \
+ CHECK (ap == 128.0##L1 + 256.0##L1 * EPSILON1); \
+ const type aq = fn (128.0##L1 + 256.0##L1 * EPSILON1, 1.0##L2); \
+ CHECK (aq == 128.0##L1 + 128.0##L1 * EPSILON1); \
+ const type ar = fn (128.0##L1 + 128.0##L1 * EPSILON1, 0.0##L2); \
+ CHECK (ar == 128.0##L1); \
+ const type as = fn (128.0##L1, 0.0##L2); \
+ CHECK (as == 128.0##L1 - 64.0##L1 * EPSILON1); \
+ const type at = fn (128.0##L1 - 64.0##L1 * EPSILON1, 5.0##L2); \
+ CHECK (at == 128.0##L1 - 128.0##L1 * EPSILON1); \
+}
+
+TEST (test1, nextafterf, float, F, F, f, f, __FLT_MIN__, __FLT_MAX__,
+ __FLT_DENORM_MIN__, __FLT_EPSILON__, __FLT_MIN__, __FLT_MAX__,
+ __FLT_DENORM_MIN__)
+TEST (test2, nextafter, double, , , , , __DBL_MIN__, __DBL_MAX__,
+ __DBL_DENORM_MIN__, __DBL_EPSILON__, __DBL_MIN__, __DBL_MAX__,
+ __DBL_DENORM_MIN__)
+#if __LDBL_MANT_DIG__ != 106
+TEST (test3, nextafterl, long double, L, L, l, l, __LDBL_MIN__, __LDBL_MAX__,
+ __LDBL_DENORM_MIN__, __LDBL_EPSILON__, __LDBL_MIN__, __LDBL_MAX__,
+ __LDBL_DENORM_MIN__)
+TEST (test4, nexttowardf, float, F, L, f, l, __FLT_MIN__, __FLT_MAX__,
+ __FLT_DENORM_MIN__, __FLT_EPSILON__, __LDBL_MIN__, __LDBL_MAX__,
+ __LDBL_DENORM_MIN__)
+TEST (test5, nexttoward, double, , L, , l, __DBL_MIN__, __DBL_MAX__,
+ __DBL_DENORM_MIN__, __DBL_EPSILON__, __LDBL_MIN__, __LDBL_MAX__,
+ __LDBL_DENORM_MIN__)
+TEST (test6, nexttowardl, long double, L, L, l, l, __LDBL_MIN__, __LDBL_MAX__,
+ __LDBL_DENORM_MIN__, __LDBL_EPSILON__, __LDBL_MIN__, __LDBL_MAX__,
+ __LDBL_DENORM_MIN__)
+#endif
+
+int
+main ()
+{
+ test1 ();
+ test2 ();
+#if __LDBL_MANT_DIG__ != 106
+ test3 ();
+ test4 ();
+ test5 ();
+ test6 ();
+#endif
+ return 0;
+}
projects / gcc.git / commitdiff