public Bpl.Function CreateTypeFunction(ITypeReference type, int parameterCount)
{
System.Diagnostics.Debug.Assert(parameterCount >= 0);
string typename = TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId);
typename = TranslationHelper.TurnStringIntoValidIdentifier(typename);
Bpl.IToken tok = type.Token();
List <Bpl.Variable> inputs = new List <Bpl.Variable>();
//for (int i = 0; i < parameterCount; i++) {
// inputs.Add(new Bpl.Formal(tok, new Bpl.TypedIdent(tok, "arg"+i, this.TypeType), true));
//}
foreach (var t in TranslationHelper.ConsolidatedGenericParameters(type))
{
var n = t.Name.Value;
var n2 = TranslationHelper.TurnStringIntoValidIdentifier(n);
inputs.Add(new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, n2, this.TypeType), true));
}
Bpl.Variable output = new Bpl.Formal(tok, new Bpl.TypedIdent(tok, "result", this.TypeType), false);
Bpl.Function func = new Bpl.Function(tok, typename, inputs, output);
var attrib = new Bpl.QKeyValue(Bpl.Token.NoToken, "constructor", new List <object>(1), null);
func.Attributes = attrib;
return(func);
}
public static void Predicate(Program p,
Func<Procedure, bool> useProcedurePredicates = null,
UniformityAnalyser uni = null)
{
useProcedurePredicates = useProcedurePredicates ?? (proc => false);
if (uni != null) {
var oldUPP = useProcedurePredicates;
useProcedurePredicates = proc => oldUPP(proc) && !uni.IsUniform(proc.Name);
}
foreach (var decl in p.TopLevelDeclarations.ToList()) {
if (decl is Procedure || decl is Implementation) {
var proc = decl as Procedure;
Implementation impl = null;
if (proc == null) {
impl = (Implementation)decl;
proc = impl.Proc;
}
bool upp = useProcedurePredicates(proc);
if (upp) {
var dwf = (DeclWithFormals)decl;
var fpVar = new Formal(Token.NoToken,
new TypedIdent(Token.NoToken, "_P",
Microsoft.Boogie.Type.Bool),
/*incoming=*/true);
dwf.InParams = new List<Variable>(
(new Variable[] {fpVar}.Concat(dwf.InParams.Cast<Variable>()))
.ToArray());
if (impl == null) {
var fpIdentifierExpr = new IdentifierExpr(Token.NoToken, fpVar);
foreach (Requires r in proc.Requires) {
new EnabledReplacementVisitor(fpIdentifierExpr).VisitExpr(r.Condition);
if (!QKeyValue.FindBoolAttribute(r.Attributes, "do_not_predicate")) {
r.Condition = Expr.Imp(fpIdentifierExpr, r.Condition);
}
}
foreach (Ensures e in proc.Ensures) {
new EnabledReplacementVisitor(new IdentifierExpr(Token.NoToken, fpVar)).VisitExpr(e.Condition);
if (!QKeyValue.FindBoolAttribute(e.Attributes, "do_not_predicate")) {
e.Condition = Expr.Imp(fpIdentifierExpr, e.Condition);
}
}
}
}
if (impl != null) {
try {
new SmartBlockPredicator(p, impl, useProcedurePredicates, uni).PredicateImplementation();
} catch (Program.IrreducibleLoopException) { }
}
}
}
}
static Bpl.Formal BplFormalVar(string /*?*/ name, Bpl.Type ty, bool incoming, out Bpl.Expr e)
{
Bpl.Formal res;
if (name == null)
{
name = Bpl.TypedIdent.NoName;
}
res = new Bpl.Formal(ty.tok, new Bpl.TypedIdent(ty.tok, name, ty), incoming);
e = new Bpl.IdentifierExpr(ty.tok, res);
return(res);
}
public FunctionCall CreateFunctionCall(string Name, Microsoft.Boogie.Type returnType, IList<Microsoft.Boogie.Type> argTypes)
{
var returnVar = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "", returnType), false);
var vars = new List<Variable>();
foreach (var T in argTypes)
{
vars.Add( new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "",T), true));
}
// Finally build the function and the function call
var funcCall = new FunctionCall(new Function(Token.NoToken, Name, vars, returnVar));
return funcCall;
}
public MethodParameter(IParameterDefinition parameterDefinition, Bpl.Type ptype) {
this.underlyingParameter = parameterDefinition;
var parameterToken = parameterDefinition.Token();
var typeToken = parameterDefinition.Type.Token();
var parameterName = TranslationHelper.TurnStringIntoValidIdentifier(parameterDefinition.Name.Value);
if (String.IsNullOrWhiteSpace(parameterName)) parameterName = "P" + parameterDefinition.Index.ToString();
this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
if (parameterDefinition.IsByReference) {
this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
} else {
this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
}
}
private static void CreateDelegateRemoveMethod(Sink sink, ITypeDefinition type, HashSet <IMethodDefinition> delegates)
{
Bpl.Formal a = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "a", sink.Heap.RefType), true);
Bpl.Formal b = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "b", sink.Heap.RefType), true);
Bpl.Formal c = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "c", sink.Heap.RefType), false);
Bpl.IdentifierExpr aExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, a);
Bpl.IdentifierExpr bExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, b);
Bpl.IdentifierExpr cExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, c);
Bpl.Procedure proc = new Bpl.Procedure(
Bpl.Token.NoToken,
sink.DelegateRemove(type),
new List <Bpl.TypeVariable>(),
new List <Bpl.Variable>(new Bpl.Variable[] { a, b }),
new List <Bpl.Variable>(new Bpl.Variable[] { c }),
new List <Bpl.Requires>(),
new List <Bpl.IdentifierExpr>(),
new List <Bpl.Ensures>());
proc.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(proc);
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
stmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, "Alloc", new List <Bpl.Expr>(), new List <Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] { cExpr })));
foreach (IMethodDefinition defn in delegates)
{
Bpl.IdentifierExpr cie = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateDelegateMethodConstant(defn));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Iff, sink.ReadMethod(cie, cExpr), Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.And, sink.ReadMethod(cie, aExpr), Bpl.Expr.Unary(Bpl.Token.NoToken, Bpl.UnaryOperator.Opcode.Not, sink.ReadMethod(cie, bExpr))))));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadReceiver(cie, cExpr), sink.ReadReceiver(cie, aExpr))));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadTypeParameters(cie, cExpr), sink.ReadTypeParameters(cie, aExpr))));
}
Bpl.IdentifierExpr nullExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.Heap.NullRef);
Bpl.IfCmd ifCmd = BuildIfCmd(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, bExpr, nullExpr), TranslationHelper.BuildAssignCmd(cExpr, aExpr), stmtBuilder.Collect(Bpl.Token.NoToken));
ifCmd = BuildIfCmd(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, aExpr, nullExpr), TranslationHelper.BuildAssignCmd(cExpr, nullExpr), ifCmd);
Bpl.Implementation impl = new Bpl.Implementation(
Bpl.Token.NoToken,
sink.DelegateRemove(type),
new List <Bpl.TypeVariable>(),
new List <Bpl.Variable>(new Bpl.Variable[] { a, b }),
new List <Bpl.Variable>(new Bpl.Variable[] { c }),
new List <Bpl.Variable>(),
BuildStmtList(ifCmd)
);
impl.AddAttribute("inline", Bpl.Expr.Literal(1));
impl.Proc = proc;
sink.TranslatedProgram.AddTopLevelDeclaration(impl);
}
private static void CreateDelegateCreateMethod(Sink sink, ITypeDefinition type, HashSet <IMethodDefinition> delegates)
{
Bpl.Formal method = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "Method", Bpl.Type.Int), true);
Bpl.Formal receiver = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "Receiver", sink.Heap.RefType), true);
Bpl.Formal typeParameters = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "TypeParameters", sink.Heap.TypeType), true);
Bpl.Formal returnDelegate = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "c", sink.Heap.RefType), false);
Bpl.IdentifierExpr methodExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, method);
Bpl.IdentifierExpr receiverExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, receiver);
Bpl.IdentifierExpr typeParametersExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, typeParameters);
Bpl.IdentifierExpr returnDelegateExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, returnDelegate);
Bpl.Procedure proc = new Bpl.Procedure(
Bpl.Token.NoToken,
sink.DelegateCreate(type),
new List <Bpl.TypeVariable>(),
new List <Bpl.Variable>(new Bpl.Variable[] { method, receiver, typeParameters }),
new List <Bpl.Variable>(new Bpl.Variable[] { returnDelegate }),
new List <Bpl.Requires>(),
new List <Bpl.IdentifierExpr>(),
new List <Bpl.Ensures>());
proc.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(proc);
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
stmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, "Alloc", new List <Bpl.Expr>(), new List <Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] { returnDelegateExpr })));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadReceiver(methodExpr, returnDelegateExpr), receiverExpr)));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadTypeParameters(methodExpr, returnDelegateExpr), typeParametersExpr)));
foreach (IMethodDefinition defn in delegates)
{
Bpl.IdentifierExpr cie = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateDelegateMethodConstant(defn));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Iff, sink.ReadMethod(cie, returnDelegateExpr), Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, methodExpr, cie))));
}
Bpl.Implementation impl = new Bpl.Implementation(
Bpl.Token.NoToken,
sink.DelegateCreate(type),
new List <Bpl.TypeVariable>(),
new List <Bpl.Variable>(new Bpl.Variable[] { method, receiver, typeParameters }),
new List <Bpl.Variable>(new Bpl.Variable[] { returnDelegate }),
new List <Bpl.Variable>(),
stmtBuilder.Collect(Bpl.Token.NoToken));
impl.AddAttribute("inline", Bpl.Expr.Literal(1));
impl.Proc = proc;
sink.TranslatedProgram.AddTopLevelDeclaration(impl);
}
public static void Predicate(Program p,
bool createCandidateInvariants = true,
bool useProcedurePredicates = true)
{
foreach (var decl in p.TopLevelDeclarations.ToList()) {
if (useProcedurePredicates && decl is DeclWithFormals && !(decl is Function)) {
var dwf = (DeclWithFormals)decl;
var fpVar = new Formal(Token.NoToken,
new TypedIdent(Token.NoToken, "_P",
Microsoft.Boogie.Type.Bool),
/*incoming=*/true);
dwf.InParams = new List<Variable>(
(new Variable[] {fpVar}.Concat(dwf.InParams.Cast<Variable>()))
.ToArray());
if (dwf is Procedure)
{
var proc = (Procedure)dwf;
var newRequires = new List<Requires>();
foreach (Requires r in proc.Requires)
{
newRequires.Add(new Requires(r.Free,
new EnabledReplacementVisitor(new IdentifierExpr(Token.NoToken, fpVar)).VisitExpr(r.Condition)));
}
var newEnsures = new List<Ensures>();
foreach (Ensures e in proc.Ensures)
{
newEnsures.Add(new Ensures(e.Free,
new EnabledReplacementVisitor(new IdentifierExpr(Token.NoToken, fpVar)).VisitExpr(e.Condition)));
}
}
}
try {
var impl = decl as Implementation;
if (impl != null)
new BlockPredicator(p, impl, createCandidateInvariants, useProcedurePredicates).PredicateImplementation();
}
catch (Program.IrreducibleLoopException) { }
}
}
public MethodParameter(IParameterDefinition parameterDefinition) {
this.underlyingParameter = parameterDefinition;
Bpl.Type ptype = Bpl.Type.Int;
var parameterToken = parameterDefinition.Token();
var typeToken = parameterDefinition.Type.Token();
var parameterName = parameterDefinition.Name.Value;
if (!parameterDefinition.IsOut) {
this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
}
if (parameterDefinition.IsByReference || parameterDefinition.IsOut) {
this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
} else {
this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
}
}
public MethodParameter(IParameterDefinition parameterDefinition, Bpl.Type ptype)
{
this.underlyingParameter = parameterDefinition;
var parameterToken = parameterDefinition.Token();
var typeToken = parameterDefinition.Type.Token();
var parameterName = TranslationHelper.TurnStringIntoValidIdentifier(parameterDefinition.Name.Value);
if (String.IsNullOrWhiteSpace(parameterName))
{
parameterName = "P" + parameterDefinition.Index.ToString();
}
this.inParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$in", ptype), true);
if (parameterDefinition.IsByReference)
{
this.outParameterCopy = new Bpl.Formal(parameterToken, new Bpl.TypedIdent(typeToken, parameterName + "$out", ptype), false);
}
else
{
this.outParameterCopy = new Bpl.LocalVariable(parameterToken, new Bpl.TypedIdent(typeToken, parameterName, ptype));
}
}
public virtual Formal VisitFormal(Formal node) {
Contract.Requires(node != null);
Contract.Ensures(Contract.Result<Formal>() != null);
return node;
}
public Function TriggerFunction(Variable v)
{
if (!triggerFuns.ContainsKey(v))
{
List<Variable> args = new List<Variable>();
args.Add(new Formal(v.tok, new TypedIdent(v.tok, "v", v.TypedIdent.Type), true));
Variable result = new Formal(v.tok, new TypedIdent(v.tok, "r", Type.Bool), false);
triggerFuns[v] = new Function(v.tok, string.Format("Trigger_{0}_{1}", proc.Name, v.Name), args, result);
}
return triggerFuns[v];
}
public AtomicActionInfo(Procedure proc, Ensures ensures, MoverType moverType, int layerNum, int availableUptoLayerNum)
: base(proc, layerNum, availableUptoLayerNum)
{
this.ensures = ensures;
this.moverType = moverType;
this.gate = new List<AssertCmd>();
this.action = ensures.Condition as CodeExpr;
this.thisGate = new List<AssertCmd>();
this.thisInParams = new List<Variable>();
this.thisOutParams = new List<Variable>();
this.thatGate = new List<AssertCmd>();
this.thatInParams = new List<Variable>();
this.thatOutParams = new List<Variable>();
this.hasAssumeCmd = false;
this.thisMap = new Dictionary<Variable, Expr>();
this.thatMap = new Dictionary<Variable, Expr>();
this.triggerFuns = new Dictionary<Variable, Function>();
foreach (Block block in this.action.Blocks)
{
block.Cmds.ForEach(x => this.hasAssumeCmd = this.hasAssumeCmd || x is AssumeCmd);
}
foreach (Block block in this.action.Blocks)
{
if (block.TransferCmd is ReturnExprCmd)
{
block.TransferCmd = new ReturnCmd(block.TransferCmd.tok);
}
}
var cmds = this.action.Blocks[0].Cmds;
for (int i = 0; i < cmds.Count; i++)
{
AssertCmd assertCmd = cmds[i] as AssertCmd;
if (assertCmd == null) break;
this.gate.Add(assertCmd);
cmds[i] = new AssumeCmd(assertCmd.tok, Expr.True);
}
foreach (Variable x in proc.InParams)
{
Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), true, x.Attributes);
this.thisInParams.Add(thisx);
this.thisMap[x] = Expr.Ident(thisx);
Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), true, x.Attributes);
this.thatInParams.Add(thatx);
this.thatMap[x] = Expr.Ident(thatx);
}
foreach (Variable x in proc.OutParams)
{
Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), false, x.Attributes);
this.thisOutParams.Add(thisx);
this.thisMap[x] = Expr.Ident(thisx);
Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false, x.Attributes);
this.thatOutParams.Add(thatx);
this.thatMap[x] = Expr.Ident(thatx);
}
List<Variable> thisLocVars = new List<Variable>();
List<Variable> thatLocVars = new List<Variable>();
foreach (Variable x in this.action.LocVars)
{
Variable thisx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "this_" + x.Name, x.TypedIdent.Type), false);
thisMap[x] = Expr.Ident(thisx);
thisLocVars.Add(thisx);
Variable thatx = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false);
thatMap[x] = Expr.Ident(thatx);
thatLocVars.Add(thatx);
}
Contract.Assume(proc.TypeParameters.Count == 0);
Substitution thisSubst = Substituter.SubstitutionFromHashtable(this.thisMap);
Substitution thatSubst = Substituter.SubstitutionFromHashtable(this.thatMap);
foreach (AssertCmd assertCmd in this.gate)
{
this.thisGate.Add((AssertCmd)Substituter.Apply(thisSubst, assertCmd));
this.thatGate.Add((AssertCmd)Substituter.Apply(thatSubst, assertCmd));
}
this.thisAction = new CodeExpr(thisLocVars, SubstituteBlocks(this.action.Blocks, thisSubst, "this_"));
this.thatAction = new CodeExpr(thatLocVars, SubstituteBlocks(this.action.Blocks, thatSubst, "that_"));
{
VariableCollector collector = new VariableCollector();
collector.Visit(this.action);
this.actionUsedGlobalVars = new HashSet<Variable>(collector.usedVars.Where(x => x is GlobalVariable));
}
List<Variable> modifiedVars = new List<Variable>();
foreach (Block block in this.action.Blocks)
{
block.Cmds.ForEach(cmd => cmd.AddAssignedVariables(modifiedVars));
}
this.modifiedGlobalVars = new HashSet<Variable>(modifiedVars.Where(x => x is GlobalVariable));
{
VariableCollector collector = new VariableCollector();
this.gate.ForEach(assertCmd => collector.Visit(assertCmd));
this.gateUsedGlobalVars = new HashSet<Variable>(collector.usedVars.Where(x => x is GlobalVariable));
}
}
void PrintFormal(Formal f) {
Contract.Requires(f != null);
if (f.IsGhost) {
wr.Write("ghost ");
}
if (f.HasName) {
wr.Write("{0}: ", f.DisplayName);
}
PrintType(f.Type);
}
public ActionInfo(Procedure proc, CodeExpr codeExpr, MoverType moverType, int phaseNum)
{
this.proc = proc;
this.moverType = moverType;
this.phaseNum = phaseNum;
this.callerPhaseNums = new HashSet<int>();
this.thisGate = new List<AssertCmd>();
this.thisAction = codeExpr;
this.thisInParams = new List<Variable>();
this.thisOutParams = new List<Variable>();
this.thatGate = new List<AssertCmd>();
this.thatInParams = new List<Variable>();
this.thatOutParams = new List<Variable>();
var cmds = thisAction.Blocks[0].Cmds;
for (int i = 0; i < cmds.Count; i++)
{
AssertCmd assertCmd = cmds[i] as AssertCmd;
if (assertCmd == null) break;
thisGate.Add(assertCmd);
cmds[i] = new AssumeCmd(assertCmd.tok, assertCmd.Expr);
}
Dictionary<Variable, Expr> map = new Dictionary<Variable, Expr>();
foreach (Variable x in proc.InParams)
{
this.thisInParams.Add(x);
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), true);
this.thatInParams.Add(y);
map[x] = new IdentifierExpr(Token.NoToken, y);
}
foreach (Variable x in proc.OutParams)
{
this.thisOutParams.Add(x);
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false);
this.thatOutParams.Add(y);
map[x] = new IdentifierExpr(Token.NoToken, y);
}
List<Variable> otherLocVars = new List<Variable>();
foreach (Variable x in thisAction.LocVars)
{
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false);
map[x] = new IdentifierExpr(Token.NoToken, y);
otherLocVars.Add(y);
}
Contract.Assume(proc.TypeParameters.Count == 0);
Substitution subst = Substituter.SubstitutionFromHashtable(map);
foreach (AssertCmd assertCmd in thisGate)
{
thatGate.Add((AssertCmd)Substituter.Apply(subst, assertCmd));
}
Dictionary<Block, Block> blockMap = new Dictionary<Block, Block>();
List<Block> otherBlocks = new List<Block>();
foreach (Block block in thisAction.Blocks)
{
List<Cmd> otherCmds = new List<Cmd>();
foreach (Cmd cmd in block.Cmds)
{
otherCmds.Add(Substituter.Apply(subst, cmd));
}
Block otherBlock = new Block();
otherBlock.Cmds = otherCmds;
otherBlock.Label = "that_" + block.Label;
block.Label = "this_" + block.Label;
otherBlocks.Add(otherBlock);
blockMap[block] = otherBlock;
if (block.TransferCmd is GotoCmd)
{
GotoCmd gotoCmd = block.TransferCmd as GotoCmd;
for (int i = 0; i < gotoCmd.labelNames.Count; i++)
{
gotoCmd.labelNames[i] = "this_" + gotoCmd.labelNames[i];
}
}
}
foreach (Block block in thisAction.Blocks)
{
if (block.TransferCmd is ReturnExprCmd)
{
block.TransferCmd = new ReturnCmd(block.TransferCmd.tok);
blockMap[block].TransferCmd = new ReturnCmd(block.TransferCmd.tok);
continue;
}
List<Block> otherGotoCmdLabelTargets = new List<Block>();
List<string> otherGotoCmdLabelNames = new List<string>();
GotoCmd gotoCmd = block.TransferCmd as GotoCmd;
foreach (Block target in gotoCmd.labelTargets)
{
otherGotoCmdLabelTargets.Add(blockMap[target]);
otherGotoCmdLabelNames.Add(blockMap[target].Label);
}
blockMap[block].TransferCmd = new GotoCmd(block.TransferCmd.tok, otherGotoCmdLabelNames, otherGotoCmdLabelTargets);
}
this.thatAction = new CodeExpr(otherLocVars, otherBlocks);
}
private static void CreateDelegateCreateMethod(Sink sink, ITypeDefinition type, HashSet<IMethodDefinition> delegates)
{
Bpl.Formal method = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "Method", Bpl.Type.Int), true);
Bpl.Formal receiver = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "Receiver", sink.Heap.RefType), true);
Bpl.Formal typeParameters = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "TypeParameters", sink.Heap.TypeType), true);
Bpl.Formal returnDelegate = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "c", sink.Heap.RefType), false);
Bpl.IdentifierExpr methodExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, method);
Bpl.IdentifierExpr receiverExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, receiver);
Bpl.IdentifierExpr typeParametersExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, typeParameters);
Bpl.IdentifierExpr returnDelegateExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, returnDelegate);
Bpl.Procedure proc = new Bpl.Procedure(
Bpl.Token.NoToken,
sink.DelegateCreate(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] {method, receiver, typeParameters}),
new List<Bpl.Variable>(new Bpl.Variable[] {returnDelegate}),
new List<Bpl.Requires>(),
new List<Bpl.IdentifierExpr>(),
new List<Bpl.Ensures>());
proc.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(proc);
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
stmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, "Alloc", new List<Bpl.Expr>(), new List<Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] {returnDelegateExpr})));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadReceiver(methodExpr, returnDelegateExpr), receiverExpr)));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadTypeParameters(methodExpr, returnDelegateExpr), typeParametersExpr)));
foreach (IMethodDefinition defn in delegates)
{
Bpl.IdentifierExpr cie = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateDelegateMethodConstant(defn));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Iff, sink.ReadMethod(cie, returnDelegateExpr), Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, methodExpr, cie))));
}
Bpl.Implementation impl = new Bpl.Implementation(
Bpl.Token.NoToken,
sink.DelegateCreate(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] { method, receiver, typeParameters }),
new List<Bpl.Variable>(new Bpl.Variable[] {returnDelegate}),
new List<Bpl.Variable>(),
stmtBuilder.Collect(Bpl.Token.NoToken));
impl.AddAttribute("inline", Bpl.Expr.Literal(1));
impl.Proc = proc;
sink.TranslatedProgram.AddTopLevelDeclaration(impl);
}
private static void CreateDispatchMethod(Sink sink, ITypeDefinition type, HashSet <IMethodDefinition> delegates)
{
Contract.Assert(type.IsDelegate);
IMethodDefinition invokeMethod = null;
foreach (IMethodDefinition m in type.Methods)
{
if (m.Name.Value == "Invoke")
{
invokeMethod = m;
break;
}
}
try {
IMethodDefinition unspecializedInvokeMethod = Sink.Unspecialize(invokeMethod).ResolvedMethod;
Sink.ProcedureInfo invokeProcedureInfo = sink.FindOrCreateProcedure(unspecializedInvokeMethod);
Bpl.Procedure invokeProcedure = (Bpl.Procedure)invokeProcedureInfo.Decl;
invokeProcedure.AddAttribute("inline", Bpl.Expr.Literal(1));
Bpl.Formal delegateVariable = invokeProcedureInfo.ThisVariable;
Bpl.IToken token = invokeMethod.Token();
List <Bpl.Variable> dispatchProcInExprs = new List <Bpl.Variable>();
for (int i = 1; i < invokeProcedure.InParams.Count; i++)
{
Bpl.Variable v = invokeProcedure.InParams[i];
dispatchProcInExprs.Add(v);
}
List <Bpl.Variable> dispatchProcOutExprs = new List <Bpl.Variable>();
foreach (Bpl.Variable v in invokeProcedure.OutParams)
{
dispatchProcOutExprs.Add(v);
}
List <Bpl.Variable> localVariables = new List <Bpl.Variable>();
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
int localCounter = 0;
foreach (IMethodDefinition defn in delegates)
{
Bpl.Constant c = sink.FindOrCreateDelegateMethodConstant(defn);
Sink.ProcedureInfo delegateProcedureInfo = sink.FindOrCreateProcedure(defn);
Bpl.Procedure delegateProcedure = (Bpl.Procedure)delegateProcedureInfo.Decl;
Bpl.Formal thisVariable = delegateProcedureInfo.ThisVariable;
int numArguments = defn.ParameterCount;
List <Bpl.Variable> tempInputs = new List <Bpl.Variable>();
List <Bpl.Variable> tempOutputs = new List <Bpl.Variable>();
for (int i = 0; i < defn.ParameterCount; i++)
{
Bpl.Variable v = delegateProcedure.InParams[(thisVariable == null ? 0 : 1) + i];
Bpl.LocalVariable localVariable = new Bpl.LocalVariable(Bpl.Token.NoToken,
new Bpl.TypedIdent(Bpl.Token.NoToken, "local" + localCounter++, v.TypedIdent.Type));
localVariables.Add(localVariable);
tempInputs.Add(localVariable);
}
for (int i = 0; i < delegateProcedure.OutParams.Count; i++)
{
Bpl.Variable v = delegateProcedure.OutParams[i];
Bpl.LocalVariable localVariable = new Bpl.LocalVariable(Bpl.Token.NoToken,
new Bpl.TypedIdent(Bpl.Token.NoToken, "local" + localCounter++, v.TypedIdent.Type));
localVariables.Add(localVariable);
tempOutputs.Add(localVariable);
}
List <Bpl.Expr> ins = new List <Bpl.Expr>();
List <Bpl.IdentifierExpr> outs = new List <Bpl.IdentifierExpr>();
if (!defn.IsStatic)
{
ins.Add(sink.ReadReceiver(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)));
}
for (int i = 0; i < tempInputs.Count; i++)
{
ins.Add(Bpl.Expr.Ident(tempInputs[i]));
}
if (defn.IsGeneric)
{
for (int i = 0; i < defn.GenericParameterCount; i++)
{
ins.Add(new Bpl.NAryExpr(Bpl.Token.NoToken,
new Bpl.FunctionCall(sink.FindOrCreateTypeParameterFunction(i)),
new List <Bpl.Expr>(new Bpl.Expr[] { sink.ReadTypeParameters(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)) })));
}
}
if (defn.IsStatic)
{
int numTypeParameters = Sink.ConsolidatedGenericParameterCount(defn.ContainingType);
for (int i = 0; i < numTypeParameters; i++)
{
ins.Add(new Bpl.NAryExpr(Bpl.Token.NoToken,
new Bpl.FunctionCall(sink.FindOrCreateTypeParameterFunction(i)),
new List <Bpl.Expr>(new Bpl.Expr[] { sink.ReadTypeParameters(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable)) })));
}
}
for (int i = 0; i < tempOutputs.Count; i++)
{
outs.Add(Bpl.Expr.Ident(tempOutputs[i]));
}
Bpl.Expr bexpr = sink.ReadMethod(Bpl.Expr.Ident(c), Bpl.Expr.Ident(delegateVariable));
Bpl.StmtListBuilder ifStmtBuilder = new Bpl.StmtListBuilder();
System.Diagnostics.Debug.Assert(tempInputs.Count == dispatchProcInExprs.Count);
if (tempInputs.Count > 0)
{
BuildAssignment(sink, ifStmtBuilder, tempInputs, dispatchProcInExprs);
}
ifStmtBuilder.Add(EmitDummySourceContext());
ifStmtBuilder.Add(new Bpl.CallCmd(token, delegateProcedure.Name, ins, outs));
System.Diagnostics.Debug.Assert(tempOutputs.Count == dispatchProcOutExprs.Count);
if (tempOutputs.Count > 0)
{
BuildAssignment(sink, ifStmtBuilder, dispatchProcOutExprs, tempOutputs);
}
stmtBuilder.Add(new Bpl.IfCmd(bexpr.tok, bexpr, ifStmtBuilder.Collect(bexpr.tok), null, null));
}
Bpl.Implementation dispatchImpl =
new Bpl.Implementation(token,
invokeProcedure.Name,
new List <Bpl.TypeVariable>(),
invokeProcedure.InParams,
invokeProcedure.OutParams,
localVariables,
stmtBuilder.Collect(token)
);
dispatchImpl.Proc = invokeProcedure;
dispatchImpl.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(dispatchImpl);
} catch (TranslationException te) {
throw new NotImplementedException(te.ToString());
} catch {
throw;
} finally {
// Maybe this is a good place to add the procedure to the toplevel declarations
}
}
private CallCmd CallToYieldProc(IToken tok, Dictionary<Variable, Variable> ogOldGlobalMap, Dictionary<string, Variable> domainNameToLocalVar)
{
List<Expr> exprSeq = new List<Expr>();
foreach (string domainName in linearTypeChecker.linearDomains.Keys)
{
exprSeq.Add(Expr.Ident(domainNameToLocalVar[domainName]));
}
foreach (IdentifierExpr ie in globalMods)
{
exprSeq.Add(Expr.Ident(ogOldGlobalMap[ie.Decl]));
}
if (yieldProc == null)
{
List<Variable> inputs = new List<Variable>();
foreach (string domainName in linearTypeChecker.linearDomains.Keys)
{
var domain = linearTypeChecker.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);
inputs.Add(f);
}
foreach (IdentifierExpr ie in globalMods)
{
Formal f = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_global_old_{0}", ie.Decl.Name), ie.Decl.TypedIdent.Type), true);
inputs.Add(f);
}
yieldProc = new Procedure(Token.NoToken, string.Format("og_yield_{0}", layerNum), new List<TypeVariable>(), inputs, new List<Variable>(), new List<Requires>(), new List<IdentifierExpr>(), new List<Ensures>());
yieldProc.AddAttribute("inline", new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1)));
}
CallCmd yieldCallCmd = new CallCmd(Token.NoToken, yieldProc.Name, exprSeq, new List<IdentifierExpr>());
yieldCallCmd.Proc = yieldProc;
return yieldCallCmd;
}
public void DesugarParallelCallCmd(List<Cmd> newCmds, ParCallCmd parCallCmd)
{
List<string> parallelCalleeNames = new List<string>();
List<Expr> ins = new List<Expr>();
List<IdentifierExpr> outs = new List<IdentifierExpr>();
string procName = "og";
foreach (CallCmd callCmd in parCallCmd.CallCmds)
{
procName = procName + "_" + callCmd.Proc.Name;
ins.AddRange(callCmd.Ins);
outs.AddRange(callCmd.Outs);
}
Procedure proc;
if (asyncAndParallelCallDesugarings.ContainsKey(procName))
{
proc = asyncAndParallelCallDesugarings[procName];
}
else
{
List<Variable> inParams = new List<Variable>();
List<Variable> outParams = new List<Variable>();
List<Requires> requiresSeq = new List<Requires>();
List<Ensures> ensuresSeq = new List<Ensures>();
int count = 0;
foreach (CallCmd callCmd in parCallCmd.CallCmds)
{
Dictionary<Variable, Expr> map = new Dictionary<Variable, Expr>();
foreach (Variable x in callCmd.Proc.InParams)
{
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_{0}_{1}", count, x.Name), x.TypedIdent.Type), true);
inParams.Add(y);
map[x] = Expr.Ident(y);
}
foreach (Variable x in callCmd.Proc.OutParams)
{
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_{0}_{1}", count, x.Name), x.TypedIdent.Type), false);
outParams.Add(y);
map[x] = Expr.Ident(y);
}
Contract.Assume(callCmd.Proc.TypeParameters.Count == 0);
Substitution subst = Substituter.SubstitutionFromHashtable(map);
foreach (Requires req in callCmd.Proc.Requires)
{
requiresSeq.Add(new Requires(req.tok, req.Free, Substituter.Apply(subst, req.Condition), null, req.Attributes));
}
foreach (Ensures ens in callCmd.Proc.Ensures)
{
ensuresSeq.Add(new Ensures(ens.tok, ens.Free, Substituter.Apply(subst, ens.Condition), null, ens.Attributes));
}
count++;
}
proc = new Procedure(Token.NoToken, procName, new List<TypeVariable>(), inParams, outParams, requiresSeq, globalMods, ensuresSeq);
asyncAndParallelCallDesugarings[procName] = proc;
}
CallCmd dummyCallCmd = new CallCmd(parCallCmd.tok, proc.Name, ins, outs, parCallCmd.Attributes);
dummyCallCmd.Proc = proc;
newCmds.Add(dummyCallCmd);
}
public static Expr Extract(Expr expr, Program program, List<Axiom> axioms)
{
Contract.Requires(expr != null && program != null && !program.TopLevelDeclarationsAreFrozen && axioms != null);
if (expr is LiteralExpr)
{
return expr;
}
var extractor = new FunctionExtractor();
var body = extractor.VisitExpr(expr);
var name = program.FreshExtractedFunctionName();
var originalVars = extractor.Substitutions.Keys.ToList();
var formalInArgs = originalVars.Select(v => new Formal(Token.NoToken, new TypedIdent(Token.NoToken, extractor.Substitutions[v].Name, extractor.Substitutions[v].TypedIdent.Type), true)).ToList<Variable>();
var formalOutArg = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, name + "$result$", expr.Type), false);
var func = new Function(Token.NoToken, name, formalInArgs, formalOutArg);
func.AddAttribute("never_pattern");
var boundVars = originalVars.Select(k => extractor.Substitutions[k]);
var axiomCall = new NAryExpr(Token.NoToken, new FunctionCall(func), boundVars.Select(b => new IdentifierExpr(Token.NoToken, b)).ToList<Expr>());
axiomCall.Type = expr.Type;
axiomCall.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
var eq = LiteralExpr.Eq(axiomCall, body);
eq.Type = body.Type;
eq.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
if (0 < formalInArgs.Count)
{
var forallExpr = new ForallExpr(Token.NoToken, boundVars.ToList<Variable>(), new Trigger(Token.NoToken, true, new List<Expr> { axiomCall }), eq);
body = forallExpr;
forallExpr.Attributes = new QKeyValue(Token.NoToken, "weight", new List<object> { new LiteralExpr(Token.NoToken, Basetypes.BigNum.FromInt(30)) }, null);
body.Type = Type.Bool;
}
else
{
body = eq;
}
var axiom = new Axiom(Token.NoToken, body);
func.DefinitionAxiom = axiom;
program.AddTopLevelDeclaration(func);
program.AddTopLevelDeclaration(axiom);
axioms.Add(axiom);
var call = new NAryExpr(Token.NoToken, new FunctionCall(func), originalVars.Select(v => new IdentifierExpr(Token.NoToken, v)).ToList<Expr>());
call.Type = expr.Type;
call.TypeParameters = SimpleTypeParamInstantiation.EMPTY;
return call;
}
void PrintFormal(Formal f, bool showNewKeyword)
{
Contract.Requires(f != null);
PrintAttributes(f.Attributes);
if (showNewKeyword && !f.IsOld) {
wr.Write("new ");
}
if (f.IsGhost) {
wr.Write("ghost ");
}
if (f.HasName) {
wr.Write("{0}: ", f.DisplayName);
}
PrintType(f.Type);
}
public AtomicActionInfo(Procedure proc, Ensures ensures, MoverType moverType, int layerNum, int availableUptoLayerNum)
: base(proc, layerNum, availableUptoLayerNum)
{
CodeExpr codeExpr = ensures.Condition as CodeExpr;
this.ensures = ensures;
this.moverType = moverType;
this.thisGate = new List<AssertCmd>();
this.thisAction = codeExpr;
this.thisInParams = new List<Variable>();
this.thisOutParams = new List<Variable>();
this.thatGate = new List<AssertCmd>();
this.thatInParams = new List<Variable>();
this.thatOutParams = new List<Variable>();
this.hasAssumeCmd = false;
foreach (Block block in codeExpr.Blocks)
{
block.Cmds.ForEach(x => this.hasAssumeCmd = this.hasAssumeCmd || x is AssumeCmd);
}
var cmds = thisAction.Blocks[0].Cmds;
for (int i = 0; i < cmds.Count; i++)
{
AssertCmd assertCmd = cmds[i] as AssertCmd;
if (assertCmd == null) break;
thisGate.Add(assertCmd);
cmds[i] = new AssumeCmd(assertCmd.tok, Expr.True);
}
Dictionary<Variable, Expr> map = new Dictionary<Variable, Expr>();
foreach (Variable x in proc.InParams)
{
this.thisInParams.Add(x);
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), true, x.Attributes);
this.thatInParams.Add(y);
map[x] = Expr.Ident(y);
}
foreach (Variable x in proc.OutParams)
{
this.thisOutParams.Add(x);
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false, x.Attributes);
this.thatOutParams.Add(y);
map[x] = Expr.Ident(y);
}
List<Variable> thatLocVars = new List<Variable>();
foreach (Variable x in thisAction.LocVars)
{
Variable y = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "that_" + x.Name, x.TypedIdent.Type), false);
map[x] = Expr.Ident(y);
thatLocVars.Add(y);
}
Contract.Assume(proc.TypeParameters.Count == 0);
Substitution subst = Substituter.SubstitutionFromHashtable(map);
foreach (AssertCmd assertCmd in thisGate)
{
thatGate.Add((AssertCmd)Substituter.Apply(subst, assertCmd));
}
Dictionary<Block, Block> blockMap = new Dictionary<Block, Block>();
List<Block> thatBlocks = new List<Block>();
foreach (Block block in thisAction.Blocks)
{
List<Cmd> otherCmds = new List<Cmd>();
foreach (Cmd cmd in block.Cmds)
{
otherCmds.Add(Substituter.Apply(subst, cmd));
}
Block thatBlock = new Block();
thatBlock.Cmds = otherCmds;
thatBlock.Label = "that_" + block.Label;
block.Label = "this_" + block.Label;
thatBlocks.Add(thatBlock);
blockMap[block] = thatBlock;
if (block.TransferCmd is GotoCmd)
{
GotoCmd gotoCmd = block.TransferCmd as GotoCmd;
for (int i = 0; i < gotoCmd.labelNames.Count; i++)
{
gotoCmd.labelNames[i] = "this_" + gotoCmd.labelNames[i];
}
}
}
foreach (Block block in thisAction.Blocks)
{
if (block.TransferCmd is ReturnExprCmd)
{
block.TransferCmd = new ReturnCmd(block.TransferCmd.tok);
blockMap[block].TransferCmd = new ReturnCmd(block.TransferCmd.tok);
continue;
}
List<Block> thatGotoCmdLabelTargets = new List<Block>();
List<string> thatGotoCmdLabelNames = new List<string>();
GotoCmd gotoCmd = block.TransferCmd as GotoCmd;
foreach (Block target in gotoCmd.labelTargets)
{
thatGotoCmdLabelTargets.Add(blockMap[target]);
thatGotoCmdLabelNames.Add(blockMap[target].Label);
}
blockMap[block].TransferCmd = new GotoCmd(block.TransferCmd.tok, thatGotoCmdLabelNames, thatGotoCmdLabelTargets);
}
this.thatAction = new CodeExpr(thatLocVars, thatBlocks);
{
VariableCollector collector = new VariableCollector();
collector.Visit(codeExpr);
this.actionUsedGlobalVars = new HashSet<Variable>(collector.usedVars.Where(x => x is GlobalVariable));
}
List<Variable> modifiedVars = new List<Variable>();
foreach (Block block in codeExpr.Blocks)
{
block.Cmds.ForEach(cmd => cmd.AddAssignedVariables(modifiedVars));
}
this.modifiedGlobalVars = new HashSet<Variable>(modifiedVars.Where(x => x is GlobalVariable));
{
VariableCollector collector = new VariableCollector();
this.thisGate.ForEach(assertCmd => collector.Visit(assertCmd));
this.gateUsedGlobalVars = new HashSet<Variable>(collector.usedVars.Where(x => x is GlobalVariable));
}
}
public override Formal VisitFormal(Formal node)
{
Contract.Ensures(Contract.Result<Formal>() == node);
return node;
}
string FormalName(Formal formal, int i) {
Contract.Requires(formal != null);
Contract.Ensures(Contract.Result<string>() != null);
return formal.HasName ? formal.CompileName : "_a" + i;
}
public Bpl.Function CreateTypeFunction(ITypeReference type, int parameterCount) {
System.Diagnostics.Debug.Assert(parameterCount >= 0);
string typename = TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId);
typename = TranslationHelper.TurnStringIntoValidIdentifier(typename);
Bpl.IToken tok = type.Token();
List<Bpl.Variable> inputs = new List<Bpl.Variable>();
//for (int i = 0; i < parameterCount; i++) {
// inputs.Add(new Bpl.Formal(tok, new Bpl.TypedIdent(tok, "arg"+i, this.TypeType), true));
//}
foreach (var t in TranslationHelper.ConsolidatedGenericParameters(type)) {
var n = t.Name.Value;
var n2 = TranslationHelper.TurnStringIntoValidIdentifier(n);
inputs.Add(new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, n2, this.TypeType), true));
}
Bpl.Variable output = new Bpl.Formal(tok, new Bpl.TypedIdent(tok, "result", this.TypeType), false);
Bpl.Function func = new Bpl.Function(tok, typename, inputs, output);
var attrib = new Bpl.QKeyValue(Bpl.Token.NoToken, "constructor", new List<object>(1), null);
func.Attributes = attrib;
return func;
}
private static void CreateDelegateRemoveMethod(Sink sink, ITypeDefinition type, HashSet<IMethodDefinition> delegates)
{
Bpl.Formal a = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "a", sink.Heap.RefType), true);
Bpl.Formal b = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "b", sink.Heap.RefType), true);
Bpl.Formal c = new Bpl.Formal(Bpl.Token.NoToken, new Bpl.TypedIdent(Bpl.Token.NoToken, "c", sink.Heap.RefType), false);
Bpl.IdentifierExpr aExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, a);
Bpl.IdentifierExpr bExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, b);
Bpl.IdentifierExpr cExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, c);
Bpl.Procedure proc = new Bpl.Procedure(
Bpl.Token.NoToken,
sink.DelegateRemove(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] { a, b }),
new List<Bpl.Variable>(new Bpl.Variable[] {c}),
new List<Bpl.Requires>(),
new List<Bpl.IdentifierExpr>(),
new List<Bpl.Ensures>());
proc.AddAttribute("inline", Bpl.Expr.Literal(1));
sink.TranslatedProgram.AddTopLevelDeclaration(proc);
Bpl.StmtListBuilder stmtBuilder = new Bpl.StmtListBuilder();
stmtBuilder.Add(new Bpl.CallCmd(Bpl.Token.NoToken, "Alloc", new List<Bpl.Expr>(), new List<Bpl.IdentifierExpr>(new Bpl.IdentifierExpr[] {cExpr})));
foreach (IMethodDefinition defn in delegates)
{
Bpl.IdentifierExpr cie = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.FindOrCreateDelegateMethodConstant(defn));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Iff, sink.ReadMethod(cie, cExpr), Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.And, sink.ReadMethod(cie, aExpr), Bpl.Expr.Unary(Bpl.Token.NoToken, Bpl.UnaryOperator.Opcode.Not, sink.ReadMethod(cie, bExpr))))));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadReceiver(cie, cExpr), sink.ReadReceiver(cie, aExpr))));
stmtBuilder.Add(new Bpl.AssumeCmd(Bpl.Token.NoToken, Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, sink.ReadTypeParameters(cie, cExpr), sink.ReadTypeParameters(cie, aExpr))));
}
Bpl.IdentifierExpr nullExpr = new Bpl.IdentifierExpr(Bpl.Token.NoToken, sink.Heap.NullRef);
Bpl.IfCmd ifCmd = BuildIfCmd(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, bExpr, nullExpr), TranslationHelper.BuildAssignCmd(cExpr, aExpr), stmtBuilder.Collect(Bpl.Token.NoToken));
ifCmd = BuildIfCmd(Bpl.Expr.Binary(Bpl.BinaryOperator.Opcode.Eq, aExpr, nullExpr), TranslationHelper.BuildAssignCmd(cExpr, nullExpr), ifCmd);
Bpl.Implementation impl = new Bpl.Implementation(
Bpl.Token.NoToken,
sink.DelegateRemove(type),
new List<Bpl.TypeVariable>(),
new List<Bpl.Variable>(new Bpl.Variable[] { a, b }),
new List<Bpl.Variable>(new Bpl.Variable[] {c}),
new List<Bpl.Variable>(),
BuildStmtList(ifCmd)
);
impl.AddAttribute("inline", Bpl.Expr.Literal(1));
impl.Proc = proc;
sink.TranslatedProgram.AddTopLevelDeclaration(impl);
}
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 LazyInliningInfo(Implementation impl, Program program, ProverContext ctxt, int uniqueId, GlobalVariable errorVariable)
{
Contract.Requires(impl != null);
Contract.Requires(program != null);
Procedure proc = cce.NonNull(impl.Proc);
this.impl = impl;
this.uniqueId = uniqueId;
this.controlFlowVariable = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, "cfc", Microsoft.Boogie.Type.Int));
impl.LocVars.Add(controlFlowVariable);
List<Variable> interfaceVars = new List<Variable>();
Expr assertExpr = new LiteralExpr(Token.NoToken, true);
Contract.Assert(assertExpr != null);
foreach (Variable v in program.GlobalVariables())
{
Contract.Assert(v != null);
interfaceVars.Add(v);
if (v.Name == "error")
inputErrorVariable = v;
}
// InParams must be obtained from impl and not proc
foreach (Variable v in impl.InParams)
{
Contract.Assert(v != null);
interfaceVars.Add(v);
}
// OutParams must be obtained from impl and not proc
foreach (Variable v in impl.OutParams)
{
Contract.Assert(v != null);
Constant c = new Constant(Token.NoToken,
new TypedIdent(Token.NoToken, impl.Name + "_" + v.Name, v.TypedIdent.Type));
interfaceVars.Add(c);
Expr eqExpr = Expr.Eq(new IdentifierExpr(Token.NoToken, c), new IdentifierExpr(Token.NoToken, v));
assertExpr = Expr.And(assertExpr, eqExpr);
}
if (errorVariable != null)
{
proc.Modifies.Add(new IdentifierExpr(Token.NoToken, errorVariable));
}
foreach (IdentifierExpr e in proc.Modifies)
{
Contract.Assert(e != null);
if (e.Decl == null)
continue;
Variable v = e.Decl;
Constant c = new Constant(Token.NoToken, new TypedIdent(Token.NoToken, impl.Name + "_" + v.Name, v.TypedIdent.Type));
interfaceVars.Add(c);
if (v.Name == "error")
{
outputErrorVariable = c;
continue;
}
Expr eqExpr = Expr.Eq(new IdentifierExpr(Token.NoToken, c), new IdentifierExpr(Token.NoToken, v));
assertExpr = Expr.And(assertExpr, eqExpr);
}
this.interfaceVars = interfaceVars;
this.assertExpr = Expr.Not(assertExpr);
List<Variable> functionInterfaceVars = new List<Variable>();
foreach (Variable v in interfaceVars)
{
Contract.Assert(v != null);
functionInterfaceVars.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, v.Name, v.TypedIdent.Type), true));
}
TypedIdent ti = new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Bool);
Contract.Assert(ti != null);
Formal returnVar = new Formal(Token.NoToken, ti, false);
Contract.Assert(returnVar != null);
this.function = new Function(Token.NoToken, proc.Name, functionInterfaceVars, returnVar);
ctxt.DeclareFunction(this.function, "");
interfaceVarCopies = new List<List<Variable>>();
int temp = 0;
for (int i = 0; i < /* CommandLineOptions.Clo.ProcedureCopyBound */ 0; i++)
{
interfaceVarCopies.Add(new List<Variable>());
foreach (Variable v in interfaceVars)
{
Constant constant = new Constant(Token.NoToken, new TypedIdent(Token.NoToken, v.Name + temp++, v.TypedIdent.Type));
interfaceVarCopies[i].Add(constant);
//program.TopLevelDeclarations.Add(constant);
}
}
}
public override void Compile_FunctionAsMethod(Function function, Dictionary<TypeParameter,Type> typeArgs,
Dictionary<string,TypeParameter> substArgs)
{
var tok = function.tok;
if (Attributes.Contains(function.Attributes, "CompiledSpec"))
{
string specName = function.Name.Substring("CompiledSpec_".Length);
function = FindFunction(specName);
}
bool hidden = Attributes.Contains(function.Attributes, "opaque");
Formal result = new Formal(function.tok, "__result", function.ResultType, false, function.IsGhost);
string funName = function.Name;
string name = FunName(DafnySpec.SimpleSanitizedName(function));
FunctionCallExpr call = new FunctionCallExpr(tok, name, new ThisExpr(tok), tok,
function.Formals.ConvertAll(f => (Expression)
MakeIdentifierExpr(f.Name, f.Type, f.IsGhost)));
call.Function = function;
call.TypeArgumentSubstitutions = typeArgs;
call.Type = function.ResultType;
CallStmt revealCall = null;
if (hidden)
{
var selectExpr = new MemberSelectExpr(tok, new ThisExpr(tok), "reveal_" + function.Name);
selectExpr.Member = FindMethod(selectExpr.MemberName); // Manually resolve here
selectExpr.TypeApplication = new List<Type>(); // Manually resolve here
selectExpr.Type = new InferredTypeProxy(); // Manually resolve here
revealCall = new CallStmt(tok, tok, new List<Expression>(), selectExpr, new List<Expression>());
revealCall.IsGhost = true;
ClassDecl cls = (ClassDecl)function.EnclosingClass;
string fullName = "#" + function.Name + "_FULL";
function = (Function)cls.Members.Find(m => m.Name == fullName);
if (function == null)
{
throw new Exception("internal error: could not find function " + fullName);
}
substArgs = new Dictionary<string,TypeParameter>();
function.TypeArgs.ForEach(t => substArgs.Add(t.Name, t));
typeArgs = typeArgs.ToDictionary(p => substArgs[p.Key.Name], p => p.Value);
}
Expression funBody = function.Body;
BlockStmt body = null;
if (funBody != null)
{
ReturnStmt retStmt = new ReturnStmt(tok, tok, new List<AssignmentRhs>() {
new ExprRhs(funBody)
});
body = new BlockStmt(tok, tok,
hidden
? (new List<Statement>() { revealCall, retStmt })
: (new List<Statement>() { retStmt }));
}
List<Expression> ens = new List<Expression> {
MakeBinaryExpr(BinaryExpr.Opcode.Eq, BinaryExpr.ResolvedOpcode.EqCommon, Type.Bool,
MakeIdentifierExpr("__result", function.ResultType, function.IsGhost),
call)
}.Concat(function.Ens).ToList();
Method method = new Method(tok, funName, function.IsStatic, function.IsGhost,
function.TypeArgs, function.Formals, new List<Formal> { result },
function.Req.ConvertAll(e => new MaybeFreeExpression(e)),
new Specification<FrameExpression>(new List<FrameExpression>(), null),
ens.ConvertAll(e => new MaybeFreeExpression(e)),
function.Decreases,
body, function.Attributes, function.SignatureEllipsis);
method.EnclosingClass = function.EnclosingClass;
Compile_Method(method, typeArgs);
}
public void AnnotateProcEnsures(Procedure proc, Implementation impl, ProverContext ctxt)
{
Contract.Requires(impl != null);
CurrentLocalVariables = impl.LocVars;
// collect the variables needed in the invariant
List<Expr> exprs = new List<Expr>();
List<Variable> vars = new List<Variable>();
List<string> names = new List<string>();
foreach (Variable v in program.GlobalVariables())
{
vars.Add(v);
exprs.Add(new OldExpr(Token.NoToken,new IdentifierExpr(Token.NoToken, v)));
names.Add(v.Name);
}
foreach (IdentifierExpr ie in proc.Modifies)
{
if (ie.Decl == null)
continue;
vars.Add(ie.Decl);
exprs.Add(ie);
names.Add(ie.Decl.Name + "_out");
}
foreach (Variable v in proc.InParams)
{
Contract.Assert(v != null);
vars.Add(v);
exprs.Add(new OldExpr(Token.NoToken, new IdentifierExpr(Token.NoToken, v)));
names.Add(v.Name);
}
foreach (Variable v in proc.OutParams)
{
Contract.Assert(v != null);
vars.Add(v);
exprs.Add(new IdentifierExpr(Token.NoToken, v));
names.Add(v.Name);
}
string name = impl.Name + "_summary";
summaries.Add(name, true);
TypedIdent ti = new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Bool);
Contract.Assert(ti != null);
Formal returnVar = new Formal(Token.NoToken, ti, false);
Contract.Assert(returnVar != null);
var function = new Function(Token.NoToken, name, vars, returnVar);
ctxt.DeclareFunction(function, "");
Expr invarExpr = new NAryExpr(Token.NoToken, new FunctionCall(function), exprs);
proc.Ensures.Add(new Ensures(Token.NoToken, false, invarExpr, "", null));
var info = new AnnotationInfo();
info.filename = proc.tok.filename;
info.lineno = proc.Line;
info.argnames = names.ToArray();
info.type = AnnotationInfo.AnnotationType.ProcedureSummary;
annotationInfo.Add(name, info);
}
private void AddYieldProcAndImpl(List<Declaration> decls)
{
if (yieldProc == null) return;
Program program = linearTypeChecker.program;
List<Variable> inputs = new List<Variable>();
foreach (string domainName in linearTypeChecker.linearDomains.Keys)
{
var domain = linearTypeChecker.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);
inputs.Add(f);
}
foreach (IdentifierExpr ie in globalMods)
{
Formal f = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_global_old_{0}", ie.Decl.Name), ie.Decl.TypedIdent.Type), true);
inputs.Add(f);
}
List<Block> blocks = new List<Block>();
TransferCmd transferCmd = new ReturnCmd(Token.NoToken);
if (yieldCheckerProcs.Count > 0)
{
List<Block> blockTargets = new List<Block>();
List<String> labelTargets = new List<String>();
int labelCount = 0;
foreach (Procedure proc in yieldCheckerProcs)
{
List<Expr> exprSeq = new List<Expr>();
foreach (Variable v in inputs)
{
exprSeq.Add(Expr.Ident(v));
}
CallCmd callCmd = new CallCmd(Token.NoToken, proc.Name, exprSeq, new List<IdentifierExpr>());
callCmd.Proc = proc;
string label = string.Format("L_{0}", labelCount++);
Block block = new Block(Token.NoToken, label, new List<Cmd> { callCmd }, new ReturnCmd(Token.NoToken));
labelTargets.Add(label);
blockTargets.Add(block);
blocks.Add(block);
}
transferCmd = new GotoCmd(Token.NoToken, labelTargets, blockTargets);
}
blocks.Insert(0, new Block(Token.NoToken, "enter", new List<Cmd>(), transferCmd));
var yieldImpl = new Implementation(Token.NoToken, yieldProc.Name, new List<TypeVariable>(), inputs, new List<Variable>(), new List<Variable>(), blocks);
yieldImpl.Proc = yieldProc;
yieldImpl.AddAttribute("inline", new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1)));
decls.Add(yieldProc);
decls.Add(yieldImpl);
}
public void GenerateVCsForStratifiedInlining()
{
Contract.Requires(program != null);
foreach (Declaration decl in program.TopLevelDeclarations)
{
Contract.Assert(decl != null);
Implementation impl = decl as Implementation;
if (impl == null)
continue;
Contract.Assert(!impl.Name.StartsWith(recordProcName), "Not allowed to have an implementation for this guy");
Procedure proc = cce.NonNull(impl.Proc);
{
StratifiedInliningInfo info = new StratifiedInliningInfo(impl, program, boogieContext, QuantifierExpr.GetNextSkolemId());
implName2StratifiedInliningInfo[impl.Name] = info;
// We don't need controlFlowVariable for stratified Inlining
//impl.LocVars.Add(info.controlFlowVariable);
List<Expr> exprs = new List<Expr>();
if (mode != Mode.Boogie && QKeyValue.FindBoolAttribute(impl.Attributes, "entrypoint"))
{
proc.Ensures.Add(new Ensures(Token.NoToken, true, Microsoft.Boogie.Expr.False, "", null));
info.assertExpr = Microsoft.Boogie.Expr.False;
// info.isMain = true;
}
else if (mode == Mode.Corral || proc.FindExprAttribute("inline") != null || proc is LoopProcedure)
{
foreach (Variable v in program.GlobalVariables())
{
Contract.Assert(v != null);
exprs.Add(new OldExpr(Token.NoToken, new IdentifierExpr(Token.NoToken, v)));
}
foreach (Variable v in proc.InParams)
{
Contract.Assert(v != null);
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
foreach (Variable v in proc.OutParams)
{
Contract.Assert(v != null);
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
foreach (IdentifierExpr ie in proc.Modifies)
{
Contract.Assert(ie != null);
if (ie.Decl == null)
continue;
exprs.Add(ie);
}
Expr freePostExpr = new NAryExpr(Token.NoToken, new FunctionCall(info.function), exprs);
#if true
if(mode == Mode.Corral || mode == Mode.OldCorral)
proc.Ensures.Add(new Ensures(Token.NoToken, true, freePostExpr, "", new QKeyValue(Token.NoToken, "si_fcall", new List<object>(), null)));
#endif
}
else // not marked "inline" must be main
{
Expr freePostExpr = new NAryExpr(Token.NoToken, new FunctionCall(info.function), exprs);
info.isMain = true;
}
}
}
if (mode == Mode.Boogie) return;
foreach (var decl in program.TopLevelDeclarations)
{
var proc = decl as Procedure;
if (proc == null) continue;
if (!proc.Name.StartsWith(recordProcName)) continue;
Contract.Assert(proc.InParams.Count == 1);
// Make a new function
TypedIdent ti = new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Bool);
Contract.Assert(ti != null);
Formal returnVar = new Formal(Token.NoToken, ti, false);
Contract.Assert(returnVar != null);
// Get record type
var argtype = proc.InParams[0].TypedIdent.Type;
var ins = new List<Variable>();
ins.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "x", argtype), true));
var recordFunc = new Function(Token.NoToken, proc.Name, ins, returnVar);
boogieContext.DeclareFunction(recordFunc, "");
var exprs = new List<Expr>();
exprs.Add(new IdentifierExpr(Token.NoToken, proc.InParams[0]));
Expr freePostExpr = new NAryExpr(Token.NoToken, new FunctionCall(recordFunc), exprs);
proc.Ensures.Add(new Ensures(true, freePostExpr));
}
}
private void CreateYieldCheckerImpl(Implementation impl, List<List<Cmd>> yields)
{
if (yields.Count == 0) return;
Dictionary<Variable, Expr> map = new Dictionary<Variable, Expr>();
foreach (Variable local in impl.LocVars)
{
var copy = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, local.Name, local.TypedIdent.Type));
map[local] = Expr.Ident(copy);
}
Program program = linearTypeChecker.program;
List<Variable> locals = new List<Variable>();
List<Variable> inputs = new List<Variable>();
foreach (IdentifierExpr ie in map.Values)
{
locals.Add(ie.Decl);
}
for (int i = 0; i < impl.InParams.Count - linearTypeChecker.linearDomains.Count; i++)
{
Variable inParam = impl.InParams[i];
Variable copy = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, inParam.Name, inParam.TypedIdent.Type));
locals.Add(copy);
map[impl.InParams[i]] = Expr.Ident(copy);
}
{
int i = impl.InParams.Count - linearTypeChecker.linearDomains.Count;
foreach (string domainName in linearTypeChecker.linearDomains.Keys)
{
Variable inParam = impl.InParams[i];
Variable copy = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, inParam.Name, inParam.TypedIdent.Type), true);
inputs.Add(copy);
map[impl.InParams[i]] = Expr.Ident(copy);
i++;
}
}
for (int i = 0; i < impl.OutParams.Count; i++)
{
Variable outParam = impl.OutParams[i];
var copy = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, outParam.Name, outParam.TypedIdent.Type));
locals.Add(copy);
map[impl.OutParams[i]] = Expr.Ident(copy);
}
Dictionary<Variable, Expr> ogOldLocalMap = new Dictionary<Variable, Expr>();
Dictionary<Variable, Expr> assumeMap = new Dictionary<Variable, Expr>(map);
foreach (IdentifierExpr ie in globalMods)
{
Variable g = ie.Decl;
var copy = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_local_old_{0}", g.Name), g.TypedIdent.Type));
locals.Add(copy);
ogOldLocalMap[g] = Expr.Ident(copy);
Formal f = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, string.Format("og_global_old_{0}", g.Name), g.TypedIdent.Type), true);
inputs.Add(f);
assumeMap[g] = Expr.Ident(f);
}
Substitution assumeSubst = Substituter.SubstitutionFromHashtable(assumeMap);
Substitution oldSubst = Substituter.SubstitutionFromHashtable(ogOldLocalMap);
Substitution subst = Substituter.SubstitutionFromHashtable(map);
List<Block> yieldCheckerBlocks = new List<Block>();
List<String> labels = new List<String>();
List<Block> labelTargets = new List<Block>();
Block yieldCheckerBlock = new Block(Token.NoToken, "exit", new List<Cmd>(), new ReturnCmd(Token.NoToken));
labels.Add(yieldCheckerBlock.Label);
labelTargets.Add(yieldCheckerBlock);
yieldCheckerBlocks.Add(yieldCheckerBlock);
int yieldCount = 0;
foreach (List<Cmd> cs in yields)
{
List<Cmd> newCmds = new List<Cmd>();
foreach (Cmd cmd in cs)
{
PredicateCmd predCmd = (PredicateCmd)cmd;
newCmds.Add(new AssumeCmd(Token.NoToken, Substituter.ApplyReplacingOldExprs(assumeSubst, oldSubst, predCmd.Expr)));
}
foreach (Cmd cmd in cs)
{
PredicateCmd predCmd = (PredicateCmd)cmd;
var newExpr = Substituter.ApplyReplacingOldExprs(subst, oldSubst, predCmd.Expr);
if (predCmd is AssertCmd)
{
AssertCmd assertCmd = new AssertCmd(predCmd.tok, newExpr, predCmd.Attributes);
assertCmd.ErrorData = "Non-interference check failed";
newCmds.Add(assertCmd);
}
else
{
newCmds.Add(new AssumeCmd(Token.NoToken, newExpr));
}
}
newCmds.Add(new AssumeCmd(Token.NoToken, Expr.False));
yieldCheckerBlock = new Block(Token.NoToken, "L" + yieldCount++, newCmds, new ReturnCmd(Token.NoToken));
labels.Add(yieldCheckerBlock.Label);
labelTargets.Add(yieldCheckerBlock);
yieldCheckerBlocks.Add(yieldCheckerBlock);
}
yieldCheckerBlocks.Insert(0, new Block(Token.NoToken, "enter", new List<Cmd>(), new GotoCmd(Token.NoToken, labels, labelTargets)));
// Create the yield checker procedure
var yieldCheckerName = string.Format("{0}_YieldChecker_{1}", "Impl", impl.Name);
var yieldCheckerProc = new Procedure(Token.NoToken, yieldCheckerName, impl.TypeParameters, inputs, new List<Variable>(), new List<Requires>(), new List<IdentifierExpr>(), new List<Ensures>());
yieldCheckerProc.AddAttribute("inline", new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1)));
yieldCheckerProcs.Add(yieldCheckerProc);
// Create the yield checker implementation
var yieldCheckerImpl = new Implementation(Token.NoToken, yieldCheckerName, impl.TypeParameters, inputs, new List<Variable>(), locals, yieldCheckerBlocks);
yieldCheckerImpl.Proc = yieldCheckerProc;
yieldCheckerImpl.AddAttribute("inline", new LiteralExpr(Token.NoToken, Microsoft.Basetypes.BigNum.FromInt(1)));
yieldCheckerImpls.Add(yieldCheckerImpl);
}
private void AnnotateBlock(Implementation impl, ProverContext ctxt, Block header)
{
Contract.Assert(header != null);
string name = impl.Name + "_" + header.Label + "_invar";
if (annotationInfo.ContainsKey(name))
return;
// collect the variables needed in the invariant
List<Expr> exprs = new List<Expr>();
List<Variable> vars = new List<Variable>();
List<string> names = new List<string>();
if (style == AnnotationStyle.Flat)
{
// in flat mode, all live globals should be in live set
#if false
foreach (Variable v in program.GlobalVariables())
{
vars.Add(v);
names.Add(v.ToString());
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
#endif
foreach (Variable v in /* impl.LocVars */ header.liveVarsBefore)
{
if (!(v is BoundVariable))
{
vars.Add(v);
names.Add(v.ToString());
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
}
}
else
{
foreach (Variable v in program.GlobalVariables())
{
vars.Add(v);
names.Add("@old_" + v.ToString());
exprs.Add(new OldExpr(Token.NoToken, new IdentifierExpr(Token.NoToken, v)));
}
foreach (IdentifierExpr ie in impl.Proc.Modifies)
{
if (ie.Decl == null)
continue;
vars.Add(ie.Decl);
names.Add(ie.Decl.ToString());
exprs.Add(ie);
}
foreach (Variable v in impl.Proc.InParams)
{
Contract.Assert(v != null);
vars.Add(v);
names.Add("@old_" + v.ToString());
exprs.Add(new OldExpr(Token.NoToken, new IdentifierExpr(Token.NoToken, v)));
}
foreach (Variable v in impl.LocVars)
{
vars.Add(v);
names.Add(v.ToString());
exprs.Add(new IdentifierExpr(Token.NoToken, v));
}
}
TypedIdent ti = new TypedIdent(Token.NoToken, "", Microsoft.Boogie.Type.Bool);
Contract.Assert(ti != null);
Formal returnVar = new Formal(Token.NoToken, ti, false);
Contract.Assert(returnVar != null);
var function = new Function(Token.NoToken, name, vars, returnVar);
ctxt.DeclareFunction(function, "");
Expr invarExpr = new NAryExpr(Token.NoToken, new FunctionCall(function), exprs);
var invarAssertion = new AssertCmd(Token.NoToken, invarExpr);
List<Cmd> newCmds = new List<Cmd>();
newCmds.Add(invarAssertion);
// make a record in annotationInfo;
var info = new AnnotationInfo();
info.filename = header.tok.filename;
info.lineno = header.Line;
info.argnames = names.ToArray();
info.type = AnnotationInfo.AnnotationType.LoopInvariant;
annotationInfo.Add(name, info);
// get file and line info from havoc, if there is...
if (header.Cmds.Count > 0)
{
PredicateCmd bif = header.Cmds[0] as PredicateCmd;
if (bif != null)
{
string foo = QKeyValue.FindStringAttribute(bif.Attributes, "sourcefile");
if (foo != null)
info.filename = foo;
int bar = QKeyValue.FindIntAttribute(bif.Attributes, "sourceline", -1);
if (bar != -1)
info.lineno = bar;
}
}
var thing = header;
foreach (Cmd c in header.Cmds)
{
newCmds.Add(c);
}
header.Cmds = newCmds;
}
public override Formal VisitFormal(Formal node) {
//Contract.Requires(node != null);
Contract.Ensures(Contract.Result<Formal>() != null);
return base.VisitFormal((Formal)node.Clone());
}
////////////////////////////////////////////////////////////////////////////
// Used to axiomatise the disjoint-sub-dag specs that are
// described by parents with the "unique" flag
private Function OneStepFunFor(Type t) {
Contract.Requires(t != null);
Contract.Ensures(Contract.Result<Function>() != null);
Function res;
if (!OneStepFuns.TryGetValue(t, out res)) {
List<Variable> args = new List<Variable>();
args.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "arg0", t), true));
args.Add(new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "arg1", t), true));
Formal result = new Formal(Token.NoToken, new TypedIdent(Token.NoToken, "res", t), false);
res = new Function(Token.NoToken, "oneStep", new List<TypeVariable>(), args, result);
OneStepFuns.Add(t, res);
}
return cce.NonNull(res);
}
