From patchwork Fri Nov 11 10:01:35 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 18636 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:6687:0:0:0:0:0 with SMTP id l7csp650080wru; Fri, 11 Nov 2022 02:03:30 -0800 (PST) X-Google-Smtp-Source: AA0mqf70jmHZJGSY3QUrQnrUWWe4YnR5k3h911JvuxvuRpLBSHBD6yEWatlhCZ/bZQjn6o2KLDVh X-Received: by 2002:a17:906:1c85:b0:7ae:ca2f:171d with SMTP id g5-20020a1709061c8500b007aeca2f171dmr931198ejh.353.1668161010234; Fri, 11 Nov 2022 02:03:30 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1668161010; cv=none; d=google.com; s=arc-20160816; b=oWhSadM5hcXuGjmCAcflKipL47klXDG0O2pvGldTxX4h1be/pqPvbMl419Tg1p91kk EoO1/uuslS4+7mQl0EVFmD393Ckb+xMcS/ftyR2B12XaCXWUNs06E5TbblmG+8j+OCHq Xqjlg9DHt1eBKFQcaAZiAYx+e1xhkO/L3nI8D3FHigwDwq9Zt04C/vNs76WK6liZNaYo 72T4tkkx9WYA2DrhB98rvOgKcQouLXY1ecnFSoOyrWBbrkLEwLHcBlr8I+WgbTcPYs1w CuJ+EYvnNcErrKjkroPN9RIZoCRVpoBrzXX44XsFBa9z1jZ7tLc7UHLgzM54qJzEzvx1 sQJg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-disposition:in-reply-to:mime-version:references:message-id :subject:cc:to:date:dmarc-filter:delivered-to:dkim-signature :dkim-filter; bh=6Fywj9duiS7D7+0wIvI00CN4r5sNhGRRL2plIBvY0B4=; b=znj6wS10qmr5GbZDRKbgKtP4x5CxDJBHfinYBEpRuvmJ49EuMZDVCTZTgKpdrOSzrd BfdBgPy2JlWczgluhMB9wlDlKUS0DUQBJdI1/LSC1i9G7M/tJtQEoglnMd2CXdX4xVOr yHU8ZJBtTHuGiWKwshK55xG96MgSLn2/SwWVSYF69KqDgrwQrCkOyRFxDVnDZ+TmcPs9 4UdZx8pWYDk1lcQj8Eu3XWLWJvqaCGrINjsiF1NLX2IHvIEubvrsv4c3x1XVndjechRE ShAw8OCW6hoTgOyqexpV9/I9jC3q9wJIPmC33HHPUWDg5XXXm5G3Syc0dclO1YEp1gVo Ol8A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=DpIPh7em; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from sourceware.org (server2.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id e14-20020a17090658ce00b007aea5ae39b1si1780366ejs.443.2022.11.11.02.03.30 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 11 Nov 2022 02:03:30 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=DpIPh7em; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 26A6A385842B for ; Fri, 11 Nov 2022 10:03:29 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 26A6A385842B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1668161009; bh=6Fywj9duiS7D7+0wIvI00CN4r5sNhGRRL2plIBvY0B4=; h=Date:To:Cc:Subject:References:In-Reply-To:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=DpIPh7em44rcDe5gTG1Wh8pK2+TFd7IfIdldbHZ/XFaoHvoWf/yq2QN1bg0ih7j+X HsrAKZn+TszpwF1fEci4C4QUvYBeSYxM+ZeThQmP7GA7oHHyQAFOZNY41tFSWq0QXy j8oUDszos+xfoBloCmrTlpwY8kU6HGC9opheuIkY= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 7978F3858C5E for ; Fri, 11 Nov 2022 10:01:43 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 7978F3858C5E Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-161-9w0Wyb_8MIqu3khcCCAzSQ-1; Fri, 11 Nov 2022 05:01:40 -0500 X-MC-Unique: 9w0Wyb_8MIqu3khcCCAzSQ-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.rdu2.redhat.com [10.11.54.2]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id A50C2101A528 for ; Fri, 11 Nov 2022 10:01:40 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.39.192.38]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 7427940C958D; Fri, 11 Nov 2022 10:01:39 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.17.1/8.17.1) with ESMTPS id 2ABA1aGT3250127 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Fri, 11 Nov 2022 11:01:37 +0100 Received: (from jakub@localhost) by tucnak.zalov.cz (8.17.1/8.17.1/Submit) id 2ABA1aet3250126; Fri, 11 Nov 2022 11:01:36 +0100 Date: Fri, 11 Nov 2022 11:01:35 +0100 To: Aldy Hernandez Cc: gcc-patches@gcc.gnu.org Subject: [PATCH] range-op: Cleanup floating point multiplication and division fold_range [PR107569] Message-ID: References: <7304acea-b8bb-c930-546a-db6e3b3ff96b@redhat.com> MIME-Version: 1.0 In-Reply-To: X-Scanned-By: MIMEDefang 3.1 on 10.11.54.2 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-3.5 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jakub Jelinek via Gcc-patches From: Jakub Jelinek Reply-To: Jakub Jelinek Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1749193599505677864?= X-GMAIL-MSGID: =?utf-8?q?1749193599505677864?= On Fri, Nov 11, 2022 at 09:52:53AM +0100, Jakub Jelinek via Gcc-patches wrote: > Ok, here is the patch rewritten in the foperator_div style, with special > cases handled first and then the ordinary cases without problematic cases. > I guess if/once we have a plugin testing infrastructure, we could compare > the two versions of the patch, I think this one is more precise. > And, admittedly there are many similar spots with the foperator_div case > (but also with significant differences), so perhaps if foperator_{mult,div} > inherit from some derived class from range_operator_float and that class > would define various smaller helper static? methods, like this > discussed in the PR - contains_zero_p, singleton_nan_p, zero_p, > that > + bool must_have_signbit_zero = false; > + bool must_have_signbit_nonzero = false; > + if (real_isneg (&lh_lb) == real_isneg (&lh_ub) > + && real_isneg (&rh_lb) == real_isneg (&rh_ub)) > + { > + if (real_isneg (&lh_lb) == real_isneg (&rh_ub)) > + must_have_signbit_zero = true; > + else > + must_have_signbit_nonzero = true; > + } > returned as -1/0/1 int, and those set result (based on the above value) to > [+INF, +INF], [-INF, -INF] or [-INF, +INF] > or > [+0, +0], [-0, -0] or [-0, +0] > or > [+0, +INF], [-INF, -0] or [-INF, +INF] > and the > + for (int i = 1; i < 4; ++i) > + { > + if (real_less (&cp[i], &cp[0]) > + || (real_iszero (&cp[0]) && real_isnegzero (&cp[i]))) > + std::swap (cp[i], cp[0]); > + if (real_less (&cp[4], &cp[i + 4]) > + || (real_isnegzero (&cp[4]) && real_iszero (&cp[i + 4]))) > + std::swap (cp[i + 4], cp[4]); > + } > block, it could be smaller and more readable. Here is an incremental patch on top of this and division patch, which does that. 2022-11-11 Jakub Jelinek PR tree-optimization/107569 * range-op-float.cc (foperator_mult_div_base): New class. (foperator_mult, foperator_div): Derive from that and use protected static methods from it to simplify the code. Jakub --- gcc/range-op-float.cc.jj 2022-11-11 10:13:30.879410560 +0100 +++ gcc/range-op-float.cc 2022-11-11 10:55:57.602617289 +0100 @@ -1911,7 +1911,125 @@ class foperator_minus : public range_ope } fop_minus; -class foperator_mult : public range_operator_float +class foperator_mult_div_base : public range_operator_float +{ +protected: + // True if [lb, ub] is [+-0, +-0]. + static bool zero_p (const REAL_VALUE_TYPE &lb, + const REAL_VALUE_TYPE &ub) + { + return real_iszero (&lb) && real_iszero (&ub); + } + + // True if +0 or -0 is in [lb, ub] range. + static bool contains_zero_p (const REAL_VALUE_TYPE &lb, + const REAL_VALUE_TYPE &ub) + { + return (real_compare (LE_EXPR, &lb, &dconst0) + && real_compare (GE_EXPR, &ub, &dconst0)); + } + + // True if [lb, ub] is [-INF, -INF] or [+INF, +INF]. + static bool singleton_inf_p (const REAL_VALUE_TYPE &lb, + const REAL_VALUE_TYPE &ub) + { + return real_isinf (&lb) && real_isinf (&ub, real_isneg (&lb)); + } + + // Return -1 if binary op result must have sign bit set, + // 1 if binary op result must have sign bit clear, + // 0 otherwise. + // Sign bit of binary op result is exclusive or of the + // operand's sign bits. + static int signbit_known_p (const REAL_VALUE_TYPE &lh_lb, + const REAL_VALUE_TYPE &lh_ub, + const REAL_VALUE_TYPE &rh_lb, + const REAL_VALUE_TYPE &rh_ub) + { + if (real_isneg (&lh_lb) == real_isneg (&lh_ub) + && real_isneg (&rh_lb) == real_isneg (&rh_ub)) + { + if (real_isneg (&lh_lb) == real_isneg (&rh_ub)) + return 1; + else + return -1; + } + return 0; + } + + // Set [lb, ub] to [-0, -0], [-0, +0] or [+0, +0] depending on + // signbit_known. + static void zero_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, + int signbit_known) + { + ub = lb = dconst0; + if (signbit_known <= 0) + lb = real_value_negate (&dconst0); + if (signbit_known < 0) + ub = lb; + } + + // Set [lb, ub] to [-INF, -INF], [-INF, +INF] or [+INF, +INF] depending on + // signbit_known. + static void inf_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, + int signbit_known) + { + if (signbit_known > 0) + ub = lb = dconstinf; + else if (signbit_known < 0) + ub = lb = dconstninf; + else + { + lb = dconstninf; + ub = dconstinf; + } + } + + // Set [lb, ub] to [-INF, -0], [-INF, +INF] or [+0, +INF] depending on + // signbit_known. + static void zero_to_inf_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, + int signbit_known) + { + if (signbit_known > 0) + { + lb = dconst0; + ub = dconstinf; + } + else if (signbit_known < 0) + { + lb = dconstninf; + ub = real_value_negate (&dconst0); + } + else + { + lb = dconstninf; + ub = dconstinf; + } + } + + // 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 { void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, bool &maybe_nan, tree type, @@ -1934,14 +2052,8 @@ class foperator_mult : public range_oper if (!is_square) { // [+-0, +-0] * [+INF,+INF] (or [-INF,-INF] or swapped is a known NAN. - if ((real_iszero (&lh_lb) - && real_iszero (&lh_ub) - && real_isinf (&rh_lb) - && real_isinf (&rh_ub, real_isneg (&rh_lb))) - || (real_iszero (&rh_lb) - && real_iszero (&rh_ub) - && real_isinf (&lh_lb) - && real_isinf (&lh_ub, real_isneg (&lh_lb)))) + 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; @@ -1951,70 +2063,28 @@ class foperator_mult : public range_oper // Otherwise, if one range includes zero and the other ends with +-INF, // it is a maybe NAN. - if ((real_compare (LE_EXPR, &lh_lb, &dconst0) - && real_compare (GE_EXPR, &lh_ub, &dconst0) + if ((contains_zero_p (lh_lb, lh_ub) && (real_isinf (&rh_lb) || real_isinf (&rh_ub))) - || (real_compare (LE_EXPR, &rh_lb, &dconst0) - && real_compare (GE_EXPR, &rh_ub, &dconst0) + || (contains_zero_p (rh_lb, rh_ub) && (real_isinf (&lh_lb) || real_isinf (&lh_ub)))) { maybe_nan = true; - bool must_have_signbit_zero = false; - bool must_have_signbit_nonzero = false; - if (real_isneg (&lh_lb) == real_isneg (&lh_ub) - && real_isneg (&rh_lb) == real_isneg (&rh_ub)) - { - if (real_isneg (&lh_lb) == real_isneg (&rh_ub)) - must_have_signbit_zero = true; - else - must_have_signbit_nonzero = 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 ((real_isinf (&lh_lb) - && real_isinf (&lh_ub, real_isneg (&lh_lb))) - || (real_isinf (&rh_lb) - && real_isinf (&rh_ub, real_isneg (&rh_lb)))) - { - // If all the boundary signs are the same, [+INF, +INF]. - if (must_have_signbit_zero) - ub = lb = dconstinf; - // If the two multiplicands have always different sign, - // [-INF, -INF]. - else if (must_have_signbit_nonzero) - ub = lb = dconstninf; - // Otherwise -> [-INF, +INF] (-INF or +INF). - else - { - lb = dconstninf; - ub = dconstinf; - } - return; - } + 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 ((real_iszero (&lh_lb) && real_iszero (&lh_ub)) - || (real_iszero (&rh_lb) && real_iszero (&rh_ub))) - { - ub = lb = dconst0; - // If all the boundary signs are the same, [+0.0, +0.0]. - if (must_have_signbit_zero) - ; - // If divisor and dividend must have different signs, - // [-0.0, -0.0]. - else if (must_have_signbit_nonzero) - ub = lb = real_value_negate (&dconst0); - // Otherwise -> [-0.0, +0.0]. - else - lb = real_value_negate (&dconst0); - return; - } + 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] @@ -2022,27 +2092,13 @@ class foperator_mult : public range_oper // 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. - if (must_have_signbit_zero) - { - lb = dconst0; - ub = dconstinf; - } - else if (must_have_signbit_nonzero) - { - lb = dconstninf; - ub = real_value_negate (&dconst0); - } - else - { - lb = dconstninf; - ub = dconstinf; - } - return; + return zero_to_inf_range (lb, ub, signbit_known); } } REAL_VALUE_TYPE cp[8]; - // Do a cross-product. + // 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) @@ -2052,9 +2108,13 @@ class foperator_mult : public range_oper // 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 (real_compare (LE_EXPR, &lh_lb, &dconst0) - && real_compare (GE_EXPR, &lh_ub, &dconst0)) - cp[1] = real_value_negate (&dconst0); + if (contains_zero_p (lh_lb, lh_ub)) + { + if (real_isneg (&lh_lb) == real_isneg (&lh_ub)) + cp[1] = dconst0; + else + cp[1] = real_value_negate (&dconst0); + } else cp[1] = cp[0]; cp[2] = cp[0]; @@ -2071,22 +2131,12 @@ class foperator_mult : public range_oper frange_arithmetic (MULT_EXPR, type, cp[3], lh_ub, rh_ub, dconstninf); frange_arithmetic (MULT_EXPR, type, cp[7], lh_ub, rh_ub, dconstinf); - for (int i = 1; i < 4; ++i) - { - if (real_less (&cp[i], &cp[0]) - || (real_iszero (&cp[0]) && real_isnegzero (&cp[i]))) - std::swap (cp[i], cp[0]); - if (real_less (&cp[4], &cp[i + 4]) - || (real_isnegzero (&cp[4]) && real_iszero (&cp[i + 4]))) - std::swap (cp[i + 4], cp[4]); - } - lb = cp[0]; - ub = cp[4]; - + find_range (lb, ub, cp); } } fop_mult; -class foperator_div : public range_operator_float + +class foperator_div : public foperator_mult_div_base { void rv_fold (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, bool &maybe_nan, tree type, @@ -2097,14 +2147,8 @@ class foperator_div : public range_opera relation_kind) const final override { // +-0.0 / +-0.0 or +-INF / +-INF is a known NAN. - if ((real_iszero (&lh_lb) - && real_iszero (&lh_ub) - && real_iszero (&rh_lb) - && real_iszero (&rh_ub)) - || (real_isinf (&lh_lb) - && real_isinf (&lh_ub, real_isneg (&lh_lb)) - && real_isinf (&rh_lb) - && real_isinf (&rh_ub, real_isneg (&rh_lb)))) + if ((zero_p (lh_lb, lh_ub) && zero_p (rh_lb, rh_ub)) + || (singleton_inf_p (lh_lb, lh_ub) || singleton_inf_p (rh_lb, rh_ub))) { real_nan (&lb, "", 0, TYPE_MODE (type)); ub = lb; @@ -2112,84 +2156,31 @@ class foperator_div : public range_opera return; } - bool both_maybe_zero = false; - bool both_maybe_inf = false; - bool must_have_signbit_zero = false; - bool must_have_signbit_nonzero = false; - // If +-0.0 is in both ranges, it is a maybe NAN. - if (real_compare (LE_EXPR, &lh_lb, &dconst0) - && real_compare (GE_EXPR, &lh_ub, &dconst0) - && real_compare (LE_EXPR, &rh_lb, &dconst0) - && real_compare (GE_EXPR, &rh_ub, &dconst0)) - { - both_maybe_zero = true; - maybe_nan = true; - } + if (contains_zero_p (lh_lb, lh_ub) && contains_zero_p (rh_lb, rh_ub)) + maybe_nan = true; // If +-INF is in both ranges, it is a maybe NAN. else if ((real_isinf (&lh_lb) || real_isinf (&lh_ub)) && (real_isinf (&rh_lb) || real_isinf (&rh_ub))) - { - both_maybe_inf = true; - maybe_nan = true; - } + maybe_nan = true; else maybe_nan = false; - if (real_isneg (&lh_lb) == real_isneg (&lh_ub) - && real_isneg (&rh_lb) == real_isneg (&rh_ub)) - { - if (real_isneg (&lh_lb) == real_isneg (&rh_ub)) - must_have_signbit_zero = true; - else - must_have_signbit_nonzero = true; - } + int signbit_known = signbit_known_p (lh_lb, lh_ub, rh_lb, rh_ub); // If dividend must be zero, the range is just +-0 // (including if the divisor is +-INF). // If divisor must be +-INF, the range is just +-0 // (including if the dividend is zero). - if ((real_iszero (&lh_lb) && real_iszero (&lh_ub)) - || real_isinf (&rh_lb, false) - || real_isinf (&rh_ub, true)) - { - ub = lb = dconst0; - // If all the boundary signs are the same, [+0.0, +0.0]. - if (must_have_signbit_zero) - ; - // If divisor and dividend must have different signs, - // [-0.0, -0.0]. - else if (must_have_signbit_nonzero) - ub = lb = real_value_negate (&dconst0); - // Otherwise -> [-0.0, +0.0]. - else - lb = real_value_negate (&dconst0); - return; - } + if (zero_p (lh_lb, lh_ub) || singleton_inf_p (rh_lb, rh_ub)) + return zero_range (lb, ub, signbit_known); // If divisor must be zero, the range is just +-INF // (including if the dividend is +-INF). // If dividend must be +-INF, the range is just +-INF // (including if the dividend is zero). - if ((real_iszero (&rh_lb) && real_iszero (&rh_ub)) - || real_isinf (&lh_lb, false) - || real_isinf (&lh_ub, true)) - { - // If all the boundary signs are the same, [+INF, +INF]. - if (must_have_signbit_zero) - ub = lb = dconstinf; - // If divisor and dividend must have different signs, - // [-INF, -INF]. - else if (must_have_signbit_nonzero) - ub = lb = dconstninf; - // Otherwise -> [-INF, +INF] (-INF or +INF). - else - { - lb = dconstninf; - ub = dconstinf; - } - return; - } + if (zero_p (rh_lb, rh_ub) || singleton_inf_p (lh_lb, lh_ub)) + return inf_range (lb, ub, signbit_known); // Otherwise if both operands may be zero, divisor could be // nextafter(0.0, +-1.0) and dividend +-0.0 @@ -2204,30 +2195,12 @@ class foperator_div : public range_opera // signs of divisor and dividend are always the same we have // [+0.0, +INF], if they are always different we have // [-INF, -0.0]. If they vary, VARYING. - if (both_maybe_zero || both_maybe_inf) - { - if (must_have_signbit_zero) - { - lb = dconst0; - ub = dconstinf; - } - else if (must_have_signbit_nonzero) - { - lb = dconstninf; - ub = real_value_negate (&dconst0); - } - else - { - lb = dconstninf; - ub = dconstinf; - } - return; - } + if (maybe_nan) + return zero_to_inf_range (lb, ub, signbit_known); REAL_VALUE_TYPE cp[8]; // Do a cross-division. At this point none of the divisions should // produce a NAN. - gcc_assert (!maybe_nan); frange_arithmetic (RDIV_EXPR, type, cp[0], lh_lb, rh_lb, dconstninf); frange_arithmetic (RDIV_EXPR, type, cp[1], lh_lb, rh_ub, dconstninf); frange_arithmetic (RDIV_EXPR, type, cp[2], lh_ub, rh_lb, dconstninf); @@ -2237,27 +2210,16 @@ class foperator_div : public range_opera frange_arithmetic (RDIV_EXPR, type, cp[6], lh_ub, rh_lb, dconstinf); frange_arithmetic (RDIV_EXPR, type, cp[7], lh_ub, rh_ub, dconstinf); - for (int i = 1; i < 4; ++i) - { - if (real_less (&cp[i], &cp[0]) - || (real_iszero (&cp[0]) && real_isnegzero (&cp[i]))) - std::swap (cp[i], cp[0]); - if (real_less (&cp[4], &cp[i + 4]) - || (real_isnegzero (&cp[4]) && real_iszero (&cp[i + 4]))) - std::swap (cp[i + 4], cp[4]); - } - lb = cp[0]; - ub = cp[4]; + find_range (lb, ub, cp); // If divisor may be zero (but is not known to be only zero), // and dividend can't be zero, the range can go up to -INF or +INF // depending on the signs. - if (real_compare (LE_EXPR, &rh_lb, &dconst0) - && real_compare (GE_EXPR, &rh_ub, &dconst0)) + if (contains_zero_p (rh_lb, rh_ub)) { - if (!must_have_signbit_zero) + if (signbit_known <= 0) real_inf (&lb, true); - if (!must_have_signbit_nonzero) + if (signbit_known >= 0) real_inf (&ub, false); } }