コード例 #1
0
ファイル: BlockWorkitemTests.cs プロジェクト: xor2003/reko
        public void Bwi_Branch_DelaySlot()
        {
            var l00100008 = new Block(proc, "l00100008");
            var l00100100 = new Block(proc, "l00101000");

            scanner.Stub(f => f.FindContainingBlock(Address.Ptr32(0x100000))).Return(block);
            scanner.Stub(f => f.FindContainingBlock(Address.Ptr32(0x100004))).Return(block);
            scanner.Stub(f => f.FindContainingBlock(Address.Ptr32(0x100008))).Return(l00100008);
            scanner.Stub(f => f.FindContainingBlock(Address.Ptr32(0x10000C))).Return(null);
            scanner.Stub(s => s.GetTrace(null, null, null)).IgnoreArguments().Return(trace);
            scanner.Stub(s => s.EnqueueJumpTarget(
                             Arg <Address> .Is.Equal(Address.Ptr32(0x00100004)),
                             Arg <Address> .Is.Equal(Address.Ptr32(0x00101000)),
                             Arg <Procedure> .Is.Equal(proc),
                             Arg <ProcessorState> .Is.NotNull)).Return(l00100100);
            scanner.Stub(s => s.EnqueueJumpTarget(
                             Arg <Address> .Is.Equal(Address.Ptr32(0x00100004)),
                             Arg <Address> .Is.Equal(Address.Ptr32(0x00100008)),
                             Arg <Procedure> .Is.Equal(proc),
                             Arg <ProcessorState> .Is.NotNull)).Return(l00100008);
            mr.ReplayAll();

            trace.Add(m => m.Branch(r1, Address.Ptr32(0x101000), RtlClass.ConditionalTransfer | RtlClass.Delay));
            trace.Add(m => m.Assign(r0, r1));   // 100004
            trace.Add(m => m.Assign(r2, r1));   // 100008

            var wi = CreateWorkItem(Address.Ptr32(0x100000), new FakeProcessorState(arch));

            wi.Process();

            Assert.AreEqual("branch r1 l00100000_ds_t", block.Statements[0].ToString());
            var blFalse = block.ElseBlock;
            var blTrue  = block.ThenBlock;

            proc.Dump(true);
            Assert.AreEqual("l00100000_ds_f", blFalse.Name);     // delay-slot-false
            Assert.AreEqual(1, blFalse.Statements.Count);
            Assert.AreEqual("r0 = r1", blFalse.Statements[0].ToString());
            Assert.AreEqual(1, blFalse.Succ.Count);
            Assert.AreEqual("l00100008", blFalse.Succ[0].Name);

            Assert.AreEqual("l00100000_ds_t", blTrue.Name);      // delay-slot-true
            Assert.AreEqual(1, blTrue.Statements.Count);
            Assert.AreEqual("r0 = r1", blTrue.Statements[0].ToString());
            Assert.AreEqual(1, blTrue.Succ.Count);
            Assert.AreEqual("l00101000", blTrue.Succ[0].Name);
        }
コード例 #2
0
 public void Transform()
 {
     foreach (var block in proc.ControlGraph.Blocks)
     {
         ReplaceLongAdditions(block);
     }
     proc.Dump(true);
 }
コード例 #3
0
 public static void DumpWatchedProcedure(string caption, Procedure proc)
 {
     if (proc.Name == "fn00100000")
     {
         Debug.Print("// {0}: {1} ==================", proc.Name, caption);
         MockGenerator.DumpMethod(proc);
         proc.Dump(true);
     }
 }
コード例 #4
0
        public void Transform()
        {
            do
            {
                dirty = false;

                foreach (var block in new DfsIterator <Block>(proc.ControlGraph).PostOrder().ToList())
                {
                    if (block == null)
                    {
                        continue;
                    }

                    if (EndsInBranch(block))
                    {
                        if (BranchTargetsEqual(block))
                        {
                            ReplaceBranchWithJump(block);
                        }
                    }

                    if (EndsInJump(block))
                    {
                        Block next = block.Succ[0];
                        if (block != proc.EntryBlock &&
                            block.Statements.Count == 0 &&
                            next.Pred.Count == 1)
                        {
                            if (Block.ReplaceJumpsTo(block, next))
                            {
                                dirty = true;
                            }
                        }
                        if (next.Pred.Count == 1 && next != proc.ExitBlock)
                        {
                            Coalesce(block, next);
                        }
#if IGNORE
                        // This bollixes up the graphs for ForkedLoop.asm, so we can't use it.
                        // It's not as important as the other three clean stages.

                        else if (EndsInBranch(next) && next.Statements.Count == 1)
                        {
                            ReplaceJumpWithBranch(block, next);
                        }
#endif
                    }
                }
            } while (dirty);

            proc.Dump(true);
        }
コード例 #5
0
 private void RunTest(string sExp)
 {
     try
     {
         GenCode(proc, sb);
         Assert.AreEqual(sExp, sb.ToString());
     }
     catch
     {
         proc.Dump(true);
         Console.WriteLine(sb.ToString());
         throw;
     }
 }
コード例 #6
0
 public void DumpWatchedProcedure(string phase, string caption, Procedure proc)
 {
     if (program.User.DebugTraceProcedures.Contains(proc.Name))
     {
         Debug.Print("// {0}: {1} ==================", proc.Name, caption);
         //MockGenerator.DumpMethod(proc);
         proc.Dump(true);
         var testSvc = this.services.GetService <ITestGenerationService>();
         if (testSvc != null)
         {
             if (!this.phaseNumbering.TryGetValue(phase, out int n))
             {
                 n = phaseNumbering.Count + 1;
                 phaseNumbering.Add(phase, n);
             }
             testSvc.ReportProcedure($"analysis_{n:00}_{phase}.txt", $"// {proc.Name} ===========", proc);
         }
     }
 }
コード例 #7
0
        public void Liv_CreateDecTest()
        {
            Prepare(delegate(ProcedureBuilder m)
            {
                Identifier id = m.Local32("id");
                m.Assign(id, Constant.Word32(10));
                m.Label("loop");
                m.Assign(id, m.ISub(id, 1));
                m.BranchIf(m.Ge(id, 0), "loop");
                m.Store(m.Word32(0x4232), id);
                m.Return(id);
            });
            proc.Dump(true);
            var liv = new LinearInductionVariableFinder(proc, ssaIds, doms);

            liv.Find();
            var iv = liv.InductionVariables[0];

            Assert.AreEqual("(9 -1 -1 signed)", iv.ToString());
        }
コード例 #8
0
        private void Prepare(Procedure proc)
        {
            this.proc = proc;
            doms      = proc.CreateBlockDominatorGraph();
            SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, doms);
            SsaState     ssa = sst.SsaState;

            ssaIds = ssa.Identifiers;

            var cce = new ConditionCodeEliminator(ssaIds, new DefaultPlatform(null, new FakeArchitecture()));

            cce.Transform();

            DeadCode.Eliminate(proc, ssa);

            var vp = new ValuePropagator(ssa.Identifiers, proc);

            vp.Transform();

            DeadCode.Eliminate(proc, ssa);
            proc.Dump(true); //$DEBUG
        }
コード例 #9
0
		private void Build(Procedure proc, IProcessorArchitecture arch)
		{
            var platform = new DefaultPlatform(null, arch);
			this.proc = proc;
			Aliases alias = new Aliases(proc, arch);
			alias.Transform();
			var gr = proc.CreateBlockDominatorGraph();
			SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, gr);
			SsaState ssa = sst.SsaState;
			this.ssaIds = ssa.Identifiers;

			ConditionCodeEliminator cce = new ConditionCodeEliminator(ssa.Identifiers, platform);
			cce.Transform();
			DeadCode.Eliminate(proc, ssa);

			ValuePropagator vp = new ValuePropagator(ssa.Identifiers, proc);
			vp.Transform();

			Coalescer coa = new Coalescer(proc, ssa);
			coa.Transform();

			DeadCode.Eliminate(proc, ssa);
            proc.Dump(true, false); //$DEBUG
		}
コード例 #10
0
		private void Prepare(Procedure proc)
		{
			this.proc = proc;
            doms = proc.CreateBlockDominatorGraph();
			SsaTransform sst = new SsaTransform(new ProgramDataFlow(), proc, doms);
			SsaState ssa = sst.SsaState;
			ssaIds = ssa.Identifiers;

			var cce = new ConditionCodeEliminator(ssaIds, new DefaultPlatform(null,new FakeArchitecture()));
			cce.Transform();

			DeadCode.Eliminate(proc, ssa);

			var vp = new ValuePropagator(ssa.Identifiers, proc);
			vp.Transform();

			DeadCode.Eliminate(proc, ssa);
            proc.Dump(true, false); //$DEBUG
		}