From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <gcc-bugzilla@gcc.gnu.org>
Received: by sourceware.org (Postfix, from userid 48)
	id 0177F3959CB4; Tue,  6 Dec 2022 09:57:47 +0000 (GMT)
DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0177F3959CB4
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org;
	s=default; t=1670320667;
	bh=wmLryNUnWJywHO026XqqYCqiQGeBEpLQBgHrvLKdl1Q=;
	h=From:To:Subject:Date:In-Reply-To:References:From;
	b=c680GvDHsqsdiESBAiA2hCKVY5qqzYDNWTHr0HpI4G4uHLmrXSqGRNuXPul4s5bOA
	 kfteB2j7Wvgdmg6i5MuIFkRRJfETs+O+ehMBXx8xTNFjO8eogbStVa8U7DQAb3gPvL
	 Qtd2xu5aNcBG37FV7KKC9snz+k7OSqRoe+WKaTok=
From: "jakub at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>
To: gcc-bugs@gcc.gnu.org
Subject: [Bug tree-optimization/107972] backward propagation of finite
 property not performed
Date: Tue, 06 Dec 2022 09:57:45 +0000
X-Bugzilla-Reason: CC
X-Bugzilla-Type: changed
X-Bugzilla-Watch-Reason: None
X-Bugzilla-Product: gcc
X-Bugzilla-Component: tree-optimization
X-Bugzilla-Version: 13.0
X-Bugzilla-Keywords: missed-optimization
X-Bugzilla-Severity: normal
X-Bugzilla-Who: jakub at gcc dot gnu.org
X-Bugzilla-Status: UNCONFIRMED
X-Bugzilla-Resolution: 
X-Bugzilla-Priority: P3
X-Bugzilla-Assigned-To: unassigned at gcc dot gnu.org
X-Bugzilla-Target-Milestone: ---
X-Bugzilla-Flags: 
X-Bugzilla-Changed-Fields: cc
Message-ID: <bug-107972-4-uhUHPhOAw0@http.gcc.gnu.org/bugzilla/>
In-Reply-To: <bug-107972-4@http.gcc.gnu.org/bugzilla/>
References: <bug-107972-4@http.gcc.gnu.org/bugzilla/>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Bugzilla-URL: http://gcc.gnu.org/bugzilla/
Auto-Submitted: auto-generated
MIME-Version: 1.0
List-Id: <gcc-bugs.sourceware.org>

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=3D107972

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |amacleod at redhat dot com

--- Comment #3 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
The backwards propagation fixed, but neither:
double
foo (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a + b;
  if (!__builtin_isfinite (res))
    __builtin_unreachable ();
  return res;
}

double
bar (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a - b;
  if (!__builtin_isfinite (res))
    __builtin_unreachable ();
  return res;
}

double
baz (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a * b;
  if (!__builtin_isfinite (res))
    __builtin_unreachable ();
  return res;
}

double
qux (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  double res =3D a / b;
  if (!__builtin_isfinite (res))
    __builtin_unreachable ();
  return res;
}

double
quux (double a, double b)
{
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a / b;
  if (__builtin_isnan (res) || res =3D=3D 0.0)
    __builtin_unreachable ();
  return res;
}
nor
double
foo (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a + b;
  __attribute__((assume (__builtin_isfinite (res))));
  return res;
}

double
bar (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a - b;
  __attribute__((assume (__builtin_isfinite (res))));
  return res;
}

double
baz (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a * b;
  __attribute__((assume (__builtin_isfinite (res))));
  return res;
}

double
qux (double a, double b)
{
  if (!__builtin_isfinite (a))
    return 42.0;
  double res =3D a / b;
  __attribute__((assume (__builtin_isfinite (res))));
  return res;
}

double
quux (double a, double b)
{
  if (!__builtin_isfinite (b))
    return 42.0;
  double res =3D a / b;
  __attribute__((assume (!__builtin_isnan (res) && res !=3D 0.0)));
  return res;
}
avoids the 4.2e+1 cases in the output, because in neither case we properly
determine the ranges of res (that it is in foo/bar/baz/qux [-DBL_MAX,DBL_MA=
X]).
For quux I think we don't have a way to represent that right now, we'd need=
 a
union of 2 ranges and after all, we also flush denormals to zero, so I think
we'd need if (!(res < 1.0)) __builtin_unreachable (); or __attribute__((ass=
ume
(res < 1.0))); so that we get [1.0, +INF] non-NAN range.
Aldy/Andrew, any ideas what's going on?=