public ExprDomain <SymbolicValue> EdgeConversion(APC @from, APC to, bool isJoinPoint, EdgeData sourceTargetMap, ExprDomain <SymbolicValue> originalState)
{
if (sourceTargetMap == null)
{
return(originalState);
}
if (DebugOptions.Debug)
{
Console.WriteLine("====Expression analysis Parallel assign====");
DumpMap(sourceTargetMap);
DumpExpressions("original expressions", originalState);
}
ExprDomain <SymbolicValue> result = originalState.Empty();
ExprDomain <SymbolicValue> domain = originalState.Empty();
foreach (SymbolicValue sv in originalState.Keys)
{
Expr <SymbolicValue> expression = originalState [sv].Concrete.Substitute(sourceTargetMap);
if (expression != null)
{
domain = domain.Add(sv, expression);
}
}
foreach (SymbolicValue sv in sourceTargetMap.Keys)
{
FlatDomain <Expr <SymbolicValue> > expressionDomain = domain [sv];
if (expressionDomain.IsNormal)
{
Expr <SymbolicValue> expression = expressionDomain.Concrete;
foreach (SymbolicValue sub in sourceTargetMap[sv].AsEnumerable())
{
result = result.Add(sub, expression);
}
}
}
if (DebugOptions.Debug)
{
DumpExpressions("new expressions", result);
}
return(result);
}
private void DumpExpressions(string header, ExprDomain <SymbolicValue> state)
{
Console.WriteLine("--- {0} ---", header);
foreach (SymbolicValue index in state.Keys)
{
FlatDomain <Expr <SymbolicValue> > domain = state [index];
if (domain.IsNormal)
{
Console.WriteLine("{0} -> {1}", index, domain.Concrete);
}
else if (domain.IsTop)
{
Console.WriteLine("{0} -> (Top)", index);
}
else if (domain.IsBottom)
{
Console.WriteLine("{0} -> (Bot)", index);
}
}
}
public override ExprDomain <TSymValue> Assume(APC pc, EdgeTag tag, TSymValue condition, ExprDomain <TSymValue> data)
{
FlatDomain <Expr <TSymValue> > aExpression = data [condition];
if (aExpression.IsNormal())
{
bool truth = tag != EdgeTag.False;
data = aExpression.Value.Decode <ExprDomain <TSymValue>, ExprDomain <TSymValue>, AssumeDecoder <TSymValue> >
(pc, condition, new AssumeDecoder <TSymValue> (truth), data);
}
return(data);
}
public override ExprDomain <TSymValue> Assert(APC pc, EdgeTag tag, TSymValue condition, ExprDomain <TSymValue> data)
{
FlatDomain <Expr <TSymValue> > expression = data [condition];
if (expression.IsNormal())
{
data = expression.Value.Decode <ExprDomain <TSymValue>, ExprDomain <TSymValue>, AssumeDecoder <TSymValue> >
(pc, condition, new AssumeDecoder <TSymValue> (true), data);
}
return(data);
}
public bool IsBottom(APC pc, ExprDomain <SymbolicValue> state)
{
return(state.IsBottom);
}
public override ExprDomain <TSymValue> DefaultVisit(APC pc, ExprDomain <TSymValue> data)
{
return(data);
}
public ExprDomain <SymbolicValue> Sizeof(APC pc, TypeNode type, SymbolicValue dest, ExprDomain <SymbolicValue> data)
{
return(data);
}
public ExprDomain <SymbolicValue> MutableVersion(ExprDomain <SymbolicValue> arg)
{
return(arg);
}
public override ExprDomain <TSymValue> LoadConst(APC pc, TypeNode type, object constant, TSymValue dest, ExprDomain <TSymValue> data)
{
return(data.Add(dest, new ConstExpr <TSymValue> (type, constant)));
}
public ExprDomain <SymbolicValue> Binary(APC pc, BinaryOperator op, SymbolicValue dest, SymbolicValue s1, SymbolicValue s2, ExprDomain <SymbolicValue> data)
{
if (this.truth && op.IsEqualityOperator())
{
if (!data.HasRefinement(s1))
{
FlatDomain <Expr <SymbolicValue> > expression2 = data [s2];
if (expression2.IsNormal && !data.IsReachableFrom(s2, s1))
{
return(data.Add(s1, expression2.Concrete));
}
}
else if (!data.HasRefinement(s2))
{
FlatDomain <Expr <SymbolicValue> > expression1 = data [s1];
if (expression1.IsNormal && !data.IsReachableFrom(s1, s2))
{
return(data.Add(s2, expression1.Concrete));
}
}
}
if (!this.truth && op == BinaryOperator.Cne_Un)
{
if (!data.HasRefinement(s1))
{
FlatDomain <Expr <SymbolicValue> > expression2 = data [s2];
if (expression2.IsNormal && !data.IsReachableFrom(s2, s1))
{
return(data.Add(s1, expression2.Concrete));
}
}
else if (!data.HasRefinement(s2))
{
FlatDomain <Expr <SymbolicValue> > expression1 = data [s1];
if (expression1.IsNormal && !data.IsReachableFrom(s1, s2))
{
return(data.Add(s2, expression1.Concrete));
}
}
}
return(data);
}
public ExprDomain <TSymValue> InitialValue(Func <TSymValue, int> keyConverter)
{
return(ExprDomain <TSymValue> .TopValue(keyConverter));
}
public ExprDomain <TSymValue> Join(ExprDomain <TSymValue> that, bool widening, out bool weaker)
{
return(new ExprDomain <TSymValue> (this.expressions.Join(that.expressions, widening, out weaker)));
}
public bool PostStateLookup(APC label, out ExprDomain <TSymValue> ifFound)
{
return(this.fix_point_info.PostStateLookup(label, out ifFound));
}
public ExprDomain <SymbolicValue> LoadNull(APC pc, SymbolicValue dest, ExprDomain <SymbolicValue> polarity)
{
return(polarity);
}
public ExprDomain <SymbolicValue> Isinst(APC pc, TypeNode type, SymbolicValue dest, SymbolicValue obj, ExprDomain <SymbolicValue> data)
{
return(data);
}
public override ExprDomain <TSymValue> Binary(APC pc, BinaryOperator op, TSymValue dest, TSymValue operand1, TSymValue operand2, ExprDomain <TSymValue> data)
{
return(data.Add(dest, new BinaryExpr <TSymValue> (operand1, operand2, op)));
}
public override ExprDomain <TSymValue> Sizeof(APC pc, TypeNode type, TSymValue dest, ExprDomain <TSymValue> data)
{
return(data.Add(dest, new SizeOfExpr <TSymValue> (type)));
}
public override ExprDomain <TSymValue> Isinst(APC pc, TypeNode type, TSymValue dest, TSymValue obj, ExprDomain <TSymValue> data)
{
return(data.Add(dest, new IsInstExpr <TSymValue> (obj, type)));
}
public ExprDomain <SymbolicValue> Unary(APC pc, UnaryOperator op, bool unsigned, SymbolicValue dest, SymbolicValue source, ExprDomain <SymbolicValue> data)
{
return(data);
}
public override ExprDomain <TSymValue> LoadNull(APC pc, TSymValue dest, ExprDomain <TSymValue> polarity)
{
return(polarity.Add(dest, NullExpr <TSymValue> .Instance));
}
public ExprDomain <SymbolicValue> Join(Pair <APC, APC> edge, ExprDomain <SymbolicValue> newstate, ExprDomain <SymbolicValue> prevstate, out bool weaker, bool widen)
{
return(prevstate.Join(newstate, widen, out weaker));
}
public override ExprDomain <TSymValue> Unary(APC pc, UnaryOperator op, bool unsigned, TSymValue dest, TSymValue source, ExprDomain <TSymValue> data)
{
return(data.Add(dest, new UnaryExpr <TSymValue> (source, op, unsigned)));
}
public ExprDomain <SymbolicValue> LoadConst(APC pc, TypeNode type, object constant, SymbolicValue dest, ExprDomain <SymbolicValue> data)
{
return(data);
}
