Google Git
Sign in
flutter/third_party/angle/refs/heads/main/./src/compiler/translator/ParseContext.h
blob: e89684bf7c64da1bccf3d655a26877effd89ef19 [file] [log] [blame] [edit]
//
// 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.
//
#ifndef COMPILER_TRANSLATOR_PARSECONTEXT_H_
#define COMPILER_TRANSLATOR_PARSECONTEXT_H_
#include "common/hash_containers.h"
#include "common/span.h"
#include "compiler/preprocessor/Preprocessor.h"
#include "compiler/translator/Compiler.h"
#include "compiler/translator/Declarator.h"
#include "compiler/translator/Diagnostics.h"
#include "compiler/translator/DirectiveHandler.h"
#include "compiler/translator/FunctionLookup.h"
#include "compiler/translator/QualifierTypes.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/ValidateVaryingLocations.h"
namespace sh
{
struct TMatrixFields
{
bool wholeRow;
bool wholeCol;
int row;
int col;
};
struct ClipCullDistanceInfo
{
// Whether the size is specified by redeclaring the built-in
uint32_t size = 0;
// What is the maximum constant index used with this built-in
int32_t maxIndex = -1;
// Whether any non-constant indices were used with this built-in
bool hasNonConstIndex = false;
// Whether .length() has been called on this built-in
bool hasArrayLengthMethodCall = false;
// A location to associate with post-parse errors
TSourceLoc firstEncounter = kNoSourceLoc;
// The IR id of this variable, only needed when !declared
ir::VariableId id = ir::kInvalidVariableId;
};
enum class GeomTessArray
{
Sized,
Deferred,
};
enum class FunctionDeclaration
{
Prototype,
Definition,
};
struct VariableAndLocation
{
TSourceLoc line = {};
const TVariable *variable = nullptr;
};
//
// The following are extra variables needed during parsing, grouped together so
// they can be passed to the parser without needing a global.
//
class TParseContext : angle::NonCopyable
{
public:
TParseContext(TSymbolTable &symt,
TExtensionBehavior &ext,
sh::GLenum type,
ShShaderSpec spec,
const ShCompileOptions &options,
TDiagnostics *diagnostics,
const ShBuiltInResources &resources,
ShShaderOutput outputType);
~TParseContext();
bool anyMultiviewExtensionAvailable();
const angle::pp::Preprocessor &getPreprocessor() const { return mPreprocessor; }
angle::pp::Preprocessor &getPreprocessor() { return mPreprocessor; }
void *getScanner() const { return mScanner; }
void setScanner(void *scanner) { mScanner = scanner; }
int getShaderVersion() const { return mShaderVersion; }
void onShaderVersionDeclared(int version);
sh::GLenum getShaderType() const { return mShaderType; }
ShShaderSpec getShaderSpec() const { return mShaderSpec; }
int numErrors() const { return mDiagnostics->numErrors(); }
void error(const TSourceLoc &loc, const char *reason, const char *token);
void error(const TSourceLoc &loc, const char *reason, const ImmutableString &token);
void warning(const TSourceLoc &loc, const char *reason, const char *token);
// If isError is false, a warning will be reported instead.
void outOfRangeError(bool isError,
const TSourceLoc &loc,
const char *reason,
const char *token);
TIntermBlock *getTreeRoot() const { return mTreeRoot; }
void setTreeRoot(TIntermBlock *treeRoot);
ir::IR getIR();
bool usesDerivatives() const { return mUsesDerivatives; }
bool isEarlyFragmentTestsSpecified() const { return mEarlyFragmentTestsSpecified; }
bool hasDiscard() const { return mHasDiscard; }
bool isSampleQualifierSpecified() const { return mSampleQualifierSpecified; }
bool isComputeShaderLocalSizeDeclared() const { return mComputeShaderLocalSizeDeclared; }
sh::WorkGroupSize getComputeShaderLocalSize() const;
int getNumViews() const { return mNumViews; }
const std::map<int, ShPixelLocalStorageLayout> &pixelLocalStorageLayouts() const
{
return mPLSLayouts;
}
void enterFunctionDeclaration() { mDeclaringFunction = true; }
void exitFunctionDeclaration() { mDeclaringFunction = false; }
bool declaringFunction() const { return mDeclaringFunction; }
TIntermConstantUnion *addScalarLiteral(const TConstantUnion *constantUnion,
const TSourceLoc &line);
// This method is guaranteed to succeed, even if no variable with 'name' exists.
const TVariable *getNamedVariable(const TSourceLoc &location,
const ImmutableString &name,
const TSymbol *symbol);
TIntermTyped *parseVariableIdentifier(const TSourceLoc &location,
const ImmutableString &name,
const TSymbol *symbol);
// Look at a '.' field selector string and change it into offsets for a vector.
bool parseVectorFields(const TSourceLoc &line,
const ImmutableString &compString,
uint32_t vecSize,
TVector<uint32_t> *fieldOffsets);
void assignError(const TSourceLoc &line, const char *op, const TType &left, const TType &right);
void unaryOpError(const TSourceLoc &line, const char *op, const TType &operand);
void binaryOpError(const TSourceLoc &line,
const char *op,
const TType &left,
const TType &right);
// Check functions - the ones that return bool return false if an error was generated.
void checkIsValidExpressionStatement(const TSourceLoc &line, TIntermTyped *expr);
bool checkIsNotReserved(const TSourceLoc &line, const ImmutableString &identifier);
void checkPrecisionSpecified(const TSourceLoc &line, TPrecision precision, TBasicType type);
bool checkCanBeLValue(const TSourceLoc &line, const char *op, TIntermTyped *node);
void checkIsConst(TIntermTyped *node);
void checkIsScalarInteger(TIntermTyped *node, const char *token);
bool checkIsAtGlobalLevel(const TSourceLoc &line, const char *token);
bool checkConstructorArguments(const TSourceLoc &line,
const TIntermSequence &arguments,
const TType &type);
// Returns a sanitized array size to use (the size is at least 1).
unsigned int checkIsValidArraySize(const TSourceLoc &line, TIntermTyped *expr);
bool checkIsValidArrayDimension(const TSourceLoc &line, TVector<unsigned int> *arraySizes);
bool checkIsValidQualifierForArray(const TSourceLoc &line, const TPublicType &elementQualifier);
bool checkArrayElementIsNotArray(const TSourceLoc &line, const TPublicType &elementType);
bool checkArrayOfArraysInOut(const TSourceLoc &line,
const TPublicType &elementType,
const TType &arrayType);
bool checkIsNonVoid(const TSourceLoc &line,
const ImmutableString &identifier,
const TBasicType &type);
bool checkIsScalarBool(const TSourceLoc &line, const TIntermTyped *type);
void checkIsScalarBool(const TSourceLoc &line, const TPublicType &pType);
bool checkIsNotOpaqueType(const TSourceLoc &line,
const TTypeSpecifierNonArray &pType,
const char *reason);
void checkDeclaratorLocationIsNotSpecified(const TSourceLoc &line, const TPublicType &pType);
void checkLocationIsNotSpecified(const TSourceLoc &location,
const TLayoutQualifier &layoutQualifier);
void checkStd430IsForShaderStorageBlock(const TSourceLoc &location,
const TLayoutBlockStorage &blockStorage,
const TQualifier &qualifier);
// Check if at least one of the specified extensions can be used, and generate error/warning as
// appropriate according to the spec.
// This function is only needed for a few different small constant sizes of extension array, and
// we want to avoid unnecessary dynamic allocations. That's why checkCanUseOneOfExtensions is a
// template function rather than one taking a vector.
template <size_t size>
bool checkCanUseOneOfExtensions(const TSourceLoc &line,
const std::array<TExtension, size> &extensions);
bool checkCanUseExtension(const TSourceLoc &line, TExtension extension);
// Done for all declarations, whether empty or not.
void declarationQualifierErrorCheck(const sh::TQualifier qualifier,
const sh::TLayoutQualifier &layoutQualifier,
const TSourceLoc &location);
// Done for the first non-empty declarator in a declaration.
void nonEmptyDeclarationErrorCheck(const TPublicType &publicType,
const TSourceLoc &identifierLocation);
// Done only for empty declarations.
void emptyDeclarationErrorCheck(const TType &type, const TSourceLoc &location);
void checkCanUseLayoutQualifier(const TSourceLoc &location);
bool checkLayoutQualifierSupported(const TSourceLoc &location,
const ImmutableString &layoutQualifierName,
int versionRequired);
bool checkWorkGroupSizeIsNotSpecified(const TSourceLoc &location,
const TLayoutQualifier &layoutQualifier);
void functionCallRValueLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *fnCall);
void checkInvariantVariableQualifier(bool invariant,
const TQualifier qualifier,
const TSourceLoc &invariantLocation);
void checkInputOutputTypeIsValidES3(const TQualifier qualifier,
const TPublicType &type,
const TSourceLoc &qualifierLocation);
void checkLocalVariableConstStorageQualifier(const TQualifierWrapperBase &qualifier);
void checkTCSOutVarIndexIsValid(TIntermBinary *binaryExpression, const TSourceLoc &location);
void checkAdvancedBlendEquationsNotSpecified(
const TSourceLoc &location,
const AdvancedBlendEquations &advancedBlendEquations,
const TQualifier &qualifier);
const TPragma &pragma() const { return mDirectiveHandler.pragma(); }
const TExtensionBehavior &extensionBehavior() const
{
return mDirectiveHandler.extensionBehavior();
}
bool isExtensionEnabled(TExtension extension) const;
void handleExtensionDirective(const TSourceLoc &loc, const char *extName, const char *behavior);
void handlePragmaDirective(const TSourceLoc &loc,
const char *name,
const char *value,
bool stdgl);
// For built-ins that can be redeclared, adjusts the type qualifier so transformations can
// identify them correctly.
void adjustRedeclaredBuiltInType(const TSourceLoc &line,
const ImmutableString &identifier,
TType *type);
// Returns true on success. *initNode may still be nullptr on success in case the initialization
// is not needed in the AST.
bool executeInitializer(const TSourceLoc &line,
const ImmutableString &identifier,
TType *type,
TIntermTyped *initializer,
TIntermBinary **initNode);
TIntermNode *addConditionInitializer(const TPublicType &pType,
const ImmutableString &identifier,
TIntermTyped *initializer,
const TSourceLoc &loc);
void beginNestedScope();
void endNestedScope();
void beginLoop(TLoopType loopType, const TSourceLoc &line);
void onLoopConditionBegin(TIntermNode *init, const TSourceLoc &line);
void onLoopConditionEnd(TIntermNode *condition, const TSourceLoc &line);
void onLoopContinueEnd(TIntermNode *statement, const TSourceLoc &line);
void onDoLoopBegin();
void onDoLoopConditionBegin();
TIntermNode *addLoop(TLoopType type,
TIntermNode *init,
TIntermNode *cond,
TIntermTyped *expr,
TIntermNode *body,
const TSourceLoc &loc);
// For "if" test nodes. There are three children: a condition, a true path, and a false path.
// The two paths are in TIntermNodePair code.
void onIfTrueBlockBegin(TIntermTyped *cond, const TSourceLoc &loc);
void onIfTrueBlockEnd();
void onIfFalseBlockBegin();
void onIfFalseBlockEnd();
TIntermNode *addIfElse(TIntermTyped *cond, TIntermNodePair code, const TSourceLoc &loc);
void addFullySpecifiedType(TPublicType *typeSpecifier);
TPublicType addFullySpecifiedType(const TTypeQualifierBuilder &typeQualifierBuilder,
const TPublicType &typeSpecifier);
TIntermDeclaration *parseSingleDeclaration(TPublicType &publicType,
const TSourceLoc &identifierOrTypeLocation,
const ImmutableString &identifier);
TIntermDeclaration *parseSingleArrayDeclaration(TPublicType &elementType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
const TSourceLoc &indexLocation,
const TVector<unsigned int> &arraySizes);
TIntermDeclaration *parseSingleInitDeclaration(const TPublicType &publicType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
const TSourceLoc &initLocation,
TIntermTyped *initializer);
// Parse a declaration like "type a[n] = initializer"
// Note that this does not apply to declarations like "type[n] a = initializer"
TIntermDeclaration *parseSingleArrayInitDeclaration(TPublicType &elementType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
const TSourceLoc &indexLocation,
const TVector<unsigned int> &arraySizes,
const TSourceLoc &initLocation,
TIntermTyped *initializer);
TIntermGlobalQualifierDeclaration *parseGlobalQualifierDeclaration(
const TTypeQualifierBuilder &typeQualifierBuilder,
const TSourceLoc &identifierLoc,
const ImmutableString &identifier,
const TSymbol *symbol);
void parseDeclarator(TPublicType &publicType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
TIntermDeclaration *declarationOut);
void parseArrayDeclarator(TPublicType &elementType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
const TSourceLoc &arrayLocation,
const TVector<unsigned int> &arraySizes,
TIntermDeclaration *declarationOut);
void parseInitDeclarator(const TPublicType &publicType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
const TSourceLoc &initLocation,
TIntermTyped *initializer,
TIntermDeclaration *declarationOut);
// Parse a declarator like "a[n] = initializer"
void parseArrayInitDeclarator(const TPublicType &elementType,
const TSourceLoc &identifierLocation,
const ImmutableString &identifier,
const TSourceLoc &indexLocation,
const TVector<unsigned int> &arraySizes,
const TSourceLoc &initLocation,
TIntermTyped *initializer,
TIntermDeclaration *declarationOut);
TIntermNode *addEmptyStatement(const TSourceLoc &location);
void parseDefaultPrecisionQualifier(const TPrecision precision,
const TPublicType &type,
const TSourceLoc &loc);
void parseGlobalLayoutQualifier(const TTypeQualifierBuilder &typeQualifierBuilder);
TIntermFunctionPrototype *addFunctionPrototypeDeclaration(const TFunction &parsedFunction,
const TSourceLoc &location);
TIntermFunctionDefinition *addFunctionDefinition(TIntermFunctionPrototype *functionPrototype,
TIntermBlock *functionBody,
const TSourceLoc &location);
void parseFunctionDefinitionHeader(const TSourceLoc &location,
const TFunction *function,
TIntermFunctionPrototype **prototypeOut);
TFunction *parseFunctionDeclarator(const TSourceLoc &location, TFunction *function);
TFunction *parseFunctionHeader(const TPublicType &type,
const ImmutableString &name,
const TSourceLoc &location);
TFunctionLookup *addNonConstructorFunc(const ImmutableString &name, const TSymbol *symbol);
TFunctionLookup *addConstructorFunc(const TPublicType &publicType);
TParameter parseParameterDeclarator(const TPublicType &type,
const ImmutableString &name,
const TSourceLoc &nameLoc);
TParameter parseParameterArrayDeclarator(const TPublicType &elementType,
const ImmutableString &name,
const TSourceLoc &nameLoc,
TVector<unsigned int> *arraySizes,
const TSourceLoc &arrayLoc);
void parseParameterQualifier(const TSourceLoc &line,
const TTypeQualifierBuilder &typeQualifierBuilder,
TPublicType &type);
void addParameter(TFunction *function, TParameter *param);
TIntermTyped *addIndexExpression(TIntermTyped *baseExpression,
const TSourceLoc &location,
TIntermTyped *indexExpression);
TIntermTyped *addFieldSelectionExpression(TIntermTyped *baseExpression,
const TSourceLoc &dotLocation,
const ImmutableString &fieldString,
const TSourceLoc &fieldLocation);
// Parse declarator for a single field
TDeclarator *parseStructDeclarator(const ImmutableString &identifier, const TSourceLoc &loc);
TDeclarator *parseStructArrayDeclarator(const ImmutableString &identifier,
const TSourceLoc &loc,
const TVector<unsigned int> *arraySizes);
void checkDoesNotHaveDuplicateFieldNames(const TFieldList *fields, const TSourceLoc &location);
void checkDoesNotHaveTooManyFields(const ImmutableString &name,
const TFieldList *fields,
const TSourceLoc &location);
TFieldList *addStructFieldList(TFieldList *fields, const TSourceLoc &location);
TFieldList *combineStructFieldLists(TFieldList *processedFields,
const TFieldList *newlyAddedFields,
const TSourceLoc &location);
TFieldList *addStructDeclaratorListWithQualifiers(
const TTypeQualifierBuilder &typeQualifierBuilder,
TPublicType *typeSpecifier,
const TDeclaratorList *declaratorList);
TFieldList *addStructDeclaratorList(const TPublicType &typeSpecifier,
const TDeclaratorList *declaratorList);
TTypeSpecifierNonArray addStructure(const TSourceLoc &structLine,
const TSourceLoc &nameLine,
const ImmutableString &structName,
TFieldList *fieldList);
TIntermDeclaration *addInterfaceBlock(const TTypeQualifierBuilder &typeQualifierBuilder,
const TSourceLoc &nameLine,
const ImmutableString &blockName,
TFieldList *fieldList,
const ImmutableString &instanceName,
const TSourceLoc &instanceLine,
const TVector<unsigned int> *arraySizes,
const TSourceLoc &arraySizesLine);
void parseLocalSize(const ImmutableString &qualifierType,
const TSourceLoc &qualifierTypeLine,
int intValue,
const TSourceLoc &intValueLine,
const std::string &intValueString,
size_t index,
sh::WorkGroupSize *localSize);
void parseNumViews(int intValue,
const TSourceLoc &intValueLine,
const std::string &intValueString,
int *numViews);
void parseInvocations(int intValue,
const TSourceLoc &intValueLine,
const std::string &intValueString,
int *numInvocations);
void parseMaxVertices(int intValue,
const TSourceLoc &intValueLine,
const std::string &intValueString,
int *numMaxVertices);
void parseVertices(int intValue,
const TSourceLoc &intValueLine,
const std::string &intValueString,
int *numVertices);
void parseIndexLayoutQualifier(int intValue,
const TSourceLoc &intValueLine,
const std::string &intValueString,
int *index);
TLayoutQualifier parseLayoutQualifier(const ImmutableString &qualifierType,
const TSourceLoc &qualifierTypeLine);
TLayoutQualifier parseLayoutQualifier(const ImmutableString &qualifierType,
const TSourceLoc &qualifierTypeLine,
int intValue,
const TSourceLoc &intValueLine);
TTypeQualifierBuilder *createTypeQualifierBuilder(const TSourceLoc &loc);
TStorageQualifierWrapper *parseGlobalStorageQualifier(TQualifier qualifier,
const TSourceLoc &loc);
TStorageQualifierWrapper *parseVaryingQualifier(const TSourceLoc &loc);
TStorageQualifierWrapper *parseInQualifier(const TSourceLoc &loc);
TStorageQualifierWrapper *parseOutQualifier(const TSourceLoc &loc);
TStorageQualifierWrapper *parseInOutQualifier(const TSourceLoc &loc);
TLayoutQualifier joinLayoutQualifiers(TLayoutQualifier leftQualifier,
TLayoutQualifier rightQualifier,
const TSourceLoc &rightQualifierLocation);
// Performs an error check for embedded struct declarations.
void enterStructDeclaration(const TSourceLoc &line, const ImmutableString &identifier);
void exitStructDeclaration();
void checkIsBelowStructNestingLimit(const TSourceLoc &line, const TField &field);
void beginSwitch(const TSourceLoc &line, TIntermTyped *init);
TIntermSwitch *addSwitch(TIntermTyped *init,
TIntermBlock *statementList,
const TSourceLoc &loc);
TIntermCase *addCase(TIntermTyped *condition, const TSourceLoc &loc);
TIntermCase *addDefault(const TSourceLoc &loc);
TIntermTyped *addUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
TIntermTyped *addUnaryMathLValue(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
TIntermTyped *addBinaryMath(TOperator op,
TIntermTyped *left,
TIntermTyped *right,
const TSourceLoc &loc);
TIntermTyped *addBinaryMathBooleanResult(TOperator op,
TIntermTyped *left,
TIntermTyped *right,
const TSourceLoc &loc);
TIntermTyped *addAssign(TOperator op,
TIntermTyped *left,
TIntermTyped *right,
const TSourceLoc &loc);
void onShortCircuitAndBegin(TIntermTyped *left, const TSourceLoc &loc);
void onShortCircuitOrBegin(TIntermTyped *left, const TSourceLoc &loc);
void onCommaLeftHandSideParsed(TIntermTyped *left);
TIntermTyped *addComma(TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
TIntermBranch *addBranch(TOperator op, const TSourceLoc &loc);
TIntermBranch *addBranch(TOperator op, TIntermTyped *expression, const TSourceLoc &loc);
void appendStatement(TIntermBlock *block, TIntermNode *statement);
void checkTextureGather(TIntermAggregate *functionCall);
void checkTextureOffset(TIntermAggregate *functionCall);
void checkImageMemoryAccessForBuiltinFunctions(TIntermAggregate *functionCall);
void checkImageMemoryAccessForUserDefinedFunctions(const TFunction *functionDefinition,
const TIntermAggregate *functionCall);
void checkAtomicMemoryBuiltinFunctions(TIntermAggregate *functionCall);
void checkInterpolationFS(TIntermAggregate *functionCall);
// fnCall is only storing the built-in op, and function name or constructor type. arguments
// has the arguments.
TIntermTyped *addFunctionCallOrMethod(TFunctionLookup *fnCall, const TSourceLoc &loc);
void onTernaryConditionParsed(TIntermTyped *cond, const TSourceLoc &line);
void onTernaryTrueExpressionParsed(TIntermTyped *trueExpression, const TSourceLoc &line);
TIntermTyped *addTernarySelection(TIntermTyped *cond,
TIntermTyped *trueExpression,
TIntermTyped *falseExpression,
const TSourceLoc &line);
uint32_t getClipDistanceArraySize() const
{
return mClipDistanceInfo.size > 0 ? mClipDistanceInfo.size : mClipDistanceInfo.maxIndex + 1;
}
uint32_t getCullDistanceArraySize() const
{
return mCullDistanceInfo.size > 0 ? mCullDistanceInfo.size : mCullDistanceInfo.maxIndex + 1;
}
bool isClipDistanceRedeclared() const { return mClipDistanceInfo.size > 0; }
bool isCullDistanceRedeclared() const { return mCullDistanceInfo.size > 0; }
bool isClipDistanceUsed() const
{
return mClipDistanceInfo.maxIndex >= 0 || mClipDistanceInfo.hasNonConstIndex;
}
int getGeometryShaderMaxVertices() const { return mGeometryShaderMaxVertices; }
int getGeometryShaderInvocations() const
{
return (mGeometryShaderInvocations > 0) ? mGeometryShaderInvocations : 1;
}
TLayoutPrimitiveType getGeometryShaderInputPrimitiveType() const
{
return mGeometryShaderInputPrimitiveType;
}
TLayoutPrimitiveType getGeometryShaderOutputPrimitiveType() const
{
return mGeometryShaderOutputPrimitiveType;
}
int getTessControlShaderOutputVertices() const { return mTessControlShaderOutputVertices; }
TLayoutTessEvaluationType getTessEvaluationShaderInputPrimitiveType() const
{
return mTessEvaluationShaderInputPrimitiveType;
}
TLayoutTessEvaluationType getTessEvaluationShaderInputVertexSpacingType() const
{
return mTessEvaluationShaderInputVertexSpacingType;
}
TLayoutTessEvaluationType getTessEvaluationShaderInputOrderingType() const
{
return mTessEvaluationShaderInputOrderingType;
}
TLayoutTessEvaluationType getTessEvaluationShaderInputPointType() const
{
return mTessEvaluationShaderInputPointType;
}
void markShaderHasPrecise() { mHasAnyPreciseType = true; }
bool hasAnyPreciseType() const { return mHasAnyPreciseType; }
AdvancedBlendEquations getAdvancedBlendEquations() const { return mAdvancedBlendEquations; }
ShShaderOutput getOutputType() const { return mOutputType; }
// Pop the side effect of a statement when it's discarded, like when ; is encountered.
void endStatementWithValue(TIntermNode *statement);
bool postParseChecks();
const ShCompileOptions &getCompileOptions() const { return mCompileOptions; }
// TODO(jmadill): make this private
TSymbolTable &symbolTable; // symbol table that goes with the language currently being parsed
private:
class AtomicCounterBindingState;
constexpr static size_t kAtomicCounterSize = 4;
// UNIFORM_ARRAY_STRIDE for atomic counter arrays is an implementation-dependent value which
// can be queried after a program is linked according to ES 3.10 section 7.7.1. This is
// controversial with the offset inheritance as described in ESSL 3.10 section 4.4.6. Currently
// we treat it as always 4 in favour of the original interpretation in
// "ARB_shader_atomic_counters".
// TODO(jie.a.chen@intel.com): Double check this once the spec vagueness is resolved.
// Note that there may be tests in AtomicCounter_test that will need to be updated as well.
constexpr static size_t kAtomicCounterArrayStride = 4;
void markStaticUseIfSymbol(TIntermNode *node);
// Returns a clamped index. If it prints out an error message, the token is "[]".
int checkIndexLessThan(bool outOfRangeIndexIsError,
const TSourceLoc &location,
int index,
unsigned int arraySize,
const char *reason);
bool declareVariable(const TSourceLoc &line,
const ImmutableString &identifier,
const TType *type,
GeomTessArray sized,
TVariable **variable);
void checkNestingLevel(const TSourceLoc &line);
bool checkCase(const TSourceLoc &line, int64_t caseValue, const char *caseOrDefault);
void checkCanBeDeclaredWithoutInitializer(const TSourceLoc &line,
const ImmutableString &identifier,
TType *type);
void checkDeclarationIsValidArraySize(const TSourceLoc &line,
const ImmutableString &identifier,
TType *type);
bool checkIsValidTypeAndQualifierForArray(const TSourceLoc &indexLocation,
const TPublicType &elementType);
// Done for all atomic counter declarations, whether empty or not.
void atomicCounterQualifierErrorCheck(const TPublicType &publicType,
const TSourceLoc &location);
// Assumes that multiplication op has already been set based on the types.
bool isMultiplicationTypeCombinationValid(TOperator op, const TType &left, const TType &right);
void checkInternalFormatIsNotSpecified(const TSourceLoc &location,
TLayoutImageInternalFormat internalFormat);
void checkMemoryQualifierIsNotSpecified(const TMemoryQualifier &memoryQualifier,
const TSourceLoc &location);
void checkAtomicCounterOffsetIsValid(bool forceAppend, const TSourceLoc &loc, TType *type);
void checkAtomicCounterOffsetDoesNotOverlap(bool forceAppend,
const TSourceLoc &loc,
TType *type);
void checkAtomicCounterOffsetAlignment(const TSourceLoc &location, const TType &type);
void checkAtomicCounterOffsetLimit(const TSourceLoc &location, const TType &type);
void checkIndexIsNotSpecified(const TSourceLoc &location, int index);
void checkBindingIsValid(const TSourceLoc &identifierLocation, const TType &type);
void checkBindingIsNotSpecified(const TSourceLoc &location, int binding);
void checkOffsetIsNotSpecified(const TSourceLoc &location, int offset);
void checkImageBindingIsValid(const TSourceLoc &location,
int binding,
int arrayTotalElementCount);
void checkSamplerBindingIsValid(const TSourceLoc &location,
int binding,
int arrayTotalElementCount);
void checkBlockBindingIsValid(const TSourceLoc &location,
const TQualifier &qualifier,
int binding,
int arraySize);
void checkAtomicCounterBindingIsValid(const TSourceLoc &location, int binding);
void checkPixelLocalStorageBindingIsValid(const TSourceLoc &, const TType &);
void checkUniformLocationInRange(const TSourceLoc &location,
int objectLocationCount,
const TLayoutQualifier &layoutQualifier);
void checkAttributeLocationInRange(const TSourceLoc &location,
int objectLocationCount,
const TLayoutQualifier &layoutQualifier);
void checkDepthIsNotSpecified(const TSourceLoc &location, TLayoutDepth depth);
void checkYuvIsNotSpecified(const TSourceLoc &location, bool yuv);
void checkEarlyFragmentTestsIsNotSpecified(const TSourceLoc &location, bool earlyFragmentTests);
void checkNoncoherentIsSpecified(const TSourceLoc &location, bool noncoherent);
void checkNoncoherentIsNotSpecified(const TSourceLoc &location, bool noncoherent);
bool checkUnsizedArrayConstructorArgumentDimensionality(const TIntermSequence &arguments,
TType type,
const TSourceLoc &line);
// Check texture offset is within range.
void checkSingleTextureOffset(const TSourceLoc &line,
const TConstantUnion *values,
size_t size,
int minOffsetValue,
int maxOffsetValue);
// Will set the size of the outermost array according to geometry shader input layout.
void checkGeometryShaderInputAndSetArraySize(const TSourceLoc &location,
const ImmutableString &token,
TType *type,
GeomTessArray *sizedOut);
// Similar, for tessellation shaders.
void checkTessellationShaderUnsizedArraysAndSetSize(const TSourceLoc &location,
const ImmutableString &token,
TType *type,
GeomTessArray *sizedOut);
// Will size any unsized array type so unsized arrays won't need to be taken into account
// further along the line in parsing.
void checkIsNotUnsizedArray(const TSourceLoc &line,
const char *errorMessage,
const ImmutableString &token,
TType *arrayType);
TIntermTyped *addBinaryMathInternal(TOperator op,
TIntermTyped *left,
TIntermTyped *right,
const TSourceLoc &loc);
TIntermTyped *createUnaryMath(TOperator op,
TIntermTyped *child,
const TSourceLoc &loc,
const TFunction *func);
TIntermTyped *addMethod(TFunctionLookup *fnCall, const TSourceLoc &loc);
TIntermTyped *addConstructor(TFunctionLookup *fnCall, const TSourceLoc &line);
TIntermTyped *addNonConstructorFunctionCallImpl(TFunctionLookup *fnCall, const TSourceLoc &loc);
TIntermTyped *addNonConstructorFunctionCall(TFunctionLookup *fnCall, const TSourceLoc &loc);
// Return either the original expression or the folded version of the expression in case the
// folded node will validate the same way during subsequent parsing.
TIntermTyped *expressionOrFoldedResult(TIntermTyped *expression);
// Return true if the checks pass
bool binaryOpCommonCheck(TOperator op,
TIntermTyped *left,
TIntermTyped *right,
const TSourceLoc &loc);
TIntermFunctionPrototype *createPrototypeNodeFromFunction(const TFunction &function,
const TSourceLoc &location,
bool insertParametersToSymbolTable);
void checkESSL100ForLoopInit(TIntermNode *init, const TSourceLoc &line);
void checkESSL100ForLoopCondition(TIntermNode *condition, const TSourceLoc &line);
void checkESSL100ForLoopContinue(TIntermNode *statement, const TSourceLoc &line);
void checkESSL100NoLoopSymbolAssign(TIntermSymbol *symbol, const TSourceLoc &line);
void checkESSL100ConstantIndex(TIntermTyped *index, const TSourceLoc &line);
bool isESSL100ConstantLoopSymbol(TIntermSymbol *symbol);
void checkCallGraph();
void setAtomicCounterBindingDefaultOffset(const TPublicType &declaration,
const TSourceLoc &location);
bool checkPrimitiveTypeMatchesTypeQualifier(const TTypeQualifier &typeQualifier);
bool parseGeometryShaderInputLayoutQualifier(const TTypeQualifier &typeQualifier);
bool parseGeometryShaderOutputLayoutQualifier(const TTypeQualifier &typeQualifier);
void setGeometryShaderInputArraySize(unsigned int inputArraySize, const TSourceLoc &line);
bool parseTessControlShaderOutputLayoutQualifier(const TTypeQualifier &typeQualifier);
bool parseTessEvaluationShaderInputLayoutQualifier(const TTypeQualifier &typeQualifier);
void checkVariableSize(const TSourceLoc &line,
const ImmutableString &identifier,
const TType *type);
void checkVaryingLocations(const TSourceLoc &line, const TVariable *variable);
void checkFragmentOutputLocations(const TSourceLoc &line, const TVariable *variable);
void checkVariableLocations(const TSourceLoc &line, const TVariable *variable);
void postParseValidateFragmentOutputLocations();
void sizeUnsizedArrayTypes(uint32_t arraySize);
enum class ControlFlowType
{
// Control flow nested under `if`.
If,
// Control flow nested under `for`, `while` or `do { ... } while`.
Loop,
// Control flow nested under `switch`.
Switch,
// Not a divergent control flow, but nested under a new `{}` scope.
NewScope,
};
bool isNestedIn(ControlFlowType type) const;
bool isDirectlyUnderSwitch() const;
void popControlFlow();
// Used to derive the IR type id of TType's that are statically allocated, which (currently)
// don't have an assigned type id. Once IR is the only path, static TTypes (used to bake the
// built-in variables and functions) can be simplified and the ID predefined and included with
// it.
ir::TypeId getTypeId(const TType &type);
// For built-ins, declare them in the IR on first use.
ir::VariableId declareBuiltInOnFirstUse(const TVariable *variable);
// Declare the variable to IR on declaration, or in the case of unsized geometry/tessellation
// arrays, whenever the size is determined.
void declareIRVariable(const TVariable *variable, GeomTessArray sized);
// Declare the function to the IR builder. If it's a definition and a prototype was previously
// seen, the parameter names are updated instead.
void declareFunction(const TFunction *function, FunctionDeclaration declaration);
// Push a variable to the IR builder.
void pushVariable(const TVariable *variable);
// Push a constant to the IR builder.
const TConstantUnion *pushConstant(const TConstantUnion *constant, const TType &type);
// Certain operations become illegal only iff the shader declares pixel local storage uniforms.
enum class PLSIllegalOperations
{
// When polyfilled with shader images, pixel local storage requires early_fragment_tests,
// which causes discard to interact differently with the depth and stencil tests.
//
// To ensure identical behavior across all backends (some of which may not have access to
// early_fragment_tests), we disallow discard if pixel local storage uniforms have been
// declared.
Discard,
// ARB_fragment_shader_interlock functions cannot be called within flow control, which
// includes any code that might execute after a return statement. To keep things simple, and
// since these "interlock" calls are automatically injected by the compiler inside of
// main(), we disallow return from main() if pixel local storage uniforms have been
// declared.
ReturnFromMain,
// When polyfilled with shader images, pixel local storage requires early_fragment_tests,
// which causes assignments to gl_FragDepth(EXT) and gl_SampleMask to be ignored.
//
// To ensure identical behavior across all backends, we disallow assignment to these values
// if pixel local storage uniforms have been declared.
AssignFragDepth,
AssignSampleMask,
// EXT_blend_func_extended may restrict the number of draw buffers with a nonzero output
// index, which can invalidate a PLS implementation.
FragDataIndexNonzero,
// KHR_blend_equation_advanced is incompatible with multiple draw buffers, which is a
// required feature for many PLS implementations.
EnableAdvancedBlendEquation,
};
// Generates an error if any pixel local storage uniforms have been declared (more specifically,
// if mPLSLayouts is not empty).
//
// If no pixel local storage uniforms have been declared, and if the PLS extension is enabled,
// saves the potential error to mPLSPotentialErrors in case we encounter a PLS uniform later.
void errorIfPLSDeclared(const TSourceLoc &, PLSIllegalOperations);
// Set to true when the last/current declarator list was started with an empty declaration. The
// non-empty declaration error check will need to be performed if the empty declaration is
// followed by a declarator.
bool mDeferredNonEmptyDeclarationErrorCheck;
sh::GLenum mShaderType; // vertex/fragment/geometry/etc shader
ShShaderSpec mShaderSpec; // The language specification compiler conforms to - GLES/WebGL/etc.
ShCompileOptions mCompileOptions; // Options passed to TCompiler
const ShBuiltInResources &mResources; // Limits passed to TCompiler
int mShaderVersion;
TIntermBlock *mTreeRoot; // root of parse tree being created
int mStructNestingLevel; // incremented while parsing a struct declaration
const TFunction *mCurrentFunction; // the function that's currently being parsed
bool mFunctionReturnsValue; // true if a non-void function has a return
bool mEarlyFragmentTestsSpecified; // true if layout(early_fragment_tests) in; is specified.
bool mHasDiscard; // true if |discard| is encountered in the shader.
bool mSampleQualifierSpecified; // true if the |sample| qualifier is used
bool mPositionRedeclaredForSeparateShaderObject; // true if EXT_separate_shader_objects is
// enabled and gl_Position is redefined.
bool mPointSizeRedeclaredForSeparateShaderObject; // true if EXT_separate_shader_objects is
// enabled and gl_PointSize is redefined.
bool mPositionOrPointSizeUsedForSeparateShaderObject; // true if gl_Position or gl_PointSize
// has been referenced.
bool mUsesDerivatives; // true if screen-space derivatives are used implicitly or explicitly
TLayoutMatrixPacking mDefaultUniformMatrixPacking;
TLayoutBlockStorage mDefaultUniformBlockStorage;
TLayoutMatrixPacking mDefaultBufferMatrixPacking;
TLayoutBlockStorage mDefaultBufferBlockStorage;
TString mHashErrMsg;
TDiagnostics *mDiagnostics;
TDirectiveHandler mDirectiveHandler;
angle::pp::Preprocessor mPreprocessor;
void *mScanner;
// Keep track of clip/cull distance redeclaration, accessed indices, etc so that gl_ClipDistance
// and gl_CullDistance can be validated and sized at the end of compilation.
ClipCullDistanceInfo mClipDistanceInfo;
ClipCullDistanceInfo mCullDistanceInfo;
// Keep track of local group size declared in layout. It should be declared only once.
bool mComputeShaderLocalSizeDeclared;
sh::WorkGroupSize mComputeShaderLocalSize;
// Keep track of number of views declared in layout.
int mNumViews;
// Maximum number of uniform blocks allowed to be declared in this shader. Taken from the
// built-in resources and resolved to this shader type.
unsigned int mMaxUniformBlocks;
// Current count of declared uniform blocks.
unsigned int mNumUniformBlocks;
// Keeps track of whether any of the built-ins that can be redeclared (see
// IsRedeclarableBuiltIn()) has been marked as invariant/precise before the possible
// redeclaration.
//
// If redeclared after being marked as invariant/precise, a compile error is generated.
// The GLSL spec does not explicitly call this out as invalid, but it's not a useful sequence
// of statements (invariant/precise could have been directly specified on the redeclaration),
// and there are no known users.
TUnorderedMap<TQualifier, bool> mBuiltInQualified;
// Keeps track whether we are declaring / defining a function
bool mDeclaringFunction;
// Keeps track whether we are declaring / defining the function main().
bool mDeclaringMain;
const TFunction *mMainFunction;
// Whether `return` has been observed in `main()`. Used to validate barrier() in tessellation
// control shaders which are not allowed after `return`.
bool mIsReturnVisitedInMain;
// Keeps track of the total size of shader-private variables, if validating that this size
// should not exceed a sensible threshold.
angle::base::CheckedNumeric<size_t> mTotalPrivateVariablesSize;
// Track state related to control flow, used for various validation:
//
// * That case is within switch, continue is within loop, and break is within loop or switch
// * That the shader statements don't get too nested (based on `MaxStatementDepth`)
// * In tessellation control shaders, barrier() cannot be called in divergent control flow.
// * ESSL 1.0 limits restricts the shape of `for` loops (see Appendix A)
// * ESSL 1.0 limits array indices to `constant-index-expressions` (see Appendix A)
// * Rejection of obvious infinite loops with WebGL.
struct ControlFlow
{
ControlFlowType type;
// Used when validating ESSL 1.0 limitations for `for` loops.
TSymbolUniqueId forLoopSymbol = TSymbolUniqueId::kInvalid();
bool isForLoopSymbolConstant = false;
// Used to detect and reject infinite loops with WebGL.
TSourceLoc loopLocation = kNoSourceLoc;
bool isLoopConditionConstantTrue = false;
const TVariable *loopConditionConstantTrueSymbol = nullptr;
bool hasBreak = false;
bool hasReturn = false;
// Used to detect and reject invalid `case` placements in a switch.
// int64_t is used to include both signed and unsigned case values (which are 32-bit). The
// default case uses a number outside the [INT_MIN, UINT_MAX] range.
TBasicType switchType = EbtInt;
static constexpr int64_t kDefaultCaseLabel = std::numeric_limits<int64_t>::max();
TVector<int64_t> caseLabels;
};
std::vector<ControlFlow> mControlFlow;
// Whether ESSL 1.0 limitations in Appendix A must be enforced.
bool mValidateESSL100Limitations;
// Whether the variable is initialized to true, and never modified. If this is used as a loop
// variable, where the loop doesn't have break or return, at the end of parse we can detect
// these loops as infinite loop.
TUnorderedSet<TSymbolUniqueId> mConstantTrueVariables;
TVector<VariableAndLocation> mPossiblyInfiniteLoops;
// Track the static call graph. Static recursion is disallowed by GLSL.
TUnorderedMap<const TFunction *, TUnorderedSet<const TFunction *>> mCallGraph;
// Track functions that have been defined. At the end of parse, if any
// function is called that's not in this list, it's a compile error.
TUnorderedSet<const TFunction *> mDefinedFunctions;
// Track the state of each atomic counter binding.
std::map<int, AtomicCounterBindingState> mAtomicCounterBindingStates;
// Track the layout qualifier of each pixel local storage binding.
std::map<int, ShPixelLocalStorageLayout> mPLSLayouts;
// Potential errors to generate immediately upon encountering a pixel local storage uniform.
std::vector<std::tuple<const TSourceLoc, PLSIllegalOperations>> mPLSPotentialErrors;
// Track the locations used by input and output varyings to detect conflicts.
LocationValidationMap mInputVaryingLocations;
LocationValidationMap mOutputVaryingLocations;
// Track the locations used by fragment shader outputs to detect conflicts.
TVector<VariableAndLocation> mFragmentOutputsWithLocation;
TVector<VariableAndLocation> mFragmentOutputsWithoutLocation;
TVector<VariableAndLocation> mFragmentOutputsYuv;
bool mFragmentOutputIndex1Used;
bool mFragmentOutputFragDepthUsed;
// Track the geometry shader global parameters declared in layout.
TLayoutPrimitiveType mGeometryShaderInputPrimitiveType;
TLayoutPrimitiveType mGeometryShaderOutputPrimitiveType;
int mGeometryShaderInvocations;
int mGeometryShaderMaxVertices;
unsigned int mGeometryInputArraySize;
int mTessControlShaderOutputVertices;
TLayoutTessEvaluationType mTessEvaluationShaderInputPrimitiveType;
TLayoutTessEvaluationType mTessEvaluationShaderInputVertexSpacingType;
TLayoutTessEvaluationType mTessEvaluationShaderInputOrderingType;
TLayoutTessEvaluationType mTessEvaluationShaderInputPointType;
// List of array declarations without an explicit size that have come before layout(vertices=N).
// Once the vertex count is specified, these arrays are sized.
TVector<TType *> mDeferredArrayTypesToSize;
// For the IR, the variables themselves are declared late instead of having to go through a
// retype.
TVector<const TVariable *> mDeferredArrayVariablesToSize;
// Whether the |precise| keyword has been seen in the shader.
bool mHasAnyPreciseType;
AdvancedBlendEquations mAdvancedBlendEquations;
// Track when we add new scope for func body in ESSL 1.00 spec
bool mFunctionBodyNewScope;
ShShaderOutput mOutputType;
ir::Builder mIRBuilder;
// Support for creating the IR while the translator still has the option to not go through the
// IR path. Once AST generation during parse is removed, TParseContext can instead keep track
// of IDs directly, instead of TSymbol derivatives, together with an array-based mapping to
// validation info including type and variable data.
struct VariableToIdInfo
{
ir::VariableId id;
// For nameless interface blocks, the shader directly references the fields. The IR instead
// selects a field from the block variable, which is found in |id|.
static constexpr uint32_t kNoImplicitField = 0xFFFF'FFFF;
uint32_t implicitField = kNoImplicitField;
};
angle::HashMap<const TSymbol *, ir::TypeId> mSymbolToTypeId;
angle::HashMap<const TVariable *, VariableToIdInfo> mVariableToId;
angle::HashMap<const TFunction *, ir::FunctionId> mFunctionToId;
};
int PaParseStrings(angle::Span<const char *const> string,
const int length[],
TParseContext *context);
} // namespace sh
#endif // COMPILER_TRANSLATOR_PARSECONTEXT_H_