Add tests for RIP rel/abs with AT&T/Intel syntax.

Also adds x86 tests that check the same absolute addressing.

suite/regress/x64_rip_rel_abs.py

+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test RIP relative and absolute addressing
+
+# Github issue: #32
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmRel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to NASM
+        ks.syntax = KS_OPT_SYNTAX_NASM
+
+        # nasm uses rel for rip relative addressing
+        encoding, count = ks.asm("lea rax, [rel __data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+        # verify that rip relative addressing is indeed rip relative
+        encoding, count = ks.asm("nop\nnop\nlea rax, [rel __data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64NasmAbs(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to NASM
+        ks.syntax = KS_OPT_SYNTAX_NASM
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm("lea rax, [abs __data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm("nop\nnop\nlea rax, [abs __data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+class TestX64AttRel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to AT&T
+        ks.syntax = KS_OPT_SYNTAX_ATT
+
+        # at&t syntax uses symbol(%rip) for rip relative addressing
+        encoding, count = ks.asm("lea __data(%rip), %rax\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+        # verify that rip relative addressing is indeed rip relative
+        encoding, count = ks.asm("nop\nnop\nlea __data(%rip), %rax\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64AttAbs(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to AT&T
+        ks.syntax = KS_OPT_SYNTAX_ATT
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm("lea __data, %rax\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm("nop\nnop\nlea __data, %rax\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+class TestX64IntelRel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to intel
+        ks.syntax = KS_OPT_SYNTAX_INTEL
+
+        # nasm uses rel for rip relative addressing
+        encoding, count = ks.asm("lea rax, [rip + __data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+        # verify that rip relative addressing is indeed rip relative
+        encoding, count = ks.asm("nop\nnop\nlea rax, [rip + __data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64IntelAbs(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_64)
+        # change the syntax to intel
+        ks.syntax = KS_OPT_SYNTAX_INTEL
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm("lea rax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x48, 0x8d, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm("nop\nnop\nlea rax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+    regress.main()

suite/regress/x86_lea_label.py

+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test RIP relative and absolute addressing
+
+# Github issue: #32
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX86Nasm(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_32)
+        # change the syntax to NASM
+        ks.syntax = KS_OPT_SYNTAX_NASM
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm("lea eax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x8d, 0x05, 0x06, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm("nop\nnop\nlea eax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x8d, 0x05, 0x08, 0x00, 0x00, 0x00 ])
+
+
+class TestX86Att(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_32)
+        # change the syntax to AT&T
+        ks.syntax = KS_OPT_SYNTAX_ATT
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm("lea __data, %eax\n__data:")
+        self.assertEqual(encoding, [ 0x8d, 0x05, 0x06, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm("nop\nnop\nlea __data, %eax\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x8d, 0x05, 0x08, 0x00, 0x00, 0x00 ])
+
+
+class TestX64Intel(regress.RegressTest):
+    def runTest(self):
+        # Initialize Keystone engine
+        ks = Ks(KS_ARCH_X86, KS_MODE_32)
+        # change the syntax to intel
+        ks.syntax = KS_OPT_SYNTAX_INTEL
+
+        # nasm uses abs for explicit absolute addressing
+        encoding, count = ks.asm("lea eax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x8d, 0x05, 0x06, 0x00, 0x00, 0x00 ])
+
+        # verify that explicit absolute addressing is indeed absolute
+        encoding, count = ks.asm("nop\nnop\nlea eax, [__data]\n__data:")
+        self.assertEqual(encoding, [ 0x90, 0x90, 0x8d, 0x05, 0x08, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+    regress.main()

suite/regress/x86_nasm_rel_abs.py

-#!/usr/bin/python
-# Nguyen Anh Quynh, 2016
-
-# This is to test NASM syntax RIP relative and absolute addressing
-
-# Github issue: #32
-# Author: Ingmar Steen
-
-from keystone import *
-
-import regress
-
-class TestX86_64(regress.RegressTest):
-    def runTest(self):
-        # Initialize Keystone engine
-        ks = Ks(KS_ARCH_X86, KS_MODE_64)
-        # change the syntax to NASM
-        ks.syntax = KS_OPT_SYNTAX_NASM
-
-        # nasm uses rel for rip relative addressing
-        encoding, count = ks.asm("lea rax, [rel __data]\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-        # verify that rip relative addressing is indeed rip relative
-        encoding, count = ks.asm("nop\nnop\nlea rax, [rel __data]\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
-
-        # nasm uses abs for explicit absolute addressing
-        encoding, count = ks.asm("lea rax, [abs __data]\n__data:")
-        self.assertEqual(encoding, [ 0x48, 0x8b, 0x04, 0x25, 0x08, 0x00, 0x00, 0x00 ])
-
-        # verify that explicit absolute addressing is indeed absolute
-        encoding, count = ks.asm("nop\nnop\nlea rax, [abs __data]\n__data:")
-        self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8b, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
-
-if __name__ == '__main__':
-    regress.main()