private void copyInfoFromInToOutSnapshot(VarLikeConstructUse variable, AssumePoint p, EvaluationLog log)
{
var variableInfo = log.GetSnapshotEntry(variable);
if (variableInfo != null)
{
var vals = variableInfo.ReadMemory(p.InSnapshot).PossibleValues;
variableInfo.WriteMemory(Output, new MemoryEntry(vals));
}
}
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);
}
}
/// <summary>
/// Creates points block from given condition
/// Points block will have single outgoing block as outcomming edge
/// </summary>
/// <param name="condition">Condition which points block is created</param>
/// <param name="outgoingBlock">Block used as outcomming edge</param>
/// <param name="expressionValues">Expression parts of assumed condition</param>
/// <returns>Created points block</returns>
internal PointsBlock CreateAssumeBlock(AssumptionCondition condition, BasicBlock outgoingBlock, params ValuePoint[] expressionValues)
{
var point = new AssumePoint(condition, expressionValues);
reportCreation(point);
var createdBlock = PointsBlock.ForPoint(point, new[] { outgoingBlock });
_createdBlocks.Add(createdBlock);
return(createdBlock);
}
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);
}
}
}
public override void VisitConditionalEx(ConditionalEx x)
{
/* Points are created in current ordering
* 1. conditionExpr,
* 2. trueAssume,
* 3. trueExpr,
* 4. falseAssume,
* 5. falseExpr,
*/
//1.
// starts branching
var conditionExpr = CreateRValue(x.CondExpr);
//create true branch
var trueAssumeCond = new AssumptionCondition(ConditionForm.All, x.CondExpr);
var trueAssume = new AssumePoint(trueAssumeCond, new[] { conditionExpr });
//2.
AppendToChain(trueAssume);
//3.
var trueExpr = CreateRValue(x.TrueExpr);
//create false branch
var falseAssumeCond = new AssumptionCondition(ConditionForm.None, x.CondExpr);
var falseAssume = new AssumePoint(falseAssumeCond, new[] { conditionExpr });
//4.
AppendToChain(falseAssume);
//5.
var falseExpr = CreateRValue(x.FalseExpr);
//connect condition - true assume will be connected via chaining
conditionExpr.AddFlowChild(falseAssume);
//create result
var expression = new ConditionalExPoint(x, conditionExpr, trueAssume, falseAssume, trueExpr, falseExpr);
//false expr is added when processing substitution
PreventChainEdge(trueExpr);
trueExpr.AddFlowChild(expression);
// Both branches must be processed before the expression
conditionExpr.CreateWorklistSegment(expression);
Result(expression);
}
private void checkDefiniteVariableInAssumption(VarLikeConstructUse variable, AssumePoint p)
{
var variableInfo = p.Log.ReadSnapshotEntry(variable);
if (variableInfo != null)
{
Input.SetMode(SnapshotMode.MemoryLevel);
MemoryEntry memoryEntry = variableInfo.ReadMemory(Input);
Input.SetMode(SnapshotMode.InfoLevel);
if (memoryEntry != null && memoryEntry.PossibleValues != null)
{
if (memoryEntry.PossibleValues.Count() == 1 && !(memoryEntry.PossibleValues.First() is AnyValue))
{
//AnalysisWarningHandler.SetWarning(Output, new AnalysisWarning(p.OwningScriptFullName, String.Format("Variable has just single possible value ({0}) and it is used in the assumption.", memoryEntry.PossibleValues.First().ToString()), variable, p, AnalysisWarningCause.OTHER));
}
}
else
{
//AnalysisWarningHandler.SetWarning(Output, new AnalysisWarning(p.OwningScriptFullName, "Variable is not defined and it is used in the assumption.", variable, p, AnalysisWarningCause.OTHER));
}
}
}
public override void VisitBinaryEx(BinaryEx x)
{
var lOperand = CreateRValue(x.LeftExpr);
ValuePoint rOperand;
BinaryExPoint expression;
switch (x.PublicOperation)
{
case Operations.And:
case Operations.Or:
/* Points are created in current ordering
* 1. blockStart,
* 2. shortendPath,
* 3. nonShortendPath,
* 4. rOperand
*/
var shortableForm = x.PublicOperation == Operations.And ? ConditionForm.None : ConditionForm.All;
var nonShortableForm = shortableForm == ConditionForm.All ? ConditionForm.None : ConditionForm.All;
var shortableCondition = new AssumptionCondition(shortableForm, x.LeftExpr);
//shortened evaluation path
var shortendPath = new AssumePoint(shortableCondition, new[] { lOperand });
var nonShortableCondition = new AssumptionCondition(nonShortableForm, x.LeftExpr);
//normal evaluation
var nonShortendPath = new AssumePoint(nonShortableCondition, new[] { lOperand });
//block borders
var blockStart = new EmptyProgramPoint();
//1.
AppendToChain(blockStart);
//2.
AppendToChain(shortendPath);
//3.
AppendToChain(nonShortendPath);
//4.
rOperand = CreateRValue(x.RightExpr);
expression = new BinaryExPoint(x, lOperand, rOperand);
//shortend path is added via chain
blockStart.AddFlowChild(nonShortendPath);
//set explicit edge
PreventChainEdge(shortendPath);
shortendPath.AddFlowChild(expression);
break;
default:
rOperand = CreateRValue(x.RightExpr);
expression = new BinaryExPoint(x, lOperand, rOperand);
break;
}
Result(expression);
}
/// <inheritdoc />
public override void VisitAssume(AssumePoint p)
{
base.VisitAssume(p);
checkDefiniteVariablesInAssumption(p);
}
/// <inheritdoc />
public override void VisitAssume(AssumePoint p)
{
propagateInfosToRefinedLocations(p);
}
