Exemple #1
0
        public static void Switch(X86Assembler m)
        {
            m.Proc("foo");
            m.Push(m.cs);
            m.Pop(m.ds);
            m.Mov(m.bl, m.MemB(Registers.si, 0));
            m.Cmp(m.bl, 0x02);
            m.Ja("default");

            m.Label("test");
            m.Xor(m.bh, m.bh);
            m.Add(m.bx, m.bx);
            m.Jmp(m.MemW(Registers.bx, "jmptable"));

            m.Label("jmptable");
            m.Dw("one");
            m.Dw("two");
            m.Dw("three");

            m.Label("one");
            m.Mov(m.ax, 1);
            m.Ret();

            m.Label("two");
            m.Mov(m.ax, 2);
            m.Ret();

            m.Label("three");
            m.Mov(m.ax, 3);
            m.Ret();

            m.Label("default");
            m.Mov(m.ax, 0);
            m.Ret();
        }
Exemple #2
0
        public static void Switch32(X86Assembler m)
        {
            m.Proc("foo");
            m.Mov(m.eax, m.MemDw(Registers.esp, 4));
            m.Cmp(m.eax, 3);
            m.Ja("default");

            m.Xor(m.edx, m.edx);
            m.Mov(m.dl, m.MemB(Registers.eax, "bytes"));
            m.Jmp(m.MemDw(Registers.edx, 4, "jumps"));

            m.Label("bytes").Db(1, 0, 1, 2);
            m.Label("jumps").Dd("jump0", "jump1", "jump2");

            m.Label("jump0");
            m.Mov(m.eax, 0);
            m.Jmp("done");

            m.Label("jump1");
            m.Mov(m.eax, 1);
            m.Jmp("done");

            m.Label("jump2");
            m.Mov(m.eax, 2);
            m.Jmp("done");

            m.Label("default");
            m.Mov(m.eax, -1);

            m.Label("done");
            m.Mov(m.MemDw("dummy"), m.eax);
            m.Ret();

            m.Label("dummy").Dd(0);

        }
Exemple #3
0
        public override void Build(X86Assembler m)
        {
            m.i86();
            // A straight-forward factorial function + a driver program to ensure the return value 
            // is USE'd.

            m.Mov(cx, 0x100);
            m.Push(cx);
            m.Call("factorial");
            m.Add(Registers.sp, 2);
            m.Mov(m.WordPtr(0x0100), ax);
            m.Ret();

            m.Proc("factorial");
            m.Push(bp);
            m.Mov(bp, sp);

            m.Mov(ax, m.WordPtr(bp, 4));
            m.Dec(ax);
            m.Jz("base_case");

            m.Push(ax);
            m.Call("factorial");
            m.Inc(sp);
            m.Inc(sp);
            m.Mov(dx, m.WordPtr(bp, 4));
            m.Imul(dx);
            m.Jmp("done");

            m.Label("base_case");
            m.Mov(ax, 1);

            m.Label("done");
            m.Pop(bp);
            m.Ret();
            m.Endp("factorial");
        }
Exemple #4
0
        public void Scanner_CallGraphTree()
        {
            Program prog = new Program();
            var addr = Address.SegPtr(0xC00, 0);
            var m = new X86Assembler(new IntelArchitecture(ProcessorMode.Real), addr, new List<EntryPoint>());
            m.i86();

            m.Proc("main");
            m.Call("baz");
            m.Ret();
            m.Endp("main");

            m.Proc("foo");
            m.Ret();
            m.Endp("foo");

            m.Proc("bar");
            m.Ret();
            m.Endp("bar");

            m.Proc("baz");
            m.Call("foo");
            m.Call("bar");
            m.Jmp("foo");
            m.Endp("baz");

            var lr = m.GetImage();
            prog.Image = lr.Image;
            prog.ImageMap = lr.ImageMap;
            prog.Architecture = lr.Architecture;
            prog.Platform = new FakePlatform(null, arch);
            var proj = new Project { Programs = { prog } };
            var scan = new Scanner(prog, new Dictionary<Address, ProcedureSignature>(), new ImportResolver(proj), new FakeDecompilerEventListener());
            EntryPoint ep = new EntryPoint(addr, prog.Architecture.CreateProcessorState());
            scan.EnqueueEntryPoint(ep);
            scan.ScanImage();

            Assert.AreEqual(4, prog.Procedures.Count);
        }