private void InstrumentProcedure(InstrumentationRegion region)
{
foreach (var ls in this.AC.CurrentLocksets)
{
if (this.ShouldSkipLockset(ls))
{
continue;
}
region.Procedure().Modifies.Add(new IdentifierExpr(ls.Id.tok, ls.Id));
}
List <Variable> vars = SharedStateAnalyser.GetMemoryRegions(DeviceDriver.GetEntryPoint(this.EP.Name));
foreach (var ls in this.AC.MemoryLocksets)
{
if (!vars.Any(val => val.Name.Equals(ls.TargetName)))
{
continue;
}
if (this.ShouldSkipLockset(ls))
{
continue;
}
region.Procedure().Modifies.Add(new IdentifierExpr(ls.Id.tok, ls.Id));
}
}
public static void CleanReadWriteModsets(AnalysisContext ac, EntryPoint ep, InstrumentationRegion region)
{
var vars = SharedStateAnalyser.GetMemoryRegions(ep);
foreach (var acv in ac.GetWriteAccessCheckingVariables())
{
string targetName = acv.Name.Split('_')[1];
if (!vars.Any(val => val.Name.Equals(targetName)))
{
continue;
}
if (ep.HasWriteAccess.ContainsKey(targetName))
{
continue;
}
region.Procedure().Modifies.RemoveAll(val => val.Name.Equals(acv.Name));
}
foreach (var acv in ac.GetReadAccessCheckingVariables())
{
string targetName = acv.Name.Split('_')[1];
if (!vars.Any(val => val.Name.Equals(targetName)))
{
continue;
}
if (ep.HasReadAccess.ContainsKey(targetName))
{
continue;
}
region.Procedure().Modifies.RemoveAll(val => val.Name.Equals(acv.Name));
}
}
private void CleanUpModset(InstrumentationRegion region)
{
region.Procedure().Modifies.RemoveAll(val => !(val.Name.Equals("$Alloc") ||
val.Name.Equals("$CurrAddr") || val.Name.Equals("CLS") ||
val.Name.Contains("LS_$") ||
val.Name.Contains("WRITTEN_$") || val.Name.Contains("READ_$")));
}
private void InstrumentProcedure(InstrumentationRegion region)
{
var vars = SharedStateAnalyser.GetMemoryRegions(this.EP);
foreach (var acv in this.AC.GetWriteAccessCheckingVariables())
{
string targetName = acv.Name.Split('_')[1];
if (!vars.Any(val => val.Name.Equals(targetName)))
{
continue;
}
if (!this.EP.HasWriteAccess.ContainsKey(targetName))
{
continue;
}
if (!region.Procedure().Modifies.Any(mod => mod.Name.Equals(acv.Name)))
{
region.Procedure().Modifies.Add(new IdentifierExpr(acv.tok, acv));
}
}
foreach (var acv in this.AC.GetReadAccessCheckingVariables())
{
string targetName = acv.Name.Split('_')[1];
if (!vars.Any(val => val.Name.Equals(targetName)))
{
continue;
}
if (!this.EP.HasReadAccess.ContainsKey(targetName))
{
continue;
}
if (!region.Procedure().Modifies.Any(mod => mod.Name.Equals(acv.Name)))
{
region.Procedure().Modifies.Add(new IdentifierExpr(acv.tok, acv));
}
}
}
protected void InstrumentImpliesEnsuresCandidate(InstrumentationRegion region, Expr implExpr,
Variable variable, bool value, bool capture = false)
{
if (this.EP.IsInlined)
{
return;
}
if (!WhoopCommandLineOptions.Get().MergeExistentials)
{
capture = false;
}
var dict = this.GetExistentialDictionary(value);
Constant cons = null;
bool consExists = false;
if (capture && dict.ContainsKey(variable) &&
GetConstantFromDictionary(out cons, dict[variable], implExpr))
{
consExists = true;
}
else
{
cons = this.CreateConstant();
}
Expr rExpr = this.CreateImplExpr(implExpr, variable, value);
Expr lExpr = Expr.Imp(new IdentifierExpr(cons.tok, cons), rExpr);
region.Procedure().Ensures.Add(new Ensures(false, lExpr));
if (capture && !dict.ContainsKey(variable) && !consExists)
{
dict.Add(variable, new Dictionary <string, Constant>());
dict[variable].Add(implExpr.ToString(), cons);
}
else if (capture && !consExists)
{
dict[variable].Add(implExpr.ToString(), cons);
}
}
protected void InstrumentEnsuresCandidate(InstrumentationRegion region, Variable variable,
bool value, bool capture = false)
{
if (this.EP.IsInlined)
{
return;
}
if (!WhoopCommandLineOptions.Get().MergeExistentials)
{
capture = false;
}
var dict = this.GetExistentialDictionary(value);
Constant cons = null;
if (capture && dict.ContainsKey(variable) && dict[variable].ContainsKey("$whoop$"))
{
cons = dict[variable]["$whoop$"];
}
else
{
cons = this.CreateConstant();
}
Expr expr = this.CreateImplExpr(cons, variable, value);
region.Procedure().Ensures.Add(new Ensures(false, expr));
if (capture && !dict.ContainsKey(variable))
{
dict.Add(variable, new Dictionary <string, Constant>());
dict[variable].Add("$whoop$", cons);
}
else if (capture && !dict[variable].ContainsKey("$whoop$"))
{
dict[variable].Add("$whoop$", cons);
}
}
protected void InstrumentEnsures(InstrumentationRegion region, Variable variable, bool value)
{
Expr expr = this.CreateExpr(variable, value);
region.Procedure().Ensures.Add(new Ensures(false, expr));
}
private void InstrumentInParamAliasInformationInRegion(InstrumentationRegion region)
{
if (region.Procedure().InParams.Count <= 1)
{
return;
}
var inParamMap = new Dictionary <string, Dictionary <Variable, int> >();
foreach (var resource in region.GetResourceAccesses())
{
if (!inParamMap.ContainsKey(resource.Key))
{
inParamMap.Add(resource.Key, new Dictionary <Variable, int>());
}
foreach (var access in resource.Value)
{
IdentifierExpr id = null;
var num = 0;
if (access is NAryExpr)
{
id = (access as NAryExpr).Args[0] as IdentifierExpr;
num = ((access as NAryExpr).Args[1] as LiteralExpr).asBigNum.ToInt;
}
else if (access is IdentifierExpr)
{
id = access as IdentifierExpr;
}
if (id == null)
{
continue;
}
var inParam = region.Procedure().InParams.Find(val => val.Name.Equals(id.Name));
if (inParam == null)
{
continue;
}
if (!inParamMap[resource.Key].ContainsKey(inParam))
{
inParamMap[resource.Key].Add(inParam, num);
}
else if (inParamMap[resource.Key][inParam] < num)
{
inParamMap[resource.Key][inParam] = num;
}
}
}
foreach (var resource in inParamMap)
{
if (resource.Value.Count <= 1)
{
continue;
}
var pairs = resource.Value.ToList();
for (int i = 0; i < pairs.Count - 1; i++)
{
for (int j = i + 1; j < pairs.Count; j++)
{
var id1 = new IdentifierExpr(pairs[i].Key.tok, pairs[i].Key);
var id2 = new IdentifierExpr(pairs[j].Key.tok, pairs[j].Key);
var num1 = new LiteralExpr(Token.NoToken, BigNum.FromInt(pairs[i].Value));
var num2 = new LiteralExpr(Token.NoToken, BigNum.FromInt(pairs[j].Value));
var lexpr = Expr.Lt(new NAryExpr(Token.NoToken, new BinaryOperator(Token.NoToken,
BinaryOperator.Opcode.Add), new List <Expr> {
id1, num1
}), id2);
var rexpr = Expr.Lt(new NAryExpr(Token.NoToken, new BinaryOperator(Token.NoToken,
BinaryOperator.Opcode.Add), new List <Expr> {
id2, num2
}), id1);
if (!this.InstrumentAssumes(region, id1, id2, num1, num2))
{
this.RequiresMap.Clear();
this.AssumesMap.Clear();
return;
}
if (!this.RequiresMap.ContainsKey(region))
{
this.RequiresMap.Add(region, new HashSet <Requires>());
}
this.RequiresMap[region].Add(new Requires(false, Expr.Or(lexpr, rexpr)));
}
}
}
}
