Skip to content

A
angle
Commit 2c4b746c by Olli Etuaho
Options

Revert "Revert "Make sure type gets set consistently in folded binary operations""

This patch was originally reverted only because a dependency patch failed a buggy Chromium test. This reverts commit aebd002d. TEST=dEQP-GLES3.functional.shaders.constant_expressions.* BUG=angleproject:817 Change-Id: Ia5acf15518ea89717c0cfe1398cb18ea27be5b19 Reviewed-on: https://chromium-review.googlesource.com/275811Tested-by: 's avatarOlli Etuaho <oetuaho@nvidia.com> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org>
parent bd4cfdcd
Showing with 130 additions and 210 deletions
src/compiler/translator/IntermNode.cpp
...@@ -747,68 +747,76 @@ bool TIntermBinary::promote(TInfoSink &infoSink) ...@@ -747,68 +747,76 @@ 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)
{
// binary operations
TConstantUnion *rightUnionArray = rightNode->getUnionArrayPointer();
TType returnType = getType();
if (!rightUnionArray)
return nullptr;
// for a case like float f = vec4(2, 3, 4, 5) + 1.2; // for a case like float f = vec4(2, 3, 4, 5) + 1.2;
if (rightNode->getType().getObjectSize() == 1 && objectSize > 1) if (rightNode->getType().getObjectSize() == 1 && objectSize > 1)
{ {
rightUnionArray = Vectorize(*rightNode->getUnionArrayPointer(), objectSize); rightArray = Vectorize(*rightNode->getUnionArrayPointer(), objectSize);
returnType = getType();
} }
else if (rightNode->getType().getObjectSize() > 1 && objectSize == 1) else if (rightNode->getType().getObjectSize() > 1 && objectSize == 1)
{ {
// for a case like float f = 1.2 + vec4(2, 3, 4, 5); // for a case like float f = 1.2 + vec4(2, 3, 4, 5);
unionArray = Vectorize(*getUnionArrayPointer(), rightNode->getType().getObjectSize()); leftArray = Vectorize(*getUnionArrayPointer(), rightNode->getType().getObjectSize());
returnType = rightNode->getType();
objectSize = rightNode->getType().getObjectSize(); objectSize = rightNode->getType().getObjectSize();
} }
TConstantUnion *tempConstArray = nullptr; TConstantUnion *resultArray = nullptr;
TIntermConstantUnion *tempNode;
bool boolNodeFlag = false;
switch(op) switch(op)
{ {
case EOpAdd: case EOpAdd:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] + rightArray[i];
break; break;
case EOpSub: case EOpSub:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] - rightArray[i];
break; break;
case EOpMul: case EOpMul:
case EOpVectorTimesScalar: case EOpVectorTimesScalar:
case EOpMatrixTimesScalar: case EOpMatrixTimesScalar:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] * rightArray[i];
break; break;
case EOpMatrixTimesMatrix: case EOpMatrixTimesMatrix:
...@@ -829,109 +837,90 @@ TIntermTyped *TIntermConstantUnion::fold( ...@@ -829,109 +837,90 @@ TIntermTyped *TIntermConstantUnion::fold(
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++)
{ {
tempConstArray[resultRows * column + row].setFConst(0.0f); resultArray[resultRows * column + row].setFConst(0.0f);
for (int i = 0; i < leftCols; i++) for (int i = 0; i < leftCols; i++)
{ {
tempConstArray[resultRows * column + row].setFConst( resultArray[resultRows * column + row].setFConst(
tempConstArray[resultRows * column + row].getFConst() + resultArray[resultRows * column + row].getFConst() +
unionArray[i * leftRows + row].getFConst() * leftArray[i * leftRows + row].getFConst() *
rightUnionArray[column * rightRows + i].getFConst()); rightArray[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:
{ {
tempConstArray = new TConstantUnion[objectSize]; resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++) for (size_t i = 0; i < objectSize; i++)
{ {
switch (getType().getBasicType()) switch (getType().getBasicType())
{ {
case EbtFloat: case EbtFloat:
if (rightUnionArray[i] == 0.0f) if (rightArray[i] == 0.0f)
{ {
infoSink.info.message( infoSink.info.message(EPrefixWarning, getLine(),
EPrefixWarning, getLine(),
"Divide by zero error during constant folding"); "Divide by zero error during constant folding");
tempConstArray[i].setFConst( resultArray[i].setFConst(leftArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX);
unionArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX);
} }
else else
{ {
ASSERT(op == EOpDiv); ASSERT(op == EOpDiv);
tempConstArray[i].setFConst( resultArray[i].setFConst(leftArray[i].getFConst() / rightArray[i].getFConst());
unionArray[i].getFConst() /
rightUnionArray[i].getFConst());
} }
break; break;
case EbtInt: case EbtInt:
if (rightUnionArray[i] == 0) if (rightArray[i] == 0)
{ {
infoSink.info.message( infoSink.info.message(EPrefixWarning, getLine(),
EPrefixWarning, getLine(),
"Divide by zero error during constant folding"); "Divide by zero error during constant folding");
tempConstArray[i].setIConst(INT_MAX); resultArray[i].setIConst(INT_MAX);
} }
else else
{ {
if (op == EOpDiv) if (op == EOpDiv)
{ {
tempConstArray[i].setIConst( resultArray[i].setIConst(leftArray[i].getIConst() / rightArray[i].getIConst());
unionArray[i].getIConst() /
rightUnionArray[i].getIConst());
} }
else else
{ {
ASSERT(op == EOpIMod); ASSERT(op == EOpIMod);
tempConstArray[i].setIConst( resultArray[i].setIConst(leftArray[i].getIConst() % rightArray[i].getIConst());
unionArray[i].getIConst() %
rightUnionArray[i].getIConst());
} }
} }
break; break;
case EbtUInt: case EbtUInt:
if (rightUnionArray[i] == 0) if (rightArray[i] == 0)
{ {
infoSink.info.message( infoSink.info.message(EPrefixWarning, getLine(),
EPrefixWarning, getLine(),
"Divide by zero error during constant folding"); "Divide by zero error during constant folding");
tempConstArray[i].setUConst(UINT_MAX); resultArray[i].setUConst(UINT_MAX);
} }
else else
{ {
if (op == EOpDiv) if (op == EOpDiv)
{ {
tempConstArray[i].setUConst( resultArray[i].setUConst(leftArray[i].getUConst() / rightArray[i].getUConst());
unionArray[i].getUConst() /
rightUnionArray[i].getUConst());
} }
else else
{ {
ASSERT(op == EOpIMod); ASSERT(op == EOpIMod);
tempConstArray[i].setUConst( resultArray[i].setUConst(leftArray[i].getUConst() % rightArray[i].getUConst());
unionArray[i].getUConst() %
rightUnionArray[i].getUConst());
} }
} }
break; break;
default: default:
infoSink.info.message( infoSink.info.message(EPrefixInternalError, getLine(),
EPrefixInternalError, getLine(),
"Constant folding cannot be done for \"/\""); "Constant folding cannot be done for \"/\"");
return nullptr; return nullptr;
} }
...@@ -943,8 +932,7 @@ TIntermTyped *TIntermConstantUnion::fold( ...@@ -943,8 +932,7 @@ TIntermTyped *TIntermConstantUnion::fold(
{ {
if (rightNode->getBasicType() != EbtFloat) if (rightNode->getBasicType() != EbtFloat)
{ {
infoSink.info.message( infoSink.info.message(EPrefixInternalError, getLine(),
EPrefixInternalError, getLine(),
"Constant Folding cannot be done for matrix times vector"); "Constant Folding cannot be done for matrix times vector");
return nullptr; return nullptr;
} }
...@@ -952,35 +940,26 @@ TIntermTyped *TIntermConstantUnion::fold( ...@@ -952,35 +940,26 @@ TIntermTyped *TIntermConstantUnion::fold(
const int matrixCols = getCols(); const int matrixCols = getCols();
const int matrixRows = getRows(); const int matrixRows = getRows();
tempConstArray = new TConstantUnion[matrixRows]; resultArray = new TConstantUnion[matrixRows];
for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++) for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{ {
tempConstArray[matrixRow].setFConst(0.0f); resultArray[matrixRow].setFConst(0.0f);
for (int col = 0; col < matrixCols; col++) for (int col = 0; col < matrixCols; col++)
{ {
tempConstArray[matrixRow].setFConst( resultArray[matrixRow].setFConst(resultArray[matrixRow].getFConst() +
tempConstArray[matrixRow].getFConst() + leftArray[col * matrixRows + matrixRow].getFConst() *
unionArray[col * matrixRows + matrixRow].getFConst() * rightArray[col].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 EOpVectorTimesMatrix:
{ {
if (getType().getBasicType() != EbtFloat) if (getType().getBasicType() != EbtFloat)
{ {
infoSink.info.message( infoSink.info.message(EPrefixInternalError, getLine(),
EPrefixInternalError, getLine(),
"Constant Folding cannot be done for vector times matrix"); "Constant Folding cannot be done for vector times matrix");
return nullptr; return nullptr;
} }
...@@ -988,58 +967,50 @@ TIntermTyped *TIntermConstantUnion::fold( ...@@ -988,58 +967,50 @@ TIntermTyped *TIntermConstantUnion::fold(
const int matrixCols = rightNode->getType().getCols(); const int matrixCols = rightNode->getType().getCols();
const int matrixRows = rightNode->getType().getRows(); const int matrixRows = rightNode->getType().getRows();
tempConstArray = new TConstantUnion[matrixCols]; resultArray = new TConstantUnion[matrixCols];
for (int matrixCol = 0; matrixCol < matrixCols; matrixCol++) for (int matrixCol = 0; matrixCol < matrixCols; matrixCol++)
{ {
tempConstArray[matrixCol].setFConst(0.0f); resultArray[matrixCol].setFConst(0.0f);
for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++) for (int matrixRow = 0; matrixRow < matrixRows; matrixRow++)
{ {
tempConstArray[matrixCol].setFConst( resultArray[matrixCol].setFConst(resultArray[matrixCol].getFConst() +
tempConstArray[matrixCol].getFConst() + leftArray[matrixRow].getFConst() *
unionArray[matrixRow].getFConst() * rightArray[matrixCol * matrixRows + matrixRow].getFConst());
rightUnionArray[matrixCol * matrixRows + matrixRow].getFConst());
} }
} }
returnType.setPrimarySize(static_cast<unsigned char>(matrixCols));
} }
break; break;
case EOpLogicalAnd: case EOpLogicalAnd:
// this code is written for possible future use,
// will not get executed currently
{ {
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] && rightArray[i];
} }
} }
break; break;
case EOpLogicalOr: case EOpLogicalOr:
// this code is written for possible future use,
// will not get executed currently
{ {
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] || rightArray[i];
} }
} }
break; break;
case EOpLogicalXor: case EOpLogicalXor:
{ {
tempConstArray = new TConstantUnion[objectSize]; resultArray = new TConstantUnion[objectSize];
for (size_t i = 0; i < objectSize; i++) for (size_t i = 0; i < objectSize; i++)
{ {
switch (getType().getBasicType()) switch (getType().getBasicType())
{ {
case EbtBool: case EbtBool:
tempConstArray[i].setBConst( resultArray[i].setBConst(leftArray[i] != rightArray[i]);
unionArray[i] == rightUnionArray[i] ? false : true);
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();
...@@ -1050,142 +1021,85 @@ TIntermTyped *TIntermConstantUnion::fold( ...@@ -1050,142 +1021,85 @@ TIntermTyped *TIntermConstantUnion::fold(
break; break;
case EOpBitwiseAnd: case EOpBitwiseAnd:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] & rightArray[i];
break; break;
case EOpBitwiseXor: case EOpBitwiseXor:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] ^ rightArray[i];
break; break;
case EOpBitwiseOr: case EOpBitwiseOr:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] | rightArray[i];
break; break;
case EOpBitShiftLeft: case EOpBitShiftLeft:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] << rightArray[i];
break; break;
case EOpBitShiftRight: case EOpBitShiftRight:
tempConstArray = new TConstantUnion[objectSize]; resultArray = 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]; resultArray[i] = leftArray[i] >> rightArray[i];
break; break;
case EOpLessThan: case EOpLessThan:
ASSERT(objectSize == 1); ASSERT(objectSize == 1);
tempConstArray = new TConstantUnion[1]; resultArray = new TConstantUnion[1];
tempConstArray->setBConst(*unionArray < *rightUnionArray); resultArray->setBConst(*leftArray < *rightArray);
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break; break;
case EOpGreaterThan: case EOpGreaterThan:
ASSERT(objectSize == 1); ASSERT(objectSize == 1);
tempConstArray = new TConstantUnion[1]; resultArray = new TConstantUnion[1];
tempConstArray->setBConst(*unionArray > *rightUnionArray); resultArray->setBConst(*leftArray > *rightArray);
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break; break;
case EOpLessThanEqual: case EOpLessThanEqual:
{
ASSERT(objectSize == 1); ASSERT(objectSize == 1);
TConstantUnion constant; resultArray = new TConstantUnion[1];
constant.setBConst(*unionArray > *rightUnionArray); resultArray->setBConst(!(*leftArray > *rightArray));
tempConstArray = new TConstantUnion[1];
tempConstArray->setBConst(!constant.getBConst());
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break; break;
}
case EOpGreaterThanEqual: case EOpGreaterThanEqual:
{
ASSERT(objectSize == 1); ASSERT(objectSize == 1);
TConstantUnion constant; resultArray = new TConstantUnion[1];
constant.setBConst(*unionArray < *rightUnionArray); resultArray->setBConst(!(*leftArray < *rightArray));
tempConstArray = new TConstantUnion[1];
tempConstArray->setBConst(!constant.getBConst());
returnType = TType(EbtBool, EbpUndefined, EvqConst);
break; break;
}
case EOpEqual: case EOpEqual:
if (getType().getBasicType() == EbtStruct)
{
if (!CompareStructure(rightNode->getType(),
rightNode->getUnionArrayPointer(),
unionArray))
{
boolNodeFlag = true;
}
}
else
{
for (size_t i = 0; i < objectSize; i++)
{
if (unionArray[i] != rightUnionArray[i])
{
boolNodeFlag = true;
break; // break out of for loop
}
}
}
tempConstArray = new TConstantUnion[1];
if (!boolNodeFlag)
{
tempConstArray->setBConst(true);
}
else
{
tempConstArray->setBConst(false);
}
tempNode = new TIntermConstantUnion(
tempConstArray, TType(EbtBool, EbpUndefined, EvqConst));
tempNode->setLine(getLine());
return tempNode;
case EOpNotEqual: case EOpNotEqual:
if (getType().getBasicType() == EbtStruct)
{ {
if (CompareStructure(rightNode->getType(), resultArray = new TConstantUnion[1];
rightNode->getUnionArrayPointer(), bool equal = true;
unionArray)) if (getType().getBasicType() == EbtStruct)
{ {
boolNodeFlag = true; equal = CompareStructure(getType(), rightArray, leftArray);
}
} }
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);
} }
}
tempNode = new TIntermConstantUnion( break;
tempConstArray, TType(EbtBool, EbpUndefined, EvqConst));
tempNode->setLine(getLine());
return tempNode;
default: default:
infoSink.info.message( infoSink.info.message(
...@@ -1193,12 +1107,25 @@ TIntermTyped *TIntermConstantUnion::fold( ...@@ -1193,12 +1107,25 @@ TIntermTyped *TIntermConstantUnion::fold(
"Invalid operator for constant folding"); "Invalid operator for constant folding");
return nullptr; return nullptr;
} }
tempNode = new TIntermConstantUnion(tempConstArray, returnType); return resultArray;
tempNode->setLine(getLine()); }
return tempNode; //
} // The fold functions see if an operation on a constant can be done in place,
else if (op == EOpAny || op == EOpAll || op == EOpLength) // without generating run-time code.
//
// Returns the node to keep using or nullptr.
//
TIntermTyped *TIntermConstantUnion::foldUnary(TOperator op, TInfoSink &infoSink)
{
TConstantUnion *unionArray = getUnionArrayPointer();
if (!unionArray)
return nullptr;
size_t objectSize = getType().getObjectSize();
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