private Dictionary <string, Expr> ComputeAvailableExprs(IEnumerable <Variable> availableLinearVars)
{
Dictionary <string, Expr> domainNameToExpr = new Dictionary <string, Expr>();
foreach (var domainName in linearTypeChecker.linearDomains.Keys)
{
var domain = linearTypeChecker.linearDomains[domainName];
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new Expr[] { Expr.False });
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
foreach (Variable v in availableLinearVars)
{
var domainName = linearTypeChecker.FindDomainName(v);
var domain = linearTypeChecker.linearDomains[domainName];
Expr ie = new NAryExpr(Token.NoToken, new FunctionCall(domain.collectors[v.TypedIdent.Type]),
new List <Expr> {
Expr.Ident(v)
});
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapOrBool),
new List <Expr> {
ie, domainNameToExpr[domainName]
});
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
return(domainNameToExpr);
}
public void FunctionCall()
{
var fc = CreateFunctionCall("bv8slt", Microsoft.Boogie.Type.Bool, new List <Microsoft.Boogie.Type>()
{
BasicType.GetBvType(8),
BasicType.GetBvType(8)
});
var constantBv = new LiteralExpr(Token.NoToken, BigNum.FromInt(0), 8);
var nary = new NAryExpr(Token.NoToken, fc, new List <Expr>()
{
constantBv, constantBv
});
// Get shallow type (this was broken when this test was written)
Assert.AreEqual(BasicType.Bool, nary.ShallowType);
// Deep type check (this was not broken before writing this test)
Assert.IsNull(nary.Type);
var tc = new TypecheckingContext(this);
nary.Typecheck(tc);
Assert.AreEqual(BasicType.Bool, nary.Type);
}
public static NAryExpr FunctionCall(Function f, params Expr[] args)
{
var expr = new NAryExpr(Token.NoToken, new FunctionCall(f), args);
var rc = new ResolutionContext(null);
rc.StateMode = ResolutionContext.State.Two;
expr.Resolve(rc);
expr.Typecheck(new TypecheckingContext(null));
return(expr);
}
public IEnumerable<Expr> PermissionExprForEachVariable(string domainName, IEnumerable<Variable> scope)
{
var domain = linearDomains[domainName];
foreach (Variable v in scope)
{
Expr expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.collectors[v.TypedIdent.Type]),
new List<Expr> {Expr.Ident(v)});
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
yield return expr;
}
}
public Expr UnionExprForPermissions(string domainName, IEnumerable<Expr> permissionExprs)
{
var domain = linearDomains[domainName];
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new Expr[] {Expr.False});
foreach (Expr e in permissionExprs)
{
expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapOr), new List<Expr> {e, expr});
}
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
return expr;
}
public void FunctionCall()
{
var fc = CreateFunctionCall("bv8slt", Microsoft.Boogie.Type.Bool, new List<Microsoft.Boogie.Type>() {
BasicType.GetBvType(8),
BasicType.GetBvType(8)
});
var constantBv = new LiteralExpr(Token.NoToken, BigNum.FromInt(0) , 8);
var nary = new NAryExpr(Token.NoToken,fc, new List<Expr>() { constantBv, constantBv} );
// Get shallow type (this was broken when this test was written)
Assert.AreEqual(BasicType.Bool, nary.ShallowType);
// Deep type check (this was not broken before writing this test)
Assert.IsNull(nary.Type);
var tc = new TypecheckingContext(this);
nary.Typecheck(tc);
Assert.AreEqual(BasicType.Bool, nary.Type);
}
private Dictionary<string, Expr> ComputeAvailableExprs(IEnumerable<Variable> availableLinearVars, Dictionary<string, Variable> domainNameToInputVar)
{
Dictionary<string, Expr> domainNameToExpr = new Dictionary<string, Expr>();
foreach (var domainName in linearTypeChecker.linearDomains.Keys)
{
var expr = Expr.Ident(domainNameToInputVar[domainName]);
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
foreach (Variable v in availableLinearVars)
{
var domainName = linearTypeChecker.FindDomainName(v);
if (!linearTypeChecker.linearDomains.ContainsKey(domainName)) continue;
var domain = linearTypeChecker.linearDomains[domainName];
if (!domain.collectors.ContainsKey(v.TypedIdent.Type)) continue;
Expr ie = new NAryExpr(Token.NoToken, new FunctionCall(domain.collectors[v.TypedIdent.Type]), new List<Expr> { Expr.Ident(v) });
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapOrBool), new List<Expr> { ie, domainNameToExpr[domainName] });
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
return domainNameToExpr;
}
public void Transform()
{
foreach (var impl in program.Implementations)
{
Dictionary<string, Variable> domainNameToInputVar = new Dictionary<string, Variable>();
foreach (string domainName in linearDomains.Keys)
{
var domain = linearDomains[domainName];
Formal f = new Formal(
Token.NoToken,
new TypedIdent(Token.NoToken,
"linear_" + domainName + "_in",
new MapType(Token.NoToken, new List<TypeVariable>(),
new List<Type> { domain.elementType }, Type.Bool)), true);
impl.InParams.Add(f);
domainNameToInputVar[domainName] = f;
}
foreach (Block b in impl.Blocks)
{
List<Cmd> newCmds = new List<Cmd>();
for (int i = 0; i < b.Cmds.Count; i++)
{
Cmd cmd = b.Cmds[i];
newCmds.Add(cmd);
if (cmd is CallCmd)
{
CallCmd callCmd = cmd as CallCmd;
if (callCmd.IsAsync)
{
foreach (var domainName in linearDomains.Keys)
{
var domain = linearDomains[domainName];
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List<Expr> { Expr.False });
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
callCmd.Ins.Add(expr);
}
}
else
{
Dictionary<string, Expr> domainNameToExpr = new Dictionary<string, Expr>();
foreach (var domainName in linearDomains.Keys)
{
domainNameToExpr[domainName] = Expr.Ident(domainNameToInputVar[domainName]);
}
foreach (Variable v in AvailableLinearVars(callCmd))
{
var domainName = FindDomainName(v);
var domain = linearDomains[domainName];
if (!domain.collectors.ContainsKey(v.TypedIdent.Type)) continue;
Expr ie = new NAryExpr(Token.NoToken, new FunctionCall(domain.collectors[v.TypedIdent.Type]), new List<Expr> { Expr.Ident(v) });
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapOrBool), new List<Expr> { ie, domainNameToExpr[domainName] });
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
foreach (var domainName in linearDomains.Keys)
{
callCmd.Ins.Add(domainNameToExpr[domainName]);
}
}
}
else if (cmd is ParCallCmd)
{
ParCallCmd parCallCmd = (ParCallCmd)cmd;
foreach (CallCmd callCmd in parCallCmd.CallCmds)
{
foreach (var domainName in linearDomains.Keys)
{
var domain = linearDomains[domainName];
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List<Expr> { Expr.False });
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
callCmd.Ins.Add(expr);
}
}
}
else if (cmd is YieldCmd)
{
AddDisjointnessExpr(newCmds, cmd, domainNameToInputVar);
}
}
b.Cmds = newCmds;
}
{
// Loops
impl.PruneUnreachableBlocks();
impl.ComputePredecessorsForBlocks();
GraphUtil.Graph<Block> g = Program.GraphFromImpl(impl);
g.ComputeLoops();
if (g.Reducible)
{
foreach (Block header in g.Headers)
{
List<Cmd> newCmds = new List<Cmd>();
AddDisjointnessExpr(newCmds, header, domainNameToInputVar);
newCmds.AddRange(header.Cmds);
header.Cmds = newCmds;
}
}
}
}
foreach (var proc in program.Procedures)
{
Dictionary<string, HashSet<Variable>> domainNameToInputScope = new Dictionary<string, HashSet<Variable>>();
Dictionary<string, HashSet<Variable>> domainNameToOutputScope = new Dictionary<string, HashSet<Variable>>();
foreach (var domainName in linearDomains.Keys)
{
domainNameToInputScope[domainName] = new HashSet<Variable>();
domainNameToOutputScope[domainName] = new HashSet<Variable>();
}
foreach (Variable v in globalVarToDomainName.Keys)
{
var domainName = globalVarToDomainName[v];
domainNameToInputScope[domainName].Add(v);
domainNameToOutputScope[domainName].Add(v);
}
foreach (Variable v in proc.InParams)
{
var domainName = FindDomainName(v);
if (domainName == null) continue;
if (!this.linearDomains.ContainsKey(domainName)) continue;
domainNameToInputScope[domainName].Add(v);
}
foreach (Variable v in proc.OutParams)
{
var domainName = FindDomainName(v);
if (domainName == null) continue;
if (!this.linearDomains.ContainsKey(domainName)) continue;
domainNameToOutputScope[domainName].Add(v);
}
foreach (var domainName in linearDomains.Keys)
{
proc.Requires.Add(new Requires(true, DisjointnessExpr(domainName, domainNameToInputScope[domainName])));
var domain = linearDomains[domainName];
Formal f = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "linear_" + domainName + "_in", new MapType(Token.NoToken, new List<TypeVariable>(), new List<Type> { domain.elementType }, Type.Bool)), true);
proc.InParams.Add(f);
proc.Ensures.Add(new Ensures(true, DisjointnessExpr(domainName, f, domainNameToOutputScope[domainName])));
}
}
foreach (LinearDomain domain in linearDomains.Values)
{
program.AddTopLevelDeclaration(domain.mapConstBool);
program.AddTopLevelDeclaration(domain.mapConstInt);
program.AddTopLevelDeclaration(domain.mapEqInt);
program.AddTopLevelDeclaration(domain.mapImpBool);
program.AddTopLevelDeclaration(domain.mapOrBool);
foreach (Axiom axiom in domain.axioms)
{
program.AddTopLevelDeclaration(axiom);
}
}
//int oldPrintUnstructured = CommandLineOptions.Clo.PrintUnstructured;
//CommandLineOptions.Clo.PrintUnstructured = 1;
//PrintBplFile("lsd.bpl", program, false, false);
//CommandLineOptions.Clo.PrintUnstructured = oldPrintUnstructured;
}
public void Transform()
{
foreach (var decl in program.TopLevelDeclarations)
{
Implementation impl = decl as Implementation;
if (impl == null)
{
continue;
}
Dictionary <string, Variable> domainNameToInputVar = new Dictionary <string, Variable>();
foreach (string domainName in linearDomains.Keys)
{
var domain = linearDomains[domainName];
Formal f = new Formal(
Token.NoToken,
new TypedIdent(Token.NoToken,
"linear_" + domainName + "_in",
new MapType(Token.NoToken, new List <TypeVariable>(),
new List <Type> {
domain.elementType
}, Type.Bool)), true);
impl.InParams.Add(f);
domainNameToInputVar[domainName] = f;
}
foreach (Block b in impl.Blocks)
{
List <Cmd> newCmds = new List <Cmd>();
for (int i = 0; i < b.Cmds.Count; i++)
{
Cmd cmd = b.Cmds[i];
newCmds.Add(cmd);
if (cmd is CallCmd)
{
CallCmd callCmd = cmd as CallCmd;
if (callCmd.IsAsync)
{
foreach (var domainName in linearDomains.Keys)
{
var domain = linearDomains[domainName];
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List <Expr> {
Expr.False
});
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
callCmd.Ins.Add(expr);
}
}
else
{
Dictionary <string, Expr> domainNameToExpr = new Dictionary <string, Expr>();
foreach (var domainName in linearDomains.Keys)
{
domainNameToExpr[domainName] = new IdentifierExpr(Token.NoToken, domainNameToInputVar[domainName]);
}
foreach (Variable v in availableLinearVars[callCmd])
{
var domainName = FindDomainName(v);
var domain = linearDomains[domainName];
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, v);
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapOrBool),
new List <Expr> {
v.TypedIdent.Type is MapType ? ie : Singleton(ie, domainName), domainNameToExpr[domainName]
});
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
foreach (var domainName in linearDomains.Keys)
{
callCmd.Ins.Add(domainNameToExpr[domainName]);
}
}
}
else if (cmd is ParCallCmd)
{
ParCallCmd parCallCmd = (ParCallCmd)cmd;
foreach (CallCmd callCmd in parCallCmd.CallCmds)
{
foreach (var domainName in linearDomains.Keys)
{
var domain = linearDomains[domainName];
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapConstBool), new List <Expr> {
Expr.False
});
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
callCmd.Ins.Add(expr);
}
}
}
else if (cmd is YieldCmd)
{
AddDisjointnessExpr(newCmds, cmd, domainNameToInputVar);
}
}
b.Cmds = newCmds;
}
{
// Loops
impl.PruneUnreachableBlocks();
impl.ComputePredecessorsForBlocks();
GraphUtil.Graph <Block> g = Program.GraphFromImpl(impl);
g.ComputeLoops();
if (g.Reducible)
{
foreach (Block header in g.Headers)
{
List <Cmd> newCmds = new List <Cmd>();
AddDisjointnessExpr(newCmds, header, domainNameToInputVar);
newCmds.AddRange(header.Cmds);
header.Cmds = newCmds;
}
}
}
}
foreach (var decl in program.TopLevelDeclarations)
{
Procedure proc = decl as Procedure;
if (proc == null)
{
continue;
}
Dictionary <string, HashSet <Variable> > domainNameToInputScope = new Dictionary <string, HashSet <Variable> >();
Dictionary <string, HashSet <Variable> > domainNameToOutputScope = new Dictionary <string, HashSet <Variable> >();
foreach (var domainName in linearDomains.Keys)
{
domainNameToInputScope[domainName] = new HashSet <Variable>();
domainNameToOutputScope[domainName] = new HashSet <Variable>();
}
foreach (Variable v in globalVarToDomainName.Keys)
{
var domainName = globalVarToDomainName[v];
domainNameToInputScope[domainName].Add(v);
domainNameToOutputScope[domainName].Add(v);
}
foreach (Variable v in proc.InParams)
{
var domainName = FindDomainName(v);
if (domainName == null)
{
continue;
}
domainNameToInputScope[domainName].Add(v);
}
foreach (Variable v in proc.OutParams)
{
var domainName = FindDomainName(v);
if (domainName == null)
{
continue;
}
domainNameToOutputScope[domainName].Add(v);
}
foreach (var domainName in linearDomains.Keys)
{
proc.Requires.Add(new Requires(true, DisjointnessExpr(domainName, domainNameToInputScope[domainName])));
var domain = linearDomains[domainName];
Formal f = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "linear_" + domainName + "_in", new MapType(Token.NoToken, new List <TypeVariable>(), new List <Type> {
domain.elementType
}, Type.Bool)), true);
proc.InParams.Add(f);
domainNameToOutputScope[domainName].Add(f);
proc.Ensures.Add(new Ensures(true, DisjointnessExpr(domainName, domainNameToOutputScope[domainName])));
}
}
foreach (LinearDomain domain in linearDomains.Values)
{
program.TopLevelDeclarations.Add(domain.mapConstBool);
program.TopLevelDeclarations.Add(domain.mapConstInt);
program.TopLevelDeclarations.Add(domain.mapEqInt);
program.TopLevelDeclarations.Add(domain.mapImpBool);
program.TopLevelDeclarations.Add(domain.mapOrBool);
foreach (Axiom axiom in domain.axioms)
{
program.TopLevelDeclarations.Add(axiom);
}
}
//int oldPrintUnstructured = CommandLineOptions.Clo.PrintUnstructured;
//CommandLineOptions.Clo.PrintUnstructured = 1;
//PrintBplFile("lsd.bpl", program, false, false);
//CommandLineOptions.Clo.PrintUnstructured = oldPrintUnstructured;
}
private Dictionary<string, Expr> ComputeAvailableExprs(HashSet<Variable> availableLinearVars, Dictionary<string, Variable> domainNameToInputVar)
{
Dictionary<string, Expr> domainNameToExpr = new Dictionary<string, Expr>();
foreach (var domainName in linearTypeChecker.linearDomains.Keys)
{
var expr = new IdentifierExpr(Token.NoToken, domainNameToInputVar[domainName]);
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
foreach (Variable v in availableLinearVars)
{
var domainName = linearTypeChecker.FindDomainName(v);
var domain = linearTypeChecker.linearDomains[domainName];
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, v);
var expr = new NAryExpr(Token.NoToken, new FunctionCall(domain.mapOrBool), new List<Expr> { v.TypedIdent.Type is MapType ? ie : linearTypeChecker.Singleton(ie, domainName), domainNameToExpr[domainName] });
expr.Resolve(new ResolutionContext(null));
expr.Typecheck(new TypecheckingContext(null));
domainNameToExpr[domainName] = expr;
}
return domainNameToExpr;
}
