kc3-lang/angle/src/tests/compiler_tests/ConstantFoldingNaN_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/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);
  }
  

Download