public void AddSingleNode()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
dfg.Nodes.Add(0, 0);
Assert.Single(dfg.Nodes);
}
/// <summary>
/// Constructs a control flow graph and a data flow graph from a CIL method body.
/// </summary>
/// <param name="self">The method body.</param>
/// <param name="dataFlowGraph">The constructed data flow graph.</param>
/// <returns>The control flow graph.</returns>
public static ControlFlowGraph <Instruction> ConstructSymbolicFlowGraph(
this MethodDef self,
out DataFlowGraph <Instruction> dataFlowGraph)
{
var body = self.Body;
var architecture = new CilArchitecture(self);
var dfgBuilder = new CilStateTransitionResolver(architecture);
var cfgBuilder = new SymbolicFlowGraphBuilder <Instruction>(
architecture,
body.Instructions,
dfgBuilder);
var ehRanges = body
.GetExceptionHandlerRanges()
.ToArray();
var cfg = cfgBuilder.ConstructFlowGraph(0, ehRanges);
if (ehRanges.Length > 0)
{
cfg.DetectExceptionHandlerRegions(ehRanges);
}
dataFlowGraph = dfgBuilder.DataFlowGraph;
return(cfg);
}
internal AstParserContext(
ControlFlowGraph <TInstruction> controlFlowGraph,
DataFlowGraph <TInstruction> dataFlowGraph)
{
_controlFlowGraph = controlFlowGraph;
DataFlowGraph = dataFlowGraph;
}
public void ConvergingShortLongDependencyPathsShouldFinishSubPathsBeforeGoingDeeper()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
var n3 = dfg.Nodes.Add(3, 3);
var n4 = dfg.Nodes.Add(4, 4);
var n5 = dfg.Nodes.Add(5, 5);
var n6 = dfg.Nodes.Add(6, 6);
n6.StackDependencies.SetCount(2);
n6.StackDependencies[0].Add(n4);
n6.StackDependencies[1].Add(n5);
n5.StackDependencies.SetCount(1);
n5.StackDependencies[0].Add(n3);
n3.StackDependencies.SetCount(1);
n3.StackDependencies[0].Add(n2);
n2.StackDependencies.SetCount(1);
n2.StackDependencies[0].Add(n1);
n4.StackDependencies.SetCount(1);
n4.StackDependencies[0].Add(n1);
Assert.Equal(new[]
{
n1, n4, n2, n3, n5, n6
}, n6.GetOrderedDependencies());
}
public void AddNodeWithSameIdentifierShouldThrow()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
dfg.Nodes.Add(0, 0);
Assert.Throws <ArgumentException>(() => dfg.Nodes.Add(0, 0));
}
public void EmptyGraph()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
Assert.Empty(dfg.Nodes);
Assert.Empty(dfg.Nodes);
}
public void IgnoreStackDependenciesWhenNotIncluded()
{
var variable = new DummyVariable("v1");
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
var n3 = dfg.Nodes.Add(3, 3);
var n4 = dfg.Nodes.Add(4, 4);
var n5 = dfg.Nodes.Add(5, 5);
n1.StackDependencies.SetCount(1);
n1.StackDependencies[0].Add(n2);
var dependency = new VariableDependency <int>(variable);
n1.VariableDependencies.Add(dependency);
dependency.Add(n3);
n3.StackDependencies.SetCount(1);
n3.StackDependencies[0].Add(n4);
dependency = new VariableDependency <int>(variable);
n3.VariableDependencies.Add(dependency);
dependency.Add(n5);
Assert.Equal(new[]
{
n5, n3, n1
}, n1.GetOrderedDependencies(DependencyCollectionFlags.IncludeVariableDependencies));
}
public void AddNodeToGraphShouldSetParentGraph()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var node = new DataFlowNode <int>(1, 2);
dfg.Nodes.Add(node);
Assert.Same(dfg, node.ParentGraph);
}
public void AddDuplicateNodeShouldNotAppearInNodes()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var node = dfg.Nodes.Add(0, 0);
dfg.Nodes.Add(node);
Assert.Single(dfg.Nodes);
}
public void SelfLoopShouldThrowCyclicDependencyException()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
n1.StackDependencies.Add(new DataDependency <int>(n1));
Assert.Throws <CyclicDependencyException>(() => n1.GetOrderedDependencies());
}
public void RemoveNodeFromGraphShouldUnsetParentGraph()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var node = new DataFlowNode <int>(1, 2);
dfg.Nodes.Add(node);
dfg.Nodes.Remove(node);
Assert.Null(node.ParentGraph);
}
public void EmptyDependencyShouldNotResultInAnEdge()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n0 = dfg.Nodes.Add(0, 0);
var n1 = dfg.Nodes.Add(1, 1);
n1.StackDependencies.Add(new DataDependency <int>());
Assert.Empty(dfg.GetEdges());
}
public void DependencyShouldResultInAnEdge()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n0 = dfg.Nodes.Add(0, 0);
var n1 = dfg.Nodes.Add(1, 1);
n1.StackDependencies.Add(new DataDependency <int>(n0));
Assert.Contains(dfg.GetEdges(), e => e.Origin == n1 && e.Target == n0);
}
public void AddFromAnotherGraphShouldThrow()
{
var dfg1 = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg1.Nodes.Add(0, 0);
var dfg2 = new DataFlowGraph <int>(IntArchitecture.Instance);
var n2 = dfg2.Nodes.Add(1, 1);
Assert.Throws <ArgumentException>(() => dfg1.Nodes.Add(n2));
}
public void NoDependencies()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
Assert.Equal(new[]
{
n1
}, n1.GetOrderedDependencies());
}
public void AddDataSourceToAnotherGraphShouldThrow()
{
var dfg1 = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg1.Nodes.Add(1, 0);
var dfg2 = new DataFlowGraph <int>(IntArchitecture.Instance);
var n2 = dfg2.Nodes.Add(2, 0);
n1.StackDependencies.Add(new DataDependency <int>());
Assert.Throws <ArgumentException>(() => n1.StackDependencies[0].Add(new DataSource <int>(n2)));
}
public void UpdateOffsetsWithNoChangeShouldReuseInstances()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n0 = dfg.Nodes.Add(0, 0);
var n1 = dfg.Nodes.Add(1, 1);
dfg.Nodes.UpdateIndices();
Assert.Same(n0, dfg.Nodes[0]);
Assert.Same(n1, dfg.Nodes[1]);
}
public void RemoveStackDependencyShouldUnsetDependant()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n0 = dfg.Nodes.Add(0, 0);
var n1 = dfg.Nodes.Add(1, 1);
var symbolicValue = new DataDependency <int>(n0);
n1.StackDependencies.Add(symbolicValue);
n1.StackDependencies.Remove(symbolicValue);
Assert.Null(symbolicValue.Dependant);
}
public void AddStackDependencyShouldSetDependant()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n0 = dfg.Nodes.Add(0, 0);
var n1 = dfg.Nodes.Add(1, 1);
var dependency = new DataDependency <int>(n0);
n1.StackDependencies.Add(dependency);
Assert.Same(n1, dependency.Dependant);
}
public void AddStackDependencyWithMultipleSourcesShouldSetDegree()
{
var graph = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = graph.Nodes.Add(1, 1);
var n2 = graph.Nodes.Add(2, 2);
var n3 = graph.Nodes.Add(3, 3);
Assert.Equal(0, n1.OutDegree);
n1.StackDependencies.Add(new DataDependency <int>(new[] { n2, n3 }));
Assert.Equal(2, n1.OutDegree);
}
public void AddStackDependencyWithSingeSourceShouldSetDegree()
{
var graph = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = graph.Nodes.Add(1, 1);
var n2 = graph.Nodes.Add(2, 2);
Assert.Equal(0, n1.OutDegree);
Assert.Equal(0, n2.InDegree);
n1.StackDependencies.Add(new DataDependency <int>(n2));
Assert.Equal(1, n1.OutDegree);
Assert.Equal(1, n2.InDegree);
}
public void AddVariableDependencyWithSingeSourceShouldSetDegree()
{
var variable = new DummyVariable("var1");
var graph = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = graph.Nodes.Add(1, 1);
var n2 = graph.Nodes.Add(2, 2);
Assert.Equal(0, n1.OutDegree);
n1.VariableDependencies.Add(variable, new DataDependency <int>(n2));
Assert.Equal(1, n1.OutDegree);
Assert.Equal(1, n2.InDegree);
}
public void SingleStackDependency()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
n2.StackDependencies.Add(new DataDependency <int>(n1));
Assert.Equal(new[]
{
n1, n2
}, n2.GetOrderedDependencies());
}
/// <summary>
/// Creates a new Ast parser with the given <see cref="ControlFlowGraph{TInstruction}"/>
/// </summary>
/// <param name="controlFlowGraph">The <see cref="ControlFlowGraph{TInstruction}"/> to parse</param>
/// <param name="dataFlowGraph">The <see cref="DataFlowGraph{TContents}"/> to parse</param>
public AstParser(ControlFlowGraph <TInstruction> controlFlowGraph, DataFlowGraph <TInstruction> dataFlowGraph)
{
if (dataFlowGraph == null)
{
throw new ArgumentNullException(nameof(dataFlowGraph));
}
_controlFlowGraph = controlFlowGraph ?? throw new ArgumentNullException(nameof(controlFlowGraph));
_architecture = new AstArchitecture <TInstruction>(controlFlowGraph.Architecture);
var context = new AstParserContext <TInstruction>(_controlFlowGraph, dataFlowGraph);
_transformer = new BlockTransformer <TInstruction>(context);
}
public static void Main(string[] args)
{
try {
// register the channel
IiopClientChannel channel = new IiopClientChannel();
ChannelServices.RegisterChannel(channel);
Object obj = new Object();
try {
// access COS naming Service
NamingContext nameService = (NamingContext)RemotingServices.Connect(typeof(NamingContext), "corbaloc::localhost:2809/NameService");
Console.WriteLine("Got reference to nameService");
// get the reference to the Graph
NameComponent[] name = new NameComponent[] { new NameComponent("Foo", "Test") };
Console.WriteLine("About to resolve Foo.Test");
obj = (DataFlowGraph)nameService.resolve(name);
Console.WriteLine("Got reference to graph");
} catch (NotFound e) {
Console.WriteLine("Could not find graph in NameService");
return;
} catch (TRANSIENT e) {
Console.WriteLine("Could not contact NameService");
return;
}
if (obj == null)
{
Console.WriteLine("Reference to graph is null...");
return;
}
DataFlowGraph graph = (DataFlowGraph)obj;
KeyValuePair[] sink_attributes = new KeyValuePair[] { new KeyValuePair("name", "CORBA.Sink01") };
Console.WriteLine("About to create node");
Node sink = (Node)graph.create_node("CORBASink", sink_attributes);
Console.WriteLine("Created CORBA sink node");
Node[] nodes = graph.get_nodes();
foreach (Node n in nodes)
{
Console.WriteLine(n.get_attribute("ID"));
}
} catch (NotFound e) {
Console.WriteLine("Could not find graph in NameService");
} catch (TRANSIENT e) {
Console.WriteLine("Could not contact graph");
} catch (Exception e) {
Console.WriteLine("exception: " + e);
}
}
public void ShortLoopShouldThrowCyclicDependencyException()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
n1.StackDependencies.SetCount(1);
n1.StackDependencies[0].Add(n2);
n2.StackDependencies.SetCount(1);
n2.StackDependencies[0].Add(n1);
Assert.Throws <CyclicDependencyException>(() => n1.GetOrderedDependencies());
}
public void PathStackDependencyGraphShouldResultInOrder()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
var n3 = dfg.Nodes.Add(3, 3);
n3.StackDependencies.Add(new DataDependency <int>(n2));
n2.StackDependencies.Add(new DataDependency <int>(n1));
Assert.Equal(new[]
{
n1, n2, n3
}, n3.GetOrderedDependencies());
}
public void LongLoopShouldThrowCyclicDependencyException()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
var n3 = dfg.Nodes.Add(3, 3);
var n4 = dfg.Nodes.Add(4, 4);
n1.StackDependencies.Add(new DataDependency <int>(n2));
n2.StackDependencies.Add(new DataDependency <int>(n3));
n3.StackDependencies.Add(new DataDependency <int>(n4));
n4.StackDependencies.Add(new DataDependency <int>(n1));
Assert.Throws <CyclicDependencyException>(() => n1.GetOrderedDependencies());
}
public void UpdateOffsetsWithDuplicatedOffsetsShouldThrowAndDiscard()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n0 = dfg.Nodes.Add(0, 0);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
n1.Contents = 4;
n2.Contents = 4;
Assert.Throws <InvalidOperationException>(() => dfg.Nodes.UpdateIndices());
Assert.Equal(0, n0.Id);
Assert.Equal(1, n1.Id);
Assert.Equal(2, n2.Id);
}
public void MultipleStackDependenciesShouldResultInOrder()
{
var dfg = new DataFlowGraph <int>(IntArchitecture.Instance);
var n1 = dfg.Nodes.Add(1, 1);
var n2 = dfg.Nodes.Add(2, 2);
var n3 = dfg.Nodes.Add(3, 3);
n3.StackDependencies.SetCount(2);
n3.StackDependencies[0].Add(n1);
n3.StackDependencies[1].Add(n2);
Assert.Equal(new[]
{
n1, n2, n3
}, n3.GetOrderedDependencies());
}
/// <summary>
/// Builds the summary.
/// </summary>
private void BuildSummary()
{
this.ControlFlowGraph = new ControlFlowGraph(this);
var dataFlowGraph = new DataFlowGraph(this);
this.DataFlowGraph = dataFlowGraph;
this.DataFlowAnalysis = dataFlowGraph;
}
