Пример #1
0
        public void Test_AsmSourceTools_parseMemOperand()
        {
            // see intel manual : 3.7.5 Specifying an Offset

            // 32-bit mode:
            // possible bases: EAX, EBX, ECX, EDX, ESP, EBP, ESI, EDI
            // possible index: EAX, EBX, ECX, EDX,      EBP, ESI, EDI
            // scale: 1, 2, 4, 8
            // displacement none, 8-bit, 16-bit, 32-bit

            // 64-bit mode:
            // possible bases: RAX, RBX, RCX, RDX, RSP, RBP, RSI, RDI
            // possible index: RAX, RBX, RCX, RDX, RSP, RBP, RSI, RDI
            // scale: 1, 2, 4, 8
            // displacement none, 8-bit, 16-bit, 32-bit

            Random rnd = new Random((int)DateTime.Now.Ticks);

            Rn[] bases32 = new Rn[] { Rn.EAX, Rn.EBX, Rn.ECX, Rn.EDX, Rn.ESP, Rn.EBP, Rn.ESI, Rn.EDI };
            Rn[] index32 = new Rn[] { Rn.EAX, Rn.EBX, Rn.ECX, Rn.EDX, Rn.EBP, Rn.ESI, Rn.EDI };

            Rn[] bases64 = new Rn[] { Rn.RAX, Rn.RBX, Rn.RCX, Rn.RDX, Rn.RSP, Rn.RBP, Rn.RSI, Rn.RDI };
            Rn[] index74 = new Rn[] { Rn.RAX, Rn.RBX, Rn.RCX, Rn.RDX, Rn.RSP, Rn.RBP, Rn.RSI, Rn.RDI };

            int[] scales = new int[] { 0, 1, 2, 4, 8 };


            for (int i = 0; i < bases32.Length; ++i)
            {
                Rn b = bases32[i];

                {
                    string str = "[" + b + "]";
                    var    t   = AsmSourceTools.ParseMemOperand(str);
                    Assert.AreEqual(true, t.valid, str);
                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                    Assert.AreEqual(Rn.NOREG, t.indexReg, "index: " + str);
                    Assert.AreEqual(0, t.scale, "scale: " + str);
                    Assert.AreEqual(0, t.displacement, "displacement: " + str);
                }

                for (int j = 0; j < index32.Length; ++j)
                {
                    Rn idx = index32[j];

                    {
                        string str = "[" + b + "+" + idx + "]";
                        var    t   = AsmSourceTools.ParseMemOperand(str);
                        Assert.AreEqual(true, t.valid, str);
                        Assert.AreEqual(b, t.baseReg, "base: " + str);
                        Assert.AreEqual(idx, t.indexReg, "index: " + str);
                        Assert.AreEqual(1, t.scale, "scale: " + str);
                        Assert.AreEqual(0, t.displacement, "displacement: " + str);
                    }
                    {
                        string str = "[" + idx + "+" + b + "]";
                        var    t   = AsmSourceTools.ParseMemOperand(str);
                        Assert.AreEqual(true, t.valid, str);
                        //idx and base can be interchanged
                        //Assert.AreEqual(b, t.Item2, "base: " + str);
                        //Assert.AreEqual(idx, t.Item3, "index: " + str);
                        Assert.AreEqual(1, t.scale, "scale: " + str);
                        Assert.AreEqual(0, t.displacement, "displacement: " + str);
                    }

                    for (int k = 0; k < scales.Length; ++k)
                    {
                        int s = scales[k];

                        //Offset = Base + (Index * Scale) + Displacement
                        {
                            string str = "[" + b + "+" + idx + " * " + s + "]";
                            var    t   = AsmSourceTools.ParseMemOperand(str);
                            Assert.AreEqual(true, t.valid, str);
                            Assert.AreEqual(b, t.baseReg, "base: " + str);
                            Assert.AreEqual(idx, t.indexReg, "index: " + str);
                            Assert.AreEqual(s, t.scale, "scale: " + str);
                            Assert.AreEqual(0, t.displacement, "displacement: " + str);
                        }
                        {
                            string str = "[" + b + "+" + s + " * " + idx + "]";
                            var    t   = AsmSourceTools.ParseMemOperand(str);
                            Assert.AreEqual(true, t.valid, str);
                            Assert.AreEqual(b, t.baseReg, "base: " + str);
                            Assert.AreEqual(idx, t.indexReg, "index: " + str);
                            Assert.AreEqual(s, t.scale, "scale: " + str);
                            Assert.AreEqual(0, t.displacement, "displacement: " + str);
                        }
                        {
                            string str = "[" + s + " * " + idx + "+" + b + "]";
                            var    t   = AsmSourceTools.ParseMemOperand(str);
                            Assert.AreEqual(true, t.valid, str);
                            Assert.AreEqual(b, t.baseReg, "base: " + str);
                            Assert.AreEqual(idx, t.indexReg, "index: " + str);
                            Assert.AreEqual(s, t.scale, "scale: " + str);
                            Assert.AreEqual(0, t.displacement, "displacement: " + str);
                        }
                        {
                            string str = "[" + idx + " * " + s + "+" + b + "]";
                            var    t   = AsmSourceTools.ParseMemOperand(str);
                            Assert.AreEqual(true, t.valid, str);
                            Assert.AreEqual(b, t.baseReg, "base: " + str);
                            Assert.AreEqual(idx, t.indexReg, "index: " + str);
                            Assert.AreEqual(s, t.scale, "scale: " + str);
                            Assert.AreEqual(0, t.displacement, "displacement: " + str);
                        }

                        for (int m = 0; m < 10; ++m)
                        {
                            long disp = RandLong(32, rnd);
                            {
                                {
                                    string str = "[" + b + "+" + idx + " * " + s + "+" + disp + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + b + "+" + s + " * " + idx + "+" + disp + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + s + " * " + idx + "+" + b + "+" + disp + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + idx + " * " + s + "+" + b + "+" + disp + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                            }
                            {
                                {
                                    string str = "[" + disp + "+" + b + "+" + idx + " * " + s + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + b + "+" + disp + "+" + idx + " * " + s + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + b + "+" + disp + "+" + s + " * " + idx + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + s + " * " + idx + "+" + disp + "+" + b + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                                {
                                    string str = "[" + idx + " * " + s + "+" + disp + "+" + b + "]";
                                    var    t   = AsmSourceTools.ParseMemOperand(str);
                                    Assert.AreEqual(true, t.valid, str);
                                    Assert.AreEqual(b, t.baseReg, "base: " + str);
                                    Assert.AreEqual(idx, t.indexReg, "index: " + str);
                                    Assert.AreEqual(s, t.scale, "scale: " + str);
                                    Assert.AreEqual(disp, t.displacement, "displacement: " + str);
                                }
                            }
                        }
                    }
                }
            }
        }