public void Test()
        {
            var instructions = new[]
            {
                new M68kInstruction(M68kOpcode.Move, 4, d0),
                new M68kInstruction(M68kOpcode.Move, d0, d1),
                new M68kInstruction(M68kOpcode.Move, 1, d3),
                new M68kInstruction(M68kOpcode.Move, d1, d2),
                new M68kInstruction(M68kOpcode.Move, d2, d0),
                new M68kInstruction(M68kOpcode.Rts)
            };

            var la = new LivenessAnalysis(instructions);

            var g     = InterferenceGraphGenerator.MakeGraph(la.Nodes, RegType.Data, "D0,D1,D2,D3,D4,D5,D6,D7".Split(',').ToList());
            var graph = g.Graph;

            Assert.IsTrue(graph.Contains(new Tuple <string, string>("D1", "D3")) || graph.Contains(new Tuple <string, string>("D3", "D1")));
            Assert.IsFalse(graph.Contains(new Tuple <string, string>("D1", "D1")));
        }
示例#2
0
        public void BranchesTest()
        {
            var d20 = new Register {
                Type = RegType.Data, Number = 20
            };
            var d21 = new Register {
                Type = RegType.Data, Number = 21
            };
            var d22 = new Register {
                Type = RegType.Data, Number = 22
            };
            var d23 = new Register {
                Type = RegType.Data, Number = 23
            };
            var d24 = new Register {
                Type = RegType.Data, Number = 24
            };
            var d25 = new Register {
                Type = RegType.Data, Number = 25
            };

            var a7 = new Register {
                Type = RegType.Address, Number = 7
            };
            var a8 = new Register {
                Type = RegType.Address, Number = 7
            };
            var a15 = new Register {
                Type = RegType.Address, Number = 15
            };
            var a16 = new Register {
                Type = RegType.Address, Number = 15
            };

            var instructions = new[]
            {
                new M68kInstruction(M68kOpcode.Move, d20, d21),
                new M68kInstruction(M68kOpcode.Add, -1, d21),
                new M68kInstruction(M68kOpcode.Jmp)
                {
                    TargetLabel = "for$body0$7"
                },
                new M68kInstruction(M68kOpcode.Label)
                {
                    Label = "for$body0"
                },
                new M68kInstruction(M68kOpcode.Label)
                {
                    Label = "for$body0$7"
                },
                new M68kInstruction(M68kOpcode.MoveQ, 0, d22),
                new M68kInstruction(M68kOpcode.Jmp)
                {
                    TargetLabel = "for$body0$end"
                },
                new M68kInstruction(M68kOpcode.Label)
                {
                    Label = "for$body0$8"
                },
                new M68kInstruction(M68kOpcode.Jmp)
                {
                    TargetLabel = "for$body0$end"
                },
                new M68kInstruction(M68kOpcode.Label)
                {
                    Label = "for$body0$end"
                },
                new M68kInstruction(M68kOpcode.MoveQ, d21, d23),
                new M68kInstruction(M68kOpcode.Sub, d22, d23),
                new M68kInstruction(M68kOpcode.Move, a7, a15),
                new M68kInstruction(M68kOpcode.Adda, d23, a15),
                new M68kInstruction(M68kOpcode.Move, a15, d24),
                new M68kInstruction(M68kOpcode.Move, a8, a16),

                new M68kInstruction(M68kOpcode.Adda, d22, a16),
                new M68kInstruction(M68kOpcode.Move, d24, a16),
                new M68kInstruction(M68kOpcode.Move, d22, d25),
                new M68kInstruction(M68kOpcode.Adda, 1, d25),
                new M68kInstruction(M68kOpcode.Cmp, d20, d25),
                new M68kInstruction(M68kOpcode.Beq)
                {
                    TargetLabel = "for$end$loopexit0"
                },
                new M68kInstruction(M68kOpcode.Move, d25, d22),
                new M68kInstruction(M68kOpcode.Jmp)
                {
                    TargetLabel = "for$body0$8"
                },
                new M68kInstruction(M68kOpcode.Label)
                {
                    Label = "for$end$loopexit0"
                },
            };

            var la = new LivenessAnalysis(instructions);

            var gr = InterferenceGraphGenerator.MakeGraph(la.Nodes, RegType.Data, new List <string>());

            Assert.IsTrue(gr.IsEdgeBetween("D21", "D20"));
            Assert.IsTrue(gr.IsEdgeBetween("D21", "D22"));
            Assert.IsTrue(gr.IsEdgeBetween("D21", "D23"));
            Assert.IsTrue(gr.IsEdgeBetween("D21", "D24"));
            Assert.IsTrue(gr.IsEdgeBetween("D21", "D25"));

            Assert.IsFalse(gr.IsEdgeBetween("D23", "D24"));
            Assert.IsFalse(gr.IsEdgeBetween("D23", "D25"));
            Assert.IsFalse(gr.IsEdgeBetween("D24", "D25"));

            Assert.IsTrue(gr.IsEdgeBetween("D22", "D20"));
            Assert.IsTrue(gr.IsEdgeBetween("D22", "D23"));
            Assert.IsTrue(gr.IsEdgeBetween("D22", "D24"));
            Assert.IsFalse(gr.IsEdgeBetween("D22", "D25"));

            /*
             *  add.l #1,D25_
             *  cmp.l D20_,D25_
             *  beq for$end$loopexit0
             *  move.l D25_,D22_
             *  jmp for$body0$8
             * for$end$loopexit0:
             */
        }
        public void Test2()
        {
            var b = d11;
            var c = d12;
            var d = d13;
            var e = d14;
            var f = d15;
            var g = d16;
            var h = d17;
            var j = d19;
            var k = d20;
            var m = d21;

            /*
             * g := mem[j+12]
             * h := k - 1
             * f := g * h
             * e := mem[j+8]
             * m := mem[j+16]
             * b := mem[f]
             * c := e + 8
             * d := c
             * k := m + 4
             * j := b*/

            var instructions = new[]
            {
                M68kInstruction.LoadFromMemory(j, g),

                new M68kInstruction(M68kOpcode.Move, k, d0),
                new M68kInstruction(M68kOpcode.Sub, 1, d0),
                new M68kInstruction(M68kOpcode.Move, d0, h),

                new M68kInstruction(M68kOpcode.Move, g, d0),
                new M68kInstruction(M68kOpcode.Add, h, d0),
                new M68kInstruction(M68kOpcode.Move, d0, f),

                M68kInstruction.LoadFromMemory(j, e),
                M68kInstruction.LoadFromMemory(j, m),
                M68kInstruction.LoadFromMemory(f, b),

                new M68kInstruction(M68kOpcode.Move, e, d0),
                new M68kInstruction(M68kOpcode.Add, 8, d0),
                new M68kInstruction(M68kOpcode.Move, d0, c),

                new M68kInstruction(M68kOpcode.Move, c, d),

                new M68kInstruction(M68kOpcode.Move, m, d0),
                new M68kInstruction(M68kOpcode.Add, 4, d0),
                new M68kInstruction(M68kOpcode.Move, d0, k),

                new M68kInstruction(M68kOpcode.Move, b, j),

                // Cause Live out: d k j

                M68kInstruction.StoreToMemory(d, j),
                M68kInstruction.StoreToMemory(k, j),
                M68kInstruction.StoreToMemory(j, j),

                //new M68kInstruction(M68kOpcode.Rts)
            };

            var la = new LivenessAnalysis(instructions);

            var gr = InterferenceGraphGenerator.MakeGraph(la.Nodes, RegType.Data, "D0,D1,D2,D3,D4,D5,D6,D7".Split(',').ToList());

            AssertEdge(gr, j, f);
            AssertEdge(gr, j, e);
            AssertEdge(gr, j, k);
            AssertEdge(gr, j, h);
            AssertEdge(gr, j, g);

            AssertEdge(gr, f, e);
            AssertEdge(gr, f, m);
            AssertEdge(gr, f, m);

            AssertEdge(gr, k, b);
            AssertEdge(gr, k, d);
            AssertEdge(gr, k, g);

            AssertEdge(gr, h, g);

            AssertEdge(gr, b, m);
            AssertEdge(gr, b, c);
            AssertEdge(gr, b, d);

            AssertNoEdge(gr, j, b);
            AssertNoEdge(gr, d, c);
        }