//////////////////////////////////////////////////////////////////////////////////////////////// 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); }