| // |
| // 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/AddDefaultReturnStatements.h" |
| #include "compiler/translator/tree_ops/ArrayReturnValueToOutParameter.h" |
| #include "compiler/translator/tree_ops/BreakVariableAliasingInInnerLoops.h" |
| #include "compiler/translator/tree_ops/EmulatePrecision.h" |
| #include "compiler/translator/tree_ops/ExpandIntegerPowExpressions.h" |
| #include "compiler/translator/tree_ops/PruneEmptyCases.h" |
| #include "compiler/translator/tree_ops/RemoveDynamicIndexing.h" |
| #include "compiler/translator/tree_ops/RewriteAtomicFunctionExpressions.h" |
| #include "compiler/translator/tree_ops/RewriteElseBlocks.h" |
| #include "compiler/translator/tree_ops/RewriteExpressionsWithShaderStorageBlock.h" |
| #include "compiler/translator/tree_ops/RewriteTexelFetchOffset.h" |
| #include "compiler/translator/tree_ops/RewriteUnaryMinusOperatorInt.h" |
| #include "compiler/translator/tree_ops/SeparateArrayConstructorStatements.h" |
| #include "compiler/translator/tree_ops/SeparateArrayInitialization.h" |
| #include "compiler/translator/tree_ops/SeparateDeclarations.h" |
| #include "compiler/translator/tree_ops/SeparateExpressionsReturningArrays.h" |
| #include "compiler/translator/tree_ops/SimplifyLoopConditions.h" |
| #include "compiler/translator/tree_ops/SplitSequenceOperator.h" |
| #include "compiler/translator/tree_ops/UnfoldShortCircuitToIf.h" |
| #include "compiler/translator/tree_ops/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, |
| ShCompileOptions compileOptions, |
| PerformanceDiagnostics *perfDiagnostics) |
| { |
| 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 (!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; |
| } |
| |
| bool precisionEmulation = |
| getResources().WEBGL_debug_shader_precision && getPragma().debugShaderPrecision; |
| |
| if (precisionEmulation) |
| { |
| EmulatePrecision emulatePrecision(&getSymbolTable()); |
| root->traverse(&emulatePrecision); |
| if (!emulatePrecision.updateTree(this, root)) |
| { |
| return false; |
| } |
| emulatePrecision.writeEmulationHelpers(getInfoSink().obj, getShaderVersion(), |
| getOutputType()); |
| } |
| |
| if ((compileOptions & SH_EXPAND_SELECT_HLSL_INTEGER_POW_EXPRESSIONS) != 0) |
| { |
| if (!sh::ExpandIntegerPowExpressions(this, root, &getSymbolTable())) |
| { |
| return false; |
| } |
| } |
| |
| if ((compileOptions & SH_REWRITE_TEXELFETCHOFFSET_TO_TEXELFETCH) != 0) |
| { |
| if (!sh::RewriteTexelFetchOffset(this, root, getSymbolTable(), getShaderVersion())) |
| { |
| return false; |
| } |
| } |
| |
| if (((compileOptions & SH_REWRITE_INTEGER_UNARY_MINUS_OPERATOR) != 0) && |
| 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; |
| } |
| } |
| |
| sh::OutputHLSL outputHLSL(getShaderType(), getShaderSpec(), getShaderVersion(), |
| getExtensionBehavior(), getSourcePath(), getOutputType(), |
| numRenderTargets, maxDualSourceDrawBuffers, getUniforms(), |
| compileOptions, getComputeShaderLocalSize(), &getSymbolTable(), |
| perfDiagnostics, mShaderStorageBlocks); |
| |
| outputHLSL.output(root, getInfoSink().obj); |
| |
| mShaderStorageBlockRegisterMap = outputHLSL.getShaderStorageBlockRegisterMap(); |
| mUniformBlockRegisterMap = outputHLSL.getUniformBlockRegisterMap(); |
| 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; |
| } |
| |
| unsigned int TranslatorHLSL::getReadonlyImage2DRegisterIndex() const |
| { |
| return mReadonlyImage2DRegisterIndex; |
| } |
| |
| unsigned int TranslatorHLSL::getImage2DRegisterIndex() const |
| { |
| return mImage2DRegisterIndex; |
| } |
| |
| const std::set<std::string> *TranslatorHLSL::getUsedImage2DFunctionNames() const |
| { |
| return &mUsedImage2DFunctionNames; |
| } |
| |
| } // namespace sh |
