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 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