4055816bc9
git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@20817 e7fa87d3-cd2b-0410-9028-fcbf551c1848
607 lines
21 KiB
C++
607 lines
21 KiB
C++
//
|
|
//Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
//Copyright (C) 2012-2013 LunarG, Inc.
|
|
//
|
|
//All rights reserved.
|
|
//
|
|
//Redistribution and use in source and binary forms, with or without
|
|
//modification, are permitted provided that the following conditions
|
|
//are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
//POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
|
|
#include "localintermediate.h"
|
|
|
|
namespace {
|
|
|
|
// Some helper functions
|
|
|
|
const double pi = 3.1415926535897932384626433832795;
|
|
|
|
bool CompareStruct(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray);
|
|
|
|
bool CompareStructure(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray)
|
|
{
|
|
if (leftNodeType.isArray()) {
|
|
TType typeWithoutArrayness = leftNodeType;
|
|
typeWithoutArrayness.dereference();
|
|
|
|
int arraySize = leftNodeType.getArraySize();
|
|
|
|
for (int i = 0; i < arraySize; ++i) {
|
|
int offset = typeWithoutArrayness.getObjectSize() * i;
|
|
if (! CompareStruct(typeWithoutArrayness, &rightUnionArray[offset], &leftUnionArray[offset]))
|
|
return false;
|
|
}
|
|
} else
|
|
return CompareStruct(leftNodeType, rightUnionArray, leftUnionArray);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CompareStruct(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray)
|
|
{
|
|
TTypeList* fields = leftNodeType.getStruct();
|
|
|
|
size_t structSize = fields->size();
|
|
int index = 0;
|
|
|
|
for (size_t j = 0; j < structSize; j++) {
|
|
int size = (*fields)[j].type->getObjectSize();
|
|
for (int i = 0; i < size; i++) {
|
|
if ((*fields)[j].type->getBasicType() == EbtStruct) {
|
|
if (!CompareStructure(*(*fields)[j].type, &rightUnionArray[index], &leftUnionArray[index]))
|
|
return false;
|
|
} else {
|
|
if (leftUnionArray[index] != rightUnionArray[index])
|
|
return false;
|
|
index++;
|
|
}
|
|
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
}; // end anonymous namespace
|
|
|
|
//
|
|
// The fold functions see if an operation on a constant can be done in place,
|
|
// without generating run-time code.
|
|
//
|
|
// Returns the node to keep using, which may or may not be the node passed in.
|
|
//
|
|
// Note: As of version 1.2, all constant operations must be folded. It is
|
|
// not opportunistic, but rather a semantic requirement.
|
|
//
|
|
|
|
//
|
|
// Do folding between a pair of nodes
|
|
//
|
|
TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode, TInfoSink& infoSink)
|
|
{
|
|
constUnion *unionArray = getUnionArrayPointer();
|
|
int objectSize = getType().getObjectSize();
|
|
constUnion* newConstArray = 0;
|
|
|
|
// For most cases, the return type matches the argument type, so set that
|
|
// up and just code to exceptions below.
|
|
TType returnType = getType();
|
|
|
|
//
|
|
// A pair of nodes is to be folded together
|
|
//
|
|
|
|
TIntermConstantUnion *node = constantNode->getAsConstantUnion();
|
|
constUnion *rightUnionArray = node->getUnionArrayPointer();
|
|
|
|
if (getType().getBasicType() != node->getBasicType()) {
|
|
infoSink.info.message(EPrefixInternalError, "Constant folding basic types don't match", getLine());
|
|
return 0;
|
|
}
|
|
|
|
if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) {
|
|
// for a case like float f = vec4(2,3,4,5) + 1.2;
|
|
rightUnionArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; ++i)
|
|
rightUnionArray[i] = *node->getUnionArrayPointer();
|
|
} else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) {
|
|
// for a case like float f = 1.2 + vec4(2,3,4,5);
|
|
rightUnionArray = node->getUnionArrayPointer();
|
|
unionArray = new constUnion[constantNode->getType().getObjectSize()];
|
|
for (int i = 0; i < constantNode->getType().getObjectSize(); ++i)
|
|
unionArray[i] = *getUnionArrayPointer();
|
|
returnType = node->getType();
|
|
objectSize = constantNode->getType().getObjectSize();
|
|
}
|
|
|
|
int index = 0;
|
|
bool boolNodeFlag = false;
|
|
switch(op) {
|
|
case EOpAdd:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] + rightUnionArray[i];
|
|
break;
|
|
case EOpSub:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] - rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpMul:
|
|
case EOpVectorTimesScalar:
|
|
case EOpMatrixTimesScalar:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] * rightUnionArray[i];
|
|
break;
|
|
case EOpMatrixTimesMatrix:
|
|
newConstArray = new constUnion[getMatrixRows() * node->getMatrixCols()];
|
|
for (int row = 0; row < getMatrixRows(); row++) {
|
|
for (int column = 0; column < node->getMatrixCols(); column++) {
|
|
float sum = 0.0f;
|
|
for (int i = 0; i < node->getMatrixRows(); i++)
|
|
sum += unionArray[i * getMatrixRows() + row].getFConst() * rightUnionArray[column * node->getMatrixRows() + i].getFConst();
|
|
newConstArray[column * getMatrixRows() + row].setFConst(sum);
|
|
}
|
|
}
|
|
returnType = TType(getType().getBasicType(), EvqConst, 0, getMatrixRows(), node->getMatrixCols());
|
|
break;
|
|
case EOpDiv:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++) {
|
|
switch (getType().getBasicType()) {
|
|
case EbtFloat:
|
|
if (rightUnionArray[i] == 0.0f) {
|
|
newConstArray[i].setFConst(FLT_MAX);
|
|
} else
|
|
newConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst());
|
|
break;
|
|
|
|
case EbtInt:
|
|
if (rightUnionArray[i] == 0) {
|
|
newConstArray[i].setIConst(0xEFFFFFFF);
|
|
} else
|
|
newConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst());
|
|
break;
|
|
default:
|
|
infoSink.info.message(EPrefixInternalError, "Constant folding cannot be done for \"/\"", getLine());
|
|
return 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EOpMatrixTimesVector:
|
|
newConstArray = new constUnion[getMatrixRows()];
|
|
for (int i = 0; i < getMatrixRows(); i++) {
|
|
float sum = 0.0f;
|
|
for (int j = 0; j < node->getVectorSize(); j++) {
|
|
sum += unionArray[j*getMatrixRows() + i].getFConst() * rightUnionArray[j].getFConst();
|
|
}
|
|
newConstArray[i].setFConst(sum);
|
|
}
|
|
|
|
returnType = TType(getBasicType(), EvqConst, getMatrixRows());
|
|
break;
|
|
|
|
case EOpVectorTimesMatrix:
|
|
newConstArray = new constUnion[node->getMatrixCols()];
|
|
for (int i = 0; i < node->getMatrixCols(); i++) {
|
|
float sum = 0.0f;
|
|
for (int j = 0; j < getVectorSize(); j++)
|
|
sum += unionArray[j].getFConst() * rightUnionArray[i*node->getMatrixRows() + j].getFConst();
|
|
newConstArray[i].setFConst(sum);
|
|
}
|
|
|
|
returnType = TType(getBasicType(), EvqConst, node->getMatrixCols());
|
|
break;
|
|
|
|
case EOpMod:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] % rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpRightShift:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] >> rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpLeftShift:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] << rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpAnd:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] & rightUnionArray[i];
|
|
break;
|
|
case EOpInclusiveOr:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] | rightUnionArray[i];
|
|
break;
|
|
case EOpExclusiveOr:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] ^ rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] && rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpLogicalOr: // this code is written for possible future use, will not get executed currently
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++)
|
|
newConstArray[i] = unionArray[i] || rightUnionArray[i];
|
|
break;
|
|
|
|
case EOpLogicalXor:
|
|
newConstArray = new constUnion[objectSize];
|
|
for (int i = 0; i < objectSize; i++) {
|
|
switch (getType().getBasicType()) {
|
|
case EbtBool: newConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break;
|
|
default: assert(false && "Default missing");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case EOpLessThan:
|
|
assert(objectSize == 1);
|
|
newConstArray = new constUnion[1];
|
|
newConstArray->setBConst(*unionArray < *rightUnionArray);
|
|
returnType = TType(EbtBool, EvqConst);
|
|
break;
|
|
case EOpGreaterThan:
|
|
assert(objectSize == 1);
|
|
newConstArray = new constUnion[1];
|
|
newConstArray->setBConst(*unionArray > *rightUnionArray);
|
|
returnType = TType(EbtBool, EvqConst);
|
|
break;
|
|
case EOpLessThanEqual:
|
|
{
|
|
assert(objectSize == 1);
|
|
constUnion constant;
|
|
constant.setBConst(*unionArray > *rightUnionArray);
|
|
newConstArray = new constUnion[1];
|
|
newConstArray->setBConst(!constant.getBConst());
|
|
returnType = TType(EbtBool, EvqConst);
|
|
break;
|
|
}
|
|
case EOpGreaterThanEqual:
|
|
{
|
|
assert(objectSize == 1);
|
|
constUnion constant;
|
|
constant.setBConst(*unionArray < *rightUnionArray);
|
|
newConstArray = new constUnion[1];
|
|
newConstArray->setBConst(!constant.getBConst());
|
|
returnType = TType(EbtBool, EvqConst);
|
|
break;
|
|
}
|
|
|
|
case EOpEqual:
|
|
if (getType().getBasicType() == EbtStruct) {
|
|
if (! CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
|
|
boolNodeFlag = true;
|
|
} else {
|
|
for (int i = 0; i < objectSize; i++) {
|
|
if (unionArray[i] != rightUnionArray[i]) {
|
|
boolNodeFlag = true;
|
|
break; // break out of for loop
|
|
}
|
|
}
|
|
}
|
|
|
|
newConstArray = new constUnion[1];
|
|
newConstArray->setBConst(! boolNodeFlag);
|
|
returnType = TType(EbtBool, EvqConst);
|
|
break;
|
|
|
|
case EOpNotEqual:
|
|
if (getType().getBasicType() == EbtStruct) {
|
|
if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
|
|
boolNodeFlag = true;
|
|
} else {
|
|
for (int i = 0; i < objectSize; i++) {
|
|
if (unionArray[i] == rightUnionArray[i]) {
|
|
boolNodeFlag = true;
|
|
break; // break out of for loop
|
|
}
|
|
}
|
|
}
|
|
|
|
newConstArray = new constUnion[1];
|
|
newConstArray->setBConst(! boolNodeFlag);
|
|
returnType = TType(EbtBool, EvqConst);
|
|
break;
|
|
|
|
default:
|
|
infoSink.info.message(EPrefixInternalError, "Invalid operator for constant folding", getLine());
|
|
|
|
return 0;
|
|
}
|
|
|
|
TIntermConstantUnion *newNode = new TIntermConstantUnion(newConstArray, returnType);
|
|
newNode->setLine(getLine());
|
|
|
|
return newNode;
|
|
}
|
|
|
|
//
|
|
// Do single unary node folding
|
|
//
|
|
TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType, TInfoSink& infoSink)
|
|
{
|
|
constUnion *unionArray = getUnionArrayPointer();
|
|
int objectSize = getType().getObjectSize();
|
|
|
|
// First, size the result, which is mostly the same as the argument's size,
|
|
// but not always.
|
|
constUnion* newConstArray;
|
|
switch (op) {
|
|
// TODO: functionality: constant folding: finish listing exceptions to size here
|
|
case EOpDeterminant:
|
|
case EOpAny:
|
|
case EOpAll:
|
|
newConstArray = new constUnion[1];
|
|
break;
|
|
default:
|
|
newConstArray = new constUnion[objectSize];
|
|
}
|
|
|
|
// TODO: Functionality: constant folding: separate component-wise from non-component-wise
|
|
for (int i = 0; i < objectSize; i++) {
|
|
switch (op) {
|
|
case EOpNegative:
|
|
switch (getType().getBasicType()) {
|
|
case EbtFloat: newConstArray[i].setFConst(-unionArray[i].getFConst()); break;
|
|
case EbtInt: newConstArray[i].setIConst(-unionArray[i].getIConst()); break;
|
|
default:
|
|
infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
|
|
return 0;
|
|
}
|
|
break;
|
|
case EOpLogicalNot:
|
|
case EOpVectorLogicalNot:
|
|
switch (getType().getBasicType()) {
|
|
case EbtBool: newConstArray[i].setBConst(!unionArray[i].getBConst()); break;
|
|
default:
|
|
infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
|
|
return 0;
|
|
}
|
|
break;
|
|
case EOpBitwiseNot:
|
|
newConstArray[i] = ~unionArray[i];
|
|
break;
|
|
case EOpRadians:
|
|
newConstArray[i].setFConst(static_cast<float>(unionArray[i].getFConst() * pi / 180.0));
|
|
break;
|
|
case EOpDegrees:
|
|
newConstArray[i].setFConst(static_cast<float>(unionArray[i].getFConst() * 180.0 / pi));
|
|
break;
|
|
case EOpSin:
|
|
newConstArray[i].setFConst(sin(unionArray[i].getFConst()));
|
|
break;
|
|
case EOpCos:
|
|
newConstArray[i].setFConst(cos(unionArray[i].getFConst()));
|
|
break;
|
|
case EOpTan:
|
|
newConstArray[i].setFConst(tan(unionArray[i].getFConst()));
|
|
break;
|
|
case EOpAsin:
|
|
newConstArray[i].setFConst(asin(unionArray[i].getFConst()));
|
|
break;
|
|
case EOpAcos:
|
|
newConstArray[i].setFConst(acos(unionArray[i].getFConst()));
|
|
break;
|
|
case EOpAtan:
|
|
newConstArray[i].setFConst(atan(unionArray[i].getFConst()));
|
|
break;
|
|
|
|
// TODO: Functionality: constant folding: the rest of the ops have to be fleshed out
|
|
|
|
case EOpExp:
|
|
case EOpLog:
|
|
case EOpExp2:
|
|
case EOpLog2:
|
|
case EOpSqrt:
|
|
case EOpInverseSqrt:
|
|
|
|
case EOpAbs:
|
|
case EOpSign:
|
|
case EOpFloor:
|
|
case EOpCeil:
|
|
case EOpFract:
|
|
|
|
case EOpLength:
|
|
|
|
case EOpDPdx:
|
|
case EOpDPdy:
|
|
case EOpFwidth:
|
|
// The derivatives are all mandated to create a constant 0.
|
|
|
|
case EOpDeterminant:
|
|
case EOpMatrixInverse:
|
|
case EOpTranspose:
|
|
|
|
case EOpAny:
|
|
case EOpAll:
|
|
|
|
default:
|
|
infoSink.info.message(EPrefixInternalError, "Invalid operator for constant folding", getLine());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
TIntermConstantUnion *newNode = new TIntermConstantUnion(newConstArray, returnType);
|
|
newNode->getTypePointer()->getQualifier().storage = EvqConst;
|
|
newNode->setLine(getLine());
|
|
|
|
return newNode;
|
|
}
|
|
|
|
//
|
|
// Do constant folding for an aggregate node that has all its children
|
|
// as constants and an operator that requires constant folding.
|
|
//
|
|
TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
|
|
{
|
|
if (! areAllChildConst(aggrNode))
|
|
return aggrNode;
|
|
|
|
if (aggrNode->isConstructor())
|
|
return foldConstructor(aggrNode);
|
|
|
|
TIntermSequence& children = aggrNode->getSequence();
|
|
|
|
// First, see if this is an operation to constant fold, kick out if not,
|
|
// see what size the result is if so.
|
|
int objectSize;
|
|
switch (aggrNode->getOp()) {
|
|
case EOpMin:
|
|
case EOpMax:
|
|
case EOpReflect:
|
|
case EOpRefract:
|
|
case EOpFaceForward:
|
|
case EOpAtan:
|
|
case EOpPow:
|
|
case EOpClamp:
|
|
case EOpMix:
|
|
case EOpDistance:
|
|
case EOpCross:
|
|
case EOpNormalize:
|
|
objectSize = children[0]->getAsConstantUnion()->getType().getObjectSize();
|
|
break;
|
|
case EOpDot:
|
|
objectSize = 1;
|
|
break;
|
|
case EOpOuterProduct:
|
|
objectSize = children[0]->getAsTyped()->getType().getVectorSize() *
|
|
children[1]->getAsTyped()->getType().getVectorSize();
|
|
break;
|
|
case EOpStep:
|
|
objectSize = std::max(children[0]->getAsTyped()->getType().getVectorSize(),
|
|
children[1]->getAsTyped()->getType().getVectorSize());
|
|
break;
|
|
case EOpSmoothStep:
|
|
objectSize = std::max(children[0]->getAsTyped()->getType().getVectorSize(),
|
|
children[2]->getAsTyped()->getType().getVectorSize());
|
|
break;
|
|
default:
|
|
return aggrNode;
|
|
}
|
|
constUnion* newConstArray = new constUnion[objectSize];
|
|
|
|
TVector<constUnion*> childConstUnions;
|
|
for (unsigned int i = 0; i < children.size(); ++i)
|
|
childConstUnions.push_back(children[i]->getAsConstantUnion()->getUnionArrayPointer());
|
|
|
|
// Second, do the actual folding
|
|
|
|
// TODO: Functionality: constant folding: separate component-wise from non-component-wise
|
|
switch (aggrNode->getOp()) {
|
|
case EOpMin:
|
|
case EOpMax:
|
|
for (int i = 0; i < objectSize; i++) {
|
|
if (aggrNode->getOp() == EOpMax)
|
|
newConstArray[i].setFConst(std::max(childConstUnions[0]->getFConst(), childConstUnions[1]->getFConst()));
|
|
else
|
|
newConstArray[i].setFConst(std::min(childConstUnions[0]->getFConst(), childConstUnions[1]->getFConst()));
|
|
}
|
|
break;
|
|
|
|
// TODO: Functionality: constant folding: the rest of the ops have to be fleshed out
|
|
|
|
case EOpAtan:
|
|
case EOpPow:
|
|
case EOpClamp:
|
|
case EOpMix:
|
|
case EOpStep:
|
|
case EOpSmoothStep:
|
|
case EOpDistance:
|
|
case EOpDot:
|
|
case EOpCross:
|
|
case EOpNormalize:
|
|
case EOpFaceForward:
|
|
case EOpReflect:
|
|
case EOpRefract:
|
|
case EOpOuterProduct:
|
|
infoSink.info.message(EPrefixInternalError, "constant folding operation not implemented", aggrNode->getLine());
|
|
return aggrNode;
|
|
|
|
default:
|
|
return aggrNode;
|
|
}
|
|
|
|
TIntermConstantUnion *newNode = new TIntermConstantUnion(newConstArray, aggrNode->getType());
|
|
newNode->getTypePointer()->getQualifier().storage = EvqConst;
|
|
newNode->setLine(aggrNode->getLine());
|
|
|
|
return newNode;
|
|
}
|
|
|
|
bool TIntermediate::areAllChildConst(TIntermAggregate* aggrNode)
|
|
{
|
|
bool allConstant = true;
|
|
|
|
// check if all the child nodes are constants so that they can be inserted into
|
|
// the parent node
|
|
if (aggrNode) {
|
|
TIntermSequence& childSequenceVector = aggrNode->getSequence();
|
|
for (TIntermSequence::iterator p = childSequenceVector.begin();
|
|
p != childSequenceVector.end(); p++) {
|
|
if (!(*p)->getAsTyped()->getAsConstantUnion())
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return allConstant;
|
|
}
|
|
|
|
TIntermTyped* TIntermediate::foldConstructor(TIntermAggregate* aggrNode)
|
|
{
|
|
bool returnVal = false;
|
|
|
|
constUnion* unionArray = new constUnion[aggrNode->getType().getObjectSize()];
|
|
if (aggrNode->getSequence().size() == 1)
|
|
returnVal = parseConstTree(aggrNode->getLine(), aggrNode, unionArray, aggrNode->getOp(), aggrNode->getType(), true);
|
|
else
|
|
returnVal = parseConstTree(aggrNode->getLine(), aggrNode, unionArray, aggrNode->getOp(), aggrNode->getType());
|
|
|
|
if (returnVal)
|
|
return aggrNode;
|
|
|
|
return addConstantUnion(unionArray, aggrNode->getType(), aggrNode->getLine());
|
|
}
|