//
// For "if" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are in the
// nodePair.
//
// Returns the selection node created.
//
TIntermNode *TIntermediate::addSelection(
TIntermTyped *cond, TIntermNodePair nodePair, const TSourceLoc &line)
{
//
// For compile time constant selections, prune the code and
// test now.
//
if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion())
{
if (cond->getAsConstantUnion()->getBConst(0) == true)
{
return nodePair.node1 ? setAggregateOperator(
nodePair.node1, EOpSequence, nodePair.node1->getLine()) : NULL;
}
else
{
return nodePair.node2 ? setAggregateOperator(
nodePair.node2, EOpSequence, nodePair.node2->getLine()) : NULL;
}
}
TIntermSelection *node = new TIntermSelection(
cond, nodePair.node1, nodePair.node2);
node->setLine(line);
return node;
}
//
// For "?:" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are specified
// as separate parameters.
//
// Returns the selection node created, or 0 if one could not be.
//
TIntermTyped *TIntermediate::addSelection(
TIntermTyped *cond, TIntermTyped *trueBlock, TIntermTyped *falseBlock,
const TSourceLoc &line)
{
if (!cond || !trueBlock || !falseBlock ||
trueBlock->getType() != falseBlock->getType())
{
return NULL;
}
//
// See if all the operands are constant, then fold it otherwise not.
//
if (cond->getAsConstantUnion() &&
trueBlock->getAsConstantUnion() &&
falseBlock->getAsConstantUnion())
{
if (cond->getAsConstantUnion()->getBConst(0))
return trueBlock;
else
return falseBlock;
}
//
// Make a selection node.
//
TIntermSelection *node = new TIntermSelection(
cond, trueBlock, falseBlock, trueBlock->getType());
node->getTypePointer()->setQualifier(EvqTemporary);
node->setLine(line);
return node;
}
//
// For "?:" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are specified
// as separate parameters.
//
// Returns the selection node created, or 0 if one could not be.
//
TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc line)
{
//
// Get compatible types.
//
TIntermTyped* child = addConversion(EOpSequence, trueBlock->getType(), falseBlock);
if (child)
falseBlock = child;
else {
child = addConversion(EOpSequence, falseBlock->getType(), trueBlock);
if (child)
trueBlock = child;
else
return 0;
}
//
// See if all the operands are constant, then fold it otherwise not.
//
if (cond->getAsConstantUnion() && trueBlock->getAsConstantUnion() && falseBlock->getAsConstantUnion()) {
if (cond->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
return trueBlock;
else
return falseBlock;
}
//
// Make a selection node.
//
TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
node->setLine(line);
return node;
}
//
// For "?:" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are specified
// as separate parameters.
//
// Returns the selection node created, or one of trueBlock and falseBlock if the expression could be folded.
//
TIntermTyped *TIntermediate::addSelection(TIntermTyped *cond, TIntermTyped *trueBlock, TIntermTyped *falseBlock,
const TSourceLoc &line)
{
// Right now it's safe to fold ternary operators only when all operands
// are constant. If only the condition is constant, it's theoretically
// possible to fold the ternary operator, but that requires making sure
// that the node returned from here won't be treated as a constant
// expression in case the node that gets eliminated was not a constant
// expression.
if (cond->getAsConstantUnion() &&
trueBlock->getAsConstantUnion() &&
falseBlock->getAsConstantUnion())
{
if (cond->getAsConstantUnion()->getBConst(0))
return trueBlock;
else
return falseBlock;
}
//
// Make a selection node.
//
TIntermSelection *node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
node->getTypePointer()->setQualifier(EvqTemporary);
node->setLine(line);
return node;
}
// For "if" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are in the
// nodePair.
TIntermNode* ir_add_selection(TIntermTyped* cond, TIntermNodePair nodePair, TSourceLoc line, TInfoSink& infoSink)
{
// Convert float/int to bool
if ( cond->getBasicType() != EbtBool)
{
cond = ir_add_conversion (EOpConstructBool,
TType (EbtBool, cond->getPrecision(), cond->getQualifier(), cond->getColsCount(), cond->getRowsCount(), cond->isMatrix(), cond->isArray()),
cond, infoSink);
}
TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2);
node->setLine(line);
return node;
}
//
// For "if" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are in the
// nodePair.
//
// Returns the selection node created.
//
TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nodePair, TSourceLoc line)
{
//
// For compile time constant selections, prune the code and
// test now.
//
if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion()) {
if (cond->getAsTyped()->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
return nodePair.node1;
else
return nodePair.node2;
}
TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2);
node->setLine(line);
return node;
}
// For "if" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are in the
// nodePair.
TIntermNode* ir_add_selection(TIntermTyped* cond, TIntermNodePair nodePair, TSourceLoc line, TInfoSink& infoSink)
{
// Convert float/int to bool
switch ( cond->getBasicType() )
{
case EbtFloat:
case EbtInt:
cond = ir_add_conversion (EOpConstructBool,
TType (EbtBool, cond->getPrecision(), cond->getQualifier(), cond->getNominalSize(), cond->isMatrix(), cond->isArray()),
cond, infoSink);
break;
default:
// Do nothing
break;
}
TIntermSelection* node = new TIntermSelection(cond, nodePair.node1, nodePair.node2);
node->setLine(line);
return node;
}
bool ElseBlockRewriter::visitAggregate(Visit visit, TIntermAggregate *node)
{
switch (node->getOp())
{
case EOpSequence:
{
for (size_t statementIndex = 0; statementIndex != node->getSequence().size(); statementIndex++)
{
TIntermNode *statement = node->getSequence()[statementIndex];
TIntermSelection *selection = statement->getAsSelectionNode();
if (selection && selection->getFalseBlock() != NULL)
{
node->getSequence()[statementIndex] = rewriteSelection(selection);
delete selection;
}
}
}
break;
default: break;
}
return true;
}
// For "?:" test nodes. There are three children; a condition,
// a true path, and a false path. The two paths are specified
// as separate parameters.
TIntermTyped* ir_add_selection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc line, TInfoSink& infoSink)
{
bool bPromoteFromTrueBlockType = true;
if (cond->getBasicType() != EbtBool)
{
cond = ir_add_conversion (EOpConstructBool,
TType (EbtBool, cond->getPrecision(), cond->getQualifier(), cond->getColsCount(), cond->getRowsCount(), cond->isMatrix(), cond->isArray()),
cond, infoSink);
}
// Choose which one to try to promote to based on which has more precision
// By default, it will promote from the falseBlock type to the trueBlock type. However,
// what we want to do is promote to the type with the most precision of the two. So here,
// check whether the false block has more precision than the true block, and if so use
// its type instead.
if ( trueBlock->getBasicType() == EbtBool )
{
if ( falseBlock->getBasicType() == EbtInt ||
falseBlock->getBasicType() == EbtFloat )
{
bPromoteFromTrueBlockType = false;
}
}
else if ( trueBlock->getBasicType() == EbtInt )
{
if ( falseBlock->getBasicType() == EbtFloat )
{
bPromoteFromTrueBlockType = false;
}
}
//
// Get compatible types.
//
if ( bPromoteFromTrueBlockType )
{
TIntermTyped* child = ir_add_conversion(EOpSequence, trueBlock->getType(), falseBlock, infoSink);
if (child)
falseBlock = child;
else
{
child = ir_add_conversion(EOpSequence, falseBlock->getType(), trueBlock, infoSink);
if (child)
trueBlock = child;
else
return 0;
}
}
else
{
TIntermTyped* child = ir_add_conversion(EOpSequence, falseBlock->getType(), trueBlock, infoSink);
if (child)
trueBlock = child;
else
{
child = ir_add_conversion(EOpSequence, trueBlock->getType(), falseBlock, infoSink);
if (child)
falseBlock = child;
else
return 0;
}
}
//
// Make a selection node.
//
TIntermSelection* node = new TIntermSelection(cond, trueBlock, falseBlock, trueBlock->getType());
node->setLine(line);
if (!node->promoteTernary(infoSink))
return 0;
return node;
}
