Handle constant folding arithmetic involving infinity

src/compiler/translator/ConstantUnion.cpp

@@ -7,7 +7,6 @@
 
 #include "compiler/translator/ConstantUnion.h"
 
-#include "base/numerics/safe_math.h"
 #include "common/mathutil.h"
 #include "compiler/translator/Diagnostics.h"
 
@@ -17,52 +16,46 @@ namespace sh
 namespace
 {
 
-template <typename T>
-T CheckedSum(base::CheckedNumeric<T> lhs,
-             base::CheckedNumeric<T> rhs,
-             TDiagnostics *diag,
-             const TSourceLoc &line)
+float CheckedSum(float lhs, float rhs, TDiagnostics *diag, const TSourceLoc &line)
 {
-    ASSERT(lhs.IsValid() && rhs.IsValid());
-    auto result = lhs + rhs;
-    if (!result.IsValid())
+    float result = lhs + rhs;
+    if (gl::isNaN(result) && !gl::isNaN(lhs) && !gl::isNaN(rhs))
     {
-        diag->error(line, "Addition out of range", "*", "");
-        return 0;
+        diag->warning(line, "Constant folded undefined addition generated NaN", "+", "");
     }
-    return result.ValueOrDefault(0);
+    else if (gl::isInf(result) && !gl::isInf(lhs) && !gl::isInf(rhs))
+    {
+        diag->warning(line, "Constant folded addition overflowed to infinity", "+", "");
+    }
+    return result;
 }
 
-template <typename T>
-T CheckedDiff(base::CheckedNumeric<T> lhs,
-              base::CheckedNumeric<T> rhs,
-              TDiagnostics *diag,
-              const TSourceLoc &line)
+float CheckedDiff(float lhs, float rhs, TDiagnostics *diag, const TSourceLoc &line)
 {
-    ASSERT(lhs.IsValid() && rhs.IsValid());
-    auto result = lhs - rhs;
-    if (!result.IsValid())
+    float result = lhs - rhs;
+    if (gl::isNaN(result) && !gl::isNaN(lhs) && !gl::isNaN(rhs))
+    {
+        diag->warning(line, "Constant folded undefined subtraction generated NaN", "-", "");
+    }
+    else if (gl::isInf(result) && !gl::isInf(lhs) && !gl::isInf(rhs))
     {
-        diag->error(line, "Difference out of range", "*", "");
-        return 0;
+        diag->warning(line, "Constant folded subtraction overflowed to infinity", "-", "");
     }
-    return result.ValueOrDefault(0);
+    return result;
 }
 
-template <typename T>
-T CheckedMul(base::CheckedNumeric<T> lhs,
-             base::CheckedNumeric<T> rhs,
-             TDiagnostics *diag,
-             const TSourceLoc &line)
+float CheckedMul(float lhs, float rhs, TDiagnostics *diag, const TSourceLoc &line)
 {
-    ASSERT(lhs.IsValid() && rhs.IsValid());
-    auto result = lhs * rhs;
-    if (!result.IsValid())
+    float result = lhs * rhs;
+    if (gl::isNaN(result) && !gl::isNaN(lhs) && !gl::isNaN(rhs))
+    {
+        diag->warning(line, "Constant folded undefined multiplication generated NaN", "*", "");
+    }
+    else if (gl::isInf(result) && !gl::isInf(lhs) && !gl::isInf(rhs))
     {
-        diag->error(line, "Multiplication out of range", "*", "");
-        return 0;
+        diag->warning(line, "Constant folded multiplication overflowed to infinity", "*", "");
     }
-    return result.ValueOrDefault(0);
+    return result;
 }
 
 }  // anonymous namespace
@@ -293,7 +286,7 @@ TConstantUnion TConstantUnion::add(const TConstantUnion &lhs,
             returnValue.setUConst(gl::WrappingSum<unsigned int>(lhs.uConst, rhs.uConst));
             break;
         case EbtFloat:
-            returnValue.setFConst(CheckedSum<float>(lhs.fConst, rhs.fConst, diag, line));
+            returnValue.setFConst(CheckedSum(lhs.fConst, rhs.fConst, diag, line));
             break;
         default:
             UNREACHABLE();
@@ -319,7 +312,7 @@ TConstantUnion TConstantUnion::sub(const TConstantUnion &lhs,
             returnValue.setUConst(gl::WrappingDiff<unsigned int>(lhs.uConst, rhs.uConst));
             break;
         case EbtFloat:
-            returnValue.setFConst(CheckedDiff<float>(lhs.fConst, rhs.fConst, diag, line));
+            returnValue.setFConst(CheckedDiff(lhs.fConst, rhs.fConst, diag, line));
             break;
         default:
             UNREACHABLE();
@@ -347,7 +340,7 @@ TConstantUnion TConstantUnion::mul(const TConstantUnion &lhs,
             returnValue.setUConst(lhs.uConst * rhs.uConst);
             break;
         case EbtFloat:
-            returnValue.setFConst(CheckedMul<float>(lhs.fConst, rhs.fConst, diag, line));
+            returnValue.setFConst(CheckedMul(lhs.fConst, rhs.fConst, diag, line));
             break;
         default:
             UNREACHABLE();

src/compiler/translator/IntermNode.cpp

@@ -1312,19 +1312,51 @@ TConstantUnion *TIntermConstantUnion::foldBinary(TOperator op,
                 switch (getType().getBasicType())
                 {
                   case EbtFloat:
-                    if (rightArray[i] == 0.0f)
-                    {
-                        diagnostics->warning(
-                            getLine(), "Divide by zero error during constant folding", "/", "");
-                        resultArray[i].setFConst(leftArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX);
-                    }
-                    else
-                    {
-                        ASSERT(op == EOpDiv);
-                        resultArray[i].setFConst(leftArray[i].getFConst() / rightArray[i].getFConst());
-                    }
-                    break;
-
+                  {
+                      ASSERT(op == EOpDiv);
+                      float dividend = leftArray[i].getFConst();
+                      float divisor  = rightArray[i].getFConst();
+                      if (divisor == 0.0f)
+                      {
+                          if (dividend == 0.0f)
+                          {
+                              diagnostics->warning(
+                                  getLine(),
+                                  "Zero divided by zero during constant folding generated NaN", "/",
+                                  "");
+                              resultArray[i].setFConst(std::numeric_limits<float>::quiet_NaN());
+                          }
+                          else
+                          {
+                              diagnostics->warning(
+                                  getLine(), "Divide by zero during constant folding", "/", "");
+                              bool negativeResult = std::signbit(dividend) != std::signbit(divisor);
+                              resultArray[i].setFConst(
+                                  negativeResult ? -std::numeric_limits<float>::infinity()
+                                                 : std::numeric_limits<float>::infinity());
+                          }
+                      }
+                      else if (gl::isInf(dividend) && gl::isInf(divisor))
+                      {
+                          diagnostics->warning(
+                              getLine(),
+                              "Infinity divided by infinity during constant folding generated NaN",
+                              "/", "");
+                          resultArray[i].setFConst(std::numeric_limits<float>::quiet_NaN());
+                      }
+                      else
+                      {
+                          float result = dividend / divisor;
+                          if (!gl::isInf(dividend) && gl::isInf(result))
+                          {
+                              diagnostics->warning(
+                                  getLine(), "Constant folded division overflowed to infinity", "/",
+                                  "");
+                          }
+                          resultArray[i].setFConst(result);
+                      }
+                      break;
+                  }
                   case EbtInt:
                     if (rightArray[i] == 0)
                     {

src/tests/angle_unittests.gypi

@@ -46,6 +46,8 @@
             '<(angle_path)/src/tests/compiler_tests/API_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/CollectVariables_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ConstantFolding_test.cpp',
+            '<(angle_path)/src/tests/compiler_tests/ConstantFoldingNaN_test.cpp',
+            '<(angle_path)/src/tests/compiler_tests/ConstantFoldingOverflow_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/ConstructCompiler_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/DebugShaderPrecision_test.cpp',
             '<(angle_path)/src/tests/compiler_tests/EmulateGLFragColorBroadcast_test.cpp',

src/tests/compiler_tests/ConstantFoldingNaN_test.cpp

+//
+// Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ConstantFoldingNaN_test.cpp:
+//   Tests for constant folding that results in NaN according to IEEE and should also generate a
+//   warning. The ESSL spec does not mandate generating NaNs, but this is reasonable behavior in
+//   this case.
+//
+
+#include "tests/test_utils/ConstantFoldingTest.h"
+
+using namespace sh;
+
+namespace
+{
+
+class ConstantFoldingNaNExpressionTest : public ConstantFoldingExpressionTest
+{
+  public:
+    ConstantFoldingNaNExpressionTest() {}
+
+    void evaluateFloatNaN(const std::string &floatString)
+    {
+        evaluateFloat(floatString);
+        ASSERT_TRUE(constantFoundInAST(std::numeric_limits<float>::quiet_NaN()));
+        ASSERT_TRUE(hasWarning());
+    }
+};
+
+}  // anonymous namespace
+
+// Test that infinity - infinity evaluates to NaN.
+TEST_F(ConstantFoldingNaNExpressionTest, FoldInfinityMinusInfinity)
+{
+    const std::string &floatString = "1.0e2048 - 1.0e2048";
+    evaluateFloatNaN(floatString);
+}
+
+// Test that infinity + negative infinity evaluates to NaN.
+TEST_F(ConstantFoldingNaNExpressionTest, FoldInfinityPlusNegativeInfinity)
+{
+    const std::string &floatString = "1.0e2048 + (-1.0e2048)";
+    evaluateFloatNaN(floatString);
+}
+
+// Test that infinity multiplied by zero evaluates to NaN.
+TEST_F(ConstantFoldingNaNExpressionTest, FoldInfinityMultipliedByZero)
+{
+    const std::string &floatString = "1.0e2048 * 0.0";
+    evaluateFloatNaN(floatString);
+}
+
+// Test that infinity divided by infinity evaluates to NaN.
+TEST_F(ConstantFoldingNaNExpressionTest, FoldInfinityDividedByInfinity)
+{
+    const std::string &floatString = "1.0e2048 / 1.0e2048";
+    evaluateFloatNaN(floatString);
+}
+
+// Test that zero divided by zero evaluates to NaN.
+TEST_F(ConstantFoldingNaNExpressionTest, FoldZeroDividedByZero)
+{
+    const std::string &floatString = "0.0 / 0.0";
+    evaluateFloatNaN(floatString);
+}

src/tests/compiler_tests/ConstantFoldingOverflow_test.cpp

+//
+// Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ConstantFoldingOverflow_test.cpp:
+//   Tests for constant folding that results in floating point overflow.
+//   In IEEE floating point, the overflow result depends on which of the various rounding modes is
+//   chosen - it's either the maximum representable value or infinity.
+//   ESSL 3.00.6 section 4.5.1 says that the rounding mode cannot be set and is undefined, so the
+//   result in this case is not defined by the spec.
+//   We decide to overflow to infinity and issue a warning.
+//
+
+#include "tests/test_utils/ConstantFoldingTest.h"
+
+using namespace sh;
+
+namespace
+{
+
+class ConstantFoldingOverflowExpressionTest : public ConstantFoldingExpressionTest
+{
+  public:
+    ConstantFoldingOverflowExpressionTest() {}
+
+    void evaluateFloatOverflow(const std::string &floatString, bool positive)
+    {
+        evaluateFloat(floatString);
+        float expected = positive ? std::numeric_limits<float>::infinity()
+                                  : -std::numeric_limits<float>::infinity();
+        ASSERT_TRUE(constantFoundInAST(expected));
+        ASSERT_TRUE(hasWarning());
+    }
+};
+
+}  // anonymous namespace
+
+// Test that addition that overflows is evaluated correctly.
+TEST_F(ConstantFoldingOverflowExpressionTest, Add)
+{
+    const std::string &floatString = "2.0e38 + 2.0e38";
+    evaluateFloatOverflow(floatString, true);
+}
+
+// Test that subtraction that overflows is evaluated correctly.
+TEST_F(ConstantFoldingOverflowExpressionTest, Subtract)
+{
+    const std::string &floatString = "2.0e38 - (-2.0e38)";
+    evaluateFloatOverflow(floatString, true);
+}
+
+// Test that multiplication that overflows is evaluated correctly.
+TEST_F(ConstantFoldingOverflowExpressionTest, Multiply)
+{
+    const std::string &floatString = "1.0e30 * 1.0e10";
+    evaluateFloatOverflow(floatString, true);
+}
+
+// Test that division that overflows is evaluated correctly.
+TEST_F(ConstantFoldingOverflowExpressionTest, Divide)
+{
+    const std::string &floatString = "1.0e30 / 1.0e-10";
+    evaluateFloatOverflow(floatString, true);
+}

src/tests/compiler_tests/ConstantFolding_test.cpp

@@ -1158,3 +1158,89 @@ TEST_F(ConstantFoldingExpressionTest, FoldFaceForwardInfinity2)
     evaluateFloat(floatString);
     ASSERT_TRUE(constantFoundInAST(-4.0f));
 }
+
+// Test that infinity - finite value evaluates to infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldInfinityMinusFinite)
+{
+    const std::string &floatString = "1.0e2048 - 1.0e20";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(std::numeric_limits<float>::infinity()));
+}
+
+// Test that -infinity + finite value evaluates to -infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldMinusInfinityPlusFinite)
+{
+    const std::string &floatString = "(-1.0e2048) + 1.0e20";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(-std::numeric_limits<float>::infinity()));
+}
+
+// Test that infinity * finite value evaluates to infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldInfinityMultipliedByFinite)
+{
+    const std::string &floatString = "1.0e2048 * 1.0e-20";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(std::numeric_limits<float>::infinity()));
+}
+
+// Test that infinity * infinity evaluates to infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldInfinityMultipliedByInfinity)
+{
+    const std::string &floatString = "1.0e2048 * 1.0e2048";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(std::numeric_limits<float>::infinity()));
+}
+
+// Test that infinity * negative infinity evaluates to negative infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldInfinityMultipliedByNegativeInfinity)
+{
+    const std::string &floatString = "1.0e2048 * (-1.0e2048)";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(-std::numeric_limits<float>::infinity()));
+}
+
+// Test that dividing by minus zero results in the appropriately signed infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+// "If both positive and negative zeros are implemented, the correctly signed Inf will be
+// generated".
+TEST_F(ConstantFoldingExpressionTest, FoldDivideByNegativeZero)
+{
+    const std::string &floatString = "1.0 / (-0.0)";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(-std::numeric_limits<float>::infinity()));
+    ASSERT_TRUE(hasWarning());
+}
+
+// Test that infinity divided by zero evaluates to infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldInfinityDividedByZero)
+{
+    const std::string &floatString = "1.0e2048 / 0.0";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(std::numeric_limits<float>::infinity()));
+    ASSERT_TRUE(hasWarning());
+}
+
+// Test that negative infinity divided by zero evaluates to negative infinity.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldMinusInfinityDividedByZero)
+{
+    const std::string &floatString = "(-1.0e2048) / 0.0";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(-std::numeric_limits<float>::infinity()));
+    ASSERT_TRUE(hasWarning());
+}
+
+// Test that dividing a finite number by infinity results in zero.
+// ESSL 3.00.6 section 4.5.1: "Infinities and zeroes are generated as dictated by IEEE".
+TEST_F(ConstantFoldingExpressionTest, FoldDivideByInfinity)
+{
+    const std::string &floatString = "1.0e30 / 1.0e2048";
+    evaluateFloat(floatString);
+    ASSERT_TRUE(constantFoundInAST(0.0f));
+}

src/tests/test_utils/ConstantFoldingTest.cpp

@@ -45,6 +45,12 @@ void ConstantFoldingTest::compile(const std::string &shaderString)
     }
 }
 
+bool ConstantFoldingTest::hasWarning()
+{
+    TInfoSink &infoSink = mTranslatorESSL->getInfoSink();
+    return infoSink.info.str().find("WARNING:") != std::string::npos;
+}
+
 void ConstantFoldingExpressionTest::evaluateFloat(const std::string &floatExpression)
 {
     std::stringstream shaderStream;

src/tests/test_utils/ConstantFoldingTest.h

@@ -85,6 +85,11 @@ class ConstantFinder : public TIntermTraverser
         {
             return gl::isInf(node.getFConst()) && node.getFConst() < 0;
         }
+        else if (gl::isNaN(value))
+        {
+            // All NaNs are treated as equal.
+            return gl::isNaN(node.getFConst());
+        }
         return mFaultTolerance >= fabsf(node.getFConst() - value);
     }
 
@@ -139,6 +144,9 @@ class ConstantFoldingTest : public testing::Test
 
     void compile(const std::string &shaderString);
 
+    // Must be called after compile()
+    bool hasWarning();
+
     template <typename T>
     bool constantFoundInAST(T constant)
     {