mewin/glslang
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Code simplification: Add (and use) helper functions for building constant scalar AST nodes for bool, int, uint, float, and double, shortening all the code segments that were doing that.

Browse Source 
git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@26600 e7fa87d3-cd2b-0410-9028-fcbf551c1848
This commit is contained in:
John Kessenich 2014-05-10 19:52:01 +00:00
parent a92c30ed23
commit 7c257eb108
4 changed files with 65 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
glslang/MachineIndependent/Intermediate.cpp
View File

@ -802,6 +802,40 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(const TConstUnionArray& un
return node; return node;
} }
TIntermConstantUnion* TIntermediate::addConstantUnion(int i, TSourceLoc loc, bool literal) const
{
TConstUnionArray unionArray(1);
unionArray[0].setIConst(i);
return addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc, literal);
}
TIntermConstantUnion* TIntermediate::addConstantUnion(unsigned int u, TSourceLoc loc, bool literal) const
{
TConstUnionArray unionArray(1);
unionArray[0].setUConst(u);
return addConstantUnion(unionArray, TType(EbtUint, EvqConst), loc, literal);
}
TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, TSourceLoc loc, bool literal) const
{
TConstUnionArray unionArray(1);
unionArray[0].setBConst(b);
return addConstantUnion(unionArray, TType(EbtBool, EvqConst), loc, literal);
}
TIntermConstantUnion* TIntermediate::addConstantUnion(double d, TBasicType baseType, TSourceLoc loc, bool literal) const
{
assert(baseType == EbtFloat || baseType == EbtDouble);
TConstUnionArray unionArray(1);
unionArray[0].setDConst(d);
return addConstantUnion(unionArray, TType(baseType, EvqConst), loc, literal);
}
TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc loc) TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc loc)
{ {
@ -812,9 +846,7 @@ TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc loc)
TIntermSequence &sequenceVector = node->getSequence(); TIntermSequence &sequenceVector = node->getSequence();
for (int i = 0; i < fields.num; i++) { for (int i = 0; i < fields.num; i++) {
TConstUnionArray unionArray(1); constIntNode = addConstantUnion(fields.offsets[i], loc);
unionArray[0].setIConst(fields.offsets[i]);
constIntNode = addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
sequenceVector.push_back(constIntNode); sequenceVector.push_back(constIntNode);
} }

31
glslang/MachineIndependent/ParseHelper.cpp
View File

@ -393,9 +393,7 @@ TIntermTyped* TParseContext::handleVariable(TSourceLoc loc, TSymbol* symbol, TSt
// Create a subtree for its dereference. // Create a subtree for its dereference.
variable = anon->getAnonContainer().getAsVariable(); variable = anon->getAnonContainer().getAsVariable();
TIntermTyped* container = intermediate.addSymbol(*variable, loc); TIntermTyped* container = intermediate.addSymbol(*variable, loc);
TConstUnionArray unionArray(1); TIntermTyped* constNode = intermediate.addConstantUnion(anon->getMemberNumber(), loc);
unionArray[0].setUConst(anon->getMemberNumber());
TIntermTyped* constNode = intermediate.addConstantUnion(unionArray, TType(EbtUint, EvqConst), loc);
node = intermediate.addIndex(EOpIndexDirectStruct, container, constNode, loc); node = intermediate.addIndex(EOpIndexDirectStruct, container, constNode, loc);
node->setType(*(*variable->getType().getStruct())[anon->getMemberNumber()].type); node->setType(*(*variable->getType().getStruct())[anon->getMemberNumber()].type);
@ -480,9 +478,7 @@ TIntermTyped* TParseContext::handleBracketDereference(TSourceLoc loc, TIntermTyp
if (result == 0) { if (result == 0) {
// Insert dummy error-recovery result // Insert dummy error-recovery result
TConstUnionArray unionArray(1); result = intermediate.addConstantUnion(0.0, EbtFloat, loc);
unionArray[0].setDConst(0.0);
result = intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), loc);
} else { } else {
// Insert valid dereferenced result // Insert valid dereferenced result
TType newType(base->getType(), 0); // dereferenced type TType newType(base->getType(), 0); // dereferenced type
@ -714,9 +710,7 @@ TIntermTyped* TParseContext::handleDotDereference(TSourceLoc loc, TIntermTyped*
result = intermediate.foldSwizzle(base, fields, loc); result = intermediate.foldSwizzle(base, fields, loc);
else { else {
if (fields.num == 1) { if (fields.num == 1) {
TConstUnionArray unionArray(1); TIntermTyped* index = intermediate.addConstantUnion(fields.offsets[0], loc);
unionArray[0].setIConst(fields.offsets[0]);
TIntermTyped* index = intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
result = intermediate.addIndex(EOpIndexDirect, base, index, loc); result = intermediate.addIndex(EOpIndexDirect, base, index, loc);
result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision)); result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision));
} else { } else {
@ -731,8 +725,8 @@ TIntermTyped* TParseContext::handleDotDereference(TSourceLoc loc, TIntermTyped*
else if (base->getBasicType() == EbtStruct || base->getBasicType() == EbtBlock) { else if (base->getBasicType() == EbtStruct || base->getBasicType() == EbtBlock) {
const TTypeList* fields = base->getType().getStruct(); const TTypeList* fields = base->getType().getStruct();
bool fieldFound = false; bool fieldFound = false;
unsigned int member; int member;
for (member = 0; member < fields->size(); ++member) { for (member = 0; member < (int)fields->size(); ++member) {
if ((*fields)[member].type->getFieldName() == field) { if ((*fields)[member].type->getFieldName() == field) {
fieldFound = true; fieldFound = true;
break; break;
@ -742,9 +736,7 @@ TIntermTyped* TParseContext::handleDotDereference(TSourceLoc loc, TIntermTyped*
if (base->getType().getQualifier().storage == EvqConst) if (base->getType().getQualifier().storage == EvqConst)
result = intermediate.foldDereference(base, member, loc); result = intermediate.foldDereference(base, member, loc);
else { else {
TConstUnionArray unionArray(1); TIntermTyped* index = intermediate.addConstantUnion(member, loc);
unionArray[0].setIConst(member);
TIntermTyped* index = intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
result = intermediate.addIndex(EOpIndexDirectStruct, base, index, loc); result = intermediate.addIndex(EOpIndexDirectStruct, base, index, loc);
result->setType(*(*fields)[member].type); result->setType(*(*fields)[member].type);
} }
@ -1015,11 +1007,8 @@ TIntermTyped* TParseContext::handleFunctionCall(TSourceLoc loc, TFunction* funct
// generic error recovery // generic error recovery
// TODO: simplification: localize all the error recoveries that look like this, and taking type into account to reduce cascades // TODO: simplification: localize all the error recoveries that look like this, and taking type into account to reduce cascades
if (result == 0) { if (result == 0)
TConstUnionArray unionArray(1); result = intermediate.addConstantUnion(0.0, EbtFloat, loc);
unionArray[0].setDConst(0.0);
result = intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), loc);
}
return result; return result;
} }
@ -1055,10 +1044,8 @@ TIntermTyped* TParseContext::handleLengthMethod(TSourceLoc loc, TFunction* funct
if (length == 0) if (length == 0)
length = 1; length = 1;
TConstUnionArray unionArray(1);
unionArray[0].setIConst(length);
return intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc); return intermediate.addConstantUnion(length, loc);
} }
// //

58
glslang/MachineIndependent/glslang.y
View File

@ -226,31 +226,21 @@ primary_expression
$$ = $1; $$ = $1;
} }
| INTCONSTANT { | INTCONSTANT {
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion($1.i, $1.loc, true);
unionArray[0].setIConst($1.i);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), $1.loc, true);
} }
| UINTCONSTANT { | UINTCONSTANT {
parseContext.fullIntegerCheck($1.loc, "unsigned literal"); parseContext.fullIntegerCheck($1.loc, "unsigned literal");
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion($1.u, $1.loc, true);
unionArray[0].setUConst($1.u);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtUint, EvqConst), $1.loc, true);
} }
| FLOATCONSTANT { | FLOATCONSTANT {
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion($1.d, EbtFloat, $1.loc, true);
unionArray[0].setDConst($1.d);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), $1.loc, true);
} }
| DOUBLECONSTANT { | DOUBLECONSTANT {
parseContext.doubleCheck($1.loc, "double literal"); parseContext.doubleCheck($1.loc, "double literal");
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion($1.d, EbtDouble, $1.loc, true);
unionArray[0].setDConst($1.d);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtDouble, EvqConst), $1.loc, true);
} }
| BOOLCONSTANT { | BOOLCONSTANT {
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion($1.b, $1.loc, true);
unionArray[0].setBConst($1.b);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $1.loc, true);
} }
| LEFT_PAREN expression RIGHT_PAREN { | LEFT_PAREN expression RIGHT_PAREN {
$$ = $2; $$ = $2;
@ -365,7 +355,7 @@ function_identifier
} }
| postfix_expression { | postfix_expression {
// //
// Should be a method or subroutine call, but we don't have arguments yet. // Should be a method or subroutine call, but we haven't recognized the arguments yet.
// //
$$.function = 0; $$.function = 0;
$$.intermNode = 0; $$.intermNode = 0;
@ -520,36 +510,28 @@ relational_expression
$$ = parseContext.intermediate.addBinaryMath(EOpLessThan, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpLessThan, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "<", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "<", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
| relational_expression RIGHT_ANGLE shift_expression { | relational_expression RIGHT_ANGLE shift_expression {
$$ = parseContext.intermediate.addBinaryMath(EOpGreaterThan, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpGreaterThan, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, ">", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, ">", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
| relational_expression LE_OP shift_expression { | relational_expression LE_OP shift_expression {
$$ = parseContext.intermediate.addBinaryMath(EOpLessThanEqual, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpLessThanEqual, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "<=", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "<=", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
| relational_expression GE_OP shift_expression { | relational_expression GE_OP shift_expression {
$$ = parseContext.intermediate.addBinaryMath(EOpGreaterThanEqual, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpGreaterThanEqual, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, ">=", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, ">=", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
; ;
@ -562,9 +544,7 @@ equality_expression
$$ = parseContext.intermediate.addBinaryMath(EOpEqual, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpEqual, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "==", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "==", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
| equality_expression NE_OP relational_expression { | equality_expression NE_OP relational_expression {
@ -573,9 +553,7 @@ equality_expression
$$ = parseContext.intermediate.addBinaryMath(EOpNotEqual, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpNotEqual, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "!=", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "!=", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
; ;
@ -622,9 +600,7 @@ logical_and_expression
$$ = parseContext.intermediate.addBinaryMath(EOpLogicalAnd, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpLogicalAnd, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "&&", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "&&", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
; ;
@ -635,9 +611,7 @@ logical_xor_expression
$$ = parseContext.intermediate.addBinaryMath(EOpLogicalXor, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpLogicalXor, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "^^", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "^^", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
; ;
@ -648,9 +622,7 @@ logical_or_expression
$$ = parseContext.intermediate.addBinaryMath(EOpLogicalOr, $1, $3, $2.loc); $$ = parseContext.intermediate.addBinaryMath(EOpLogicalOr, $1, $3, $2.loc);
if ($$ == 0) { if ($$ == 0) {
parseContext.binaryOpError($2.loc, "||", $1->getCompleteString(), $3->getCompleteString()); parseContext.binaryOpError($2.loc, "||", $1->getCompleteString(), $3->getCompleteString());
TConstUnionArray unionArray(1); $$ = parseContext.intermediate.addConstantUnion(false, $2.loc);
unionArray[0].setBConst(false);
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);
} }
} }
; ;

4
glslang/MachineIndependent/localintermediate.h
View File

@ -157,6 +157,10 @@ public:
TIntermTyped* addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc); TIntermTyped* addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc);
TIntermTyped* addMethod(TIntermTyped*, const TType&, const TString*, TSourceLoc); TIntermTyped* addMethod(TIntermTyped*, const TType&, const TString*, TSourceLoc);
TIntermConstantUnion* addConstantUnion(const TConstUnionArray&, const TType&, TSourceLoc, bool literal = false) const; TIntermConstantUnion* addConstantUnion(const TConstUnionArray&, const TType&, TSourceLoc, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(int, TSourceLoc, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(unsigned int, TSourceLoc, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(bool, TSourceLoc, bool literal = false) const;
TIntermConstantUnion* addConstantUnion(double, TBasicType, TSourceLoc, bool literal = false) const;
TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) const; TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) const;
bool parseConstTree(TIntermNode*, TConstUnionArray, TOperator, const TType&, bool singleConstantParam = false); bool parseConstTree(TIntermNode*, TConstUnionArray, TOperator, const TType&, bool singleConstantParam = false);
TIntermLoop* addLoop(TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst, TSourceLoc); TIntermLoop* addLoop(TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst, TSourceLoc);