private BasicMapWrite( MapType mapType, ITypeTuple indexTypes, IType sourceType, IType resultType, ITypeTuple mapTypeArguments ) { Debug.Assert(mapType != null); Debug.Assert(mapTypeArguments != null); Debug.Assert(indexTypes != null); Debug.Assert(sourceType != null); Debug.Assert(resultType != null); Debug.Assert(indexTypes.Count() == mapType.domain.Count()); Debug.Assert(mapTypeArguments.Count() == mapType.typeParameters.Length); this.mapType = mapType; mapIndexTypes = indexTypes; this.sourceType = sourceType; this.resultType = resultType; this.mapTypeArguments = TypeTuple.make(mapTypeArguments); Debug.Assert(this.mapTypeArguments != null); this.typeArguments = TypeTuple.make(new IType[1] { mapType }.Concat(mapTypeArguments)); this.argumentTypes = TypeTuple.make(new [] { mapType }.Concat(mapIndexTypes).Concat(new[] { sourceType })); this.freeTypeVariables = new HashSet <TypeVariable>(resultType.freeTypeVariables. Union(mapType.freeTypeVariables). Union(sourceType.freeTypeVariables). Union(from it in mapIndexTypes from fv in it.freeTypeVariables select fv) ); }
//////////////////////////////////////////// //////////////////////////////////////////// public override Expression substitute(ExpressionSubstitution s) { string ss = makeSubstitutionString(s); if (substitutionCache.ContainsKey(ss)) { return(substitutionCache[ss]); } bool needSubstitution = false; foreach (var fv in freeVariables) { if (s.lookup(fv.name) != null) { needSubstitution = true; } } foreach (var ftv in freeTypeVariables) { if (s.typeSubstitution.map(ftv) != null) { needSubstitution = true; } } Expression result = this; if (needSubstitution) { ExpressionList sArgs = arguments.substitute(s); if (function.name == "==<>") { Debug.Assert(sArgs.count == 2); if (sArgs[0].type.ToStringN() == sArgs[1].type.ToStringN()) { result = new BasicFAE( BFunctionTemplate.eq.getInstance(TypeTuple.make(new[] { sArgs[0].type })), sArgs); } else if (sArgs.freeTypeVariables.Count > 0) { result = new BasicFAE( BFunctionTemplate.eqG.getInstance(TypeTuple.make(from a in sArgs select a.type)), sArgs); } else { result = new BasicLiteralExpression(BooleanValue.makeBooleanValue(false)); } //equality of different types } else { result = new BasicFAE(function.substitute(s.typeSubstitution), sArgs); } } substitutionCache[ss] = result; return(result); }
public static Function eq(IType t) { if (t is BooleanType) { return(equivalence); } return(BFunctionTemplate.eq.getInstance(TypeTuple.make(new [] { t }))); }
protected Operator(string name, string nameN, IEnumerable <IType> argumentTypes) { Debug.Assert(name != null); Debug.Assert(!name.Contains('!')); this.name = name; this.nameN = nameN; this.argumentTypes = TypeTuple.make(argumentTypes); }
public ITypeTuple makeTypes(IList <Type> boogieTypes, Context context) { var types = new IType[boogieTypes.Count]; for (int i = 0; i < boogieTypes.Count; i++) { types[i] = makeTypeI(boogieTypes[i], context); } return(TypeTuple.make(types)); }
public IFormula visit(ExistentialFormula f) { var fvs = (from fv in f.f.ffreeVariables where fv != f.var select fv).ToArray(); var fvts = TypeTuple.make(from fv in fvs select fv.type); var newF = srs.getFreshFunction("@sk", fvts, f.var.type); var fvTerms = (from fv in fvs select new Variable(fv)).ToArray <ITerm>(); return(f.f.substitute(new Substitution(f.var, new FunctionApplicationFormula(newF, fvTerms))).visit(this)); }
public BasicFunctionSignature(IType resultType, IEnumerable <IType> arguments) { Debug.Assert(resultType != null); Debug.Assert(arguments != null); foreach (var a in arguments) { Debug.Assert(a != null); } this.resultType = resultType; argumentTypes = TypeTuple.make(arguments); }
public static BasicMapRead mapRead(MapType mapType, ITypeTuple typeArguments) { Debug.Assert(mapType != null); Debug.Assert(typeArguments != null); Debug.Assert(mapType.typeParameters.Length == typeArguments.Count()); var s = new TypeParameterInstantiation(mapType.typeParameters, typeArguments); var argumentTypes = TypeTuple.make(new [] { mapType }.Concat(from a in mapType.domain select a.substitute(s))); var resultType = mapType.range.substitute(s); return(mapRead(typeArguments, argumentTypes, resultType)); }
public static Function eq(IType t1, IType t2) { //urij: special treatment for equality with type quantification Debug.Assert(!t1.isGround || !t2.isGround); if (t1.ToStringN() == t2.ToStringN()) { return(BFunctionTemplate.eq.getInstance(TypeTuple.make(new [] { t1 }))); } else { return(BFunctionTemplate.eqG.getInstance(TypeTuple.make(new[] { t1, t2 }))); } }
public BasicFunctionTemplateInstance( FunctionTemplate template, IEnumerable <IType> typeArguments ) : base( template.name, template.signature.resultType.substitute(new TypeParameterInstantiation(template.typeParameters, typeArguments)), (from at in template.signature.argumentTypes select at.substitute(new TypeParameterInstantiation(template.typeParameters, typeArguments))).ToArray() ) { this.template = template; pTypeArguments = TypeTuple.make(typeArguments); }
protected TermTupleC(IEnumerable <T> ts) : base(ts) { this.orderedFreeVariables = new List <LVar>(); foreach (var t in ts) { foreach (var fv in t.orderedFreeVariables) { if (!orderedFreeVariables.Contains(fv)) { orderedFreeVariables.Add(fv); } } } this.dataTypes = TypeTuple.make(from t in ts select t.type); }
private BoogieBitVectorConcatenationFunction(BvConcatExpr bce, int w0, int w1) : base( "++",//bce."++",//FunctionSymbol.ToString(), BitVectorType.makeBitVectorType(w0 + w1), new IType[2] { BitVectorType.makeBitVectorType(w0), BitVectorType.makeBitVectorType(w1) } ) { boogieExpression = bce; this.w0 = w0; this.w1 = w1; typeArguments = TypeTuple.make(); }
private BoogieBitVectorExtractorFunction(BvExtractExpr bee, int w, int from, int to) : base( "BV[]",//bee.FunctionSymbol.ToString(), BitVectorType.makeBitVectorType(to - from), new IType[1] { BitVectorType.makeBitVectorType(w) } ) { boogieExpression = bee; this.w = w; this.from = from; this.to = to; typeArguments = TypeTuple.make(); }
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 Literal makeDefinition(ISet <Clause> d, Clause c) { Debug.Assert(!c.isFalse); Debug.Assert(!c.isTrue); Debug.Assert(c.literals.Count > 0); if (c.literals.Count == 1) { return(c.literals.First()); } var fvs = c.freeVariables.ToArray(); var dts = TypeTuple.make(from fv in fvs select fv.type); var N = srs.getFreshPredicate(CSRS.NPPrefix, dts); // Console.WriteLine("\t\t Defining {0} as {1}", c.ToString(), N.name); { var nc = new List <Literal>(); var vs = srs.getFreshVariables(fvs); var vts = (from v in vs select new Variable(v)).ToArray(); nc.Add(new Literal(new PredicateApplication(N, vts), false)); var s = new Substitution(fvs, vts); foreach (var a in c.literals) { nc.Add(a.substitute(s)); } d.Add(new Clause(nc)); // Console.WriteLine("\t\t\t Adding {0}", nc.ToString()); } foreach (var a in c.literals) { var nc = new List <Literal>(); var vs = srs.getFreshVariables(fvs); var vts = (from v in vs select new Variable(v)).ToArray(); var s = new Substitution(fvs, vts); nc.Add(new Literal(new PredicateApplication(N, vts), true)); nc.Add(a.substitute(s).negate()); d.Add(new Clause(nc)); // Console.WriteLine("\t\t\t Adding {0}", nc.ToString()); } var ovts = (from v in fvs select new Variable(v)).ToArray(); return(new Literal(new PredicateApplication(N, ovts), true)); }
public BFunction( string name, IType resultType, IEnumerable <IType> argumentTypes ) { Debug.Assert(name != null); Debug.Assert(resultType != null); Debug.Assert(argumentTypes != null); foreach (var at in argumentTypes) { Debug.Assert(at != null); } // Debug.Assert(name != "true" && name != "True" && name != "false" && name != "False"); this.name = name; this.argumentTypes = TypeTuple.make(argumentTypes); this.resultType = resultType; }
public static BasicMapRead mapRead(IEnumerable <IType> typeArguments, IEnumerable <IType> argumentTypes, IType resultType) { Debug.Assert(typeArguments != null); Debug.Assert(argumentTypes != null); Debug.Assert(argumentTypes.Count() > 0); var mapType = argumentTypes.First() as MapType; Debug.Assert(mapType != null); Debug.Assert(typeArguments.Count() == mapType.typeParameters.Length); Debug.Assert(mapType.domain.Count() == argumentTypes.Count() - 1); var substitution = new TypeParameterInstantiation(mapType.typeParameters, typeArguments); IType sresultType = mapType.range.substitute(substitution); Debug.Assert(resultType.ToStringN() == sresultType.ToStringN()); Debug.Assert(argumentTypes.Skip(1).Zip(mapType.domain, (at, mtD) => at.isEquivalent(mtD.substitute(substitution))).All(x => x)); string indexString = makeIndexString(TypeTuple.make(typeArguments), TypeTuple.make(argumentTypes)); BasicMapRead result = null; bool foundInstance = instances.TryGetValue(indexString, out result); if (result != null) { if (!ReferenceEquals(resultType, result.resultType)) { foundInstance = false; } else if (argumentTypes.Zip(result.argumentTypes, (x, y) => x.isEquivalent(y)).Any(x => !x)) { foundInstance = false; } } if (!foundInstance) { var indexTypes = argumentTypes.Skip(1); result = new BasicMapRead(mapType, typeArguments, indexTypes, resultType); instances[indexString] = result; } return(result); }
public Expression visit(FAE e) { var ml = e.function as MapRead; if (ml != null) { Dictionary <string, ITypeTuple> entry; if (!srs.mapReads.TryGetValue(ml.mapType.ToStringN(), out entry)) { srs.mapReads[ml.mapType.ToStringN()] = entry = new Dictionary <string, ITypeTuple>(); } var dts = TypeTuple.make(ml.mapTypeArguments); entry[dts.ToString()] = dts; } foreach (var a in e.arguments) { a.visit(this); } return(e); }
private Predicate makeDefinition(SortedSet <Clause> d, IEnumerable <Clause> cs) { // N :: forall ci in cs :: [ N \/ \/_i !Nci ] /\ /\_i [!N \/ Nci] var defs = from c in cs select makeDefinition(d, c); var fvs = freeVariables(cs).ToArray(); var dts = TypeTuple.make(from fv in fvs select fv.type); var N = srs.getFreshPredicate(CSRS.NPPrefix, dts); // Console.WriteLine("\t Defining {0} as {1}", cs.ToString(), N.name); foreach (var def in defs) { var c = new List <Literal>(); var vs = srs.getFreshVariables(fvs); var vts = (from v in vs select new Variable(v)).ToArray(); c.Add(new Literal(new PredicateApplication(N, vts), false)); var s = new Substitution(fvs, vts); c.Add(def.substitute(s)); d.Add(new Clause(c)); // Console.WriteLine("\t\t Adding {0}", c.ToString()); } { var c = new List <Literal>(); var vs = srs.getFreshVariables(fvs); var vts = (from v in vs select new Variable(v)).ToArray(); var s = new Substitution(fvs, vts); c.Add(new Literal(new PredicateApplication(N, vts), true)); foreach (var def in defs) { c.Add(def.substitute(s).negate()); } d.Add(new Clause(c)); // Console.WriteLine("\t\t Adding {0}", c.ToString()); } // definitionMap[cs.ToString()] = N; return(N); }
private BasicMapRead(MapType mapType, IEnumerable <IType> mapTypeArguments, IEnumerable <IType> indexTypes, IType resultType) { Debug.Assert(mapType != null); Debug.Assert(indexTypes != null); Debug.Assert(resultType != null); Debug.Assert(mapType.domain.Count() == indexTypes.Count()); Debug.Assert(mapTypeArguments != null); Debug.Assert(mapType.typeParameters.Length == mapTypeArguments.Count()); var substitution = new TypeParameterInstantiation(mapType.typeParameters, mapTypeArguments); Debug.Assert(resultType.ToStringN() == mapType.range.substitute(substitution).ToStringN()); Debug.Assert(mapType.domain.Zip(indexTypes, (x, y) => x.substitute(substitution).isEquivalent(y)).All(x => x)); /* for (int i = 0; i < indexTypes.Count(); i++) * Debug.Assert(indexTypes[i].ToStringExpanded() == * mapType.domain[i].substitute(substitution).ToStringExpanded()); */ this.mapType = mapType; mapIndexTypes = TypeTuple.make(indexTypes); this.resultType = resultType; this.mapTypeArguments = TypeTuple.make(mapTypeArguments); }
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); }
//////////////////////////////////////////////////////////////////////////////////// private Expression makeExpression(NAryExpr fae, bool old) { if (fae.Fun is TypeCoercion) { return(makeExpression(fae.Args[0], old)); } var arguments = new ExpressionList((from Expr e in fae.Args select makeExpression(e, old)).ToArray()); Function function; if (fae.Fun is MapSelect) { var typeArguments = new IType[fae.TypeParameters.FormalTypeParams.Count]; for (int i = 0; i < fae.TypeParameters.FormalTypeParams.Count; i++) { typeArguments[i] = makeType(fae.TypeParameters[fae.TypeParameters.FormalTypeParams[i]]); } var argumentTypes = TypeTuple.make(from a in arguments select a.type); function = BasicMapRead.mapRead( typeArguments, argumentTypes, makeType(fae.Type) ); } else if (fae.Fun is MapStore) { var typeArguments = new IType[fae.TypeParameters.FormalTypeParams.Count]; for (int i = 0; i < fae.TypeParameters.FormalTypeParams.Count; i++) { typeArguments[i] = makeType(fae.TypeParameters[fae.TypeParameters.FormalTypeParams[i]]); } function = BasicMapWrite.makeMapWrite(typeArguments, (from a in arguments select a.type).ToArray(), makeType(fae.ShallowType)); } else if (fae.Fun.FunctionName == "==" || fae.Fun.FunctionName == "!=") { if (arguments[0].type.isEquivalent(arguments[1].type)) { function = BFunction.eq(arguments[0].type); } else { Debug.Assert(!arguments[0].type.isGround || !arguments[1].type.isGround); function = BFunction.eq(arguments[0].type, arguments[1].type); } if (fae.Fun.FunctionName == "!=") { arguments = new ExpressionList( new BasicFAE( function, arguments ) ); function = scope.getFunction("!", TypeTuple.make()); } } else if (fae.Fun.FunctionName == "<:") { function = scope.getFunction(fae.Fun.FunctionName, TypeTuple.make(new[] { arguments[0].type })); } else if (fae.Fun.FunctionName == BFunctionTemplate.iteName) { function = scope.getFunction(fae.Fun.FunctionName, TypeTuple.make(new[] { arguments[1].type })); } else if (fae.Fun.FunctionName == @"-" && fae.Fun.ArgumentCount == 1) { arguments = new ExpressionList(new[] { new BasicLiteralExpression(IntegerValue.make(0)), arguments[0] }); function = scope.getFunction(@"-", TypeTuple.make()); } else { var typeArguments = TypeTuple.make((fae.TypeParameters == null) ? new IType[0] : (from ftp in fae.TypeParameters.FormalTypeParams select scope.typeFactory.makeTypeI(fae.TypeParameters[ftp], context))); function = scope.getFunction(fae.Fun.FunctionName, typeArguments); } var result = new BoogieFunctionApplicationExpression(fae, function, arguments); Debug.Assert(result.type.ToStringN() == makeType(fae.Type == null ? fae.ShallowType : fae.Type).ToStringN()); Debug.Assert(result != null); foreach (var fv in result.freeVariables) { Debug.Assert(context.lookupVariableByOwnName(fv.name) == fv); } foreach (var ftv in result.freeTypeVariables) { Debug.Assert(ReferenceEquals(context.lookupTypeVariable(ftv.name), ftv)); } return(result); }
private LTPredicate() : base(StateSpace.Functions.Basic.BFunctionTemplate.lt.name, TypeTuple.make(new[] { IntegerType.integerType, IntegerType.integerType })) { }
public Function getInstance() { return(getInstance(TypeTuple.make())); }
public static MapRead mu2ml(MapWrite mu) { var mlArgTypes = TypeTuple.make(mu.argumentTypes.Take(mu.argumentTypes.Count() - 1)); return(BasicMapRead.mapRead(mu.typeArguments.Skip(1).ToArray(), mlArgTypes, mu.argumentTypes.Last())); }
public MapRead mapRead(IEnumerable <IType> mapTypeArgs) { Debug.Assert(mapTypeArgs.Count() == mapType.typeParameters.Length); return(BasicMapRead.mapRead(mapType, TypeTuple.make(mapTypeArgs))); }
private FalsePredicate() : base("false", TypeTuple.make()) { }
private TruePredicate() : base("true", TypeTuple.make()) { }
public static BasicMapWrite makeMapWrite( IEnumerable <IType> mapTypeArgumentsA, IEnumerable <IType> argumentTypesA, IType resultType) { var mapTypeArguments = TypeTuple.make(mapTypeArgumentsA); var argumentTypes = TypeTuple.make(argumentTypesA); Debug.Assert(mapTypeArguments != null); Debug.Assert(argumentTypes != null); Debug.Assert(argumentTypes.Count() > 1); var mapType = argumentTypes[0] as MapType; var sourceType = argumentTypes.Last(); Debug.Assert(mapType != null); Debug.Assert(mapType.domain.Count() == argumentTypes.Count() - 2); Debug.Assert(mapType.typeParameters.Count() == mapTypeArguments.Count()); var indexString = ""; foreach (var a in argumentTypes) { indexString += (indexString == "" ? "" : ",") + a.ToString(); } var indexTypes = TypeTuple.make(argumentTypes.Skip(1).Take(argumentTypes.Count() - 2)); BasicMapWrite result = null; bool foundInstance = instances.TryGetValue(indexString, out result); if (result != null) { if (!ReferenceEquals(resultType, result.resultType)) { foundInstance = false; } else { for (int i = 0; i < argumentTypes.Count(); i++) { if (!ReferenceEquals(argumentTypes[i], result.argumentTypes[i])) { foundInstance = false; break; } } } } if (!foundInstance) { result = new BasicMapWrite(mapType, indexTypes, sourceType, resultType, mapTypeArguments); Debug.Assert(indexString != null); Debug.Assert(instances != null); Debug.Assert(result != null); // instances.Add(indexString,result); instances[indexString] = result; } return(result); }