public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
node.InParams = this.VisitVariableSeq(node.InParams);
node.OutParams = this.VisitVariableSeq(node.OutParams);
if (node is Function)
{
node = this.VisitFunction((Function)node);
}
else if (node is Implementation)
{
node = this.VisitImplementation((Implementation)node);
}
else if (node is Procedure)
{
node = this.VisitProcedure((Procedure)node);
}
else
{
node.Emit(new TokenTextWriter(Console.Out), 0);
throw new InvalidInput("Unknown declaration type");
}
return(node);
}
public override Function VisitFunction(Function node)
{
currentDeclaration = node;
if (node.DefinitionAxiom != null)
{
VisitAxiom(node.DefinitionAxiom);
}
if (node.OtherDefinitionAxioms != null)
{
foreach (var a in node.OtherDefinitionAxioms)
{
if (a != node.DefinitionAxiom)
{
VisitAxiom(a);
}
}
}
var result = base.VisitFunction(node);
node.DependenciesCollected = true;
currentDeclaration = null;
return(result);
}
public void AddProcedure(DeclWithFormals proc)
{
Contract.Requires(proc != null);
Contract.Requires(proc.Name != null);
string name = proc.Name;
var previous = (DeclWithFormals)funcdures[name];
if (previous == null)
{
funcdures.Add(name, proc);
}
else
{
var r = (DeclWithFormals)SelectNonExtern(proc, previous);
if (r == null)
{
Error(proc, "more than one declaration of function/procedure name: {0}", name);
}
else
{
funcdures[name] = r;
}
}
}
public virtual DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
Contract.Requires(node != null);
Contract.Ensures(Contract.Result <DeclWithFormals>() != null);
node.InParams = this.VisitVariableSeq(node.InParams);
node.OutParams = this.VisitVariableSeq(node.OutParams);
return(node);
}
public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
if (node.TypeParameters.Count > 0)
{
isMonomorphic = false;
}
return(base.VisitDeclWithFormals(node));
}
private void Instrument(DeclWithFormals dwf)
{
foreach (var rule in _rules)
{
foreach (var procSig in rule.ProcedureToMatchToInsertion.Keys)
{
// match references attribute
bool matchPtrs = QKeyValue.FindBoolAttribute(procSig.Attributes, ExprMatchVisitor.BoogieKeyWords.MatchPtrs);
int anyParamsPosition;
QKeyValue anyParamsAttributes;
int anyParamsPositionOut;
QKeyValue anyParamsAttributesOut;
Dictionary <Declaration, Expr> paramSubstitution;
if (ProcedureSigMatcher.MatchSig(procSig, dwf, _program, out anyParamsAttributes, out anyParamsPosition, out anyParamsAttributesOut, out anyParamsPositionOut, out paramSubstitution, matchPtrs))
{
Implementation impl = null;
if (dwf is Implementation)
{
impl = (Implementation)dwf;
}
else if (dwf is Procedure)
{
var proc = (Procedure)dwf;
var newInParams = new List <Variable>();
foreach (var v in proc.InParams)
{
newInParams.Add(new LocalVariable(v.tok, v.TypedIdent));
}
var newOutParams = new List <Variable>();
foreach (var v in proc.OutParams)
{
newOutParams.Add(new LocalVariable(v.tok, v.TypedIdent));
}
impl = new Implementation(proc.tok, proc.Name, proc.TypeParameters, newInParams, newOutParams, new List <Variable>(), new List <Block>());
impl.Proc = proc;
//_program.AddTopLevelDeclaration(impl);
}
InjectCode(impl, anyParamsPosition, anyParamsAttributes, anyParamsPositionOut, anyParamsAttributesOut, procSig, rule, paramSubstitution);
if (dwf is Procedure && impl.Blocks.Count > 0)
{
_program.AddTopLevelDeclaration(impl);
}
//TODO: sig matching is broken, so is the stat
Stats.count("Times " + PropertyKeyWords.ProcedureRule + " injected code");
//only take the first match
return;
}
}
}
}
private void Instrument(DeclWithFormals dwf)
{
foreach (var rule in _rules)
{
foreach (var procSig in rule.ProcedureToMatchToInsertion.Keys)
{
int anyParamsPosition;
QKeyValue anyParamsAttributes;
int anyParamsPositionOut;
QKeyValue anyParamsAttributesOut;
Dictionary <Declaration, Expr> paramSubstitution;
if (ProcedureSigMatcher.MatchSig(procSig, dwf, _program, out anyParamsAttributes, out anyParamsPosition, out anyParamsAttributesOut, out anyParamsPositionOut, out paramSubstitution))
{
Implementation impl = null;
if (dwf is Implementation)
{
impl = (Implementation)dwf;
}
else if (dwf is Procedure)
{
var proc = (Procedure)dwf;
var newInParams = new List <Variable>();
foreach (var v in proc.InParams)
{
newInParams.Add(new LocalVariable(v.tok, v.TypedIdent));
}
var newOutParams = new List <Variable>();
foreach (var v in proc.OutParams)
{
newOutParams.Add(new LocalVariable(v.tok, v.TypedIdent));
}
impl = new Implementation(proc.tok, proc.Name, proc.TypeParameters, newInParams, newOutParams, new List <Variable>(), new List <Block>());
_program.AddTopLevelDeclaration(impl);
}
InjectCode(impl, anyParamsPosition, anyParamsAttributes, anyParamsPositionOut, anyParamsAttributesOut, procSig, rule, paramSubstitution);
Stats.count("Times " + PropertyKeyWords.ProcedureRule + " injected code");
//only take the first match
return;
}
}
}
}
public override Procedure VisitProcedure(Procedure node)
{
currentDeclaration = node;
foreach (var param in node.InParams)
{
if (param.TypedIdent != null && param.TypedIdent.WhereExpr != null)
{
VisitExpr(param.TypedIdent.WhereExpr);
}
}
var result = base.VisitProcedure(node);
node.DependenciesCollected = true;
currentDeclaration = null;
return(result);
}
public override Implementation VisitImplementation(Implementation node)
{
currentDeclaration = node;
foreach (var param in node.InParams)
{
if (param.TypedIdent != null && param.TypedIdent.WhereExpr != null)
{
VisitExpr(param.TypedIdent.WhereExpr);
}
}
if (node.Proc != null)
{
node.AddProcedureDependency(node.Proc);
}
var result = base.VisitImplementation(node);
node.DependenciesCollected = true;
currentDeclaration = null;
return(result);
}
public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
//if (FVisited.Contains(node))
// return node;
//FVisited.Add(node);
if (node == null)
{
Console.WriteLine();
}
if (node is Function)
{
node = this.VisitFunction((Function)node);
}
if (node is Implementation)
{
node = this.VisitImplementation((Implementation)node);
}
if (node is Procedure)
{
node = this.VisitProcedure((Procedure)node);
}
return(base.VisitDeclWithFormals(node));
}
public static List <Declaration> CreateNoninterferenceCheckers(
CivlTypeChecker civlTypeChecker,
LinearTypeChecker linearTypeChecker,
int layerNum,
Dictionary <Absy, Absy> absyMap,
DeclWithFormals decl,
List <Variable> declLocalVariables)
{
Dictionary <string, Variable> domainNameToHoleVar = new Dictionary <string, Variable>();
Dictionary <Variable, Variable> localVarMap = new Dictionary <Variable, Variable>();
Dictionary <Variable, Expr> map = new Dictionary <Variable, Expr>();
List <Variable> locals = new List <Variable>();
List <Variable> inputs = new List <Variable>();
foreach (var domainName in linearTypeChecker.linearDomains.Keys)
{
var inParam = linearTypeChecker.LinearDomainInFormal(domainName);
inputs.Add(inParam);
domainNameToHoleVar[domainName] = inParam;
}
foreach (Variable local in declLocalVariables.Union(decl.InParams).Union(decl.OutParams))
{
var copy = CopyLocal(local);
locals.Add(copy);
localVarMap[local] = copy;
map[local] = Expr.Ident(copy);
}
Dictionary <Variable, Expr> oldLocalMap = new Dictionary <Variable, Expr>();
Dictionary <Variable, Expr> assumeMap = new Dictionary <Variable, Expr>(map);
foreach (Variable g in civlTypeChecker.GlobalVariables)
{
var copy = OldLocalLocal(g);
locals.Add(copy);
oldLocalMap[g] = Expr.Ident(copy);
Formal f = OldGlobalFormal(g);
inputs.Add(f);
assumeMap[g] = Expr.Ident(f);
}
var linearPermissionInstrumentation = new LinearPermissionInstrumentation(civlTypeChecker, linearTypeChecker, layerNum, absyMap, domainNameToHoleVar, localVarMap);
List <Tuple <List <Cmd>, List <PredicateCmd> > > yieldInfo = null;
if (decl is Implementation impl)
{
yieldInfo = CollectYields(civlTypeChecker, absyMap, layerNum, impl).Select(kv => new Tuple <List <Cmd>, List <PredicateCmd> >(linearPermissionInstrumentation.DisjointnessAssumeCmds(kv.Key, false), kv.Value)).ToList();
}
else if (decl is Procedure proc)
{
yieldInfo = new List <Tuple <List <Cmd>, List <PredicateCmd> > >();
if (civlTypeChecker.procToYieldInvariant.ContainsKey(proc))
{
if (proc.Requires.Count > 0)
{
var disjointnessCmds = linearPermissionInstrumentation.ProcDisjointnessAssumeCmds(proc, true);
var yieldPredicates = proc.Requires.Select(requires =>
requires.Free
? (PredicateCmd) new AssumeCmd(requires.tok, requires.Condition)
: (PredicateCmd) new AssertCmd(requires.tok, requires.Condition)).ToList();
yieldInfo.Add(new Tuple <List <Cmd>, List <PredicateCmd> >(disjointnessCmds, yieldPredicates));
}
}
else
{
if (proc.Requires.Count > 0)
{
var entryDisjointnessCmds =
linearPermissionInstrumentation.ProcDisjointnessAssumeCmds(proc, true);
var entryYieldPredicates = proc.Requires.Select(requires =>
requires.Free
? (PredicateCmd) new AssumeCmd(requires.tok, requires.Condition)
: (PredicateCmd) new AssertCmd(requires.tok, requires.Condition)).ToList();
yieldInfo.Add(
new Tuple <List <Cmd>, List <PredicateCmd> >(entryDisjointnessCmds, entryYieldPredicates));
}
if (proc.Ensures.Count > 0)
{
var exitDisjointnessCmds =
linearPermissionInstrumentation.ProcDisjointnessAssumeCmds(proc, false);
var exitYieldPredicates = proc.Ensures.Select(ensures =>
ensures.Free
? (PredicateCmd) new AssumeCmd(ensures.tok, ensures.Condition)
: (PredicateCmd) new AssertCmd(ensures.tok, ensures.Condition)).ToList();
yieldInfo.Add(
new Tuple <List <Cmd>, List <PredicateCmd> >(exitDisjointnessCmds, exitYieldPredicates));
}
}
}
else
{
Debug.Assert(false);
}
Substitution assumeSubst = Substituter.SubstitutionFromHashtable(assumeMap);
Substitution oldSubst = Substituter.SubstitutionFromHashtable(oldLocalMap);
Substitution subst = Substituter.SubstitutionFromHashtable(map);
List <Block> noninterferenceCheckerBlocks = new List <Block>();
List <String> labels = new List <String>();
List <Block> labelTargets = new List <Block>();
Block noninterferenceCheckerBlock = new Block(Token.NoToken, "exit", new List <Cmd>(), new ReturnCmd(Token.NoToken));
labels.Add(noninterferenceCheckerBlock.Label);
labelTargets.Add(noninterferenceCheckerBlock);
noninterferenceCheckerBlocks.Add(noninterferenceCheckerBlock);
int yieldCount = 0;
foreach (var kv in yieldInfo)
{
var disjointnessCmds = kv.Item1;
var yieldPredicates = kv.Item2;
var newCmds = new List <Cmd>(disjointnessCmds);
foreach (var predCmd in yieldPredicates)
{
var newExpr = Substituter.ApplyReplacingOldExprs(assumeSubst, oldSubst, predCmd.Expr);
newCmds.Add(new AssumeCmd(Token.NoToken, newExpr));
}
foreach (var predCmd in yieldPredicates)
{
if (predCmd is AssertCmd)
{
var newExpr = Substituter.ApplyReplacingOldExprs(subst, oldSubst, predCmd.Expr);
AssertCmd assertCmd = new AssertCmd(predCmd.tok, newExpr, predCmd.Attributes);
assertCmd.ErrorData = "Non-interference check failed";
newCmds.Add(assertCmd);
}
}
newCmds.Add(new AssumeCmd(Token.NoToken, Expr.False));
noninterferenceCheckerBlock = new Block(Token.NoToken, "L" + yieldCount++, newCmds, new ReturnCmd(Token.NoToken));
labels.Add(noninterferenceCheckerBlock.Label);
labelTargets.Add(noninterferenceCheckerBlock);
noninterferenceCheckerBlocks.Add(noninterferenceCheckerBlock);
}
noninterferenceCheckerBlocks.Insert(0,
new Block(Token.NoToken, "enter", new List <Cmd>(), new GotoCmd(Token.NoToken, labels, labelTargets)));
// Create the yield checker procedure
var noninterferenceCheckerName = decl is Procedure ? $"NoninterferenceChecker_proc_{decl.Name}" : $"NoninterferenceChecker_impl_{decl.Name}";
var noninterferenceCheckerProc = new Procedure(Token.NoToken, noninterferenceCheckerName, decl.TypeParameters, inputs,
new List <Variable>(), new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>());
CivlUtil.AddInlineAttribute(noninterferenceCheckerProc);
// Create the yield checker implementation
var noninterferenceCheckerImpl = new Implementation(Token.NoToken, noninterferenceCheckerName, decl.TypeParameters, inputs,
new List <Variable>(), locals, noninterferenceCheckerBlocks);
noninterferenceCheckerImpl.Proc = noninterferenceCheckerProc;
CivlUtil.AddInlineAttribute(noninterferenceCheckerImpl);
return(new List <Declaration> {
noninterferenceCheckerProc, noninterferenceCheckerImpl
});
}
public static bool MatchSig(Implementation toMatch, DeclWithFormals dwf, Program boogieProgram, out QKeyValue toMatchAnyParamsAttributes, out int anyParamsPosition, out QKeyValue toMatchAnyParamsAttributesOut, out int anyParamsPositionOut, out Dictionary <Declaration, Expr> paramSubstitution, bool matchPtrs)
{
toMatchAnyParamsAttributes = null;
anyParamsPosition = int.MaxValue;
toMatchAnyParamsAttributesOut = null;
anyParamsPositionOut = int.MaxValue;
paramSubstitution = new Dictionary <Declaration, Expr>();
if (!ExprMatchVisitor.AreAttributesASubset(toMatch.Attributes, dwf.Attributes))
{
return(false);
}
// match procedure name
// Positive filters: AnyProcedure, NameMatches, ByName
if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.AnyProcedure, toMatch.Attributes))
{
//do nothing
}
else if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.NameMatches, toMatch.Attributes))
{
var nmAttrParams = BoogieUtil.getAttr(ExprMatchVisitor.BoogieKeyWords.NameMatches, toMatch.Attributes);
Debug.Assert(nmAttrParams.Count() == 1, "Expecting exactly one #NameMatches attribute, found " + nmAttrParams.Count());
var regex = nmAttrParams.First().ToString();
var m = Regex.Match(dwf.Name, regex);
if (m.Success)
{
//do nothing
}
else
{
return(false);
}
}
else if (toMatch.Name != dwf.Name)
{
return(false);
}
//Negative filter: NameNotMatches (can be multiple of them)
if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.NameNotMatches, toMatch.Attributes))
{
//get the params from multiple matching key
var getAttrRepeated = new Func <QKeyValue, string, IList <IList <object> > >((attr, name) =>
{
var ret = new List <IList <object> >();
for (; attr != null; attr = attr.Next)
{
if (attr.Key == name)
{
ret.Add(attr.Params);
}
}
return(ret);
});
var nmAttrParams = getAttrRepeated(toMatch.Attributes, ExprMatchVisitor.BoogieKeyWords.NameNotMatches);
foreach (var nm in nmAttrParams)
{
if (Regex.Match(dwf.Name, nm.First().ToString()).Success)
{
return(false);
}
}
}
// if the procedure name is matched, it may still be that we are looking only for stubs
if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.NoImplementation, toMatch.Attributes))
{
foreach (var i in boogieProgram.Implementations)
{
if (i.Name == dwf.Name)
{
return(false);
}
}
}
Procedure dwfProc = null;
if (dwf is Implementation)
{
dwfProc = ((Implementation)dwf).Proc;
}
else if (dwf is Procedure)
{
dwfProc = (Procedure)dwf;
}
if (!MatchParams(ref toMatchAnyParamsAttributes, ref anyParamsPosition, paramSubstitution, toMatch.InParams, toMatch.Proc.InParams, dwf.InParams, dwfProc.InParams, matchPtrs))
{
return(false);
}
if (!MatchParams(ref toMatchAnyParamsAttributesOut, ref anyParamsPositionOut, paramSubstitution, toMatch.OutParams, toMatch.Proc.OutParams, dwf.OutParams, dwfProc.OutParams, matchPtrs))
{
return(false);
}
return(true);
}
public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
add(node);
return(base.VisitDeclWithFormals(node));
}
public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
return(base.VisitDeclWithFormals((DeclWithFormals)node.Clone()));
}
private bool Analyse(Implementation impl, List<Cmd> cmdSeq, bool ControlFlowIsUniform)
{
foreach (Cmd c in cmdSeq)
{
if (c is AssignCmd)
{
AssignCmd assignCmd = c as AssignCmd;
foreach (var a in assignCmd.Lhss.Zip(assignCmd.Rhss))
{
if (a.Item1 is SimpleAssignLhs)
{
SimpleAssignLhs lhs = a.Item1 as SimpleAssignLhs;
Expr rhs = a.Item2;
if (IsUniform(impl.Name, lhs.AssignedVariable.Name) &&
(!ControlFlowIsUniform || !IsUniform(impl.Name, rhs)))
{
SetNonUniform(impl.Name, lhs.AssignedVariable.Name);
}
}
}
}
else if (c is HavocCmd)
{
HavocCmd havocCmd = c as HavocCmd;
foreach(IdentifierExpr ie in havocCmd.Vars)
{
if(IsUniform(impl.Name, ie.Decl.Name)) {
SetNonUniform(impl.Name, ie.Decl.Name);
}
}
}
else if (c is CallCmd)
{
CallCmd callCmd = c as CallCmd;
DeclWithFormals Callee = GetProcedure(callCmd.callee);
Debug.Assert(Callee != null);
if (!ControlFlowIsUniform)
{
if (IsUniform(callCmd.callee))
{
SetNonUniform(callCmd.callee);
}
}
for (int i = 0; i < Callee.InParams.Count; i++)
{
if (IsUniform(callCmd.callee, Callee.InParams[i].Name)
&& !IsUniform(impl.Name, callCmd.Ins[i]))
{
SetNonUniform(callCmd.callee, Callee.InParams[i].Name);
}
}
for (int i = 0; i < Callee.OutParams.Count; i++)
{
if (IsUniform(impl.Name, callCmd.Outs[i].Name)
&& !IsUniform(callCmd.callee, Callee.OutParams[i].Name))
{
SetNonUniform(impl.Name, callCmd.Outs[i].Name);
}
}
}
else if (c is AssumeCmd)
{
var ac = (AssumeCmd)c;
if (ControlFlowIsUniform && QKeyValue.FindBoolAttribute(ac.Attributes, "partition") &&
!IsUniform(impl.Name, ac.Expr))
{
ControlFlowIsUniform = false;
}
}
}
return ControlFlowIsUniform;
}
public override DeclWithFormals VisitDeclWithFormals(DeclWithFormals node)
{
//Contract.Requires(node != null);
Contract.Ensures(Contract.Result <DeclWithFormals>() != null);
return(base.VisitDeclWithFormals((DeclWithFormals)node.Clone()));
}
public static List <Declaration> CreateNoninterferenceCheckers(
CivlTypeChecker civlTypeChecker,
int layerNum,
AbsyMap absyMap,
DeclWithFormals decl,
List <Variable> declLocalVariables)
{
var linearTypeChecker = civlTypeChecker.linearTypeChecker;
Dictionary <string, Variable> domainNameToHoleVar = new Dictionary <string, Variable>();
Dictionary <Variable, Variable> localVarMap = new Dictionary <Variable, Variable>();
Dictionary <Variable, Expr> map = new Dictionary <Variable, Expr>();
List <Variable> locals = new List <Variable>();
List <Variable> inputs = new List <Variable>();
foreach (var domainName in linearTypeChecker.linearDomains.Keys)
{
var inParam = linearTypeChecker.LinearDomainInFormal(domainName);
inputs.Add(inParam);
domainNameToHoleVar[domainName] = inParam;
}
foreach (Variable local in declLocalVariables.Union(decl.InParams).Union(decl.OutParams))
{
var copy = CopyLocal(local);
locals.Add(copy);
localVarMap[local] = copy;
map[local] = Expr.Ident(copy);
}
Dictionary <Variable, Expr> oldLocalMap = new Dictionary <Variable, Expr>();
Dictionary <Variable, Expr> assumeMap = new Dictionary <Variable, Expr>(map);
foreach (Variable g in civlTypeChecker.GlobalVariables)
{
var copy = OldGlobalLocal(civlTypeChecker, g);
locals.Add(copy);
oldLocalMap[g] = Expr.Ident(copy);
Formal f = SnapshotGlobalFormal(civlTypeChecker, g);
inputs.Add(f);
assumeMap[g] = Expr.Ident(f);
}
var linearPermissionInstrumentation = new LinearPermissionInstrumentation(civlTypeChecker,
layerNum, absyMap, domainNameToHoleVar, localVarMap);
List <YieldInfo> yieldInfos = null;
string noninterferenceCheckerName = null;
if (decl is Implementation impl)
{
noninterferenceCheckerName = $"impl_{absyMap.Original(impl).Name}_{layerNum}";
yieldInfos = CollectYields(civlTypeChecker, absyMap, layerNum, impl).Select(kv =>
new YieldInfo(linearPermissionInstrumentation.DisjointnessAssumeCmds(kv.Key, false), kv.Value)).ToList();
}
else if (decl is Procedure proc)
{
yieldInfos = new List <YieldInfo>();
if (civlTypeChecker.procToYieldInvariant.ContainsKey(proc))
{
noninterferenceCheckerName = $"yield_{proc.Name}";
if (proc.Requires.Count > 0)
{
var disjointnessCmds = linearPermissionInstrumentation.ProcDisjointnessAssumeCmds(proc, true);
var yieldPredicates = proc.Requires.Select(requires =>
requires.Free
? (PredicateCmd) new AssumeCmd(requires.tok, requires.Condition)
: (PredicateCmd) new AssertCmd(requires.tok, requires.Condition)).ToList();
yieldInfos.Add(new YieldInfo(disjointnessCmds, yieldPredicates));
}
}
else
{
noninterferenceCheckerName = $"proc_{absyMap.Original(proc).Name}_{layerNum}";
if (proc.Requires.Count > 0)
{
var entryDisjointnessCmds =
linearPermissionInstrumentation.ProcDisjointnessAssumeCmds(proc, true);
var entryYieldPredicates = proc.Requires.Select(requires =>
requires.Free
? (PredicateCmd) new AssumeCmd(requires.tok, requires.Condition)
: (PredicateCmd) new AssertCmd(requires.tok, requires.Condition)).ToList();
yieldInfos.Add(new YieldInfo(entryDisjointnessCmds, entryYieldPredicates));
}
if (proc.Ensures.Count > 0)
{
var exitDisjointnessCmds =
linearPermissionInstrumentation.ProcDisjointnessAssumeCmds(proc, false);
var exitYieldPredicates = proc.Ensures.Select(ensures =>
ensures.Free
? (PredicateCmd) new AssumeCmd(ensures.tok, ensures.Condition)
: (PredicateCmd) new AssertCmd(ensures.tok, ensures.Condition)).ToList();
yieldInfos.Add(new YieldInfo(exitDisjointnessCmds, exitYieldPredicates));
}
}
}
else
{
Debug.Assert(false);
}
var filteredYieldInfos = yieldInfos.Where(info =>
info.invariantCmds.Any(predCmd => new GlobalAccessChecker().AccessesGlobal(predCmd.Expr)));
if (filteredYieldInfos.Count() == 0)
{
return(new List <Declaration>());
}
Substitution assumeSubst = Substituter.SubstitutionFromDictionary(assumeMap);
Substitution oldSubst = Substituter.SubstitutionFromDictionary(oldLocalMap);
Substitution subst = Substituter.SubstitutionFromDictionary(map);
List <Block> noninterferenceCheckerBlocks = new List <Block>();
List <Block> labelTargets = new List <Block>();
Block noninterferenceCheckerBlock = BlockHelper.Block("exit", new List <Cmd>());
labelTargets.Add(noninterferenceCheckerBlock);
noninterferenceCheckerBlocks.Add(noninterferenceCheckerBlock);
int yieldCount = 0;
foreach (var kv in filteredYieldInfos)
{
var newCmds = new List <Cmd>(kv.disjointnessCmds);
foreach (var predCmd in kv.invariantCmds)
{
var newExpr = Substituter.ApplyReplacingOldExprs(assumeSubst, oldSubst, predCmd.Expr);
newCmds.Add(new AssumeCmd(predCmd.tok, newExpr));
}
foreach (var predCmd in kv.invariantCmds)
{
if (predCmd is AssertCmd)
{
var newExpr = Substituter.ApplyReplacingOldExprs(subst, oldSubst, predCmd.Expr);
AssertCmd assertCmd = new AssertCmd(predCmd.tok, newExpr, predCmd.Attributes);
assertCmd.ErrorData = "Non-interference check failed";
newCmds.Add(assertCmd);
}
}
newCmds.Add(CmdHelper.AssumeCmd(Expr.False));
noninterferenceCheckerBlock = BlockHelper.Block("L" + yieldCount++, newCmds);
labelTargets.Add(noninterferenceCheckerBlock);
noninterferenceCheckerBlocks.Add(noninterferenceCheckerBlock);
}
noninterferenceCheckerBlocks.Insert(0, BlockHelper.Block("enter", new List <Cmd>(), labelTargets));
// Create the yield checker procedure
noninterferenceCheckerName = civlTypeChecker.AddNamePrefix($"NoninterferenceChecker_{noninterferenceCheckerName}");
var noninterferenceCheckerProc = DeclHelper.Procedure(noninterferenceCheckerName,
inputs, new List <Variable>(), new List <Requires>(), new List <IdentifierExpr>(), new List <Ensures>());
CivlUtil.AddInlineAttribute(noninterferenceCheckerProc);
// Create the yield checker implementation
var noninterferenceCheckerImpl = DeclHelper.Implementation(noninterferenceCheckerProc,
inputs, new List <Variable>(), locals, noninterferenceCheckerBlocks);
CivlUtil.AddInlineAttribute(noninterferenceCheckerImpl);
return(new List <Declaration> {
noninterferenceCheckerProc, noninterferenceCheckerImpl
});
}
private CallCmd ActionCallCmd(AtomicAction action, DeclWithFormals paramProvider)
{
return(CmdHelper.CallCmd(action.proc, paramProvider.InParams, paramProvider.OutParams));
}
public static bool MatchSig(Implementation toMatch, DeclWithFormals dwf, Program boogieProgram, out QKeyValue toMatchAnyParamsAttributes, out int anyParamsPosition, out QKeyValue toMatchAnyParamsAttributesOut, out int anyParamsPositionOut, out Dictionary <Declaration, Expr> paramSubstitution)
{
toMatchAnyParamsAttributes = null;
anyParamsPosition = int.MaxValue;
toMatchAnyParamsAttributesOut = null;
anyParamsPositionOut = int.MaxValue;
paramSubstitution = new Dictionary <Declaration, Expr>();
if (!ExprMatchVisitor.AreAttributesASubset(toMatch.Attributes, dwf.Attributes))
{
return(false);
}
// match procedure name
if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.AnyProcedure, toMatch.Attributes))
{
//do nothing
}
else if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.NameMatches, toMatch.Attributes))
{
var nmAttrParams = BoogieUtil.getAttr(ExprMatchVisitor.BoogieKeyWords.NameMatches, toMatch.Attributes);
var regex = nmAttrParams.First().ToString();
var m = Regex.Match(dwf.Name, regex);
if (m.Success)
{
//do nothing
}
else
{
return(false);
}
}
else if (toMatch.Name != dwf.Name)
{
return(false);
}
// if the procedure name is matched, it may still be that we are looking only for stubs
if (BoogieUtil.checkAttrExists(ExprMatchVisitor.BoogieKeyWords.NoImplementation, toMatch.Attributes))
{
foreach (var i in boogieProgram.Implementations)
{
if (i.Name == dwf.Name)
{
return(false);
}
}
}
if (!MatchParams(ref toMatchAnyParamsAttributes, ref anyParamsPosition, paramSubstitution, toMatch.InParams, toMatch.Proc.InParams, dwf.InParams))
{
return(false);
}
if (!MatchParams(ref toMatchAnyParamsAttributesOut, ref anyParamsPositionOut, paramSubstitution, toMatch.OutParams, toMatch.Proc.OutParams, dwf.OutParams))
{
return(false);
}
return(true);
}