private void TryElimination(IEnumerable <Variable> extraDefinedVariables)
{
bool Defined(Variable v) => varToExpr.ContainsKey(v) || extraDefinedVariables.Contains(v);
bool changed;
do
{
changed = false;
var remainingAssignments = new List <Assignment>();
foreach (var assignment in assignments)
{
if (!Defined(assignment.Var) &&
VariableCollector.Collect(assignment.Expr).
Intersect(AllIntroducedVariables).All(Defined))
{
varToExpr[assignment.Var] = SubstitutionHelper.Apply(varToExpr, assignment.Expr);
changed = true;
}
else
{
remainingAssignments.Add(assignment);
}
}
Substitution sub = Substituter.SubstitutionFromHashtable(varToExpr);
foreach (var assignment in remainingAssignments)
{
assignment.Expr = Substituter.Apply(sub, assignment.Expr);
}
assignments = remainingAssignments;
assumes = SubstitutionHelper.Apply(sub, assumes).ToList();
} while (changed);
}
private HashSet <VariableDescriptor> GetControlDependencyVariables(string proc, Block b)
{
// This method works under the assumption that assume statements
// relevant to control flow between basic blocks have the "partition" attribute
HashSet <VariableDescriptor> result = new HashSet <VariableDescriptor>();
var gotoCmd = b.TransferCmd as GotoCmd;
if (gotoCmd != null && gotoCmd.labelTargets.Count >= 2)
{
foreach (Block succ in gotoCmd.labelTargets)
{
foreach (Cmd c in succ.Cmds)
{
AssumeCmd a = c as AssumeCmd;
if (a != null && QKeyValue.FindBoolAttribute(a.Attributes, "partition"))
{
var VarCollector = new VariableCollector();
VarCollector.VisitExpr(a.Expr);
result.UnionWith(VarCollector.usedVars.Where(Item => VariableRelevantToAnalysis(Item, proc)).
Select(Item => MakeDescriptor(proc, Item)));
}
else
{
break;
}
}
}
}
return(result);
}
private static void SubstituteBackwardAssignments(AtomicAction action)
{
foreach (Block block in action.impl.Blocks)
{
List <Cmd> cmds = new List <Cmd>();
foreach (Cmd cmd in block.cmds)
{
if (cmd is AssignCmd _assignCmd &&
QKeyValue.FindBoolAttribute(_assignCmd.Attributes, CivlAttributes.BACKWARD))
{
AssignCmd assignCmd = _assignCmd.AsSimpleAssignCmd;
var lhss = assignCmd.Lhss;
var rhss = assignCmd.Rhss;
var rhssVars = rhss.SelectMany(x => VariableCollector.Collect(x));
var lhssVars = lhss.SelectMany(x => VariableCollector.Collect(x));
if (rhssVars.Intersect(lhssVars).Any())
{
// TODO
throw new NotImplementedException("Substitution of backward assignment where lhs appears on rhs");
}
else
{
List <Expr> assumeExprs = new List <Expr>();
for (int k = 0; k < lhss.Count; k++)
{
assumeExprs.Add(Expr.Eq(lhss[k].AsExpr, rhss[k]));
}
cmds.Add(new AssumeCmd(Token.NoToken, Expr.And(assumeExprs)));
cmds.Add(new HavocCmd(Token.NoToken, lhss.Select(x => x.DeepAssignedIdentifier).ToList()));
}
}
public EPModuleVariableInitServicesImpl(
VariableCollector variableCollector,
EventTypeResolver eventTypeResolver)
{
VariableCollector = variableCollector;
EventTypeResolver = eventTypeResolver;
}
public AtomicAction(Procedure proc, Implementation impl, MoverType moverType, LayerRange layerRange)
{
this.proc = proc;
this.impl = impl;
this.moverType = moverType;
this.layerRange = layerRange;
CivlUtil.AddInlineAttribute(proc);
CivlUtil.AddInlineAttribute(impl);
// The gate of an atomic action is represented as asserts at the beginning of the procedure body.
this.gate = impl.Blocks[0].cmds.TakeWhile((c, i) => c is AssertCmd).Cast <AssertCmd>().ToList();
impl.Blocks[0].cmds.RemoveRange(0, gate.Count);
gateUsedGlobalVars = new HashSet <Variable>(VariableCollector.Collect(gate).Where(x => x is GlobalVariable));
actionUsedGlobalVars = new HashSet <Variable>(VariableCollector.Collect(impl).Where(x => x is GlobalVariable));
modifiedGlobalVars = new HashSet <Variable>(AssignedVariables().Where(x => x is GlobalVariable));
// We usually declare the Boogie procedure and implementation of an atomic action together.
// Since Boogie only stores the supplied attributes (in particular linearity) in the procedure parameters,
// we copy them into the implementation parameters here.
for (int i = 0; i < proc.InParams.Count; i++)
{
impl.InParams[i].Attributes = proc.InParams[i].Attributes;
}
for (int i = 0; i < proc.OutParams.Count; i++)
{
impl.OutParams[i].Attributes = proc.OutParams[i].Attributes;
}
AtomicActionDuplicator.SetupCopy(this, ref firstGate, ref firstImpl, "first_");
AtomicActionDuplicator.SetupCopy(this, ref secondGate, ref secondImpl, "second_");
DeclareTriggerFunctions();
}
private bool OnlyRefersToConstants(Expr e)
{
VariableCollector vc = new VariableCollector();
vc.Visit(e);
return(vc.usedVars.OfType <Constant>().Count() == vc.usedVars.Count());
}
private IEnumerable <VariableDescriptor> GetReferencedVariables(Absy node, string proc)
{
var VarCollector = new VariableCollector();
VarCollector.Visit(node);
return(VarCollector.usedVars.Where(Item => VariableRelevantToAnalysis(Item, proc)).
Select(Item => MakeDescriptor(proc, Item)));
}
public override Expr VisitIdentifierExpr(IdentifierExpr node)
{
VariableCollector vc = new VariableCollector();
vc.Visit(node);
var existConsts = vc.usedVars.Where(x => QKeyValue.FindBoolAttribute(x.Attributes, "existential"));
existConsts.Iter(x => usedExistentialConstants.Add(x));
return(base.VisitIdentifierExpr(node));
}
public override Expr VisitExpr(Expr node)
{
if (node is NAryExpr nary &&
nary.Fun is BinaryOperator op &&
op.Op == BinaryOperator.Opcode.Eq &&
VariableCollector.Collect(node).Contains(choice))
{
return(Expr.True);
}
return(base.VisitExpr(node));
}
public FOLKnowledgeBase(FOLDomain domain, InferenceProcedure inferenceProcedure, Unifier unifier)
{
this.parser = new FOLParser(new FOLDomain(domain));
this.inferenceProcedure = inferenceProcedure;
this.unifier = unifier;
//
this.substVisitor = new SubstVisitor();
this.variableCollector = new VariableCollector();
this._standardizeApart = new StandardizeApart(variableCollector, substVisitor);
this.cnfConverter = new CNFConverter(parser);
}
private void propagateInfosToRefinedLocations(AssumePoint p)
{
var visitor = new VariableCollector();
p.Condition.Parts.First().SourceElement.VisitMe(visitor);
var variables = visitor.Variables;
foreach (var variable in variables)
{
copyInfoFromInToOutSnapshot(variable, p, p.Log);
}
}
private void checkDefiniteVariablesInAssumption(AssumePoint p)
{
foreach (var conditionPart in p.Condition.Parts)
{
var visitor = new VariableCollector();
conditionPart.SourceElement.VisitMe(visitor);
var variables = visitor.Variables;
foreach (var variable in variables)
{
checkDefiniteVariableInAssumption(variable, p);
}
}
}
private void MergeIgnoredAnnotations()
{
var IgnoredAnnotationsToVariables = new Dictionary <string, HashSet <Variable> >();
foreach (var c in AllAnnotationIdentifiers())
{
IgnoredAnnotationsToVariables[c] = new HashSet <Variable>();
}
foreach (var ci in AnnotationInstances())
{
if (!IgnoredAnnotationsToVariables.ContainsKey(ci.AnnotationIdentifier))
{
continue;
}
VariableCollector vc = new VariableCollector();
vc.Visit(ci.Expr);
if (vc.usedVars.Select(Item => varDepAnalyser.VariableRelevantToAnalysis(Item, ci.Proc)).Count() != 0)
{
continue;
}
foreach (var v in vc.usedVars)
{
if (varDepAnalyser.Ignoring(v, ci.Proc))
{
IgnoredAnnotationsToVariables[ci.AnnotationIdentifier].Add(v);
}
}
}
foreach (var c in IgnoredAnnotationsToVariables.Keys)
{
foreach (var d in IgnoredAnnotationsToVariables.Keys)
{
if (c == d)
{
continue;
}
if (IgnoredAnnotationsToVariables[c].Equals(IgnoredAnnotationsToVariables[d]))
{
AnnotationDependences.AddEdge(c, d);
}
}
}
}
private bool TryElimination(IEnumerable <Variable> extraDefinedVariables)
{
bool changed = false;
var remainingCmds = new List <Cmd>();
foreach (var cmd in newCmds)
{
if (cmd is AssignCmd assignCmd)
{
var lhss = new List <AssignLhs>();
var rhss = new List <Expr>();
for (int k = 0; k < assignCmd.Lhss.Count; k++)
{
var lhs = assignCmd.Lhss[k];
var rhs = assignCmd.Rhss[k];
Variable assignedVar = lhs.DeepAssignedVariable;
var allDefinedVars = varToExpr.Keys.Union(extraDefinedVariables);
if (!allDefinedVars.Contains(assignedVar) &&
!VariableCollector.Collect(rhs).Intersect(AllIntroducedVariables).
Except(allDefinedVars).Any())
{
varToExpr[assignedVar] = rhs;
changed = true;
}
else
{
lhss.Add(lhs);
rhss.Add(rhs);
}
}
if (lhss.Any())
{
remainingCmds.Add(new AssignCmd(cmd.tok, lhss, rhss, assignCmd.Attributes));
}
}
else if (cmd is AssumeCmd)
{
remainingCmds.Add(cmd);
}
}
Substitution sub = Substituter.SubstitutionFromHashtable(varToExpr);
newCmds = remainingCmds.Select(cmd => ApplyOnRhss(sub, cmd)).ToList();
return(changed);
}
private HashSet <VariableDescriptor> UsedVars(Expr e)
{
VariableCollector vc = new VariableCollector();
vc.Visit(e);
HashSet <VariableDescriptor> result = new HashSet <VariableDescriptor>();
foreach (var v in vc.usedVars)
{
var vd = MakeDescriptor(v);
if (vd != null)
{
result.Add(vd);
}
}
return(result);
}
public Tuple <string, IEnumerable <LemmaDecl> > GenerateTactic(Expr e)
{
var varCollector = new VariableCollector();
varCollector.Visit(e);
var lookupTyThms = new List <string>();
var funMemThms = new List <string>();
foreach (var v in varCollector.usedVars)
{
try
{
lookupTyThms.Add(programAccessor.LookupVarTyLemma(v));
}
catch
{
//variable not found, possible if, for example, v is bound
}
}
var usedFuncs = functionCollector.UsedFunctions(e);
foreach (var f in usedFuncs)
{
funMemThms.Add(programAccessor.MembershipLemma(f));
}
var hintLemmas = equalityHintGenerator.GetHints(e);
var hintsML = MLUtil.IsaToMLThms(hintLemmas.Select(lemma => lemma.Name));
var lookupTyML = MLUtil.IsaToMLThms(lookupTyThms);
var funMemML = MLUtil.IsaToMLThms(funMemThms);
var args = new List <string>
{
MLUtil.ContextAntiquotation(),
hintsML,
lookupTyML,
funMemML
};
var tactic = ProofUtil.Apply(ProofUtil.MLTactic("typing_tac " + string.Join(" ", args), 1));
return(Tuple.Create(tactic, hintLemmas));
}
private void PendingPropagate(HashSet <Variable> allExistsVars, Dictionary <Variable, Expr> existsSubstitutionMap, Variable eVar, Expr eVarSubstExpr, Dictionary <Variable, Expr> pendingMap)
{
var usedExistsVars = VariableCollector.Collect(eVarSubstExpr).Intersect(allExistsVars);
if (usedExistsVars.Count() == 0)
{
existsSubstitutionMap[eVar] = eVarSubstExpr;
}
else if (usedExistsVars.Except(existsSubstitutionMap.Keys).Count() == 0)
{
Substitution subst = Substituter.SubstitutionFromHashtable(existsSubstitutionMap);
existsSubstitutionMap[eVar] = Substituter.Apply(subst, eVarSubstExpr);
}
else
{
pendingMap[eVar] = eVarSubstExpr;
}
}
public override Expr VisitNAryExpr(NAryExpr node)
{
if (node.Fun is FunctionCall)
{
var collector = new VariableCollector();
collector.Visit(node);
if (existentialExpr != null && existentialExpr.Dummies.Intersect(collector.usedVars).Any())
{
functionsUsed.Add(Tuple.Create((node.Fun as FunctionCall).Func, existentialExpr));
}
else
{
functionsUsed.Add(Tuple.Create <Function, ExistsExpr>((node.Fun as FunctionCall).Func, null));
}
}
return(base.VisitNAryExpr(node));
}
private void AddDependences(AnnotationInstance ci)
{
VariableCollector vc = new VariableCollector();
vc.VisitExpr(ci.Expr);
foreach (var v in vc.usedVars.Where(Item => varDepAnalyser.VariableRelevantToAnalysis(Item, ci.Proc)))
{
VariableDescriptor vd =
varDepAnalyser.MakeDescriptor(ci.Proc, v);
if (!variableDirectlyReferredToByAnnotations.ContainsKey(vd))
{
variableDirectlyReferredToByAnnotations[vd] = new HashSet <string>();
}
variableDirectlyReferredToByAnnotations[vd].Add(ci.AnnotationIdentifier);
foreach (var w in varDepAnalyser.DependsOn(vd))
{
annotationDependsOn[ci.AnnotationIdentifier].Add(w);
}
}
}
private static void PropagateCall(CallCmd cc, HashSet <Variable> liveVarsAfter, Program program)
{
// globals U in-params U (after - out-params)
cc.Outs.Where(ie => ie != null).Iter(ie => liveVarsAfter.Remove(ie.Decl));
if (program != null)
{
program.TopLevelDeclarations
.OfType <GlobalVariable>()
.Iter(v => liveVarsAfter.Add(v));
}
VariableCollector /*!*/ collector = new VariableCollector();
cc.Ins.Where(e => e != null).Iter(e => collector.Visit(e));
if (program == null)
{
liveVarsAfter.UnionWith(collector.usedVars.Where(v => v is LocalVariable || v is Formal));
}
else
{
liveVarsAfter.UnionWith(collector.usedVars);
}
}
private static void UpdateLiveSet(Cmd cmd, HashSet <Variable> liveVars)
{
if (cmd is AssignCmd assignCmd)
{
foreach (var lhs in assignCmd.Lhss)
{
liveVars.Remove(lhs.DeepAssignedVariable);
}
foreach (var rhs in assignCmd.Rhss)
{
var collector = new VariableCollector();
collector.Visit(rhs);
//we neglect that the corresponding lhs may be dead
liveVars.UnionWith(collector.usedVars);
}
}
else if (cmd is HavocCmd havocCmd)
{
foreach (var ie in havocCmd.Vars)
{
liveVars.Remove(ie.Decl);
}
}
else if (cmd is PredicateCmd predicateCmd)
{
//live set is not cleared when reaching "assert false" or "assume false"
var collector = new VariableCollector();
collector.Visit(predicateCmd.Expr);
liveVars.UnionWith(collector.usedVars);
}
else
{
throw new ProofGenUnexpectedStateException(
"Unsupported command in program right before passification.");
}
}
private void AddDependences(CandidateInstance ci)
{
VariableCollector vc = new VariableCollector();
vc.VisitExpr(ci.Expr);
foreach (var v in vc.usedVars.Where(Item => varDepAnalyser.VariableRelevantToAnalysis(Item, ci.Proc))) {
VariableDescriptor vd =
varDepAnalyser.MakeDescriptor(ci.Proc, v);
if (!variableDirectlyReferredToByCandidates.ContainsKey(vd)) {
variableDirectlyReferredToByCandidates[vd] = new HashSet<string>();
}
variableDirectlyReferredToByCandidates[vd].Add(ci.Candidate);
foreach (var w in varDepAnalyser.DependsOn(vd)) {
candidateDependsOn[ci.Candidate].Add(w);
}
}
}
private bool OnlyRefersToConstants(Expr e) {
VariableCollector vc = new VariableCollector();
vc.Visit(e);
return vc.usedVars.OfType<Constant>().Count() == vc.usedVars.Count();
}
private void MergeIgnoredCandidates()
{
var IgnoredCandidatesToVariables = new Dictionary<string, HashSet<Variable>>();
foreach(var c in candidates) {
IgnoredCandidatesToVariables[c] = new HashSet<Variable>();
}
foreach(var ci in CandidateInstances()) {
if(!IgnoredCandidatesToVariables.ContainsKey(ci.Candidate)) {
continue;
}
VariableCollector vc = new VariableCollector();
vc.Visit(ci.Expr);
if(vc.usedVars.Select(Item => varDepAnalyser.VariableRelevantToAnalysis(Item, ci.Proc)).Count() != 0) {
continue;
}
foreach(var v in vc.usedVars) {
if(varDepAnalyser.Ignoring(v, ci.Proc)) {
IgnoredCandidatesToVariables[ci.Candidate].Add(v);
}
}
}
foreach(var c in IgnoredCandidatesToVariables.Keys) {
foreach(var d in IgnoredCandidatesToVariables.Keys) {
if(c == d) {
continue;
}
if(IgnoredCandidatesToVariables[c].Equals(IgnoredCandidatesToVariables[d])) {
CandidateDependences.AddEdge(c, d);
}
}
}
}
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>();
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));
}
}
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 void setUp()
{
parser = new FOLParser(DomainFactory.crusadesDomain());
vc = new VariableCollector();
}
private Expr CalculatePathCondition(PathInfo path)
{
HashSet <Variable> allExistsVars = new HashSet <Variable>(firstExistsVars.Union(secondExistsVars));
HashSet <Variable> usedExistsVars = new HashSet <Variable>();
Dictionary <Variable, Expr> existsSubstitutionMap = new Dictionary <Variable, Expr>();
List <Expr> inferredSelectEqualities = new List <Expr>();
foreach (Variable v in path.varToExpr.Keys.Except(postExistVars))
{
var expr = path.varToExpr[v];
usedExistsVars.UnionWith(VariableCollector.Collect(expr).Intersect(allExistsVars));
IdentifierExpr ie = expr as IdentifierExpr;
if (ie != null && IsExistsVar(ie.Decl) && !existsSubstitutionMap.ContainsKey(ie.Decl))
{
existsSubstitutionMap[ie.Decl] = Expr.Ident(v);
}
else if (IsMapStoreExpr(expr))
{
inferredSelectEqualities.Add(GenerateEqualityWithSelect(expr as NAryExpr, Expr.Ident(v)));
}
}
foreach (Expr expr in path.pathExprs)
{
usedExistsVars.UnionWith(VariableCollector.Collect(expr).Intersect(allExistsVars));
}
InferSubstitution(allExistsVars, existsSubstitutionMap, path.pathExprs, inferredSelectEqualities);
List <Expr> triggerExprs = new List <Expr>();
List <Variable> quantifiedVars = new List <Variable>();
foreach (var v in usedExistsVars.Except(existsSubstitutionMap.Keys))
{
var triggerFun = TriggerFunction(v); // this call populates existsVars[v]
var quantifiedVar = existsVars[v];
triggerExprs.Add(
new NAryExpr(Token.NoToken,
new FunctionCall(triggerFun),
new Expr[] { Expr.Ident(quantifiedVar) }));
quantifiedVars.Add(quantifiedVar);
existsSubstitutionMap[v] = Expr.Ident(quantifiedVar);
}
Substitution subst = Substituter.SubstitutionFromHashtable(existsSubstitutionMap);
List <Expr> returnExprs = new List <Expr>();
foreach (Variable v in path.varToExpr.Keys.Except(postExistVars))
{
Expr withOldExpr = MyDuplicator.Duplicate(path.varToExpr[v]);
var substExpr = Expr.Eq(Expr.Ident(v), Substituter.Apply(subst, withOldExpr));
substExpr.Type = Type.Bool;
returnExprs.Add(substExpr);
}
foreach (Expr x in path.pathExprs)
{
var withOldExpr = MyDuplicator.Duplicate(x);
returnExprs.Add(Substituter.Apply(subst, withOldExpr));
}
var returnExpr = Expr.And(returnExprs);
if (quantifiedVars.Count > 0)
{
if (first == null)
{
returnExpr = new ExistsExpr(Token.NoToken, quantifiedVars, returnExpr);
}
else
{
returnExpr = new ExistsExpr(Token.NoToken,
quantifiedVars,
new Trigger(Token.NoToken, true, triggerExprs),
returnExpr);
}
}
return(returnExpr);
}
// perform in place update of liveSet
public static void Propagate(Cmd cmd, HashSet <Variable /*!*/> /*!*/ liveSet, bool allGlobalsAreLive)
{
Contract.Requires(cmd != null);
Contract.Requires(cce.NonNullElements(liveSet));
if (cmd is AssignCmd)
{
AssignCmd /*!*/ assignCmd = (AssignCmd)cce.NonNull(cmd);
// I must first iterate over all the targets and remove the live ones.
// After the removals are done, I must add the variables referred on
// the right side of the removed targets
AssignCmd simpleAssignCmd = assignCmd.AsSimpleAssignCmd;
HashSet <int> indexSet = new HashSet <int>();
int index = 0;
foreach (AssignLhs /*!*/ lhs in simpleAssignCmd.Lhss)
{
Contract.Assert(lhs != null);
SimpleAssignLhs salhs = lhs as SimpleAssignLhs;
Contract.Assert(salhs != null);
Variable var = salhs.DeepAssignedVariable;
if (var != null && (liveSet.Contains(var) || (allGlobalsAreLive && var is GlobalVariable)))
{
indexSet.Add(index);
liveSet.Remove(var);
}
index++;
}
index = 0;
foreach (Expr /*!*/ expr in simpleAssignCmd.Rhss)
{
Contract.Assert(expr != null);
if (indexSet.Contains(index))
{
VariableCollector /*!*/ collector = new VariableCollector();
collector.Visit(expr);
if (allGlobalsAreLive)
{
liveSet.UnionWith(collector.usedVars.Where(v => v is LocalVariable || v is Formal));
}
else
{
liveSet.UnionWith(collector.usedVars);
}
}
index++;
}
}
else if (cmd is HavocCmd)
{
HavocCmd /*!*/ havocCmd = (HavocCmd)cmd;
foreach (IdentifierExpr /*!*/ expr in havocCmd.Vars)
{
Contract.Assert(expr != null);
if (expr.Decl != null)
{
liveSet.Remove(expr.Decl);
}
}
}
else if (cmd is PredicateCmd)
{
Contract.Assert((cmd is AssertCmd || cmd is AssumeCmd));
PredicateCmd /*!*/ predicateCmd = (PredicateCmd)cce.NonNull(cmd);
if (predicateCmd.Expr is LiteralExpr)
{
LiteralExpr le = (LiteralExpr)predicateCmd.Expr;
if (le.IsFalse)
{
liveSet.Clear();
}
}
else
{
VariableCollector /*!*/ collector = new VariableCollector();
collector.Visit(predicateCmd.Expr);
if (allGlobalsAreLive)
{
liveSet.UnionWith(collector.usedVars.Where(v => v is LocalVariable || v is Formal));
}
else
{
liveSet.UnionWith(collector.usedVars);
}
}
}
else if (cmd is CommentCmd)
{
// comments are just for debugging and don't affect verification
}
else if (cmd is SugaredCmd)
{
SugaredCmd /*!*/ sugCmd = (SugaredCmd)cce.NonNull(cmd);
Propagate(sugCmd.Desugaring, liveSet, allGlobalsAreLive);
}
else if (cmd is StateCmd)
{
StateCmd /*!*/ stCmd = (StateCmd)cce.NonNull(cmd);
List <Cmd> /*!*/ cmds = cce.NonNull(stCmd.Cmds);
int len = cmds.Count;
for (int i = len - 1; i >= 0; i--)
{
Propagate(cmds[i], liveSet, allGlobalsAreLive);
}
foreach (Variable /*!*/ v in stCmd.Locals)
{
Contract.Assert(v != null);
liveSet.Remove(v);
}
}
else
{
{
Contract.Assert(false);
throw new cce.UnreachableException();
}
}
}
