diff options
author | Andrew Knight <andrew.knight@digia.com> | 2014-08-05 12:59:44 +0300 |
---|---|---|
committer | Andrew Knight <andrew.knight@digia.com> | 2014-08-05 16:43:22 +0200 |
commit | a6a12d8c0fc918972c15268f749ecc7c90b95d6c (patch) | |
tree | cb6d986d30ef97e932ab51768854d5d9b46729d3 /src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp | |
parent | 14f9c09542bd6cc19430473da9ce4c68f239ec7d (diff) |
ANGLE: upgrade to 2.1~07d49ef5350a
This version of ANGLE provides partial ES3 support, numerous
bug fixes, and several potentially useful vendor extensions.
All patches have been rebased. The following changes are noted:
0000-General-fixes-for-ANGLE-2.1.patch
contains compile fixes for the new ANGLE
0004-Make-it-possible-to-link-ANGLE-statically-for-single.patch
has incorporated patch 0015.
0007-Make-DX9-DX11-mutually-exclusive.patch
has been removed as it was fixed upstream.
0007-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
has been moved up to fill the patch number gap.
0010-ANGLE-Enable-D3D11-for-feature-level-9-cards.patch
now contains patch 0014 and 0017.
0013-ANGLE-Allow-for-universal-program-binaries.patch
has been removed as it is no longer relevant.
0014-ANGLE-D3D11-Fix-internal-index-buffer-for-level-9-ha.patch
has been merged with patch 0010.
0015-ANGLE-Don-t-export-DLLMain-functions-for-static-buil.patch
has been merged with patch 0004.
0016-ANGLE-WinRT-Call-Trim-when-application-suspends.patch
has been removed and will be replaced by a follow-up patch using a
different technique.
0017-ANGLE-D3D11-Don-t-use-mipmaps-in-level-9-textures.patch
has been merged with patch 0010.
0018-ANGLE-WinRT-Create-swap-chain-using-physical-resolut.patch
has been removed and will be replaced by a follow-up patch extending
the EGL_ANGLE_window_fixed_size extension.
0019-Fix-ANGLE-build-with-Microsoft-Visual-Studio-14-CTP.patch
is now patch 0007.
[ChangeLog][Third-party libraries] ANGLE has been upgraded to
version 2.1, bringing partial support for OpenGL ES3 over
Direct3D 11, numerous bug fixes, and several new vendor extensions.
Change-Id: I6d95ce1480462d67228d83c1e5c74a1706b5b21c
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@digia.com>
Diffstat (limited to 'src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp')
-rw-r--r-- | src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp | 428 |
1 files changed, 236 insertions, 192 deletions
diff --git a/src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp b/src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp index 3c2cc41cda..c1a7b7524f 100644 --- a/src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp +++ b/src/3rdparty/angle/src/compiler/translator/ValidateLimitations.cpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. +// Copyright (c) 2002-2013 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. // @@ -8,26 +8,10 @@ #include "compiler/translator/InfoSink.h" #include "compiler/translator/InitializeParseContext.h" #include "compiler/translator/ParseContext.h" +#include "angle_gl.h" -namespace { -bool IsLoopIndex(const TIntermSymbol* symbol, const TLoopStack& stack) { - for (TLoopStack::const_iterator i = stack.begin(); i != stack.end(); ++i) { - if (i->index.id == symbol->getId()) - return true; - } - return false; -} - -void MarkLoopForUnroll(const TIntermSymbol* symbol, TLoopStack& stack) { - for (TLoopStack::iterator i = stack.begin(); i != stack.end(); ++i) { - if (i->index.id == symbol->getId()) { - ASSERT(i->loop != NULL); - i->loop->setUnrollFlag(true); - return; - } - } - UNREACHABLE(); -} +namespace +{ // Traverses a node to check if it represents a constant index expression. // Definition: @@ -38,110 +22,146 @@ void MarkLoopForUnroll(const TIntermSymbol* symbol, TLoopStack& stack) { // - Constant expressions // - Loop indices as defined in section 4 // - Expressions composed of both of the above -class ValidateConstIndexExpr : public TIntermTraverser { -public: - ValidateConstIndexExpr(const TLoopStack& stack) +class ValidateConstIndexExpr : public TIntermTraverser +{ + public: + ValidateConstIndexExpr(TLoopStack& stack) : mValid(true), mLoopStack(stack) {} // Returns true if the parsed node represents a constant index expression. bool isValid() const { return mValid; } - virtual void visitSymbol(TIntermSymbol* symbol) { + virtual void visitSymbol(TIntermSymbol *symbol) + { // Only constants and loop indices are allowed in a // constant index expression. - if (mValid) { + if (mValid) + { mValid = (symbol->getQualifier() == EvqConst) || - IsLoopIndex(symbol, mLoopStack); + (mLoopStack.findLoop(symbol)); } } -private: + private: bool mValid; - const TLoopStack& mLoopStack; + TLoopStack& mLoopStack; }; -// Traverses a node to check if it uses a loop index. -// If an int loop index is used in its body as a sampler array index, -// mark the loop for unroll. -class ValidateLoopIndexExpr : public TIntermTraverser { -public: - ValidateLoopIndexExpr(TLoopStack& stack) - : mUsesFloatLoopIndex(false), - mUsesIntLoopIndex(false), - mLoopStack(stack) {} - - bool usesFloatLoopIndex() const { return mUsesFloatLoopIndex; } - bool usesIntLoopIndex() const { return mUsesIntLoopIndex; } - - virtual void visitSymbol(TIntermSymbol* symbol) { - if (IsLoopIndex(symbol, mLoopStack)) { - switch (symbol->getBasicType()) { - case EbtFloat: - mUsesFloatLoopIndex = true; - break; - case EbtInt: - mUsesIntLoopIndex = true; - MarkLoopForUnroll(symbol, mLoopStack); - break; - default: - UNREACHABLE(); - } - } +const char *GetOperatorString(TOperator op) +{ + switch (op) + { + case EOpInitialize: return "="; + case EOpAssign: return "="; + case EOpAddAssign: return "+="; + case EOpSubAssign: return "-="; + case EOpDivAssign: return "/="; + + // Fall-through. + case EOpMulAssign: + case EOpVectorTimesMatrixAssign: + case EOpVectorTimesScalarAssign: + case EOpMatrixTimesScalarAssign: + case EOpMatrixTimesMatrixAssign: return "*="; + + // Fall-through. + case EOpIndexDirect: + case EOpIndexIndirect: return "[]"; + + case EOpIndexDirectStruct: + case EOpIndexDirectInterfaceBlock: return "."; + case EOpVectorSwizzle: return "."; + case EOpAdd: return "+"; + case EOpSub: return "-"; + case EOpMul: return "*"; + case EOpDiv: return "/"; + case EOpMod: UNIMPLEMENTED(); break; + case EOpEqual: return "=="; + case EOpNotEqual: return "!="; + case EOpLessThan: return "<"; + case EOpGreaterThan: return ">"; + case EOpLessThanEqual: return "<="; + case EOpGreaterThanEqual: return ">="; + + // Fall-through. + case EOpVectorTimesScalar: + case EOpVectorTimesMatrix: + case EOpMatrixTimesVector: + case EOpMatrixTimesScalar: + case EOpMatrixTimesMatrix: return "*"; + + case EOpLogicalOr: return "||"; + case EOpLogicalXor: return "^^"; + case EOpLogicalAnd: return "&&"; + case EOpNegative: return "-"; + case EOpVectorLogicalNot: return "not"; + case EOpLogicalNot: return "!"; + case EOpPostIncrement: return "++"; + case EOpPostDecrement: return "--"; + case EOpPreIncrement: return "++"; + case EOpPreDecrement: return "--"; + + case EOpRadians: return "radians"; + case EOpDegrees: return "degrees"; + case EOpSin: return "sin"; + case EOpCos: return "cos"; + case EOpTan: return "tan"; + case EOpAsin: return "asin"; + case EOpAcos: return "acos"; + case EOpAtan: return "atan"; + case EOpExp: return "exp"; + case EOpLog: return "log"; + case EOpExp2: return "exp2"; + case EOpLog2: return "log2"; + case EOpSqrt: return "sqrt"; + case EOpInverseSqrt: return "inversesqrt"; + case EOpAbs: return "abs"; + case EOpSign: return "sign"; + case EOpFloor: return "floor"; + case EOpCeil: return "ceil"; + case EOpFract: return "fract"; + case EOpLength: return "length"; + case EOpNormalize: return "normalize"; + case EOpDFdx: return "dFdx"; + case EOpDFdy: return "dFdy"; + case EOpFwidth: return "fwidth"; + case EOpAny: return "any"; + case EOpAll: return "all"; + + default: break; } + return ""; +} -private: - bool mUsesFloatLoopIndex; - bool mUsesIntLoopIndex; - TLoopStack& mLoopStack; -}; -} // namespace +} // namespace anonymous -ValidateLimitations::ValidateLimitations(ShShaderType shaderType, - TInfoSinkBase& sink) +ValidateLimitations::ValidateLimitations(sh::GLenum shaderType, + TInfoSinkBase &sink) : mShaderType(shaderType), mSink(sink), mNumErrors(0) { } -bool ValidateLimitations::visitBinary(Visit, TIntermBinary* node) +bool ValidateLimitations::visitBinary(Visit, TIntermBinary *node) { // Check if loop index is modified in the loop body. validateOperation(node, node->getLeft()); // Check indexing. - switch (node->getOp()) { + switch (node->getOp()) + { case EOpIndexDirect: - validateIndexing(node); - break; case EOpIndexIndirect: -#if defined(__APPLE__) - // Loop unrolling is a work-around for a Mac Cg compiler bug where it - // crashes when a sampler array's index is also the loop index. - // Once Apple fixes this bug, we should remove the code in this CL. - // See http://codereview.appspot.com/4331048/. - if ((node->getLeft() != NULL) && (node->getRight() != NULL) && - (node->getLeft()->getAsSymbolNode())) { - TIntermSymbol* symbol = node->getLeft()->getAsSymbolNode(); - if (IsSampler(symbol->getBasicType()) && symbol->isArray()) { - ValidateLoopIndexExpr validate(mLoopStack); - node->getRight()->traverse(&validate); - if (validate.usesFloatLoopIndex()) { - error(node->getLine(), - "sampler array index is float loop index", - "for"); - } - } - } -#endif validateIndexing(node); break; - default: break; + default: + break; } return true; } -bool ValidateLimitations::visitUnary(Visit, TIntermUnary* node) +bool ValidateLimitations::visitUnary(Visit, TIntermUnary *node) { // Check if loop index is modified in the loop body. validateOperation(node, node->getOperand()); @@ -149,7 +169,7 @@ bool ValidateLimitations::visitUnary(Visit, TIntermUnary* node) return true; } -bool ValidateLimitations::visitAggregate(Visit, TIntermAggregate* node) +bool ValidateLimitations::visitAggregate(Visit, TIntermAggregate *node) { switch (node->getOp()) { case EOpFunctionCall: @@ -161,22 +181,20 @@ bool ValidateLimitations::visitAggregate(Visit, TIntermAggregate* node) return true; } -bool ValidateLimitations::visitLoop(Visit, TIntermLoop* node) +bool ValidateLimitations::visitLoop(Visit, TIntermLoop *node) { if (!validateLoopType(node)) return false; - TLoopInfo info; - memset(&info, 0, sizeof(TLoopInfo)); - info.loop = node; - if (!validateForLoopHeader(node, &info)) + if (!validateForLoopHeader(node)) return false; - TIntermNode* body = node->getBody(); - if (body != NULL) { - mLoopStack.push_back(info); + TIntermNode *body = node->getBody(); + if (body != NULL) + { + mLoopStack.push(node); body->traverse(this); - mLoopStack.pop_back(); + mLoopStack.pop(); } // The loop is fully processed - no need to visit children. @@ -184,7 +202,7 @@ bool ValidateLimitations::visitLoop(Visit, TIntermLoop* node) } void ValidateLimitations::error(TSourceLoc loc, - const char *reason, const char* token) + const char *reason, const char *token) { mSink.prefix(EPrefixError); mSink.location(loc); @@ -197,12 +215,13 @@ bool ValidateLimitations::withinLoopBody() const return !mLoopStack.empty(); } -bool ValidateLimitations::isLoopIndex(const TIntermSymbol* symbol) const +bool ValidateLimitations::isLoopIndex(TIntermSymbol *symbol) { - return IsLoopIndex(symbol, mLoopStack); + return mLoopStack.findLoop(symbol) != NULL; } -bool ValidateLimitations::validateLoopType(TIntermLoop* node) { +bool ValidateLimitations::validateLoopType(TIntermLoop *node) +{ TLoopType type = node->getType(); if (type == ELoopFor) return true; @@ -214,8 +233,7 @@ bool ValidateLimitations::validateLoopType(TIntermLoop* node) { return false; } -bool ValidateLimitations::validateForLoopHeader(TIntermLoop* node, - TLoopInfo* info) +bool ValidateLimitations::validateForLoopHeader(TIntermLoop *node) { ASSERT(node->getType() == ELoopFor); @@ -223,74 +241,80 @@ bool ValidateLimitations::validateForLoopHeader(TIntermLoop* node, // The for statement has the form: // for ( init-declaration ; condition ; expression ) statement // - if (!validateForLoopInit(node, info)) + int indexSymbolId = validateForLoopInit(node); + if (indexSymbolId < 0) return false; - if (!validateForLoopCond(node, info)) + if (!validateForLoopCond(node, indexSymbolId)) return false; - if (!validateForLoopExpr(node, info)) + if (!validateForLoopExpr(node, indexSymbolId)) return false; return true; } -bool ValidateLimitations::validateForLoopInit(TIntermLoop* node, - TLoopInfo* info) +int ValidateLimitations::validateForLoopInit(TIntermLoop *node) { - TIntermNode* init = node->getInit(); - if (init == NULL) { + TIntermNode *init = node->getInit(); + if (init == NULL) + { error(node->getLine(), "Missing init declaration", "for"); - return false; + return -1; } // // init-declaration has the form: // type-specifier identifier = constant-expression // - TIntermAggregate* decl = init->getAsAggregate(); - if ((decl == NULL) || (decl->getOp() != EOpDeclaration)) { + TIntermAggregate *decl = init->getAsAggregate(); + if ((decl == NULL) || (decl->getOp() != EOpDeclaration)) + { error(init->getLine(), "Invalid init declaration", "for"); - return false; + return -1; } // To keep things simple do not allow declaration list. - TIntermSequence& declSeq = decl->getSequence(); - if (declSeq.size() != 1) { + TIntermSequence *declSeq = decl->getSequence(); + if (declSeq->size() != 1) + { error(decl->getLine(), "Invalid init declaration", "for"); - return false; + return -1; } - TIntermBinary* declInit = declSeq[0]->getAsBinaryNode(); - if ((declInit == NULL) || (declInit->getOp() != EOpInitialize)) { + TIntermBinary *declInit = (*declSeq)[0]->getAsBinaryNode(); + if ((declInit == NULL) || (declInit->getOp() != EOpInitialize)) + { error(decl->getLine(), "Invalid init declaration", "for"); - return false; + return -1; } - TIntermSymbol* symbol = declInit->getLeft()->getAsSymbolNode(); - if (symbol == NULL) { + TIntermSymbol *symbol = declInit->getLeft()->getAsSymbolNode(); + if (symbol == NULL) + { error(declInit->getLine(), "Invalid init declaration", "for"); - return false; + return -1; } // The loop index has type int or float. TBasicType type = symbol->getBasicType(); - if ((type != EbtInt) && (type != EbtFloat)) { + if ((type != EbtInt) && (type != EbtUInt) && (type != EbtFloat)) { error(symbol->getLine(), "Invalid type for loop index", getBasicString(type)); - return false; + return -1; } // The loop index is initialized with constant expression. - if (!isConstExpr(declInit->getRight())) { + if (!isConstExpr(declInit->getRight())) + { error(declInit->getLine(), "Loop index cannot be initialized with non-constant expression", symbol->getSymbol().c_str()); - return false; + return -1; } - info->index.id = symbol->getId(); - return true; + return symbol->getId(); } -bool ValidateLimitations::validateForLoopCond(TIntermLoop* node, - TLoopInfo* info) +bool ValidateLimitations::validateForLoopCond(TIntermLoop *node, + int indexSymbolId) { - TIntermNode* cond = node->getCondition(); - if (cond == NULL) { + TIntermNode *cond = node->getCondition(); + if (cond == NULL) + { error(node->getLine(), "Missing condition", "for"); return false; } @@ -298,24 +322,28 @@ bool ValidateLimitations::validateForLoopCond(TIntermLoop* node, // condition has the form: // loop_index relational_operator constant_expression // - TIntermBinary* binOp = cond->getAsBinaryNode(); - if (binOp == NULL) { + TIntermBinary *binOp = cond->getAsBinaryNode(); + if (binOp == NULL) + { error(node->getLine(), "Invalid condition", "for"); return false; } // Loop index should be to the left of relational operator. - TIntermSymbol* symbol = binOp->getLeft()->getAsSymbolNode(); - if (symbol == NULL) { + TIntermSymbol *symbol = binOp->getLeft()->getAsSymbolNode(); + if (symbol == NULL) + { error(binOp->getLine(), "Invalid condition", "for"); return false; } - if (symbol->getId() != info->index.id) { + if (symbol->getId() != indexSymbolId) + { error(symbol->getLine(), "Expected loop index", symbol->getSymbol().c_str()); return false; } // Relational operator is one of: > >= < <= == or !=. - switch (binOp->getOp()) { + switch (binOp->getOp()) + { case EOpEqual: case EOpNotEqual: case EOpLessThan: @@ -326,11 +354,12 @@ bool ValidateLimitations::validateForLoopCond(TIntermLoop* node, default: error(binOp->getLine(), "Invalid relational operator", - getOperatorString(binOp->getOp())); + GetOperatorString(binOp->getOp())); break; } // Loop index must be compared with a constant. - if (!isConstExpr(binOp->getRight())) { + if (!isConstExpr(binOp->getRight())) + { error(binOp->getLine(), "Loop index cannot be compared with non-constant expression", symbol->getSymbol().c_str()); @@ -340,11 +369,12 @@ bool ValidateLimitations::validateForLoopCond(TIntermLoop* node, return true; } -bool ValidateLimitations::validateForLoopExpr(TIntermLoop* node, - TLoopInfo* info) +bool ValidateLimitations::validateForLoopExpr(TIntermLoop *node, + int indexSymbolId) { - TIntermNode* expr = node->getExpression(); - if (expr == NULL) { + TIntermNode *expr = node->getExpression(); + if (expr == NULL) + { error(node->getLine(), "Missing expression", "for"); return false; } @@ -358,50 +388,58 @@ bool ValidateLimitations::validateForLoopExpr(TIntermLoop* node, // --loop_index // The last two forms are not specified in the spec, but I am assuming // its an oversight. - TIntermUnary* unOp = expr->getAsUnaryNode(); - TIntermBinary* binOp = unOp ? NULL : expr->getAsBinaryNode(); + TIntermUnary *unOp = expr->getAsUnaryNode(); + TIntermBinary *binOp = unOp ? NULL : expr->getAsBinaryNode(); TOperator op = EOpNull; - TIntermSymbol* symbol = NULL; - if (unOp != NULL) { + TIntermSymbol *symbol = NULL; + if (unOp != NULL) + { op = unOp->getOp(); symbol = unOp->getOperand()->getAsSymbolNode(); - } else if (binOp != NULL) { + } + else if (binOp != NULL) + { op = binOp->getOp(); symbol = binOp->getLeft()->getAsSymbolNode(); } // The operand must be loop index. - if (symbol == NULL) { + if (symbol == NULL) + { error(expr->getLine(), "Invalid expression", "for"); return false; } - if (symbol->getId() != info->index.id) { + if (symbol->getId() != indexSymbolId) + { error(symbol->getLine(), "Expected loop index", symbol->getSymbol().c_str()); return false; } // The operator is one of: ++ -- += -=. - switch (op) { - case EOpPostIncrement: - case EOpPostDecrement: - case EOpPreIncrement: - case EOpPreDecrement: - ASSERT((unOp != NULL) && (binOp == NULL)); - break; - case EOpAddAssign: - case EOpSubAssign: - ASSERT((unOp == NULL) && (binOp != NULL)); - break; - default: - error(expr->getLine(), "Invalid operator", getOperatorString(op)); - return false; + switch (op) + { + case EOpPostIncrement: + case EOpPostDecrement: + case EOpPreIncrement: + case EOpPreDecrement: + ASSERT((unOp != NULL) && (binOp == NULL)); + break; + case EOpAddAssign: + case EOpSubAssign: + ASSERT((unOp == NULL) && (binOp != NULL)); + break; + default: + error(expr->getLine(), "Invalid operator", GetOperatorString(op)); + return false; } // Loop index must be incremented/decremented with a constant. - if (binOp != NULL) { - if (!isConstExpr(binOp->getRight())) { + if (binOp != NULL) + { + if (!isConstExpr(binOp->getRight())) + { error(binOp->getLine(), "Loop index cannot be modified by non-constant expression", symbol->getSymbol().c_str()); @@ -412,7 +450,7 @@ bool ValidateLimitations::validateForLoopExpr(TIntermLoop* node, return true; } -bool ValidateLimitations::validateFunctionCall(TIntermAggregate* node) +bool ValidateLimitations::validateFunctionCall(TIntermAggregate *node) { ASSERT(node->getOp() == EOpFunctionCall); @@ -423,9 +461,10 @@ bool ValidateLimitations::validateFunctionCall(TIntermAggregate* node) // List of param indices for which loop indices are used as argument. typedef std::vector<size_t> ParamIndex; ParamIndex pIndex; - TIntermSequence& params = node->getSequence(); - for (TIntermSequence::size_type i = 0; i < params.size(); ++i) { - TIntermSymbol* symbol = params[i]->getAsSymbolNode(); + TIntermSequence *params = node->getSequence(); + for (TIntermSequence::size_type i = 0; i < params->size(); ++i) + { + TIntermSymbol *symbol = (*params)[i]->getAsSymbolNode(); if (symbol && isLoopIndex(symbol)) pIndex.push_back(i); } @@ -436,17 +475,19 @@ bool ValidateLimitations::validateFunctionCall(TIntermAggregate* node) bool valid = true; TSymbolTable& symbolTable = GetGlobalParseContext()->symbolTable; - TSymbol* symbol = symbolTable.find(node->getName()); + TSymbol* symbol = symbolTable.find(node->getName(), GetGlobalParseContext()->shaderVersion); ASSERT(symbol && symbol->isFunction()); - TFunction* function = static_cast<TFunction*>(symbol); + TFunction *function = static_cast<TFunction *>(symbol); for (ParamIndex::const_iterator i = pIndex.begin(); - i != pIndex.end(); ++i) { - const TParameter& param = function->getParam(*i); + i != pIndex.end(); ++i) + { + const TParameter ¶m = function->getParam(*i); TQualifier qual = param.type->getQualifier(); - if ((qual == EvqOut) || (qual == EvqInOut)) { - error(params[*i]->getLine(), + if ((qual == EvqOut) || (qual == EvqInOut)) + { + error((*params)[*i]->getLine(), "Loop index cannot be used as argument to a function out or inout parameter", - params[*i]->getAsSymbolNode()->getSymbol().c_str()); + (*params)[*i]->getAsSymbolNode()->getSymbol().c_str()); valid = false; } } @@ -454,14 +495,16 @@ bool ValidateLimitations::validateFunctionCall(TIntermAggregate* node) return valid; } -bool ValidateLimitations::validateOperation(TIntermOperator* node, - TIntermNode* operand) { +bool ValidateLimitations::validateOperation(TIntermOperator *node, + TIntermNode* operand) +{ // Check if loop index is modified in the loop body. if (!withinLoopBody() || !node->isAssignment()) return true; - const TIntermSymbol* symbol = operand->getAsSymbolNode(); - if (symbol && isLoopIndex(symbol)) { + TIntermSymbol *symbol = operand->getAsSymbolNode(); + if (symbol && isLoopIndex(symbol)) + { error(node->getLine(), "Loop index cannot be statically assigned to within the body of the loop", symbol->getSymbol().c_str()); @@ -469,13 +512,13 @@ bool ValidateLimitations::validateOperation(TIntermOperator* node, return true; } -bool ValidateLimitations::isConstExpr(TIntermNode* node) +bool ValidateLimitations::isConstExpr(TIntermNode *node) { ASSERT(node != NULL); return node->getAsConstantUnion() != NULL; } -bool ValidateLimitations::isConstIndexExpr(TIntermNode* node) +bool ValidateLimitations::isConstIndexExpr(TIntermNode *node) { ASSERT(node != NULL); @@ -484,15 +527,15 @@ bool ValidateLimitations::isConstIndexExpr(TIntermNode* node) return validate.isValid(); } -bool ValidateLimitations::validateIndexing(TIntermBinary* node) +bool ValidateLimitations::validateIndexing(TIntermBinary *node) { ASSERT((node->getOp() == EOpIndexDirect) || (node->getOp() == EOpIndexIndirect)); bool valid = true; - TIntermTyped* index = node->getRight(); + TIntermTyped *index = node->getRight(); // The index expression must have integral type. - if (!index->isScalar() || (index->getBasicType() != EbtInt)) { + if (!index->isScalarInt()) { error(index->getLine(), "Index expression must have integral type", index->getCompleteString().c_str()); @@ -500,10 +543,11 @@ bool ValidateLimitations::validateIndexing(TIntermBinary* node) } // The index expession must be a constant-index-expression unless // the operand is a uniform in a vertex shader. - TIntermTyped* operand = node->getLeft(); - bool skip = (mShaderType == SH_VERTEX_SHADER) && + TIntermTyped *operand = node->getLeft(); + bool skip = (mShaderType == GL_VERTEX_SHADER) && (operand->getQualifier() == EvqUniform); - if (!skip && !isConstIndexExpr(index)) { + if (!skip && !isConstIndexExpr(index)) + { error(index->getLine(), "Index expression must be constant", "[]"); valid = false; } |