diff --git a/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp b/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
index a6eb3eb27f18f82da479409c0e8df8f8f8edeeac..6652fc4f65bfb16c45a36e33c73798154057cfd7 100644
--- a/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
+++ b/llvm/lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp
@@ -631,7 +631,7 @@ getThumbBLTargetOpValue(const MCInst &MI, unsigned OpIdx,
if (MO.isExpr())
return ::getBranchTargetOpValue(MI, OpIdx, ARM::fixup_arm_thumb_bl,
Fixups, STI);
- return encodeThumbBLOffset(MO.getImm());
+ return encodeThumbBLOffset(MO.getImm() - MI.getAddress() - 4);
}
/// getThumbBLXTargetOpValue - Return encoding info for Thumb immediate
@@ -644,7 +644,7 @@ getThumbBLXTargetOpValue(const MCInst &MI, unsigned OpIdx,
if (MO.isExpr())
return ::getBranchTargetOpValue(MI, OpIdx, ARM::fixup_arm_thumb_blx,
Fixups, STI);
- return encodeThumbBLOffset(MO.getImm());
+ return encodeThumbBLOffset(MO.getImm() - MI.getAddress() - 4);
}
/// getThumbBRTargetOpValue - Return encoding info for Thumb branch target.
diff --git a/suite/regress/arm_blx_rel_thumb.py b/suite/regress/arm_blx_rel_thumb.py
new file mode 100755
index 0000000000000000000000000000000000000000..d39469202bc83d5b84a38b4727c2d01aa5499ab3
--- /dev/null
+++ b/suite/regress/arm_blx_rel_thumb.py
@@ -0,0 +1,26 @@
+#!/usr/bin/python
+# example on how to code a Keystone regression in Python
+# Nguyen Anh Quynh, 2016
+
+# This tests the relative BLX instruction for Thumb-mode
+
+# Fill in the information in the form below when you create a new regression
+
+# Github issue: #36
+# Author: Edgar Barbosa
+
+from keystone import *
+
+import regress
+
+class TestARM(regress.RegressTest):
+ def runTest(self):
+ # Initialize Keystone engine
+ ks = Ks(KS_ARCH_ARM, KS_MODE_THUMB)
+ # Assemble to get back insn encoding & statement count
+ encoding, count = ks.asm(b"blx 0x86535200",addr=0x865351d4)
+ # Assert the result
+ self.assertEqual(encoding, [ 0x0, 0xf0, 0x14, 0xe8 ])
+
+if __name__ == '__main__':
+ regress.main()
diff --git a/suite/regress/x64_lea_label.py b/suite/regress/x64_lea_label.py
new file mode 100755
index 0000000000000000000000000000000000000000..f75cd6daee99b54d9bc4b4596cc1f7cdccd5feb9
--- /dev/null
+++ b/suite/regress/x64_lea_label.py
@@ -0,0 +1,63 @@
+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test label addressing on X86_64
+
+# Github issue: #34
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmLabel(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(b"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(b"nop\nnop\nlea rax, [__data]\n__data:")
+ self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+class TestX64AttLabel(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(b"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(b"nop\nnop\nlea __data, %rax\n__data:")
+ self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+class TestX64IntelLabel(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(b"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(b"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()
diff --git a/suite/regress/x64_lea_label_nasm_abs.py b/suite/regress/x64_lea_label_nasm_abs.py
new file mode 100755
index 0000000000000000000000000000000000000000..6c8797ec2590bcbe9e4e7e9f0a80af016779de14
--- /dev/null
+++ b/suite/regress/x64_lea_label_nasm_abs.py
@@ -0,0 +1,31 @@
+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test nasm syntax' explicit abs addressing
+
+# Github issue: #32
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmLabelAbs(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(b"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(b"nop\nnop\nlea rax, [abs __data]\n__data:")
+ self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x04, 0x25, 0x0a, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+ regress.main()
diff --git a/suite/regress/x64_lea_label_rel.py b/suite/regress/x64_lea_label_rel.py
new file mode 100755
index 0000000000000000000000000000000000000000..9833f174f85a95f71b6d95cc3b9b402ea4f6150c
--- /dev/null
+++ b/suite/regress/x64_lea_label_rel.py
@@ -0,0 +1,64 @@
+#!/usr/bin/python
+# Ingmar Steen, 2016
+
+# This is to test RIP relative and absolute addressing using all
+# available syntaxes.
+
+# Github issue: #32
+# Author: Ingmar Steen
+
+from keystone import *
+
+import regress
+
+
+class TestX64NasmLabelRel(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(b"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(b"nop\nnop\nlea rax, [rel __data]\n__data:")
+ self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64AttLabelRel(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(b"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(b"nop\nnop\nlea __data(%rip), %rax\n__data:")
+ self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+class TestX64IntelLabelRel(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
+
+ # intel uses rip + label for rip relative addressing
+ encoding, count = ks.asm(b"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(b"nop\nnop\nlea rax, [rip + __data]\n__data:")
+ self.assertEqual(encoding, [ 0x90, 0x90, 0x48, 0x8d, 0x05, 0x00, 0x00, 0x00, 0x00 ])
+
+
+if __name__ == '__main__':
+ regress.main()
diff --git a/suite/regress/x64_rip_rel_abs.py b/suite/regress/x64_rip_rel_abs.py
deleted file mode 100755
index 8624af3f9ad6d79685b0442079480bf680a0a1e3..0000000000000000000000000000000000000000
--- a/suite/regress/x64_rip_rel_abs.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/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(b"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(b"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(b"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(b"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(b"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(b"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(b"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(b"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(b"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(b"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(b"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(b"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()