////////////////////////////////////////////////////////////////////////////
public override Statement visit(ConditionalBranch s)
{
ControlStatement result = s;
// var ne = si.fae.visit(this);
ProgramVariable oc = s.condition;
ProgramVariable nc = s.condition;
EqualityDatabase.Representative rep = database.tryGetRepresentative(s.condition);
if (rep != null)
{
Expression ne = rep.expression;
if (ne is LiteralExpression)
{
if (((ne as LiteralExpression).value as BooleanValue).value)
{
result = new UnconditionalBranch(s.trueBranch.source, s.trueBranch.target);
}
else
{
result = new UnconditionalBranch(s.falseBranch.source, s.falseBranch.target);
}
nc = null;
}
else
{
if (ne is ProgramVariableExpression)
{
s.condition = (ne as ProgramVariableExpression).programVariable;
nc = s.condition;
}
else
{
nc =
(EqualityDatabase.getCompactNegationIfBoolean(ne) as ProgramVariableExpression).
programVariable;
result = new ConditionalBranch(
database.statementId.basicBlock,
nc,
s.falseBranch.target,
s.trueBranch.target
);
}
}
}
if (nc != null && !database.conditionVariableIndices.ContainsKey(nc.name))
{
database.addConditionVariable(nc);
}
return(result);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private static void redirectFriend(BasicBlock f, BasicBlock assumeInsertion)
{
bool polarity = true;
var fcb = f.getControlStatement() as ConditionalBranch;
Debug.Assert(fcb != null);
var icb = assumeInsertion.getControlStatement() as ConditionalBranch;
Debug.Assert(icb != null);
ProgramVariable icv = icb.condition;
Debug.Assert(
(fcb.trueBranch.target == icb.trueBranch.target && fcb.falseBranch.target == icb.falseBranch.target) ||
(fcb.trueBranch.target == icb.falseBranch.target && fcb.falseBranch.target == icb.trueBranch.target)
);
if (fcb.trueBranch.target == icb.trueBranch.target)
{
polarity = true;
}
else
{
polarity = false;
}
Expression assumeE;
getOwnAssume(f, out assumeE);
if (assumeE != null)
{
var assume = f.statements[f.statements.Count - 2].statement as Assume;
Expression newAssumeE = (polarity) ? assumeE : EqualityDatabase.getCompactNegationIfBoolean(assumeE);
assume.expression = new BasicFAE(
BFunction.equivalence, //eq(BooleanType.booleanType),
new ExpressionList(
new BasicProgramVariableExpression(icv),
newAssumeE
)
);
}
f.setControlStatement(new UnconditionalBranch(f, assumeInsertion));
}
////////////////////////////////////////////////////////////////////////////
private int evaluatePredicateExpression(Expression expression)
{
if (database.isFact(expression))
{
return(1);
}
if (database.isFact(EqualityDatabase.getCompactNegationIfBoolean(expression)))
{
return(-1);
}
var le = expression as LiteralExpression;
if (le != null)
{
Debug.Assert(le.type is BooleanType);
return(((le.value as BooleanValue).value) ? 1 : -1);
}
return(0);
}
