kc3-lang/angle/src/compiler/translator/TranslatorHLSL.cpp

• Show log

  Commit

• Hash : 91a5635a
  Author :
  Date : 2022-12-16T00:00:00
  

  Support arbitrary clip and cull distance array sizes
  
  Removed limitSimultaneousClipAndCullDistanceUsage cap.
  
  Enhanced HLSL translator to support all valid combinations
  of clip and cull distances.
  
  Validate that these arrays are sized explicitly or by using
  only constant indices; adjusted link program error message.
  
  Enhanced tests to cover all possible combinations of
  implicit and explicit array sizes for both built-ins.
  
  Bug: angleproject:4452
  Change-Id: I704db6dc3c8951e5ba482a3e4dad09e5b0182f9c
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4111645
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Alexey Knyazev <lexa.knyazev@gmail.com>
  

Download

• src/compiler/translator/TranslatorHLSL.cpp

• //
  // Copyright 2002 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.
  //
  
  #include "compiler/translator/TranslatorHLSL.h"
  
  #include "compiler/translator/OutputHLSL.h"
  #include "compiler/translator/tree_ops/RemoveDynamicIndexing.h"
  #include "compiler/translator/tree_ops/RewriteTexelFetchOffset.h"
  #include "compiler/translator/tree_ops/SimplifyLoopConditions.h"
  #include "compiler/translator/tree_ops/SplitSequenceOperator.h"
  #include "compiler/translator/tree_ops/d3d/AddDefaultReturnStatements.h"
  #include "compiler/translator/tree_ops/d3d/AggregateAssignArraysInSSBOs.h"
  #include "compiler/translator/tree_ops/d3d/AggregateAssignStructsInSSBOs.h"
  #include "compiler/translator/tree_ops/d3d/ArrayReturnValueToOutParameter.h"
  #include "compiler/translator/tree_ops/d3d/BreakVariableAliasingInInnerLoops.h"
  #include "compiler/translator/tree_ops/d3d/ExpandIntegerPowExpressions.h"
  #include "compiler/translator/tree_ops/d3d/RecordUniformBlocksWithLargeArrayMember.h"
  #include "compiler/translator/tree_ops/d3d/RewriteAtomicFunctionExpressions.h"
  #include "compiler/translator/tree_ops/d3d/RewriteElseBlocks.h"
  #include "compiler/translator/tree_ops/d3d/RewriteExpressionsWithShaderStorageBlock.h"
  #include "compiler/translator/tree_ops/d3d/RewriteUnaryMinusOperatorInt.h"
  #include "compiler/translator/tree_ops/d3d/SeparateArrayConstructorStatements.h"
  #include "compiler/translator/tree_ops/d3d/SeparateArrayInitialization.h"
  #include "compiler/translator/tree_ops/d3d/SeparateExpressionsReturningArrays.h"
  #include "compiler/translator/tree_ops/d3d/UnfoldShortCircuitToIf.h"
  #include "compiler/translator/tree_ops/d3d/WrapSwitchStatementsInBlocks.h"
  #include "compiler/translator/tree_util/IntermNodePatternMatcher.h"
  
  namespace sh
  {
  
  TranslatorHLSL::TranslatorHLSL(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output)
      : TCompiler(type, spec, output)
  {}
  
  bool TranslatorHLSL::translate(TIntermBlock *root,
                                 const ShCompileOptions &compileOptions,
                                 PerformanceDiagnostics *perfDiagnostics)
  {
      // A few transformations leave the tree in an inconsistent state.  For example, when unfolding
      // the short-circuit in the following function:
      //
      //     mediump float f(float a) { return a > 0 ? 0.0 : 1.0; }
      //
      // a temp variable is created to hold the result of the expression.  Currently the precision of
      // the return value of the function is not propagated to its return expressions.  Additionally,
      // an expression such as
      //
      //     cond ? gl_NumWorkGroups.x : gl_NumWorkGroups.y
      //
      // does not have a precision as the built-in does not specify a precision.
      //
      // Precision is not applicable to HLSL so fixing these issues are deferred.
      mValidateASTOptions.validatePrecision = false;
  
      const ShBuiltInResources &resources = getResources();
      int numRenderTargets                = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1;
      int maxDualSourceDrawBuffers =
          resources.EXT_blend_func_extended ? resources.MaxDualSourceDrawBuffers : 0;
  
      if (!sh::AddDefaultReturnStatements(this, root))
      {
          return false;
      }
  
      // Note that SimplifyLoopConditions needs to be run before any other AST transformations that
      // may need to generate new statements from loop conditions or loop expressions.
      // Note that SeparateDeclarations has already been run in TCompiler::compileTreeImpl().
      if (!SimplifyLoopConditions(
              this, root,
              IntermNodePatternMatcher::kExpressionReturningArray |
                  IntermNodePatternMatcher::kUnfoldedShortCircuitExpression |
                  IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue,
              &getSymbolTable()))
      {
          return false;
      }
  
      if (!SplitSequenceOperator(
              this, root,
              IntermNodePatternMatcher::kExpressionReturningArray |
                  IntermNodePatternMatcher::kUnfoldedShortCircuitExpression |
                  IntermNodePatternMatcher::kDynamicIndexingOfVectorOrMatrixInLValue,
              &getSymbolTable()))
      {
          return false;
      }
  
      // Note that SeparateDeclarations needs to be run before UnfoldShortCircuitToIf.
      if (!UnfoldShortCircuitToIf(this, root, &getSymbolTable()))
      {
          return false;
      }
  
      if (!SeparateArrayConstructorStatements(this, root))
      {
          return false;
      }
  
      if (getShaderVersion() >= 310)
      {
          // Do element-by-element assignments of arrays in SSBOs. This allows the D3D backend to use
          // RWByteAddressBuffer.Load() and .Store(), which only operate on values up to 16 bytes in
          // size. Note that this must be done before SeparateExpressionsReturningArrays.
          if (!sh::AggregateAssignArraysInSSBOs(this, root, &getSymbolTable()))
          {
              return false;
          }
          // Do field-by-field assignment of structs in SSBOs. This allows the D3D backend to use
          // RWByteAddressBuffer.Load() and .Store(), which only operate on values up to 16 bytes in
          // size.
          if (!sh::AggregateAssignStructsInSSBOs(this, root, &getSymbolTable()))
          {
              return false;
          }
      }
  
      if (!SeparateExpressionsReturningArrays(this, root, &getSymbolTable()))
      {
          return false;
      }
  
      // Note that SeparateDeclarations needs to be run before SeparateArrayInitialization.
      if (!SeparateArrayInitialization(this, root))
      {
          return false;
      }
  
      // HLSL doesn't support arrays as return values, we'll need to make functions that have an array
      // as a return value to use an out parameter to transfer the array data instead.
      if (!ArrayReturnValueToOutParameter(this, root, &getSymbolTable()))
      {
          return false;
      }
  
      if (!shouldRunLoopAndIndexingValidation(compileOptions))
      {
          // HLSL doesn't support dynamic indexing of vectors and matrices.
          if (!RemoveDynamicIndexingOfNonSSBOVectorOrMatrix(this, root, &getSymbolTable(),
                                                            perfDiagnostics))
          {
              return false;
          }
      }
  
      // Work around D3D9 bug that would manifest in vertex shaders with selection blocks which
      // use a vertex attribute as a condition, and some related computation in the else block.
      if (getOutputType() == SH_HLSL_3_0_OUTPUT && getShaderType() == GL_VERTEX_SHADER)
      {
          if (!sh::RewriteElseBlocks(this, root, &getSymbolTable()))
          {
              return false;
          }
      }
  
      // Work around an HLSL compiler frontend aliasing optimization bug.
      // TODO(cwallez) The date is 2016-08-25, Microsoft said the bug would be fixed
      // in the next release of d3dcompiler.dll, it would be nice to detect the DLL
      // version and only apply the workaround if it is too old.
      if (!sh::BreakVariableAliasingInInnerLoops(this, root))
      {
          return false;
      }
  
      // WrapSwitchStatementsInBlocks should be called after any AST transformations that might
      // introduce variable declarations inside the main scope of any switch statement. It cannot
      // result in no-op cases at the end of switch statements, because unreferenced variables
      // have already been pruned.
      if (!WrapSwitchStatementsInBlocks(this, root))
      {
          return false;
      }
  
      if (compileOptions.expandSelectHLSLIntegerPowExpressions)
      {
          if (!sh::ExpandIntegerPowExpressions(this, root, &getSymbolTable()))
          {
              return false;
          }
      }
  
      if (compileOptions.rewriteTexelFetchOffsetToTexelFetch)
      {
          if (!sh::RewriteTexelFetchOffset(this, root, getSymbolTable(), getShaderVersion()))
          {
              return false;
          }
      }
  
      if (compileOptions.rewriteIntegerUnaryMinusOperator && getShaderType() == GL_VERTEX_SHADER)
      {
          if (!sh::RewriteUnaryMinusOperatorInt(this, root))
          {
              return false;
          }
      }
  
      if (getShaderVersion() >= 310)
      {
          // Due to ssbo also can be used as the argument of atomic memory functions, we should put
          // RewriteExpressionsWithShaderStorageBlock before RewriteAtomicFunctionExpressions.
          if (!sh::RewriteExpressionsWithShaderStorageBlock(this, root, &getSymbolTable()))
          {
              return false;
          }
          if (!sh::RewriteAtomicFunctionExpressions(this, root, &getSymbolTable(),
                                                    getShaderVersion()))
          {
              return false;
          }
      }
  
      mUniformBlockOptimizedMap.clear();
      mSlowCompilingUniformBlockSet.clear();
      // In order to get the exact maximum of slots are available for shader resources, which would
      // been bound with StructuredBuffer, we only translate uniform block with a large array member
      // into StructuredBuffer when shader version is 300.
      if (getShaderVersion() == 300 && compileOptions.allowTranslateUniformBlockToStructuredBuffer)
      {
          if (!sh::RecordUniformBlocksWithLargeArrayMember(root, mUniformBlockOptimizedMap,
                                                           mSlowCompilingUniformBlockSet))
          {
              return false;
          }
      }
  
      sh::OutputHLSL outputHLSL(
          getShaderType(), getShaderSpec(), getShaderVersion(), getExtensionBehavior(),
          getSourcePath(), getOutputType(), numRenderTargets, maxDualSourceDrawBuffers, getUniforms(),
          compileOptions, getComputeShaderLocalSize(), &getSymbolTable(), perfDiagnostics,
          mUniformBlockOptimizedMap, mShaderStorageBlocks, getClipDistanceArraySize(),
          getCullDistanceArraySize(), isEarlyFragmentTestsSpecified());
  
      outputHLSL.output(root, getInfoSink().obj);
  
      mShaderStorageBlockRegisterMap      = outputHLSL.getShaderStorageBlockRegisterMap();
      mUniformBlockRegisterMap            = outputHLSL.getUniformBlockRegisterMap();
      mUniformBlockUseStructuredBufferMap = outputHLSL.getUniformBlockUseStructuredBufferMap();
      mUniformRegisterMap                 = outputHLSL.getUniformRegisterMap();
      mReadonlyImage2DRegisterIndex       = outputHLSL.getReadonlyImage2DRegisterIndex();
      mImage2DRegisterIndex               = outputHLSL.getImage2DRegisterIndex();
      mUsedImage2DFunctionNames           = outputHLSL.getUsedImage2DFunctionNames();
  
      return true;
  }
  
  bool TranslatorHLSL::shouldFlattenPragmaStdglInvariantAll()
  {
      // Not necessary when translating to HLSL.
      return false;
  }
  
  bool TranslatorHLSL::hasShaderStorageBlock(const std::string &uniformBlockName) const
  {
      return (mShaderStorageBlockRegisterMap.count(uniformBlockName) > 0);
  }
  
  unsigned int TranslatorHLSL::getShaderStorageBlockRegister(
      const std::string &shaderStorageBlockName) const
  {
      ASSERT(hasShaderStorageBlock(shaderStorageBlockName));
      return mShaderStorageBlockRegisterMap.find(shaderStorageBlockName)->second;
  }
  
  bool TranslatorHLSL::hasUniformBlock(const std::string &uniformBlockName) const
  {
      return (mUniformBlockRegisterMap.count(uniformBlockName) > 0);
  }
  
  unsigned int TranslatorHLSL::getUniformBlockRegister(const std::string &uniformBlockName) const
  {
      ASSERT(hasUniformBlock(uniformBlockName));
      return mUniformBlockRegisterMap.find(uniformBlockName)->second;
  }
  
  const std::map<std::string, unsigned int> *TranslatorHLSL::getUniformRegisterMap() const
  {
      return &mUniformRegisterMap;
  }
  
  const std::set<std::string> *TranslatorHLSL::getSlowCompilingUniformBlockSet() const
  {
      return &mSlowCompilingUniformBlockSet;
  }
  
  unsigned int TranslatorHLSL::getReadonlyImage2DRegisterIndex() const
  {
      return mReadonlyImage2DRegisterIndex;
  }
  
  unsigned int TranslatorHLSL::getImage2DRegisterIndex() const
  {
      return mImage2DRegisterIndex;
  }
  
  const std::set<std::string> *TranslatorHLSL::getUsedImage2DFunctionNames() const
  {
      return &mUsedImage2DFunctionNames;
  }
  
  bool TranslatorHLSL::shouldUniformBlockUseStructuredBuffer(
      const std::string &uniformBlockName) const
  {
      auto uniformBlockIter = mUniformBlockUseStructuredBufferMap.find(uniformBlockName);
      return uniformBlockIter != mUniformBlockUseStructuredBufferMap.end() &&
             uniformBlockIter->second;
  }
  
  }  // namespace sh
  

Download