From patchwork Sat Apr 21 17:36:25 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 902513 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-476700-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="S77BBKhN"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 40T0K34kzvz9s0W for ; Sun, 22 Apr 2018 03:36:52 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:reply-to:mime-version :content-type; q=dns; s=default; b=DPvIYYgxzGBLe5QtGATxjcci9Wl2b 0TwshWkqo1baw3o0f5gv5GktApvqH3lvvPMD7wG0Tw5gRG48pHBkebxgOjsWv2pW XstKtkSYvdDx/ddTLzM1BOvn1h4b/DjAI58OIQP8vmFIQHFibDAFexhhYnmWl0E7 xooK2w86eE8YUE= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:date :from:to:cc:subject:message-id:reply-to:mime-version :content-type; s=default; bh=JHIdWcRcAPhjLe+23hZCtTAFAw4=; b=S77 BBKhNORhuav/NrQyGnoAR1YfW1xy+hrBewd/qQNSTAcqcqMzi17NtTFuM1we70xC ogjEtAsKFYJYGUWcY8MH44V539AOkC9Zb+wMKc72fiPPTuawIzhjLsX0NJ3yI+cq 3trabBoDRlwnYFIaWrOqGSQ2cbdeitFcIX2nSoPI= Received: (qmail 48504 invoked by alias); 21 Apr 2018 17:36:44 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 48495 invoked by uid 89); 21 Apr 2018 17:36:43 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-11.6 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_2, GIT_PATCH_3, SPF_HELO_PASS autolearn=ham version=3.3.2 spammy=1.5, modes, fl, nextafter X-HELO: mx1.redhat.com Received: from mx3-rdu2.redhat.com (HELO mx1.redhat.com) (66.187.233.73) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 21 Apr 2018 17:36:41 +0000 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id ABBD7402290A; Sat, 21 Apr 2018 17:36:33 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.36.118.110]) by smtp.corp.redhat.com (Postfix) with ESMTPS id AC2962166BAE; Sat, 21 Apr 2018 17:36:30 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.15.2/8.15.2) with ESMTP id w3LHaR0X008799; Sat, 21 Apr 2018 19:36:28 +0200 Received: (from jakub@localhost) by tucnak.zalov.cz (8.15.2/8.15.2/Submit) id w3LHaPOh008798; Sat, 21 Apr 2018 19:36:25 +0200 Date: Sat, 21 Apr 2018 19:36:25 +0200 From: Jakub Jelinek To: Richard Biener , Jeff Law Cc: gcc-patches@gcc.gnu.org Subject: [PATCH] Add constant folding support for next{after, toward}{, f, l} (PR libstdc++/85466) Message-ID: <20180421173625.GN8577@tucnak> Reply-To: Jakub Jelinek MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.9.2 (2017-12-15) X-IsSubscribed: yes Hi! This patch adds constant folding for next{after,toward}{,f,l}. It doesn't handle decimal (we don't have a builtins that would need it), nor composite modes (IBM double double; nextafter/nexttoward for variable precision types isn't really well defined; we handle nexttoward where long double is IBM double double) and for now punts also on formats without denormals or infinities (don't really know what the library nextafter does for those). Bootstrapped/regtested on x86_64-linux and i686-linux, ok for stage1? 2018-04-21 Jakub Jelinek PR libstdc++/85466 * real.h (real_nextafter): Declare. * real.c (real_nextafter): New function. * fold-const-call.c (fold_const_nextafter): New function. (fold_const_call_sss): Call it for CASE_CFN_NEXTAFTER and CASE_CFN_NEXTTOWARD. (fold_const_call_1): For CASE_CFN_NEXTTOWARD call fold_const_call_sss even when arg1_mode is different from arg0_mode. * gcc.dg/nextafter-1.c: New test. * gcc.dg/nextafter-2.c: New test. * gcc.dg/nextafter-3.c: New test. * gcc.dg/nextafter-4.c: New test. Jakub --- gcc/real.h.jj 2018-01-03 10:19:54.349533828 +0100 +++ gcc/real.h 2018-04-20 12:44:30.707350855 +0200 @@ -507,6 +507,10 @@ extern void real_copysign (REAL_VALUE_TY extern bool real_isinteger (const REAL_VALUE_TYPE *, format_helper); extern bool real_isinteger (const REAL_VALUE_TYPE *, HOST_WIDE_INT *); +/* Calculate nextafter (X, Y) in format FMT. */ +extern bool real_nextafter (REAL_VALUE_TYPE *, format_helper, + const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *); + /* 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. BUF must be large enough to contain the result. */ --- gcc/real.c.jj 2018-01-03 10:19:55.003533933 +0100 +++ gcc/real.c 2018-04-21 19:29:09.103584254 +0200 @@ -5048,6 +5048,102 @@ real_isinteger (const REAL_VALUE_TYPE *c 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 --- gcc/fold-const-call.c.jj 2018-01-14 17:16:52.873836266 +0100 +++ gcc/fold-const-call.c 2018-04-20 19:36:40.987942433 +0200 @@ -529,6 +529,49 @@ fold_const_pow (real_value *result, cons /* 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 (flag_signaling_nans + && (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) in format FORMAT. Return true on success. */ @@ -1260,6 +1303,10 @@ fold_const_call_sss (real_value *result, 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; } @@ -1365,20 +1412,33 @@ fold_const_call_1 (combined_fn fn, tree 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; } --- gcc/testsuite/gcc.dg/nextafter-1.c.jj 2018-04-20 20:53:15.418133039 +0200 +++ gcc/testsuite/gcc.dg/nextafter-1.c 2018-04-20 20:59:27.598468003 +0200 @@ -0,0 +1,159 @@ +/* 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; +} --- gcc/testsuite/gcc.dg/nextafter-2.c.jj 2018-04-20 20:53:24.662141363 +0200 +++ gcc/testsuite/gcc.dg/nextafter-2.c 2018-04-20 20:54:01.031174134 +0200 @@ -0,0 +1,6 @@ +/* PR libstdc++/85466 */ +/* { dg-do run } */ +/* { dg-options "-O2 -fno-builtin" } */ +/* { dg-add-options ieee } */ + +#include "nextafter-1.c" --- gcc/testsuite/gcc.dg/nextafter-3.c.jj 2018-04-20 20:54:09.867182101 +0200 +++ gcc/testsuite/gcc.dg/nextafter-3.c 2018-04-20 20:59:48.280486574 +0200 @@ -0,0 +1,9 @@ +/* PR libstdc++/85466 */ +/* { dg-do run } */ +/* { dg-options "-O2 -fmath-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" } } */ + +#define NEED_ERRNO 1 +#include "nextafter-1.c" --- gcc/testsuite/gcc.dg/nextafter-4.c.jj 2018-04-20 20:55:11.880237977 +0200 +++ gcc/testsuite/gcc.dg/nextafter-4.c 2018-04-20 20:59:54.927492541 +0200 @@ -0,0 +1,10 @@ +/* PR libstdc++/85466 */ +/* { dg-do run } */ +/* { dg-options "-O2 -fmath-errno -ftrapping-math -fdump-tree-optimized" } */ +/* { dg-add-options ieee } */ +/* { dg-final { scan-tree-dump-not "nextafter" "optimized" } } */ +/* { dg-final { scan-tree-dump-not "nexttoward" "optimized" } } */ + +#define NEED_ERRNO 1 +#define NEED_EXC 1 +#include "nextafter-1.c"