/// <summary>
/// node2 \in mapping[node1]
/// </summary>
/// <param name="node1"></param>
/// <param name="node2"></param>
public void Relate(IPTAnalysisNode node1, IPTAnalysisNode node2)
{
Nodes ns = Nodes.Empty;
if (!mapping.ContainsKey(node1))
mapping[node1] = ns;
else
ns = mapping[node1];
// For omega nodes we must add all objects reachable from the caller's node
// and set load node (and parameters) as omega nodes.
if (node1.IsOmega || node1.IsOmegaLoad || node1.IsOmegaConfined)
{
Nodes reachRef = node1.IsOmegaConfined ? this.callerPTG.getReachRefsOwned(node2) : this.callerPTG.getReachRefs(node2);
foreach (IPTAnalysisNode nr in reachRef)
{
if (nr.IsLoad)
{
ILoadNode iln = (ILoadNode)nr;
iln.SetOmegaLoadNode();
if(node1.IsOmegaConfined)
iln.SetOmegaConfinedLoadNode();
}
ns.Add(nr);
}
}
else
{
ns.Add(node2);
}
}
private bool HasInvariantField(IPTAnalysisNode n)
{
var x = new Nodes();
x.Add(n);
return(HasInvariantField(x));
}
protected virtual AbstractValue ConsistencyFor(IPTAnalysisNode n)
{
if (consistency.ContainsKey(n))
{
return(consistency[n]);
}
return(ConsistencyLattice.AVal.MaybeInconsistent);
//return ConsistencyLattice.AVal.Consistent;
}
public void WeakUpdateNode(IPTAnalysisNode n, AbstractValue a)
{
if (consistency.ContainsKey(n))
{
consistency[n] = ConsistencyLattice.It.Join(a, consistency[n]);
}
else
{
UpdateNode(n, a);
}
}
public void WeakUpdateNode(IPTAnalysisNode n, AbstractValue a)
{
if (consistency.ContainsKey(n))
consistency[n] = ConsistencyLattice.It.Join(a, consistency[n]);
else
UpdateNode(n, a);
}
private bool IsVisibleNode(IPTAnalysisNode n)
{
if (n.IsInside)
return false;
bool isVisible = true;
// Nodes B = ReachablesFromOutside();
isVisible = isVisible && IsReachableFromOutside(n);
return isVisible;
}
/// <summary>
/// return mapping[n] U ({n} - PNode)
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public Nodes RelatedExtended(IPTAnalysisNode n)
{
Nodes res = new Nodes(Related(n));
// if (!(n.IsParameterNode) && (!n.IsVariableReference) && !IsRemovedLoadNode(n))
// VariableReference includes ParameterNodes
if ((!n.IsVariableReference) && !IsRemovedLoadNode(n))
{
if (res.Count != 0 && n.IsParameterValueLNode &&
n.Label.Method.Equals(calleePTG.Method))
{
}
else
res.Add(n);
}
return res;
}
private bool IsRemovedLoadNode(IPTAnalysisNode n)
{
return n.IsLoad && removedLoadNodes.Contains((LNode)n);
}
/// <summary>
/// sNodes \in mapping[node1]
/// </summary>
/// <param name="node1"></param>
/// <param name="node2"></param>
public void Relate(IPTAnalysisNode node1, Nodes sNodes)
{
/*
Nodes ns = Nodes.Empty;
if (!mapping.ContainsKey(node1))
mapping[node1] = ns;
else
ns = mapping[node1];
ns.AddRange(sNodes);
*/
foreach (IPTAnalysisNode n2 in sNodes)
Relate(node1, n2);
}
/// <summary>
/// return mapping[n]
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public Nodes Related(IPTAnalysisNode n)
{
Nodes res = Nodes.Empty;
if (mapping.ContainsKey(n))
res.AddRange(mapping[n]);
return res;
}
protected virtual AbstractValue ConsistencyFor(IPTAnalysisNode n)
{
if (consistency.ContainsKey(n))
return consistency[n];
return ConsistencyLattice.AVal.MaybeInconsistent;
//return ConsistencyLattice.AVal.Consistent;
}
public void UpdateNode(IPTAnalysisNode n, AbstractValue a)
{
consistency[n] = a;
}
public void UpdateNode(IPTAnalysisNode n, AbstractValue a)
{
consistency[n] = a;
}
private void RegisterReadEffect(IPTAnalysisNode n, Field f, Label lb)
{
if (IsVisibleEffect(n, f))
{
readEffects.AddEffect(n, f, lb);
}
allReadEffects.AddEffect(n, f, lb);
}
private void RegisterWriteEffect(IPTAnalysisNode n, Field f, Label lb, bool wasNull)
{
if (IsVisibleEffect(n, f))
{
writeEffects.AddEffect(n, f, lb,wasNull);
}
allWriteEffects.AddEffect(n, f, lb,wasNull);
}
public void AddEffect(IPTAnalysisNode n, Field f, Label lb,bool wasNull)
{
AField af = new AField(n, f, lb,wasNull);
AddWriteEffect(af);
}
public virtual bool IsExposable(IPTAnalysisNode n)
{
ConsistencyLattice.AVal a = (ConsistencyLattice.AVal)ConsistencyFor(n);
return a.IsExposable;
}
private bool IsReachableFromOutside(IPTAnalysisNode n)
{
Nodes Esc = new Nodes(PointsToGraph.E);
Esc.Add(GNode.nGBL);
foreach (PNode pn in PointsToGraph.AddrPNodes)
{
Esc.Add(pn);
}
return PointsToGraph.IsReachableFrom(n,Esc,true,true,true);
}
bool IsVisibleEffect(IPTAnalysisNode n, Field f)
{
bool isVisibleEffect = true;
if (IsVisibleNode(n))
{
if (n.IsParameterNode)
{
PNode pn = (PNode)n;
if (pn.IsByValue && (f.Equals(PTGraph.asterisk) || pn.IsStruct))
isVisibleEffect = false;
}
}
else
isVisibleEffect = false;
return isVisibleEffect;
}
public virtual bool IsExposable(IPTAnalysisNode n)
{
ConsistencyLattice.AVal a = (ConsistencyLattice.AVal)ConsistencyFor(n);
return(a.IsExposable);
}
private bool HasInvariantField(IPTAnalysisNode n)
{
var x = new Nodes();
x.Add(n);
return HasInvariantField(x);
}
