public void EntryPointPopWithSingleItemOnStackShouldAddDependencyToExternalSource()
        {
            var instructions = new[]
            {
                DummyInstruction.Pop(0, 1),
                DummyInstruction.Ret(1),
            };

            var dfgBuilder = new DummyTransitionResolver();
            var argument   = new ExternalDataSourceNode <DummyInstruction>(-1, "Argument 1");

            dfgBuilder.DataFlowGraph.Nodes.Add(argument);
            dfgBuilder.InitialState = new SymbolicProgramState <DummyInstruction>();
            dfgBuilder.InitialState.Stack.Push(new SymbolicValue <DummyInstruction>(argument));

            var cfgBuilder = new SymbolicFlowGraphBuilder <DummyInstruction>(
                DummyArchitecture.Instance,
                instructions,
                dfgBuilder);

            cfgBuilder.ConstructFlowGraph(0);
            var dfg = dfgBuilder.DataFlowGraph;

            Assert.Equal(new[] { argument }, dfg.Nodes[0].StackDependencies[0].GetNodes());
        }
Exemple #2
0
        private ControlFlowGraph <Statement <DummyInstruction> > ConstructAst(
            IEnumerable <DummyInstruction> instructions)
        {
            var architecture = DummyArchitecture.Instance;

            var dfgBuilder = new DummyTransitionResolver();
            var cfgBuilder = new SymbolicFlowGraphBuilder <DummyInstruction>(architecture, instructions, dfgBuilder);

            var cfg        = cfgBuilder.ConstructFlowGraph(0);
            var astBuilder = new AstParser <DummyInstruction>(cfg, dfgBuilder.DataFlowGraph);

            return(astBuilder.Parse());
        }
        private static (ControlFlowGraph <DummyInstruction> cfg, DataFlowGraph <DummyInstruction> dfg) BuildFlowGraphs(
            DummyInstruction[] instructions,
            long entrypoint = 0,
            IEnumerable <long> knownBlockHeaders = null)
        {
            var dfgBuilder = new DummyTransitionResolver();
            var cfgBuilder = new SymbolicFlowGraphBuilder <DummyInstruction>(
                DummyArchitecture.Instance,
                instructions,
                dfgBuilder);

            var cfg = cfgBuilder.ConstructFlowGraph(entrypoint, knownBlockHeaders ?? ImmutableArray <long> .Empty);

            return(cfg, dfgBuilder.DataFlowGraph);
        }
        public void EntryPointPopWithInitialStateEmptyShouldThrow()
        {
            var instructions = new[]
            {
                DummyInstruction.Pop(0, 1),
                DummyInstruction.Ret(1),
            };

            var dfgBuilder = new DummyTransitionResolver
            {
                InitialState = new SymbolicProgramState <DummyInstruction>()
            };

            var cfgBuilder = new SymbolicFlowGraphBuilder <DummyInstruction>(
                DummyArchitecture.Instance,
                instructions,
                dfgBuilder);

            Assert.Throws <StackImbalanceException>(() => cfgBuilder.ConstructFlowGraph(0));
        }