kc3-lang/angle/src/tests/test_utils/ConstantFoldingTest.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/test_utils/ConstantFoldingTest.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.
  //
  // ConstantFoldingTest.cpp:
  //   Utilities for constant folding tests.
  //
  
  #include "tests/test_utils/ConstantFoldingTest.h"
  
  #include "angle_gl.h"
  #include "compiler/translator/TranslatorESSL.h"
  #include "GLSLANG/ShaderLang.h"
  
  using namespace sh;
  
  void ConstantFoldingTest::SetUp()
  {
      allocator.push();
      SetGlobalPoolAllocator(&allocator);
      ShBuiltInResources resources;
      InitBuiltInResources(&resources);
  
      mTranslatorESSL = new TranslatorESSL(GL_FRAGMENT_SHADER, SH_GLES3_SPEC);
      ASSERT_TRUE(mTranslatorESSL->Init(resources));
  }
  
  void ConstantFoldingTest::TearDown()
  {
      delete mTranslatorESSL;
      SetGlobalPoolAllocator(NULL);
      allocator.pop();
  }
  
  void ConstantFoldingTest::compile(const std::string &shaderString)
  {
      const char *shaderStrings[] = {shaderString.c_str()};
  
      mASTRoot = mTranslatorESSL->compileTreeForTesting(shaderStrings, 1, SH_OBJECT_CODE);
      if (!mASTRoot)
      {
          TInfoSink &infoSink = mTranslatorESSL->getInfoSink();
          FAIL() << "Shader compilation into ESSL failed " << infoSink.info.c_str();
      }
  }
  
  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;
      shaderStream << "#version 300 es\n"
                      "precision mediump float;\n"
                      "out float my_FragColor;\n"
                      "void main()\n"
                      "{\n"
                   << "    my_FragColor = " << floatExpression << ";\n"
                   << "}\n";
      compile(shaderStream.str());
  }
  

Download