public bool isNonPostEnsure(bpl.Ensures ens)
{
if (ens == null)
{
return(false);
}
return(!hasAttrKey(ens.Attributes, postCondAttr));
}
public bool isNonInvariantEnsure(bpl.Ensures ens)
{
if (ens == null)
{
return(false);
}
return(!hasAttrKey(ens.Attributes, invariantAttr));
}
public bool isEnvGuaranteeEnsure(bpl.Ensures ens)
{
if (ens == null)
{
return(false);
}
return(hasAttrKey(ens.Attributes, envGuaranteeAttr));
}
public bool isEnvRelyEnsure(bpl.Ensures req)
{
if (req == null)
{
return(false);
}
return(hasAttrKey(req.Attributes, envRelyAttr));
}
public bool isNonEnvRelyEnsure(bpl.Ensures ens)
{
if (ens == null)
{
return(false);
}
return(!hasAttrKey(ens.Attributes, envRelyAttr));
}
public IEnumerable<Bpl.Ensures> getPostconditionTranslation(IMethodContract contract) {
ICollection<Bpl.Ensures> translatedPosts = new List<Bpl.Ensures>();
foreach (IPostcondition post in contract.Postconditions) {
var stmtTraverser = this.Factory.MakeStatementTraverser(sink, null, true);
ExpressionTraverser exptravers = this.Factory.MakeExpressionTraverser(sink, stmtTraverser, true);
exptravers.Traverse(post.Condition);
// Todo: Deal with Descriptions
var ens = new Bpl.Ensures(post.Token(), false, exptravers.TranslatedExpressions.Pop(), "");
translatedPosts.Add(ens);
}
return translatedPosts;
}
public IEnumerable <Bpl.Ensures> getPostconditionTranslation(IMethodContract contract)
{
ICollection <Bpl.Ensures> translatedPosts = new List <Bpl.Ensures>();
foreach (IPostcondition post in contract.Postconditions)
{
var stmtTraverser = this.Factory.MakeStatementTraverser(sink, null, true);
ExpressionTraverser exptravers = this.Factory.MakeExpressionTraverser(sink, stmtTraverser, true);
exptravers.Traverse(post.Condition);
// Todo: Deal with Descriptions
var ens = new Bpl.Ensures(post.Token(), false, exptravers.TranslatedExpressions.Pop(), "");
translatedPosts.Add(ens);
}
return(translatedPosts);
}
public static MoverType GetMoverType(Ensures e, out int phaseNum)
{
phaseNum = QKeyValue.FindIntAttribute(e.Attributes, "atomic", int.MaxValue);
if (phaseNum != int.MaxValue)
return MoverType.Atomic;
phaseNum = QKeyValue.FindIntAttribute(e.Attributes, "right", int.MaxValue);
if (phaseNum != int.MaxValue)
return MoverType.Right;
phaseNum = QKeyValue.FindIntAttribute(e.Attributes, "left", int.MaxValue);
if (phaseNum != int.MaxValue)
return MoverType.Left;
phaseNum = QKeyValue.FindIntAttribute(e.Attributes, "both", int.MaxValue);
if (phaseNum != int.MaxValue)
return MoverType.Both;
return MoverType.Top;
}
public static void DesugarYieldAssert(Program program)
{
foreach (var proc in program.Procedures)
{
if (RemoveAttribute(proc, kv => kv.Key == YIELD_ASSERT))
{
proc.AddAttribute(YIELDS);
foreach (var requires in proc.Requires)
{
var ensures = new Ensures(false, requires.Condition);
ensures.Attributes = requires.Attributes;
proc.Ensures.Add(ensures);
}
}
}
}
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));
}
}
private void CreateFailurePreservationChecker(Program program, AtomicActionInfo first, AtomicActionInfo second)
{
if (first.gateUsedGlobalVars.Intersect(second.modifiedGlobalVars).Count() == 0)
return;
if (!failurePreservationCheckerCache.Add(new Tuple<AtomicActionInfo, AtomicActionInfo>(first, second)))
return;
List<Variable> inputs = Enumerable.Union(first.thatInParams, second.thisInParams).ToList();
List<Variable> outputs = Enumerable.Union(first.thatOutParams, second.thisOutParams).ToList();
List<Variable> locals = new List<Variable>(second.thisAction.LocVars);
List<Block> secondBlocks = CloneBlocks(second.thisAction.Blocks);
HashSet<Variable> frame = new HashSet<Variable>();
frame.UnionWith(first.gateUsedGlobalVars);
frame.UnionWith(second.gateUsedGlobalVars);
frame.UnionWith(second.actionUsedGlobalVars);
List<Requires> requires = new List<Requires>();
requires.Add(DisjointnessRequires(program, first.thatInParams.Union(second.thisInParams), frame));
Expr gateExpr = Expr.Not(Expr.And(first.thatGate.Select(a => a.Expr)));
gateExpr.Type = Type.Bool; // necessary?
requires.Add(new Requires(false, gateExpr));
foreach (AssertCmd assertCmd in second.thisGate)
requires.Add(new Requires(false, assertCmd.Expr));
IEnumerable<Expr> linearityAssumes = DisjointnessExpr(program, first.thatInParams.Union(second.thisOutParams), frame);
Ensures ensureCheck = new Ensures(false, Expr.Imp(Expr.And(linearityAssumes), gateExpr));
ensureCheck.ErrorData = string.Format("Gate failure of {0} not preserved by {1}", first.proc.Name, second.proc.Name);
List<Ensures> ensures = new List<Ensures> { ensureCheck };
string checkerName = string.Format("FailurePreservationChecker_{0}_{1}", first.proc.Name, second.proc.Name);
List<IdentifierExpr> globalVars = civlTypeChecker.SharedVariables.Select(x => Expr.Ident(x)).ToList();
Procedure proc = new Procedure(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, requires, globalVars, ensures);
Implementation impl = new Implementation(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, locals, secondBlocks);
impl.Proc = proc;
this.decls.Add(impl);
this.decls.Add(proc);
}
private void CreateNonBlockingChecker(Program program, AtomicActionInfo second)
{
List<Variable> inputs = new List<Variable>();
inputs.AddRange(second.thisInParams);
HashSet<Variable> frame = new HashSet<Variable>();
frame.UnionWith(second.gateUsedGlobalVars);
frame.UnionWith(second.actionUsedGlobalVars);
List<Requires> requires = new List<Requires>();
requires.Add(DisjointnessRequires(program, second.thisInParams, frame));
foreach (AssertCmd assertCmd in second.thisGate)
{
requires.Add(new Requires(false, assertCmd.Expr));
}
HashSet<Variable> postExistVars = new HashSet<Variable>();
postExistVars.UnionWith(frame);
postExistVars.UnionWith(second.thisOutParams);
Expr ensuresExpr = (new TransitionRelationComputation(program, second, frame, postExistVars)).TransitionRelationCompute();
Ensures ensureCheck = new Ensures(false, ensuresExpr);
ensureCheck.ErrorData = string.Format("{0} is blocking", second.proc.Name);
List<Ensures> ensures = new List<Ensures> { ensureCheck };
List<Block> blocks = new List<Block> { new Block(Token.NoToken, "L", new List<Cmd>(), new ReturnCmd(Token.NoToken)) };
string checkerName = string.Format("NonBlockingChecker_{0}", second.proc.Name);
List<IdentifierExpr> globalVars = civlTypeChecker.SharedVariables.Select(x => Expr.Ident(x)).ToList();
Procedure proc = new Procedure(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, new List<Variable>(), requires, globalVars, ensures);
Implementation impl = new Implementation(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, new List<Variable>(), new List<Variable>(), blocks);
impl.Proc = proc;
this.decls.Add(impl);
this.decls.Add(proc);
}
/// <summary>
///
/// </summary>
public override void Visit(IMethodDefinition method) {
Dictionary<IParameterDefinition, MethodParameter> formalMap = new Dictionary<IParameterDefinition, MethodParameter>();
this.sink.BeginMethod();
try {
#region Create in- and out-parameters
int in_count = 0;
int out_count = 0;
MethodParameter mp;
foreach (IParameterDefinition formal in method.ResolvedMethod.Parameters) {
mp = new MethodParameter(formal);
if (mp.inParameterCopy != null) in_count++;
if (mp.outParameterCopy != null && (formal.IsByReference || formal.IsOut))
out_count++;
formalMap.Add(formal, mp);
}
this.sink.FormalMap = formalMap;
#region Look for Returnvalue
// This is just a hack, should be replaced with something more robust
if (method.Type.TypeCode != PrimitiveTypeCode.Void) {
Bpl.Type rettype = Bpl.Type.Int;
out_count++;
this.sink.RetVariable = new Bpl.Formal(method.Token(),
new Bpl.TypedIdent(method.Type.Token(),
"$result", rettype), false);
} else {
this.sink.RetVariable = null;
}
#endregion
#region Create 'this' parameter
in_count++;
Bpl.Type selftype = Bpl.Type.Int;
Bpl.Formal self = new Bpl.Formal(method.Token(),
new Bpl.TypedIdent(method.Type.Token(),
"this", selftype), true);
#endregion
Bpl.Variable[] invars = new Bpl.Formal[in_count];
Bpl.Variable[] outvars = new Bpl.Formal[out_count];
int i = 0;
int j = 0;
#region Add 'this' parameter as first in parameter
invars[i++] = self;
#endregion
foreach (MethodParameter mparam in formalMap.Values) {
if (mparam.inParameterCopy != null) {
invars[i++] = mparam.inParameterCopy;
}
if (mparam.outParameterCopy != null) {
if (mparam.underlyingParameter.IsByReference || mparam.underlyingParameter.IsOut)
outvars[j++] = mparam.outParameterCopy;
}
}
#region add the returnvalue to out if there is one
if (this.sink.RetVariable != null) outvars[j] = this.sink.RetVariable;
#endregion
#endregion
#region Check The Method Contracts
Bpl.RequiresSeq boogiePrecondition = new Bpl.RequiresSeq();
Bpl.EnsuresSeq boogiePostcondition = new Bpl.EnsuresSeq();
Bpl.IdentifierExprSeq boogieModifies = new Bpl.IdentifierExprSeq();
IMethodContract contract = ContractProvider.GetMethodContractFor(method);
if (contract != null) {
try {
foreach (IPrecondition pre in contract.Preconditions) {
ExpressionTraverser exptravers = this.factory.MakeExpressionTraverser(this.sink, null);
exptravers.Visit(pre.Condition); // TODO
// Todo: Deal with Descriptions
Bpl.Requires req
= new Bpl.Requires(pre.Token(),
true, exptravers.TranslatedExpressions.Pop(), "");
boogiePrecondition.Add(req);
}
foreach (IPostcondition post in contract.Postconditions) {
ExpressionTraverser exptravers = this.factory.MakeExpressionTraverser(this.sink, null);
exptravers.Visit(post.Condition);
// Todo: Deal with Descriptions
Bpl.Ensures ens =
new Bpl.Ensures(post.Token(),
true, exptravers.TranslatedExpressions.Pop(), "");
boogiePostcondition.Add(ens);
}
foreach (IAddressableExpression mod in contract.ModifiedVariables) {
ExpressionTraverser exptravers = this.factory.MakeExpressionTraverser(this.sink, null);
exptravers.Visit(mod);
Bpl.IdentifierExpr idexp = exptravers.TranslatedExpressions.Pop() as Bpl.IdentifierExpr;
if (idexp == null) {
throw new TranslationException(String.Format("Cannot create IdentifierExpr for Modifyed Variable {0}", mod.ToString()));
}
boogieModifies.Add(idexp);
}
} catch (TranslationException te) {
throw new NotImplementedException("Cannot Handle Errors in Method Contract: " + te.ToString());
} catch {
throw;
}
}
#endregion
string MethodName = TranslationHelper.CreateUniqueMethodName(method);
Bpl.Procedure proc = new Bpl.Procedure(method.Token(),
MethodName, // make it unique!
new Bpl.TypeVariableSeq(),
new Bpl.VariableSeq(invars), // in
new Bpl.VariableSeq(outvars), // out
boogiePrecondition,
boogieModifies,
boogiePostcondition);
this.sink.TranslatedProgram.TopLevelDeclarations.Add(proc);
if (method.IsAbstract) {
throw new NotImplementedException("abstract methods are not yet implemented");
}
StatementTraverser stmtTraverser = this.factory.MakeStatementTraverser(this.sink);
#region Add assignements from In-Params to local-Params
foreach (MethodParameter mparam in formalMap.Values) {
if (mparam.inParameterCopy != null) {
Bpl.IToken tok = method.Token();
stmtTraverser.StmtBuilder.Add(Bpl.Cmd.SimpleAssign(tok,
new Bpl.IdentifierExpr(tok, mparam.outParameterCopy),
new Bpl.IdentifierExpr(tok, mparam.inParameterCopy)));
}
}
#endregion
try {
method.ResolvedMethod.Body.Dispatch(stmtTraverser);
} catch (TranslationException te) {
throw new NotImplementedException("No Errorhandling in Methodvisitor / " + te.ToString());
} catch {
throw;
}
#region Create Local Vars For Implementation
List<Bpl.Variable> vars = new List<Bpl.Variable>();
foreach (MethodParameter mparam in formalMap.Values) {
if (!(mparam.underlyingParameter.IsByReference || mparam.underlyingParameter.IsOut))
vars.Add(mparam.outParameterCopy);
}
foreach (Bpl.Variable v in this.sink.LocalVarMap.Values) {
vars.Add(v);
}
Bpl.VariableSeq vseq = new Bpl.VariableSeq(vars.ToArray());
#endregion
Bpl.Implementation impl =
new Bpl.Implementation(method.Token(),
MethodName, // make unique
new Microsoft.Boogie.TypeVariableSeq(),
new Microsoft.Boogie.VariableSeq(invars),
new Microsoft.Boogie.VariableSeq(outvars),
vseq,
stmtTraverser.StmtBuilder.Collect(Bpl.Token.NoToken));
impl.Proc = proc;
this.sink.TranslatedProgram.TopLevelDeclarations.Add(impl);
} 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 void CreateCommutativityChecker(Program program, AtomicActionInfo first, AtomicActionInfo second)
{
if (first == second && first.thatInParams.Count == 0 && first.thatOutParams.Count == 0)
return;
if (first.CommutesWith(second))
return;
if (!commutativityCheckerCache.Add(new Tuple<AtomicActionInfo, AtomicActionInfo>(first, second)))
return;
List<Variable> inputs = Enumerable.Union(first.thatInParams, second.thisInParams).ToList();
List<Variable> outputs = Enumerable.Union(first.thatOutParams, second.thisOutParams).ToList();
List<Variable> locals = Enumerable.Union(first.thatAction.LocVars, second.thisAction.LocVars).ToList();
List<Block> firstBlocks = CloneBlocks(first.thatAction.Blocks);
List<Block> secondBlocks = CloneBlocks(second.thisAction.Blocks);
foreach (Block b in firstBlocks.Where(b => b.TransferCmd is ReturnCmd))
{
List<Block> bs = new List<Block> { secondBlocks[0] };
List<string> ls = new List<string> { secondBlocks[0].Label };
b.TransferCmd = new GotoCmd(Token.NoToken, ls, bs);
}
List<Block> blocks = Enumerable.Union(firstBlocks, secondBlocks).ToList();
HashSet<Variable> frame = new HashSet<Variable>();
frame.UnionWith(first.gateUsedGlobalVars);
frame.UnionWith(first.actionUsedGlobalVars);
frame.UnionWith(second.gateUsedGlobalVars);
frame.UnionWith(second.actionUsedGlobalVars);
List<Requires> requires = new List<Requires>();
requires.Add(DisjointnessRequires(program, first.thatInParams.Union(second.thisInParams), frame));
foreach (AssertCmd assertCmd in Enumerable.Union(first.thatGate, second.thisGate))
requires.Add(new Requires(false, assertCmd.Expr));
var transitionRelationComputation = new TransitionRelationComputation(program, first, second, frame, new HashSet<Variable>());
Expr transitionRelation = transitionRelationComputation.TransitionRelationCompute();
{
List<Block> bs = new List<Block> { blocks[0] };
List<string> ls = new List<string> { blocks[0].Label };
var initBlock = new Block(Token.NoToken, string.Format("{0}_{1}_init", first.proc.Name, second.proc.Name), transitionRelationComputation.TriggerAssumes(), new GotoCmd(Token.NoToken, ls, bs));
blocks.Insert(0, initBlock);
}
IEnumerable<Expr> linearityAssumes = DisjointnessExpr(program, first.thatOutParams.Union(second.thisInParams), frame).Union(DisjointnessExpr(program, first.thatOutParams.Union(second.thisOutParams), frame));
Ensures ensureCheck = new Ensures(false, Expr.Imp(Expr.And(linearityAssumes), transitionRelation));
ensureCheck.ErrorData = string.Format("Commutativity check between {0} and {1} failed", first.proc.Name, second.proc.Name);
List<Ensures> ensures = new List<Ensures> { ensureCheck };
string checkerName = string.Format("CommutativityChecker_{0}_{1}", first.proc.Name, second.proc.Name);
List<IdentifierExpr> globalVars = civlTypeChecker.SharedVariables.Select(x => Expr.Ident(x)).ToList();
Procedure proc = new Procedure(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, requires, globalVars, ensures);
Implementation impl = new Implementation(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, locals, blocks);
impl.Proc = proc;
this.decls.Add(impl);
this.decls.Add(proc);
}
public override Ensures VisitEnsures(Ensures ensures)
{
Contract.Ensures(Contract.Result<Ensures>() == ensures);
this.VisitExpr(ensures.Condition);
return ensures;
}
public override Ensures VisitEnsures(Ensures node)
{
Ensures ensures = base.VisitEnsures(node);
if (node.Free)
return ensures;
if (ensures.IsAtomicSpecification || QKeyValue.FindIntAttribute(ensures.Attributes, "phase", int.MaxValue) != phaseNum)
{
ensures.Condition = Expr.True;
ensures.Attributes = OwickiGries.RemoveMoverAttribute(ensures.Attributes);
}
return ensures;
}
private Cmd InlinedEnsures(CallCmd callCmd, Ensures ens) {
if (QKeyValue.FindBoolAttribute(ens.Attributes, "InlineAssume")) {
return new AssumeCmd(ens.tok, codeCopier.CopyExpr(ens.Condition));
} else if (ens.Free) {
return new AssumeCmd(ens.tok, Expr.True);
} else {
Ensures/*!*/ ensCopy = (Ensures/*!*/)cce.NonNull(ens.Clone());
ensCopy.Condition = codeCopier.CopyExpr(ens.Condition);
return new AssertEnsuresCmd(ensCopy);
}
}
public override Ensures VisitEnsures(Ensures ensures)
{
if (ensures.IsAtomicSpecification)
{
inAtomicSpecification = true;
Ensures ret = base.VisitEnsures(ensures);
inAtomicSpecification = false;
return ret;
}
int phaseNum = QKeyValue.FindIntAttribute(ensures.Attributes, "phase", int.MaxValue);
assertionPhaseNums.Add(phaseNum);
if (phaseNum > enclosingProcPhaseNum)
{
Error(ensures, "The phase of ensures clause cannot be greater than the phase of enclosing procedure");
}
return ensures;
}
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 Ensures VisitEnsures(Ensures ensures)
{
minLayerNum = int.MaxValue;
maxLayerNum = -1;
canAccessSharedVars = true;
Ensures ret = base.VisitEnsures(ensures);
canAccessSharedVars = false;
ActionInfo actionInfo = procToActionInfo[enclosingProc];
AtomicActionInfo atomicActionInfo = actionInfo as AtomicActionInfo;
if (atomicActionInfo != null && atomicActionInfo.ensures == ensures)
{
// This case has already been checked
}
else
{
CheckAndAddLayers(ensures, ensures.Attributes, actionInfo.createdAtLayerNum);
}
return ret;
}
private static MoverType GetMoverType(Ensures e)
{
if (QKeyValue.FindBoolAttribute(e.Attributes, "atomic"))
return MoverType.Atomic;
if (QKeyValue.FindBoolAttribute(e.Attributes, "right"))
return MoverType.Right;
if (QKeyValue.FindBoolAttribute(e.Attributes, "left"))
return MoverType.Left;
if (QKeyValue.FindBoolAttribute(e.Attributes, "both"))
return MoverType.Both;
return MoverType.Top;
}
public override Ensures VisitEnsures(Ensures node)
{
node.Attributes = RemoveLayerAttribute(node.Attributes);
return base.VisitEnsures(node);
}
public AssertEnsuresCmd(Ensures/*!*/ ens)
: base(ens.tok, ens.Condition)
{
Contract.Requires(ens != null);
this.Ensures = ens;
}
public override Ensures VisitEnsures(Ensures ensures)
{
ActionInfo actionInfo = procToActionInfo[enclosingProc];
AtomicActionInfo atomicActionInfo = actionInfo as AtomicActionInfo;
if (atomicActionInfo != null && atomicActionInfo.ensures == ensures)
{
// This case has already been checked
}
else
{
sharedVarsAccessed = new HashSet<Variable>();
Debug.Assert(introducedLocalVarsUpperBound == int.MinValue);
base.VisitEnsures(ensures);
CheckAndAddLayers(ensures, ensures.Attributes, actionInfo.createdAtLayerNum);
if (introducedLocalVarsUpperBound > Least(FindLayers(ensures.Attributes)))
{
Error(ensures, "An introduced local variable is accessed but not available");
}
introducedLocalVarsUpperBound = int.MinValue;
sharedVarsAccessed = null;
}
return ensures;
}
private static MoverType GetMoverType(Ensures e)
{
if (e.IsAtomic())
return MoverType.Atomic;
if (e.IsRight())
return MoverType.Right;
if (e.IsLeft())
return MoverType.Left;
if (e.IsBoth())
return MoverType.Both;
return MoverType.Top;
}
public override Ensures VisitEnsures(Ensures node)
{
CivlAttributes.RemoveLayerAttribute(node);
return base.VisitEnsures(node);
}
public override Ensures VisitEnsures(Ensures node)
{
Ensures ensures = base.VisitEnsures(node);
if (node.Free)
return ensures;
AtomicActionInfo atomicActionInfo = civlTypeChecker.procToActionInfo[enclosingProc] as AtomicActionInfo;
bool isAtomicSpecification = atomicActionInfo != null && atomicActionInfo.ensures == node;
if (isAtomicSpecification || !civlTypeChecker.absyToLayerNums[node].Contains(layerNum))
{
ensures.Condition = Expr.True;
ensures.Attributes = CivlRefinement.RemoveMoverAttribute(ensures.Attributes);
}
return ensures;
}
public virtual Ensures VisitEnsures(Ensures @ensures) {
Contract.Requires(@ensures != null);
Contract.Ensures(Contract.Result<Ensures>() != null);
@ensures.Condition = this.VisitExpr(@ensures.Condition);
return @ensures;
}
private void CreateFailurePreservationChecker(Program program, AtomicActionInfo first, AtomicActionInfo second)
{
if (first.gateUsedGlobalVars.Intersect(second.modifiedGlobalVars).Count() == 0)
return;
Tuple<AtomicActionInfo, AtomicActionInfo> actionPair = new Tuple<AtomicActionInfo, AtomicActionInfo>(first, second);
if (failurePreservationCheckerCache.Contains(actionPair))
return;
failurePreservationCheckerCache.Add(actionPair);
List<Variable> inputs = new List<Variable>();
inputs.AddRange(first.thatInParams);
inputs.AddRange(second.thisInParams);
List<Variable> outputs = new List<Variable>();
outputs.AddRange(first.thatOutParams);
outputs.AddRange(second.thisOutParams);
List<Variable> locals = new List<Variable>();
locals.AddRange(second.thisAction.LocVars);
List<Block> secondBlocks = CloneBlocks(second.thisAction.Blocks);
HashSet<Variable> frame = new HashSet<Variable>();
frame.UnionWith(first.gateUsedGlobalVars);
frame.UnionWith(second.gateUsedGlobalVars);
frame.UnionWith(second.actionUsedGlobalVars);
List<Requires> requires = DisjointnessRequires(program, first, second, frame);
Expr gateExpr = Expr.True;
foreach (AssertCmd assertCmd in first.thatGate)
{
gateExpr = Expr.And(gateExpr, assertCmd.Expr);
gateExpr.Type = Type.Bool;
}
gateExpr = Expr.Not(gateExpr);
gateExpr.Type = Type.Bool;
requires.Add(new Requires(false, gateExpr));
List<Ensures> ensures = new List<Ensures>();
Ensures ensureCheck = new Ensures(false, gateExpr);
ensureCheck.ErrorData = string.Format("Gate failure of {0} not preserved by {1}", first.proc.Name, second.proc.Name);
ensures.Add(ensureCheck);
foreach (AssertCmd assertCmd in second.thisGate)
requires.Add(new Requires(false, assertCmd.Expr));
string checkerName = string.Format("FailurePreservationChecker_{0}_{1}", first.proc.Name, second.proc.Name);
List<IdentifierExpr> globalVars = new List<IdentifierExpr>();
civlTypeChecker.SharedVariables.Iter(x => globalVars.Add(Expr.Ident(x)));
Procedure proc = new Procedure(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, requires, globalVars, ensures);
Implementation impl = new Implementation(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, locals, secondBlocks);
impl.Proc = proc;
this.decls.Add(impl);
this.decls.Add(proc);
}
public override Ensures VisitEnsures(Ensures ensures)
{
return ensures;
}
private void EmitProcSpec(TokenTextWriter twr, Procedure proc, StratifiedInliningInfo info, RPFP.Transformer annot)
{
// last ensures clause will be the symbolic one
if (!info.isMain)
{
var ens = proc.Ensures[proc.Ensures.Count - 1];
if (ens.Condition != Expr.False) // this is main
{
var postExpr = ens.Condition as NAryExpr;
var args = postExpr.Args;
var ind = annot.IndParams;
var bound = new Dictionary<VCExpr, Expr>();
for (int i = 0; i < args.Count; i++)
{
bound[ind[i]] = args[i];
}
var new_ens_cond = VCExprToExpr(annot.Formula, bound);
if (new_ens_cond != Expr.True)
{
var new_ens = new Ensures(false, new_ens_cond);
var enslist = new List<Ensures>();
enslist.Add(new_ens);
var new_proc = new Procedure(proc.tok, proc.Name, proc.TypeParameters, proc.InParams,
proc.OutParams, new List<Requires>(), new List<IdentifierExpr>(), enslist);
new_proc.Emit(twr, 0);
}
}
}
}
public override Ensures VisitEnsures(Ensures node)
{
//Contract.Requires(node != null);
Contract.Ensures(Contract.Result<Ensures>() != null);
return base.VisitEnsures((Ensures)node.Clone());
}
private void CreateCommutativityChecker(Program program, AtomicActionInfo first, AtomicActionInfo second)
{
if (first == second && first.thatInParams.Count == 0 && first.thatOutParams.Count == 0)
return;
if (first.CommutesWith(second))
return;
Tuple<AtomicActionInfo, AtomicActionInfo> actionPair = new Tuple<AtomicActionInfo, AtomicActionInfo>(first, second);
if (commutativityCheckerCache.Contains(actionPair))
return;
commutativityCheckerCache.Add(actionPair);
List<Variable> inputs = new List<Variable>();
inputs.AddRange(first.thatInParams);
inputs.AddRange(second.thisInParams);
List<Variable> outputs = new List<Variable>();
outputs.AddRange(first.thatOutParams);
outputs.AddRange(second.thisOutParams);
List<Variable> locals = new List<Variable>();
locals.AddRange(first.thatAction.LocVars);
locals.AddRange(second.thisAction.LocVars);
List<Block> firstBlocks = CloneBlocks(first.thatAction.Blocks);
List<Block> secondBlocks = CloneBlocks(second.thisAction.Blocks);
foreach (Block b in firstBlocks)
{
if (b.TransferCmd is ReturnCmd)
{
List<Block> bs = new List<Block>();
bs.Add(secondBlocks[0]);
List<string> ls = new List<string>();
ls.Add(secondBlocks[0].Label);
b.TransferCmd = new GotoCmd(Token.NoToken, ls, bs);
}
}
List<Block> blocks = new List<Block>();
blocks.AddRange(firstBlocks);
blocks.AddRange(secondBlocks);
HashSet<Variable> frame = new HashSet<Variable>();
frame.UnionWith(first.gateUsedGlobalVars);
frame.UnionWith(first.actionUsedGlobalVars);
frame.UnionWith(second.gateUsedGlobalVars);
frame.UnionWith(second.actionUsedGlobalVars);
List<Requires> requires = DisjointnessRequires(program, first, second, frame);
foreach (AssertCmd assertCmd in first.thatGate)
requires.Add(new Requires(false, assertCmd.Expr));
foreach (AssertCmd assertCmd in second.thisGate)
requires.Add(new Requires(false, assertCmd.Expr));
List<Ensures> ensures = new List<Ensures>();
Expr transitionRelation = (new TransitionRelationComputation(program, first, second, frame, new HashSet<Variable>())).TransitionRelationCompute();
Ensures ensureCheck = new Ensures(false, transitionRelation);
ensureCheck.ErrorData = string.Format("Commutativity check between {0} and {1} failed", first.proc.Name, second.proc.Name);
ensures.Add(ensureCheck);
string checkerName = string.Format("CommutativityChecker_{0}_{1}", first.proc.Name, second.proc.Name);
List<IdentifierExpr> globalVars = new List<IdentifierExpr>();
civlTypeChecker.SharedVariables.Iter(x => globalVars.Add(Expr.Ident(x)));
Procedure proc = new Procedure(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, requires, globalVars, ensures);
Implementation impl = new Implementation(Token.NoToken, checkerName, new List<TypeVariable>(), inputs, outputs, locals, blocks);
impl.Proc = proc;
this.decls.Add(impl);
this.decls.Add(proc);
}
