kc3-lang/angle/src/tests/test_utils/ShaderCompileTreeTest.cpp

• Show log

  Commit

• Hash : cccf2b00
  Author :
  Date : 2017-07-05T14:50:54
  

  Reorganize AST traversal utility code
  
  Define TIntermTraverser and TIntermLValueTrackingTraverser in a
  separate header file. hash() function is moved out from
  TIntermTraverser as it is not related to the core functionality
  of traversing and transforming ASTs.
  
  Also reorganize some traversers to follow common conventions:
  
  - Intermediate output is now in OutputTree.h/.cpp
  - Max tree depth check is now in IsASTDepthBelowLimit.h/.cpp
  
  BUG=angleproject:1490
  TEST=angle_unittests
  
  Change-Id: Id4968aa9d4e24d0c5bac90dc147fc9f310de0184
  Reviewed-on: https://chromium-review.googlesource.com/559531
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/tests/test_utils/ShaderCompileTreeTest.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.
  //
  // ShaderCompileTreeTest.cpp:
  //   Test that shader validation results in the correct compile status.
  //
  
  #include "tests/test_utils/ShaderCompileTreeTest.h"
  
  #include "compiler/translator/IntermTraverse.h"
  #include "compiler/translator/TranslatorESSL.h"
  
  namespace sh
  {
  
  namespace
  {
  
  // Checks that the node traversed is a zero node. It can be made out of multiple constructors and
  // constant union nodes as long as there's no arithmetic involved and all constants are zero.
  class OnlyContainsZeroConstantsTraverser final : public TIntermTraverser
  {
    public:
      OnlyContainsZeroConstantsTraverser()
          : TIntermTraverser(true, false, false), mOnlyContainsConstantZeros(true)
      {
      }
  
      bool visitUnary(Visit, TIntermUnary *node) override
      {
          mOnlyContainsConstantZeros = false;
          return false;
      }
  
      bool visitBinary(Visit, TIntermBinary *node) override
      {
          mOnlyContainsConstantZeros = false;
          return false;
      }
  
      bool visitTernary(Visit, TIntermTernary *node) override
      {
          mOnlyContainsConstantZeros = false;
          return false;
      }
  
      bool visitSwizzle(Visit, TIntermSwizzle *node) override
      {
          mOnlyContainsConstantZeros = false;
          return false;
      }
  
      bool visitAggregate(Visit, TIntermAggregate *node) override
      {
          if (node->getOp() != EOpConstruct)
          {
              mOnlyContainsConstantZeros = false;
              return false;
          }
          return true;
      }
  
      void visitSymbol(TIntermSymbol *node) override { mOnlyContainsConstantZeros = false; }
  
      void visitConstantUnion(TIntermConstantUnion *node) override
      {
          if (!mOnlyContainsConstantZeros)
          {
              return;
          }
  
          const TType &type = node->getType();
          size_t objectSize = type.getObjectSize();
          for (size_t i = 0u; i < objectSize && mOnlyContainsConstantZeros; ++i)
          {
              bool isZero = false;
              switch (type.getBasicType())
              {
                  case EbtFloat:
                      isZero = (node->getFConst(i) == 0.0f);
                      break;
                  case EbtInt:
                      isZero = (node->getIConst(i) == 0);
                      break;
                  case EbtUInt:
                      isZero = (node->getUConst(i) == 0u);
                      break;
                  case EbtBool:
                      isZero = (node->getBConst(i) == false);
                      break;
                  default:
                      // Cannot handle.
                      break;
              }
              if (!isZero)
              {
                  mOnlyContainsConstantZeros = false;
                  return;
              }
          }
      }
  
      bool onlyContainsConstantZeros() const { return mOnlyContainsConstantZeros; }
  
    private:
      bool mOnlyContainsConstantZeros;
  };
  
  }  // anonymous namespace
  
  void ShaderCompileTreeTest::SetUp()
  {
      mAllocator.push();
      SetGlobalPoolAllocator(&mAllocator);
  
      ShBuiltInResources resources;
      sh::InitBuiltInResources(&resources);
  
      initResources(&resources);
  
      mTranslator = new TranslatorESSL(getShaderType(), getShaderSpec());
      ASSERT_TRUE(mTranslator->Init(resources));
  }
  
  void ShaderCompileTreeTest::TearDown()
  {
      delete mTranslator;
  
      SetGlobalPoolAllocator(nullptr);
      mAllocator.pop();
  }
  
  bool ShaderCompileTreeTest::compile(const std::string &shaderString)
  {
      const char *shaderStrings[] = {shaderString.c_str()};
      mASTRoot = mTranslator->compileTreeForTesting(shaderStrings, 1, mExtraCompileOptions);
      TInfoSink &infoSink = mTranslator->getInfoSink();
      mInfoLog            = infoSink.info.c_str();
      return mASTRoot != nullptr;
  }
  
  void ShaderCompileTreeTest::compileAssumeSuccess(const std::string &shaderString)
  {
      if (!compile(shaderString))
      {
          FAIL() << "Shader compilation into ESSL failed, log:\n" << mInfoLog;
      }
  }
  
  bool ShaderCompileTreeTest::hasWarning() const
  {
      return mInfoLog.find("WARNING: ") != std::string::npos;
  }
  
  const std::vector<sh::Uniform> &ShaderCompileTreeTest::getUniforms() const
  {
      ASSERT(mExtraCompileOptions & SH_VARIABLES);
      return mTranslator->getUniforms();
  }
  
  const std::vector<sh::Attribute> &ShaderCompileTreeTest::getAttributes() const
  {
      ASSERT(mExtraCompileOptions & SH_VARIABLES);
      return mTranslator->getAttributes();
  }
  
  bool IsZero(TIntermNode *node)
  {
      if (!node->getAsTyped())
      {
          return false;
      }
      OnlyContainsZeroConstantsTraverser traverser;
      node->traverse(&traverser);
      return traverser.onlyContainsConstantZeros();
  }
  
  }  // namespace sh
  

Download