Source code
Revision control
Copy as Markdown
Other Tools
//
// 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/Compiler.h"
#include <sstream>
#include "angle_gl.h"
#include "common/utilities.h"
#include "compiler/translator/CallDAG.h"
#include "compiler/translator/CollectVariables.h"
#include "compiler/translator/Initialize.h"
#include "compiler/translator/IsASTDepthBelowLimit.h"
#include "compiler/translator/OutputTree.h"
#include "compiler/translator/ParseContext.h"
#include "compiler/translator/ValidateBarrierFunctionCall.h"
#include "compiler/translator/ValidateClipCullDistance.h"
#include "compiler/translator/ValidateLimitations.h"
#include "compiler/translator/ValidateMaxParameters.h"
#include "compiler/translator/ValidateOutputs.h"
#include "compiler/translator/ValidateTypeSizeLimitations.h"
#include "compiler/translator/ValidateVaryingLocations.h"
#include "compiler/translator/VariablePacker.h"
#include "compiler/translator/tree_ops/ClampIndirectIndices.h"
#include "compiler/translator/tree_ops/ClampPointSize.h"
#include "compiler/translator/tree_ops/DeclareAndInitBuiltinsForInstancedMultiview.h"
#include "compiler/translator/tree_ops/DeferGlobalInitializers.h"
#include "compiler/translator/tree_ops/EmulateGLFragColorBroadcast.h"
#include "compiler/translator/tree_ops/EmulateMultiDrawShaderBuiltins.h"
#include "compiler/translator/tree_ops/FoldExpressions.h"
#include "compiler/translator/tree_ops/ForcePrecisionQualifier.h"
#include "compiler/translator/tree_ops/InitializeVariables.h"
#include "compiler/translator/tree_ops/MonomorphizeUnsupportedFunctions.h"
#include "compiler/translator/tree_ops/PruneEmptyCases.h"
#include "compiler/translator/tree_ops/PruneNoOps.h"
#include "compiler/translator/tree_ops/RemoveArrayLengthMethod.h"
#include "compiler/translator/tree_ops/RemoveDynamicIndexing.h"
#include "compiler/translator/tree_ops/RemoveInvariantDeclaration.h"
#include "compiler/translator/tree_ops/RemoveUnreferencedVariables.h"
#include "compiler/translator/tree_ops/RewritePixelLocalStorage.h"
#include "compiler/translator/tree_ops/ScalarizeVecAndMatConstructorArgs.h"
#include "compiler/translator/tree_ops/SeparateDeclarations.h"
#include "compiler/translator/tree_ops/SimplifyLoopConditions.h"
#include "compiler/translator/tree_ops/SplitSequenceOperator.h"
#include "compiler/translator/tree_ops/apple/AddAndTrueToLoopCondition.h"
#include "compiler/translator/tree_ops/apple/RewriteDoWhile.h"
#include "compiler/translator/tree_ops/apple/UnfoldShortCircuitAST.h"
#include "compiler/translator/tree_ops/gl/ClampFragDepth.h"
#include "compiler/translator/tree_ops/gl/RegenerateStructNames.h"
#include "compiler/translator/tree_ops/gl/RewriteRepeatedAssignToSwizzled.h"
#include "compiler/translator/tree_ops/gl/UseInterfaceBlockFields.h"
#include "compiler/translator/tree_util/BuiltIn.h"
#include "compiler/translator/tree_util/IntermNodePatternMatcher.h"
#include "compiler/translator/tree_util/ReplaceShadowingVariables.h"
#include "compiler/translator/util.h"
// #define ANGLE_FUZZER_CORPUS_OUTPUT_DIR "corpus/"
#if defined(ANGLE_FUZZER_CORPUS_OUTPUT_DIR)
# include "common/hash_utils.h"
# include "common/mathutil.h"
#endif
namespace sh
{
namespace
{
// Helper that returns if a top-level node is unused. If it's a function, the function prototype is
// returned as well.
bool IsTopLevelNodeUnusedFunction(const CallDAG &callDag,
const std::vector<TFunctionMetadata> &metadata,
TIntermNode *node,
const TFunction **functionOut)
{
const TIntermFunctionPrototype *asFunctionPrototype = node->getAsFunctionPrototypeNode();
const TIntermFunctionDefinition *asFunctionDefinition = node->getAsFunctionDefinition();
*functionOut = nullptr;
if (asFunctionDefinition)
{
*functionOut = asFunctionDefinition->getFunction();
}
else if (asFunctionPrototype)
{
*functionOut = asFunctionPrototype->getFunction();
}
if (*functionOut == nullptr)
{
return false;
}
size_t callDagIndex = callDag.findIndex((*functionOut)->uniqueId());
if (callDagIndex == CallDAG::InvalidIndex)
{
// This happens only for unimplemented prototypes which are thus unused
ASSERT(asFunctionPrototype);
return true;
}
ASSERT(callDagIndex < metadata.size());
return !metadata[callDagIndex].used;
}
#if defined(ANGLE_FUZZER_CORPUS_OUTPUT_DIR)
void DumpFuzzerCase(char const *const *shaderStrings,
size_t numStrings,
uint32_t type,
uint32_t spec,
uint32_t output,
const ShCompileOptions &options)
{
ShaderDumpHeader header{};
header.type = type;
header.spec = spec;
header.output = output;
memcpy(&header.basicCompileOptions, &options, offsetof(ShCompileOptions, metal));
static_assert(offsetof(ShCompileOptions, metal) <= sizeof(header.basicCompileOptions));
memcpy(&header.metalCompileOptions, &options.metal, sizeof(options.metal));
static_assert(sizeof(options.metal) <= sizeof(header.metalCompileOptions));
memcpy(&header.plsCompileOptions, &options.pls, sizeof(options.pls));
static_assert(sizeof(options.pls) <= sizeof(header.plsCompileOptions));
size_t contentsLength = sizeof(header) + 1; // Extra: header + nul terminator.
for (size_t i = 0; i < numStrings; i++)
{
contentsLength += strlen(shaderStrings[i]);
}
std::vector<uint8_t> contents(rx::roundUp<size_t>(contentsLength, 4), 0);
memcpy(&contents[0], &header, sizeof(header));
uint8_t *data = &contents[sizeof(header)];
for (size_t i = 0; i < numStrings; i++)
{
auto length = strlen(shaderStrings[i]);
memcpy(data, shaderStrings[i], length);
data += length;
}
auto hash = angle::ComputeGenericHash(contents.data(), contents.size());
std::ostringstream o = sh::InitializeStream<std::ostringstream>();
o << ANGLE_FUZZER_CORPUS_OUTPUT_DIR << std::hex << std::setw(16) << std::setfill('0') << hash
<< ".sample";
std::string s = o.str();
// Must match the input format of the fuzzer
FILE *f = fopen(s.c_str(), "w");
fwrite(contents.data(), sizeof(char), contentsLength, f);
fclose(f);
}
#endif // defined(ANGLE_FUZZER_CORPUS_OUTPUT_DIR)
} // anonymous namespace
bool IsGLSL130OrNewer(ShShaderOutput output)
{
return (output == SH_GLSL_130_OUTPUT || output == SH_GLSL_140_OUTPUT ||
output == SH_GLSL_150_CORE_OUTPUT || output == SH_GLSL_330_CORE_OUTPUT ||
output == SH_GLSL_400_CORE_OUTPUT || output == SH_GLSL_410_CORE_OUTPUT ||
output == SH_GLSL_420_CORE_OUTPUT || output == SH_GLSL_430_CORE_OUTPUT ||
output == SH_GLSL_440_CORE_OUTPUT || output == SH_GLSL_450_CORE_OUTPUT);
}
bool IsGLSL420OrNewer(ShShaderOutput output)
{
return (output == SH_GLSL_420_CORE_OUTPUT || output == SH_GLSL_430_CORE_OUTPUT ||
output == SH_GLSL_440_CORE_OUTPUT || output == SH_GLSL_450_CORE_OUTPUT);
}
bool IsGLSL410OrOlder(ShShaderOutput output)
{
return (output == SH_GLSL_130_OUTPUT || output == SH_GLSL_140_OUTPUT ||
output == SH_GLSL_150_CORE_OUTPUT || output == SH_GLSL_330_CORE_OUTPUT ||
output == SH_GLSL_400_CORE_OUTPUT || output == SH_GLSL_410_CORE_OUTPUT);
}
bool RemoveInvariant(sh::GLenum shaderType,
int shaderVersion,
ShShaderOutput outputType,
const ShCompileOptions &compileOptions)
{
if (shaderType == GL_FRAGMENT_SHADER && IsGLSL420OrNewer(outputType))
return true;
if (compileOptions.removeInvariantAndCentroidForESSL3 && shaderVersion >= 300 &&
shaderType == GL_VERTEX_SHADER)
return true;
return false;
}
size_t GetGlobalMaxTokenSize(ShShaderSpec spec)
{
// WebGL defines a max token length of 256, while ES2 leaves max token
// size undefined. ES3 defines a max size of 1024 characters.
switch (spec)
{
case SH_WEBGL_SPEC:
return 256;
default:
return 1024;
}
}
int GetMaxUniformVectorsForShaderType(GLenum shaderType, const ShBuiltInResources &resources)
{
switch (shaderType)
{
case GL_VERTEX_SHADER:
return resources.MaxVertexUniformVectors;
case GL_FRAGMENT_SHADER:
return resources.MaxFragmentUniformVectors;
// TODO (jiawei.shao@intel.com): check if we need finer-grained component counting
case GL_COMPUTE_SHADER:
return resources.MaxComputeUniformComponents / 4;
case GL_GEOMETRY_SHADER_EXT:
return resources.MaxGeometryUniformComponents / 4;
default:
UNREACHABLE();
return -1;
}
}
namespace
{
class [[nodiscard]] TScopedPoolAllocator
{
public:
TScopedPoolAllocator(angle::PoolAllocator *allocator) : mAllocator(allocator)
{
mAllocator->push();
SetGlobalPoolAllocator(mAllocator);
}
~TScopedPoolAllocator()
{
SetGlobalPoolAllocator(nullptr);
mAllocator->pop();
}
private:
angle::PoolAllocator *mAllocator;
};
class [[nodiscard]] TScopedSymbolTableLevel
{
public:
TScopedSymbolTableLevel(TSymbolTable *table) : mTable(table)
{
ASSERT(mTable->isEmpty());
mTable->push();
}
~TScopedSymbolTableLevel()
{
while (!mTable->isEmpty())
mTable->pop();
}
private:
TSymbolTable *mTable;
};
int GetMaxShaderVersionForSpec(ShShaderSpec spec)
{
switch (spec)
{
case SH_GLES2_SPEC:
case SH_WEBGL_SPEC:
return 100;
case SH_GLES3_SPEC:
case SH_WEBGL2_SPEC:
return 300;
case SH_GLES3_1_SPEC:
case SH_WEBGL3_SPEC:
return 310;
case SH_GLES3_2_SPEC:
return 320;
case SH_GL_CORE_SPEC:
case SH_GL_COMPATIBILITY_SPEC:
return 460;
default:
UNREACHABLE();
return 0;
}
}
bool ValidateFragColorAndFragData(GLenum shaderType,
int shaderVersion,
const TSymbolTable &symbolTable,
TDiagnostics *diagnostics)
{
if (shaderVersion > 100 || shaderType != GL_FRAGMENT_SHADER)
{
return true;
}
bool usesFragColor = false;
bool usesFragData = false;
// This validation is a bit stricter than the spec - it's only an error to write to
// both FragData and FragColor. But because it's better not to have reads from undefined
// variables, we always return an error if they are both referenced, rather than only if they
// are written.
if (symbolTable.isStaticallyUsed(*BuiltInVariable::gl_FragColor()) ||
symbolTable.isStaticallyUsed(*BuiltInVariable::gl_SecondaryFragColorEXT()))
{
usesFragColor = true;
}
// Extension variables may not always be initialized (saves some time at symbol table init).
bool secondaryFragDataUsed =
symbolTable.gl_SecondaryFragDataEXT() != nullptr &&
symbolTable.isStaticallyUsed(*symbolTable.gl_SecondaryFragDataEXT());
if (symbolTable.isStaticallyUsed(*symbolTable.gl_FragData()) || secondaryFragDataUsed)
{
usesFragData = true;
}
if (usesFragColor && usesFragData)
{
const char *errorMessage = "cannot use both gl_FragData and gl_FragColor";
if (symbolTable.isStaticallyUsed(*BuiltInVariable::gl_SecondaryFragColorEXT()) ||
secondaryFragDataUsed)
{
errorMessage =
"cannot use both output variable sets (gl_FragData, gl_SecondaryFragDataEXT)"
" and (gl_FragColor, gl_SecondaryFragColorEXT)";
}
diagnostics->globalError(errorMessage);
return false;
}
return true;
}
} // namespace
TShHandleBase::TShHandleBase()
{
allocator.push();
SetGlobalPoolAllocator(&allocator);
}
TShHandleBase::~TShHandleBase()
{
SetGlobalPoolAllocator(nullptr);
allocator.popAll();
}
TCompiler::TCompiler(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output)
: mVariablesCollected(false),
mGLPositionInitialized(false),
mShaderType(type),
mShaderSpec(spec),
mOutputType(output),
mBuiltInFunctionEmulator(),
mDiagnostics(mInfoSink.info),
mSourcePath(nullptr),
mComputeShaderLocalSizeDeclared(false),
mComputeShaderLocalSize(1),
mGeometryShaderMaxVertices(-1),
mGeometryShaderInvocations(0),
mGeometryShaderInputPrimitiveType(EptUndefined),
mGeometryShaderOutputPrimitiveType(EptUndefined),
mTessControlShaderOutputVertices(0),
mTessEvaluationShaderInputPrimitiveType(EtetUndefined),
mTessEvaluationShaderInputVertexSpacingType(EtetUndefined),
mTessEvaluationShaderInputOrderingType(EtetUndefined),
mTessEvaluationShaderInputPointType(EtetUndefined),
mHasAnyPreciseType(false),
mAdvancedBlendEquations(0),
mHasPixelLocalStorageUniforms(false),
mCompileOptions{}
{}
TCompiler::~TCompiler() {}
bool TCompiler::isHighPrecisionSupported() const
{
return mShaderVersion > 100 || mShaderType != GL_FRAGMENT_SHADER ||
mResources.FragmentPrecisionHigh == 1;
}
bool TCompiler::shouldRunLoopAndIndexingValidation(const ShCompileOptions &compileOptions) const
{
// If compiling an ESSL 1.00 shader for WebGL, or if its been requested through the API,
// validate loop and indexing as well (to verify that the shader only uses minimal functionality
// of ESSL 1.00 as in Appendix A of the spec).
return (IsWebGLBasedSpec(mShaderSpec) && mShaderVersion == 100) ||
compileOptions.validateLoopIndexing;
}
bool TCompiler::shouldLimitTypeSizes() const
{
// WebGL shaders limit the size of variables' types in shaders,
// including arrays, structs and interface blocks.
return IsWebGLBasedSpec(mShaderSpec);
}
bool TCompiler::Init(const ShBuiltInResources &resources)
{
SetGlobalPoolAllocator(&allocator);
// Generate built-in symbol table.
if (!initBuiltInSymbolTable(resources))
return false;
mResources = resources;
setResourceString();
InitExtensionBehavior(resources, mExtensionBehavior);
return true;
}
TIntermBlock *TCompiler::compileTreeForTesting(const char *const shaderStrings[],
size_t numStrings,
const ShCompileOptions &compileOptions)
{
return compileTreeImpl(shaderStrings, numStrings, compileOptions);
}
TIntermBlock *TCompiler::compileTreeImpl(const char *const shaderStrings[],
size_t numStrings,
const ShCompileOptions &compileOptions)
{
// Remember the compile options for helper functions such as validateAST.
mCompileOptions = compileOptions;
clearResults();
ASSERT(numStrings > 0);
ASSERT(GetGlobalPoolAllocator());
// Reset the extension behavior for each compilation unit.
ResetExtensionBehavior(mResources, mExtensionBehavior, compileOptions);
// If gl_DrawID is not supported, remove it from the available extensions
// Currently we only allow emulation of gl_DrawID
const bool glDrawIDSupported = compileOptions.emulateGLDrawID;
if (!glDrawIDSupported)
{
auto it = mExtensionBehavior.find(TExtension::ANGLE_multi_draw);
if (it != mExtensionBehavior.end())
{
mExtensionBehavior.erase(it);
}
}
const bool glBaseVertexBaseInstanceSupported = compileOptions.emulateGLBaseVertexBaseInstance;
if (!glBaseVertexBaseInstanceSupported)
{
auto it =
mExtensionBehavior.find(TExtension::ANGLE_base_vertex_base_instance_shader_builtin);
if (it != mExtensionBehavior.end())
{
mExtensionBehavior.erase(it);
}
}
// First string is path of source file if flag is set. The actual source follows.
size_t firstSource = 0;
if (compileOptions.sourcePath)
{
mSourcePath = shaderStrings[0];
++firstSource;
}
TParseContext parseContext(mSymbolTable, mExtensionBehavior, mShaderType, mShaderSpec,
compileOptions, !IsDesktopGLSpec(mShaderSpec), &mDiagnostics,
getResources(), getOutputType());
parseContext.setFragmentPrecisionHighOnESSL1(mResources.FragmentPrecisionHigh == 1);
// We preserve symbols at the built-in level from compile-to-compile.
// Start pushing the user-defined symbols at global level.
TScopedSymbolTableLevel globalLevel(&mSymbolTable);
ASSERT(mSymbolTable.atGlobalLevel());
// Parse shader.
if (PaParseStrings(numStrings - firstSource, &shaderStrings[firstSource], nullptr,
&parseContext) != 0)
{
return nullptr;
}
if (!postParseChecks(parseContext))
{
return nullptr;
}
setASTMetadata(parseContext);
if (!checkShaderVersion(&parseContext))
{
return nullptr;
}
TIntermBlock *root = parseContext.getTreeRoot();
if (!checkAndSimplifyAST(root, parseContext, compileOptions))
{
return nullptr;
}
return root;
}
bool TCompiler::checkShaderVersion(TParseContext *parseContext)
{
if (GetMaxShaderVersionForSpec(mShaderSpec) < mShaderVersion)
{
mDiagnostics.globalError("unsupported shader version");
return false;
}
ASSERT(parseContext);
switch (mShaderType)
{
case GL_COMPUTE_SHADER:
if (mShaderVersion < 310)
{
mDiagnostics.globalError("Compute shader is not supported in this shader version.");
return false;
}
break;
case GL_GEOMETRY_SHADER_EXT:
if (mShaderVersion < 310)
{
mDiagnostics.globalError(
"Geometry shader is not supported in this shader version.");
return false;
}
else if (mShaderVersion == 310)
{
if (!parseContext->checkCanUseOneOfExtensions(
sh::TSourceLoc(),
std::array<TExtension, 2u>{
{TExtension::EXT_geometry_shader, TExtension::OES_geometry_shader}}))
{
return false;
}
}
break;
case GL_TESS_CONTROL_SHADER_EXT:
case GL_TESS_EVALUATION_SHADER_EXT:
if (mShaderVersion < 310)
{
mDiagnostics.globalError(
"Tessellation shaders are not supported in this shader version.");
return false;
}
else if (mShaderVersion == 310)
{
if (!parseContext->checkCanUseExtension(sh::TSourceLoc(),
TExtension::EXT_tessellation_shader))
{
return false;
}
}
break;
default:
break;
}
return true;
}
void TCompiler::setASTMetadata(const TParseContext &parseContext)
{
mShaderVersion = parseContext.getShaderVersion();
mPragma = parseContext.pragma();
mSymbolTable.setGlobalInvariant(mPragma.stdgl.invariantAll);
mEarlyFragmentTestsSpecified = parseContext.isEarlyFragmentTestsSpecified();
mHasDiscard = parseContext.hasDiscard();
mEnablesPerSampleShading = parseContext.isSampleQualifierSpecified();
mComputeShaderLocalSizeDeclared = parseContext.isComputeShaderLocalSizeDeclared();
mComputeShaderLocalSize = parseContext.getComputeShaderLocalSize();
mNumViews = parseContext.getNumViews();
mHasAnyPreciseType = parseContext.hasAnyPreciseType();
if (mShaderType == GL_FRAGMENT_SHADER)
{
mAdvancedBlendEquations = parseContext.getAdvancedBlendEquations();
mHasPixelLocalStorageUniforms = !parseContext.pixelLocalStorageBindings().empty();
}
if (mShaderType == GL_GEOMETRY_SHADER_EXT)
{
mGeometryShaderInputPrimitiveType = parseContext.getGeometryShaderInputPrimitiveType();
mGeometryShaderOutputPrimitiveType = parseContext.getGeometryShaderOutputPrimitiveType();
mGeometryShaderMaxVertices = parseContext.getGeometryShaderMaxVertices();
mGeometryShaderInvocations = parseContext.getGeometryShaderInvocations();
}
if (mShaderType == GL_TESS_CONTROL_SHADER_EXT)
{
mTessControlShaderOutputVertices = parseContext.getTessControlShaderOutputVertices();
}
if (mShaderType == GL_TESS_EVALUATION_SHADER_EXT)
{
mTessEvaluationShaderInputPrimitiveType =
parseContext.getTessEvaluationShaderInputPrimitiveType();
mTessEvaluationShaderInputVertexSpacingType =
parseContext.getTessEvaluationShaderInputVertexSpacingType();
mTessEvaluationShaderInputOrderingType =
parseContext.getTessEvaluationShaderInputOrderingType();
mTessEvaluationShaderInputPointType = parseContext.getTessEvaluationShaderInputPointType();
}
}
unsigned int TCompiler::getSharedMemorySize() const
{
unsigned int sharedMemSize = 0;
for (const sh::ShaderVariable &var : mSharedVariables)
{
sharedMemSize += var.getExternalSize();
}
return sharedMemSize;
}
bool TCompiler::validateAST(TIntermNode *root)
{
if (mCompileOptions.validateAST)
{
bool valid = ValidateAST(root, &mDiagnostics, mValidateASTOptions);
#if defined(ANGLE_ENABLE_ASSERTS)
if (!valid)
{
OutputTree(root, mInfoSink.info);
fprintf(stderr, "AST validation error(s):\n%s\n", mInfoSink.info.c_str());
}
#endif
// In debug, assert validation. In release, validation errors will be returned back to the
// application as internal ANGLE errors.
ASSERT(valid);
return valid;
}
return true;
}
bool TCompiler::disableValidateFunctionCall()
{
bool wasEnabled = mValidateASTOptions.validateFunctionCall;
mValidateASTOptions.validateFunctionCall = false;
return wasEnabled;
}
void TCompiler::restoreValidateFunctionCall(bool enable)
{
ASSERT(!mValidateASTOptions.validateFunctionCall);
mValidateASTOptions.validateFunctionCall = enable;
}
bool TCompiler::disableValidateVariableReferences()
{
bool wasEnabled = mValidateASTOptions.validateVariableReferences;
mValidateASTOptions.validateVariableReferences = false;
return wasEnabled;
}
void TCompiler::restoreValidateVariableReferences(bool enable)
{
ASSERT(!mValidateASTOptions.validateVariableReferences);
mValidateASTOptions.validateVariableReferences = enable;
}
void TCompiler::enableValidateNoMoreTransformations()
{
mValidateASTOptions.validateNoMoreTransformations = true;
}
bool TCompiler::checkAndSimplifyAST(TIntermBlock *root,
const TParseContext &parseContext,
const ShCompileOptions &compileOptions)
{
mValidateASTOptions = {};
// Desktop GLSL shaders don't have precision, so don't expect them to be specified.
mValidateASTOptions.validatePrecision = !IsDesktopGLSpec(mShaderSpec);
if (!validateAST(root))
{
return false;
}
// For now, rewrite pixel local storage before collecting variables or any operations on images.
//
// TODO(anglebug.com/7279):
// Should this actually run after collecting variables?
// Do we need more introspection?
// Do we want to hide rewritten shader image uniforms from glGetActiveUniform?
if (hasPixelLocalStorageUniforms())
{
ASSERT(
IsExtensionEnabled(mExtensionBehavior, TExtension::ANGLE_shader_pixel_local_storage));
if (!RewritePixelLocalStorage(this, root, getSymbolTable(), compileOptions,
getShaderVersion()))
{
mDiagnostics.globalError("internal compiler error translating pixel local storage");
return false;
}
}
// Disallow expressions deemed too complex.
if (compileOptions.limitExpressionComplexity && !limitExpressionComplexity(root))
{
return false;
}
if (shouldRunLoopAndIndexingValidation(compileOptions) &&
!ValidateLimitations(root, mShaderType, &mSymbolTable, &mDiagnostics))
{
return false;
}
if (shouldLimitTypeSizes() && !ValidateTypeSizeLimitations(mResources, root, &mSymbolTable, &mDiagnostics))
{
return false;
}
if (!ValidateFragColorAndFragData(mShaderType, mShaderVersion, mSymbolTable, &mDiagnostics))
{
return false;
}
// Fold expressions that could not be folded before validation that was done as a part of
// parsing.
if (!FoldExpressions(this, root, &mDiagnostics))
{
return false;
}
// Folding should only be able to generate warnings.
ASSERT(mDiagnostics.numErrors() == 0);
// Validate no barrier() after return before prunning it in |PruneNoOps()| below.
if (mShaderType == GL_TESS_CONTROL_SHADER && !ValidateBarrierFunctionCall(root, &mDiagnostics))
{
return false;
}
// We prune no-ops to work around driver bugs and to keep AST processing and output simple.
// The following kinds of no-ops are pruned:
// 1. Empty declarations "int;".
// 2. Literal statements: "1.0;". The ESSL output doesn't define a default precision
// for float, so float literal statements would end up with no precision which is
// invalid ESSL.
// 3. Any unreachable statement after a discard, return, break or continue.
// After this empty declarations are not allowed in the AST.
if (!PruneNoOps(this, root, &mSymbolTable))
{
return false;
}
mValidateASTOptions.validateNoStatementsAfterBranch = true;
// We need to generate globals early if we have non constant initializers enabled
bool initializeLocalsAndGlobals =
compileOptions.initializeUninitializedLocals && !IsOutputHLSL(getOutputType());
bool canUseLoopsToInitialize = !compileOptions.dontUseLoopsToInitializeVariables;
bool highPrecisionSupported = isHighPrecisionSupported();
bool enableNonConstantInitializers = IsExtensionEnabled(
mExtensionBehavior, TExtension::EXT_shader_non_constant_global_initializers);
// forceDeferGlobalInitializers is needed for MSL
// to convert a non-const global. For example:
//
// int someGlobal = 123;
//
// to
//
// int someGlobal;
// void main() {
// someGlobal = 123;
//
// This is because MSL doesn't allow statically initialized globals.
bool forceDeferGlobalInitializers = getOutputType() == SH_MSL_METAL_OUTPUT;
if (enableNonConstantInitializers &&
!DeferGlobalInitializers(this, root, initializeLocalsAndGlobals, canUseLoopsToInitialize,
highPrecisionSupported, forceDeferGlobalInitializers,
&mSymbolTable))
{
return false;
}
// Create the function DAG and check there is no recursion
if (!initCallDag(root))
{
return false;
}
if (compileOptions.limitCallStackDepth && !checkCallDepth())
{
return false;
}
// Checks which functions are used and if "main" exists
mFunctionMetadata.clear();
mFunctionMetadata.resize(mCallDag.size());
if (!tagUsedFunctions())
{
return false;
}
if (!pruneUnusedFunctions(root))
{
return false;
}
if (IsSpecWithFunctionBodyNewScope(mShaderSpec, mShaderVersion))
{
if (!ReplaceShadowingVariables(this, root, &mSymbolTable))
{
return false;
}
}
if (mShaderVersion >= 310 && !ValidateVaryingLocations(root, &mDiagnostics, mShaderType))
{
return false;
}
// anglebug.com/7484: The ESSL spec has a bug with images as function arguments. The recommended
// workaround is to inline functions that accept image arguments.
if (mShaderVersion >= 310 && !MonomorphizeUnsupportedFunctions(
this, root, &mSymbolTable, compileOptions,
UnsupportedFunctionArgsBitSet{UnsupportedFunctionArgs::Image}))
{
return false;
}
if (mShaderVersion >= 300 && mShaderType == GL_FRAGMENT_SHADER &&
!ValidateOutputs(root, getExtensionBehavior(), mResources.MaxDrawBuffers, &mDiagnostics))
{
return false;
}
if (parseContext.isExtensionEnabled(TExtension::EXT_clip_cull_distance))
{
if (!ValidateClipCullDistance(root, &mDiagnostics,
mResources.MaxCombinedClipAndCullDistances))
{
return false;
}
}
// Clamping uniform array bounds needs to happen after validateLimitations pass.
if (compileOptions.clampIndirectArrayBounds)
{
if (!ClampIndirectIndices(this, root, &mSymbolTable))
{
return false;
}
}
if (compileOptions.initializeBuiltinsForInstancedMultiview &&
(parseContext.isExtensionEnabled(TExtension::OVR_multiview2) ||
parseContext.isExtensionEnabled(TExtension::OVR_multiview)) &&
getShaderType() != GL_COMPUTE_SHADER)
{
if (!DeclareAndInitBuiltinsForInstancedMultiview(
this, root, mNumViews, mShaderType, compileOptions, mOutputType, &mSymbolTable))
{
return false;
}
}
// This pass might emit short circuits so keep it before the short circuit unfolding
if (compileOptions.rewriteDoWhileLoops)
{
if (!RewriteDoWhile(this, root, &mSymbolTable))
{
return false;
}
}
if (compileOptions.addAndTrueToLoopCondition)
{
if (!AddAndTrueToLoopCondition(this, root))
{
return false;
}
}
if (compileOptions.unfoldShortCircuit)
{
if (!UnfoldShortCircuitAST(this, root))
{
return false;
}
}
if (compileOptions.regenerateStructNames)
{
if (!RegenerateStructNames(this, root, &mSymbolTable))
{
return false;
}
}
if (mShaderType == GL_VERTEX_SHADER &&
IsExtensionEnabled(mExtensionBehavior, TExtension::ANGLE_multi_draw))
{
if (compileOptions.emulateGLDrawID)
{
if (!EmulateGLDrawID(this, root, &mSymbolTable, &mUniforms,
shouldCollectVariables(compileOptions)))
{
return false;
}
}
}
if (mShaderType == GL_VERTEX_SHADER &&
IsExtensionEnabled(mExtensionBehavior,
TExtension::ANGLE_base_vertex_base_instance_shader_builtin))
{
if (compileOptions.emulateGLBaseVertexBaseInstance)
{
if (!EmulateGLBaseVertexBaseInstance(this, root, &mSymbolTable, &mUniforms,
shouldCollectVariables(compileOptions),
compileOptions.addBaseVertexToVertexID))
{
return false;
}
}
}
if (mShaderType == GL_FRAGMENT_SHADER && mShaderVersion == 100 && mResources.EXT_draw_buffers &&
mResources.MaxDrawBuffers > 1 &&
IsExtensionEnabled(mExtensionBehavior, TExtension::EXT_draw_buffers))
{
if (!EmulateGLFragColorBroadcast(this, root, mResources.MaxDrawBuffers, &mOutputVariables,
&mSymbolTable, mShaderVersion))
{
return false;
}
}
int simplifyScalarized = compileOptions.scalarizeVecAndMatConstructorArgs
? IntermNodePatternMatcher::kScalarizedVecOrMatConstructor
: 0;
// Split multi declarations and remove calls to array length().
// 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.
if (!SimplifyLoopConditions(this, root,
IntermNodePatternMatcher::kMultiDeclaration |
IntermNodePatternMatcher::kArrayLengthMethod |
simplifyScalarized,
&getSymbolTable()))
{
return false;
}
// Note that separate declarations need to be run before other AST transformations that
// generate new statements from expressions.
if (!SeparateDeclarations(this, root, &getSymbolTable()))
{
return false;
}
mValidateASTOptions.validateMultiDeclarations = true;
if (!SplitSequenceOperator(this, root,
IntermNodePatternMatcher::kArrayLengthMethod | simplifyScalarized,
&getSymbolTable()))
{
return false;
}
if (!RemoveArrayLengthMethod(this, root))
{
return false;
}
if (!RemoveUnreferencedVariables(this, root, &mSymbolTable))
{
return false;
}
// In case the last case inside a switch statement is a certain type of no-op, GLSL compilers in
// drivers may not accept it. In this case we clean up the dead code from the end of switch
// statements. This is also required because PruneNoOps or RemoveUnreferencedVariables may have
// left switch statements that only contained an empty declaration inside the final case in an
// invalid state. Relies on that PruneNoOps and RemoveUnreferencedVariables have already been
// run.
if (!PruneEmptyCases(this, root))
{
return false;
}
// Built-in function emulation needs to happen after validateLimitations pass.
GetGlobalPoolAllocator()->lock();
initBuiltInFunctionEmulator(&mBuiltInFunctionEmulator, compileOptions);
GetGlobalPoolAllocator()->unlock();
mBuiltInFunctionEmulator.markBuiltInFunctionsForEmulation(root);
if (compileOptions.scalarizeVecAndMatConstructorArgs)
{
if (!ScalarizeVecAndMatConstructorArgs(this, root, &mSymbolTable))
{
return false;
}
}
if (compileOptions.forceShaderPrecisionHighpToMediump)
{
if (!ForceShaderPrecisionToMediump(root, &mSymbolTable, mShaderType))
{
return false;
}
}
if (shouldCollectVariables(compileOptions))
{
ASSERT(!mVariablesCollected);
CollectVariables(root, &mAttributes, &mOutputVariables, &mUniforms, &mInputVaryings,
&mOutputVaryings, &mSharedVariables, &mUniformBlocks,
&mShaderStorageBlocks, mResources.HashFunction, &mSymbolTable, mShaderType,
mExtensionBehavior, mResources, mTessControlShaderOutputVertices);
collectInterfaceBlocks();
mVariablesCollected = true;
if (compileOptions.useUnusedStandardSharedBlocks)
{
if (!useAllMembersInUnusedStandardAndSharedBlocks(root))
{
return false;
}
}
if (compileOptions.enforcePackingRestrictions)
{
int maxUniformVectors = GetMaxUniformVectorsForShaderType(mShaderType, mResources);
// Returns true if, after applying the packing rules in the GLSL ES 1.00.17 spec
// Appendix A, section 7, the shader does not use too many uniforms.
if (!CheckVariablesInPackingLimits(maxUniformVectors, mUniforms))
{
mDiagnostics.globalError("too many uniforms");
return false;
}
}
bool needInitializeOutputVariables =
compileOptions.initOutputVariables && mShaderType != GL_COMPUTE_SHADER;
needInitializeOutputVariables |=
compileOptions.initFragmentOutputVariables && mShaderType == GL_FRAGMENT_SHADER;
if (needInitializeOutputVariables)
{
if (!initializeOutputVariables(root))
{
return false;
}
}
}
// Removing invariant declarations must be done after collecting variables.
// Otherwise, built-in invariant declarations don't apply.
if (RemoveInvariant(mShaderType, mShaderVersion, mOutputType, compileOptions))
{
if (!RemoveInvariantDeclaration(this, root))
{
return false;
}
}
// gl_Position is always written in compatibility output mode.
// It may have been already initialized among other output variables, in that case we don't
// need to initialize it twice.
if (mShaderType == GL_VERTEX_SHADER && !mGLPositionInitialized &&
(compileOptions.initGLPosition || mOutputType == SH_GLSL_COMPATIBILITY_OUTPUT))
{
if (!initializeGLPosition(root))
{
return false;
}
mGLPositionInitialized = true;
}
if (mShaderType == GL_VERTEX_SHADER && compileOptions.initGLPointSize)
{
sh::ShaderVariable var(GL_FLOAT);
var.name = "gl_PointSize";
if (!InitializeVariables(this, root, {var}, &mSymbolTable, mShaderVersion,
mExtensionBehavior, false, false))
{
return false;
}
}
// DeferGlobalInitializers needs to be run before other AST transformations that generate new
// statements from expressions. But it's fine to run DeferGlobalInitializers after the above
// SplitSequenceOperator and RemoveArrayLengthMethod since they only have an effect on the AST
// on ESSL >= 3.00, and the initializers that need to be deferred can only exist in ESSL < 3.00.
// Exception: if EXT_shader_non_constant_global_initializers is enabled, we must generate global
// initializers before we generate the DAG, since initializers may call functions which must not
// be optimized out
if (!enableNonConstantInitializers &&
!DeferGlobalInitializers(this, root, initializeLocalsAndGlobals, canUseLoopsToInitialize,
highPrecisionSupported, forceDeferGlobalInitializers,
&mSymbolTable))
{
return false;
}
if (initializeLocalsAndGlobals)
{
// Initialize uninitialized local variables.
// In some cases initializing can generate extra statements in the parent block, such as
// when initializing nameless structs or initializing arrays in ESSL 1.00. In that case
// we need to first simplify loop conditions. We've already separated declarations
// earlier, which is also required. If we don't follow the Appendix A limitations, loop
// init statements can declare arrays or nameless structs and have multiple
// declarations.
if (!shouldRunLoopAndIndexingValidation(compileOptions))
{
if (!SimplifyLoopConditions(this, root,
IntermNodePatternMatcher::kArrayDeclaration |
IntermNodePatternMatcher::kNamelessStructDeclaration,
&getSymbolTable()))
{
return false;
}
}
if (!InitializeUninitializedLocals(this, root, getShaderVersion(), canUseLoopsToInitialize,
highPrecisionSupported, &getSymbolTable()))
{
return false;
}
}
if (getShaderType() == GL_VERTEX_SHADER && compileOptions.clampPointSize)
{
if (!ClampPointSize(this, root, mResources.MaxPointSize, &getSymbolTable()))
{
return false;
}
}
if (getShaderType() == GL_FRAGMENT_SHADER && compileOptions.clampFragDepth)
{
if (!ClampFragDepth(this, root, &getSymbolTable()))
{
return false;
}
}
if (compileOptions.rewriteRepeatedAssignToSwizzled)
{
if (!sh::RewriteRepeatedAssignToSwizzled(this, root))
{
return false;
}
}
if (compileOptions.removeDynamicIndexingOfSwizzledVector)
{
if (!sh::RemoveDynamicIndexingOfSwizzledVector(this, root, &getSymbolTable(), nullptr))
{
return false;
}
}
return true;
}
bool TCompiler::postParseChecks(const TParseContext &parseContext)
{
std::stringstream errorMessage;
if (parseContext.getTreeRoot() == nullptr)
{
errorMessage << "Shader parsing failed (mTreeRoot == nullptr)";
}
for (TType *type : parseContext.getDeferredArrayTypesToSize())
{
errorMessage << "Unsized global array type: " << type->getBasicString();
}
if (!errorMessage.str().empty())
{
mDiagnostics.globalError(errorMessage.str().c_str());
return false;
}
return true;
}
bool TCompiler::compile(const char *const shaderStrings[],
size_t numStrings,
const ShCompileOptions &compileOptionsIn)
{
#if defined(ANGLE_FUZZER_CORPUS_OUTPUT_DIR)
DumpFuzzerCase(shaderStrings, numStrings, mShaderType, mShaderSpec, mOutputType,
compileOptionsIn);
#endif // defined(ANGLE_FUZZER_CORPUS_OUTPUT_DIR)
if (numStrings == 0)
return true;
ShCompileOptions compileOptions = compileOptionsIn;
// Apply key workarounds.
if (shouldFlattenPragmaStdglInvariantAll())
{
// This should be harmless to do in all cases, but for the moment, do it only conditionally.
compileOptions.flattenPragmaSTDGLInvariantAll = true;
}
TScopedPoolAllocator scopedAlloc(&allocator);
TIntermBlock *root = compileTreeImpl(shaderStrings, numStrings, compileOptions);
if (root)
{
if (compileOptions.intermediateTree)
{
OutputTree(root, mInfoSink.info);
}
if (compileOptions.objectCode)
{
PerformanceDiagnostics perfDiagnostics(&mDiagnostics);
if (!translate(root, compileOptions, &perfDiagnostics))
{
return false;
}
}
if (mShaderType == GL_VERTEX_SHADER)
{
bool lookForDrawID =
IsExtensionEnabled(mExtensionBehavior, TExtension::ANGLE_multi_draw) &&
compileOptions.emulateGLDrawID;
bool lookForBaseVertexBaseInstance =
IsExtensionEnabled(mExtensionBehavior,
TExtension::ANGLE_base_vertex_base_instance_shader_builtin) &&
compileOptions.emulateGLBaseVertexBaseInstance;
if (lookForDrawID || lookForBaseVertexBaseInstance)
{
for (auto &uniform : mUniforms)
{
if (lookForDrawID && uniform.name == "angle_DrawID" &&
uniform.mappedName == "angle_DrawID")
{
uniform.name = "gl_DrawID";
}
else if (lookForBaseVertexBaseInstance && uniform.name == "angle_BaseVertex" &&
uniform.mappedName == "angle_BaseVertex")
{
uniform.name = "gl_BaseVertex";
}
else if (lookForBaseVertexBaseInstance &&
uniform.name == "angle_BaseInstance" &&
uniform.mappedName == "angle_BaseInstance")
{
uniform.name = "gl_BaseInstance";
}
}
}
}
// The IntermNode tree doesn't need to be deleted here, since the
// memory will be freed in a big chunk by the PoolAllocator.
return true;
}
return false;
}
bool TCompiler::initBuiltInSymbolTable(const ShBuiltInResources &resources)
{
if (resources.MaxDrawBuffers < 1)
{
return false;
}
if (resources.EXT_blend_func_extended && resources.MaxDualSourceDrawBuffers < 1)
{
return false;
}
mSymbolTable.initializeBuiltIns(mShaderType, mShaderSpec, resources);
return true;
}
void TCompiler::setResourceString()
{
std::ostringstream strstream = sh::InitializeStream<std::ostringstream>();
// clang-format off
strstream << ":MaxVertexAttribs:" << mResources.MaxVertexAttribs
<< ":MaxVertexUniformVectors:" << mResources.MaxVertexUniformVectors
<< ":MaxVaryingVectors:" << mResources.MaxVaryingVectors
<< ":MaxVertexTextureImageUnits:" << mResources.MaxVertexTextureImageUnits
<< ":MaxCombinedTextureImageUnits:" << mResources.MaxCombinedTextureImageUnits
<< ":MaxTextureImageUnits:" << mResources.MaxTextureImageUnits
<< ":MaxFragmentUniformVectors:" << mResources.MaxFragmentUniformVectors
<< ":MaxDrawBuffers:" << mResources.MaxDrawBuffers
<< ":OES_standard_derivatives:" << mResources.OES_standard_derivatives
<< ":OES_EGL_image_external:" << mResources.OES_EGL_image_external
<< ":OES_EGL_image_external_essl3:" << mResources.OES_EGL_image_external_essl3
<< ":NV_EGL_stream_consumer_external:" << mResources.NV_EGL_stream_consumer_external
<< ":ARB_texture_rectangle:" << mResources.ARB_texture_rectangle
<< ":EXT_draw_buffers:" << mResources.EXT_draw_buffers
<< ":FragmentPrecisionHigh:" << mResources.FragmentPrecisionHigh
<< ":MaxExpressionComplexity:" << mResources.MaxExpressionComplexity
<< ":MaxCallStackDepth:" << mResources.MaxCallStackDepth
<< ":MaxFunctionParameters:" << mResources.MaxFunctionParameters
<< ":EXT_blend_func_extended:" << mResources.EXT_blend_func_extended
<< ":EXT_frag_depth:" << mResources.EXT_frag_depth
<< ":EXT_primitive_bounding_box:" << mResources.EXT_primitive_bounding_box
<< ":OES_primitive_bounding_box:" << mResources.OES_primitive_bounding_box
<< ":EXT_shader_texture_lod:" << mResources.EXT_shader_texture_lod
<< ":EXT_shader_framebuffer_fetch:" << mResources.EXT_shader_framebuffer_fetch
<< ":EXT_shader_framebuffer_fetch_non_coherent:" << mResources.EXT_shader_framebuffer_fetch_non_coherent
<< ":NV_shader_framebuffer_fetch:" << mResources.NV_shader_framebuffer_fetch
<< ":ARM_shader_framebuffer_fetch:" << mResources.ARM_shader_framebuffer_fetch
<< ":OVR_multiview2:" << mResources.OVR_multiview2
<< ":OVR_multiview:" << mResources.OVR_multiview
<< ":EXT_YUV_target:" << mResources.EXT_YUV_target
<< ":EXT_geometry_shader:" << mResources.EXT_geometry_shader
<< ":OES_geometry_shader:" << mResources.OES_geometry_shader
<< ":OES_shader_io_blocks:" << mResources.OES_shader_io_blocks
<< ":EXT_shader_io_blocks:" << mResources.EXT_shader_io_blocks
<< ":EXT_gpu_shader5:" << mResources.EXT_gpu_shader5
<< ":OES_texture_3D:" << mResources.OES_texture_3D
<< ":MaxVertexOutputVectors:" << mResources.MaxVertexOutputVectors
<< ":MaxFragmentInputVectors:" << mResources.MaxFragmentInputVectors
<< ":MinProgramTexelOffset:" << mResources.MinProgramTexelOffset
<< ":MaxProgramTexelOffset:" << mResources.MaxProgramTexelOffset
<< ":MaxDualSourceDrawBuffers:" << mResources.MaxDualSourceDrawBuffers
<< ":MaxViewsOVR:" << mResources.MaxViewsOVR
<< ":NV_draw_buffers:" << mResources.NV_draw_buffers
<< ":ANGLE_multi_draw:" << mResources.ANGLE_multi_draw
<< ":ANGLE_base_vertex_base_instance_shader_builtin:" << mResources.ANGLE_base_vertex_base_instance_shader_builtin
<< ":APPLE_clip_distance:" << mResources.APPLE_clip_distance
<< ":OES_texture_cube_map_array:" << mResources.OES_texture_cube_map_array
<< ":EXT_texture_cube_map_array:" << mResources.EXT_texture_cube_map_array
<< ":EXT_shadow_samplers:" << mResources.EXT_shadow_samplers
<< ":OES_shader_multisample_interpolation:" << mResources.OES_shader_multisample_interpolation
<< ":OES_shader_image_atomic:" << mResources.OES_shader_image_atomic
<< ":EXT_tessellation_shader:" << mResources.EXT_tessellation_shader
<< ":OES_texture_buffer:" << mResources.OES_texture_buffer
<< ":EXT_texture_buffer:" << mResources.EXT_texture_buffer
<< ":OES_sample_variables:" << mResources.OES_sample_variables
<< ":EXT_clip_cull_distance:" << mResources.EXT_clip_cull_distance
<< ":MinProgramTextureGatherOffset:" << mResources.MinProgramTextureGatherOffset
<< ":MaxProgramTextureGatherOffset:" << mResources.MaxProgramTextureGatherOffset
<< ":MaxImageUnits:" << mResources.MaxImageUnits
<< ":MaxSamples:" << mResources.MaxSamples
<< ":MaxVertexImageUniforms:" << mResources.MaxVertexImageUniforms
<< ":MaxFragmentImageUniforms:" << mResources.MaxFragmentImageUniforms
<< ":MaxComputeImageUniforms:" << mResources.MaxComputeImageUniforms
<< ":MaxCombinedImageUniforms:" << mResources.MaxCombinedImageUniforms
<< ":MaxCombinedShaderOutputResources:" << mResources.MaxCombinedShaderOutputResources
<< ":MaxComputeWorkGroupCountX:" << mResources.MaxComputeWorkGroupCount[0]
<< ":MaxComputeWorkGroupCountY:" << mResources.MaxComputeWorkGroupCount[1]
<< ":MaxComputeWorkGroupCountZ:" << mResources.MaxComputeWorkGroupCount[2]
<< ":MaxComputeWorkGroupSizeX:" << mResources.MaxComputeWorkGroupSize[0]
<< ":MaxComputeWorkGroupSizeY:" << mResources.MaxComputeWorkGroupSize[1]
<< ":MaxComputeWorkGroupSizeZ:" << mResources.MaxComputeWorkGroupSize[2]
<< ":MaxComputeUniformComponents:" << mResources.MaxComputeUniformComponents
<< ":MaxComputeTextureImageUnits:" << mResources.MaxComputeTextureImageUnits
<< ":MaxComputeAtomicCounters:" << mResources.MaxComputeAtomicCounters
<< ":MaxComputeAtomicCounterBuffers:" << mResources.MaxComputeAtomicCounterBuffers
<< ":MaxVertexAtomicCounters:" << mResources.MaxVertexAtomicCounters
<< ":MaxFragmentAtomicCounters:" << mResources.MaxFragmentAtomicCounters
<< ":MaxCombinedAtomicCounters:" << mResources.MaxCombinedAtomicCounters
<< ":MaxAtomicCounterBindings:" << mResources.MaxAtomicCounterBindings
<< ":MaxVertexAtomicCounterBuffers:" << mResources.MaxVertexAtomicCounterBuffers
<< ":MaxFragmentAtomicCounterBuffers:" << mResources.MaxFragmentAtomicCounterBuffers
<< ":MaxCombinedAtomicCounterBuffers:" << mResources.MaxCombinedAtomicCounterBuffers
<< ":MaxAtomicCounterBufferSize:" << mResources.MaxAtomicCounterBufferSize
<< ":MaxGeometryUniformComponents:" << mResources.MaxGeometryUniformComponents
<< ":MaxGeometryUniformBlocks:" << mResources.MaxGeometryUniformBlocks
<< ":MaxGeometryInputComponents:" << mResources.MaxGeometryInputComponents
<< ":MaxGeometryOutputComponents:" << mResources.MaxGeometryOutputComponents
<< ":MaxGeometryOutputVertices:" << mResources.MaxGeometryOutputVertices
<< ":MaxGeometryTotalOutputComponents:" << mResources.MaxGeometryTotalOutputComponents
<< ":MaxGeometryTextureImageUnits:" << mResources.MaxGeometryTextureImageUnits
<< ":MaxGeometryAtomicCounterBuffers:" << mResources.MaxGeometryAtomicCounterBuffers
<< ":MaxGeometryAtomicCounters:" << mResources.MaxGeometryAtomicCounters
<< ":MaxGeometryShaderStorageBlocks:" << mResources.MaxGeometryShaderStorageBlocks
<< ":MaxGeometryShaderInvocations:" << mResources.MaxGeometryShaderInvocations
<< ":MaxGeometryImageUniforms:" << mResources.MaxGeometryImageUniforms
<< ":MaxClipDistances" << mResources.MaxClipDistances
<< ":MaxCullDistances" << mResources.MaxCullDistances
<< ":MaxCombinedClipAndCullDistances" << mResources.MaxCombinedClipAndCullDistances
<< ":MaxTessControlInputComponents:" << mResources.MaxTessControlInputComponents
<< ":MaxTessControlOutputComponents:" << mResources.MaxTessControlOutputComponents
<< ":MaxTessControlTextureImageUnits:" << mResources.MaxTessControlTextureImageUnits
<< ":MaxTessControlUniformComponents:" << mResources.MaxTessControlUniformComponents
<< ":MaxTessControlTotalOutputComponents:" << mResources.MaxTessControlTotalOutputComponents
<< ":MaxTessControlImageUniforms:" << mResources.MaxTessControlImageUniforms
<< ":MaxTessControlAtomicCounters:" << mResources.MaxTessControlAtomicCounters
<< ":MaxTessControlAtomicCounterBuffers:" << mResources.MaxTessControlAtomicCounterBuffers
<< ":MaxTessPatchComponents:" << mResources.MaxTessPatchComponents
<< ":MaxPatchVertices:" << mResources.MaxPatchVertices
<< ":MaxTessGenLevel:" << mResources.MaxTessGenLevel
<< ":MaxTessEvaluationInputComponents:" << mResources.MaxTessEvaluationInputComponents
<< ":MaxTessEvaluationOutputComponents:" << mResources.MaxTessEvaluationOutputComponents
<< ":MaxTessEvaluationTextureImageUnits:" << mResources.MaxTessEvaluationTextureImageUnits
<< ":MaxTessEvaluationUniformComponents:" << mResources.MaxTessEvaluationUniformComponents
<< ":MaxTessEvaluationImageUniforms:" << mResources.MaxTessEvaluationImageUniforms
<< ":MaxTessEvaluationAtomicCounters:" << mResources.MaxTessEvaluationAtomicCounters
<< ":MaxTessEvaluationAtomicCounterBuffers:" << mResources.MaxTessEvaluationAtomicCounterBuffers;
// clang-format on
mBuiltInResourcesString = strstream.str();
}
void TCompiler::collectInterfaceBlocks()
{
ASSERT(mInterfaceBlocks.empty());
mInterfaceBlocks.reserve(mUniformBlocks.size() + mShaderStorageBlocks.size());
mInterfaceBlocks.insert(mInterfaceBlocks.end(), mUniformBlocks.begin(), mUniformBlocks.end());
mInterfaceBlocks.insert(mInterfaceBlocks.end(), mShaderStorageBlocks.begin(),
mShaderStorageBlocks.end());
}
void TCompiler::clearResults()
{
mInfoSink.info.erase();
mInfoSink.obj.erase();
mInfoSink.debug.erase();
mDiagnostics.resetErrorCount();
mAttributes.clear();
mOutputVariables.clear();
mUniforms.clear();
mInputVaryings.clear();
mOutputVaryings.clear();
mSharedVariables.clear();
mInterfaceBlocks.clear();
mUniformBlocks.clear();
mShaderStorageBlocks.clear();
mVariablesCollected = false;
mGLPositionInitialized = false;
mNumViews = -1;
mGeometryShaderInputPrimitiveType = EptUndefined;
mGeometryShaderOutputPrimitiveType = EptUndefined;
mGeometryShaderInvocations = 0;
mGeometryShaderMaxVertices = -1;
mTessControlShaderOutputVertices = 0;
mTessEvaluationShaderInputPrimitiveType = EtetUndefined;
mTessEvaluationShaderInputVertexSpacingType = EtetUndefined;
mTessEvaluationShaderInputOrderingType = EtetUndefined;
mTessEvaluationShaderInputPointType = EtetUndefined;
mBuiltInFunctionEmulator.cleanup();
mNameMap.clear();
mSourcePath = nullptr;
mSymbolTable.clearCompilationResults();
}
bool TCompiler::initCallDag(TIntermNode *root)
{
mCallDag.clear();
switch (mCallDag.init(root, &mDiagnostics))
{
case CallDAG::INITDAG_SUCCESS:
return true;
case CallDAG::INITDAG_RECURSION:
case CallDAG::INITDAG_UNDEFINED:
// Error message has already been written out.
ASSERT(mDiagnostics.numErrors() > 0);
return false;
}
UNREACHABLE();
return true;
}
bool TCompiler::checkCallDepth()
{
std::vector<int> depths(mCallDag.size());
for (size_t i = 0; i < mCallDag.size(); i++)
{
int depth = 0;
const CallDAG::Record &record = mCallDag.getRecordFromIndex(i);
for (int calleeIndex : record.callees)
{
depth = std::max(depth, depths[calleeIndex] + 1);
}
depths[i] = depth;
if (depth >= mResources.MaxCallStackDepth)
{
// Trace back the function chain to have a meaningful info log.
std::stringstream errorStream = sh::InitializeStream<std::stringstream>();
errorStream << "Call stack too deep (larger than " << mResources.MaxCallStackDepth
<< ") with the following call chain: "
<< record.node->getFunction()->name();
int currentFunction = static_cast<int>(i);
int currentDepth = depth;
while (currentFunction != -1)
{
errorStream
<< " -> "
<< mCallDag.getRecordFromIndex(currentFunction).node->getFunction()->name();
int nextFunction = -1;
for (const int &calleeIndex : mCallDag.getRecordFromIndex(currentFunction).callees)
{
if (depths[calleeIndex] == currentDepth - 1)
{
currentDepth--;
nextFunction = calleeIndex;
}
}
currentFunction = nextFunction;
}
std::string errorStr = errorStream.str();
mDiagnostics.globalError(errorStr.c_str());
return false;
}
}
return true;
}
bool TCompiler::tagUsedFunctions()
{
// Search from main, starting from the end of the DAG as it usually is the root.
for (size_t i = mCallDag.size(); i-- > 0;)
{
if (mCallDag.getRecordFromIndex(i).node->getFunction()->isMain())
{
internalTagUsedFunction(i);
return true;
}
}
mDiagnostics.globalError("Missing main()");
return false;
}
void TCompiler::internalTagUsedFunction(size_t index)
{
if (mFunctionMetadata[index].used)
{
return;
}
mFunctionMetadata[index].used = true;
for (int calleeIndex : mCallDag.getRecordFromIndex(index).callees)
{
internalTagUsedFunction(calleeIndex);
}
}
bool TCompiler::pruneUnusedFunctions(TIntermBlock *root)
{
TIntermSequence *sequence = root->getSequence();
size_t writeIndex = 0;
for (size_t readIndex = 0; readIndex < sequence->size(); ++readIndex)
{
TIntermNode *node = sequence->at(readIndex);
// Keep anything that's not unused.
const TFunction *function = nullptr;
const bool shouldPrune =
IsTopLevelNodeUnusedFunction(mCallDag, mFunctionMetadata, node, &function);
if (!shouldPrune)
{
(*sequence)[writeIndex++] = node;
continue;
}
// If a function is unused, it may have a struct declaration in its return value which
// shouldn't be pruned. In that case, replace the function definition with the struct
// definition.
ASSERT(function != nullptr);
const TType &returnType = function->getReturnType();
if (!returnType.isStructSpecifier())
{
continue;
}
TVariable *structVariable =
new TVariable(&mSymbolTable, kEmptyImmutableString, &returnType, SymbolType::Empty);
TIntermSymbol *structSymbol = new TIntermSymbol(structVariable);
TIntermDeclaration *structDeclaration = new TIntermDeclaration;
structDeclaration->appendDeclarator(structSymbol);
structSymbol->setLine(node->getLine());
structDeclaration->setLine(node->getLine());
(*sequence)[writeIndex++] = structDeclaration;
}
sequence->resize(writeIndex);
return validateAST(root);
}
bool TCompiler::limitExpressionComplexity(TIntermBlock *root)
{
if (!IsASTDepthBelowLimit(root, mResources.MaxExpressionComplexity))
{
mDiagnostics.globalError("Expression too complex.");
return false;
}
if (!ValidateMaxParameters(root, mResources.MaxFunctionParameters))
{
mDiagnostics.globalError("Function has too many parameters.");
return false;
}
return true;
}
bool TCompiler::shouldCollectVariables(const ShCompileOptions &compileOptions)
{
return compileOptions.variables;
}
bool TCompiler::wereVariablesCollected() const
{
return mVariablesCollected;
}
bool TCompiler::initializeGLPosition(TIntermBlock *root)
{
sh::ShaderVariable var(GL_FLOAT_VEC4);
var.name = "gl_Position";
return InitializeVariables(this, root, {var}, &mSymbolTable, mShaderVersion, mExtensionBehavior,
false, false);
}
bool TCompiler::useAllMembersInUnusedStandardAndSharedBlocks(TIntermBlock *root)
{
sh::InterfaceBlockList list;
for (const sh::InterfaceBlock &block : mUniformBlocks)
{
if (!block.staticUse &&
(block.layout == sh::BLOCKLAYOUT_STD140 || block.layout == sh::BLOCKLAYOUT_SHARED))
{
list.push_back(block);
}
}
return sh::UseInterfaceBlockFields(this, root, list, mSymbolTable);
}
bool TCompiler::initializeOutputVariables(TIntermBlock *root)
{
InitVariableList list;
list.reserve(mOutputVaryings.size());
if (mShaderType == GL_VERTEX_SHADER || mShaderType == GL_GEOMETRY_SHADER_EXT)
{
for (const sh::ShaderVariable &var : mOutputVaryings)
{
list.push_back(var);
if (var.name == "gl_Position")
{
ASSERT(!mGLPositionInitialized);
mGLPositionInitialized = true;
}
}
}
else
{
ASSERT(mShaderType == GL_FRAGMENT_SHADER);
for (const sh::ShaderVariable &var : mOutputVariables)
{
// in-out variables represent the context of the framebuffer
// when the draw call starts, so they have to be considered
// as already initialized.
if (!var.isFragmentInOut)
{
list.push_back(var);
}
}
}
return InitializeVariables(this, root, list, &mSymbolTable, mShaderVersion, mExtensionBehavior,
false, false);
}
const TExtensionBehavior &TCompiler::getExtensionBehavior() const
{
return mExtensionBehavior;
}
const char *TCompiler::getSourcePath() const
{
return mSourcePath;
}
const ShBuiltInResources &TCompiler::getResources() const
{
return mResources;
}
const BuiltInFunctionEmulator &TCompiler::getBuiltInFunctionEmulator() const
{
return mBuiltInFunctionEmulator;
}
bool TCompiler::isVaryingDefined(const char *varyingName)
{
ASSERT(mVariablesCollected);
for (size_t ii = 0; ii < mInputVaryings.size(); ++ii)
{
if (mInputVaryings[ii].name == varyingName)
{
return true;
}
}
for (size_t ii = 0; ii < mOutputVaryings.size(); ++ii)
{
if (mOutputVaryings[ii].name == varyingName)
{
return true;
}
}
return false;
}
} // namespace sh