kc3-lang/angle/src/tests/compiler_tests/ConstantFoldingOverflow_test.cpp

• Show log

  Commit

• Hash : 2d73665d
  Author :
  Date : 2016-11-30T10:37:49
  

  Handle constant folding arithmetic involving infinity
  
  Constant folding arithmetic operations that involve infinity are now
  handled correctly in the cases where the result is infinity or zero.
  The implementation mostly relies on C++ to implement IEEE float
  arithmetic correctly so that unnecessary overhead is avoided.
  
  Constant folding arithmetic operations that result in overflow now
  issue a warning but result in infinity. This is not mandated by the
  spec but is a reasonable choice since it is the behavior of the
  default IEEE rounding mode.
  
  Constant folding arithmetic operations that result in NaN in IEEE will
  generate a warning but the NaN is kept. This is also not mandated by
  the spec, but is among the allowed behaviors.
  
  There's no special handling for ESSL 1.00. ESSL 1.00 doesn't really
  have the concept of NaN, but since it is not feasible to control
  generating NaNs at shader run time either way, it should not be a big
  issue if constant folding may generate them as well.
  
  TEST=angle_unittests
  BUG=chromium:661857
  
  Change-Id: I06116c6fdd02f224939d4a651e4e62f2fd4c98a8
  Reviewed-on: https://chromium-review.googlesource.com/414911
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• 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);
  }
  

Download