////////////////////////////////////////////////////////////////////////////////////////////////
private static Expression PF2E(IDictionary <int, ProgramVariable> conditionVariableNames, PropositionalFormula f)
{
if (f.isTrue)
{
return(new BasicLiteralExpression(BooleanValue.makeBooleanValue(true)));
}
if (f.isFalse)
{
return(new BasicLiteralExpression(BooleanValue.makeBooleanValue(false)));
}
Debug.Assert(f.disjuncts.Count() > 0);
Expression result = null;
foreach (var d in f.disjuncts)
{
if (result == null)
{
result = D2E(conditionVariableNames, d);
}
else
{
result = new BasicFAE(
BFunctionTemplate.or.getInstance(),
new ExpressionList(
result,
D2E(conditionVariableNames, d)
)
);
}
}
return(result);
}
////////////////////////////////////////////////////////////////////////////////////////////////
private static Expression C2E(IDictionary <int, ProgramVariable> conditionVariableNames, Tuple <bool, int> c)
{
Expression result = new BasicProgramVariableExpression(conditionVariableNames[c.Item2]);
if (!c.Item1)
{
result = new BasicFAE(
BFunctionTemplate.not.getInstance(),
new ExpressionList(
result
)
);
}
return(result);
}
public virtual Expression visit(FAE f)
{
Function newF = visitFunction(f.function);
ExpressionList newA = f.arguments.visit(this);
Expression result;
if (!ReferenceEquals(f.function, newF) || !ReferenceEquals(f.arguments, newA))
{
result = new BasicFAE(newF, newA);
}
else
{
result = f;
}
return(result);
}
private Expression makeMapWriteMap(FAE fae)
{
Debug.Assert(fae.function is MapWrite);
Debug.Assert(fae.arguments[0].type is MapType);
var mu = fae.function as MapWrite;
Expression result;
if (!versionMap.TryGetValue(fae.ToString(), out result))
{
var ot = fae.arguments[0].type as MapType;
Debug.Assert(ot != null);
var s = new TypeParameterInstantiation(ot.typeParameters, mu.typeArguments.Skip(1).ToArray());
// var ots = new MapType(new TypeVariable[0], (from m in ot.domain select m.substitute(s)).ToArray(), ot.range.substitute(s));
Expression m = fae.arguments[0];
Expression[] i = fae.arguments.Take(fae.arguments.count - 1).Skip(1).ToArray();
if (fae.freeVariables.Count > 0)
{
//m(fv)[i(fv):=x(fv)] ==> v(fv) (assume v(fv)[i]==x, assume forall fv : forall j : j!=i(fv) ==> v(fv)[j] == m(fv)[j]
var fvt = TypeTuple.make(from fv in fae.freeVariables select fv.type);
string fn = getFreshMUName("mu");
var ft = new BFunctionTemplate(fn, "", new TypeVariable[0], new BasicFunctionSignature(ot, fvt),
null);
Function f = ft.getInstance();
IEnumerable <BasicBoundVariableExpression> fve = from fv in fae.freeVariables
select new BasicBoundVariableExpression(fv);
result = new BasicFAE(f, new ExpressionList(fve));
}
else
{
//m[i:=x] ==> v (assume v[i]==x, assume forall j : j!=i ==> v[j] == m[j]
string nvn = getFreshMUName("mu");
var nv = new ProgramVariable(nvn, ot, false, false, false, false);
procedure.addVariable(nv);
result = new BasicProgramVariableExpression(nv);
}
Expression[] j =
(from e in i select new BasicBoundVariableExpression(makeBoundVariable(e.type))).ToArray();
//forall j : j!=i ==> v[j]==m[j]
addConditionalMapEqualityAxiom(i, result, m, mu.typeArguments);
//v[i]==x;
Expression x = fae.arguments.Last();
addEqualityAxiom(ml(result, i, mu.typeArguments.Skip(1).ToArray(), x.type), fae.arguments.Last());
}
return(result);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private Expression cascadeConnective(Function connective, Expression[] instances, bool zeroValue)
{
if (instances.Count() == 0)
{
return(new BasicLiteralExpression(BooleanValue.makeBooleanValue(zeroValue)));
}
Expression result = null;
foreach (var i in instances)
{
if (result == null)
{
result = i;
}
else
{
result = new BasicFAE(connective, new ExpressionList(result, i));
}
}
return(result);
}
//m[m][b] := c;
//m:A b:B c:C
// type(m) = [A] ([B]C)
// ==> m [m := m[m] [b:=c]]
// ==> MU<[A]([B]C)>(m, m ,MU<[B]C>( ML<[A]([B]C)>(m,m), b, c )
//m[m] := b
// ==> m := m[m:=b]
// ==> m := MU<[A]B>(m,m,b)
/////////////////////////////////////////////////////////////////////////////////////
private Expression getAssignmentSourceExpression(MapAssignLhs target, Expression source)
{
var arguments = new List <Expression>();
arguments.Add(procedure.expressionFactory.makeExpression(target.Map.AsExpr));
foreach (var e in target.Indexes)
{
arguments.Add(procedure.expressionFactory.makeExpression(e));
}
arguments.Add(source);
var mt = arguments[0].type as MapType;
Debug.Assert(mt != null);
var argumentTypes = new IType[arguments.Count];
for (int i = 0; i < arguments.Count; i++)
{
argumentTypes[i] = arguments[i].type;
}
IType resultType = arguments[0].type;
var typeArguments = new IType[target.TypeParameters.FormalTypeParams.Count];
for (int i = 0; i < typeArguments.Length; i++)
{
typeArguments[i] = makeType(target.TypeParameters[target.TypeParameters.FormalTypeParams[i]]);
}
Expression recSource = new BasicFAE(
BasicMapWrite.makeMapWrite(typeArguments, argumentTypes, resultType), new ExpressionList(arguments)
);
return(getAssignmentSourceExpression(target.Map, recSource));
}
////////////////////////////////////////////////////////////////////////////////////////////////
private static Expression makeFlatExpression(BasicBlock bb, PropositionalFormula pathCondition, Expression e)
{
Expression result;
if (pathCondition.isTrue)
{
result = e;
}
else
{
result = new BasicFAE(
BFunctionTemplate.implication.getInstance(),
new ExpressionList(
PF2E(bb.getPreState(0).equalityAnalyzer.conditionVariableNames, pathCondition),
e
)
);
}
//TODO:handle assume false
//Debug.Assert(!(result is LiteralExpression));
return(result);
}
////////////////////////////////////////////////////////////////////////////////////////////////
private static Expression D2E(IDictionary <int, ProgramVariable> conditionVariableNames,
PropositionalFormula.Conjunction d)
{
Expression result = null;
foreach (var c in d.conjuncts)
{
if (result == null)
{
result = C2E(conditionVariableNames, c);
}
else
{
result = new BasicFAE(
BFunctionTemplate.and.getInstance(),
new ExpressionList(
result,
C2E(conditionVariableNames, c)
)
);
}
}
return(result);
}
public CFG <BasicBlock, BasicEdge> getCFGFromDAG(Implementation imp, Program program)
{
// Console.WriteLine("getCFGFromDAG");
cfg = new CFG <BasicBlock, BasicEdge>();
entry = cfg.addNode("$start");
exit = cfg.addNode("$exit");
labelIndex = 0;
// Console.WriteLine("\t\t\tDeclarations");
foreach (var tld in program.TopLevelDeclarations)
{
var a = tld as Axiom;
if (a != null)
{
// Console.WriteLine("\t\tAdding axiom {0}",a.Expr.ToString());
var assume = new Assume(procedure.expressionFactory.makeExpression(a.Expr));
entry.appendStatement(assume);
}
else
{
var bf = tld as Function;
if (bf != null && bf.Body != null)
{
var ft = scope.findFunctionTemplate(bf.Name);
var b = ft.body;
Debug.Assert(b != null);
var eqF = BFunctionTemplate.eq.getInstance(TypeTuple.make(new[] { ft.signature.resultType }));
var lhs = new BasicFAE(ft.getInstance(TypeTuple.make(from tv in ft.typeParameters select new VariableType(tv))), new ExpressionList(from bv in b.arguments select new BasicBoundVariableExpression(bv)));
var eqe = new BasicFAE(eqF, new ExpressionList(lhs, b.expression));
var axiom = procedure.expressionFactory.makeSentence(eqe);
var assume = new Assume(axiom);
entry.appendStatement(assume);
}
}
}
// Console.WriteLine("\t\t\tBlocks");
// var topoSortedBlocks
foreach (var b in topoSort(imp.Blocks, imp.Blocks[0]))
{
addBlock(b);
}
BasicBlock start = cfg.lookupOrAddNode(imp.Blocks[0].Label);
entry.setControlStatement(new UnconditionalBranch(entry, start));
exit.setControlStatement(new Programs.Statements.Block(exit));
cfg.setStartNode("$start");
cfg.setEndNode("$exit");
foreach (var bb in cfg.nodes)
{
if (!ReferenceEquals(bb, exit) && bb.successors.Count == 0)
{
bb.setControlStatement(new UnconditionalBranch(bb, exit));
}
}
foreach (var bb in cfg.nodes)
{
if (!ReferenceEquals(bb, entry) && bb.predecessors.Count == 0)
{
Console.WriteLine("Warning - removing orphan - {0}", bb.label);
bb.setControlStatement(new Programs.Statements.Block(bb));
bb.delete();
}
}
return(cfg);
}
