asmjit 0.2.0 → 0.2.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (204) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile.lock +1 -1
  3. data/Rakefile +5 -3
  4. data/asmjit.gemspec +1 -3
  5. data/ext/asmjit/asmjit/.editorconfig +10 -0
  6. data/ext/asmjit/asmjit/.github/FUNDING.yml +1 -0
  7. data/ext/asmjit/asmjit/.github/workflows/build-config.json +47 -0
  8. data/ext/asmjit/asmjit/.github/workflows/build.yml +156 -0
  9. data/ext/asmjit/asmjit/.gitignore +6 -0
  10. data/ext/asmjit/asmjit/CMakeLists.txt +611 -0
  11. data/ext/asmjit/asmjit/LICENSE.md +17 -0
  12. data/ext/asmjit/asmjit/README.md +69 -0
  13. data/ext/asmjit/asmjit/src/asmjit/a64.h +62 -0
  14. data/ext/asmjit/asmjit/src/asmjit/arm/a64archtraits_p.h +81 -0
  15. data/ext/asmjit/asmjit/src/asmjit/arm/a64assembler.cpp +5115 -0
  16. data/ext/asmjit/asmjit/src/asmjit/arm/a64assembler.h +72 -0
  17. data/ext/asmjit/asmjit/src/asmjit/arm/a64builder.cpp +51 -0
  18. data/ext/asmjit/asmjit/src/asmjit/arm/a64builder.h +57 -0
  19. data/ext/asmjit/asmjit/src/asmjit/arm/a64compiler.cpp +60 -0
  20. data/ext/asmjit/asmjit/src/asmjit/arm/a64compiler.h +247 -0
  21. data/ext/asmjit/asmjit/src/asmjit/arm/a64emithelper.cpp +464 -0
  22. data/ext/asmjit/asmjit/src/asmjit/arm/a64emithelper_p.h +50 -0
  23. data/ext/asmjit/asmjit/src/asmjit/arm/a64emitter.h +1228 -0
  24. data/ext/asmjit/asmjit/src/asmjit/arm/a64formatter.cpp +298 -0
  25. data/ext/asmjit/asmjit/src/asmjit/arm/a64formatter_p.h +59 -0
  26. data/ext/asmjit/asmjit/src/asmjit/arm/a64func.cpp +189 -0
  27. data/ext/asmjit/asmjit/src/asmjit/arm/a64func_p.h +33 -0
  28. data/ext/asmjit/asmjit/src/asmjit/arm/a64globals.h +1894 -0
  29. data/ext/asmjit/asmjit/src/asmjit/arm/a64instapi.cpp +278 -0
  30. data/ext/asmjit/asmjit/src/asmjit/arm/a64instapi_p.h +41 -0
  31. data/ext/asmjit/asmjit/src/asmjit/arm/a64instdb.cpp +1957 -0
  32. data/ext/asmjit/asmjit/src/asmjit/arm/a64instdb.h +74 -0
  33. data/ext/asmjit/asmjit/src/asmjit/arm/a64instdb_p.h +876 -0
  34. data/ext/asmjit/asmjit/src/asmjit/arm/a64operand.cpp +85 -0
  35. data/ext/asmjit/asmjit/src/asmjit/arm/a64operand.h +312 -0
  36. data/ext/asmjit/asmjit/src/asmjit/arm/a64rapass.cpp +852 -0
  37. data/ext/asmjit/asmjit/src/asmjit/arm/a64rapass_p.h +105 -0
  38. data/ext/asmjit/asmjit/src/asmjit/arm/a64utils.h +179 -0
  39. data/ext/asmjit/asmjit/src/asmjit/arm/armformatter.cpp +143 -0
  40. data/ext/asmjit/asmjit/src/asmjit/arm/armformatter_p.h +44 -0
  41. data/ext/asmjit/asmjit/src/asmjit/arm/armglobals.h +21 -0
  42. data/ext/asmjit/asmjit/src/asmjit/arm/armoperand.h +621 -0
  43. data/ext/asmjit/asmjit/src/asmjit/arm.h +62 -0
  44. data/ext/asmjit/asmjit/src/asmjit/asmjit-scope-begin.h +17 -0
  45. data/ext/asmjit/asmjit/src/asmjit/asmjit-scope-end.h +9 -0
  46. data/ext/asmjit/asmjit/src/asmjit/asmjit.h +33 -0
  47. data/ext/asmjit/asmjit/src/asmjit/core/api-build_p.h +55 -0
  48. data/ext/asmjit/asmjit/src/asmjit/core/api-config.h +613 -0
  49. data/ext/asmjit/asmjit/src/asmjit/core/archcommons.h +229 -0
  50. data/ext/asmjit/asmjit/src/asmjit/core/archtraits.cpp +160 -0
  51. data/ext/asmjit/asmjit/src/asmjit/core/archtraits.h +290 -0
  52. data/ext/asmjit/asmjit/src/asmjit/core/assembler.cpp +406 -0
  53. data/ext/asmjit/asmjit/src/asmjit/core/assembler.h +129 -0
  54. data/ext/asmjit/asmjit/src/asmjit/core/builder.cpp +889 -0
  55. data/ext/asmjit/asmjit/src/asmjit/core/builder.h +1391 -0
  56. data/ext/asmjit/asmjit/src/asmjit/core/codebuffer.h +113 -0
  57. data/ext/asmjit/asmjit/src/asmjit/core/codeholder.cpp +1149 -0
  58. data/ext/asmjit/asmjit/src/asmjit/core/codeholder.h +1035 -0
  59. data/ext/asmjit/asmjit/src/asmjit/core/codewriter.cpp +175 -0
  60. data/ext/asmjit/asmjit/src/asmjit/core/codewriter_p.h +179 -0
  61. data/ext/asmjit/asmjit/src/asmjit/core/compiler.cpp +582 -0
  62. data/ext/asmjit/asmjit/src/asmjit/core/compiler.h +737 -0
  63. data/ext/asmjit/asmjit/src/asmjit/core/compilerdefs.h +173 -0
  64. data/ext/asmjit/asmjit/src/asmjit/core/constpool.cpp +363 -0
  65. data/ext/asmjit/asmjit/src/asmjit/core/constpool.h +250 -0
  66. data/ext/asmjit/asmjit/src/asmjit/core/cpuinfo.cpp +1162 -0
  67. data/ext/asmjit/asmjit/src/asmjit/core/cpuinfo.h +813 -0
  68. data/ext/asmjit/asmjit/src/asmjit/core/emithelper.cpp +323 -0
  69. data/ext/asmjit/asmjit/src/asmjit/core/emithelper_p.h +58 -0
  70. data/ext/asmjit/asmjit/src/asmjit/core/emitter.cpp +333 -0
  71. data/ext/asmjit/asmjit/src/asmjit/core/emitter.h +741 -0
  72. data/ext/asmjit/asmjit/src/asmjit/core/emitterutils.cpp +129 -0
  73. data/ext/asmjit/asmjit/src/asmjit/core/emitterutils_p.h +89 -0
  74. data/ext/asmjit/asmjit/src/asmjit/core/environment.cpp +46 -0
  75. data/ext/asmjit/asmjit/src/asmjit/core/environment.h +508 -0
  76. data/ext/asmjit/asmjit/src/asmjit/core/errorhandler.cpp +14 -0
  77. data/ext/asmjit/asmjit/src/asmjit/core/errorhandler.h +228 -0
  78. data/ext/asmjit/asmjit/src/asmjit/core/formatter.cpp +584 -0
  79. data/ext/asmjit/asmjit/src/asmjit/core/formatter.h +247 -0
  80. data/ext/asmjit/asmjit/src/asmjit/core/formatter_p.h +34 -0
  81. data/ext/asmjit/asmjit/src/asmjit/core/func.cpp +286 -0
  82. data/ext/asmjit/asmjit/src/asmjit/core/func.h +1445 -0
  83. data/ext/asmjit/asmjit/src/asmjit/core/funcargscontext.cpp +293 -0
  84. data/ext/asmjit/asmjit/src/asmjit/core/funcargscontext_p.h +199 -0
  85. data/ext/asmjit/asmjit/src/asmjit/core/globals.cpp +133 -0
  86. data/ext/asmjit/asmjit/src/asmjit/core/globals.h +393 -0
  87. data/ext/asmjit/asmjit/src/asmjit/core/inst.cpp +113 -0
  88. data/ext/asmjit/asmjit/src/asmjit/core/inst.h +772 -0
  89. data/ext/asmjit/asmjit/src/asmjit/core/jitallocator.cpp +1242 -0
  90. data/ext/asmjit/asmjit/src/asmjit/core/jitallocator.h +261 -0
  91. data/ext/asmjit/asmjit/src/asmjit/core/jitruntime.cpp +80 -0
  92. data/ext/asmjit/asmjit/src/asmjit/core/jitruntime.h +89 -0
  93. data/ext/asmjit/asmjit/src/asmjit/core/logger.cpp +69 -0
  94. data/ext/asmjit/asmjit/src/asmjit/core/logger.h +198 -0
  95. data/ext/asmjit/asmjit/src/asmjit/core/misc_p.h +33 -0
  96. data/ext/asmjit/asmjit/src/asmjit/core/operand.cpp +132 -0
  97. data/ext/asmjit/asmjit/src/asmjit/core/operand.h +1611 -0
  98. data/ext/asmjit/asmjit/src/asmjit/core/osutils.cpp +84 -0
  99. data/ext/asmjit/asmjit/src/asmjit/core/osutils.h +61 -0
  100. data/ext/asmjit/asmjit/src/asmjit/core/osutils_p.h +68 -0
  101. data/ext/asmjit/asmjit/src/asmjit/core/raassignment_p.h +418 -0
  102. data/ext/asmjit/asmjit/src/asmjit/core/rabuilders_p.h +612 -0
  103. data/ext/asmjit/asmjit/src/asmjit/core/radefs_p.h +1204 -0
  104. data/ext/asmjit/asmjit/src/asmjit/core/ralocal.cpp +1166 -0
  105. data/ext/asmjit/asmjit/src/asmjit/core/ralocal_p.h +254 -0
  106. data/ext/asmjit/asmjit/src/asmjit/core/rapass.cpp +1969 -0
  107. data/ext/asmjit/asmjit/src/asmjit/core/rapass_p.h +1183 -0
  108. data/ext/asmjit/asmjit/src/asmjit/core/rastack.cpp +184 -0
  109. data/ext/asmjit/asmjit/src/asmjit/core/rastack_p.h +171 -0
  110. data/ext/asmjit/asmjit/src/asmjit/core/string.cpp +559 -0
  111. data/ext/asmjit/asmjit/src/asmjit/core/string.h +372 -0
  112. data/ext/asmjit/asmjit/src/asmjit/core/support.cpp +494 -0
  113. data/ext/asmjit/asmjit/src/asmjit/core/support.h +1773 -0
  114. data/ext/asmjit/asmjit/src/asmjit/core/target.cpp +14 -0
  115. data/ext/asmjit/asmjit/src/asmjit/core/target.h +53 -0
  116. data/ext/asmjit/asmjit/src/asmjit/core/type.cpp +74 -0
  117. data/ext/asmjit/asmjit/src/asmjit/core/type.h +419 -0
  118. data/ext/asmjit/asmjit/src/asmjit/core/virtmem.cpp +722 -0
  119. data/ext/asmjit/asmjit/src/asmjit/core/virtmem.h +242 -0
  120. data/ext/asmjit/asmjit/src/asmjit/core/zone.cpp +353 -0
  121. data/ext/asmjit/asmjit/src/asmjit/core/zone.h +615 -0
  122. data/ext/asmjit/asmjit/src/asmjit/core/zonehash.cpp +309 -0
  123. data/ext/asmjit/asmjit/src/asmjit/core/zonehash.h +186 -0
  124. data/ext/asmjit/asmjit/src/asmjit/core/zonelist.cpp +163 -0
  125. data/ext/asmjit/asmjit/src/asmjit/core/zonelist.h +209 -0
  126. data/ext/asmjit/asmjit/src/asmjit/core/zonestack.cpp +176 -0
  127. data/ext/asmjit/asmjit/src/asmjit/core/zonestack.h +239 -0
  128. data/ext/asmjit/asmjit/src/asmjit/core/zonestring.h +120 -0
  129. data/ext/asmjit/asmjit/src/asmjit/core/zonetree.cpp +99 -0
  130. data/ext/asmjit/asmjit/src/asmjit/core/zonetree.h +380 -0
  131. data/ext/asmjit/asmjit/src/asmjit/core/zonevector.cpp +356 -0
  132. data/ext/asmjit/asmjit/src/asmjit/core/zonevector.h +690 -0
  133. data/ext/asmjit/asmjit/src/asmjit/core.h +1861 -0
  134. data/ext/asmjit/asmjit/src/asmjit/x86/x86archtraits_p.h +148 -0
  135. data/ext/asmjit/asmjit/src/asmjit/x86/x86assembler.cpp +5110 -0
  136. data/ext/asmjit/asmjit/src/asmjit/x86/x86assembler.h +685 -0
  137. data/ext/asmjit/asmjit/src/asmjit/x86/x86builder.cpp +52 -0
  138. data/ext/asmjit/asmjit/src/asmjit/x86/x86builder.h +351 -0
  139. data/ext/asmjit/asmjit/src/asmjit/x86/x86compiler.cpp +61 -0
  140. data/ext/asmjit/asmjit/src/asmjit/x86/x86compiler.h +721 -0
  141. data/ext/asmjit/asmjit/src/asmjit/x86/x86emithelper.cpp +619 -0
  142. data/ext/asmjit/asmjit/src/asmjit/x86/x86emithelper_p.h +60 -0
  143. data/ext/asmjit/asmjit/src/asmjit/x86/x86emitter.h +4315 -0
  144. data/ext/asmjit/asmjit/src/asmjit/x86/x86formatter.cpp +944 -0
  145. data/ext/asmjit/asmjit/src/asmjit/x86/x86formatter_p.h +58 -0
  146. data/ext/asmjit/asmjit/src/asmjit/x86/x86func.cpp +503 -0
  147. data/ext/asmjit/asmjit/src/asmjit/x86/x86func_p.h +33 -0
  148. data/ext/asmjit/asmjit/src/asmjit/x86/x86globals.h +2169 -0
  149. data/ext/asmjit/asmjit/src/asmjit/x86/x86instapi.cpp +1732 -0
  150. data/ext/asmjit/asmjit/src/asmjit/x86/x86instapi_p.h +41 -0
  151. data/ext/asmjit/asmjit/src/asmjit/x86/x86instdb.cpp +4427 -0
  152. data/ext/asmjit/asmjit/src/asmjit/x86/x86instdb.h +563 -0
  153. data/ext/asmjit/asmjit/src/asmjit/x86/x86instdb_p.h +311 -0
  154. data/ext/asmjit/asmjit/src/asmjit/x86/x86opcode_p.h +436 -0
  155. data/ext/asmjit/asmjit/src/asmjit/x86/x86operand.cpp +231 -0
  156. data/ext/asmjit/asmjit/src/asmjit/x86/x86operand.h +1085 -0
  157. data/ext/asmjit/asmjit/src/asmjit/x86/x86rapass.cpp +1509 -0
  158. data/ext/asmjit/asmjit/src/asmjit/x86/x86rapass_p.h +94 -0
  159. data/ext/asmjit/asmjit/src/asmjit/x86.h +93 -0
  160. data/ext/asmjit/asmjit/src/asmjit.natvis +245 -0
  161. data/ext/asmjit/asmjit/test/asmjit_test_assembler.cpp +84 -0
  162. data/ext/asmjit/asmjit/test/asmjit_test_assembler.h +85 -0
  163. data/ext/asmjit/asmjit/test/asmjit_test_assembler_a64.cpp +4006 -0
  164. data/ext/asmjit/asmjit/test/asmjit_test_assembler_x64.cpp +17833 -0
  165. data/ext/asmjit/asmjit/test/asmjit_test_assembler_x86.cpp +8300 -0
  166. data/ext/asmjit/asmjit/test/asmjit_test_compiler.cpp +253 -0
  167. data/ext/asmjit/asmjit/test/asmjit_test_compiler.h +73 -0
  168. data/ext/asmjit/asmjit/test/asmjit_test_compiler_a64.cpp +690 -0
  169. data/ext/asmjit/asmjit/test/asmjit_test_compiler_x86.cpp +4317 -0
  170. data/ext/asmjit/asmjit/test/asmjit_test_emitters.cpp +197 -0
  171. data/ext/asmjit/asmjit/test/asmjit_test_instinfo.cpp +181 -0
  172. data/ext/asmjit/asmjit/test/asmjit_test_misc.h +257 -0
  173. data/ext/asmjit/asmjit/test/asmjit_test_perf.cpp +62 -0
  174. data/ext/asmjit/asmjit/test/asmjit_test_perf.h +61 -0
  175. data/ext/asmjit/asmjit/test/asmjit_test_perf_a64.cpp +699 -0
  176. data/ext/asmjit/asmjit/test/asmjit_test_perf_x86.cpp +5032 -0
  177. data/ext/asmjit/asmjit/test/asmjit_test_unit.cpp +172 -0
  178. data/ext/asmjit/asmjit/test/asmjit_test_x86_sections.cpp +172 -0
  179. data/ext/asmjit/asmjit/test/asmjitutils.h +38 -0
  180. data/ext/asmjit/asmjit/test/broken.cpp +312 -0
  181. data/ext/asmjit/asmjit/test/broken.h +148 -0
  182. data/ext/asmjit/asmjit/test/cmdline.h +61 -0
  183. data/ext/asmjit/asmjit/test/performancetimer.h +41 -0
  184. data/ext/asmjit/asmjit/tools/configure-makefiles.sh +13 -0
  185. data/ext/asmjit/asmjit/tools/configure-ninja.sh +13 -0
  186. data/ext/asmjit/asmjit/tools/configure-sanitizers.sh +13 -0
  187. data/ext/asmjit/asmjit/tools/configure-vs2019-x64.bat +2 -0
  188. data/ext/asmjit/asmjit/tools/configure-vs2019-x86.bat +2 -0
  189. data/ext/asmjit/asmjit/tools/configure-vs2022-x64.bat +2 -0
  190. data/ext/asmjit/asmjit/tools/configure-vs2022-x86.bat +2 -0
  191. data/ext/asmjit/asmjit/tools/configure-xcode.sh +8 -0
  192. data/ext/asmjit/asmjit/tools/enumgen.js +417 -0
  193. data/ext/asmjit/asmjit/tools/enumgen.sh +3 -0
  194. data/ext/asmjit/asmjit/tools/tablegen-arm.js +365 -0
  195. data/ext/asmjit/asmjit/tools/tablegen-arm.sh +3 -0
  196. data/ext/asmjit/asmjit/tools/tablegen-x86.js +2638 -0
  197. data/ext/asmjit/asmjit/tools/tablegen-x86.sh +3 -0
  198. data/ext/asmjit/asmjit/tools/tablegen.js +947 -0
  199. data/ext/asmjit/asmjit/tools/tablegen.sh +4 -0
  200. data/ext/asmjit/asmjit.cc +167 -30
  201. data/ext/asmjit/extconf.rb +9 -9
  202. data/lib/asmjit/version.rb +1 -1
  203. data/lib/asmjit.rb +14 -4
  204. metadata +198 -17
@@ -0,0 +1,4006 @@
1
+ // This file is part of AsmJit project <https://asmjit.com>
2
+ //
3
+ // See asmjit.h or LICENSE.md for license and copyright information
4
+ // SPDX-License-Identifier: Zlib
5
+
6
+ #include <asmjit/core.h>
7
+ #if !defined(ASMJIT_NO_AARCH64)
8
+
9
+ #include <asmjit/a64.h>
10
+ #include <stdio.h>
11
+ #include <stdlib.h>
12
+ #include <string.h>
13
+
14
+ #include "asmjit_test_assembler.h"
15
+ #include "cmdline.h"
16
+
17
+ using namespace asmjit;
18
+
19
+ #define TEST_INSTRUCTION(OPCODE, ...) \
20
+ tester.testInstruction(OPCODE, #__VA_ARGS__, tester.assembler.__VA_ARGS__)
21
+
22
+ static void ASMJIT_NOINLINE testA64AssemblerBase(AssemblerTester<a64::Assembler>& tester) noexcept {
23
+ using namespace a64;
24
+
25
+ TEST_INSTRUCTION("4100031A", adc(w1, w2, w3));
26
+ TEST_INSTRUCTION("4100039A", adc(x1, x2, x3));
27
+ TEST_INSTRUCTION("E103031A", adc(w1, wzr, w3));
28
+ TEST_INSTRUCTION("E103039A", adc(x1, xzr, x3));
29
+ TEST_INSTRUCTION("5F00031A", adc(wzr, w2, w3));
30
+ TEST_INSTRUCTION("5F00039A", adc(xzr, x2, x3));
31
+ TEST_INSTRUCTION("4100033A", adcs(w1, w2, w3));
32
+ TEST_INSTRUCTION("410003BA", adcs(x1, x2, x3));
33
+ TEST_INSTRUCTION("4100030B", add(w1, w2, w3));
34
+ TEST_INSTRUCTION("4100038B", add(x1, x2, x3));
35
+ TEST_INSTRUCTION("410C030B", add(w1, w2, w3, lsl(3)));
36
+ TEST_INSTRUCTION("410C038B", add(x1, x2, x3, lsl(3)));
37
+ TEST_INSTRUCTION("FF030411", add(wsp, wsp, 256));
38
+ TEST_INSTRUCTION("FFFF3F11", add(wsp, wsp, 0xFFF));
39
+ TEST_INSTRUCTION("FF030491", add(sp, sp, 256));
40
+ TEST_INSTRUCTION("FFFF3F91", add(sp, sp, 0xFFF));
41
+ TEST_INSTRUCTION("E103030B", add(w1, wzr, w3));
42
+ TEST_INSTRUCTION("E103038B", add(x1, xzr, x3));
43
+ TEST_INSTRUCTION("5F00030B", add(wzr, w2, w3));
44
+ TEST_INSTRUCTION("5F00038B", add(xzr, x2, x3));
45
+ TEST_INSTRUCTION("83004011", add(w3, w4, 0, lsl(12)));
46
+ TEST_INSTRUCTION("83004091", add(x3, x4, 0, lsl(12)));
47
+ TEST_INSTRUCTION("83005011", add(w3, w4, 1024, lsl(12)));
48
+ TEST_INSTRUCTION("83005091", add(x3, x4, 1024, lsl(12)));
49
+ TEST_INSTRUCTION("83005011", add(w3, w4, 1024, lsl(12)));
50
+ TEST_INSTRUCTION("83005091", add(x3, x4, 1024, lsl(12)));
51
+ TEST_INSTRUCTION("FF830091", add(sp, sp, 32));
52
+ TEST_INSTRUCTION("412C8291", addg(x1, x2, 32, 11));
53
+ TEST_INSTRUCTION("5F2C8291", addg(sp, x2, 32, 11));
54
+ TEST_INSTRUCTION("E12F8291", addg(x1, sp, 32, 11));
55
+ TEST_INSTRUCTION("4100032B", adds(w1, w2, w3));
56
+ TEST_INSTRUCTION("410003AB", adds(x1, x2, x3));
57
+ TEST_INSTRUCTION("01000010", adr(x1, 0));
58
+ TEST_INSTRUCTION("01080010", adr(x1, 256));
59
+ TEST_INSTRUCTION("010000B0", adrp(x1, 4096));
60
+ TEST_INSTRUCTION("4100030A", and_(w1, w2, w3));
61
+ TEST_INSTRUCTION("4100038A", and_(x1, x2, x3));
62
+ TEST_INSTRUCTION("41000012", and_(w1, w2, 1));
63
+ TEST_INSTRUCTION("41004092", and_(x1, x2, 1));
64
+ TEST_INSTRUCTION("410C0012", and_(w1, w2, 15));
65
+ TEST_INSTRUCTION("410C4092", and_(x1, x2, 15));
66
+ TEST_INSTRUCTION("3F1C0012", and_(wsp, w1, 0xFF));
67
+ TEST_INSTRUCTION("3F1C4092", and_(sp, x1, 0xFF));
68
+ TEST_INSTRUCTION("E103030A", and_(w1, wzr, w3));
69
+ TEST_INSTRUCTION("E103038A", and_(x1, xzr, x3));
70
+ TEST_INSTRUCTION("5F00030A", and_(wzr, w2, w3));
71
+ TEST_INSTRUCTION("5F00038A", and_(xzr, x2, x3));
72
+ TEST_INSTRUCTION("00000012", and_(w0, w0, 0x1));
73
+ TEST_INSTRUCTION("00004092", and_(x0, x0, 0x1));
74
+ TEST_INSTRUCTION("410C0012", and_(w1, w2, 0xf));
75
+ TEST_INSTRUCTION("410C4092", and_(x1, x2, 0xf));
76
+ TEST_INSTRUCTION("BFEC7C92", and_(sp, x5, 0xfffffffffffffff0));
77
+ TEST_INSTRUCTION("4100036A", ands(w1, w2, w3));
78
+ TEST_INSTRUCTION("410003EA", ands(x1, x2, x3));
79
+ TEST_INSTRUCTION("E103036A", ands(w1, wzr, w3));
80
+ TEST_INSTRUCTION("E10303EA", ands(x1, xzr, x3));
81
+ TEST_INSTRUCTION("5F00036A", ands(wzr, w2, w3));
82
+ TEST_INSTRUCTION("5F0003EA", ands(xzr, x2, x3));
83
+ TEST_INSTRUCTION("00000072", ands(w0, w0, 0x1));
84
+ TEST_INSTRUCTION("000040F2", ands(x0, x0, 0x1));
85
+ TEST_INSTRUCTION("410C0072", ands(w1, w2, 0xf));
86
+ TEST_INSTRUCTION("410C40F2", ands(x1, x2, 0xf));
87
+ TEST_INSTRUCTION("417C0F13", asr(w1, w2, 15));
88
+ TEST_INSTRUCTION("41FC4F93", asr(x1, x2, 15));
89
+ TEST_INSTRUCTION("4128C31A", asrv(w1, w2, w3));
90
+ TEST_INSTRUCTION("4128C39A", asrv(x1, x2, x3));
91
+ TEST_INSTRUCTION("4F7808D5", at(Predicate::AT::kS1E0R, x15));
92
+ TEST_INSTRUCTION("4118C1DA", autda(x1, x2));
93
+ TEST_INSTRUCTION("E11BC1DA", autda(x1, sp));
94
+ TEST_INSTRUCTION("411CC1DA", autdb(x1, x2));
95
+ TEST_INSTRUCTION("E11FC1DA", autdb(x1, sp));
96
+ TEST_INSTRUCTION("E13BC1DA", autdza(x1));
97
+ TEST_INSTRUCTION("F43BC1DA", autdza(x20));
98
+ TEST_INSTRUCTION("E13FC1DA", autdzb(x1));
99
+ TEST_INSTRUCTION("F43FC1DA", autdzb(x20));
100
+ TEST_INSTRUCTION("4110C1DA", autia(x1, x2));
101
+ TEST_INSTRUCTION("E113C1DA", autia(x1, sp));
102
+ TEST_INSTRUCTION("9F2103D5", autia1716());
103
+ TEST_INSTRUCTION("BF2303D5", autiasp());
104
+ TEST_INSTRUCTION("9F2303D5", autiaz());
105
+ TEST_INSTRUCTION("4114C1DA", autib(x1, x2));
106
+ TEST_INSTRUCTION("E117C1DA", autib(x1, sp));
107
+ TEST_INSTRUCTION("DF2103D5", autib1716());
108
+ TEST_INSTRUCTION("FF2303D5", autibsp());
109
+ TEST_INSTRUCTION("DF2303D5", autibz());
110
+ TEST_INSTRUCTION("E133C1DA", autiza(x1));
111
+ TEST_INSTRUCTION("F433C1DA", autiza(x20));
112
+ TEST_INSTRUCTION("E137C1DA", autizb(x1));
113
+ TEST_INSTRUCTION("F437C1DA", autizb(x20));
114
+ TEST_INSTRUCTION("5F4000D5", axflag());
115
+ TEST_INSTRUCTION("E13F1833", bfc(w1, 8, 16));
116
+ TEST_INSTRUCTION("E13F78B3", bfc(x1, 8, 16));
117
+ TEST_INSTRUCTION("413C1833", bfi(w1, w2, 8, 16));
118
+ TEST_INSTRUCTION("413C78B3", bfi(x1, x2, 8, 16));
119
+ TEST_INSTRUCTION("41400833", bfm(w1, w2, 8, 16));
120
+ TEST_INSTRUCTION("414048B3", bfm(x1, x2, 8, 16));
121
+ TEST_INSTRUCTION("415C0833", bfxil(w1, w2, 8, 16));
122
+ TEST_INSTRUCTION("415C48B3", bfxil(x1, x2, 8, 16));
123
+ TEST_INSTRUCTION("41781F12", bic(w1, w2, 1));
124
+ TEST_INSTRUCTION("41F87F92", bic(x1, x2, 1));
125
+ TEST_INSTRUCTION("416C1C12", bic(w1, w2, 15));
126
+ TEST_INSTRUCTION("41EC7C92", bic(x1, x2, 15));
127
+ TEST_INSTRUCTION("4110230A", bic(w1, w2, w3, lsl(4)));
128
+ TEST_INSTRUCTION("4110238A", bic(x1, x2, x3, lsl(4)));
129
+ TEST_INSTRUCTION("E103230A", bic(w1, wzr, w3));
130
+ TEST_INSTRUCTION("E103238A", bic(x1, xzr, x3));
131
+ TEST_INSTRUCTION("41781F72", bics(w1, w2, 1));
132
+ TEST_INSTRUCTION("41F87FF2", bics(x1, x2, 1));
133
+ TEST_INSTRUCTION("416C1C72", bics(w1, w2, 15));
134
+ TEST_INSTRUCTION("41EC7CF2", bics(x1, x2, 15));
135
+ TEST_INSTRUCTION("4110236A", bics(w1, w2, w3, lsl(4)));
136
+ TEST_INSTRUCTION("411023EA", bics(x1, x2, x3, lsl(4)));
137
+ TEST_INSTRUCTION("E103236A", bics(w1, wzr, w3));
138
+ TEST_INSTRUCTION("E10323EA", bics(x1, xzr, x3));
139
+ TEST_INSTRUCTION("60031FD6", br(x27));
140
+ TEST_INSTRUCTION("E0031FD6", br(xzr));
141
+ TEST_INSTRUCTION("200020D4", brk(1));
142
+ TEST_INSTRUCTION("627CA188", cas(w1, w2, ptr(x3)));
143
+ TEST_INSTRUCTION("627CA1C8", cas(x1, x2, ptr(x3)));
144
+ TEST_INSTRUCTION("627CE188", casa(w1, w2, ptr(x3)));
145
+ TEST_INSTRUCTION("627CE1C8", casa(x1, x2, ptr(x3)));
146
+ TEST_INSTRUCTION("627CE108", casab(w1, w2, ptr(x3)));
147
+ TEST_INSTRUCTION("627CE148", casah(w1, w2, ptr(x3)));
148
+ TEST_INSTRUCTION("62FCE188", casal(w1, w2, ptr(x3)));
149
+ TEST_INSTRUCTION("62FCE1C8", casal(x1, x2, ptr(x3)));
150
+ TEST_INSTRUCTION("62FCE108", casalb(w1, w2, ptr(x3)));
151
+ TEST_INSTRUCTION("62FCE148", casalh(w1, w2, ptr(x3)));
152
+ TEST_INSTRUCTION("627CA108", casb(w1, w2, ptr(x3)));
153
+ TEST_INSTRUCTION("627CA148", cash(w1, w2, ptr(x3)));
154
+ TEST_INSTRUCTION("62FCA188", casl(w1, w2, ptr(x3)));
155
+ TEST_INSTRUCTION("62FCA1C8", casl(x1, x2, ptr(x3)));
156
+ TEST_INSTRUCTION("62FCA108", caslb(w1, w2, ptr(x3)));
157
+ TEST_INSTRUCTION("62FCA148", caslh(w1, w2, ptr(x3)));
158
+ TEST_INSTRUCTION("687C2208", casp(w2, w3, w8, w9, ptr(x3)));
159
+ TEST_INSTRUCTION("687C2248", casp(x2, x3, x8, x9, ptr(x3)));
160
+ TEST_INSTRUCTION("687C6208", caspa(w2, w3, w8, w9, ptr(x3)));
161
+ TEST_INSTRUCTION("687C6248", caspa(x2, x3, x8, x9, ptr(x3)));
162
+ TEST_INSTRUCTION("68FC6208", caspal(w2, w3, w8, w9, ptr(x3)));
163
+ TEST_INSTRUCTION("68FC6248", caspal(x2, x3, x8, x9, ptr(x3)));
164
+ TEST_INSTRUCTION("68FC2208", caspl(w2, w3, w8, w9, ptr(x3)));
165
+ TEST_INSTRUCTION("68FC2248", caspl(x2, x3, x8, x9, ptr(x3)));
166
+ TEST_INSTRUCTION("2300423A", ccmn(w1, w2, 3, CondCode::kEQ));
167
+ TEST_INSTRUCTION("230042BA", ccmn(x1, x2, 3, CondCode::kEQ));
168
+ TEST_INSTRUCTION("2308423A", ccmn(w1, 2, 3, CondCode::kEQ));
169
+ TEST_INSTRUCTION("230842BA", ccmn(x1, 2, 3, CondCode::kEQ));
170
+ TEST_INSTRUCTION("23005F3A", ccmn(w1, wzr, 3, CondCode::kEQ));
171
+ TEST_INSTRUCTION("23005FBA", ccmn(x1, xzr, 3, CondCode::kEQ));
172
+ TEST_INSTRUCTION("2300427A", ccmp(w1, w2, 3, CondCode::kEQ));
173
+ TEST_INSTRUCTION("230042FA", ccmp(x1, x2, 3, CondCode::kEQ));
174
+ TEST_INSTRUCTION("2308427A", ccmp(w1, 2, 3, CondCode::kEQ));
175
+ TEST_INSTRUCTION("230842FA", ccmp(x1, 2, 3, CondCode::kEQ));
176
+ TEST_INSTRUCTION("23005F7A", ccmp(w1, wzr, 3, CondCode::kEQ));
177
+ TEST_INSTRUCTION("23005FFA", ccmp(x1, xzr, 3, CondCode::kEQ));
178
+ TEST_INSTRUCTION("1F4000D5", cfinv());
179
+ TEST_INSTRUCTION("4114821A", cinc(w1, w2, CondCode::kEQ));
180
+ TEST_INSTRUCTION("4114829A", cinc(x1, x2, CondCode::kEQ));
181
+ TEST_INSTRUCTION("5F14821A", cinc(wzr, w2, CondCode::kEQ));
182
+ TEST_INSTRUCTION("E1179F1A", cinc(w1, wzr, CondCode::kEQ));
183
+ TEST_INSTRUCTION("5F14829A", cinc(xzr, x2, CondCode::kEQ));
184
+ TEST_INSTRUCTION("E1179F9A", cinc(x1, xzr, CondCode::kEQ));
185
+ TEST_INSTRUCTION("4110825A", cinv(w1, w2, CondCode::kEQ));
186
+ TEST_INSTRUCTION("411082DA", cinv(x1, x2, CondCode::kEQ));
187
+ TEST_INSTRUCTION("5F10825A", cinv(wzr, w2, CondCode::kEQ));
188
+ TEST_INSTRUCTION("E1139F5A", cinv(w1, wzr, CondCode::kEQ));
189
+ TEST_INSTRUCTION("5F1082DA", cinv(xzr, x2, CondCode::kEQ));
190
+ TEST_INSTRUCTION("E1139FDA", cinv(x1, xzr, CondCode::kEQ));
191
+ TEST_INSTRUCTION("5F3B03D5", clrex(11));
192
+ TEST_INSTRUCTION("4114C05A", cls(w1, w2));
193
+ TEST_INSTRUCTION("4114C0DA", cls(x1, x2));
194
+ TEST_INSTRUCTION("E117C05A", cls(w1, wzr));
195
+ TEST_INSTRUCTION("E117C0DA", cls(x1, xzr));
196
+ TEST_INSTRUCTION("5F14C05A", cls(wzr, w2));
197
+ TEST_INSTRUCTION("5F14C0DA", cls(xzr, x2));
198
+ TEST_INSTRUCTION("4110C05A", clz(w1, w2));
199
+ TEST_INSTRUCTION("4110C0DA", clz(x1, x2));
200
+ TEST_INSTRUCTION("E113C05A", clz(w1, wzr));
201
+ TEST_INSTRUCTION("E113C0DA", clz(x1, xzr));
202
+ TEST_INSTRUCTION("5F10C05A", clz(wzr, w2));
203
+ TEST_INSTRUCTION("5F10C0DA", clz(xzr, x2));
204
+ TEST_INSTRUCTION("3F840031", cmn(w1, 33));
205
+ TEST_INSTRUCTION("3FFC4331", cmn(w1, 0xFF000));
206
+ TEST_INSTRUCTION("FF030231", cmn(wsp, 128));
207
+ TEST_INSTRUCTION("3F8400B1", cmn(x1, 33));
208
+ TEST_INSTRUCTION("3FFC43B1", cmn(x1, 0xFF000));
209
+ TEST_INSTRUCTION("FF0302B1", cmn(sp, 128));
210
+ TEST_INSTRUCTION("3F00022B", cmn(w1, w2));
211
+ TEST_INSTRUCTION("3F0002AB", cmn(x1, x2));
212
+ TEST_INSTRUCTION("3F08222B", cmn(w1, w2, uxtb(2)));
213
+ TEST_INSTRUCTION("3F0822AB", cmn(x1, x2, uxtb(2)));
214
+ TEST_INSTRUCTION("FF43212B", cmn(wsp, w1));
215
+ TEST_INSTRUCTION("FF07212B", cmn(wsp, w1, uxtb(1)));
216
+ TEST_INSTRUCTION("FF6321AB", cmn(sp, x1));
217
+ TEST_INSTRUCTION("FF6721AB", cmn(sp, x1, uxtx(1)));
218
+ TEST_INSTRUCTION("3F840071", cmp(w1, 33));
219
+ TEST_INSTRUCTION("3FFC4371", cmp(w1, 0xFF000));
220
+ TEST_INSTRUCTION("FF030271", cmp(wsp, 128));
221
+ TEST_INSTRUCTION("3F8400F1", cmp(x1, 33));
222
+ TEST_INSTRUCTION("3FFC43F1", cmp(x1, 0xFF000));
223
+ TEST_INSTRUCTION("FF0302F1", cmp(sp, 128));
224
+ TEST_INSTRUCTION("3F00026B", cmp(w1, w2));
225
+ TEST_INSTRUCTION("3F0002EB", cmp(x1, x2));
226
+ TEST_INSTRUCTION("3F08226B", cmp(w1, w2, uxtb(2)));
227
+ TEST_INSTRUCTION("3F0822EB", cmp(x1, x2, uxtb(2)));
228
+ TEST_INSTRUCTION("FF43216B", cmp(wsp, w1));
229
+ TEST_INSTRUCTION("FF07216B", cmp(wsp, w1, uxtb(1)));
230
+ TEST_INSTRUCTION("FF6321EB", cmp(sp, x1));
231
+ TEST_INSTRUCTION("FF6721EB", cmp(sp, x1, uxtx(1)));
232
+ TEST_INSTRUCTION("3F00C2BA", cmpp(x1, x2));
233
+ TEST_INSTRUCTION("3F00DFBA", cmpp(x1, sp));
234
+ TEST_INSTRUCTION("FF03C2BA", cmpp(sp, x2));
235
+ TEST_INSTRUCTION("FF03DFBA", cmpp(sp, sp));
236
+ TEST_INSTRUCTION("4140C31A", crc32b(w1, w2, w3));
237
+ TEST_INSTRUCTION("5F40C31A", crc32b(wzr, w2, w3));
238
+ TEST_INSTRUCTION("E143C31A", crc32b(w1, wzr, w3));
239
+ TEST_INSTRUCTION("4140DF1A", crc32b(w1, w2, wzr));
240
+ TEST_INSTRUCTION("4150C31A", crc32cb(w1, w2, w3));
241
+ TEST_INSTRUCTION("5F50C31A", crc32cb(wzr, w2, w3));
242
+ TEST_INSTRUCTION("E153C31A", crc32cb(w1, wzr, w3));
243
+ TEST_INSTRUCTION("4150DF1A", crc32cb(w1, w2, wzr));
244
+ TEST_INSTRUCTION("4154C31A", crc32ch(w1, w2, w3));
245
+ TEST_INSTRUCTION("5F54C31A", crc32ch(wzr, w2, w3));
246
+ TEST_INSTRUCTION("E157C31A", crc32ch(w1, wzr, w3));
247
+ TEST_INSTRUCTION("4154DF1A", crc32ch(w1, w2, wzr));
248
+ TEST_INSTRUCTION("4158C31A", crc32cw(w1, w2, w3));
249
+ TEST_INSTRUCTION("5F58C31A", crc32cw(wzr, w2, w3));
250
+ TEST_INSTRUCTION("E15BC31A", crc32cw(w1, wzr, w3));
251
+ TEST_INSTRUCTION("4158DF1A", crc32cw(w1, w2, wzr));
252
+ TEST_INSTRUCTION("415CC39A", crc32cx(w1, w2, x3));
253
+ TEST_INSTRUCTION("5F5CC39A", crc32cx(wzr, w2, x3));
254
+ TEST_INSTRUCTION("E15FC39A", crc32cx(w1, wzr, x3));
255
+ TEST_INSTRUCTION("415CDF9A", crc32cx(w1, w2, xzr));
256
+ TEST_INSTRUCTION("4144C31A", crc32h(w1, w2, w3));
257
+ TEST_INSTRUCTION("5F44C31A", crc32h(wzr, w2, w3));
258
+ TEST_INSTRUCTION("E147C31A", crc32h(w1, wzr, w3));
259
+ TEST_INSTRUCTION("4144DF1A", crc32h(w1, w2, wzr));
260
+ TEST_INSTRUCTION("4148C31A", crc32w(w1, w2, w3));
261
+ TEST_INSTRUCTION("5F48C31A", crc32w(wzr, w2, w3));
262
+ TEST_INSTRUCTION("E14BC31A", crc32w(w1, wzr, w3));
263
+ TEST_INSTRUCTION("4148DF1A", crc32w(w1, w2, wzr));
264
+ TEST_INSTRUCTION("414CC39A", crc32x(w1, w2, x3));
265
+ TEST_INSTRUCTION("5F4CC39A", crc32x(wzr, w2, x3));
266
+ TEST_INSTRUCTION("E14FC39A", crc32x(w1, wzr, x3));
267
+ TEST_INSTRUCTION("414CDF9A", crc32x(w1, w2, xzr));
268
+ TEST_INSTRUCTION("9F2203D5", csdb());
269
+ TEST_INSTRUCTION("4100831A", csel(w1, w2, w3, CondCode::kEQ));
270
+ TEST_INSTRUCTION("4100839A", csel(x1, x2, x3, CondCode::kEQ));
271
+ TEST_INSTRUCTION("E1179F1A", cset(w1, CondCode::kEQ));
272
+ TEST_INSTRUCTION("E1179F9A", cset(x1, CondCode::kEQ));
273
+ TEST_INSTRUCTION("E1179F1A", cset(w1, CondCode::kEQ));
274
+ TEST_INSTRUCTION("E1179F9A", cset(x1, CondCode::kEQ));
275
+ TEST_INSTRUCTION("E1139F5A", csetm(w1, CondCode::kEQ));
276
+ TEST_INSTRUCTION("E1139FDA", csetm(x1, CondCode::kEQ));
277
+ TEST_INSTRUCTION("4104831A", csinc(w1, w2, w3, CondCode::kEQ));
278
+ TEST_INSTRUCTION("4104839A", csinc(x1, x2, x3, CondCode::kEQ));
279
+ TEST_INSTRUCTION("4100835A", csinv(w1, w2, w3, CondCode::kEQ));
280
+ TEST_INSTRUCTION("410083DA", csinv(x1, x2, x3, CondCode::kEQ));
281
+ TEST_INSTRUCTION("4104835A", csneg(w1, w2, w3, CondCode::kEQ));
282
+ TEST_INSTRUCTION("410483DA", csneg(x1, x2, x3, CondCode::kEQ));
283
+ TEST_INSTRUCTION("2F740BD5", dc(Predicate::DC::kZVA, x15));
284
+ TEST_INSTRUCTION("2100B0D4", dcps1(0x8001));
285
+ TEST_INSTRUCTION("2200B0D4", dcps2(0x8001));
286
+ TEST_INSTRUCTION("2300B0D4", dcps3(0x8001));
287
+ TEST_INSTRUCTION("DF2003D5", dgh());
288
+ TEST_INSTRUCTION("BF3103D5", dmb(1));
289
+ TEST_INSTRUCTION("E003BFD6", drps());
290
+ TEST_INSTRUCTION("9F3103D5", dsb(1));
291
+ TEST_INSTRUCTION("4100234A", eon(w1, w2, w3));
292
+ TEST_INSTRUCTION("5F00234A", eon(wzr, w2, w3));
293
+ TEST_INSTRUCTION("E103234A", eon(w1, wzr, w3));
294
+ TEST_INSTRUCTION("41003F4A", eon(w1, w2, wzr));
295
+ TEST_INSTRUCTION("4110234A", eon(w1, w2, w3, lsl(4)));
296
+ TEST_INSTRUCTION("410023CA", eon(x1, x2, x3));
297
+ TEST_INSTRUCTION("5F0023CA", eon(xzr, x2, x3));
298
+ TEST_INSTRUCTION("E10323CA", eon(x1, xzr, x3));
299
+ TEST_INSTRUCTION("41003FCA", eon(x1, x2, xzr));
300
+ TEST_INSTRUCTION("411023CA", eon(x1, x2, x3, lsl(4)));
301
+ TEST_INSTRUCTION("4100034A", eor(w1, w2, w3));
302
+ TEST_INSTRUCTION("5F00034A", eor(wzr, w2, w3));
303
+ TEST_INSTRUCTION("E103034A", eor(w1, wzr, w3));
304
+ TEST_INSTRUCTION("41001F4A", eor(w1, w2, wzr));
305
+ TEST_INSTRUCTION("410003CA", eor(x1, x2, x3));
306
+ TEST_INSTRUCTION("5F0003CA", eor(xzr, x2, x3));
307
+ TEST_INSTRUCTION("E10303CA", eor(x1, xzr, x3));
308
+ TEST_INSTRUCTION("41001FCA", eor(x1, x2, xzr));
309
+ TEST_INSTRUCTION("4110034A", eor(w1, w2, w3, lsl(4)));
310
+ TEST_INSTRUCTION("411003CA", eor(x1, x2, x3, lsl(4)));
311
+ TEST_INSTRUCTION("3F1C0052", eor(wsp, w1, 0xFF));
312
+ TEST_INSTRUCTION("FF1F0052", eor(wsp, wzr, 0xFF));
313
+ TEST_INSTRUCTION("3F1C40D2", eor(sp, x1, 0xFF));
314
+ TEST_INSTRUCTION("FF1F40D2", eor(sp, xzr, 0xFF));
315
+ TEST_INSTRUCTION("41001252", eor(w1, w2, 0x4000));
316
+ TEST_INSTRUCTION("410071D2", eor(x1, x2, 0x8000));
317
+ TEST_INSTRUCTION("E0039FD6", eret());
318
+ TEST_INSTRUCTION("1F2203D5", esb());
319
+ TEST_INSTRUCTION("413C8313", extr(w1, w2, w3, 15));
320
+ TEST_INSTRUCTION("5F3C8313", extr(wzr, w2, w3, 15));
321
+ TEST_INSTRUCTION("E13F8313", extr(w1, wzr, w3, 15));
322
+ TEST_INSTRUCTION("413C9F13", extr(w1, w2, wzr, 15));
323
+ TEST_INSTRUCTION("413CC393", extr(x1, x2, x3, 15));
324
+ TEST_INSTRUCTION("5F3CC393", extr(xzr, x2, x3, 15));
325
+ TEST_INSTRUCTION("E13FC393", extr(x1, xzr, x3, 15));
326
+ TEST_INSTRUCTION("413CDF93", extr(x1, x2, xzr, 15));
327
+ TEST_INSTRUCTION("4114C39A", gmi(x1, x2, x3));
328
+ TEST_INSTRUCTION("E117C39A", gmi(x1, sp, x3));
329
+ TEST_INSTRUCTION("200040D4", hlt(1));
330
+ TEST_INSTRUCTION("220000D4", hvc(1));
331
+ TEST_INSTRUCTION("2F750BD5", ic(Predicate::IC::kIVAU, x15));
332
+ TEST_INSTRUCTION("DF3103D5", isb(1));
333
+ TEST_INSTRUCTION("620021B8", ldadd(w1, w2, ptr(x3)));
334
+ TEST_INSTRUCTION("E20321B8", ldadd(w1, w2, ptr(sp)));
335
+ TEST_INSTRUCTION("620021F8", ldadd(x1, x2, ptr(x3)));
336
+ TEST_INSTRUCTION("E20321F8", ldadd(x1, x2, ptr(sp)));
337
+ TEST_INSTRUCTION("6200A1B8", ldadda(w1, w2, ptr(x3)));
338
+ TEST_INSTRUCTION("E203A1B8", ldadda(w1, w2, ptr(sp)));
339
+ TEST_INSTRUCTION("6200A1F8", ldadda(x1, x2, ptr(x3)));
340
+ TEST_INSTRUCTION("E203A1F8", ldadda(x1, x2, ptr(sp)));
341
+ TEST_INSTRUCTION("6200A138", ldaddab(w1, w2, ptr(x3)));
342
+ TEST_INSTRUCTION("E203A138", ldaddab(w1, w2, ptr(sp)));
343
+ TEST_INSTRUCTION("6200A178", ldaddah(w1, w2, ptr(x3)));
344
+ TEST_INSTRUCTION("E203A178", ldaddah(w1, w2, ptr(sp)));
345
+ TEST_INSTRUCTION("6200E1B8", ldaddal(w1, w2, ptr(x3)));
346
+ TEST_INSTRUCTION("E203E1B8", ldaddal(w1, w2, ptr(sp)));
347
+ TEST_INSTRUCTION("6200E1F8", ldaddal(x1, x2, ptr(x3)));
348
+ TEST_INSTRUCTION("E203E1F8", ldaddal(x1, x2, ptr(sp)));
349
+ TEST_INSTRUCTION("6200E138", ldaddalb(w1, w2, ptr(x3)));
350
+ TEST_INSTRUCTION("E203E138", ldaddalb(w1, w2, ptr(sp)));
351
+ TEST_INSTRUCTION("6200E178", ldaddalh(w1, w2, ptr(x3)));
352
+ TEST_INSTRUCTION("E203E178", ldaddalh(w1, w2, ptr(sp)));
353
+ TEST_INSTRUCTION("62002138", ldaddb(w1, w2, ptr(x3)));
354
+ TEST_INSTRUCTION("E2032138", ldaddb(w1, w2, ptr(sp)));
355
+ TEST_INSTRUCTION("62002178", ldaddh(w1, w2, ptr(x3)));
356
+ TEST_INSTRUCTION("E2032178", ldaddh(w1, w2, ptr(sp)));
357
+ TEST_INSTRUCTION("620061B8", ldaddl(w1, w2, ptr(x3)));
358
+ TEST_INSTRUCTION("E20361B8", ldaddl(w1, w2, ptr(sp)));
359
+ TEST_INSTRUCTION("620061F8", ldaddl(x1, x2, ptr(x3)));
360
+ TEST_INSTRUCTION("E20361F8", ldaddl(x1, x2, ptr(sp)));
361
+ TEST_INSTRUCTION("62006138", ldaddlb(w1, w2, ptr(x3)));
362
+ TEST_INSTRUCTION("E2036138", ldaddlb(w1, w2, ptr(sp)));
363
+ TEST_INSTRUCTION("62006178", ldaddlh(w1, w2, ptr(x3)));
364
+ TEST_INSTRUCTION("E2036178", ldaddlh(w1, w2, ptr(sp)));
365
+ TEST_INSTRUCTION("621021B8", ldclr(w1, w2, ptr(x3)));
366
+ TEST_INSTRUCTION("E21321B8", ldclr(w1, w2, ptr(sp)));
367
+ TEST_INSTRUCTION("621021F8", ldclr(x1, x2, ptr(x3)));
368
+ TEST_INSTRUCTION("E21321F8", ldclr(x1, x2, ptr(sp)));
369
+ TEST_INSTRUCTION("6210A1B8", ldclra(w1, w2, ptr(x3)));
370
+ TEST_INSTRUCTION("E213A1B8", ldclra(w1, w2, ptr(sp)));
371
+ TEST_INSTRUCTION("6210A1F8", ldclra(x1, x2, ptr(x3)));
372
+ TEST_INSTRUCTION("E213A1F8", ldclra(x1, x2, ptr(sp)));
373
+ TEST_INSTRUCTION("6210A138", ldclrab(w1, w2, ptr(x3)));
374
+ TEST_INSTRUCTION("E213A138", ldclrab(w1, w2, ptr(sp)));
375
+ TEST_INSTRUCTION("6210A178", ldclrah(w1, w2, ptr(x3)));
376
+ TEST_INSTRUCTION("E213A178", ldclrah(w1, w2, ptr(sp)));
377
+ TEST_INSTRUCTION("6210E1B8", ldclral(w1, w2, ptr(x3)));
378
+ TEST_INSTRUCTION("E213E1B8", ldclral(w1, w2, ptr(sp)));
379
+ TEST_INSTRUCTION("6210E1F8", ldclral(x1, x2, ptr(x3)));
380
+ TEST_INSTRUCTION("E213E1F8", ldclral(x1, x2, ptr(sp)));
381
+ TEST_INSTRUCTION("6210E138", ldclralb(w1, w2, ptr(x3)));
382
+ TEST_INSTRUCTION("E213E138", ldclralb(w1, w2, ptr(sp)));
383
+ TEST_INSTRUCTION("6210E178", ldclralh(w1, w2, ptr(x3)));
384
+ TEST_INSTRUCTION("E213E178", ldclralh(w1, w2, ptr(sp)));
385
+ TEST_INSTRUCTION("62102138", ldclrb(w1, w2, ptr(x3)));
386
+ TEST_INSTRUCTION("E2132138", ldclrb(w1, w2, ptr(sp)));
387
+ TEST_INSTRUCTION("62102178", ldclrh(w1, w2, ptr(x3)));
388
+ TEST_INSTRUCTION("E2132178", ldclrh(w1, w2, ptr(sp)));
389
+ TEST_INSTRUCTION("621061B8", ldclrl(w1, w2, ptr(x3)));
390
+ TEST_INSTRUCTION("E21361B8", ldclrl(w1, w2, ptr(sp)));
391
+ TEST_INSTRUCTION("621061F8", ldclrl(x1, x2, ptr(x3)));
392
+ TEST_INSTRUCTION("E21361F8", ldclrl(x1, x2, ptr(sp)));
393
+ TEST_INSTRUCTION("62106138", ldclrlb(w1, w2, ptr(x3)));
394
+ TEST_INSTRUCTION("E2136138", ldclrlb(w1, w2, ptr(sp)));
395
+ TEST_INSTRUCTION("62106178", ldclrlh(w1, w2, ptr(x3)));
396
+ TEST_INSTRUCTION("E2136178", ldclrlh(w1, w2, ptr(sp)));
397
+ TEST_INSTRUCTION("622021B8", ldeor(w1, w2, ptr(x3)));
398
+ TEST_INSTRUCTION("E22321B8", ldeor(w1, w2, ptr(sp)));
399
+ TEST_INSTRUCTION("622021F8", ldeor(x1, x2, ptr(x3)));
400
+ TEST_INSTRUCTION("E22321F8", ldeor(x1, x2, ptr(sp)));
401
+ TEST_INSTRUCTION("6220A1B8", ldeora(w1, w2, ptr(x3)));
402
+ TEST_INSTRUCTION("E223A1B8", ldeora(w1, w2, ptr(sp)));
403
+ TEST_INSTRUCTION("6220A1F8", ldeora(x1, x2, ptr(x3)));
404
+ TEST_INSTRUCTION("E223A1F8", ldeora(x1, x2, ptr(sp)));
405
+ TEST_INSTRUCTION("6220A138", ldeorab(w1, w2, ptr(x3)));
406
+ TEST_INSTRUCTION("E223A138", ldeorab(w1, w2, ptr(sp)));
407
+ TEST_INSTRUCTION("6220A178", ldeorah(w1, w2, ptr(x3)));
408
+ TEST_INSTRUCTION("E223A178", ldeorah(w1, w2, ptr(sp)));
409
+ TEST_INSTRUCTION("6220E1B8", ldeoral(w1, w2, ptr(x3)));
410
+ TEST_INSTRUCTION("E223E1B8", ldeoral(w1, w2, ptr(sp)));
411
+ TEST_INSTRUCTION("6220E1F8", ldeoral(x1, x2, ptr(x3)));
412
+ TEST_INSTRUCTION("E223E1F8", ldeoral(x1, x2, ptr(sp)));
413
+ TEST_INSTRUCTION("6220E138", ldeoralb(w1, w2, ptr(x3)));
414
+ TEST_INSTRUCTION("E223E138", ldeoralb(w1, w2, ptr(sp)));
415
+ TEST_INSTRUCTION("6220E178", ldeoralh(w1, w2, ptr(x3)));
416
+ TEST_INSTRUCTION("E223E178", ldeoralh(w1, w2, ptr(sp)));
417
+ TEST_INSTRUCTION("62202138", ldeorb(w1, w2, ptr(x3)));
418
+ TEST_INSTRUCTION("E2232138", ldeorb(w1, w2, ptr(sp)));
419
+ TEST_INSTRUCTION("62202178", ldeorh(w1, w2, ptr(x3)));
420
+ TEST_INSTRUCTION("E2232178", ldeorh(w1, w2, ptr(sp)));
421
+ TEST_INSTRUCTION("622061B8", ldeorl(w1, w2, ptr(x3)));
422
+ TEST_INSTRUCTION("E22361B8", ldeorl(w1, w2, ptr(sp)));
423
+ TEST_INSTRUCTION("622061F8", ldeorl(x1, x2, ptr(x3)));
424
+ TEST_INSTRUCTION("E22361F8", ldeorl(x1, x2, ptr(sp)));
425
+ TEST_INSTRUCTION("62206138", ldeorlb(w1, w2, ptr(x3)));
426
+ TEST_INSTRUCTION("E2236138", ldeorlb(w1, w2, ptr(sp)));
427
+ TEST_INSTRUCTION("62206178", ldeorlh(w1, w2, ptr(x3)));
428
+ TEST_INSTRUCTION("E2236178", ldeorlh(w1, w2, ptr(sp)));
429
+ TEST_INSTRUCTION("410060D9", ldg(x1, ptr(x2)));
430
+ TEST_INSTRUCTION("418060D9", ldg(x1, ptr(x2, 128)));
431
+ TEST_INSTRUCTION("E10360D9", ldg(x1, ptr(sp)));
432
+ TEST_INSTRUCTION("E18360D9", ldg(x1, ptr(sp, 128)));
433
+ TEST_INSTRUCTION("4100E0D9", ldgm(x1, ptr(x2)));
434
+ TEST_INSTRUCTION("E103E0D9", ldgm(x1, ptr(sp)));
435
+ TEST_INSTRUCTION("417CDF88", ldlar(w1, ptr(x2)));
436
+ TEST_INSTRUCTION("E17FDF88", ldlar(w1, ptr(sp)));
437
+ TEST_INSTRUCTION("417CDFC8", ldlar(x1, ptr(x2)));
438
+ TEST_INSTRUCTION("E17FDFC8", ldlar(x1, ptr(sp)));
439
+ TEST_INSTRUCTION("417CDF08", ldlarb(w1, ptr(x2)));
440
+ TEST_INSTRUCTION("E17FDF08", ldlarb(w1, ptr(sp)));
441
+ TEST_INSTRUCTION("417CDF48", ldlarh(w1, ptr(x2)));
442
+ TEST_INSTRUCTION("E17FDF48", ldlarh(w1, ptr(sp)));
443
+ TEST_INSTRUCTION("41084028", ldnp(w1, w2, ptr(x2)));
444
+ TEST_INSTRUCTION("41086028", ldnp(w1, w2, ptr(x2, -256)));
445
+ TEST_INSTRUCTION("41885F28", ldnp(w1, w2, ptr(x2, 252)));
446
+ TEST_INSTRUCTION("410840A8", ldnp(x1, x2, ptr(x2)));
447
+ TEST_INSTRUCTION("410860A8", ldnp(x1, x2, ptr(x2, -512)));
448
+ TEST_INSTRUCTION("41885FA8", ldnp(x1, x2, ptr(x2, 504)));
449
+ TEST_INSTRUCTION("41084029", ldp(w1, w2, ptr(x2)));
450
+ TEST_INSTRUCTION("41086029", ldp(w1, w2, ptr(x2, -256)));
451
+ TEST_INSTRUCTION("41885F29", ldp(w1, w2, ptr(x2, 252)));
452
+ TEST_INSTRUCTION("410840A9", ldp(x1, x2, ptr(x2)));
453
+ TEST_INSTRUCTION("410860A9", ldp(x1, x2, ptr(x2, -512)));
454
+ TEST_INSTRUCTION("41885FA9", ldp(x1, x2, ptr(x2, 504)));
455
+ TEST_INSTRUCTION("41084069", ldpsw(x1, x2, ptr(x2)));
456
+ TEST_INSTRUCTION("41086069", ldpsw(x1, x2, ptr(x2, -256)));
457
+ TEST_INSTRUCTION("41885F69", ldpsw(x1, x2, ptr(x2, 252)));
458
+ TEST_INSTRUCTION("410040B9", ldr(w1, ptr(x2)));
459
+ TEST_INSTRUCTION("413040B9", ldr(w1, ptr(x2, 48)));
460
+ TEST_INSTRUCTION("410C43B8", ldr(w1, ptr_pre(x2, 48)));
461
+ TEST_INSTRUCTION("416863B8", ldr(w1, ptr(x2, x3)));
462
+ TEST_INSTRUCTION("410040F9", ldr(x1, ptr(x2)));
463
+ TEST_INSTRUCTION("411840F9", ldr(x1, ptr(x2, 48)));
464
+ TEST_INSTRUCTION("410C43F8", ldr(x1, ptr_pre(x2, 48)));
465
+ TEST_INSTRUCTION("416863F8", ldr(x1, ptr(x2, x3)));
466
+ TEST_INSTRUCTION("FB0F5FF8", ldr(x27, ptr_pre(sp, -16)));
467
+ TEST_INSTRUCTION("FB0741F8", ldr(x27, ptr_post(sp, 16)));
468
+ TEST_INSTRUCTION("411040B8", ldr(w1, ptr(x2, 1))); // LDUR
469
+ TEST_INSTRUCTION("41D05FB8", ldr(w1, ptr(x2, -3))); // LDUR
470
+ TEST_INSTRUCTION("41705FB8", ldr(w1, ptr(x2, -9))); // LDUR
471
+ TEST_INSTRUCTION("411040F8", ldr(x1, ptr(x2, 1))); // LDUR
472
+ TEST_INSTRUCTION("413040F8", ldr(x1, ptr(x2, 3))); // LDUR
473
+ TEST_INSTRUCTION("41705FF8", ldr(x1, ptr(x2, -9))); // LDUR
474
+ TEST_INSTRUCTION("41004039", ldrb(w1, ptr(x2)));
475
+ TEST_INSTRUCTION("41C04039", ldrb(w1, ptr(x2, 48)));
476
+ TEST_INSTRUCTION("410C4338", ldrb(w1, ptr_pre(x2, 48)));
477
+ TEST_INSTRUCTION("41686338", ldrb(w1, ptr(x2, x3)));
478
+ TEST_INSTRUCTION("41044039", ldrb(w1, ptr(x2, 1)));
479
+ TEST_INSTRUCTION("41D05F38", ldrb(w1, ptr(x2, -3))); // LDURB
480
+ TEST_INSTRUCTION("41705F38", ldrb(w1, ptr(x2, -9))); // LDURB
481
+ TEST_INSTRUCTION("41004079", ldrh(w1, ptr(x2)));
482
+ TEST_INSTRUCTION("41604079", ldrh(w1, ptr(x2, 48)));
483
+ TEST_INSTRUCTION("410C4378", ldrh(w1, ptr_pre(x2, 48)));
484
+ TEST_INSTRUCTION("41686378", ldrh(w1, ptr(x2, x3)));
485
+ TEST_INSTRUCTION("41104078", ldrh(w1, ptr(x2, 1))); // LDURH
486
+ TEST_INSTRUCTION("41D05F78", ldrh(w1, ptr(x2, -3))); // LDURH
487
+ TEST_INSTRUCTION("41705F78", ldrh(w1, ptr(x2, -9))); // LDURH
488
+ TEST_INSTRUCTION("4104C039", ldrsb(w1, ptr(x2, 1)));
489
+ TEST_INSTRUCTION("41D0DF38", ldrsb(w1, ptr(x2, -3))); // LDURSB
490
+ TEST_INSTRUCTION("4170DF38", ldrsb(w1, ptr(x2, -9))); // LDURSB
491
+ TEST_INSTRUCTION("41048039", ldrsb(x1, ptr(x2, 1)));
492
+ TEST_INSTRUCTION("41D09F38", ldrsb(x1, ptr(x2, -3))); // LDURSB
493
+ TEST_INSTRUCTION("41709F38", ldrsb(x1, ptr(x2, -9))); // LDURSB
494
+ TEST_INSTRUCTION("4110C078", ldrsh(w1, ptr(x2, 1))); // LDURSH
495
+ TEST_INSTRUCTION("41D0DF78", ldrsh(w1, ptr(x2, -3))); // LDURSH
496
+ TEST_INSTRUCTION("4170DF78", ldrsh(w1, ptr(x2, -9))); // LDURSH
497
+ TEST_INSTRUCTION("41108078", ldrsh(x1, ptr(x2, 1))); // LDURSH
498
+ TEST_INSTRUCTION("41D09F78", ldrsh(x1, ptr(x2, -3))); // LDURSH
499
+ TEST_INSTRUCTION("41709F78", ldrsh(x1, ptr(x2, -9))); // LDURSH
500
+ TEST_INSTRUCTION("410080B9", ldrsw(x1, ptr(x2)));
501
+ TEST_INSTRUCTION("413080B9", ldrsw(x1, ptr(x2, 48)));
502
+ TEST_INSTRUCTION("410C83B8", ldrsw(x1, ptr_pre(x2, 48)));
503
+ TEST_INSTRUCTION("410483B8", ldrsw(x1, ptr_post(x2, 48)));
504
+ TEST_INSTRUCTION("4168A3B8", ldrsw(x1, ptr(x2, x3)));
505
+ TEST_INSTRUCTION("411080B8", ldrsw(x1, ptr(x2, 1))); // LDURSW
506
+ TEST_INSTRUCTION("413080B8", ldrsw(x1, ptr(x2, 3))); // LDURSW
507
+ TEST_INSTRUCTION("41709FB8", ldrsw(x1, ptr(x2, -9))); // LDURSW
508
+ TEST_INSTRUCTION("410420F8", ldraa(x1, ptr(x2)));
509
+ TEST_INSTRUCTION("410460F8", ldraa(x1, ptr(x2, -4096)));
510
+ TEST_INSTRUCTION("410C60F8", ldraa(x1, ptr_pre(x2, -4096)));
511
+ TEST_INSTRUCTION("41FC3FF8", ldraa(x1, ptr_pre(x2, 4088)));
512
+ TEST_INSTRUCTION("E10720F8", ldraa(x1, ptr(sp)));
513
+ TEST_INSTRUCTION("E10760F8", ldraa(x1, ptr(sp, -4096)));
514
+ TEST_INSTRUCTION("E10F60F8", ldraa(x1, ptr_pre(sp, -4096)));
515
+ TEST_INSTRUCTION("E1FF3FF8", ldraa(x1, ptr_pre(sp, 4088)));
516
+ TEST_INSTRUCTION("4104A0F8", ldrab(x1, ptr(x2)));
517
+ TEST_INSTRUCTION("4104E0F8", ldrab(x1, ptr(x2, -4096)));
518
+ TEST_INSTRUCTION("410CE0F8", ldrab(x1, ptr_pre(x2, -4096)));
519
+ TEST_INSTRUCTION("41FCBFF8", ldrab(x1, ptr_pre(x2, 4088)));
520
+ TEST_INSTRUCTION("E107A0F8", ldrab(x1, ptr(sp)));
521
+ TEST_INSTRUCTION("E107E0F8", ldrab(x1, ptr(sp, -4096)));
522
+ TEST_INSTRUCTION("E10FE0F8", ldrab(x1, ptr_pre(sp, -4096)));
523
+ TEST_INSTRUCTION("E1FFBFF8", ldrab(x1, ptr_pre(sp, 4088)));
524
+ TEST_INSTRUCTION("60DBA0B8", ldrsw(x0, ptr(x27, w0, sxtw(2))));
525
+ TEST_INSTRUCTION("623021B8", ldset(w1, w2, ptr(x3)));
526
+ TEST_INSTRUCTION("E23321B8", ldset(w1, w2, ptr(sp)));
527
+ TEST_INSTRUCTION("623021F8", ldset(x1, x2, ptr(x3)));
528
+ TEST_INSTRUCTION("E23321F8", ldset(x1, x2, ptr(sp)));
529
+ TEST_INSTRUCTION("6230A1B8", ldseta(w1, w2, ptr(x3)));
530
+ TEST_INSTRUCTION("E233A1B8", ldseta(w1, w2, ptr(sp)));
531
+ TEST_INSTRUCTION("6230A1F8", ldseta(x1, x2, ptr(x3)));
532
+ TEST_INSTRUCTION("E233A1F8", ldseta(x1, x2, ptr(sp)));
533
+ TEST_INSTRUCTION("6230A138", ldsetab(w1, w2, ptr(x3)));
534
+ TEST_INSTRUCTION("E233A138", ldsetab(w1, w2, ptr(sp)));
535
+ TEST_INSTRUCTION("6230A178", ldsetah(w1, w2, ptr(x3)));
536
+ TEST_INSTRUCTION("E233A178", ldsetah(w1, w2, ptr(sp)));
537
+ TEST_INSTRUCTION("6230E1B8", ldsetal(w1, w2, ptr(x3)));
538
+ TEST_INSTRUCTION("E233E1B8", ldsetal(w1, w2, ptr(sp)));
539
+ TEST_INSTRUCTION("6230E1F8", ldsetal(x1, x2, ptr(x3)));
540
+ TEST_INSTRUCTION("E233E1F8", ldsetal(x1, x2, ptr(sp)));
541
+ TEST_INSTRUCTION("6230E178", ldsetalh(w1, w2, ptr(x3)));
542
+ TEST_INSTRUCTION("E233E178", ldsetalh(w1, w2, ptr(sp)));
543
+ TEST_INSTRUCTION("6230E138", ldsetalb(w1, w2, ptr(x3)));
544
+ TEST_INSTRUCTION("E233E138", ldsetalb(w1, w2, ptr(sp)));
545
+ TEST_INSTRUCTION("62302138", ldsetb(w1, w2, ptr(x3)));
546
+ TEST_INSTRUCTION("E2332138", ldsetb(w1, w2, ptr(sp)));
547
+ TEST_INSTRUCTION("62302178", ldseth(w1, w2, ptr(x3)));
548
+ TEST_INSTRUCTION("E2332178", ldseth(w1, w2, ptr(sp)));
549
+ TEST_INSTRUCTION("623061B8", ldsetl(w1, w2, ptr(x3)));
550
+ TEST_INSTRUCTION("E23361B8", ldsetl(w1, w2, ptr(sp)));
551
+ TEST_INSTRUCTION("623061F8", ldsetl(x1, x2, ptr(x3)));
552
+ TEST_INSTRUCTION("E23361F8", ldsetl(x1, x2, ptr(sp)));
553
+ TEST_INSTRUCTION("62306138", ldsetlb(w1, w2, ptr(x3)));
554
+ TEST_INSTRUCTION("E2336138", ldsetlb(w1, w2, ptr(sp)));
555
+ TEST_INSTRUCTION("62306178", ldsetlh(w1, w2, ptr(x3)));
556
+ TEST_INSTRUCTION("E2336178", ldsetlh(w1, w2, ptr(sp)));
557
+ TEST_INSTRUCTION("624021B8", ldsmax(w1, w2, ptr(x3)));
558
+ TEST_INSTRUCTION("E24321B8", ldsmax(w1, w2, ptr(sp)));
559
+ TEST_INSTRUCTION("624021F8", ldsmax(x1, x2, ptr(x3)));
560
+ TEST_INSTRUCTION("E24321F8", ldsmax(x1, x2, ptr(sp)));
561
+ TEST_INSTRUCTION("6240A1B8", ldsmaxa(w1, w2, ptr(x3)));
562
+ TEST_INSTRUCTION("E243A1B8", ldsmaxa(w1, w2, ptr(sp)));
563
+ TEST_INSTRUCTION("6240A1F8", ldsmaxa(x1, x2, ptr(x3)));
564
+ TEST_INSTRUCTION("E243A1F8", ldsmaxa(x1, x2, ptr(sp)));
565
+ TEST_INSTRUCTION("6240A138", ldsmaxab(w1, w2, ptr(x3)));
566
+ TEST_INSTRUCTION("E243A138", ldsmaxab(w1, w2, ptr(sp)));
567
+ TEST_INSTRUCTION("6240A178", ldsmaxah(w1, w2, ptr(x3)));
568
+ TEST_INSTRUCTION("E243A178", ldsmaxah(w1, w2, ptr(sp)));
569
+ TEST_INSTRUCTION("6240E1B8", ldsmaxal(w1, w2, ptr(x3)));
570
+ TEST_INSTRUCTION("E243E1B8", ldsmaxal(w1, w2, ptr(sp)));
571
+ TEST_INSTRUCTION("6240E1F8", ldsmaxal(x1, x2, ptr(x3)));
572
+ TEST_INSTRUCTION("E243E1F8", ldsmaxal(x1, x2, ptr(sp)));
573
+ TEST_INSTRUCTION("6240E138", ldsmaxalb(w1, w2, ptr(x3)));
574
+ TEST_INSTRUCTION("E243E138", ldsmaxalb(w1, w2, ptr(sp)));
575
+ TEST_INSTRUCTION("6240E178", ldsmaxalh(w1, w2, ptr(x3)));
576
+ TEST_INSTRUCTION("E243E178", ldsmaxalh(w1, w2, ptr(sp)));
577
+ TEST_INSTRUCTION("62402138", ldsmaxb(w1, w2, ptr(x3)));
578
+ TEST_INSTRUCTION("E2432138", ldsmaxb(w1, w2, ptr(sp)));
579
+ TEST_INSTRUCTION("62402178", ldsmaxh(w1, w2, ptr(x3)));
580
+ TEST_INSTRUCTION("E2432178", ldsmaxh(w1, w2, ptr(sp)));
581
+ TEST_INSTRUCTION("624061B8", ldsmaxl(w1, w2, ptr(x3)));
582
+ TEST_INSTRUCTION("E24361B8", ldsmaxl(w1, w2, ptr(sp)));
583
+ TEST_INSTRUCTION("624061F8", ldsmaxl(x1, x2, ptr(x3)));
584
+ TEST_INSTRUCTION("E24361F8", ldsmaxl(x1, x2, ptr(sp)));
585
+ TEST_INSTRUCTION("62406138", ldsmaxlb(w1, w2, ptr(x3)));
586
+ TEST_INSTRUCTION("E2436138", ldsmaxlb(w1, w2, ptr(sp)));
587
+ TEST_INSTRUCTION("62406178", ldsmaxlh(w1, w2, ptr(x3)));
588
+ TEST_INSTRUCTION("E2436178", ldsmaxlh(w1, w2, ptr(sp)));
589
+ TEST_INSTRUCTION("625021B8", ldsmin(w1, w2, ptr(x3)));
590
+ TEST_INSTRUCTION("E25321B8", ldsmin(w1, w2, ptr(sp)));
591
+ TEST_INSTRUCTION("625021F8", ldsmin(x1, x2, ptr(x3)));
592
+ TEST_INSTRUCTION("E25321F8", ldsmin(x1, x2, ptr(sp)));
593
+ TEST_INSTRUCTION("6250A1B8", ldsmina(w1, w2, ptr(x3)));
594
+ TEST_INSTRUCTION("E253A1B8", ldsmina(w1, w2, ptr(sp)));
595
+ TEST_INSTRUCTION("6250A1F8", ldsmina(x1, x2, ptr(x3)));
596
+ TEST_INSTRUCTION("E253A1F8", ldsmina(x1, x2, ptr(sp)));
597
+ TEST_INSTRUCTION("6250A138", ldsminab(w1, w2, ptr(x3)));
598
+ TEST_INSTRUCTION("E253A138", ldsminab(w1, w2, ptr(sp)));
599
+ TEST_INSTRUCTION("6250A178", ldsminah(w1, w2, ptr(x3)));
600
+ TEST_INSTRUCTION("E253A178", ldsminah(w1, w2, ptr(sp)));
601
+ TEST_INSTRUCTION("6250E1B8", ldsminal(w1, w2, ptr(x3)));
602
+ TEST_INSTRUCTION("E253E1B8", ldsminal(w1, w2, ptr(sp)));
603
+ TEST_INSTRUCTION("6250E1F8", ldsminal(x1, x2, ptr(x3)));
604
+ TEST_INSTRUCTION("E253E1F8", ldsminal(x1, x2, ptr(sp)));
605
+ TEST_INSTRUCTION("6250E138", ldsminalb(w1, w2, ptr(x3)));
606
+ TEST_INSTRUCTION("E253E138", ldsminalb(w1, w2, ptr(sp)));
607
+ TEST_INSTRUCTION("6250E178", ldsminalh(w1, w2, ptr(x3)));
608
+ TEST_INSTRUCTION("E253E178", ldsminalh(w1, w2, ptr(sp)));
609
+ TEST_INSTRUCTION("62502138", ldsminb(w1, w2, ptr(x3)));
610
+ TEST_INSTRUCTION("E2532138", ldsminb(w1, w2, ptr(sp)));
611
+ TEST_INSTRUCTION("62502178", ldsminh(w1, w2, ptr(x3)));
612
+ TEST_INSTRUCTION("E2532178", ldsminh(w1, w2, ptr(sp)));
613
+ TEST_INSTRUCTION("625061B8", ldsminl(w1, w2, ptr(x3)));
614
+ TEST_INSTRUCTION("E25361B8", ldsminl(w1, w2, ptr(sp)));
615
+ TEST_INSTRUCTION("625061F8", ldsminl(x1, x2, ptr(x3)));
616
+ TEST_INSTRUCTION("E25361F8", ldsminl(x1, x2, ptr(sp)));
617
+ TEST_INSTRUCTION("62506138", ldsminlb(w1, w2, ptr(x3)));
618
+ TEST_INSTRUCTION("E2536138", ldsminlb(w1, w2, ptr(sp)));
619
+ TEST_INSTRUCTION("62506178", ldsminlh(w1, w2, ptr(x3)));
620
+ TEST_INSTRUCTION("E2536178", ldsminlh(w1, w2, ptr(sp)));
621
+ TEST_INSTRUCTION("410840B8", ldtr(w1, ptr(x2)));
622
+ TEST_INSTRUCTION("411848B8", ldtr(w1, ptr(x2, 129)));
623
+ TEST_INSTRUCTION("E10B40B8", ldtr(w1, ptr(sp)));
624
+ TEST_INSTRUCTION("E11B48B8", ldtr(w1, ptr(sp, 129)));
625
+ TEST_INSTRUCTION("410840F8", ldtr(x1, ptr(x2)));
626
+ TEST_INSTRUCTION("411848F8", ldtr(x1, ptr(x2, 129)));
627
+ TEST_INSTRUCTION("E10B40F8", ldtr(x1, ptr(sp)));
628
+ TEST_INSTRUCTION("E11B48F8", ldtr(x1, ptr(sp, 129)));
629
+ TEST_INSTRUCTION("41084038", ldtrb(w1, ptr(x2)));
630
+ TEST_INSTRUCTION("41184838", ldtrb(w1, ptr(x2, 129)));
631
+ TEST_INSTRUCTION("E10B4038", ldtrb(w1, ptr(sp)));
632
+ TEST_INSTRUCTION("E11B4838", ldtrb(w1, ptr(sp, 129)));
633
+ TEST_INSTRUCTION("41084078", ldtrh(w1, ptr(x2)));
634
+ TEST_INSTRUCTION("41184878", ldtrh(w1, ptr(x2, 129)));
635
+ TEST_INSTRUCTION("E10B4078", ldtrh(w1, ptr(sp)));
636
+ TEST_INSTRUCTION("E11B4878", ldtrh(w1, ptr(sp, 129)));
637
+ TEST_INSTRUCTION("4108C038", ldtrsb(w1, ptr(x2)));
638
+ TEST_INSTRUCTION("4118C838", ldtrsb(w1, ptr(x2, 129)));
639
+ TEST_INSTRUCTION("E10BC038", ldtrsb(w1, ptr(sp)));
640
+ TEST_INSTRUCTION("E11BC838", ldtrsb(w1, ptr(sp, 129)));
641
+ TEST_INSTRUCTION("4108C078", ldtrsh(w1, ptr(x2)));
642
+ TEST_INSTRUCTION("4118C878", ldtrsh(w1, ptr(x2, 129)));
643
+ TEST_INSTRUCTION("E10BC078", ldtrsh(w1, ptr(sp)));
644
+ TEST_INSTRUCTION("E11BC878", ldtrsh(w1, ptr(sp, 129)));
645
+ TEST_INSTRUCTION("410880B8", ldtrsw(x1, ptr(x2)));
646
+ TEST_INSTRUCTION("411888B8", ldtrsw(x1, ptr(x2, 129)));
647
+ TEST_INSTRUCTION("E10B80B8", ldtrsw(x1, ptr(sp)));
648
+ TEST_INSTRUCTION("E11B88B8", ldtrsw(x1, ptr(sp, 129)));
649
+ TEST_INSTRUCTION("626021B8", ldumax(w1, w2, ptr(x3)));
650
+ TEST_INSTRUCTION("E26321B8", ldumax(w1, w2, ptr(sp)));
651
+ TEST_INSTRUCTION("626021F8", ldumax(x1, x2, ptr(x3)));
652
+ TEST_INSTRUCTION("E26321F8", ldumax(x1, x2, ptr(sp)));
653
+ TEST_INSTRUCTION("6260A1B8", ldumaxa(w1, w2, ptr(x3)));
654
+ TEST_INSTRUCTION("E263A1B8", ldumaxa(w1, w2, ptr(sp)));
655
+ TEST_INSTRUCTION("6260A1F8", ldumaxa(x1, x2, ptr(x3)));
656
+ TEST_INSTRUCTION("E263A1F8", ldumaxa(x1, x2, ptr(sp)));
657
+ TEST_INSTRUCTION("6260A138", ldumaxab(w1, w2, ptr(x3)));
658
+ TEST_INSTRUCTION("E263A138", ldumaxab(w1, w2, ptr(sp)));
659
+ TEST_INSTRUCTION("6260A178", ldumaxah(w1, w2, ptr(x3)));
660
+ TEST_INSTRUCTION("E263A178", ldumaxah(w1, w2, ptr(sp)));
661
+ TEST_INSTRUCTION("6260E1B8", ldumaxal(w1, w2, ptr(x3)));
662
+ TEST_INSTRUCTION("E263E1B8", ldumaxal(w1, w2, ptr(sp)));
663
+ TEST_INSTRUCTION("6260E1F8", ldumaxal(x1, x2, ptr(x3)));
664
+ TEST_INSTRUCTION("E263E1F8", ldumaxal(x1, x2, ptr(sp)));
665
+ TEST_INSTRUCTION("6260E138", ldumaxalb(w1, w2, ptr(x3)));
666
+ TEST_INSTRUCTION("E263E138", ldumaxalb(w1, w2, ptr(sp)));
667
+ TEST_INSTRUCTION("6260E178", ldumaxalh(w1, w2, ptr(x3)));
668
+ TEST_INSTRUCTION("E263E178", ldumaxalh(w1, w2, ptr(sp)));
669
+ TEST_INSTRUCTION("62602138", ldumaxb(w1, w2, ptr(x3)));
670
+ TEST_INSTRUCTION("E2632138", ldumaxb(w1, w2, ptr(sp)));
671
+ TEST_INSTRUCTION("62602178", ldumaxh(w1, w2, ptr(x3)));
672
+ TEST_INSTRUCTION("E2632178", ldumaxh(w1, w2, ptr(sp)));
673
+ TEST_INSTRUCTION("626061B8", ldumaxl(w1, w2, ptr(x3)));
674
+ TEST_INSTRUCTION("E26361B8", ldumaxl(w1, w2, ptr(sp)));
675
+ TEST_INSTRUCTION("626061F8", ldumaxl(x1, x2, ptr(x3)));
676
+ TEST_INSTRUCTION("E26361F8", ldumaxl(x1, x2, ptr(sp)));
677
+ TEST_INSTRUCTION("62606138", ldumaxlb(w1, w2, ptr(x3)));
678
+ TEST_INSTRUCTION("E2636138", ldumaxlb(w1, w2, ptr(sp)));
679
+ TEST_INSTRUCTION("62606178", ldumaxlh(w1, w2, ptr(x3)));
680
+ TEST_INSTRUCTION("E2636178", ldumaxlh(w1, w2, ptr(sp)));
681
+ TEST_INSTRUCTION("627021B8", ldumin(w1, w2, ptr(x3)));
682
+ TEST_INSTRUCTION("E27321B8", ldumin(w1, w2, ptr(sp)));
683
+ TEST_INSTRUCTION("627021F8", ldumin(x1, x2, ptr(x3)));
684
+ TEST_INSTRUCTION("E27321F8", ldumin(x1, x2, ptr(sp)));
685
+ TEST_INSTRUCTION("6270A1B8", ldumina(w1, w2, ptr(x3)));
686
+ TEST_INSTRUCTION("E273A1B8", ldumina(w1, w2, ptr(sp)));
687
+ TEST_INSTRUCTION("6270A1F8", ldumina(x1, x2, ptr(x3)));
688
+ TEST_INSTRUCTION("E273A1F8", ldumina(x1, x2, ptr(sp)));
689
+ TEST_INSTRUCTION("6270A138", lduminab(w1, w2, ptr(x3)));
690
+ TEST_INSTRUCTION("E273A138", lduminab(w1, w2, ptr(sp)));
691
+ TEST_INSTRUCTION("6270A178", lduminah(w1, w2, ptr(x3)));
692
+ TEST_INSTRUCTION("E273A178", lduminah(w1, w2, ptr(sp)));
693
+ TEST_INSTRUCTION("6270E1B8", lduminal(w1, w2, ptr(x3)));
694
+ TEST_INSTRUCTION("E273E1B8", lduminal(w1, w2, ptr(sp)));
695
+ TEST_INSTRUCTION("6270E1F8", lduminal(x1, x2, ptr(x3)));
696
+ TEST_INSTRUCTION("E273E1F8", lduminal(x1, x2, ptr(sp)));
697
+ TEST_INSTRUCTION("6270E138", lduminalb(w1, w2, ptr(x3)));
698
+ TEST_INSTRUCTION("E273E138", lduminalb(w1, w2, ptr(sp)));
699
+ TEST_INSTRUCTION("6270E178", lduminalh(w1, w2, ptr(x3)));
700
+ TEST_INSTRUCTION("E273E178", lduminalh(w1, w2, ptr(sp)));
701
+ TEST_INSTRUCTION("62702138", lduminb(w1, w2, ptr(x3)));
702
+ TEST_INSTRUCTION("E2732138", lduminb(w1, w2, ptr(sp)));
703
+ TEST_INSTRUCTION("62702178", lduminh(w1, w2, ptr(x3)));
704
+ TEST_INSTRUCTION("E2732178", lduminh(w1, w2, ptr(sp)));
705
+ TEST_INSTRUCTION("627061B8", lduminl(w1, w2, ptr(x3)));
706
+ TEST_INSTRUCTION("E27361B8", lduminl(w1, w2, ptr(sp)));
707
+ TEST_INSTRUCTION("627061F8", lduminl(x1, x2, ptr(x3)));
708
+ TEST_INSTRUCTION("E27361F8", lduminl(x1, x2, ptr(sp)));
709
+ TEST_INSTRUCTION("62706138", lduminlb(w1, w2, ptr(x3)));
710
+ TEST_INSTRUCTION("E2736138", lduminlb(w1, w2, ptr(sp)));
711
+ TEST_INSTRUCTION("62706178", lduminlh(w1, w2, ptr(x3)));
712
+ TEST_INSTRUCTION("E2736178", lduminlh(w1, w2, ptr(sp)));
713
+ TEST_INSTRUCTION("410040B8", ldur(w1, ptr(x2)));
714
+ TEST_INSTRUCTION("411048B8", ldur(w1, ptr(x2, 129)));
715
+ TEST_INSTRUCTION("E10340B8", ldur(w1, ptr(sp)));
716
+ TEST_INSTRUCTION("E11348B8", ldur(w1, ptr(sp, 129)));
717
+ TEST_INSTRUCTION("410040F8", ldur(x1, ptr(x2)));
718
+ TEST_INSTRUCTION("411048F8", ldur(x1, ptr(x2, 129)));
719
+ TEST_INSTRUCTION("E10340F8", ldur(x1, ptr(sp)));
720
+ TEST_INSTRUCTION("E11348F8", ldur(x1, ptr(sp, 129)));
721
+ TEST_INSTRUCTION("41004038", ldurb(w1, ptr(x2)));
722
+ TEST_INSTRUCTION("41104838", ldurb(w1, ptr(x2, 129)));
723
+ TEST_INSTRUCTION("E1034038", ldurb(w1, ptr(sp)));
724
+ TEST_INSTRUCTION("E1134838", ldurb(w1, ptr(sp, 129)));
725
+ TEST_INSTRUCTION("41004078", ldurh(w1, ptr(x2)));
726
+ TEST_INSTRUCTION("41104878", ldurh(w1, ptr(x2, 129)));
727
+ TEST_INSTRUCTION("E1034078", ldurh(w1, ptr(sp)));
728
+ TEST_INSTRUCTION("E1134878", ldurh(w1, ptr(sp, 129)));
729
+ TEST_INSTRUCTION("4100C038", ldursb(w1, ptr(x2)));
730
+ TEST_INSTRUCTION("4110C838", ldursb(w1, ptr(x2, 129)));
731
+ TEST_INSTRUCTION("E103C038", ldursb(w1, ptr(sp)));
732
+ TEST_INSTRUCTION("E113C838", ldursb(w1, ptr(sp, 129)));
733
+ TEST_INSTRUCTION("4100C078", ldursh(w1, ptr(x2)));
734
+ TEST_INSTRUCTION("4110C878", ldursh(w1, ptr(x2, 129)));
735
+ TEST_INSTRUCTION("E103C078", ldursh(w1, ptr(sp)));
736
+ TEST_INSTRUCTION("E113C878", ldursh(w1, ptr(sp, 129)));
737
+ TEST_INSTRUCTION("410080B8", ldursw(x1, ptr(x2)));
738
+ TEST_INSTRUCTION("411088B8", ldursw(x1, ptr(x2, 129)));
739
+ TEST_INSTRUCTION("E10380B8", ldursw(x1, ptr(sp)));
740
+ TEST_INSTRUCTION("E11388B8", ldursw(x1, ptr(sp, 129)));
741
+ TEST_INSTRUCTION("61087F88", ldxp(w1, w2, ptr(x3)));
742
+ TEST_INSTRUCTION("E10B7F88", ldxp(w1, w2, ptr(sp)));
743
+ TEST_INSTRUCTION("61087FC8", ldxp(x1, x2, ptr(x3)));
744
+ TEST_INSTRUCTION("E10B7FC8", ldxp(x1, x2, ptr(sp)));
745
+ TEST_INSTRUCTION("417C5F88", ldxr(w1, ptr(x2)));
746
+ TEST_INSTRUCTION("E17F5F88", ldxr(w1, ptr(sp)));
747
+ TEST_INSTRUCTION("417C5FC8", ldxr(x1, ptr(x2)));
748
+ TEST_INSTRUCTION("E17F5FC8", ldxr(x1, ptr(sp)));
749
+ TEST_INSTRUCTION("417C5F08", ldxrb(w1, ptr(x2)));
750
+ TEST_INSTRUCTION("E17F5F08", ldxrb(w1, ptr(sp)));
751
+ TEST_INSTRUCTION("417C5F48", ldxrh(w1, ptr(x2)));
752
+ TEST_INSTRUCTION("E17F5F48", ldxrh(w1, ptr(sp)));
753
+ TEST_INSTRUCTION("4120C31A", lsl(w1, w2, w3));
754
+ TEST_INSTRUCTION("4120C39A", lsl(x1, x2, x3));
755
+ TEST_INSTRUCTION("41401153", lsl(w1, w2, 15));
756
+ TEST_INSTRUCTION("41C071D3", lsl(x1, x2, 15));
757
+ TEST_INSTRUCTION("4120C31A", lslv(w1, w2, w3));
758
+ TEST_INSTRUCTION("4120C39A", lslv(x1, x2, x3));
759
+ TEST_INSTRUCTION("4124C31A", lsr(w1, w2, w3));
760
+ TEST_INSTRUCTION("4124C39A", lsr(x1, x2, x3));
761
+ TEST_INSTRUCTION("417C0F53", lsr(w1, w2, 15));
762
+ TEST_INSTRUCTION("41FC4FD3", lsr(x1, x2, 15));
763
+ TEST_INSTRUCTION("4124C31A", lsrv(w1, w2, w3));
764
+ TEST_INSTRUCTION("4124C39A", lsrv(x1, x2, x3));
765
+ TEST_INSTRUCTION("4110031B", madd(w1, w2, w3, w4));
766
+ TEST_INSTRUCTION("4110039B", madd(x1, x2, x3, x4));
767
+ TEST_INSTRUCTION("41FC031B", mneg(w1, w2, w3));
768
+ TEST_INSTRUCTION("41FC039B", mneg(x1, x2, x3));
769
+ TEST_INSTRUCTION("E103022A", mov(w1, w2));
770
+ TEST_INSTRUCTION("E10302AA", mov(x1, x2));
771
+ TEST_INSTRUCTION("01008052", mov(w1, 0));
772
+ TEST_INSTRUCTION("01008012", mov(w1, -1));
773
+ TEST_INSTRUCTION("21008052", mov(w1, 1));
774
+ TEST_INSTRUCTION("41008052", mov(w1, 2));
775
+ TEST_INSTRUCTION("61008052", mov(w1, 3));
776
+ TEST_INSTRUCTION("81008052", mov(w1, 4));
777
+ TEST_INSTRUCTION("A1008052", mov(w1, 5));
778
+ TEST_INSTRUCTION("C1008052", mov(w1, 6));
779
+ TEST_INSTRUCTION("E1008052", mov(w1, 7));
780
+ TEST_INSTRUCTION("01018052", mov(w1, 8));
781
+ TEST_INSTRUCTION("21018052", mov(w1, 9));
782
+ TEST_INSTRUCTION("41018052", mov(w1, 10));
783
+ TEST_INSTRUCTION("8146A252", mov(w1, 0x12340000));
784
+ TEST_INSTRUCTION("81468252", mov(w1, 0x00001234));
785
+ TEST_INSTRUCTION("61B9BD12", mov(w1, 0x1234FFFF));
786
+ TEST_INSTRUCTION("61B99D12", mov(w1, 0xFFFF1234));
787
+ TEST_INSTRUCTION("010080D2", mov(x1, 0));
788
+ TEST_INSTRUCTION("01008092", mov(x1, -1));
789
+ TEST_INSTRUCTION("8146E2D2", mov(x1, 0x1234000000000000));
790
+ TEST_INSTRUCTION("8146C2D2", mov(x1, 0x0000123400000000));
791
+ TEST_INSTRUCTION("8146A2D2", mov(x1, 0x0000000012340000));
792
+ TEST_INSTRUCTION("814682D2", mov(x1, 0x0000000000001234));
793
+ TEST_INSTRUCTION("61B9FD92", mov(x1, 0x1234FFFFFFFFFFFF));
794
+ TEST_INSTRUCTION("61B9DD92", mov(x1, 0xFFFF1234FFFFFFFF));
795
+ TEST_INSTRUCTION("61B9BD92", mov(x1, 0xFFFFFFFF1234FFFF));
796
+ TEST_INSTRUCTION("61B99D92", mov(x1, 0xFFFFFFFFFFFF1234));
797
+ TEST_INSTRUCTION("E1030011", mov(w1, wsp));
798
+ TEST_INSTRUCTION("E1030091", mov(x1, sp));
799
+ TEST_INSTRUCTION("3F000011", mov(wsp, w1));
800
+ TEST_INSTRUCTION("FF3F0032", mov(wsp, 0xFFFF));
801
+ TEST_INSTRUCTION("3F000091", mov(sp, x1));
802
+ TEST_INSTRUCTION("FF3F40B2", mov(sp, 0xFFFF));
803
+ TEST_INSTRUCTION("FF030011", mov(wsp, wsp));
804
+ TEST_INSTRUCTION("FF030091", mov(sp, sp));
805
+ TEST_INSTRUCTION("015138D5", mrs(x1, Predicate::SysReg::kAFSR0_EL1));
806
+ TEST_INSTRUCTION("01423BD5", mrs(x1, Predicate::SysReg::kNZCV));
807
+ TEST_INSTRUCTION("015118D5", msr(Predicate::SysReg::kAFSR0_EL1, x1));
808
+ TEST_INSTRUCTION("01421BD5", msr(Predicate::SysReg::kNZCV, x1));
809
+ TEST_INSTRUCTION("4190031B", msub(w1, w2, w3, w4));
810
+ TEST_INSTRUCTION("4190039B", msub(x1, x2, x3, x4));
811
+ TEST_INSTRUCTION("417C031B", mul(w1, w2, w3));
812
+ TEST_INSTRUCTION("417C039B", mul(x1, x2, x3));
813
+ TEST_INSTRUCTION("E103222A", mvn(w1, w2));
814
+ TEST_INSTRUCTION("E10322AA", mvn(x1, x2));
815
+ TEST_INSTRUCTION("E113222A", mvn(w1, w2, lsl(4)));
816
+ TEST_INSTRUCTION("E11322AA", mvn(x1, x2, lsl(4)));
817
+ TEST_INSTRUCTION("E103024B", neg(w1, w2));
818
+ TEST_INSTRUCTION("E10302CB", neg(x1, x2));
819
+ TEST_INSTRUCTION("E113024B", neg(w1, w2, lsl(4)));
820
+ TEST_INSTRUCTION("E11302CB", neg(x1, x2, lsl(4)));
821
+ TEST_INSTRUCTION("E103026B", negs(w1, w2));
822
+ TEST_INSTRUCTION("E10302EB", negs(x1, x2));
823
+ TEST_INSTRUCTION("E113026B", negs(w1, w2, lsl(4)));
824
+ TEST_INSTRUCTION("E11302EB", negs(x1, x2, lsl(4)));
825
+ TEST_INSTRUCTION("E103025A", ngc(w1, w2));
826
+ TEST_INSTRUCTION("E10302DA", ngc(x1, x2));
827
+ TEST_INSTRUCTION("E103027A", ngcs(w1, w2));
828
+ TEST_INSTRUCTION("E10302FA", ngcs(x1, x2));
829
+ TEST_INSTRUCTION("4100232A", orn(w1, w2, w3));
830
+ TEST_INSTRUCTION("410023AA", orn(x1, x2, x3));
831
+ TEST_INSTRUCTION("4110232A", orn(w1, w2, w3, lsl(4)));
832
+ TEST_INSTRUCTION("411023AA", orn(x1, x2, x3, lsl(4)));
833
+ TEST_INSTRUCTION("4100032A", orr(w1, w2, w3));
834
+ TEST_INSTRUCTION("410003AA", orr(x1, x2, x3));
835
+ TEST_INSTRUCTION("4110032A", orr(w1, w2, w3, lsl(4)));
836
+ TEST_INSTRUCTION("411003AA", orr(x1, x2, x3, lsl(4)));
837
+ TEST_INSTRUCTION("3F1C0032", orr(wsp, w1, 0xFF));
838
+ TEST_INSTRUCTION("3F1C40B2", orr(sp, x1, 0xFF));
839
+ TEST_INSTRUCTION("41001232", orr(w1, w2, 0x4000));
840
+ TEST_INSTRUCTION("410071B2", orr(x1, x2, 0x8000));
841
+ TEST_INSTRUCTION("E8030032", orr(w8, wzr, 0x1));
842
+ TEST_INSTRUCTION("E80340B2", orr(x8, xzr, 0x1));
843
+ TEST_INSTRUCTION("4108C1DA", pacda(x1, x2));
844
+ TEST_INSTRUCTION("E10BC1DA", pacda(x1, sp));
845
+ TEST_INSTRUCTION("410CC1DA", pacdb(x1, x2));
846
+ TEST_INSTRUCTION("E10FC1DA", pacdb(x1, sp));
847
+ TEST_INSTRUCTION("E12BC1DA", pacdza(x1));
848
+ TEST_INSTRUCTION("F42BC1DA", pacdza(x20));
849
+ TEST_INSTRUCTION("E12FC1DA", pacdzb(x1));
850
+ TEST_INSTRUCTION("F42FC1DA", pacdzb(x20));
851
+ TEST_INSTRUCTION("4130C39A", pacga(x1, x2, x3));
852
+ TEST_INSTRUCTION("4130DF9A", pacga(x1, x2, sp));
853
+ TEST_INSTRUCTION("9F3403D5", pssbb());
854
+ TEST_INSTRUCTION("4100C05A", rbit(w1, w2));
855
+ TEST_INSTRUCTION("4100C0DA", rbit(x1, x2));
856
+ TEST_INSTRUCTION("4108C05A", rev(w1, w2));
857
+ TEST_INSTRUCTION("410CC0DA", rev(x1, x2));
858
+ TEST_INSTRUCTION("4104C05A", rev16(w1, w2));
859
+ TEST_INSTRUCTION("4104C0DA", rev16(x1, x2));
860
+ TEST_INSTRUCTION("4108C0DA", rev32(x1, x2));
861
+ TEST_INSTRUCTION("410CC0DA", rev64(x1, x2));
862
+ TEST_INSTRUCTION("412CC31A", ror(w1, w2, w3));
863
+ TEST_INSTRUCTION("412CC39A", ror(x1, x2, x3));
864
+ TEST_INSTRUCTION("413C8213", ror(w1, w2, 15));
865
+ TEST_INSTRUCTION("413CC293", ror(x1, x2, 15));
866
+ TEST_INSTRUCTION("412CC31A", rorv(w1, w2, w3));
867
+ TEST_INSTRUCTION("412CC39A", rorv(x1, x2, x3));
868
+ TEST_INSTRUCTION("4100035A", sbc(w1, w2, w3));
869
+ TEST_INSTRUCTION("410003DA", sbc(x1, x2, x3));
870
+ TEST_INSTRUCTION("4100037A", sbcs(w1, w2, w3));
871
+ TEST_INSTRUCTION("410003FA", sbcs(x1, x2, x3));
872
+ TEST_INSTRUCTION("41241B13", sbfiz(w1, w2, 5, 10));
873
+ TEST_INSTRUCTION("41247B93", sbfiz(x1, x2, 5, 10));
874
+ TEST_INSTRUCTION("41280513", sbfm(w1, w2, 5, 10));
875
+ TEST_INSTRUCTION("41284593", sbfm(x1, x2, 5, 10));
876
+ TEST_INSTRUCTION("41380513", sbfx(w1, w2, 5, 10));
877
+ TEST_INSTRUCTION("41384593", sbfx(x1, x2, 5, 10));
878
+ TEST_INSTRUCTION("410CC31A", sdiv(w1, w2, w3));
879
+ TEST_INSTRUCTION("410CC39A", sdiv(x1, x2, x3));
880
+ TEST_INSTRUCTION("2D08003A", setf8(w1));
881
+ TEST_INSTRUCTION("2D48003A", setf16(w1));
882
+ TEST_INSTRUCTION("4110239B", smaddl(x1, w2, w3, x4));
883
+ TEST_INSTRUCTION("230000D4", smc(1));
884
+ TEST_INSTRUCTION("41FC239B", smnegl(x1, w2, w3));
885
+ TEST_INSTRUCTION("4190239B", smsubl(x1, w2, w3, x4));
886
+ TEST_INSTRUCTION("417C439B", smulh(x1, x2, x3));
887
+ TEST_INSTRUCTION("417C239B", smull(x1, w2, w3));
888
+ TEST_INSTRUCTION("9F3003D5", ssbb());
889
+ TEST_INSTRUCTION("4108A0D9", st2g(x1, ptr(x2)));
890
+ TEST_INSTRUCTION("4188A0D9", st2g(x1, ptr(x2, 128)));
891
+ TEST_INSTRUCTION("418CA0D9", st2g(x1, ptr_pre(x2, 128)));
892
+ TEST_INSTRUCTION("4184A0D9", st2g(x1, ptr_post(x2, 128)));
893
+ TEST_INSTRUCTION("E10BA0D9", st2g(x1, ptr(sp)));
894
+ TEST_INSTRUCTION("E18BA0D9", st2g(x1, ptr(sp, 128)));
895
+ TEST_INSTRUCTION("E18FA0D9", st2g(x1, ptr_pre(sp, 128)));
896
+ TEST_INSTRUCTION("E187A0D9", st2g(x1, ptr_post(sp, 128)));
897
+ TEST_INSTRUCTION("5F08A0D9", st2g(sp, ptr(x2)));
898
+ TEST_INSTRUCTION("5F88A0D9", st2g(sp, ptr(x2, 128)));
899
+ TEST_INSTRUCTION("5F8CA0D9", st2g(sp, ptr_pre(x2, 128)));
900
+ TEST_INSTRUCTION("5F84A0D9", st2g(sp, ptr_post(x2, 128)));
901
+ TEST_INSTRUCTION("FF0BA0D9", st2g(sp, ptr(sp)));
902
+ TEST_INSTRUCTION("FF8BA0D9", st2g(sp, ptr(sp, 128)));
903
+ TEST_INSTRUCTION("FF8FA0D9", st2g(sp, ptr_pre(sp, 128)));
904
+ TEST_INSTRUCTION("FF87A0D9", st2g(sp, ptr_post(sp, 128)));
905
+ TEST_INSTRUCTION("410820D9", stg(x1, ptr(x2)));
906
+ TEST_INSTRUCTION("418820D9", stg(x1, ptr(x2, 128)));
907
+ TEST_INSTRUCTION("418C20D9", stg(x1, ptr_pre(x2, 128)));
908
+ TEST_INSTRUCTION("418420D9", stg(x1, ptr_post(x2, 128)));
909
+ TEST_INSTRUCTION("E10B20D9", stg(x1, ptr(sp)));
910
+ TEST_INSTRUCTION("E18B20D9", stg(x1, ptr(sp, 128)));
911
+ TEST_INSTRUCTION("E18F20D9", stg(x1, ptr_pre(sp, 128)));
912
+ TEST_INSTRUCTION("E18720D9", stg(x1, ptr_post(sp, 128)));
913
+ TEST_INSTRUCTION("5F0820D9", stg(sp, ptr(x2)));
914
+ TEST_INSTRUCTION("5F8820D9", stg(sp, ptr(x2, 128)));
915
+ TEST_INSTRUCTION("5F8C20D9", stg(sp, ptr_pre(x2, 128)));
916
+ TEST_INSTRUCTION("5F8420D9", stg(sp, ptr_post(x2, 128)));
917
+ TEST_INSTRUCTION("FF0B20D9", stg(sp, ptr(sp)));
918
+ TEST_INSTRUCTION("FF8B20D9", stg(sp, ptr(sp, 128)));
919
+ TEST_INSTRUCTION("FF8F20D9", stg(sp, ptr_pre(sp, 128)));
920
+ TEST_INSTRUCTION("FF8720D9", stg(sp, ptr_post(sp, 128)));
921
+ TEST_INSTRUCTION("4100A0D9", stgm(x1, ptr(x2)));
922
+ TEST_INSTRUCTION("E103A0D9", stgm(x1, ptr(sp)));
923
+ TEST_INSTRUCTION("FF03A0D9", stgm(xzr, ptr(sp)));
924
+ TEST_INSTRUCTION("61080069", stgp(x1, x2, ptr(x3)));
925
+ TEST_INSTRUCTION("61082069", stgp(x1, x2, ptr(x3, -1024)));
926
+ TEST_INSTRUCTION("6108A069", stgp(x1, x2, ptr_pre(x3, -1024)));
927
+ TEST_INSTRUCTION("6108A068", stgp(x1, x2, ptr_post(x3, -1024)));
928
+ TEST_INSTRUCTION("61881F69", stgp(x1, x2, ptr(x3, 1008)));
929
+ TEST_INSTRUCTION("61889F69", stgp(x1, x2, ptr_pre(x3, 1008)));
930
+ TEST_INSTRUCTION("61889F68", stgp(x1, x2, ptr_post(x3, 1008)));
931
+ TEST_INSTRUCTION("E10B0069", stgp(x1, x2, ptr(sp)));
932
+ TEST_INSTRUCTION("E10B2069", stgp(x1, x2, ptr(sp, -1024)));
933
+ TEST_INSTRUCTION("E10BA069", stgp(x1, x2, ptr_pre(sp, -1024)));
934
+ TEST_INSTRUCTION("E10BA068", stgp(x1, x2, ptr_post(sp, -1024)));
935
+ TEST_INSTRUCTION("E18B1F69", stgp(x1, x2, ptr(sp, 1008)));
936
+ TEST_INSTRUCTION("E18B9F69", stgp(x1, x2, ptr_pre(sp, 1008)));
937
+ TEST_INSTRUCTION("E18B9F68", stgp(x1, x2, ptr_post(sp, 1008)));
938
+ TEST_INSTRUCTION("41080029", stp(w1, w2, ptr(x2)));
939
+ TEST_INSTRUCTION("41082029", stp(w1, w2, ptr(x2, -256)));
940
+ TEST_INSTRUCTION("41881F29", stp(w1, w2, ptr(x2, 252)));
941
+ TEST_INSTRUCTION("410800A9", stp(x1, x2, ptr(x2)));
942
+ TEST_INSTRUCTION("410820A9", stp(x1, x2, ptr(x2, -512)));
943
+ TEST_INSTRUCTION("41881FA9", stp(x1, x2, ptr(x2, 504)));
944
+ TEST_INSTRUCTION("FB0F1FF8", str(x27, ptr_pre(sp, -16)));
945
+ TEST_INSTRUCTION("411000B8", str(w1, ptr(x2, 1))); // STUR
946
+ TEST_INSTRUCTION("41D01FB8", str(w1, ptr(x2, -3))); // STUR
947
+ TEST_INSTRUCTION("41701FB8", str(w1, ptr(x2, -9))); // STUR
948
+ TEST_INSTRUCTION("411000F8", str(x1, ptr(x2, 1))); // STUR
949
+ TEST_INSTRUCTION("413000F8", str(x1, ptr(x2, 3))); // STUR
950
+ TEST_INSTRUCTION("41701FF8", str(x1, ptr(x2, -9))); // STUR
951
+ TEST_INSTRUCTION("41040039", strb(w1, ptr(x2, 1)));
952
+ TEST_INSTRUCTION("41D01F38", strb(w1, ptr(x2, -3))); // STURB
953
+ TEST_INSTRUCTION("41701F38", strb(w1, ptr(x2, -9))); // STURB
954
+ TEST_INSTRUCTION("41100078", strh(w1, ptr(x2, 1))); // STURH
955
+ TEST_INSTRUCTION("41D01F78", strh(w1, ptr(x2, -3))); // STURH
956
+ TEST_INSTRUCTION("41701F78", strh(w1, ptr(x2, -9))); // STURH
957
+ TEST_INSTRUCTION("410800B8", sttr(w1, ptr(x2)));
958
+ TEST_INSTRUCTION("411808B8", sttr(w1, ptr(x2, 129)));
959
+ TEST_INSTRUCTION("E10B00B8", sttr(w1, ptr(sp)));
960
+ TEST_INSTRUCTION("E11B08B8", sttr(w1, ptr(sp, 129)));
961
+ TEST_INSTRUCTION("410800F8", sttr(x1, ptr(x2)));
962
+ TEST_INSTRUCTION("411808F8", sttr(x1, ptr(x2, 129)));
963
+ TEST_INSTRUCTION("E10B00F8", sttr(x1, ptr(sp)));
964
+ TEST_INSTRUCTION("E11B08F8", sttr(x1, ptr(sp, 129)));
965
+ TEST_INSTRUCTION("41080038", sttrb(w1, ptr(x2)));
966
+ TEST_INSTRUCTION("41180838", sttrb(w1, ptr(x2, 129)));
967
+ TEST_INSTRUCTION("E10B0038", sttrb(w1, ptr(sp)));
968
+ TEST_INSTRUCTION("E11B0838", sttrb(w1, ptr(sp, 129)));
969
+ TEST_INSTRUCTION("41080078", sttrh(w1, ptr(x2)));
970
+ TEST_INSTRUCTION("41180878", sttrh(w1, ptr(x2, 129)));
971
+ TEST_INSTRUCTION("E10B0078", sttrh(w1, ptr(sp)));
972
+ TEST_INSTRUCTION("E11B0878", sttrh(w1, ptr(sp, 129)));
973
+ TEST_INSTRUCTION("410000B8", stur(w1, ptr(x2)));
974
+ TEST_INSTRUCTION("411008B8", stur(w1, ptr(x2, 129)));
975
+ TEST_INSTRUCTION("E10300B8", stur(w1, ptr(sp)));
976
+ TEST_INSTRUCTION("E11308B8", stur(w1, ptr(sp, 129)));
977
+ TEST_INSTRUCTION("410000F8", stur(x1, ptr(x2)));
978
+ TEST_INSTRUCTION("411008F8", stur(x1, ptr(x2, 129)));
979
+ TEST_INSTRUCTION("E10300F8", stur(x1, ptr(sp)));
980
+ TEST_INSTRUCTION("E11308F8", stur(x1, ptr(sp, 129)));
981
+ TEST_INSTRUCTION("41000038", sturb(w1, ptr(x2)));
982
+ TEST_INSTRUCTION("41100838", sturb(w1, ptr(x2, 129)));
983
+ TEST_INSTRUCTION("E1030038", sturb(w1, ptr(sp)));
984
+ TEST_INSTRUCTION("E1130838", sturb(w1, ptr(sp, 129)));
985
+ TEST_INSTRUCTION("41000078", sturh(w1, ptr(x2)));
986
+ TEST_INSTRUCTION("41100878", sturh(w1, ptr(x2, 129)));
987
+ TEST_INSTRUCTION("E1030078", sturh(w1, ptr(sp)));
988
+ TEST_INSTRUCTION("E1130878", sturh(w1, ptr(sp, 129)));
989
+ TEST_INSTRUCTION("820C2188", stxp(w1, w2, w3, ptr(x4)));
990
+ TEST_INSTRUCTION("E20F2188", stxp(w1, w2, w3, ptr(sp)));
991
+ TEST_INSTRUCTION("820C21C8", stxp(w1, x2, x3, ptr(x4)));
992
+ TEST_INSTRUCTION("E20F21C8", stxp(w1, x2, x3, ptr(sp)));
993
+ TEST_INSTRUCTION("627C0188", stxr(w1, w2, ptr(x3)));
994
+ TEST_INSTRUCTION("E27F0188", stxr(w1, w2, ptr(sp)));
995
+ TEST_INSTRUCTION("627C01C8", stxr(w1, x2, ptr(x3)));
996
+ TEST_INSTRUCTION("E27F01C8", stxr(w1, x2, ptr(sp)));
997
+ TEST_INSTRUCTION("627C0108", stxrb(w1, w2, ptr(x3)));
998
+ TEST_INSTRUCTION("E27F0108", stxrb(w1, w2, ptr(sp)));
999
+ TEST_INSTRUCTION("627C0148", stxrh(w1, w2, ptr(x3)));
1000
+ TEST_INSTRUCTION("E27F0148", stxrh(w1, w2, ptr(sp)));
1001
+ TEST_INSTRUCTION("4108E0D9", stz2g(x1, ptr(x2)));
1002
+ TEST_INSTRUCTION("4108F0D9", stz2g(x1, ptr(x2, -4096)));
1003
+ TEST_INSTRUCTION("410CF0D9", stz2g(x1, ptr_pre(x2, -4096)));
1004
+ TEST_INSTRUCTION("4104F0D9", stz2g(x1, ptr_post(x2, -4096)));
1005
+ TEST_INSTRUCTION("41F8EFD9", stz2g(x1, ptr(x2, 4080)));
1006
+ TEST_INSTRUCTION("41FCEFD9", stz2g(x1, ptr_pre(x2, 4080)));
1007
+ TEST_INSTRUCTION("41F4EFD9", stz2g(x1, ptr_post(x2, 4080)));
1008
+ TEST_INSTRUCTION("E10BE0D9", stz2g(x1, ptr(sp)));
1009
+ TEST_INSTRUCTION("E10BF0D9", stz2g(x1, ptr(sp, -4096)));
1010
+ TEST_INSTRUCTION("E10FF0D9", stz2g(x1, ptr_pre(sp, -4096)));
1011
+ TEST_INSTRUCTION("E107F0D9", stz2g(x1, ptr_post(sp, -4096)));
1012
+ TEST_INSTRUCTION("E1FBEFD9", stz2g(x1, ptr(sp, 4080)));
1013
+ TEST_INSTRUCTION("E1FFEFD9", stz2g(x1, ptr_pre(sp, 4080)));
1014
+ TEST_INSTRUCTION("E1F7EFD9", stz2g(x1, ptr_post(sp, 4080)));
1015
+ TEST_INSTRUCTION("410860D9", stzg(x1, ptr(x2)));
1016
+ TEST_INSTRUCTION("418860D9", stzg(x1, ptr(x2, 128)));
1017
+ TEST_INSTRUCTION("418C60D9", stzg(x1, ptr_pre(x2, 128)));
1018
+ TEST_INSTRUCTION("418460D9", stzg(x1, ptr_post(x2, 128)));
1019
+ TEST_INSTRUCTION("E10B60D9", stzg(x1, ptr(sp)));
1020
+ TEST_INSTRUCTION("E18B60D9", stzg(x1, ptr(sp, 128)));
1021
+ TEST_INSTRUCTION("E18F60D9", stzg(x1, ptr_pre(sp, 128)));
1022
+ TEST_INSTRUCTION("E18760D9", stzg(x1, ptr_post(sp, 128)));
1023
+ TEST_INSTRUCTION("5F0860D9", stzg(sp, ptr(x2)));
1024
+ TEST_INSTRUCTION("5F8860D9", stzg(sp, ptr(x2, 128)));
1025
+ TEST_INSTRUCTION("5F8C60D9", stzg(sp, ptr_pre(x2, 128)));
1026
+ TEST_INSTRUCTION("5F8460D9", stzg(sp, ptr_post(x2, 128)));
1027
+ TEST_INSTRUCTION("FF0B60D9", stzg(sp, ptr(sp)));
1028
+ TEST_INSTRUCTION("FF8B60D9", stzg(sp, ptr(sp, 128)));
1029
+ TEST_INSTRUCTION("FF8F60D9", stzg(sp, ptr_pre(sp, 128)));
1030
+ TEST_INSTRUCTION("FF8760D9", stzg(sp, ptr_post(sp, 128)));
1031
+ TEST_INSTRUCTION("410020D9", stzgm(x1, ptr(x2)));
1032
+ TEST_INSTRUCTION("E10320D9", stzgm(x1, ptr(sp)));
1033
+ TEST_INSTRUCTION("4100034B", sub(w1, w2, w3));
1034
+ TEST_INSTRUCTION("410003CB", sub(x1, x2, x3));
1035
+ TEST_INSTRUCTION("410C034B", sub(w1, w2, w3, lsl(3)));
1036
+ TEST_INSTRUCTION("410C03CB", sub(x1, x2, x3, lsl(3)));
1037
+ TEST_INSTRUCTION("FF030451", sub(wsp, wsp, 256));
1038
+ TEST_INSTRUCTION("FFFF3F51", sub(wsp, wsp, 0xFFF));
1039
+ TEST_INSTRUCTION("FF0304D1", sub(sp, sp, 256));
1040
+ TEST_INSTRUCTION("FFFF3FD1", sub(sp, sp, 0xFFF));
1041
+ TEST_INSTRUCTION("412C82D1", subg(x1, x2, 32, 11));
1042
+ TEST_INSTRUCTION("5F2C82D1", subg(sp, x2, 32, 11));
1043
+ TEST_INSTRUCTION("E12F82D1", subg(x1, sp, 32, 11));
1044
+ TEST_INSTRUCTION("4100C39A", subp(x1, x2, x3));
1045
+ TEST_INSTRUCTION("E103C39A", subp(x1, sp, x3));
1046
+ TEST_INSTRUCTION("4100DF9A", subp(x1, x2, sp));
1047
+ TEST_INSTRUCTION("4100C3BA", subps(x1, x2, x3));
1048
+ TEST_INSTRUCTION("E103C3BA", subps(x1, sp, x3));
1049
+ TEST_INSTRUCTION("4100DFBA", subps(x1, x2, sp));
1050
+ TEST_INSTRUCTION("4100036B", subs(w1, w2, w3));
1051
+ TEST_INSTRUCTION("410003EB", subs(x1, x2, x3));
1052
+ TEST_INSTRUCTION("410C036B", subs(w1, w2, w3, lsl(3)));
1053
+ TEST_INSTRUCTION("410C03EB", subs(x1, x2, x3, lsl(3)));
1054
+ TEST_INSTRUCTION("210000D4", svc(1));
1055
+ TEST_INSTRUCTION("411C0013", sxtb(w1, w2));
1056
+ TEST_INSTRUCTION("411C4093", sxtb(x1, w2));
1057
+ TEST_INSTRUCTION("413C0013", sxth(w1, w2));
1058
+ TEST_INSTRUCTION("413C4093", sxth(x1, w2));
1059
+ TEST_INSTRUCTION("417C4093", sxtw(x1, w2));
1060
+ TEST_INSTRUCTION("932309D5", sys(1, 2, 3, 4, x19));
1061
+ TEST_INSTRUCTION("AF8708D5", tlbi(Predicate::TLBI::kVALE1, x15));
1062
+ TEST_INSTRUCTION("3F000072", tst(w1, 1));
1063
+ TEST_INSTRUCTION("3F0040F2", tst(x1, 1));
1064
+ TEST_INSTRUCTION("3F00026A", tst(w1, w2));
1065
+ TEST_INSTRUCTION("3F0002EA", tst(x1, x2));
1066
+ TEST_INSTRUCTION("3F10026A", tst(w1, w2, lsl(4)));
1067
+ TEST_INSTRUCTION("3F1002EA", tst(x1, x2, lsl(4)));
1068
+ TEST_INSTRUCTION("00000000", udf(0));
1069
+ TEST_INSTRUCTION("01800000", udf(0x8001));
1070
+ TEST_INSTRUCTION("4108C31A", udiv(w1, w2, w3));
1071
+ TEST_INSTRUCTION("4108C39A", udiv(x1, x2, x3));
1072
+ TEST_INSTRUCTION("41241B53", ubfiz(w1, w2, 5, 10));
1073
+ TEST_INSTRUCTION("41247BD3", ubfiz(x1, x2, 5, 10));
1074
+ TEST_INSTRUCTION("41280553", ubfm(w1, w2, 5, 10));
1075
+ TEST_INSTRUCTION("412845D3", ubfm(x1, x2, 5, 10));
1076
+ TEST_INSTRUCTION("41380553", ubfx(w1, w2, 5, 10));
1077
+ TEST_INSTRUCTION("413845D3", ubfx(x1, x2, 5, 10));
1078
+ TEST_INSTRUCTION("4110A39B", umaddl(x1, w2, w3, x4));
1079
+ TEST_INSTRUCTION("41FCA39B", umnegl(x1, w2, w3));
1080
+ TEST_INSTRUCTION("4190A39B", umsubl(x1, w2, w3, x4));
1081
+ TEST_INSTRUCTION("417CC39B", umulh(x1, x2, x3));
1082
+ TEST_INSTRUCTION("417CA39B", umull(x1, w2, w3));
1083
+ TEST_INSTRUCTION("411C0053", uxtb(w1, w2));
1084
+ TEST_INSTRUCTION("413C0053", uxth(w1, w2));
1085
+ TEST_INSTRUCTION("3F4000D5", xaflag());
1086
+ TEST_INSTRUCTION("E147C1DA", xpacd(x1));
1087
+ TEST_INSTRUCTION("E143C1DA", xpaci(x1));
1088
+ TEST_INSTRUCTION("FF2003D5", xpaclri());
1089
+ }
1090
+
1091
+ static void ASMJIT_NOINLINE testA64AssemblerRel(AssemblerTester<a64::Assembler>& tester) noexcept {
1092
+ using namespace a64;
1093
+
1094
+ // Must be a reference, because it's recreated after every `TEST_INSTRUCTION()`.
1095
+ const Label& L0 = tester.L0;
1096
+
1097
+ TEST_INSTRUCTION("01000010", adr(x1, L0));
1098
+ TEST_INSTRUCTION("00000014", b(L0));
1099
+ TEST_INSTRUCTION("00000014", b_al(L0));
1100
+ TEST_INSTRUCTION("00000054", b_eq(L0));
1101
+ TEST_INSTRUCTION("01000054", b_ne(L0));
1102
+ TEST_INSTRUCTION("02000054", b_hs(L0));
1103
+ TEST_INSTRUCTION("03000054", b_lo(L0));
1104
+ TEST_INSTRUCTION("04000054", b_mi(L0));
1105
+ TEST_INSTRUCTION("05000054", b_pl(L0));
1106
+ TEST_INSTRUCTION("06000054", b_vs(L0));
1107
+ TEST_INSTRUCTION("07000054", b_vc(L0));
1108
+ TEST_INSTRUCTION("08000054", b_hi(L0));
1109
+ TEST_INSTRUCTION("09000054", b_ls(L0));
1110
+ TEST_INSTRUCTION("0A000054", b_ge(L0));
1111
+ TEST_INSTRUCTION("0B000054", b_lt(L0));
1112
+ TEST_INSTRUCTION("0C000054", b_gt(L0));
1113
+ TEST_INSTRUCTION("0D000054", b_le(L0));
1114
+ TEST_INSTRUCTION("00000014", b(CondCode::kAL, L0));
1115
+ TEST_INSTRUCTION("00000054", b(CondCode::kEQ, L0));
1116
+ TEST_INSTRUCTION("01000054", b(CondCode::kNE, L0));
1117
+ TEST_INSTRUCTION("02000054", b(CondCode::kHS, L0));
1118
+ TEST_INSTRUCTION("03000054", b(CondCode::kLO, L0));
1119
+ TEST_INSTRUCTION("04000054", b(CondCode::kMI, L0));
1120
+ TEST_INSTRUCTION("05000054", b(CondCode::kPL, L0));
1121
+ TEST_INSTRUCTION("06000054", b(CondCode::kVS, L0));
1122
+ TEST_INSTRUCTION("07000054", b(CondCode::kVC, L0));
1123
+ TEST_INSTRUCTION("08000054", b(CondCode::kHI, L0));
1124
+ TEST_INSTRUCTION("09000054", b(CondCode::kLS, L0));
1125
+ TEST_INSTRUCTION("0A000054", b(CondCode::kGE, L0));
1126
+ TEST_INSTRUCTION("0B000054", b(CondCode::kLT, L0));
1127
+ TEST_INSTRUCTION("0C000054", b(CondCode::kGT, L0));
1128
+ TEST_INSTRUCTION("0D000054", b(CondCode::kLE, L0));
1129
+
1130
+ TEST_INSTRUCTION("00000094", bl(L0));
1131
+ TEST_INSTRUCTION("01000034", cbz(w1, L0));
1132
+ TEST_INSTRUCTION("010000B4", cbz(x1, L0));
1133
+ TEST_INSTRUCTION("01000035", cbnz(w1, L0));
1134
+ TEST_INSTRUCTION("010000B5", cbnz(x1, L0));
1135
+ TEST_INSTRUCTION("01001837", tbnz(w1, 3, L0));
1136
+ TEST_INSTRUCTION("010008B7", tbnz(x1, 33, L0));
1137
+ TEST_INSTRUCTION("01001836", tbz(w1, 3, L0));
1138
+ TEST_INSTRUCTION("010008B6", tbz(x1, 33, L0));
1139
+ }
1140
+
1141
+ static void ASMJIT_NOINLINE testA64AssemblerSIMD(AssemblerTester<a64::Assembler>& tester) noexcept {
1142
+ using namespace a64;
1143
+
1144
+ TEST_INSTRUCTION("41B8200E", abs(v1.b8(), v2.b8()));
1145
+ TEST_INSTRUCTION("41B8600E", abs(v1.h4(), v2.h4()));
1146
+ TEST_INSTRUCTION("41B8A00E", abs(v1.s2(), v2.s2()));
1147
+ TEST_INSTRUCTION("41B8E05E", abs(d1, d2));
1148
+ TEST_INSTRUCTION("41B8204E", abs(v1.b16(), v2.b16()));
1149
+ TEST_INSTRUCTION("41B8604E", abs(v1.h8(), v2.h8()));
1150
+ TEST_INSTRUCTION("41B8A04E", abs(v1.s4(), v2.s4()));
1151
+ TEST_INSTRUCTION("41B8E04E", abs(v1.d2(), v2.d2()));
1152
+ TEST_INSTRUCTION("4184230E", add(v1.b8(), v2.b8(), v3.b8()));
1153
+ TEST_INSTRUCTION("4184630E", add(v1.h4(), v2.h4(), v3.h4()));
1154
+ TEST_INSTRUCTION("4184A30E", add(v1.s2(), v2.s2(), v3.s2()));
1155
+ TEST_INSTRUCTION("4184E35E", add(d1, d2, d3));
1156
+ TEST_INSTRUCTION("4184234E", add(v1.b16(), v2.b16(), v3.b16()));
1157
+ TEST_INSTRUCTION("4184634E", add(v1.h8(), v2.h8(), v3.h8()));
1158
+ TEST_INSTRUCTION("4184A34E", add(v1.s4(), v2.s4(), v3.s4()));
1159
+ TEST_INSTRUCTION("4184E34E", add(v1.d2(), v2.d2(), v3.d2()));
1160
+ TEST_INSTRUCTION("4140230E", addhn(v1.b8(), v2.h8(), v3.h8()));
1161
+ TEST_INSTRUCTION("4140630E", addhn(v1.h4(), v2.s4(), v3.s4()));
1162
+ TEST_INSTRUCTION("4140A30E", addhn(v1.s2(), v2.d2(), v3.d2()));
1163
+ TEST_INSTRUCTION("4140234E", addhn2(v1.b16(), v2.h8(), v3.h8()));
1164
+ TEST_INSTRUCTION("4140634E", addhn2(v1.h8(), v2.s4(), v3.s4()));
1165
+ TEST_INSTRUCTION("4140A34E", addhn2(v1.s4(), v2.d2(), v3.d2()));
1166
+ TEST_INSTRUCTION("41BC230E", addp(v1.b8(), v2.b8(), v3.b8()));
1167
+ TEST_INSTRUCTION("41BC630E", addp(v1.h4(), v2.h4(), v3.h4()));
1168
+ TEST_INSTRUCTION("41BCA30E", addp(v1.s2(), v2.s2(), v3.s2()));
1169
+ TEST_INSTRUCTION("41B8F15E", addp(d1, v2.d2()));
1170
+ TEST_INSTRUCTION("41BC234E", addp(v1.b16(), v2.b16(), v3.b16()));
1171
+ TEST_INSTRUCTION("41BC634E", addp(v1.h8(), v2.h8(), v3.h8()));
1172
+ TEST_INSTRUCTION("41BCA34E", addp(v1.s4(), v2.s4(), v3.s4()));
1173
+ TEST_INSTRUCTION("41BCE34E", addp(v1.d2(), v2.d2(), v3.d2()));
1174
+ TEST_INSTRUCTION("41B8310E", addv(b1, v2.b8()));
1175
+ TEST_INSTRUCTION("41B8314E", addv(b1, v2.b16()));
1176
+ TEST_INSTRUCTION("41B8710E", addv(h1, v2.h4()));
1177
+ TEST_INSTRUCTION("41B8714E", addv(h1, v2.h8()));
1178
+ TEST_INSTRUCTION("41B8B14E", addv(s1, v2.s4()));
1179
+ TEST_INSTRUCTION("4158284E", aesd(v1.b16(), v2.b16()));
1180
+ TEST_INSTRUCTION("4148284E", aese(v1.b16(), v2.b16()));
1181
+ TEST_INSTRUCTION("4178284E", aesimc(v1.b16(), v2.b16()));
1182
+ TEST_INSTRUCTION("4168284E", aesmc(v1.b16(), v2.b16()));
1183
+ TEST_INSTRUCTION("411C230E", and_(v1.b8(), v2.b8(), v3.b8()));
1184
+ TEST_INSTRUCTION("411C234E", and_(v1.b16(), v2.b16(), v3.b16()));
1185
+ TEST_INSTRUCTION("411023CE", bcax(v1.b16(), v2.b16(), v3.b16(), v4.b16()));
1186
+ TEST_INSTRUCTION("4140631E", bfcvt(h1, s2));
1187
+ TEST_INSTRUCTION("4168A10E", bfcvtn(v1.h4(), v2.s4()));
1188
+ TEST_INSTRUCTION("4168A14E", bfcvtn2(v1.h8(), v2.s4()));
1189
+ TEST_INSTRUCTION("41FC432E", bfdot(v1.s2(), v2.h4(), v3.h4()));
1190
+ TEST_INSTRUCTION("41FC436E", bfdot(v1.s4(), v2.h8(), v3.h8()));
1191
+ TEST_INSTRUCTION("41F0430F", bfdot(v1.s2(), v2.h4(), v3.h2(0)));
1192
+ TEST_INSTRUCTION("41F8634F", bfdot(v1.s4(), v2.h8(), v3.h2(3)));
1193
+ TEST_INSTRUCTION("41FCC32E", bfmlalb(v1.s4(), v2.h8(), v3.h8()));
1194
+ TEST_INSTRUCTION("41F0C30F", bfmlalb(v1.s4(), v2.h8(), v3.h(0)));
1195
+ TEST_INSTRUCTION("41F8F30F", bfmlalb(v1.s4(), v2.h8(), v3.h(7)));
1196
+ TEST_INSTRUCTION("41FCC36E", bfmlalt(v1.s4(), v2.h8(), v3.h8()));
1197
+ TEST_INSTRUCTION("41F0C34F", bfmlalt(v1.s4(), v2.h8(), v3.h(0)));
1198
+ TEST_INSTRUCTION("41F8F34F", bfmlalt(v1.s4(), v2.h8(), v3.h(7)));
1199
+ TEST_INSTRUCTION("41EC436E", bfmmla(v1.s4(), v2.h8(), v3.h8()));
1200
+ TEST_INSTRUCTION("411C630E", bic(v1.b8(), v2.b8(), v3.b8()));
1201
+ TEST_INSTRUCTION("411C634E", bic(v1.b16(), v2.b16(), v3.b16()));
1202
+ TEST_INSTRUCTION("E197072F", bic(v1.h4(), 255));
1203
+ TEST_INSTRUCTION("E1B7072F", bic(v1.h4(), 255, lsl(8)));
1204
+ TEST_INSTRUCTION("E197076F", bic(v1.h8(), 255));
1205
+ TEST_INSTRUCTION("E1B7076F", bic(v1.h8(), 255, lsl(8)));
1206
+ TEST_INSTRUCTION("E117072F", bic(v1.s2(), 255));
1207
+ TEST_INSTRUCTION("E137072F", bic(v1.s2(), 255, lsl(8)));
1208
+ TEST_INSTRUCTION("E117076F", bic(v1.s4(), 255));
1209
+ TEST_INSTRUCTION("E177076F", bic(v1.s4(), 255, lsl(24)));
1210
+ TEST_INSTRUCTION("411CE32E", bif(v1.b8(), v2.b8(), v3.b8()));
1211
+ TEST_INSTRUCTION("411CE36E", bif(v1.b16(), v2.b16(), v3.b16()));
1212
+ TEST_INSTRUCTION("411CA32E", bit(v1.b8(), v2.b8(), v3.b8()));
1213
+ TEST_INSTRUCTION("411CA36E", bit(v1.b16(), v2.b16(), v3.b16()));
1214
+ TEST_INSTRUCTION("411C632E", bsl(v1.b8(), v2.b8(), v3.b8()));
1215
+ TEST_INSTRUCTION("411C636E", bsl(v1.b16(), v2.b16(), v3.b16()));
1216
+ TEST_INSTRUCTION("4148200E", cls(v1.b8(), v2.b8()));
1217
+ TEST_INSTRUCTION("4148600E", cls(v1.h4(), v2.h4()));
1218
+ TEST_INSTRUCTION("4148A00E", cls(v1.s2(), v2.s2()));
1219
+ TEST_INSTRUCTION("4148204E", cls(v1.b16(), v2.b16()));
1220
+ TEST_INSTRUCTION("4148604E", cls(v1.h8(), v2.h8()));
1221
+ TEST_INSTRUCTION("4148A04E", cls(v1.s4(), v2.s4()));
1222
+ TEST_INSTRUCTION("4148202E", clz(v1.b8(), v2.b8()));
1223
+ TEST_INSTRUCTION("4148602E", clz(v1.h4(), v2.h4()));
1224
+ TEST_INSTRUCTION("4148A02E", clz(v1.s2(), v2.s2()));
1225
+ TEST_INSTRUCTION("4148206E", clz(v1.b16(), v2.b16()));
1226
+ TEST_INSTRUCTION("4148606E", clz(v1.h8(), v2.h8()));
1227
+ TEST_INSTRUCTION("4148A06E", clz(v1.s4(), v2.s4()));
1228
+ TEST_INSTRUCTION("418C232E", cmeq(v1.b8(), v2.b8(), v3.b8()));
1229
+ TEST_INSTRUCTION("418C632E", cmeq(v1.h4(), v2.h4(), v3.h4()));
1230
+ TEST_INSTRUCTION("418CA32E", cmeq(v1.s2(), v2.s2(), v3.s2()));
1231
+ TEST_INSTRUCTION("418CE37E", cmeq(d1, d2, d3));
1232
+ TEST_INSTRUCTION("418C236E", cmeq(v1.b16(), v2.b16(), v3.b16()));
1233
+ TEST_INSTRUCTION("418C636E", cmeq(v1.h8(), v2.h8(), v3.h8()));
1234
+ TEST_INSTRUCTION("418CA36E", cmeq(v1.s4(), v2.s4(), v3.s4()));
1235
+ TEST_INSTRUCTION("418CE36E", cmeq(v1.d2(), v2.d2(), v3.d2()));
1236
+ TEST_INSTRUCTION("4198200E", cmeq(v1.b8(), v2.b8(), 0));
1237
+ TEST_INSTRUCTION("4198600E", cmeq(v1.h4(), v2.h4(), 0));
1238
+ TEST_INSTRUCTION("4198A00E", cmeq(v1.s2(), v2.s2(), 0));
1239
+ TEST_INSTRUCTION("4198E05E", cmeq(d1, d2, 0));
1240
+ TEST_INSTRUCTION("4198204E", cmeq(v1.b16(), v2.b16(), 0));
1241
+ TEST_INSTRUCTION("4198604E", cmeq(v1.h8(), v2.h8(), 0));
1242
+ TEST_INSTRUCTION("4198A04E", cmeq(v1.s4(), v2.s4(), 0));
1243
+ TEST_INSTRUCTION("4198E04E", cmeq(v1.d2(), v2.d2(), 0));
1244
+ TEST_INSTRUCTION("413C230E", cmge(v1.b8(), v2.b8(), v3.b8()));
1245
+ TEST_INSTRUCTION("413C630E", cmge(v1.h4(), v2.h4(), v3.h4()));
1246
+ TEST_INSTRUCTION("413CA30E", cmge(v1.s2(), v2.s2(), v3.s2()));
1247
+ TEST_INSTRUCTION("413CE35E", cmge(d1, d2, d3));
1248
+ TEST_INSTRUCTION("413C234E", cmge(v1.b16(), v2.b16(), v3.b16()));
1249
+ TEST_INSTRUCTION("413C634E", cmge(v1.h8(), v2.h8(), v3.h8()));
1250
+ TEST_INSTRUCTION("413CA34E", cmge(v1.s4(), v2.s4(), v3.s4()));
1251
+ TEST_INSTRUCTION("413CE34E", cmge(v1.d2(), v2.d2(), v3.d2()));
1252
+ TEST_INSTRUCTION("4188202E", cmge(v1.b8(), v2.b8(), 0));
1253
+ TEST_INSTRUCTION("4188602E", cmge(v1.h4(), v2.h4(), 0));
1254
+ TEST_INSTRUCTION("4188A02E", cmge(v1.s2(), v2.s2(), 0));
1255
+ TEST_INSTRUCTION("4188E07E", cmge(d1, d2, 0));
1256
+ TEST_INSTRUCTION("4188206E", cmge(v1.b16(), v2.b16(), 0));
1257
+ TEST_INSTRUCTION("4188606E", cmge(v1.h8(), v2.h8(), 0));
1258
+ TEST_INSTRUCTION("4188A06E", cmge(v1.s4(), v2.s4(), 0));
1259
+ TEST_INSTRUCTION("4188E06E", cmge(v1.d2(), v2.d2(), 0));
1260
+ TEST_INSTRUCTION("4134230E", cmgt(v1.b8(), v2.b8(), v3.b8()));
1261
+ TEST_INSTRUCTION("4134630E", cmgt(v1.h4(), v2.h4(), v3.h4()));
1262
+ TEST_INSTRUCTION("4134A30E", cmgt(v1.s2(), v2.s2(), v3.s2()));
1263
+ TEST_INSTRUCTION("4134E35E", cmgt(d1, d2, d3));
1264
+ TEST_INSTRUCTION("4134234E", cmgt(v1.b16(), v2.b16(), v3.b16()));
1265
+ TEST_INSTRUCTION("4134634E", cmgt(v1.h8(), v2.h8(), v3.h8()));
1266
+ TEST_INSTRUCTION("4134A34E", cmgt(v1.s4(), v2.s4(), v3.s4()));
1267
+ TEST_INSTRUCTION("4134E34E", cmgt(v1.d2(), v2.d2(), v3.d2()));
1268
+ TEST_INSTRUCTION("4188200E", cmgt(v1.b8(), v2.b8(), 0));
1269
+ TEST_INSTRUCTION("4188600E", cmgt(v1.h4(), v2.h4(), 0));
1270
+ TEST_INSTRUCTION("4188A00E", cmgt(v1.s2(), v2.s2(), 0));
1271
+ TEST_INSTRUCTION("4188E05E", cmgt(d1, d2, 0));
1272
+ TEST_INSTRUCTION("4188204E", cmgt(v1.b16(), v2.b16(), 0));
1273
+ TEST_INSTRUCTION("4188604E", cmgt(v1.h8(), v2.h8(), 0));
1274
+ TEST_INSTRUCTION("4188A04E", cmgt(v1.s4(), v2.s4(), 0));
1275
+ TEST_INSTRUCTION("4188E04E", cmgt(v1.d2(), v2.d2(), 0));
1276
+ TEST_INSTRUCTION("4134232E", cmhi(v1.b8(), v2.b8(), v3.b8()));
1277
+ TEST_INSTRUCTION("4134632E", cmhi(v1.h4(), v2.h4(), v3.h4()));
1278
+ TEST_INSTRUCTION("4134A32E", cmhi(v1.s2(), v2.s2(), v3.s2()));
1279
+ TEST_INSTRUCTION("4134E37E", cmhi(d1, d2, d3));
1280
+ TEST_INSTRUCTION("4134236E", cmhi(v1.b16(), v2.b16(), v3.b16()));
1281
+ TEST_INSTRUCTION("4134636E", cmhi(v1.h8(), v2.h8(), v3.h8()));
1282
+ TEST_INSTRUCTION("4134A36E", cmhi(v1.s4(), v2.s4(), v3.s4()));
1283
+ TEST_INSTRUCTION("4134E36E", cmhi(v1.d2(), v2.d2(), v3.d2()));
1284
+ TEST_INSTRUCTION("413C232E", cmhs(v1.b8(), v2.b8(), v3.b8()));
1285
+ TEST_INSTRUCTION("413C632E", cmhs(v1.h4(), v2.h4(), v3.h4()));
1286
+ TEST_INSTRUCTION("413CA32E", cmhs(v1.s2(), v2.s2(), v3.s2()));
1287
+ TEST_INSTRUCTION("413CE37E", cmhs(d1, d2, d3));
1288
+ TEST_INSTRUCTION("413C236E", cmhs(v1.b16(), v2.b16(), v3.b16()));
1289
+ TEST_INSTRUCTION("413C636E", cmhs(v1.h8(), v2.h8(), v3.h8()));
1290
+ TEST_INSTRUCTION("413CA36E", cmhs(v1.s4(), v2.s4(), v3.s4()));
1291
+ TEST_INSTRUCTION("413CE36E", cmhs(v1.d2(), v2.d2(), v3.d2()));
1292
+ TEST_INSTRUCTION("4198202E", cmle(v1.b8(), v2.b8(), 0));
1293
+ TEST_INSTRUCTION("4198602E", cmle(v1.h4(), v2.h4(), 0));
1294
+ TEST_INSTRUCTION("4198A02E", cmle(v1.s2(), v2.s2(), 0));
1295
+ TEST_INSTRUCTION("4198E07E", cmle(d1, d2, 0));
1296
+ TEST_INSTRUCTION("4198206E", cmle(v1.b16(), v2.b16(), 0));
1297
+ TEST_INSTRUCTION("4198606E", cmle(v1.h8(), v2.h8(), 0));
1298
+ TEST_INSTRUCTION("4198A06E", cmle(v1.s4(), v2.s4(), 0));
1299
+ TEST_INSTRUCTION("4198E06E", cmle(v1.d2(), v2.d2(), 0));
1300
+ TEST_INSTRUCTION("41A8200E", cmlt(v1.b8(), v2.b8(), 0));
1301
+ TEST_INSTRUCTION("41A8600E", cmlt(v1.h4(), v2.h4(), 0));
1302
+ TEST_INSTRUCTION("41A8A00E", cmlt(v1.s2(), v2.s2(), 0));
1303
+ TEST_INSTRUCTION("41A8E05E", cmlt(d1, d2, 0));
1304
+ TEST_INSTRUCTION("41A8204E", cmlt(v1.b16(), v2.b16(), 0));
1305
+ TEST_INSTRUCTION("41A8604E", cmlt(v1.h8(), v2.h8(), 0));
1306
+ TEST_INSTRUCTION("41A8A04E", cmlt(v1.s4(), v2.s4(), 0));
1307
+ TEST_INSTRUCTION("41A8E04E", cmlt(v1.d2(), v2.d2(), 0));
1308
+ TEST_INSTRUCTION("418C230E", cmtst(v1.b8(), v2.b8(), v3.b8()));
1309
+ TEST_INSTRUCTION("418C630E", cmtst(v1.h4(), v2.h4(), v3.h4()));
1310
+ TEST_INSTRUCTION("418CA30E", cmtst(v1.s2(), v2.s2(), v3.s2()));
1311
+ TEST_INSTRUCTION("418CE35E", cmtst(d1, d2, d3));
1312
+ TEST_INSTRUCTION("418C234E", cmtst(v1.b16(), v2.b16(), v3.b16()));
1313
+ TEST_INSTRUCTION("418C634E", cmtst(v1.h8(), v2.h8(), v3.h8()));
1314
+ TEST_INSTRUCTION("418CA34E", cmtst(v1.s4(), v2.s4(), v3.s4()));
1315
+ TEST_INSTRUCTION("418CE34E", cmtst(v1.d2(), v2.d2(), v3.d2()));
1316
+ TEST_INSTRUCTION("4158200E", cnt(v1.b8(), v2.b8()));
1317
+ TEST_INSTRUCTION("4158204E", cnt(v1.b16(), v2.b16()));
1318
+ TEST_INSTRUCTION("410C010E", dup(v1.b8(), w2));
1319
+ TEST_INSTRUCTION("410C020E", dup(v1.h4(), w2));
1320
+ TEST_INSTRUCTION("410C040E", dup(v1.s2(), w2));
1321
+ TEST_INSTRUCTION("410C014E", dup(v1.b16(), w2));
1322
+ TEST_INSTRUCTION("410C024E", dup(v1.h8(), w2));
1323
+ TEST_INSTRUCTION("410C044E", dup(v1.s4(), w2));
1324
+ TEST_INSTRUCTION("410C084E", dup(v1.d2(), x2));
1325
+ TEST_INSTRUCTION("4F04035E", dup(b15, v2.b(1)));
1326
+ TEST_INSTRUCTION("4F04065E", dup(h15, v2.h(1)));
1327
+ TEST_INSTRUCTION("4F040C5E", dup(s15, v2.s(1)));
1328
+ TEST_INSTRUCTION("4F04185E", dup(d15, v2.d(1)));
1329
+ TEST_INSTRUCTION("4F04030E", dup(v15.b8(), v2.b(1)));
1330
+ TEST_INSTRUCTION("4F04060E", dup(v15.h4(), v2.h(1)));
1331
+ TEST_INSTRUCTION("4F040C0E", dup(v15.s2(), v2.s(1)));
1332
+ TEST_INSTRUCTION("4F04034E", dup(v15.b16(), v2.b(1)));
1333
+ TEST_INSTRUCTION("4F04064E", dup(v15.h8(), v2.h(1)));
1334
+ TEST_INSTRUCTION("4F040C4E", dup(v15.s4(), v2.s(1)));
1335
+ TEST_INSTRUCTION("4F04184E", dup(v15.d2(), v2.d(1)));
1336
+ TEST_INSTRUCTION("411C232E", eor(v1.b8(), v2.b8(), v3.b8()));
1337
+ TEST_INSTRUCTION("411C236E", eor(v1.b16(), v2.b16(), v3.b16()));
1338
+ TEST_INSTRUCTION("411003CE", eor3(v1.b16(), v2.b16(), v3.b16(), v4.b16()));
1339
+ TEST_INSTRUCTION("4128032E", ext(v1.b8(), v2.b8(), v3.b8(), 5));
1340
+ TEST_INSTRUCTION("4128036E", ext(v1.b16(), v2.b16(), v3.b16(), 5));
1341
+ TEST_INSTRUCTION("4114C37E", fabd(h1, h2, h3));
1342
+ TEST_INSTRUCTION("41D4A37E", fabd(s1, s2, s3));
1343
+ TEST_INSTRUCTION("41D4E37E", fabd(d1, d2, d3));
1344
+ TEST_INSTRUCTION("4114C32E", fabd(v1.h4(), v2.h4(), v3.h4()));
1345
+ TEST_INSTRUCTION("41D4A32E", fabd(v1.s2(), v2.s2(), v3.s2()));
1346
+ TEST_INSTRUCTION("4114C36E", fabd(v1.h8(), v2.h8(), v3.h8()));
1347
+ TEST_INSTRUCTION("41D4A36E", fabd(v1.s4(), v2.s4(), v3.s4()));
1348
+ TEST_INSTRUCTION("41D4E36E", fabd(v1.d2(), v2.d2(), v3.d2()));
1349
+ TEST_INSTRUCTION("41C0E01E", fabs(h1, h2));
1350
+ TEST_INSTRUCTION("41C0201E", fabs(s1, s2));
1351
+ TEST_INSTRUCTION("41C0601E", fabs(d1, d2));
1352
+ TEST_INSTRUCTION("41F8F80E", fabs(v1.h4(), v2.h4()));
1353
+ TEST_INSTRUCTION("41F8A00E", fabs(v1.s2(), v2.s2()));
1354
+ TEST_INSTRUCTION("41F8F84E", fabs(v1.h8(), v2.h8()));
1355
+ TEST_INSTRUCTION("41F8A04E", fabs(v1.s4(), v2.s4()));
1356
+ TEST_INSTRUCTION("41F8E04E", fabs(v1.d2(), v2.d2()));
1357
+ TEST_INSTRUCTION("412C437E", facge(h1, h2, h3));
1358
+ TEST_INSTRUCTION("41EC237E", facge(s1, s2, s3));
1359
+ TEST_INSTRUCTION("41EC637E", facge(d1, d2, d3));
1360
+ TEST_INSTRUCTION("412C432E", facge(v1.h4(), v2.h4(), v3.h4()));
1361
+ TEST_INSTRUCTION("41EC232E", facge(v1.s2(), v2.s2(), v3.s2()));
1362
+ TEST_INSTRUCTION("412C436E", facge(v1.h8(), v2.h8(), v3.h8()));
1363
+ TEST_INSTRUCTION("41EC236E", facge(v1.s4(), v2.s4(), v3.s4()));
1364
+ TEST_INSTRUCTION("41EC636E", facge(v1.d2(), v2.d2(), v3.d2()));
1365
+ TEST_INSTRUCTION("412CC37E", facgt(h1, h2, h3));
1366
+ TEST_INSTRUCTION("41ECA37E", facgt(s1, s2, s3));
1367
+ TEST_INSTRUCTION("41ECE37E", facgt(d1, d2, d3));
1368
+ TEST_INSTRUCTION("412CC32E", facgt(v1.h4(), v2.h4(), v3.h4()));
1369
+ TEST_INSTRUCTION("41ECA32E", facgt(v1.s2(), v2.s2(), v3.s2()));
1370
+ TEST_INSTRUCTION("412CC36E", facgt(v1.h8(), v2.h8(), v3.h8()));
1371
+ TEST_INSTRUCTION("41ECA36E", facgt(v1.s4(), v2.s4(), v3.s4()));
1372
+ TEST_INSTRUCTION("41ECE36E", facgt(v1.d2(), v2.d2(), v3.d2()));
1373
+ TEST_INSTRUCTION("4128E31E", fadd(h1, h2, h3));
1374
+ TEST_INSTRUCTION("4128231E", fadd(s1, s2, s3));
1375
+ TEST_INSTRUCTION("4128631E", fadd(d1, d2, d3));
1376
+ TEST_INSTRUCTION("4114430E", fadd(v1.h4(), v2.h4(), v3.h4()));
1377
+ TEST_INSTRUCTION("41D4230E", fadd(v1.s2(), v2.s2(), v3.s2()));
1378
+ TEST_INSTRUCTION("4114434E", fadd(v1.h8(), v2.h8(), v3.h8()));
1379
+ TEST_INSTRUCTION("41D4234E", fadd(v1.s4(), v2.s4(), v3.s4()));
1380
+ TEST_INSTRUCTION("41D4634E", fadd(v1.d2(), v2.d2(), v3.d2()));
1381
+ TEST_INSTRUCTION("41D8305E", faddp(h1, v2.h2()));
1382
+ TEST_INSTRUCTION("41D8307E", faddp(s1, v2.s2()));
1383
+ TEST_INSTRUCTION("41D8707E", faddp(d1, v2.d2()));
1384
+ TEST_INSTRUCTION("4114432E", faddp(v1.h4(), v2.h4(), v3.h4()));
1385
+ TEST_INSTRUCTION("41D4232E", faddp(v1.s2(), v2.s2(), v3.s2()));
1386
+ TEST_INSTRUCTION("4114436E", faddp(v1.h8(), v2.h8(), v3.h8()));
1387
+ TEST_INSTRUCTION("41D4236E", faddp(v1.s4(), v2.s4(), v3.s4()));
1388
+ TEST_INSTRUCTION("41D4636E", faddp(v1.d2(), v2.d2(), v3.d2()));
1389
+ TEST_INSTRUCTION("41E4432E", fcadd(v1.h4(), v2.h4(), v3.h4(), 90));
1390
+ TEST_INSTRUCTION("41E4832E", fcadd(v1.s2(), v2.s2(), v3.s2(), 90));
1391
+ TEST_INSTRUCTION("41E4436E", fcadd(v1.h8(), v2.h8(), v3.h8(), 90));
1392
+ TEST_INSTRUCTION("41E4836E", fcadd(v1.s4(), v2.s4(), v3.s4(), 90));
1393
+ TEST_INSTRUCTION("41E4C36E", fcadd(v1.d2(), v2.d2(), v3.d2(), 90));
1394
+ TEST_INSTRUCTION("41F4432E", fcadd(v1.h4(), v2.h4(), v3.h4(), 270));
1395
+ TEST_INSTRUCTION("41F4832E", fcadd(v1.s2(), v2.s2(), v3.s2(), 270));
1396
+ TEST_INSTRUCTION("41F4436E", fcadd(v1.h8(), v2.h8(), v3.h8(), 270));
1397
+ TEST_INSTRUCTION("41F4836E", fcadd(v1.s4(), v2.s4(), v3.s4(), 270));
1398
+ TEST_INSTRUCTION("41F4C36E", fcadd(v1.d2(), v2.d2(), v3.d2(), 270));
1399
+ TEST_INSTRUCTION("2404E21E", fccmp(h1, h2, 4, CondCode::kEQ));
1400
+ TEST_INSTRUCTION("2404221E", fccmp(s1, s2, 4, CondCode::kEQ));
1401
+ TEST_INSTRUCTION("2404621E", fccmp(d1, d2, 4, CondCode::kEQ));
1402
+ TEST_INSTRUCTION("3404E21E", fccmpe(h1, h2, 4, CondCode::kEQ));
1403
+ TEST_INSTRUCTION("3404221E", fccmpe(s1, s2, 4, CondCode::kEQ));
1404
+ TEST_INSTRUCTION("3404621E", fccmpe(d1, d2, 4, CondCode::kEQ));
1405
+ TEST_INSTRUCTION("4124435E", fcmeq(h1, h2, h3));
1406
+ TEST_INSTRUCTION("41E4235E", fcmeq(s1, s2, s3));
1407
+ TEST_INSTRUCTION("41E4635E", fcmeq(d1, d2, d3));
1408
+ TEST_INSTRUCTION("4124430E", fcmeq(v1.h4(), v2.h4(), v3.h4()));
1409
+ TEST_INSTRUCTION("41E4230E", fcmeq(v1.s2(), v2.s2(), v3.s2()));
1410
+ TEST_INSTRUCTION("4124434E", fcmeq(v1.h8(), v2.h8(), v3.h8()));
1411
+ TEST_INSTRUCTION("41E4234E", fcmeq(v1.s4(), v2.s4(), v3.s4()));
1412
+ TEST_INSTRUCTION("41E4634E", fcmeq(v1.d2(), v2.d2(), v3.d2()));
1413
+ TEST_INSTRUCTION("41D8F85E", fcmeq(h1, h2, 0));
1414
+ TEST_INSTRUCTION("41D8A05E", fcmeq(s1, s2, 0));
1415
+ TEST_INSTRUCTION("41D8E05E", fcmeq(d1, d2, 0));
1416
+ TEST_INSTRUCTION("41D8F80E", fcmeq(v1.h4(), v2.h4(), 0));
1417
+ TEST_INSTRUCTION("41D8A00E", fcmeq(v1.s2(), v2.s2(), 0));
1418
+ TEST_INSTRUCTION("41D8F84E", fcmeq(v1.h8(), v2.h8(), 0));
1419
+ TEST_INSTRUCTION("41D8A04E", fcmeq(v1.s4(), v2.s4(), 0));
1420
+ TEST_INSTRUCTION("41D8E04E", fcmeq(v1.d2(), v2.d2(), 0));
1421
+ TEST_INSTRUCTION("4124437E", fcmge(h1, h2, h3));
1422
+ TEST_INSTRUCTION("41E4237E", fcmge(s1, s2, s3));
1423
+ TEST_INSTRUCTION("41E4637E", fcmge(d1, d2, d3));
1424
+ TEST_INSTRUCTION("4124432E", fcmge(v1.h4(), v2.h4(), v3.h4()));
1425
+ TEST_INSTRUCTION("41E4232E", fcmge(v1.s2(), v2.s2(), v3.s2()));
1426
+ TEST_INSTRUCTION("4124436E", fcmge(v1.h8(), v2.h8(), v3.h8()));
1427
+ TEST_INSTRUCTION("41E4236E", fcmge(v1.s4(), v2.s4(), v3.s4()));
1428
+ TEST_INSTRUCTION("41E4636E", fcmge(v1.d2(), v2.d2(), v3.d2()));
1429
+ TEST_INSTRUCTION("41C8F87E", fcmge(h1, h2, 0));
1430
+ TEST_INSTRUCTION("41C8A07E", fcmge(s1, s2, 0));
1431
+ TEST_INSTRUCTION("41C8E07E", fcmge(d1, d2, 0));
1432
+ TEST_INSTRUCTION("41C8F82E", fcmge(v1.h4(), v2.h4(), 0));
1433
+ TEST_INSTRUCTION("41C8A02E", fcmge(v1.s2(), v2.s2(), 0));
1434
+ TEST_INSTRUCTION("41C8F86E", fcmge(v1.h8(), v2.h8(), 0));
1435
+ TEST_INSTRUCTION("41C8A06E", fcmge(v1.s4(), v2.s4(), 0));
1436
+ TEST_INSTRUCTION("41C8E06E", fcmge(v1.d2(), v2.d2(), 0));
1437
+ TEST_INSTRUCTION("4124C37E", fcmgt(h1, h2, h3));
1438
+ TEST_INSTRUCTION("41E4A37E", fcmgt(s1, s2, s3));
1439
+ TEST_INSTRUCTION("41E4E37E", fcmgt(d1, d2, d3));
1440
+ TEST_INSTRUCTION("4124C32E", fcmgt(v1.h4(), v2.h4(), v3.h4()));
1441
+ TEST_INSTRUCTION("41E4A32E", fcmgt(v1.s2(), v2.s2(), v3.s2()));
1442
+ TEST_INSTRUCTION("4124C36E", fcmgt(v1.h8(), v2.h8(), v3.h8()));
1443
+ TEST_INSTRUCTION("41E4A36E", fcmgt(v1.s4(), v2.s4(), v3.s4()));
1444
+ TEST_INSTRUCTION("41E4E36E", fcmgt(v1.d2(), v2.d2(), v3.d2()));
1445
+ TEST_INSTRUCTION("41C8F85E", fcmgt(h1, h2, 0));
1446
+ TEST_INSTRUCTION("41C8A05E", fcmgt(s1, s2, 0));
1447
+ TEST_INSTRUCTION("41C8E05E", fcmgt(d1, d2, 0));
1448
+ TEST_INSTRUCTION("41C8F80E", fcmgt(v1.h4(), v2.h4(), 0));
1449
+ TEST_INSTRUCTION("41C8A00E", fcmgt(v1.s2(), v2.s2(), 0));
1450
+ TEST_INSTRUCTION("41C8F84E", fcmgt(v1.h8(), v2.h8(), 0));
1451
+ TEST_INSTRUCTION("41C8A04E", fcmgt(v1.s4(), v2.s4(), 0));
1452
+ TEST_INSTRUCTION("41C8E04E", fcmgt(v1.d2(), v2.d2(), 0));
1453
+ TEST_INSTRUCTION("41CC432E", fcmla(v1.h4(), v2.h4(), v3.h4(), 90));
1454
+ TEST_INSTRUCTION("41CC832E", fcmla(v1.s2(), v2.s2(), v3.s2(), 90));
1455
+ TEST_INSTRUCTION("41CC436E", fcmla(v1.h8(), v2.h8(), v3.h8(), 90));
1456
+ TEST_INSTRUCTION("41CC836E", fcmla(v1.s4(), v2.s4(), v3.s4(), 90));
1457
+ TEST_INSTRUCTION("41CCC36E", fcmla(v1.d2(), v2.d2(), v3.d2(), 90));
1458
+ TEST_INSTRUCTION("41DC432E", fcmla(v1.h4(), v2.h4(), v3.h4(), 270));
1459
+ TEST_INSTRUCTION("41DC832E", fcmla(v1.s2(), v2.s2(), v3.s2(), 270));
1460
+ TEST_INSTRUCTION("41DC436E", fcmla(v1.h8(), v2.h8(), v3.h8(), 270));
1461
+ TEST_INSTRUCTION("41DC836E", fcmla(v1.s4(), v2.s4(), v3.s4(), 270));
1462
+ TEST_INSTRUCTION("41DCC36E", fcmla(v1.d2(), v2.d2(), v3.d2(), 270));
1463
+ TEST_INSTRUCTION("4130432F", fcmla(v1.h4(), v2.h4(), v3.h(0), 90));
1464
+ TEST_INSTRUCTION("4130632F", fcmla(v1.h4(), v2.h4(), v3.h(1), 90));
1465
+ TEST_INSTRUCTION("4130436F", fcmla(v1.h8(), v2.h8(), v3.h(0), 90));
1466
+ TEST_INSTRUCTION("4138636F", fcmla(v1.h8(), v2.h8(), v3.h(3), 90));
1467
+ TEST_INSTRUCTION("4130836F", fcmla(v1.s4(), v2.s4(), v3.s(0), 90));
1468
+ TEST_INSTRUCTION("4138836F", fcmla(v1.s4(), v2.s4(), v3.s(1), 90));
1469
+ TEST_INSTRUCTION("4170432F", fcmla(v1.h4(), v2.h4(), v3.h(0), 270));
1470
+ TEST_INSTRUCTION("4170632F", fcmla(v1.h4(), v2.h4(), v3.h(1), 270));
1471
+ TEST_INSTRUCTION("4170436F", fcmla(v1.h8(), v2.h8(), v3.h(0), 270));
1472
+ TEST_INSTRUCTION("4178636F", fcmla(v1.h8(), v2.h8(), v3.h(3), 270));
1473
+ TEST_INSTRUCTION("4170836F", fcmla(v1.s4(), v2.s4(), v3.s(0), 270));
1474
+ TEST_INSTRUCTION("4178836F", fcmla(v1.s4(), v2.s4(), v3.s(1), 270));
1475
+ TEST_INSTRUCTION("41D8F87E", fcmle(h1, h2, 0));
1476
+ TEST_INSTRUCTION("41D8A07E", fcmle(s1, s2, 0));
1477
+ TEST_INSTRUCTION("41D8E07E", fcmle(d1, d2, 0));
1478
+ TEST_INSTRUCTION("41D8F82E", fcmle(v1.h4(), v2.h4(), 0));
1479
+ TEST_INSTRUCTION("41D8A02E", fcmle(v1.s2(), v2.s2(), 0));
1480
+ TEST_INSTRUCTION("41D8F86E", fcmle(v1.h8(), v2.h8(), 0));
1481
+ TEST_INSTRUCTION("41D8A06E", fcmle(v1.s4(), v2.s4(), 0));
1482
+ TEST_INSTRUCTION("41D8E06E", fcmle(v1.d2(), v2.d2(), 0));
1483
+ TEST_INSTRUCTION("41E8F85E", fcmlt(h1, h2, 0));
1484
+ TEST_INSTRUCTION("41E8A05E", fcmlt(s1, s2, 0));
1485
+ TEST_INSTRUCTION("41E8E05E", fcmlt(d1, d2, 0));
1486
+ TEST_INSTRUCTION("41E8F80E", fcmlt(v1.h4(), v2.h4(), 0));
1487
+ TEST_INSTRUCTION("41E8A00E", fcmlt(v1.s2(), v2.s2(), 0));
1488
+ TEST_INSTRUCTION("41E8F84E", fcmlt(v1.h8(), v2.h8(), 0));
1489
+ TEST_INSTRUCTION("41E8A04E", fcmlt(v1.s4(), v2.s4(), 0));
1490
+ TEST_INSTRUCTION("41E8E04E", fcmlt(v1.d2(), v2.d2(), 0));
1491
+ TEST_INSTRUCTION("2020E21E", fcmp(h1, h2));
1492
+ TEST_INSTRUCTION("2020221E", fcmp(s1, s2));
1493
+ TEST_INSTRUCTION("2020621E", fcmp(d1, d2));
1494
+ TEST_INSTRUCTION("2820E01E", fcmp(h1, 0));
1495
+ TEST_INSTRUCTION("2820201E", fcmp(s1, 0));
1496
+ TEST_INSTRUCTION("2820601E", fcmp(d1, 0));
1497
+ TEST_INSTRUCTION("3020E21E", fcmpe(h1, h2));
1498
+ TEST_INSTRUCTION("3020221E", fcmpe(s1, s2));
1499
+ TEST_INSTRUCTION("3020621E", fcmpe(d1, d2));
1500
+ TEST_INSTRUCTION("3820E01E", fcmpe(h1, 0));
1501
+ TEST_INSTRUCTION("3820201E", fcmpe(s1, 0));
1502
+ TEST_INSTRUCTION("3820601E", fcmpe(d1, 0));
1503
+ TEST_INSTRUCTION("410CE31E", fcsel(h1, h2, h3, CondCode::kEQ));
1504
+ TEST_INSTRUCTION("410C231E", fcsel(s1, s2, s3, CondCode::kEQ));
1505
+ TEST_INSTRUCTION("410C631E", fcsel(d1, d2, d3, CondCode::kEQ));
1506
+ TEST_INSTRUCTION("41C0231E", fcvt(h1, s2));
1507
+ TEST_INSTRUCTION("41C0631E", fcvt(h1, d2));
1508
+ TEST_INSTRUCTION("4140E21E", fcvt(s1, h2));
1509
+ TEST_INSTRUCTION("4140621E", fcvt(s1, d2));
1510
+ TEST_INSTRUCTION("41C0E21E", fcvt(d1, h2));
1511
+ TEST_INSTRUCTION("41C0221E", fcvt(d1, s2));
1512
+ TEST_INSTRUCTION("4100E41E", fcvtas(w1, h2));
1513
+ TEST_INSTRUCTION("4100241E", fcvtas(w1, s2));
1514
+ TEST_INSTRUCTION("4100641E", fcvtas(w1, d2));
1515
+ TEST_INSTRUCTION("4100E49E", fcvtas(x1, h2));
1516
+ TEST_INSTRUCTION("4100249E", fcvtas(x1, s2));
1517
+ TEST_INSTRUCTION("4100649E", fcvtas(x1, d2));
1518
+ TEST_INSTRUCTION("41C8795E", fcvtas(h1, h2));
1519
+ TEST_INSTRUCTION("41C8215E", fcvtas(s1, s2));
1520
+ TEST_INSTRUCTION("41C8615E", fcvtas(d1, d2));
1521
+ TEST_INSTRUCTION("41C8790E", fcvtas(v1.h4(), v2.h4()));
1522
+ TEST_INSTRUCTION("41C8210E", fcvtas(v1.s2(), v2.s2()));
1523
+ TEST_INSTRUCTION("41C8794E", fcvtas(v1.h8(), v2.h8()));
1524
+ TEST_INSTRUCTION("41C8214E", fcvtas(v1.s4(), v2.s4()));
1525
+ TEST_INSTRUCTION("41C8614E", fcvtas(v1.d2(), v2.d2()));
1526
+ TEST_INSTRUCTION("4100E51E", fcvtau(w1, h2));
1527
+ TEST_INSTRUCTION("4100251E", fcvtau(w1, s2));
1528
+ TEST_INSTRUCTION("4100651E", fcvtau(w1, d2));
1529
+ TEST_INSTRUCTION("4100E59E", fcvtau(x1, h2));
1530
+ TEST_INSTRUCTION("4100259E", fcvtau(x1, s2));
1531
+ TEST_INSTRUCTION("4100659E", fcvtau(x1, d2));
1532
+ TEST_INSTRUCTION("41C8797E", fcvtau(h1, h2));
1533
+ TEST_INSTRUCTION("41C8217E", fcvtau(s1, s2));
1534
+ TEST_INSTRUCTION("41C8617E", fcvtau(d1, d2));
1535
+ TEST_INSTRUCTION("41C8792E", fcvtau(v1.h4(), v2.h4()));
1536
+ TEST_INSTRUCTION("41C8212E", fcvtau(v1.s2(), v2.s2()));
1537
+ TEST_INSTRUCTION("41C8796E", fcvtau(v1.h8(), v2.h8()));
1538
+ TEST_INSTRUCTION("41C8216E", fcvtau(v1.s4(), v2.s4()));
1539
+ TEST_INSTRUCTION("41C8616E", fcvtau(v1.d2(), v2.d2()));
1540
+ TEST_INSTRUCTION("4178210E", fcvtl(v1.s4(), v2.h4()));
1541
+ TEST_INSTRUCTION("4178214E", fcvtl2(v1.s4(), v2.h8()));
1542
+ TEST_INSTRUCTION("4178610E", fcvtl(v1.d2(), v2.s2()));
1543
+ TEST_INSTRUCTION("4178614E", fcvtl2(v1.d2(), v2.s4()));
1544
+ TEST_INSTRUCTION("4100F01E", fcvtms(w1, h2));
1545
+ TEST_INSTRUCTION("4100301E", fcvtms(w1, s2));
1546
+ TEST_INSTRUCTION("4100701E", fcvtms(w1, d2));
1547
+ TEST_INSTRUCTION("4100F09E", fcvtms(x1, h2));
1548
+ TEST_INSTRUCTION("4100309E", fcvtms(x1, s2));
1549
+ TEST_INSTRUCTION("4100709E", fcvtms(x1, d2));
1550
+ TEST_INSTRUCTION("41B8795E", fcvtms(h1, h2));
1551
+ TEST_INSTRUCTION("41B8215E", fcvtms(s1, s2));
1552
+ TEST_INSTRUCTION("41B8615E", fcvtms(d1, d2));
1553
+ TEST_INSTRUCTION("41B8790E", fcvtms(v1.h4(), v2.h4()));
1554
+ TEST_INSTRUCTION("41B8210E", fcvtms(v1.s2(), v2.s2()));
1555
+ TEST_INSTRUCTION("41B8794E", fcvtms(v1.h8(), v2.h8()));
1556
+ TEST_INSTRUCTION("41B8214E", fcvtms(v1.s4(), v2.s4()));
1557
+ TEST_INSTRUCTION("41B8614E", fcvtms(v1.d2(), v2.d2()));
1558
+ TEST_INSTRUCTION("4100F11E", fcvtmu(w1, h2));
1559
+ TEST_INSTRUCTION("4100311E", fcvtmu(w1, s2));
1560
+ TEST_INSTRUCTION("4100711E", fcvtmu(w1, d2));
1561
+ TEST_INSTRUCTION("4100F19E", fcvtmu(x1, h2));
1562
+ TEST_INSTRUCTION("4100319E", fcvtmu(x1, s2));
1563
+ TEST_INSTRUCTION("4100719E", fcvtmu(x1, d2));
1564
+ TEST_INSTRUCTION("41B8797E", fcvtmu(h1, h2));
1565
+ TEST_INSTRUCTION("41B8217E", fcvtmu(s1, s2));
1566
+ TEST_INSTRUCTION("41B8617E", fcvtmu(d1, d2));
1567
+ TEST_INSTRUCTION("41B8792E", fcvtmu(v1.h4(), v2.h4()));
1568
+ TEST_INSTRUCTION("41B8212E", fcvtmu(v1.s2(), v2.s2()));
1569
+ TEST_INSTRUCTION("41B8796E", fcvtmu(v1.h8(), v2.h8()));
1570
+ TEST_INSTRUCTION("41B8216E", fcvtmu(v1.s4(), v2.s4()));
1571
+ TEST_INSTRUCTION("41B8616E", fcvtmu(v1.d2(), v2.d2()));
1572
+ TEST_INSTRUCTION("4168210E", fcvtn(v1.h4(), v2.s4()));
1573
+ TEST_INSTRUCTION("4168214E", fcvtn2(v1.h8(), v2.s4()));
1574
+ TEST_INSTRUCTION("4168610E", fcvtn(v1.s2(), v2.d2()));
1575
+ TEST_INSTRUCTION("4168614E", fcvtn2(v1.s4(), v2.d2()));
1576
+ TEST_INSTRUCTION("4100E01E", fcvtns(w1, h2));
1577
+ TEST_INSTRUCTION("4100201E", fcvtns(w1, s2));
1578
+ TEST_INSTRUCTION("4100601E", fcvtns(w1, d2));
1579
+ TEST_INSTRUCTION("4100E09E", fcvtns(x1, h2));
1580
+ TEST_INSTRUCTION("4100209E", fcvtns(x1, s2));
1581
+ TEST_INSTRUCTION("4100609E", fcvtns(x1, d2));
1582
+ TEST_INSTRUCTION("41A8795E", fcvtns(h1, h2));
1583
+ TEST_INSTRUCTION("41A8215E", fcvtns(s1, s2));
1584
+ TEST_INSTRUCTION("41A8615E", fcvtns(d1, d2));
1585
+ TEST_INSTRUCTION("41A8790E", fcvtns(v1.h4(), v2.h4()));
1586
+ TEST_INSTRUCTION("41A8210E", fcvtns(v1.s2(), v2.s2()));
1587
+ TEST_INSTRUCTION("41A8794E", fcvtns(v1.h8(), v2.h8()));
1588
+ TEST_INSTRUCTION("41A8214E", fcvtns(v1.s4(), v2.s4()));
1589
+ TEST_INSTRUCTION("41A8614E", fcvtns(v1.d2(), v2.d2()));
1590
+ TEST_INSTRUCTION("4100E11E", fcvtnu(w1, h2));
1591
+ TEST_INSTRUCTION("4100211E", fcvtnu(w1, s2));
1592
+ TEST_INSTRUCTION("4100611E", fcvtnu(w1, d2));
1593
+ TEST_INSTRUCTION("4100E19E", fcvtnu(x1, h2));
1594
+ TEST_INSTRUCTION("4100219E", fcvtnu(x1, s2));
1595
+ TEST_INSTRUCTION("4100619E", fcvtnu(x1, d2));
1596
+ TEST_INSTRUCTION("41A8797E", fcvtnu(h1, h2));
1597
+ TEST_INSTRUCTION("41A8217E", fcvtnu(s1, s2));
1598
+ TEST_INSTRUCTION("41A8617E", fcvtnu(d1, d2));
1599
+ TEST_INSTRUCTION("41A8792E", fcvtnu(v1.h4(), v2.h4()));
1600
+ TEST_INSTRUCTION("41A8212E", fcvtnu(v1.s2(), v2.s2()));
1601
+ TEST_INSTRUCTION("41A8796E", fcvtnu(v1.h8(), v2.h8()));
1602
+ TEST_INSTRUCTION("41A8216E", fcvtnu(v1.s4(), v2.s4()));
1603
+ TEST_INSTRUCTION("41A8616E", fcvtnu(v1.d2(), v2.d2()));
1604
+ TEST_INSTRUCTION("4100E81E", fcvtps(w1, h2));
1605
+ TEST_INSTRUCTION("4100281E", fcvtps(w1, s2));
1606
+ TEST_INSTRUCTION("4100681E", fcvtps(w1, d2));
1607
+ TEST_INSTRUCTION("4100E89E", fcvtps(x1, h2));
1608
+ TEST_INSTRUCTION("4100289E", fcvtps(x1, s2));
1609
+ TEST_INSTRUCTION("4100689E", fcvtps(x1, d2));
1610
+ TEST_INSTRUCTION("41A8F95E", fcvtps(h1, h2));
1611
+ TEST_INSTRUCTION("41A8A15E", fcvtps(s1, s2));
1612
+ TEST_INSTRUCTION("41A8E15E", fcvtps(d1, d2));
1613
+ TEST_INSTRUCTION("41A8F90E", fcvtps(v1.h4(), v2.h4()));
1614
+ TEST_INSTRUCTION("41A8A10E", fcvtps(v1.s2(), v2.s2()));
1615
+ TEST_INSTRUCTION("41A8F94E", fcvtps(v1.h8(), v2.h8()));
1616
+ TEST_INSTRUCTION("41A8A14E", fcvtps(v1.s4(), v2.s4()));
1617
+ TEST_INSTRUCTION("41A8E14E", fcvtps(v1.d2(), v2.d2()));
1618
+ TEST_INSTRUCTION("4100E91E", fcvtpu(w1, h2));
1619
+ TEST_INSTRUCTION("4100291E", fcvtpu(w1, s2));
1620
+ TEST_INSTRUCTION("4100691E", fcvtpu(w1, d2));
1621
+ TEST_INSTRUCTION("4100E99E", fcvtpu(x1, h2));
1622
+ TEST_INSTRUCTION("4100299E", fcvtpu(x1, s2));
1623
+ TEST_INSTRUCTION("4100699E", fcvtpu(x1, d2));
1624
+ TEST_INSTRUCTION("41A8F97E", fcvtpu(h1, h2));
1625
+ TEST_INSTRUCTION("41A8A17E", fcvtpu(s1, s2));
1626
+ TEST_INSTRUCTION("41A8E17E", fcvtpu(d1, d2));
1627
+ TEST_INSTRUCTION("41A8F92E", fcvtpu(v1.h4(), v2.h4()));
1628
+ TEST_INSTRUCTION("41A8A12E", fcvtpu(v1.s2(), v2.s2()));
1629
+ TEST_INSTRUCTION("41A8F96E", fcvtpu(v1.h8(), v2.h8()));
1630
+ TEST_INSTRUCTION("41A8A16E", fcvtpu(v1.s4(), v2.s4()));
1631
+ TEST_INSTRUCTION("41A8E16E", fcvtpu(v1.d2(), v2.d2()));
1632
+ TEST_INSTRUCTION("2168617E", fcvtxn(s1, d1));
1633
+ TEST_INSTRUCTION("4168612E", fcvtxn(v1.s2(), v2.d2()));
1634
+ TEST_INSTRUCTION("4168616E", fcvtxn2(v1.s4(), v2.d2()));
1635
+ TEST_INSTRUCTION("4100F81E", fcvtzs(w1, h2));
1636
+ TEST_INSTRUCTION("4100381E", fcvtzs(w1, s2));
1637
+ TEST_INSTRUCTION("4100781E", fcvtzs(w1, d2));
1638
+ TEST_INSTRUCTION("4100F89E", fcvtzs(x1, h2));
1639
+ TEST_INSTRUCTION("4100389E", fcvtzs(x1, s2));
1640
+ TEST_INSTRUCTION("4100789E", fcvtzs(x1, d2));
1641
+ TEST_INSTRUCTION("41B8F95E", fcvtzs(h1, h2));
1642
+ TEST_INSTRUCTION("41B8A15E", fcvtzs(s1, s2));
1643
+ TEST_INSTRUCTION("41B8E15E", fcvtzs(d1, d2));
1644
+ TEST_INSTRUCTION("41B8F90E", fcvtzs(v1.h4(), v2.h4()));
1645
+ TEST_INSTRUCTION("41B8A10E", fcvtzs(v1.s2(), v2.s2()));
1646
+ TEST_INSTRUCTION("41B8F94E", fcvtzs(v1.h8(), v2.h8()));
1647
+ TEST_INSTRUCTION("41B8A14E", fcvtzs(v1.s4(), v2.s4()));
1648
+ TEST_INSTRUCTION("41B8E14E", fcvtzs(v1.d2(), v2.d2()));
1649
+ TEST_INSTRUCTION("41E0D81E", fcvtzs(w1, h2, 8));
1650
+ TEST_INSTRUCTION("41E0181E", fcvtzs(w1, s2, 8));
1651
+ TEST_INSTRUCTION("41E0581E", fcvtzs(w1, d2, 8));
1652
+ TEST_INSTRUCTION("41E0D89E", fcvtzs(x1, h2, 8));
1653
+ TEST_INSTRUCTION("41E0189E", fcvtzs(x1, s2, 8));
1654
+ TEST_INSTRUCTION("41E0589E", fcvtzs(x1, d2, 8));
1655
+ TEST_INSTRUCTION("41FC185F", fcvtzs(h1, h2, 8));
1656
+ TEST_INSTRUCTION("41FC385F", fcvtzs(s1, s2, 8));
1657
+ TEST_INSTRUCTION("41FC785F", fcvtzs(d1, d2, 8));
1658
+ TEST_INSTRUCTION("41FC180F", fcvtzs(v1.h4(), v2.h4(), 8));
1659
+ TEST_INSTRUCTION("41FC380F", fcvtzs(v1.s2(), v2.s2(), 8));
1660
+ TEST_INSTRUCTION("41FC184F", fcvtzs(v1.h8(), v2.h8(), 8));
1661
+ TEST_INSTRUCTION("41FC384F", fcvtzs(v1.s4(), v2.s4(), 8));
1662
+ TEST_INSTRUCTION("41FC784F", fcvtzs(v1.d2(), v2.d2(), 8));
1663
+ TEST_INSTRUCTION("4100F91E", fcvtzu(w1, h2));
1664
+ TEST_INSTRUCTION("4100391E", fcvtzu(w1, s2));
1665
+ TEST_INSTRUCTION("4100791E", fcvtzu(w1, d2));
1666
+ TEST_INSTRUCTION("4100F99E", fcvtzu(x1, h2));
1667
+ TEST_INSTRUCTION("4100399E", fcvtzu(x1, s2));
1668
+ TEST_INSTRUCTION("4100799E", fcvtzu(x1, d2));
1669
+ TEST_INSTRUCTION("41B8F97E", fcvtzu(h1, h2));
1670
+ TEST_INSTRUCTION("41B8A17E", fcvtzu(s1, s2));
1671
+ TEST_INSTRUCTION("41B8E17E", fcvtzu(d1, d2));
1672
+ TEST_INSTRUCTION("41B8F92E", fcvtzu(v1.h4(), v2.h4()));
1673
+ TEST_INSTRUCTION("41B8A12E", fcvtzu(v1.s2(), v2.s2()));
1674
+ TEST_INSTRUCTION("41B8F96E", fcvtzu(v1.h8(), v2.h8()));
1675
+ TEST_INSTRUCTION("41B8A16E", fcvtzu(v1.s4(), v2.s4()));
1676
+ TEST_INSTRUCTION("41B8E16E", fcvtzu(v1.d2(), v2.d2()));
1677
+ TEST_INSTRUCTION("41E0D91E", fcvtzu(w1, h2, 8));
1678
+ TEST_INSTRUCTION("41E0191E", fcvtzu(w1, s2, 8));
1679
+ TEST_INSTRUCTION("41E0591E", fcvtzu(w1, d2, 8));
1680
+ TEST_INSTRUCTION("41E0D99E", fcvtzu(x1, h2, 8));
1681
+ TEST_INSTRUCTION("41E0199E", fcvtzu(x1, s2, 8));
1682
+ TEST_INSTRUCTION("41E0599E", fcvtzu(x1, d2, 8));
1683
+ TEST_INSTRUCTION("41FC187F", fcvtzu(h1, h2, 8));
1684
+ TEST_INSTRUCTION("41FC387F", fcvtzu(s1, s2, 8));
1685
+ TEST_INSTRUCTION("41FC787F", fcvtzu(d1, d2, 8));
1686
+ TEST_INSTRUCTION("41FC182F", fcvtzu(v1.h4(), v2.h4(), 8));
1687
+ TEST_INSTRUCTION("41FC382F", fcvtzu(v1.s2(), v2.s2(), 8));
1688
+ TEST_INSTRUCTION("41FC186F", fcvtzu(v1.h8(), v2.h8(), 8));
1689
+ TEST_INSTRUCTION("41FC386F", fcvtzu(v1.s4(), v2.s4(), 8));
1690
+ TEST_INSTRUCTION("41FC786F", fcvtzu(v1.d2(), v2.d2(), 8));
1691
+ TEST_INSTRUCTION("4118E31E", fdiv(h1, h2, h3));
1692
+ TEST_INSTRUCTION("4118231E", fdiv(s1, s2, s3));
1693
+ TEST_INSTRUCTION("4118631E", fdiv(d1, d2, d3));
1694
+ TEST_INSTRUCTION("413C432E", fdiv(v1.h4(), v2.h4(), v3.h4()));
1695
+ TEST_INSTRUCTION("41FC232E", fdiv(v1.s2(), v2.s2(), v3.s2()));
1696
+ TEST_INSTRUCTION("413C436E", fdiv(v1.h8(), v2.h8(), v3.h8()));
1697
+ TEST_INSTRUCTION("41FC236E", fdiv(v1.s4(), v2.s4(), v3.s4()));
1698
+ TEST_INSTRUCTION("41FC636E", fdiv(v1.d2(), v2.d2(), v3.d2()));
1699
+ TEST_INSTRUCTION("41007E1E", fjcvtzs(w1, d2));
1700
+ TEST_INSTRUCTION("4110C31F", fmadd(h1, h2, h3, h4));
1701
+ TEST_INSTRUCTION("4110031F", fmadd(s1, s2, s3, s4));
1702
+ TEST_INSTRUCTION("4110431F", fmadd(d1, d2, d3, d4));
1703
+ TEST_INSTRUCTION("4148E31E", fmax(h1, h2, h3));
1704
+ TEST_INSTRUCTION("4148231E", fmax(s1, s2, s3));
1705
+ TEST_INSTRUCTION("4148631E", fmax(d1, d2, d3));
1706
+ TEST_INSTRUCTION("4134430E", fmax(v1.h4(), v2.h4(), v3.h4()));
1707
+ TEST_INSTRUCTION("41F4230E", fmax(v1.s2(), v2.s2(), v3.s2()));
1708
+ TEST_INSTRUCTION("4134434E", fmax(v1.h8(), v2.h8(), v3.h8()));
1709
+ TEST_INSTRUCTION("41F4234E", fmax(v1.s4(), v2.s4(), v3.s4()));
1710
+ TEST_INSTRUCTION("41F4634E", fmax(v1.d2(), v2.d2(), v3.d2()));
1711
+ TEST_INSTRUCTION("4168E31E", fmaxnm(h1, h2, h3));
1712
+ TEST_INSTRUCTION("4168231E", fmaxnm(s1, s2, s3));
1713
+ TEST_INSTRUCTION("4168631E", fmaxnm(d1, d2, d3));
1714
+ TEST_INSTRUCTION("4104430E", fmaxnm(v1.h4(), v2.h4(), v3.h4()));
1715
+ TEST_INSTRUCTION("41C4230E", fmaxnm(v1.s2(), v2.s2(), v3.s2()));
1716
+ TEST_INSTRUCTION("4104434E", fmaxnm(v1.h8(), v2.h8(), v3.h8()));
1717
+ TEST_INSTRUCTION("41C4234E", fmaxnm(v1.s4(), v2.s4(), v3.s4()));
1718
+ TEST_INSTRUCTION("41C4634E", fmaxnm(v1.d2(), v2.d2(), v3.d2()));
1719
+ TEST_INSTRUCTION("41C8305E", fmaxnmp(h1, v2.h2()));
1720
+ TEST_INSTRUCTION("41C8307E", fmaxnmp(s1, v2.s2()));
1721
+ TEST_INSTRUCTION("41C8707E", fmaxnmp(d1, v2.d2()));
1722
+ TEST_INSTRUCTION("4104432E", fmaxnmp(v1.h4(), v2.h4(), v3.h4()));
1723
+ TEST_INSTRUCTION("41C4232E", fmaxnmp(v1.s2(), v2.s2(), v3.s2()));
1724
+ TEST_INSTRUCTION("4104436E", fmaxnmp(v1.h8(), v2.h8(), v3.h8()));
1725
+ TEST_INSTRUCTION("41C4236E", fmaxnmp(v1.s4(), v2.s4(), v3.s4()));
1726
+ TEST_INSTRUCTION("41C4636E", fmaxnmp(v1.d2(), v2.d2(), v3.d2()));
1727
+ TEST_INSTRUCTION("41C8300E", fmaxnmv(h1, v2.h4()));
1728
+ TEST_INSTRUCTION("41C8304E", fmaxnmv(h1, v2.h8()));
1729
+ TEST_INSTRUCTION("41C8306E", fmaxnmv(s1, v2.s4()));
1730
+ TEST_INSTRUCTION("41F8305E", fmaxp(h1, v2.h2()));
1731
+ TEST_INSTRUCTION("41F8307E", fmaxp(s1, v2.s2()));
1732
+ TEST_INSTRUCTION("41F8707E", fmaxp(d1, v2.d2()));
1733
+ TEST_INSTRUCTION("4134432E", fmaxp(v1.h4(), v2.h4(), v3.h4()));
1734
+ TEST_INSTRUCTION("41F4232E", fmaxp(v1.s2(), v2.s2(), v3.s2()));
1735
+ TEST_INSTRUCTION("4134436E", fmaxp(v1.h8(), v2.h8(), v3.h8()));
1736
+ TEST_INSTRUCTION("41F4236E", fmaxp(v1.s4(), v2.s4(), v3.s4()));
1737
+ TEST_INSTRUCTION("41F4636E", fmaxp(v1.d2(), v2.d2(), v3.d2()));
1738
+ TEST_INSTRUCTION("41F8300E", fmaxv(h1, v2.h4()));
1739
+ TEST_INSTRUCTION("41F8304E", fmaxv(h1, v2.h8()));
1740
+ TEST_INSTRUCTION("41F8306E", fmaxv(s1, v2.s4()));
1741
+ TEST_INSTRUCTION("4158E31E", fmin(h1, h2, h3));
1742
+ TEST_INSTRUCTION("4158231E", fmin(s1, s2, s3));
1743
+ TEST_INSTRUCTION("4158631E", fmin(d1, d2, d3));
1744
+ TEST_INSTRUCTION("4134C30E", fmin(v1.h4(), v2.h4(), v3.h4()));
1745
+ TEST_INSTRUCTION("41F4A30E", fmin(v1.s2(), v2.s2(), v3.s2()));
1746
+ TEST_INSTRUCTION("4134C34E", fmin(v1.h8(), v2.h8(), v3.h8()));
1747
+ TEST_INSTRUCTION("41F4A34E", fmin(v1.s4(), v2.s4(), v3.s4()));
1748
+ TEST_INSTRUCTION("41F4E34E", fmin(v1.d2(), v2.d2(), v3.d2()));
1749
+ TEST_INSTRUCTION("4178E31E", fminnm(h1, h2, h3));
1750
+ TEST_INSTRUCTION("4178231E", fminnm(s1, s2, s3));
1751
+ TEST_INSTRUCTION("4178631E", fminnm(d1, d2, d3));
1752
+ TEST_INSTRUCTION("4104C30E", fminnm(v1.h4(), v2.h4(), v3.h4()));
1753
+ TEST_INSTRUCTION("41C4A30E", fminnm(v1.s2(), v2.s2(), v3.s2()));
1754
+ TEST_INSTRUCTION("4104C34E", fminnm(v1.h8(), v2.h8(), v3.h8()));
1755
+ TEST_INSTRUCTION("41C4A34E", fminnm(v1.s4(), v2.s4(), v3.s4()));
1756
+ TEST_INSTRUCTION("41C4E34E", fminnm(v1.d2(), v2.d2(), v3.d2()));
1757
+ TEST_INSTRUCTION("41C8B05E", fminnmp(h1, v2.h2()));
1758
+ TEST_INSTRUCTION("41C8B07E", fminnmp(s1, v2.s2()));
1759
+ TEST_INSTRUCTION("41C8F07E", fminnmp(d1, v2.d2()));
1760
+ TEST_INSTRUCTION("4104C32E", fminnmp(v1.h4(), v2.h4(), v3.h4()));
1761
+ TEST_INSTRUCTION("41C4A32E", fminnmp(v1.s2(), v2.s2(), v3.s2()));
1762
+ TEST_INSTRUCTION("4104C36E", fminnmp(v1.h8(), v2.h8(), v3.h8()));
1763
+ TEST_INSTRUCTION("41C4A36E", fminnmp(v1.s4(), v2.s4(), v3.s4()));
1764
+ TEST_INSTRUCTION("41C4E36E", fminnmp(v1.d2(), v2.d2(), v3.d2()));
1765
+ TEST_INSTRUCTION("41C8B00E", fminnmv(h1, v2.h4()));
1766
+ TEST_INSTRUCTION("41C8B04E", fminnmv(h1, v2.h8()));
1767
+ TEST_INSTRUCTION("41C8B06E", fminnmv(s1, v2.s4()));
1768
+ TEST_INSTRUCTION("41F8B05E", fminp(h1, v2.h2()));
1769
+ TEST_INSTRUCTION("41F8B07E", fminp(s1, v2.s2()));
1770
+ TEST_INSTRUCTION("41F8F07E", fminp(d1, v2.d2()));
1771
+ TEST_INSTRUCTION("4134C32E", fminp(v1.h4(), v2.h4(), v3.h4()));
1772
+ TEST_INSTRUCTION("41F4A32E", fminp(v1.s2(), v2.s2(), v3.s2()));
1773
+ TEST_INSTRUCTION("4134C36E", fminp(v1.h8(), v2.h8(), v3.h8()));
1774
+ TEST_INSTRUCTION("41F4A36E", fminp(v1.s4(), v2.s4(), v3.s4()));
1775
+ TEST_INSTRUCTION("41F4E36E", fminp(v1.d2(), v2.d2(), v3.d2()));
1776
+ TEST_INSTRUCTION("41F8B00E", fminv(h1, v2.h4()));
1777
+ TEST_INSTRUCTION("41F8B04E", fminv(h1, v2.h8()));
1778
+ TEST_INSTRUCTION("41F8B06E", fminv(s1, v2.s4()));
1779
+ TEST_INSTRUCTION("410C430E", fmla(v1.h4(), v2.h4(), v3.h4()));
1780
+ TEST_INSTRUCTION("41CC230E", fmla(v1.s2(), v2.s2(), v3.s2()));
1781
+ TEST_INSTRUCTION("410C434E", fmla(v1.h8(), v2.h8(), v3.h8()));
1782
+ TEST_INSTRUCTION("41CC234E", fmla(v1.s4(), v2.s4(), v3.s4()));
1783
+ TEST_INSTRUCTION("41CC634E", fmla(v1.d2(), v2.d2(), v3.d2()));
1784
+ TEST_INSTRUCTION("4118335F", fmla(h1, h2, v3.h(7)));
1785
+ TEST_INSTRUCTION("4118A35F", fmla(s1, s2, v3.s(3)));
1786
+ TEST_INSTRUCTION("4118C35F", fmla(d1, d2, v3.d(1)));
1787
+ TEST_INSTRUCTION("4118330F", fmla(v1.h4(), v2.h4(), v3.h(7)));
1788
+ TEST_INSTRUCTION("4118A30F", fmla(v1.s2(), v2.s2(), v3.s(3)));
1789
+ TEST_INSTRUCTION("4118334F", fmla(v1.h8(), v2.h8(), v3.h(7)));
1790
+ TEST_INSTRUCTION("4118A34F", fmla(v1.s4(), v2.s4(), v3.s(3)));
1791
+ TEST_INSTRUCTION("4118C34F", fmla(v1.d2(), v2.d2(), v3.d(1)));
1792
+ TEST_INSTRUCTION("41EC230E", fmlal(v1.s2(), v2.h2(), v3.h2()));
1793
+ TEST_INSTRUCTION("41EC234E", fmlal(v1.s4(), v2.h4(), v3.h4()));
1794
+ TEST_INSTRUCTION("4100830F", fmlal(v1.s2(), v2.h2(), v3.h(0)));
1795
+ TEST_INSTRUCTION("4108B30F", fmlal(v1.s2(), v2.h2(), v3.h(7)));
1796
+ TEST_INSTRUCTION("4100834F", fmlal(v1.s4(), v2.h4(), v3.h(0)));
1797
+ TEST_INSTRUCTION("4108B34F", fmlal(v1.s4(), v2.h4(), v3.h(7)));
1798
+ TEST_INSTRUCTION("41CC232E", fmlal2(v1.s2(), v2.h2(), v3.h2()));
1799
+ TEST_INSTRUCTION("41CC236E", fmlal2(v1.s4(), v2.h4(), v3.h4()));
1800
+ TEST_INSTRUCTION("4180832F", fmlal2(v1.s2(), v2.h2(), v3.h(0)));
1801
+ TEST_INSTRUCTION("4188B32F", fmlal2(v1.s2(), v2.h2(), v3.h(7)));
1802
+ TEST_INSTRUCTION("4180836F", fmlal2(v1.s4(), v2.h4(), v3.h(0)));
1803
+ TEST_INSTRUCTION("4188B36F", fmlal2(v1.s4(), v2.h4(), v3.h(7)));
1804
+ TEST_INSTRUCTION("410CC30E", fmls(v1.h4(), v2.h4(), v3.h4()));
1805
+ TEST_INSTRUCTION("41CCA30E", fmls(v1.s2(), v2.s2(), v3.s2()));
1806
+ TEST_INSTRUCTION("410CC34E", fmls(v1.h8(), v2.h8(), v3.h8()));
1807
+ TEST_INSTRUCTION("41CCA34E", fmls(v1.s4(), v2.s4(), v3.s4()));
1808
+ TEST_INSTRUCTION("41CCE34E", fmls(v1.d2(), v2.d2(), v3.d2()));
1809
+ TEST_INSTRUCTION("4158335F", fmls(h1, h2, v3.h(7)));
1810
+ TEST_INSTRUCTION("4158A35F", fmls(s1, s2, v3.s(3)));
1811
+ TEST_INSTRUCTION("4158C35F", fmls(d1, d2, v3.d(1)));
1812
+ TEST_INSTRUCTION("4158330F", fmls(v1.h4(), v2.h4(), v3.h(7)));
1813
+ TEST_INSTRUCTION("4158A30F", fmls(v1.s2(), v2.s2(), v3.s(3)));
1814
+ TEST_INSTRUCTION("4158334F", fmls(v1.h8(), v2.h8(), v3.h(7)));
1815
+ TEST_INSTRUCTION("4158A34F", fmls(v1.s4(), v2.s4(), v3.s(3)));
1816
+ TEST_INSTRUCTION("4158C34F", fmls(v1.d2(), v2.d2(), v3.d(1)));
1817
+ TEST_INSTRUCTION("41ECA30E", fmlsl(v1.s2(), v2.h2(), v3.h2()));
1818
+ TEST_INSTRUCTION("41ECA34E", fmlsl(v1.s4(), v2.h4(), v3.h4()));
1819
+ TEST_INSTRUCTION("4140830F", fmlsl(v1.s2(), v2.h2(), v3.h(0)));
1820
+ TEST_INSTRUCTION("4148B30F", fmlsl(v1.s2(), v2.h2(), v3.h(7)));
1821
+ TEST_INSTRUCTION("4140834F", fmlsl(v1.s4(), v2.h4(), v3.h(0)));
1822
+ TEST_INSTRUCTION("4148B34F", fmlsl(v1.s4(), v2.h4(), v3.h(7)));
1823
+ TEST_INSTRUCTION("41CCA32E", fmlsl2(v1.s2(), v2.h2(), v3.h2()));
1824
+ TEST_INSTRUCTION("41CCA36E", fmlsl2(v1.s4(), v2.h4(), v3.h4()));
1825
+ TEST_INSTRUCTION("41C0832F", fmlsl2(v1.s2(), v2.h2(), v3.h(0)));
1826
+ TEST_INSTRUCTION("41C8B32F", fmlsl2(v1.s2(), v2.h2(), v3.h(7)));
1827
+ TEST_INSTRUCTION("41C0836F", fmlsl2(v1.s4(), v2.h4(), v3.h(0)));
1828
+ TEST_INSTRUCTION("41C8B36F", fmlsl2(v1.s4(), v2.h4(), v3.h(7)));
1829
+ TEST_INSTRUCTION("4100E71E", fmov(h1, w2));
1830
+ TEST_INSTRUCTION("4100E79E", fmov(h1, x2));
1831
+ TEST_INSTRUCTION("4100271E", fmov(s1, w2));
1832
+ TEST_INSTRUCTION("4100679E", fmov(d1, x2));
1833
+ TEST_INSTRUCTION("4100AF9E", fmov(v1.d(1), x2));
1834
+ TEST_INSTRUCTION("4100E61E", fmov(w1, h2));
1835
+ TEST_INSTRUCTION("4100E69E", fmov(x1, h2));
1836
+ TEST_INSTRUCTION("4100261E", fmov(w1, s2));
1837
+ TEST_INSTRUCTION("4100669E", fmov(x1, d2));
1838
+ TEST_INSTRUCTION("4100AE9E", fmov(x1, v2.d(1)));
1839
+ TEST_INSTRUCTION("0110EA1E", fmov(h1, 0.25));
1840
+ TEST_INSTRUCTION("0110EC1E", fmov(h1, 0.5));
1841
+ TEST_INSTRUCTION("0110EF1E", fmov(h1, 1.5));
1842
+ TEST_INSTRUCTION("0110E01E", fmov(h1, 2.0));
1843
+ TEST_INSTRUCTION("01D0E51E", fmov(h1, 15.0));
1844
+ TEST_INSTRUCTION("01102A1E", fmov(s1, 0.25));
1845
+ TEST_INSTRUCTION("01102C1E", fmov(s1, 0.5));
1846
+ TEST_INSTRUCTION("01102F1E", fmov(s1, 1.5));
1847
+ TEST_INSTRUCTION("0110201E", fmov(s1, 2.0));
1848
+ TEST_INSTRUCTION("01D0251E", fmov(s1, 15.0));
1849
+ TEST_INSTRUCTION("01106A1E", fmov(d1, 0.25));
1850
+ TEST_INSTRUCTION("01106C1E", fmov(d1, 0.5));
1851
+ TEST_INSTRUCTION("01106F1E", fmov(d1, 1.5));
1852
+ TEST_INSTRUCTION("0110601E", fmov(d1, 2.0));
1853
+ TEST_INSTRUCTION("01D0651E", fmov(d1, 15.0));
1854
+ TEST_INSTRUCTION("01FC030F", fmov(v1.h4(), 0.5));
1855
+ TEST_INSTRUCTION("01FC000F", fmov(v1.h4(), 2.0));
1856
+ TEST_INSTRUCTION("01FC034F", fmov(v1.h8(), 0.5));
1857
+ TEST_INSTRUCTION("01FC004F", fmov(v1.h8(), 2.0));
1858
+ TEST_INSTRUCTION("01F4030F", fmov(v1.s2(), 0.5));
1859
+ TEST_INSTRUCTION("01F4000F", fmov(v1.s2(), 2.0));
1860
+ TEST_INSTRUCTION("01F4034F", fmov(v1.s4(), 0.5));
1861
+ TEST_INSTRUCTION("01F4004F", fmov(v1.s4(), 2.0));
1862
+ TEST_INSTRUCTION("01F4036F", fmov(v1.d2(), 0.5));
1863
+ TEST_INSTRUCTION("01F4006F", fmov(v1.d2(), 2.0));
1864
+ TEST_INSTRUCTION("4190C31F", fmsub(h1, h2, h3, h4));
1865
+ TEST_INSTRUCTION("4190031F", fmsub(s1, s2, s3, s4));
1866
+ TEST_INSTRUCTION("4190431F", fmsub(d1, d2, d3, d4));
1867
+ TEST_INSTRUCTION("4108E31E", fmul(h1, h2, h3));
1868
+ TEST_INSTRUCTION("4108231E", fmul(s1, s2, s3));
1869
+ TEST_INSTRUCTION("4108631E", fmul(d1, d2, d3));
1870
+ TEST_INSTRUCTION("411C432E", fmul(v1.h4(), v2.h4(), v3.h4()));
1871
+ TEST_INSTRUCTION("41DC232E", fmul(v1.s2(), v2.s2(), v3.s2()));
1872
+ TEST_INSTRUCTION("411C436E", fmul(v1.h8(), v2.h8(), v3.h8()));
1873
+ TEST_INSTRUCTION("41DC236E", fmul(v1.s4(), v2.s4(), v3.s4()));
1874
+ TEST_INSTRUCTION("41DC636E", fmul(v1.d2(), v2.d2(), v3.d2()));
1875
+ TEST_INSTRUCTION("4198335F", fmul(h1, h2, v3.h(7)));
1876
+ TEST_INSTRUCTION("4198A35F", fmul(s1, s2, v3.s(3)));
1877
+ TEST_INSTRUCTION("4198C35F", fmul(d1, d2, v3.d(1)));
1878
+ TEST_INSTRUCTION("4198330F", fmul(v1.h4(), v2.h4(), v3.h(7)));
1879
+ TEST_INSTRUCTION("4198A30F", fmul(v1.s2(), v2.s2(), v3.s(3)));
1880
+ TEST_INSTRUCTION("4198334F", fmul(v1.h8(), v2.h8(), v3.h(7)));
1881
+ TEST_INSTRUCTION("4198A34F", fmul(v1.s4(), v2.s4(), v3.s(3)));
1882
+ TEST_INSTRUCTION("4198C34F", fmul(v1.d2(), v2.d2(), v3.d(1)));
1883
+ TEST_INSTRUCTION("411C435E", fmulx(h1, h2, h3));
1884
+ TEST_INSTRUCTION("41DC235E", fmulx(s1, s2, s3));
1885
+ TEST_INSTRUCTION("41DC635E", fmulx(d1, d2, d3));
1886
+ TEST_INSTRUCTION("411C430E", fmulx(v1.h4(), v2.h4(), v3.h4()));
1887
+ TEST_INSTRUCTION("41DC230E", fmulx(v1.s2(), v2.s2(), v3.s2()));
1888
+ TEST_INSTRUCTION("411C434E", fmulx(v1.h8(), v2.h8(), v3.h8()));
1889
+ TEST_INSTRUCTION("41DC234E", fmulx(v1.s4(), v2.s4(), v3.s4()));
1890
+ TEST_INSTRUCTION("41DC634E", fmulx(v1.d2(), v2.d2(), v3.d2()));
1891
+ TEST_INSTRUCTION("4198337F", fmulx(h1, h2, v3.h(7)));
1892
+ TEST_INSTRUCTION("4198A37F", fmulx(s1, s2, v3.s(3)));
1893
+ TEST_INSTRUCTION("4198C37F", fmulx(d1, d2, v3.d(1)));
1894
+ TEST_INSTRUCTION("4198332F", fmulx(v1.h4(), v2.h4(), v3.h(7)));
1895
+ TEST_INSTRUCTION("4198A32F", fmulx(v1.s2(), v2.s2(), v3.s(3)));
1896
+ TEST_INSTRUCTION("4198336F", fmulx(v1.h8(), v2.h8(), v3.h(7)));
1897
+ TEST_INSTRUCTION("4198A36F", fmulx(v1.s4(), v2.s4(), v3.s(3)));
1898
+ TEST_INSTRUCTION("4198C36F", fmulx(v1.d2(), v2.d2(), v3.d(1)));
1899
+ TEST_INSTRUCTION("4140E11E", fneg(h1, h2));
1900
+ TEST_INSTRUCTION("4140211E", fneg(s1, s2));
1901
+ TEST_INSTRUCTION("4140611E", fneg(d1, d2));
1902
+ TEST_INSTRUCTION("41F8F82E", fneg(v1.h4(), v2.h4()));
1903
+ TEST_INSTRUCTION("41F8A02E", fneg(v1.s2(), v2.s2()));
1904
+ TEST_INSTRUCTION("41F8F86E", fneg(v1.h8(), v2.h8()));
1905
+ TEST_INSTRUCTION("41F8A06E", fneg(v1.s4(), v2.s4()));
1906
+ TEST_INSTRUCTION("41F8E06E", fneg(v1.d2(), v2.d2()));
1907
+ TEST_INSTRUCTION("4110E31F", fnmadd(h1, h2, h3, h4));
1908
+ TEST_INSTRUCTION("4110231F", fnmadd(s1, s2, s3, s4));
1909
+ TEST_INSTRUCTION("4110631F", fnmadd(d1, d2, d3, d4));
1910
+ TEST_INSTRUCTION("4190E31F", fnmsub(h1, h2, h3, h4));
1911
+ TEST_INSTRUCTION("4190231F", fnmsub(s1, s2, s3, s4));
1912
+ TEST_INSTRUCTION("4190631F", fnmsub(d1, d2, d3, d4));
1913
+ TEST_INSTRUCTION("4188E31E", fnmul(h1, h2, h3));
1914
+ TEST_INSTRUCTION("4188231E", fnmul(s1, s2, s3));
1915
+ TEST_INSTRUCTION("4188631E", fnmul(d1, d2, d3));
1916
+ TEST_INSTRUCTION("41D8F95E", frecpe(h1, h2));
1917
+ TEST_INSTRUCTION("41D8A15E", frecpe(s1, s2));
1918
+ TEST_INSTRUCTION("41D8E15E", frecpe(d1, d2));
1919
+ TEST_INSTRUCTION("41D8F90E", frecpe(v1.h4(), v2.h4()));
1920
+ TEST_INSTRUCTION("41D8A10E", frecpe(v1.s2(), v2.s2()));
1921
+ TEST_INSTRUCTION("41D8F94E", frecpe(v1.h8(), v2.h8()));
1922
+ TEST_INSTRUCTION("41D8A14E", frecpe(v1.s4(), v2.s4()));
1923
+ TEST_INSTRUCTION("41D8E14E", frecpe(v1.d2(), v2.d2()));
1924
+ TEST_INSTRUCTION("413C435E", frecps(h1, h2, h3));
1925
+ TEST_INSTRUCTION("41FC235E", frecps(s1, s2, s3));
1926
+ TEST_INSTRUCTION("41FC635E", frecps(d1, d2, d3));
1927
+ TEST_INSTRUCTION("413C430E", frecps(v1.h4(), v2.h4(), v3.h4()));
1928
+ TEST_INSTRUCTION("41FC230E", frecps(v1.s2(), v2.s2(), v3.s2()));
1929
+ TEST_INSTRUCTION("413C434E", frecps(v1.h8(), v2.h8(), v3.h8()));
1930
+ TEST_INSTRUCTION("41FC234E", frecps(v1.s4(), v2.s4(), v3.s4()));
1931
+ TEST_INSTRUCTION("41FC634E", frecps(v1.d2(), v2.d2(), v3.d2()));
1932
+ TEST_INSTRUCTION("41F8F95E", frecpx(h1, h2));
1933
+ TEST_INSTRUCTION("41F8A15E", frecpx(s1, s2));
1934
+ TEST_INSTRUCTION("41F8E15E", frecpx(d1, d2));
1935
+ TEST_INSTRUCTION("41C0281E", frint32x(s1, s2));
1936
+ TEST_INSTRUCTION("41C0681E", frint32x(d1, d2));
1937
+ TEST_INSTRUCTION("41E8212E", frint32x(v1.s2(), v2.s2()));
1938
+ TEST_INSTRUCTION("41E8216E", frint32x(v1.s4(), v2.s4()));
1939
+ TEST_INSTRUCTION("41E8616E", frint32x(v1.d2(), v2.d2()));
1940
+ TEST_INSTRUCTION("4140281E", frint32z(s1, s2));
1941
+ TEST_INSTRUCTION("4140681E", frint32z(d1, d2));
1942
+ TEST_INSTRUCTION("41E8210E", frint32z(v1.s2(), v2.s2()));
1943
+ TEST_INSTRUCTION("41E8214E", frint32z(v1.s4(), v2.s4()));
1944
+ TEST_INSTRUCTION("41E8614E", frint32z(v1.d2(), v2.d2()));
1945
+ TEST_INSTRUCTION("41C0291E", frint64x(s1, s2));
1946
+ TEST_INSTRUCTION("41C0691E", frint64x(d1, d2));
1947
+ TEST_INSTRUCTION("41F8212E", frint64x(v1.s2(), v2.s2()));
1948
+ TEST_INSTRUCTION("41F8216E", frint64x(v1.s4(), v2.s4()));
1949
+ TEST_INSTRUCTION("41F8616E", frint64x(v1.d2(), v2.d2()));
1950
+ TEST_INSTRUCTION("4140291E", frint64z(s1, s2));
1951
+ TEST_INSTRUCTION("4140691E", frint64z(d1, d2));
1952
+ TEST_INSTRUCTION("41F8210E", frint64z(v1.s2(), v2.s2()));
1953
+ TEST_INSTRUCTION("41F8214E", frint64z(v1.s4(), v2.s4()));
1954
+ TEST_INSTRUCTION("41F8614E", frint64z(v1.d2(), v2.d2()));
1955
+ TEST_INSTRUCTION("4140E61E", frinta(h1, h2));
1956
+ TEST_INSTRUCTION("4140261E", frinta(s1, s2));
1957
+ TEST_INSTRUCTION("4140661E", frinta(d1, d2));
1958
+ TEST_INSTRUCTION("4188792E", frinta(v1.h4(), v2.h4()));
1959
+ TEST_INSTRUCTION("4188212E", frinta(v1.s2(), v2.s2()));
1960
+ TEST_INSTRUCTION("4188796E", frinta(v1.h8(), v2.h8()));
1961
+ TEST_INSTRUCTION("4188216E", frinta(v1.s4(), v2.s4()));
1962
+ TEST_INSTRUCTION("4188616E", frinta(v1.d2(), v2.d2()));
1963
+ TEST_INSTRUCTION("41C0E71E", frinti(h1, h2));
1964
+ TEST_INSTRUCTION("41C0271E", frinti(s1, s2));
1965
+ TEST_INSTRUCTION("41C0671E", frinti(d1, d2));
1966
+ TEST_INSTRUCTION("4198F92E", frinti(v1.h4(), v2.h4()));
1967
+ TEST_INSTRUCTION("4198A12E", frinti(v1.s2(), v2.s2()));
1968
+ TEST_INSTRUCTION("4198F96E", frinti(v1.h8(), v2.h8()));
1969
+ TEST_INSTRUCTION("4198A16E", frinti(v1.s4(), v2.s4()));
1970
+ TEST_INSTRUCTION("4198E16E", frinti(v1.d2(), v2.d2()));
1971
+ TEST_INSTRUCTION("4140E51E", frintm(h1, h2));
1972
+ TEST_INSTRUCTION("4140251E", frintm(s1, s2));
1973
+ TEST_INSTRUCTION("4140651E", frintm(d1, d2));
1974
+ TEST_INSTRUCTION("4198790E", frintm(v1.h4(), v2.h4()));
1975
+ TEST_INSTRUCTION("4198210E", frintm(v1.s2(), v2.s2()));
1976
+ TEST_INSTRUCTION("4198794E", frintm(v1.h8(), v2.h8()));
1977
+ TEST_INSTRUCTION("4198214E", frintm(v1.s4(), v2.s4()));
1978
+ TEST_INSTRUCTION("4198614E", frintm(v1.d2(), v2.d2()));
1979
+ TEST_INSTRUCTION("4140E41E", frintn(h1, h2));
1980
+ TEST_INSTRUCTION("4140241E", frintn(s1, s2));
1981
+ TEST_INSTRUCTION("4140641E", frintn(d1, d2));
1982
+ TEST_INSTRUCTION("4188790E", frintn(v1.h4(), v2.h4()));
1983
+ TEST_INSTRUCTION("4188210E", frintn(v1.s2(), v2.s2()));
1984
+ TEST_INSTRUCTION("4188794E", frintn(v1.h8(), v2.h8()));
1985
+ TEST_INSTRUCTION("4188214E", frintn(v1.s4(), v2.s4()));
1986
+ TEST_INSTRUCTION("4188614E", frintn(v1.d2(), v2.d2()));
1987
+ TEST_INSTRUCTION("41C0E41E", frintp(h1, h2));
1988
+ TEST_INSTRUCTION("41C0241E", frintp(s1, s2));
1989
+ TEST_INSTRUCTION("41C0641E", frintp(d1, d2));
1990
+ TEST_INSTRUCTION("4188F90E", frintp(v1.h4(), v2.h4()));
1991
+ TEST_INSTRUCTION("4188A10E", frintp(v1.s2(), v2.s2()));
1992
+ TEST_INSTRUCTION("4188F94E", frintp(v1.h8(), v2.h8()));
1993
+ TEST_INSTRUCTION("4188A14E", frintp(v1.s4(), v2.s4()));
1994
+ TEST_INSTRUCTION("4188E14E", frintp(v1.d2(), v2.d2()));
1995
+ TEST_INSTRUCTION("4140E71E", frintx(h1, h2));
1996
+ TEST_INSTRUCTION("4140271E", frintx(s1, s2));
1997
+ TEST_INSTRUCTION("4140671E", frintx(d1, d2));
1998
+ TEST_INSTRUCTION("4198792E", frintx(v1.h4(), v2.h4()));
1999
+ TEST_INSTRUCTION("4198212E", frintx(v1.s2(), v2.s2()));
2000
+ TEST_INSTRUCTION("4198796E", frintx(v1.h8(), v2.h8()));
2001
+ TEST_INSTRUCTION("4198216E", frintx(v1.s4(), v2.s4()));
2002
+ TEST_INSTRUCTION("4198616E", frintx(v1.d2(), v2.d2()));
2003
+ TEST_INSTRUCTION("41C0E51E", frintz(h1, h2));
2004
+ TEST_INSTRUCTION("41C0251E", frintz(s1, s2));
2005
+ TEST_INSTRUCTION("41C0651E", frintz(d1, d2));
2006
+ TEST_INSTRUCTION("4198F90E", frintz(v1.h4(), v2.h4()));
2007
+ TEST_INSTRUCTION("4198A10E", frintz(v1.s2(), v2.s2()));
2008
+ TEST_INSTRUCTION("4198F94E", frintz(v1.h8(), v2.h8()));
2009
+ TEST_INSTRUCTION("4198A14E", frintz(v1.s4(), v2.s4()));
2010
+ TEST_INSTRUCTION("4198E14E", frintz(v1.d2(), v2.d2()));
2011
+ TEST_INSTRUCTION("41D8F97E", frsqrte(h1, h2));
2012
+ TEST_INSTRUCTION("41D8A17E", frsqrte(s1, s2));
2013
+ TEST_INSTRUCTION("41D8E17E", frsqrte(d1, d2));
2014
+ TEST_INSTRUCTION("41D8F92E", frsqrte(v1.h4(), v2.h4()));
2015
+ TEST_INSTRUCTION("41D8A12E", frsqrte(v1.s2(), v2.s2()));
2016
+ TEST_INSTRUCTION("41D8F96E", frsqrte(v1.h8(), v2.h8()));
2017
+ TEST_INSTRUCTION("41D8A16E", frsqrte(v1.s4(), v2.s4()));
2018
+ TEST_INSTRUCTION("41D8E16E", frsqrte(v1.d2(), v2.d2()));
2019
+ TEST_INSTRUCTION("413CC35E", frsqrts(h1, h2, h3));
2020
+ TEST_INSTRUCTION("41FCA35E", frsqrts(s1, s2, s3));
2021
+ TEST_INSTRUCTION("41FCE35E", frsqrts(d1, d2, d3));
2022
+ TEST_INSTRUCTION("413CC30E", frsqrts(v1.h4(), v2.h4(), v3.h4()));
2023
+ TEST_INSTRUCTION("41FCA30E", frsqrts(v1.s2(), v2.s2(), v3.s2()));
2024
+ TEST_INSTRUCTION("413CC34E", frsqrts(v1.h8(), v2.h8(), v3.h8()));
2025
+ TEST_INSTRUCTION("41FCA34E", frsqrts(v1.s4(), v2.s4(), v3.s4()));
2026
+ TEST_INSTRUCTION("41FCE34E", frsqrts(v1.d2(), v2.d2(), v3.d2()));
2027
+ TEST_INSTRUCTION("41C0E11E", fsqrt(h1, h2));
2028
+ TEST_INSTRUCTION("41C0211E", fsqrt(s1, s2));
2029
+ TEST_INSTRUCTION("41C0611E", fsqrt(d1, d2));
2030
+ TEST_INSTRUCTION("41F8F92E", fsqrt(v1.h4(), v2.h4()));
2031
+ TEST_INSTRUCTION("41F8A12E", fsqrt(v1.s2(), v2.s2()));
2032
+ TEST_INSTRUCTION("41F8F96E", fsqrt(v1.h8(), v2.h8()));
2033
+ TEST_INSTRUCTION("41F8A16E", fsqrt(v1.s4(), v2.s4()));
2034
+ TEST_INSTRUCTION("41F8E16E", fsqrt(v1.d2(), v2.d2()));
2035
+ TEST_INSTRUCTION("4138E31E", fsub(h1, h2, h3));
2036
+ TEST_INSTRUCTION("4138231E", fsub(s1, s2, s3));
2037
+ TEST_INSTRUCTION("4138631E", fsub(d1, d2, d3));
2038
+ TEST_INSTRUCTION("4114C30E", fsub(v1.h4(), v2.h4(), v3.h4()));
2039
+ TEST_INSTRUCTION("41D4A30E", fsub(v1.s2(), v2.s2(), v3.s2()));
2040
+ TEST_INSTRUCTION("4114C34E", fsub(v1.h8(), v2.h8(), v3.h8()));
2041
+ TEST_INSTRUCTION("41D4A34E", fsub(v1.s4(), v2.s4(), v3.s4()));
2042
+ TEST_INSTRUCTION("41D4E34E", fsub(v1.d2(), v2.d2(), v3.d2()));
2043
+ TEST_INSTRUCTION("411C014E", ins(v1.b(0), w2));
2044
+ TEST_INSTRUCTION("411C074E", ins(v1.b(3), w2));
2045
+ TEST_INSTRUCTION("411C0D4E", ins(v1.b(6), w2));
2046
+ TEST_INSTRUCTION("411C134E", ins(v1.b(9), w2));
2047
+ TEST_INSTRUCTION("411C1F4E", ins(v1.b(15), w2));
2048
+ TEST_INSTRUCTION("411C024E", ins(v1.h(0), w2));
2049
+ TEST_INSTRUCTION("411C0E4E", ins(v1.h(3), w2));
2050
+ TEST_INSTRUCTION("411C1E4E", ins(v1.h(7), w2));
2051
+ TEST_INSTRUCTION("411C044E", ins(v1.s(0), w2));
2052
+ TEST_INSTRUCTION("411C0C4E", ins(v1.s(1), w2));
2053
+ TEST_INSTRUCTION("411C144E", ins(v1.s(2), w2));
2054
+ TEST_INSTRUCTION("411C1C4E", ins(v1.s(3), w2));
2055
+ TEST_INSTRUCTION("411C084E", ins(v1.d(0), x2));
2056
+ TEST_INSTRUCTION("411C184E", ins(v1.d(1), x2));
2057
+ TEST_INSTRUCTION("417C016E", ins(v1.b(0), v2.b(15)));
2058
+ TEST_INSTRUCTION("4174036E", ins(v1.b(1), v2.b(14)));
2059
+ TEST_INSTRUCTION("4174026E", ins(v1.h(0), v2.h(7)));
2060
+ TEST_INSTRUCTION("4164066E", ins(v1.h(1), v2.h(6)));
2061
+ TEST_INSTRUCTION("4164046E", ins(v1.s(0), v2.s(3)));
2062
+ TEST_INSTRUCTION("41440C6E", ins(v1.s(1), v2.s(2)));
2063
+ TEST_INSTRUCTION("4144086E", ins(v1.d(0), v2.d(1)));
2064
+ TEST_INSTRUCTION("4104186E", ins(v1.d(1), v2.d(0)));
2065
+ TEST_INSTRUCTION("4100400D", ld1(v1.b(0), ptr(x2)));
2066
+ TEST_INSTRUCTION("4100DF0D", ld1(v1.b(0), ptr_post(x2, 1)));
2067
+ TEST_INSTRUCTION("4100CB0D", ld1(v1.b(0), ptr_post(x2, x11)));
2068
+ TEST_INSTRUCTION("4140400D", ld1(v1.h(0), ptr(x2)));
2069
+ TEST_INSTRUCTION("4140DF0D", ld1(v1.h(0), ptr_post(x2, 2)));
2070
+ TEST_INSTRUCTION("4140CB0D", ld1(v1.h(0), ptr_post(x2, x11)));
2071
+ TEST_INSTRUCTION("4180400D", ld1(v1.s(0), ptr(x2)));
2072
+ TEST_INSTRUCTION("4180DF0D", ld1(v1.s(0), ptr_post(x2, 4)));
2073
+ TEST_INSTRUCTION("4180CB0D", ld1(v1.s(0), ptr_post(x2, x11)));
2074
+ TEST_INSTRUCTION("4184400D", ld1(v1.d(0), ptr(x2)));
2075
+ TEST_INSTRUCTION("4184DF0D", ld1(v1.d(0), ptr_post(x2, 8)));
2076
+ TEST_INSTRUCTION("4184CB0D", ld1(v1.d(0), ptr_post(x2, x11)));
2077
+ TEST_INSTRUCTION("411C404D", ld1(v1.b(15), ptr(x2)));
2078
+ TEST_INSTRUCTION("411CDF4D", ld1(v1.b(15), ptr_post(x2, 1)));
2079
+ TEST_INSTRUCTION("411CCB4D", ld1(v1.b(15), ptr_post(x2, x11)));
2080
+ TEST_INSTRUCTION("4158404D", ld1(v1.h(7), ptr(x2)));
2081
+ TEST_INSTRUCTION("4158DF4D", ld1(v1.h(7), ptr_post(x2, 2)));
2082
+ TEST_INSTRUCTION("4158CB4D", ld1(v1.h(7), ptr_post(x2, x11)));
2083
+ TEST_INSTRUCTION("4190404D", ld1(v1.s(3), ptr(x2)));
2084
+ TEST_INSTRUCTION("4190DF4D", ld1(v1.s(3), ptr_post(x2, 4)));
2085
+ TEST_INSTRUCTION("4190CB4D", ld1(v1.s(3), ptr_post(x2, x11)));
2086
+ TEST_INSTRUCTION("4184404D", ld1(v1.d(1), ptr(x2)));
2087
+ TEST_INSTRUCTION("4184DF4D", ld1(v1.d(1), ptr_post(x2, 8)));
2088
+ TEST_INSTRUCTION("4184CB4D", ld1(v1.d(1), ptr_post(x2, x11)));
2089
+ TEST_INSTRUCTION("4170400C", ld1(v1.b8(), ptr(x2)));
2090
+ TEST_INSTRUCTION("4170DF0C", ld1(v1.b8(), ptr_post(x2, 8)));
2091
+ TEST_INSTRUCTION("4170404C", ld1(v1.b16(), ptr(x2)));
2092
+ TEST_INSTRUCTION("4170DF4C", ld1(v1.b16(), ptr_post(x2, 16)));
2093
+ TEST_INSTRUCTION("61A0400C", ld1(v1.b8(), v2.b8(), ptr(x3)));
2094
+ TEST_INSTRUCTION("61A0DF0C", ld1(v1.b8(), v2.b8(), ptr_post(x3, 16)));
2095
+ TEST_INSTRUCTION("61A0404C", ld1(v1.b16(), v2.b16(), ptr(x3)));
2096
+ TEST_INSTRUCTION("61A0DF4C", ld1(v1.b16(), v2.b16(), ptr_post(x3, 32)));
2097
+ TEST_INSTRUCTION("8160400C", ld1(v1.b8(), v2.b8(), v3.b8(), ptr(x4)));
2098
+ TEST_INSTRUCTION("8160DF0C", ld1(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24)));
2099
+ TEST_INSTRUCTION("8160404C", ld1(v1.b16(), v2.b16(), v3.b16(), ptr(x4)));
2100
+ TEST_INSTRUCTION("8160DF4C", ld1(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48)));
2101
+ TEST_INSTRUCTION("A120400C", ld1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5)));
2102
+ TEST_INSTRUCTION("A120DF0C", ld1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32)));
2103
+ TEST_INSTRUCTION("A120404C", ld1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5)));
2104
+ TEST_INSTRUCTION("A120DF4C", ld1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64)));
2105
+ TEST_INSTRUCTION("4174400C", ld1(v1.h4(), ptr(x2)));
2106
+ TEST_INSTRUCTION("4174DF0C", ld1(v1.h4(), ptr_post(x2, 8)));
2107
+ TEST_INSTRUCTION("4174404C", ld1(v1.h8(), ptr(x2)));
2108
+ TEST_INSTRUCTION("4174DF4C", ld1(v1.h8(), ptr_post(x2, 16)));
2109
+ TEST_INSTRUCTION("61A4400C", ld1(v1.h4(), v2.h4(), ptr(x3)));
2110
+ TEST_INSTRUCTION("61A4DF0C", ld1(v1.h4(), v2.h4(), ptr_post(x3, 16)));
2111
+ TEST_INSTRUCTION("61A4404C", ld1(v1.h8(), v2.h8(), ptr(x3)));
2112
+ TEST_INSTRUCTION("61A4DF4C", ld1(v1.h8(), v2.h8(), ptr_post(x3, 32)));
2113
+ TEST_INSTRUCTION("8164400C", ld1(v1.h4(), v2.h4(), v3.h4(), ptr(x4)));
2114
+ TEST_INSTRUCTION("8164DF0C", ld1(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24)));
2115
+ TEST_INSTRUCTION("8164404C", ld1(v1.h8(), v2.h8(), v3.h8(), ptr(x4)));
2116
+ TEST_INSTRUCTION("8164DF4C", ld1(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48)));
2117
+ TEST_INSTRUCTION("A124400C", ld1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5)));
2118
+ TEST_INSTRUCTION("A124DF0C", ld1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32)));
2119
+ TEST_INSTRUCTION("A124404C", ld1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5)));
2120
+ TEST_INSTRUCTION("A124DF4C", ld1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64)));
2121
+ TEST_INSTRUCTION("4178400C", ld1(v1.s2(), ptr(x2)));
2122
+ TEST_INSTRUCTION("4178DF0C", ld1(v1.s2(), ptr_post(x2, 8)));
2123
+ TEST_INSTRUCTION("4178404C", ld1(v1.s4(), ptr(x2)));
2124
+ TEST_INSTRUCTION("4178DF4C", ld1(v1.s4(), ptr_post(x2, 16)));
2125
+ TEST_INSTRUCTION("61A8400C", ld1(v1.s2(), v2.s2(), ptr(x3)));
2126
+ TEST_INSTRUCTION("61A8DF0C", ld1(v1.s2(), v2.s2(), ptr_post(x3, 16)));
2127
+ TEST_INSTRUCTION("61A8404C", ld1(v1.s4(), v2.s4(), ptr(x3)));
2128
+ TEST_INSTRUCTION("61A8DF4C", ld1(v1.s4(), v2.s4(), ptr_post(x3, 32)));
2129
+ TEST_INSTRUCTION("8168400C", ld1(v1.s2(), v2.s2(), v3.s2(), ptr(x4)));
2130
+ TEST_INSTRUCTION("8168DF0C", ld1(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24)));
2131
+ TEST_INSTRUCTION("8168404C", ld1(v1.s4(), v2.s4(), v3.s4(), ptr(x4)));
2132
+ TEST_INSTRUCTION("8168DF4C", ld1(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48)));
2133
+ TEST_INSTRUCTION("A128400C", ld1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5)));
2134
+ TEST_INSTRUCTION("A128DF0C", ld1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32)));
2135
+ TEST_INSTRUCTION("A128404C", ld1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5)));
2136
+ TEST_INSTRUCTION("A128DF4C", ld1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64)));
2137
+ TEST_INSTRUCTION("417C404C", ld1(v1.d2(), ptr(x2)));
2138
+ TEST_INSTRUCTION("417CDF4C", ld1(v1.d2(), ptr_post(x2, 16)));
2139
+ TEST_INSTRUCTION("61AC404C", ld1(v1.d2(), v2.d2(), ptr(x3)));
2140
+ TEST_INSTRUCTION("61ACDF4C", ld1(v1.d2(), v2.d2(), ptr_post(x3, 32)));
2141
+ TEST_INSTRUCTION("816C404C", ld1(v1.d2(), v2.d2(), v3.d2(), ptr(x4)));
2142
+ TEST_INSTRUCTION("816CDF4C", ld1(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48)));
2143
+ TEST_INSTRUCTION("A12C404C", ld1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5)));
2144
+ TEST_INSTRUCTION("A12CDF4C", ld1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64)));
2145
+ TEST_INSTRUCTION("41C0400D", ld1r(v1.b8(), ptr(x2)));
2146
+ TEST_INSTRUCTION("41C0DF0D", ld1r(v1.b8(), ptr_post(x2, 1)));
2147
+ TEST_INSTRUCTION("41C0CB0D", ld1r(v1.b8(), ptr_post(x2, x11)));
2148
+ TEST_INSTRUCTION("41C0404D", ld1r(v1.b16(), ptr(x2)));
2149
+ TEST_INSTRUCTION("41C0DF4D", ld1r(v1.b16(), ptr_post(x2, 1)));
2150
+ TEST_INSTRUCTION("41C0CB4D", ld1r(v1.b16(), ptr_post(x2, x11)));
2151
+ TEST_INSTRUCTION("41C4400D", ld1r(v1.h4(), ptr(x2)));
2152
+ TEST_INSTRUCTION("41C4DF0D", ld1r(v1.h4(), ptr_post(x2, 2)));
2153
+ TEST_INSTRUCTION("41C4CB0D", ld1r(v1.h4(), ptr_post(x2, x11)));
2154
+ TEST_INSTRUCTION("41C4404D", ld1r(v1.h8(), ptr(x2)));
2155
+ TEST_INSTRUCTION("41C4DF4D", ld1r(v1.h8(), ptr_post(x2, 2)));
2156
+ TEST_INSTRUCTION("41C4CB4D", ld1r(v1.h8(), ptr_post(x2, x11)));
2157
+ TEST_INSTRUCTION("41C8400D", ld1r(v1.s2(), ptr(x2)));
2158
+ TEST_INSTRUCTION("41C8DF0D", ld1r(v1.s2(), ptr_post(x2, 4)));
2159
+ TEST_INSTRUCTION("41C8CB0D", ld1r(v1.s2(), ptr_post(x2, x11)));
2160
+ TEST_INSTRUCTION("41C8404D", ld1r(v1.s4(), ptr(x2)));
2161
+ TEST_INSTRUCTION("41C8DF4D", ld1r(v1.s4(), ptr_post(x2, 4)));
2162
+ TEST_INSTRUCTION("41C8CB4D", ld1r(v1.s4(), ptr_post(x2, x11)));
2163
+ TEST_INSTRUCTION("41CC404D", ld1r(v1.d2(), ptr(x2)));
2164
+ TEST_INSTRUCTION("41CCDF4D", ld1r(v1.d2(), ptr_post(x2, 8)));
2165
+ TEST_INSTRUCTION("41CCCB4D", ld1r(v1.d2(), ptr_post(x2, x11)));
2166
+ TEST_INSTRUCTION("6100600D", ld2(v1.b(0), v2.b(0), ptr(x3)));
2167
+ TEST_INSTRUCTION("6100FF0D", ld2(v1.b(0), v2.b(0), ptr_post(x3, 2)));
2168
+ TEST_INSTRUCTION("6100EB0D", ld2(v1.b(0), v2.b(0), ptr_post(x3, x11)));
2169
+ TEST_INSTRUCTION("6140600D", ld2(v1.h(0), v2.h(0), ptr(x3)));
2170
+ TEST_INSTRUCTION("6140FF0D", ld2(v1.h(0), v2.h(0), ptr_post(x3, 4)));
2171
+ TEST_INSTRUCTION("6140EB0D", ld2(v1.h(0), v2.h(0), ptr_post(x3, x11)));
2172
+ TEST_INSTRUCTION("6180600D", ld2(v1.s(0), v2.s(0), ptr(x3)));
2173
+ TEST_INSTRUCTION("6180FF0D", ld2(v1.s(0), v2.s(0), ptr_post(x3, 8)));
2174
+ TEST_INSTRUCTION("6180EB0D", ld2(v1.s(0), v2.s(0), ptr_post(x3, x11)));
2175
+ TEST_INSTRUCTION("6184600D", ld2(v1.d(0), v2.d(0), ptr(x3)));
2176
+ TEST_INSTRUCTION("6184FF0D", ld2(v1.d(0), v2.d(0), ptr_post(x3, 16)));
2177
+ TEST_INSTRUCTION("6184EB0D", ld2(v1.d(0), v2.d(0), ptr_post(x3, x11)));
2178
+ TEST_INSTRUCTION("611C604D", ld2(v1.b(15), v2.b(15), ptr(x3)));
2179
+ TEST_INSTRUCTION("611CFF4D", ld2(v1.b(15), v2.b(15), ptr_post(x3, 2)));
2180
+ TEST_INSTRUCTION("611CEB4D", ld2(v1.b(15), v2.b(15), ptr_post(x3, x11)));
2181
+ TEST_INSTRUCTION("6158604D", ld2(v1.h(7), v2.h(7), ptr(x3)));
2182
+ TEST_INSTRUCTION("6158FF4D", ld2(v1.h(7), v2.h(7), ptr_post(x3, 4)));
2183
+ TEST_INSTRUCTION("6158EB4D", ld2(v1.h(7), v2.h(7), ptr_post(x3, x11)));
2184
+ TEST_INSTRUCTION("6190604D", ld2(v1.s(3), v2.s(3), ptr(x3)));
2185
+ TEST_INSTRUCTION("6190FF4D", ld2(v1.s(3), v2.s(3), ptr_post(x3, 8)));
2186
+ TEST_INSTRUCTION("6190EB4D", ld2(v1.s(3), v2.s(3), ptr_post(x3, x11)));
2187
+ TEST_INSTRUCTION("6184604D", ld2(v1.d(1), v2.d(1), ptr(x3)));
2188
+ TEST_INSTRUCTION("6184FF4D", ld2(v1.d(1), v2.d(1), ptr_post(x3, 16)));
2189
+ TEST_INSTRUCTION("6184EB4D", ld2(v1.d(1), v2.d(1), ptr_post(x3, x11)));
2190
+ TEST_INSTRUCTION("6180400C", ld2(v1.b8(), v2.b8(), ptr(x3)));
2191
+ TEST_INSTRUCTION("6180DF0C", ld2(v1.b8(), v2.b8(), ptr_post(x3, 16)));
2192
+ TEST_INSTRUCTION("6180CB0C", ld2(v1.b8(), v2.b8(), ptr_post(x3, x11)));
2193
+ TEST_INSTRUCTION("6180404C", ld2(v1.b16(), v2.b16(), ptr(x3)));
2194
+ TEST_INSTRUCTION("6180DF4C", ld2(v1.b16(), v2.b16(), ptr_post(x3, 32)));
2195
+ TEST_INSTRUCTION("6180CB4C", ld2(v1.b16(), v2.b16(), ptr_post(x3, x11)));
2196
+ TEST_INSTRUCTION("6184400C", ld2(v1.h4(), v2.h4(), ptr(x3)));
2197
+ TEST_INSTRUCTION("6184DF0C", ld2(v1.h4(), v2.h4(), ptr_post(x3, 16)));
2198
+ TEST_INSTRUCTION("6184CB0C", ld2(v1.h4(), v2.h4(), ptr_post(x3, x11)));
2199
+ TEST_INSTRUCTION("6184404C", ld2(v1.h8(), v2.h8(), ptr(x3)));
2200
+ TEST_INSTRUCTION("6184DF4C", ld2(v1.h8(), v2.h8(), ptr_post(x3, 32)));
2201
+ TEST_INSTRUCTION("6184CB4C", ld2(v1.h8(), v2.h8(), ptr_post(x3, x11)));
2202
+ TEST_INSTRUCTION("6188400C", ld2(v1.s2(), v2.s2(), ptr(x3)));
2203
+ TEST_INSTRUCTION("6188DF0C", ld2(v1.s2(), v2.s2(), ptr_post(x3, 16)));
2204
+ TEST_INSTRUCTION("6188CB0C", ld2(v1.s2(), v2.s2(), ptr_post(x3, x11)));
2205
+ TEST_INSTRUCTION("6188404C", ld2(v1.s4(), v2.s4(), ptr(x3)));
2206
+ TEST_INSTRUCTION("6188DF4C", ld2(v1.s4(), v2.s4(), ptr_post(x3, 32)));
2207
+ TEST_INSTRUCTION("6188CB4C", ld2(v1.s4(), v2.s4(), ptr_post(x3, x11)));
2208
+ TEST_INSTRUCTION("618C404C", ld2(v1.d2(), v2.d2(), ptr(x3)));
2209
+ TEST_INSTRUCTION("618CDF4C", ld2(v1.d2(), v2.d2(), ptr_post(x3, 32)));
2210
+ TEST_INSTRUCTION("618CCB4C", ld2(v1.d2(), v2.d2(), ptr_post(x3, x11)));
2211
+ TEST_INSTRUCTION("61C0600D", ld2r(v1.b8(), v2.b8(), ptr(x3)));
2212
+ TEST_INSTRUCTION("61C0FF0D", ld2r(v1.b8(), v2.b8(), ptr_post(x3, 2)));
2213
+ TEST_INSTRUCTION("61C0EB0D", ld2r(v1.b8(), v2.b8(), ptr_post(x3, x11)));
2214
+ TEST_INSTRUCTION("61C0604D", ld2r(v1.b16(), v2.b16(), ptr(x3)));
2215
+ TEST_INSTRUCTION("61C0FF4D", ld2r(v1.b16(), v2.b16(), ptr_post(x3, 2)));
2216
+ TEST_INSTRUCTION("61C0EB4D", ld2r(v1.b16(), v2.b16(), ptr_post(x3, x11)));
2217
+ TEST_INSTRUCTION("61C4600D", ld2r(v1.h4(), v2.h4(), ptr(x3)));
2218
+ TEST_INSTRUCTION("61C4FF0D", ld2r(v1.h4(), v2.h4(), ptr_post(x3, 4)));
2219
+ TEST_INSTRUCTION("61C4EB0D", ld2r(v1.h4(), v2.h4(), ptr_post(x3, x11)));
2220
+ TEST_INSTRUCTION("61C4604D", ld2r(v1.h8(), v2.h8(), ptr(x3)));
2221
+ TEST_INSTRUCTION("61C4FF4D", ld2r(v1.h8(), v2.h8(), ptr_post(x3, 4)));
2222
+ TEST_INSTRUCTION("61C4EB4D", ld2r(v1.h8(), v2.h8(), ptr_post(x3, x11)));
2223
+ TEST_INSTRUCTION("61C8600D", ld2r(v1.s2(), v2.s2(), ptr(x3)));
2224
+ TEST_INSTRUCTION("61C8FF0D", ld2r(v1.s2(), v2.s2(), ptr_post(x3, 8)));
2225
+ TEST_INSTRUCTION("61C8EB0D", ld2r(v1.s2(), v2.s2(), ptr_post(x3, x11)));
2226
+ TEST_INSTRUCTION("61C8604D", ld2r(v1.s4(), v2.s4(), ptr(x3)));
2227
+ TEST_INSTRUCTION("61C8FF4D", ld2r(v1.s4(), v2.s4(), ptr_post(x3, 8)));
2228
+ TEST_INSTRUCTION("61C8EB4D", ld2r(v1.s4(), v2.s4(), ptr_post(x3, x11)));
2229
+ TEST_INSTRUCTION("61CC604D", ld2r(v1.d2(), v2.d2(), ptr(x3)));
2230
+ TEST_INSTRUCTION("61CCFF4D", ld2r(v1.d2(), v2.d2(), ptr_post(x3, 16)));
2231
+ TEST_INSTRUCTION("61CCEB4D", ld2r(v1.d2(), v2.d2(), ptr_post(x3, x11)));
2232
+ TEST_INSTRUCTION("8120400D", ld3(v1.b(0), v2.b(0), v3.b(0), ptr(x4)));
2233
+ TEST_INSTRUCTION("8120DF0D", ld3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, 3)));
2234
+ TEST_INSTRUCTION("8120CB0D", ld3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, x11)));
2235
+ TEST_INSTRUCTION("8160400D", ld3(v1.h(0), v2.h(0), v3.h(0), ptr(x4)));
2236
+ TEST_INSTRUCTION("8160DF0D", ld3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, 6)));
2237
+ TEST_INSTRUCTION("8160CB0D", ld3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, x11)));
2238
+ TEST_INSTRUCTION("81A0400D", ld3(v1.s(0), v2.s(0), v3.s(0), ptr(x4)));
2239
+ TEST_INSTRUCTION("81A0DF0D", ld3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, 12)));
2240
+ TEST_INSTRUCTION("81A0CB0D", ld3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, x11)));
2241
+ TEST_INSTRUCTION("81A4400D", ld3(v1.d(0), v2.d(0), v3.d(0), ptr(x4)));
2242
+ TEST_INSTRUCTION("81A4DF0D", ld3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, 24)));
2243
+ TEST_INSTRUCTION("81A4CB0D", ld3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, x11)));
2244
+ TEST_INSTRUCTION("813C404D", ld3(v1.b(15), v2.b(15), v3.b(15), ptr(x4)));
2245
+ TEST_INSTRUCTION("813CDF4D", ld3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, 3)));
2246
+ TEST_INSTRUCTION("813CCB4D", ld3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, x11)));
2247
+ TEST_INSTRUCTION("8178404D", ld3(v1.h(7), v2.h(7), v3.h(7), ptr(x4)));
2248
+ TEST_INSTRUCTION("8178DF4D", ld3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, 6)));
2249
+ TEST_INSTRUCTION("8178CB4D", ld3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, x11)));
2250
+ TEST_INSTRUCTION("81B0404D", ld3(v1.s(3), v2.s(3), v3.s(3), ptr(x4)));
2251
+ TEST_INSTRUCTION("81B0DF4D", ld3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, 12)));
2252
+ TEST_INSTRUCTION("81B0CB4D", ld3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, x11)));
2253
+ TEST_INSTRUCTION("81A4404D", ld3(v1.d(1), v2.d(1), v3.d(1), ptr(x4)));
2254
+ TEST_INSTRUCTION("81A4DF4D", ld3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, 24)));
2255
+ TEST_INSTRUCTION("81A4CB4D", ld3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, x11)));
2256
+ TEST_INSTRUCTION("8140400C", ld3(v1.b8(), v2.b8(), v3.b8(), ptr(x4)));
2257
+ TEST_INSTRUCTION("8140DF0C", ld3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24)));
2258
+ TEST_INSTRUCTION("8140CB0C", ld3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, x11)));
2259
+ TEST_INSTRUCTION("8140404C", ld3(v1.b16(), v2.b16(), v3.b16(), ptr(x4)));
2260
+ TEST_INSTRUCTION("8140DF4C", ld3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48)));
2261
+ TEST_INSTRUCTION("8140CB4C", ld3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, x11)));
2262
+ TEST_INSTRUCTION("8144400C", ld3(v1.h4(), v2.h4(), v3.h4(), ptr(x4)));
2263
+ TEST_INSTRUCTION("8144DF0C", ld3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24)));
2264
+ TEST_INSTRUCTION("8144CB0C", ld3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, x11)));
2265
+ TEST_INSTRUCTION("8144404C", ld3(v1.h8(), v2.h8(), v3.h8(), ptr(x4)));
2266
+ TEST_INSTRUCTION("8144DF4C", ld3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48)));
2267
+ TEST_INSTRUCTION("8144CB4C", ld3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, x11)));
2268
+ TEST_INSTRUCTION("8148400C", ld3(v1.s2(), v2.s2(), v3.s2(), ptr(x4)));
2269
+ TEST_INSTRUCTION("8148DF0C", ld3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24)));
2270
+ TEST_INSTRUCTION("8148CB0C", ld3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, x11)));
2271
+ TEST_INSTRUCTION("8148404C", ld3(v1.s4(), v2.s4(), v3.s4(), ptr(x4)));
2272
+ TEST_INSTRUCTION("8148DF4C", ld3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48)));
2273
+ TEST_INSTRUCTION("8148CB4C", ld3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, x11)));
2274
+ TEST_INSTRUCTION("814C404C", ld3(v1.d2(), v2.d2(), v3.d2(), ptr(x4)));
2275
+ TEST_INSTRUCTION("814CDF4C", ld3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48)));
2276
+ TEST_INSTRUCTION("814CCB4C", ld3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, x11)));
2277
+ TEST_INSTRUCTION("81E0400D", ld3r(v1.b8(), v2.b8(), v3.b8(), ptr(x4)));
2278
+ TEST_INSTRUCTION("81E0DF0D", ld3r(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 3)));
2279
+ TEST_INSTRUCTION("81E0CB0D", ld3r(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, x11)));
2280
+ TEST_INSTRUCTION("81E0404D", ld3r(v1.b16(), v2.b16(), v3.b16(), ptr(x4)));
2281
+ TEST_INSTRUCTION("81E0DF4D", ld3r(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 3)));
2282
+ TEST_INSTRUCTION("81E0CB4D", ld3r(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, x11)));
2283
+ TEST_INSTRUCTION("81E4400D", ld3r(v1.h4(), v2.h4(), v3.h4(), ptr(x4)));
2284
+ TEST_INSTRUCTION("81E4DF0D", ld3r(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 6)));
2285
+ TEST_INSTRUCTION("81E4CB0D", ld3r(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, x11)));
2286
+ TEST_INSTRUCTION("81E4404D", ld3r(v1.h8(), v2.h8(), v3.h8(), ptr(x4)));
2287
+ TEST_INSTRUCTION("81E4DF4D", ld3r(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 6)));
2288
+ TEST_INSTRUCTION("81E4CB4D", ld3r(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, x11)));
2289
+ TEST_INSTRUCTION("81E8400D", ld3r(v1.s2(), v2.s2(), v3.s2(), ptr(x4)));
2290
+ TEST_INSTRUCTION("81E8DF0D", ld3r(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 12)));
2291
+ TEST_INSTRUCTION("81E8CB0D", ld3r(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, x11)));
2292
+ TEST_INSTRUCTION("81E8404D", ld3r(v1.s4(), v2.s4(), v3.s4(), ptr(x4)));
2293
+ TEST_INSTRUCTION("81E8DF4D", ld3r(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 12)));
2294
+ TEST_INSTRUCTION("81E8CB4D", ld3r(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, x11)));
2295
+ TEST_INSTRUCTION("81EC404D", ld3r(v1.d2(), v2.d2(), v3.d2(), ptr(x4)));
2296
+ TEST_INSTRUCTION("81ECDF4D", ld3r(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 24)));
2297
+ TEST_INSTRUCTION("81ECCB4D", ld3r(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, x11)));
2298
+ TEST_INSTRUCTION("A120600D", ld4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr(x5)));
2299
+ TEST_INSTRUCTION("A120FF0D", ld4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, 4)));
2300
+ TEST_INSTRUCTION("A120EB0D", ld4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, x11)));
2301
+ TEST_INSTRUCTION("A160600D", ld4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr(x5)));
2302
+ TEST_INSTRUCTION("A160FF0D", ld4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, 8)));
2303
+ TEST_INSTRUCTION("A160EB0D", ld4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, x11)));
2304
+ TEST_INSTRUCTION("A1A0600D", ld4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr(x5)));
2305
+ TEST_INSTRUCTION("A1A0FF0D", ld4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, 16)));
2306
+ TEST_INSTRUCTION("A1A0EB0D", ld4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, x11)));
2307
+ TEST_INSTRUCTION("A1A4600D", ld4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr(x5)));
2308
+ TEST_INSTRUCTION("A1A4FF0D", ld4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, 32)));
2309
+ TEST_INSTRUCTION("A1A4EB0D", ld4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, x11)));
2310
+ TEST_INSTRUCTION("A13C604D", ld4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr(x5)));
2311
+ TEST_INSTRUCTION("A13CFF4D", ld4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, 4)));
2312
+ TEST_INSTRUCTION("A13CEB4D", ld4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, x11)));
2313
+ TEST_INSTRUCTION("A178604D", ld4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr(x5)));
2314
+ TEST_INSTRUCTION("A178FF4D", ld4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, 8)));
2315
+ TEST_INSTRUCTION("A178EB4D", ld4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, x11)));
2316
+ TEST_INSTRUCTION("A1B0604D", ld4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr(x5)));
2317
+ TEST_INSTRUCTION("A1B0FF4D", ld4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, 16)));
2318
+ TEST_INSTRUCTION("A1B0EB4D", ld4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, x11)));
2319
+ TEST_INSTRUCTION("A1A4604D", ld4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr(x5)));
2320
+ TEST_INSTRUCTION("A1A4FF4D", ld4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, 32)));
2321
+ TEST_INSTRUCTION("A1A4EB4D", ld4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, x11)));
2322
+ TEST_INSTRUCTION("A100400C", ld4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5)));
2323
+ TEST_INSTRUCTION("A100DF0C", ld4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32)));
2324
+ TEST_INSTRUCTION("A100CB0C", ld4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, x11)));
2325
+ TEST_INSTRUCTION("A100404C", ld4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5)));
2326
+ TEST_INSTRUCTION("A100DF4C", ld4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64)));
2327
+ TEST_INSTRUCTION("A100CB4C", ld4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, x11)));
2328
+ TEST_INSTRUCTION("A104400C", ld4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5)));
2329
+ TEST_INSTRUCTION("A104DF0C", ld4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32)));
2330
+ TEST_INSTRUCTION("A104CB0C", ld4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, x11)));
2331
+ TEST_INSTRUCTION("A104404C", ld4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5)));
2332
+ TEST_INSTRUCTION("A104DF4C", ld4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64)));
2333
+ TEST_INSTRUCTION("A104CB4C", ld4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, x11)));
2334
+ TEST_INSTRUCTION("A108400C", ld4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5)));
2335
+ TEST_INSTRUCTION("A108DF0C", ld4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32)));
2336
+ TEST_INSTRUCTION("A108CB0C", ld4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, x11)));
2337
+ TEST_INSTRUCTION("A108404C", ld4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5)));
2338
+ TEST_INSTRUCTION("A108DF4C", ld4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64)));
2339
+ TEST_INSTRUCTION("A108CB4C", ld4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, x11)));
2340
+ TEST_INSTRUCTION("A10C404C", ld4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5)));
2341
+ TEST_INSTRUCTION("A10CDF4C", ld4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64)));
2342
+ TEST_INSTRUCTION("A10CCB4C", ld4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, x11)));
2343
+ TEST_INSTRUCTION("A1E0600D", ld4r(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5)));
2344
+ TEST_INSTRUCTION("A1E0FF0D", ld4r(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 4)));
2345
+ TEST_INSTRUCTION("A1E0EB0D", ld4r(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, x11)));
2346
+ TEST_INSTRUCTION("A1E0604D", ld4r(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5)));
2347
+ TEST_INSTRUCTION("A1E0FF4D", ld4r(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 4)));
2348
+ TEST_INSTRUCTION("A1E0EB4D", ld4r(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, x11)));
2349
+ TEST_INSTRUCTION("A1E4600D", ld4r(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5)));
2350
+ TEST_INSTRUCTION("A1E4FF0D", ld4r(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 8)));
2351
+ TEST_INSTRUCTION("A1E4EB0D", ld4r(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, x11)));
2352
+ TEST_INSTRUCTION("A1E4604D", ld4r(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5)));
2353
+ TEST_INSTRUCTION("A1E4FF4D", ld4r(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 8)));
2354
+ TEST_INSTRUCTION("A1E4EB4D", ld4r(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, x11)));
2355
+ TEST_INSTRUCTION("A1E8600D", ld4r(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5)));
2356
+ TEST_INSTRUCTION("A1E8FF0D", ld4r(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 16)));
2357
+ TEST_INSTRUCTION("A1E8EB0D", ld4r(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, x11)));
2358
+ TEST_INSTRUCTION("A1E8604D", ld4r(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5)));
2359
+ TEST_INSTRUCTION("A1E8FF4D", ld4r(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 16)));
2360
+ TEST_INSTRUCTION("A1E8EB4D", ld4r(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, x11)));
2361
+ TEST_INSTRUCTION("A1EC604D", ld4r(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5)));
2362
+ TEST_INSTRUCTION("A1ECFF4D", ld4r(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 32)));
2363
+ TEST_INSTRUCTION("A1ECEB4D", ld4r(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, x11)));
2364
+ TEST_INSTRUCTION("8109402C", ldnp(s1, s2, ptr(x12)));
2365
+ TEST_INSTRUCTION("8189402C", ldnp(s1, s2, ptr(x12, 4)));
2366
+ TEST_INSTRUCTION("8109702C", ldnp(s1, s2, ptr(x12, -128)));
2367
+ TEST_INSTRUCTION("E10B402C", ldnp(s1, s2, ptr(sp)));
2368
+ TEST_INSTRUCTION("E18B402C", ldnp(s1, s2, ptr(sp, 4)));
2369
+ TEST_INSTRUCTION("E10B502C", ldnp(s1, s2, ptr(sp, 128)));
2370
+ TEST_INSTRUCTION("8109406C", ldnp(d1, d2, ptr(x12)));
2371
+ TEST_INSTRUCTION("8189406C", ldnp(d1, d2, ptr(x12, 8)));
2372
+ TEST_INSTRUCTION("8109786C", ldnp(d1, d2, ptr(x12, -128)));
2373
+ TEST_INSTRUCTION("E10B406C", ldnp(d1, d2, ptr(sp)));
2374
+ TEST_INSTRUCTION("E18B406C", ldnp(d1, d2, ptr(sp, 8)));
2375
+ TEST_INSTRUCTION("E10B486C", ldnp(d1, d2, ptr(sp, 128)));
2376
+ TEST_INSTRUCTION("810940AC", ldnp(q1, q2, ptr(x12)));
2377
+ TEST_INSTRUCTION("818940AC", ldnp(q1, q2, ptr(x12, 16)));
2378
+ TEST_INSTRUCTION("81097CAC", ldnp(q1, q2, ptr(x12, -128)));
2379
+ TEST_INSTRUCTION("E10B40AC", ldnp(q1, q2, ptr(sp)));
2380
+ TEST_INSTRUCTION("E18B40AC", ldnp(q1, q2, ptr(sp, 16)));
2381
+ TEST_INSTRUCTION("E10B44AC", ldnp(q1, q2, ptr(sp, 128)));
2382
+ TEST_INSTRUCTION("8109402D", ldp(s1, s2, ptr(x12)));
2383
+ TEST_INSTRUCTION("8189402D", ldp(s1, s2, ptr(x12, 4)));
2384
+ TEST_INSTRUCTION("8109702D", ldp(s1, s2, ptr(x12, -128)));
2385
+ TEST_INSTRUCTION("8189C02D", ldp(s1, s2, ptr_pre(x12, 4)));
2386
+ TEST_INSTRUCTION("8189C02C", ldp(s1, s2, ptr_post(x12, 4)));
2387
+ TEST_INSTRUCTION("E10B402D", ldp(s1, s2, ptr(sp)));
2388
+ TEST_INSTRUCTION("E18B402D", ldp(s1, s2, ptr(sp, 4)));
2389
+ TEST_INSTRUCTION("E10B502D", ldp(s1, s2, ptr(sp, 128)));
2390
+ TEST_INSTRUCTION("E18BC02C", ldp(s1, s2, ptr_post(sp, 4)));
2391
+ TEST_INSTRUCTION("E18BC02D", ldp(s1, s2, ptr_pre(sp, 4)));
2392
+ TEST_INSTRUCTION("8109406D", ldp(d1, d2, ptr(x12)));
2393
+ TEST_INSTRUCTION("8189406D", ldp(d1, d2, ptr(x12, 8)));
2394
+ TEST_INSTRUCTION("8109786D", ldp(d1, d2, ptr(x12, -128)));
2395
+ TEST_INSTRUCTION("8189C06D", ldp(d1, d2, ptr_pre(x12, 8)));
2396
+ TEST_INSTRUCTION("8189C06C", ldp(d1, d2, ptr_post(x12, 8)));
2397
+ TEST_INSTRUCTION("E10B406D", ldp(d1, d2, ptr(sp)));
2398
+ TEST_INSTRUCTION("E18B406D", ldp(d1, d2, ptr(sp, 8)));
2399
+ TEST_INSTRUCTION("E10B486D", ldp(d1, d2, ptr(sp, 128)));
2400
+ TEST_INSTRUCTION("E18BC06D", ldp(d1, d2, ptr_pre(sp, 8)));
2401
+ TEST_INSTRUCTION("E18BC06C", ldp(d1, d2, ptr_post(sp, 8)));
2402
+ TEST_INSTRUCTION("810940AD", ldp(q1, q2, ptr(x12)));
2403
+ TEST_INSTRUCTION("818940AD", ldp(q1, q2, ptr(x12, 16)));
2404
+ TEST_INSTRUCTION("81097CAD", ldp(q1, q2, ptr(x12, -128)));
2405
+ TEST_INSTRUCTION("8189C0AD", ldp(q1, q2, ptr_pre(x12, 16)));
2406
+ TEST_INSTRUCTION("8189C0AC", ldp(q1, q2, ptr_post(x12, 16)));
2407
+ TEST_INSTRUCTION("E10B40AD", ldp(q1, q2, ptr(sp)));
2408
+ TEST_INSTRUCTION("E18B40AD", ldp(q1, q2, ptr(sp, 16)));
2409
+ TEST_INSTRUCTION("E10B44AD", ldp(q1, q2, ptr(sp, 128)));
2410
+ TEST_INSTRUCTION("E18BC0AD", ldp(q1, q2, ptr_pre(sp, 16)));
2411
+ TEST_INSTRUCTION("E18BC0AC", ldp(q1, q2, ptr_post(sp, 16)));
2412
+ TEST_INSTRUCTION("4100403D", ldr(b1, ptr(x2)));
2413
+ TEST_INSTRUCTION("4114403C", ldr(b1, ptr_post(x2, 1)));
2414
+ TEST_INSTRUCTION("4104403D", ldr(b1, ptr(x2, 1)));
2415
+ TEST_INSTRUCTION("411C403C", ldr(b1, ptr_pre(x2, 1)));
2416
+ TEST_INSTRUCTION("4114483C", ldr(b1, ptr_post(x2, 129)));
2417
+ TEST_INSTRUCTION("4100407D", ldr(h1, ptr(x2)));
2418
+ TEST_INSTRUCTION("4124407C", ldr(h1, ptr_post(x2, 2)));
2419
+ TEST_INSTRUCTION("4104407D", ldr(h1, ptr(x2, 2)));
2420
+ TEST_INSTRUCTION("412C407C", ldr(h1, ptr_pre(x2, 2)));
2421
+ TEST_INSTRUCTION("4124487C", ldr(h1, ptr_post(x2, 130)));
2422
+ TEST_INSTRUCTION("410040BD", ldr(s1, ptr(x2)));
2423
+ TEST_INSTRUCTION("414440BC", ldr(s1, ptr_post(x2, 4)));
2424
+ TEST_INSTRUCTION("410440BD", ldr(s1, ptr(x2, 4)));
2425
+ TEST_INSTRUCTION("414C40BC", ldr(s1, ptr_pre(x2, 4)));
2426
+ TEST_INSTRUCTION("414448BC", ldr(s1, ptr_post(x2, 132)));
2427
+ TEST_INSTRUCTION("410040FD", ldr(d1, ptr(x2)));
2428
+ TEST_INSTRUCTION("418440FC", ldr(d1, ptr_post(x2, 8)));
2429
+ TEST_INSTRUCTION("410440FD", ldr(d1, ptr(x2, 8)));
2430
+ TEST_INSTRUCTION("418C40FC", ldr(d1, ptr_pre(x2, 8)));
2431
+ TEST_INSTRUCTION("414448FC", ldr(d1, ptr_post(x2, 132)));
2432
+ TEST_INSTRUCTION("4168633C", ldr(b1, ptr(x2, x3)));
2433
+ TEST_INSTRUCTION("4148633C", ldr(b1, ptr(x2, w3, uxtw(0))));
2434
+ TEST_INSTRUCTION("41C8633C", ldr(b1, ptr(x2, w3, sxtw(0))));
2435
+ TEST_INSTRUCTION("4168637C", ldr(h1, ptr(x2, x3)));
2436
+ TEST_INSTRUCTION("4178637C", ldr(h1, ptr(x2, x3, lsl(1))));
2437
+ TEST_INSTRUCTION("4148637C", ldr(h1, ptr(x2, w3, uxtw(0))));
2438
+ TEST_INSTRUCTION("4158637C", ldr(h1, ptr(x2, w3, uxtw(1))));
2439
+ TEST_INSTRUCTION("41C8637C", ldr(h1, ptr(x2, w3, sxtw(0))));
2440
+ TEST_INSTRUCTION("41D8637C", ldr(h1, ptr(x2, w3, sxtw(1))));
2441
+ TEST_INSTRUCTION("416863BC", ldr(s1, ptr(x2, x3)));
2442
+ TEST_INSTRUCTION("417863BC", ldr(s1, ptr(x2, x3, lsl(2))));
2443
+ TEST_INSTRUCTION("414863BC", ldr(s1, ptr(x2, w3, uxtw(0))));
2444
+ TEST_INSTRUCTION("415863BC", ldr(s1, ptr(x2, w3, uxtw(2))));
2445
+ TEST_INSTRUCTION("41C863BC", ldr(s1, ptr(x2, w3, sxtw(0))));
2446
+ TEST_INSTRUCTION("41D863BC", ldr(s1, ptr(x2, w3, sxtw(2))));
2447
+ TEST_INSTRUCTION("416863FC", ldr(d1, ptr(x2, x3)));
2448
+ TEST_INSTRUCTION("417863FC", ldr(d1, ptr(x2, x3, lsl(3))));
2449
+ TEST_INSTRUCTION("414863FC", ldr(d1, ptr(x2, w3, uxtw(0))));
2450
+ TEST_INSTRUCTION("415863FC", ldr(d1, ptr(x2, w3, uxtw(3))));
2451
+ TEST_INSTRUCTION("41C863FC", ldr(d1, ptr(x2, w3, sxtw(0))));
2452
+ TEST_INSTRUCTION("41D863FC", ldr(d1, ptr(x2, w3, sxtw(3))));
2453
+ TEST_INSTRUCTION("4104403D", ldr(b1, ptr(x2, 1)));
2454
+ TEST_INSTRUCTION("41F05F3C", ldr(b1, ptr(x2, -1))); // LDUR
2455
+ TEST_INSTRUCTION("4110407C", ldr(h1, ptr(x2, 1))); // LDUR
2456
+ TEST_INSTRUCTION("41F05F7C", ldr(h1, ptr(x2, -1))); // LDUR
2457
+ TEST_INSTRUCTION("411040BC", ldr(s1, ptr(x2, 1))); // LDUR
2458
+ TEST_INSTRUCTION("41F05FBC", ldr(s1, ptr(x2, -1))); // LDUR
2459
+ TEST_INSTRUCTION("411040FC", ldr(d1, ptr(x2, 1))); // LDUR
2460
+ TEST_INSTRUCTION("41F05FFC", ldr(d1, ptr(x2, -1))); // LDUR
2461
+ TEST_INSTRUCTION("8101403C", ldur(b1, ptr(x12)));
2462
+ TEST_INSTRUCTION("8131403C", ldur(b1, ptr(x12, 3)));
2463
+ TEST_INSTRUCTION("8131463C", ldur(b1, ptr(x12, 99)));
2464
+ TEST_INSTRUCTION("81F14F3C", ldur(b1, ptr(x12, 255)));
2465
+ TEST_INSTRUCTION("8101503C", ldur(b1, ptr(x12, -256)));
2466
+ TEST_INSTRUCTION("E103403C", ldur(b1, ptr(sp)));
2467
+ TEST_INSTRUCTION("E153483C", ldur(b1, ptr(sp, 133)));
2468
+ TEST_INSTRUCTION("8101407C", ldur(h1, ptr(x12)));
2469
+ TEST_INSTRUCTION("8131407C", ldur(h1, ptr(x12, 3)));
2470
+ TEST_INSTRUCTION("8131467C", ldur(h1, ptr(x12, 99)));
2471
+ TEST_INSTRUCTION("81F14F7C", ldur(h1, ptr(x12, 255)));
2472
+ TEST_INSTRUCTION("8101507C", ldur(h1, ptr(x12, -256)));
2473
+ TEST_INSTRUCTION("E103407C", ldur(h1, ptr(sp)));
2474
+ TEST_INSTRUCTION("E153487C", ldur(h1, ptr(sp, 133)));
2475
+ TEST_INSTRUCTION("810140BC", ldur(s1, ptr(x12)));
2476
+ TEST_INSTRUCTION("813140BC", ldur(s1, ptr(x12, 3)));
2477
+ TEST_INSTRUCTION("813146BC", ldur(s1, ptr(x12, 99)));
2478
+ TEST_INSTRUCTION("81F14FBC", ldur(s1, ptr(x12, 255)));
2479
+ TEST_INSTRUCTION("810150BC", ldur(s1, ptr(x12, -256)));
2480
+ TEST_INSTRUCTION("E10340BC", ldur(s1, ptr(sp)));
2481
+ TEST_INSTRUCTION("E15348BC", ldur(s1, ptr(sp, 133)));
2482
+ TEST_INSTRUCTION("810140FC", ldur(d1, ptr(x12)));
2483
+ TEST_INSTRUCTION("813140FC", ldur(d1, ptr(x12, 3)));
2484
+ TEST_INSTRUCTION("813146FC", ldur(d1, ptr(x12, 99)));
2485
+ TEST_INSTRUCTION("81F14FFC", ldur(d1, ptr(x12, 255)));
2486
+ TEST_INSTRUCTION("810150FC", ldur(d1, ptr(x12, -256)));
2487
+ TEST_INSTRUCTION("E10340FC", ldur(d1, ptr(sp)));
2488
+ TEST_INSTRUCTION("E15348FC", ldur(d1, ptr(sp, 133)));
2489
+ TEST_INSTRUCTION("8101C03C", ldur(q1, ptr(x12)));
2490
+ TEST_INSTRUCTION("8131C03C", ldur(q1, ptr(x12, 3)));
2491
+ TEST_INSTRUCTION("8131C63C", ldur(q1, ptr(x12, 99)));
2492
+ TEST_INSTRUCTION("81F1CF3C", ldur(q1, ptr(x12, 255)));
2493
+ TEST_INSTRUCTION("8101D03C", ldur(q1, ptr(x12, -256)));
2494
+ TEST_INSTRUCTION("E103C03C", ldur(q1, ptr(sp)));
2495
+ TEST_INSTRUCTION("E153C83C", ldur(q1, ptr(sp, 133)));
2496
+ TEST_INSTRUCTION("4194230E", mla(v1.b8(), v2.b8(), v3.b8()));
2497
+ TEST_INSTRUCTION("4194630E", mla(v1.h4(), v2.h4(), v3.h4()));
2498
+ TEST_INSTRUCTION("4194A30E", mla(v1.s2(), v2.s2(), v3.s2()));
2499
+ TEST_INSTRUCTION("4194234E", mla(v1.b16(), v2.b16(), v3.b16()));
2500
+ TEST_INSTRUCTION("4194634E", mla(v1.h8(), v2.h8(), v3.h8()));
2501
+ TEST_INSTRUCTION("4194A34E", mla(v1.s4(), v2.s4(), v3.s4()));
2502
+ TEST_INSTRUCTION("4100432F", mla(v1.h4(), v2.h4(), v3.h(0)));
2503
+ TEST_INSTRUCTION("4100532F", mla(v1.h4(), v2.h4(), v3.h(1)));
2504
+ TEST_INSTRUCTION("4100632F", mla(v1.h4(), v2.h4(), v3.h(2)));
2505
+ TEST_INSTRUCTION("4100732F", mla(v1.h4(), v2.h4(), v3.h(3)));
2506
+ TEST_INSTRUCTION("4108436F", mla(v1.h8(), v2.h8(), v3.h(4)));
2507
+ TEST_INSTRUCTION("4108536F", mla(v1.h8(), v2.h8(), v3.h(5)));
2508
+ TEST_INSTRUCTION("4108636F", mla(v1.h8(), v2.h8(), v3.h(6)));
2509
+ TEST_INSTRUCTION("4108736F", mla(v1.h8(), v2.h8(), v3.h(7)));
2510
+ TEST_INSTRUCTION("4100832F", mla(v1.s2(), v2.s2(), v3.s(0)));
2511
+ TEST_INSTRUCTION("4100A32F", mla(v1.s2(), v2.s2(), v3.s(1)));
2512
+ TEST_INSTRUCTION("4108836F", mla(v1.s4(), v2.s4(), v3.s(2)));
2513
+ TEST_INSTRUCTION("4108A36F", mla(v1.s4(), v2.s4(), v3.s(3)));
2514
+ TEST_INSTRUCTION("4194232E", mls(v1.b8(), v2.b8(), v3.b8()));
2515
+ TEST_INSTRUCTION("4194632E", mls(v1.h4(), v2.h4(), v3.h4()));
2516
+ TEST_INSTRUCTION("4194A32E", mls(v1.s2(), v2.s2(), v3.s2()));
2517
+ TEST_INSTRUCTION("4194236E", mls(v1.b16(), v2.b16(), v3.b16()));
2518
+ TEST_INSTRUCTION("4194636E", mls(v1.h8(), v2.h8(), v3.h8()));
2519
+ TEST_INSTRUCTION("4194A36E", mls(v1.s4(), v2.s4(), v3.s4()));
2520
+ TEST_INSTRUCTION("4140432F", mls(v1.h4(), v2.h4(), v3.h(0)));
2521
+ TEST_INSTRUCTION("4140532F", mls(v1.h4(), v2.h4(), v3.h(1)));
2522
+ TEST_INSTRUCTION("4140632F", mls(v1.h4(), v2.h4(), v3.h(2)));
2523
+ TEST_INSTRUCTION("4140732F", mls(v1.h4(), v2.h4(), v3.h(3)));
2524
+ TEST_INSTRUCTION("4148436F", mls(v1.h8(), v2.h8(), v3.h(4)));
2525
+ TEST_INSTRUCTION("4148536F", mls(v1.h8(), v2.h8(), v3.h(5)));
2526
+ TEST_INSTRUCTION("4148636F", mls(v1.h8(), v2.h8(), v3.h(6)));
2527
+ TEST_INSTRUCTION("4148736F", mls(v1.h8(), v2.h8(), v3.h(7)));
2528
+ TEST_INSTRUCTION("4140832F", mls(v1.s2(), v2.s2(), v3.s(0)));
2529
+ TEST_INSTRUCTION("4140A32F", mls(v1.s2(), v2.s2(), v3.s(1)));
2530
+ TEST_INSTRUCTION("4148836F", mls(v1.s4(), v2.s4(), v3.s(2)));
2531
+ TEST_INSTRUCTION("4148A36F", mls(v1.s4(), v2.s4(), v3.s(3)));
2532
+ TEST_INSTRUCTION("4F04035E", mov(b15, v2.b(1)));
2533
+ TEST_INSTRUCTION("4F04065E", mov(h15, v2.h(1)));
2534
+ TEST_INSTRUCTION("4F040C5E", mov(s15, v2.s(1)));
2535
+ TEST_INSTRUCTION("4F04185E", mov(d15, v2.d(1)));
2536
+ TEST_INSTRUCTION("411C014E", mov(v1.b(0), w2));
2537
+ TEST_INSTRUCTION("411C074E", mov(v1.b(3), w2));
2538
+ TEST_INSTRUCTION("411C0D4E", mov(v1.b(6), w2));
2539
+ TEST_INSTRUCTION("411C134E", mov(v1.b(9), w2));
2540
+ TEST_INSTRUCTION("411C1F4E", mov(v1.b(15), w2));
2541
+ TEST_INSTRUCTION("411C024E", mov(v1.h(0), w2));
2542
+ TEST_INSTRUCTION("411C0E4E", mov(v1.h(3), w2));
2543
+ TEST_INSTRUCTION("411C1E4E", mov(v1.h(7), w2));
2544
+ TEST_INSTRUCTION("411C044E", mov(v1.s(0), w2));
2545
+ TEST_INSTRUCTION("411C0C4E", mov(v1.s(1), w2));
2546
+ TEST_INSTRUCTION("411C144E", mov(v1.s(2), w2));
2547
+ TEST_INSTRUCTION("411C1C4E", mov(v1.s(3), w2));
2548
+ TEST_INSTRUCTION("411C084E", mov(v1.d(0), x2));
2549
+ TEST_INSTRUCTION("411C184E", mov(v1.d(1), x2));
2550
+ TEST_INSTRUCTION("417C016E", mov(v1.b(0), v2.b(15)));
2551
+ TEST_INSTRUCTION("4174036E", mov(v1.b(1), v2.b(14)));
2552
+ TEST_INSTRUCTION("4174026E", mov(v1.h(0), v2.h(7)));
2553
+ TEST_INSTRUCTION("4164066E", mov(v1.h(1), v2.h(6)));
2554
+ TEST_INSTRUCTION("4164046E", mov(v1.s(0), v2.s(3)));
2555
+ TEST_INSTRUCTION("41440C6E", mov(v1.s(1), v2.s(2)));
2556
+ TEST_INSTRUCTION("4144086E", mov(v1.d(0), v2.d(1)));
2557
+ TEST_INSTRUCTION("4104186E", mov(v1.d(1), v2.d(0)));
2558
+ TEST_INSTRUCTION("41E5010F", movi(v1.b8(), 42));
2559
+ TEST_INSTRUCTION("4185010F", movi(v1.h4(), 42));
2560
+ TEST_INSTRUCTION("4105010F", movi(v1.s2(), 42));
2561
+ TEST_INSTRUCTION("C1E5022F", movi(d1, 0x00FF0000FFFFFF00u));
2562
+ TEST_INSTRUCTION("41E5014F", movi(v1.b16(), 42));
2563
+ TEST_INSTRUCTION("4185014F", movi(v1.h8(), 42));
2564
+ TEST_INSTRUCTION("4105014F", movi(v1.s4(), 42));
2565
+ TEST_INSTRUCTION("E167074F", movi(v1.s4(), 0xFF, lsl(24)));
2566
+ TEST_INSTRUCTION("E1D7074F", movi(v1.s4(), 0xFF, msl(16)));
2567
+ TEST_INSTRUCTION("C1E5026F", movi(v1.d2(), 0x00FF0000FFFFFF00u));
2568
+ TEST_INSTRUCTION("419C230E", mul(v1.b8(), v2.b8(), v3.b8()));
2569
+ TEST_INSTRUCTION("419C630E", mul(v1.h4(), v2.h4(), v3.h4()));
2570
+ TEST_INSTRUCTION("419CA30E", mul(v1.s2(), v2.s2(), v3.s2()));
2571
+ TEST_INSTRUCTION("419C234E", mul(v1.b16(), v2.b16(), v3.b16()));
2572
+ TEST_INSTRUCTION("419C634E", mul(v1.h8(), v2.h8(), v3.h8()));
2573
+ TEST_INSTRUCTION("419CA34E", mul(v1.s4(), v2.s4(), v3.s4()));
2574
+ TEST_INSTRUCTION("4158202E", mvn(v1.b8(), v2.b8()));
2575
+ TEST_INSTRUCTION("4158206E", mvn(v1.b16(), v2.b16()));
2576
+ TEST_INSTRUCTION("4185012F", mvni(v1.h4(), 42));
2577
+ TEST_INSTRUCTION("4105012F", mvni(v1.s2(), 42));
2578
+ TEST_INSTRUCTION("4185016F", mvni(v1.h8(), 42));
2579
+ TEST_INSTRUCTION("4105016F", mvni(v1.s4(), 42));
2580
+ TEST_INSTRUCTION("41B8202E", neg(v1.b8(), v2.b8()));
2581
+ TEST_INSTRUCTION("41B8602E", neg(v1.h4(), v2.h4()));
2582
+ TEST_INSTRUCTION("41B8A02E", neg(v1.s2(), v2.s2()));
2583
+ TEST_INSTRUCTION("41B8E07E", neg(d1, d2));
2584
+ TEST_INSTRUCTION("41B8206E", neg(v1.b16(), v2.b16()));
2585
+ TEST_INSTRUCTION("41B8606E", neg(v1.h8(), v2.h8()));
2586
+ TEST_INSTRUCTION("41B8A06E", neg(v1.s4(), v2.s4()));
2587
+ TEST_INSTRUCTION("41B8E06E", neg(v1.d2(), v2.d2()));
2588
+ TEST_INSTRUCTION("4158202E", not_(v1.b8(), v2.b8()));
2589
+ TEST_INSTRUCTION("4158206E", not_(v1.b16(), v2.b16()));
2590
+ TEST_INSTRUCTION("411CE30E", orn(v1.b8(), v2.b8(), v3.b8()));
2591
+ TEST_INSTRUCTION("411CE34E", orn(v1.b16(), v2.b16(), v3.b16()));
2592
+ TEST_INSTRUCTION("411CA30E", orr(v1.b8(), v2.b8(), v3.b8()));
2593
+ TEST_INSTRUCTION("411CA34E", orr(v1.b16(), v2.b16(), v3.b16()));
2594
+ TEST_INSTRUCTION("E197070F", orr(v1.h4(), 255));
2595
+ TEST_INSTRUCTION("E1B7070F", orr(v1.h4(), 255, lsl(8)));
2596
+ TEST_INSTRUCTION("E197074F", orr(v1.h8(), 255));
2597
+ TEST_INSTRUCTION("E1B7074F", orr(v1.h8(), 255, lsl(8)));
2598
+ TEST_INSTRUCTION("E117070F", orr(v1.s2(), 255));
2599
+ TEST_INSTRUCTION("E137070F", orr(v1.s2(), 255, lsl(8)));
2600
+ TEST_INSTRUCTION("E117074F", orr(v1.s4(), 255));
2601
+ TEST_INSTRUCTION("E177074F", orr(v1.s4(), 255, lsl(24)));
2602
+ TEST_INSTRUCTION("419C232E", pmul(v1.b8(), v2.b8(), v3.b8()));
2603
+ TEST_INSTRUCTION("419C236E", pmul(v1.b16(), v2.b16(), v3.b16()));
2604
+ TEST_INSTRUCTION("41E0230E", pmull(v1.h8(), v2.b8(), v3.b8()));
2605
+ TEST_INSTRUCTION("41E0E30E", pmull(q1, d2, d3));
2606
+ TEST_INSTRUCTION("41E0234E", pmull2(v1.h8(), v2.b16(), v3.b16()));
2607
+ TEST_INSTRUCTION("41E0E34E", pmull2(q1, v2.d2(), v3.d2()));
2608
+ TEST_INSTRUCTION("4140232E", raddhn(v1.b8(), v2.h8(), v3.h8()));
2609
+ TEST_INSTRUCTION("4140632E", raddhn(v1.h4(), v2.s4(), v3.s4()));
2610
+ TEST_INSTRUCTION("4140A32E", raddhn(v1.s2(), v2.d2(), v3.d2()));
2611
+ TEST_INSTRUCTION("4140236E", raddhn2(v1.b16(), v2.h8(), v3.h8()));
2612
+ TEST_INSTRUCTION("4140636E", raddhn2(v1.h8(), v2.s4(), v3.s4()));
2613
+ TEST_INSTRUCTION("4140A36E", raddhn2(v1.s4(), v2.d2(), v3.d2()));
2614
+ TEST_INSTRUCTION("418C63CE", rax1(v1.d2(), v2.d2(), v3.d2()));
2615
+ TEST_INSTRUCTION("4158602E", rbit(v1.b8(), v2.b8()));
2616
+ TEST_INSTRUCTION("4158606E", rbit(v1.b16(), v2.b16()));
2617
+ TEST_INSTRUCTION("4118200E", rev16(v1.b8(), v2.b8()));
2618
+ TEST_INSTRUCTION("4118204E", rev16(v1.b16(), v2.b16()));
2619
+ TEST_INSTRUCTION("4108202E", rev32(v1.b8(), v2.b8()));
2620
+ TEST_INSTRUCTION("4108206E", rev32(v1.b16(), v2.b16()));
2621
+ TEST_INSTRUCTION("4108602E", rev32(v1.h4(), v2.h4()));
2622
+ TEST_INSTRUCTION("4108606E", rev32(v1.h8(), v2.h8()));
2623
+ TEST_INSTRUCTION("4108200E", rev64(v1.b8(), v2.b8()));
2624
+ TEST_INSTRUCTION("4108204E", rev64(v1.b16(), v2.b16()));
2625
+ TEST_INSTRUCTION("4108600E", rev64(v1.h4(), v2.h4()));
2626
+ TEST_INSTRUCTION("4108604E", rev64(v1.h8(), v2.h8()));
2627
+ TEST_INSTRUCTION("4108A00E", rev64(v1.s2(), v2.s2()));
2628
+ TEST_INSTRUCTION("4108A04E", rev64(v1.s4(), v2.s4()));
2629
+ TEST_INSTRUCTION("418C090F", rshrn(v1.b8(), v2.h8(), 7));
2630
+ TEST_INSTRUCTION("418C110F", rshrn(v1.h4(), v2.s4(), 15));
2631
+ TEST_INSTRUCTION("418C210F", rshrn(v1.s2(), v2.d2(), 31));
2632
+ TEST_INSTRUCTION("418C094F", rshrn2(v1.b16(), v2.h8(), 7));
2633
+ TEST_INSTRUCTION("418C114F", rshrn2(v1.h8(), v2.s4(), 15));
2634
+ TEST_INSTRUCTION("418C214F", rshrn2(v1.s4(), v2.d2(), 31));
2635
+ TEST_INSTRUCTION("4160232E", rsubhn(v1.b8(), v2.h8(), v3.h8()));
2636
+ TEST_INSTRUCTION("4160632E", rsubhn(v1.h4(), v2.s4(), v3.s4()));
2637
+ TEST_INSTRUCTION("4160A32E", rsubhn(v1.s2(), v2.d2(), v3.d2()));
2638
+ TEST_INSTRUCTION("4160236E", rsubhn2(v1.b16(), v2.h8(), v3.h8()));
2639
+ TEST_INSTRUCTION("4160636E", rsubhn2(v1.h8(), v2.s4(), v3.s4()));
2640
+ TEST_INSTRUCTION("4160A36E", rsubhn2(v1.s4(), v2.d2(), v3.d2()));
2641
+ TEST_INSTRUCTION("417C230E", saba(v1.b8(), v2.b8(), v3.b8()));
2642
+ TEST_INSTRUCTION("417C630E", saba(v1.h4(), v2.h4(), v3.h4()));
2643
+ TEST_INSTRUCTION("417CA30E", saba(v1.s2(), v2.s2(), v3.s2()));
2644
+ TEST_INSTRUCTION("417C234E", saba(v1.b16(), v2.b16(), v3.b16()));
2645
+ TEST_INSTRUCTION("417C634E", saba(v1.h8(), v2.h8(), v3.h8()));
2646
+ TEST_INSTRUCTION("417CA34E", saba(v1.s4(), v2.s4(), v3.s4()));
2647
+ TEST_INSTRUCTION("4150230E", sabal(v1.h8(), v2.b8(), v3.b8()));
2648
+ TEST_INSTRUCTION("4150630E", sabal(v1.s4(), v2.h4(), v3.h4()));
2649
+ TEST_INSTRUCTION("4150A30E", sabal(v1.d2(), v2.s2(), v3.s2()));
2650
+ TEST_INSTRUCTION("4150234E", sabal2(v1.h8(), v2.b16(), v3.b16()));
2651
+ TEST_INSTRUCTION("4150634E", sabal2(v1.s4(), v2.h8(), v3.h8()));
2652
+ TEST_INSTRUCTION("4150A34E", sabal2(v1.d2(), v2.s4(), v3.s4()));
2653
+ TEST_INSTRUCTION("4174230E", sabd(v1.b8(), v2.b8(), v3.b8()));
2654
+ TEST_INSTRUCTION("4174630E", sabd(v1.h4(), v2.h4(), v3.h4()));
2655
+ TEST_INSTRUCTION("4174A30E", sabd(v1.s2(), v2.s2(), v3.s2()));
2656
+ TEST_INSTRUCTION("4174234E", sabd(v1.b16(), v2.b16(), v3.b16()));
2657
+ TEST_INSTRUCTION("4174634E", sabd(v1.h8(), v2.h8(), v3.h8()));
2658
+ TEST_INSTRUCTION("4174A34E", sabd(v1.s4(), v2.s4(), v3.s4()));
2659
+ TEST_INSTRUCTION("4170230E", sabdl(v1.h8(), v2.b8(), v3.b8()));
2660
+ TEST_INSTRUCTION("4170630E", sabdl(v1.s4(), v2.h4(), v3.h4()));
2661
+ TEST_INSTRUCTION("4170A30E", sabdl(v1.d2(), v2.s2(), v3.s2()));
2662
+ TEST_INSTRUCTION("4170234E", sabdl2(v1.h8(), v2.b16(), v3.b16()));
2663
+ TEST_INSTRUCTION("4170634E", sabdl2(v1.s4(), v2.h8(), v3.h8()));
2664
+ TEST_INSTRUCTION("4170A34E", sabdl2(v1.d2(), v2.s4(), v3.s4()));
2665
+ TEST_INSTRUCTION("4168200E", sadalp(v1.h4(), v2.b8()));
2666
+ TEST_INSTRUCTION("4168600E", sadalp(v1.s2(), v2.h4()));
2667
+ TEST_INSTRUCTION("4168A00E", sadalp(d1, v2.s2()));
2668
+ TEST_INSTRUCTION("4168204E", sadalp(v1.h8(), v2.b16()));
2669
+ TEST_INSTRUCTION("4168604E", sadalp(v1.s4(), v2.h8()));
2670
+ TEST_INSTRUCTION("4168A04E", sadalp(v1.d2(), v2.s4()));
2671
+ TEST_INSTRUCTION("4100230E", saddl(v1.h8(), v2.b8(), v3.b8()));
2672
+ TEST_INSTRUCTION("4100630E", saddl(v1.s4(), v2.h4(), v3.h4()));
2673
+ TEST_INSTRUCTION("4100A30E", saddl(v1.d2(), v2.s2(), v3.s2()));
2674
+ TEST_INSTRUCTION("4100234E", saddl2(v1.h8(), v2.b16(), v3.b16()));
2675
+ TEST_INSTRUCTION("4100634E", saddl2(v1.s4(), v2.h8(), v3.h8()));
2676
+ TEST_INSTRUCTION("4100A34E", saddl2(v1.d2(), v2.s4(), v3.s4()));
2677
+ TEST_INSTRUCTION("4128200E", saddlp(v1.h4(), v2.b8()));
2678
+ TEST_INSTRUCTION("4128600E", saddlp(v1.s2(), v2.h4()));
2679
+ TEST_INSTRUCTION("4128A00E", saddlp(d1, v2.s2()));
2680
+ TEST_INSTRUCTION("4128204E", saddlp(v1.h8(), v2.b16()));
2681
+ TEST_INSTRUCTION("4128604E", saddlp(v1.s4(), v2.h8()));
2682
+ TEST_INSTRUCTION("4128A04E", saddlp(v1.d2(), v2.s4()));
2683
+ TEST_INSTRUCTION("4138300E", saddlv(h1, v2.b8()));
2684
+ TEST_INSTRUCTION("4138304E", saddlv(h1, v2.b16()));
2685
+ TEST_INSTRUCTION("4138700E", saddlv(s1, v2.h4()));
2686
+ TEST_INSTRUCTION("4138704E", saddlv(s1, v2.h8()));
2687
+ TEST_INSTRUCTION("4138B04E", saddlv(d1, v2.s4()));
2688
+ TEST_INSTRUCTION("4110230E", saddw(v1.h8(), v2.h8(), v3.b8()));
2689
+ TEST_INSTRUCTION("4110630E", saddw(v1.s4(), v2.s4(), v3.h4()));
2690
+ TEST_INSTRUCTION("4110A30E", saddw(v1.d2(), v2.d2(), v3.s2()));
2691
+ TEST_INSTRUCTION("4110234E", saddw2(v1.h8(), v2.h8(), v3.b16()));
2692
+ TEST_INSTRUCTION("4110634E", saddw2(v1.s4(), v2.s4(), v3.h8()));
2693
+ TEST_INSTRUCTION("4110A34E", saddw2(v1.d2(), v2.d2(), v3.s4()));
2694
+ TEST_INSTRUCTION("4100E21E", scvtf(h1, w2));
2695
+ TEST_INSTRUCTION("4100221E", scvtf(s1, w2));
2696
+ TEST_INSTRUCTION("4100621E", scvtf(d1, w2));
2697
+ TEST_INSTRUCTION("4100E29E", scvtf(h1, x2));
2698
+ TEST_INSTRUCTION("4100229E", scvtf(s1, x2));
2699
+ TEST_INSTRUCTION("4100629E", scvtf(d1, x2));
2700
+ TEST_INSTRUCTION("41D8795E", scvtf(h1, h2));
2701
+ TEST_INSTRUCTION("41D8215E", scvtf(s1, s2));
2702
+ TEST_INSTRUCTION("41D8615E", scvtf(d1, d2));
2703
+ TEST_INSTRUCTION("41D8790E", scvtf(v1.h4(), v2.h4()));
2704
+ TEST_INSTRUCTION("41D8210E", scvtf(v1.s2(), v2.s2()));
2705
+ TEST_INSTRUCTION("41D8794E", scvtf(v1.h8(), v2.h8()));
2706
+ TEST_INSTRUCTION("41D8214E", scvtf(v1.s4(), v2.s4()));
2707
+ TEST_INSTRUCTION("41D8614E", scvtf(v1.d2(), v2.d2()));
2708
+ TEST_INSTRUCTION("41E0C21E", scvtf(h1, w2, 8));
2709
+ TEST_INSTRUCTION("41E0021E", scvtf(s1, w2, 8));
2710
+ TEST_INSTRUCTION("41E0421E", scvtf(d1, w2, 8));
2711
+ TEST_INSTRUCTION("41E0C29E", scvtf(h1, x2, 8));
2712
+ TEST_INSTRUCTION("41E0029E", scvtf(s1, x2, 8));
2713
+ TEST_INSTRUCTION("41E0429E", scvtf(d1, x2, 8));
2714
+ TEST_INSTRUCTION("41E4185F", scvtf(h1, h2, 8));
2715
+ TEST_INSTRUCTION("41E4385F", scvtf(s1, s2, 8));
2716
+ TEST_INSTRUCTION("41E4785F", scvtf(d1, d2, 8));
2717
+ TEST_INSTRUCTION("41E4180F", scvtf(v1.h4(), v2.h4(), 8));
2718
+ TEST_INSTRUCTION("41E4380F", scvtf(v1.s2(), v2.s2(), 8));
2719
+ TEST_INSTRUCTION("41E4184F", scvtf(v1.h8(), v2.h8(), 8));
2720
+ TEST_INSTRUCTION("41E4384F", scvtf(v1.s4(), v2.s4(), 8));
2721
+ TEST_INSTRUCTION("41E4784F", scvtf(v1.d2(), v2.d2(), 8));
2722
+ TEST_INSTRUCTION("4194830E", sdot(v1.s2(), v2.b8(), v3.b8()));
2723
+ TEST_INSTRUCTION("4194834E", sdot(v1.s4(), v2.b16(), v3.b16()));
2724
+ TEST_INSTRUCTION("41E0830F", sdot(v1.s2(), v2.b8(), v3.b4(0)));
2725
+ TEST_INSTRUCTION("41E0A30F", sdot(v1.s2(), v2.b8(), v3.b4(1)));
2726
+ TEST_INSTRUCTION("41E8830F", sdot(v1.s2(), v2.b8(), v3.b4(2)));
2727
+ TEST_INSTRUCTION("41E8A30F", sdot(v1.s2(), v2.b8(), v3.b4(3)));
2728
+ TEST_INSTRUCTION("41E0834F", sdot(v1.s4(), v2.b16(), v3.b4(0)));
2729
+ TEST_INSTRUCTION("41E0A34F", sdot(v1.s4(), v2.b16(), v3.b4(1)));
2730
+ TEST_INSTRUCTION("41E8834F", sdot(v1.s4(), v2.b16(), v3.b4(2)));
2731
+ TEST_INSTRUCTION("41E8A34F", sdot(v1.s4(), v2.b16(), v3.b4(3)));
2732
+ TEST_INSTRUCTION("4100035E", sha1c(q1, s2, v3.s4()));
2733
+ TEST_INSTRUCTION("4108285E", sha1h(s1, s2));
2734
+ TEST_INSTRUCTION("4120035E", sha1m(q1, s2, v3.s4()));
2735
+ TEST_INSTRUCTION("4110035E", sha1p(q1, s2, v3.s4()));
2736
+ TEST_INSTRUCTION("4130035E", sha1su0(v1.s4(), v2.s4(), v3.s4()));
2737
+ TEST_INSTRUCTION("4118285E", sha1su1(v1.s4(), v2.s4()));
2738
+ TEST_INSTRUCTION("4140035E", sha256h(q1, q2, v3.s4()));
2739
+ TEST_INSTRUCTION("4150035E", sha256h2(q1, q2, v3.s4()));
2740
+ TEST_INSTRUCTION("4128285E", sha256su0(v1.s4(), v2.s4()));
2741
+ TEST_INSTRUCTION("4160035E", sha256su1(v1.s4(), v2.s4(), v3.s4()));
2742
+ TEST_INSTRUCTION("4104230E", shadd(v1.b8(), v2.b8(), v3.b8()));
2743
+ TEST_INSTRUCTION("4104630E", shadd(v1.h4(), v2.h4(), v3.h4()));
2744
+ TEST_INSTRUCTION("4104A30E", shadd(v1.s2(), v2.s2(), v3.s2()));
2745
+ TEST_INSTRUCTION("4104234E", shadd(v1.b16(), v2.b16(), v3.b16()));
2746
+ TEST_INSTRUCTION("4104634E", shadd(v1.h8(), v2.h8(), v3.h8()));
2747
+ TEST_INSTRUCTION("4104A34E", shadd(v1.s4(), v2.s4(), v3.s4()));
2748
+ TEST_INSTRUCTION("41540F0F", shl(v1.b8(), v2.b8(), 7));
2749
+ TEST_INSTRUCTION("41541F0F", shl(v1.h4(), v2.h4(), 15));
2750
+ TEST_INSTRUCTION("41543F0F", shl(v1.s2(), v2.s2(), 31));
2751
+ TEST_INSTRUCTION("41547F5F", shl(d1, d2, 63));
2752
+ TEST_INSTRUCTION("41540F4F", shl(v1.b16(), v2.b16(), 7));
2753
+ TEST_INSTRUCTION("41541F4F", shl(v1.h8(), v2.h8(), 15));
2754
+ TEST_INSTRUCTION("41543F4F", shl(v1.s4(), v2.s4(), 31));
2755
+ TEST_INSTRUCTION("41547F4F", shl(v1.d2(), v2.d2(), 63));
2756
+ TEST_INSTRUCTION("4138212E", shll(v1.h8(), v2.b8(), 8));
2757
+ TEST_INSTRUCTION("4138612E", shll(v1.s4(), v2.h4(), 16));
2758
+ TEST_INSTRUCTION("4138A12E", shll(v1.d2(), v2.s2(), 32));
2759
+ TEST_INSTRUCTION("4138216E", shll2(v1.h8(), v2.b16(), 8));
2760
+ TEST_INSTRUCTION("4138616E", shll2(v1.s4(), v2.h8(), 16));
2761
+ TEST_INSTRUCTION("4138A16E", shll2(v1.d2(), v2.s4(), 32));
2762
+ TEST_INSTRUCTION("4184090F", shrn(v1.b8(), v2.h8(), 7));
2763
+ TEST_INSTRUCTION("4184110F", shrn(v1.h4(), v2.s4(), 15));
2764
+ TEST_INSTRUCTION("4184210F", shrn(v1.s2(), v2.d2(), 31));
2765
+ TEST_INSTRUCTION("4184094F", shrn2(v1.b16(), v2.h8(), 7));
2766
+ TEST_INSTRUCTION("4184114F", shrn2(v1.h8(), v2.s4(), 15));
2767
+ TEST_INSTRUCTION("4184214F", shrn2(v1.s4(), v2.d2(), 31));
2768
+ TEST_INSTRUCTION("4124230E", shsub(v1.b8(), v2.b8(), v3.b8()));
2769
+ TEST_INSTRUCTION("4124630E", shsub(v1.h4(), v2.h4(), v3.h4()));
2770
+ TEST_INSTRUCTION("4124A30E", shsub(v1.s2(), v2.s2(), v3.s2()));
2771
+ TEST_INSTRUCTION("4124234E", shsub(v1.b16(), v2.b16(), v3.b16()));
2772
+ TEST_INSTRUCTION("4124634E", shsub(v1.h8(), v2.h8(), v3.h8()));
2773
+ TEST_INSTRUCTION("4124A34E", shsub(v1.s4(), v2.s4(), v3.s4()));
2774
+ TEST_INSTRUCTION("41540F2F", sli(v1.b8(), v2.b8(), 7));
2775
+ TEST_INSTRUCTION("41541F2F", sli(v1.h4(), v2.h4(), 15));
2776
+ TEST_INSTRUCTION("41543F2F", sli(v1.s2(), v2.s2(), 31));
2777
+ TEST_INSTRUCTION("41547F7F", sli(d1, d2, 63));
2778
+ TEST_INSTRUCTION("41540F6F", sli(v1.b16(), v2.b16(), 7));
2779
+ TEST_INSTRUCTION("41541F6F", sli(v1.h8(), v2.h8(), 15));
2780
+ TEST_INSTRUCTION("41543F6F", sli(v1.s4(), v2.s4(), 31));
2781
+ TEST_INSTRUCTION("41547F6F", sli(v1.d2(), v2.d2(), 63));
2782
+ TEST_INSTRUCTION("41C063CE", sm3partw1(v1.s4(), v2.s4(), v3.s4()));
2783
+ TEST_INSTRUCTION("41C463CE", sm3partw2(v1.s4(), v2.s4(), v3.s4()));
2784
+ TEST_INSTRUCTION("411043CE", sm3ss1(v1.s4(), v2.s4(), v3.s4(), v4.s4()));
2785
+ TEST_INSTRUCTION("418044CE", sm3tt1a(v1.s4(), v2.s4(), v4.s(0)));
2786
+ TEST_INSTRUCTION("41B044CE", sm3tt1a(v1.s4(), v2.s4(), v4.s(3)));
2787
+ TEST_INSTRUCTION("418444CE", sm3tt1b(v1.s4(), v2.s4(), v4.s(0)));
2788
+ TEST_INSTRUCTION("41B444CE", sm3tt1b(v1.s4(), v2.s4(), v4.s(3)));
2789
+ TEST_INSTRUCTION("418844CE", sm3tt2a(v1.s4(), v2.s4(), v4.s(0)));
2790
+ TEST_INSTRUCTION("41B844CE", sm3tt2a(v1.s4(), v2.s4(), v4.s(3)));
2791
+ TEST_INSTRUCTION("418C44CE", sm3tt2b(v1.s4(), v2.s4(), v4.s(0)));
2792
+ TEST_INSTRUCTION("41BC44CE", sm3tt2b(v1.s4(), v2.s4(), v4.s(3)));
2793
+ TEST_INSTRUCTION("4184C0CE", sm4e(v1.s4(), v2.s4()));
2794
+ TEST_INSTRUCTION("41C863CE", sm4ekey(v1.s4(), v2.s4(), v3.s4()));
2795
+ TEST_INSTRUCTION("4164230E", smax(v1.b8(), v2.b8(), v3.b8()));
2796
+ TEST_INSTRUCTION("4164630E", smax(v1.h4(), v2.h4(), v3.h4()));
2797
+ TEST_INSTRUCTION("4164A30E", smax(v1.s2(), v2.s2(), v3.s2()));
2798
+ TEST_INSTRUCTION("4164234E", smax(v1.b16(), v2.b16(), v3.b16()));
2799
+ TEST_INSTRUCTION("4164634E", smax(v1.h8(), v2.h8(), v3.h8()));
2800
+ TEST_INSTRUCTION("4164A34E", smax(v1.s4(), v2.s4(), v3.s4()));
2801
+ TEST_INSTRUCTION("41A4230E", smaxp(v1.b8(), v2.b8(), v3.b8()));
2802
+ TEST_INSTRUCTION("41A4630E", smaxp(v1.h4(), v2.h4(), v3.h4()));
2803
+ TEST_INSTRUCTION("41A4A30E", smaxp(v1.s2(), v2.s2(), v3.s2()));
2804
+ TEST_INSTRUCTION("41A4234E", smaxp(v1.b16(), v2.b16(), v3.b16()));
2805
+ TEST_INSTRUCTION("41A4634E", smaxp(v1.h8(), v2.h8(), v3.h8()));
2806
+ TEST_INSTRUCTION("41A4A34E", smaxp(v1.s4(), v2.s4(), v3.s4()));
2807
+ TEST_INSTRUCTION("41A8300E", smaxv(b1, v2.b8()));
2808
+ TEST_INSTRUCTION("41A8304E", smaxv(b1, v2.b16()));
2809
+ TEST_INSTRUCTION("41A8700E", smaxv(h1, v2.h4()));
2810
+ TEST_INSTRUCTION("41A8704E", smaxv(h1, v2.h8()));
2811
+ TEST_INSTRUCTION("41A8B04E", smaxv(s1, v2.s4()));
2812
+ TEST_INSTRUCTION("416C230E", smin(v1.b8(), v2.b8(), v3.b8()));
2813
+ TEST_INSTRUCTION("416C630E", smin(v1.h4(), v2.h4(), v3.h4()));
2814
+ TEST_INSTRUCTION("416CA30E", smin(v1.s2(), v2.s2(), v3.s2()));
2815
+ TEST_INSTRUCTION("416C234E", smin(v1.b16(), v2.b16(), v3.b16()));
2816
+ TEST_INSTRUCTION("416C634E", smin(v1.h8(), v2.h8(), v3.h8()));
2817
+ TEST_INSTRUCTION("416CA34E", smin(v1.s4(), v2.s4(), v3.s4()));
2818
+ TEST_INSTRUCTION("41AC230E", sminp(v1.b8(), v2.b8(), v3.b8()));
2819
+ TEST_INSTRUCTION("41AC630E", sminp(v1.h4(), v2.h4(), v3.h4()));
2820
+ TEST_INSTRUCTION("41ACA30E", sminp(v1.s2(), v2.s2(), v3.s2()));
2821
+ TEST_INSTRUCTION("41AC234E", sminp(v1.b16(), v2.b16(), v3.b16()));
2822
+ TEST_INSTRUCTION("41AC634E", sminp(v1.h8(), v2.h8(), v3.h8()));
2823
+ TEST_INSTRUCTION("41ACA34E", sminp(v1.s4(), v2.s4(), v3.s4()));
2824
+ TEST_INSTRUCTION("41A8310E", sminv(b1, v2.b8()));
2825
+ TEST_INSTRUCTION("41A8314E", sminv(b1, v2.b16()));
2826
+ TEST_INSTRUCTION("41A8710E", sminv(h1, v2.h4()));
2827
+ TEST_INSTRUCTION("41A8714E", sminv(h1, v2.h8()));
2828
+ TEST_INSTRUCTION("41A8B14E", sminv(s1, v2.s4()));
2829
+ TEST_INSTRUCTION("4180230E", smlal(v1.h8(), v2.b8(), v3.b8()));
2830
+ TEST_INSTRUCTION("4180630E", smlal(v1.s4(), v2.h4(), v3.h4()));
2831
+ TEST_INSTRUCTION("4180A30E", smlal(v1.d2(), v2.s2(), v3.s2()));
2832
+ TEST_INSTRUCTION("4120730F", smlal(v1.s4(), v2.h4(), v3.h(3)));
2833
+ TEST_INSTRUCTION("4128A30F", smlal(v1.d2(), v2.s2(), v3.s(3)));
2834
+ TEST_INSTRUCTION("4180234E", smlal2(v1.h8(), v2.b16(), v3.b16()));
2835
+ TEST_INSTRUCTION("4180634E", smlal2(v1.s4(), v2.h8(), v3.h8()));
2836
+ TEST_INSTRUCTION("4180A34E", smlal2(v1.d2(), v2.s4(), v3.s4()));
2837
+ TEST_INSTRUCTION("4120734F", smlal2(v1.s4(), v2.h8(), v3.h(3)));
2838
+ TEST_INSTRUCTION("4128A34F", smlal2(v1.d2(), v2.s4(), v3.s(3)));
2839
+ TEST_INSTRUCTION("41A0230E", smlsl(v1.h8(), v2.b8(), v3.b8()));
2840
+ TEST_INSTRUCTION("41A0630E", smlsl(v1.s4(), v2.h4(), v3.h4()));
2841
+ TEST_INSTRUCTION("41A0A30E", smlsl(v1.d2(), v2.s2(), v3.s2()));
2842
+ TEST_INSTRUCTION("4160730F", smlsl(v1.s4(), v2.h4(), v3.h(3)));
2843
+ TEST_INSTRUCTION("4168A30F", smlsl(v1.d2(), v2.s2(), v3.s(3)));
2844
+ TEST_INSTRUCTION("41A0234E", smlsl2(v1.h8(), v2.b16(), v3.b16()));
2845
+ TEST_INSTRUCTION("41A0634E", smlsl2(v1.s4(), v2.h8(), v3.h8()));
2846
+ TEST_INSTRUCTION("41A0A34E", smlsl2(v1.d2(), v2.s4(), v3.s4()));
2847
+ TEST_INSTRUCTION("4160734F", smlsl2(v1.s4(), v2.h8(), v3.h(3)));
2848
+ TEST_INSTRUCTION("4168A34F", smlsl2(v1.d2(), v2.s4(), v3.s(3)));
2849
+ TEST_INSTRUCTION("41A4834E", smmla(v1.s4(), v2.b16(), v3.b16()));
2850
+ TEST_INSTRUCTION("412C010E", smov(w1, v2.b(0)));
2851
+ TEST_INSTRUCTION("412C1F0E", smov(w1, v2.b(15)));
2852
+ TEST_INSTRUCTION("412C020E", smov(w1, v2.h(0)));
2853
+ TEST_INSTRUCTION("412C1E0E", smov(w1, v2.h(7)));
2854
+ TEST_INSTRUCTION("412C014E", smov(x1, v2.b(0)));
2855
+ TEST_INSTRUCTION("412C1F4E", smov(x1, v2.b(15)));
2856
+ TEST_INSTRUCTION("412C024E", smov(x1, v2.h(0)));
2857
+ TEST_INSTRUCTION("412C1E4E", smov(x1, v2.h(7)));
2858
+ TEST_INSTRUCTION("412C044E", smov(x1, v2.s(0)));
2859
+ TEST_INSTRUCTION("412C1C4E", smov(x1, v2.s(3)));
2860
+ TEST_INSTRUCTION("41C0230E", smull(v1.h8(), v2.b8(), v3.b8()));
2861
+ TEST_INSTRUCTION("41C0630E", smull(v1.s4(), v2.h4(), v3.h4()));
2862
+ TEST_INSTRUCTION("41C0A30E", smull(v1.d2(), v2.s2(), v3.s2()));
2863
+ TEST_INSTRUCTION("41A0730F", smull(v1.s4(), v2.h4(), v3.h(3)));
2864
+ TEST_INSTRUCTION("41A8A30F", smull(v1.d2(), v2.s2(), v3.s(3)));
2865
+ TEST_INSTRUCTION("41C0234E", smull2(v1.h8(), v2.b16(), v3.b16()));
2866
+ TEST_INSTRUCTION("41C0634E", smull2(v1.s4(), v2.h8(), v3.h8()));
2867
+ TEST_INSTRUCTION("41C0A34E", smull2(v1.d2(), v2.s4(), v3.s4()));
2868
+ TEST_INSTRUCTION("41A0734F", smull2(v1.s4(), v2.h8(), v3.h(3)));
2869
+ TEST_INSTRUCTION("41A8A34F", smull2(v1.d2(), v2.s4(), v3.s(3)));
2870
+ TEST_INSTRUCTION("4178205E", sqabs(b1, b2));
2871
+ TEST_INSTRUCTION("4178605E", sqabs(h1, h2));
2872
+ TEST_INSTRUCTION("4178A05E", sqabs(s1, s2));
2873
+ TEST_INSTRUCTION("4178E05E", sqabs(d1, d2));
2874
+ TEST_INSTRUCTION("4178200E", sqabs(v1.b8(), v2.b8()));
2875
+ TEST_INSTRUCTION("4178600E", sqabs(v1.h4(), v2.h4()));
2876
+ TEST_INSTRUCTION("4178A00E", sqabs(v1.s2(), v2.s2()));
2877
+ TEST_INSTRUCTION("4178204E", sqabs(v1.b16(), v2.b16()));
2878
+ TEST_INSTRUCTION("4178604E", sqabs(v1.h8(), v2.h8()));
2879
+ TEST_INSTRUCTION("4178A04E", sqabs(v1.s4(), v2.s4()));
2880
+ TEST_INSTRUCTION("4178E04E", sqabs(v1.d2(), v2.d2()));
2881
+ TEST_INSTRUCTION("410C235E", sqadd(b1, b2, b3));
2882
+ TEST_INSTRUCTION("410C635E", sqadd(h1, h2, h3));
2883
+ TEST_INSTRUCTION("410CA35E", sqadd(s1, s2, s3));
2884
+ TEST_INSTRUCTION("410CE35E", sqadd(d1, d2, d3));
2885
+ TEST_INSTRUCTION("410C230E", sqadd(v1.b8(), v2.b8(), v3.b8()));
2886
+ TEST_INSTRUCTION("410C630E", sqadd(v1.h4(), v2.h4(), v3.h4()));
2887
+ TEST_INSTRUCTION("410CA30E", sqadd(v1.s2(), v2.s2(), v3.s2()));
2888
+ TEST_INSTRUCTION("410C234E", sqadd(v1.b16(), v2.b16(), v3.b16()));
2889
+ TEST_INSTRUCTION("410C634E", sqadd(v1.h8(), v2.h8(), v3.h8()));
2890
+ TEST_INSTRUCTION("410CA34E", sqadd(v1.s4(), v2.s4(), v3.s4()));
2891
+ TEST_INSTRUCTION("410CE34E", sqadd(v1.d2(), v2.d2(), v3.d2()));
2892
+ TEST_INSTRUCTION("4190635E", sqdmlal(s1, h2, h3));
2893
+ TEST_INSTRUCTION("4190A35E", sqdmlal(d1, s2, s3));
2894
+ TEST_INSTRUCTION("4190630E", sqdmlal(v1.s4(), v2.h4(), v3.h4()));
2895
+ TEST_INSTRUCTION("4190A30E", sqdmlal(v1.d2(), v2.s2(), v3.s2()));
2896
+ TEST_INSTRUCTION("4130730F", sqdmlal(v1.s4(), v2.h4(), v3.h(3)));
2897
+ TEST_INSTRUCTION("4138A30F", sqdmlal(v1.d2(), v2.s2(), v3.s(3)));
2898
+ TEST_INSTRUCTION("4190634E", sqdmlal2(v1.s4(), v2.h8(), v3.h8()));
2899
+ TEST_INSTRUCTION("4190A34E", sqdmlal2(v1.d2(), v2.s4(), v3.s4()));
2900
+ TEST_INSTRUCTION("4130734F", sqdmlal2(v1.s4(), v2.h8(), v3.h(3)));
2901
+ TEST_INSTRUCTION("4138A34F", sqdmlal2(v1.d2(), v2.s4(), v3.s(3)));
2902
+ TEST_INSTRUCTION("41B0635E", sqdmlsl(s1, h2, h3));
2903
+ TEST_INSTRUCTION("41B0A35E", sqdmlsl(d1, s2, s3));
2904
+ TEST_INSTRUCTION("41B0630E", sqdmlsl(v1.s4(), v2.h4(), v3.h4()));
2905
+ TEST_INSTRUCTION("41B0A30E", sqdmlsl(v1.d2(), v2.s2(), v3.s2()));
2906
+ TEST_INSTRUCTION("4170730F", sqdmlsl(v1.s4(), v2.h4(), v3.h(3)));
2907
+ TEST_INSTRUCTION("4178A30F", sqdmlsl(v1.d2(), v2.s2(), v3.s(3)));
2908
+ TEST_INSTRUCTION("41B0634E", sqdmlsl2(v1.s4(), v2.h8(), v3.h8()));
2909
+ TEST_INSTRUCTION("41B0A34E", sqdmlsl2(v1.d2(), v2.s4(), v3.s4()));
2910
+ TEST_INSTRUCTION("4170734F", sqdmlsl2(v1.s4(), v2.h8(), v3.h(3)));
2911
+ TEST_INSTRUCTION("4178A34F", sqdmlsl2(v1.d2(), v2.s4(), v3.s(3)));
2912
+ TEST_INSTRUCTION("41B4635E", sqdmulh(h1, h2, h3));
2913
+ TEST_INSTRUCTION("41B4A35E", sqdmulh(s1, s2, s3));
2914
+ TEST_INSTRUCTION("41B4630E", sqdmulh(v1.h4(), v2.h4(), v3.h4()));
2915
+ TEST_INSTRUCTION("41B4A30E", sqdmulh(v1.s2(), v2.s2(), v3.s2()));
2916
+ TEST_INSTRUCTION("41B4634E", sqdmulh(v1.h8(), v2.h8(), v3.h8()));
2917
+ TEST_INSTRUCTION("41B4A34E", sqdmulh(v1.s4(), v2.s4(), v3.s4()));
2918
+ TEST_INSTRUCTION("41C0730F", sqdmulh(v1.h4(), v2.h4(), v3.h(3)));
2919
+ TEST_INSTRUCTION("41C8A30F", sqdmulh(v1.s2(), v2.s2(), v3.s(3)));
2920
+ TEST_INSTRUCTION("41C0734F", sqdmulh(v1.h8(), v2.h8(), v3.h(3)));
2921
+ TEST_INSTRUCTION("41C8A34F", sqdmulh(v1.s4(), v2.s4(), v3.s(3)));
2922
+ TEST_INSTRUCTION("41D0635E", sqdmull(s1, h2, h3));
2923
+ TEST_INSTRUCTION("41D0A35E", sqdmull(d1, s2, s3));
2924
+ TEST_INSTRUCTION("41D0630E", sqdmull(v1.s4(), v2.h4(), v3.h4()));
2925
+ TEST_INSTRUCTION("41D0A30E", sqdmull(v1.d2(), v2.s2(), v3.s2()));
2926
+ TEST_INSTRUCTION("41B0730F", sqdmull(v1.s4(), v2.h4(), v3.h(3)));
2927
+ TEST_INSTRUCTION("41B8A30F", sqdmull(v1.d2(), v2.s2(), v3.s(3)));
2928
+ TEST_INSTRUCTION("41D0634E", sqdmull2(v1.s4(), v2.h8(), v3.h8()));
2929
+ TEST_INSTRUCTION("41D0A34E", sqdmull2(v1.d2(), v2.s4(), v3.s4()));
2930
+ TEST_INSTRUCTION("41B0734F", sqdmull2(v1.s4(), v2.h8(), v3.h(3)));
2931
+ TEST_INSTRUCTION("41B8A34F", sqdmull2(v1.d2(), v2.s4(), v3.s(3)));
2932
+ TEST_INSTRUCTION("4178207E", sqneg(b1, b2));
2933
+ TEST_INSTRUCTION("4178607E", sqneg(h1, h2));
2934
+ TEST_INSTRUCTION("4178A07E", sqneg(s1, s2));
2935
+ TEST_INSTRUCTION("4178E07E", sqneg(d1, d2));
2936
+ TEST_INSTRUCTION("4178202E", sqneg(v1.b8(), v2.b8()));
2937
+ TEST_INSTRUCTION("4178602E", sqneg(v1.h4(), v2.h4()));
2938
+ TEST_INSTRUCTION("4178A02E", sqneg(v1.s2(), v2.s2()));
2939
+ TEST_INSTRUCTION("4178206E", sqneg(v1.b16(), v2.b16()));
2940
+ TEST_INSTRUCTION("4178606E", sqneg(v1.h8(), v2.h8()));
2941
+ TEST_INSTRUCTION("4178A06E", sqneg(v1.s4(), v2.s4()));
2942
+ TEST_INSTRUCTION("4178E06E", sqneg(v1.d2(), v2.d2()));
2943
+ TEST_INSTRUCTION("4184437E", sqrdmlah(h1, h2, h3));
2944
+ TEST_INSTRUCTION("4184837E", sqrdmlah(s1, s2, s3));
2945
+ TEST_INSTRUCTION("4184432E", sqrdmlah(v1.h4(), v2.h4(), v3.h4()));
2946
+ TEST_INSTRUCTION("4184832E", sqrdmlah(v1.s2(), v2.s2(), v3.s2()));
2947
+ TEST_INSTRUCTION("41D0732F", sqrdmlah(v1.h4(), v2.h4(), v3.h(3)));
2948
+ TEST_INSTRUCTION("41D8A32F", sqrdmlah(v1.s2(), v2.s2(), v3.s(3)));
2949
+ TEST_INSTRUCTION("4184436E", sqrdmlah(v1.h8(), v2.h8(), v3.h8()));
2950
+ TEST_INSTRUCTION("4184836E", sqrdmlah(v1.s4(), v2.s4(), v3.s4()));
2951
+ TEST_INSTRUCTION("41D0736F", sqrdmlah(v1.h8(), v2.h8(), v3.h(3)));
2952
+ TEST_INSTRUCTION("41D8A36F", sqrdmlah(v1.s4(), v2.s4(), v3.s(3)));
2953
+ TEST_INSTRUCTION("418C437E", sqrdmlsh(h1, h2, h3));
2954
+ TEST_INSTRUCTION("418C837E", sqrdmlsh(s1, s2, s3));
2955
+ TEST_INSTRUCTION("418C432E", sqrdmlsh(v1.h4(), v2.h4(), v3.h4()));
2956
+ TEST_INSTRUCTION("418C832E", sqrdmlsh(v1.s2(), v2.s2(), v3.s2()));
2957
+ TEST_INSTRUCTION("41F0732F", sqrdmlsh(v1.h4(), v2.h4(), v3.h(3)));
2958
+ TEST_INSTRUCTION("41F8A32F", sqrdmlsh(v1.s2(), v2.s2(), v3.s(3)));
2959
+ TEST_INSTRUCTION("418C436E", sqrdmlsh(v1.h8(), v2.h8(), v3.h8()));
2960
+ TEST_INSTRUCTION("418C836E", sqrdmlsh(v1.s4(), v2.s4(), v3.s4()));
2961
+ TEST_INSTRUCTION("41F0736F", sqrdmlsh(v1.h8(), v2.h8(), v3.h(3)));
2962
+ TEST_INSTRUCTION("41F8A36F", sqrdmlsh(v1.s4(), v2.s4(), v3.s(3)));
2963
+ TEST_INSTRUCTION("41B4637E", sqrdmulh(h1, h2, h3));
2964
+ TEST_INSTRUCTION("41B4A37E", sqrdmulh(s1, s2, s3));
2965
+ TEST_INSTRUCTION("41B4632E", sqrdmulh(v1.h4(), v2.h4(), v3.h4()));
2966
+ TEST_INSTRUCTION("41B4A32E", sqrdmulh(v1.s2(), v2.s2(), v3.s2()));
2967
+ TEST_INSTRUCTION("41D0730F", sqrdmulh(v1.h4(), v2.h4(), v3.h(3)));
2968
+ TEST_INSTRUCTION("41D8A30F", sqrdmulh(v1.s2(), v2.s2(), v3.s(3)));
2969
+ TEST_INSTRUCTION("41B4636E", sqrdmulh(v1.h8(), v2.h8(), v3.h8()));
2970
+ TEST_INSTRUCTION("41B4A36E", sqrdmulh(v1.s4(), v2.s4(), v3.s4()));
2971
+ TEST_INSTRUCTION("41D0734F", sqrdmulh(v1.h8(), v2.h8(), v3.h(3)));
2972
+ TEST_INSTRUCTION("41D8A34F", sqrdmulh(v1.s4(), v2.s4(), v3.s(3)));
2973
+ TEST_INSTRUCTION("415C235E", sqrshl(b1, b2, b3));
2974
+ TEST_INSTRUCTION("415C635E", sqrshl(h1, h2, h3));
2975
+ TEST_INSTRUCTION("415CA35E", sqrshl(s1, s2, s3));
2976
+ TEST_INSTRUCTION("415C230E", sqrshl(v1.b8(), v2.b8(), v3.b8()));
2977
+ TEST_INSTRUCTION("415C630E", sqrshl(v1.h4(), v2.h4(), v3.h4()));
2978
+ TEST_INSTRUCTION("415CA30E", sqrshl(v1.s2(), v2.s2(), v3.s2()));
2979
+ TEST_INSTRUCTION("415CE35E", sqrshl(d1, d2, d3));
2980
+ TEST_INSTRUCTION("415C234E", sqrshl(v1.b16(), v2.b16(), v3.b16()));
2981
+ TEST_INSTRUCTION("415C634E", sqrshl(v1.h8(), v2.h8(), v3.h8()));
2982
+ TEST_INSTRUCTION("415CA34E", sqrshl(v1.s4(), v2.s4(), v3.s4()));
2983
+ TEST_INSTRUCTION("415CE34E", sqrshl(v1.d2(), v2.d2(), v3.d2()));
2984
+ TEST_INSTRUCTION("419C085F", sqrshrn(b1, h2, 8));
2985
+ TEST_INSTRUCTION("419C105F", sqrshrn(h1, s2, 16));
2986
+ TEST_INSTRUCTION("419C205F", sqrshrn(s1, d2, 32));
2987
+ TEST_INSTRUCTION("419C080F", sqrshrn(v1.b8(), v2.h8(), 8));
2988
+ TEST_INSTRUCTION("419C100F", sqrshrn(v1.h4(), v2.s4(), 16));
2989
+ TEST_INSTRUCTION("419C200F", sqrshrn(v1.s2(), v2.d2(), 32));
2990
+ TEST_INSTRUCTION("419C084F", sqrshrn2(v1.b16(), v2.h8(), 8));
2991
+ TEST_INSTRUCTION("419C104F", sqrshrn2(v1.h8(), v2.s4(), 16));
2992
+ TEST_INSTRUCTION("419C204F", sqrshrn2(v1.s4(), v2.d2(), 32));
2993
+ TEST_INSTRUCTION("418C087F", sqrshrun(b1, h2, 8));
2994
+ TEST_INSTRUCTION("418C107F", sqrshrun(h1, s2, 16));
2995
+ TEST_INSTRUCTION("418C207F", sqrshrun(s1, d2, 32));
2996
+ TEST_INSTRUCTION("418C082F", sqrshrun(v1.b8(), v2.h8(), 8));
2997
+ TEST_INSTRUCTION("418C102F", sqrshrun(v1.h4(), v2.s4(), 16));
2998
+ TEST_INSTRUCTION("418C202F", sqrshrun(v1.s2(), v2.d2(), 32));
2999
+ TEST_INSTRUCTION("418C086F", sqrshrun2(v1.b16(), v2.h8(), 8));
3000
+ TEST_INSTRUCTION("418C106F", sqrshrun2(v1.h8(), v2.s4(), 16));
3001
+ TEST_INSTRUCTION("418C206F", sqrshrun2(v1.s4(), v2.d2(), 32));
3002
+ TEST_INSTRUCTION("4174095F", sqshl(b1, b2, 1));
3003
+ TEST_INSTRUCTION("4174125F", sqshl(h1, h2, 2));
3004
+ TEST_INSTRUCTION("4174235F", sqshl(s1, s2, 3));
3005
+ TEST_INSTRUCTION("41740F0F", sqshl(v1.b8(), v2.b8(), 7));
3006
+ TEST_INSTRUCTION("41741F0F", sqshl(v1.h4(), v2.h4(), 15));
3007
+ TEST_INSTRUCTION("41743F0F", sqshl(v1.s2(), v2.s2(), 31));
3008
+ TEST_INSTRUCTION("41747F5F", sqshl(d1, d2, 63));
3009
+ TEST_INSTRUCTION("41740F4F", sqshl(v1.b16(), v2.b16(), 7));
3010
+ TEST_INSTRUCTION("41741F4F", sqshl(v1.h8(), v2.h8(), 15));
3011
+ TEST_INSTRUCTION("41743F4F", sqshl(v1.s4(), v2.s4(), 31));
3012
+ TEST_INSTRUCTION("41747F4F", sqshl(v1.d2(), v2.d2(), 63));
3013
+ TEST_INSTRUCTION("414C235E", sqshl(b1, b2, b3));
3014
+ TEST_INSTRUCTION("414C635E", sqshl(h1, h2, h3));
3015
+ TEST_INSTRUCTION("414CA35E", sqshl(s1, s2, s3));
3016
+ TEST_INSTRUCTION("414C230E", sqshl(v1.b8(), v2.b8(), v3.b8()));
3017
+ TEST_INSTRUCTION("414C630E", sqshl(v1.h4(), v2.h4(), v3.h4()));
3018
+ TEST_INSTRUCTION("414CA30E", sqshl(v1.s2(), v2.s2(), v3.s2()));
3019
+ TEST_INSTRUCTION("414CE35E", sqshl(d1, d2, d3));
3020
+ TEST_INSTRUCTION("414C234E", sqshl(v1.b16(), v2.b16(), v3.b16()));
3021
+ TEST_INSTRUCTION("414C634E", sqshl(v1.h8(), v2.h8(), v3.h8()));
3022
+ TEST_INSTRUCTION("414CA34E", sqshl(v1.s4(), v2.s4(), v3.s4()));
3023
+ TEST_INSTRUCTION("414CE34E", sqshl(v1.d2(), v2.d2(), v3.d2()));
3024
+ TEST_INSTRUCTION("4164097F", sqshlu(b1, b2, 1));
3025
+ TEST_INSTRUCTION("4164127F", sqshlu(h1, h2, 2));
3026
+ TEST_INSTRUCTION("4164237F", sqshlu(s1, s2, 3));
3027
+ TEST_INSTRUCTION("41640F2F", sqshlu(v1.b8(), v2.b8(), 7));
3028
+ TEST_INSTRUCTION("41641F2F", sqshlu(v1.h4(), v2.h4(), 15));
3029
+ TEST_INSTRUCTION("41643F2F", sqshlu(v1.s2(), v2.s2(), 31));
3030
+ TEST_INSTRUCTION("41647F7F", sqshlu(d1, d2, 63));
3031
+ TEST_INSTRUCTION("41640F6F", sqshlu(v1.b16(), v2.b16(), 7));
3032
+ TEST_INSTRUCTION("41641F6F", sqshlu(v1.h8(), v2.h8(), 15));
3033
+ TEST_INSTRUCTION("41643F6F", sqshlu(v1.s4(), v2.s4(), 31));
3034
+ TEST_INSTRUCTION("41647F6F", sqshlu(v1.d2(), v2.d2(), 63));
3035
+ TEST_INSTRUCTION("4194085F", sqshrn(b1, h2, 8));
3036
+ TEST_INSTRUCTION("4194105F", sqshrn(h1, s2, 16));
3037
+ TEST_INSTRUCTION("4194205F", sqshrn(s1, d2, 32));
3038
+ TEST_INSTRUCTION("4194080F", sqshrn(v1.b8(), v2.h8(), 8));
3039
+ TEST_INSTRUCTION("4194100F", sqshrn(v1.h4(), v2.s4(), 16));
3040
+ TEST_INSTRUCTION("4194200F", sqshrn(v1.s2(), v2.d2(), 32));
3041
+ TEST_INSTRUCTION("4194084F", sqshrn2(v1.b16(), v2.h8(), 8));
3042
+ TEST_INSTRUCTION("4194104F", sqshrn2(v1.h8(), v2.s4(), 16));
3043
+ TEST_INSTRUCTION("4194204F", sqshrn2(v1.s4(), v2.d2(), 32));
3044
+ TEST_INSTRUCTION("4184087F", sqshrun(b1, h2, 8));
3045
+ TEST_INSTRUCTION("4184107F", sqshrun(h1, s2, 16));
3046
+ TEST_INSTRUCTION("4184207F", sqshrun(s1, d2, 32));
3047
+ TEST_INSTRUCTION("4184082F", sqshrun(v1.b8(), v2.h8(), 8));
3048
+ TEST_INSTRUCTION("4184102F", sqshrun(v1.h4(), v2.s4(), 16));
3049
+ TEST_INSTRUCTION("4184202F", sqshrun(v1.s2(), v2.d2(), 32));
3050
+ TEST_INSTRUCTION("4184086F", sqshrun2(v1.b16(), v2.h8(), 8));
3051
+ TEST_INSTRUCTION("4184106F", sqshrun2(v1.h8(), v2.s4(), 16));
3052
+ TEST_INSTRUCTION("4184206F", sqshrun2(v1.s4(), v2.d2(), 32));
3053
+ TEST_INSTRUCTION("412C235E", sqsub(b1, b2, b3));
3054
+ TEST_INSTRUCTION("412C635E", sqsub(h1, h2, h3));
3055
+ TEST_INSTRUCTION("412CA35E", sqsub(s1, s2, s3));
3056
+ TEST_INSTRUCTION("412CE35E", sqsub(d1, d2, d3));
3057
+ TEST_INSTRUCTION("412C230E", sqsub(v1.b8(), v2.b8(), v3.b8()));
3058
+ TEST_INSTRUCTION("412C630E", sqsub(v1.h4(), v2.h4(), v3.h4()));
3059
+ TEST_INSTRUCTION("412CA30E", sqsub(v1.s2(), v2.s2(), v3.s2()));
3060
+ TEST_INSTRUCTION("412C234E", sqsub(v1.b16(), v2.b16(), v3.b16()));
3061
+ TEST_INSTRUCTION("412C634E", sqsub(v1.h8(), v2.h8(), v3.h8()));
3062
+ TEST_INSTRUCTION("412CA34E", sqsub(v1.s4(), v2.s4(), v3.s4()));
3063
+ TEST_INSTRUCTION("412CE34E", sqsub(v1.d2(), v2.d2(), v3.d2()));
3064
+ TEST_INSTRUCTION("4148215E", sqxtn(b1, h2));
3065
+ TEST_INSTRUCTION("4148615E", sqxtn(h1, s2));
3066
+ TEST_INSTRUCTION("4148A15E", sqxtn(s1, d2));
3067
+ TEST_INSTRUCTION("4148210E", sqxtn(v1.b8(), v2.h8()));
3068
+ TEST_INSTRUCTION("4148610E", sqxtn(v1.h4(), v2.s4()));
3069
+ TEST_INSTRUCTION("4148A10E", sqxtn(v1.s2(), v2.d2()));
3070
+ TEST_INSTRUCTION("4148214E", sqxtn2(v1.b16(), v2.h8()));
3071
+ TEST_INSTRUCTION("4148614E", sqxtn2(v1.h8(), v2.s4()));
3072
+ TEST_INSTRUCTION("4148A14E", sqxtn2(v1.s4(), v2.d2()));
3073
+ TEST_INSTRUCTION("4128217E", sqxtun(b1, h2));
3074
+ TEST_INSTRUCTION("4128617E", sqxtun(h1, s2));
3075
+ TEST_INSTRUCTION("4128A17E", sqxtun(s1, d2));
3076
+ TEST_INSTRUCTION("4128212E", sqxtun(v1.b8(), v2.h8()));
3077
+ TEST_INSTRUCTION("4128612E", sqxtun(v1.h4(), v2.s4()));
3078
+ TEST_INSTRUCTION("4128A12E", sqxtun(v1.s2(), v2.d2()));
3079
+ TEST_INSTRUCTION("4128216E", sqxtun2(v1.b16(), v2.h8()));
3080
+ TEST_INSTRUCTION("4128616E", sqxtun2(v1.h8(), v2.s4()));
3081
+ TEST_INSTRUCTION("4128A16E", sqxtun2(v1.s4(), v2.d2()));
3082
+ TEST_INSTRUCTION("4114230E", srhadd(v1.b8(), v2.b8(), v3.b8()));
3083
+ TEST_INSTRUCTION("4114630E", srhadd(v1.h4(), v2.h4(), v3.h4()));
3084
+ TEST_INSTRUCTION("4114A30E", srhadd(v1.s2(), v2.s2(), v3.s2()));
3085
+ TEST_INSTRUCTION("4114234E", srhadd(v1.b16(), v2.b16(), v3.b16()));
3086
+ TEST_INSTRUCTION("4114634E", srhadd(v1.h8(), v2.h8(), v3.h8()));
3087
+ TEST_INSTRUCTION("4114A34E", srhadd(v1.s4(), v2.s4(), v3.s4()));
3088
+ TEST_INSTRUCTION("4144092F", sri(v1.b8(), v2.b8(), 7));
3089
+ TEST_INSTRUCTION("4144112F", sri(v1.h4(), v2.h4(), 15));
3090
+ TEST_INSTRUCTION("4144212F", sri(v1.s2(), v2.s2(), 31));
3091
+ TEST_INSTRUCTION("4144417F", sri(d1, d2, 63));
3092
+ TEST_INSTRUCTION("4144096F", sri(v1.b16(), v2.b16(), 7));
3093
+ TEST_INSTRUCTION("4144116F", sri(v1.h8(), v2.h8(), 15));
3094
+ TEST_INSTRUCTION("4144216F", sri(v1.s4(), v2.s4(), 31));
3095
+ TEST_INSTRUCTION("4144416F", sri(v1.d2(), v2.d2(), 63));
3096
+ TEST_INSTRUCTION("4154230E", srshl(v1.b8(), v2.b8(), v3.b8()));
3097
+ TEST_INSTRUCTION("4154630E", srshl(v1.h4(), v2.h4(), v3.h4()));
3098
+ TEST_INSTRUCTION("4154A30E", srshl(v1.s2(), v2.s2(), v3.s2()));
3099
+ TEST_INSTRUCTION("4154E35E", srshl(d1, d2, d3));
3100
+ TEST_INSTRUCTION("4154234E", srshl(v1.b16(), v2.b16(), v3.b16()));
3101
+ TEST_INSTRUCTION("4154634E", srshl(v1.h8(), v2.h8(), v3.h8()));
3102
+ TEST_INSTRUCTION("4154A34E", srshl(v1.s4(), v2.s4(), v3.s4()));
3103
+ TEST_INSTRUCTION("4154E34E", srshl(v1.d2(), v2.d2(), v3.d2()));
3104
+ TEST_INSTRUCTION("4124090F", srshr(v1.b8(), v2.b8(), 7));
3105
+ TEST_INSTRUCTION("4124110F", srshr(v1.h4(), v2.h4(), 15));
3106
+ TEST_INSTRUCTION("4124210F", srshr(v1.s2(), v2.s2(), 31));
3107
+ TEST_INSTRUCTION("4124415F", srshr(d1, d2, 63));
3108
+ TEST_INSTRUCTION("4124094F", srshr(v1.b16(), v2.b16(), 7));
3109
+ TEST_INSTRUCTION("4124114F", srshr(v1.h8(), v2.h8(), 15));
3110
+ TEST_INSTRUCTION("4124214F", srshr(v1.s4(), v2.s4(), 31));
3111
+ TEST_INSTRUCTION("4124414F", srshr(v1.d2(), v2.d2(), 63));
3112
+ TEST_INSTRUCTION("4134090F", srsra(v1.b8(), v2.b8(), 7));
3113
+ TEST_INSTRUCTION("4134110F", srsra(v1.h4(), v2.h4(), 15));
3114
+ TEST_INSTRUCTION("4134210F", srsra(v1.s2(), v2.s2(), 31));
3115
+ TEST_INSTRUCTION("4134415F", srsra(d1, d2, 63));
3116
+ TEST_INSTRUCTION("4134094F", srsra(v1.b16(), v2.b16(), 7));
3117
+ TEST_INSTRUCTION("4134114F", srsra(v1.h8(), v2.h8(), 15));
3118
+ TEST_INSTRUCTION("4134214F", srsra(v1.s4(), v2.s4(), 31));
3119
+ TEST_INSTRUCTION("4134414F", srsra(v1.d2(), v2.d2(), 63));
3120
+ TEST_INSTRUCTION("4144230E", sshl(v1.b8(), v2.b8(), v3.b8()));
3121
+ TEST_INSTRUCTION("4144630E", sshl(v1.h4(), v2.h4(), v3.h4()));
3122
+ TEST_INSTRUCTION("4144A30E", sshl(v1.s2(), v2.s2(), v3.s2()));
3123
+ TEST_INSTRUCTION("4144E35E", sshl(d1, d2, d3));
3124
+ TEST_INSTRUCTION("4144234E", sshl(v1.b16(), v2.b16(), v3.b16()));
3125
+ TEST_INSTRUCTION("4144634E", sshl(v1.h8(), v2.h8(), v3.h8()));
3126
+ TEST_INSTRUCTION("4144A34E", sshl(v1.s4(), v2.s4(), v3.s4()));
3127
+ TEST_INSTRUCTION("4144E34E", sshl(v1.d2(), v2.d2(), v3.d2()));
3128
+ TEST_INSTRUCTION("41A40F0F", sshll(v1.h8(), v2.b8(), 7));
3129
+ TEST_INSTRUCTION("41A41F0F", sshll(v1.s4(), v2.h4(), 15));
3130
+ TEST_INSTRUCTION("41A43F0F", sshll(v1.d2(), v2.s2(), 31));
3131
+ TEST_INSTRUCTION("41A40F4F", sshll2(v1.h8(), v2.b16(), 7));
3132
+ TEST_INSTRUCTION("41A41F4F", sshll2(v1.s4(), v2.h8(), 15));
3133
+ TEST_INSTRUCTION("41A43F4F", sshll2(v1.s2(), v2.s4(), 31));
3134
+ TEST_INSTRUCTION("4104090F", sshr(v1.b8(), v2.b8(), 7));
3135
+ TEST_INSTRUCTION("4104110F", sshr(v1.h4(), v2.h4(), 15));
3136
+ TEST_INSTRUCTION("4104210F", sshr(v1.s2(), v2.s2(), 31));
3137
+ TEST_INSTRUCTION("4104415F", sshr(d1, d2, 63));
3138
+ TEST_INSTRUCTION("4104094F", sshr(v1.b16(), v2.b16(), 7));
3139
+ TEST_INSTRUCTION("4104114F", sshr(v1.h8(), v2.h8(), 15));
3140
+ TEST_INSTRUCTION("4104214F", sshr(v1.s4(), v2.s4(), 31));
3141
+ TEST_INSTRUCTION("4104414F", sshr(v1.d2(), v2.d2(), 63));
3142
+ TEST_INSTRUCTION("4114090F", ssra(v1.b8(), v2.b8(), 7));
3143
+ TEST_INSTRUCTION("4114110F", ssra(v1.h4(), v2.h4(), 15));
3144
+ TEST_INSTRUCTION("4114210F", ssra(v1.s2(), v2.s2(), 31));
3145
+ TEST_INSTRUCTION("4114415F", ssra(d1, d2, 63));
3146
+ TEST_INSTRUCTION("4114094F", ssra(v1.b16(), v2.b16(), 7));
3147
+ TEST_INSTRUCTION("4114114F", ssra(v1.h8(), v2.h8(), 15));
3148
+ TEST_INSTRUCTION("4114214F", ssra(v1.s4(), v2.s4(), 31));
3149
+ TEST_INSTRUCTION("4114414F", ssra(v1.d2(), v2.d2(), 63));
3150
+ TEST_INSTRUCTION("4120230E", ssubl(v1.h8(), v2.b8(), v3.b8()));
3151
+ TEST_INSTRUCTION("4120630E", ssubl(v1.s4(), v2.h4(), v3.h4()));
3152
+ TEST_INSTRUCTION("4120A30E", ssubl(v1.d2(), v2.s2(), v3.s2()));
3153
+ TEST_INSTRUCTION("4120234E", ssubl2(v1.h8(), v2.b16(), v3.b16()));
3154
+ TEST_INSTRUCTION("4120634E", ssubl2(v1.s4(), v2.h8(), v3.h8()));
3155
+ TEST_INSTRUCTION("4120A34E", ssubl2(v1.d2(), v2.s4(), v3.s4()));
3156
+ TEST_INSTRUCTION("4130230E", ssubw(v1.h8(), v2.h8(), v3.b8()));
3157
+ TEST_INSTRUCTION("4130630E", ssubw(v1.s4(), v2.s4(), v3.h4()));
3158
+ TEST_INSTRUCTION("4130A30E", ssubw(v1.d2(), v2.d2(), v3.s2()));
3159
+ TEST_INSTRUCTION("4130234E", ssubw2(v1.h8(), v2.h8(), v3.b16()));
3160
+ TEST_INSTRUCTION("4130634E", ssubw2(v1.s4(), v2.s4(), v3.h8()));
3161
+ TEST_INSTRUCTION("4130A34E", ssubw2(v1.d2(), v2.d2(), v3.s4()));
3162
+ TEST_INSTRUCTION("4100000D", st1(v1.b(0), ptr(x2)));
3163
+ TEST_INSTRUCTION("41009F0D", st1(v1.b(0), ptr_post(x2, 1)));
3164
+ TEST_INSTRUCTION("4140000D", st1(v1.h(0), ptr(x2)));
3165
+ TEST_INSTRUCTION("41409F0D", st1(v1.h(0), ptr_post(x2, 2)));
3166
+ TEST_INSTRUCTION("4180000D", st1(v1.s(0), ptr(x2)));
3167
+ TEST_INSTRUCTION("41809F0D", st1(v1.s(0), ptr_post(x2, 4)));
3168
+ TEST_INSTRUCTION("4184000D", st1(v1.d(0), ptr(x2)));
3169
+ TEST_INSTRUCTION("41849F0D", st1(v1.d(0), ptr_post(x2, 8)));
3170
+ TEST_INSTRUCTION("411C004D", st1(v1.b(15), ptr(x2)));
3171
+ TEST_INSTRUCTION("411C9F4D", st1(v1.b(15), ptr_post(x2, 1)));
3172
+ TEST_INSTRUCTION("4158004D", st1(v1.h(7), ptr(x2)));
3173
+ TEST_INSTRUCTION("41589F4D", st1(v1.h(7), ptr_post(x2, 2)));
3174
+ TEST_INSTRUCTION("4190004D", st1(v1.s(3), ptr(x2)));
3175
+ TEST_INSTRUCTION("41909F4D", st1(v1.s(3), ptr_post(x2, 4)));
3176
+ TEST_INSTRUCTION("4184004D", st1(v1.d(1), ptr(x2)));
3177
+ TEST_INSTRUCTION("41849F4D", st1(v1.d(1), ptr_post(x2, 8)));
3178
+ TEST_INSTRUCTION("4170000C", st1(v1.b8(), ptr(x2)));
3179
+ TEST_INSTRUCTION("41709F0C", st1(v1.b8(), ptr_post(x2, 8)));
3180
+ TEST_INSTRUCTION("4170004C", st1(v1.b16(), ptr(x2)));
3181
+ TEST_INSTRUCTION("41709F4C", st1(v1.b16(), ptr_post(x2, 16)));
3182
+ TEST_INSTRUCTION("61A0000C", st1(v1.b8(), v2.b8(), ptr(x3)));
3183
+ TEST_INSTRUCTION("61A09F0C", st1(v1.b8(), v2.b8(), ptr_post(x3, 16)));
3184
+ TEST_INSTRUCTION("61A0004C", st1(v1.b16(), v2.b16(), ptr(x3)));
3185
+ TEST_INSTRUCTION("61A09F4C", st1(v1.b16(), v2.b16(), ptr_post(x3, 32)));
3186
+ TEST_INSTRUCTION("8160000C", st1(v1.b8(), v2.b8(), v3.b8(), ptr(x4)));
3187
+ TEST_INSTRUCTION("81609F0C", st1(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24)));
3188
+ TEST_INSTRUCTION("8160004C", st1(v1.b16(), v2.b16(), v3.b16(), ptr(x4)));
3189
+ TEST_INSTRUCTION("81609F4C", st1(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48)));
3190
+ TEST_INSTRUCTION("A120000C", st1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5)));
3191
+ TEST_INSTRUCTION("A1209F0C", st1(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32)));
3192
+ TEST_INSTRUCTION("A120004C", st1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5)));
3193
+ TEST_INSTRUCTION("A1209F4C", st1(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64)));
3194
+ TEST_INSTRUCTION("4174000C", st1(v1.h4(), ptr(x2)));
3195
+ TEST_INSTRUCTION("41749F0C", st1(v1.h4(), ptr_post(x2, 8)));
3196
+ TEST_INSTRUCTION("4174004C", st1(v1.h8(), ptr(x2)));
3197
+ TEST_INSTRUCTION("41749F4C", st1(v1.h8(), ptr_post(x2, 16)));
3198
+ TEST_INSTRUCTION("61A4000C", st1(v1.h4(), v2.h4(), ptr(x3)));
3199
+ TEST_INSTRUCTION("61A49F0C", st1(v1.h4(), v2.h4(), ptr_post(x3, 16)));
3200
+ TEST_INSTRUCTION("61A4004C", st1(v1.h8(), v2.h8(), ptr(x3)));
3201
+ TEST_INSTRUCTION("61A49F4C", st1(v1.h8(), v2.h8(), ptr_post(x3, 32)));
3202
+ TEST_INSTRUCTION("8164000C", st1(v1.h4(), v2.h4(), v3.h4(), ptr(x4)));
3203
+ TEST_INSTRUCTION("81649F0C", st1(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24)));
3204
+ TEST_INSTRUCTION("8164004C", st1(v1.h8(), v2.h8(), v3.h8(), ptr(x4)));
3205
+ TEST_INSTRUCTION("81649F4C", st1(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48)));
3206
+ TEST_INSTRUCTION("A124000C", st1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5)));
3207
+ TEST_INSTRUCTION("A1249F0C", st1(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32)));
3208
+ TEST_INSTRUCTION("A124004C", st1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5)));
3209
+ TEST_INSTRUCTION("A1249F4C", st1(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64)));
3210
+ TEST_INSTRUCTION("4178000C", st1(v1.s2(), ptr(x2)));
3211
+ TEST_INSTRUCTION("41789F0C", st1(v1.s2(), ptr_post(x2, 8)));
3212
+ TEST_INSTRUCTION("4178004C", st1(v1.s4(), ptr(x2)));
3213
+ TEST_INSTRUCTION("41789F4C", st1(v1.s4(), ptr_post(x2, 16)));
3214
+ TEST_INSTRUCTION("61A8000C", st1(v1.s2(), v2.s2(), ptr(x3)));
3215
+ TEST_INSTRUCTION("61A89F0C", st1(v1.s2(), v2.s2(), ptr_post(x3, 16)));
3216
+ TEST_INSTRUCTION("61A8004C", st1(v1.s4(), v2.s4(), ptr(x3)));
3217
+ TEST_INSTRUCTION("61A89F4C", st1(v1.s4(), v2.s4(), ptr_post(x3, 32)));
3218
+ TEST_INSTRUCTION("8168000C", st1(v1.s2(), v2.s2(), v3.s2(), ptr(x4)));
3219
+ TEST_INSTRUCTION("81689F0C", st1(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24)));
3220
+ TEST_INSTRUCTION("8168004C", st1(v1.s4(), v2.s4(), v3.s4(), ptr(x4)));
3221
+ TEST_INSTRUCTION("81689F4C", st1(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48)));
3222
+ TEST_INSTRUCTION("A128000C", st1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5)));
3223
+ TEST_INSTRUCTION("A1289F0C", st1(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32)));
3224
+ TEST_INSTRUCTION("A128004C", st1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5)));
3225
+ TEST_INSTRUCTION("A1289F4C", st1(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64)));
3226
+ TEST_INSTRUCTION("417C004C", st1(v1.d2(), ptr(x2)));
3227
+ TEST_INSTRUCTION("417C9F4C", st1(v1.d2(), ptr_post(x2, 16)));
3228
+ TEST_INSTRUCTION("61AC004C", st1(v1.d2(), v2.d2(), ptr(x3)));
3229
+ TEST_INSTRUCTION("61AC9F4C", st1(v1.d2(), v2.d2(), ptr_post(x3, 32)));
3230
+ TEST_INSTRUCTION("816C004C", st1(v1.d2(), v2.d2(), v3.d2(), ptr(x4)));
3231
+ TEST_INSTRUCTION("816C9F4C", st1(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48)));
3232
+ TEST_INSTRUCTION("A12C004C", st1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5)));
3233
+ TEST_INSTRUCTION("A12C9F4C", st1(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64)));
3234
+ TEST_INSTRUCTION("6100200D", st2(v1.b(0), v2.b(0), ptr(x3)));
3235
+ TEST_INSTRUCTION("6100BF0D", st2(v1.b(0), v2.b(0), ptr_post(x3, 2)));
3236
+ TEST_INSTRUCTION("6100AB0D", st2(v1.b(0), v2.b(0), ptr_post(x3, x11)));
3237
+ TEST_INSTRUCTION("6140200D", st2(v1.h(0), v2.h(0), ptr(x3)));
3238
+ TEST_INSTRUCTION("6140BF0D", st2(v1.h(0), v2.h(0), ptr_post(x3, 4)));
3239
+ TEST_INSTRUCTION("6140AB0D", st2(v1.h(0), v2.h(0), ptr_post(x3, x11)));
3240
+ TEST_INSTRUCTION("6180200D", st2(v1.s(0), v2.s(0), ptr(x3)));
3241
+ TEST_INSTRUCTION("6180BF0D", st2(v1.s(0), v2.s(0), ptr_post(x3, 8)));
3242
+ TEST_INSTRUCTION("6180AB0D", st2(v1.s(0), v2.s(0), ptr_post(x3, x11)));
3243
+ TEST_INSTRUCTION("6184200D", st2(v1.d(0), v2.d(0), ptr(x3)));
3244
+ TEST_INSTRUCTION("6184BF0D", st2(v1.d(0), v2.d(0), ptr_post(x3, 16)));
3245
+ TEST_INSTRUCTION("6184AB0D", st2(v1.d(0), v2.d(0), ptr_post(x3, x11)));
3246
+ TEST_INSTRUCTION("611C204D", st2(v1.b(15), v2.b(15), ptr(x3)));
3247
+ TEST_INSTRUCTION("611CBF4D", st2(v1.b(15), v2.b(15), ptr_post(x3, 2)));
3248
+ TEST_INSTRUCTION("611CAB4D", st2(v1.b(15), v2.b(15), ptr_post(x3, x11)));
3249
+ TEST_INSTRUCTION("6158204D", st2(v1.h(7), v2.h(7), ptr(x3)));
3250
+ TEST_INSTRUCTION("6158BF4D", st2(v1.h(7), v2.h(7), ptr_post(x3, 4)));
3251
+ TEST_INSTRUCTION("6158AB4D", st2(v1.h(7), v2.h(7), ptr_post(x3, x11)));
3252
+ TEST_INSTRUCTION("6190204D", st2(v1.s(3), v2.s(3), ptr(x3)));
3253
+ TEST_INSTRUCTION("6190BF4D", st2(v1.s(3), v2.s(3), ptr_post(x3, 8)));
3254
+ TEST_INSTRUCTION("6190AB4D", st2(v1.s(3), v2.s(3), ptr_post(x3, x11)));
3255
+ TEST_INSTRUCTION("6184204D", st2(v1.d(1), v2.d(1), ptr(x3)));
3256
+ TEST_INSTRUCTION("6184BF4D", st2(v1.d(1), v2.d(1), ptr_post(x3, 16)));
3257
+ TEST_INSTRUCTION("6184AB4D", st2(v1.d(1), v2.d(1), ptr_post(x3, x11)));
3258
+ TEST_INSTRUCTION("6180000C", st2(v1.b8(), v2.b8(), ptr(x3)));
3259
+ TEST_INSTRUCTION("61809F0C", st2(v1.b8(), v2.b8(), ptr_post(x3, 16)));
3260
+ TEST_INSTRUCTION("61808B0C", st2(v1.b8(), v2.b8(), ptr_post(x3, x11)));
3261
+ TEST_INSTRUCTION("6180004C", st2(v1.b16(), v2.b16(), ptr(x3)));
3262
+ TEST_INSTRUCTION("61809F4C", st2(v1.b16(), v2.b16(), ptr_post(x3, 32)));
3263
+ TEST_INSTRUCTION("61808B4C", st2(v1.b16(), v2.b16(), ptr_post(x3, x11)));
3264
+ TEST_INSTRUCTION("6184000C", st2(v1.h4(), v2.h4(), ptr(x3)));
3265
+ TEST_INSTRUCTION("61849F0C", st2(v1.h4(), v2.h4(), ptr_post(x3, 16)));
3266
+ TEST_INSTRUCTION("61848B0C", st2(v1.h4(), v2.h4(), ptr_post(x3, x11)));
3267
+ TEST_INSTRUCTION("6184004C", st2(v1.h8(), v2.h8(), ptr(x3)));
3268
+ TEST_INSTRUCTION("61849F4C", st2(v1.h8(), v2.h8(), ptr_post(x3, 32)));
3269
+ TEST_INSTRUCTION("61848B4C", st2(v1.h8(), v2.h8(), ptr_post(x3, x11)));
3270
+ TEST_INSTRUCTION("6188000C", st2(v1.s2(), v2.s2(), ptr(x3)));
3271
+ TEST_INSTRUCTION("61889F0C", st2(v1.s2(), v2.s2(), ptr_post(x3, 16)));
3272
+ TEST_INSTRUCTION("61888B0C", st2(v1.s2(), v2.s2(), ptr_post(x3, x11)));
3273
+ TEST_INSTRUCTION("6188004C", st2(v1.s4(), v2.s4(), ptr(x3)));
3274
+ TEST_INSTRUCTION("61889F4C", st2(v1.s4(), v2.s4(), ptr_post(x3, 32)));
3275
+ TEST_INSTRUCTION("61888B4C", st2(v1.s4(), v2.s4(), ptr_post(x3, x11)));
3276
+ TEST_INSTRUCTION("618C004C", st2(v1.d2(), v2.d2(), ptr(x3)));
3277
+ TEST_INSTRUCTION("618C9F4C", st2(v1.d2(), v2.d2(), ptr_post(x3, 32)));
3278
+ TEST_INSTRUCTION("618C8B4C", st2(v1.d2(), v2.d2(), ptr_post(x3, x11)));
3279
+ TEST_INSTRUCTION("8120000D", st3(v1.b(0), v2.b(0), v3.b(0), ptr(x4)));
3280
+ TEST_INSTRUCTION("81209F0D", st3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, 3)));
3281
+ TEST_INSTRUCTION("81208B0D", st3(v1.b(0), v2.b(0), v3.b(0), ptr_post(x4, x11)));
3282
+ TEST_INSTRUCTION("8160000D", st3(v1.h(0), v2.h(0), v3.h(0), ptr(x4)));
3283
+ TEST_INSTRUCTION("81609F0D", st3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, 6)));
3284
+ TEST_INSTRUCTION("81608B0D", st3(v1.h(0), v2.h(0), v3.h(0), ptr_post(x4, x11)));
3285
+ TEST_INSTRUCTION("81A0000D", st3(v1.s(0), v2.s(0), v3.s(0), ptr(x4)));
3286
+ TEST_INSTRUCTION("81A09F0D", st3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, 12)));
3287
+ TEST_INSTRUCTION("81A08B0D", st3(v1.s(0), v2.s(0), v3.s(0), ptr_post(x4, x11)));
3288
+ TEST_INSTRUCTION("81A4000D", st3(v1.d(0), v2.d(0), v3.d(0), ptr(x4)));
3289
+ TEST_INSTRUCTION("81A49F0D", st3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, 24)));
3290
+ TEST_INSTRUCTION("81A48B0D", st3(v1.d(0), v2.d(0), v3.d(0), ptr_post(x4, x11)));
3291
+ TEST_INSTRUCTION("813C004D", st3(v1.b(15), v2.b(15), v3.b(15), ptr(x4)));
3292
+ TEST_INSTRUCTION("813C9F4D", st3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, 3)));
3293
+ TEST_INSTRUCTION("813C8B4D", st3(v1.b(15), v2.b(15), v3.b(15), ptr_post(x4, x11)));
3294
+ TEST_INSTRUCTION("8178004D", st3(v1.h(7), v2.h(7), v3.h(7), ptr(x4)));
3295
+ TEST_INSTRUCTION("81789F4D", st3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, 6)));
3296
+ TEST_INSTRUCTION("81788B4D", st3(v1.h(7), v2.h(7), v3.h(7), ptr_post(x4, x11)));
3297
+ TEST_INSTRUCTION("81B0004D", st3(v1.s(3), v2.s(3), v3.s(3), ptr(x4)));
3298
+ TEST_INSTRUCTION("81B09F4D", st3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, 12)));
3299
+ TEST_INSTRUCTION("81B08B4D", st3(v1.s(3), v2.s(3), v3.s(3), ptr_post(x4, x11)));
3300
+ TEST_INSTRUCTION("81A4004D", st3(v1.d(1), v2.d(1), v3.d(1), ptr(x4)));
3301
+ TEST_INSTRUCTION("81A49F4D", st3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, 24)));
3302
+ TEST_INSTRUCTION("81A48B4D", st3(v1.d(1), v2.d(1), v3.d(1), ptr_post(x4, x11)));
3303
+ TEST_INSTRUCTION("8140000C", st3(v1.b8(), v2.b8(), v3.b8(), ptr(x4)));
3304
+ TEST_INSTRUCTION("81409F0C", st3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, 24)));
3305
+ TEST_INSTRUCTION("81408B0C", st3(v1.b8(), v2.b8(), v3.b8(), ptr_post(x4, x11)));
3306
+ TEST_INSTRUCTION("8140004C", st3(v1.b16(), v2.b16(), v3.b16(), ptr(x4)));
3307
+ TEST_INSTRUCTION("81409F4C", st3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, 48)));
3308
+ TEST_INSTRUCTION("81408B4C", st3(v1.b16(), v2.b16(), v3.b16(), ptr_post(x4, x11)));
3309
+ TEST_INSTRUCTION("8144000C", st3(v1.h4(), v2.h4(), v3.h4(), ptr(x4)));
3310
+ TEST_INSTRUCTION("81449F0C", st3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, 24)));
3311
+ TEST_INSTRUCTION("81448B0C", st3(v1.h4(), v2.h4(), v3.h4(), ptr_post(x4, x11)));
3312
+ TEST_INSTRUCTION("8144004C", st3(v1.h8(), v2.h8(), v3.h8(), ptr(x4)));
3313
+ TEST_INSTRUCTION("81449F4C", st3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, 48)));
3314
+ TEST_INSTRUCTION("81448B4C", st3(v1.h8(), v2.h8(), v3.h8(), ptr_post(x4, x11)));
3315
+ TEST_INSTRUCTION("8148000C", st3(v1.s2(), v2.s2(), v3.s2(), ptr(x4)));
3316
+ TEST_INSTRUCTION("81489F0C", st3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, 24)));
3317
+ TEST_INSTRUCTION("81488B0C", st3(v1.s2(), v2.s2(), v3.s2(), ptr_post(x4, x11)));
3318
+ TEST_INSTRUCTION("8148004C", st3(v1.s4(), v2.s4(), v3.s4(), ptr(x4)));
3319
+ TEST_INSTRUCTION("81489F4C", st3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, 48)));
3320
+ TEST_INSTRUCTION("81488B4C", st3(v1.s4(), v2.s4(), v3.s4(), ptr_post(x4, x11)));
3321
+ TEST_INSTRUCTION("814C004C", st3(v1.d2(), v2.d2(), v3.d2(), ptr(x4)));
3322
+ TEST_INSTRUCTION("814C9F4C", st3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, 48)));
3323
+ TEST_INSTRUCTION("814C8B4C", st3(v1.d2(), v2.d2(), v3.d2(), ptr_post(x4, x11)));
3324
+ TEST_INSTRUCTION("A120200D", st4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr(x5)));
3325
+ TEST_INSTRUCTION("A120BF0D", st4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, 4)));
3326
+ TEST_INSTRUCTION("A120AB0D", st4(v1.b(0), v2.b(0), v3.b(0), v4.b(0), ptr_post(x5, x11)));
3327
+ TEST_INSTRUCTION("A160200D", st4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr(x5)));
3328
+ TEST_INSTRUCTION("A160BF0D", st4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, 8)));
3329
+ TEST_INSTRUCTION("A160AB0D", st4(v1.h(0), v2.h(0), v3.h(0), v4.h(0), ptr_post(x5, x11)));
3330
+ TEST_INSTRUCTION("A1A0200D", st4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr(x5)));
3331
+ TEST_INSTRUCTION("A1A0BF0D", st4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, 16)));
3332
+ TEST_INSTRUCTION("A1A0AB0D", st4(v1.s(0), v2.s(0), v3.s(0), v4.s(0), ptr_post(x5, x11)));
3333
+ TEST_INSTRUCTION("A1A4200D", st4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr(x5)));
3334
+ TEST_INSTRUCTION("A1A4BF0D", st4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, 32)));
3335
+ TEST_INSTRUCTION("A1A4AB0D", st4(v1.d(0), v2.d(0), v3.d(0), v4.d(0), ptr_post(x5, x11)));
3336
+ TEST_INSTRUCTION("A13C204D", st4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr(x5)));
3337
+ TEST_INSTRUCTION("A13CBF4D", st4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, 4)));
3338
+ TEST_INSTRUCTION("A13CAB4D", st4(v1.b(15), v2.b(15), v3.b(15), v4.b(15), ptr_post(x5, x11)));
3339
+ TEST_INSTRUCTION("A178204D", st4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr(x5)));
3340
+ TEST_INSTRUCTION("A178BF4D", st4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, 8)));
3341
+ TEST_INSTRUCTION("A178AB4D", st4(v1.h(7), v2.h(7), v3.h(7), v4.h(7), ptr_post(x5, x11)));
3342
+ TEST_INSTRUCTION("A1B0204D", st4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr(x5)));
3343
+ TEST_INSTRUCTION("A1B0BF4D", st4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, 16)));
3344
+ TEST_INSTRUCTION("A1B0AB4D", st4(v1.s(3), v2.s(3), v3.s(3), v4.s(3), ptr_post(x5, x11)));
3345
+ TEST_INSTRUCTION("A1A4204D", st4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr(x5)));
3346
+ TEST_INSTRUCTION("A1A4BF4D", st4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, 32)));
3347
+ TEST_INSTRUCTION("A1A4AB4D", st4(v1.d(1), v2.d(1), v3.d(1), v4.d(1), ptr_post(x5, x11)));
3348
+ TEST_INSTRUCTION("A100000C", st4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr(x5)));
3349
+ TEST_INSTRUCTION("A1009F0C", st4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, 32)));
3350
+ TEST_INSTRUCTION("A1008B0C", st4(v1.b8(), v2.b8(), v3.b8(), v4.b8(), ptr_post(x5, x11)));
3351
+ TEST_INSTRUCTION("A100004C", st4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr(x5)));
3352
+ TEST_INSTRUCTION("A1009F4C", st4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, 64)));
3353
+ TEST_INSTRUCTION("A1008B4C", st4(v1.b16(), v2.b16(), v3.b16(), v4.b16(), ptr_post(x5, x11)));
3354
+ TEST_INSTRUCTION("A104000C", st4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr(x5)));
3355
+ TEST_INSTRUCTION("A1049F0C", st4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, 32)));
3356
+ TEST_INSTRUCTION("A1048B0C", st4(v1.h4(), v2.h4(), v3.h4(), v4.h4(), ptr_post(x5, x11)));
3357
+ TEST_INSTRUCTION("A104004C", st4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr(x5)));
3358
+ TEST_INSTRUCTION("A1049F4C", st4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, 64)));
3359
+ TEST_INSTRUCTION("A1048B4C", st4(v1.h8(), v2.h8(), v3.h8(), v4.h8(), ptr_post(x5, x11)));
3360
+ TEST_INSTRUCTION("A108000C", st4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr(x5)));
3361
+ TEST_INSTRUCTION("A1089F0C", st4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, 32)));
3362
+ TEST_INSTRUCTION("A1088B0C", st4(v1.s2(), v2.s2(), v3.s2(), v4.s2(), ptr_post(x5, x11)));
3363
+ TEST_INSTRUCTION("A108004C", st4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr(x5)));
3364
+ TEST_INSTRUCTION("A1089F4C", st4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, 64)));
3365
+ TEST_INSTRUCTION("A1088B4C", st4(v1.s4(), v2.s4(), v3.s4(), v4.s4(), ptr_post(x5, x11)));
3366
+ TEST_INSTRUCTION("A10C004C", st4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr(x5)));
3367
+ TEST_INSTRUCTION("A10C9F4C", st4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, 64)));
3368
+ TEST_INSTRUCTION("A10C8B4C", st4(v1.d2(), v2.d2(), v3.d2(), v4.d2(), ptr_post(x5, x11)));
3369
+ TEST_INSTRUCTION("8109002C", stnp(s1, s2, ptr(x12)));
3370
+ TEST_INSTRUCTION("8189002C", stnp(s1, s2, ptr(x12, 4)));
3371
+ TEST_INSTRUCTION("8109302C", stnp(s1, s2, ptr(x12, -128)));
3372
+ TEST_INSTRUCTION("E10B002C", stnp(s1, s2, ptr(sp)));
3373
+ TEST_INSTRUCTION("E18B002C", stnp(s1, s2, ptr(sp, 4)));
3374
+ TEST_INSTRUCTION("E10B102C", stnp(s1, s2, ptr(sp, 128)));
3375
+ TEST_INSTRUCTION("8109006C", stnp(d1, d2, ptr(x12)));
3376
+ TEST_INSTRUCTION("8189006C", stnp(d1, d2, ptr(x12, 8)));
3377
+ TEST_INSTRUCTION("8109386C", stnp(d1, d2, ptr(x12, -128)));
3378
+ TEST_INSTRUCTION("E10B006C", stnp(d1, d2, ptr(sp)));
3379
+ TEST_INSTRUCTION("E18B006C", stnp(d1, d2, ptr(sp, 8)));
3380
+ TEST_INSTRUCTION("E10B086C", stnp(d1, d2, ptr(sp, 128)));
3381
+ TEST_INSTRUCTION("810900AC", stnp(q1, q2, ptr(x12)));
3382
+ TEST_INSTRUCTION("818900AC", stnp(q1, q2, ptr(x12, 16)));
3383
+ TEST_INSTRUCTION("81093CAC", stnp(q1, q2, ptr(x12, -128)));
3384
+ TEST_INSTRUCTION("E10B00AC", stnp(q1, q2, ptr(sp)));
3385
+ TEST_INSTRUCTION("E18B00AC", stnp(q1, q2, ptr(sp, 16)));
3386
+ TEST_INSTRUCTION("E10B04AC", stnp(q1, q2, ptr(sp, 128)));
3387
+ TEST_INSTRUCTION("8109002D", stp(s1, s2, ptr(x12)));
3388
+ TEST_INSTRUCTION("8189002D", stp(s1, s2, ptr(x12, 4)));
3389
+ TEST_INSTRUCTION("8109302D", stp(s1, s2, ptr(x12, -128)));
3390
+ TEST_INSTRUCTION("8189802D", stp(s1, s2, ptr_pre(x12, 4)));
3391
+ TEST_INSTRUCTION("8189802C", stp(s1, s2, ptr_post(x12, 4)));
3392
+ TEST_INSTRUCTION("E10B002D", stp(s1, s2, ptr(sp)));
3393
+ TEST_INSTRUCTION("E18B002D", stp(s1, s2, ptr(sp, 4)));
3394
+ TEST_INSTRUCTION("E10B102D", stp(s1, s2, ptr(sp, 128)));
3395
+ TEST_INSTRUCTION("E18B802D", stp(s1, s2, ptr_pre(sp, 4)));
3396
+ TEST_INSTRUCTION("E18B802C", stp(s1, s2, ptr_post(sp, 4)));
3397
+ TEST_INSTRUCTION("8109006D", stp(d1, d2, ptr(x12)));
3398
+ TEST_INSTRUCTION("8189006D", stp(d1, d2, ptr(x12, 8)));
3399
+ TEST_INSTRUCTION("8109386D", stp(d1, d2, ptr(x12, -128)));
3400
+ TEST_INSTRUCTION("8189806D", stp(d1, d2, ptr_pre(x12, 8)));
3401
+ TEST_INSTRUCTION("8189806C", stp(d1, d2, ptr_post(x12, 8)));
3402
+ TEST_INSTRUCTION("E10B006D", stp(d1, d2, ptr(sp)));
3403
+ TEST_INSTRUCTION("E18B006D", stp(d1, d2, ptr(sp, 8)));
3404
+ TEST_INSTRUCTION("E10B086D", stp(d1, d2, ptr(sp, 128)));
3405
+ TEST_INSTRUCTION("E18B806D", stp(d1, d2, ptr_pre(sp, 8)));
3406
+ TEST_INSTRUCTION("E18B806C", stp(d1, d2, ptr_post(sp, 8)));
3407
+ TEST_INSTRUCTION("810900AD", stp(q1, q2, ptr(x12)));
3408
+ TEST_INSTRUCTION("818900AD", stp(q1, q2, ptr(x12, 16)));
3409
+ TEST_INSTRUCTION("81093CAD", stp(q1, q2, ptr(x12, -128)));
3410
+ TEST_INSTRUCTION("818980AD", stp(q1, q2, ptr_pre(x12, 16)));
3411
+ TEST_INSTRUCTION("818980AC", stp(q1, q2, ptr_post(x12, 16)));
3412
+ TEST_INSTRUCTION("E10B00AD", stp(q1, q2, ptr(sp)));
3413
+ TEST_INSTRUCTION("E18B00AD", stp(q1, q2, ptr(sp, 16)));
3414
+ TEST_INSTRUCTION("E10B04AD", stp(q1, q2, ptr(sp, 128)));
3415
+ TEST_INSTRUCTION("E18B80AD", stp(q1, q2, ptr_pre(sp, 16)));
3416
+ TEST_INSTRUCTION("E18B80AC", stp(q1, q2, ptr_post(sp, 16)));
3417
+ TEST_INSTRUCTION("4100003D", str(b1, ptr(x2)));
3418
+ TEST_INSTRUCTION("4114003C", str(b1, ptr_post(x2, 1)));
3419
+ TEST_INSTRUCTION("4104003D", str(b1, ptr(x2, 1)));
3420
+ TEST_INSTRUCTION("411C003C", str(b1, ptr_pre(x2, 1)));
3421
+ TEST_INSTRUCTION("4114083C", str(b1, ptr_post(x2, 129)));
3422
+ TEST_INSTRUCTION("4100007D", str(h1, ptr(x2)));
3423
+ TEST_INSTRUCTION("4124007C", str(h1, ptr_post(x2, 2)));
3424
+ TEST_INSTRUCTION("4104007D", str(h1, ptr(x2, 2)));
3425
+ TEST_INSTRUCTION("412C007C", str(h1, ptr_pre(x2, 2)));
3426
+ TEST_INSTRUCTION("4124087C", str(h1, ptr_post(x2, 130)));
3427
+ TEST_INSTRUCTION("410000BD", str(s1, ptr(x2)));
3428
+ TEST_INSTRUCTION("414400BC", str(s1, ptr_post(x2, 4)));
3429
+ TEST_INSTRUCTION("410400BD", str(s1, ptr(x2, 4)));
3430
+ TEST_INSTRUCTION("414C00BC", str(s1, ptr_pre(x2, 4)));
3431
+ TEST_INSTRUCTION("414408BC", str(s1, ptr_post(x2, 132)));
3432
+ TEST_INSTRUCTION("410000FD", str(d1, ptr(x2)));
3433
+ TEST_INSTRUCTION("418400FC", str(d1, ptr_post(x2, 8)));
3434
+ TEST_INSTRUCTION("410400FD", str(d1, ptr(x2, 8)));
3435
+ TEST_INSTRUCTION("418C00FC", str(d1, ptr_pre(x2, 8)));
3436
+ TEST_INSTRUCTION("414408FC", str(d1, ptr_post(x2, 132)));
3437
+ TEST_INSTRUCTION("4168233C", str(b1, ptr(x2, x3)));
3438
+ TEST_INSTRUCTION("4148233C", str(b1, ptr(x2, w3, uxtw(0))));
3439
+ TEST_INSTRUCTION("41C8233C", str(b1, ptr(x2, w3, sxtw(0))));
3440
+ TEST_INSTRUCTION("4168237C", str(h1, ptr(x2, x3)));
3441
+ TEST_INSTRUCTION("4178237C", str(h1, ptr(x2, x3, lsl(1))));
3442
+ TEST_INSTRUCTION("4148237C", str(h1, ptr(x2, w3, uxtw(0))));
3443
+ TEST_INSTRUCTION("4158237C", str(h1, ptr(x2, w3, uxtw(1))));
3444
+ TEST_INSTRUCTION("41C8237C", str(h1, ptr(x2, w3, sxtw(0))));
3445
+ TEST_INSTRUCTION("41D8237C", str(h1, ptr(x2, w3, sxtw(1))));
3446
+ TEST_INSTRUCTION("416823BC", str(s1, ptr(x2, x3)));
3447
+ TEST_INSTRUCTION("417823BC", str(s1, ptr(x2, x3, lsl(2))));
3448
+ TEST_INSTRUCTION("414823BC", str(s1, ptr(x2, w3, uxtw(0))));
3449
+ TEST_INSTRUCTION("415823BC", str(s1, ptr(x2, w3, uxtw(2))));
3450
+ TEST_INSTRUCTION("41C823BC", str(s1, ptr(x2, w3, sxtw(0))));
3451
+ TEST_INSTRUCTION("41D823BC", str(s1, ptr(x2, w3, sxtw(2))));
3452
+ TEST_INSTRUCTION("416823FC", str(d1, ptr(x2, x3)));
3453
+ TEST_INSTRUCTION("417823FC", str(d1, ptr(x2, x3, lsl(3))));
3454
+ TEST_INSTRUCTION("414823FC", str(d1, ptr(x2, w3, uxtw(0))));
3455
+ TEST_INSTRUCTION("415823FC", str(d1, ptr(x2, w3, uxtw(3))));
3456
+ TEST_INSTRUCTION("41C823FC", str(d1, ptr(x2, w3, sxtw(0))));
3457
+ TEST_INSTRUCTION("41D823FC", str(d1, ptr(x2, w3, sxtw(3))));
3458
+ TEST_INSTRUCTION("4104003D", str(b1, ptr(x2, 1)));
3459
+ TEST_INSTRUCTION("41F01F3C", str(b1, ptr(x2, -1))); // STUR
3460
+ TEST_INSTRUCTION("4110007C", str(h1, ptr(x2, 1))); // STUR
3461
+ TEST_INSTRUCTION("41F01F7C", str(h1, ptr(x2, -1))); // STUR
3462
+ TEST_INSTRUCTION("411000BC", str(s1, ptr(x2, 1))); // STUR
3463
+ TEST_INSTRUCTION("41F01FBC", str(s1, ptr(x2, -1))); // STUR
3464
+ TEST_INSTRUCTION("411000FC", str(d1, ptr(x2, 1))); // STUR
3465
+ TEST_INSTRUCTION("41F01FFC", str(d1, ptr(x2, -1))); // STUR
3466
+ TEST_INSTRUCTION("8101003C", stur(b1, ptr(x12)));
3467
+ TEST_INSTRUCTION("8131003C", stur(b1, ptr(x12, 3)));
3468
+ TEST_INSTRUCTION("8131063C", stur(b1, ptr(x12, 99)));
3469
+ TEST_INSTRUCTION("81F10F3C", stur(b1, ptr(x12, 255)));
3470
+ TEST_INSTRUCTION("8101103C", stur(b1, ptr(x12, -256)));
3471
+ TEST_INSTRUCTION("E103003C", stur(b1, ptr(sp)));
3472
+ TEST_INSTRUCTION("E153083C", stur(b1, ptr(sp, 133)));
3473
+ TEST_INSTRUCTION("8101007C", stur(h1, ptr(x12)));
3474
+ TEST_INSTRUCTION("8131007C", stur(h1, ptr(x12, 3)));
3475
+ TEST_INSTRUCTION("8131067C", stur(h1, ptr(x12, 99)));
3476
+ TEST_INSTRUCTION("81F10F7C", stur(h1, ptr(x12, 255)));
3477
+ TEST_INSTRUCTION("8101107C", stur(h1, ptr(x12, -256)));
3478
+ TEST_INSTRUCTION("E103007C", stur(h1, ptr(sp)));
3479
+ TEST_INSTRUCTION("E153087C", stur(h1, ptr(sp, 133)));
3480
+ TEST_INSTRUCTION("810100BC", stur(s1, ptr(x12)));
3481
+ TEST_INSTRUCTION("813100BC", stur(s1, ptr(x12, 3)));
3482
+ TEST_INSTRUCTION("813106BC", stur(s1, ptr(x12, 99)));
3483
+ TEST_INSTRUCTION("81F10FBC", stur(s1, ptr(x12, 255)));
3484
+ TEST_INSTRUCTION("810110BC", stur(s1, ptr(x12, -256)));
3485
+ TEST_INSTRUCTION("E10300BC", stur(s1, ptr(sp)));
3486
+ TEST_INSTRUCTION("E15308BC", stur(s1, ptr(sp, 133)));
3487
+ TEST_INSTRUCTION("810100FC", stur(d1, ptr(x12)));
3488
+ TEST_INSTRUCTION("813100FC", stur(d1, ptr(x12, 3)));
3489
+ TEST_INSTRUCTION("813106FC", stur(d1, ptr(x12, 99)));
3490
+ TEST_INSTRUCTION("81F10FFC", stur(d1, ptr(x12, 255)));
3491
+ TEST_INSTRUCTION("810110FC", stur(d1, ptr(x12, -256)));
3492
+ TEST_INSTRUCTION("E10300FC", stur(d1, ptr(sp)));
3493
+ TEST_INSTRUCTION("E15308FC", stur(d1, ptr(sp, 133)));
3494
+ TEST_INSTRUCTION("8101803C", stur(q1, ptr(x12)));
3495
+ TEST_INSTRUCTION("8131803C", stur(q1, ptr(x12, 3)));
3496
+ TEST_INSTRUCTION("8131863C", stur(q1, ptr(x12, 99)));
3497
+ TEST_INSTRUCTION("81F18F3C", stur(q1, ptr(x12, 255)));
3498
+ TEST_INSTRUCTION("8101903C", stur(q1, ptr(x12, -256)));
3499
+ TEST_INSTRUCTION("E103803C", stur(q1, ptr(sp)));
3500
+ TEST_INSTRUCTION("E153883C", stur(q1, ptr(sp, 133)));
3501
+ TEST_INSTRUCTION("4184232E", sub(v1.b8(), v2.b8(), v3.b8()));
3502
+ TEST_INSTRUCTION("4184632E", sub(v1.h4(), v2.h4(), v3.h4()));
3503
+ TEST_INSTRUCTION("4184A32E", sub(v1.s2(), v2.s2(), v3.s2()));
3504
+ TEST_INSTRUCTION("4184E37E", sub(d1, d2, d3));
3505
+ TEST_INSTRUCTION("4184236E", sub(v1.b16(), v2.b16(), v3.b16()));
3506
+ TEST_INSTRUCTION("4184636E", sub(v1.h8(), v2.h8(), v3.h8()));
3507
+ TEST_INSTRUCTION("4184A36E", sub(v1.s4(), v2.s4(), v3.s4()));
3508
+ TEST_INSTRUCTION("4184E36E", sub(v1.d2(), v2.d2(), v3.d2()));
3509
+ TEST_INSTRUCTION("4160230E", subhn(v1.b8(), v2.h8(), v3.h8()));
3510
+ TEST_INSTRUCTION("4160630E", subhn(v1.h4(), v2.s4(), v3.s4()));
3511
+ TEST_INSTRUCTION("4160A30E", subhn(v1.s2(), v2.d2(), v3.d2()));
3512
+ TEST_INSTRUCTION("4160234E", subhn2(v1.b16(), v2.h8(), v3.h8()));
3513
+ TEST_INSTRUCTION("4160634E", subhn2(v1.h8(), v2.s4(), v3.s4()));
3514
+ TEST_INSTRUCTION("4160A34E", subhn2(v1.s4(), v2.d2(), v3.d2()));
3515
+ TEST_INSTRUCTION("41F0030F", sudot(v1.s2(), v2.b8(), v3.b4(0)));
3516
+ TEST_INSTRUCTION("41F0230F", sudot(v1.s2(), v2.b8(), v3.b4(1)));
3517
+ TEST_INSTRUCTION("41F8030F", sudot(v1.s2(), v2.b8(), v3.b4(2)));
3518
+ TEST_INSTRUCTION("41F8230F", sudot(v1.s2(), v2.b8(), v3.b4(3)));
3519
+ TEST_INSTRUCTION("41F0034F", sudot(v1.s4(), v2.b16(), v3.b4(0)));
3520
+ TEST_INSTRUCTION("41F0234F", sudot(v1.s4(), v2.b16(), v3.b4(1)));
3521
+ TEST_INSTRUCTION("41F8034F", sudot(v1.s4(), v2.b16(), v3.b4(2)));
3522
+ TEST_INSTRUCTION("41F8234F", sudot(v1.s4(), v2.b16(), v3.b4(3)));
3523
+ TEST_INSTRUCTION("4138205E", suqadd(b1, b2));
3524
+ TEST_INSTRUCTION("4138605E", suqadd(h1, h2));
3525
+ TEST_INSTRUCTION("4138A05E", suqadd(s1, s2));
3526
+ TEST_INSTRUCTION("4138E05E", suqadd(d1, d2));
3527
+ TEST_INSTRUCTION("4138200E", suqadd(v1.b8(), v2.b8()));
3528
+ TEST_INSTRUCTION("4138600E", suqadd(v1.h4(), v2.h4()));
3529
+ TEST_INSTRUCTION("4138A00E", suqadd(v1.s2(), v2.s2()));
3530
+ TEST_INSTRUCTION("4138204E", suqadd(v1.b16(), v2.b16()));
3531
+ TEST_INSTRUCTION("4138604E", suqadd(v1.h8(), v2.h8()));
3532
+ TEST_INSTRUCTION("4138A04E", suqadd(v1.s4(), v2.s4()));
3533
+ TEST_INSTRUCTION("4138E04E", suqadd(v1.d2(), v2.d2()));
3534
+ TEST_INSTRUCTION("41A4080F", sxtl(v1.h8(), v2.b8()));
3535
+ TEST_INSTRUCTION("41A4100F", sxtl(v1.s4(), v2.h4()));
3536
+ TEST_INSTRUCTION("41A4200F", sxtl(v1.d2(), v2.s2()));
3537
+ TEST_INSTRUCTION("41A4084F", sxtl2(v1.h8(), v2.b16()));
3538
+ TEST_INSTRUCTION("41A4104F", sxtl2(v1.s4(), v2.h8()));
3539
+ TEST_INSTRUCTION("41A4204F", sxtl2(v1.d2(), v2.s4()));
3540
+ TEST_INSTRUCTION("4100030E", tbl(v1.b8(), v2.b16(), v3.b8()));
3541
+ TEST_INSTRUCTION("4120040E", tbl(v1.b8(), v2.b16(), v3.b16(), v4.b8()));
3542
+ TEST_INSTRUCTION("4140050E", tbl(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b8()));
3543
+ TEST_INSTRUCTION("4160060E", tbl(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b8()));
3544
+ TEST_INSTRUCTION("4100034E", tbl(v1.b16(), v2.b16(), v3.b16()));
3545
+ TEST_INSTRUCTION("4120044E", tbl(v1.b16(), v2.b16(), v3.b16(), v4.b16()));
3546
+ TEST_INSTRUCTION("4140054E", tbl(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16()));
3547
+ TEST_INSTRUCTION("4160064E", tbl(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b16()));
3548
+ TEST_INSTRUCTION("4110030E", tbx(v1.b8(), v2.b16(), v3.b8()));
3549
+ TEST_INSTRUCTION("4130040E", tbx(v1.b8(), v2.b16(), v3.b16(), v4.b8()));
3550
+ TEST_INSTRUCTION("4150050E", tbx(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b8()));
3551
+ TEST_INSTRUCTION("4170060E", tbx(v1.b8(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b8()));
3552
+ TEST_INSTRUCTION("4110034E", tbx(v1.b16(), v2.b16(), v3.b16()));
3553
+ TEST_INSTRUCTION("4130044E", tbx(v1.b16(), v2.b16(), v3.b16(), v4.b16()));
3554
+ TEST_INSTRUCTION("4150054E", tbx(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16()));
3555
+ TEST_INSTRUCTION("4170064E", tbx(v1.b16(), v2.b16(), v3.b16(), v4.b16(), v5.b16(), v6.b16()));
3556
+ TEST_INSTRUCTION("4128030E", trn1(v1.b8(), v2.b8(), v3.b8()));
3557
+ TEST_INSTRUCTION("4128430E", trn1(v1.h4(), v2.h4(), v3.h4()));
3558
+ TEST_INSTRUCTION("4128830E", trn1(v1.s2(), v2.s2(), v3.s2()));
3559
+ TEST_INSTRUCTION("4128034E", trn1(v1.b16(), v2.b16(), v3.b16()));
3560
+ TEST_INSTRUCTION("4128434E", trn1(v1.h8(), v2.h8(), v3.h8()));
3561
+ TEST_INSTRUCTION("4128834E", trn1(v1.s4(), v2.s4(), v3.s4()));
3562
+ TEST_INSTRUCTION("4128C34E", trn1(v1.d2(), v2.d2(), v3.d2()));
3563
+ TEST_INSTRUCTION("4168030E", trn2(v1.b8(), v2.b8(), v3.b8()));
3564
+ TEST_INSTRUCTION("4168430E", trn2(v1.h4(), v2.h4(), v3.h4()));
3565
+ TEST_INSTRUCTION("4168830E", trn2(v1.s2(), v2.s2(), v3.s2()));
3566
+ TEST_INSTRUCTION("4168034E", trn2(v1.b16(), v2.b16(), v3.b16()));
3567
+ TEST_INSTRUCTION("4168434E", trn2(v1.h8(), v2.h8(), v3.h8()));
3568
+ TEST_INSTRUCTION("4168834E", trn2(v1.s4(), v2.s4(), v3.s4()));
3569
+ TEST_INSTRUCTION("4168C34E", trn2(v1.d2(), v2.d2(), v3.d2()));
3570
+ TEST_INSTRUCTION("417C232E", uaba(v1.b8(), v2.b8(), v3.b8()));
3571
+ TEST_INSTRUCTION("417C632E", uaba(v1.h4(), v2.h4(), v3.h4()));
3572
+ TEST_INSTRUCTION("417CA32E", uaba(v1.s2(), v2.s2(), v3.s2()));
3573
+ TEST_INSTRUCTION("417C236E", uaba(v1.b16(), v2.b16(), v3.b16()));
3574
+ TEST_INSTRUCTION("417C636E", uaba(v1.h8(), v2.h8(), v3.h8()));
3575
+ TEST_INSTRUCTION("417CA36E", uaba(v1.s4(), v2.s4(), v3.s4()));
3576
+ TEST_INSTRUCTION("4150232E", uabal(v1.h8(), v2.b8(), v3.b8()));
3577
+ TEST_INSTRUCTION("4150632E", uabal(v1.s4(), v2.h4(), v3.h4()));
3578
+ TEST_INSTRUCTION("4150A32E", uabal(v1.d2(), v2.s2(), v3.s2()));
3579
+ TEST_INSTRUCTION("4150236E", uabal2(v1.h8(), v2.b16(), v3.b16()));
3580
+ TEST_INSTRUCTION("4150636E", uabal2(v1.s4(), v2.h8(), v3.h8()));
3581
+ TEST_INSTRUCTION("4150A36E", uabal2(v1.d2(), v2.s4(), v3.s4()));
3582
+ TEST_INSTRUCTION("4174232E", uabd(v1.b8(), v2.b8(), v3.b8()));
3583
+ TEST_INSTRUCTION("4174632E", uabd(v1.h4(), v2.h4(), v3.h4()));
3584
+ TEST_INSTRUCTION("4174A32E", uabd(v1.s2(), v2.s2(), v3.s2()));
3585
+ TEST_INSTRUCTION("4174236E", uabd(v1.b16(), v2.b16(), v3.b16()));
3586
+ TEST_INSTRUCTION("4174636E", uabd(v1.h8(), v2.h8(), v3.h8()));
3587
+ TEST_INSTRUCTION("4174A36E", uabd(v1.s4(), v2.s4(), v3.s4()));
3588
+ TEST_INSTRUCTION("4170232E", uabdl(v1.h8(), v2.b8(), v3.b8()));
3589
+ TEST_INSTRUCTION("4170632E", uabdl(v1.s4(), v2.h4(), v3.h4()));
3590
+ TEST_INSTRUCTION("4170A32E", uabdl(v1.d2(), v2.s2(), v3.s2()));
3591
+ TEST_INSTRUCTION("4170236E", uabdl2(v1.h8(), v2.b16(), v3.b16()));
3592
+ TEST_INSTRUCTION("4170636E", uabdl2(v1.s4(), v2.h8(), v3.h8()));
3593
+ TEST_INSTRUCTION("4170A36E", uabdl2(v1.d2(), v2.s4(), v3.s4()));
3594
+ TEST_INSTRUCTION("4168202E", uadalp(v1.h4(), v2.b8()));
3595
+ TEST_INSTRUCTION("4168602E", uadalp(v1.s2(), v2.h4()));
3596
+ TEST_INSTRUCTION("4168A02E", uadalp(d1, v2.s2()));
3597
+ TEST_INSTRUCTION("4168206E", uadalp(v1.h8(), v2.b16()));
3598
+ TEST_INSTRUCTION("4168606E", uadalp(v1.s4(), v2.h8()));
3599
+ TEST_INSTRUCTION("4168A06E", uadalp(v1.d2(), v2.s4()));
3600
+ TEST_INSTRUCTION("4100232E", uaddl(v1.h8(), v2.b8(), v3.b8()));
3601
+ TEST_INSTRUCTION("4100632E", uaddl(v1.s4(), v2.h4(), v3.h4()));
3602
+ TEST_INSTRUCTION("4100A32E", uaddl(v1.d2(), v2.s2(), v3.s2()));
3603
+ TEST_INSTRUCTION("4100236E", uaddl2(v1.h8(), v2.b16(), v3.b16()));
3604
+ TEST_INSTRUCTION("4100636E", uaddl2(v1.s4(), v2.h8(), v3.h8()));
3605
+ TEST_INSTRUCTION("4100A36E", uaddl2(v1.d2(), v2.s4(), v3.s4()));
3606
+ TEST_INSTRUCTION("4128202E", uaddlp(v1.h4(), v2.b8()));
3607
+ TEST_INSTRUCTION("4128602E", uaddlp(v1.s2(), v2.h4()));
3608
+ TEST_INSTRUCTION("4128A02E", uaddlp(d1, v2.s2()));
3609
+ TEST_INSTRUCTION("4128206E", uaddlp(v1.h8(), v2.b16()));
3610
+ TEST_INSTRUCTION("4128606E", uaddlp(v1.s4(), v2.h8()));
3611
+ TEST_INSTRUCTION("4128A06E", uaddlp(v1.d2(), v2.s4()));
3612
+ TEST_INSTRUCTION("4138302E", uaddlv(h1, v2.b8()));
3613
+ TEST_INSTRUCTION("4138306E", uaddlv(h1, v2.b16()));
3614
+ TEST_INSTRUCTION("4138702E", uaddlv(s1, v2.h4()));
3615
+ TEST_INSTRUCTION("4138706E", uaddlv(s1, v2.h8()));
3616
+ TEST_INSTRUCTION("4138B06E", uaddlv(d1, v2.s4()));
3617
+ TEST_INSTRUCTION("4110232E", uaddw(v1.h8(), v2.h8(), v3.b8()));
3618
+ TEST_INSTRUCTION("4110632E", uaddw(v1.s4(), v2.s4(), v3.h4()));
3619
+ TEST_INSTRUCTION("4110A32E", uaddw(v1.d2(), v2.d2(), v3.s2()));
3620
+ TEST_INSTRUCTION("4110236E", uaddw2(v1.h8(), v2.h8(), v3.b16()));
3621
+ TEST_INSTRUCTION("4110636E", uaddw2(v1.s4(), v2.s4(), v3.h8()));
3622
+ TEST_INSTRUCTION("4110A36E", uaddw2(v1.d2(), v2.d2(), v3.s4()));
3623
+ TEST_INSTRUCTION("4100E31E", ucvtf(h1, w2));
3624
+ TEST_INSTRUCTION("4100231E", ucvtf(s1, w2));
3625
+ TEST_INSTRUCTION("4100631E", ucvtf(d1, w2));
3626
+ TEST_INSTRUCTION("4100E39E", ucvtf(h1, x2));
3627
+ TEST_INSTRUCTION("4100239E", ucvtf(s1, x2));
3628
+ TEST_INSTRUCTION("4100639E", ucvtf(d1, x2));
3629
+ TEST_INSTRUCTION("41D8797E", ucvtf(h1, h2));
3630
+ TEST_INSTRUCTION("41D8217E", ucvtf(s1, s2));
3631
+ TEST_INSTRUCTION("41D8617E", ucvtf(d1, d2));
3632
+ TEST_INSTRUCTION("41D8792E", ucvtf(v1.h4(), v2.h4()));
3633
+ TEST_INSTRUCTION("41D8212E", ucvtf(v1.s2(), v2.s2()));
3634
+ TEST_INSTRUCTION("41D8796E", ucvtf(v1.h8(), v2.h8()));
3635
+ TEST_INSTRUCTION("41D8216E", ucvtf(v1.s4(), v2.s4()));
3636
+ TEST_INSTRUCTION("41D8616E", ucvtf(v1.d2(), v2.d2()));
3637
+ TEST_INSTRUCTION("41E0C31E", ucvtf(h1, w2, 8));
3638
+ TEST_INSTRUCTION("41E0031E", ucvtf(s1, w2, 8));
3639
+ TEST_INSTRUCTION("41E0431E", ucvtf(d1, w2, 8));
3640
+ TEST_INSTRUCTION("41E0C39E", ucvtf(h1, x2, 8));
3641
+ TEST_INSTRUCTION("41E0039E", ucvtf(s1, x2, 8));
3642
+ TEST_INSTRUCTION("41E0439E", ucvtf(d1, x2, 8));
3643
+ TEST_INSTRUCTION("41E4187F", ucvtf(h1, h2, 8));
3644
+ TEST_INSTRUCTION("41E4387F", ucvtf(s1, s2, 8));
3645
+ TEST_INSTRUCTION("41E4787F", ucvtf(d1, d2, 8));
3646
+ TEST_INSTRUCTION("41E4182F", ucvtf(v1.h4(), v2.h4(), 8));
3647
+ TEST_INSTRUCTION("41E4382F", ucvtf(v1.s2(), v2.s2(), 8));
3648
+ TEST_INSTRUCTION("41E4186F", ucvtf(v1.h8(), v2.h8(), 8));
3649
+ TEST_INSTRUCTION("41E4386F", ucvtf(v1.s4(), v2.s4(), 8));
3650
+ TEST_INSTRUCTION("41E4786F", ucvtf(v1.d2(), v2.d2(), 8));
3651
+ TEST_INSTRUCTION("4194832E", udot(v1.s2(), v2.b8(), v3.b8()));
3652
+ TEST_INSTRUCTION("4194836E", udot(v1.s4(), v2.b16(), v3.b16()));
3653
+ TEST_INSTRUCTION("41E0832F", udot(v1.s2(), v2.b8(), v3.b4(0)));
3654
+ TEST_INSTRUCTION("41E0A32F", udot(v1.s2(), v2.b8(), v3.b4(1)));
3655
+ TEST_INSTRUCTION("41E8832F", udot(v1.s2(), v2.b8(), v3.b4(2)));
3656
+ TEST_INSTRUCTION("41E8A32F", udot(v1.s2(), v2.b8(), v3.b4(3)));
3657
+ TEST_INSTRUCTION("41E0836F", udot(v1.s4(), v2.b16(), v3.b4(0)));
3658
+ TEST_INSTRUCTION("41E0A36F", udot(v1.s4(), v2.b16(), v3.b4(1)));
3659
+ TEST_INSTRUCTION("41E8836F", udot(v1.s4(), v2.b16(), v3.b4(2)));
3660
+ TEST_INSTRUCTION("41E8A36F", udot(v1.s4(), v2.b16(), v3.b4(3)));
3661
+ TEST_INSTRUCTION("4104232E", uhadd(v1.b8(), v2.b8(), v3.b8()));
3662
+ TEST_INSTRUCTION("4104632E", uhadd(v1.h4(), v2.h4(), v3.h4()));
3663
+ TEST_INSTRUCTION("4104A32E", uhadd(v1.s2(), v2.s2(), v3.s2()));
3664
+ TEST_INSTRUCTION("4104236E", uhadd(v1.b16(), v2.b16(), v3.b16()));
3665
+ TEST_INSTRUCTION("4104636E", uhadd(v1.h8(), v2.h8(), v3.h8()));
3666
+ TEST_INSTRUCTION("4104A36E", uhadd(v1.s4(), v2.s4(), v3.s4()));
3667
+ TEST_INSTRUCTION("4124232E", uhsub(v1.b8(), v2.b8(), v3.b8()));
3668
+ TEST_INSTRUCTION("4124632E", uhsub(v1.h4(), v2.h4(), v3.h4()));
3669
+ TEST_INSTRUCTION("4124A32E", uhsub(v1.s2(), v2.s2(), v3.s2()));
3670
+ TEST_INSTRUCTION("4124236E", uhsub(v1.b16(), v2.b16(), v3.b16()));
3671
+ TEST_INSTRUCTION("4124636E", uhsub(v1.h8(), v2.h8(), v3.h8()));
3672
+ TEST_INSTRUCTION("4124A36E", uhsub(v1.s4(), v2.s4(), v3.s4()));
3673
+ TEST_INSTRUCTION("4164232E", umax(v1.b8(), v2.b8(), v3.b8()));
3674
+ TEST_INSTRUCTION("4164632E", umax(v1.h4(), v2.h4(), v3.h4()));
3675
+ TEST_INSTRUCTION("4164A32E", umax(v1.s2(), v2.s2(), v3.s2()));
3676
+ TEST_INSTRUCTION("4164236E", umax(v1.b16(), v2.b16(), v3.b16()));
3677
+ TEST_INSTRUCTION("4164636E", umax(v1.h8(), v2.h8(), v3.h8()));
3678
+ TEST_INSTRUCTION("4164A36E", umax(v1.s4(), v2.s4(), v3.s4()));
3679
+ TEST_INSTRUCTION("41A4232E", umaxp(v1.b8(), v2.b8(), v3.b8()));
3680
+ TEST_INSTRUCTION("41A4632E", umaxp(v1.h4(), v2.h4(), v3.h4()));
3681
+ TEST_INSTRUCTION("41A4A32E", umaxp(v1.s2(), v2.s2(), v3.s2()));
3682
+ TEST_INSTRUCTION("41A4236E", umaxp(v1.b16(), v2.b16(), v3.b16()));
3683
+ TEST_INSTRUCTION("41A4636E", umaxp(v1.h8(), v2.h8(), v3.h8()));
3684
+ TEST_INSTRUCTION("41A4A36E", umaxp(v1.s4(), v2.s4(), v3.s4()));
3685
+ TEST_INSTRUCTION("41A8302E", umaxv(b1, v2.b8()));
3686
+ TEST_INSTRUCTION("41A8306E", umaxv(b1, v2.b16()));
3687
+ TEST_INSTRUCTION("41A8702E", umaxv(h1, v2.h4()));
3688
+ TEST_INSTRUCTION("41A8706E", umaxv(h1, v2.h8()));
3689
+ TEST_INSTRUCTION("41A8B06E", umaxv(s1, v2.s4()));
3690
+ TEST_INSTRUCTION("416C232E", umin(v1.b8(), v2.b8(), v3.b8()));
3691
+ TEST_INSTRUCTION("416C632E", umin(v1.h4(), v2.h4(), v3.h4()));
3692
+ TEST_INSTRUCTION("416CA32E", umin(v1.s2(), v2.s2(), v3.s2()));
3693
+ TEST_INSTRUCTION("416C236E", umin(v1.b16(), v2.b16(), v3.b16()));
3694
+ TEST_INSTRUCTION("416C636E", umin(v1.h8(), v2.h8(), v3.h8()));
3695
+ TEST_INSTRUCTION("416CA36E", umin(v1.s4(), v2.s4(), v3.s4()));
3696
+ TEST_INSTRUCTION("41AC232E", uminp(v1.b8(), v2.b8(), v3.b8()));
3697
+ TEST_INSTRUCTION("41AC632E", uminp(v1.h4(), v2.h4(), v3.h4()));
3698
+ TEST_INSTRUCTION("41ACA32E", uminp(v1.s2(), v2.s2(), v3.s2()));
3699
+ TEST_INSTRUCTION("41AC236E", uminp(v1.b16(), v2.b16(), v3.b16()));
3700
+ TEST_INSTRUCTION("41AC636E", uminp(v1.h8(), v2.h8(), v3.h8()));
3701
+ TEST_INSTRUCTION("41ACA36E", uminp(v1.s4(), v2.s4(), v3.s4()));
3702
+ TEST_INSTRUCTION("41A8312E", uminv(b1, v2.b8()));
3703
+ TEST_INSTRUCTION("41A8316E", uminv(b1, v2.b16()));
3704
+ TEST_INSTRUCTION("41A8712E", uminv(h1, v2.h4()));
3705
+ TEST_INSTRUCTION("41A8716E", uminv(h1, v2.h8()));
3706
+ TEST_INSTRUCTION("41A8B16E", uminv(s1, v2.s4()));
3707
+ TEST_INSTRUCTION("4180232E", umlal(v1.h8(), v2.b8(), v3.b8()));
3708
+ TEST_INSTRUCTION("4180632E", umlal(v1.s4(), v2.h4(), v3.h4()));
3709
+ TEST_INSTRUCTION("4180A32E", umlal(v1.d2(), v2.s2(), v3.s2()));
3710
+ TEST_INSTRUCTION("4120732F", umlal(v1.s4(), v2.h4(), v3.h(3)));
3711
+ TEST_INSTRUCTION("4128A32F", umlal(v1.d2(), v2.s2(), v3.s(3)));
3712
+ TEST_INSTRUCTION("4180236E", umlal2(v1.h8(), v2.b16(), v3.b16()));
3713
+ TEST_INSTRUCTION("4180636E", umlal2(v1.s4(), v2.h8(), v3.h8()));
3714
+ TEST_INSTRUCTION("4180A36E", umlal2(v1.d2(), v2.s4(), v3.s4()));
3715
+ TEST_INSTRUCTION("4120736F", umlal2(v1.s4(), v2.h8(), v3.h(3)));
3716
+ TEST_INSTRUCTION("4128A36F", umlal2(v1.d2(), v2.s4(), v3.s(3)));
3717
+ TEST_INSTRUCTION("41A0232E", umlsl(v1.h8(), v2.b8(), v3.b8()));
3718
+ TEST_INSTRUCTION("41A0632E", umlsl(v1.s4(), v2.h4(), v3.h4()));
3719
+ TEST_INSTRUCTION("41A0A32E", umlsl(v1.d2(), v2.s2(), v3.s2()));
3720
+ TEST_INSTRUCTION("4160732F", umlsl(v1.s4(), v2.h4(), v3.h(3)));
3721
+ TEST_INSTRUCTION("4168A32F", umlsl(v1.d2(), v2.s2(), v3.s(3)));
3722
+ TEST_INSTRUCTION("41A0236E", umlsl2(v1.h8(), v2.b16(), v3.b16()));
3723
+ TEST_INSTRUCTION("41A0636E", umlsl2(v1.s4(), v2.h8(), v3.h8()));
3724
+ TEST_INSTRUCTION("41A0A36E", umlsl2(v1.d2(), v2.s4(), v3.s4()));
3725
+ TEST_INSTRUCTION("4160736F", umlsl2(v1.s4(), v2.h8(), v3.h(3)));
3726
+ TEST_INSTRUCTION("4168A36F", umlsl2(v1.d2(), v2.s4(), v3.s(3)));
3727
+ TEST_INSTRUCTION("41A4836E", ummla(v1.s4(), v2.b16(), v3.b16()));
3728
+ TEST_INSTRUCTION("413C010E", umov(w1, v2.b(0)));
3729
+ TEST_INSTRUCTION("413C1F0E", umov(w1, v2.b(15)));
3730
+ TEST_INSTRUCTION("413C020E", umov(w1, v2.h(0)));
3731
+ TEST_INSTRUCTION("413C1E0E", umov(w1, v2.h(7)));
3732
+ TEST_INSTRUCTION("413C040E", umov(w1, v2.s(0)));
3733
+ TEST_INSTRUCTION("413C1C0E", umov(w1, v2.s(3)));
3734
+ TEST_INSTRUCTION("413C084E", umov(x1, v2.d(0)));
3735
+ TEST_INSTRUCTION("413C184E", umov(x1, v2.d(1)));
3736
+ TEST_INSTRUCTION("41C0232E", umull(v1.h8(), v2.b8(), v3.b8()));
3737
+ TEST_INSTRUCTION("41C0632E", umull(v1.s4(), v2.h4(), v3.h4()));
3738
+ TEST_INSTRUCTION("41C0A32E", umull(v1.d2(), v2.s2(), v3.s2()));
3739
+ TEST_INSTRUCTION("41A0732F", umull(v1.s4(), v2.h4(), v3.h(3)));
3740
+ TEST_INSTRUCTION("41A8A32F", umull(v1.d2(), v2.s2(), v3.s(3)));
3741
+ TEST_INSTRUCTION("41C0236E", umull2(v1.h8(), v2.b16(), v3.b16()));
3742
+ TEST_INSTRUCTION("41C0636E", umull2(v1.s4(), v2.h8(), v3.h8()));
3743
+ TEST_INSTRUCTION("41C0A36E", umull2(v1.d2(), v2.s4(), v3.s4()));
3744
+ TEST_INSTRUCTION("41A0736F", umull2(v1.s4(), v2.h8(), v3.h(3)));
3745
+ TEST_INSTRUCTION("41A8A36F", umull2(v1.d2(), v2.s4(), v3.s(3)));
3746
+ TEST_INSTRUCTION("410C237E", uqadd(b1, b2, b3));
3747
+ TEST_INSTRUCTION("410C637E", uqadd(h1, h2, h3));
3748
+ TEST_INSTRUCTION("410CA37E", uqadd(s1, s2, s3));
3749
+ TEST_INSTRUCTION("410CE37E", uqadd(d1, d2, d3));
3750
+ TEST_INSTRUCTION("410C232E", uqadd(v1.b8(), v2.b8(), v3.b8()));
3751
+ TEST_INSTRUCTION("410C632E", uqadd(v1.h4(), v2.h4(), v3.h4()));
3752
+ TEST_INSTRUCTION("410CA32E", uqadd(v1.s2(), v2.s2(), v3.s2()));
3753
+ TEST_INSTRUCTION("410C236E", uqadd(v1.b16(), v2.b16(), v3.b16()));
3754
+ TEST_INSTRUCTION("410C636E", uqadd(v1.h8(), v2.h8(), v3.h8()));
3755
+ TEST_INSTRUCTION("410CA36E", uqadd(v1.s4(), v2.s4(), v3.s4()));
3756
+ TEST_INSTRUCTION("410CE36E", uqadd(v1.d2(), v2.d2(), v3.d2()));
3757
+ TEST_INSTRUCTION("415C237E", uqrshl(b1, b2, b3));
3758
+ TEST_INSTRUCTION("415C637E", uqrshl(h1, h2, h3));
3759
+ TEST_INSTRUCTION("415CA37E", uqrshl(s1, s2, s3));
3760
+ TEST_INSTRUCTION("415C232E", uqrshl(v1.b8(), v2.b8(), v3.b8()));
3761
+ TEST_INSTRUCTION("415C632E", uqrshl(v1.h4(), v2.h4(), v3.h4()));
3762
+ TEST_INSTRUCTION("415CA32E", uqrshl(v1.s2(), v2.s2(), v3.s2()));
3763
+ TEST_INSTRUCTION("415CE37E", uqrshl(d1, d2, d3));
3764
+ TEST_INSTRUCTION("415C236E", uqrshl(v1.b16(), v2.b16(), v3.b16()));
3765
+ TEST_INSTRUCTION("415C636E", uqrshl(v1.h8(), v2.h8(), v3.h8()));
3766
+ TEST_INSTRUCTION("415CA36E", uqrshl(v1.s4(), v2.s4(), v3.s4()));
3767
+ TEST_INSTRUCTION("415CE36E", uqrshl(v1.d2(), v2.d2(), v3.d2()));
3768
+ TEST_INSTRUCTION("419C087F", uqrshrn(b1, h2, 8));
3769
+ TEST_INSTRUCTION("419C107F", uqrshrn(h1, s2, 16));
3770
+ TEST_INSTRUCTION("419C207F", uqrshrn(s1, d2, 32));
3771
+ TEST_INSTRUCTION("419C082F", uqrshrn(v1.b8(), v2.h8(), 8));
3772
+ TEST_INSTRUCTION("419C102F", uqrshrn(v1.h4(), v2.s4(), 16));
3773
+ TEST_INSTRUCTION("419C202F", uqrshrn(v1.s2(), v2.d2(), 32));
3774
+ TEST_INSTRUCTION("419C086F", uqrshrn2(v1.b16(), v2.h8(), 8));
3775
+ TEST_INSTRUCTION("419C106F", uqrshrn2(v1.h8(), v2.s4(), 16));
3776
+ TEST_INSTRUCTION("419C206F", uqrshrn2(v1.s4(), v2.d2(), 32));
3777
+ TEST_INSTRUCTION("4174097F", uqshl(b1, b2, 1));
3778
+ TEST_INSTRUCTION("4174127F", uqshl(h1, h2, 2));
3779
+ TEST_INSTRUCTION("4174237F", uqshl(s1, s2, 3));
3780
+ TEST_INSTRUCTION("41740F2F", uqshl(v1.b8(), v2.b8(), 7));
3781
+ TEST_INSTRUCTION("41741F2F", uqshl(v1.h4(), v2.h4(), 15));
3782
+ TEST_INSTRUCTION("41743F2F", uqshl(v1.s2(), v2.s2(), 31));
3783
+ TEST_INSTRUCTION("41747F7F", uqshl(d1, d2, 63));
3784
+ TEST_INSTRUCTION("41740F6F", uqshl(v1.b16(), v2.b16(), 7));
3785
+ TEST_INSTRUCTION("41741F6F", uqshl(v1.h8(), v2.h8(), 15));
3786
+ TEST_INSTRUCTION("41743F6F", uqshl(v1.s4(), v2.s4(), 31));
3787
+ TEST_INSTRUCTION("41747F6F", uqshl(v1.d2(), v2.d2(), 63));
3788
+ TEST_INSTRUCTION("414C237E", uqshl(b1, b2, b3));
3789
+ TEST_INSTRUCTION("414C637E", uqshl(h1, h2, h3));
3790
+ TEST_INSTRUCTION("414CA37E", uqshl(s1, s2, s3));
3791
+ TEST_INSTRUCTION("414C232E", uqshl(v1.b8(), v2.b8(), v3.b8()));
3792
+ TEST_INSTRUCTION("414C632E", uqshl(v1.h4(), v2.h4(), v3.h4()));
3793
+ TEST_INSTRUCTION("414CA32E", uqshl(v1.s2(), v2.s2(), v3.s2()));
3794
+ TEST_INSTRUCTION("414CE37E", uqshl(d1, d2, d3));
3795
+ TEST_INSTRUCTION("414C236E", uqshl(v1.b16(), v2.b16(), v3.b16()));
3796
+ TEST_INSTRUCTION("414C636E", uqshl(v1.h8(), v2.h8(), v3.h8()));
3797
+ TEST_INSTRUCTION("414CA36E", uqshl(v1.s4(), v2.s4(), v3.s4()));
3798
+ TEST_INSTRUCTION("414CE36E", uqshl(v1.d2(), v2.d2(), v3.d2()));
3799
+ TEST_INSTRUCTION("4194087F", uqshrn(b1, h2, 8));
3800
+ TEST_INSTRUCTION("4194107F", uqshrn(h1, s2, 16));
3801
+ TEST_INSTRUCTION("4194207F", uqshrn(s1, d2, 32));
3802
+ TEST_INSTRUCTION("4194082F", uqshrn(v1.b8(), v2.h8(), 8));
3803
+ TEST_INSTRUCTION("4194102F", uqshrn(v1.h4(), v2.s4(), 16));
3804
+ TEST_INSTRUCTION("4194202F", uqshrn(v1.s2(), v2.d2(), 32));
3805
+ TEST_INSTRUCTION("4194086F", uqshrn2(v1.b16(), v2.h8(), 8));
3806
+ TEST_INSTRUCTION("4194106F", uqshrn2(v1.h8(), v2.s4(), 16));
3807
+ TEST_INSTRUCTION("4194206F", uqshrn2(v1.s4(), v2.d2(), 32));
3808
+ TEST_INSTRUCTION("412C237E", uqsub(b1, b2, b3));
3809
+ TEST_INSTRUCTION("412C637E", uqsub(h1, h2, h3));
3810
+ TEST_INSTRUCTION("412CA37E", uqsub(s1, s2, s3));
3811
+ TEST_INSTRUCTION("412CE37E", uqsub(d1, d2, d3));
3812
+ TEST_INSTRUCTION("412C232E", uqsub(v1.b8(), v2.b8(), v3.b8()));
3813
+ TEST_INSTRUCTION("412C632E", uqsub(v1.h4(), v2.h4(), v3.h4()));
3814
+ TEST_INSTRUCTION("412CA32E", uqsub(v1.s2(), v2.s2(), v3.s2()));
3815
+ TEST_INSTRUCTION("412C236E", uqsub(v1.b16(), v2.b16(), v3.b16()));
3816
+ TEST_INSTRUCTION("412C636E", uqsub(v1.h8(), v2.h8(), v3.h8()));
3817
+ TEST_INSTRUCTION("412CA36E", uqsub(v1.s4(), v2.s4(), v3.s4()));
3818
+ TEST_INSTRUCTION("412CE36E", uqsub(v1.d2(), v2.d2(), v3.d2()));
3819
+ TEST_INSTRUCTION("4148217E", uqxtn(b1, h2));
3820
+ TEST_INSTRUCTION("4148617E", uqxtn(h1, s2));
3821
+ TEST_INSTRUCTION("4148A17E", uqxtn(s1, d2));
3822
+ TEST_INSTRUCTION("4148212E", uqxtn(v1.b8(), v2.h8()));
3823
+ TEST_INSTRUCTION("4148612E", uqxtn(v1.h4(), v2.s4()));
3824
+ TEST_INSTRUCTION("4148A12E", uqxtn(v1.s2(), v2.d2()));
3825
+ TEST_INSTRUCTION("4148216E", uqxtn2(v1.b16(), v2.h8()));
3826
+ TEST_INSTRUCTION("4148616E", uqxtn2(v1.h8(), v2.s4()));
3827
+ TEST_INSTRUCTION("4148A16E", uqxtn2(v1.s4(), v2.d2()));
3828
+ TEST_INSTRUCTION("41C8A10E", urecpe(v1.s2(), v2.s2()));
3829
+ TEST_INSTRUCTION("41C8A14E", urecpe(v1.s4(), v2.s4()));
3830
+ TEST_INSTRUCTION("4114232E", urhadd(v1.b8(), v2.b8(), v3.b8()));
3831
+ TEST_INSTRUCTION("4114632E", urhadd(v1.h4(), v2.h4(), v3.h4()));
3832
+ TEST_INSTRUCTION("4114A32E", urhadd(v1.s2(), v2.s2(), v3.s2()));
3833
+ TEST_INSTRUCTION("4114236E", urhadd(v1.b16(), v2.b16(), v3.b16()));
3834
+ TEST_INSTRUCTION("4114636E", urhadd(v1.h8(), v2.h8(), v3.h8()));
3835
+ TEST_INSTRUCTION("4114A36E", urhadd(v1.s4(), v2.s4(), v3.s4()));
3836
+ TEST_INSTRUCTION("4154232E", urshl(v1.b8(), v2.b8(), v3.b8()));
3837
+ TEST_INSTRUCTION("4154632E", urshl(v1.h4(), v2.h4(), v3.h4()));
3838
+ TEST_INSTRUCTION("4154A32E", urshl(v1.s2(), v2.s2(), v3.s2()));
3839
+ TEST_INSTRUCTION("4154E37E", urshl(d1, d2, d3));
3840
+ TEST_INSTRUCTION("4154236E", urshl(v1.b16(), v2.b16(), v3.b16()));
3841
+ TEST_INSTRUCTION("4154636E", urshl(v1.h8(), v2.h8(), v3.h8()));
3842
+ TEST_INSTRUCTION("4154A36E", urshl(v1.s4(), v2.s4(), v3.s4()));
3843
+ TEST_INSTRUCTION("4154E36E", urshl(v1.d2(), v2.d2(), v3.d2()));
3844
+ TEST_INSTRUCTION("4124092F", urshr(v1.b8(), v2.b8(), 7));
3845
+ TEST_INSTRUCTION("4124112F", urshr(v1.h4(), v2.h4(), 15));
3846
+ TEST_INSTRUCTION("4124212F", urshr(v1.s2(), v2.s2(), 31));
3847
+ TEST_INSTRUCTION("4124417F", urshr(d1, d2, 63));
3848
+ TEST_INSTRUCTION("4124096F", urshr(v1.b16(), v2.b16(), 7));
3849
+ TEST_INSTRUCTION("4124116F", urshr(v1.h8(), v2.h8(), 15));
3850
+ TEST_INSTRUCTION("4124216F", urshr(v1.s4(), v2.s4(), 31));
3851
+ TEST_INSTRUCTION("4124416F", urshr(v1.d2(), v2.d2(), 63));
3852
+ TEST_INSTRUCTION("41C8A12E", ursqrte(v1.s2(), v2.s2()));
3853
+ TEST_INSTRUCTION("41C8A16E", ursqrte(v1.s4(), v2.s4()));
3854
+ TEST_INSTRUCTION("4134092F", ursra(v1.b8(), v2.b8(), 7));
3855
+ TEST_INSTRUCTION("4134112F", ursra(v1.h4(), v2.h4(), 15));
3856
+ TEST_INSTRUCTION("4134212F", ursra(v1.s2(), v2.s2(), 31));
3857
+ TEST_INSTRUCTION("4134417F", ursra(d1, d2, 63));
3858
+ TEST_INSTRUCTION("4134096F", ursra(v1.b16(), v2.b16(), 7));
3859
+ TEST_INSTRUCTION("4134116F", ursra(v1.h8(), v2.h8(), 15));
3860
+ TEST_INSTRUCTION("4134216F", ursra(v1.s4(), v2.s4(), 31));
3861
+ TEST_INSTRUCTION("4134416F", ursra(v1.d2(), v2.d2(), 63));
3862
+ TEST_INSTRUCTION("419C830E", usdot(v1.s2(), v2.b8(), v3.b8()));
3863
+ TEST_INSTRUCTION("419C834E", usdot(v1.s4(), v2.b16(), v3.b16()));
3864
+ TEST_INSTRUCTION("41F0830F", usdot(v1.s2(), v2.b8(), v3.b4(0)));
3865
+ TEST_INSTRUCTION("41F0A30F", usdot(v1.s2(), v2.b8(), v3.b4(1)));
3866
+ TEST_INSTRUCTION("41F8830F", usdot(v1.s2(), v2.b8(), v3.b4(2)));
3867
+ TEST_INSTRUCTION("41F8A30F", usdot(v1.s2(), v2.b8(), v3.b4(3)));
3868
+ TEST_INSTRUCTION("41F0834F", usdot(v1.s4(), v2.b16(), v3.b4(0)));
3869
+ TEST_INSTRUCTION("41F0A34F", usdot(v1.s4(), v2.b16(), v3.b4(1)));
3870
+ TEST_INSTRUCTION("41F8834F", usdot(v1.s4(), v2.b16(), v3.b4(2)));
3871
+ TEST_INSTRUCTION("41F8A34F", usdot(v1.s4(), v2.b16(), v3.b4(3)));
3872
+ TEST_INSTRUCTION("4144232E", ushl(v1.b8(), v2.b8(), v3.b8()));
3873
+ TEST_INSTRUCTION("4144632E", ushl(v1.h4(), v2.h4(), v3.h4()));
3874
+ TEST_INSTRUCTION("4144A32E", ushl(v1.s2(), v2.s2(), v3.s2()));
3875
+ TEST_INSTRUCTION("4144E37E", ushl(d1, d2, d3));
3876
+ TEST_INSTRUCTION("4144236E", ushl(v1.b16(), v2.b16(), v3.b16()));
3877
+ TEST_INSTRUCTION("4144636E", ushl(v1.h8(), v2.h8(), v3.h8()));
3878
+ TEST_INSTRUCTION("4144A36E", ushl(v1.s4(), v2.s4(), v3.s4()));
3879
+ TEST_INSTRUCTION("4144E36E", ushl(v1.d2(), v2.d2(), v3.d2()));
3880
+ TEST_INSTRUCTION("41A40F2F", ushll(v1.h8(), v2.b8(), 7));
3881
+ TEST_INSTRUCTION("41A41F2F", ushll(v1.s4(), v2.h4(), 15));
3882
+ TEST_INSTRUCTION("41A43F2F", ushll(v1.d2(), v2.s2(), 31));
3883
+ TEST_INSTRUCTION("41A40F6F", ushll2(v1.h8(), v2.b16(), 7));
3884
+ TEST_INSTRUCTION("41A41F6F", ushll2(v1.s4(), v2.h8(), 15));
3885
+ TEST_INSTRUCTION("41A43F6F", ushll2(v1.s2(), v2.s4(), 31));
3886
+ TEST_INSTRUCTION("4104092F", ushr(v1.b8(), v2.b8(), 7));
3887
+ TEST_INSTRUCTION("4104112F", ushr(v1.h4(), v2.h4(), 15));
3888
+ TEST_INSTRUCTION("4104212F", ushr(v1.s2(), v2.s2(), 31));
3889
+ TEST_INSTRUCTION("4104417F", ushr(d1, d2, 63));
3890
+ TEST_INSTRUCTION("4104096F", ushr(v1.b16(), v2.b16(), 7));
3891
+ TEST_INSTRUCTION("4104116F", ushr(v1.h8(), v2.h8(), 15));
3892
+ TEST_INSTRUCTION("4104216F", ushr(v1.s4(), v2.s4(), 31));
3893
+ TEST_INSTRUCTION("4104416F", ushr(v1.d2(), v2.d2(), 63));
3894
+ TEST_INSTRUCTION("41AC834E", usmmla(v1.s4(), v2.b16(), v3.b16()));
3895
+ TEST_INSTRUCTION("4138207E", usqadd(b1, b2));
3896
+ TEST_INSTRUCTION("4138607E", usqadd(h1, h2));
3897
+ TEST_INSTRUCTION("4138A07E", usqadd(s1, s2));
3898
+ TEST_INSTRUCTION("4138E07E", usqadd(d1, d2));
3899
+ TEST_INSTRUCTION("4138202E", usqadd(v1.b8(), v2.b8()));
3900
+ TEST_INSTRUCTION("4138602E", usqadd(v1.h4(), v2.h4()));
3901
+ TEST_INSTRUCTION("4138A02E", usqadd(v1.s2(), v2.s2()));
3902
+ TEST_INSTRUCTION("4138206E", usqadd(v1.b16(), v2.b16()));
3903
+ TEST_INSTRUCTION("4138606E", usqadd(v1.h8(), v2.h8()));
3904
+ TEST_INSTRUCTION("4138A06E", usqadd(v1.s4(), v2.s4()));
3905
+ TEST_INSTRUCTION("4138E06E", usqadd(v1.d2(), v2.d2()));
3906
+ TEST_INSTRUCTION("4114092F", usra(v1.b8(), v2.b8(), 7));
3907
+ TEST_INSTRUCTION("4114112F", usra(v1.h4(), v2.h4(), 15));
3908
+ TEST_INSTRUCTION("4114212F", usra(v1.s2(), v2.s2(), 31));
3909
+ TEST_INSTRUCTION("4114417F", usra(d1, d2, 63));
3910
+ TEST_INSTRUCTION("4114096F", usra(v1.b16(), v2.b16(), 7));
3911
+ TEST_INSTRUCTION("4114116F", usra(v1.h8(), v2.h8(), 15));
3912
+ TEST_INSTRUCTION("4114216F", usra(v1.s4(), v2.s4(), 31));
3913
+ TEST_INSTRUCTION("4114416F", usra(v1.d2(), v2.d2(), 63));
3914
+ TEST_INSTRUCTION("4120232E", usubl(v1.h8(), v2.b8(), v3.b8()));
3915
+ TEST_INSTRUCTION("4120632E", usubl(v1.s4(), v2.h4(), v3.h4()));
3916
+ TEST_INSTRUCTION("4120A32E", usubl(v1.d2(), v2.s2(), v3.s2()));
3917
+ TEST_INSTRUCTION("4120236E", usubl2(v1.h8(), v2.b16(), v3.b16()));
3918
+ TEST_INSTRUCTION("4120636E", usubl2(v1.s4(), v2.h8(), v3.h8()));
3919
+ TEST_INSTRUCTION("4120A36E", usubl2(v1.d2(), v2.s4(), v3.s4()));
3920
+ TEST_INSTRUCTION("4130232E", usubw(v1.h8(), v2.h8(), v3.b8()));
3921
+ TEST_INSTRUCTION("4130632E", usubw(v1.s4(), v2.s4(), v3.h4()));
3922
+ TEST_INSTRUCTION("4130A32E", usubw(v1.d2(), v2.d2(), v3.s2()));
3923
+ TEST_INSTRUCTION("4130236E", usubw2(v1.h8(), v2.h8(), v3.b16()));
3924
+ TEST_INSTRUCTION("4130636E", usubw2(v1.s4(), v2.s4(), v3.h8()));
3925
+ TEST_INSTRUCTION("4130A36E", usubw2(v1.d2(), v2.d2(), v3.s4()));
3926
+ TEST_INSTRUCTION("41A4082F", uxtl(v1.h8(), v2.b8()));
3927
+ TEST_INSTRUCTION("41A4102F", uxtl(v1.s4(), v2.h4()));
3928
+ TEST_INSTRUCTION("41A4202F", uxtl(v1.d2(), v2.s2()));
3929
+ TEST_INSTRUCTION("41A4086F", uxtl2(v1.h8(), v2.b16()));
3930
+ TEST_INSTRUCTION("41A4106F", uxtl2(v1.s4(), v2.h8()));
3931
+ TEST_INSTRUCTION("41A4206F", uxtl2(v1.d2(), v2.s4()));
3932
+ TEST_INSTRUCTION("4118030E", uzp1(v1.b8(), v2.b8(), v3.b8()));
3933
+ TEST_INSTRUCTION("4118430E", uzp1(v1.h4(), v2.h4(), v3.h4()));
3934
+ TEST_INSTRUCTION("4118830E", uzp1(v1.s2(), v2.s2(), v3.s2()));
3935
+ TEST_INSTRUCTION("4118034E", uzp1(v1.b16(), v2.b16(), v3.b16()));
3936
+ TEST_INSTRUCTION("4118434E", uzp1(v1.h8(), v2.h8(), v3.h8()));
3937
+ TEST_INSTRUCTION("4118834E", uzp1(v1.s4(), v2.s4(), v3.s4()));
3938
+ TEST_INSTRUCTION("4118C34E", uzp1(v1.d2(), v2.d2(), v3.d2()));
3939
+ TEST_INSTRUCTION("4158030E", uzp2(v1.b8(), v2.b8(), v3.b8()));
3940
+ TEST_INSTRUCTION("4158430E", uzp2(v1.h4(), v2.h4(), v3.h4()));
3941
+ TEST_INSTRUCTION("4158830E", uzp2(v1.s2(), v2.s2(), v3.s2()));
3942
+ TEST_INSTRUCTION("4158034E", uzp2(v1.b16(), v2.b16(), v3.b16()));
3943
+ TEST_INSTRUCTION("4158434E", uzp2(v1.h8(), v2.h8(), v3.h8()));
3944
+ TEST_INSTRUCTION("4158834E", uzp2(v1.s4(), v2.s4(), v3.s4()));
3945
+ TEST_INSTRUCTION("4158C34E", uzp2(v1.d2(), v2.d2(), v3.d2()));
3946
+ TEST_INSTRUCTION("4128210E", xtn(v1.b8(), v2.h8()));
3947
+ TEST_INSTRUCTION("4128610E", xtn(v1.h4(), v2.s4()));
3948
+ TEST_INSTRUCTION("4128A10E", xtn(v1.s2(), v2.d2()));
3949
+ TEST_INSTRUCTION("4128214E", xtn2(v1.b16(), v2.h8()));
3950
+ TEST_INSTRUCTION("4128614E", xtn2(v1.h8(), v2.s4()));
3951
+ TEST_INSTRUCTION("4128A14E", xtn2(v1.s4(), v2.d2()));
3952
+ TEST_INSTRUCTION("4138030E", zip1(v1.b8(), v2.b8(), v3.b8()));
3953
+ TEST_INSTRUCTION("4138430E", zip1(v1.h4(), v2.h4(), v3.h4()));
3954
+ TEST_INSTRUCTION("4138830E", zip1(v1.s2(), v2.s2(), v3.s2()));
3955
+ TEST_INSTRUCTION("4138034E", zip1(v1.b16(), v2.b16(), v3.b16()));
3956
+ TEST_INSTRUCTION("4138434E", zip1(v1.h8(), v2.h8(), v3.h8()));
3957
+ TEST_INSTRUCTION("4138834E", zip1(v1.s4(), v2.s4(), v3.s4()));
3958
+ TEST_INSTRUCTION("4138C34E", zip1(v1.d2(), v2.d2(), v3.d2()));
3959
+ TEST_INSTRUCTION("4178030E", zip2(v1.b8(), v2.b8(), v3.b8()));
3960
+ TEST_INSTRUCTION("4178430E", zip2(v1.h4(), v2.h4(), v3.h4()));
3961
+ TEST_INSTRUCTION("4178830E", zip2(v1.s2(), v2.s2(), v3.s2()));
3962
+ TEST_INSTRUCTION("4178034E", zip2(v1.b16(), v2.b16(), v3.b16()));
3963
+ TEST_INSTRUCTION("4178434E", zip2(v1.h8(), v2.h8(), v3.h8()));
3964
+ TEST_INSTRUCTION("4178834E", zip2(v1.s4(), v2.s4(), v3.s4()));
3965
+ TEST_INSTRUCTION("4178C34E", zip2(v1.d2(), v2.d2(), v3.d2()));
3966
+ }
3967
+
3968
+ static void ASMJIT_NOINLINE testA64AssemblerExtras(AssemblerTester<a64::Assembler>& tester) noexcept {
3969
+ using namespace a64;
3970
+
3971
+ // AsmJit additions - AArch64 assembler accepts variety of immediates in
3972
+ // MOVI instruction that it encodes by changing the size of its operands.
3973
+ TEST_INSTRUCTION("C1E7074F", movi(v1.b16(), 0xFE));
3974
+ TEST_INSTRUCTION("C1E7074F", movi(v1.h8(), 0xFEFE));
3975
+ TEST_INSTRUCTION("C1E7074F", movi(v1.s4(), 0xFEFEFEFE));
3976
+ TEST_INSTRUCTION("C1E7074F", movi(v1.d2(), 0xFEFEFEFEFEFEFEFE));
3977
+ TEST_INSTRUCTION("C1A7074F", movi(v1.h8(), 0xFE, lsl(8)));
3978
+ TEST_INSTRUCTION("C1A7074F", movi(v1.h8(), 0xFE00));
3979
+ TEST_INSTRUCTION("C1A7074F", movi(v1.s4(), 0xFE00FE00));
3980
+ TEST_INSTRUCTION("C1A7074F", movi(v1.d2(), 0xFE00FE00FE00FE00));
3981
+ TEST_INSTRUCTION("C147074F", movi(v1.s4(), 0xFE, lsl(16)));
3982
+ TEST_INSTRUCTION("C147074F", movi(v1.s4(), 0x00FE0000));
3983
+ TEST_INSTRUCTION("C147074F", movi(v1.d2(), 0x00FE000000FE0000));
3984
+ TEST_INSTRUCTION("C167074F", movi(v1.s4(), 0xFE, lsl(24)));
3985
+ TEST_INSTRUCTION("C167074F", movi(v1.s4(), 0xFE000000));
3986
+ TEST_INSTRUCTION("C167074F", movi(v1.d2(), 0xFE000000FE000000));
3987
+ }
3988
+
3989
+ bool testA64Assembler(const TestSettings& settings) noexcept {
3990
+ using namespace a64;
3991
+
3992
+ AssemblerTester<Assembler> tester(Arch::kAArch64, settings);
3993
+ tester.printHeader("AArch64");
3994
+
3995
+ testA64AssemblerBase(tester);
3996
+ testA64AssemblerRel(tester);
3997
+ testA64AssemblerSIMD(tester);
3998
+ testA64AssemblerExtras(tester);
3999
+
4000
+ tester.printSummary();
4001
+ return tester.didPass();
4002
+ }
4003
+
4004
+ #undef TEST_INSTRUCTION
4005
+
4006
+ #endif // !ASMJIT_NO_AARCH64