Skip to content

A
angle
Commit b07aba07 by Olli Etuaho
Options

Make sure type gets set consistently in folded binary operations

Add a wrapper function that handles creating the folded node and setting the right parameters on it, so that the folding function handles only calculating the folded values. This will fix the precision set to constant folded values in some cases. Previously the precision was always set to be equal to one of the operands to the binary operation, but now both operands are taken into account. Folding binary operations is now in a separate function from folding unary operations. TEST=dEQP-GLES3.functional.shaders.constant_expressions.* BUG=angleproject:817 Change-Id: Id97e765173c6110f49607e21c3fb90019b1ebac7 Reviewed-on: https://chromium-review.googlesource.com/274001Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Tested-by: 's avatarOlli Etuaho <oetuaho@nvidia.com>
parent b50788d1
Showing with 286 additions and 366 deletions
src/compiler/translator/IntermNode.cpp
...@@ -747,458 +747,385 @@ bool TIntermBinary::promote(TInfoSink &infoSink) ...@@ -747,458 +747,385 @@ bool TIntermBinary::promote(TInfoSink &infoSink)
return true; return true;
} }
TIntermTyped *TIntermBinary::fold(TInfoSink &infoSink)
{
TIntermConstantUnion *leftConstant = mLeft->getAsConstantUnion();
TIntermConstantUnion *rightConstant = mRight->getAsConstantUnion();
if (leftConstant == nullptr || rightConstant == nullptr)
{
return nullptr;
}
TConstantUnion *constArray = leftConstant->foldBinary(mOp, rightConstant, infoSink);
if (constArray == nullptr)
{
return nullptr;
}
TIntermTyped *folded = new TIntermConstantUnion(constArray, getType());
folded->getTypePointer()->setQualifier(EvqConst);
folded->setLine(getLine());
return folded;
}
// //
// The fold functions see if an operation on a constant can be done in place, // The fold functions see if an operation on a constant can be done in place,
// without generating run-time code. // without generating run-time code.
// //
// Returns the node to keep using, which may or may not be the node passed in. // Returns the constant value to keep using or nullptr.
// //
TIntermTyped *TIntermConstantUnion::fold( TConstantUnion *TIntermConstantUnion::foldBinary(TOperator op, TIntermConstantUnion *rightNode, TInfoSink &infoSink)
TOperator op, TIntermConstantUnion *rightNode, TInfoSink &infoSink)
{ {
TConstantUnion *unionArray = getUnionArrayPointer(); TConstantUnion *leftArray = getUnionArrayPointer();
TConstantUnion *rightArray = rightNode->getUnionArrayPointer();
if (!unionArray) if (!leftArray)
return nullptr;
if (!rightArray)
return nullptr; return nullptr;
size_t objectSize = getType().getObjectSize(); size_t objectSize = getType().getObjectSize();
if (rightNode) // for a case like float f = vec4(2, 3, 4, 5) + 1.2;
if (rightNode->getType().getObjectSize() == 1 && objectSize > 1)
{
rightArray = Vectorize(*rightNode->getUnionArrayPointer(), objectSize);
}
else if (rightNode->getType().getObjectSize() > 1 && objectSize == 1)
{ {
// binary operations // for a case like float f = 1.2 + vec4(2, 3, 4, 5);
TConstantUnion *rightUnionArray = rightNode->getUnionArrayPointer(); leftArray = Vectorize(*getUnionArrayPointer(), rightNode->getType().getObjectSize());
TType returnType = getType(); objectSize = rightNode->getType().getObjectSize();
}
if (!rightUnionArray) TConstantUnion *resultArray = nullptr;
return nullptr;
// for a case like float f = vec4(2, 3, 4, 5) + 1.2; switch(op)
if (rightNode->getType().getObjectSize() == 1 && objectSize > 1) {
{ case EOpAdd:
rightUnionArray = Vectorize(*rightNode->getUnionArrayPointer(), objectSize); resultArray = new TConstantUnion[objectSize];
returnType = getType(); for (size_t i = 0; i < objectSize; i++)
} resultArray[i] = leftArray[i] + rightArray[i];
else if (rightNode->getType().getObjectSize() > 1 && objectSize == 1) break;
{ case EOpSub:
// for a case like float f = 1.2 + vec4(2, 3, 4, 5); resultArray = new TConstantUnion[objectSize];
unionArray = Vectorize(*getUnionArrayPointer(), rightNode->getType().getObjectSize()); for (size_t i = 0; i < objectSize; i++)
returnType = rightNode->getType(); resultArray[i] = leftArray[i] - rightArray[i];
objectSize = rightNode->getType().getObjectSize(); break;
}
TConstantUnion *tempConstArray = nullptr; case EOpMul:
TIntermConstantUnion *tempNode; case EOpVectorTimesScalar:
case EOpMatrixTimesScalar:
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
resultArray[i] = leftArray[i] * rightArray[i];
break;
bool boolNodeFlag = false; case EOpMatrixTimesMatrix:
switch(op)
{ {
case EOpAdd: if (getType().getBasicType() != EbtFloat ||
tempConstArray = new TConstantUnion[objectSize]; rightNode->getBasicType() != EbtFloat)
for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] + rightUnionArray[i];
break;
case EOpSub:
tempConstArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] - rightUnionArray[i];
break;
case EOpMul:
case EOpVectorTimesScalar:
case EOpMatrixTimesScalar:
tempConstArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] * rightUnionArray[i];
break;
case EOpMatrixTimesMatrix:
{ {
if (getType().getBasicType() != EbtFloat || infoSink.info.message(
rightNode->getBasicType() != EbtFloat) EPrefixInternalError, getLine(),
{ "Constant Folding cannot be done for matrix multiply");
infoSink.info.message( return nullptr;
EPrefixInternalError, getLine(), }
"Constant Folding cannot be done for matrix multiply");
return nullptr;
}
const int leftCols = getCols(); const int leftCols = getCols();
const int leftRows = getRows(); const int leftRows = getRows();
const int rightCols = rightNode->getType().getCols(); const int rightCols = rightNode->getType().getCols();
const int rightRows = rightNode->getType().getRows(); const int rightRows = rightNode->getType().getRows();
const int resultCols = rightCols; const int resultCols = rightCols;
const int resultRows = leftRows; const int resultRows = leftRows;
tempConstArray = new TConstantUnion[resultCols * resultRows]; resultArray = new TConstantUnion[resultCols * resultRows];
for (int row = 0; row < resultRows; row++) for (int row = 0; row < resultRows; row++)
{
for (int column = 0; column < resultCols; column++)
{ {
for (int column = 0; column < resultCols; column++) resultArray[resultRows * column + row].setFConst(0.0f);
for (int i = 0; i < leftCols; i++)
{ {
tempConstArray[resultRows * column + row].setFConst(0.0f); resultArray[resultRows * column + row].setFConst(
for (int i = 0; i < leftCols; i++) resultArray[resultRows * column + row].getFConst() +
{ leftArray[i * leftRows + row].getFConst() *
tempConstArray[resultRows * column + row].setFConst( rightArray[column * rightRows + i].getFConst());
tempConstArray[resultRows * column + row].getFConst() +
unionArray[i * leftRows + row].getFConst() *
rightUnionArray[column * rightRows + i].getFConst());
}
} }
} }
// update return type for matrix product
returnType.setPrimarySize(static_cast<unsigned char>(resultCols));
returnType.setSecondarySize(static_cast<unsigned char>(resultRows));
} }
break; }
break;
case EOpDiv: case EOpDiv:
case EOpIMod: case EOpIMod:
{
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
{ {
tempConstArray = new TConstantUnion[objectSize]; switch (getType().getBasicType())
for (size_t i = 0; i < objectSize; i++)
{ {
switch (getType().getBasicType()) case EbtFloat:
if (rightArray[i] == 0.0f)
{ {
case EbtFloat: infoSink.info.message(EPrefixWarning, getLine(),
if (rightUnionArray[i] == 0.0f) "Divide by zero error during constant folding");
{ resultArray[i].setFConst(leftArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX);
infoSink.info.message( }
EPrefixWarning, getLine(), else
"Divide by zero error during constant folding"); {
tempConstArray[i].setFConst( ASSERT(op == EOpDiv);
unionArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX); resultArray[i].setFConst(leftArray[i].getFConst() / rightArray[i].getFConst());
} }
else break;
{
ASSERT(op == EOpDiv);
tempConstArray[i].setFConst(
unionArray[i].getFConst() /
rightUnionArray[i].getFConst());
}
break;
case EbtInt: case EbtInt:
if (rightUnionArray[i] == 0) if (rightArray[i] == 0)
{
infoSink.info.message(EPrefixWarning, getLine(),
"Divide by zero error during constant folding");
resultArray[i].setIConst(INT_MAX);
}
else
{
if (op == EOpDiv)
{ {
infoSink.info.message( resultArray[i].setIConst(leftArray[i].getIConst() / rightArray[i].getIConst());
EPrefixWarning, getLine(),
"Divide by zero error during constant folding");
tempConstArray[i].setIConst(INT_MAX);
} }
else else
{ {
if (op == EOpDiv) ASSERT(op == EOpIMod);
{ resultArray[i].setIConst(leftArray[i].getIConst() % rightArray[i].getIConst());
tempConstArray[i].setIConst(
unionArray[i].getIConst() /
rightUnionArray[i].getIConst());
}
else
{
ASSERT(op == EOpIMod);
tempConstArray[i].setIConst(
unionArray[i].getIConst() %
rightUnionArray[i].getIConst());
}
} }
break; }
break;
case EbtUInt: case EbtUInt:
if (rightUnionArray[i] == 0) if (rightArray[i] == 0)
{
infoSink.info.message(EPrefixWarning, getLine(),
"Divide by zero error during constant folding");
resultArray[i].setUConst(UINT_MAX);
}
else
{
if (op == EOpDiv)
{ {
infoSink.info.message( resultArray[i].setUConst(leftArray[i].getUConst() / rightArray[i].getUConst());
EPrefixWarning, getLine(),
"Divide by zero error during constant folding");
tempConstArray[i].setUConst(UINT_MAX);
} }
else else
{ {
if (op == EOpDiv) ASSERT(op == EOpIMod);
{ resultArray[i].setUConst(leftArray[i].getUConst() % rightArray[i].getUConst());
tempConstArray[i].setUConst(
unionArray[i].getUConst() /
rightUnionArray[i].getUConst());
}
else
{
ASSERT(op == EOpIMod);
tempConstArray[i].setUConst(
unionArray[i].getUConst() %
rightUnionArray[i].getUConst());
}
} }
break;
default:
infoSink.info.message(
EPrefixInternalError, getLine(),
"Constant folding cannot be done for \"/\"");
return nullptr;
} }
} break;
}
break;
case EOpMatrixTimesVector: default:
{ infoSink.info.message(EPrefixInternalError, getLine(),
if (rightNode->getBasicType() != EbtFloat) "Constant folding cannot be done for \"/\"");
{
infoSink.info.message(
EPrefixInternalError, getLine(),
"Constant Folding cannot be done for matrix times vector");
return nullptr; return nullptr;
} }
const int matrixCols = getCols();
const int matrixRows = getRows();
tempConstArray = new TConstantUnion[matrixRows];
for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{
tempConstArray[matrixRow].setFConst(0.0f);
for (int col = 0; col < matrixCols; col++)
{
tempConstArray[matrixRow].setFConst(
tempConstArray[matrixRow].getFConst() +
unionArray[col * matrixRows + matrixRow].getFConst() *
rightUnionArray[col].getFConst());
}
}
returnType = rightNode->getType();
returnType.setPrimarySize(static_cast<unsigned char>(matrixRows));
tempNode = new TIntermConstantUnion(tempConstArray, returnType);
tempNode->setLine(getLine());
return tempNode;
} }
}
break;
case EOpVectorTimesMatrix: case EOpMatrixTimesVector:
{
if (rightNode->getBasicType() != EbtFloat)
{ {
if (getType().getBasicType() != EbtFloat) infoSink.info.message(EPrefixInternalError, getLine(),
{ "Constant Folding cannot be done for matrix times vector");
infoSink.info.message( return nullptr;
EPrefixInternalError, getLine(), }
"Constant Folding cannot be done for vector times matrix");
return nullptr;
}
const int matrixCols = rightNode->getType().getCols(); const int matrixCols = getCols();
const int matrixRows = rightNode->getType().getRows(); const int matrixRows = getRows();
tempConstArray = new TConstantUnion[matrixCols]; resultArray = new TConstantUnion[matrixRows];
for (int matrixCol = 0; matrixCol < matrixCols; matrixCol++) for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{
tempConstArray[matrixCol].setFConst(0.0f);
for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{
tempConstArray[matrixCol].setFConst(
tempConstArray[matrixCol].getFConst() +
unionArray[matrixRow].getFConst() *
rightUnionArray[matrixCol * matrixRows + matrixRow].getFConst());
}
}
returnType.setPrimarySize(static_cast<unsigned char>(matrixCols));
}
break;
case EOpLogicalAnd:
// this code is written for possible future use,
// will not get executed currently
{ {
tempConstArray = new TConstantUnion[objectSize]; resultArray[matrixRow].setFConst(0.0f);
for (size_t i = 0; i < objectSize; i++) for (int col = 0; col < matrixCols; col++)
{ {
tempConstArray[i] = unionArray[i] && rightUnionArray[i]; resultArray[matrixRow].setFConst(resultArray[matrixRow].getFConst() +
leftArray[col * matrixRows + matrixRow].getFConst() *
rightArray[col].getFConst());
} }
} }
break; }
break;
case EOpLogicalOr: case EOpVectorTimesMatrix:
// this code is written for possible future use, {
// will not get executed currently if (getType().getBasicType() != EbtFloat)
{ {
tempConstArray = new TConstantUnion[objectSize]; infoSink.info.message(EPrefixInternalError, getLine(),
for (size_t i = 0; i < objectSize; i++) "Constant Folding cannot be done for vector times matrix");
{ return nullptr;
tempConstArray[i] = unionArray[i] || rightUnionArray[i];
}
} }
break;
case EOpLogicalXor: const int matrixCols = rightNode->getType().getCols();
const int matrixRows = rightNode->getType().getRows();
resultArray = new TConstantUnion[matrixCols];
for (int matrixCol = 0; matrixCol < matrixCols; matrixCol++)
{ {
tempConstArray = new TConstantUnion[objectSize]; resultArray[matrixCol].setFConst(0.0f);
for (size_t i = 0; i < objectSize; i++) for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{ {
switch (getType().getBasicType()) resultArray[matrixCol].setFConst(resultArray[matrixCol].getFConst() +
{ leftArray[matrixRow].getFConst() *
case EbtBool: rightArray[matrixCol * matrixRows + matrixRow].getFConst());
tempConstArray[i].setBConst(
unionArray[i] == rightUnionArray[i] ? false : true);
break;
default:
UNREACHABLE();
break;
}
} }
} }
break; }
break;
case EOpBitwiseAnd: case EOpLogicalAnd:
tempConstArray = new TConstantUnion[objectSize]; {
for (size_t i = 0; i < objectSize; i++) resultArray = new TConstantUnion[objectSize];
tempConstArray[i] = unionArray[i] & rightUnionArray[i];
break;
case EOpBitwiseXor:
tempConstArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] ^ rightUnionArray[i];
break;
case EOpBitwiseOr:
tempConstArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] | rightUnionArray[i];
break;
case EOpBitShiftLeft:
tempConstArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] << rightUnionArray[i];
break;
case EOpBitShiftRight:
tempConstArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++) for (size_t i = 0; i < objectSize; i++)
tempConstArray[i] = unionArray[i] >> rightUnionArray[i];
break;
case EOpLessThan:
ASSERT(objectSize == 1);
tempConstArray = new TConstantUnion[1];
tempConstArray->setBConst(*unionArray < *rightUnionArray);
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break;
case EOpGreaterThan:
ASSERT(objectSize == 1);
tempConstArray = new TConstantUnion[1];
tempConstArray->setBConst(*unionArray > *rightUnionArray);
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break;
case EOpLessThanEqual:
{ {
ASSERT(objectSize == 1); resultArray[i] = leftArray[i] && rightArray[i];
TConstantUnion constant;
constant.setBConst(*unionArray > *rightUnionArray);
tempConstArray = new TConstantUnion[1];
tempConstArray->setBConst(!constant.getBConst());
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break;
} }
}
break;
case EOpGreaterThanEqual: case EOpLogicalOr:
{
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
{ {
ASSERT(objectSize == 1); resultArray[i] = leftArray[i] || rightArray[i];
TConstantUnion constant;
constant.setBConst(*unionArray < *rightUnionArray);
tempConstArray = new TConstantUnion[1];
tempConstArray->setBConst(!constant.getBConst());
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break;
} }
}
break;
case EOpEqual: case EOpLogicalXor:
if (getType().getBasicType() == EbtStruct) {
{ resultArray = new TConstantUnion[objectSize];
if (!CompareStructure(rightNode->getType(), for (size_t i = 0; i < objectSize; i++)
rightNode->getUnionArrayPointer(),
unionArray))
{
boolNodeFlag = true;
}
}
else
{ {
for (size_t i = 0; i < objectSize; i++) switch (getType().getBasicType())
{ {
if (unionArray[i] != rightUnionArray[i]) case EbtBool:
{ resultArray[i].setBConst(leftArray[i] != rightArray[i]);
boolNodeFlag = true; break;
break; // break out of for loop default:
} UNREACHABLE();
break;
} }
} }
}
break;
tempConstArray = new TConstantUnion[1]; case EOpBitwiseAnd:
if (!boolNodeFlag) resultArray = new TConstantUnion[objectSize];
{ for (size_t i = 0; i < objectSize; i++)
tempConstArray->setBConst(true); resultArray[i] = leftArray[i] & rightArray[i];
} break;
else case EOpBitwiseXor:
{ resultArray = new TConstantUnion[objectSize];
tempConstArray->setBConst(false); for (size_t i = 0; i < objectSize; i++)
} resultArray[i] = leftArray[i] ^ rightArray[i];
break;
case EOpBitwiseOr:
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
resultArray[i] = leftArray[i] | rightArray[i];
break;
case EOpBitShiftLeft:
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
resultArray[i] = leftArray[i] << rightArray[i];
break;
case EOpBitShiftRight:
resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++)
resultArray[i] = leftArray[i] >> rightArray[i];
break;
tempNode = new TIntermConstantUnion( case EOpLessThan:
tempConstArray, TType(EbtBool, EbpUndefined, EvqConst)); ASSERT(objectSize == 1);
tempNode->setLine(getLine()); resultArray = new TConstantUnion[1];
resultArray->setBConst(*leftArray < *rightArray);
break;
return tempNode; case EOpGreaterThan:
ASSERT(objectSize == 1);
resultArray = new TConstantUnion[1];
resultArray->setBConst(*leftArray > *rightArray);
break;
case EOpNotEqual: case EOpLessThanEqual:
ASSERT(objectSize == 1);
resultArray = new TConstantUnion[1];
resultArray->setBConst(!(*leftArray > *rightArray));
break;
case EOpGreaterThanEqual:
ASSERT(objectSize == 1);
resultArray = new TConstantUnion[1];
resultArray->setBConst(!(*leftArray < *rightArray));
break;
case EOpEqual:
case EOpNotEqual:
{
resultArray = new TConstantUnion[1];
bool equal = true;
if (getType().getBasicType() == EbtStruct) if (getType().getBasicType() == EbtStruct)
{ {
if (CompareStructure(rightNode->getType(), equal = CompareStructure(getType(), rightArray, leftArray);
rightNode->getUnionArrayPointer(),
unionArray))
{
boolNodeFlag = true;
}
} }
else else
{ {
for (size_t i = 0; i < objectSize; i++) for (size_t i = 0; i < objectSize; i++)
{ {
if (unionArray[i] == rightUnionArray[i]) if (leftArray[i] != rightArray[i])
{ {
boolNodeFlag = true; equal = false;
break; // break out of for loop break; // break out of for loop
} }
} }
} }
if (op == EOpEqual)
tempConstArray = new TConstantUnion[1];
if (!boolNodeFlag)
{ {
tempConstArray->setBConst(true); resultArray->setBConst(equal);
} }
else else
{ {
tempConstArray->setBConst(false); resultArray->setBConst(!equal);
} }
}
break;
default:
infoSink.info.message(
EPrefixInternalError, getLine(),
"Invalid operator for constant folding");
return nullptr;
}
return resultArray;
}
tempNode = new TIntermConstantUnion( //
tempConstArray, TType(EbtBool, EbpUndefined, EvqConst)); // The fold functions see if an operation on a constant can be done in place,
tempNode->setLine(getLine()); // without generating run-time code.
//
// Returns the node to keep using or nullptr.
//
TIntermTyped *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSink)
{
TConstantUnion *unionArray = getUnionArrayPointer();
return tempNode; if (!unionArray)
return nullptr;
default: size_t objectSize = getType().getObjectSize();
infoSink.info.message(
EPrefixInternalError, getLine(),
"Invalid operator for constant folding");
return nullptr;
}
tempNode = new TIntermConstantUnion(tempConstArray, returnType);
tempNode->setLine(getLine());
return tempNode; if (op == EOpAny || op == EOpAll || op == EOpLength)
}
else if (op == EOpAny || op == EOpAll || op == EOpLength)
{ {
// Do operations where the return type is different from the operand type. // Do operations where the return type is different from the operand type.
......
src/compiler/translator/IntermNode.h
...@@ -299,7 +299,8 @@ class TIntermConstantUnion : public TIntermTyped ...@@ -299,7 +299,8 @@ class TIntermConstantUnion : public TIntermTyped
virtual void traverse(TIntermTraverser *); virtual void traverse(TIntermTraverser *);
virtual bool replaceChildNode(TIntermNode *, TIntermNode *) { return false; } virtual bool replaceChildNode(TIntermNode *, TIntermNode *) { return false; }
TIntermTyped *fold(TOperator op, TIntermConstantUnion *rightNode, TInfoSink &infoSink); TConstantUnion *foldBinary(TOperator op, TIntermConstantUnion *rightNode, TInfoSink &infoSink);
TIntermTyped *foldUnary(TOperator op, TInfoSink &infoSink);
static TIntermTyped *FoldAggregateBuiltIn(TOperator op, TIntermAggregate *aggregate, TInfoSink &infoSink); static TIntermTyped *FoldAggregateBuiltIn(TOperator op, TIntermAggregate *aggregate, TInfoSink &infoSink);
...@@ -362,6 +363,7 @@ class TIntermBinary : public TIntermOperator ...@@ -362,6 +363,7 @@ class TIntermBinary : public TIntermOperator
TIntermTyped *getLeft() const { return mLeft; } TIntermTyped *getLeft() const { return mLeft; }
TIntermTyped *getRight() const { return mRight; } TIntermTyped *getRight() const { return mRight; }
bool promote(TInfoSink &); bool promote(TInfoSink &);
TIntermTyped *fold(TInfoSink &infoSink);
void setAddIndexClamp() { mAddIndexClamp = true; } void setAddIndexClamp() { mAddIndexClamp = true; }
bool getAddIndexClamp() { return mAddIndexClamp; } bool getAddIndexClamp() { return mAddIndexClamp; }
......
src/compiler/translator/Intermediate.cpp
...@@ -57,19 +57,10 @@ TIntermTyped *TIntermediate::addBinaryMath( ...@@ -57,19 +57,10 @@ TIntermTyped *TIntermediate::addBinaryMath(
if (!node->promote(mInfoSink)) if (!node->promote(mInfoSink))
return NULL; return NULL;
//
// See if we can fold constants. // See if we can fold constants.
// TIntermTyped *foldedNode = node->fold(mInfoSink);
TIntermConstantUnion *leftTempConstant = left->getAsConstantUnion(); if (foldedNode)
TIntermConstantUnion *rightTempConstant = right->getAsConstantUnion(); return foldedNode;
if (leftTempConstant && rightTempConstant)
{
TIntermTyped *typedReturnNode =
leftTempConstant->fold(node->getOp(), rightTempConstant, mInfoSink);
if (typedReturnNode)
return typedReturnNode;
}
return node; return node;
} }
...@@ -143,7 +134,7 @@ TIntermTyped *TIntermediate::addUnaryMath( ...@@ -143,7 +134,7 @@ TIntermTyped *TIntermediate::addUnaryMath(
if (childTempConstant) if (childTempConstant)
{ {
TIntermTyped *newChild = childTempConstant->fold(op, nullptr, mInfoSink); TIntermTyped *newChild = childTempConstant->foldUnary(op, mInfoSink);
if (newChild) if (newChild)
return newChild; return newChild;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment