summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asmjit/test
diff options
context:
space:
mode:
author Patrick Mackinlay <pmackinlay@hotmail.com>2020-05-28 20:24:40 +0700
committer Patrick Mackinlay <pmackinlay@hotmail.com>2020-05-28 20:24:40 +0700
commit45615b7f4b7b50df29dc14bcb74fd13850bb7633 (patch)
treed2c8c1b93d68b3fb87c06060ff3f2435301dd3b9 /3rdparty/asmjit/test
parent3ed842c01cb666533da31a0bc0907ef8bd4a0f63 (diff)
asmjit: new 3rdparty library
Diffstat (limited to '3rdparty/asmjit/test')
-rw-r--r--3rdparty/asmjit/test/asmjit_bench_x86.cpp168
-rw-r--r--3rdparty/asmjit/test/asmjit_test_misc.h186
-rw-r--r--3rdparty/asmjit/test/asmjit_test_opcode.cpp108
-rw-r--r--3rdparty/asmjit/test/asmjit_test_opcode.h6060
-rw-r--r--3rdparty/asmjit/test/asmjit_test_unit.cpp332
-rw-r--r--3rdparty/asmjit/test/asmjit_test_x86_asm.cpp195
-rw-r--r--3rdparty/asmjit/test/asmjit_test_x86_cc.cpp4167
-rw-r--r--3rdparty/asmjit/test/asmjit_test_x86_sections.cpp176
-rw-r--r--3rdparty/asmjit/test/broken.cpp312
-rw-r--r--3rdparty/asmjit/test/broken.h148
10 files changed, 11852 insertions, 0 deletions
diff --git a/3rdparty/asmjit/test/asmjit_bench_x86.cpp b/3rdparty/asmjit/test/asmjit_bench_x86.cpp
new file mode 100644
index 00000000000..95f792d0c03
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_bench_x86.cpp
@@ -0,0 +1,168 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#include <asmjit/x86.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "./asmjit_test_opcode.h"
+
+#ifndef ASMJIT_NO_COMPILER
+ #include "./asmjit_test_misc.h"
+#endif
+
+using namespace asmjit;
+
+// ============================================================================
+// [Configuration]
+// ============================================================================
+
+static constexpr uint32_t kNumRepeats = 25;
+static constexpr uint32_t kNumIterations = 1000;
+
+// ============================================================================
+// [BenchUtils]
+// ============================================================================
+
+namespace BenchUtils {
+ class Performance {
+ public:
+ inline Performance() noexcept { reset(); }
+
+ inline void reset() noexcept {
+ tick = 0u;
+ best = 0xFFFFFFFFu;
+ }
+
+ inline uint32_t start() noexcept { return (tick = now()); }
+ inline uint32_t diff() const noexcept { return now() - tick; }
+
+ inline uint32_t end() noexcept {
+ tick = diff();
+ if (best > tick)
+ best = tick;
+ return tick;
+ }
+
+ static inline uint32_t now() noexcept {
+ return OSUtils::getTickCount();
+ }
+
+ uint32_t tick;
+ uint32_t best;
+ };
+
+ static double mbps(uint32_t time, uint64_t outputSize) noexcept {
+ if (!time) return 0.0;
+
+ double bytesTotal = double(outputSize);
+ return (bytesTotal * 1000) / (double(time) * 1024 * 1024);
+ }
+
+ template<typename EmitterT, typename FuncT>
+ static void bench(CodeHolder& code, uint32_t archId, const char* testName, const FuncT& func) noexcept {
+ EmitterT emitter;
+
+ const char* archName =
+ archId == ArchInfo::kIdX86 ? "X86" :
+ archId == ArchInfo::kIdX64 ? "X64" : "???";
+
+ const char* emitterName =
+ emitter.isAssembler() ? "Assembler" :
+ emitter.isCompiler() ? "Compiler" :
+ emitter.isBuilder() ? "Builder" : "Unknown";
+
+ Performance perf;
+ uint64_t codeSize = 0;
+
+ CodeInfo codeInfo(archId);
+ codeInfo.setCdeclCallConv(archId == ArchInfo::kIdX86 ? CallConv::kIdX86CDecl : CallConv::kIdX86SysV64);
+
+ for (uint32_t r = 0; r < kNumRepeats; r++) {
+ perf.start();
+ codeSize = 0;
+ for (uint32_t i = 0; i < kNumIterations; i++) {
+ code.init(codeInfo);
+ code.attach(&emitter);
+
+ func(emitter);
+ codeSize += code.codeSize();
+
+ code.reset();
+ }
+ perf.end();
+ }
+
+ printf("[%s] %-9s %-8s | Time:%6u [ms] | ", archName, emitterName, testName, perf.best);
+ if (codeSize)
+ printf("Speed: %7.3f [MB/s]", mbps(perf.best, codeSize));
+ else
+ printf("Speed: N/A");
+ printf("\n");
+ }
+}
+
+// ============================================================================
+// [Main]
+// ============================================================================
+
+#ifdef ASMJIT_BUILD_X86
+static void benchX86(uint32_t archId) noexcept {
+ CodeHolder code;
+
+ BenchUtils::bench<x86::Assembler>(code, archId, "[raw]", [](x86::Assembler& a) {
+ asmtest::generateOpcodes(a.as<x86::Emitter>());
+ });
+
+#ifndef ASMJIT_NO_BUILDER
+ BenchUtils::bench<x86::Builder>(code, archId, "[raw]", [](x86::Builder& cb) {
+ asmtest::generateOpcodes(cb.as<x86::Emitter>());
+ });
+
+ BenchUtils::bench<x86::Builder>(code, archId, "[final]", [](x86::Builder& cb) {
+ asmtest::generateOpcodes(cb.as<x86::Emitter>());
+ cb.finalize();
+ });
+#endif
+
+#ifndef ASMJIT_NO_COMPILER
+ BenchUtils::bench<x86::Compiler>(code, archId, "[raw]", [](x86::Compiler& cc) {
+ asmtest::generateAlphaBlend(cc);
+ });
+
+ BenchUtils::bench<x86::Compiler>(code, archId, "[final]", [](x86::Compiler& cc) {
+ asmtest::generateAlphaBlend(cc);
+ cc.finalize();
+ });
+#endif
+}
+#endif
+
+int main() {
+#ifdef ASMJIT_BUILD_X86
+ benchX86(ArchInfo::kIdX86);
+ benchX86(ArchInfo::kIdX64);
+#endif
+
+ return 0;
+}
diff --git a/3rdparty/asmjit/test/asmjit_test_misc.h b/3rdparty/asmjit/test/asmjit_test_misc.h
new file mode 100644
index 00000000000..be1757ab1c9
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_misc.h
@@ -0,0 +1,186 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#ifndef ASMJIT_TEST_MISC_H_INCLUDED
+#define ASMJIT_TEST_MISC_H_INCLUDED
+
+#include <asmjit/x86.h>
+
+namespace asmtest {
+
+// Generate a typical alpha blend function using SSE2 instruction set. Used
+// for benchmarking and also in test86. The generated code should be stable
+// and fully functional.
+static void generateAlphaBlend(asmjit::x86::Compiler& cc) {
+ using namespace asmjit;
+ using namespace asmjit::x86;
+
+ Gp dst = cc.newIntPtr("dst");
+ Gp src = cc.newIntPtr("src");
+
+ Gp i = cc.newIntPtr("i");
+ Gp j = cc.newIntPtr("j");
+ Gp t = cc.newIntPtr("t");
+
+ Xmm vzero = cc.newXmm("vzero");
+ Xmm v0080 = cc.newXmm("v0080");
+ Xmm v0101 = cc.newXmm("v0101");
+
+ Label L_SmallLoop = cc.newLabel();
+ Label L_SmallEnd = cc.newLabel();
+ Label L_LargeLoop = cc.newLabel();
+ Label L_LargeEnd = cc.newLabel();
+ Label L_DataPool = cc.newLabel();
+
+ cc.addFunc(FuncSignatureT<void, void*, const void*, size_t>(cc.codeInfo().cdeclCallConv()));
+
+ cc.setArg(0, dst);
+ cc.setArg(1, src);
+ cc.setArg(2, i);
+
+ // How many pixels have to be processed to make the loop aligned.
+ cc.lea(t, x86::ptr(L_DataPool));
+ cc.xorps(vzero, vzero);
+ cc.movaps(v0080, x86::ptr(t, 0));
+ cc.movaps(v0101, x86::ptr(t, 16));
+
+ cc.xor_(j, j);
+ cc.sub(j, dst);
+ cc.and_(j, 15);
+ cc.shr(j, 2);
+ cc.jz(L_SmallEnd);
+
+ cc.cmp(j, i);
+ cc.cmovg(j, i); // j = min(i, j).
+ cc.sub(i, j); // i -= j.
+
+ // Small loop.
+ cc.bind(L_SmallLoop);
+ {
+ Xmm x0 = cc.newXmm("x0");
+ Xmm y0 = cc.newXmm("y0");
+ Xmm a0 = cc.newXmm("a0");
+
+ cc.movd(y0, x86::ptr(src));
+ cc.movd(x0, x86::ptr(dst));
+
+ cc.pcmpeqb(a0, a0);
+ cc.pxor(a0, y0);
+ cc.psrlw(a0, 8);
+ cc.punpcklbw(x0, vzero);
+
+ cc.pshuflw(a0, a0, x86::Predicate::shuf(1, 1, 1, 1));
+ cc.punpcklbw(y0, vzero);
+
+ cc.pmullw(x0, a0);
+ cc.paddsw(x0, v0080);
+ cc.pmulhuw(x0, v0101);
+
+ cc.paddw(x0, y0);
+ cc.packuswb(x0, x0);
+
+ cc.movd(x86::ptr(dst), x0);
+
+ cc.add(dst, 4);
+ cc.add(src, 4);
+
+ cc.dec(j);
+ cc.jnz(L_SmallLoop);
+ }
+
+ // Second section, prepare for an aligned loop.
+ cc.bind(L_SmallEnd);
+
+ cc.test(i, i);
+ cc.mov(j, i);
+ cc.jz(cc.func()->exitLabel());
+
+ cc.and_(j, 3);
+ cc.shr(i, 2);
+ cc.jz(L_LargeEnd);
+
+ // Aligned loop.
+ cc.bind(L_LargeLoop);
+ {
+ Xmm x0 = cc.newXmm("x0");
+ Xmm x1 = cc.newXmm("x1");
+ Xmm y0 = cc.newXmm("y0");
+ Xmm a0 = cc.newXmm("a0");
+ Xmm a1 = cc.newXmm("a1");
+
+ cc.movups(y0, x86::ptr(src));
+ cc.movaps(x0, x86::ptr(dst));
+
+ cc.pcmpeqb(a0, a0);
+ cc.xorps(a0, y0);
+ cc.movaps(x1, x0);
+
+ cc.psrlw(a0, 8);
+ cc.punpcklbw(x0, vzero);
+
+ cc.movaps(a1, a0);
+ cc.punpcklwd(a0, a0);
+
+ cc.punpckhbw(x1, vzero);
+ cc.punpckhwd(a1, a1);
+
+ cc.pshufd(a0, a0, x86::Predicate::shuf(3, 3, 1, 1));
+ cc.pshufd(a1, a1, x86::Predicate::shuf(3, 3, 1, 1));
+
+ cc.pmullw(x0, a0);
+ cc.pmullw(x1, a1);
+
+ cc.paddsw(x0, v0080);
+ cc.paddsw(x1, v0080);
+
+ cc.pmulhuw(x0, v0101);
+ cc.pmulhuw(x1, v0101);
+
+ cc.add(src, 16);
+ cc.packuswb(x0, x1);
+
+ cc.paddw(x0, y0);
+ cc.movaps(x86::ptr(dst), x0);
+
+ cc.add(dst, 16);
+
+ cc.dec(i);
+ cc.jnz(L_LargeLoop);
+ }
+
+ cc.bind(L_LargeEnd);
+ cc.test(j, j);
+ cc.jnz(L_SmallLoop);
+
+ cc.endFunc();
+
+ // Data.
+ cc.align(kAlignData, 16);
+ cc.bind(L_DataPool);
+ cc.dxmm(Data128::fromI16(0x0080));
+ cc.dxmm(Data128::fromI16(0x0101));
+}
+
+} // {asmtest}
+
+#endif // ASMJIT_TEST_MISC_H_INCLUDED
diff --git a/3rdparty/asmjit/test/asmjit_test_opcode.cpp b/3rdparty/asmjit/test/asmjit_test_opcode.cpp
new file mode 100644
index 00000000000..908435beb00
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_opcode.cpp
@@ -0,0 +1,108 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+// This file is used to test opcodes generated by AsmJit. Output can be
+// disassembled in your IDE or by your favorite disassembler. Instructions
+// are grouped by category and then sorted alphabetically.
+
+#include <asmjit/x86.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "./asmjit_test_opcode.h"
+
+using namespace asmjit;
+
+struct OpcodeDumpInfo {
+ uint32_t archId;
+ bool useRex1;
+ bool useRex2;
+};
+
+static const char* archIdToString(uint32_t archId) {
+ switch (archId) {
+ case ArchInfo::kIdNone: return "None";
+ case ArchInfo::kIdX86 : return "X86";
+ case ArchInfo::kIdX64 : return "X64";
+ case ArchInfo::kIdA32 : return "A32";
+ case ArchInfo::kIdA64 : return "A64";
+
+ default:
+ return "<unknown>";
+ }
+}
+
+struct TestErrorHandler : public ErrorHandler {
+ virtual void handleError(Error err, const char* message, BaseEmitter* origin) {
+ (void)origin;
+ printf("ERROR 0x%08X: %s\n", err, message);
+ }
+};
+
+typedef void (*VoidFunc)(void);
+
+int main() {
+ TestErrorHandler eh;
+
+ OpcodeDumpInfo infoList[] = {
+ { ArchInfo::kIdX86, false, false },
+ { ArchInfo::kIdX64, false, false },
+ { ArchInfo::kIdX64, false, true },
+ { ArchInfo::kIdX64, true , false },
+ { ArchInfo::kIdX64, true , true }
+ };
+
+ for (uint32_t i = 0; i < ASMJIT_ARRAY_SIZE(infoList); i++) {
+ const OpcodeDumpInfo& info = infoList[i];
+
+ printf("Opcodes [ARCH=%s REX1=%s REX2=%s]\n",
+ archIdToString(info.archId),
+ info.useRex1 ? "true" : "false",
+ info.useRex2 ? "true" : "false");
+
+ CodeHolder code;
+ code.init(CodeInfo(info.archId));
+ code.setErrorHandler(&eh);
+
+#ifndef ASMJIT_NO_LOGGING
+ FileLogger logger(stdout);
+ logger.addFlags(FormatOptions::kFlagMachineCode);
+ code.setLogger(&logger);
+#endif
+
+ x86::Assembler a(&code);
+ asmtest::generateOpcodes(a.as<x86::Emitter>(), info.useRex1, info.useRex2);
+
+ // If this is the host architecture the code generated can be executed
+ // for debugging purposes (the first instruction is ret anyway).
+ if (code.archId() == ArchInfo::kIdHost) {
+ JitRuntime runtime;
+ VoidFunc p;
+
+ Error err = runtime.add(&p, &code);
+ if (err == kErrorOk) p();
+ }
+ }
+
+ return 0;
+}
diff --git a/3rdparty/asmjit/test/asmjit_test_opcode.h b/3rdparty/asmjit/test/asmjit_test_opcode.h
new file mode 100644
index 00000000000..e89db426ffd
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_opcode.h
@@ -0,0 +1,6060 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#ifndef ASMJIT_TEST_OPCODE_H_INCLUDED
+#define ASMJIT_TEST_OPCODE_H_INCLUDED
+
+#include <asmjit/x86.h>
+
+namespace asmtest {
+
+// Generate all instructions asmjit can emit.
+static void generateOpcodes(asmjit::x86::Emitter* e, bool useRex1 = false, bool useRex2 = false) {
+ using namespace asmjit;
+ using namespace asmjit::x86;
+
+ bool isX64 = e->is64Bit();
+
+ // Prevent a crash when the generated function is called to see the disassembly.
+ e->ret();
+
+ // All instructions use the following register that can be changed to see if
+ // `x86::Assembler` can properly encode all possible combinations. If the given
+ // `useRexRegs` argument is true the `A` version will in most cases contain
+ // a register having index 8 or greater to force REX prefix.
+ Gp gLoA = useRex1 ? r8b : al;
+ Gp gLoB = useRex2 ? r9b : bl;
+
+ Gp gHiA = ah;
+ Gp gHiB = bh;
+
+ Gp gwA = useRex1 ? r8w : ax;
+ Gp gwB = useRex2 ? r9w : bx;
+
+ Gp gdA = useRex1 ? r8d : eax;
+ Gp gdB = useRex2 ? r9d : ebx;
+ Gp gdC = useRex2 ? r10d : ecx;
+
+ Gp gzA = useRex1 ? r8 : e->zax();
+ Gp gzB = useRex2 ? r9 : e->zbx();
+ Gp gzC = useRex2 ? r10 : e->zcx();
+ Gp gzD = useRex2 ? r11 : e->zdx();
+
+ KReg kA = k1;
+ KReg kB = k2;
+ KReg kC = k3;
+
+ Mem anyptr_gpA = ptr(gzA);
+ Mem anyptr_gpB = ptr(gzB);
+ Mem anyptr_gpC = ptr(gzC);
+ Mem anyptr_gpD = ptr(gzD);
+
+ Mem intptr_gpA = e->intptr_ptr(gzA);
+ Mem intptr_gpB = e->intptr_ptr(gzB);
+
+ St stA = st0;
+ St stB = st7;
+
+ Mm mmA = mm0;
+ Mm mmB = mm1;
+
+ Xmm xmmA = useRex1 ? xmm8 : xmm0;
+ Xmm xmmB = useRex2 ? xmm9 : xmm1;
+ Xmm xmmC = useRex2 ? xmm10 : xmm2;
+ Xmm xmmD = useRex2 ? xmm11 : xmm3;
+
+ Ymm ymmA = useRex1 ? ymm8 : ymm0;
+ Ymm ymmB = useRex2 ? ymm9 : ymm1;
+ Ymm ymmC = useRex2 ? ymm10 : ymm2;
+ Ymm ymmD = useRex2 ? ymm11 : ymm3;
+
+ Zmm zmmA = useRex1 ? zmm8 : zmm0;
+ Zmm zmmB = useRex2 ? zmm9 : zmm1;
+ Zmm zmmC = useRex2 ? zmm10 : zmm2;
+ Zmm zmmD = useRex2 ? zmm11 : zmm3;
+
+ Mem vx_ptr = ptr(gzB, xmmB);
+ Mem vy_ptr = ptr(gzB, ymmB);
+ Mem vz_ptr = ptr(gzB, zmmB);
+
+ Label L;
+
+ // Base.
+ e->adc(gLoA, 1);
+ e->adc(gLoB, 1);
+ e->adc(gHiA, 1);
+ e->adc(gHiB, 1);
+ e->adc(gwA, 1);
+ e->adc(gwB, 1);
+ e->adc(gdA, 1);
+ e->adc(gdB, 1);
+ e->adc(gzA, 1);
+ e->adc(gzA, gzB);
+ e->adc(gzA, intptr_gpB);
+ e->adc(intptr_gpA, 1);
+ e->adc(intptr_gpA, gzB);
+ e->add(gLoA, 1);
+ e->add(gLoB, 1);
+ e->add(gHiA, 1);
+ e->add(gHiB, 1);
+ e->add(gwA, 1);
+ e->add(gwB, 1);
+ e->add(gdA, 1);
+ e->add(gdB, 1);
+ e->add(gzA, 1);
+ e->add(gzA, gzB);
+ e->add(gzA, intptr_gpB);
+ e->add(intptr_gpA, 1);
+ e->add(intptr_gpA, gzB);
+ e->and_(gLoA, 1);
+ e->and_(gLoB, 1);
+ e->and_(gHiA, 1);
+ e->and_(gHiB, 1);
+ e->and_(gwA, 1);
+ e->and_(gwB, 1);
+ e->and_(gdA, 1);
+ e->and_(gdB, 1);
+ e->and_(gzA, 1);
+ e->and_(gzA, gzB);
+ e->and_(gzA, intptr_gpB);
+ e->and_(intptr_gpA, 1);
+ e->and_(intptr_gpA, gzB);
+ e->bswap(gzA);
+ e->bt(gdA, 1);
+ e->bt(gzA, 1);
+ e->bt(gdA, gdB);
+ e->bt(gzA, gzB);
+ e->bt(intptr_gpA, 1);
+ e->bt(anyptr_gpA, gdB);
+ e->bt(intptr_gpA, gzB);
+ e->btc(gdA, 1);
+ e->btc(gzA, 1);
+ e->btc(gdA, gdB);
+ e->btc(gzA, gzB);
+ e->btc(intptr_gpA, 1);
+ e->btc(anyptr_gpA, gdB);
+ e->btc(intptr_gpA, gzB);
+ e->btr(gdA, 1);
+ e->btr(gzA, 1);
+ e->btr(gdA, gdB);
+ e->btr(gzA, gzB);
+ e->btr(intptr_gpA, 1);
+ e->btr(anyptr_gpA, gdB);
+ e->btr(intptr_gpA, gzB);
+ e->bts(gdA, 1);
+ e->bts(gzA, 1);
+ e->bts(gdA, gdB);
+ e->bts(gzA, gzB);
+ e->bts(intptr_gpA, 1);
+ e->bts(anyptr_gpA, gdB);
+ e->bts(intptr_gpA, gzB);
+ e->call(gzA);
+ e->call(intptr_gpA);
+ e->cbw(); // Implicit AX <- Sign Extend AL.
+ e->cbw(ax); // Explicit AX <- Sign Extend AL.
+ e->cdq(); // Implicit EDX:EAX <- Sign Extend EAX.
+ e->cdq(edx, eax); // Explicit EDX:EAX <- Sign Extend EAX.
+ if (isX64) e->cdqe(); // Implicit RAX <- Sign Extend EAX.
+ if (isX64) e->cdqe(eax); // Explicit RAX <- Sign Extend EAX.
+ e->cwd(); // Implicit DX:AX <- Sign Extend AX.
+ e->cwd(dx, ax); // Explicit DX:AX <- Sign Extend AX.
+ e->cwde(); // Implicit EAX <- Sign Extend AX.
+ e->cwde(eax); // Explicit EAX <- Sign Extend AX.
+ if (isX64) e->cqo(); // Implicit RDX:RAX <- Sign Extend RAX.
+ if (isX64) e->cqo(rdx, rax); // Explicit RDX:RAX <- Sign Extend RAX.
+ e->clc();
+ e->cld();
+ e->cmc();
+ e->cmp(gLoA, 1);
+ e->cmp(gLoB, 1);
+ e->cmp(gHiA, 1);
+ e->cmp(gHiB, 1);
+ e->cmp(gwA, 1);
+ e->cmp(gwB, 1);
+ e->cmp(gdA, 1);
+ e->cmp(gdB, 1);
+ e->cmp(gzA, 1);
+ e->cmp(gLoA, gLoB);
+ e->cmp(gHiA, gHiB);
+ e->cmp(gwA, gwB);
+ e->cmp(gdA, gdB);
+ e->cmp(gzA, gzB);
+ e->cmp(gdA, anyptr_gpB);
+ e->cmp(gzA, intptr_gpB);
+ e->cmp(intptr_gpA, 1);
+ e->cmp(anyptr_gpA, gdB);
+ e->cmp(intptr_gpA, gzB);
+ e->cmpxchg(gdA, gdB); // Implicit regA, regB, <EAX>
+ e->cmpxchg(gzA, gzB); // Implicit regA, regB, <ZAX>
+ e->cmpxchg(gdA, gdB, eax); // Explicit regA, regB, <EAX>
+ e->cmpxchg(gzA, gzB, e->zax()); // Explicit regA, regB, <ZAX>
+ e->cmpxchg(anyptr_gpA, gdB); // Implicit mem , regB, <EAX>
+ e->cmpxchg(anyptr_gpA, gzB); // Implicit mem , regB, <ZAX>
+ e->cmpxchg(anyptr_gpA, gdB, eax); // Explicit mem , regB, <EAX>
+ e->cmpxchg(anyptr_gpA, gzB, e->zax()); // Explicit mem , regB, <ZAX>
+ e->cmpxchg8b(anyptr_gpA); // Implicit mem , <EDX>, <EAX>, <ECX>, <EBX>
+ e->cmpxchg8b(anyptr_gpA,
+ x86::edx, x86::eax,
+ x86::ecx, x86::ebx); // Explicit mem , <EDX>, <EAX>, <ECX>, <EBX>
+ if (isX64) e->cmpxchg16b(anyptr_gpA); // Implicit mem , <RDX>, <RAX>, <RCX>, <RBX>
+ if (isX64) e->cmpxchg16b(anyptr_gpA,
+ x86::rdx, x86::rax,
+ x86::rcx, x86::rbx); // Explicit mem , <EDX>, <EAX>, <ECX>, <EBX>
+ e->cpuid(); // Implicit <EAX>, <EBX>, <ECX>, <EDX>
+ e->cpuid(eax, ebx, ecx, edx); // Explicit <EAX>, <EBX>, <ECX>, <EDX>
+ e->crc32(gdA, byte_ptr(gzB));
+ e->crc32(gdA, word_ptr(gzB));
+ e->crc32(gdA, dword_ptr(gzB));
+ if (isX64) e->crc32(gdA, qword_ptr(gzB));
+ if (isX64) e->crc32(gzA, qword_ptr(gzB));
+ e->dec(gLoA);
+ e->dec(gHiA);
+ e->dec(gwA);
+ e->dec(gdA);
+ e->dec(gzA);
+ e->dec(intptr_gpA);
+ e->inc(gLoA);
+ e->inc(gwA);
+ e->inc(gdA);
+ e->inc(gzA);
+ e->inc(intptr_gpA);
+ e->int_(13);
+ e->int3();
+ e->into();
+ e->lea(gzA, intptr_gpB);
+ e->mov(gLoA, 1);
+ e->mov(gHiA, 1);
+ e->mov(gwA, 1);
+ e->mov(gdA, 1);
+ e->mov(gzA, 1);
+ e->mov(gLoA, gLoB);
+ e->mov(gHiA, gHiB);
+ e->mov(gwA, gwB);
+ e->mov(gdA, gdB);
+ e->mov(gzA, gzB);
+ e->mov(gLoA, anyptr_gpB);
+ e->mov(gwA, anyptr_gpB);
+ e->mov(gdA, anyptr_gpB);
+ e->mov(gzA, intptr_gpB);
+ e->mov(anyptr_gpA, gLoB);
+ e->mov(anyptr_gpA, gwB);
+ e->mov(anyptr_gpA, gdB);
+ e->mov(intptr_gpA, 1);
+ e->mov(intptr_gpA, gzB);
+ e->movsx(gzA, gLoB);
+ e->movsx(gzA, byte_ptr(gzB));
+ e->movzx(gzA, gLoB);
+ e->movzx(gzA, byte_ptr(gzB));
+ e->movbe(gzA, anyptr_gpB);
+ e->movbe(anyptr_gpA, gzB);
+ e->neg(gzA);
+ e->neg(intptr_gpA);
+ e->nop();
+ e->not_(gzA);
+ e->not_(intptr_gpA);
+ e->or_(gLoA, 1);
+ e->or_(gLoB, 1);
+ e->or_(gHiA, 1);
+ e->or_(gHiB, 1);
+ e->or_(gwA, 1);
+ e->or_(gwB, 1);
+ e->or_(gdA, 1);
+ e->or_(gdB, 1);
+ e->or_(gzA, 1);
+ e->or_(gzA, gzB);
+ e->or_(gzA, intptr_gpB);
+ e->or_(intptr_gpA, 1);
+ e->or_(intptr_gpA, gzB);
+ e->pop(gzA);
+ e->pop(intptr_gpA);
+ if (!isX64) e->popa();
+ if (!isX64) e->popad();
+ e->popf();
+ if (!isX64) e->popfd();
+ if ( isX64) e->popfq();
+ e->push(gzA);
+ e->push(intptr_gpA);
+ e->push(0);
+ if (!isX64) e->pusha();
+ if (!isX64) e->pushad();
+ e->pushf();
+ if (!isX64) e->pushfd();
+ if ( isX64) e->pushfq();
+ e->rcl(gdA, 0);
+ e->rcl(gzA, 0);
+ e->rcl(gdA, 1);
+ e->rcl(gzA, 1);
+ e->rcl(gdA, cl);
+ e->rcl(gzA, cl);
+ e->rcl(intptr_gpA, 0);
+ e->rcl(intptr_gpA, 1);
+ e->rcl(intptr_gpA, cl);
+ e->rcr(gdA, 0);
+ e->rcr(gzA, 0);
+ e->rcr(gdA, 1);
+ e->rcr(gzA, 1);
+ e->rcr(gdA, cl);
+ e->rcr(gzA, cl);
+ e->rcr(intptr_gpA, 0);
+ e->rcr(intptr_gpA, 1);
+ e->rcr(intptr_gpA, cl);
+ e->rdtsc(); // Implicit <EDX:EAX>
+ e->rdtsc(edx, eax); // Explicit <EDX:EAX>
+ e->rdtscp(); // Implicit <EDX:EAX>, <ECX>
+ e->rdtscp(edx, eax, ecx); // Implicit <EDX:EAX>, <ECX>
+ e->ret();
+ e->ret(0);
+ e->rol(gdA, 0);
+ e->rol(gzA, 0);
+ e->rol(gdA, 1);
+ e->rol(gzA, 1);
+ e->rol(gdA, cl);
+ e->rol(gzA, cl);
+ e->rol(intptr_gpA, 0);
+ e->rol(intptr_gpA, 1);
+ e->rol(intptr_gpA, cl);
+ e->ror(gdA, 0);
+ e->ror(gzA, 0);
+ e->ror(gdA, 1);
+ e->ror(gzA, 1);
+ e->ror(gdA, cl);
+ e->ror(gzA, cl);
+ e->ror(intptr_gpA, 0);
+ e->ror(intptr_gpA, 1);
+ e->ror(intptr_gpA, cl);
+ e->sbb(gLoA, 1);
+ e->sbb(gLoB, 1);
+ e->sbb(gHiA, 1);
+ e->sbb(gHiB, 1);
+ e->sbb(gwA, 1);
+ e->sbb(gwB, 1);
+ e->sbb(gdA, 1);
+ e->sbb(gdB, 1);
+ e->sbb(gzA, 1);
+ e->sbb(gzA, gzB);
+ e->sbb(gzA, intptr_gpB);
+ e->sbb(intptr_gpA, 1);
+ e->sbb(intptr_gpA, gzB);
+ e->sal(gdA, 0);
+ e->sal(gzA, 0);
+ e->sal(gdA, 1);
+ e->sal(gzA, 1);
+ e->sal(gdA, cl);
+ e->sal(gzA, cl);
+ e->sal(intptr_gpA, 0);
+ e->sal(intptr_gpA, 1);
+ e->sal(intptr_gpA, cl);
+ e->sar(gdA, 0);
+ e->sar(gzA, 0);
+ e->sar(gdA, 1);
+ e->sar(gzA, 1);
+ e->sar(gdA, cl);
+ e->sar(gzA, cl);
+ e->sar(intptr_gpA, 0);
+ e->sar(intptr_gpA, 1);
+ e->sar(intptr_gpA, cl);
+ e->shl(gdA, 0);
+ e->shl(gzA, 0);
+ e->shl(gdA, 1);
+ e->shl(gzA, 1);
+ e->shl(gdA, cl);
+ e->shl(gzA, cl);
+ e->shl(intptr_gpA, 0);
+ e->shl(intptr_gpA, 1);
+ e->shl(intptr_gpA, cl);
+ e->shr(gdA, 0);
+ e->shr(gzA, 0);
+ e->shr(gdA, 1);
+ e->shr(gzA, 1);
+ e->shr(gdA, cl);
+ e->shr(gzA, cl);
+ e->shr(intptr_gpA, 0);
+ e->shr(intptr_gpA, 1);
+ e->shr(intptr_gpA, cl);
+ e->shld(gdA, gdB, 0);
+ e->shld(gzA, gzB, 0);
+ e->shld(gdA, gdB, cl);
+ e->shld(gzA, gzB, cl);
+ e->shld(anyptr_gpA, gdB, 0);
+ e->shld(intptr_gpA, gzB, 0);
+ e->shld(anyptr_gpA, gdB, cl);
+ e->shld(intptr_gpA, gzB, cl);
+ e->shrd(gdA, gdB, 0);
+ e->shrd(gzA, gzB, 0);
+ e->shrd(gdA, gdB, cl);
+ e->shrd(gzA, gzB, cl);
+ e->shrd(anyptr_gpA, gdB, 0);
+ e->shrd(intptr_gpA, gzB, 0);
+ e->shrd(anyptr_gpA, gdB, cl);
+ e->shrd(intptr_gpA, gzB, cl);
+ e->stc();
+ e->std();
+ e->sti();
+ e->sub(gLoA, 1);
+ e->sub(gLoB, 1);
+ e->sub(gHiA, 1);
+ e->sub(gHiB, 1);
+ e->sub(gwA, 1);
+ e->sub(gwB, 1);
+ e->sub(gdA, 1);
+ e->sub(gdB, 1);
+ e->sub(gzA, 1);
+ e->sub(gzA, gzB);
+ e->sub(gzA, intptr_gpB);
+ e->sub(intptr_gpA, 1);
+ e->sub(intptr_gpA, gzB);
+ e->swapgs();
+ e->test(gzA, 1);
+ e->test(gzA, gzB);
+ e->test(intptr_gpA, 1);
+ e->test(intptr_gpA, gzB);
+ e->ud2();
+ e->xadd(gzA, gzB);
+ e->xadd(intptr_gpA, gzB);
+ e->xchg(gzA, gzB);
+ e->xchg(intptr_gpA, gzB);
+ e->xchg(gzA, intptr_gpB);
+ e->xor_(gLoA, 1);
+ e->xor_(gLoB, 1);
+ e->xor_(gHiA, 1);
+ e->xor_(gHiB, 1);
+ e->xor_(gwA, 1);
+ e->xor_(gwB, 1);
+ e->xor_(gdA, 1);
+ e->xor_(gdB, 1);
+ e->xor_(gzA, 1);
+ e->xor_(gzA, gzB);
+ e->xor_(gzA, intptr_gpB);
+ e->xor_(intptr_gpA, 1);
+ e->xor_(intptr_gpA, gzB);
+
+ // Special case - div|mul.
+ e->div(cl); // Implicit AH:AL <- AX * r8
+ e->div(byte_ptr(gzA)); // Implicit AH:AL <- AX * m8
+ e->div(ax, cl); // Explicit AH:AL <- AX * r8
+ e->div(ax, anyptr_gpA); // Explicit AH:AL <- AX * m8
+
+ e->div(cx); // Implicit DX:AX <- DX:AX * r16
+ e->div(word_ptr(gzA)); // Implicit DX:AX <- DX:AX * m16
+ e->div(dx, ax, cx); // Explicit DX:AX <- DX:AX * r16
+ e->div(dx, ax, anyptr_gpA); // Explicit DX:AX <- DX:AX * m16
+
+ e->div(ecx); // Implicit EDX:EAX <- EDX:EAX * r32
+ e->div(dword_ptr(gzA)); // Implicit EDX:EAX <- EDX:EAX * m32
+ e->div(edx, eax, ecx); // Explicit EDX:EAX <- EDX:EAX * r32
+ e->div(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EDX:EAX * m32
+
+ if (isX64) e->div(rcx); // Implicit RDX|RAX <- RDX:RAX * r64
+ if (isX64) e->div(qword_ptr(gzA)); // Implicit RDX|RAX <- RDX:RAX * m64
+ if (isX64) e->div(rdx, rax, rcx); // Explicit RDX|RAX <- RDX:RAX * r64
+ if (isX64) e->div(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RDX:RAX * m64
+
+ e->idiv(cl); // Implicit AH:AL <- AX * r8
+ e->idiv(byte_ptr(gzA)); // Implicit AH:AL <- AX * m8
+ e->idiv(ax, cl); // Explicit AH:AL <- AX * r8
+ e->idiv(ax, anyptr_gpA); // Explicit AH:AL <- AX * m8
+
+ e->idiv(cx); // Implicit DX:AX <- DX:AX * r16
+ e->idiv(word_ptr(gzA)); // Implicit DX:AX <- DX:AX * m16
+ e->idiv(dx, ax, cx); // Explicit DX:AX <- DX:AX * r16
+ e->idiv(dx, ax, anyptr_gpA); // Explicit DX:AX <- DX:AX * m16
+
+ e->idiv(ecx); // Implicit EDX:EAX <- EDX:EAX * r32
+ e->idiv(dword_ptr(gzA)); // Implicit EDX:EAX <- EDX:EAX * m32
+ e->idiv(edx, eax, ecx); // Explicit EDX:EAX <- EDX:EAX * r32
+ e->idiv(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EDX:EAX * m32
+
+ if (isX64) e->idiv(rcx); // Implicit RDX|RAX <- RDX:RAX * r64
+ if (isX64) e->idiv(qword_ptr(gzA)); // Implicit RDX|RAX <- RDX:RAX * m64
+ if (isX64) e->idiv(rdx, rax, rcx); // Explicit RDX|RAX <- RDX:RAX * r64
+ if (isX64) e->idiv(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RDX:RAX * m64
+
+ e->mul(cl); // Implicit AX <- AL * r8
+ e->mul(byte_ptr(gzA)); // Implicit AX <- AL * m8
+ e->mul(ax, cl); // Explicit AX <- AL * r8
+ e->mul(ax, anyptr_gpA); // Explicit AX <- AL * m8
+
+ e->mul(cx); // Implicit DX:AX <- AX * r16
+ e->mul(word_ptr(gzA)); // Implicit DX:AX <- AX * m16
+ e->mul(dx, ax, cx); // Explicit DX:AX <- AX * r16
+ e->mul(dx, ax, anyptr_gpA); // Explicit DX:AX <- AX * m16
+
+ e->mul(ecx); // Implicit EDX:EAX <- EAX * r32
+ e->mul(dword_ptr(gzA)); // Implicit EDX:EAX <- EAX * m32
+ e->mul(edx, eax, ecx); // Explicit EDX:EAX <- EAX * r32
+ e->mul(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EAX * m32
+
+ if (isX64) e->mul(rcx); // Implicit RDX|RAX <- RAX * r64
+ if (isX64) e->mul(qword_ptr(gzA)); // Implicit RDX|RAX <- RAX * m64
+ if (isX64) e->mul(rdx, rax, rcx); // Explicit RDX|RAX <- RAX * r64
+ if (isX64) e->mul(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RAX * m64
+
+ e->imul(gdA);
+ e->imul(gzA);
+ e->imul(intptr_gpA);
+ e->imul(gdA, 1);
+ e->imul(gzA, 1);
+ e->imul(gdA, gdB);
+ e->imul(gzA, gzB);
+ e->imul(gdA, gdB, 1);
+ e->imul(gzA, gzB, 1);
+ e->imul(gdA, anyptr_gpB);
+ e->imul(gzA, intptr_gpB);
+ e->imul(gdA, anyptr_gpB, 1);
+ e->imul(gzA, intptr_gpB, 1);
+
+ // Special case - zero-extend 32-bit immediate instead of sign-extend:
+ if (isX64) e->mov(gzA, uint32_t(0xFEEDFEED));
+ if (isX64) e->and_(gzA, uint32_t(0xFEEDFEED));
+
+ // Special case - mov with absolute 32-bit address.
+ e->mov(al , ptr(0x01020304u));
+ e->mov(ax , ptr(0x01020304u));
+ e->mov(eax, ptr(0x01020304u));
+ e->mov(ptr(0x01020304u), al );
+ e->mov(ptr(0x01020304u), ax );
+ e->mov(ptr(0x01020304u), eax);
+
+ // Special case - mov with absolute 64-bit address.
+ if (isX64) e->mov(al , ptr(0x0102030405060708u));
+ if (isX64) e->mov(ax , ptr(0x0102030405060708u));
+ if (isX64) e->mov(eax, ptr(0x0102030405060708u));
+ if (isX64) e->mov(rax, ptr(0x0102030405060708u));
+ if (isX64) e->mov(ptr(0x0102030405060708u), al );
+ if (isX64) e->mov(ptr(0x0102030405060708u), ax );
+ if (isX64) e->mov(ptr(0x0102030405060708u), eax);
+ if (isX64) e->mov(ptr(0x0102030405060708u), rax);
+
+ // Control registers.
+ e->nop();
+
+ e->mov(gzA, cr0);
+ e->mov(cr0, gzA);
+ if (isX64) e->mov(gzA, cr8);
+ if (isX64) e->mov(cr8, gzA);
+
+ // Debug registers.
+ e->nop();
+
+ e->mov(gzA, dr0);
+ e->mov(dr0, gzA);
+
+ // Segment registers.
+ e->nop();
+
+ if (!isX64) e->mov(es, ax);
+ if (!isX64) e->mov(es, bx);
+ if (!isX64) e->mov(ax, es);
+ if (!isX64) e->mov(bx, es);
+
+ if (!isX64) e->mov(cs, ax);
+ if (!isX64) e->mov(cs, bx);
+ if (!isX64) e->mov(ax, cs);
+ if (!isX64) e->mov(bx, cs);
+
+ if (!isX64) e->mov(ss, ax);
+ if (!isX64) e->mov(ss, bx);
+ if (!isX64) e->mov(ax, ss);
+ if (!isX64) e->mov(bx, ss);
+
+ if (!isX64) e->mov(ds, ax);
+ if (!isX64) e->mov(ds, bx);
+ if (!isX64) e->mov(ax, ds);
+ if (!isX64) e->mov(bx, ds);
+
+ e->mov(fs, ax);
+ e->mov(fs, bx);
+ e->mov(ax, fs);
+ e->mov(bx, fs);
+
+ e->mov(gs, ax);
+ e->mov(gs, bx);
+ e->mov(ax, gs);
+ e->mov(bx, gs);
+
+ // Instructions using REP prefix.
+ e->nop();
+
+ e->in(al, 0);
+ e->in(al, dx);
+ e->in(ax, 0);
+ e->in(ax, dx);
+ e->in(eax, 0);
+ e->in(eax, dx);
+ e->rep().ins(byte_ptr(e->zdi()), dx);
+ e->rep().ins(word_ptr(e->zdi()), dx);
+ e->rep().ins(dword_ptr(e->zdi()), dx);
+
+ e->out(imm(0), al);
+ e->out(dx, al);
+ e->out(imm(0), ax);
+ e->out(dx, ax);
+ e->out(imm(0), eax);
+ e->out(dx, eax);
+ e->rep().outs(dx, byte_ptr(e->zsi()));
+ e->rep().outs(dx, word_ptr(e->zsi()));
+ e->rep().outs(dx, dword_ptr(e->zsi()));
+
+ e->lodsb();
+ e->lodsd();
+ e->lodsw();
+ e->rep().lodsb();
+ e->rep().lodsd();
+ e->rep().lodsw();
+ if (isX64) e->rep().lodsq();
+
+ e->movsb();
+ e->movsd();
+ e->movsw();
+ e->rep().movsb();
+ e->rep().movsd();
+ e->rep().movsw();
+ if (isX64) e->rep().movsq();
+
+ e->stosb();
+ e->stosd();
+ e->stosw();
+ e->rep().stosb();
+ e->rep().stosd();
+ e->rep().stosw();
+ if (isX64) e->rep().stosq();
+
+ e->cmpsb();
+ e->cmpsd();
+ e->cmpsw();
+ e->repz().cmpsb();
+ e->repz().cmpsd();
+ e->repz().cmpsw();
+ if (isX64) e->repz().cmpsq();
+ e->repnz().cmpsb();
+ e->repnz().cmpsd();
+ e->repnz().cmpsw();
+ if (isX64) e->repnz().cmpsq();
+
+ e->scasb();
+ e->scasd();
+ e->scasw();
+ e->repz().scasb();
+ e->repz().scasd();
+ e->repz().scasw();
+ if (isX64) e->repz().scasq();
+ e->repnz().scasb();
+ e->repnz().scasd();
+ e->repnz().scasw();
+ if (isX64) e->repnz().scasq();
+
+ // Label...Jcc/Jecxz/Jmp.
+ e->nop();
+
+ L = e->newLabel();
+ e->bind(L);
+ e->ja(L);
+ e->jae(L);
+ e->jb(L);
+ e->jbe(L);
+ e->jc(L);
+ e->je(L);
+ e->jg(L);
+ e->jge(L);
+ e->jl(L);
+ e->jle(L);
+ e->jna(L);
+ e->jnae(L);
+ e->jnb(L);
+ e->jnbe(L);
+ e->jnc(L);
+ e->jne(L);
+ e->jng(L);
+ e->jnge(L);
+ e->jnl(L);
+ e->jnle(L);
+ e->jno(L);
+ e->jnp(L);
+ e->jns(L);
+ e->jnz(L);
+ e->jo(L);
+ e->jp(L);
+ e->jpe(L);
+ e->jpo(L);
+ e->js(L);
+ e->jz(L);
+ e->jecxz(ecx, L);
+ e->jmp(L);
+
+ // Jcc/Jecxz/Jmp...Label.
+ e->nop();
+
+ L = e->newLabel();
+ e->ja(L);
+ e->jae(L);
+ e->jb(L);
+ e->jbe(L);
+ e->jc(L);
+ e->je(L);
+ e->jg(L);
+ e->jge(L);
+ e->jl(L);
+ e->jle(L);
+ e->jna(L);
+ e->jnae(L);
+ e->jnb(L);
+ e->jnbe(L);
+ e->jnc(L);
+ e->jne(L);
+ e->jng(L);
+ e->jnge(L);
+ e->jnl(L);
+ e->jnle(L);
+ e->jno(L);
+ e->jnp(L);
+ e->jns(L);
+ e->jnz(L);
+ e->jo(L);
+ e->jp(L);
+ e->jpe(L);
+ e->jpo(L);
+ e->js(L);
+ e->jz(L);
+ e->jecxz(ecx, L);
+ e->jmp(L);
+ e->bind(L);
+
+ // FPU.
+ e->nop();
+
+ e->f2xm1();
+ e->fabs();
+ e->fadd(stA, stB);
+ e->fadd(stB, stA);
+ e->fadd(dword_ptr(gzA));
+ e->fadd(qword_ptr(gzA));
+ e->faddp(stB);
+ e->faddp();
+ e->fbld(dword_ptr(gzA));
+ e->fbstp(dword_ptr(gzA));
+ e->fchs();
+ e->fclex();
+ e->fcom(stB);
+ e->fcom();
+ e->fcom(dword_ptr(gzA));
+ e->fcom(qword_ptr(gzA));
+ e->fcomp(stB);
+ e->fcomp();
+ e->fcomp(dword_ptr(gzA));
+ e->fcomp(qword_ptr(gzA));
+ e->fcompp();
+ e->fcos();
+ e->fdecstp();
+ e->fdiv(stA, stB);
+ e->fdiv(stB, stA);
+ e->fdiv(dword_ptr(gzA));
+ e->fdiv(qword_ptr(gzA));
+ e->fdivp(stB);
+ e->fdivp();
+ e->fdivr(stA, stB);
+ e->fdivr(stB, stA);
+ e->fdivr(dword_ptr(gzA));
+ e->fdivr(qword_ptr(gzA));
+ e->fdivrp(stB);
+ e->fdivrp();
+ e->fiadd(dword_ptr(gzA));
+ e->ficom(word_ptr(gzA));
+ e->ficom(dword_ptr(gzA));
+ e->ficomp(word_ptr(gzA));
+ e->ficomp(dword_ptr(gzA));
+ e->fidiv(word_ptr(gzA));
+ e->fidiv(dword_ptr(gzA));
+ e->fidivr(word_ptr(gzA));
+ e->fidivr(dword_ptr(gzA));
+ e->fild(word_ptr(gzA));
+ e->fild(dword_ptr(gzA));
+ e->fild(qword_ptr(gzA));
+ e->fimul(word_ptr(gzA));
+ e->fimul(dword_ptr(gzA));
+ e->fincstp();
+ e->finit();
+ e->fninit();
+ e->fisub(word_ptr(gzA));
+ e->fisub(dword_ptr(gzA));
+ e->fisubr(word_ptr(gzA));
+ e->fisubr(dword_ptr(gzA));
+ e->fist(word_ptr(gzA));
+ e->fist(dword_ptr(gzA));
+ e->fistp(word_ptr(gzA));
+ e->fistp(dword_ptr(gzA));
+ e->fistp(qword_ptr(gzA));
+ e->fld(dword_ptr(gzA));
+ e->fld(qword_ptr(gzA));
+ e->fld(tword_ptr(gzA));
+ e->fld1();
+ e->fldl2t();
+ e->fldl2e();
+ e->fldpi();
+ e->fldlg2();
+ e->fldln2();
+ e->fldz();
+ e->fldcw(anyptr_gpA);
+ e->fldenv(anyptr_gpA);
+ e->fmul(stA, stB);
+ e->fmul(stB, stA);
+ e->fmul(dword_ptr(gzA));
+ e->fmul(qword_ptr(gzA));
+ e->fmulp(stB);
+ e->fmulp();
+ e->fnclex();
+ e->fnop();
+ e->fnsave(anyptr_gpA);
+ e->fnstenv(anyptr_gpA);
+ e->fnstcw(anyptr_gpA);
+ e->fpatan();
+ e->fprem();
+ e->fprem1();
+ e->fptan();
+ e->frndint();
+ e->frstor(anyptr_gpA);
+ e->fsave(anyptr_gpA);
+ e->fscale();
+ e->fsin();
+ e->fsincos();
+ e->fsqrt();
+ e->fst(dword_ptr(gzA));
+ e->fst(qword_ptr(gzA));
+ e->fstp(dword_ptr(gzA));
+ e->fstp(qword_ptr(gzA));
+ e->fstp(tword_ptr(gzA));
+ e->fstcw(anyptr_gpA);
+ e->fstenv(anyptr_gpA);
+ e->fsub(stA, stB);
+ e->fsub(stB, stA);
+ e->fsub(dword_ptr(gzA));
+ e->fsub(qword_ptr(gzA));
+ e->fsubp(stB);
+ e->fsubp();
+ e->fsubr(stA, stB);
+ e->fsubr(stB, stA);
+ e->fsubr(dword_ptr(gzA));
+ e->fsubr(qword_ptr(gzA));
+ e->fsubrp(stB);
+ e->fsubrp();
+ e->ftst();
+ e->fucom(stB);
+ e->fucom();
+ e->fucom(stB);
+ e->fucomi(stB);
+ e->fucomip(stB);
+ e->fucomp(stB);
+ e->fucompp();
+ e->fxam();
+ e->fxtract();
+ e->fyl2x();
+ e->fyl2xp1();
+
+ // LAHF/SAHF
+ e->lahf(); // Implicit <AH>
+ e->lahf(ah); // Explicit <AH>
+ e->sahf(); // Implicit <AH>
+ e->sahf(ah); // Explicit <AH>
+
+ // FXSR.
+ e->fxrstor(anyptr_gpA);
+ e->fxsave(anyptr_gpA);
+
+ // XSAVE.
+ e->nop();
+
+ e->xgetbv(); // Implicit <EDX:EAX>, <ECX>
+ e->xgetbv(edx, eax, ecx); // Explicit <EDX:EAX>, <ECX>
+
+ e->xsetbv(); // Implicit <EDX:EAX>, <ECX>
+ e->xsetbv(edx, eax, ecx); // Explicit <EDX:EAX>, <ECX>
+
+ e->xrstor(anyptr_gpA); // Implicit <EDX:EAX>
+ e->xrstors(anyptr_gpA); // Implicit <EDX:EAX>
+ e->xsave(anyptr_gpA); // Implicit <EDX:EAX>
+ e->xsavec(anyptr_gpA); // Implicit <EDX:EAX>
+ e->xsaveopt(anyptr_gpA); // Implicit <EDX:EAX>
+ e->xsaves(anyptr_gpA); // Implicit <EDX:EAX>
+
+ if (isX64) e->xrstor64(anyptr_gpA); // Implicit <EDX:EAX>
+ if (isX64) e->xrstors64(anyptr_gpA); // Implicit <EDX:EAX>
+ if (isX64) e->xsave64(anyptr_gpA); // Implicit <EDX:EAX>
+ if (isX64) e->xsavec64(anyptr_gpA); // Implicit <EDX:EAX>
+ if (isX64) e->xsaveopt64(anyptr_gpA); // Implicit <EDX:EAX>
+ if (isX64) e->xsaves64(anyptr_gpA); // Implicit <EDX:EAX>
+
+ // POPCNT.
+ e->nop();
+
+ e->popcnt(gdA, gdB);
+ e->popcnt(gzA, gzB);
+ e->popcnt(gdA, anyptr_gpB);
+ e->popcnt(gzA, anyptr_gpB);
+
+ // LZCNT.
+ e->nop();
+
+ e->lzcnt(gdA, gdB);
+ e->lzcnt(gzA, gzB);
+ e->lzcnt(gdA, anyptr_gpB);
+ e->lzcnt(gzA, anyptr_gpB);
+
+ // BMI.
+ e->nop();
+
+ e->andn(gdA, gdB, gdC);
+ e->andn(gzA, gzB, gzC);
+ e->andn(gdA, gdB, anyptr_gpC);
+ e->andn(gzA, gzB, anyptr_gpC);
+ e->bextr(gdA, gdB, gdC);
+ e->bextr(gzA, gzB, gzC);
+ e->bextr(gdA, anyptr_gpB, gdC);
+ e->bextr(gzA, anyptr_gpB, gzC);
+ e->blsi(gdA, gdB);
+ e->blsi(gzA, gzB);
+ e->blsi(gdA, anyptr_gpB);
+ e->blsi(gzA, anyptr_gpB);
+ e->blsmsk(gdA, gdB);
+ e->blsmsk(gzA, gzB);
+ e->blsmsk(gdA, anyptr_gpB);
+ e->blsmsk(gzA, anyptr_gpB);
+ e->blsr(gdA, gdB);
+ e->blsr(gzA, gzB);
+ e->blsr(gdA, anyptr_gpB);
+ e->blsr(gzA, anyptr_gpB);
+ e->tzcnt(gdA, gdB);
+ e->tzcnt(gzA, gzB);
+ e->tzcnt(gdA, anyptr_gpB);
+ e->tzcnt(gzA, anyptr_gpB);
+
+ // BMI2.
+ e->nop();
+
+ e->bzhi(gdA, gdB, gdC);
+ e->bzhi(gzA, gzB, gzC);
+ e->bzhi(gdA, anyptr_gpB, gdC);
+ e->bzhi(gzA, anyptr_gpB, gzC);
+ e->mulx(gdA, gdB, gdC); // Implicit gpA, gpB, gpC, <EDX>
+ e->mulx(gdA, gdB, gdC, edx); // Explicit gpA, gpB, gpC, <EDX>
+ e->mulx(gzA, gzB, gzC); // Implicit gpA, gpB, gpC, <EDX|RDX>
+ e->mulx(gzA, gzB, gzC, e->zdx()); // Explicit gpA, gpB, gpC, <EDX|RDX>
+ e->mulx(gdA, gdB, anyptr_gpC); // Implicit gpA, gpB, mem, <EDX>
+ e->mulx(gdA, gdB, anyptr_gpC, edx); // Explicit gpA, gpB, mem, <EDX>
+ e->mulx(gzA, gzB, anyptr_gpC); // Implicit gpA, gpB, mem, <EDX|RDX>
+ e->mulx(gzA, gzB, anyptr_gpC, e->zdx()); // Explicit gpA, gpB, mem, <EDX|RDX>
+ e->pdep(gdA, gdB, gdC);
+ e->pdep(gzA, gzB, gzC);
+ e->pdep(gdA, gdB, anyptr_gpC);
+ e->pdep(gzA, gzB, anyptr_gpC);
+ e->pext(gdA, gdB, gdC);
+ e->pext(gzA, gzB, gzC);
+ e->pext(gdA, gdB, anyptr_gpC);
+ e->pext(gzA, gzB, anyptr_gpC);
+ e->rorx(gdA, gdB, 0);
+ e->rorx(gzA, gzB, 0);
+ e->rorx(gdA, anyptr_gpB, 0);
+ e->rorx(gzA, anyptr_gpB, 0);
+ e->sarx(gdA, gdB, gdC);
+ e->sarx(gzA, gzB, gzC);
+ e->sarx(gdA, anyptr_gpB, gdC);
+ e->sarx(gzA, anyptr_gpB, gzC);
+ e->shlx(gdA, gdB, gdC);
+ e->shlx(gzA, gzB, gzC);
+ e->shlx(gdA, anyptr_gpB, gdC);
+ e->shlx(gzA, anyptr_gpB, gzC);
+ e->shrx(gdA, gdB, gdC);
+ e->shrx(gzA, gzB, gzC);
+ e->shrx(gdA, anyptr_gpB, gdC);
+ e->shrx(gzA, anyptr_gpB, gzC);
+
+ // ADX.
+ e->nop();
+
+ e->adcx(gdA, gdB);
+ e->adcx(gzA, gzB);
+ e->adcx(gdA, anyptr_gpB);
+ e->adcx(gzA, anyptr_gpB);
+ e->adox(gdA, gdB);
+ e->adox(gzA, gzB);
+ e->adox(gdA, anyptr_gpB);
+ e->adox(gzA, anyptr_gpB);
+
+ // TBM.
+ e->nop();
+
+ e->blcfill(gdA, gdB);
+ e->blcfill(gzA, gzB);
+ e->blcfill(gdA, anyptr_gpB);
+ e->blcfill(gzA, anyptr_gpB);
+
+ e->blci(gdA, gdB);
+ e->blci(gzA, gzB);
+ e->blci(gdA, anyptr_gpB);
+ e->blci(gzA, anyptr_gpB);
+
+ e->blcic(gdA, gdB);
+ e->blcic(gzA, gzB);
+ e->blcic(gdA, anyptr_gpB);
+ e->blcic(gzA, anyptr_gpB);
+
+ e->blcmsk(gdA, gdB);
+ e->blcmsk(gzA, gzB);
+ e->blcmsk(gdA, anyptr_gpB);
+ e->blcmsk(gzA, anyptr_gpB);
+
+ e->blcs(gdA, gdB);
+ e->blcs(gzA, gzB);
+ e->blcs(gdA, anyptr_gpB);
+ e->blcs(gzA, anyptr_gpB);
+
+ e->blsfill(gdA, gdB);
+ e->blsfill(gzA, gzB);
+ e->blsfill(gdA, anyptr_gpB);
+ e->blsfill(gzA, anyptr_gpB);
+
+ e->blsic(gdA, gdB);
+ e->blsic(gzA, gzB);
+ e->blsic(gdA, anyptr_gpB);
+ e->blsic(gzA, anyptr_gpB);
+
+ e->t1mskc(gdA, gdB);
+ e->t1mskc(gzA, gzB);
+ e->t1mskc(gdA, anyptr_gpB);
+ e->t1mskc(gzA, anyptr_gpB);
+
+ e->tzmsk(gdA, gdB);
+ e->tzmsk(gzA, gzB);
+ e->tzmsk(gdA, anyptr_gpB);
+ e->tzmsk(gzA, anyptr_gpB);
+
+ // CLFLUSH / CLFLUSH_OPT.
+ e->nop();
+ e->clflush(anyptr_gpA);
+ e->clflushopt(anyptr_gpA);
+
+ // CLWB.
+ e->nop();
+ e->clwb(anyptr_gpA);
+
+ // CLZERO.
+ e->nop();
+ e->clzero(); // Implicit <ds:[EAX|RAX]>
+ e->clzero(ptr(e->zax())); // Explicit <ds:[EAX|RAX]>
+
+ // MONITOR[X] / MWAIT[X].
+ e->nop();
+ e->monitor(); // Implicit <ds:[EAX|RAX]>, <ECX>, <EDX>
+ e->monitorx(); // Implicit <ds:[EAX|RAX]>, <ECX>, <EDX>
+ e->mwait(); // Implicit <EAX>, <ECX>
+ e->mwaitx(); // Implicit <EAX>, <ECX>, <EBX>
+
+ // PCOMMIT.
+ e->nop();
+ e->pcommit();
+
+ // PREFETCH / PREFETCHW / PREFETCHWT1.
+ e->nop();
+ e->prefetch(anyptr_gpA); // 3DNOW.
+ e->prefetchnta(anyptr_gpA); // MMX+SSE.
+ e->prefetcht0(anyptr_gpA); // MMX+SSE.
+ e->prefetcht1(anyptr_gpA); // MMX+SSE.
+ e->prefetcht2(anyptr_gpA); // MMX+SSE.
+ e->prefetchw(anyptr_gpA); // PREFETCHW.
+ e->prefetchwt1(anyptr_gpA); // PREFETCHWT1.
+
+ // RDRAND / RDSEED.
+ e->nop();
+
+ e->rdrand(gdA);
+ e->rdrand(gzA);
+ e->rdseed(gdA);
+ e->rdseed(gzA);
+
+ // MMX/MMX2.
+ e->nop();
+
+ e->movd(anyptr_gpA, mmB);
+ e->movd(gdA, mmB);
+ e->movd(mmA, anyptr_gpB);
+ e->movd(mmA, gdB);
+ e->movq(mmA, mmB);
+ e->movq(anyptr_gpA, mmB);
+ e->movq(mmA, anyptr_gpB);
+ e->packuswb(mmA, mmB);
+ e->packuswb(mmA, anyptr_gpB);
+ e->paddb(mmA, mmB);
+ e->paddb(mmA, anyptr_gpB);
+ e->paddw(mmA, mmB);
+ e->paddw(mmA, anyptr_gpB);
+ e->paddd(mmA, mmB);
+ e->paddd(mmA, anyptr_gpB);
+ e->paddsb(mmA, mmB);
+ e->paddsb(mmA, anyptr_gpB);
+ e->paddsw(mmA, mmB);
+ e->paddsw(mmA, anyptr_gpB);
+ e->paddusb(mmA, mmB);
+ e->paddusb(mmA, anyptr_gpB);
+ e->paddusw(mmA, mmB);
+ e->paddusw(mmA, anyptr_gpB);
+ e->pand(mmA, mmB);
+ e->pand(mmA, anyptr_gpB);
+ e->pandn(mmA, mmB);
+ e->pandn(mmA, anyptr_gpB);
+ e->pcmpeqb(mmA, mmB);
+ e->pcmpeqb(mmA, anyptr_gpB);
+ e->pcmpeqw(mmA, mmB);
+ e->pcmpeqw(mmA, anyptr_gpB);
+ e->pcmpeqd(mmA, mmB);
+ e->pcmpeqd(mmA, anyptr_gpB);
+ e->pcmpgtb(mmA, mmB);
+ e->pcmpgtb(mmA, anyptr_gpB);
+ e->pcmpgtw(mmA, mmB);
+ e->pcmpgtw(mmA, anyptr_gpB);
+ e->pcmpgtd(mmA, mmB);
+ e->pcmpgtd(mmA, anyptr_gpB);
+ e->pmulhw(mmA, mmB);
+ e->pmulhw(mmA, anyptr_gpB);
+ e->pmullw(mmA, mmB);
+ e->pmullw(mmA, anyptr_gpB);
+ e->por(mmA, mmB);
+ e->por(mmA, anyptr_gpB);
+ e->pmaddwd(mmA, mmB);
+ e->pmaddwd(mmA, anyptr_gpB);
+ e->pslld(mmA, mmB);
+ e->pslld(mmA, anyptr_gpB);
+ e->pslld(mmA, 0);
+ e->psllq(mmA, mmB);
+ e->psllq(mmA, anyptr_gpB);
+ e->psllq(mmA, 0);
+ e->psllw(mmA, mmB);
+ e->psllw(mmA, anyptr_gpB);
+ e->psllw(mmA, 0);
+ e->psrad(mmA, mmB);
+ e->psrad(mmA, anyptr_gpB);
+ e->psrad(mmA, 0);
+ e->psraw(mmA, mmB);
+ e->psraw(mmA, anyptr_gpB);
+ e->psraw(mmA, 0);
+ e->psrld(mmA, mmB);
+ e->psrld(mmA, anyptr_gpB);
+ e->psrld(mmA, 0);
+ e->psrlq(mmA, mmB);
+ e->psrlq(mmA, anyptr_gpB);
+ e->psrlq(mmA, 0);
+ e->psrlw(mmA, mmB);
+ e->psrlw(mmA, anyptr_gpB);
+ e->psrlw(mmA, 0);
+ e->psubb(mmA, mmB);
+ e->psubb(mmA, anyptr_gpB);
+ e->psubw(mmA, mmB);
+ e->psubw(mmA, anyptr_gpB);
+ e->psubd(mmA, mmB);
+ e->psubd(mmA, anyptr_gpB);
+ e->psubsb(mmA, mmB);
+ e->psubsb(mmA, anyptr_gpB);
+ e->psubsw(mmA, mmB);
+ e->psubsw(mmA, anyptr_gpB);
+ e->psubusb(mmA, mmB);
+ e->psubusb(mmA, anyptr_gpB);
+ e->psubusw(mmA, mmB);
+ e->psubusw(mmA, anyptr_gpB);
+ e->punpckhbw(mmA, mmB);
+ e->punpckhbw(mmA, anyptr_gpB);
+ e->punpckhwd(mmA, mmB);
+ e->punpckhwd(mmA, anyptr_gpB);
+ e->punpckhdq(mmA, mmB);
+ e->punpckhdq(mmA, anyptr_gpB);
+ e->punpcklbw(mmA, mmB);
+ e->punpcklbw(mmA, anyptr_gpB);
+ e->punpcklwd(mmA, mmB);
+ e->punpcklwd(mmA, anyptr_gpB);
+ e->punpckldq(mmA, mmB);
+ e->punpckldq(mmA, anyptr_gpB);
+ e->pxor(mmA, mmB);
+ e->pxor(mmA, anyptr_gpB);
+ e->emms();
+
+ // 3DNOW.
+ e->nop();
+
+ e->pavgusb(mmA, mmB);
+ e->pavgusb(mmA, anyptr_gpB);
+ e->pf2id(mmA, mmB);
+ e->pf2id(mmA, anyptr_gpB);
+ e->pf2iw(mmA, mmB);
+ e->pf2iw(mmA, anyptr_gpB);
+ e->pfacc(mmA, mmB);
+ e->pfacc(mmA, anyptr_gpB);
+ e->pfadd(mmA, mmB);
+ e->pfadd(mmA, anyptr_gpB);
+ e->pfcmpeq(mmA, mmB);
+ e->pfcmpeq(mmA, anyptr_gpB);
+ e->pfcmpge(mmA, mmB);
+ e->pfcmpge(mmA, anyptr_gpB);
+ e->pfcmpgt(mmA, mmB);
+ e->pfcmpgt(mmA, anyptr_gpB);
+ e->pfmax(mmA, mmB);
+ e->pfmax(mmA, anyptr_gpB);
+ e->pfmin(mmA, mmB);
+ e->pfmin(mmA, anyptr_gpB);
+ e->pfmul(mmA, mmB);
+ e->pfmul(mmA, anyptr_gpB);
+ e->pfnacc(mmA, mmB);
+ e->pfnacc(mmA, anyptr_gpB);
+ e->pfpnacc(mmA, mmB);
+ e->pfpnacc(mmA, anyptr_gpB);
+ e->pfrcp(mmA, mmB);
+ e->pfrcp(mmA, anyptr_gpB);
+ e->pfrcpit1(mmA, mmB);
+ e->pfrcpit1(mmA, anyptr_gpB);
+ e->pfrcpit2(mmA, mmB);
+ e->pfrcpit2(mmA, anyptr_gpB);
+ e->pfrcpv(mmA, mmB);
+ e->pfrcpv(mmA, anyptr_gpB);
+ e->pfrsqit1(mmA, mmB);
+ e->pfrsqit1(mmA, anyptr_gpB);
+ e->pfrsqrt(mmA, mmB);
+ e->pfrsqrt(mmA, anyptr_gpB);
+ e->pfrsqrtv(mmA, mmB);
+ e->pfrsqrtv(mmA, anyptr_gpB);
+ e->pfsub(mmA, mmB);
+ e->pfsub(mmA, anyptr_gpB);
+ e->pfsubr(mmA, mmB);
+ e->pfsubr(mmA, anyptr_gpB);
+ e->pi2fd(mmA, mmB);
+ e->pi2fd(mmA, anyptr_gpB);
+ e->pi2fw(mmA, mmB);
+ e->pi2fw(mmA, anyptr_gpB);
+ e->pmulhrw(mmA, mmB);
+ e->pmulhrw(mmA, anyptr_gpB);
+ e->pswapd(mmA, mmB);
+ e->pswapd(mmA, anyptr_gpB);
+ e->femms();
+
+ // SSE.
+ e->nop();
+
+ e->addps(xmmA, xmmB);
+ e->addps(xmmA, anyptr_gpB);
+ e->addss(xmmA, xmmB);
+ e->addss(xmmA, anyptr_gpB);
+ e->andnps(xmmA, xmmB);
+ e->andnps(xmmA, anyptr_gpB);
+ e->andps(xmmA, xmmB);
+ e->andps(xmmA, anyptr_gpB);
+ e->cmpps(xmmA, xmmB, 0);
+ e->cmpps(xmmA, anyptr_gpB, 0);
+ e->cmpss(xmmA, xmmB, 0);
+ e->cmpss(xmmA, anyptr_gpB, 0);
+ e->comiss(xmmA, xmmB);
+ e->comiss(xmmA, anyptr_gpB);
+ e->cvtpi2ps(xmmA, mmB);
+ e->cvtpi2ps(xmmA, anyptr_gpB);
+ e->cvtps2pi(mmA, xmmB);
+ e->cvtps2pi(mmA, anyptr_gpB);
+ e->cvtsi2ss(xmmA, gdB);
+ e->cvtsi2ss(xmmA, gzB);
+ e->cvtsi2ss(xmmA, anyptr_gpB);
+ e->cvtss2si(gdA, xmmB);
+ e->cvtss2si(gzA, xmmB);
+ e->cvtss2si(gdA, anyptr_gpB);
+ e->cvtss2si(gzA, anyptr_gpB);
+ e->cvttps2pi(mmA, xmmB);
+ e->cvttps2pi(mmA, anyptr_gpB);
+ e->cvttss2si(gdA, xmmB);
+ e->cvttss2si(gzA, xmmB);
+ e->cvttss2si(gdA, anyptr_gpB);
+ e->cvttss2si(gzA, anyptr_gpB);
+ e->divps(xmmA, xmmB);
+ e->divps(xmmA, anyptr_gpB);
+ e->divss(xmmA, xmmB);
+ e->divss(xmmA, anyptr_gpB);
+ e->ldmxcsr(anyptr_gpA);
+ e->maskmovq(mmA, mmB); // Implicit mmA, mmB, <ds:[EDI|RDI]>
+ e->maskmovq(mmA, mmB, ptr(e->zdi())); // Explicit mmA, mmB, <ds:[EDI|RDI]>
+ e->maxps(xmmA, xmmB);
+ e->maxps(xmmA, anyptr_gpB);
+ e->maxss(xmmA, xmmB);
+ e->maxss(xmmA, anyptr_gpB);
+ e->minps(xmmA, xmmB);
+ e->minps(xmmA, anyptr_gpB);
+ e->minss(xmmA, xmmB);
+ e->minss(xmmA, anyptr_gpB);
+ e->movaps(xmmA, xmmB);
+ e->movaps(xmmA, anyptr_gpB);
+ e->movaps(anyptr_gpA, xmmB);
+ e->movd(anyptr_gpA, xmmB);
+ e->movd(gdA, xmmB);
+ e->movd(gzA, xmmB);
+ e->movd(xmmA, anyptr_gpB);
+ e->movd(xmmA, gdB);
+ e->movd(xmmA, gzB);
+ e->movq(mmA, mmB);
+ e->movq(xmmA, xmmB);
+ e->movq(anyptr_gpA, xmmB);
+ e->movq(xmmA, anyptr_gpB);
+ e->movntq(anyptr_gpA, mmB);
+ e->movhlps(xmmA, xmmB);
+ e->movhps(xmmA, anyptr_gpB);
+ e->movhps(anyptr_gpA, xmmB);
+ e->movlhps(xmmA, xmmB);
+ e->movlps(xmmA, anyptr_gpB);
+ e->movlps(anyptr_gpA, xmmB);
+ e->movntps(anyptr_gpA, xmmB);
+ e->movss(xmmA, anyptr_gpB);
+ e->movss(anyptr_gpA, xmmB);
+ e->movups(xmmA, xmmB);
+ e->movups(xmmA, anyptr_gpB);
+ e->movups(anyptr_gpA, xmmB);
+ e->mulps(xmmA, xmmB);
+ e->mulps(xmmA, anyptr_gpB);
+ e->mulss(xmmA, xmmB);
+ e->mulss(xmmA, anyptr_gpB);
+ e->orps(xmmA, xmmB);
+ e->orps(xmmA, anyptr_gpB);
+ e->pavgb(mmA, mmB);
+ e->pavgb(mmA, anyptr_gpB);
+ e->pavgw(mmA, mmB);
+ e->pavgw(mmA, anyptr_gpB);
+ e->pextrw(gdA, mmB, 0);
+ e->pextrw(gzA, mmB, 0);
+ e->pinsrw(mmA, gdB, 0);
+ e->pinsrw(mmA, gzB, 0);
+ e->pinsrw(mmA, anyptr_gpB, 0);
+ e->pmaxsw(mmA, mmB);
+ e->pmaxsw(mmA, anyptr_gpB);
+ e->pmaxub(mmA, mmB);
+ e->pmaxub(mmA, anyptr_gpB);
+ e->pminsw(mmA, mmB);
+ e->pminsw(mmA, anyptr_gpB);
+ e->pminub(mmA, mmB);
+ e->pminub(mmA, anyptr_gpB);
+ e->pmovmskb(gdA, mmB);
+ e->pmovmskb(gzA, mmB);
+ e->pmulhuw(mmA, mmB);
+ e->pmulhuw(mmA, anyptr_gpB);
+ e->psadbw(mmA, mmB);
+ e->psadbw(mmA, anyptr_gpB);
+ e->pshufw(mmA, mmB, 0);
+ e->pshufw(mmA, anyptr_gpB, 0);
+ e->rcpps(xmmA, xmmB);
+ e->rcpps(xmmA, anyptr_gpB);
+ e->rcpss(xmmA, xmmB);
+ e->rcpss(xmmA, anyptr_gpB);
+ e->psadbw(xmmA, xmmB);
+ e->psadbw(xmmA, anyptr_gpB);
+ e->rsqrtps(xmmA, xmmB);
+ e->rsqrtps(xmmA, anyptr_gpB);
+ e->rsqrtss(xmmA, xmmB);
+ e->rsqrtss(xmmA, anyptr_gpB);
+ e->sfence();
+ e->shufps(xmmA, xmmB, 0);
+ e->shufps(xmmA, anyptr_gpB, 0);
+ e->sqrtps(xmmA, xmmB);
+ e->sqrtps(xmmA, anyptr_gpB);
+ e->sqrtss(xmmA, xmmB);
+ e->sqrtss(xmmA, anyptr_gpB);
+ e->stmxcsr(anyptr_gpA);
+ e->subps(xmmA, xmmB);
+ e->subps(xmmA, anyptr_gpB);
+ e->subss(xmmA, xmmB);
+ e->subss(xmmA, anyptr_gpB);
+ e->ucomiss(xmmA, xmmB);
+ e->ucomiss(xmmA, anyptr_gpB);
+ e->unpckhps(xmmA, xmmB);
+ e->unpckhps(xmmA, anyptr_gpB);
+ e->unpcklps(xmmA, xmmB);
+ e->unpcklps(xmmA, anyptr_gpB);
+ e->xorps(xmmA, xmmB);
+ e->xorps(xmmA, anyptr_gpB);
+
+ // SSE2.
+ e->nop();
+
+ e->addpd(xmmA, xmmB);
+ e->addpd(xmmA, anyptr_gpB);
+ e->addsd(xmmA, xmmB);
+ e->addsd(xmmA, anyptr_gpB);
+ e->andnpd(xmmA, xmmB);
+ e->andnpd(xmmA, anyptr_gpB);
+ e->andpd(xmmA, xmmB);
+ e->andpd(xmmA, anyptr_gpB);
+ e->cmppd(xmmA, xmmB, 0);
+ e->cmppd(xmmA, anyptr_gpB, 0);
+ e->cmpsd(xmmA, xmmB, 0);
+ e->cmpsd(xmmA, anyptr_gpB, 0);
+ e->comisd(xmmA, xmmB);
+ e->comisd(xmmA, anyptr_gpB);
+ e->cvtdq2pd(xmmA, xmmB);
+ e->cvtdq2pd(xmmA, anyptr_gpB);
+ e->cvtdq2ps(xmmA, xmmB);
+ e->cvtdq2ps(xmmA, anyptr_gpB);
+ e->cvtpd2dq(xmmA, xmmB);
+ e->cvtpd2dq(xmmA, anyptr_gpB);
+ e->cvtpd2pi(mmA, xmmB);
+ e->cvtpd2pi(mmA, anyptr_gpB);
+ e->cvtpd2ps(xmmA, xmmB);
+ e->cvtpd2ps(xmmA, anyptr_gpB);
+ e->cvtpi2pd(xmmA, mmB);
+ e->cvtpi2pd(xmmA, anyptr_gpB);
+ e->cvtps2dq(xmmA, xmmB);
+ e->cvtps2dq(xmmA, anyptr_gpB);
+ e->cvtps2pd(xmmA, xmmB);
+ e->cvtps2pd(xmmA, anyptr_gpB);
+ e->cvtsd2si(gdA, xmmB);
+ e->cvtsd2si(gzA, xmmB);
+ e->cvtsd2si(gdA, anyptr_gpB);
+ e->cvtsd2si(gzA, anyptr_gpB);
+ e->cvtsd2ss(xmmA, xmmB);
+ e->cvtsd2ss(xmmA, anyptr_gpB);
+ e->cvtsi2sd(xmmA, gdB);
+ e->cvtsi2sd(xmmA, gzB);
+ e->cvtsi2sd(xmmA, anyptr_gpB);
+ e->cvtss2sd(xmmA, xmmB);
+ e->cvtss2sd(xmmA, anyptr_gpB);
+ e->cvtss2si(gdA, xmmB);
+ e->cvtss2si(gzA, xmmB);
+ e->cvtss2si(gdA, anyptr_gpB);
+ e->cvtss2si(gzA, anyptr_gpB);
+ e->cvttpd2pi(mmA, xmmB);
+ e->cvttpd2pi(mmA, anyptr_gpB);
+ e->cvttpd2dq(xmmA, xmmB);
+ e->cvttpd2dq(xmmA, anyptr_gpB);
+ e->cvttps2dq(xmmA, xmmB);
+ e->cvttps2dq(xmmA, anyptr_gpB);
+ e->cvttsd2si(gdA, xmmB);
+ e->cvttsd2si(gzA, xmmB);
+ e->cvttsd2si(gdA, anyptr_gpB);
+ e->cvttsd2si(gzA, anyptr_gpB);
+ e->divpd(xmmA, xmmB);
+ e->divpd(xmmA, anyptr_gpB);
+ e->divsd(xmmA, xmmB);
+ e->divsd(xmmA, anyptr_gpB);
+ e->lfence();
+ e->maskmovdqu(xmmA, xmmB); // Implicit xmmA, xmmB, <ds:[EDI|RDI]>
+ e->maskmovdqu(xmmA, xmmB, ptr(e->zdi())); // Explicit xmmA, xmmB, <ds:[EDI|RDI]>
+ e->maxpd(xmmA, xmmB);
+ e->maxpd(xmmA, anyptr_gpB);
+ e->maxsd(xmmA, xmmB);
+ e->maxsd(xmmA, anyptr_gpB);
+ e->mfence();
+ e->minpd(xmmA, xmmB);
+ e->minpd(xmmA, anyptr_gpB);
+ e->minsd(xmmA, xmmB);
+ e->minsd(xmmA, anyptr_gpB);
+ e->movdqa(xmmA, xmmB);
+ e->movdqa(xmmA, anyptr_gpB);
+ e->movdqa(anyptr_gpA, xmmB);
+ e->movdqu(xmmA, xmmB);
+ e->movdqu(xmmA, anyptr_gpB);
+ e->movdqu(anyptr_gpA, xmmB);
+ e->movmskps(gdA, xmmB);
+ e->movmskps(gzA, xmmB);
+ e->movmskpd(gdA, xmmB);
+ e->movmskpd(gzA, xmmB);
+ e->movsd(xmmA, xmmB);
+ e->movsd(xmmA, anyptr_gpB);
+ e->movsd(anyptr_gpA, xmmB);
+ e->movapd(xmmA, anyptr_gpB);
+ e->movapd(anyptr_gpA, xmmB);
+ e->movdq2q(mmA, xmmB);
+ e->movq2dq(xmmA, mmB);
+ e->movhpd(xmmA, anyptr_gpB);
+ e->movhpd(anyptr_gpA, xmmB);
+ e->movlpd(xmmA, anyptr_gpB);
+ e->movlpd(anyptr_gpA, xmmB);
+ e->movntdq(anyptr_gpA, xmmB);
+ e->movnti(anyptr_gpA, gdB);
+ e->movnti(anyptr_gpA, gzB);
+ e->movntpd(anyptr_gpA, xmmB);
+ e->movupd(xmmA, anyptr_gpB);
+ e->movupd(anyptr_gpA, xmmB);
+ e->mulpd(xmmA, xmmB);
+ e->mulpd(xmmA, anyptr_gpB);
+ e->mulsd(xmmA, xmmB);
+ e->mulsd(xmmA, anyptr_gpB);
+ e->orpd(xmmA, xmmB);
+ e->orpd(xmmA, anyptr_gpB);
+ e->packsswb(xmmA, xmmB);
+ e->packsswb(xmmA, anyptr_gpB);
+ e->packssdw(xmmA, xmmB);
+ e->packssdw(xmmA, anyptr_gpB);
+ e->packuswb(xmmA, xmmB);
+ e->packuswb(xmmA, anyptr_gpB);
+ e->paddb(xmmA, xmmB);
+ e->paddb(xmmA, anyptr_gpB);
+ e->paddw(xmmA, xmmB);
+ e->paddw(xmmA, anyptr_gpB);
+ e->paddd(xmmA, xmmB);
+ e->paddd(xmmA, anyptr_gpB);
+ e->paddq(mmA, mmB);
+ e->paddq(mmA, anyptr_gpB);
+ e->paddq(xmmA, xmmB);
+ e->paddq(xmmA, anyptr_gpB);
+ e->paddsb(xmmA, xmmB);
+ e->paddsb(xmmA, anyptr_gpB);
+ e->paddsw(xmmA, xmmB);
+ e->paddsw(xmmA, anyptr_gpB);
+ e->paddusb(xmmA, xmmB);
+ e->paddusb(xmmA, anyptr_gpB);
+ e->paddusw(xmmA, xmmB);
+ e->paddusw(xmmA, anyptr_gpB);
+ e->pand(xmmA, xmmB);
+ e->pand(xmmA, anyptr_gpB);
+ e->pandn(xmmA, xmmB);
+ e->pandn(xmmA, anyptr_gpB);
+ e->pause();
+ e->pavgb(xmmA, xmmB);
+ e->pavgb(xmmA, anyptr_gpB);
+ e->pavgw(xmmA, xmmB);
+ e->pavgw(xmmA, anyptr_gpB);
+ e->pcmpeqb(xmmA, xmmB);
+ e->pcmpeqb(xmmA, anyptr_gpB);
+ e->pcmpeqw(xmmA, xmmB);
+ e->pcmpeqw(xmmA, anyptr_gpB);
+ e->pcmpeqd(xmmA, xmmB);
+ e->pcmpeqd(xmmA, anyptr_gpB);
+ e->pcmpgtb(xmmA, xmmB);
+ e->pcmpgtb(xmmA, anyptr_gpB);
+ e->pcmpgtw(xmmA, xmmB);
+ e->pcmpgtw(xmmA, anyptr_gpB);
+ e->pcmpgtd(xmmA, xmmB);
+ e->pcmpgtd(xmmA, anyptr_gpB);
+ e->pmaxsw(xmmA, xmmB);
+ e->pmaxsw(xmmA, anyptr_gpB);
+ e->pmaxub(xmmA, xmmB);
+ e->pmaxub(xmmA, anyptr_gpB);
+ e->pminsw(xmmA, xmmB);
+ e->pminsw(xmmA, anyptr_gpB);
+ e->pminub(xmmA, xmmB);
+ e->pminub(xmmA, anyptr_gpB);
+ e->pmovmskb(gdA, xmmB);
+ e->pmovmskb(gzA, xmmB);
+ e->pmulhw(xmmA, xmmB);
+ e->pmulhw(xmmA, anyptr_gpB);
+ e->pmulhuw(xmmA, xmmB);
+ e->pmulhuw(xmmA, anyptr_gpB);
+ e->pmullw(xmmA, xmmB);
+ e->pmullw(xmmA, anyptr_gpB);
+ e->pmuludq(mmA, mmB);
+ e->pmuludq(mmA, anyptr_gpB);
+ e->pmuludq(xmmA, xmmB);
+ e->pmuludq(xmmA, anyptr_gpB);
+ e->por(xmmA, xmmB);
+ e->por(xmmA, anyptr_gpB);
+ e->pslld(xmmA, xmmB);
+ e->pslld(xmmA, anyptr_gpB);
+ e->pslld(xmmA, 0);
+ e->psllq(xmmA, xmmB);
+ e->psllq(xmmA, anyptr_gpB);
+ e->psllq(xmmA, 0);
+ e->psllw(xmmA, xmmB);
+ e->psllw(xmmA, anyptr_gpB);
+ e->psllw(xmmA, 0);
+ e->pslldq(xmmA, 0);
+ e->psrad(xmmA, xmmB);
+ e->psrad(xmmA, anyptr_gpB);
+ e->psrad(xmmA, 0);
+ e->psraw(xmmA, xmmB);
+ e->psraw(xmmA, anyptr_gpB);
+ e->psraw(xmmA, 0);
+ e->psubb(xmmA, xmmB);
+ e->psubb(xmmA, anyptr_gpB);
+ e->psubw(xmmA, xmmB);
+ e->psubw(xmmA, anyptr_gpB);
+ e->psubd(xmmA, xmmB);
+ e->psubd(xmmA, anyptr_gpB);
+ e->psubq(mmA, mmB);
+ e->psubq(mmA, anyptr_gpB);
+ e->psubq(xmmA, xmmB);
+ e->psubq(xmmA, anyptr_gpB);
+ e->pmaddwd(xmmA, xmmB);
+ e->pmaddwd(xmmA, anyptr_gpB);
+ e->pshufd(xmmA, xmmB, 0);
+ e->pshufd(xmmA, anyptr_gpB, 0);
+ e->pshufhw(xmmA, xmmB, 0);
+ e->pshufhw(xmmA, anyptr_gpB, 0);
+ e->pshuflw(xmmA, xmmB, 0);
+ e->pshuflw(xmmA, anyptr_gpB, 0);
+ e->psrld(xmmA, xmmB);
+ e->psrld(xmmA, anyptr_gpB);
+ e->psrld(xmmA, 0);
+ e->psrlq(xmmA, xmmB);
+ e->psrlq(xmmA, anyptr_gpB);
+ e->psrlq(xmmA, 0);
+ e->psrldq(xmmA, 0);
+ e->psrlw(xmmA, xmmB);
+ e->psrlw(xmmA, anyptr_gpB);
+ e->psrlw(xmmA, 0);
+ e->psubsb(xmmA, xmmB);
+ e->psubsb(xmmA, anyptr_gpB);
+ e->psubsw(xmmA, xmmB);
+ e->psubsw(xmmA, anyptr_gpB);
+ e->psubusb(xmmA, xmmB);
+ e->psubusb(xmmA, anyptr_gpB);
+ e->psubusw(xmmA, xmmB);
+ e->psubusw(xmmA, anyptr_gpB);
+ e->punpckhbw(xmmA, xmmB);
+ e->punpckhbw(xmmA, anyptr_gpB);
+ e->punpckhwd(xmmA, xmmB);
+ e->punpckhwd(xmmA, anyptr_gpB);
+ e->punpckhdq(xmmA, xmmB);
+ e->punpckhdq(xmmA, anyptr_gpB);
+ e->punpckhqdq(xmmA, xmmB);
+ e->punpckhqdq(xmmA, anyptr_gpB);
+ e->punpcklbw(xmmA, xmmB);
+ e->punpcklbw(xmmA, anyptr_gpB);
+ e->punpcklwd(xmmA, xmmB);
+ e->punpcklwd(xmmA, anyptr_gpB);
+ e->punpckldq(xmmA, xmmB);
+ e->punpckldq(xmmA, anyptr_gpB);
+ e->punpcklqdq(xmmA, xmmB);
+ e->punpcklqdq(xmmA, anyptr_gpB);
+ e->pxor(xmmA, xmmB);
+ e->pxor(xmmA, anyptr_gpB);
+ e->sqrtpd(xmmA, xmmB);
+ e->sqrtpd(xmmA, anyptr_gpB);
+ e->sqrtsd(xmmA, xmmB);
+ e->sqrtsd(xmmA, anyptr_gpB);
+ e->subpd(xmmA, xmmB);
+ e->subpd(xmmA, anyptr_gpB);
+ e->subsd(xmmA, xmmB);
+ e->subsd(xmmA, anyptr_gpB);
+ e->ucomisd(xmmA, xmmB);
+ e->ucomisd(xmmA, anyptr_gpB);
+ e->unpckhpd(xmmA, xmmB);
+ e->unpckhpd(xmmA, anyptr_gpB);
+ e->unpcklpd(xmmA, xmmB);
+ e->unpcklpd(xmmA, anyptr_gpB);
+ e->xorpd(xmmA, xmmB);
+ e->xorpd(xmmA, anyptr_gpB);
+
+ // SSE3.
+ e->nop();
+
+ e->addsubpd(xmmA, xmmB);
+ e->addsubpd(xmmA, anyptr_gpB);
+ e->addsubps(xmmA, xmmB);
+ e->addsubps(xmmA, anyptr_gpB);
+ e->fisttp(dword_ptr(gzA));
+ e->haddpd(xmmA, xmmB);
+ e->haddpd(xmmA, anyptr_gpB);
+ e->haddps(xmmA, xmmB);
+ e->haddps(xmmA, anyptr_gpB);
+ e->hsubpd(xmmA, xmmB);
+ e->hsubpd(xmmA, anyptr_gpB);
+ e->hsubps(xmmA, xmmB);
+ e->hsubps(xmmA, anyptr_gpB);
+ e->lddqu(xmmA, anyptr_gpB);
+ e->movddup(xmmA, xmmB);
+ e->movddup(xmmA, anyptr_gpB);
+ e->movshdup(xmmA, xmmB);
+ e->movshdup(xmmA, anyptr_gpB);
+ e->movsldup(xmmA, xmmB);
+ e->movsldup(xmmA, anyptr_gpB);
+
+ // SSSE3.
+ e->nop();
+
+ e->psignb(mmA, mmB);
+ e->psignb(mmA, anyptr_gpB);
+ e->psignb(xmmA, xmmB);
+ e->psignb(xmmA, anyptr_gpB);
+ e->psignw(mmA, mmB);
+ e->psignw(mmA, anyptr_gpB);
+ e->psignw(xmmA, xmmB);
+ e->psignw(xmmA, anyptr_gpB);
+ e->psignd(mmA, mmB);
+ e->psignd(mmA, anyptr_gpB);
+ e->psignd(xmmA, xmmB);
+ e->psignd(xmmA, anyptr_gpB);
+ e->phaddw(mmA, mmB);
+ e->phaddw(mmA, anyptr_gpB);
+ e->phaddw(xmmA, xmmB);
+ e->phaddw(xmmA, anyptr_gpB);
+ e->phaddd(mmA, mmB);
+ e->phaddd(mmA, anyptr_gpB);
+ e->phaddd(xmmA, xmmB);
+ e->phaddd(xmmA, anyptr_gpB);
+ e->phaddsw(mmA, mmB);
+ e->phaddsw(mmA, anyptr_gpB);
+ e->phaddsw(xmmA, xmmB);
+ e->phaddsw(xmmA, anyptr_gpB);
+ e->phsubw(mmA, mmB);
+ e->phsubw(mmA, anyptr_gpB);
+ e->phsubw(xmmA, xmmB);
+ e->phsubw(xmmA, anyptr_gpB);
+ e->phsubd(mmA, mmB);
+ e->phsubd(mmA, anyptr_gpB);
+ e->phsubd(xmmA, xmmB);
+ e->phsubd(xmmA, anyptr_gpB);
+ e->phsubsw(mmA, mmB);
+ e->phsubsw(mmA, anyptr_gpB);
+ e->phsubsw(xmmA, xmmB);
+ e->phsubsw(xmmA, anyptr_gpB);
+ e->pmaddubsw(mmA, mmB);
+ e->pmaddubsw(mmA, anyptr_gpB);
+ e->pmaddubsw(xmmA, xmmB);
+ e->pmaddubsw(xmmA, anyptr_gpB);
+ e->pabsb(mmA, mmB);
+ e->pabsb(mmA, anyptr_gpB);
+ e->pabsb(xmmA, xmmB);
+ e->pabsb(xmmA, anyptr_gpB);
+ e->pabsw(mmA, mmB);
+ e->pabsw(mmA, anyptr_gpB);
+ e->pabsw(xmmA, xmmB);
+ e->pabsw(xmmA, anyptr_gpB);
+ e->pabsd(mmA, mmB);
+ e->pabsd(mmA, anyptr_gpB);
+ e->pabsd(xmmA, xmmB);
+ e->pabsd(xmmA, anyptr_gpB);
+ e->pmulhrsw(mmA, mmB);
+ e->pmulhrsw(mmA, anyptr_gpB);
+ e->pmulhrsw(xmmA, xmmB);
+ e->pmulhrsw(xmmA, anyptr_gpB);
+ e->pshufb(mmA, mmB);
+ e->pshufb(mmA, anyptr_gpB);
+ e->pshufb(xmmA, xmmB);
+ e->pshufb(xmmA, anyptr_gpB);
+ e->palignr(mmA, mmB, 0);
+ e->palignr(mmA, anyptr_gpB, 0);
+ e->palignr(xmmA, xmmB, 0);
+ e->palignr(xmmA, anyptr_gpB, 0);
+
+ // SSE4.1.
+ e->nop();
+
+ e->blendpd(xmmA, xmmB, 0);
+ e->blendpd(xmmA, anyptr_gpB, 0);
+ e->blendps(xmmA, xmmB, 0);
+ e->blendps(xmmA, anyptr_gpB, 0);
+ e->blendvpd(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0>
+ e->blendvpd(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0>
+ e->blendvpd(xmmA, anyptr_gpB); // Implicit xmmA, mem , <XMM0>
+ e->blendvpd(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem , <XMM0>
+ e->blendvps(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0>
+ e->blendvps(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0>
+ e->blendvps(xmmA, anyptr_gpB); // Implicit xmmA, mem , <XMM0>
+ e->blendvps(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem , <XMM0>
+
+ e->dppd(xmmA, xmmB, 0);
+ e->dppd(xmmA, anyptr_gpB, 0);
+ e->dpps(xmmA, xmmB, 0);
+ e->dpps(xmmA, anyptr_gpB, 0);
+ e->extractps(gdA, xmmB, 0);
+ e->extractps(gzA, xmmB, 0);
+ e->extractps(anyptr_gpA, xmmB, 0);
+ e->insertps(xmmA, xmmB, 0);
+ e->insertps(xmmA, anyptr_gpB, 0);
+ e->movntdqa(xmmA, anyptr_gpB);
+ e->mpsadbw(xmmA, xmmB, 0);
+ e->mpsadbw(xmmA, anyptr_gpB, 0);
+ e->packusdw(xmmA, xmmB);
+ e->packusdw(xmmA, anyptr_gpB);
+ e->pblendvb(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0>
+ e->pblendvb(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0>
+ e->pblendvb(xmmA, anyptr_gpB); // Implicit xmmA, mem, <XMM0>
+ e->pblendvb(xmmA, anyptr_gpB, xmm0); // Implicit xmmA, mem, <XMM0>
+ e->pblendw(xmmA, xmmB, 0);
+ e->pblendw(xmmA, anyptr_gpB, 0);
+ e->pcmpeqq(xmmA, xmmB);
+ e->pcmpeqq(xmmA, anyptr_gpB);
+ e->pextrb(gdA, xmmB, 0);
+ e->pextrb(gzA, xmmB, 0);
+ e->pextrb(anyptr_gpA, xmmB, 0);
+ e->pextrd(gdA, xmmB, 0);
+ e->pextrd(gzA, xmmB, 0);
+ e->pextrd(anyptr_gpA, xmmB, 0);
+ if (isX64) e->pextrq(gzA, xmmB, 0);
+ if (isX64) e->pextrq(anyptr_gpA, xmmB, 0);
+ e->pextrw(gdA, xmmB, 0);
+ e->pextrw(gzA, xmmB, 0);
+ e->pextrw(anyptr_gpA, xmmB, 0);
+ e->phminposuw(xmmA, xmmB);
+ e->phminposuw(xmmA, anyptr_gpB);
+ e->pinsrb(xmmA, gdB, 0);
+ e->pinsrb(xmmA, gzB, 0);
+ e->pinsrb(xmmA, anyptr_gpB, 0);
+ e->pinsrd(xmmA, gdB, 0);
+ e->pinsrd(xmmA, gzB, 0);
+ e->pinsrd(xmmA, anyptr_gpB, 0);
+ e->pinsrw(xmmA, gdB, 0);
+ e->pinsrw(xmmA, gzB, 0);
+ e->pinsrw(xmmA, anyptr_gpB, 0);
+ e->pmaxuw(xmmA, xmmB);
+ e->pmaxuw(xmmA, anyptr_gpB);
+ e->pmaxsb(xmmA, xmmB);
+ e->pmaxsb(xmmA, anyptr_gpB);
+ e->pmaxsd(xmmA, xmmB);
+ e->pmaxsd(xmmA, anyptr_gpB);
+ e->pmaxud(xmmA, xmmB);
+ e->pmaxud(xmmA, anyptr_gpB);
+ e->pminsb(xmmA, xmmB);
+ e->pminsb(xmmA, anyptr_gpB);
+ e->pminuw(xmmA, xmmB);
+ e->pminuw(xmmA, anyptr_gpB);
+ e->pminud(xmmA, xmmB);
+ e->pminud(xmmA, anyptr_gpB);
+ e->pminsd(xmmA, xmmB);
+ e->pminsd(xmmA, anyptr_gpB);
+ e->pmovsxbw(xmmA, xmmB);
+ e->pmovsxbw(xmmA, anyptr_gpB);
+ e->pmovsxbd(xmmA, xmmB);
+ e->pmovsxbd(xmmA, anyptr_gpB);
+ e->pmovsxbq(xmmA, xmmB);
+ e->pmovsxbq(xmmA, anyptr_gpB);
+ e->pmovsxwd(xmmA, xmmB);
+ e->pmovsxwd(xmmA, anyptr_gpB);
+ e->pmovsxwq(xmmA, xmmB);
+ e->pmovsxwq(xmmA, anyptr_gpB);
+ e->pmovsxdq(xmmA, xmmB);
+ e->pmovsxdq(xmmA, anyptr_gpB);
+ e->pmovzxbw(xmmA, xmmB);
+ e->pmovzxbw(xmmA, anyptr_gpB);
+ e->pmovzxbd(xmmA, xmmB);
+ e->pmovzxbd(xmmA, anyptr_gpB);
+ e->pmovzxbq(xmmA, xmmB);
+ e->pmovzxbq(xmmA, anyptr_gpB);
+ e->pmovzxwd(xmmA, xmmB);
+ e->pmovzxwd(xmmA, anyptr_gpB);
+ e->pmovzxwq(xmmA, xmmB);
+ e->pmovzxwq(xmmA, anyptr_gpB);
+ e->pmovzxdq(xmmA, xmmB);
+ e->pmovzxdq(xmmA, anyptr_gpB);
+ e->pmuldq(xmmA, xmmB);
+ e->pmuldq(xmmA, anyptr_gpB);
+ e->pmulld(xmmA, xmmB);
+ e->pmulld(xmmA, anyptr_gpB);
+ e->ptest(xmmA, xmmB);
+ e->ptest(xmmA, anyptr_gpB);
+ e->roundps(xmmA, xmmB, 0);
+ e->roundps(xmmA, anyptr_gpB, 0);
+ e->roundss(xmmA, xmmB, 0);
+ e->roundss(xmmA, anyptr_gpB, 0);
+ e->roundpd(xmmA, xmmB, 0);
+ e->roundpd(xmmA, anyptr_gpB, 0);
+ e->roundsd(xmmA, xmmB, 0);
+ e->roundsd(xmmA, anyptr_gpB, 0);
+
+ // SSE4.2.
+ e->nop();
+
+ e->pcmpestri(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <ECX>, <EAX>, <EDX>
+ e->pcmpestri(xmmA, xmmB , imm(0), ecx, eax, edx); // Explicit xmmA, xmmB, imm, <ECX>, <EAX>, <EDX>
+ e->pcmpestri(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <ECX>, <EAX>, <EDX>
+ e->pcmpestri(xmmA, anyptr_gpB, imm(0), ecx, eax, edx); // Explicit xmmA, mem , imm, <ECX>, <EAX>, <EDX>
+ e->pcmpestrm(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <XMM0>, <EAX>, <EDX>
+ e->pcmpestrm(xmmA, xmmB , imm(0), xmm0, eax, edx); // Explicit xmmA, xmmB, imm, <XMM0>, <EAX>, <EDX>
+ e->pcmpestrm(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <XMM0>, <EAX>, <EDX>
+ e->pcmpestrm(xmmA, anyptr_gpB, imm(0), xmm0, eax, edx); // Explicit xmmA, mem , imm, <XMM0>, <EAX>, <EDX>
+ e->pcmpistri(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <ECX>
+ e->pcmpistri(xmmA, xmmB , imm(0), ecx); // Explicit xmmA, xmmB, imm, <ECX>
+ e->pcmpistri(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <ECX>
+ e->pcmpistri(xmmA, anyptr_gpB, imm(0), ecx); // Explicit xmmA, mem , imm, <ECX>
+ e->pcmpistrm(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <XMM0>
+ e->pcmpistrm(xmmA, xmmB , imm(0), xmm0); // Explicit xmmA, xmmB, imm, <XMM0>
+ e->pcmpistrm(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <XMM0>
+ e->pcmpistrm(xmmA, anyptr_gpB, imm(0), xmm0); // Explicit xmmA, mem , imm, <XMM0>
+
+ e->pcmpgtq(xmmA, xmmB);
+ e->pcmpgtq(xmmA, anyptr_gpB);
+
+ // SSE4A.
+ e->nop();
+
+ e->extrq(xmmA, xmmB);
+ e->extrq(xmmA, 0x1, 0x2);
+ e->extrq(xmmB, 0x1, 0x2);
+ e->insertq(xmmA, xmmB);
+ e->insertq(xmmA, xmmB, 0x1, 0x2);
+ e->movntsd(anyptr_gpA, xmmB);
+ e->movntss(anyptr_gpA, xmmB);
+
+ // AESNI.
+ e->nop();
+
+ e->aesdec(xmmA, xmmB);
+ e->aesdec(xmmA, anyptr_gpB);
+ e->aesdeclast(xmmA, xmmB);
+ e->aesdeclast(xmmA, anyptr_gpB);
+ e->aesenc(xmmA, xmmB);
+ e->aesenc(xmmA, anyptr_gpB);
+ e->aesenclast(xmmA, xmmB);
+ e->aesenclast(xmmA, anyptr_gpB);
+ e->aesimc(xmmA, xmmB);
+ e->aesimc(xmmA, anyptr_gpB);
+ e->aeskeygenassist(xmmA, xmmB, 0);
+ e->aeskeygenassist(xmmA, anyptr_gpB, 0);
+
+ // SHA.
+ e->nop();
+
+ e->sha1msg1(xmmA, xmmB);
+ e->sha1msg1(xmmA, anyptr_gpB);
+ e->sha1msg2(xmmA, xmmB);
+ e->sha1msg2(xmmA, anyptr_gpB);
+ e->sha1nexte(xmmA, xmmB);
+ e->sha1nexte(xmmA, anyptr_gpB);
+ e->sha1rnds4(xmmA, xmmB, 0);
+ e->sha1rnds4(xmmA, anyptr_gpB, 0);
+ e->sha256msg1(xmmA, xmmB);
+ e->sha256msg1(xmmA, anyptr_gpB);
+ e->sha256msg2(xmmA, xmmB);
+ e->sha256msg2(xmmA, anyptr_gpB);
+ e->sha256rnds2(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0>
+ e->sha256rnds2(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0>
+ e->sha256rnds2(xmmA, anyptr_gpB); // Implicit xmmA, mem, <XMM0>
+ e->sha256rnds2(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem, <XMM0>
+
+ // PCLMULQDQ.
+ e->nop();
+
+ e->pclmulqdq(xmmA, xmmB, 0);
+ e->pclmulqdq(xmmA, anyptr_gpB, 0);
+
+ // AVX.
+ e->nop();
+
+ e->vaddpd(xmmA, xmmB, xmmC);
+ e->vaddpd(xmmA, xmmB, anyptr_gpC);
+ e->vaddpd(ymmA, ymmB, ymmC);
+ e->vaddpd(ymmA, ymmB, anyptr_gpC);
+ e->vaddps(xmmA, xmmB, xmmC);
+ e->vaddps(xmmA, xmmB, anyptr_gpC);
+ e->vaddps(ymmA, ymmB, ymmC);
+ e->vaddps(ymmA, ymmB, anyptr_gpC);
+ e->vaddsd(xmmA, xmmB, xmmC);
+ e->vaddsd(xmmA, xmmB, anyptr_gpC);
+ e->vaddss(xmmA, xmmB, xmmC);
+ e->vaddss(xmmA, xmmB, anyptr_gpC);
+ e->vaddsubpd(xmmA, xmmB, xmmC);
+ e->vaddsubpd(xmmA, xmmB, anyptr_gpC);
+ e->vaddsubpd(ymmA, ymmB, ymmC);
+ e->vaddsubpd(ymmA, ymmB, anyptr_gpC);
+ e->vaddsubps(xmmA, xmmB, xmmC);
+ e->vaddsubps(xmmA, xmmB, anyptr_gpC);
+ e->vaddsubps(ymmA, ymmB, ymmC);
+ e->vaddsubps(ymmA, ymmB, anyptr_gpC);
+ e->vandpd(xmmA, xmmB, xmmC);
+ e->vandpd(xmmA, xmmB, anyptr_gpC);
+ e->vandpd(ymmA, ymmB, ymmC);
+ e->vandpd(ymmA, ymmB, anyptr_gpC);
+ e->vandps(xmmA, xmmB, xmmC);
+ e->vandps(xmmA, xmmB, anyptr_gpC);
+ e->vandps(ymmA, ymmB, ymmC);
+ e->vandps(ymmA, ymmB, anyptr_gpC);
+ e->vandnpd(xmmA, xmmB, xmmC);
+ e->vandnpd(xmmA, xmmB, anyptr_gpC);
+ e->vandnpd(ymmA, ymmB, ymmC);
+ e->vandnpd(ymmA, ymmB, anyptr_gpC);
+ e->vandnps(xmmA, xmmB, xmmC);
+ e->vandnps(xmmA, xmmB, anyptr_gpC);
+ e->vandnps(ymmA, ymmB, ymmC);
+ e->vandnps(ymmA, ymmB, anyptr_gpC);
+ e->vblendpd(xmmA, xmmB, xmmC, 0);
+ e->vblendpd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vblendpd(ymmA, ymmB, ymmC, 0);
+ e->vblendpd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vblendps(xmmA, xmmB, xmmC, 0);
+ e->vblendps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vblendps(ymmA, ymmB, ymmC, 0);
+ e->vblendps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vblendvpd(xmmA, xmmB, xmmC, xmmD);
+ e->vblendvpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vblendvpd(ymmA, ymmB, ymmC, ymmD);
+ e->vblendvpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vbroadcastf128(ymmA, anyptr_gpB);
+ e->vbroadcastsd(ymmA, anyptr_gpB);
+ e->vbroadcastss(xmmA, anyptr_gpB);
+ e->vbroadcastss(ymmA, anyptr_gpB);
+ e->vcmppd(xmmA, xmmB, xmmC, 0);
+ e->vcmppd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vcmppd(ymmA, ymmB, ymmC, 0);
+ e->vcmppd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vcmpps(xmmA, xmmB, xmmC, 0);
+ e->vcmpps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vcmpps(ymmA, ymmB, ymmC, 0);
+ e->vcmpps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vcmpsd(xmmA, xmmB, xmmC, 0);
+ e->vcmpsd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vcmpss(xmmA, xmmB, xmmC, 0);
+ e->vcmpss(xmmA, xmmB, anyptr_gpC, 0);
+ e->vcomisd(xmmA, xmmB);
+ e->vcomisd(xmmA, anyptr_gpB);
+ e->vcomiss(xmmA, xmmB);
+ e->vcomiss(xmmA, anyptr_gpB);
+ e->vcvtdq2pd(xmmA, xmmB);
+ e->vcvtdq2pd(xmmA, anyptr_gpB);
+ e->vcvtdq2pd(ymmA, xmmB);
+ e->vcvtdq2pd(ymmA, anyptr_gpB);
+ e->vcvtdq2ps(xmmA, xmmB);
+ e->vcvtdq2ps(xmmA, anyptr_gpB);
+ e->vcvtdq2ps(ymmA, ymmB);
+ e->vcvtdq2ps(ymmA, anyptr_gpB);
+ e->vcvtpd2dq(xmmA, xmmB);
+ e->vcvtpd2dq(xmmA, ymmB);
+ e->vcvtpd2dq(xmmA, anyptr_gpB);
+ e->vcvtpd2ps(xmmA, xmmB);
+ e->vcvtpd2ps(xmmA, ymmB);
+ e->vcvtpd2ps(xmmA, anyptr_gpB);
+ e->vcvtps2dq(xmmA, xmmB);
+ e->vcvtps2dq(xmmA, anyptr_gpB);
+ e->vcvtps2dq(ymmA, ymmB);
+ e->vcvtps2dq(ymmA, anyptr_gpB);
+ e->vcvtps2pd(xmmA, xmmB);
+ e->vcvtps2pd(xmmA, anyptr_gpB);
+ e->vcvtps2pd(ymmA, xmmB);
+ e->vcvtps2pd(ymmA, anyptr_gpB);
+ e->vcvtsd2si(gzA, xmmB);
+ e->vcvtsd2si(gzA, anyptr_gpB);
+ e->vcvtsd2ss(xmmA, xmmB, xmmC);
+ e->vcvtsd2ss(xmmA, xmmB, anyptr_gpC);
+ e->vcvtsi2sd(xmmA, xmmB, gzC);
+ e->vcvtsi2sd(xmmA, xmmB, anyptr_gpC);
+ e->vcvtsi2ss(xmmA, xmmB, gzC);
+ e->vcvtsi2ss(xmmA, xmmB, anyptr_gpC);
+ e->vcvtss2sd(xmmA, xmmB, xmmC);
+ e->vcvtss2sd(xmmA, xmmB, anyptr_gpC);
+ e->vcvtss2si(gzA, xmmB);
+ e->vcvtss2si(gzA, anyptr_gpB);
+ e->vcvttpd2dq(xmmA, xmmB);
+ e->vcvttpd2dq(xmmA, ymmB);
+ e->vcvttpd2dq(xmmA, anyptr_gpB);
+ e->vcvttps2dq(xmmA, xmmB);
+ e->vcvttps2dq(xmmA, anyptr_gpB);
+ e->vcvttps2dq(ymmA, ymmB);
+ e->vcvttps2dq(ymmA, anyptr_gpB);
+ e->vcvttsd2si(gzA, xmmB);
+ e->vcvttsd2si(gzA, anyptr_gpB);
+ e->vcvttss2si(gzA, xmmB);
+ e->vcvttss2si(gzA, anyptr_gpB);
+ e->vdivpd(xmmA, xmmB, xmmC);
+ e->vdivpd(xmmA, xmmB, anyptr_gpC);
+ e->vdivpd(ymmA, ymmB, ymmC);
+ e->vdivpd(ymmA, ymmB, anyptr_gpC);
+ e->vdivps(xmmA, xmmB, xmmC);
+ e->vdivps(xmmA, xmmB, anyptr_gpC);
+ e->vdivps(ymmA, ymmB, ymmC);
+ e->vdivps(ymmA, ymmB, anyptr_gpC);
+ e->vdivsd(xmmA, xmmB, xmmC);
+ e->vdivsd(xmmA, xmmB, anyptr_gpC);
+ e->vdivss(xmmA, xmmB, xmmC);
+ e->vdivss(xmmA, xmmB, anyptr_gpC);
+ e->vdppd(xmmA, xmmB, xmmC, 0);
+ e->vdppd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vdpps(xmmA, xmmB, xmmC, 0);
+ e->vdpps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vdpps(ymmA, ymmB, ymmC, 0);
+ e->vdpps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vextractf128(xmmA, ymmB, 0);
+ e->vextractf128(anyptr_gpA, ymmB, 0);
+ e->vextractps(gzA, xmmB, 0);
+ e->vextractps(anyptr_gpA, xmmB, 0);
+ e->vhaddpd(xmmA, xmmB, xmmC);
+ e->vhaddpd(xmmA, xmmB, anyptr_gpC);
+ e->vhaddpd(ymmA, ymmB, ymmC);
+ e->vhaddpd(ymmA, ymmB, anyptr_gpC);
+ e->vhaddps(xmmA, xmmB, xmmC);
+ e->vhaddps(xmmA, xmmB, anyptr_gpC);
+ e->vhaddps(ymmA, ymmB, ymmC);
+ e->vhaddps(ymmA, ymmB, anyptr_gpC);
+ e->vhsubpd(xmmA, xmmB, xmmC);
+ e->vhsubpd(xmmA, xmmB, anyptr_gpC);
+ e->vhsubpd(ymmA, ymmB, ymmC);
+ e->vhsubpd(ymmA, ymmB, anyptr_gpC);
+ e->vhsubps(xmmA, xmmB, xmmC);
+ e->vhsubps(xmmA, xmmB, anyptr_gpC);
+ e->vhsubps(ymmA, ymmB, ymmC);
+ e->vhsubps(ymmA, ymmB, anyptr_gpC);
+ e->vinsertf128(ymmA, ymmB, xmmC, 0);
+ e->vinsertf128(ymmA, ymmB, anyptr_gpC, 0);
+ e->vinsertps(xmmA, xmmB, xmmC, 0);
+ e->vinsertps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vlddqu(xmmA, anyptr_gpB);
+ e->vlddqu(ymmA, anyptr_gpB);
+ e->vldmxcsr(anyptr_gpA);
+ e->vmaskmovdqu(xmmA, xmmB); // Implicit xmmA, xmmB, <ds:[EDI|RDI]>
+ e->vmaskmovdqu(xmmA, xmmB, ptr(e->zdi())); // Explicit xmmA, xmmB, <ds:[EDI|RDI]>
+ e->vmaskmovps(xmmA, xmmB, anyptr_gpC);
+ e->vmaskmovps(ymmA, ymmB, anyptr_gpC);
+ e->vmaskmovps(anyptr_gpA, xmmB, xmmC);
+ e->vmaskmovps(anyptr_gpA, ymmB, ymmC);
+ e->vmaskmovpd(xmmA, xmmB, anyptr_gpC);
+ e->vmaskmovpd(ymmA, ymmB, anyptr_gpC);
+ e->vmaskmovpd(anyptr_gpA, xmmB, xmmC);
+ e->vmaskmovpd(anyptr_gpA, ymmB, ymmC);
+ e->vmaxpd(xmmA, xmmB, xmmC);
+ e->vmaxpd(xmmA, xmmB, anyptr_gpC);
+ e->vmaxpd(ymmA, ymmB, ymmC);
+ e->vmaxpd(ymmA, ymmB, anyptr_gpC);
+ e->vmaxps(xmmA, xmmB, xmmC);
+ e->vmaxps(xmmA, xmmB, anyptr_gpC);
+ e->vmaxps(ymmA, ymmB, ymmC);
+ e->vmaxps(ymmA, ymmB, anyptr_gpC);
+ e->vmaxsd(xmmA, xmmB, xmmC);
+ e->vmaxsd(xmmA, xmmB, anyptr_gpC);
+ e->vmaxss(xmmA, xmmB, xmmC);
+ e->vmaxss(xmmA, xmmB, anyptr_gpC);
+ e->vminpd(xmmA, xmmB, xmmC);
+ e->vminpd(xmmA, xmmB, anyptr_gpC);
+ e->vminpd(ymmA, ymmB, ymmC);
+ e->vminpd(ymmA, ymmB, anyptr_gpC);
+ e->vminps(xmmA, xmmB, xmmC);
+ e->vminps(xmmA, xmmB, anyptr_gpC);
+ e->vminps(ymmA, ymmB, ymmC);
+ e->vminps(ymmA, ymmB, anyptr_gpC);
+ e->vminsd(xmmA, xmmB, xmmC);
+ e->vminsd(xmmA, xmmB, anyptr_gpC);
+ e->vminss(xmmA, xmmB, xmmC);
+ e->vminss(xmmA, xmmB, anyptr_gpC);
+ e->vmovapd(xmmA, xmmB);
+ e->vmovapd(xmmA, anyptr_gpB);
+ e->vmovapd(anyptr_gpA, xmmB);
+ e->vmovapd(ymmA, ymmB);
+ e->vmovapd(ymmA, anyptr_gpB);
+ e->vmovapd(anyptr_gpA, ymmB);
+ e->vmovaps(xmmA, xmmB);
+ e->vmovaps(xmmA, anyptr_gpB);
+ e->vmovaps(anyptr_gpA, xmmB);
+ e->vmovaps(ymmA, ymmB);
+ e->vmovaps(ymmA, anyptr_gpB);
+ e->vmovaps(anyptr_gpA, ymmB);
+ e->vmovd(xmmA, gzB);
+ e->vmovd(xmmA, anyptr_gpB);
+ e->vmovd(gzA, xmmB);
+ e->vmovd(anyptr_gpA, xmmB);
+ e->vmovddup(xmmA, xmmB);
+ e->vmovddup(xmmA, anyptr_gpB);
+ e->vmovddup(ymmA, ymmB);
+ e->vmovddup(ymmA, anyptr_gpB);
+ e->vmovdqa(xmmA, xmmB);
+ e->vmovdqa(xmmA, anyptr_gpB);
+ e->vmovdqa(anyptr_gpA, xmmB);
+ e->vmovdqa(ymmA, ymmB);
+ e->vmovdqa(ymmA, anyptr_gpB);
+ e->vmovdqa(anyptr_gpA, ymmB);
+ e->vmovdqu(xmmA, xmmB);
+ e->vmovdqu(xmmA, anyptr_gpB);
+ e->vmovdqu(anyptr_gpA, xmmB);
+ e->vmovdqu(ymmA, ymmB);
+ e->vmovdqu(ymmA, anyptr_gpB);
+ e->vmovdqu(anyptr_gpA, ymmB);
+ e->vmovhlps(xmmA, xmmB, xmmC);
+ e->vmovhpd(xmmA, xmmB, anyptr_gpC);
+ e->vmovhpd(anyptr_gpA, xmmB);
+ e->vmovhps(xmmA, xmmB, anyptr_gpC);
+ e->vmovhps(anyptr_gpA, xmmB);
+ e->vmovlhps(xmmA, xmmB, xmmC);
+ e->vmovlpd(xmmA, xmmB, anyptr_gpC);
+ e->vmovlpd(anyptr_gpA, xmmB);
+ e->vmovlps(xmmA, xmmB, anyptr_gpC);
+ e->vmovlps(anyptr_gpA, xmmB);
+ e->vmovmskpd(gzA, xmmB);
+ e->vmovmskpd(gzA, ymmB);
+ e->vmovmskps(gzA, xmmB);
+ e->vmovmskps(gzA, ymmB);
+ e->vmovntdq(anyptr_gpA, xmmB);
+ e->vmovntdq(anyptr_gpA, ymmB);
+ e->vmovntdqa(xmmA, anyptr_gpB);
+ e->vmovntpd(anyptr_gpA, xmmB);
+ e->vmovntpd(anyptr_gpA, ymmB);
+ e->vmovntps(anyptr_gpA, xmmB);
+ e->vmovntps(anyptr_gpA, ymmB);
+ e->vmovsd(xmmA, xmmB, xmmC);
+ e->vmovsd(xmmA, anyptr_gpB);
+ e->vmovsd(anyptr_gpA, xmmB);
+ e->vmovshdup(xmmA, xmmB);
+ e->vmovshdup(xmmA, anyptr_gpB);
+ e->vmovshdup(ymmA, ymmB);
+ e->vmovshdup(ymmA, anyptr_gpB);
+ e->vmovsldup(xmmA, xmmB);
+ e->vmovsldup(xmmA, anyptr_gpB);
+ e->vmovsldup(ymmA, ymmB);
+ e->vmovsldup(ymmA, anyptr_gpB);
+ e->vmovss(xmmA, xmmB, xmmC);
+ e->vmovss(xmmA, anyptr_gpB);
+ e->vmovss(anyptr_gpA, xmmB);
+ e->vmovupd(xmmA, xmmB);
+ e->vmovupd(xmmA, anyptr_gpB);
+ e->vmovupd(anyptr_gpA, xmmB);
+ e->vmovupd(ymmA, ymmB);
+ e->vmovupd(ymmA, anyptr_gpB);
+ e->vmovupd(anyptr_gpA, ymmB);
+ e->vmovups(xmmA, xmmB);
+ e->vmovups(xmmA, anyptr_gpB);
+ e->vmovups(anyptr_gpA, xmmB);
+ e->vmovups(ymmA, ymmB);
+ e->vmovups(ymmA, anyptr_gpB);
+ e->vmovups(anyptr_gpA, ymmB);
+ e->vmpsadbw(xmmA, xmmB, xmmC, 0);
+ e->vmpsadbw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vmulpd(xmmA, xmmB, xmmC);
+ e->vmulpd(xmmA, xmmB, anyptr_gpC);
+ e->vmulpd(ymmA, ymmB, ymmC);
+ e->vmulpd(ymmA, ymmB, anyptr_gpC);
+ e->vmulps(xmmA, xmmB, xmmC);
+ e->vmulps(xmmA, xmmB, anyptr_gpC);
+ e->vmulps(ymmA, ymmB, ymmC);
+ e->vmulps(ymmA, ymmB, anyptr_gpC);
+ e->vmulsd(xmmA, xmmB, xmmC);
+ e->vmulsd(xmmA, xmmB, anyptr_gpC);
+ e->vmulss(xmmA, xmmB, xmmC);
+ e->vmulss(xmmA, xmmB, anyptr_gpC);
+ e->vorpd(xmmA, xmmB, xmmC);
+ e->vorpd(xmmA, xmmB, anyptr_gpC);
+ e->vorpd(ymmA, ymmB, ymmC);
+ e->vorpd(ymmA, ymmB, anyptr_gpC);
+ e->vorps(xmmA, xmmB, xmmC);
+ e->vorps(xmmA, xmmB, anyptr_gpC);
+ e->vorps(ymmA, ymmB, ymmC);
+ e->vorps(ymmA, ymmB, anyptr_gpC);
+ e->vpabsb(xmmA, xmmB);
+ e->vpabsb(xmmA, anyptr_gpB);
+ e->vpabsd(xmmA, xmmB);
+ e->vpabsd(xmmA, anyptr_gpB);
+ e->vpabsw(xmmA, xmmB);
+ e->vpabsw(xmmA, anyptr_gpB);
+ e->vpackssdw(xmmA, xmmB, xmmC);
+ e->vpackssdw(xmmA, xmmB, anyptr_gpC);
+ e->vpacksswb(xmmA, xmmB, xmmC);
+ e->vpacksswb(xmmA, xmmB, anyptr_gpC);
+ e->vpackusdw(xmmA, xmmB, xmmC);
+ e->vpackusdw(xmmA, xmmB, anyptr_gpC);
+ e->vpackuswb(xmmA, xmmB, xmmC);
+ e->vpackuswb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddb(xmmA, xmmB, xmmC);
+ e->vpaddb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddd(xmmA, xmmB, xmmC);
+ e->vpaddd(xmmA, xmmB, anyptr_gpC);
+ e->vpaddq(xmmA, xmmB, xmmC);
+ e->vpaddq(xmmA, xmmB, anyptr_gpC);
+ e->vpaddw(xmmA, xmmB, xmmC);
+ e->vpaddw(xmmA, xmmB, anyptr_gpC);
+ e->vpaddsb(xmmA, xmmB, xmmC);
+ e->vpaddsb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddsw(xmmA, xmmB, xmmC);
+ e->vpaddsw(xmmA, xmmB, anyptr_gpC);
+ e->vpaddusb(xmmA, xmmB, xmmC);
+ e->vpaddusb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddusw(xmmA, xmmB, xmmC);
+ e->vpaddusw(xmmA, xmmB, anyptr_gpC);
+ e->vpalignr(xmmA, xmmB, xmmC, 0);
+ e->vpalignr(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpand(xmmA, xmmB, xmmC);
+ e->vpand(xmmA, xmmB, anyptr_gpC);
+ e->vpandn(xmmA, xmmB, xmmC);
+ e->vpandn(xmmA, xmmB, anyptr_gpC);
+ e->vpavgb(xmmA, xmmB, xmmC);
+ e->vpavgb(xmmA, xmmB, anyptr_gpC);
+ e->vpavgw(xmmA, xmmB, xmmC);
+ e->vpavgw(xmmA, xmmB, anyptr_gpC);
+ e->vpblendvb(xmmA, xmmB, xmmC, xmmD);
+ e->vpblendvb(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpblendw(xmmA, xmmB, xmmC, 0);
+ e->vpblendw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcmpeqb(xmmA, xmmB, xmmC);
+ e->vpcmpeqb(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpeqd(xmmA, xmmB, xmmC);
+ e->vpcmpeqd(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpeqq(xmmA, xmmB, xmmC);
+ e->vpcmpeqq(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpeqw(xmmA, xmmB, xmmC);
+ e->vpcmpeqw(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpgtb(xmmA, xmmB, xmmC);
+ e->vpcmpgtb(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpgtd(xmmA, xmmB, xmmC);
+ e->vpcmpgtd(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpgtq(xmmA, xmmB, xmmC);
+ e->vpcmpgtq(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpgtw(xmmA, xmmB, xmmC);
+ e->vpcmpgtw(xmmA, xmmB, anyptr_gpC);
+ e->vpcmpestri(xmmA, xmmB, 0);
+ e->vpcmpestri(xmmA, anyptr_gpB, 0);
+ e->vpcmpestrm(xmmA, xmmB, 0);
+ e->vpcmpestrm(xmmA, anyptr_gpB, 0);
+ e->vpcmpistri(xmmA, xmmB, 0);
+ e->vpcmpistri(xmmA, anyptr_gpB, 0);
+ e->vpcmpistrm(xmmA, xmmB, 0);
+ e->vpcmpistrm(xmmA, anyptr_gpB, 0);
+ e->vpermilpd(xmmA, xmmB, xmmC);
+ e->vpermilpd(xmmA, xmmB, anyptr_gpC);
+ e->vpermilpd(ymmA, ymmB, ymmC);
+ e->vpermilpd(ymmA, ymmB, anyptr_gpC);
+ e->vpermilpd(xmmA, xmmB, 0);
+ e->vpermilpd(xmmA, anyptr_gpB, 0);
+ e->vpermilpd(ymmA, ymmB, 0);
+ e->vpermilpd(ymmA, anyptr_gpB, 0);
+ e->vpermilps(xmmA, xmmB, xmmC);
+ e->vpermilps(xmmA, xmmB, anyptr_gpC);
+ e->vpermilps(ymmA, ymmB, ymmC);
+ e->vpermilps(ymmA, ymmB, anyptr_gpC);
+ e->vpermilps(xmmA, xmmB, 0);
+ e->vpermilps(xmmA, anyptr_gpB, 0);
+ e->vpermilps(ymmA, ymmB, 0);
+ e->vpermilps(ymmA, anyptr_gpB, 0);
+ e->vperm2f128(ymmA, ymmB, ymmC, 0);
+ e->vperm2f128(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpextrb(gzA, xmmB, 0);
+ e->vpextrb(anyptr_gpA, xmmB, 0);
+ e->vpextrd(gzA, xmmB, 0);
+ e->vpextrd(anyptr_gpA, xmmB, 0);
+ if (isX64) e->vpextrq(gzA, xmmB, 0);
+ if (isX64) e->vpextrq(anyptr_gpA, xmmB, 0);
+ e->vpextrw(gzA, xmmB, 0);
+ e->vpextrw(anyptr_gpA, xmmB, 0);
+ e->vphaddd(xmmA, xmmB, xmmC);
+ e->vphaddd(xmmA, xmmB, anyptr_gpC);
+ e->vphaddsw(xmmA, xmmB, xmmC);
+ e->vphaddsw(xmmA, xmmB, anyptr_gpC);
+ e->vphaddw(xmmA, xmmB, xmmC);
+ e->vphaddw(xmmA, xmmB, anyptr_gpC);
+ e->vphminposuw(xmmA, xmmB);
+ e->vphminposuw(xmmA, anyptr_gpB);
+ e->vphsubd(xmmA, xmmB, xmmC);
+ e->vphsubd(xmmA, xmmB, anyptr_gpC);
+ e->vphsubsw(xmmA, xmmB, xmmC);
+ e->vphsubsw(xmmA, xmmB, anyptr_gpC);
+ e->vphsubw(xmmA, xmmB, xmmC);
+ e->vphsubw(xmmA, xmmB, anyptr_gpC);
+ e->vpinsrb(xmmA, xmmB, gzC, 0);
+ e->vpinsrb(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpinsrd(xmmA, xmmB, gzC, 0);
+ e->vpinsrd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpinsrw(xmmA, xmmB, gzC, 0);
+ e->vpinsrw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpmaddubsw(xmmA, xmmB, xmmC);
+ e->vpmaddubsw(xmmA, xmmB, anyptr_gpC);
+ e->vpmaddwd(xmmA, xmmB, xmmC);
+ e->vpmaddwd(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsb(xmmA, xmmB, xmmC);
+ e->vpmaxsb(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsd(xmmA, xmmB, xmmC);
+ e->vpmaxsd(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsw(xmmA, xmmB, xmmC);
+ e->vpmaxsw(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxub(xmmA, xmmB, xmmC);
+ e->vpmaxub(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxud(xmmA, xmmB, xmmC);
+ e->vpmaxud(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxuw(xmmA, xmmB, xmmC);
+ e->vpmaxuw(xmmA, xmmB, anyptr_gpC);
+ e->vpminsb(xmmA, xmmB, xmmC);
+ e->vpminsb(xmmA, xmmB, anyptr_gpC);
+ e->vpminsd(xmmA, xmmB, xmmC);
+ e->vpminsd(xmmA, xmmB, anyptr_gpC);
+ e->vpminsw(xmmA, xmmB, xmmC);
+ e->vpminsw(xmmA, xmmB, anyptr_gpC);
+ e->vpminub(xmmA, xmmB, xmmC);
+ e->vpminub(xmmA, xmmB, anyptr_gpC);
+ e->vpminud(xmmA, xmmB, xmmC);
+ e->vpminud(xmmA, xmmB, anyptr_gpC);
+ e->vpminuw(xmmA, xmmB, xmmC);
+ e->vpminuw(xmmA, xmmB, anyptr_gpC);
+ e->vpmovmskb(gzA, xmmB);
+ e->vpmovsxbd(xmmA, xmmB);
+ e->vpmovsxbd(xmmA, anyptr_gpB);
+ e->vpmovsxbq(xmmA, xmmB);
+ e->vpmovsxbq(xmmA, anyptr_gpB);
+ e->vpmovsxbw(xmmA, xmmB);
+ e->vpmovsxbw(xmmA, anyptr_gpB);
+ e->vpmovsxdq(xmmA, xmmB);
+ e->vpmovsxdq(xmmA, anyptr_gpB);
+ e->vpmovsxwd(xmmA, xmmB);
+ e->vpmovsxwd(xmmA, anyptr_gpB);
+ e->vpmovsxwq(xmmA, xmmB);
+ e->vpmovsxwq(xmmA, anyptr_gpB);
+ e->vpmovzxbd(xmmA, xmmB);
+ e->vpmovzxbd(xmmA, anyptr_gpB);
+ e->vpmovzxbq(xmmA, xmmB);
+ e->vpmovzxbq(xmmA, anyptr_gpB);
+ e->vpmovzxbw(xmmA, xmmB);
+ e->vpmovzxbw(xmmA, anyptr_gpB);
+ e->vpmovzxdq(xmmA, xmmB);
+ e->vpmovzxdq(xmmA, anyptr_gpB);
+ e->vpmovzxwd(xmmA, xmmB);
+ e->vpmovzxwd(xmmA, anyptr_gpB);
+ e->vpmovzxwq(xmmA, xmmB);
+ e->vpmovzxwq(xmmA, anyptr_gpB);
+ e->vpmuldq(xmmA, xmmB, xmmC);
+ e->vpmuldq(xmmA, xmmB, anyptr_gpC);
+ e->vpmulhrsw(xmmA, xmmB, xmmC);
+ e->vpmulhrsw(xmmA, xmmB, anyptr_gpC);
+ e->vpmulhuw(xmmA, xmmB, xmmC);
+ e->vpmulhuw(xmmA, xmmB, anyptr_gpC);
+ e->vpmulhw(xmmA, xmmB, xmmC);
+ e->vpmulhw(xmmA, xmmB, anyptr_gpC);
+ e->vpmulld(xmmA, xmmB, xmmC);
+ e->vpmulld(xmmA, xmmB, anyptr_gpC);
+ e->vpmullw(xmmA, xmmB, xmmC);
+ e->vpmullw(xmmA, xmmB, anyptr_gpC);
+ e->vpmuludq(xmmA, xmmB, xmmC);
+ e->vpmuludq(xmmA, xmmB, anyptr_gpC);
+ e->vpor(xmmA, xmmB, xmmC);
+ e->vpor(xmmA, xmmB, anyptr_gpC);
+ e->vpsadbw(xmmA, xmmB, xmmC);
+ e->vpsadbw(xmmA, xmmB, anyptr_gpC);
+ e->vpshufb(xmmA, xmmB, xmmC);
+ e->vpshufb(xmmA, xmmB, anyptr_gpC);
+ e->vpshufd(xmmA, xmmB, 0);
+ e->vpshufd(xmmA, anyptr_gpB, 0);
+ e->vpshufhw(xmmA, xmmB, 0);
+ e->vpshufhw(xmmA, anyptr_gpB, 0);
+ e->vpshuflw(xmmA, xmmB, 0);
+ e->vpshuflw(xmmA, anyptr_gpB, 0);
+ e->vpsignb(xmmA, xmmB, xmmC);
+ e->vpsignb(xmmA, xmmB, anyptr_gpC);
+ e->vpsignd(xmmA, xmmB, xmmC);
+ e->vpsignd(xmmA, xmmB, anyptr_gpC);
+ e->vpsignw(xmmA, xmmB, xmmC);
+ e->vpsignw(xmmA, xmmB, anyptr_gpC);
+ e->vpslld(xmmA, xmmB, xmmC);
+ e->vpslld(xmmA, xmmB, anyptr_gpC);
+ e->vpslld(xmmA, xmmB, 0);
+ e->vpslldq(xmmA, xmmB, 0);
+ e->vpsllq(xmmA, xmmB, xmmC);
+ e->vpsllq(xmmA, xmmB, anyptr_gpC);
+ e->vpsllq(xmmA, xmmB, 0);
+ e->vpsllw(xmmA, xmmB, xmmC);
+ e->vpsllw(xmmA, xmmB, anyptr_gpC);
+ e->vpsllw(xmmA, xmmB, 0);
+ e->vpsrad(xmmA, xmmB, xmmC);
+ e->vpsrad(xmmA, xmmB, anyptr_gpC);
+ e->vpsrad(xmmA, xmmB, 0);
+ e->vpsraw(xmmA, xmmB, xmmC);
+ e->vpsraw(xmmA, xmmB, anyptr_gpC);
+ e->vpsraw(xmmA, xmmB, 0);
+ e->vpsrld(xmmA, xmmB, xmmC);
+ e->vpsrld(xmmA, xmmB, anyptr_gpC);
+ e->vpsrld(xmmA, xmmB, 0);
+ e->vpsrldq(xmmA, xmmB, 0);
+ e->vpsrlq(xmmA, xmmB, xmmC);
+ e->vpsrlq(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlq(xmmA, xmmB, 0);
+ e->vpsrlw(xmmA, xmmB, xmmC);
+ e->vpsrlw(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlw(xmmA, xmmB, 0);
+ e->vpsubb(xmmA, xmmB, xmmC);
+ e->vpsubb(xmmA, xmmB, anyptr_gpC);
+ e->vpsubd(xmmA, xmmB, xmmC);
+ e->vpsubd(xmmA, xmmB, anyptr_gpC);
+ e->vpsubq(xmmA, xmmB, xmmC);
+ e->vpsubq(xmmA, xmmB, anyptr_gpC);
+ e->vpsubw(xmmA, xmmB, xmmC);
+ e->vpsubw(xmmA, xmmB, anyptr_gpC);
+ e->vpsubsb(xmmA, xmmB, xmmC);
+ e->vpsubsb(xmmA, xmmB, anyptr_gpC);
+ e->vpsubsw(xmmA, xmmB, xmmC);
+ e->vpsubsw(xmmA, xmmB, anyptr_gpC);
+ e->vpsubusb(xmmA, xmmB, xmmC);
+ e->vpsubusb(xmmA, xmmB, anyptr_gpC);
+ e->vpsubusw(xmmA, xmmB, xmmC);
+ e->vpsubusw(xmmA, xmmB, anyptr_gpC);
+ e->vptest(xmmA, xmmB);
+ e->vptest(xmmA, anyptr_gpB);
+ e->vptest(ymmA, ymmB);
+ e->vptest(ymmA, anyptr_gpB);
+ e->vpunpckhbw(xmmA, xmmB, xmmC);
+ e->vpunpckhbw(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhdq(xmmA, xmmB, xmmC);
+ e->vpunpckhdq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhqdq(xmmA, xmmB, xmmC);
+ e->vpunpckhqdq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhwd(xmmA, xmmB, xmmC);
+ e->vpunpckhwd(xmmA, xmmB, anyptr_gpC);
+ e->vpunpcklbw(xmmA, xmmB, xmmC);
+ e->vpunpcklbw(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckldq(xmmA, xmmB, xmmC);
+ e->vpunpckldq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpcklqdq(xmmA, xmmB, xmmC);
+ e->vpunpcklqdq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpcklwd(xmmA, xmmB, xmmC);
+ e->vpunpcklwd(xmmA, xmmB, anyptr_gpC);
+ e->vpxor(xmmA, xmmB, xmmC);
+ e->vpxor(xmmA, xmmB, anyptr_gpC);
+ e->vrcpps(xmmA, xmmB);
+ e->vrcpps(xmmA, anyptr_gpB);
+ e->vrcpps(ymmA, ymmB);
+ e->vrcpps(ymmA, anyptr_gpB);
+ e->vrcpss(xmmA, xmmB, xmmC);
+ e->vrcpss(xmmA, xmmB, anyptr_gpC);
+ e->vrsqrtps(xmmA, xmmB);
+ e->vrsqrtps(xmmA, anyptr_gpB);
+ e->vrsqrtps(ymmA, ymmB);
+ e->vrsqrtps(ymmA, anyptr_gpB);
+ e->vrsqrtss(xmmA, xmmB, xmmC);
+ e->vrsqrtss(xmmA, xmmB, anyptr_gpC);
+ e->vroundpd(xmmA, xmmB, 0);
+ e->vroundpd(xmmA, anyptr_gpB, 0);
+ e->vroundpd(ymmA, ymmB, 0);
+ e->vroundpd(ymmA, anyptr_gpB, 0);
+ e->vroundps(xmmA, xmmB, 0);
+ e->vroundps(xmmA, anyptr_gpB, 0);
+ e->vroundps(ymmA, ymmB, 0);
+ e->vroundps(ymmA, anyptr_gpB, 0);
+ e->vroundsd(xmmA, xmmB, xmmC, 0);
+ e->vroundsd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vroundss(xmmA, xmmB, xmmC, 0);
+ e->vroundss(xmmA, xmmB, anyptr_gpC, 0);
+ e->vshufpd(xmmA, xmmB, xmmC, 0);
+ e->vshufpd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vshufpd(ymmA, ymmB, ymmC, 0);
+ e->vshufpd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshufps(xmmA, xmmB, xmmC, 0);
+ e->vshufps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vshufps(ymmA, ymmB, ymmC, 0);
+ e->vshufps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vsqrtpd(xmmA, xmmB);
+ e->vsqrtpd(xmmA, anyptr_gpB);
+ e->vsqrtpd(ymmA, ymmB);
+ e->vsqrtpd(ymmA, anyptr_gpB);
+ e->vsqrtps(xmmA, xmmB);
+ e->vsqrtps(xmmA, anyptr_gpB);
+ e->vsqrtps(ymmA, ymmB);
+ e->vsqrtps(ymmA, anyptr_gpB);
+ e->vsqrtsd(xmmA, xmmB, xmmC);
+ e->vsqrtsd(xmmA, xmmB, anyptr_gpC);
+ e->vsqrtss(xmmA, xmmB, xmmC);
+ e->vsqrtss(xmmA, xmmB, anyptr_gpC);
+ e->vstmxcsr(anyptr_gpA);
+ e->vsubpd(xmmA, xmmB, xmmC);
+ e->vsubpd(xmmA, xmmB, anyptr_gpC);
+ e->vsubpd(ymmA, ymmB, ymmC);
+ e->vsubpd(ymmA, ymmB, anyptr_gpC);
+ e->vsubps(xmmA, xmmB, xmmC);
+ e->vsubps(xmmA, xmmB, anyptr_gpC);
+ e->vsubps(ymmA, ymmB, ymmC);
+ e->vsubps(ymmA, ymmB, anyptr_gpC);
+ e->vsubsd(xmmA, xmmB, xmmC);
+ e->vsubsd(xmmA, xmmB, anyptr_gpC);
+ e->vsubss(xmmA, xmmB, xmmC);
+ e->vsubss(xmmA, xmmB, anyptr_gpC);
+ e->vtestps(xmmA, xmmB);
+ e->vtestps(xmmA, anyptr_gpB);
+ e->vtestps(ymmA, ymmB);
+ e->vtestps(ymmA, anyptr_gpB);
+ e->vtestpd(xmmA, xmmB);
+ e->vtestpd(xmmA, anyptr_gpB);
+ e->vtestpd(ymmA, ymmB);
+ e->vtestpd(ymmA, anyptr_gpB);
+ e->vucomisd(xmmA, xmmB);
+ e->vucomisd(xmmA, anyptr_gpB);
+ e->vucomiss(xmmA, xmmB);
+ e->vucomiss(xmmA, anyptr_gpB);
+ e->vunpckhpd(xmmA, xmmB, xmmC);
+ e->vunpckhpd(xmmA, xmmB, anyptr_gpC);
+ e->vunpckhpd(ymmA, ymmB, ymmC);
+ e->vunpckhpd(ymmA, ymmB, anyptr_gpC);
+ e->vunpckhps(xmmA, xmmB, xmmC);
+ e->vunpckhps(xmmA, xmmB, anyptr_gpC);
+ e->vunpckhps(ymmA, ymmB, ymmC);
+ e->vunpckhps(ymmA, ymmB, anyptr_gpC);
+ e->vunpcklpd(xmmA, xmmB, xmmC);
+ e->vunpcklpd(xmmA, xmmB, anyptr_gpC);
+ e->vunpcklpd(ymmA, ymmB, ymmC);
+ e->vunpcklpd(ymmA, ymmB, anyptr_gpC);
+ e->vunpcklps(xmmA, xmmB, xmmC);
+ e->vunpcklps(xmmA, xmmB, anyptr_gpC);
+ e->vunpcklps(ymmA, ymmB, ymmC);
+ e->vunpcklps(ymmA, ymmB, anyptr_gpC);
+ e->vxorpd(xmmA, xmmB, xmmC);
+ e->vxorpd(xmmA, xmmB, anyptr_gpC);
+ e->vxorpd(ymmA, ymmB, ymmC);
+ e->vxorpd(ymmA, ymmB, anyptr_gpC);
+ e->vxorps(xmmA, xmmB, xmmC);
+ e->vxorps(xmmA, xmmB, anyptr_gpC);
+ e->vxorps(ymmA, ymmB, ymmC);
+ e->vxorps(ymmA, ymmB, anyptr_gpC);
+ e->vzeroall();
+ e->vex3().vzeroall();
+ e->vzeroupper();
+ e->vex3().vzeroupper();
+
+ // AVX+AESNI.
+ e->nop();
+
+ e->vaesdec(xmmA, xmmB, xmmC);
+ e->vaesdec(xmmA, xmmB, anyptr_gpC);
+ e->vaesdeclast(xmmA, xmmB, xmmC);
+ e->vaesdeclast(xmmA, xmmB, anyptr_gpC);
+ e->vaesenc(xmmA, xmmB, xmmC);
+ e->vaesenc(xmmA, xmmB, anyptr_gpC);
+ e->vaesenclast(xmmA, xmmB, xmmC);
+ e->vaesenclast(xmmA, xmmB, anyptr_gpC);
+ e->vaesimc(xmmA, xmmB);
+ e->vaesimc(xmmA, anyptr_gpB);
+ e->vaeskeygenassist(xmmA, xmmB, 0);
+ e->vaeskeygenassist(xmmA, anyptr_gpB, 0);
+
+ // AVX+PCLMULQDQ.
+ e->nop();
+
+ e->vpclmulqdq(xmmA, xmmB, xmmC, 0);
+ e->vpclmulqdq(xmmA, xmmB, anyptr_gpC, 0);
+
+ // AVX2.
+ e->nop();
+
+ e->vbroadcasti128(ymmA, anyptr_gpB);
+ e->vbroadcastsd(ymmA, xmmB);
+ e->vbroadcastss(xmmA, xmmB);
+ e->vbroadcastss(ymmA, xmmB);
+ e->vextracti128(xmmA, ymmB, 0);
+ e->vextracti128(anyptr_gpA, ymmB, 0);
+ e->vgatherdpd(xmmA, vx_ptr, xmmC);
+ e->vgatherdpd(ymmA, vx_ptr, ymmC);
+ e->vgatherdps(xmmA, vx_ptr, xmmC);
+ e->vgatherdps(ymmA, vy_ptr, ymmC);
+ e->vgatherqpd(xmmA, vx_ptr, xmmC);
+ e->vgatherqpd(ymmA, vy_ptr, ymmC);
+ e->vgatherqps(xmmA, vx_ptr, xmmC);
+ e->vgatherqps(xmmA, vy_ptr, xmmC);
+ e->vinserti128(ymmA, ymmB, xmmC, 0);
+ e->vinserti128(ymmA, ymmB, anyptr_gpC, 0);
+ e->vmovntdqa(ymmA, anyptr_gpB);
+ e->vmpsadbw(ymmA, ymmB, ymmC, 0);
+ e->vmpsadbw(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpabsb(ymmA, ymmB);
+ e->vpabsb(ymmA, anyptr_gpB);
+ e->vpabsd(ymmA, ymmB);
+ e->vpabsd(ymmA, anyptr_gpB);
+ e->vpabsw(ymmA, ymmB);
+ e->vpabsw(ymmA, anyptr_gpB);
+ e->vpackssdw(ymmA, ymmB, ymmC);
+ e->vpackssdw(ymmA, ymmB, anyptr_gpC);
+ e->vpacksswb(ymmA, ymmB, ymmC);
+ e->vpacksswb(ymmA, ymmB, anyptr_gpC);
+ e->vpackusdw(ymmA, ymmB, ymmC);
+ e->vpackusdw(ymmA, ymmB, anyptr_gpC);
+ e->vpackuswb(ymmA, ymmB, ymmC);
+ e->vpackuswb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddb(ymmA, ymmB, ymmC);
+ e->vpaddb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddd(ymmA, ymmB, ymmC);
+ e->vpaddd(ymmA, ymmB, anyptr_gpC);
+ e->vpaddq(ymmA, ymmB, ymmC);
+ e->vpaddq(ymmA, ymmB, anyptr_gpC);
+ e->vpaddw(ymmA, ymmB, ymmC);
+ e->vpaddw(ymmA, ymmB, anyptr_gpC);
+ e->vpaddsb(ymmA, ymmB, ymmC);
+ e->vpaddsb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddsw(ymmA, ymmB, ymmC);
+ e->vpaddsw(ymmA, ymmB, anyptr_gpC);
+ e->vpaddusb(ymmA, ymmB, ymmC);
+ e->vpaddusb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddusw(ymmA, ymmB, ymmC);
+ e->vpaddusw(ymmA, ymmB, anyptr_gpC);
+ e->vpalignr(ymmA, ymmB, ymmC, 0);
+ e->vpalignr(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpand(ymmA, ymmB, ymmC);
+ e->vpand(ymmA, ymmB, anyptr_gpC);
+ e->vpandn(ymmA, ymmB, ymmC);
+ e->vpandn(ymmA, ymmB, anyptr_gpC);
+ e->vpavgb(ymmA, ymmB, ymmC);
+ e->vpavgb(ymmA, ymmB, anyptr_gpC);
+ e->vpavgw(ymmA, ymmB, ymmC);
+ e->vpavgw(ymmA, ymmB, anyptr_gpC);
+ e->vpblendd(xmmA, xmmB, xmmC, 0);
+ e->vpblendd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpblendd(ymmA, ymmB, ymmC, 0);
+ e->vpblendd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpblendvb(ymmA, ymmB, ymmC, ymmD);
+ e->vpblendvb(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vpblendw(ymmA, ymmB, ymmC, 0);
+ e->vpblendw(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpbroadcastb(xmmA, xmmB);
+ e->vpbroadcastb(xmmA, anyptr_gpB);
+ e->vpbroadcastb(ymmA, xmmB);
+ e->vpbroadcastb(ymmA, anyptr_gpB);
+ e->vpbroadcastd(xmmA, xmmB);
+ e->vpbroadcastd(xmmA, anyptr_gpB);
+ e->vpbroadcastd(ymmA, xmmB);
+ e->vpbroadcastd(ymmA, anyptr_gpB);
+ e->vpbroadcastq(xmmA, xmmB);
+ e->vpbroadcastq(xmmA, anyptr_gpB);
+ e->vpbroadcastq(ymmA, xmmB);
+ e->vpbroadcastq(ymmA, anyptr_gpB);
+ e->vpbroadcastw(xmmA, xmmB);
+ e->vpbroadcastw(xmmA, anyptr_gpB);
+ e->vpbroadcastw(ymmA, xmmB);
+ e->vpbroadcastw(ymmA, anyptr_gpB);
+ e->vpcmpeqb(ymmA, ymmB, ymmC);
+ e->vpcmpeqb(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpeqd(ymmA, ymmB, ymmC);
+ e->vpcmpeqd(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpeqq(ymmA, ymmB, ymmC);
+ e->vpcmpeqq(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpeqw(ymmA, ymmB, ymmC);
+ e->vpcmpeqw(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpgtb(ymmA, ymmB, ymmC);
+ e->vpcmpgtb(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpgtd(ymmA, ymmB, ymmC);
+ e->vpcmpgtd(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpgtq(ymmA, ymmB, ymmC);
+ e->vpcmpgtq(ymmA, ymmB, anyptr_gpC);
+ e->vpcmpgtw(ymmA, ymmB, ymmC);
+ e->vpcmpgtw(ymmA, ymmB, anyptr_gpC);
+ e->vperm2i128(ymmA, ymmB, ymmC, 0);
+ e->vperm2i128(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpermd(ymmA, ymmB, ymmC);
+ e->vpermd(ymmA, ymmB, anyptr_gpC);
+ e->vpermps(ymmA, ymmB, ymmC);
+ e->vpermps(ymmA, ymmB, anyptr_gpC);
+ e->vpermpd(ymmA, ymmB, 0);
+ e->vpermpd(ymmA, anyptr_gpB, 0);
+ e->vpermq(ymmA, ymmB, 0);
+ e->vpermq(ymmA, anyptr_gpB, 0);
+ e->vpgatherdd(xmmA, vx_ptr, xmmC);
+ e->vpgatherdd(ymmA, vy_ptr, ymmC);
+ e->vpgatherdq(xmmA, vx_ptr, xmmC);
+ e->vpgatherdq(ymmA, vx_ptr, ymmC);
+ e->vpgatherqd(xmmA, vx_ptr, xmmC);
+ e->vpgatherqd(xmmA, vy_ptr, xmmC);
+ e->vpgatherqq(xmmA, vx_ptr, xmmC);
+ e->vpgatherqq(ymmA, vy_ptr, ymmC);
+ e->vpmovmskb(gzA, ymmB);
+ e->vpmovsxbd(ymmA, anyptr_gpB);
+ e->vpmovsxbd(ymmA, xmmB);
+ e->vpmovsxbq(ymmA, anyptr_gpB);
+ e->vpmovsxbq(ymmA, xmmB);
+ e->vpmovsxbw(ymmA, anyptr_gpB);
+ e->vpmovsxbw(ymmA, xmmB);
+ e->vpmovsxdq(ymmA, anyptr_gpB);
+ e->vpmovsxdq(ymmA, xmmB);
+ e->vpmovsxwd(ymmA, anyptr_gpB);
+ e->vpmovsxwd(ymmA, xmmB);
+ e->vpmovsxwq(ymmA, anyptr_gpB);
+ e->vpmovsxwq(ymmA, xmmB);
+ e->vpmovzxbd(ymmA, anyptr_gpB);
+ e->vpmovzxbd(ymmA, xmmB);
+ e->vpmovzxbq(ymmA, anyptr_gpB);
+ e->vpmovzxbq(ymmA, xmmB);
+ e->vpmovzxbw(ymmA, anyptr_gpB);
+ e->vpmovzxbw(ymmA, xmmB);
+ e->vpmovzxdq(ymmA, anyptr_gpB);
+ e->vpmovzxdq(ymmA, xmmB);
+ e->vpmovzxwd(ymmA, anyptr_gpB);
+ e->vpmovzxwd(ymmA, xmmB);
+ e->vpmovzxwq(ymmA, anyptr_gpB);
+ e->vpmovzxwq(ymmA, xmmB);
+ e->vpshufd(ymmA, anyptr_gpB, 0);
+ e->vpshufd(ymmA, ymmB, 0);
+ e->vpshufhw(ymmA, anyptr_gpB, 0);
+ e->vpshufhw(ymmA, ymmB, 0);
+ e->vpshuflw(ymmA, anyptr_gpB, 0);
+ e->vpshuflw(ymmA, ymmB, 0);
+ e->vpslld(ymmA, ymmB, 0);
+ e->vpslldq(ymmA, ymmB, 0);
+ e->vpsllq(ymmA, ymmB, 0);
+ e->vpsllw(ymmA, ymmB, 0);
+ e->vpsrad(ymmA, ymmB, 0);
+ e->vpsraw(ymmA, ymmB, 0);
+ e->vpsrld(ymmA, ymmB, 0);
+ e->vpsrldq(ymmA, ymmB, 0);
+ e->vpsrlq(ymmA, ymmB, 0);
+ e->vpsrlw(ymmA, ymmB, 0);
+ e->vphaddd(ymmA, ymmB, anyptr_gpC);
+ e->vphaddd(ymmA, ymmB, ymmC);
+ e->vphaddsw(ymmA, ymmB, anyptr_gpC);
+ e->vphaddsw(ymmA, ymmB, ymmC);
+ e->vphaddw(ymmA, ymmB, anyptr_gpC);
+ e->vphaddw(ymmA, ymmB, ymmC);
+ e->vphsubd(ymmA, ymmB, anyptr_gpC);
+ e->vphsubd(ymmA, ymmB, ymmC);
+ e->vphsubsw(ymmA, ymmB, anyptr_gpC);
+ e->vphsubsw(ymmA, ymmB, ymmC);
+ e->vphsubw(ymmA, ymmB, anyptr_gpC);
+ e->vphsubw(ymmA, ymmB, ymmC);
+ e->vpmaddubsw(ymmA, ymmB, anyptr_gpC);
+ e->vpmaddubsw(ymmA, ymmB, ymmC);
+ e->vpmaddwd(ymmA, ymmB, anyptr_gpC);
+ e->vpmaddwd(ymmA, ymmB, ymmC);
+ e->vpmaskmovd(anyptr_gpA, xmmB, xmmC);
+ e->vpmaskmovd(anyptr_gpA, ymmB, ymmC);
+ e->vpmaskmovd(xmmA, xmmB, anyptr_gpC);
+ e->vpmaskmovd(ymmA, ymmB, anyptr_gpC);
+ e->vpmaskmovq(anyptr_gpA, xmmB, xmmC);
+ e->vpmaskmovq(anyptr_gpA, ymmB, ymmC);
+ e->vpmaskmovq(xmmA, xmmB, anyptr_gpC);
+ e->vpmaskmovq(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsb(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsb(ymmA, ymmB, ymmC);
+ e->vpmaxsd(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsd(ymmA, ymmB, ymmC);
+ e->vpmaxsw(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsw(ymmA, ymmB, ymmC);
+ e->vpmaxub(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxub(ymmA, ymmB, ymmC);
+ e->vpmaxud(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxud(ymmA, ymmB, ymmC);
+ e->vpmaxuw(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxuw(ymmA, ymmB, ymmC);
+ e->vpminsb(ymmA, ymmB, anyptr_gpC);
+ e->vpminsb(ymmA, ymmB, ymmC);
+ e->vpminsd(ymmA, ymmB, anyptr_gpC);
+ e->vpminsd(ymmA, ymmB, ymmC);
+ e->vpminsw(ymmA, ymmB, anyptr_gpC);
+ e->vpminsw(ymmA, ymmB, ymmC);
+ e->vpminub(ymmA, ymmB, anyptr_gpC);
+ e->vpminub(ymmA, ymmB, ymmC);
+ e->vpminud(ymmA, ymmB, anyptr_gpC);
+ e->vpminud(ymmA, ymmB, ymmC);
+ e->vpminuw(ymmA, ymmB, anyptr_gpC);
+ e->vpminuw(ymmA, ymmB, ymmC);
+ e->vpmuldq(ymmA, ymmB, anyptr_gpC);
+ e->vpmuldq(ymmA, ymmB, ymmC);
+ e->vpmulhrsw(ymmA, ymmB, anyptr_gpC);
+ e->vpmulhrsw(ymmA, ymmB, ymmC);
+ e->vpmulhuw(ymmA, ymmB, anyptr_gpC);
+ e->vpmulhuw(ymmA, ymmB, ymmC);
+ e->vpmulhw(ymmA, ymmB, anyptr_gpC);
+ e->vpmulhw(ymmA, ymmB, ymmC);
+ e->vpmulld(ymmA, ymmB, anyptr_gpC);
+ e->vpmulld(ymmA, ymmB, ymmC);
+ e->vpmullw(ymmA, ymmB, anyptr_gpC);
+ e->vpmullw(ymmA, ymmB, ymmC);
+ e->vpmuludq(ymmA, ymmB, anyptr_gpC);
+ e->vpmuludq(ymmA, ymmB, ymmC);
+ e->vpor(ymmA, ymmB, anyptr_gpC);
+ e->vpor(ymmA, ymmB, ymmC);
+ e->vpsadbw(ymmA, ymmB, anyptr_gpC);
+ e->vpsadbw(ymmA, ymmB, ymmC);
+ e->vpshufb(ymmA, ymmB, anyptr_gpC);
+ e->vpshufb(ymmA, ymmB, ymmC);
+ e->vpsignb(ymmA, ymmB, anyptr_gpC);
+ e->vpsignb(ymmA, ymmB, ymmC);
+ e->vpsignd(ymmA, ymmB, anyptr_gpC);
+ e->vpsignd(ymmA, ymmB, ymmC);
+ e->vpsignw(ymmA, ymmB, anyptr_gpC);
+ e->vpsignw(ymmA, ymmB, ymmC);
+ e->vpslld(ymmA, ymmB, anyptr_gpC);
+ e->vpslld(ymmA, ymmB, xmmC);
+ e->vpsllq(ymmA, ymmB, anyptr_gpC);
+ e->vpsllq(ymmA, ymmB, xmmC);
+ e->vpsllvd(xmmA, xmmB, anyptr_gpC);
+ e->vpsllvd(xmmA, xmmB, xmmC);
+ e->vpsllvd(ymmA, ymmB, anyptr_gpC);
+ e->vpsllvd(ymmA, ymmB, ymmC);
+ e->vpsllvq(xmmA, xmmB, anyptr_gpC);
+ e->vpsllvq(xmmA, xmmB, xmmC);
+ e->vpsllvq(ymmA, ymmB, anyptr_gpC);
+ e->vpsllvq(ymmA, ymmB, ymmC);
+ e->vpsllw(ymmA, ymmB, anyptr_gpC);
+ e->vpsllw(ymmA, ymmB, xmmC);
+ e->vpsrad(ymmA, ymmB, anyptr_gpC);
+ e->vpsrad(ymmA, ymmB, xmmC);
+ e->vpsravd(xmmA, xmmB, anyptr_gpC);
+ e->vpsravd(xmmA, xmmB, xmmC);
+ e->vpsravd(ymmA, ymmB, anyptr_gpC);
+ e->vpsravd(ymmA, ymmB, ymmC);
+ e->vpsraw(ymmA, ymmB, anyptr_gpC);
+ e->vpsraw(ymmA, ymmB, xmmC);
+ e->vpsrld(ymmA, ymmB, anyptr_gpC);
+ e->vpsrld(ymmA, ymmB, xmmC);
+ e->vpsrlq(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlq(ymmA, ymmB, xmmC);
+ e->vpsrlvd(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlvd(xmmA, xmmB, xmmC);
+ e->vpsrlvd(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlvd(ymmA, ymmB, ymmC);
+ e->vpsrlvq(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlvq(xmmA, xmmB, xmmC);
+ e->vpsrlvq(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlvq(ymmA, ymmB, ymmC);
+ e->vpsrlw(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlw(ymmA, ymmB, xmmC);
+ e->vpsubb(ymmA, ymmB, anyptr_gpC);
+ e->vpsubb(ymmA, ymmB, ymmC);
+ e->vpsubd(ymmA, ymmB, anyptr_gpC);
+ e->vpsubd(ymmA, ymmB, ymmC);
+ e->vpsubq(ymmA, ymmB, anyptr_gpC);
+ e->vpsubq(ymmA, ymmB, ymmC);
+ e->vpsubsb(ymmA, ymmB, anyptr_gpC);
+ e->vpsubsb(ymmA, ymmB, ymmC);
+ e->vpsubsw(ymmA, ymmB, anyptr_gpC);
+ e->vpsubsw(ymmA, ymmB, ymmC);
+ e->vpsubusb(ymmA, ymmB, anyptr_gpC);
+ e->vpsubusb(ymmA, ymmB, ymmC);
+ e->vpsubusw(ymmA, ymmB, anyptr_gpC);
+ e->vpsubusw(ymmA, ymmB, ymmC);
+ e->vpsubw(ymmA, ymmB, anyptr_gpC);
+ e->vpsubw(ymmA, ymmB, ymmC);
+ e->vpunpckhbw(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhbw(ymmA, ymmB, ymmC);
+ e->vpunpckhdq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhdq(ymmA, ymmB, ymmC);
+ e->vpunpckhqdq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhqdq(ymmA, ymmB, ymmC);
+ e->vpunpckhwd(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhwd(ymmA, ymmB, ymmC);
+ e->vpunpcklbw(ymmA, ymmB, anyptr_gpC);
+ e->vpunpcklbw(ymmA, ymmB, ymmC);
+ e->vpunpckldq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckldq(ymmA, ymmB, ymmC);
+ e->vpunpcklqdq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpcklqdq(ymmA, ymmB, ymmC);
+ e->vpunpcklwd(ymmA, ymmB, anyptr_gpC);
+ e->vpunpcklwd(ymmA, ymmB, ymmC);
+ e->vpxor(ymmA, ymmB, anyptr_gpC);
+ e->vpxor(ymmA, ymmB, ymmC);
+
+ // FMA.
+ e->nop();
+
+ e->vfmadd132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132pd(xmmA, xmmB, xmmC);
+ e->vfmadd132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd132pd(ymmA, ymmB, ymmC);
+ e->vfmadd132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132ps(xmmA, xmmB, xmmC);
+ e->vfmadd132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd132ps(ymmA, ymmB, ymmC);
+ e->vfmadd132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132sd(xmmA, xmmB, xmmC);
+ e->vfmadd132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132ss(xmmA, xmmB, xmmC);
+ e->vfmadd213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213pd(xmmA, xmmB, xmmC);
+ e->vfmadd213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd213pd(ymmA, ymmB, ymmC);
+ e->vfmadd213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213ps(xmmA, xmmB, xmmC);
+ e->vfmadd213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd213ps(ymmA, ymmB, ymmC);
+ e->vfmadd213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213sd(xmmA, xmmB, xmmC);
+ e->vfmadd213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213ss(xmmA, xmmB, xmmC);
+ e->vfmadd231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231pd(xmmA, xmmB, xmmC);
+ e->vfmadd231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd231pd(ymmA, ymmB, ymmC);
+ e->vfmadd231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231ps(xmmA, xmmB, xmmC);
+ e->vfmadd231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd231ps(ymmA, ymmB, ymmC);
+ e->vfmadd231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231sd(xmmA, xmmB, xmmC);
+ e->vfmadd231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231ss(xmmA, xmmB, xmmC);
+ e->vfmaddsub132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub132pd(xmmA, xmmB, xmmC);
+ e->vfmaddsub132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub132pd(ymmA, ymmB, ymmC);
+ e->vfmaddsub132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub132ps(xmmA, xmmB, xmmC);
+ e->vfmaddsub132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub132ps(ymmA, ymmB, ymmC);
+ e->vfmaddsub213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub213pd(xmmA, xmmB, xmmC);
+ e->vfmaddsub213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub213pd(ymmA, ymmB, ymmC);
+ e->vfmaddsub213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub213ps(xmmA, xmmB, xmmC);
+ e->vfmaddsub213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub213ps(ymmA, ymmB, ymmC);
+ e->vfmaddsub231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub231pd(xmmA, xmmB, xmmC);
+ e->vfmaddsub231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub231pd(ymmA, ymmB, ymmC);
+ e->vfmaddsub231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub231ps(xmmA, xmmB, xmmC);
+ e->vfmaddsub231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub231ps(ymmA, ymmB, ymmC);
+ e->vfmsub132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132pd(xmmA, xmmB, xmmC);
+ e->vfmsub132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub132pd(ymmA, ymmB, ymmC);
+ e->vfmsub132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132ps(xmmA, xmmB, xmmC);
+ e->vfmsub132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub132ps(ymmA, ymmB, ymmC);
+ e->vfmsub132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132sd(xmmA, xmmB, xmmC);
+ e->vfmsub132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132ss(xmmA, xmmB, xmmC);
+ e->vfmsub213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213pd(xmmA, xmmB, xmmC);
+ e->vfmsub213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub213pd(ymmA, ymmB, ymmC);
+ e->vfmsub213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213ps(xmmA, xmmB, xmmC);
+ e->vfmsub213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub213ps(ymmA, ymmB, ymmC);
+ e->vfmsub213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213sd(xmmA, xmmB, xmmC);
+ e->vfmsub213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213ss(xmmA, xmmB, xmmC);
+ e->vfmsub231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231pd(xmmA, xmmB, xmmC);
+ e->vfmsub231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub231pd(ymmA, ymmB, ymmC);
+ e->vfmsub231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231ps(xmmA, xmmB, xmmC);
+ e->vfmsub231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub231ps(ymmA, ymmB, ymmC);
+ e->vfmsub231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231sd(xmmA, xmmB, xmmC);
+ e->vfmsub231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231ss(xmmA, xmmB, xmmC);
+ e->vfmsubadd132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd132pd(xmmA, xmmB, xmmC);
+ e->vfmsubadd132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd132pd(ymmA, ymmB, ymmC);
+ e->vfmsubadd132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd132ps(xmmA, xmmB, xmmC);
+ e->vfmsubadd132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd132ps(ymmA, ymmB, ymmC);
+ e->vfmsubadd213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd213pd(xmmA, xmmB, xmmC);
+ e->vfmsubadd213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd213pd(ymmA, ymmB, ymmC);
+ e->vfmsubadd213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd213ps(xmmA, xmmB, xmmC);
+ e->vfmsubadd213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd213ps(ymmA, ymmB, ymmC);
+ e->vfmsubadd231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd231pd(xmmA, xmmB, xmmC);
+ e->vfmsubadd231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd231pd(ymmA, ymmB, ymmC);
+ e->vfmsubadd231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd231ps(xmmA, xmmB, xmmC);
+ e->vfmsubadd231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd231ps(ymmA, ymmB, ymmC);
+ e->vfnmadd132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132pd(xmmA, xmmB, xmmC);
+ e->vfnmadd132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd132pd(ymmA, ymmB, ymmC);
+ e->vfnmadd132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132ps(xmmA, xmmB, xmmC);
+ e->vfnmadd132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd132ps(ymmA, ymmB, ymmC);
+ e->vfnmadd132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132sd(xmmA, xmmB, xmmC);
+ e->vfnmadd132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132ss(xmmA, xmmB, xmmC);
+ e->vfnmadd213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213pd(xmmA, xmmB, xmmC);
+ e->vfnmadd213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd213pd(ymmA, ymmB, ymmC);
+ e->vfnmadd213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213ps(xmmA, xmmB, xmmC);
+ e->vfnmadd213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd213ps(ymmA, ymmB, ymmC);
+ e->vfnmadd213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213sd(xmmA, xmmB, xmmC);
+ e->vfnmadd213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213ss(xmmA, xmmB, xmmC);
+ e->vfnmadd231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231pd(xmmA, xmmB, xmmC);
+ e->vfnmadd231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd231pd(ymmA, ymmB, ymmC);
+ e->vfnmadd231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231ps(xmmA, xmmB, xmmC);
+ e->vfnmadd231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd231ps(ymmA, ymmB, ymmC);
+ e->vfnmadd231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231sd(xmmA, xmmB, xmmC);
+ e->vfnmadd231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231ss(xmmA, xmmB, xmmC);
+ e->vfnmsub132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132pd(xmmA, xmmB, xmmC);
+ e->vfnmsub132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub132pd(ymmA, ymmB, ymmC);
+ e->vfnmsub132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132ps(xmmA, xmmB, xmmC);
+ e->vfnmsub132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub132ps(ymmA, ymmB, ymmC);
+ e->vfnmsub132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132sd(xmmA, xmmB, xmmC);
+ e->vfnmsub132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132ss(xmmA, xmmB, xmmC);
+ e->vfnmsub213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213pd(xmmA, xmmB, xmmC);
+ e->vfnmsub213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub213pd(ymmA, ymmB, ymmC);
+ e->vfnmsub213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213ps(xmmA, xmmB, xmmC);
+ e->vfnmsub213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub213ps(ymmA, ymmB, ymmC);
+ e->vfnmsub213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213sd(xmmA, xmmB, xmmC);
+ e->vfnmsub213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213ss(xmmA, xmmB, xmmC);
+ e->vfnmsub231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231pd(xmmA, xmmB, xmmC);
+ e->vfnmsub231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub231pd(ymmA, ymmB, ymmC);
+ e->vfnmsub231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231ps(xmmA, xmmB, xmmC);
+ e->vfnmsub231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub231ps(ymmA, ymmB, ymmC);
+ e->vfnmsub231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231sd(xmmA, xmmB, xmmC);
+ e->vfnmsub231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231ss(xmmA, xmmB, xmmC);
+
+ // FMA4.
+ e->nop();
+
+ e->vfmaddpd(xmmA, xmmB, xmmC, xmmD);
+ e->vfmaddpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmaddpd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmaddpd(ymmA, ymmB, ymmC, ymmD);
+ e->vfmaddpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmaddpd(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmaddps(xmmA, xmmB, xmmC, xmmD);
+ e->vfmaddps(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmaddps(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmaddps(ymmA, ymmB, ymmC, ymmD);
+ e->vfmaddps(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmaddps(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmaddsd(xmmA, xmmB, xmmC, xmmD);
+ e->vfmaddsd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmaddsd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmaddss(xmmA, xmmB, xmmC, xmmD);
+ e->vfmaddss(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmaddss(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmaddsubpd(xmmA, xmmB, xmmC, xmmD);
+ e->vfmaddsubpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmaddsubpd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmaddsubpd(ymmA, ymmB, ymmC, ymmD);
+ e->vfmaddsubpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmaddsubpd(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmaddsubps(xmmA, xmmB, xmmC, xmmD);
+ e->vfmaddsubps(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmaddsubps(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmaddsubps(ymmA, ymmB, ymmC, ymmD);
+ e->vfmaddsubps(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmaddsubps(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmsubaddpd(xmmA, xmmB, xmmC, xmmD);
+ e->vfmsubaddpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmsubaddpd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmsubaddpd(ymmA, ymmB, ymmC, ymmD);
+ e->vfmsubaddpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmsubaddpd(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmsubaddps(xmmA, xmmB, xmmC, xmmD);
+ e->vfmsubaddps(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmsubaddps(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmsubaddps(ymmA, ymmB, ymmC, ymmD);
+ e->vfmsubaddps(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmsubaddps(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmsubpd(xmmA, xmmB, xmmC, xmmD);
+ e->vfmsubpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmsubpd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmsubpd(ymmA, ymmB, ymmC, ymmD);
+ e->vfmsubpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmsubpd(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmsubps(xmmA, xmmB, xmmC, xmmD);
+ e->vfmsubps(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmsubps(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmsubps(ymmA, ymmB, ymmC, ymmD);
+ e->vfmsubps(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfmsubps(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfmsubsd(xmmA, xmmB, xmmC, xmmD);
+ e->vfmsubsd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmsubsd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfmsubss(xmmA, xmmB, xmmC, xmmD);
+ e->vfmsubss(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfmsubss(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmaddpd(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmaddpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmaddpd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmaddpd(ymmA, ymmB, ymmC, ymmD);
+ e->vfnmaddpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfnmaddpd(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfnmaddps(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmaddps(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmaddps(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmaddps(ymmA, ymmB, ymmC, ymmD);
+ e->vfnmaddps(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfnmaddps(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfnmaddsd(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmaddsd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmaddsd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmaddss(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmaddss(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmaddss(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmsubpd(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmsubpd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmsubpd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmsubpd(ymmA, ymmB, ymmC, ymmD);
+ e->vfnmsubpd(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfnmsubpd(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfnmsubps(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmsubps(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmsubps(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmsubps(ymmA, ymmB, ymmC, ymmD);
+ e->vfnmsubps(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vfnmsubps(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vfnmsubsd(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmsubsd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmsubsd(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vfnmsubss(xmmA, xmmB, xmmC, xmmD);
+ e->vfnmsubss(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vfnmsubss(xmmA, xmmB, xmmC, anyptr_gpD);
+
+ // XOP.
+ e->nop();
+
+ e->vfrczpd(xmmA, xmmB);
+ e->vfrczpd(xmmA, anyptr_gpB);
+ e->vfrczpd(ymmA, ymmB);
+ e->vfrczpd(ymmA, anyptr_gpB);
+ e->vfrczps(xmmA, xmmB);
+ e->vfrczps(xmmA, anyptr_gpB);
+ e->vfrczps(ymmA, ymmB);
+ e->vfrczps(ymmA, anyptr_gpB);
+ e->vfrczsd(xmmA, xmmB);
+ e->vfrczsd(xmmA, anyptr_gpB);
+ e->vfrczss(xmmA, xmmB);
+ e->vfrczss(xmmA, anyptr_gpB);
+ e->vpcmov(xmmA, xmmB, xmmC, xmmD);
+ e->vpcmov(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpcmov(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vpcmov(ymmA, ymmB, ymmC, ymmD);
+ e->vpcmov(ymmA, ymmB, anyptr_gpC, ymmD);
+ e->vpcmov(ymmA, ymmB, ymmC, anyptr_gpD);
+ e->vpcomb(xmmA, xmmB, xmmC, 0);
+ e->vpcomb(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomd(xmmA, xmmB, xmmC, 0);
+ e->vpcomd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomq(xmmA, xmmB, xmmC, 0);
+ e->vpcomq(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomw(xmmA, xmmB, xmmC, 0);
+ e->vpcomw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomub(xmmA, xmmB, xmmC, 0);
+ e->vpcomub(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomud(xmmA, xmmB, xmmC, 0);
+ e->vpcomud(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomuq(xmmA, xmmB, xmmC, 0);
+ e->vpcomuq(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpcomuw(xmmA, xmmB, xmmC, 0);
+ e->vpcomuw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpermil2pd(xmmA, xmmB, xmmC, xmmD, 0);
+ e->vpermil2pd(xmmA, xmmB, anyptr_gpC, xmmD, 0);
+ e->vpermil2pd(xmmA, xmmB, xmmC, anyptr_gpD, 0);
+ e->vpermil2pd(ymmA, ymmB, ymmC, ymmD, 0);
+ e->vpermil2pd(ymmA, ymmB, anyptr_gpC, ymmD, 0);
+ e->vpermil2pd(ymmA, ymmB, ymmC, anyptr_gpD, 0);
+ e->vpermil2ps(xmmA, xmmB, xmmC, xmmD, 0);
+ e->vpermil2ps(xmmA, xmmB, anyptr_gpC, xmmD, 0);
+ e->vpermil2ps(xmmA, xmmB, xmmC, anyptr_gpD, 0);
+ e->vpermil2ps(ymmA, ymmB, ymmC, ymmD, 0);
+ e->vpermil2ps(ymmA, ymmB, anyptr_gpC, ymmD, 0);
+ e->vpermil2ps(ymmA, ymmB, ymmC, anyptr_gpD, 0);
+ e->vphaddbd(xmmA, xmmB);
+ e->vphaddbd(xmmA, anyptr_gpB);
+ e->vphaddbq(xmmA, xmmB);
+ e->vphaddbq(xmmA, anyptr_gpB);
+ e->vphaddbw(xmmA, xmmB);
+ e->vphaddbw(xmmA, anyptr_gpB);
+ e->vphadddq(xmmA, xmmB);
+ e->vphadddq(xmmA, anyptr_gpB);
+ e->vphaddwd(xmmA, xmmB);
+ e->vphaddwd(xmmA, anyptr_gpB);
+ e->vphaddwq(xmmA, xmmB);
+ e->vphaddwq(xmmA, anyptr_gpB);
+ e->vphaddubd(xmmA, xmmB);
+ e->vphaddubd(xmmA, anyptr_gpB);
+ e->vphaddubq(xmmA, xmmB);
+ e->vphaddubq(xmmA, anyptr_gpB);
+ e->vphaddubw(xmmA, xmmB);
+ e->vphaddubw(xmmA, anyptr_gpB);
+ e->vphaddudq(xmmA, xmmB);
+ e->vphaddudq(xmmA, anyptr_gpB);
+ e->vphadduwd(xmmA, xmmB);
+ e->vphadduwd(xmmA, anyptr_gpB);
+ e->vphadduwq(xmmA, xmmB);
+ e->vphadduwq(xmmA, anyptr_gpB);
+ e->vphsubbw(xmmA, xmmB);
+ e->vphsubbw(xmmA, anyptr_gpB);
+ e->vphsubdq(xmmA, xmmB);
+ e->vphsubdq(xmmA, anyptr_gpB);
+ e->vphsubwd(xmmA, xmmB);
+ e->vphsubwd(xmmA, anyptr_gpB);
+ e->vpmacsdd(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacsdd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacsdqh(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacsdqh(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacsdql(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacsdql(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacswd(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacswd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacsww(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacsww(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacssdd(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacssdd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacssdqh(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacssdqh(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacssdql(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacssdql(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacsswd(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacsswd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmacssww(xmmA, xmmB, xmmC, xmmD);
+ e->vpmacssww(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmadcsswd(xmmA, xmmB, xmmC, xmmD);
+ e->vpmadcsswd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpmadcswd(xmmA, xmmB, xmmC, xmmD);
+ e->vpmadcswd(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpperm(xmmA, xmmB, xmmC, xmmD);
+ e->vpperm(xmmA, xmmB, anyptr_gpC, xmmD);
+ e->vpperm(xmmA, xmmB, xmmC, anyptr_gpD);
+ e->vprotb(xmmA, xmmB, xmmC);
+ e->vprotb(xmmA, anyptr_gpB, xmmC);
+ e->vprotb(xmmA, xmmB, anyptr_gpC);
+ e->vprotb(xmmA, xmmB, 0);
+ e->vprotb(xmmA, anyptr_gpB, 0);
+ e->vprotd(xmmA, xmmB, xmmC);
+ e->vprotd(xmmA, anyptr_gpB, xmmC);
+ e->vprotd(xmmA, xmmB, anyptr_gpC);
+ e->vprotd(xmmA, xmmB, 0);
+ e->vprotd(xmmA, anyptr_gpB, 0);
+ e->vprotq(xmmA, xmmB, xmmC);
+ e->vprotq(xmmA, anyptr_gpB, xmmC);
+ e->vprotq(xmmA, xmmB, anyptr_gpC);
+ e->vprotq(xmmA, xmmB, 0);
+ e->vprotq(xmmA, anyptr_gpB, 0);
+ e->vprotw(xmmA, xmmB, xmmC);
+ e->vprotw(xmmA, anyptr_gpB, xmmC);
+ e->vprotw(xmmA, xmmB, anyptr_gpC);
+ e->vprotw(xmmA, xmmB, 0);
+ e->vprotw(xmmA, anyptr_gpB, 0);
+ e->vpshab(xmmA, xmmB, xmmC);
+ e->vpshab(xmmA, anyptr_gpB, xmmC);
+ e->vpshab(xmmA, xmmB, anyptr_gpC);
+ e->vpshad(xmmA, xmmB, xmmC);
+ e->vpshad(xmmA, anyptr_gpB, xmmC);
+ e->vpshad(xmmA, xmmB, anyptr_gpC);
+ e->vpshaq(xmmA, xmmB, xmmC);
+ e->vpshaq(xmmA, anyptr_gpB, xmmC);
+ e->vpshaq(xmmA, xmmB, anyptr_gpC);
+ e->vpshaw(xmmA, xmmB, xmmC);
+ e->vpshaw(xmmA, anyptr_gpB, xmmC);
+ e->vpshaw(xmmA, xmmB, anyptr_gpC);
+ e->vpshlb(xmmA, xmmB, xmmC);
+ e->vpshlb(xmmA, anyptr_gpB, xmmC);
+ e->vpshlb(xmmA, xmmB, anyptr_gpC);
+ e->vpshld(xmmA, xmmB, xmmC);
+ e->vpshld(xmmA, anyptr_gpB, xmmC);
+ e->vpshld(xmmA, xmmB, anyptr_gpC);
+ e->vpshlq(xmmA, xmmB, xmmC);
+ e->vpshlq(xmmA, anyptr_gpB, xmmC);
+ e->vpshlq(xmmA, xmmB, anyptr_gpC);
+ e->vpshlw(xmmA, xmmB, xmmC);
+ e->vpshlw(xmmA, anyptr_gpB, xmmC);
+ e->vpshlw(xmmA, xmmB, anyptr_gpC);
+
+ // F16C.
+ e->nop();
+
+ e->vcvtph2ps(xmmA, xmmB);
+ e->vcvtph2ps(xmmA, anyptr_gpB);
+ e->vcvtph2ps(ymmA, xmmB);
+ e->vcvtph2ps(ymmA, anyptr_gpB);
+ e->vcvtps2ph(xmmA, xmmB, 0);
+ e->vcvtps2ph(anyptr_gpA, xmmB, 0);
+ e->vcvtps2ph(xmmA, ymmB, 0);
+ e->vcvtps2ph(anyptr_gpA, ymmB, 0);
+
+ // AVX512.
+ e->nop();
+
+ e->kaddb(kA, kB, kC);
+ e->kaddd(kA, kB, kC);
+ e->kaddq(kA, kB, kC);
+ e->kaddw(kA, kB, kC);
+ e->kandb(kA, kB, kC);
+ e->kandd(kA, kB, kC);
+ e->kandnb(kA, kB, kC);
+ e->kandnd(kA, kB, kC);
+ e->kandnq(kA, kB, kC);
+ e->kandnw(kA, kB, kC);
+ e->kandq(kA, kB, kC);
+ e->kandw(kA, kB, kC);
+ e->kmovb(kA, kB);
+ e->kmovb(kA, anyptr_gpB);
+ e->kmovb(kA, gdB);
+ if (isX64) e->kmovb(kA, gzB);
+ e->kmovb(anyptr_gpA, kB);
+ e->kmovb(gdA, kB);
+ if (isX64) e->kmovb(gzA, kB);
+ e->kmovd(kA, kB);
+ e->kmovd(kA, anyptr_gpB);
+ e->kmovd(kA, gdB);
+ if (isX64) e->kmovd(kA, gzB);
+ e->kmovd(anyptr_gpA, kB);
+ e->kmovd(gdA, kB);
+ if (isX64) e->kmovd(gzA, kB);
+ e->kmovq(kA, kB);
+ e->kmovq(kA, anyptr_gpB);
+ if (isX64) e->kmovq(kA, gzB);
+ e->kmovq(anyptr_gpA, kB);
+ if (isX64) e->kmovq(gzA, kB);
+ e->kmovw(kA, kB);
+ e->kmovw(kA, anyptr_gpB);
+ e->kmovw(kA, gdB);
+ if (isX64) e->kmovw(kA, gzB);
+ e->kmovw(anyptr_gpA, kB);
+ e->kmovw(gdA, kB);
+ if (isX64) e->kmovw(gzA, kB);
+ e->knotb(kA, kB);
+ e->knotd(kA, kB);
+ e->knotq(kA, kB);
+ e->knotw(kA, kB);
+ e->korb(kA, kB, kC);
+ e->kord(kA, kB, kC);
+ e->korq(kA, kB, kC);
+ e->kortestb(kA, kB);
+ e->kortestd(kA, kB);
+ e->kortestq(kA, kB);
+ e->kortestw(kA, kB);
+ e->korw(kA, kB, kC);
+ e->kshiftlb(kA, kB, 0);
+ e->kshiftld(kA, kB, 0);
+ e->kshiftlq(kA, kB, 0);
+ e->kshiftlw(kA, kB, 0);
+ e->kshiftrb(kA, kB, 0);
+ e->kshiftrd(kA, kB, 0);
+ e->kshiftrq(kA, kB, 0);
+ e->kshiftrw(kA, kB, 0);
+ e->ktestb(kA, kB);
+ e->ktestd(kA, kB);
+ e->ktestq(kA, kB);
+ e->ktestw(kA, kB);
+ e->kunpckbw(kA, kB, kC);
+ e->kunpckdq(kA, kB, kC);
+ e->kunpckwd(kA, kB, kC);
+ e->kxnorb(kA, kB, kC);
+ e->kxnord(kA, kB, kC);
+ e->kxnorq(kA, kB, kC);
+ e->kxnorw(kA, kB, kC);
+ e->kxorb(kA, kB, kC);
+ e->kxord(kA, kB, kC);
+ e->kxorq(kA, kB, kC);
+ e->kxorw(kA, kB, kC);
+ e->nop();
+
+ e->vaddpd(xmmA, xmmB, xmmC);
+ e->vaddpd(xmmA, xmmB, anyptr_gpC);
+ e->vaddpd(ymmA, ymmB, ymmC);
+ e->vaddpd(ymmA, ymmB, anyptr_gpC);
+ e->vaddpd(zmmA, zmmB, zmmC);
+ e->vaddpd(zmmA, zmmB, anyptr_gpC);
+ e->vaddps(xmmA, xmmB, xmmC);
+ e->vaddps(xmmA, xmmB, anyptr_gpC);
+ e->vaddps(ymmA, ymmB, ymmC);
+ e->vaddps(ymmA, ymmB, anyptr_gpC);
+ e->vaddps(zmmA, zmmB, zmmC);
+ e->vaddps(zmmA, zmmB, anyptr_gpC);
+ e->vaddsd(xmmA, xmmB, xmmC);
+ e->vaddsd(xmmA, xmmB, anyptr_gpC);
+ e->vaddss(xmmA, xmmB, xmmC);
+ e->vaddss(xmmA, xmmB, anyptr_gpC);
+ e->valignd(xmmA, xmmB, xmmC, 0);
+ e->valignd(xmmA, xmmB, anyptr_gpC, 0);
+ e->valignd(ymmA, ymmB, ymmC, 0);
+ e->valignd(ymmA, ymmB, anyptr_gpC, 0);
+ e->valignd(zmmA, zmmB, zmmC, 0);
+ e->valignd(zmmA, zmmB, anyptr_gpC, 0);
+ e->valignq(xmmA, xmmB, xmmC, 0);
+ e->valignq(xmmA, xmmB, anyptr_gpC, 0);
+ e->valignq(ymmA, ymmB, ymmC, 0);
+ e->valignq(ymmA, ymmB, anyptr_gpC, 0);
+ e->valignq(zmmA, zmmB, zmmC, 0);
+ e->valignq(zmmA, zmmB, anyptr_gpC, 0);
+ e->vandnpd(xmmA, xmmB, xmmC);
+ e->vandnpd(xmmA, xmmB, anyptr_gpC);
+ e->vandnpd(ymmA, ymmB, ymmC);
+ e->vandnpd(ymmA, ymmB, anyptr_gpC);
+ e->vandnpd(zmmA, zmmB, zmmC);
+ e->vandnpd(zmmA, zmmB, anyptr_gpC);
+ e->vandnps(xmmA, xmmB, xmmC);
+ e->vandnps(xmmA, xmmB, anyptr_gpC);
+ e->vandnps(ymmA, ymmB, ymmC);
+ e->vandnps(ymmA, ymmB, anyptr_gpC);
+ e->vandnps(zmmA, zmmB, zmmC);
+ e->vandnps(zmmA, zmmB, anyptr_gpC);
+ e->vandpd(xmmA, xmmB, xmmC);
+ e->vandpd(xmmA, xmmB, anyptr_gpC);
+ e->vandpd(ymmA, ymmB, ymmC);
+ e->vandpd(ymmA, ymmB, anyptr_gpC);
+ e->vandpd(zmmA, zmmB, zmmC);
+ e->vandpd(zmmA, zmmB, anyptr_gpC);
+ e->vandps(xmmA, xmmB, xmmC);
+ e->vandps(xmmA, xmmB, anyptr_gpC);
+ e->vandps(ymmA, ymmB, ymmC);
+ e->vandps(ymmA, ymmB, anyptr_gpC);
+ e->vandps(zmmA, zmmB, zmmC);
+ e->vandps(zmmA, zmmB, anyptr_gpC);
+ e->vblendmb(xmmA, xmmB, xmmC);
+ e->vblendmb(xmmA, xmmB, anyptr_gpC);
+ e->vblendmb(ymmA, ymmB, ymmC);
+ e->vblendmb(ymmA, ymmB, anyptr_gpC);
+ e->vblendmb(zmmA, zmmB, zmmC);
+ e->vblendmb(zmmA, zmmB, anyptr_gpC);
+ e->vblendmd(xmmA, xmmB, xmmC);
+ e->vblendmd(xmmA, xmmB, anyptr_gpC);
+ e->vblendmd(ymmA, ymmB, ymmC);
+ e->vblendmd(ymmA, ymmB, anyptr_gpC);
+ e->vblendmd(zmmA, zmmB, zmmC);
+ e->vblendmd(zmmA, zmmB, anyptr_gpC);
+ e->vblendmpd(xmmA, xmmB, xmmC);
+ e->vblendmpd(xmmA, xmmB, anyptr_gpC);
+ e->vblendmpd(ymmA, ymmB, ymmC);
+ e->vblendmpd(ymmA, ymmB, anyptr_gpC);
+ e->vblendmpd(zmmA, zmmB, zmmC);
+ e->vblendmpd(zmmA, zmmB, anyptr_gpC);
+ e->vblendmps(xmmA, xmmB, xmmC);
+ e->vblendmps(xmmA, xmmB, anyptr_gpC);
+ e->vblendmps(ymmA, ymmB, ymmC);
+ e->vblendmps(ymmA, ymmB, anyptr_gpC);
+ e->vblendmps(zmmA, zmmB, zmmC);
+ e->vblendmps(zmmA, zmmB, anyptr_gpC);
+ e->vblendmq(xmmA, xmmB, xmmC);
+ e->vblendmq(xmmA, xmmB, anyptr_gpC);
+ e->vblendmq(ymmA, ymmB, ymmC);
+ e->vblendmq(ymmA, ymmB, anyptr_gpC);
+ e->vblendmq(zmmA, zmmB, zmmC);
+ e->vblendmq(zmmA, zmmB, anyptr_gpC);
+ e->vblendmw(xmmA, xmmB, xmmC);
+ e->vblendmw(xmmA, xmmB, anyptr_gpC);
+ e->vblendmw(ymmA, ymmB, ymmC);
+ e->vblendmw(ymmA, ymmB, anyptr_gpC);
+ e->vblendmw(zmmA, zmmB, zmmC);
+ e->vblendmw(zmmA, zmmB, anyptr_gpC);
+ e->vbroadcastf32x2(ymmA, xmmB);
+ e->vbroadcastf32x2(ymmA, anyptr_gpB);
+ e->vbroadcastf32x2(zmmA, xmmB);
+ e->vbroadcastf32x2(zmmA, anyptr_gpB);
+ e->vbroadcastf32x4(ymmA, anyptr_gpB);
+ e->vbroadcastf32x4(zmmA, anyptr_gpB);
+ e->vbroadcastf32x8(zmmA, anyptr_gpB);
+ e->vbroadcastf64x2(ymmA, anyptr_gpB);
+ e->vbroadcastf64x2(zmmA, anyptr_gpB);
+ e->vbroadcastf64x4(zmmA, anyptr_gpB);
+ e->vbroadcasti32x2(xmmA, xmmB);
+ e->vbroadcasti32x2(xmmA, anyptr_gpB);
+ e->vbroadcasti32x2(ymmA, xmmB);
+ e->vbroadcasti32x2(ymmA, anyptr_gpB);
+ e->vbroadcasti32x2(zmmA, xmmB);
+ e->vbroadcasti32x2(zmmA, anyptr_gpB);
+ e->vbroadcasti32x4(ymmA, anyptr_gpB);
+ e->vbroadcasti32x4(zmmA, anyptr_gpB);
+ e->vbroadcasti32x8(zmmA, anyptr_gpB);
+ e->vbroadcasti64x2(ymmA, anyptr_gpB);
+ e->vbroadcasti64x2(zmmA, anyptr_gpB);
+ e->vbroadcasti64x4(zmmA, anyptr_gpB);
+ e->vbroadcastsd(ymmA, xmmB);
+ e->vbroadcastsd(ymmA, anyptr_gpB);
+ e->vbroadcastsd(zmmA, xmmB);
+ e->vbroadcastsd(zmmA, anyptr_gpB);
+ e->vbroadcastss(xmmA, xmmB);
+ e->vbroadcastss(xmmA, anyptr_gpB);
+ e->vbroadcastss(ymmA, xmmB);
+ e->vbroadcastss(ymmA, anyptr_gpB);
+ e->vbroadcastss(zmmA, xmmB);
+ e->vbroadcastss(zmmA, anyptr_gpB);
+ e->vcmppd(kA, xmmB, xmmC, 0);
+ e->vcmppd(kA, xmmB, anyptr_gpC, 0);
+ e->vcmppd(kA, ymmB, ymmC, 0);
+ e->vcmppd(kA, ymmB, anyptr_gpC, 0);
+ e->vcmppd(kA, zmmB, zmmC, 0);
+ e->vcmppd(kA, zmmB, anyptr_gpC, 0);
+ e->vcmpps(kA, xmmB, xmmC, 0);
+ e->vcmpps(kA, xmmB, anyptr_gpC, 0);
+ e->vcmpps(kA, ymmB, ymmC, 0);
+ e->vcmpps(kA, ymmB, anyptr_gpC, 0);
+ e->vcmpps(kA, zmmB, zmmC, 0);
+ e->vcmpps(kA, zmmB, anyptr_gpC, 0);
+ e->vcmpsd(kA, xmmB, xmmC, 0);
+ e->vcmpsd(kA, xmmB, anyptr_gpC, 0);
+ e->vcmpss(kA, xmmB, xmmC, 0);
+ e->vcmpss(kA, xmmB, anyptr_gpC, 0);
+ e->vcomisd(xmmA, xmmB);
+ e->vcomisd(xmmA, anyptr_gpB);
+ e->vcomiss(xmmA, xmmB);
+ e->vcomiss(xmmA, anyptr_gpB);
+ e->vcompresspd(xmmA, xmmB);
+ e->vcompresspd(anyptr_gpA, xmmB);
+ e->vcompresspd(ymmA, ymmB);
+ e->vcompresspd(anyptr_gpA, ymmB);
+ e->vcompresspd(zmmA, zmmB);
+ e->vcompresspd(anyptr_gpA, zmmB);
+ e->vcompressps(xmmA, xmmB);
+ e->vcompressps(anyptr_gpA, xmmB);
+ e->vcompressps(ymmA, ymmB);
+ e->vcompressps(anyptr_gpA, ymmB);
+ e->vcompressps(zmmA, zmmB);
+ e->vcompressps(anyptr_gpA, zmmB);
+ e->vcvtdq2pd(xmmA, xmmB);
+ e->vcvtdq2pd(xmmA, anyptr_gpB);
+ e->vcvtdq2pd(ymmA, xmmB);
+ e->vcvtdq2pd(ymmA, anyptr_gpB);
+ e->vcvtdq2pd(zmmA, ymmB);
+ e->vcvtdq2pd(zmmA, anyptr_gpB);
+ e->vcvtdq2ps(xmmA, xmmB);
+ e->vcvtdq2ps(xmmA, anyptr_gpB);
+ e->vcvtdq2ps(ymmA, ymmB);
+ e->vcvtdq2ps(ymmA, anyptr_gpB);
+ e->vcvtdq2ps(zmmA, zmmB);
+ e->vcvtdq2ps(zmmA, anyptr_gpB);
+ e->vcvtpd2dq(xmmA, xmmB);
+ e->vcvtpd2dq(xmmA, anyptr_gpB);
+ e->vcvtpd2dq(xmmA, ymmB);
+ e->vcvtpd2dq(xmmA, anyptr_gpB);
+ e->vcvtpd2dq(ymmA, zmmB);
+ e->vcvtpd2dq(ymmA, anyptr_gpB);
+ e->vcvtpd2qq(xmmA, xmmB);
+ e->vcvtpd2qq(xmmA, anyptr_gpB);
+ e->vcvtpd2qq(ymmA, ymmB);
+ e->vcvtpd2qq(ymmA, anyptr_gpB);
+ e->vcvtpd2qq(zmmA, zmmB);
+ e->vcvtpd2qq(zmmA, anyptr_gpB);
+ e->vcvtpd2udq(xmmA, xmmB);
+ e->vcvtpd2udq(xmmA, anyptr_gpB);
+ e->vcvtpd2udq(xmmA, ymmB);
+ e->vcvtpd2udq(xmmA, anyptr_gpB);
+ e->vcvtpd2udq(ymmA, zmmB);
+ e->vcvtpd2udq(ymmA, anyptr_gpB);
+ e->vcvtpd2uqq(xmmA, xmmB);
+ e->vcvtpd2uqq(xmmA, anyptr_gpB);
+ e->vcvtpd2uqq(ymmA, ymmB);
+ e->vcvtpd2uqq(ymmA, anyptr_gpB);
+ e->vcvtpd2uqq(zmmA, zmmB);
+ e->vcvtpd2uqq(zmmA, anyptr_gpB);
+ e->vcvtph2ps(xmmA, xmmB);
+ e->vcvtph2ps(xmmA, anyptr_gpB);
+ e->vcvtph2ps(ymmA, xmmB);
+ e->vcvtph2ps(ymmA, anyptr_gpB);
+ e->vcvtph2ps(zmmA, ymmB);
+ e->vcvtph2ps(zmmA, anyptr_gpB);
+ e->vcvtps2dq(xmmA, xmmB);
+ e->vcvtps2dq(xmmA, anyptr_gpB);
+ e->vcvtps2dq(ymmA, ymmB);
+ e->vcvtps2dq(ymmA, anyptr_gpB);
+ e->vcvtps2dq(zmmA, zmmB);
+ e->vcvtps2dq(zmmA, anyptr_gpB);
+ e->vcvtps2pd(xmmA, xmmB);
+ e->vcvtps2pd(xmmA, anyptr_gpB);
+ e->vcvtps2pd(ymmA, xmmB);
+ e->vcvtps2pd(ymmA, anyptr_gpB);
+ e->vcvtps2pd(zmmA, ymmB);
+ e->vcvtps2pd(zmmA, anyptr_gpB);
+ e->vcvtps2ph(xmmA, xmmB, 0);
+ e->vcvtps2ph(anyptr_gpA, xmmB, 0);
+ e->vcvtps2ph(xmmA, ymmB, 0);
+ e->vcvtps2ph(anyptr_gpA, ymmB, 0);
+ e->vcvtps2ph(ymmA, zmmB, 0);
+ e->vcvtps2ph(anyptr_gpA, zmmB, 0);
+ e->vcvtps2qq(xmmA, xmmB);
+ e->vcvtps2qq(xmmA, anyptr_gpB);
+ e->vcvtps2qq(ymmA, xmmB);
+ e->vcvtps2qq(ymmA, anyptr_gpB);
+ e->vcvtps2qq(zmmA, ymmB);
+ e->vcvtps2qq(zmmA, anyptr_gpB);
+ e->vcvtps2udq(xmmA, xmmB);
+ e->vcvtps2udq(xmmA, anyptr_gpB);
+ e->vcvtps2udq(ymmA, ymmB);
+ e->vcvtps2udq(ymmA, anyptr_gpB);
+ e->vcvtps2udq(zmmA, zmmB);
+ e->vcvtps2udq(zmmA, anyptr_gpB);
+ e->vcvtps2uqq(xmmA, xmmB);
+ e->vcvtps2uqq(xmmA, anyptr_gpB);
+ e->vcvtps2uqq(ymmA, xmmB);
+ e->vcvtps2uqq(ymmA, anyptr_gpB);
+ e->vcvtps2uqq(zmmA, ymmB);
+ e->vcvtps2uqq(zmmA, anyptr_gpB);
+ e->vcvtqq2pd(xmmA, xmmB);
+ e->vcvtqq2pd(xmmA, anyptr_gpB);
+ e->vcvtqq2pd(ymmA, ymmB);
+ e->vcvtqq2pd(ymmA, anyptr_gpB);
+ e->vcvtqq2pd(zmmA, zmmB);
+ e->vcvtqq2pd(zmmA, anyptr_gpB);
+ e->vcvtqq2ps(xmmA, xmmB);
+ e->vcvtqq2ps(xmmA, anyptr_gpB);
+ e->vcvtqq2ps(xmmA, ymmB);
+ e->vcvtqq2ps(xmmA, anyptr_gpB);
+ e->vcvtqq2ps(ymmA, zmmB);
+ e->vcvtqq2ps(ymmA, anyptr_gpB);
+ e->vcvtsd2si(gdA, xmmB);
+ e->vcvtsd2si(gdA, anyptr_gpB);
+ if (isX64) e->vcvtsd2si(gzA, xmmB);
+ if (isX64) e->vcvtsd2si(gzA, anyptr_gpB);
+ e->vcvtsd2ss(xmmA, xmmB, xmmC);
+ e->vcvtsd2ss(xmmA, xmmB, anyptr_gpC);
+ e->vcvtsd2usi(gdA, xmmB);
+ e->vcvtsd2usi(gdA, anyptr_gpB);
+ if (isX64) e->vcvtsd2usi(gzA, xmmB);
+ if (isX64) e->vcvtsd2usi(gzA, anyptr_gpB);
+ e->vcvtsi2sd(xmmA, xmmB, gdC);
+ e->vcvtsi2sd(xmmA, xmmB, dword_ptr(gzC));
+ if (isX64) e->vcvtsi2sd(xmmA, xmmB, gzC);
+ if (isX64) e->vcvtsi2sd(xmmA, xmmB, qword_ptr(gzC));
+ e->vcvtsi2ss(xmmA, xmmB, gdC);
+ e->vcvtsi2ss(xmmA, xmmB, dword_ptr(gzC));
+ if (isX64) e->vcvtsi2ss(xmmA, xmmB, gzC);
+ if (isX64) e->vcvtsi2ss(xmmA, xmmB, qword_ptr(gzC));
+ e->vcvtss2sd(xmmA, xmmB, xmmC);
+ e->vcvtss2sd(xmmA, xmmB, anyptr_gpC);
+ e->vcvtss2si(gdA, xmmB);
+ e->vcvtss2si(gdA, anyptr_gpB);
+ if (isX64) e->vcvtss2si(gzA, xmmB);
+ if (isX64) e->vcvtss2si(gzA, anyptr_gpB);
+ e->vcvtss2usi(gdA, xmmB);
+ e->vcvtss2usi(gdA, anyptr_gpB);
+ if (isX64) e->vcvtss2usi(gzA, xmmB);
+ if (isX64) e->vcvtss2usi(gzA, anyptr_gpB);
+ e->vcvttpd2dq(xmmA, xmmB);
+ e->vcvttpd2dq(xmmA, anyptr_gpB);
+ e->vcvttpd2dq(xmmA, ymmB);
+ e->vcvttpd2dq(xmmA, anyptr_gpB);
+ e->vcvttpd2dq(ymmA, zmmB);
+ e->vcvttpd2dq(ymmA, anyptr_gpB);
+ e->vcvttpd2qq(xmmA, xmmB);
+ e->vcvttpd2qq(xmmA, anyptr_gpB);
+ e->vcvttpd2qq(ymmA, ymmB);
+ e->vcvttpd2qq(ymmA, anyptr_gpB);
+ e->vcvttpd2qq(zmmA, zmmB);
+ e->vcvttpd2qq(zmmA, anyptr_gpB);
+ e->vcvttpd2udq(xmmA, xmmB);
+ e->vcvttpd2udq(xmmA, anyptr_gpB);
+ e->vcvttpd2udq(xmmA, ymmB);
+ e->vcvttpd2udq(xmmA, anyptr_gpB);
+ e->vcvttpd2udq(ymmA, zmmB);
+ e->vcvttpd2udq(ymmA, anyptr_gpB);
+ e->vcvttpd2uqq(xmmA, xmmB);
+ e->vcvttpd2uqq(xmmA, anyptr_gpB);
+ e->vcvttpd2uqq(ymmA, ymmB);
+ e->vcvttpd2uqq(ymmA, anyptr_gpB);
+ e->vcvttpd2uqq(zmmA, zmmB);
+ e->vcvttpd2uqq(zmmA, anyptr_gpB);
+ e->vcvttps2dq(xmmA, xmmB);
+ e->vcvttps2dq(xmmA, anyptr_gpB);
+ e->vcvttps2dq(ymmA, ymmB);
+ e->vcvttps2dq(ymmA, anyptr_gpB);
+ e->vcvttps2dq(zmmA, zmmB);
+ e->vcvttps2dq(zmmA, anyptr_gpB);
+ e->vcvttps2qq(xmmA, xmmB);
+ e->vcvttps2qq(xmmA, anyptr_gpB);
+ e->vcvttps2qq(ymmA, xmmB);
+ e->vcvttps2qq(ymmA, anyptr_gpB);
+ e->vcvttps2qq(zmmA, ymmB);
+ e->vcvttps2qq(zmmA, anyptr_gpB);
+ e->vcvttps2udq(xmmA, xmmB);
+ e->vcvttps2udq(xmmA, anyptr_gpB);
+ e->vcvttps2udq(ymmA, ymmB);
+ e->vcvttps2udq(ymmA, anyptr_gpB);
+ e->vcvttps2udq(zmmA, zmmB);
+ e->vcvttps2udq(zmmA, anyptr_gpB);
+ e->vcvttps2uqq(xmmA, xmmB);
+ e->vcvttps2uqq(xmmA, anyptr_gpB);
+ e->vcvttps2uqq(ymmA, xmmB);
+ e->vcvttps2uqq(ymmA, anyptr_gpB);
+ e->vcvttps2uqq(zmmA, ymmB);
+ e->vcvttps2uqq(zmmA, anyptr_gpB);
+ e->vcvttsd2si(gdA, xmmB);
+ e->vcvttsd2si(gdA, anyptr_gpB);
+ if (isX64) e->vcvttsd2si(gzA, xmmB);
+ if (isX64) e->vcvttsd2si(gzA, anyptr_gpB);
+ e->vcvttsd2usi(gdA, xmmB);
+ e->vcvttsd2usi(gdA, anyptr_gpB);
+ if (isX64) e->vcvttsd2usi(gzA, xmmB);
+ if (isX64) e->vcvttsd2usi(gzA, anyptr_gpB);
+ e->vcvttss2si(gdA, xmmB);
+ e->vcvttss2si(gdA, anyptr_gpB);
+ if (isX64) e->vcvttss2si(gzA, xmmB);
+ if (isX64) e->vcvttss2si(gzA, anyptr_gpB);
+ e->vcvttss2usi(gdA, xmmB);
+ e->vcvttss2usi(gdA, anyptr_gpB);
+ if (isX64) e->vcvttss2usi(gzA, xmmB);
+ if (isX64) e->vcvttss2usi(gzA, anyptr_gpB);
+ e->vcvtudq2pd(xmmA, xmmB);
+ e->vcvtudq2pd(xmmA, anyptr_gpB);
+ e->vcvtudq2pd(ymmA, xmmB);
+ e->vcvtudq2pd(ymmA, anyptr_gpB);
+ e->vcvtudq2pd(zmmA, ymmB);
+ e->vcvtudq2pd(zmmA, anyptr_gpB);
+ e->vcvtudq2ps(xmmA, xmmB);
+ e->vcvtudq2ps(xmmA, anyptr_gpB);
+ e->vcvtudq2ps(ymmA, ymmB);
+ e->vcvtudq2ps(ymmA, anyptr_gpB);
+ e->vcvtudq2ps(zmmA, zmmB);
+ e->vcvtudq2ps(zmmA, anyptr_gpB);
+ e->vcvtuqq2pd(xmmA, xmmB);
+ e->vcvtuqq2pd(xmmA, anyptr_gpB);
+ e->vcvtuqq2pd(ymmA, ymmB);
+ e->vcvtuqq2pd(ymmA, anyptr_gpB);
+ e->vcvtuqq2pd(zmmA, zmmB);
+ e->vcvtuqq2pd(zmmA, anyptr_gpB);
+ e->vcvtuqq2ps(xmmA, xmmB);
+ e->vcvtuqq2ps(xmmA, anyptr_gpB);
+ e->vcvtuqq2ps(xmmA, ymmB);
+ e->vcvtuqq2ps(xmmA, anyptr_gpB);
+ e->vcvtuqq2ps(ymmA, zmmB);
+ e->vcvtuqq2ps(ymmA, anyptr_gpB);
+ e->vcvtusi2sd(xmmA, xmmB, gdC);
+ e->vcvtusi2sd(xmmA, xmmB, dword_ptr(gzC));
+ if (isX64) e->vcvtusi2sd(xmmA, xmmB, gzC);
+ if (isX64) e->vcvtusi2sd(xmmA, xmmB, qword_ptr(gzC));
+ e->vcvtusi2ss(xmmA, xmmB, gdC);
+ e->vcvtusi2ss(xmmA, xmmB, dword_ptr(gzC));
+ if (isX64) e->vcvtusi2ss(xmmA, xmmB, gzC);
+ if (isX64) e->vcvtusi2ss(xmmA, xmmB, qword_ptr(gzC));
+ e->vdbpsadbw(xmmA, xmmB, xmmC, 0);
+ e->vdbpsadbw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vdbpsadbw(ymmA, ymmB, ymmC, 0);
+ e->vdbpsadbw(ymmA, ymmB, anyptr_gpC, 0);
+ e->vdbpsadbw(zmmA, zmmB, zmmC, 0);
+ e->vdbpsadbw(zmmA, zmmB, anyptr_gpC, 0);
+ e->vdivpd(xmmA, xmmB, xmmC);
+ e->vdivpd(xmmA, xmmB, anyptr_gpC);
+ e->vdivpd(ymmA, ymmB, ymmC);
+ e->vdivpd(ymmA, ymmB, anyptr_gpC);
+ e->vdivpd(zmmA, zmmB, zmmC);
+ e->vdivpd(zmmA, zmmB, anyptr_gpC);
+ e->vdivps(xmmA, xmmB, xmmC);
+ e->vdivps(xmmA, xmmB, anyptr_gpC);
+ e->vdivps(ymmA, ymmB, ymmC);
+ e->vdivps(ymmA, ymmB, anyptr_gpC);
+ e->vdivps(zmmA, zmmB, zmmC);
+ e->vdivps(zmmA, zmmB, anyptr_gpC);
+ e->vdivsd(xmmA, xmmB, xmmC);
+ e->vdivsd(xmmA, xmmB, anyptr_gpC);
+ e->vdivss(xmmA, xmmB, xmmC);
+ e->vdivss(xmmA, xmmB, anyptr_gpC);
+ e->vexp2pd(zmmA, zmmB);
+ e->vexp2pd(zmmA, anyptr_gpB);
+ e->vexp2ps(zmmA, zmmB);
+ e->vexp2ps(zmmA, anyptr_gpB);
+ e->vexpandpd(xmmA, xmmB);
+ e->vexpandpd(xmmA, anyptr_gpB);
+ e->vexpandpd(ymmA, ymmB);
+ e->vexpandpd(ymmA, anyptr_gpB);
+ e->vexpandpd(zmmA, zmmB);
+ e->vexpandpd(zmmA, anyptr_gpB);
+ e->vexpandps(xmmA, xmmB);
+ e->vexpandps(xmmA, anyptr_gpB);
+ e->vexpandps(ymmA, ymmB);
+ e->vexpandps(ymmA, anyptr_gpB);
+ e->vexpandps(zmmA, zmmB);
+ e->vexpandps(zmmA, anyptr_gpB);
+ e->vextractf32x4(xmmA, ymmB, 0);
+ e->vextractf32x4(anyptr_gpA, ymmB, 0);
+ e->vextractf32x4(xmmA, zmmB, 0);
+ e->vextractf32x4(anyptr_gpA, zmmB, 0);
+ e->vextractf32x8(ymmA, zmmB, 0);
+ e->vextractf32x8(anyptr_gpA, zmmB, 0);
+ e->vextractf64x2(xmmA, ymmB, 0);
+ e->vextractf64x2(anyptr_gpA, ymmB, 0);
+ e->vextractf64x2(xmmA, zmmB, 0);
+ e->vextractf64x2(anyptr_gpA, zmmB, 0);
+ e->vextractf64x4(ymmA, zmmB, 0);
+ e->vextractf64x4(anyptr_gpA, zmmB, 0);
+ e->vextracti32x4(xmmA, ymmB, 0);
+ e->vextracti32x4(anyptr_gpA, ymmB, 0);
+ e->vextracti32x4(xmmA, zmmB, 0);
+ e->vextracti32x4(anyptr_gpA, zmmB, 0);
+ e->vextracti32x8(ymmA, zmmB, 0);
+ e->vextracti32x8(anyptr_gpA, zmmB, 0);
+ e->vextracti64x2(xmmA, ymmB, 0);
+ e->vextracti64x2(anyptr_gpA, ymmB, 0);
+ e->vextracti64x2(xmmA, zmmB, 0);
+ e->vextracti64x2(anyptr_gpA, zmmB, 0);
+ e->vextracti64x4(ymmA, zmmB, 0);
+ e->vextracti64x4(anyptr_gpA, zmmB, 0);
+ e->vextractps(gdA, xmmB, 0);
+ e->vextractps(gzA, xmmB, 0);
+ e->vextractps(anyptr_gpA, xmmB, 0);
+ e->vfixupimmpd(xmmA, xmmB, xmmC, 0);
+ e->vfixupimmpd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vfixupimmpd(ymmA, ymmB, ymmC, 0);
+ e->vfixupimmpd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vfixupimmpd(zmmA, zmmB, zmmC, 0);
+ e->vfixupimmpd(zmmA, zmmB, anyptr_gpC, 0);
+ e->vfixupimmps(xmmA, xmmB, xmmC, 0);
+ e->vfixupimmps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vfixupimmps(ymmA, ymmB, ymmC, 0);
+ e->vfixupimmps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vfixupimmps(zmmA, zmmB, zmmC, 0);
+ e->vfixupimmps(zmmA, zmmB, anyptr_gpC, 0);
+ e->vfixupimmsd(xmmA, xmmB, xmmC, 0);
+ e->vfixupimmsd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vfixupimmss(xmmA, xmmB, xmmC, 0);
+ e->vfixupimmss(xmmA, xmmB, anyptr_gpC, 0);
+ e->vfmadd132pd(xmmA, xmmB, xmmC);
+ e->vfmadd132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132pd(ymmA, ymmB, ymmC);
+ e->vfmadd132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd132pd(zmmA, zmmB, zmmC);
+ e->vfmadd132pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmadd132ps(xmmA, xmmB, xmmC);
+ e->vfmadd132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132ps(ymmA, ymmB, ymmC);
+ e->vfmadd132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd132ps(zmmA, zmmB, zmmC);
+ e->vfmadd132ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmadd132sd(xmmA, xmmB, xmmC);
+ e->vfmadd132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd132ss(xmmA, xmmB, xmmC);
+ e->vfmadd132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213pd(xmmA, xmmB, xmmC);
+ e->vfmadd213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213pd(ymmA, ymmB, ymmC);
+ e->vfmadd213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd213pd(zmmA, zmmB, zmmC);
+ e->vfmadd213pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmadd213ps(xmmA, xmmB, xmmC);
+ e->vfmadd213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213ps(ymmA, ymmB, ymmC);
+ e->vfmadd213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd213ps(zmmA, zmmB, zmmC);
+ e->vfmadd213ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmadd213sd(xmmA, xmmB, xmmC);
+ e->vfmadd213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd213ss(xmmA, xmmB, xmmC);
+ e->vfmadd213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231pd(xmmA, xmmB, xmmC);
+ e->vfmadd231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231pd(ymmA, ymmB, ymmC);
+ e->vfmadd231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd231pd(zmmA, zmmB, zmmC);
+ e->vfmadd231pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmadd231ps(xmmA, xmmB, xmmC);
+ e->vfmadd231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231ps(ymmA, ymmB, ymmC);
+ e->vfmadd231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmadd231ps(zmmA, zmmB, zmmC);
+ e->vfmadd231ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmadd231sd(xmmA, xmmB, xmmC);
+ e->vfmadd231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmadd231ss(xmmA, xmmB, xmmC);
+ e->vfmadd231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub132pd(xmmA, xmmB, xmmC);
+ e->vfmaddsub132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub132pd(ymmA, ymmB, ymmC);
+ e->vfmaddsub132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub132pd(zmmA, zmmB, zmmC);
+ e->vfmaddsub132pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmaddsub132ps(xmmA, xmmB, xmmC);
+ e->vfmaddsub132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub132ps(ymmA, ymmB, ymmC);
+ e->vfmaddsub132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub132ps(zmmA, zmmB, zmmC);
+ e->vfmaddsub132ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmaddsub213pd(xmmA, xmmB, xmmC);
+ e->vfmaddsub213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub213pd(ymmA, ymmB, ymmC);
+ e->vfmaddsub213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub213pd(zmmA, zmmB, zmmC);
+ e->vfmaddsub213pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmaddsub213ps(xmmA, xmmB, xmmC);
+ e->vfmaddsub213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub213ps(ymmA, ymmB, ymmC);
+ e->vfmaddsub213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub213ps(zmmA, zmmB, zmmC);
+ e->vfmaddsub213ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmaddsub231pd(xmmA, xmmB, xmmC);
+ e->vfmaddsub231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub231pd(ymmA, ymmB, ymmC);
+ e->vfmaddsub231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub231pd(zmmA, zmmB, zmmC);
+ e->vfmaddsub231pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmaddsub231ps(xmmA, xmmB, xmmC);
+ e->vfmaddsub231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmaddsub231ps(ymmA, ymmB, ymmC);
+ e->vfmaddsub231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmaddsub231ps(zmmA, zmmB, zmmC);
+ e->vfmaddsub231ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub132pd(xmmA, xmmB, xmmC);
+ e->vfmsub132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132pd(ymmA, ymmB, ymmC);
+ e->vfmsub132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub132pd(zmmA, zmmB, zmmC);
+ e->vfmsub132pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub132ps(xmmA, xmmB, xmmC);
+ e->vfmsub132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132ps(ymmA, ymmB, ymmC);
+ e->vfmsub132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub132ps(zmmA, zmmB, zmmC);
+ e->vfmsub132ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub132sd(xmmA, xmmB, xmmC);
+ e->vfmsub132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub132ss(xmmA, xmmB, xmmC);
+ e->vfmsub132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213pd(xmmA, xmmB, xmmC);
+ e->vfmsub213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213pd(ymmA, ymmB, ymmC);
+ e->vfmsub213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub213pd(zmmA, zmmB, zmmC);
+ e->vfmsub213pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub213ps(xmmA, xmmB, xmmC);
+ e->vfmsub213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213ps(ymmA, ymmB, ymmC);
+ e->vfmsub213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub213ps(zmmA, zmmB, zmmC);
+ e->vfmsub213ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub213sd(xmmA, xmmB, xmmC);
+ e->vfmsub213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub213ss(xmmA, xmmB, xmmC);
+ e->vfmsub213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231pd(xmmA, xmmB, xmmC);
+ e->vfmsub231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231pd(ymmA, ymmB, ymmC);
+ e->vfmsub231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub231pd(zmmA, zmmB, zmmC);
+ e->vfmsub231pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub231ps(xmmA, xmmB, xmmC);
+ e->vfmsub231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231ps(ymmA, ymmB, ymmC);
+ e->vfmsub231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsub231ps(zmmA, zmmB, zmmC);
+ e->vfmsub231ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmsub231sd(xmmA, xmmB, xmmC);
+ e->vfmsub231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsub231ss(xmmA, xmmB, xmmC);
+ e->vfmsub231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd132pd(xmmA, xmmB, xmmC);
+ e->vfmsubadd132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd132pd(ymmA, ymmB, ymmC);
+ e->vfmsubadd132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd132pd(zmmA, zmmB, zmmC);
+ e->vfmsubadd132pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmsubadd132ps(xmmA, xmmB, xmmC);
+ e->vfmsubadd132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd132ps(ymmA, ymmB, ymmC);
+ e->vfmsubadd132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd132ps(zmmA, zmmB, zmmC);
+ e->vfmsubadd132ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmsubadd213pd(xmmA, xmmB, xmmC);
+ e->vfmsubadd213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd213pd(ymmA, ymmB, ymmC);
+ e->vfmsubadd213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd213pd(zmmA, zmmB, zmmC);
+ e->vfmsubadd213pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmsubadd213ps(xmmA, xmmB, xmmC);
+ e->vfmsubadd213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd213ps(ymmA, ymmB, ymmC);
+ e->vfmsubadd213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd213ps(zmmA, zmmB, zmmC);
+ e->vfmsubadd213ps(zmmA, zmmB, anyptr_gpC);
+ e->vfmsubadd231pd(xmmA, xmmB, xmmC);
+ e->vfmsubadd231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd231pd(ymmA, ymmB, ymmC);
+ e->vfmsubadd231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd231pd(zmmA, zmmB, zmmC);
+ e->vfmsubadd231pd(zmmA, zmmB, anyptr_gpC);
+ e->vfmsubadd231ps(xmmA, xmmB, xmmC);
+ e->vfmsubadd231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfmsubadd231ps(ymmA, ymmB, ymmC);
+ e->vfmsubadd231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfmsubadd231ps(zmmA, zmmB, zmmC);
+ e->vfmsubadd231ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd132pd(xmmA, xmmB, xmmC);
+ e->vfnmadd132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132pd(ymmA, ymmB, ymmC);
+ e->vfnmadd132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd132pd(zmmA, zmmB, zmmC);
+ e->vfnmadd132pd(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd132ps(xmmA, xmmB, xmmC);
+ e->vfnmadd132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132ps(ymmA, ymmB, ymmC);
+ e->vfnmadd132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd132ps(zmmA, zmmB, zmmC);
+ e->vfnmadd132ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd132sd(xmmA, xmmB, xmmC);
+ e->vfnmadd132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd132ss(xmmA, xmmB, xmmC);
+ e->vfnmadd132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213pd(xmmA, xmmB, xmmC);
+ e->vfnmadd213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213pd(ymmA, ymmB, ymmC);
+ e->vfnmadd213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd213pd(zmmA, zmmB, zmmC);
+ e->vfnmadd213pd(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd213ps(xmmA, xmmB, xmmC);
+ e->vfnmadd213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213ps(ymmA, ymmB, ymmC);
+ e->vfnmadd213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd213ps(zmmA, zmmB, zmmC);
+ e->vfnmadd213ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd213sd(xmmA, xmmB, xmmC);
+ e->vfnmadd213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd213ss(xmmA, xmmB, xmmC);
+ e->vfnmadd213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231pd(xmmA, xmmB, xmmC);
+ e->vfnmadd231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231pd(ymmA, ymmB, ymmC);
+ e->vfnmadd231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd231pd(zmmA, zmmB, zmmC);
+ e->vfnmadd231pd(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd231ps(xmmA, xmmB, xmmC);
+ e->vfnmadd231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231ps(ymmA, ymmB, ymmC);
+ e->vfnmadd231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmadd231ps(zmmA, zmmB, zmmC);
+ e->vfnmadd231ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmadd231sd(xmmA, xmmB, xmmC);
+ e->vfnmadd231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmadd231ss(xmmA, xmmB, xmmC);
+ e->vfnmadd231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132pd(xmmA, xmmB, xmmC);
+ e->vfnmsub132pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132pd(ymmA, ymmB, ymmC);
+ e->vfnmsub132pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub132pd(zmmA, zmmB, zmmC);
+ e->vfnmsub132pd(zmmA, zmmB, anyptr_gpC);
+ e->vfnmsub132ps(xmmA, xmmB, xmmC);
+ e->vfnmsub132ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132ps(ymmA, ymmB, ymmC);
+ e->vfnmsub132ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub132ps(zmmA, zmmB, zmmC);
+ e->vfnmsub132ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmsub132sd(xmmA, xmmB, xmmC);
+ e->vfnmsub132sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub132ss(xmmA, xmmB, xmmC);
+ e->vfnmsub132ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213pd(xmmA, xmmB, xmmC);
+ e->vfnmsub213pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213pd(ymmA, ymmB, ymmC);
+ e->vfnmsub213pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub213pd(zmmA, zmmB, zmmC);
+ e->vfnmsub213pd(zmmA, zmmB, anyptr_gpC);
+ e->vfnmsub213ps(xmmA, xmmB, xmmC);
+ e->vfnmsub213ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213ps(ymmA, ymmB, ymmC);
+ e->vfnmsub213ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub213ps(zmmA, zmmB, zmmC);
+ e->vfnmsub213ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmsub213sd(xmmA, xmmB, xmmC);
+ e->vfnmsub213sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub213ss(xmmA, xmmB, xmmC);
+ e->vfnmsub213ss(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231pd(xmmA, xmmB, xmmC);
+ e->vfnmsub231pd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231pd(ymmA, ymmB, ymmC);
+ e->vfnmsub231pd(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub231pd(zmmA, zmmB, zmmC);
+ e->vfnmsub231pd(zmmA, zmmB, anyptr_gpC);
+ e->vfnmsub231ps(xmmA, xmmB, xmmC);
+ e->vfnmsub231ps(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231ps(ymmA, ymmB, ymmC);
+ e->vfnmsub231ps(ymmA, ymmB, anyptr_gpC);
+ e->vfnmsub231ps(zmmA, zmmB, zmmC);
+ e->vfnmsub231ps(zmmA, zmmB, anyptr_gpC);
+ e->vfnmsub231sd(xmmA, xmmB, xmmC);
+ e->vfnmsub231sd(xmmA, xmmB, anyptr_gpC);
+ e->vfnmsub231ss(xmmA, xmmB, xmmC);
+ e->vfnmsub231ss(xmmA, xmmB, anyptr_gpC);
+ e->vfpclasspd(kA, xmmB, 0);
+ e->vfpclasspd(kA, anyptr_gpB, 0);
+ e->vfpclasspd(kA, ymmB, 0);
+ e->vfpclasspd(kA, anyptr_gpB, 0);
+ e->vfpclasspd(kA, zmmB, 0);
+ e->vfpclasspd(kA, anyptr_gpB, 0);
+ e->vfpclassps(kA, xmmB, 0);
+ e->vfpclassps(kA, anyptr_gpB, 0);
+ e->vfpclassps(kA, ymmB, 0);
+ e->vfpclassps(kA, anyptr_gpB, 0);
+ e->vfpclassps(kA, zmmB, 0);
+ e->vfpclassps(kA, anyptr_gpB, 0);
+ e->vfpclasssd(kA, xmmB, 0);
+ e->vfpclasssd(kA, anyptr_gpB, 0);
+ e->vfpclassss(kA, xmmB, 0);
+ e->vfpclassss(kA, anyptr_gpB, 0);
+ e->vgatherdpd(xmmA, vx_ptr);
+ e->vgatherdpd(ymmA, vy_ptr);
+ e->vgatherdpd(zmmA, vz_ptr);
+ e->vgatherdps(xmmA, vx_ptr);
+ e->vgatherdps(ymmA, vy_ptr);
+ e->vgatherdps(zmmA, vz_ptr);
+ e->vgatherpf0dpd(vy_ptr);
+ e->vgatherpf0dps(vz_ptr);
+ e->vgatherpf0qpd(vz_ptr);
+ e->vgatherpf0qps(vz_ptr);
+ e->vgatherpf1dpd(vy_ptr);
+ e->vgatherpf1dps(vz_ptr);
+ e->vgatherpf1qpd(vz_ptr);
+ e->vgatherpf1qps(vz_ptr);
+ e->vgatherqpd(xmmA, vx_ptr);
+ e->vgatherqpd(ymmA, vy_ptr);
+ e->vgatherqpd(zmmA, vz_ptr);
+ e->vgatherqps(xmmA, vx_ptr);
+ e->vgatherqps(ymmA, vy_ptr);
+ e->vgatherqps(zmmA, vz_ptr);
+ e->vgetexppd(xmmA, xmmB);
+ e->vgetexppd(xmmA, anyptr_gpB);
+ e->vgetexppd(ymmA, ymmB);
+ e->vgetexppd(ymmA, anyptr_gpB);
+ e->vgetexppd(zmmA, zmmB);
+ e->vgetexppd(zmmA, anyptr_gpB);
+ e->vgetexpps(xmmA, xmmB);
+ e->vgetexpps(xmmA, anyptr_gpB);
+ e->vgetexpps(ymmA, ymmB);
+ e->vgetexpps(ymmA, anyptr_gpB);
+ e->vgetexpps(zmmA, zmmB);
+ e->vgetexpps(zmmA, anyptr_gpB);
+ e->vgetexpsd(xmmA, xmmB, xmmC);
+ e->vgetexpsd(xmmA, xmmB, anyptr_gpB);
+ e->vgetexpss(xmmA, xmmB, xmmC);
+ e->vgetexpss(xmmA, xmmB, anyptr_gpB);
+ e->vgetmantpd(xmmA, xmmB, 0);
+ e->vgetmantpd(xmmA, anyptr_gpB, 0);
+ e->vgetmantpd(ymmA, ymmB, 0);
+ e->vgetmantpd(ymmA, anyptr_gpB, 0);
+ e->vgetmantpd(zmmA, zmmB, 0);
+ e->vgetmantpd(zmmA, anyptr_gpB, 0);
+ e->vgetmantps(xmmA, xmmB, 0);
+ e->vgetmantps(xmmA, anyptr_gpB, 0);
+ e->vgetmantps(ymmA, ymmB, 0);
+ e->vgetmantps(ymmA, anyptr_gpB, 0);
+ e->vgetmantps(zmmA, zmmB, 0);
+ e->vgetmantps(zmmA, anyptr_gpB, 0);
+ e->vgetmantsd(xmmA, xmmB, xmmC, 0);
+ e->vgetmantsd(xmmA, xmmB, anyptr_gpB, 0);
+ e->vgetmantss(xmmA, xmmB, xmmC, 0);
+ e->vgetmantss(xmmA, xmmB, anyptr_gpB, 0);
+ e->vinsertf32x4(ymmA, ymmB, xmmC, 0);
+ e->vinsertf32x4(ymmA, ymmB, anyptr_gpC, 0);
+ e->vinsertf32x4(zmmA, zmmB, xmmC, 0);
+ e->vinsertf32x4(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinsertf32x8(zmmA, zmmB, ymmC, 0);
+ e->vinsertf32x8(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinsertf64x2(ymmA, ymmB, xmmC, 0);
+ e->vinsertf64x2(ymmA, ymmB, anyptr_gpC, 0);
+ e->vinsertf64x2(zmmA, zmmB, xmmC, 0);
+ e->vinsertf64x2(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinsertf64x4(zmmA, zmmB, ymmC, 0);
+ e->vinsertf64x4(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinserti32x4(ymmA, ymmB, xmmC, 0);
+ e->vinserti32x4(ymmA, ymmB, anyptr_gpC, 0);
+ e->vinserti32x4(zmmA, zmmB, xmmC, 0);
+ e->vinserti32x4(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinserti32x8(zmmA, zmmB, ymmC, 0);
+ e->vinserti32x8(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinserti64x2(ymmA, ymmB, xmmC, 0);
+ e->vinserti64x2(ymmA, ymmB, anyptr_gpC, 0);
+ e->vinserti64x2(zmmA, zmmB, xmmC, 0);
+ e->vinserti64x2(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinserti64x4(zmmA, zmmB, ymmC, 0);
+ e->vinserti64x4(zmmA, zmmB, anyptr_gpC, 0);
+ e->vinsertps(xmmA, xmmB, xmmC, 0);
+ e->vinsertps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vmaxpd(xmmA, xmmB, xmmC);
+ e->vmaxpd(xmmA, xmmB, anyptr_gpC);
+ e->vmaxpd(ymmA, ymmB, ymmC);
+ e->vmaxpd(ymmA, ymmB, anyptr_gpC);
+ e->vmaxpd(zmmA, zmmB, zmmC);
+ e->vmaxpd(zmmA, zmmB, anyptr_gpC);
+ e->vmaxps(xmmA, xmmB, xmmC);
+ e->vmaxps(xmmA, xmmB, anyptr_gpC);
+ e->vmaxps(ymmA, ymmB, ymmC);
+ e->vmaxps(ymmA, ymmB, anyptr_gpC);
+ e->vmaxps(zmmA, zmmB, zmmC);
+ e->vmaxps(zmmA, zmmB, anyptr_gpC);
+ e->vmaxsd(xmmA, xmmB, xmmC);
+ e->vmaxsd(xmmA, xmmB, anyptr_gpC);
+ e->vmaxss(xmmA, xmmB, xmmC);
+ e->vmaxss(xmmA, xmmB, anyptr_gpC);
+ e->vminpd(xmmA, xmmB, xmmC);
+ e->vminpd(xmmA, xmmB, anyptr_gpC);
+ e->vminpd(ymmA, ymmB, ymmC);
+ e->vminpd(ymmA, ymmB, anyptr_gpC);
+ e->vminpd(zmmA, zmmB, zmmC);
+ e->vminpd(zmmA, zmmB, anyptr_gpC);
+ e->vminps(xmmA, xmmB, xmmC);
+ e->vminps(xmmA, xmmB, anyptr_gpC);
+ e->vminps(ymmA, ymmB, ymmC);
+ e->vminps(ymmA, ymmB, anyptr_gpC);
+ e->vminps(zmmA, zmmB, zmmC);
+ e->vminps(zmmA, zmmB, anyptr_gpC);
+ e->vminsd(xmmA, xmmB, xmmC);
+ e->vminsd(xmmA, xmmB, anyptr_gpC);
+ e->vminss(xmmA, xmmB, xmmC);
+ e->vminss(xmmA, xmmB, anyptr_gpC);
+ e->vmovapd(xmmA, xmmB);
+ e->vmovapd(xmmA, anyptr_gpB);
+ e->vmovapd(xmmA, xmmB);
+ e->vmovapd(anyptr_gpA, xmmB);
+ e->vmovapd(ymmA, ymmB);
+ e->vmovapd(ymmA, anyptr_gpB);
+ e->vmovapd(ymmA, ymmB);
+ e->vmovapd(anyptr_gpA, ymmB);
+ e->vmovapd(zmmA, zmmB);
+ e->vmovapd(zmmA, anyptr_gpB);
+ e->vmovapd(zmmA, zmmB);
+ e->vmovapd(anyptr_gpA, zmmB);
+ e->vmovaps(xmmA, xmmB);
+ e->vmovaps(xmmA, anyptr_gpB);
+ e->vmovaps(xmmA, xmmB);
+ e->vmovaps(anyptr_gpA, xmmB);
+ e->vmovaps(ymmA, ymmB);
+ e->vmovaps(ymmA, anyptr_gpB);
+ e->vmovaps(ymmA, ymmB);
+ e->vmovaps(anyptr_gpA, ymmB);
+ e->vmovaps(zmmA, zmmB);
+ e->vmovaps(zmmA, anyptr_gpB);
+ e->vmovaps(zmmA, zmmB);
+ e->vmovaps(anyptr_gpA, zmmB);
+ e->vmovd(gdA, xmmB);
+ e->vmovd(gzA, xmmB);
+ e->vmovd(anyptr_gpA, xmmB);
+ e->vmovd(xmmA, gdB);
+ e->vmovd(xmmA, gzB);
+ e->vmovd(xmmA, anyptr_gpB);
+ e->vmovddup(xmmA, xmmB);
+ e->vmovddup(xmmA, anyptr_gpB);
+ e->vmovddup(ymmA, ymmB);
+ e->vmovddup(ymmA, anyptr_gpB);
+ e->vmovddup(zmmA, zmmB);
+ e->vmovddup(zmmA, anyptr_gpB);
+ e->vmovdqa32(xmmA, xmmB);
+ e->vmovdqa32(xmmA, anyptr_gpB);
+ e->vmovdqa32(xmmA, xmmB);
+ e->vmovdqa32(anyptr_gpA, xmmB);
+ e->vmovdqa32(ymmA, ymmB);
+ e->vmovdqa32(ymmA, anyptr_gpB);
+ e->vmovdqa32(ymmA, ymmB);
+ e->vmovdqa32(anyptr_gpA, ymmB);
+ e->vmovdqa32(zmmA, zmmB);
+ e->vmovdqa32(zmmA, anyptr_gpB);
+ e->vmovdqa32(zmmA, zmmB);
+ e->vmovdqa32(anyptr_gpA, zmmB);
+ e->vmovdqa64(xmmA, xmmB);
+ e->vmovdqa64(xmmA, anyptr_gpB);
+ e->vmovdqa64(xmmA, xmmB);
+ e->vmovdqa64(anyptr_gpA, xmmB);
+ e->vmovdqa64(ymmA, ymmB);
+ e->vmovdqa64(ymmA, anyptr_gpB);
+ e->vmovdqa64(ymmA, ymmB);
+ e->vmovdqa64(anyptr_gpA, ymmB);
+ e->vmovdqa64(zmmA, zmmB);
+ e->vmovdqa64(zmmA, anyptr_gpB);
+ e->vmovdqa64(zmmA, zmmB);
+ e->vmovdqa64(anyptr_gpA, zmmB);
+ e->vmovdqu16(xmmA, xmmB);
+ e->vmovdqu16(xmmA, anyptr_gpB);
+ e->vmovdqu16(xmmA, xmmB);
+ e->vmovdqu16(anyptr_gpA, xmmB);
+ e->vmovdqu16(ymmA, ymmB);
+ e->vmovdqu16(ymmA, anyptr_gpB);
+ e->vmovdqu16(ymmA, ymmB);
+ e->vmovdqu16(anyptr_gpA, ymmB);
+ e->vmovdqu16(zmmA, zmmB);
+ e->vmovdqu16(zmmA, anyptr_gpB);
+ e->vmovdqu16(zmmA, zmmB);
+ e->vmovdqu16(anyptr_gpA, zmmB);
+ e->vmovdqu32(xmmA, xmmB);
+ e->vmovdqu32(xmmA, anyptr_gpB);
+ e->vmovdqu32(xmmA, xmmB);
+ e->vmovdqu32(anyptr_gpA, xmmB);
+ e->vmovdqu32(ymmA, ymmB);
+ e->vmovdqu32(ymmA, anyptr_gpB);
+ e->vmovdqu32(ymmA, ymmB);
+ e->vmovdqu32(anyptr_gpA, ymmB);
+ e->vmovdqu32(zmmA, zmmB);
+ e->vmovdqu32(zmmA, anyptr_gpB);
+ e->vmovdqu32(zmmA, zmmB);
+ e->vmovdqu32(anyptr_gpA, zmmB);
+ e->vmovdqu64(xmmA, xmmB);
+ e->vmovdqu64(xmmA, anyptr_gpB);
+ e->vmovdqu64(xmmA, xmmB);
+ e->vmovdqu64(anyptr_gpA, xmmB);
+ e->vmovdqu64(ymmA, ymmB);
+ e->vmovdqu64(ymmA, anyptr_gpB);
+ e->vmovdqu64(ymmA, ymmB);
+ e->vmovdqu64(anyptr_gpA, ymmB);
+ e->vmovdqu64(zmmA, zmmB);
+ e->vmovdqu64(zmmA, anyptr_gpB);
+ e->vmovdqu64(zmmA, zmmB);
+ e->vmovdqu64(anyptr_gpA, zmmB);
+ e->vmovdqu8(xmmA, xmmB);
+ e->vmovdqu8(xmmA, anyptr_gpB);
+ e->vmovdqu8(xmmA, xmmB);
+ e->vmovdqu8(anyptr_gpA, xmmB);
+ e->vmovdqu8(ymmA, ymmB);
+ e->vmovdqu8(ymmA, anyptr_gpB);
+ e->vmovdqu8(ymmA, ymmB);
+ e->vmovdqu8(anyptr_gpA, ymmB);
+ e->vmovdqu8(zmmA, zmmB);
+ e->vmovdqu8(zmmA, anyptr_gpB);
+ e->vmovdqu8(zmmA, zmmB);
+ e->vmovdqu8(anyptr_gpA, zmmB);
+ e->vmovhlps(xmmA, xmmB, xmmC);
+ e->vmovhpd(anyptr_gpA, xmmB);
+ e->vmovhpd(xmmA, xmmB, anyptr_gpC);
+ e->vmovhps(anyptr_gpA, xmmB);
+ e->vmovhps(xmmA, xmmB, anyptr_gpC);
+ e->vmovlhps(xmmA, xmmB, xmmC);
+ e->vmovlpd(anyptr_gpA, xmmB);
+ e->vmovlpd(xmmA, xmmB, anyptr_gpC);
+ e->vmovlps(anyptr_gpA, xmmB);
+ e->vmovlps(xmmA, xmmB, anyptr_gpC);
+ e->vmovntdq(anyptr_gpA, xmmB);
+ e->vmovntdq(anyptr_gpA, ymmB);
+ e->vmovntdq(anyptr_gpA, zmmB);
+ e->vmovntdqa(xmmA, anyptr_gpB);
+ e->vmovntdqa(ymmA, anyptr_gpB);
+ e->vmovntdqa(zmmA, anyptr_gpB);
+ e->vmovntpd(anyptr_gpA, xmmB);
+ e->vmovntpd(anyptr_gpA, ymmB);
+ e->vmovntpd(anyptr_gpA, zmmB);
+ e->vmovntps(anyptr_gpA, xmmB);
+ e->vmovntps(anyptr_gpA, ymmB);
+ e->vmovntps(anyptr_gpA, zmmB);
+ if (isX64) e->vmovq(gzA, xmmB);
+ if (isX64) e->vmovq(xmmA, gzB);
+ e->vmovq(anyptr_gpA, xmmB);
+ e->vmovq(xmmA, anyptr_gpB);
+ e->vmovq(xmmA, xmmB);
+ e->vmovq(xmmA, anyptr_gpB);
+ e->vmovq(xmmA, xmmB);
+ e->vmovq(anyptr_gpA, xmmB);
+ e->vmovsd(anyptr_gpA, xmmB);
+ e->vmovsd(xmmA, anyptr_gpB);
+ e->vmovsd(xmmA, xmmB, xmmC);
+ e->vmovsd(xmmA, xmmB, xmmC);
+ e->vmovshdup(xmmA, xmmB);
+ e->vmovshdup(xmmA, anyptr_gpB);
+ e->vmovshdup(ymmA, ymmB);
+ e->vmovshdup(ymmA, anyptr_gpB);
+ e->vmovshdup(zmmA, zmmB);
+ e->vmovshdup(zmmA, anyptr_gpB);
+ e->vmovsldup(xmmA, xmmB);
+ e->vmovsldup(xmmA, anyptr_gpB);
+ e->vmovsldup(ymmA, ymmB);
+ e->vmovsldup(ymmA, anyptr_gpB);
+ e->vmovsldup(zmmA, zmmB);
+ e->vmovsldup(zmmA, anyptr_gpB);
+ e->vmovss(anyptr_gpA, xmmB);
+ e->vmovss(xmmA, anyptr_gpB);
+ e->vmovss(xmmA, xmmB, xmmC);
+ e->vmovss(xmmA, xmmB, xmmC);
+ e->vmovupd(xmmA, xmmB);
+ e->vmovupd(xmmA, anyptr_gpB);
+ e->vmovupd(xmmA, xmmB);
+ e->vmovupd(anyptr_gpA, xmmB);
+ e->vmovupd(ymmA, ymmB);
+ e->vmovupd(ymmA, anyptr_gpB);
+ e->vmovupd(ymmA, ymmB);
+ e->vmovupd(anyptr_gpA, ymmB);
+ e->vmovupd(zmmA, zmmB);
+ e->vmovupd(zmmA, anyptr_gpB);
+ e->vmovupd(zmmA, zmmB);
+ e->vmovupd(anyptr_gpA, zmmB);
+ e->vmovups(xmmA, xmmB);
+ e->vmovups(xmmA, anyptr_gpB);
+ e->vmovups(xmmA, xmmB);
+ e->vmovups(anyptr_gpA, xmmB);
+ e->vmovups(ymmA, ymmB);
+ e->vmovups(ymmA, anyptr_gpB);
+ e->vmovups(ymmA, ymmB);
+ e->vmovups(anyptr_gpA, ymmB);
+ e->vmovups(zmmA, zmmB);
+ e->vmovups(zmmA, anyptr_gpB);
+ e->vmovups(zmmA, zmmB);
+ e->vmovups(anyptr_gpA, zmmB);
+ e->vmulpd(xmmA, xmmB, xmmC);
+ e->vmulpd(xmmA, xmmB, anyptr_gpC);
+ e->vmulpd(ymmA, ymmB, ymmC);
+ e->vmulpd(ymmA, ymmB, anyptr_gpC);
+ e->vmulpd(zmmA, zmmB, zmmC);
+ e->vmulpd(zmmA, zmmB, anyptr_gpC);
+ e->vmulps(xmmA, xmmB, xmmC);
+ e->vmulps(xmmA, xmmB, anyptr_gpC);
+ e->vmulps(ymmA, ymmB, ymmC);
+ e->vmulps(ymmA, ymmB, anyptr_gpC);
+ e->vmulps(zmmA, zmmB, zmmC);
+ e->vmulps(zmmA, zmmB, anyptr_gpC);
+ e->vmulsd(xmmA, xmmB, xmmC);
+ e->vmulsd(xmmA, xmmB, anyptr_gpC);
+ e->vmulss(xmmA, xmmB, xmmC);
+ e->vmulss(xmmA, xmmB, anyptr_gpC);
+ e->vorpd(xmmA, xmmB, xmmC);
+ e->vorpd(xmmA, xmmB, anyptr_gpC);
+ e->vorpd(ymmA, ymmB, ymmC);
+ e->vorpd(ymmA, ymmB, anyptr_gpC);
+ e->vorpd(zmmA, zmmB, zmmC);
+ e->vorpd(zmmA, zmmB, anyptr_gpC);
+ e->vorps(xmmA, xmmB, xmmC);
+ e->vorps(xmmA, xmmB, anyptr_gpC);
+ e->vorps(ymmA, ymmB, ymmC);
+ e->vorps(ymmA, ymmB, anyptr_gpC);
+ e->vorps(zmmA, zmmB, zmmC);
+ e->vorps(zmmA, zmmB, anyptr_gpC);
+ e->vpabsb(xmmA, xmmB);
+ e->vpabsb(xmmA, anyptr_gpB);
+ e->vpabsb(ymmA, ymmB);
+ e->vpabsb(ymmA, anyptr_gpB);
+ e->vpabsb(zmmA, zmmB);
+ e->vpabsb(zmmA, anyptr_gpB);
+ e->vpabsd(xmmA, xmmB);
+ e->vpabsd(xmmA, anyptr_gpB);
+ e->vpabsd(ymmA, ymmB);
+ e->vpabsd(ymmA, anyptr_gpB);
+ e->vpabsd(zmmA, zmmB);
+ e->vpabsd(zmmA, anyptr_gpB);
+ e->vpabsq(xmmA, xmmB);
+ e->vpabsq(xmmA, anyptr_gpB);
+ e->vpabsq(ymmA, ymmB);
+ e->vpabsq(ymmA, anyptr_gpB);
+ e->vpabsq(zmmA, zmmB);
+ e->vpabsq(zmmA, anyptr_gpB);
+ e->vpabsw(xmmA, xmmB);
+ e->vpabsw(xmmA, anyptr_gpB);
+ e->vpabsw(ymmA, ymmB);
+ e->vpabsw(ymmA, anyptr_gpB);
+ e->vpabsw(zmmA, zmmB);
+ e->vpabsw(zmmA, anyptr_gpB);
+ e->vpackssdw(xmmA, xmmB, xmmC);
+ e->vpackssdw(xmmA, xmmB, anyptr_gpC);
+ e->vpackssdw(ymmA, ymmB, ymmC);
+ e->vpackssdw(ymmA, ymmB, anyptr_gpC);
+ e->vpackssdw(zmmA, zmmB, zmmC);
+ e->vpackssdw(zmmA, zmmB, anyptr_gpC);
+ e->vpacksswb(xmmA, xmmB, xmmC);
+ e->vpacksswb(xmmA, xmmB, anyptr_gpC);
+ e->vpacksswb(ymmA, ymmB, ymmC);
+ e->vpacksswb(ymmA, ymmB, anyptr_gpC);
+ e->vpacksswb(zmmA, zmmB, zmmC);
+ e->vpacksswb(zmmA, zmmB, anyptr_gpC);
+ e->vpackusdw(xmmA, xmmB, xmmC);
+ e->vpackusdw(xmmA, xmmB, anyptr_gpC);
+ e->vpackusdw(ymmA, ymmB, ymmC);
+ e->vpackusdw(ymmA, ymmB, anyptr_gpC);
+ e->vpackusdw(zmmA, zmmB, zmmC);
+ e->vpackusdw(zmmA, zmmB, anyptr_gpC);
+ e->vpackuswb(xmmA, xmmB, xmmC);
+ e->vpackuswb(xmmA, xmmB, anyptr_gpC);
+ e->vpackuswb(ymmA, ymmB, ymmC);
+ e->vpackuswb(ymmA, ymmB, anyptr_gpC);
+ e->vpackuswb(zmmA, zmmB, zmmC);
+ e->vpackuswb(zmmA, zmmB, anyptr_gpC);
+ e->vpaddb(xmmA, xmmB, xmmC);
+ e->vpaddb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddb(ymmA, ymmB, ymmC);
+ e->vpaddb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddb(zmmA, zmmB, zmmC);
+ e->vpaddb(zmmA, zmmB, anyptr_gpC);
+ e->vpaddd(xmmA, xmmB, xmmC);
+ e->vpaddd(xmmA, xmmB, anyptr_gpC);
+ e->vpaddd(ymmA, ymmB, ymmC);
+ e->vpaddd(ymmA, ymmB, anyptr_gpC);
+ e->vpaddd(zmmA, zmmB, zmmC);
+ e->vpaddd(zmmA, zmmB, anyptr_gpC);
+ e->vpaddq(xmmA, xmmB, xmmC);
+ e->vpaddq(xmmA, xmmB, anyptr_gpC);
+ e->vpaddq(ymmA, ymmB, ymmC);
+ e->vpaddq(ymmA, ymmB, anyptr_gpC);
+ e->vpaddq(zmmA, zmmB, zmmC);
+ e->vpaddq(zmmA, zmmB, anyptr_gpC);
+ e->vpaddsb(xmmA, xmmB, xmmC);
+ e->vpaddsb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddsb(ymmA, ymmB, ymmC);
+ e->vpaddsb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddsb(zmmA, zmmB, zmmC);
+ e->vpaddsb(zmmA, zmmB, anyptr_gpC);
+ e->vpaddsw(xmmA, xmmB, xmmC);
+ e->vpaddsw(xmmA, xmmB, anyptr_gpC);
+ e->vpaddsw(ymmA, ymmB, ymmC);
+ e->vpaddsw(ymmA, ymmB, anyptr_gpC);
+ e->vpaddsw(zmmA, zmmB, zmmC);
+ e->vpaddsw(zmmA, zmmB, anyptr_gpC);
+ e->vpaddusb(xmmA, xmmB, xmmC);
+ e->vpaddusb(xmmA, xmmB, anyptr_gpC);
+ e->vpaddusb(ymmA, ymmB, ymmC);
+ e->vpaddusb(ymmA, ymmB, anyptr_gpC);
+ e->vpaddusb(zmmA, zmmB, zmmC);
+ e->vpaddusb(zmmA, zmmB, anyptr_gpC);
+ e->vpaddusw(xmmA, xmmB, xmmC);
+ e->vpaddusw(xmmA, xmmB, anyptr_gpC);
+ e->vpaddusw(ymmA, ymmB, ymmC);
+ e->vpaddusw(ymmA, ymmB, anyptr_gpC);
+ e->vpaddusw(zmmA, zmmB, zmmC);
+ e->vpaddusw(zmmA, zmmB, anyptr_gpC);
+ e->vpaddw(xmmA, xmmB, xmmC);
+ e->vpaddw(xmmA, xmmB, anyptr_gpC);
+ e->vpaddw(ymmA, ymmB, ymmC);
+ e->vpaddw(ymmA, ymmB, anyptr_gpC);
+ e->vpaddw(zmmA, zmmB, zmmC);
+ e->vpaddw(zmmA, zmmB, anyptr_gpC);
+ e->vpalignr(xmmA, xmmB, xmmC, 0);
+ e->vpalignr(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpalignr(ymmA, ymmB, ymmC, 0);
+ e->vpalignr(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpalignr(zmmA, zmmB, zmmC, 0);
+ e->vpalignr(zmmA, zmmB, anyptr_gpC, 0);
+ e->vpandd(xmmA, xmmB, xmmC);
+ e->vpandd(xmmA, xmmB, anyptr_gpC);
+ e->vpandd(ymmA, ymmB, ymmC);
+ e->vpandd(ymmA, ymmB, anyptr_gpC);
+ e->vpandd(zmmA, zmmB, zmmC);
+ e->vpandd(zmmA, zmmB, anyptr_gpC);
+ e->vpandnd(xmmA, xmmB, xmmC);
+ e->vpandnd(xmmA, xmmB, anyptr_gpC);
+ e->vpandnd(ymmA, ymmB, ymmC);
+ e->vpandnd(ymmA, ymmB, anyptr_gpC);
+ e->vpandnd(zmmA, zmmB, zmmC);
+ e->vpandnd(zmmA, zmmB, anyptr_gpC);
+ e->vpandnq(xmmA, xmmB, xmmC);
+ e->vpandnq(xmmA, xmmB, anyptr_gpC);
+ e->vpandnq(ymmA, ymmB, ymmC);
+ e->vpandnq(ymmA, ymmB, anyptr_gpC);
+ e->vpandnq(zmmA, zmmB, zmmC);
+ e->vpandnq(zmmA, zmmB, anyptr_gpC);
+ e->vpandq(xmmA, xmmB, xmmC);
+ e->vpandq(xmmA, xmmB, anyptr_gpC);
+ e->vpandq(ymmA, ymmB, ymmC);
+ e->vpandq(ymmA, ymmB, anyptr_gpC);
+ e->vpandq(zmmA, zmmB, zmmC);
+ e->vpandq(zmmA, zmmB, anyptr_gpC);
+ e->vpavgb(xmmA, xmmB, xmmC);
+ e->vpavgb(xmmA, xmmB, anyptr_gpC);
+ e->vpavgb(ymmA, ymmB, ymmC);
+ e->vpavgb(ymmA, ymmB, anyptr_gpC);
+ e->vpavgb(zmmA, zmmB, zmmC);
+ e->vpavgb(zmmA, zmmB, anyptr_gpC);
+ e->vpavgw(xmmA, xmmB, xmmC);
+ e->vpavgw(xmmA, xmmB, anyptr_gpC);
+ e->vpavgw(ymmA, ymmB, ymmC);
+ e->vpavgw(ymmA, ymmB, anyptr_gpC);
+ e->vpavgw(zmmA, zmmB, zmmC);
+ e->vpavgw(zmmA, zmmB, anyptr_gpC);
+ e->vpbroadcastb(xmmA, gdB);
+ e->vpbroadcastb(xmmA, gzB);
+ e->vpbroadcastb(xmmA, xmmB);
+ e->vpbroadcastb(xmmA, anyptr_gpB);
+ e->vpbroadcastb(ymmA, gdB);
+ e->vpbroadcastb(ymmA, gzB);
+ e->vpbroadcastb(ymmA, xmmB);
+ e->vpbroadcastb(ymmA, anyptr_gpB);
+ e->vpbroadcastb(zmmA, gdB);
+ e->vpbroadcastb(zmmA, gzB);
+ e->vpbroadcastb(zmmA, xmmB);
+ e->vpbroadcastb(zmmA, anyptr_gpB);
+ e->vpbroadcastd(xmmA, gdB);
+ e->vpbroadcastd(xmmA, gzB);
+ e->vpbroadcastd(xmmA, xmmB);
+ e->vpbroadcastd(xmmA, anyptr_gpB);
+ e->vpbroadcastd(ymmA, gdB);
+ e->vpbroadcastd(ymmA, gzB);
+ e->vpbroadcastd(ymmA, xmmB);
+ e->vpbroadcastd(ymmA, anyptr_gpB);
+ e->vpbroadcastd(zmmA, gdB);
+ e->vpbroadcastd(zmmA, gzB);
+ e->vpbroadcastd(zmmA, xmmB);
+ e->vpbroadcastd(zmmA, anyptr_gpB);
+ e->vpbroadcastmb2d(xmmA, kB);
+ e->vpbroadcastmb2d(ymmA, kB);
+ e->vpbroadcastmb2d(zmmA, kB);
+ e->vpbroadcastmb2q(xmmA, kB);
+ e->vpbroadcastmb2q(ymmA, kB);
+ e->vpbroadcastmb2q(zmmA, kB);
+ if (isX64) e->vpbroadcastq(xmmA, gzB);
+ e->vpbroadcastq(xmmA, xmmB);
+ e->vpbroadcastq(xmmA, anyptr_gpB);
+ if (isX64) e->vpbroadcastq(ymmA, gzB);
+ e->vpbroadcastq(ymmA, xmmB);
+ e->vpbroadcastq(ymmA, anyptr_gpB);
+ if (isX64) e->vpbroadcastq(zmmA, gzB);
+ e->vpbroadcastq(zmmA, xmmB);
+ e->vpbroadcastq(zmmA, anyptr_gpB);
+ e->vpbroadcastw(xmmA, gdB);
+ e->vpbroadcastw(xmmA, gzB);
+ e->vpbroadcastw(xmmA, xmmB);
+ e->vpbroadcastw(xmmA, anyptr_gpB);
+ e->vpbroadcastw(ymmA, gdB);
+ e->vpbroadcastw(ymmA, gzB);
+ e->vpbroadcastw(ymmA, xmmB);
+ e->vpbroadcastw(ymmA, anyptr_gpB);
+ e->vpbroadcastw(zmmA, gdB);
+ e->vpbroadcastw(zmmA, gzB);
+ e->vpbroadcastw(zmmA, xmmB);
+ e->vpbroadcastw(zmmA, anyptr_gpB);
+ e->vpcmpb(kA, xmmB, xmmC, 0);
+ e->vpcmpb(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpb(kA, ymmB, ymmC, 0);
+ e->vpcmpb(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpb(kA, zmmB, zmmC, 0);
+ e->vpcmpb(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpd(kA, xmmB, xmmC, 0);
+ e->vpcmpd(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpd(kA, ymmB, ymmC, 0);
+ e->vpcmpd(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpd(kA, zmmB, zmmC, 0);
+ e->vpcmpd(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpeqb(kA, xmmB, xmmC);
+ e->vpcmpeqb(kA, xmmB, anyptr_gpC);
+ e->vpcmpeqb(kA, ymmB, ymmC);
+ e->vpcmpeqb(kA, ymmB, anyptr_gpC);
+ e->vpcmpeqb(kA, zmmB, zmmC);
+ e->vpcmpeqb(kA, zmmB, anyptr_gpC);
+ e->vpcmpeqd(kA, xmmB, xmmC);
+ e->vpcmpeqd(kA, xmmB, anyptr_gpC);
+ e->vpcmpeqd(kA, ymmB, ymmC);
+ e->vpcmpeqd(kA, ymmB, anyptr_gpC);
+ e->vpcmpeqd(kA, zmmB, zmmC);
+ e->vpcmpeqd(kA, zmmB, anyptr_gpC);
+ e->vpcmpeqq(kA, xmmB, xmmC);
+ e->vpcmpeqq(kA, xmmB, anyptr_gpC);
+ e->vpcmpeqq(kA, ymmB, ymmC);
+ e->vpcmpeqq(kA, ymmB, anyptr_gpC);
+ e->vpcmpeqq(kA, zmmB, zmmC);
+ e->vpcmpeqq(kA, zmmB, anyptr_gpC);
+ e->vpcmpeqw(kA, xmmB, xmmC);
+ e->vpcmpeqw(kA, xmmB, anyptr_gpC);
+ e->vpcmpeqw(kA, ymmB, ymmC);
+ e->vpcmpeqw(kA, ymmB, anyptr_gpC);
+ e->vpcmpeqw(kA, zmmB, zmmC);
+ e->vpcmpeqw(kA, zmmB, anyptr_gpC);
+ e->vpcmpgtb(kA, xmmB, xmmC);
+ e->vpcmpgtb(kA, xmmB, anyptr_gpC);
+ e->vpcmpgtb(kA, ymmB, ymmC);
+ e->vpcmpgtb(kA, ymmB, anyptr_gpC);
+ e->vpcmpgtb(kA, zmmB, zmmC);
+ e->vpcmpgtb(kA, zmmB, anyptr_gpC);
+ e->vpcmpgtd(kA, xmmB, xmmC);
+ e->vpcmpgtd(kA, xmmB, anyptr_gpC);
+ e->vpcmpgtd(kA, ymmB, ymmC);
+ e->vpcmpgtd(kA, ymmB, anyptr_gpC);
+ e->vpcmpgtd(kA, zmmB, zmmC);
+ e->vpcmpgtd(kA, zmmB, anyptr_gpC);
+ e->vpcmpgtq(kA, xmmB, xmmC);
+ e->vpcmpgtq(kA, xmmB, anyptr_gpC);
+ e->vpcmpgtq(kA, ymmB, ymmC);
+ e->vpcmpgtq(kA, ymmB, anyptr_gpC);
+ e->vpcmpgtq(kA, zmmB, zmmC);
+ e->vpcmpgtq(kA, zmmB, anyptr_gpC);
+ e->vpcmpgtw(kA, xmmB, xmmC);
+ e->vpcmpgtw(kA, xmmB, anyptr_gpC);
+ e->vpcmpgtw(kA, ymmB, ymmC);
+ e->vpcmpgtw(kA, ymmB, anyptr_gpC);
+ e->vpcmpgtw(kA, zmmB, zmmC);
+ e->vpcmpgtw(kA, zmmB, anyptr_gpC);
+ e->vpcmpq(kA, xmmB, xmmC, 0);
+ e->vpcmpq(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpq(kA, ymmB, ymmC, 0);
+ e->vpcmpq(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpq(kA, zmmB, zmmC, 0);
+ e->vpcmpq(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpub(kA, xmmB, xmmC, 0);
+ e->vpcmpub(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpub(kA, ymmB, ymmC, 0);
+ e->vpcmpub(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpub(kA, zmmB, zmmC, 0);
+ e->vpcmpub(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpud(kA, xmmB, xmmC, 0);
+ e->vpcmpud(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpud(kA, ymmB, ymmC, 0);
+ e->vpcmpud(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpud(kA, zmmB, zmmC, 0);
+ e->vpcmpud(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpuq(kA, xmmB, xmmC, 0);
+ e->vpcmpuq(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpuq(kA, ymmB, ymmC, 0);
+ e->vpcmpuq(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpuq(kA, zmmB, zmmC, 0);
+ e->vpcmpuq(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpuw(kA, xmmB, xmmC, 0);
+ e->vpcmpuw(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpuw(kA, ymmB, ymmC, 0);
+ e->vpcmpuw(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpuw(kA, zmmB, zmmC, 0);
+ e->vpcmpuw(kA, zmmB, anyptr_gpC, 0);
+ e->vpcmpw(kA, xmmB, xmmC, 0);
+ e->vpcmpw(kA, xmmB, anyptr_gpC, 0);
+ e->vpcmpw(kA, ymmB, ymmC, 0);
+ e->vpcmpw(kA, ymmB, anyptr_gpC, 0);
+ e->vpcmpw(kA, zmmB, zmmC, 0);
+ e->vpcmpw(kA, zmmB, anyptr_gpC, 0);
+ e->vpcompressd(xmmA, xmmB);
+ e->vpcompressd(anyptr_gpA, xmmB);
+ e->vpcompressd(ymmA, ymmB);
+ e->vpcompressd(anyptr_gpA, ymmB);
+ e->vpcompressd(zmmA, zmmB);
+ e->vpcompressd(anyptr_gpA, zmmB);
+ e->vpcompressq(xmmA, xmmB);
+ e->vpcompressq(anyptr_gpA, xmmB);
+ e->vpcompressq(ymmA, ymmB);
+ e->vpcompressq(anyptr_gpA, ymmB);
+ e->vpcompressq(zmmA, zmmB);
+ e->vpcompressq(anyptr_gpA, zmmB);
+ e->vpconflictd(xmmA, xmmB);
+ e->vpconflictd(xmmA, anyptr_gpB);
+ e->vpconflictd(ymmA, ymmB);
+ e->vpconflictd(ymmA, anyptr_gpB);
+ e->vpconflictd(zmmA, zmmB);
+ e->vpconflictd(zmmA, anyptr_gpB);
+ e->vpconflictq(xmmA, xmmB);
+ e->vpconflictq(xmmA, anyptr_gpB);
+ e->vpconflictq(ymmA, ymmB);
+ e->vpconflictq(ymmA, anyptr_gpB);
+ e->vpconflictq(zmmA, zmmB);
+ e->vpconflictq(zmmA, anyptr_gpB);
+ e->vpermb(xmmA, xmmB, xmmC);
+ e->vpermb(xmmA, xmmB, anyptr_gpC);
+ e->vpermb(ymmA, ymmB, ymmC);
+ e->vpermb(ymmA, ymmB, anyptr_gpC);
+ e->vpermb(zmmA, zmmB, zmmC);
+ e->vpermb(zmmA, zmmB, anyptr_gpC);
+ e->vpermd(ymmA, ymmB, ymmC);
+ e->vpermd(ymmA, ymmB, anyptr_gpC);
+ e->vpermd(zmmA, zmmB, zmmC);
+ e->vpermd(zmmA, zmmB, anyptr_gpC);
+ e->vpermi2b(xmmA, xmmB, xmmC);
+ e->vpermi2b(xmmA, xmmB, anyptr_gpC);
+ e->vpermi2b(ymmA, ymmB, ymmC);
+ e->vpermi2b(ymmA, ymmB, anyptr_gpC);
+ e->vpermi2b(zmmA, zmmB, zmmC);
+ e->vpermi2b(zmmA, zmmB, anyptr_gpC);
+ e->vpermi2d(xmmA, xmmB, xmmC);
+ e->vpermi2d(xmmA, xmmB, anyptr_gpC);
+ e->vpermi2d(ymmA, ymmB, ymmC);
+ e->vpermi2d(ymmA, ymmB, anyptr_gpC);
+ e->vpermi2d(zmmA, zmmB, zmmC);
+ e->vpermi2d(zmmA, zmmB, anyptr_gpC);
+ e->vpermi2pd(xmmA, xmmB, xmmC);
+ e->vpermi2pd(xmmA, xmmB, anyptr_gpC);
+ e->vpermi2pd(ymmA, ymmB, ymmC);
+ e->vpermi2pd(ymmA, ymmB, anyptr_gpC);
+ e->vpermi2pd(zmmA, zmmB, zmmC);
+ e->vpermi2pd(zmmA, zmmB, anyptr_gpC);
+ e->vpermi2ps(xmmA, xmmB, xmmC);
+ e->vpermi2ps(xmmA, xmmB, anyptr_gpC);
+ e->vpermi2ps(ymmA, ymmB, ymmC);
+ e->vpermi2ps(ymmA, ymmB, anyptr_gpC);
+ e->vpermi2ps(zmmA, zmmB, zmmC);
+ e->vpermi2ps(zmmA, zmmB, anyptr_gpC);
+ e->vpermi2q(xmmA, xmmB, xmmC);
+ e->vpermi2q(xmmA, xmmB, anyptr_gpC);
+ e->vpermi2q(ymmA, ymmB, ymmC);
+ e->vpermi2q(ymmA, ymmB, anyptr_gpC);
+ e->vpermi2q(zmmA, zmmB, zmmC);
+ e->vpermi2q(zmmA, zmmB, anyptr_gpC);
+ e->vpermi2w(xmmA, xmmB, xmmC);
+ e->vpermi2w(xmmA, xmmB, anyptr_gpC);
+ e->vpermi2w(ymmA, ymmB, ymmC);
+ e->vpermi2w(ymmA, ymmB, anyptr_gpC);
+ e->vpermi2w(zmmA, zmmB, zmmC);
+ e->vpermi2w(zmmA, zmmB, anyptr_gpC);
+ e->vpermilpd(xmmA, xmmB, xmmC);
+ e->vpermilpd(xmmA, xmmB, anyptr_gpC);
+ e->vpermilpd(ymmA, ymmB, ymmC);
+ e->vpermilpd(ymmA, ymmB, anyptr_gpC);
+ e->vpermilpd(zmmA, zmmB, zmmC);
+ e->vpermilpd(zmmA, zmmB, anyptr_gpC);
+ e->vpermilpd(xmmA, xmmB, 0);
+ e->vpermilpd(xmmA, anyptr_gpB, 0);
+ e->vpermilpd(ymmA, ymmB, 0);
+ e->vpermilpd(ymmA, anyptr_gpB, 0);
+ e->vpermilpd(zmmA, zmmB, 0);
+ e->vpermilpd(zmmA, anyptr_gpB, 0);
+ e->vpermilps(xmmA, xmmB, xmmC);
+ e->vpermilps(xmmA, xmmB, anyptr_gpC);
+ e->vpermilps(ymmA, ymmB, ymmC);
+ e->vpermilps(ymmA, ymmB, anyptr_gpC);
+ e->vpermilps(zmmA, zmmB, zmmC);
+ e->vpermilps(zmmA, zmmB, anyptr_gpC);
+ e->vpermilps(xmmA, xmmB, 0);
+ e->vpermilps(xmmA, anyptr_gpB, 0);
+ e->vpermilps(ymmA, ymmB, 0);
+ e->vpermilps(ymmA, anyptr_gpB, 0);
+ e->vpermilps(zmmA, zmmB, 0);
+ e->vpermilps(zmmA, anyptr_gpB, 0);
+ e->vpermq(ymmA, ymmB, ymmC);
+ e->vpermq(ymmA, ymmB, anyptr_gpC);
+ e->vpermq(zmmA, zmmB, zmmC);
+ e->vpermq(zmmA, zmmB, anyptr_gpC);
+ e->vpermq(ymmA, ymmB, 0);
+ e->vpermq(ymmA, anyptr_gpB, 0);
+ e->vpermq(zmmA, zmmB, 0);
+ e->vpermq(zmmA, anyptr_gpB, 0);
+ e->vpermt2b(xmmA, xmmB, xmmC);
+ e->vpermt2b(xmmA, xmmB, anyptr_gpC);
+ e->vpermt2b(ymmA, ymmB, ymmC);
+ e->vpermt2b(ymmA, ymmB, anyptr_gpC);
+ e->vpermt2b(zmmA, zmmB, zmmC);
+ e->vpermt2b(zmmA, zmmB, anyptr_gpC);
+ e->vpermt2d(xmmA, xmmB, xmmC);
+ e->vpermt2d(xmmA, xmmB, anyptr_gpC);
+ e->vpermt2d(ymmA, ymmB, ymmC);
+ e->vpermt2d(ymmA, ymmB, anyptr_gpC);
+ e->vpermt2d(zmmA, zmmB, zmmC);
+ e->vpermt2d(zmmA, zmmB, anyptr_gpC);
+ e->vpermt2pd(xmmA, xmmB, xmmC);
+ e->vpermt2pd(xmmA, xmmB, anyptr_gpC);
+ e->vpermt2pd(ymmA, ymmB, ymmC);
+ e->vpermt2pd(ymmA, ymmB, anyptr_gpC);
+ e->vpermt2pd(zmmA, zmmB, zmmC);
+ e->vpermt2pd(zmmA, zmmB, anyptr_gpC);
+ e->vpermt2ps(xmmA, xmmB, xmmC);
+ e->vpermt2ps(xmmA, xmmB, anyptr_gpC);
+ e->vpermt2ps(ymmA, ymmB, ymmC);
+ e->vpermt2ps(ymmA, ymmB, anyptr_gpC);
+ e->vpermt2ps(zmmA, zmmB, zmmC);
+ e->vpermt2ps(zmmA, zmmB, anyptr_gpC);
+ e->vpermt2q(xmmA, xmmB, xmmC);
+ e->vpermt2q(xmmA, xmmB, anyptr_gpC);
+ e->vpermt2q(ymmA, ymmB, ymmC);
+ e->vpermt2q(ymmA, ymmB, anyptr_gpC);
+ e->vpermt2q(zmmA, zmmB, zmmC);
+ e->vpermt2q(zmmA, zmmB, anyptr_gpC);
+ e->vpermt2w(xmmA, xmmB, xmmC);
+ e->vpermt2w(xmmA, xmmB, anyptr_gpC);
+ e->vpermt2w(ymmA, ymmB, ymmC);
+ e->vpermt2w(ymmA, ymmB, anyptr_gpC);
+ e->vpermt2w(zmmA, zmmB, zmmC);
+ e->vpermt2w(zmmA, zmmB, anyptr_gpC);
+ e->vpermw(xmmA, xmmB, xmmC);
+ e->vpermw(xmmA, xmmB, anyptr_gpC);
+ e->vpermw(ymmA, ymmB, ymmC);
+ e->vpermw(ymmA, ymmB, anyptr_gpC);
+ e->vpermw(zmmA, zmmB, zmmC);
+ e->vpermw(zmmA, zmmB, anyptr_gpC);
+ e->vpexpandd(xmmA, xmmB);
+ e->vpexpandd(xmmA, anyptr_gpB);
+ e->vpexpandd(ymmA, ymmB);
+ e->vpexpandd(ymmA, anyptr_gpB);
+ e->vpexpandd(zmmA, zmmB);
+ e->vpexpandd(zmmA, anyptr_gpB);
+ e->vpexpandq(xmmA, xmmB);
+ e->vpexpandq(xmmA, anyptr_gpB);
+ e->vpexpandq(ymmA, ymmB);
+ e->vpexpandq(ymmA, anyptr_gpB);
+ e->vpexpandq(zmmA, zmmB);
+ e->vpexpandq(zmmA, anyptr_gpB);
+ e->vpextrb(gdA, xmmB, 0);
+ e->vpextrb(anyptr_gpA, xmmB, 0);
+ e->vpextrb(gzA, xmmB, 0);
+ e->vpextrd(gdA, xmmB, 0);
+ e->vpextrd(anyptr_gpA, xmmB, 0);
+ if (isX64) e->vpextrd(gzA, xmmB, 0);
+ if (isX64) e->vpextrq(gzA, xmmB, 0);
+ e->vpextrq(anyptr_gpA, xmmB, 0);
+ e->vpextrw(gdA, xmmB, 0);
+ e->vpextrw(gzA, xmmB, 0);
+ e->vpextrw(gdA, xmmB, 0);
+ e->vpextrw(anyptr_gpA, xmmB, 0);
+ e->vpextrw(gzA, xmmB, 0);
+ e->vpgatherdd(xmmA, vx_ptr);
+ e->vpgatherdd(ymmA, vy_ptr);
+ e->vpgatherdd(zmmA, vz_ptr);
+ e->vpgatherdq(xmmA, vx_ptr);
+ e->vpgatherdq(ymmA, vy_ptr);
+ e->vpgatherdq(zmmA, vz_ptr);
+ e->vpgatherqd(xmmA, vx_ptr);
+ e->vpgatherqd(ymmA, vy_ptr);
+ e->vpgatherqd(zmmA, vz_ptr);
+ e->vpgatherqq(xmmA, vx_ptr);
+ e->vpgatherqq(ymmA, vy_ptr);
+ e->vpgatherqq(zmmA, vz_ptr);
+ e->vpinsrb(xmmA, xmmB, gdC, 0);
+ e->vpinsrb(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpinsrb(xmmA, xmmB, gzC, 0);
+ e->vpinsrd(xmmA, xmmB, gdC, 0);
+ e->vpinsrd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpinsrd(xmmA, xmmB, gzC, 0);
+ if (isX64) e->vpinsrq(xmmA, xmmB, gzC, 0);
+ e->vpinsrq(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpinsrw(xmmA, xmmB, gdC, 0);
+ e->vpinsrw(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpinsrw(xmmA, xmmB, gzC, 0);
+ e->vplzcntd(xmmA, xmmB);
+ e->vplzcntd(xmmA, anyptr_gpB);
+ e->vplzcntd(ymmA, ymmB);
+ e->vplzcntd(ymmA, anyptr_gpB);
+ e->vplzcntd(zmmA, zmmB);
+ e->vplzcntd(zmmA, anyptr_gpB);
+ e->vplzcntq(xmmA, xmmB);
+ e->vplzcntq(xmmA, anyptr_gpB);
+ e->vplzcntq(ymmA, ymmB);
+ e->vplzcntq(ymmA, anyptr_gpB);
+ e->vplzcntq(zmmA, zmmB);
+ e->vplzcntq(zmmA, anyptr_gpB);
+ e->vpmadd52huq(xmmA, xmmB, xmmC);
+ e->vpmadd52huq(xmmA, xmmB, anyptr_gpC);
+ e->vpmadd52huq(ymmA, ymmB, ymmC);
+ e->vpmadd52huq(ymmA, ymmB, anyptr_gpC);
+ e->vpmadd52huq(zmmA, zmmB, zmmC);
+ e->vpmadd52huq(zmmA, zmmB, anyptr_gpC);
+ e->vpmadd52luq(xmmA, xmmB, xmmC);
+ e->vpmadd52luq(xmmA, xmmB, anyptr_gpC);
+ e->vpmadd52luq(ymmA, ymmB, ymmC);
+ e->vpmadd52luq(ymmA, ymmB, anyptr_gpC);
+ e->vpmadd52luq(zmmA, zmmB, zmmC);
+ e->vpmadd52luq(zmmA, zmmB, anyptr_gpC);
+ e->vpmaddubsw(xmmA, xmmB, xmmC);
+ e->vpmaddubsw(xmmA, xmmB, anyptr_gpC);
+ e->vpmaddubsw(ymmA, ymmB, ymmC);
+ e->vpmaddubsw(ymmA, ymmB, anyptr_gpC);
+ e->vpmaddubsw(zmmA, zmmB, zmmC);
+ e->vpmaddubsw(zmmA, zmmB, anyptr_gpC);
+ e->vpmaddwd(xmmA, xmmB, xmmC);
+ e->vpmaddwd(xmmA, xmmB, anyptr_gpC);
+ e->vpmaddwd(ymmA, ymmB, ymmC);
+ e->vpmaddwd(ymmA, ymmB, anyptr_gpC);
+ e->vpmaddwd(zmmA, zmmB, zmmC);
+ e->vpmaddwd(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxsb(xmmA, xmmB, xmmC);
+ e->vpmaxsb(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsb(ymmA, ymmB, ymmC);
+ e->vpmaxsb(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsb(zmmA, zmmB, zmmC);
+ e->vpmaxsb(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxsd(xmmA, xmmB, xmmC);
+ e->vpmaxsd(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsd(ymmA, ymmB, ymmC);
+ e->vpmaxsd(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsd(zmmA, zmmB, zmmC);
+ e->vpmaxsd(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxsq(xmmA, xmmB, xmmC);
+ e->vpmaxsq(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsq(ymmA, ymmB, ymmC);
+ e->vpmaxsq(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsq(zmmA, zmmB, zmmC);
+ e->vpmaxsq(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxsw(xmmA, xmmB, xmmC);
+ e->vpmaxsw(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxsw(ymmA, ymmB, ymmC);
+ e->vpmaxsw(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxsw(zmmA, zmmB, zmmC);
+ e->vpmaxsw(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxub(xmmA, xmmB, xmmC);
+ e->vpmaxub(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxub(ymmA, ymmB, ymmC);
+ e->vpmaxub(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxub(zmmA, zmmB, zmmC);
+ e->vpmaxub(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxud(xmmA, xmmB, xmmC);
+ e->vpmaxud(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxud(ymmA, ymmB, ymmC);
+ e->vpmaxud(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxud(zmmA, zmmB, zmmC);
+ e->vpmaxud(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxuq(xmmA, xmmB, xmmC);
+ e->vpmaxuq(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxuq(ymmA, ymmB, ymmC);
+ e->vpmaxuq(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxuq(zmmA, zmmB, zmmC);
+ e->vpmaxuq(zmmA, zmmB, anyptr_gpC);
+ e->vpmaxuw(xmmA, xmmB, xmmC);
+ e->vpmaxuw(xmmA, xmmB, anyptr_gpC);
+ e->vpmaxuw(ymmA, ymmB, ymmC);
+ e->vpmaxuw(ymmA, ymmB, anyptr_gpC);
+ e->vpmaxuw(zmmA, zmmB, zmmC);
+ e->vpmaxuw(zmmA, zmmB, anyptr_gpC);
+ e->vpminsb(xmmA, xmmB, xmmC);
+ e->vpminsb(xmmA, xmmB, anyptr_gpC);
+ e->vpminsb(ymmA, ymmB, ymmC);
+ e->vpminsb(ymmA, ymmB, anyptr_gpC);
+ e->vpminsb(zmmA, zmmB, zmmC);
+ e->vpminsb(zmmA, zmmB, anyptr_gpC);
+ e->vpminsd(xmmA, xmmB, xmmC);
+ e->vpminsd(xmmA, xmmB, anyptr_gpC);
+ e->vpminsd(ymmA, ymmB, ymmC);
+ e->vpminsd(ymmA, ymmB, anyptr_gpC);
+ e->vpminsd(zmmA, zmmB, zmmC);
+ e->vpminsd(zmmA, zmmB, anyptr_gpC);
+ e->vpminsq(xmmA, xmmB, xmmC);
+ e->vpminsq(xmmA, xmmB, anyptr_gpC);
+ e->vpminsq(ymmA, ymmB, ymmC);
+ e->vpminsq(ymmA, ymmB, anyptr_gpC);
+ e->vpminsq(zmmA, zmmB, zmmC);
+ e->vpminsq(zmmA, zmmB, anyptr_gpC);
+ e->vpminsw(xmmA, xmmB, xmmC);
+ e->vpminsw(xmmA, xmmB, anyptr_gpC);
+ e->vpminsw(ymmA, ymmB, ymmC);
+ e->vpminsw(ymmA, ymmB, anyptr_gpC);
+ e->vpminsw(zmmA, zmmB, zmmC);
+ e->vpminsw(zmmA, zmmB, anyptr_gpC);
+ e->vpminub(xmmA, xmmB, xmmC);
+ e->vpminub(xmmA, xmmB, anyptr_gpC);
+ e->vpminub(ymmA, ymmB, ymmC);
+ e->vpminub(ymmA, ymmB, anyptr_gpC);
+ e->vpminub(zmmA, zmmB, zmmC);
+ e->vpminub(zmmA, zmmB, anyptr_gpC);
+ e->vpminud(xmmA, xmmB, xmmC);
+ e->vpminud(xmmA, xmmB, anyptr_gpC);
+ e->vpminud(ymmA, ymmB, ymmC);
+ e->vpminud(ymmA, ymmB, anyptr_gpC);
+ e->vpminud(zmmA, zmmB, zmmC);
+ e->vpminud(zmmA, zmmB, anyptr_gpC);
+ e->vpminuq(xmmA, xmmB, xmmC);
+ e->vpminuq(xmmA, xmmB, anyptr_gpC);
+ e->vpminuq(ymmA, ymmB, ymmC);
+ e->vpminuq(ymmA, ymmB, anyptr_gpC);
+ e->vpminuq(zmmA, zmmB, zmmC);
+ e->vpminuq(zmmA, zmmB, anyptr_gpC);
+ e->vpminuw(xmmA, xmmB, xmmC);
+ e->vpminuw(xmmA, xmmB, anyptr_gpC);
+ e->vpminuw(ymmA, ymmB, ymmC);
+ e->vpminuw(ymmA, ymmB, anyptr_gpC);
+ e->vpminuw(zmmA, zmmB, zmmC);
+ e->vpminuw(zmmA, zmmB, anyptr_gpC);
+ e->vpmovb2m(kA, xmmB);
+ e->vpmovb2m(kA, ymmB);
+ e->vpmovb2m(kA, zmmB);
+ e->vpmovd2m(kA, xmmB);
+ e->vpmovd2m(kA, ymmB);
+ e->vpmovd2m(kA, zmmB);
+ e->vpmovdb(xmmA, xmmB);
+ e->vpmovdb(anyptr_gpA, xmmB);
+ e->vpmovdb(xmmA, ymmB);
+ e->vpmovdb(anyptr_gpA, ymmB);
+ e->vpmovdb(xmmA, zmmB);
+ e->vpmovdb(anyptr_gpA, zmmB);
+ e->vpmovdw(xmmA, xmmB);
+ e->vpmovdw(anyptr_gpA, xmmB);
+ e->vpmovdw(xmmA, ymmB);
+ e->vpmovdw(anyptr_gpA, ymmB);
+ e->vpmovdw(ymmA, zmmB);
+ e->vpmovdw(anyptr_gpA, zmmB);
+ e->vpmovm2b(xmmA, kB);
+ e->vpmovm2b(ymmA, kB);
+ e->vpmovm2b(zmmA, kB);
+ e->vpmovm2d(xmmA, kB);
+ e->vpmovm2d(ymmA, kB);
+ e->vpmovm2d(zmmA, kB);
+ e->vpmovm2q(xmmA, kB);
+ e->vpmovm2q(ymmA, kB);
+ e->vpmovm2q(zmmA, kB);
+ e->vpmovm2w(xmmA, kB);
+ e->vpmovm2w(ymmA, kB);
+ e->vpmovm2w(zmmA, kB);
+ e->vpmovq2m(kA, xmmB);
+ e->vpmovq2m(kA, ymmB);
+ e->vpmovq2m(kA, zmmB);
+ e->vpmovqb(xmmA, xmmB);
+ e->vpmovqb(anyptr_gpA, xmmB);
+ e->vpmovqb(xmmA, ymmB);
+ e->vpmovqb(anyptr_gpA, ymmB);
+ e->vpmovqb(xmmA, zmmB);
+ e->vpmovqb(anyptr_gpA, zmmB);
+ e->vpmovqd(xmmA, xmmB);
+ e->vpmovqd(anyptr_gpA, xmmB);
+ e->vpmovqd(xmmA, ymmB);
+ e->vpmovqd(anyptr_gpA, ymmB);
+ e->vpmovqd(ymmA, zmmB);
+ e->vpmovqd(anyptr_gpA, zmmB);
+ e->vpmovqw(xmmA, xmmB);
+ e->vpmovqw(anyptr_gpA, xmmB);
+ e->vpmovqw(xmmA, ymmB);
+ e->vpmovqw(anyptr_gpA, ymmB);
+ e->vpmovqw(xmmA, zmmB);
+ e->vpmovqw(anyptr_gpA, zmmB);
+ e->vpmovsdb(xmmA, xmmB);
+ e->vpmovsdb(anyptr_gpA, xmmB);
+ e->vpmovsdb(xmmA, ymmB);
+ e->vpmovsdb(anyptr_gpA, ymmB);
+ e->vpmovsdb(xmmA, zmmB);
+ e->vpmovsdb(anyptr_gpA, zmmB);
+ e->vpmovsdw(xmmA, xmmB);
+ e->vpmovsdw(anyptr_gpA, xmmB);
+ e->vpmovsdw(xmmA, ymmB);
+ e->vpmovsdw(anyptr_gpA, ymmB);
+ e->vpmovsdw(ymmA, zmmB);
+ e->vpmovsdw(anyptr_gpA, zmmB);
+ e->vpmovsqb(xmmA, xmmB);
+ e->vpmovsqb(anyptr_gpA, xmmB);
+ e->vpmovsqb(xmmA, ymmB);
+ e->vpmovsqb(anyptr_gpA, ymmB);
+ e->vpmovsqb(xmmA, zmmB);
+ e->vpmovsqb(anyptr_gpA, zmmB);
+ e->vpmovsqd(xmmA, xmmB);
+ e->vpmovsqd(anyptr_gpA, xmmB);
+ e->vpmovsqd(xmmA, ymmB);
+ e->vpmovsqd(anyptr_gpA, ymmB);
+ e->vpmovsqd(ymmA, zmmB);
+ e->vpmovsqd(anyptr_gpA, zmmB);
+ e->vpmovsqw(xmmA, xmmB);
+ e->vpmovsqw(anyptr_gpA, xmmB);
+ e->vpmovsqw(xmmA, ymmB);
+ e->vpmovsqw(anyptr_gpA, ymmB);
+ e->vpmovsqw(xmmA, zmmB);
+ e->vpmovsqw(anyptr_gpA, zmmB);
+ e->vpmovswb(xmmA, xmmB);
+ e->vpmovswb(anyptr_gpA, xmmB);
+ e->vpmovswb(xmmA, ymmB);
+ e->vpmovswb(anyptr_gpA, ymmB);
+ e->vpmovswb(ymmA, zmmB);
+ e->vpmovswb(anyptr_gpA, zmmB);
+ e->vpmovsxbd(xmmA, xmmB);
+ e->vpmovsxbd(xmmA, anyptr_gpB);
+ e->vpmovsxbd(ymmA, xmmB);
+ e->vpmovsxbd(ymmA, anyptr_gpB);
+ e->vpmovsxbd(zmmA, xmmB);
+ e->vpmovsxbd(zmmA, anyptr_gpB);
+ e->vpmovsxbq(xmmA, xmmB);
+ e->vpmovsxbq(xmmA, anyptr_gpB);
+ e->vpmovsxbq(ymmA, xmmB);
+ e->vpmovsxbq(ymmA, anyptr_gpB);
+ e->vpmovsxbq(zmmA, xmmB);
+ e->vpmovsxbq(zmmA, anyptr_gpB);
+ e->vpmovsxbw(xmmA, xmmB);
+ e->vpmovsxbw(xmmA, anyptr_gpB);
+ e->vpmovsxbw(ymmA, xmmB);
+ e->vpmovsxbw(ymmA, anyptr_gpB);
+ e->vpmovsxbw(zmmA, ymmB);
+ e->vpmovsxbw(zmmA, anyptr_gpB);
+ e->vpmovsxdq(xmmA, xmmB);
+ e->vpmovsxdq(xmmA, anyptr_gpB);
+ e->vpmovsxdq(ymmA, xmmB);
+ e->vpmovsxdq(ymmA, anyptr_gpB);
+ e->vpmovsxdq(zmmA, ymmB);
+ e->vpmovsxdq(zmmA, anyptr_gpB);
+ e->vpmovsxwd(xmmA, xmmB);
+ e->vpmovsxwd(xmmA, anyptr_gpB);
+ e->vpmovsxwd(ymmA, xmmB);
+ e->vpmovsxwd(ymmA, anyptr_gpB);
+ e->vpmovsxwd(zmmA, ymmB);
+ e->vpmovsxwd(zmmA, anyptr_gpB);
+ e->vpmovsxwq(xmmA, xmmB);
+ e->vpmovsxwq(xmmA, anyptr_gpB);
+ e->vpmovsxwq(ymmA, xmmB);
+ e->vpmovsxwq(ymmA, anyptr_gpB);
+ e->vpmovsxwq(zmmA, xmmB);
+ e->vpmovsxwq(zmmA, anyptr_gpB);
+ e->vpmovusdb(xmmA, xmmB);
+ e->vpmovusdb(anyptr_gpA, xmmB);
+ e->vpmovusdb(xmmA, ymmB);
+ e->vpmovusdb(anyptr_gpA, ymmB);
+ e->vpmovusdb(xmmA, zmmB);
+ e->vpmovusdb(anyptr_gpA, zmmB);
+ e->vpmovusdw(xmmA, xmmB);
+ e->vpmovusdw(anyptr_gpA, xmmB);
+ e->vpmovusdw(xmmA, ymmB);
+ e->vpmovusdw(anyptr_gpA, ymmB);
+ e->vpmovusdw(ymmA, zmmB);
+ e->vpmovusdw(anyptr_gpA, zmmB);
+ e->vpmovusqb(xmmA, xmmB);
+ e->vpmovusqb(anyptr_gpA, xmmB);
+ e->vpmovusqb(xmmA, ymmB);
+ e->vpmovusqb(anyptr_gpA, ymmB);
+ e->vpmovusqb(xmmA, zmmB);
+ e->vpmovusqb(anyptr_gpA, zmmB);
+ e->vpmovusqd(xmmA, xmmB);
+ e->vpmovusqd(anyptr_gpA, xmmB);
+ e->vpmovusqd(xmmA, ymmB);
+ e->vpmovusqd(anyptr_gpA, ymmB);
+ e->vpmovusqd(ymmA, zmmB);
+ e->vpmovusqd(anyptr_gpA, zmmB);
+ e->vpmovusqw(xmmA, xmmB);
+ e->vpmovusqw(anyptr_gpA, xmmB);
+ e->vpmovusqw(xmmA, ymmB);
+ e->vpmovusqw(anyptr_gpA, ymmB);
+ e->vpmovusqw(xmmA, zmmB);
+ e->vpmovusqw(anyptr_gpA, zmmB);
+ e->vpmovuswb(xmmA, xmmB);
+ e->vpmovuswb(anyptr_gpA, xmmB);
+ e->vpmovuswb(xmmA, ymmB);
+ e->vpmovuswb(anyptr_gpA, ymmB);
+ e->vpmovuswb(ymmA, zmmB);
+ e->vpmovuswb(anyptr_gpA, zmmB);
+ e->vpmovw2m(kA, xmmB);
+ e->vpmovw2m(kA, ymmB);
+ e->vpmovw2m(kA, zmmB);
+ e->vpmovwb(xmmA, xmmB);
+ e->vpmovwb(anyptr_gpA, xmmB);
+ e->vpmovwb(xmmA, ymmB);
+ e->vpmovwb(anyptr_gpA, ymmB);
+ e->vpmovwb(ymmA, zmmB);
+ e->vpmovwb(anyptr_gpA, zmmB);
+ e->vpmovzxbd(xmmA, xmmB);
+ e->vpmovzxbd(xmmA, anyptr_gpB);
+ e->vpmovzxbd(ymmA, xmmB);
+ e->vpmovzxbd(ymmA, anyptr_gpB);
+ e->vpmovzxbd(zmmA, xmmB);
+ e->vpmovzxbd(zmmA, anyptr_gpB);
+ e->vpmovzxbq(xmmA, xmmB);
+ e->vpmovzxbq(xmmA, anyptr_gpB);
+ e->vpmovzxbq(ymmA, xmmB);
+ e->vpmovzxbq(ymmA, anyptr_gpB);
+ e->vpmovzxbq(zmmA, xmmB);
+ e->vpmovzxbq(zmmA, anyptr_gpB);
+ e->vpmovzxbw(xmmA, xmmB);
+ e->vpmovzxbw(xmmA, anyptr_gpB);
+ e->vpmovzxbw(ymmA, xmmB);
+ e->vpmovzxbw(ymmA, anyptr_gpB);
+ e->vpmovzxbw(zmmA, ymmB);
+ e->vpmovzxbw(zmmA, anyptr_gpB);
+ e->vpmovzxdq(xmmA, xmmB);
+ e->vpmovzxdq(xmmA, anyptr_gpB);
+ e->vpmovzxdq(ymmA, xmmB);
+ e->vpmovzxdq(ymmA, anyptr_gpB);
+ e->vpmovzxdq(zmmA, ymmB);
+ e->vpmovzxdq(zmmA, anyptr_gpB);
+ e->vpmovzxwd(xmmA, xmmB);
+ e->vpmovzxwd(xmmA, anyptr_gpB);
+ e->vpmovzxwd(ymmA, xmmB);
+ e->vpmovzxwd(ymmA, anyptr_gpB);
+ e->vpmovzxwd(zmmA, ymmB);
+ e->vpmovzxwd(zmmA, anyptr_gpB);
+ e->vpmovzxwq(xmmA, xmmB);
+ e->vpmovzxwq(xmmA, anyptr_gpB);
+ e->vpmovzxwq(ymmA, xmmB);
+ e->vpmovzxwq(ymmA, anyptr_gpB);
+ e->vpmovzxwq(zmmA, xmmB);
+ e->vpmovzxwq(zmmA, anyptr_gpB);
+ e->vpmuldq(xmmA, xmmB, xmmC);
+ e->vpmuldq(xmmA, xmmB, anyptr_gpC);
+ e->vpmuldq(ymmA, ymmB, ymmC);
+ e->vpmuldq(ymmA, ymmB, anyptr_gpC);
+ e->vpmuldq(zmmA, zmmB, zmmC);
+ e->vpmuldq(zmmA, zmmB, anyptr_gpC);
+ e->vpmulhrsw(xmmA, xmmB, xmmC);
+ e->vpmulhrsw(xmmA, xmmB, anyptr_gpC);
+ e->vpmulhrsw(ymmA, ymmB, ymmC);
+ e->vpmulhrsw(ymmA, ymmB, anyptr_gpC);
+ e->vpmulhrsw(zmmA, zmmB, zmmC);
+ e->vpmulhrsw(zmmA, zmmB, anyptr_gpC);
+ e->vpmulhuw(xmmA, xmmB, xmmC);
+ e->vpmulhuw(xmmA, xmmB, anyptr_gpC);
+ e->vpmulhuw(ymmA, ymmB, ymmC);
+ e->vpmulhuw(ymmA, ymmB, anyptr_gpC);
+ e->vpmulhuw(zmmA, zmmB, zmmC);
+ e->vpmulhuw(zmmA, zmmB, anyptr_gpC);
+ e->vpmulhw(xmmA, xmmB, xmmC);
+ e->vpmulhw(xmmA, xmmB, anyptr_gpC);
+ e->vpmulhw(ymmA, ymmB, ymmC);
+ e->vpmulhw(ymmA, ymmB, anyptr_gpC);
+ e->vpmulhw(zmmA, zmmB, zmmC);
+ e->vpmulhw(zmmA, zmmB, anyptr_gpC);
+ e->vpmulld(xmmA, xmmB, xmmC);
+ e->vpmulld(xmmA, xmmB, anyptr_gpC);
+ e->vpmulld(ymmA, ymmB, ymmC);
+ e->vpmulld(ymmA, ymmB, anyptr_gpC);
+ e->vpmulld(zmmA, zmmB, zmmC);
+ e->vpmulld(zmmA, zmmB, anyptr_gpC);
+ e->vpmullq(xmmA, xmmB, xmmC);
+ e->vpmullq(xmmA, xmmB, anyptr_gpC);
+ e->vpmullq(ymmA, ymmB, ymmC);
+ e->vpmullq(ymmA, ymmB, anyptr_gpC);
+ e->vpmullq(zmmA, zmmB, zmmC);
+ e->vpmullq(zmmA, zmmB, anyptr_gpC);
+ e->vpmullw(xmmA, xmmB, xmmC);
+ e->vpmullw(xmmA, xmmB, anyptr_gpC);
+ e->vpmullw(ymmA, ymmB, ymmC);
+ e->vpmullw(ymmA, ymmB, anyptr_gpC);
+ e->vpmullw(zmmA, zmmB, zmmC);
+ e->vpmullw(zmmA, zmmB, anyptr_gpC);
+ e->vpmultishiftqb(xmmA, xmmB, xmmC);
+ e->vpmultishiftqb(xmmA, xmmB, anyptr_gpC);
+ e->vpmultishiftqb(ymmA, ymmB, ymmC);
+ e->vpmultishiftqb(ymmA, ymmB, anyptr_gpC);
+ e->vpmultishiftqb(zmmA, zmmB, zmmC);
+ e->vpmultishiftqb(zmmA, zmmB, anyptr_gpC);
+ e->vpmuludq(xmmA, xmmB, xmmC);
+ e->vpmuludq(xmmA, xmmB, anyptr_gpC);
+ e->vpmuludq(ymmA, ymmB, ymmC);
+ e->vpmuludq(ymmA, ymmB, anyptr_gpC);
+ e->vpmuludq(zmmA, zmmB, zmmC);
+ e->vpmuludq(zmmA, zmmB, anyptr_gpC);
+ e->vpopcntd(zmmA, zmmB);
+ e->vpopcntd(zmmA, anyptr_gpB);
+ e->vpopcntq(zmmA, zmmB);
+ e->vpopcntq(zmmA, anyptr_gpB);
+ e->vpord(xmmA, xmmB, xmmC);
+ e->vpord(xmmA, xmmB, anyptr_gpC);
+ e->vpord(ymmA, ymmB, ymmC);
+ e->vpord(ymmA, ymmB, anyptr_gpC);
+ e->vpord(zmmA, zmmB, zmmC);
+ e->vpord(zmmA, zmmB, anyptr_gpC);
+ e->vporq(xmmA, xmmB, xmmC);
+ e->vporq(xmmA, xmmB, anyptr_gpC);
+ e->vporq(ymmA, ymmB, ymmC);
+ e->vporq(ymmA, ymmB, anyptr_gpC);
+ e->vporq(zmmA, zmmB, zmmC);
+ e->vporq(zmmA, zmmB, anyptr_gpC);
+ e->vprold(xmmA, xmmB, 0);
+ e->vprold(xmmA, anyptr_gpB, 0);
+ e->vprold(ymmA, ymmB, 0);
+ e->vprold(ymmA, anyptr_gpB, 0);
+ e->vprold(zmmA, zmmB, 0);
+ e->vprold(zmmA, anyptr_gpB, 0);
+ e->vprolq(xmmA, xmmB, 0);
+ e->vprolq(xmmA, anyptr_gpB, 0);
+ e->vprolq(ymmA, ymmB, 0);
+ e->vprolq(ymmA, anyptr_gpB, 0);
+ e->vprolq(zmmA, zmmB, 0);
+ e->vprolq(zmmA, anyptr_gpB, 0);
+ e->vprolvd(xmmA, xmmB, xmmC);
+ e->vprolvd(xmmA, xmmB, anyptr_gpC);
+ e->vprolvd(ymmA, ymmB, ymmC);
+ e->vprolvd(ymmA, ymmB, anyptr_gpC);
+ e->vprolvd(zmmA, zmmB, zmmC);
+ e->vprolvd(zmmA, zmmB, anyptr_gpC);
+ e->vprolvq(xmmA, xmmB, xmmC);
+ e->vprolvq(xmmA, xmmB, anyptr_gpC);
+ e->vprolvq(ymmA, ymmB, ymmC);
+ e->vprolvq(ymmA, ymmB, anyptr_gpC);
+ e->vprolvq(zmmA, zmmB, zmmC);
+ e->vprolvq(zmmA, zmmB, anyptr_gpC);
+ e->vprord(xmmA, xmmB, 0);
+ e->vprord(xmmA, anyptr_gpB, 0);
+ e->vprord(ymmA, ymmB, 0);
+ e->vprord(ymmA, anyptr_gpB, 0);
+ e->vprord(zmmA, zmmB, 0);
+ e->vprord(zmmA, anyptr_gpB, 0);
+ e->vprorq(xmmA, xmmB, 0);
+ e->vprorq(xmmA, anyptr_gpB, 0);
+ e->vprorq(ymmA, ymmB, 0);
+ e->vprorq(ymmA, anyptr_gpB, 0);
+ e->vprorq(zmmA, zmmB, 0);
+ e->vprorq(zmmA, anyptr_gpB, 0);
+ e->vprorvd(xmmA, xmmB, xmmC);
+ e->vprorvd(xmmA, xmmB, anyptr_gpC);
+ e->vprorvd(ymmA, ymmB, ymmC);
+ e->vprorvd(ymmA, ymmB, anyptr_gpC);
+ e->vprorvd(zmmA, zmmB, zmmC);
+ e->vprorvd(zmmA, zmmB, anyptr_gpC);
+ e->vprorvq(xmmA, xmmB, xmmC);
+ e->vprorvq(xmmA, xmmB, anyptr_gpC);
+ e->vprorvq(ymmA, ymmB, ymmC);
+ e->vprorvq(ymmA, ymmB, anyptr_gpC);
+ e->vprorvq(zmmA, zmmB, zmmC);
+ e->vprorvq(zmmA, zmmB, anyptr_gpC);
+ e->vpsadbw(xmmA, xmmB, xmmC);
+ e->vpsadbw(xmmA, xmmB, anyptr_gpC);
+ e->vpsadbw(ymmA, ymmB, ymmC);
+ e->vpsadbw(ymmA, ymmB, anyptr_gpC);
+ e->vpsadbw(zmmA, zmmB, zmmC);
+ e->vpsadbw(zmmA, zmmB, anyptr_gpC);
+ e->vpscatterdd(vx_ptr, xmmB);
+ e->vpscatterdd(vy_ptr, ymmB);
+ e->vpscatterdd(vz_ptr, zmmB);
+ e->vpscatterdq(vx_ptr, xmmB);
+ e->vpscatterdq(vy_ptr, ymmB);
+ e->vpscatterdq(vz_ptr, zmmB);
+ e->vpscatterqd(vx_ptr, xmmB);
+ e->vpscatterqd(vy_ptr, xmmB);
+ e->vpscatterqd(vz_ptr, ymmB);
+ e->vpscatterqq(vx_ptr, xmmB);
+ e->vpscatterqq(vy_ptr, ymmB);
+ e->vpscatterqq(vz_ptr, zmmB);
+ e->vpshufb(xmmA, xmmB, xmmC);
+ e->vpshufb(xmmA, xmmB, anyptr_gpC);
+ e->vpshufb(ymmA, ymmB, ymmC);
+ e->vpshufb(ymmA, ymmB, anyptr_gpC);
+ e->vpshufb(zmmA, zmmB, zmmC);
+ e->vpshufb(zmmA, zmmB, anyptr_gpC);
+ e->vpshufd(xmmA, xmmB, 0);
+ e->vpshufd(xmmA, anyptr_gpB, 0);
+ e->vpshufd(ymmA, ymmB, 0);
+ e->vpshufd(ymmA, anyptr_gpB, 0);
+ e->vpshufd(zmmA, zmmB, 0);
+ e->vpshufd(zmmA, anyptr_gpB, 0);
+ e->vpshufhw(xmmA, xmmB, 0);
+ e->vpshufhw(xmmA, anyptr_gpB, 0);
+ e->vpshufhw(ymmA, ymmB, 0);
+ e->vpshufhw(ymmA, anyptr_gpB, 0);
+ e->vpshufhw(zmmA, zmmB, 0);
+ e->vpshufhw(zmmA, anyptr_gpB, 0);
+ e->vpshuflw(xmmA, xmmB, 0);
+ e->vpshuflw(xmmA, anyptr_gpB, 0);
+ e->vpshuflw(ymmA, ymmB, 0);
+ e->vpshuflw(ymmA, anyptr_gpB, 0);
+ e->vpshuflw(zmmA, zmmB, 0);
+ e->vpshuflw(zmmA, anyptr_gpB, 0);
+ e->vpslld(xmmA, xmmB, xmmC);
+ e->vpslld(xmmA, xmmB, anyptr_gpC);
+ e->vpslld(xmmA, xmmB, 0);
+ e->vpslld(xmmA, anyptr_gpB, 0);
+ e->vpslld(ymmA, ymmB, xmmC);
+ e->vpslld(ymmA, ymmB, anyptr_gpC);
+ e->vpslld(ymmA, ymmB, 0);
+ e->vpslld(ymmA, anyptr_gpB, 0);
+ e->vpslld(zmmA, zmmB, xmmC);
+ e->vpslld(zmmA, zmmB, anyptr_gpC);
+ e->vpslld(zmmA, zmmB, 0);
+ e->vpslld(zmmA, anyptr_gpB, 0);
+ e->vpslldq(xmmA, xmmB, 0);
+ e->vpslldq(xmmA, anyptr_gpB, 0);
+ e->vpslldq(ymmA, ymmB, 0);
+ e->vpslldq(ymmA, anyptr_gpB, 0);
+ e->vpslldq(zmmA, zmmB, 0);
+ e->vpslldq(zmmA, anyptr_gpB, 0);
+ e->vpsllq(xmmA, xmmB, xmmC);
+ e->vpsllq(xmmA, xmmB, anyptr_gpC);
+ e->vpsllq(xmmA, xmmB, 0);
+ e->vpsllq(xmmA, anyptr_gpB, 0);
+ e->vpsllq(ymmA, ymmB, xmmC);
+ e->vpsllq(ymmA, ymmB, anyptr_gpC);
+ e->vpsllq(ymmA, ymmB, 0);
+ e->vpsllq(ymmA, anyptr_gpB, 0);
+ e->vpsllq(zmmA, zmmB, xmmC);
+ e->vpsllq(zmmA, zmmB, anyptr_gpC);
+ e->vpsllq(zmmA, zmmB, 0);
+ e->vpsllq(zmmA, anyptr_gpB, 0);
+ e->vpsllvd(xmmA, xmmB, xmmC);
+ e->vpsllvd(xmmA, xmmB, anyptr_gpC);
+ e->vpsllvd(ymmA, ymmB, ymmC);
+ e->vpsllvd(ymmA, ymmB, anyptr_gpC);
+ e->vpsllvd(zmmA, zmmB, zmmC);
+ e->vpsllvd(zmmA, zmmB, anyptr_gpC);
+ e->vpsllvq(xmmA, xmmB, xmmC);
+ e->vpsllvq(xmmA, xmmB, anyptr_gpC);
+ e->vpsllvq(ymmA, ymmB, ymmC);
+ e->vpsllvq(ymmA, ymmB, anyptr_gpC);
+ e->vpsllvq(zmmA, zmmB, zmmC);
+ e->vpsllvq(zmmA, zmmB, anyptr_gpC);
+ e->vpsllvw(xmmA, xmmB, xmmC);
+ e->vpsllvw(xmmA, xmmB, anyptr_gpC);
+ e->vpsllvw(ymmA, ymmB, ymmC);
+ e->vpsllvw(ymmA, ymmB, anyptr_gpC);
+ e->vpsllvw(zmmA, zmmB, zmmC);
+ e->vpsllvw(zmmA, zmmB, anyptr_gpC);
+ e->vpsllw(xmmA, xmmB, xmmC);
+ e->vpsllw(xmmA, xmmB, anyptr_gpC);
+ e->vpsllw(xmmA, xmmB, 0);
+ e->vpsllw(xmmA, anyptr_gpB, 0);
+ e->vpsllw(ymmA, ymmB, xmmC);
+ e->vpsllw(ymmA, ymmB, anyptr_gpC);
+ e->vpsllw(ymmA, ymmB, 0);
+ e->vpsllw(ymmA, anyptr_gpB, 0);
+ e->vpsllw(zmmA, zmmB, xmmC);
+ e->vpsllw(zmmA, zmmB, anyptr_gpC);
+ e->vpsllw(zmmA, zmmB, 0);
+ e->vpsllw(zmmA, anyptr_gpB, 0);
+ e->vpsrad(xmmA, xmmB, xmmC);
+ e->vpsrad(xmmA, xmmB, anyptr_gpC);
+ e->vpsrad(xmmA, xmmB, 0);
+ e->vpsrad(xmmA, anyptr_gpB, 0);
+ e->vpsrad(ymmA, ymmB, xmmC);
+ e->vpsrad(ymmA, ymmB, anyptr_gpC);
+ e->vpsrad(ymmA, ymmB, 0);
+ e->vpsrad(ymmA, anyptr_gpB, 0);
+ e->vpsrad(zmmA, zmmB, xmmC);
+ e->vpsrad(zmmA, zmmB, anyptr_gpC);
+ e->vpsrad(zmmA, zmmB, 0);
+ e->vpsrad(zmmA, anyptr_gpB, 0);
+ e->vpsraq(xmmA, xmmB, xmmC);
+ e->vpsraq(xmmA, xmmB, anyptr_gpC);
+ e->vpsraq(xmmA, xmmB, 0);
+ e->vpsraq(xmmA, anyptr_gpB, 0);
+ e->vpsraq(ymmA, ymmB, xmmC);
+ e->vpsraq(ymmA, ymmB, anyptr_gpC);
+ e->vpsraq(ymmA, ymmB, 0);
+ e->vpsraq(ymmA, anyptr_gpB, 0);
+ e->vpsraq(zmmA, zmmB, xmmC);
+ e->vpsraq(zmmA, zmmB, anyptr_gpC);
+ e->vpsraq(zmmA, zmmB, 0);
+ e->vpsraq(zmmA, anyptr_gpB, 0);
+ e->vpsravd(xmmA, xmmB, xmmC);
+ e->vpsravd(xmmA, xmmB, anyptr_gpC);
+ e->vpsravd(ymmA, ymmB, ymmC);
+ e->vpsravd(ymmA, ymmB, anyptr_gpC);
+ e->vpsravd(zmmA, zmmB, zmmC);
+ e->vpsravd(zmmA, zmmB, anyptr_gpC);
+ e->vpsravq(xmmA, xmmB, xmmC);
+ e->vpsravq(xmmA, xmmB, anyptr_gpC);
+ e->vpsravq(ymmA, ymmB, ymmC);
+ e->vpsravq(ymmA, ymmB, anyptr_gpC);
+ e->vpsravq(zmmA, zmmB, zmmC);
+ e->vpsravq(zmmA, zmmB, anyptr_gpC);
+ e->vpsravw(xmmA, xmmB, xmmC);
+ e->vpsravw(xmmA, xmmB, anyptr_gpC);
+ e->vpsravw(ymmA, ymmB, ymmC);
+ e->vpsravw(ymmA, ymmB, anyptr_gpC);
+ e->vpsravw(zmmA, zmmB, zmmC);
+ e->vpsravw(zmmA, zmmB, anyptr_gpC);
+ e->vpsraw(xmmA, xmmB, xmmC);
+ e->vpsraw(xmmA, xmmB, anyptr_gpC);
+ e->vpsraw(xmmA, xmmB, 0);
+ e->vpsraw(xmmA, anyptr_gpB, 0);
+ e->vpsraw(ymmA, ymmB, xmmC);
+ e->vpsraw(ymmA, ymmB, anyptr_gpC);
+ e->vpsraw(ymmA, ymmB, 0);
+ e->vpsraw(ymmA, anyptr_gpB, 0);
+ e->vpsraw(zmmA, zmmB, xmmC);
+ e->vpsraw(zmmA, zmmB, anyptr_gpC);
+ e->vpsraw(zmmA, zmmB, 0);
+ e->vpsraw(zmmA, anyptr_gpB, 0);
+ e->vpsrld(xmmA, xmmB, xmmC);
+ e->vpsrld(xmmA, xmmB, anyptr_gpC);
+ e->vpsrld(xmmA, xmmB, 0);
+ e->vpsrld(xmmA, anyptr_gpB, 0);
+ e->vpsrld(ymmA, ymmB, xmmC);
+ e->vpsrld(ymmA, ymmB, anyptr_gpC);
+ e->vpsrld(ymmA, ymmB, 0);
+ e->vpsrld(ymmA, anyptr_gpB, 0);
+ e->vpsrld(zmmA, zmmB, xmmC);
+ e->vpsrld(zmmA, zmmB, anyptr_gpC);
+ e->vpsrld(zmmA, zmmB, 0);
+ e->vpsrld(zmmA, anyptr_gpB, 0);
+ e->vpsrldq(xmmA, xmmB, 0);
+ e->vpsrldq(xmmA, anyptr_gpB, 0);
+ e->vpsrldq(ymmA, ymmB, 0);
+ e->vpsrldq(ymmA, anyptr_gpB, 0);
+ e->vpsrldq(zmmA, zmmB, 0);
+ e->vpsrldq(zmmA, anyptr_gpB, 0);
+ e->vpsrlq(xmmA, xmmB, xmmC);
+ e->vpsrlq(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlq(xmmA, xmmB, 0);
+ e->vpsrlq(xmmA, anyptr_gpB, 0);
+ e->vpsrlq(ymmA, ymmB, xmmC);
+ e->vpsrlq(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlq(ymmA, ymmB, 0);
+ e->vpsrlq(ymmA, anyptr_gpB, 0);
+ e->vpsrlq(zmmA, zmmB, xmmC);
+ e->vpsrlq(zmmA, zmmB, anyptr_gpC);
+ e->vpsrlq(zmmA, zmmB, 0);
+ e->vpsrlq(zmmA, anyptr_gpB, 0);
+ e->vpsrlvd(xmmA, xmmB, xmmC);
+ e->vpsrlvd(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlvd(ymmA, ymmB, ymmC);
+ e->vpsrlvd(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlvd(zmmA, zmmB, zmmC);
+ e->vpsrlvd(zmmA, zmmB, anyptr_gpC);
+ e->vpsrlvq(xmmA, xmmB, xmmC);
+ e->vpsrlvq(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlvq(ymmA, ymmB, ymmC);
+ e->vpsrlvq(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlvq(zmmA, zmmB, zmmC);
+ e->vpsrlvq(zmmA, zmmB, anyptr_gpC);
+ e->vpsrlvw(xmmA, xmmB, xmmC);
+ e->vpsrlvw(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlvw(ymmA, ymmB, ymmC);
+ e->vpsrlvw(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlvw(zmmA, zmmB, zmmC);
+ e->vpsrlvw(zmmA, zmmB, anyptr_gpC);
+ e->vpsrlw(xmmA, xmmB, xmmC);
+ e->vpsrlw(xmmA, xmmB, anyptr_gpC);
+ e->vpsrlw(xmmA, xmmB, 0);
+ e->vpsrlw(xmmA, anyptr_gpB, 0);
+ e->vpsrlw(ymmA, ymmB, xmmC);
+ e->vpsrlw(ymmA, ymmB, anyptr_gpC);
+ e->vpsrlw(ymmA, ymmB, 0);
+ e->vpsrlw(ymmA, anyptr_gpB, 0);
+ e->vpsrlw(zmmA, zmmB, xmmC);
+ e->vpsrlw(zmmA, zmmB, anyptr_gpC);
+ e->vpsrlw(zmmA, zmmB, 0);
+ e->vpsrlw(zmmA, anyptr_gpB, 0);
+ e->vpsubb(xmmA, xmmB, xmmC);
+ e->vpsubb(xmmA, xmmB, anyptr_gpC);
+ e->vpsubb(ymmA, ymmB, ymmC);
+ e->vpsubb(ymmA, ymmB, anyptr_gpC);
+ e->vpsubb(zmmA, zmmB, zmmC);
+ e->vpsubb(zmmA, zmmB, anyptr_gpC);
+ e->vpsubd(xmmA, xmmB, xmmC);
+ e->vpsubd(xmmA, xmmB, anyptr_gpC);
+ e->vpsubd(ymmA, ymmB, ymmC);
+ e->vpsubd(ymmA, ymmB, anyptr_gpC);
+ e->vpsubd(zmmA, zmmB, zmmC);
+ e->vpsubd(zmmA, zmmB, anyptr_gpC);
+ e->vpsubq(xmmA, xmmB, xmmC);
+ e->vpsubq(xmmA, xmmB, anyptr_gpC);
+ e->vpsubq(ymmA, ymmB, ymmC);
+ e->vpsubq(ymmA, ymmB, anyptr_gpC);
+ e->vpsubq(zmmA, zmmB, zmmC);
+ e->vpsubq(zmmA, zmmB, anyptr_gpC);
+ e->vpsubsb(xmmA, xmmB, xmmC);
+ e->vpsubsb(xmmA, xmmB, anyptr_gpC);
+ e->vpsubsb(ymmA, ymmB, ymmC);
+ e->vpsubsb(ymmA, ymmB, anyptr_gpC);
+ e->vpsubsb(zmmA, zmmB, zmmC);
+ e->vpsubsb(zmmA, zmmB, anyptr_gpC);
+ e->vpsubsw(xmmA, xmmB, xmmC);
+ e->vpsubsw(xmmA, xmmB, anyptr_gpC);
+ e->vpsubsw(ymmA, ymmB, ymmC);
+ e->vpsubsw(ymmA, ymmB, anyptr_gpC);
+ e->vpsubsw(zmmA, zmmB, zmmC);
+ e->vpsubsw(zmmA, zmmB, anyptr_gpC);
+ e->vpsubusb(xmmA, xmmB, xmmC);
+ e->vpsubusb(xmmA, xmmB, anyptr_gpC);
+ e->vpsubusb(ymmA, ymmB, ymmC);
+ e->vpsubusb(ymmA, ymmB, anyptr_gpC);
+ e->vpsubusb(zmmA, zmmB, zmmC);
+ e->vpsubusb(zmmA, zmmB, anyptr_gpC);
+ e->vpsubusw(xmmA, xmmB, xmmC);
+ e->vpsubusw(xmmA, xmmB, anyptr_gpC);
+ e->vpsubusw(ymmA, ymmB, ymmC);
+ e->vpsubusw(ymmA, ymmB, anyptr_gpC);
+ e->vpsubusw(zmmA, zmmB, zmmC);
+ e->vpsubusw(zmmA, zmmB, anyptr_gpC);
+ e->vpsubw(xmmA, xmmB, xmmC);
+ e->vpsubw(xmmA, xmmB, anyptr_gpC);
+ e->vpsubw(ymmA, ymmB, ymmC);
+ e->vpsubw(ymmA, ymmB, anyptr_gpC);
+ e->vpsubw(zmmA, zmmB, zmmC);
+ e->vpsubw(zmmA, zmmB, anyptr_gpC);
+ e->vpternlogd(xmmA, xmmB, xmmC, 0);
+ e->vpternlogd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpternlogd(ymmA, ymmB, ymmC, 0);
+ e->vpternlogd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpternlogd(zmmA, zmmB, zmmC, 0);
+ e->vpternlogd(zmmA, zmmB, anyptr_gpC, 0);
+ e->vpternlogq(xmmA, xmmB, xmmC, 0);
+ e->vpternlogq(xmmA, xmmB, anyptr_gpC, 0);
+ e->vpternlogq(ymmA, ymmB, ymmC, 0);
+ e->vpternlogq(ymmA, ymmB, anyptr_gpC, 0);
+ e->vpternlogq(zmmA, zmmB, zmmC, 0);
+ e->vpternlogq(zmmA, zmmB, anyptr_gpC, 0);
+ e->vptestmb(kA, xmmB, xmmC);
+ e->vptestmb(kA, xmmB, anyptr_gpC);
+ e->vptestmb(kA, ymmB, ymmC);
+ e->vptestmb(kA, ymmB, anyptr_gpC);
+ e->vptestmb(kA, zmmB, zmmC);
+ e->vptestmb(kA, zmmB, anyptr_gpC);
+ e->vptestmd(kA, xmmB, xmmC);
+ e->vptestmd(kA, xmmB, anyptr_gpC);
+ e->vptestmd(kA, ymmB, ymmC);
+ e->vptestmd(kA, ymmB, anyptr_gpC);
+ e->vptestmd(kA, zmmB, zmmC);
+ e->vptestmd(kA, zmmB, anyptr_gpC);
+ e->vptestmq(kA, xmmB, xmmC);
+ e->vptestmq(kA, xmmB, anyptr_gpC);
+ e->vptestmq(kA, ymmB, ymmC);
+ e->vptestmq(kA, ymmB, anyptr_gpC);
+ e->vptestmq(kA, zmmB, zmmC);
+ e->vptestmq(kA, zmmB, anyptr_gpC);
+ e->vptestmw(kA, xmmB, xmmC);
+ e->vptestmw(kA, xmmB, anyptr_gpC);
+ e->vptestmw(kA, ymmB, ymmC);
+ e->vptestmw(kA, ymmB, anyptr_gpC);
+ e->vptestmw(kA, zmmB, zmmC);
+ e->vptestmw(kA, zmmB, anyptr_gpC);
+ e->vptestnmb(kA, xmmB, xmmC);
+ e->vptestnmb(kA, xmmB, anyptr_gpC);
+ e->vptestnmb(kA, ymmB, ymmC);
+ e->vptestnmb(kA, ymmB, anyptr_gpC);
+ e->vptestnmb(kA, zmmB, zmmC);
+ e->vptestnmb(kA, zmmB, anyptr_gpC);
+ e->vptestnmd(kA, xmmB, xmmC);
+ e->vptestnmd(kA, xmmB, anyptr_gpC);
+ e->vptestnmd(kA, ymmB, ymmC);
+ e->vptestnmd(kA, ymmB, anyptr_gpC);
+ e->vptestnmd(kA, zmmB, zmmC);
+ e->vptestnmd(kA, zmmB, anyptr_gpC);
+ e->vptestnmq(kA, xmmB, xmmC);
+ e->vptestnmq(kA, xmmB, anyptr_gpC);
+ e->vptestnmq(kA, ymmB, ymmC);
+ e->vptestnmq(kA, ymmB, anyptr_gpC);
+ e->vptestnmq(kA, zmmB, zmmC);
+ e->vptestnmq(kA, zmmB, anyptr_gpC);
+ e->vptestnmw(kA, xmmB, xmmC);
+ e->vptestnmw(kA, xmmB, anyptr_gpC);
+ e->vptestnmw(kA, ymmB, ymmC);
+ e->vptestnmw(kA, ymmB, anyptr_gpC);
+ e->vptestnmw(kA, zmmB, zmmC);
+ e->vptestnmw(kA, zmmB, anyptr_gpC);
+ e->vpunpckhbw(xmmA, xmmB, xmmC);
+ e->vpunpckhbw(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhbw(ymmA, ymmB, ymmC);
+ e->vpunpckhbw(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhbw(zmmA, zmmB, zmmC);
+ e->vpunpckhbw(zmmA, zmmB, anyptr_gpC);
+ e->vpunpckhdq(xmmA, xmmB, xmmC);
+ e->vpunpckhdq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhdq(ymmA, ymmB, ymmC);
+ e->vpunpckhdq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhdq(zmmA, zmmB, zmmC);
+ e->vpunpckhdq(zmmA, zmmB, anyptr_gpC);
+ e->vpunpckhqdq(xmmA, xmmB, xmmC);
+ e->vpunpckhqdq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhqdq(ymmA, ymmB, ymmC);
+ e->vpunpckhqdq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhqdq(zmmA, zmmB, zmmC);
+ e->vpunpckhqdq(zmmA, zmmB, anyptr_gpC);
+ e->vpunpckhwd(xmmA, xmmB, xmmC);
+ e->vpunpckhwd(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckhwd(ymmA, ymmB, ymmC);
+ e->vpunpckhwd(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckhwd(zmmA, zmmB, zmmC);
+ e->vpunpckhwd(zmmA, zmmB, anyptr_gpC);
+ e->vpunpcklbw(xmmA, xmmB, xmmC);
+ e->vpunpcklbw(xmmA, xmmB, anyptr_gpC);
+ e->vpunpcklbw(ymmA, ymmB, ymmC);
+ e->vpunpcklbw(ymmA, ymmB, anyptr_gpC);
+ e->vpunpcklbw(zmmA, zmmB, zmmC);
+ e->vpunpcklbw(zmmA, zmmB, anyptr_gpC);
+ e->vpunpckldq(xmmA, xmmB, xmmC);
+ e->vpunpckldq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpckldq(ymmA, ymmB, ymmC);
+ e->vpunpckldq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpckldq(zmmA, zmmB, zmmC);
+ e->vpunpckldq(zmmA, zmmB, anyptr_gpC);
+ e->vpunpcklqdq(xmmA, xmmB, xmmC);
+ e->vpunpcklqdq(xmmA, xmmB, anyptr_gpC);
+ e->vpunpcklqdq(ymmA, ymmB, ymmC);
+ e->vpunpcklqdq(ymmA, ymmB, anyptr_gpC);
+ e->vpunpcklqdq(zmmA, zmmB, zmmC);
+ e->vpunpcklqdq(zmmA, zmmB, anyptr_gpC);
+ e->vpunpcklwd(xmmA, xmmB, xmmC);
+ e->vpunpcklwd(xmmA, xmmB, anyptr_gpC);
+ e->vpunpcklwd(ymmA, ymmB, ymmC);
+ e->vpunpcklwd(ymmA, ymmB, anyptr_gpC);
+ e->vpunpcklwd(zmmA, zmmB, zmmC);
+ e->vpunpcklwd(zmmA, zmmB, anyptr_gpC);
+ e->vpxord(xmmA, xmmB, xmmC);
+ e->vpxord(xmmA, xmmB, anyptr_gpC);
+ e->vpxord(ymmA, ymmB, ymmC);
+ e->vpxord(ymmA, ymmB, anyptr_gpC);
+ e->vpxord(zmmA, zmmB, zmmC);
+ e->vpxord(zmmA, zmmB, anyptr_gpC);
+ e->vpxorq(xmmA, xmmB, xmmC);
+ e->vpxorq(xmmA, xmmB, anyptr_gpC);
+ e->vpxorq(ymmA, ymmB, ymmC);
+ e->vpxorq(ymmA, ymmB, anyptr_gpC);
+ e->vpxorq(zmmA, zmmB, zmmC);
+ e->vpxorq(zmmA, zmmB, anyptr_gpC);
+ e->vrangepd(xmmA, xmmB, xmmC, 0);
+ e->vrangepd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrangepd(ymmA, ymmB, ymmC, 0);
+ e->vrangepd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vrangepd(zmmA, zmmB, zmmC, 0);
+ e->vrangepd(zmmA, zmmB, anyptr_gpC, 0);
+ e->vrangeps(xmmA, xmmB, xmmC, 0);
+ e->vrangeps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrangeps(ymmA, ymmB, ymmC, 0);
+ e->vrangeps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vrangeps(zmmA, zmmB, zmmC, 0);
+ e->vrangeps(zmmA, zmmB, anyptr_gpC, 0);
+ e->vrangesd(xmmA, xmmB, xmmC, 0);
+ e->vrangesd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrangess(xmmA, xmmB, xmmC, 0);
+ e->vrangess(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrcp14pd(xmmA, xmmB);
+ e->vrcp14pd(xmmA, anyptr_gpB);
+ e->vrcp14pd(ymmA, ymmB);
+ e->vrcp14pd(ymmA, anyptr_gpB);
+ e->vrcp14pd(zmmA, zmmB);
+ e->vrcp14pd(zmmA, anyptr_gpB);
+ e->vrcp14ps(xmmA, xmmB);
+ e->vrcp14ps(xmmA, anyptr_gpB);
+ e->vrcp14ps(ymmA, ymmB);
+ e->vrcp14ps(ymmA, anyptr_gpB);
+ e->vrcp14ps(zmmA, zmmB);
+ e->vrcp14ps(zmmA, anyptr_gpB);
+ e->vrcp14sd(xmmA, xmmB, xmmC);
+ e->vrcp14sd(xmmA, xmmB, anyptr_gpC);
+ e->vrcp14ss(xmmA, xmmB, xmmC);
+ e->vrcp14ss(xmmA, xmmB, anyptr_gpC);
+ e->vrcp28pd(zmmA, zmmB);
+ e->vrcp28pd(zmmA, anyptr_gpB);
+ e->vrcp28ps(zmmA, zmmB);
+ e->vrcp28ps(zmmA, anyptr_gpB);
+ e->vrcp28sd(xmmA, xmmB, xmmC);
+ e->vrcp28sd(xmmA, xmmB, anyptr_gpC);
+ e->vrcp28ss(xmmA, xmmB, xmmC);
+ e->vrcp28ss(xmmA, xmmB, anyptr_gpC);
+ e->vreducepd(xmmA, xmmB, 0);
+ e->vreducepd(xmmA, anyptr_gpB, 0);
+ e->vreducepd(ymmA, ymmB, 0);
+ e->vreducepd(ymmA, anyptr_gpB, 0);
+ e->vreducepd(zmmA, zmmB, 0);
+ e->vreducepd(zmmA, anyptr_gpB, 0);
+ e->vreduceps(xmmA, xmmB, 0);
+ e->vreduceps(xmmA, anyptr_gpB, 0);
+ e->vreduceps(ymmA, ymmB, 0);
+ e->vreduceps(ymmA, anyptr_gpB, 0);
+ e->vreduceps(zmmA, zmmB, 0);
+ e->vreduceps(zmmA, anyptr_gpB, 0);
+ e->vreducesd(xmmA, xmmB, xmmC, 0);
+ e->vreducesd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vreducess(xmmA, xmmB, xmmC, 0);
+ e->vreducess(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrndscalepd(xmmA, xmmB, 0);
+ e->vrndscalepd(xmmA, anyptr_gpB, 0);
+ e->vrndscalepd(ymmA, ymmB, 0);
+ e->vrndscalepd(ymmA, anyptr_gpB, 0);
+ e->vrndscalepd(zmmA, zmmB, 0);
+ e->vrndscalepd(zmmA, anyptr_gpB, 0);
+ e->vrndscaleps(xmmA, xmmB, 0);
+ e->vrndscaleps(xmmA, anyptr_gpB, 0);
+ e->vrndscaleps(ymmA, ymmB, 0);
+ e->vrndscaleps(ymmA, anyptr_gpB, 0);
+ e->vrndscaleps(zmmA, zmmB, 0);
+ e->vrndscaleps(zmmA, anyptr_gpB, 0);
+ e->vrndscalesd(xmmA, xmmB, xmmC, 0);
+ e->vrndscalesd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrndscaless(xmmA, xmmB, xmmC, 0);
+ e->vrndscaless(xmmA, xmmB, anyptr_gpC, 0);
+ e->vrsqrt14pd(xmmA, xmmB);
+ e->vrsqrt14pd(xmmA, anyptr_gpB);
+ e->vrsqrt14pd(ymmA, ymmB);
+ e->vrsqrt14pd(ymmA, anyptr_gpB);
+ e->vrsqrt14pd(zmmA, zmmB);
+ e->vrsqrt14pd(zmmA, anyptr_gpB);
+ e->vrsqrt14ps(xmmA, xmmB);
+ e->vrsqrt14ps(xmmA, anyptr_gpB);
+ e->vrsqrt14ps(ymmA, ymmB);
+ e->vrsqrt14ps(ymmA, anyptr_gpB);
+ e->vrsqrt14ps(zmmA, zmmB);
+ e->vrsqrt14ps(zmmA, anyptr_gpB);
+ e->vrsqrt14sd(xmmA, xmmB, xmmC);
+ e->vrsqrt14sd(xmmA, xmmB, anyptr_gpC);
+ e->vrsqrt14ss(xmmA, xmmB, xmmC);
+ e->vrsqrt14ss(xmmA, xmmB, anyptr_gpC);
+ e->vrsqrt28pd(zmmA, zmmB);
+ e->vrsqrt28pd(zmmA, anyptr_gpB);
+ e->vrsqrt28ps(zmmA, zmmB);
+ e->vrsqrt28ps(zmmA, anyptr_gpB);
+ e->vrsqrt28sd(xmmA, xmmB, xmmC);
+ e->vrsqrt28sd(xmmA, xmmB, anyptr_gpC);
+ e->vrsqrt28ss(xmmA, xmmB, xmmC);
+ e->vrsqrt28ss(xmmA, xmmB, anyptr_gpC);
+ e->vscalefpd(xmmA, xmmB, xmmC);
+ e->vscalefpd(xmmA, xmmB, anyptr_gpC);
+ e->vscalefpd(ymmA, ymmB, ymmC);
+ e->vscalefpd(ymmA, ymmB, anyptr_gpC);
+ e->vscalefpd(zmmA, zmmB, zmmC);
+ e->vscalefpd(zmmA, zmmB, anyptr_gpC);
+ e->vscalefps(xmmA, xmmB, xmmC);
+ e->vscalefps(xmmA, xmmB, anyptr_gpC);
+ e->vscalefps(ymmA, ymmB, ymmC);
+ e->vscalefps(ymmA, ymmB, anyptr_gpC);
+ e->vscalefps(zmmA, zmmB, zmmC);
+ e->vscalefps(zmmA, zmmB, anyptr_gpC);
+ e->vscalefsd(xmmA, xmmB, xmmC);
+ e->vscalefsd(xmmA, xmmB, anyptr_gpC);
+ e->vscalefss(xmmA, xmmB, xmmC);
+ e->vscalefss(xmmA, xmmB, anyptr_gpC);
+ e->vscatterdpd(vx_ptr, xmmB);
+ e->vscatterdpd(vx_ptr, ymmB);
+ e->vscatterdpd(vy_ptr, zmmB);
+ e->vscatterdps(vx_ptr, xmmB);
+ e->vscatterdps(vy_ptr, ymmB);
+ e->vscatterdps(vz_ptr, zmmB);
+ e->vscatterpf0dpd(vy_ptr);
+ e->vscatterpf0dps(vz_ptr);
+ e->vscatterpf0qpd(vz_ptr);
+ e->vscatterpf0qps(vz_ptr);
+ e->vscatterpf1dpd(vy_ptr);
+ e->vscatterpf1dps(vz_ptr);
+ e->vscatterpf1qpd(vz_ptr);
+ e->vscatterpf1qps(vz_ptr);
+ e->vscatterqpd(vx_ptr, xmmB);
+ e->vscatterqpd(vy_ptr, ymmB);
+ e->vscatterqpd(vz_ptr, zmmB);
+ e->vscatterqps(vx_ptr, xmmB);
+ e->vscatterqps(vy_ptr, xmmB);
+ e->vscatterqps(vz_ptr, ymmB);
+ e->vshuff32x4(ymmA, ymmB, ymmC, 0);
+ e->vshuff32x4(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshuff32x4(zmmA, zmmB, zmmC, 0);
+ e->vshuff32x4(zmmA, zmmB, anyptr_gpC, 0);
+ e->vshuff64x2(ymmA, ymmB, ymmC, 0);
+ e->vshuff64x2(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshuff64x2(zmmA, zmmB, zmmC, 0);
+ e->vshuff64x2(zmmA, zmmB, anyptr_gpC, 0);
+ e->vshufi32x4(ymmA, ymmB, ymmC, 0);
+ e->vshufi32x4(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshufi32x4(zmmA, zmmB, zmmC, 0);
+ e->vshufi32x4(zmmA, zmmB, anyptr_gpC, 0);
+ e->vshufi64x2(ymmA, ymmB, ymmC, 0);
+ e->vshufi64x2(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshufi64x2(zmmA, zmmB, zmmC, 0);
+ e->vshufi64x2(zmmA, zmmB, anyptr_gpC, 0);
+ e->vshufpd(xmmA, xmmB, xmmC, 0);
+ e->vshufpd(xmmA, xmmB, anyptr_gpC, 0);
+ e->vshufpd(ymmA, ymmB, ymmC, 0);
+ e->vshufpd(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshufpd(zmmA, zmmB, zmmC, 0);
+ e->vshufpd(zmmA, zmmB, anyptr_gpC, 0);
+ e->vshufps(xmmA, xmmB, xmmC, 0);
+ e->vshufps(xmmA, xmmB, anyptr_gpC, 0);
+ e->vshufps(ymmA, ymmB, ymmC, 0);
+ e->vshufps(ymmA, ymmB, anyptr_gpC, 0);
+ e->vshufps(zmmA, zmmB, zmmC, 0);
+ e->vshufps(zmmA, zmmB, anyptr_gpC, 0);
+ e->vsqrtpd(xmmA, xmmB);
+ e->vsqrtpd(xmmA, anyptr_gpB);
+ e->vsqrtpd(ymmA, ymmB);
+ e->vsqrtpd(ymmA, anyptr_gpB);
+ e->vsqrtpd(zmmA, zmmB);
+ e->vsqrtpd(zmmA, anyptr_gpB);
+ e->vsqrtps(xmmA, xmmB);
+ e->vsqrtps(xmmA, anyptr_gpB);
+ e->vsqrtps(ymmA, ymmB);
+ e->vsqrtps(ymmA, anyptr_gpB);
+ e->vsqrtps(zmmA, zmmB);
+ e->vsqrtps(zmmA, anyptr_gpB);
+ e->vsqrtsd(xmmA, xmmB, xmmC);
+ e->vsqrtsd(xmmA, xmmB, anyptr_gpC);
+ e->vsqrtss(xmmA, xmmB, xmmC);
+ e->vsqrtss(xmmA, xmmB, anyptr_gpC);
+ e->vsubpd(xmmA, xmmB, xmmC);
+ e->vsubpd(xmmA, xmmB, anyptr_gpC);
+ e->vsubpd(ymmA, ymmB, ymmC);
+ e->vsubpd(ymmA, ymmB, anyptr_gpC);
+ e->vsubpd(zmmA, zmmB, zmmC);
+ e->vsubpd(zmmA, zmmB, anyptr_gpC);
+ e->vsubps(xmmA, xmmB, xmmC);
+ e->vsubps(xmmA, xmmB, anyptr_gpC);
+ e->vsubps(ymmA, ymmB, ymmC);
+ e->vsubps(ymmA, ymmB, anyptr_gpC);
+ e->vsubps(zmmA, zmmB, zmmC);
+ e->vsubps(zmmA, zmmB, anyptr_gpC);
+ e->vsubsd(xmmA, xmmB, xmmC);
+ e->vsubsd(xmmA, xmmB, anyptr_gpC);
+ e->vsubss(xmmA, xmmB, xmmC);
+ e->vsubss(xmmA, xmmB, anyptr_gpC);
+ e->vucomisd(xmmA, xmmB);
+ e->vucomisd(xmmA, anyptr_gpB);
+ e->vucomiss(xmmA, xmmB);
+ e->vucomiss(xmmA, anyptr_gpB);
+ e->vunpckhpd(xmmA, xmmB, xmmC);
+ e->vunpckhpd(xmmA, xmmB, anyptr_gpC);
+ e->vunpckhpd(ymmA, ymmB, ymmC);
+ e->vunpckhpd(ymmA, ymmB, anyptr_gpC);
+ e->vunpckhpd(zmmA, zmmB, zmmC);
+ e->vunpckhpd(zmmA, zmmB, anyptr_gpC);
+ e->vunpckhps(xmmA, xmmB, xmmC);
+ e->vunpckhps(xmmA, xmmB, anyptr_gpC);
+ e->vunpckhps(ymmA, ymmB, ymmC);
+ e->vunpckhps(ymmA, ymmB, anyptr_gpC);
+ e->vunpckhps(zmmA, zmmB, zmmC);
+ e->vunpckhps(zmmA, zmmB, anyptr_gpC);
+ e->vunpcklpd(xmmA, xmmB, xmmC);
+ e->vunpcklpd(xmmA, xmmB, anyptr_gpC);
+ e->vunpcklpd(ymmA, ymmB, ymmC);
+ e->vunpcklpd(ymmA, ymmB, anyptr_gpC);
+ e->vunpcklpd(zmmA, zmmB, zmmC);
+ e->vunpcklpd(zmmA, zmmB, anyptr_gpC);
+ e->vunpcklps(xmmA, xmmB, xmmC);
+ e->vunpcklps(xmmA, xmmB, anyptr_gpC);
+ e->vunpcklps(ymmA, ymmB, ymmC);
+ e->vunpcklps(ymmA, ymmB, anyptr_gpC);
+ e->vunpcklps(zmmA, zmmB, zmmC);
+ e->vunpcklps(zmmA, zmmB, anyptr_gpC);
+ e->vxorpd(xmmA, xmmB, xmmC);
+ e->vxorpd(xmmA, xmmB, anyptr_gpC);
+ e->vxorpd(ymmA, ymmB, ymmC);
+ e->vxorpd(ymmA, ymmB, anyptr_gpC);
+ e->vxorpd(zmmA, zmmB, zmmC);
+ e->vxorpd(zmmA, zmmB, anyptr_gpC);
+ e->vxorps(xmmA, xmmB, xmmC);
+ e->vxorps(xmmA, xmmB, anyptr_gpC);
+ e->vxorps(ymmA, ymmB, ymmC);
+ e->vxorps(ymmA, ymmB, anyptr_gpC);
+ e->vxorps(zmmA, zmmB, zmmC);
+ e->vxorps(zmmA, zmmB, anyptr_gpC);
+
+ // Mark the end.
+ e->nop();
+ e->nop();
+ e->nop();
+ e->nop();
+}
+
+} // {asmtest}
+
+#endif // ASMJIT_TEST_OPCODE_H_INCLUDED
diff --git a/3rdparty/asmjit/test/asmjit_test_unit.cpp b/3rdparty/asmjit/test/asmjit_test_unit.cpp
new file mode 100644
index 00000000000..f88018a7ac1
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_unit.cpp
@@ -0,0 +1,332 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#include <asmjit/asmjit.h>
+#include "./broken.h"
+
+using namespace asmjit;
+
+// ============================================================================
+// [DumpCpu]
+// ============================================================================
+
+struct DumpCpuFeature {
+ uint32_t feature;
+ const char* name;
+};
+
+static const char* hostArch() noexcept {
+ switch (ArchInfo::kIdHost) {
+ case ArchInfo::kIdX86: return "X86";
+ case ArchInfo::kIdX64: return "X64";
+ case ArchInfo::kIdA32: return "ARM32";
+ case ArchInfo::kIdA64: return "ARM64";
+ default: return "Unknown";
+ }
+}
+
+static void dumpFeatures(const CpuInfo& cpu, const DumpCpuFeature* data, size_t count) noexcept {
+ for (size_t i = 0; i < count; i++)
+ if (cpu.hasFeature(data[i].feature))
+ INFO(" %s", data[i].name);
+}
+
+static void dumpCpu(void) noexcept {
+ const CpuInfo& cpu = CpuInfo::host();
+
+ INFO("Host CPU:");
+ INFO(" Vendor : %s", cpu.vendor());
+ INFO(" Brand : %s", cpu.brand());
+ INFO(" Model ID : %u", cpu.modelId());
+ INFO(" Brand ID : %u", cpu.brandId());
+ INFO(" Family ID : %u", cpu.familyId());
+ INFO(" Stepping : %u", cpu.stepping());
+ INFO(" Processor Type : %u", cpu.processorType());
+ INFO(" Max logical Processors : %u", cpu.maxLogicalProcessors());
+ INFO(" Cache-Line Size : %u", cpu.cacheLineSize());
+ INFO(" HW-Thread Count : %u", cpu.hwThreadCount());
+ INFO("");
+
+ // --------------------------------------------------------------------------
+ // [X86]
+ // --------------------------------------------------------------------------
+
+#if ASMJIT_ARCH_X86
+ static const DumpCpuFeature x86FeaturesList[] = {
+ { x86::Features::kNX , "NX" },
+ { x86::Features::kMT , "MT" },
+ { x86::Features::k3DNOW , "3DNOW" },
+ { x86::Features::k3DNOW2 , "3DNOW2" },
+ { x86::Features::kADX , "ADX" },
+ { x86::Features::kAESNI , "AESNI" },
+ { x86::Features::kALTMOVCR8 , "ALTMOVCR8" },
+ { x86::Features::kAVX , "AVX" },
+ { x86::Features::kAVX2 , "AVX2" },
+ { x86::Features::kAVX512_4FMAPS , "AVX512_4FMAPS" },
+ { x86::Features::kAVX512_4VNNIW , "AVX512_4VNNIW" },
+ { x86::Features::kAVX512_BITALG , "AVX512_BITALG" },
+ { x86::Features::kAVX512_BW , "AVX512_BW" },
+ { x86::Features::kAVX512_CDI , "AVX512_CDI" },
+ { x86::Features::kAVX512_DQ , "AVX512_DQ" },
+ { x86::Features::kAVX512_ERI , "AVX512_ERI" },
+ { x86::Features::kAVX512_F , "AVX512_F" },
+ { x86::Features::kAVX512_IFMA , "AVX512_IFMA" },
+ { x86::Features::kAVX512_PFI , "AVX512_PFI" },
+ { x86::Features::kAVX512_VBMI , "AVX512_VBMI" },
+ { x86::Features::kAVX512_VBMI2 , "AVX512_VBMI2" },
+ { x86::Features::kAVX512_VL , "AVX512_VL" },
+ { x86::Features::kAVX512_VNNI , "AVX512_VNNI" },
+ { x86::Features::kAVX512_VPOPCNTDQ, "AVX512_VPOPCNTDQ" },
+ { x86::Features::kBMI , "BMI" },
+ { x86::Features::kBMI2 , "BMI2" },
+ { x86::Features::kCLFLUSH , "CLFLUSH" },
+ { x86::Features::kCLFLUSHOPT , "CLFLUSHOPT" },
+ { x86::Features::kCLWB , "CLWB" },
+ { x86::Features::kCLZERO , "CLZERO" },
+ { x86::Features::kCMOV , "CMOV" },
+ { x86::Features::kCMPXCHG16B , "CMPXCHG16B" },
+ { x86::Features::kCMPXCHG8B , "CMPXCHG8B" },
+ { x86::Features::kERMS , "ERMS" },
+ { x86::Features::kF16C , "F16C" },
+ { x86::Features::kFMA , "FMA" },
+ { x86::Features::kFMA4 , "FMA4" },
+ { x86::Features::kFPU , "FPU" },
+ { x86::Features::kFSGSBASE , "FSGSBASE" },
+ { x86::Features::kFXSR , "FXSR" },
+ { x86::Features::kFXSROPT , "FXSROPT" },
+ { x86::Features::kGEODE , "GEODE" },
+ { x86::Features::kGFNI , "GFNI" },
+ { x86::Features::kHLE , "HLE" },
+ { x86::Features::kI486 , "I486" },
+ { x86::Features::kLAHFSAHF , "LAHFSAHF" },
+ { x86::Features::kLWP , "LWP" },
+ { x86::Features::kLZCNT , "LZCNT" },
+ { x86::Features::kMMX , "MMX" },
+ { x86::Features::kMMX2 , "MMX2" },
+ { x86::Features::kMONITOR , "MONITOR" },
+ { x86::Features::kMONITORX , "MONITORX" },
+ { x86::Features::kMOVBE , "MOVBE" },
+ { x86::Features::kMPX , "MPX" },
+ { x86::Features::kMSR , "MSR" },
+ { x86::Features::kMSSE , "MSSE" },
+ { x86::Features::kOSXSAVE , "OSXSAVE" },
+ { x86::Features::kPCLMULQDQ , "PCLMULQDQ" },
+ { x86::Features::kPCOMMIT , "PCOMMIT" },
+ { x86::Features::kPOPCNT , "POPCNT" },
+ { x86::Features::kPREFETCHW , "PREFETCHW" },
+ { x86::Features::kPREFETCHWT1 , "PREFETCHWT1" },
+ { x86::Features::kRDRAND , "RDRAND" },
+ { x86::Features::kRDSEED , "RDSEED" },
+ { x86::Features::kRDTSC , "RDTSC" },
+ { x86::Features::kRDTSCP , "RDTSCP" },
+ { x86::Features::kRTM , "RTM" },
+ { x86::Features::kSHA , "SHA" },
+ { x86::Features::kSKINIT , "SKINIT" },
+ { x86::Features::kSMAP , "SMAP" },
+ { x86::Features::kSMEP , "SMEP" },
+ { x86::Features::kSMX , "SMX" },
+ { x86::Features::kSSE , "SSE" },
+ { x86::Features::kSSE2 , "SSE2" },
+ { x86::Features::kSSE3 , "SSE3" },
+ { x86::Features::kSSE4_1 , "SSE4.1" },
+ { x86::Features::kSSE4_2 , "SSE4.2" },
+ { x86::Features::kSSE4A , "SSE4A" },
+ { x86::Features::kSSSE3 , "SSSE3" },
+ { x86::Features::kSVM , "SVM" },
+ { x86::Features::kTBM , "TBM" },
+ { x86::Features::kTSX , "TSX" },
+ { x86::Features::kVAES , "VAES" },
+ { x86::Features::kVMX , "VMX" },
+ { x86::Features::kVPCLMULQDQ , "VPCLMULQDQ" },
+ { x86::Features::kXOP , "XOP" },
+ { x86::Features::kXSAVE , "XSAVE" },
+ { x86::Features::kXSAVEC , "XSAVEC" },
+ { x86::Features::kXSAVEOPT , "XSAVEOPT" },
+ { x86::Features::kXSAVES , "XSAVES" }
+ };
+
+ INFO("X86 Features:");
+ dumpFeatures(cpu, x86FeaturesList, ASMJIT_ARRAY_SIZE(x86FeaturesList));
+ INFO("");
+#endif
+
+ // --------------------------------------------------------------------------
+ // [ARM]
+ // --------------------------------------------------------------------------
+
+#if ASMJIT_ARCH_ARM
+ static const DumpCpuFeature armFeaturesList[] = {
+ { arm::Features::kARMv6 , "ARMv6" },
+ { arm::Features::kARMv7 , "ARMv7" },
+ { arm::Features::kARMv8 , "ARMv8" },
+ { arm::Features::kTHUMB , "THUMB" },
+ { arm::Features::kTHUMBv2 , "THUMBv2" },
+ { arm::Features::kVFP2 , "VFPv2" },
+ { arm::Features::kVFP3 , "VFPv3" },
+ { arm::Features::kVFP4 , "VFPv4" },
+ { arm::Features::kVFP_D32 , "VFP D32" },
+ { arm::Features::kNEON , "NEON" },
+ { arm::Features::kDSP , "DSP" },
+ { arm::Features::kIDIV , "IDIV" },
+ { arm::Features::kAES , "AES" },
+ { arm::Features::kCRC32 , "CRC32" },
+ { arm::Features::kSHA1 , "SHA1" },
+ { arm::Features::kSHA256 , "SHA256" },
+ { arm::Features::kATOMIC64 , "ATOMIC64" }
+ };
+
+ INFO("ARM Features:");
+ dumpFeatures(cpu, armFeaturesList, ASMJIT_ARRAY_SIZE(armFeaturesList));
+ INFO("");
+#endif
+}
+
+// ============================================================================
+// [DumpSizeOf]
+// ============================================================================
+
+#define DUMP_TYPE(...) \
+ INFO(" %-26s: %u", #__VA_ARGS__, uint32_t(sizeof(__VA_ARGS__)))
+
+static void dumpSizeOf(void) noexcept {
+ INFO("Size of C++ types:");
+ DUMP_TYPE(int8_t);
+ DUMP_TYPE(int16_t);
+ DUMP_TYPE(int32_t);
+ DUMP_TYPE(int64_t);
+ DUMP_TYPE(int);
+ DUMP_TYPE(long);
+ DUMP_TYPE(size_t);
+ DUMP_TYPE(intptr_t);
+ DUMP_TYPE(float);
+ DUMP_TYPE(double);
+ DUMP_TYPE(void*);
+ INFO("");
+
+ INFO("Size of base classes:");
+ DUMP_TYPE(BaseAssembler);
+ DUMP_TYPE(BaseEmitter);
+ DUMP_TYPE(CodeBuffer);
+ DUMP_TYPE(CodeHolder);
+ DUMP_TYPE(ConstPool);
+ DUMP_TYPE(LabelEntry);
+ DUMP_TYPE(RelocEntry);
+ DUMP_TYPE(Section);
+ DUMP_TYPE(String);
+ DUMP_TYPE(Target);
+ DUMP_TYPE(Zone);
+ DUMP_TYPE(ZoneAllocator);
+ DUMP_TYPE(ZoneBitVector);
+ DUMP_TYPE(ZoneHashNode);
+ DUMP_TYPE(ZoneHash<ZoneHashNode>);
+ DUMP_TYPE(ZoneList<int>);
+ DUMP_TYPE(ZoneVector<int>);
+ INFO("");
+
+ INFO("Size of operand classes:");
+ DUMP_TYPE(Operand);
+ DUMP_TYPE(BaseReg);
+ DUMP_TYPE(BaseMem);
+ DUMP_TYPE(Imm);
+ DUMP_TYPE(Label);
+ INFO("");
+
+ INFO("Size of function classes:");
+ DUMP_TYPE(CallConv);
+ DUMP_TYPE(FuncFrame);
+ DUMP_TYPE(FuncValue);
+ DUMP_TYPE(FuncDetail);
+ DUMP_TYPE(FuncSignature);
+ DUMP_TYPE(FuncArgsAssignment);
+ INFO("");
+
+#ifndef ASMJIT_NO_BUILDER
+ INFO("Size of builder classes:");
+ DUMP_TYPE(BaseBuilder);
+ DUMP_TYPE(BaseNode);
+ DUMP_TYPE(InstNode);
+ DUMP_TYPE(InstExNode);
+ DUMP_TYPE(AlignNode);
+ DUMP_TYPE(LabelNode);
+ DUMP_TYPE(EmbedDataNode);
+ DUMP_TYPE(EmbedLabelNode);
+ DUMP_TYPE(ConstPoolNode);
+ DUMP_TYPE(CommentNode);
+ DUMP_TYPE(SentinelNode);
+ INFO("");
+#endif
+
+#ifndef ASMJIT_NO_COMPILER
+ INFO("Size of compiler classes:");
+ DUMP_TYPE(BaseCompiler);
+ DUMP_TYPE(FuncNode);
+ DUMP_TYPE(FuncRetNode);
+ DUMP_TYPE(FuncCallNode);
+ INFO("");
+#endif
+
+#ifdef ASMJIT_BUILD_X86
+ INFO("Size of x86-specific classes:");
+ DUMP_TYPE(x86::Assembler);
+ #ifndef ASMJIT_NO_BUILDER
+ DUMP_TYPE(x86::Builder);
+ #endif
+ #ifndef ASMJIT_NO_COMPILER
+ DUMP_TYPE(x86::Compiler);
+ #endif
+ DUMP_TYPE(x86::InstDB::InstInfo);
+ DUMP_TYPE(x86::InstDB::CommonInfo);
+ DUMP_TYPE(x86::InstDB::OpSignature);
+ DUMP_TYPE(x86::InstDB::InstSignature);
+ INFO("");
+#endif
+}
+
+#undef DUMP_TYPE
+
+// ============================================================================
+// [Main]
+// ============================================================================
+
+static void onBeforeRun(void) noexcept {
+ dumpCpu();
+ dumpSizeOf();
+}
+
+int main(int argc, const char* argv[]) {
+#if defined(ASMJIT_BUILD_DEBUG)
+ const char buildType[] = "Debug";
+#else
+ const char buildType[] = "Release";
+#endif
+
+ INFO("AsmJit Unit-Test v%u.%u.%u [Arch=%s] [Mode=%s]\n\n",
+ unsigned((ASMJIT_LIBRARY_VERSION >> 16) ),
+ unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF),
+ unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF),
+ hostArch(),
+ buildType
+ );
+
+ return BrokenAPI::run(argc, argv, onBeforeRun);
+}
diff --git a/3rdparty/asmjit/test/asmjit_test_x86_asm.cpp b/3rdparty/asmjit/test/asmjit_test_x86_asm.cpp
new file mode 100644
index 00000000000..a01185d80f9
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_x86_asm.cpp
@@ -0,0 +1,195 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#include <asmjit/x86.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+using namespace asmjit;
+
+// Signature of the generated function.
+typedef void (*SumIntsFunc)(int* dst, const int* a, const int* b);
+
+// This function works with both x86::Assembler and x86::Builder. It shows how
+// `x86::Emitter` can be used to make your code more generic.
+static void makeRawFunc(x86::Emitter* emitter) noexcept {
+ // Decide which registers will be mapped to function arguments. Try changing
+ // registers of `dst`, `src_a`, and `src_b` and see what happens in function's
+ // prolog and epilog.
+ x86::Gp dst = emitter->zax();
+ x86::Gp src_a = emitter->zcx();
+ x86::Gp src_b = emitter->zdx();
+
+ // Decide which vector registers to use. We use these to keep the code generic,
+ // you can switch to any other registers when needed.
+ x86::Xmm vec0 = x86::xmm0;
+ x86::Xmm vec1 = x86::xmm1;
+
+ // Create and initialize `FuncDetail` and `FuncFrame`.
+ FuncDetail func;
+ func.init(FuncSignatureT<void, int*, const int*, const int*>(CallConv::kIdHost));
+
+ FuncFrame frame;
+ frame.init(func);
+
+ // Make XMM0 and XMM1 dirty. VEC group includes XMM|YMM|ZMM registers.
+ frame.addDirtyRegs(x86::xmm0, x86::xmm1);
+
+ FuncArgsAssignment args(&func); // Create arguments assignment context.
+ args.assignAll(dst, src_a, src_b); // Assign our registers to arguments.
+ args.updateFuncFrame(frame); // Reflect our args in FuncFrame.
+ frame.finalize();
+
+ // Emit prolog and allocate arguments to registers.
+ emitter->emitProlog(frame);
+ emitter->emitArgsAssignment(frame, args);
+
+ emitter->movdqu(vec0, x86::ptr(src_a)); // Load 4 ints from [src_a] to XMM0.
+ emitter->movdqu(vec1, x86::ptr(src_b)); // Load 4 ints from [src_b] to XMM1.
+
+ emitter->paddd(vec0, vec1); // Add 4 ints in XMM1 to XMM0.
+ emitter->movdqu(x86::ptr(dst), vec0); // Store the result to [dst].
+
+ // Emit epilog and return.
+ emitter->emitEpilog(frame);
+}
+
+#ifndef ASMJIT_NO_COMPILER
+// This function works with x86::Compiler, provided for comparison.
+static void makeCompiledFunc(x86::Compiler* cc) noexcept {
+ x86::Gp dst = cc->newIntPtr();
+ x86::Gp src_a = cc->newIntPtr();
+ x86::Gp src_b = cc->newIntPtr();
+
+ x86::Xmm vec0 = cc->newXmm();
+ x86::Xmm vec1 = cc->newXmm();
+
+ cc->addFunc(FuncSignatureT<void, int*, const int*, const int*>(CallConv::kIdHost));
+ cc->setArg(0, dst);
+ cc->setArg(1, src_a);
+ cc->setArg(2, src_b);
+
+ cc->movdqu(vec0, x86::ptr(src_a));
+ cc->movdqu(vec1, x86::ptr(src_b));
+ cc->paddd(vec0, vec1);
+ cc->movdqu(x86::ptr(dst), vec0);
+ cc->endFunc();
+}
+#endif
+
+static uint32_t testFunc(JitRuntime& rt, uint32_t emitterType) noexcept {
+#ifndef ASMJIT_NO_LOGGING
+ FileLogger logger(stdout);
+#endif
+
+ CodeHolder code;
+ code.init(rt.codeInfo());
+
+#ifndef ASMJIT_NO_LOGGING
+ code.setLogger(&logger);
+#endif
+
+ Error err = kErrorOk;
+ switch (emitterType) {
+ case BaseEmitter::kTypeAssembler: {
+ printf("Using x86::Assembler:\n");
+ x86::Assembler a(&code);
+ makeRawFunc(a.as<x86::Emitter>());
+ break;
+ }
+
+#ifndef ASMJIT_NO_BUILDER
+ case BaseEmitter::kTypeBuilder: {
+ printf("Using x86::Builder:\n");
+ x86::Builder cb(&code);
+ makeRawFunc(cb.as<x86::Emitter>());
+
+ err = cb.finalize();
+ if (err) {
+ printf("x86::Builder::finalize() failed: %s\n", DebugUtils::errorAsString(err));
+ return 1;
+ }
+ break;
+ }
+#endif
+
+#ifndef ASMJIT_NO_COMPILER
+ case BaseEmitter::kTypeCompiler: {
+ printf("Using x86::Compiler:\n");
+ x86::Compiler cc(&code);
+ makeCompiledFunc(&cc);
+
+ err = cc.finalize();
+ if (err) {
+ printf("x86::Compiler::finalize() failed: %s\n", DebugUtils::errorAsString(err));
+ return 1;
+ }
+ break;
+ }
+#endif
+ }
+
+ // Add the code generated to the runtime.
+ SumIntsFunc fn;
+ err = rt.add(&fn, &code);
+
+ if (err) {
+ printf("JitRuntime::add() failed: %s\n", DebugUtils::errorAsString(err));
+ return 1;
+ }
+
+ // Execute the generated function.
+ int inA[4] = { 4, 3, 2, 1 };
+ int inB[4] = { 1, 5, 2, 8 };
+ int out[4];
+ fn(out, inA, inB);
+
+ // Should print {5 8 4 9}.
+ printf("Result = { %d %d %d %d }\n\n", out[0], out[1], out[2], out[3]);
+
+ rt.release(fn);
+ return !(out[0] == 5 && out[1] == 8 && out[2] == 4 && out[3] == 9);
+}
+
+int main() {
+ unsigned nFailed = 0;
+ JitRuntime rt;
+
+ nFailed += testFunc(rt, BaseEmitter::kTypeAssembler);
+
+#ifndef ASMJIT_NO_BUILDER
+ nFailed += testFunc(rt, BaseEmitter::kTypeBuilder);
+#endif
+
+#ifndef ASMJIT_NO_COMPILER
+ nFailed += testFunc(rt, BaseEmitter::kTypeCompiler);
+#endif
+
+ if (!nFailed)
+ printf("[PASSED] All tests passed\n");
+ else
+ printf("[FAILED] %u %s failed\n", nFailed, nFailed == 1 ? "test" : "tests");
+
+ return nFailed ? 1 : 0;
+}
diff --git a/3rdparty/asmjit/test/asmjit_test_x86_cc.cpp b/3rdparty/asmjit/test/asmjit_test_x86_cc.cpp
new file mode 100644
index 00000000000..a0e50e97097
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_x86_cc.cpp
@@ -0,0 +1,4167 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#include <asmjit/x86.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "./asmjit_test_misc.h"
+
+#ifdef _MSC_VER
+// Interaction between '_setjmp' and C++ object destruction is non-portable.
+#pragma warning(disable: 4611)
+#endif
+
+using namespace asmjit;
+
+// ============================================================================
+// [CmdLine]
+// ============================================================================
+
+class CmdLine {
+public:
+ CmdLine(int argc, const char* const* argv) noexcept
+ : _argc(argc),
+ _argv(argv) {}
+
+ bool hasArg(const char* arg) noexcept {
+ for (int i = 1; i < _argc; i++)
+ if (strcmp(_argv[i], arg) == 0)
+ return true;
+ return false;
+ }
+
+ int _argc;
+ const char* const* _argv;
+};
+
+// ============================================================================
+// [SimpleErrorHandler]
+// ============================================================================
+
+class SimpleErrorHandler : public ErrorHandler {
+public:
+ SimpleErrorHandler() : _err(kErrorOk) {}
+ virtual void handleError(Error err, const char* message, BaseEmitter* origin) {
+ DebugUtils::unused(origin);
+ _err = err;
+ _message.assignString(message);
+ }
+
+ Error _err;
+ String _message;
+};
+
+// ============================================================================
+// [X86Test]
+// ============================================================================
+
+//! Base test interface for testing `x86::Compiler`.
+class X86Test {
+public:
+ X86Test(const char* name = nullptr) { _name.assignString(name); }
+ virtual ~X86Test() {}
+
+ inline const char* name() const { return _name.data(); }
+
+ virtual void compile(x86::Compiler& c) = 0;
+ virtual bool run(void* func, String& result, String& expect) = 0;
+
+ String _name;
+};
+
+// ============================================================================
+// [X86TestApp]
+// ============================================================================
+
+class X86TestApp {
+public:
+ Zone _zone;
+ ZoneAllocator _allocator;
+ ZoneVector<X86Test*> _tests;
+
+ unsigned _nFailed;
+ size_t _outputSize;
+
+ bool _verbose;
+ bool _dumpAsm;
+
+ X86TestApp() noexcept
+ : _zone(8096 - Zone::kBlockOverhead),
+ _allocator(&_zone),
+ _nFailed(0),
+ _outputSize(0),
+ _verbose(false),
+ _dumpAsm(false) {}
+
+ ~X86TestApp() noexcept {
+ for (X86Test* test : _tests)
+ delete test;
+ }
+
+ Error add(X86Test* test) noexcept{
+ return _tests.append(&_allocator, test);
+ }
+
+ template<class T>
+ inline void addT() { T::add(*this); }
+
+ int handleArgs(int argc, const char* const* argv);
+ void showInfo();
+ int run();
+};
+
+int X86TestApp::handleArgs(int argc, const char* const* argv) {
+ CmdLine cmd(argc, argv);
+
+ if (cmd.hasArg("--verbose")) _verbose = true;
+ if (cmd.hasArg("--dump-asm")) _dumpAsm = true;
+
+ return 0;
+}
+
+void X86TestApp::showInfo() {
+ printf("AsmJit Compiler Test-Suite v%u.%u.%u [Arch=%s]:\n",
+ unsigned((ASMJIT_LIBRARY_VERSION >> 16) ),
+ unsigned((ASMJIT_LIBRARY_VERSION >> 8) & 0xFF),
+ unsigned((ASMJIT_LIBRARY_VERSION ) & 0xFF),
+ sizeof(void*) == 8 ? "X64" : "X86");
+ printf(" [%s] Verbose (use --verbose to turn verbose output ON)\n", _verbose ? "x" : " ");
+ printf(" [%s] DumpAsm (use --dump-asm to turn assembler dumps ON)\n", _dumpAsm ? "x" : " ");
+ printf("\n");
+}
+
+int X86TestApp::run() {
+#ifndef ASMJIT_NO_LOGGING
+ uint32_t kFormatFlags = FormatOptions::kFlagMachineCode |
+ FormatOptions::kFlagExplainImms |
+ FormatOptions::kFlagRegCasts |
+ FormatOptions::kFlagAnnotations |
+ FormatOptions::kFlagDebugPasses |
+ FormatOptions::kFlagDebugRA ;
+
+ FileLogger fileLogger(stdout);
+ fileLogger.addFlags(kFormatFlags);
+
+ StringLogger stringLogger;
+ stringLogger.addFlags(kFormatFlags);
+#endif
+
+ for (X86Test* test : _tests) {
+ JitRuntime runtime;
+ CodeHolder code;
+ SimpleErrorHandler errorHandler;
+
+ code.init(runtime.codeInfo());
+ code.setErrorHandler(&errorHandler);
+
+#ifndef ASMJIT_NO_LOGGING
+ if (_verbose) {
+ code.setLogger(&fileLogger);
+ }
+ else {
+ stringLogger.clear();
+ code.setLogger(&stringLogger);
+ }
+#endif
+
+ printf("[Test] %s", test->name());
+
+#ifndef ASMJIT_NO_LOGGING
+ if (_verbose) printf("\n");
+#endif
+
+ x86::Compiler cc(&code);
+ test->compile(cc);
+
+ void* func = nullptr;
+ Error err = errorHandler._err;
+
+ if (!err)
+ err = cc.finalize();
+
+#ifndef ASMJIT_NO_LOGGING
+ if (_dumpAsm) {
+ if (!_verbose) printf("\n");
+
+ String sb;
+ cc.dump(sb, kFormatFlags);
+ printf("%s", sb.data());
+ }
+#endif
+
+ if (err == kErrorOk)
+ err = runtime.add(&func, &code);
+
+ if (_verbose)
+ fflush(stdout);
+
+ if (err == kErrorOk) {
+ _outputSize += code.codeSize();
+
+ StringTmp<128> result;
+ StringTmp<128> expect;
+
+ if (test->run(func, result, expect)) {
+ if (!_verbose) printf(" [OK]\n");
+ }
+ else {
+ if (!_verbose) printf(" [FAILED]\n");
+
+#ifndef ASMJIT_NO_LOGGING
+ if (!_verbose) printf("%s", stringLogger.data());
+#endif
+
+ printf("[Status]\n");
+ printf(" Returned: %s\n", result.data());
+ printf(" Expected: %s\n", expect.data());
+
+ _nFailed++;
+ }
+
+ if (_dumpAsm)
+ printf("\n");
+
+ runtime.release(func);
+ }
+ else {
+ if (!_verbose) printf(" [FAILED]\n");
+
+#ifndef ASMJIT_NO_LOGGING
+ if (!_verbose) printf("%s", stringLogger.data());
+#endif
+
+ printf("[Status]\n");
+ printf(" ERROR 0x%08X: %s\n", unsigned(err), errorHandler._message.data());
+
+ _nFailed++;
+ }
+ }
+
+ if (_nFailed == 0)
+ printf("\n[PASSED] All %u tests passed\n", unsigned(_tests.size()));
+ else
+ printf("\n[FAILED] %u %s of %u failed\n", _nFailed, _nFailed == 1 ? "test" : "tests", unsigned(_tests.size()));
+
+ printf(" OutputSize=%zu\n", _outputSize);
+
+ return _nFailed == 0 ? 0 : 1;
+}
+
+// ============================================================================
+// [X86Test_AlignBase]
+// ============================================================================
+
+class X86Test_AlignBase : public X86Test {
+public:
+ X86Test_AlignBase(uint32_t argCount, uint32_t alignment, bool preserveFP)
+ : _argCount(argCount),
+ _alignment(alignment),
+ _preserveFP(preserveFP) {
+ _name.assignFormat("AlignBase {NumArgs=%u Alignment=%u PreserveFP=%c}", argCount, alignment, preserveFP ? 'Y' : 'N');
+ }
+
+ static void add(X86TestApp& app) {
+ for (uint32_t i = 0; i <= 16; i++) {
+ for (uint32_t a = 16; a <= 32; a += 16) {
+ app.add(new X86Test_AlignBase(i, a, true));
+ app.add(new X86Test_AlignBase(i, a, false));
+ }
+ }
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ uint32_t i;
+ uint32_t argCount = _argCount;
+
+ FuncSignatureBuilder signature(CallConv::kIdHost);
+ signature.setRetT<int>();
+ for (i = 0; i < argCount; i++)
+ signature.addArgT<int>();
+
+ cc.addFunc(signature);
+ if (_preserveFP)
+ cc.func()->frame().setPreservedFP();
+
+ x86::Gp gpVar = cc.newIntPtr("gpVar");
+ x86::Gp gpSum;
+ x86::Mem stack = cc.newStack(_alignment, _alignment);
+
+ // Do a sum of arguments to verify a possible relocation when misaligned.
+ if (argCount) {
+ for (i = 0; i < argCount; i++) {
+ x86::Gp gpArg = cc.newInt32("gpArg%u", i);
+ cc.setArg(i, gpArg);
+
+ if (i == 0)
+ gpSum = gpArg;
+ else
+ cc.add(gpSum, gpArg);
+ }
+ }
+
+ // Check alignment of xmmVar (has to be 16).
+ cc.lea(gpVar, stack);
+ cc.and_(gpVar, _alignment - 1);
+
+ // Add a sum of all arguments to check if they are correct.
+ if (argCount)
+ cc.or_(gpVar.r32(), gpSum);
+
+ cc.ret(gpVar);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef unsigned int U;
+
+ typedef U (*Func0)();
+ typedef U (*Func1)(U);
+ typedef U (*Func2)(U, U);
+ typedef U (*Func3)(U, U, U);
+ typedef U (*Func4)(U, U, U, U);
+ typedef U (*Func5)(U, U, U, U, U);
+ typedef U (*Func6)(U, U, U, U, U, U);
+ typedef U (*Func7)(U, U, U, U, U, U, U);
+ typedef U (*Func8)(U, U, U, U, U, U, U, U);
+ typedef U (*Func9)(U, U, U, U, U, U, U, U, U);
+ typedef U (*Func10)(U, U, U, U, U, U, U, U, U, U);
+ typedef U (*Func11)(U, U, U, U, U, U, U, U, U, U, U);
+ typedef U (*Func12)(U, U, U, U, U, U, U, U, U, U, U, U);
+ typedef U (*Func13)(U, U, U, U, U, U, U, U, U, U, U, U, U);
+ typedef U (*Func14)(U, U, U, U, U, U, U, U, U, U, U, U, U, U);
+ typedef U (*Func15)(U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
+ typedef U (*Func16)(U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
+
+ unsigned int resultRet = 0;
+ unsigned int expectRet = 0;
+
+ switch (_argCount) {
+ case 0:
+ resultRet = ptr_as_func<Func0>(_func)();
+ expectRet = 0;
+ break;
+ case 1:
+ resultRet = ptr_as_func<Func1>(_func)(1);
+ expectRet = 1;
+ break;
+ case 2:
+ resultRet = ptr_as_func<Func2>(_func)(1, 2);
+ expectRet = 1 + 2;
+ break;
+ case 3:
+ resultRet = ptr_as_func<Func3>(_func)(1, 2, 3);
+ expectRet = 1 + 2 + 3;
+ break;
+ case 4:
+ resultRet = ptr_as_func<Func4>(_func)(1, 2, 3, 4);
+ expectRet = 1 + 2 + 3 + 4;
+ break;
+ case 5:
+ resultRet = ptr_as_func<Func5>(_func)(1, 2, 3, 4, 5);
+ expectRet = 1 + 2 + 3 + 4 + 5;
+ break;
+ case 6:
+ resultRet = ptr_as_func<Func6>(_func)(1, 2, 3, 4, 5, 6);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6;
+ break;
+ case 7:
+ resultRet = ptr_as_func<Func7>(_func)(1, 2, 3, 4, 5, 6, 7);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7;
+ break;
+ case 8:
+ resultRet = ptr_as_func<Func8>(_func)(1, 2, 3, 4, 5, 6, 7, 8);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8;
+ break;
+ case 9:
+ resultRet = ptr_as_func<Func9>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9;
+ break;
+ case 10:
+ resultRet = ptr_as_func<Func10>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10;
+ break;
+ case 11:
+ resultRet = ptr_as_func<Func11>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11;
+ break;
+ case 12:
+ resultRet = ptr_as_func<Func12>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12;
+ break;
+ case 13:
+ resultRet = ptr_as_func<Func13>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13;
+ break;
+ case 14:
+ resultRet = ptr_as_func<Func14>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14;
+ break;
+ case 15:
+ resultRet = ptr_as_func<Func15>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15;
+ break;
+ case 16:
+ resultRet = ptr_as_func<Func16>(_func)(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
+ expectRet = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16;
+ break;
+ }
+
+ result.assignFormat("ret={%u, %u}", resultRet >> 28, resultRet & 0x0FFFFFFFu);
+ expect.assignFormat("ret={%u, %u}", expectRet >> 28, expectRet & 0x0FFFFFFFu);
+
+ return resultRet == expectRet;
+ }
+
+ uint32_t _argCount;
+ uint32_t _alignment;
+ bool _preserveFP;
+};
+
+// ============================================================================
+// [X86Test_NoCode]
+// ============================================================================
+
+class X86Test_NoCode : public X86Test {
+public:
+ X86Test_NoCode() : X86Test("NoCode") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_NoCode());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost));
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ DebugUtils::unused(result, expect);
+
+ typedef void(*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ func();
+ return true;
+ }
+};
+
+// ============================================================================
+// [X86Test_AlignNone]
+// ============================================================================
+
+class X86Test_NoAlign : public X86Test {
+public:
+ X86Test_NoAlign() : X86Test("NoAlign") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_NoAlign());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost));
+ cc.align(kAlignCode, 0);
+ cc.align(kAlignCode, 1);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ DebugUtils::unused(result, expect);
+
+ typedef void (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ func();
+ return true;
+ }
+};
+
+// ============================================================================
+// [X86Test_JumpMerge]
+// ============================================================================
+
+class X86Test_JumpMerge : public X86Test {
+public:
+ X86Test_JumpMerge() : X86Test("JumpMerge") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_JumpMerge());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, int*, int>(CallConv::kIdHost));
+
+ Label L0 = cc.newLabel();
+ Label L1 = cc.newLabel();
+ Label L2 = cc.newLabel();
+ Label LEnd = cc.newLabel();
+
+ x86::Gp dst = cc.newIntPtr("dst");
+ x86::Gp val = cc.newInt32("val");
+
+ cc.setArg(0, dst);
+ cc.setArg(1, val);
+
+ cc.cmp(val, 0);
+ cc.je(L2);
+
+ cc.cmp(val, 1);
+ cc.je(L1);
+
+ cc.cmp(val, 2);
+ cc.je(L0);
+
+ cc.mov(x86::dword_ptr(dst), val);
+ cc.jmp(LEnd);
+
+ // On purpose. This tests whether the CFG constructs a single basic-block
+ // from multiple labels next to each other.
+ cc.bind(L0);
+ cc.bind(L1);
+ cc.bind(L2);
+ cc.mov(x86::dword_ptr(dst), 0);
+
+ cc.bind(LEnd);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void(*Func)(int*, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int arr[5] = { -1, -1, -1, -1, -1 };
+ int exp[5] = { 0, 0, 0, 3, 4 };
+
+ for (int i = 0; i < 5; i++)
+ func(&arr[i], i);
+
+ result.assignFormat("ret={%d, %d, %d, %d, %d}", arr[0], arr[1], arr[2], arr[3], arr[4]);
+ expect.assignFormat("ret={%d, %d, %d, %d, %d}", exp[0], exp[1], exp[2], exp[3], exp[4]);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_JumpCross]
+// ============================================================================
+
+class X86Test_JumpCross : public X86Test {
+public:
+ X86Test_JumpCross() : X86Test("JumpCross") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_JumpCross());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost));
+
+ Label L1 = cc.newLabel();
+ Label L2 = cc.newLabel();
+ Label L3 = cc.newLabel();
+
+ cc.jmp(L2);
+
+ cc.bind(L1);
+ cc.jmp(L3);
+
+ cc.bind(L2);
+ cc.jmp(L1);
+
+ cc.bind(L3);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ DebugUtils::unused(result, expect);
+
+ typedef void (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ func();
+ return true;
+ }
+};
+
+// ============================================================================
+// [X86Test_JumpMany]
+// ============================================================================
+
+class X86Test_JumpMany : public X86Test {
+public:
+ X86Test_JumpMany() : X86Test("JumpMany") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_JumpMany());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+ for (uint32_t i = 0; i < 1000; i++) {
+ Label L = cc.newLabel();
+ cc.jmp(L);
+ cc.bind(L);
+ }
+
+ x86::Gp ret = cc.newInt32("ret");
+ cc.xor_(ret, ret);
+ cc.ret(ret);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 0;
+
+ result.assignFormat("ret={%d}", resultRet);
+ expect.assignFormat("ret={%d}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_JumpUnreachable1]
+// ============================================================================
+
+class X86Test_JumpUnreachable1 : public X86Test {
+public:
+ X86Test_JumpUnreachable1() : X86Test("JumpUnreachable1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_JumpUnreachable1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost));
+
+ Label L_1 = cc.newLabel();
+ Label L_2 = cc.newLabel();
+ Label L_3 = cc.newLabel();
+ Label L_4 = cc.newLabel();
+ Label L_5 = cc.newLabel();
+ Label L_6 = cc.newLabel();
+ Label L_7 = cc.newLabel();
+
+ x86::Gp v0 = cc.newUInt32("v0");
+ x86::Gp v1 = cc.newUInt32("v1");
+
+ cc.bind(L_2);
+ cc.bind(L_3);
+
+ cc.jmp(L_1);
+
+ cc.bind(L_5);
+ cc.mov(v0, 0);
+
+ cc.bind(L_6);
+ cc.jmp(L_3);
+ cc.mov(v1, 1);
+ cc.jmp(L_1);
+
+ cc.bind(L_4);
+ cc.jmp(L_2);
+ cc.bind(L_7);
+ cc.add(v0, v1);
+
+ cc.align(kAlignCode, 16);
+ cc.bind(L_1);
+ cc.ret();
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ func();
+
+ result.appendString("ret={}");
+ expect.appendString("ret={}");
+
+ return true;
+ }
+};
+
+// ============================================================================
+// [X86Test_JumpUnreachable2]
+// ============================================================================
+
+class X86Test_JumpUnreachable2 : public X86Test {
+public:
+ X86Test_JumpUnreachable2() : X86Test("JumpUnreachable2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_JumpUnreachable2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void>(CallConv::kIdHost));
+
+ Label L_1 = cc.newLabel();
+ Label L_2 = cc.newLabel();
+
+ x86::Gp v0 = cc.newUInt32("v0");
+ x86::Gp v1 = cc.newUInt32("v1");
+
+ cc.jmp(L_1);
+ cc.bind(L_2);
+ cc.mov(v0, 1);
+ cc.mov(v1, 2);
+ cc.cmp(v0, v1);
+ cc.jz(L_2);
+ cc.jmp(L_1);
+
+ cc.bind(L_1);
+ cc.ret();
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ func();
+
+ result.appendString("ret={}");
+ expect.appendString("ret={}");
+
+ return true;
+ }
+};
+
+// ============================================================================
+// [X86Test_JumpTable]
+// ============================================================================
+
+class X86Test_JumpTable : public X86Test {
+public:
+ bool _annotated;
+
+ X86Test_JumpTable(bool annotated)
+ : X86Test("X86Test_JumpTable"),
+ _annotated(annotated) {
+ _name.assignFormat("JumpTable {%s}", annotated ? "Annotated" : "Unknown Reg/Mem");
+ }
+
+ enum Operator {
+ kOperatorAdd = 0,
+ kOperatorSub = 1,
+ kOperatorMul = 2,
+ kOperatorDiv = 3
+ };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_JumpTable(false));
+ app.add(new X86Test_JumpTable(true));
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<float, float, float, uint32_t>(CallConv::kIdHost));
+
+ x86::Xmm a = cc.newXmmSs("a");
+ x86::Xmm b = cc.newXmmSs("b");
+ x86::Gp op = cc.newUInt32("op");
+ x86::Gp target = cc.newIntPtr("target");
+ x86::Gp offset = cc.newIntPtr("offset");
+
+ Label L_End = cc.newLabel();
+
+ Label L_Table = cc.newLabel();
+ Label L_Add = cc.newLabel();
+ Label L_Sub = cc.newLabel();
+ Label L_Mul = cc.newLabel();
+ Label L_Div = cc.newLabel();
+
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+ cc.setArg(2, op);
+
+ cc.lea(offset, x86::ptr(L_Table));
+ if (cc.is64Bit())
+ cc.movsxd(target, x86::dword_ptr(offset, op.cloneAs(offset), 2));
+ else
+ cc.mov(target, x86::dword_ptr(offset, op.cloneAs(offset), 2));
+ cc.add(target, offset);
+
+ // JumpAnnotation allows to annotate all possible jump targets of
+ // instructions where it cannot be deduced from operands.
+ if (_annotated) {
+ JumpAnnotation* annotation = cc.newJumpAnnotation();
+ annotation->addLabel(L_Add);
+ annotation->addLabel(L_Sub);
+ annotation->addLabel(L_Mul);
+ annotation->addLabel(L_Div);
+ cc.jmp(target, annotation);
+ }
+ else {
+ cc.jmp(target);
+ }
+
+ cc.bind(L_Add);
+ cc.addss(a, b);
+ cc.jmp(L_End);
+
+ cc.bind(L_Sub);
+ cc.subss(a, b);
+ cc.jmp(L_End);
+
+ cc.bind(L_Mul);
+ cc.mulss(a, b);
+ cc.jmp(L_End);
+
+ cc.bind(L_Div);
+ cc.divss(a, b);
+
+ cc.bind(L_End);
+ cc.ret(a);
+
+ cc.endFunc();
+
+ cc.bind(L_Table);
+ cc.embedLabelDelta(L_Add, L_Table, 4);
+ cc.embedLabelDelta(L_Sub, L_Table, 4);
+ cc.embedLabelDelta(L_Mul, L_Table, 4);
+ cc.embedLabelDelta(L_Div, L_Table, 4);
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef float (*Func)(float, float, uint32_t);
+ Func func = ptr_as_func<Func>(_func);
+
+ float results[4];
+ float expected[4];
+
+ results[0] = func(33.0f, 14.0f, kOperatorAdd);
+ results[1] = func(33.0f, 14.0f, kOperatorSub);
+ results[2] = func(10.0f, 6.0f, kOperatorMul);
+ results[3] = func(80.0f, 8.0f, kOperatorDiv);
+
+ expected[0] = 47.0f;
+ expected[1] = 19.0f;
+ expected[2] = 60.0f;
+ expected[3] = 10.0f;
+
+ result.assignFormat("ret={%f, %f, %f, %f}", results[0], results[1], results[2], results[3]);
+ expect.assignFormat("ret={%f, %f, %f, %f}", expected[0], expected[1], expected[2], expected[3]);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocBase]
+// ============================================================================
+
+class X86Test_AllocBase : public X86Test {
+public:
+ X86Test_AllocBase() : X86Test("AllocBase") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocBase());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ x86::Gp v0 = cc.newInt32("v0");
+ x86::Gp v1 = cc.newInt32("v1");
+ x86::Gp v2 = cc.newInt32("v2");
+ x86::Gp v3 = cc.newInt32("v3");
+ x86::Gp v4 = cc.newInt32("v4");
+
+ cc.xor_(v0, v0);
+
+ cc.mov(v1, 1);
+ cc.mov(v2, 2);
+ cc.mov(v3, 3);
+ cc.mov(v4, 4);
+
+ cc.add(v0, v1);
+ cc.add(v0, v2);
+ cc.add(v0, v3);
+ cc.add(v0, v4);
+
+ cc.ret(v0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 1 + 2 + 3 + 4;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocMany1]
+// ============================================================================
+
+class X86Test_AllocMany1 : public X86Test {
+public:
+ X86Test_AllocMany1() : X86Test("AllocMany1") {}
+
+ enum { kCount = 8 };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocMany1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, int*, int*>(CallConv::kIdHost));
+
+ x86::Gp a0 = cc.newIntPtr("a0");
+ x86::Gp a1 = cc.newIntPtr("a1");
+
+ cc.setArg(0, a0);
+ cc.setArg(1, a1);
+
+ // Create some variables.
+ x86::Gp t = cc.newInt32("t");
+ x86::Gp x[kCount];
+
+ uint32_t i;
+
+ // Setup variables (use mov with reg/imm to se if register allocator works).
+ for (i = 0; i < kCount; i++) x[i] = cc.newInt32("x%u", i);
+ for (i = 0; i < kCount; i++) cc.mov(x[i], int(i + 1));
+
+ // Make sum (addition).
+ cc.xor_(t, t);
+ for (i = 0; i < kCount; i++) cc.add(t, x[i]);
+
+ // Store result to a given pointer in first argument.
+ cc.mov(x86::dword_ptr(a0), t);
+
+ // Clear t.
+ cc.xor_(t, t);
+
+ // Make sum (subtraction).
+ for (i = 0; i < kCount; i++) cc.sub(t, x[i]);
+
+ // Store result to a given pointer in second argument.
+ cc.mov(x86::dword_ptr(a1), t);
+
+ // End of function.
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(int*, int*);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultX;
+ int resultY;
+
+ int expectX = 36;
+ int expectY = -36;
+
+ func(&resultX, &resultY);
+
+ result.assignFormat("ret={x=%d, y=%d}", resultX, resultY);
+ expect.assignFormat("ret={x=%d, y=%d}", expectX, expectY);
+
+ return resultX == expectX && resultY == expectY;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocMany2]
+// ============================================================================
+
+class X86Test_AllocMany2 : public X86Test {
+public:
+ X86Test_AllocMany2() : X86Test("AllocMany2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocMany2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, uint32_t*>(CallConv::kIdHost));
+
+ x86::Gp a = cc.newIntPtr("a");
+ x86::Gp v[32];
+
+ uint32_t i;
+ cc.setArg(0, a);
+
+ for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) v[i] = cc.newInt32("v%d", i);
+ for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.xor_(v[i], v[i]);
+
+ x86::Gp x = cc.newInt32("x");
+ Label L = cc.newLabel();
+
+ cc.mov(x, 32);
+ cc.bind(L);
+ for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.add(v[i], i);
+
+ cc.dec(x);
+ cc.jnz(L);
+ for (i = 0; i < ASMJIT_ARRAY_SIZE(v); i++) cc.mov(x86::dword_ptr(a, int(i * 4)), v[i]);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(uint32_t*);
+ Func func = ptr_as_func<Func>(_func);
+
+ uint32_t i;
+ uint32_t resultBuf[32];
+ uint32_t expectBuf[32];
+
+ for (i = 0; i < ASMJIT_ARRAY_SIZE(resultBuf); i++)
+ expectBuf[i] = i * 32;
+ func(resultBuf);
+
+ for (i = 0; i < ASMJIT_ARRAY_SIZE(resultBuf); i++) {
+ if (i != 0) {
+ result.appendChar(',');
+ expect.appendChar(',');
+ }
+
+ result.appendFormat("%u", resultBuf[i]);
+ expect.appendFormat("%u", expectBuf[i]);
+ }
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocImul1]
+// ============================================================================
+
+class X86Test_AllocImul1 : public X86Test {
+public:
+ X86Test_AllocImul1() : X86Test("AllocImul1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocImul1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, int*, int*, int, int>(CallConv::kIdHost));
+
+ x86::Gp dstHi = cc.newIntPtr("dstHi");
+ x86::Gp dstLo = cc.newIntPtr("dstLo");
+
+ x86::Gp vHi = cc.newInt32("vHi");
+ x86::Gp vLo = cc.newInt32("vLo");
+ x86::Gp src = cc.newInt32("src");
+
+ cc.setArg(0, dstHi);
+ cc.setArg(1, dstLo);
+ cc.setArg(2, vLo);
+ cc.setArg(3, src);
+
+ cc.imul(vHi, vLo, src);
+
+ cc.mov(x86::dword_ptr(dstHi), vHi);
+ cc.mov(x86::dword_ptr(dstLo), vLo);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(int*, int*, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int v0 = 4;
+ int v1 = 4;
+
+ int resultHi;
+ int resultLo;
+
+ int expectHi = 0;
+ int expectLo = v0 * v1;
+
+ func(&resultHi, &resultLo, v0, v1);
+
+ result.assignFormat("hi=%d, lo=%d", resultHi, resultLo);
+ expect.assignFormat("hi=%d, lo=%d", expectHi, expectLo);
+
+ return resultHi == expectHi && resultLo == expectLo;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocImul2]
+// ============================================================================
+
+class X86Test_AllocImul2 : public X86Test {
+public:
+ X86Test_AllocImul2() : X86Test("AllocImul2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocImul2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, int*, const int*>(CallConv::kIdHost));
+
+ x86::Gp dst = cc.newIntPtr("dst");
+ x86::Gp src = cc.newIntPtr("src");
+
+ cc.setArg(0, dst);
+ cc.setArg(1, src);
+
+ for (unsigned int i = 0; i < 4; i++) {
+ x86::Gp x = cc.newInt32("x");
+ x86::Gp y = cc.newInt32("y");
+ x86::Gp hi = cc.newInt32("hi");
+
+ cc.mov(x, x86::dword_ptr(src, 0));
+ cc.mov(y, x86::dword_ptr(src, 4));
+
+ cc.imul(hi, x, y);
+ cc.add(x86::dword_ptr(dst, 0), hi);
+ cc.add(x86::dword_ptr(dst, 4), x);
+ }
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(int*, const int*);
+ Func func = ptr_as_func<Func>(_func);
+
+ int src[2] = { 4, 9 };
+ int resultRet[2] = { 0, 0 };
+ int expectRet[2] = { 0, (4 * 9) * 4 };
+
+ func(resultRet, src);
+
+ result.assignFormat("ret={%d, %d}", resultRet[0], resultRet[1]);
+ expect.assignFormat("ret={%d, %d}", expectRet[0], expectRet[1]);
+
+ return resultRet[0] == expectRet[0] && resultRet[1] == expectRet[1];
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocIdiv1]
+// ============================================================================
+
+class X86Test_AllocIdiv1 : public X86Test {
+public:
+ X86Test_AllocIdiv1() : X86Test("AllocIdiv1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocIdiv1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+ x86::Gp dummy = cc.newInt32("dummy");
+
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ cc.xor_(dummy, dummy);
+ cc.idiv(dummy, a, b);
+
+ cc.ret(a);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int v0 = 2999;
+ int v1 = 245;
+
+ int resultRet = func(v0, v1);
+ int expectRet = 2999 / 245;
+
+ result.assignFormat("result=%d", resultRet);
+ expect.assignFormat("result=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocSetz]
+// ============================================================================
+
+class X86Test_AllocSetz : public X86Test {
+public:
+ X86Test_AllocSetz() : X86Test("AllocSetz") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocSetz());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, int, int, char*>(CallConv::kIdHost));
+
+ x86::Gp src0 = cc.newInt32("src0");
+ x86::Gp src1 = cc.newInt32("src1");
+ x86::Gp dst0 = cc.newIntPtr("dst0");
+
+ cc.setArg(0, src0);
+ cc.setArg(1, src1);
+ cc.setArg(2, dst0);
+
+ cc.cmp(src0, src1);
+ cc.setz(x86::byte_ptr(dst0));
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(int, int, char*);
+ Func func = ptr_as_func<Func>(_func);
+
+ char resultBuf[4];
+ char expectBuf[4] = { 1, 0, 0, 1 };
+
+ func(0, 0, &resultBuf[0]); // We are expecting 1 (0 == 0).
+ func(0, 1, &resultBuf[1]); // We are expecting 0 (0 != 1).
+ func(1, 0, &resultBuf[2]); // We are expecting 0 (1 != 0).
+ func(1, 1, &resultBuf[3]); // We are expecting 1 (1 == 1).
+
+ result.assignFormat("out={%d, %d, %d, %d}", resultBuf[0], resultBuf[1], resultBuf[2], resultBuf[3]);
+ expect.assignFormat("out={%d, %d, %d, %d}", expectBuf[0], expectBuf[1], expectBuf[2], expectBuf[3]);
+
+ return resultBuf[0] == expectBuf[0] &&
+ resultBuf[1] == expectBuf[1] &&
+ resultBuf[2] == expectBuf[2] &&
+ resultBuf[3] == expectBuf[3] ;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocShlRor]
+// ============================================================================
+
+class X86Test_AllocShlRor : public X86Test {
+public:
+ X86Test_AllocShlRor() : X86Test("AllocShlRor") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocShlRor());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, int*, int, int, int>(CallConv::kIdHost));
+
+ x86::Gp dst = cc.newIntPtr("dst");
+ x86::Gp var = cc.newInt32("var");
+ x86::Gp vShlParam = cc.newInt32("vShlParam");
+ x86::Gp vRorParam = cc.newInt32("vRorParam");
+
+ cc.setArg(0, dst);
+ cc.setArg(1, var);
+ cc.setArg(2, vShlParam);
+ cc.setArg(3, vRorParam);
+
+ cc.shl(var, vShlParam);
+ cc.ror(var, vRorParam);
+
+ cc.mov(x86::dword_ptr(dst), var);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(int*, int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int v0 = 0x000000FF;
+
+ int resultRet;
+ int expectRet = 0x0000FF00;
+
+ func(&resultRet, v0, 16, 8);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocGpbLo]
+// ============================================================================
+
+class X86Test_AllocGpbLo1 : public X86Test {
+public:
+ X86Test_AllocGpbLo1() : X86Test("AllocGpbLo1") {}
+
+ enum { kCount = 32 };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocGpbLo1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<uint32_t, uint32_t*>(CallConv::kIdHost));
+
+ x86::Gp rPtr = cc.newUIntPtr("rPtr");
+ x86::Gp rSum = cc.newUInt32("rSum");
+
+ cc.setArg(0, rPtr);
+
+ x86::Gp x[kCount];
+ uint32_t i;
+
+ for (i = 0; i < kCount; i++) {
+ x[i] = cc.newUInt32("x%u", i);
+ }
+
+ // Init pseudo-regs with values from our array.
+ for (i = 0; i < kCount; i++) {
+ cc.mov(x[i], x86::dword_ptr(rPtr, int(i * 4)));
+ }
+
+ for (i = 2; i < kCount; i++) {
+ // Add and truncate to 8 bit; no purpose, just mess with jit.
+ cc.add (x[i ], x[i-1]);
+ cc.movzx(x[i ], x[i ].r8());
+ cc.movzx(x[i-2], x[i-1].r8());
+ cc.movzx(x[i-1], x[i-2].r8());
+ }
+
+ // Sum up all computed values.
+ cc.mov(rSum, 0);
+ for (i = 0; i < kCount; i++) {
+ cc.add(rSum, x[i]);
+ }
+
+ // Return the sum.
+ cc.ret(rSum);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef uint32_t (*Func)(uint32_t*);
+ Func func = ptr_as_func<Func>(_func);
+
+ uint32_t i;
+ uint32_t buf[kCount];
+ uint32_t resultRet;
+ uint32_t expectRet;
+
+ expectRet = 0;
+ for (i = 0; i < kCount; i++) {
+ buf[i] = 1;
+ }
+
+ for (i = 2; i < kCount; i++) {
+ buf[i ]+= buf[i-1];
+ buf[i ] = buf[i ] & 0xFF;
+ buf[i-2] = buf[i-1] & 0xFF;
+ buf[i-1] = buf[i-2] & 0xFF;
+ }
+
+ for (i = 0; i < kCount; i++) {
+ expectRet += buf[i];
+ }
+
+ for (i = 0; i < kCount; i++) {
+ buf[i] = 1;
+ }
+ resultRet = func(buf);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocGpbLo2]
+// ============================================================================
+
+class X86Test_AllocGpbLo2 : public X86Test {
+public:
+ X86Test_AllocGpbLo2() : X86Test("AllocGpbLo2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocGpbLo2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<uint32_t, uint32_t>(CallConv::kIdHost));
+
+ x86::Gp v = cc.newUInt32("v");
+ cc.setArg(0, v);
+ cc.mov(v.r8(), 0xFF);
+ cc.ret(v);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef uint32_t (*Func)(uint32_t);
+ Func func = ptr_as_func<Func>(_func);
+
+ uint32_t resultRet = func(0x12345678u);
+ uint32_t expectRet = 0x123456FFu;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocRepMovsb]
+// ============================================================================
+
+class X86Test_AllocRepMovsb : public X86Test {
+public:
+ X86Test_AllocRepMovsb() : X86Test("AllocRepMovsb") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocRepMovsb());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, void*, void*, size_t>(CallConv::kIdHost));
+
+ x86::Gp dst = cc.newIntPtr("dst");
+ x86::Gp src = cc.newIntPtr("src");
+ x86::Gp cnt = cc.newIntPtr("cnt");
+
+ cc.setArg(0, dst);
+ cc.setArg(1, src);
+ cc.setArg(2, cnt);
+
+ cc.rep(cnt).movs(x86::byte_ptr(dst), x86::byte_ptr(src));
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(void*, void*, size_t);
+ Func func = ptr_as_func<Func>(_func);
+
+ char dst[20] = { 0 };
+ char src[20] = "Hello AsmJit!";
+ func(dst, src, strlen(src) + 1);
+
+ result.assignFormat("ret=\"%s\"", dst);
+ expect.assignFormat("ret=\"%s\"", src);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocIfElse1]
+// ============================================================================
+
+class X86Test_AllocIfElse1 : public X86Test {
+public:
+ X86Test_AllocIfElse1() : X86Test("AllocIfElse1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocIfElse1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ x86::Gp v1 = cc.newInt32("v1");
+ x86::Gp v2 = cc.newInt32("v2");
+
+ Label L_1 = cc.newLabel();
+ Label L_2 = cc.newLabel();
+
+ cc.setArg(0, v1);
+ cc.setArg(1, v2);
+
+ cc.cmp(v1, v2);
+ cc.jg(L_1);
+
+ cc.mov(v1, 1);
+ cc.jmp(L_2);
+
+ cc.bind(L_1);
+ cc.mov(v1, 2);
+
+ cc.bind(L_2);
+ cc.ret(v1);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int a = func(0, 1);
+ int b = func(1, 0);
+
+ result.appendFormat("ret={%d, %d}", a, b);
+ expect.appendFormat("ret={%d, %d}", 1, 2);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocIfElse2]
+// ============================================================================
+
+class X86Test_AllocIfElse2 : public X86Test {
+public:
+ X86Test_AllocIfElse2() : X86Test("AllocIfElse2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocIfElse2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ x86::Gp v1 = cc.newInt32("v1");
+ x86::Gp v2 = cc.newInt32("v2");
+
+ Label L_1 = cc.newLabel();
+ Label L_2 = cc.newLabel();
+ Label L_3 = cc.newLabel();
+ Label L_4 = cc.newLabel();
+
+ cc.setArg(0, v1);
+ cc.setArg(1, v2);
+
+ cc.jmp(L_1);
+ cc.bind(L_2);
+ cc.jmp(L_4);
+ cc.bind(L_1);
+
+ cc.cmp(v1, v2);
+ cc.jg(L_3);
+
+ cc.mov(v1, 1);
+ cc.jmp(L_2);
+
+ cc.bind(L_3);
+ cc.mov(v1, 2);
+ cc.jmp(L_2);
+
+ cc.bind(L_4);
+
+ cc.ret(v1);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int a = func(0, 1);
+ int b = func(1, 0);
+
+ result.appendFormat("ret={%d, %d}", a, b);
+ expect.appendFormat("ret={%d, %d}", 1, 2);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocIfElse3]
+// ============================================================================
+
+class X86Test_AllocIfElse3 : public X86Test {
+public:
+ X86Test_AllocIfElse3() : X86Test("AllocIfElse3") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocIfElse3());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ x86::Gp v1 = cc.newInt32("v1");
+ x86::Gp v2 = cc.newInt32("v2");
+ x86::Gp counter = cc.newInt32("counter");
+
+ Label L_1 = cc.newLabel();
+ Label L_Loop = cc.newLabel();
+ Label L_Exit = cc.newLabel();
+
+ cc.setArg(0, v1);
+ cc.setArg(1, v2);
+
+ cc.cmp(v1, v2);
+ cc.jg(L_1);
+
+ cc.mov(counter, 0);
+
+ cc.bind(L_Loop);
+ cc.mov(v1, counter);
+
+ cc.inc(counter);
+ cc.cmp(counter, 1);
+ cc.jle(L_Loop);
+ cc.jmp(L_Exit);
+
+ cc.bind(L_1);
+ cc.mov(v1, 2);
+
+ cc.bind(L_Exit);
+ cc.ret(v1);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int a = func(0, 1);
+ int b = func(1, 0);
+
+ result.appendFormat("ret={%d, %d}", a, b);
+ expect.appendFormat("ret={%d, %d}", 1, 2);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocIfElse4]
+// ============================================================================
+
+class X86Test_AllocIfElse4 : public X86Test {
+public:
+ X86Test_AllocIfElse4() : X86Test("AllocIfElse4") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocIfElse4());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ x86::Gp v1 = cc.newInt32("v1");
+ x86::Gp v2 = cc.newInt32("v2");
+ x86::Gp counter = cc.newInt32("counter");
+
+ Label L_1 = cc.newLabel();
+ Label L_Loop1 = cc.newLabel();
+ Label L_Loop2 = cc.newLabel();
+ Label L_Exit = cc.newLabel();
+
+ cc.mov(counter, 0);
+
+ cc.setArg(0, v1);
+ cc.setArg(1, v2);
+
+ cc.cmp(v1, v2);
+ cc.jg(L_1);
+
+ cc.bind(L_Loop1);
+ cc.mov(v1, counter);
+
+ cc.inc(counter);
+ cc.cmp(counter, 1);
+ cc.jle(L_Loop1);
+ cc.jmp(L_Exit);
+
+ cc.bind(L_1);
+ cc.bind(L_Loop2);
+ cc.mov(v1, counter);
+ cc.inc(counter);
+ cc.cmp(counter, 2);
+ cc.jle(L_Loop2);
+
+ cc.bind(L_Exit);
+ cc.ret(v1);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int a = func(0, 1);
+ int b = func(1, 0);
+
+ result.appendFormat("ret={%d, %d}", a, b);
+ expect.appendFormat("ret={%d, %d}", 1, 2);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocInt8]
+// ============================================================================
+
+class X86Test_AllocInt8 : public X86Test {
+public:
+ X86Test_AllocInt8() : X86Test("AllocInt8") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocInt8());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp x = cc.newInt8("x");
+ x86::Gp y = cc.newInt32("y");
+
+ cc.addFunc(FuncSignatureT<int, char>(CallConv::kIdHost));
+ cc.setArg(0, x);
+
+ cc.movsx(y, x);
+
+ cc.ret(y);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(char);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(-13);
+ int expectRet = -13;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocUnhandledArg]
+// ============================================================================
+
+class X86Test_AllocUnhandledArg : public X86Test {
+public:
+ X86Test_AllocUnhandledArg() : X86Test("AllocUnhandledArg") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocUnhandledArg());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+
+ x86::Gp x = cc.newInt32("x");
+ cc.setArg(2, x);
+ cc.ret(x);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(42, 155, 199);
+ int expectRet = 199;
+
+ result.assignFormat("ret={%d}", resultRet);
+ expect.assignFormat("ret={%d}", expectRet);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocArgsIntPtr]
+// ============================================================================
+
+class X86Test_AllocArgsIntPtr : public X86Test {
+public:
+ X86Test_AllocArgsIntPtr() : X86Test("AllocArgsIntPtr") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocArgsIntPtr());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, void*, void*, void*, void*, void*, void*, void*, void*>(CallConv::kIdHost));
+
+ uint32_t i;
+ x86::Gp var[8];
+
+ for (i = 0; i < 8; i++) {
+ var[i] = cc.newIntPtr("var%u", i);
+ cc.setArg(i, var[i]);
+ }
+
+ for (i = 0; i < 8; i++) {
+ cc.add(var[i], int(i + 1));
+ }
+
+ // Move some data into buffer provided by arguments so we can verify if it
+ // really works without looking into assembler output.
+ for (i = 0; i < 8; i++) {
+ cc.add(x86::byte_ptr(var[i]), int(i + 1));
+ }
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(void*, void*, void*, void*, void*, void*, void*, void*);
+ Func func = ptr_as_func<Func>(_func);
+
+ uint8_t resultBuf[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+ uint8_t expectBuf[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+
+ func(resultBuf, resultBuf, resultBuf, resultBuf,
+ resultBuf, resultBuf, resultBuf, resultBuf);
+
+ result.assignFormat("buf={%d, %d, %d, %d, %d, %d, %d, %d, %d}",
+ resultBuf[0], resultBuf[1], resultBuf[2], resultBuf[3],
+ resultBuf[4], resultBuf[5], resultBuf[6], resultBuf[7],
+ resultBuf[8]);
+ expect.assignFormat("buf={%d, %d, %d, %d, %d, %d, %d, %d, %d}",
+ expectBuf[0], expectBuf[1], expectBuf[2], expectBuf[3],
+ expectBuf[4], expectBuf[5], expectBuf[6], expectBuf[7],
+ expectBuf[8]);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocArgsFloat]
+// ============================================================================
+
+class X86Test_AllocArgsFloat : public X86Test {
+public:
+ X86Test_AllocArgsFloat() : X86Test("AllocArgsFloat") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocArgsFloat());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, float, float, float, float, float, float, float, void*>(CallConv::kIdHost));
+
+ uint32_t i;
+
+ x86::Gp p = cc.newIntPtr("p");
+ x86::Xmm xv[7];
+
+ for (i = 0; i < 7; i++) {
+ xv[i] = cc.newXmmSs("xv%u", i);
+ cc.setArg(i, xv[i]);
+ }
+
+ cc.setArg(7, p);
+
+ cc.addss(xv[0], xv[1]);
+ cc.addss(xv[0], xv[2]);
+ cc.addss(xv[0], xv[3]);
+ cc.addss(xv[0], xv[4]);
+ cc.addss(xv[0], xv[5]);
+ cc.addss(xv[0], xv[6]);
+
+ cc.movss(x86::ptr(p), xv[0]);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(float, float, float, float, float, float, float, float*);
+ Func func = ptr_as_func<Func>(_func);
+
+ float resultRet;
+ float expectRet = 1.0f + 2.0f + 3.0f + 4.0f + 5.0f + 6.0f + 7.0f;
+
+ func(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, &resultRet);
+
+ result.assignFormat("ret={%g}", resultRet);
+ expect.assignFormat("ret={%g}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocArgsDouble]
+// ============================================================================
+
+class X86Test_AllocArgsDouble : public X86Test {
+public:
+ X86Test_AllocArgsDouble() : X86Test("AllocArgsDouble") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocArgsDouble());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<void, double, double, double, double, double, double, double, void*>(CallConv::kIdHost));
+
+ uint32_t i;
+
+ x86::Gp p = cc.newIntPtr("p");
+ x86::Xmm xv[7];
+
+ for (i = 0; i < 7; i++) {
+ xv[i] = cc.newXmmSd("xv%u", i);
+ cc.setArg(i, xv[i]);
+ }
+
+ cc.setArg(7, p);
+
+ cc.addsd(xv[0], xv[1]);
+ cc.addsd(xv[0], xv[2]);
+ cc.addsd(xv[0], xv[3]);
+ cc.addsd(xv[0], xv[4]);
+ cc.addsd(xv[0], xv[5]);
+ cc.addsd(xv[0], xv[6]);
+
+ cc.movsd(x86::ptr(p), xv[0]);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(double, double, double, double, double, double, double, double*);
+ Func func = ptr_as_func<Func>(_func);
+
+ double resultRet;
+ double expectRet = 1.0 + 2.0 + 3.0 + 4.0 + 5.0 + 6.0 + 7.0;
+
+ func(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, &resultRet);
+
+ result.assignFormat("ret={%g}", resultRet);
+ expect.assignFormat("ret={%g}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocRetFloat1]
+// ============================================================================
+
+class X86Test_AllocRetFloat1 : public X86Test {
+public:
+ X86Test_AllocRetFloat1() : X86Test("AllocRetFloat1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocRetFloat1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<float, float>(CallConv::kIdHost));
+
+ x86::Xmm x = cc.newXmmSs("x");
+ cc.setArg(0, x);
+ cc.ret(x);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef float (*Func)(float);
+ Func func = ptr_as_func<Func>(_func);
+
+ float resultRet = func(42.0f);
+ float expectRet = 42.0f;
+
+ result.assignFormat("ret={%g}", resultRet);
+ expect.assignFormat("ret={%g}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocRetFloat2]
+// ============================================================================
+
+class X86Test_AllocRetFloat2 : public X86Test {
+public:
+ X86Test_AllocRetFloat2() : X86Test("AllocRetFloat2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocRetFloat2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<float, float, float>(CallConv::kIdHost));
+
+ x86::Xmm x = cc.newXmmSs("x");
+ x86::Xmm y = cc.newXmmSs("y");
+
+ cc.setArg(0, x);
+ cc.setArg(1, y);
+
+ cc.addss(x, y);
+ cc.ret(x);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef float (*Func)(float, float);
+ Func func = ptr_as_func<Func>(_func);
+
+ float resultRet = func(1.0f, 2.0f);
+ float expectRet = 1.0f + 2.0f;
+
+ result.assignFormat("ret={%g}", resultRet);
+ expect.assignFormat("ret={%g}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocRetDouble1]
+// ============================================================================
+
+class X86Test_AllocRetDouble1 : public X86Test {
+public:
+ X86Test_AllocRetDouble1() : X86Test("AllocRetDouble1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocRetDouble1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<double, double>(CallConv::kIdHost));
+
+ x86::Xmm x = cc.newXmmSd("x");
+ cc.setArg(0, x);
+ cc.ret(x);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(double);
+ Func func = ptr_as_func<Func>(_func);
+
+ double resultRet = func(42.0);
+ double expectRet = 42.0;
+
+ result.assignFormat("ret={%g}", resultRet);
+ expect.assignFormat("ret={%g}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+// ============================================================================
+// [X86Test_AllocRetDouble2]
+// ============================================================================
+
+class X86Test_AllocRetDouble2 : public X86Test {
+public:
+ X86Test_AllocRetDouble2() : X86Test("AllocRetDouble2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocRetDouble2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<double, double, double>(CallConv::kIdHost));
+
+ x86::Xmm x = cc.newXmmSd("x");
+ x86::Xmm y = cc.newXmmSd("y");
+
+ cc.setArg(0, x);
+ cc.setArg(1, y);
+
+ cc.addsd(x, y);
+ cc.ret(x);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(double, double);
+ Func func = ptr_as_func<Func>(_func);
+
+ double resultRet = func(1.0, 2.0);
+ double expectRet = 1.0 + 2.0;
+
+ result.assignFormat("ret={%g}", resultRet);
+ expect.assignFormat("ret={%g}", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocStack]
+// ============================================================================
+
+class X86Test_AllocStack : public X86Test {
+public:
+ X86Test_AllocStack() : X86Test("AllocStack") {}
+
+ enum { kSize = 256 };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocStack());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ x86::Mem stack = cc.newStack(kSize, 1);
+ stack.setSize(1);
+
+ x86::Gp i = cc.newIntPtr("i");
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+
+ Label L_1 = cc.newLabel();
+ Label L_2 = cc.newLabel();
+
+ // Fill stack by sequence [0, 1, 2, 3 ... 255].
+ cc.xor_(i, i);
+
+ x86::Mem stackWithIndex = stack.clone();
+ stackWithIndex.setIndex(i, 0);
+
+ cc.bind(L_1);
+ cc.mov(stackWithIndex, i.r8());
+ cc.inc(i);
+ cc.cmp(i, 255);
+ cc.jle(L_1);
+
+ // Sum sequence in stack.
+ cc.xor_(i, i);
+ cc.xor_(a, a);
+
+ cc.bind(L_2);
+ cc.movzx(b, stackWithIndex);
+ cc.add(a, b);
+ cc.inc(i);
+ cc.cmp(i, 255);
+ cc.jle(L_2);
+
+ cc.ret(a);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 32640;
+
+ result.assignInt(resultRet);
+ expect.assignInt(expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocMemcpy]
+// ============================================================================
+
+class X86Test_AllocMemcpy : public X86Test {
+public:
+ X86Test_AllocMemcpy() : X86Test("AllocMemcpy") {}
+
+ enum { kCount = 32 };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocMemcpy());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp dst = cc.newIntPtr("dst");
+ x86::Gp src = cc.newIntPtr("src");
+ x86::Gp cnt = cc.newUIntPtr("cnt");
+
+ Label L_Loop = cc.newLabel(); // Create base labels we use
+ Label L_Exit = cc.newLabel(); // in our function.
+
+ cc.addFunc(FuncSignatureT<void, uint32_t*, const uint32_t*, size_t>(CallConv::kIdHost));
+ cc.setArg(0, dst);
+ cc.setArg(1, src);
+ cc.setArg(2, cnt);
+
+ cc.test(cnt, cnt); // Exit if the size is zero.
+ cc.jz(L_Exit);
+
+ cc.bind(L_Loop); // Bind the loop label here.
+
+ x86::Gp tmp = cc.newInt32("tmp"); // Copy a single dword (4 bytes).
+ cc.mov(tmp, x86::dword_ptr(src));
+ cc.mov(x86::dword_ptr(dst), tmp);
+
+ cc.add(src, 4); // Increment dst/src pointers.
+ cc.add(dst, 4);
+
+ cc.dec(cnt); // Loop until cnt isn't zero.
+ cc.jnz(L_Loop);
+
+ cc.bind(L_Exit); // Bind the exit label here.
+ cc.endFunc(); // End of function.
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(uint32_t*, const uint32_t*, size_t);
+ Func func = ptr_as_func<Func>(_func);
+
+ uint32_t i;
+
+ uint32_t dstBuffer[kCount];
+ uint32_t srcBuffer[kCount];
+
+ for (i = 0; i < kCount; i++) {
+ dstBuffer[i] = 0;
+ srcBuffer[i] = i;
+ }
+
+ func(dstBuffer, srcBuffer, kCount);
+
+ result.assignString("buf={");
+ expect.assignString("buf={");
+
+ for (i = 0; i < kCount; i++) {
+ if (i != 0) {
+ result.appendString(", ");
+ expect.appendString(", ");
+ }
+
+ result.appendFormat("%u", unsigned(dstBuffer[i]));
+ expect.appendFormat("%u", unsigned(srcBuffer[i]));
+ }
+
+ result.appendString("}");
+ expect.appendString("}");
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocExtraBlock]
+// ============================================================================
+
+class X86Test_AllocExtraBlock : public X86Test {
+public:
+ X86Test_AllocExtraBlock() : X86Test("AllocExtraBlock") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocExtraBlock());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp cond = cc.newInt32("cond");
+ x86::Gp ret = cc.newInt32("ret");
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+
+ cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+ cc.setArg(0, cond);
+ cc.setArg(1, a);
+ cc.setArg(2, b);
+
+ Label L_Ret = cc.newLabel();
+ Label L_Extra = cc.newLabel();
+
+ cc.test(cond, cond);
+ cc.jnz(L_Extra);
+
+ cc.mov(ret, a);
+ cc.add(ret, b);
+
+ cc.bind(L_Ret);
+ cc.ret(ret);
+
+ // Emit code sequence at the end of the function.
+ BaseNode* prevCursor = cc.setCursor(cc.func()->endNode()->prev());
+ cc.bind(L_Extra);
+ cc.mov(ret, a);
+ cc.sub(ret, b);
+ cc.jmp(L_Ret);
+ cc.setCursor(prevCursor);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int ret1 = func(0, 4, 5);
+ int ret2 = func(1, 4, 5);
+
+ int exp1 = 4 + 5;
+ int exp2 = 4 - 5;
+
+ result.assignFormat("ret={%d, %d}", ret1, ret2);
+ expect.assignFormat("ret={%d, %d}", exp1, exp2);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_AllocAlphaBlend]
+// ============================================================================
+
+class X86Test_AllocAlphaBlend : public X86Test {
+public:
+ X86Test_AllocAlphaBlend() : X86Test("AllocAlphaBlend") {}
+
+ enum { kCount = 17 };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_AllocAlphaBlend());
+ }
+
+ static uint32_t blendSrcOver(uint32_t d, uint32_t s) {
+ uint32_t saInv = ~s >> 24;
+
+ uint32_t d_20 = (d ) & 0x00FF00FF;
+ uint32_t d_31 = (d >> 8) & 0x00FF00FF;
+
+ d_20 *= saInv;
+ d_31 *= saInv;
+
+ d_20 = ((d_20 + ((d_20 >> 8) & 0x00FF00FFu) + 0x00800080u) & 0xFF00FF00u) >> 8;
+ d_31 = ((d_31 + ((d_31 >> 8) & 0x00FF00FFu) + 0x00800080u) & 0xFF00FF00u);
+
+ return d_20 + d_31 + s;
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ asmtest::generateAlphaBlend(cc);
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(void*, const void*, size_t);
+ Func func = ptr_as_func<Func>(_func);
+
+ static const uint32_t dstConstData[] = { 0x00000000, 0x10101010, 0x20100804, 0x30200003, 0x40204040, 0x5000004D, 0x60302E2C, 0x706F6E6D, 0x807F4F2F, 0x90349001, 0xA0010203, 0xB03204AB, 0xC023AFBD, 0xD0D0D0C0, 0xE0AABBCC, 0xFFFFFFFF, 0xF8F4F2F1 };
+ static const uint32_t srcConstData[] = { 0xE0E0E0E0, 0xA0008080, 0x341F1E1A, 0xFEFEFEFE, 0x80302010, 0x49490A0B, 0x998F7798, 0x00000000, 0x01010101, 0xA0264733, 0xBAB0B1B9, 0xFF000000, 0xDAB0A0C1, 0xE0BACFDA, 0x99887766, 0xFFFFFF80, 0xEE0A5FEC };
+
+ uint32_t _dstBuffer[kCount + 3];
+ uint32_t _srcBuffer[kCount + 3];
+
+ // Has to be aligned.
+ uint32_t* dstBuffer = (uint32_t*)Support::alignUp<intptr_t>((intptr_t)_dstBuffer, 16);
+ uint32_t* srcBuffer = (uint32_t*)Support::alignUp<intptr_t>((intptr_t)_srcBuffer, 16);
+
+ memcpy(dstBuffer, dstConstData, sizeof(dstConstData));
+ memcpy(srcBuffer, srcConstData, sizeof(srcConstData));
+
+ uint32_t i;
+ uint32_t expBuffer[kCount];
+
+ for (i = 0; i < kCount; i++) {
+ expBuffer[i] = blendSrcOver(dstBuffer[i], srcBuffer[i]);
+ }
+
+ func(dstBuffer, srcBuffer, kCount);
+
+ result.assignString("buf={");
+ expect.assignString("buf={");
+
+ for (i = 0; i < kCount; i++) {
+ if (i != 0) {
+ result.appendString(", ");
+ expect.appendString(", ");
+ }
+
+ result.appendFormat("%08X", unsigned(dstBuffer[i]));
+ expect.appendFormat("%08X", unsigned(expBuffer[i]));
+ }
+
+ result.appendString("}");
+ expect.appendString("}");
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallBase1]
+// ============================================================================
+
+class X86Test_FuncCallBase1 : public X86Test {
+public:
+ X86Test_FuncCallBase1() : X86Test("FuncCallBase1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallBase1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp v0 = cc.newInt32("v0");
+ x86::Gp v1 = cc.newInt32("v1");
+ x86::Gp v2 = cc.newInt32("v2");
+
+ cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+ cc.setArg(0, v0);
+ cc.setArg(1, v1);
+ cc.setArg(2, v2);
+
+ // Just do something.
+ cc.shl(v0, 1);
+ cc.shl(v1, 1);
+ cc.shl(v2, 1);
+
+ // Call a function.
+ FuncCallNode* call = cc.call(imm((void*)calledFunc), FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+ call->setArg(0, v2);
+ call->setArg(1, v1);
+ call->setArg(2, v0);
+ call->setRet(0, v0);
+
+ cc.ret(v0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(3, 2, 1);
+ int expectRet = 36;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static int calledFunc(int a, int b, int c) { return (a + b) * c; }
+};
+
+// ============================================================================
+// [X86Test_FuncCallBase2]
+// ============================================================================
+
+class X86Test_FuncCallBase2 : public X86Test {
+public:
+ X86Test_FuncCallBase2() : X86Test("FuncCallBase2") {}
+
+ enum { kSize = 256 };
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallBase2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ const int kTokenSize = 32;
+
+ x86::Mem s1 = cc.newStack(kTokenSize, 32);
+ x86::Mem s2 = cc.newStack(kTokenSize, 32);
+
+ x86::Gp p1 = cc.newIntPtr("p1");
+ x86::Gp p2 = cc.newIntPtr("p2");
+
+ x86::Gp ret = cc.newInt32("ret");
+ Label L_Exit = cc.newLabel();
+
+ static const char token[kTokenSize] = "-+:|abcdefghijklmnopqrstuvwxyz|";
+ FuncCallNode* call;
+
+ cc.lea(p1, s1);
+ cc.lea(p2, s2);
+
+ // Try to corrupt the stack if wrongly allocated.
+ call = cc.call(imm((void*)memcpy), FuncSignatureT<void*, void*, void*, size_t>(CallConv::kIdHostCDecl));
+ call->setArg(0, p1);
+ call->setArg(1, imm(token));
+ call->setArg(2, imm(kTokenSize));
+ call->setRet(0, p1);
+
+ call = cc.call(imm((void*)memcpy), FuncSignatureT<void*, void*, void*, size_t>(CallConv::kIdHostCDecl));
+ call->setArg(0, p2);
+ call->setArg(1, imm(token));
+ call->setArg(2, imm(kTokenSize));
+ call->setRet(0, p2);
+
+ call = cc.call(imm((void*)memcmp), FuncSignatureT<int, void*, void*, size_t>(CallConv::kIdHostCDecl));
+ call->setArg(0, p1);
+ call->setArg(1, p2);
+ call->setArg(2, imm(kTokenSize));
+ call->setRet(0, ret);
+
+ // This should be 0 on success, however, if both `p1` and `p2` were
+ // allocated in the same address this check will still pass.
+ cc.cmp(ret, 0);
+ cc.jnz(L_Exit);
+
+ // Checks whether `p1` and `p2` are different (must be).
+ cc.xor_(ret, ret);
+ cc.cmp(p1, p2);
+ cc.setz(ret.r8());
+
+ cc.bind(L_Exit);
+ cc.ret(ret);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 0; // Must be zero, stack addresses must be different.
+
+ result.assignInt(resultRet);
+ expect.assignInt(expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallStd]
+// ============================================================================
+
+class X86Test_FuncCallStd : public X86Test {
+public:
+ X86Test_FuncCallStd() : X86Test("FuncCallStd") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallStd());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp x = cc.newInt32("x");
+ x86::Gp y = cc.newInt32("y");
+ x86::Gp z = cc.newInt32("z");
+
+ cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+ cc.setArg(0, x);
+ cc.setArg(1, y);
+ cc.setArg(2, z);
+
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, int, int, int>(CallConv::kIdHostStdCall));
+ call->setArg(0, x);
+ call->setArg(1, y);
+ call->setArg(2, z);
+ call->setRet(0, x);
+
+ cc.ret(x);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(1, 42, 3);
+ int expectRet = calledFunc(1, 42, 3);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ // STDCALL function that is called inside the generated one.
+ static int ASMJIT_STDCALL calledFunc(int a, int b, int c) noexcept {
+ return (a + b) * c;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallFast]
+// ============================================================================
+
+class X86Test_FuncCallFast : public X86Test {
+public:
+ X86Test_FuncCallFast() : X86Test("FuncCallFast") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallFast());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp var = cc.newInt32("var");
+
+ cc.addFunc(FuncSignatureT<int, int>(CallConv::kIdHost));
+ cc.setArg(0, var);
+
+ FuncCallNode* call;
+ call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, int>(CallConv::kIdHostFastCall));
+ call->setArg(0, var);
+ call->setRet(0, var);
+
+ call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, int>(CallConv::kIdHostFastCall));
+ call->setArg(0, var);
+ call->setRet(0, var);
+
+ cc.ret(var);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(9);
+ int expectRet = (9 * 9) * (9 * 9);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ // FASTCALL function that is called inside the generated one.
+ static int ASMJIT_FASTCALL calledFunc(int a) noexcept {
+ return a * a;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallLight]
+// ============================================================================
+
+class X86Test_FuncCallLight : public X86Test {
+public:
+ X86Test_FuncCallLight() : X86Test("FuncCallLight") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallLight());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ FuncSignatureT<void, const void*, const void*, const void*, const void*, void*> funcSig(CallConv::kIdHostCDecl);
+ FuncSignatureT<x86::Xmm, x86::Xmm, x86::Xmm> fastSig(CallConv::kIdHostLightCall2);
+
+ FuncNode* func = cc.newFunc(funcSig);
+ FuncNode* fast = cc.newFunc(fastSig);
+
+ {
+ x86::Gp aPtr = cc.newIntPtr("aPtr");
+ x86::Gp bPtr = cc.newIntPtr("bPtr");
+ x86::Gp cPtr = cc.newIntPtr("cPtr");
+ x86::Gp dPtr = cc.newIntPtr("dPtr");
+ x86::Gp pOut = cc.newIntPtr("pOut");
+
+ x86::Xmm aXmm = cc.newXmm("aXmm");
+ x86::Xmm bXmm = cc.newXmm("bXmm");
+ x86::Xmm cXmm = cc.newXmm("cXmm");
+ x86::Xmm dXmm = cc.newXmm("dXmm");
+
+ cc.addFunc(func);
+
+ cc.setArg(0, aPtr);
+ cc.setArg(1, bPtr);
+ cc.setArg(2, cPtr);
+ cc.setArg(3, dPtr);
+ cc.setArg(4, pOut);
+
+ cc.movups(aXmm, x86::ptr(aPtr));
+ cc.movups(bXmm, x86::ptr(bPtr));
+ cc.movups(cXmm, x86::ptr(cPtr));
+ cc.movups(dXmm, x86::ptr(dPtr));
+
+ x86::Xmm xXmm = cc.newXmm("xXmm");
+ x86::Xmm yXmm = cc.newXmm("yXmm");
+
+ FuncCallNode* call1 = cc.call(fast->label(), fastSig);
+ call1->setArg(0, aXmm);
+ call1->setArg(1, bXmm);
+ call1->setRet(0, xXmm);
+
+ FuncCallNode* call2 = cc.call(fast->label(), fastSig);
+ call2->setArg(0, cXmm);
+ call2->setArg(1, dXmm);
+ call2->setRet(0, yXmm);
+
+ cc.pmullw(xXmm, yXmm);
+ cc.movups(x86::ptr(pOut), xXmm);
+
+ cc.endFunc();
+ }
+
+ {
+ x86::Xmm aXmm = cc.newXmm("aXmm");
+ x86::Xmm bXmm = cc.newXmm("bXmm");
+
+ cc.addFunc(fast);
+ cc.setArg(0, aXmm);
+ cc.setArg(1, bXmm);
+ cc.paddw(aXmm, bXmm);
+ cc.ret(aXmm);
+ cc.endFunc();
+ }
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef void (*Func)(const void*, const void*, const void*, const void*, void*);
+
+ Func func = ptr_as_func<Func>(_func);
+
+ int16_t a[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ int16_t b[8] = { 7, 6, 5, 4, 3, 2, 1, 0 };
+ int16_t c[8] = { 1, 3, 9, 7, 5, 4, 2, 1 };
+ int16_t d[8] = { 2, 0,-6,-4,-2,-1, 1, 2 };
+
+ int16_t o[8];
+ int oExp = 7 * 3;
+
+ func(a, b, c, d, o);
+
+ result.assignFormat("ret={%02X %02X %02X %02X %02X %02X %02X %02X}", o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7]);
+ expect.assignFormat("ret={%02X %02X %02X %02X %02X %02X %02X %02X}", oExp, oExp, oExp, oExp, oExp, oExp, oExp, oExp);
+
+ return result == expect;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallManyArgs]
+// ============================================================================
+
+class X86Test_FuncCallManyArgs : public X86Test {
+public:
+ X86Test_FuncCallManyArgs() : X86Test("FuncCallManyArgs") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallManyArgs());
+ }
+
+ static int calledFunc(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) {
+ return (a * b * c * d * e) + (f * g * h * i * j);
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ // Prepare.
+ x86::Gp va = cc.newInt32("va");
+ x86::Gp vb = cc.newInt32("vb");
+ x86::Gp vc = cc.newInt32("vc");
+ x86::Gp vd = cc.newInt32("vd");
+ x86::Gp ve = cc.newInt32("ve");
+ x86::Gp vf = cc.newInt32("vf");
+ x86::Gp vg = cc.newInt32("vg");
+ x86::Gp vh = cc.newInt32("vh");
+ x86::Gp vi = cc.newInt32("vi");
+ x86::Gp vj = cc.newInt32("vj");
+
+ cc.mov(va, 0x03);
+ cc.mov(vb, 0x12);
+ cc.mov(vc, 0xA0);
+ cc.mov(vd, 0x0B);
+ cc.mov(ve, 0x2F);
+ cc.mov(vf, 0x02);
+ cc.mov(vg, 0x0C);
+ cc.mov(vh, 0x12);
+ cc.mov(vi, 0x18);
+ cc.mov(vj, 0x1E);
+
+ // Call function.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConv::kIdHost));
+ call->setArg(0, va);
+ call->setArg(1, vb);
+ call->setArg(2, vc);
+ call->setArg(3, vd);
+ call->setArg(4, ve);
+ call->setArg(5, vf);
+ call->setArg(6, vg);
+ call->setArg(7, vh);
+ call->setArg(8, vi);
+ call->setArg(9, vj);
+ call->setRet(0, va);
+
+ cc.ret(va);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = calledFunc(0x03, 0x12, 0xA0, 0x0B, 0x2F, 0x02, 0x0C, 0x12, 0x18, 0x1E);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallDuplicateArgs]
+// ============================================================================
+
+class X86Test_FuncCallDuplicateArgs : public X86Test {
+public:
+ X86Test_FuncCallDuplicateArgs() : X86Test("FuncCallDuplicateArgs") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallDuplicateArgs());
+ }
+
+ static int calledFunc(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) {
+ return (a * b * c * d * e) + (f * g * h * i * j);
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ // Prepare.
+ x86::Gp a = cc.newInt32("a");
+ cc.mov(a, 3);
+
+ // Call function.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConv::kIdHost));
+ call->setArg(0, a);
+ call->setArg(1, a);
+ call->setArg(2, a);
+ call->setArg(3, a);
+ call->setArg(4, a);
+ call->setArg(5, a);
+ call->setArg(6, a);
+ call->setArg(7, a);
+ call->setArg(8, a);
+ call->setArg(9, a);
+ call->setRet(0, a);
+
+ cc.ret(a);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = calledFunc(3, 3, 3, 3, 3, 3, 3, 3, 3, 3);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallImmArgs]
+// ============================================================================
+
+class X86Test_FuncCallImmArgs : public X86Test {
+public:
+ X86Test_FuncCallImmArgs() : X86Test("FuncCallImmArgs") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallImmArgs());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ // Prepare.
+ x86::Gp rv = cc.newInt32("rv");
+
+ // Call function.
+ FuncCallNode* call = cc.call(
+ imm((void*)X86Test_FuncCallManyArgs::calledFunc),
+ FuncSignatureT<int, int, int, int, int, int, int, int, int, int, int>(CallConv::kIdHost));
+
+ call->setArg(0, imm(0x03));
+ call->setArg(1, imm(0x12));
+ call->setArg(2, imm(0xA0));
+ call->setArg(3, imm(0x0B));
+ call->setArg(4, imm(0x2F));
+ call->setArg(5, imm(0x02));
+ call->setArg(6, imm(0x0C));
+ call->setArg(7, imm(0x12));
+ call->setArg(8, imm(0x18));
+ call->setArg(9, imm(0x1E));
+ call->setRet(0, rv);
+
+ cc.ret(rv);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = X86Test_FuncCallManyArgs::calledFunc(0x03, 0x12, 0xA0, 0x0B, 0x2F, 0x02, 0x0C, 0x12, 0x18, 0x1E);
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallPtrArgs]
+// ============================================================================
+
+class X86Test_FuncCallPtrArgs : public X86Test {
+public:
+ X86Test_FuncCallPtrArgs() : X86Test("FuncCallPtrArgs") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallPtrArgs());
+ }
+
+ static int calledFunc(void* a, void* b, void* c, void* d, void* e, void* f, void* g, void* h, void* i, void* j) {
+ return int((intptr_t)a) +
+ int((intptr_t)b) +
+ int((intptr_t)c) +
+ int((intptr_t)d) +
+ int((intptr_t)e) +
+ int((intptr_t)f) +
+ int((intptr_t)g) +
+ int((intptr_t)h) +
+ int((intptr_t)i) +
+ int((intptr_t)j) ;
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ // Prepare.
+ x86::Gp rv = cc.newInt32("rv");
+
+ // Call function.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, void*, void*, void*, void*, void*, void*, void*, void*, void*, void*>(CallConv::kIdHost));
+
+ call->setArg(0, imm(0x01));
+ call->setArg(1, imm(0x02));
+ call->setArg(2, imm(0x03));
+ call->setArg(3, imm(0x04));
+ call->setArg(4, imm(0x05));
+ call->setArg(5, imm(0x06));
+ call->setArg(6, imm(0x07));
+ call->setArg(7, imm(0x08));
+ call->setArg(8, imm(0x09));
+ call->setArg(9, imm(0x0A));
+ call->setRet(0, rv);
+
+ cc.ret(rv);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 55;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallRefArgs]
+// ============================================================================
+
+class X86Test_FuncCallRefArgs : public X86Test {
+public:
+ X86Test_FuncCallRefArgs() : X86Test("FuncCallRefArgs") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallRefArgs());
+ }
+
+ static int calledFunc(int& a, int& b, int& c, int& d) {
+ a += a;
+ b += b;
+ c += c;
+ d += d;
+ return a + b + c + d;
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int&, int&, int&, int&>(CallConv::kIdHost));
+
+ // Prepare.
+ x86::Gp arg1 = cc.newInt32();
+ x86::Gp arg2 = cc.newInt32();
+ x86::Gp arg3 = cc.newInt32();
+ x86::Gp arg4 = cc.newInt32();
+ x86::Gp rv = cc.newInt32("rv");
+
+ cc.setArg(0, arg1);
+ cc.setArg(1, arg2);
+ cc.setArg(2, arg3);
+ cc.setArg(3, arg4);
+
+ // Call function.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, int&, int&, int&, int&>(CallConv::kIdHost));
+
+ call->setArg(0, arg1);
+ call->setArg(1, arg2);
+ call->setArg(2, arg3);
+ call->setArg(3, arg4);
+ call->setRet(0, rv);
+
+ cc.ret(rv);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int&, int&, int&, int&);
+ Func func = ptr_as_func<Func>(_func);
+
+ int inputs[4] = { 1, 2, 3, 4 };
+ int outputs[4] = { 2, 4, 6, 8 };
+ int resultRet = func(inputs[0], inputs[1], inputs[2], inputs[3]);
+ int expectRet = 20;
+
+ result.assignFormat("ret={%08X %08X %08X %08X %08X}", resultRet, inputs[0], inputs[1], inputs[2], inputs[3]);
+ expect.assignFormat("ret={%08X %08X %08X %08X %08X}", expectRet, outputs[0], outputs[1], outputs[2], outputs[3]);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallFloatAsXmmRet]
+// ============================================================================
+
+class X86Test_FuncCallFloatAsXmmRet : public X86Test {
+public:
+ X86Test_FuncCallFloatAsXmmRet() : X86Test("FuncCallFloatAsXmmRet") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallFloatAsXmmRet());
+ }
+
+ static float calledFunc(float a, float b) {
+ return a * b;
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<float, float, float>(CallConv::kIdHost));
+
+ x86::Xmm a = cc.newXmmSs("a");
+ x86::Xmm b = cc.newXmmSs("b");
+ x86::Xmm ret = cc.newXmmSs("ret");
+
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ // Call function.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<float, float, float>(CallConv::kIdHost));
+ call->setArg(0, a);
+ call->setArg(1, b);
+ call->setRet(0, ret);
+
+ cc.ret(ret);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef float (*Func)(float, float);
+ Func func = ptr_as_func<Func>(_func);
+
+ float resultRet = func(15.5f, 2.0f);
+ float expectRet = calledFunc(15.5f, 2.0f);
+
+ result.assignFormat("ret=%g", resultRet);
+ expect.assignFormat("ret=%g", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallDoubleAsXmmRet]
+// ============================================================================
+
+class X86Test_FuncCallDoubleAsXmmRet : public X86Test {
+public:
+ X86Test_FuncCallDoubleAsXmmRet() : X86Test("FuncCallDoubleAsXmmRet") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallDoubleAsXmmRet());
+ }
+
+ static double calledFunc(double a, double b) {
+ return a * b;
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<double, double, double>(CallConv::kIdHost));
+
+ x86::Xmm a = cc.newXmmSd("a");
+ x86::Xmm b = cc.newXmmSd("b");
+ x86::Xmm ret = cc.newXmmSd("ret");
+
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<double, double, double>(CallConv::kIdHost));
+ call->setArg(0, a);
+ call->setArg(1, b);
+ call->setRet(0, ret);
+
+ cc.ret(ret);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(double, double);
+ Func func = ptr_as_func<Func>(_func);
+
+ double resultRet = func(15.5, 2.0);
+ double expectRet = calledFunc(15.5, 2.0);
+
+ result.assignFormat("ret=%g", resultRet);
+ expect.assignFormat("ret=%g", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallConditional]
+// ============================================================================
+
+class X86Test_FuncCallConditional : public X86Test {
+public:
+ X86Test_FuncCallConditional() : X86Test("FuncCallConditional") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallConditional());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp x = cc.newInt32("x");
+ x86::Gp y = cc.newInt32("y");
+ x86::Gp op = cc.newInt32("op");
+
+ FuncCallNode* call;
+ x86::Gp result;
+
+ cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+ cc.setArg(0, x);
+ cc.setArg(1, y);
+ cc.setArg(2, op);
+
+ Label opAdd = cc.newLabel();
+ Label opMul = cc.newLabel();
+
+ cc.cmp(op, 0);
+ cc.jz(opAdd);
+ cc.cmp(op, 1);
+ cc.jz(opMul);
+
+ result = cc.newInt32("result_0");
+ cc.mov(result, 0);
+ cc.ret(result);
+
+ cc.bind(opAdd);
+ result = cc.newInt32("result_1");
+
+ call = cc.call((uint64_t)calledFuncAdd, FuncSignatureT<int, int, int>(CallConv::kIdHost));
+ call->setArg(0, x);
+ call->setArg(1, y);
+ call->setRet(0, result);
+ cc.ret(result);
+
+ cc.bind(opMul);
+ result = cc.newInt32("result_2");
+
+ call = cc.call((uint64_t)calledFuncMul, FuncSignatureT<int, int, int>(CallConv::kIdHost));
+ call->setArg(0, x);
+ call->setArg(1, y);
+ call->setRet(0, result);
+
+ cc.ret(result);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int arg1 = 4;
+ int arg2 = 8;
+
+ int resultAdd = func(arg1, arg2, 0);
+ int expectAdd = calledFuncAdd(arg1, arg2);
+
+ int resultMul = func(arg1, arg2, 1);
+ int expectMul = calledFuncMul(arg1, arg2);
+
+ result.assignFormat("ret={add=%d, mul=%d}", resultAdd, resultMul);
+ expect.assignFormat("ret={add=%d, mul=%d}", expectAdd, expectMul);
+
+ return (resultAdd == expectAdd) && (resultMul == expectMul);
+ }
+
+ static int calledFuncAdd(int x, int y) { return x + y; }
+ static int calledFuncMul(int x, int y) { return x * y; }
+};
+
+// ============================================================================
+// [X86Test_FuncCallMultiple]
+// ============================================================================
+
+class X86Test_FuncCallMultiple : public X86Test {
+public:
+ X86Test_FuncCallMultiple() : X86Test("FuncCallMultiple") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallMultiple());
+ }
+
+ static int ASMJIT_FASTCALL calledFunc(int* pInt, int index) {
+ return pInt[index];
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ unsigned int i;
+
+ x86::Gp buf = cc.newIntPtr("buf");
+ x86::Gp acc0 = cc.newInt32("acc0");
+ x86::Gp acc1 = cc.newInt32("acc1");
+
+ cc.addFunc(FuncSignatureT<int, int*>(CallConv::kIdHost));
+ cc.setArg(0, buf);
+
+ cc.mov(acc0, 0);
+ cc.mov(acc1, 0);
+
+ for (i = 0; i < 4; i++) {
+ x86::Gp ret = cc.newInt32("ret");
+ x86::Gp ptr = cc.newIntPtr("ptr");
+ x86::Gp idx = cc.newInt32("idx");
+ FuncCallNode* call;
+
+ cc.mov(ptr, buf);
+ cc.mov(idx, int(i));
+
+ call = cc.call((uint64_t)calledFunc, FuncSignatureT<int, int*, int>(CallConv::kIdHostFastCall));
+ call->setArg(0, ptr);
+ call->setArg(1, idx);
+ call->setRet(0, ret);
+
+ cc.add(acc0, ret);
+
+ cc.mov(ptr, buf);
+ cc.mov(idx, int(i));
+
+ call = cc.call((uint64_t)calledFunc, FuncSignatureT<int, int*, int>(CallConv::kIdHostFastCall));
+ call->setArg(0, ptr);
+ call->setArg(1, idx);
+ call->setRet(0, ret);
+
+ cc.sub(acc1, ret);
+ }
+
+ cc.add(acc0, acc1);
+ cc.ret(acc0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int*);
+ Func func = ptr_as_func<Func>(_func);
+
+ int buffer[4] = { 127, 87, 23, 17 };
+
+ int resultRet = func(buffer);
+ int expectRet = 0;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallRecursive]
+// ============================================================================
+
+class X86Test_FuncCallRecursive : public X86Test {
+public:
+ X86Test_FuncCallRecursive() : X86Test("FuncCallRecursive") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallRecursive());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ x86::Gp val = cc.newInt32("val");
+ Label skip = cc.newLabel();
+
+ FuncNode* func = cc.addFunc(FuncSignatureT<int, int>(CallConv::kIdHost));
+ cc.setArg(0, val);
+
+ cc.cmp(val, 1);
+ cc.jle(skip);
+
+ x86::Gp tmp = cc.newInt32("tmp");
+ cc.mov(tmp, val);
+ cc.dec(tmp);
+
+ FuncCallNode* call = cc.call(func->label(), FuncSignatureT<int, int>(CallConv::kIdHost));
+ call->setArg(0, tmp);
+ call->setRet(0, tmp);
+ cc.mul(cc.newInt32(), val, tmp);
+
+ cc.bind(skip);
+ cc.ret(val);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(5);
+ int expectRet = 1 * 2 * 3 * 4 * 5;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallVarArg1]
+// ============================================================================
+
+class X86Test_FuncCallVarArg1 : public X86Test {
+public:
+ X86Test_FuncCallVarArg1() : X86Test("FuncCallVarArg1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallVarArg1());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int, int, int>(CallConv::kIdHost));
+
+ x86::Gp a0 = cc.newInt32("a0");
+ x86::Gp a1 = cc.newInt32("a1");
+ x86::Gp a2 = cc.newInt32("a2");
+ x86::Gp a3 = cc.newInt32("a3");
+
+ cc.setArg(0, a0);
+ cc.setArg(1, a1);
+ cc.setArg(2, a2);
+ cc.setArg(3, a3);
+
+ // We call `int func(size_t, ...)`
+ // - The `vaIndex` must be 1 (first argument after size_t).
+ // - The full signature of varargs (int, int, int, int) must follow.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<int, size_t, int, int, int, int>(CallConv::kIdHost, 1));
+ call->setArg(0, imm(4));
+ call->setArg(1, a0);
+ call->setArg(2, a1);
+ call->setArg(3, a2);
+ call->setArg(4, a3);
+ call->setRet(0, a0);
+
+ cc.ret(a0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(1, 2, 3, 4);
+ int expectRet = 1 + 2 + 3 + 4;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static int calledFunc(size_t n, ...) {
+ int sum = 0;
+ va_list ap;
+ va_start(ap, n);
+ for (size_t i = 0; i < n; i++) {
+ int arg = va_arg(ap, int);
+ sum += arg;
+ }
+ va_end(ap);
+ return sum;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallVarArg2]
+// ============================================================================
+
+class X86Test_FuncCallVarArg2 : public X86Test {
+public:
+ X86Test_FuncCallVarArg2() : X86Test("FuncCallVarArg2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallVarArg2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<double, double, double, double, double>(CallConv::kIdHost));
+
+ x86::Xmm a0 = cc.newXmmSd("a0");
+ x86::Xmm a1 = cc.newXmmSd("a1");
+ x86::Xmm a2 = cc.newXmmSd("a2");
+ x86::Xmm a3 = cc.newXmmSd("a3");
+
+ cc.setArg(0, a0);
+ cc.setArg(1, a1);
+ cc.setArg(2, a2);
+ cc.setArg(3, a3);
+
+ // We call `double func(size_t, ...)`
+ // - The `vaIndex` must be 1 (first argument after size_t).
+ // - The full signature of varargs (double, double, double, double) must follow.
+ FuncCallNode* call = cc.call(
+ imm((void*)calledFunc),
+ FuncSignatureT<double, size_t, double, double, double, double>(CallConv::kIdHost, 1));
+ call->setArg(0, imm(4));
+ call->setArg(1, a0);
+ call->setArg(2, a1);
+ call->setArg(3, a2);
+ call->setArg(4, a3);
+ call->setRet(0, a0);
+
+ cc.ret(a0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(double, double, double, double);
+ Func func = ptr_as_func<Func>(_func);
+
+ double resultRet = func(1.0, 2.0, 3.0, 4.0);
+ double expectRet = 1.0 + 2.0 + 3.0 + 4.0;
+
+ result.assignFormat("ret=%f", resultRet);
+ expect.assignFormat("ret=%f", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static double calledFunc(size_t n, ...) {
+ double sum = 0;
+ va_list ap;
+ va_start(ap, n);
+ for (size_t i = 0; i < n; i++) {
+ double arg = va_arg(ap, double);
+ sum += arg;
+ }
+ va_end(ap);
+ return sum;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallMisc1]
+// ============================================================================
+
+class X86Test_FuncCallMisc1 : public X86Test {
+public:
+ X86Test_FuncCallMisc1() : X86Test("FuncCallMisc1") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallMisc1());
+ }
+
+ static void dummy(int, int) {}
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+ x86::Gp r = cc.newInt32("r");
+
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ FuncCallNode* call = cc.call(
+ imm((void*)dummy),
+ FuncSignatureT<void, int, int>(CallConv::kIdHost));
+ call->setArg(0, a);
+ call->setArg(1, b);
+
+ cc.lea(r, x86::ptr(a, b));
+ cc.ret(r);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(44, 199);
+ int expectRet = 243;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_FuncCallMisc2]
+// ============================================================================
+
+class X86Test_FuncCallMisc2 : public X86Test {
+public:
+ X86Test_FuncCallMisc2() : X86Test("FuncCallMisc2") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallMisc2());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<double, const double*>(CallConv::kIdHost));
+
+ x86::Gp p = cc.newIntPtr("p");
+ x86::Xmm arg = cc.newXmmSd("arg");
+ x86::Xmm ret = cc.newXmmSd("ret");
+
+ cc.setArg(0, p);
+ cc.movsd(arg, x86::ptr(p));
+
+ FuncCallNode* call = cc.call(
+ imm((void*)op),
+ FuncSignatureT<double, double>(CallConv::kIdHost));
+ call->setArg(0, arg);
+ call->setRet(0, ret);
+
+ cc.ret(ret);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(const double*);
+ Func func = ptr_as_func<Func>(_func);
+
+ double arg = 2;
+
+ double resultRet = func(&arg);
+ double expectRet = op(arg);
+
+ result.assignFormat("ret=%g", resultRet);
+ expect.assignFormat("ret=%g", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static double op(double a) { return a * a; }
+};
+
+// ============================================================================
+// [X86Test_FuncCallMisc3]
+// ============================================================================
+
+class X86Test_FuncCallMisc3 : public X86Test {
+public:
+ X86Test_FuncCallMisc3() : X86Test("FuncCallMisc3") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallMisc3());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<double, const double*>(CallConv::kIdHost));
+
+ x86::Gp p = cc.newIntPtr("p");
+ x86::Xmm arg = cc.newXmmSd("arg");
+ x86::Xmm ret = cc.newXmmSd("ret");
+
+ cc.setArg(0, p);
+ cc.movsd(arg, x86::ptr(p));
+
+ FuncCallNode* call = cc.call(
+ imm((void*)op),
+ FuncSignatureT<double, double>(CallConv::kIdHost));
+ call->setArg(0, arg);
+ call->setRet(0, ret);
+
+ cc.xorps(arg, arg);
+ cc.subsd(arg, ret);
+
+ cc.ret(arg);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(const double*);
+ Func func = ptr_as_func<Func>(_func);
+
+ double arg = 2;
+
+ double resultRet = func(&arg);
+ double expectRet = -op(arg);
+
+ result.assignFormat("ret=%g", resultRet);
+ expect.assignFormat("ret=%g", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static double op(double a) { return a * a; }
+};
+
+// ============================================================================
+// [X86Test_FuncCallMisc4]
+// ============================================================================
+
+class X86Test_FuncCallMisc4 : public X86Test {
+public:
+ X86Test_FuncCallMisc4() : X86Test("FuncCallMisc4") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallMisc4());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ FuncSignatureBuilder funcPrototype;
+ funcPrototype.setCallConv(CallConv::kIdHost);
+ funcPrototype.setRet(Type::kIdF64);
+ cc.addFunc(funcPrototype);
+
+ FuncSignatureBuilder callPrototype;
+ callPrototype.setCallConv(CallConv::kIdHost);
+ callPrototype.setRet(Type::kIdF64);
+ FuncCallNode* call = cc.call(imm((void*)calledFunc), callPrototype);
+
+ x86::Xmm ret = cc.newXmmSd("ret");
+ call->setRet(0, ret);
+ cc.ret(ret);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef double (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ double resultRet = func();
+ double expectRet = 3.14;
+
+ result.assignFormat("ret=%g", resultRet);
+ expect.assignFormat("ret=%g", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static double calledFunc() { return 3.14; }
+};
+
+// ============================================================================
+// [X86Test_FuncCallMisc5]
+// ============================================================================
+
+// The register allocator should clobber the register used by the `call` itself.
+class X86Test_FuncCallMisc5 : public X86Test {
+public:
+ X86Test_FuncCallMisc5() : X86Test("FuncCallMisc5") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_FuncCallMisc5());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ x86::Gp pFn = cc.newIntPtr("pFn");
+ x86::Gp vars[16];
+
+ uint32_t i, regCount = cc.gpCount();
+ ASMJIT_ASSERT(regCount <= ASMJIT_ARRAY_SIZE(vars));
+
+ cc.mov(pFn, imm((void*)calledFunc));
+
+ for (i = 0; i < regCount; i++) {
+ if (i == x86::Gp::kIdBp || i == x86::Gp::kIdSp)
+ continue;
+
+ vars[i] = cc.newInt32("%%%u", unsigned(i));
+ cc.mov(vars[i], 1);
+ }
+
+ cc.call(pFn, FuncSignatureT<void>(CallConv::kIdHost));
+ for (i = 1; i < regCount; i++)
+ if (vars[i].isValid())
+ cc.add(vars[0], vars[i]);
+ cc.ret(vars[0]);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = sizeof(void*) == 4 ? 6 : 14;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static void calledFunc() {}
+};
+
+// ============================================================================
+// [X86Test_MiscLocalConstPool]
+// ============================================================================
+
+class X86Test_MiscLocalConstPool : public X86Test {
+public:
+ X86Test_MiscLocalConstPool() : X86Test("MiscLocalConstPool") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_MiscLocalConstPool());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ x86::Gp v0 = cc.newInt32("v0");
+ x86::Gp v1 = cc.newInt32("v1");
+
+ x86::Mem c0 = cc.newInt32Const(ConstPool::kScopeLocal, 200);
+ x86::Mem c1 = cc.newInt32Const(ConstPool::kScopeLocal, 33);
+
+ cc.mov(v0, c0);
+ cc.mov(v1, c1);
+ cc.add(v0, v1);
+
+ cc.ret(v0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 233;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_MiscGlobalConstPool]
+// ============================================================================
+
+class X86Test_MiscGlobalConstPool : public X86Test {
+public:
+ X86Test_MiscGlobalConstPool() : X86Test("MiscGlobalConstPool") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_MiscGlobalConstPool());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int>(CallConv::kIdHost));
+
+ x86::Gp v0 = cc.newInt32("v0");
+ x86::Gp v1 = cc.newInt32("v1");
+
+ x86::Mem c0 = cc.newInt32Const(ConstPool::kScopeGlobal, 200);
+ x86::Mem c1 = cc.newInt32Const(ConstPool::kScopeGlobal, 33);
+
+ cc.mov(v0, c0);
+ cc.mov(v1, c1);
+ cc.add(v0, v1);
+
+ cc.ret(v0);
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(void);
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func();
+ int expectRet = 233;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return resultRet == expectRet;
+ }
+};
+
+// ============================================================================
+// [X86Test_MiscMultiRet]
+// ============================================================================
+
+struct X86Test_MiscMultiRet : public X86Test {
+ X86Test_MiscMultiRet() : X86Test("MiscMultiRet") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_MiscMultiRet());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ cc.addFunc(FuncSignatureT<int, int, int, int>(CallConv::kIdHost));
+
+ x86::Gp op = cc.newInt32("op");
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+
+ Label L_Zero = cc.newLabel();
+ Label L_Add = cc.newLabel();
+ Label L_Sub = cc.newLabel();
+ Label L_Mul = cc.newLabel();
+ Label L_Div = cc.newLabel();
+
+ cc.setArg(0, op);
+ cc.setArg(1, a);
+ cc.setArg(2, b);
+
+ cc.cmp(op, 0);
+ cc.jz(L_Add);
+
+ cc.cmp(op, 1);
+ cc.jz(L_Sub);
+
+ cc.cmp(op, 2);
+ cc.jz(L_Mul);
+
+ cc.cmp(op, 3);
+ cc.jz(L_Div);
+
+ cc.bind(L_Zero);
+ cc.xor_(a, a);
+ cc.ret(a);
+
+ cc.bind(L_Add);
+ cc.add(a, b);
+ cc.ret(a);
+
+ cc.bind(L_Sub);
+ cc.sub(a, b);
+ cc.ret(a);
+
+ cc.bind(L_Mul);
+ cc.imul(a, b);
+ cc.ret(a);
+
+ cc.bind(L_Div);
+ cc.cmp(b, 0);
+ cc.jz(L_Zero);
+
+ x86::Gp zero = cc.newInt32("zero");
+ cc.xor_(zero, zero);
+ cc.idiv(zero, a, b);
+ cc.ret(a);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int, int);
+
+ Func func = ptr_as_func<Func>(_func);
+
+ int a = 44;
+ int b = 3;
+
+ int r0 = func(0, a, b);
+ int r1 = func(1, a, b);
+ int r2 = func(2, a, b);
+ int r3 = func(3, a, b);
+ int e0 = a + b;
+ int e1 = a - b;
+ int e2 = a * b;
+ int e3 = a / b;
+
+ result.assignFormat("ret={%d %d %d %d}", r0, r1, r2, r3);
+ expect.assignFormat("ret={%d %d %d %d}", e0, e1, e2, e3);
+
+ return result.eq(expect);
+ }
+};
+
+// ============================================================================
+// [X86Test_MiscMultiFunc]
+// ============================================================================
+
+class X86Test_MiscMultiFunc : public X86Test {
+public:
+ X86Test_MiscMultiFunc() : X86Test("MiscMultiFunc") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_MiscMultiFunc());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ FuncNode* f1 = cc.newFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+ FuncNode* f2 = cc.newFunc(FuncSignatureT<int, int, int>(CallConv::kIdHost));
+
+ {
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+
+ cc.addFunc(f1);
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ FuncCallNode* call = cc.call(f2->label(), FuncSignatureT<int, int, int>(CallConv::kIdHost));
+ call->setArg(0, a);
+ call->setArg(1, b);
+ call->setRet(0, a);
+
+ cc.ret(a);
+ cc.endFunc();
+ }
+
+ {
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newInt32("b");
+
+ cc.addFunc(f2);
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ cc.add(a, b);
+ cc.ret(a);
+ cc.endFunc();
+ }
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (*Func)(int, int);
+
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = func(56, 22);
+ int expectRet = 56 + 22;
+
+ result.assignFormat("ret=%d", resultRet);
+ expect.assignFormat("ret=%d", expectRet);
+
+ return result.eq(expect);
+ }
+};
+
+// ============================================================================
+// [X86Test_MiscUnfollow]
+// ============================================================================
+
+// Global (I didn't find a better way to test this).
+static jmp_buf globalJmpBuf;
+
+class X86Test_MiscUnfollow : public X86Test {
+public:
+ X86Test_MiscUnfollow() : X86Test("MiscUnfollow") {}
+
+ static void add(X86TestApp& app) {
+ app.add(new X86Test_MiscUnfollow());
+ }
+
+ virtual void compile(x86::Compiler& cc) {
+ // NOTE: Fastcall calling convention is the most appropriate here, as all
+ // arguments will be passed by registers and there won't be any stack
+ // misalignment when we call the `handler()`. This was failing on OSX
+ // when targeting 32-bit.
+ cc.addFunc(FuncSignatureT<int, int, void*>(CallConv::kIdHostFastCall));
+
+ x86::Gp a = cc.newInt32("a");
+ x86::Gp b = cc.newIntPtr("b");
+ Label tramp = cc.newLabel();
+
+ cc.setArg(0, a);
+ cc.setArg(1, b);
+
+ cc.cmp(a, 0);
+ cc.jz(tramp);
+
+ cc.ret(a);
+
+ cc.bind(tramp);
+ cc.unfollow().jmp(b);
+
+ cc.endFunc();
+ }
+
+ virtual bool run(void* _func, String& result, String& expect) {
+ typedef int (ASMJIT_FASTCALL *Func)(int, void*);
+
+ Func func = ptr_as_func<Func>(_func);
+
+ int resultRet = 0;
+ int expectRet = 1;
+
+ if (!setjmp(globalJmpBuf))
+ resultRet = func(0, (void*)handler);
+ else
+ resultRet = 1;
+
+ result.assignFormat("ret={%d}", resultRet);
+ expect.assignFormat("ret={%d}", expectRet);
+
+ return resultRet == expectRet;
+ }
+
+ static void ASMJIT_FASTCALL handler() { longjmp(globalJmpBuf, 1); }
+};
+
+// ============================================================================
+// [Main]
+// ============================================================================
+
+int main(int argc, char* argv[]) {
+ X86TestApp app;
+
+ app.handleArgs(argc, argv);
+ app.showInfo();
+
+ // Base tests.
+ app.addT<X86Test_NoCode>();
+ app.addT<X86Test_NoAlign>();
+ app.addT<X86Test_AlignBase>();
+
+ // Jump tests.
+ app.addT<X86Test_JumpMerge>();
+ app.addT<X86Test_JumpCross>();
+ app.addT<X86Test_JumpMany>();
+ app.addT<X86Test_JumpUnreachable1>();
+ app.addT<X86Test_JumpUnreachable2>();
+ app.addT<X86Test_JumpTable>();
+
+ // Alloc tests.
+ app.addT<X86Test_AllocBase>();
+ app.addT<X86Test_AllocMany1>();
+ app.addT<X86Test_AllocMany2>();
+ app.addT<X86Test_AllocImul1>();
+ app.addT<X86Test_AllocImul2>();
+ app.addT<X86Test_AllocIdiv1>();
+ app.addT<X86Test_AllocSetz>();
+ app.addT<X86Test_AllocShlRor>();
+ app.addT<X86Test_AllocGpbLo1>();
+ app.addT<X86Test_AllocGpbLo2>();
+ app.addT<X86Test_AllocRepMovsb>();
+ app.addT<X86Test_AllocIfElse1>();
+ app.addT<X86Test_AllocIfElse2>();
+ app.addT<X86Test_AllocIfElse3>();
+ app.addT<X86Test_AllocIfElse4>();
+ app.addT<X86Test_AllocInt8>();
+ app.addT<X86Test_AllocUnhandledArg>();
+ app.addT<X86Test_AllocArgsIntPtr>();
+ app.addT<X86Test_AllocArgsFloat>();
+ app.addT<X86Test_AllocArgsDouble>();
+ app.addT<X86Test_AllocRetFloat1>();
+ app.addT<X86Test_AllocRetFloat2>();
+ app.addT<X86Test_AllocRetDouble1>();
+ app.addT<X86Test_AllocRetDouble2>();
+ app.addT<X86Test_AllocStack>();
+ app.addT<X86Test_AllocMemcpy>();
+ app.addT<X86Test_AllocExtraBlock>();
+ app.addT<X86Test_AllocAlphaBlend>();
+
+ // Function call tests.
+ app.addT<X86Test_FuncCallBase1>();
+ app.addT<X86Test_FuncCallBase2>();
+ app.addT<X86Test_FuncCallStd>();
+ app.addT<X86Test_FuncCallFast>();
+ app.addT<X86Test_FuncCallLight>();
+ app.addT<X86Test_FuncCallManyArgs>();
+ app.addT<X86Test_FuncCallDuplicateArgs>();
+ app.addT<X86Test_FuncCallImmArgs>();
+ app.addT<X86Test_FuncCallPtrArgs>();
+ app.addT<X86Test_FuncCallRefArgs>();
+ app.addT<X86Test_FuncCallFloatAsXmmRet>();
+ app.addT<X86Test_FuncCallDoubleAsXmmRet>();
+ app.addT<X86Test_FuncCallConditional>();
+ app.addT<X86Test_FuncCallMultiple>();
+ app.addT<X86Test_FuncCallRecursive>();
+ app.addT<X86Test_FuncCallVarArg1>();
+ app.addT<X86Test_FuncCallVarArg2>();
+ app.addT<X86Test_FuncCallMisc1>();
+ app.addT<X86Test_FuncCallMisc2>();
+ app.addT<X86Test_FuncCallMisc3>();
+ app.addT<X86Test_FuncCallMisc4>();
+ app.addT<X86Test_FuncCallMisc5>();
+
+ // Miscellaneous tests.
+ app.addT<X86Test_MiscLocalConstPool>();
+ app.addT<X86Test_MiscGlobalConstPool>();
+ app.addT<X86Test_MiscMultiRet>();
+ app.addT<X86Test_MiscMultiFunc>();
+ app.addT<X86Test_MiscUnfollow>();
+
+ return app.run();
+}
diff --git a/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp b/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp
new file mode 100644
index 00000000000..a9645b31649
--- /dev/null
+++ b/3rdparty/asmjit/test/asmjit_test_x86_sections.cpp
@@ -0,0 +1,176 @@
+// AsmJit - Machine code generation for C++
+//
+// * Official AsmJit Home Page: https://asmjit.com
+// * Official Github Repository: https://github.com/asmjit/asmjit
+//
+// Copyright (c) 2008-2020 The AsmJit Authors
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+// claim that you wrote the original software. If you use this software
+// in a product, an acknowledgment in the product documentation would be
+// appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+// misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+// ----------------------------------------------------------------------------
+// This is a working example that demonstrates how multiple sections can be
+// used in a JIT-based code generator. It shows also the necessary tooling
+// that is expected to be done by the user when the feature is used. It's
+// important to handle the following cases:
+//
+// - Assign offsets to sections when the code generation is finished.
+// - Tell the CodeHolder to resolve unresolved links and check whether
+// all links were resolved.
+// - Relocate the code
+// - Copy the code to the destination address.
+// ----------------------------------------------------------------------------
+
+#include <asmjit/x86.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+using namespace asmjit;
+
+// The generated function is very simple, it only accesses the built-in data
+// (from .data section) at the index as provided by its first argument. This
+// data is inlined into the resulting function so we can use it this array
+// for verification that the function returns correct values.
+static const uint8_t dataArray[] = { 2, 9, 4, 7, 1, 3, 8, 5, 6, 0 };
+
+static void fail(const char* message, Error err) {
+ printf("%s: %s\n", message, DebugUtils::errorAsString(err));
+ exit(1);
+}
+
+int main() {
+ CodeInfo codeInfo(ArchInfo::kIdHost);
+ JitAllocator allocator;
+
+#ifndef ASMJIT_NO_LOGGING
+ FileLogger logger(stdout);
+ logger.setIndentation(FormatOptions::kIndentationCode, 2);
+#endif
+
+ CodeHolder code;
+ code.init(codeInfo);
+
+#ifndef ASMJIT_NO_LOGGING
+ code.setLogger(&logger);
+#endif
+
+ Section* dataSection;
+ Error err = code.newSection(&dataSection, ".data", SIZE_MAX, 0, 8);
+
+ if (err) {
+ fail("Failed to create a .data section", err);
+ }
+ else {
+ printf("Generating code:\n");
+ x86::Assembler a(&code);
+ x86::Gp idx = a.zax();
+ x86::Gp addr = a.zcx();
+
+ Label data = a.newLabel();
+
+ FuncDetail func;
+ func.init(FuncSignatureT<size_t, size_t>(CallConv::kIdHost));
+
+ FuncFrame frame;
+ frame.init(func);
+ frame.addDirtyRegs(idx, addr);
+
+ FuncArgsAssignment args(&func);
+ args.assignAll(idx);
+ args.updateFuncFrame(frame);
+ frame.finalize();
+
+ a.emitProlog(frame);
+ a.emitArgsAssignment(frame, args);
+
+ a.lea(addr, x86::ptr(data));
+ a.movzx(idx, x86::byte_ptr(addr, idx));
+
+ a.emitEpilog(frame);
+
+ a.section(dataSection);
+ a.bind(data);
+
+ a.embed(dataArray, sizeof(dataArray));
+ }
+
+ // Manually change he offsets of each section, start at 0. This code is very
+ // similar to what `CodeHolder::flatten()` does, however, it's shown here
+ // how to do it explicitly.
+ printf("\nCalculating section offsets:\n");
+ uint64_t offset = 0;
+ for (Section* section : code.sections()) {
+ offset = Support::alignUp(offset, section->alignment());
+ section->setOffset(offset);
+ offset += section->realSize();
+
+ printf(" [0x%08X %s] {Id=%u Size=%u}\n",
+ uint32_t(section->offset()),
+ section->name(),
+ section->id(),
+ uint32_t(section->realSize()));
+ }
+ size_t codeSize = size_t(offset);
+ printf(" Final code size: %zu\n", codeSize);
+
+ // Resolve cross-section links (if any). On 32-bit X86 this is not necessary
+ // as this is handled through relocations as the addressing is different.
+ if (code.hasUnresolvedLinks()) {
+ printf("\nResolving cross-section links:\n");
+ printf(" Before 'resolveUnresolvedLinks()': %zu\n", code.unresolvedLinkCount());
+
+ err = code.resolveUnresolvedLinks();
+ if (err)
+ fail("Failed to resolve cross-section links", err);
+ printf(" After 'resolveUnresolvedLinks()': %zu\n", code.unresolvedLinkCount());
+ }
+
+ // Allocate memory for the function and relocate it there.
+ void* roPtr;
+ void* rwPtr;
+ err = allocator.alloc(&roPtr, &rwPtr, codeSize);
+ if (err)
+ fail("Failed to allocate executable memory", err);
+
+ // Relocate to the base-address of the allocated memory.
+ code.relocateToBase(uint64_t(uintptr_t(roPtr)));
+
+ // Copy the flattened code into `mem.rw`. There are two ways. You can either copy
+ // everything manually by iterating over all sections or use `copyFlattenedData`.
+ // This code is similar to what `copyFlattenedData(p, codeSize, 0)` would do:
+ for (Section* section : code.sections())
+ memcpy(static_cast<uint8_t*>(rwPtr) + size_t(section->offset()), section->data(), section->bufferSize());
+
+ // Execute the function and test whether it works.
+ typedef size_t (*Func)(size_t idx);
+ Func fn = (Func)roPtr;
+
+ printf("\nTesting the generated function:\n");
+ if (fn(0) != dataArray[0] ||
+ fn(3) != dataArray[3] ||
+ fn(6) != dataArray[6] ||
+ fn(9) != dataArray[9] ) {
+ printf(" [FAILED] The generated function returned incorrect result(s)\n");
+ return 1;
+ }
+ else {
+ printf(" [PASSED] The generated function returned expected results\n");
+ }
+
+ allocator.release((void*)fn);
+ return 0;
+}
diff --git a/3rdparty/asmjit/test/broken.cpp b/3rdparty/asmjit/test/broken.cpp
new file mode 100644
index 00000000000..bb874fdc13b
--- /dev/null
+++ b/3rdparty/asmjit/test/broken.cpp
@@ -0,0 +1,312 @@
+// Broken - Lightweight unit testing for C++
+//
+// This is free and unencumbered software released into the public domain.
+//
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+//
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// For more information, please refer to <http://unlicense.org>
+
+#include "./broken.h"
+#include <stdarg.h>
+
+// ============================================================================
+// [Broken - Global]
+// ============================================================================
+
+// Zero initialized globals.
+struct BrokenGlobal {
+ // Application arguments.
+ int _argc;
+ const char** _argv;
+
+ // Output file.
+ FILE* _file;
+
+ // Unit tests.
+ BrokenAPI::Unit* _unitList;
+ BrokenAPI::Unit* _unitRunning;
+
+ bool hasArg(const char* a) const noexcept {
+ for (int i = 1; i < _argc; i++)
+ if (strcmp(_argv[i], a) == 0)
+ return true;
+ return false;
+ }
+
+ inline FILE* file() const noexcept { return _file ? _file : stdout; }
+};
+static BrokenGlobal _brokenGlobal;
+
+// ============================================================================
+// [Broken - API]
+// ============================================================================
+
+// Get whether the string `a` starts with string `b`.
+static bool BrokenAPI_startsWith(const char* a, const char* b) noexcept {
+ for (size_t i = 0; ; i++) {
+ if (b[i] == '\0') return true;
+ if (a[i] != b[i]) return false;
+ }
+}
+
+//! Compares names and priority of two unit tests.
+static int BrokenAPI_compareUnits(const BrokenAPI::Unit* a, const BrokenAPI::Unit* b) noexcept {
+ if (a->priority == b->priority)
+ return strcmp(a->name, b->name);
+ else
+ return a->priority > b->priority ? 1 : -1;
+}
+
+// Get whether the strings `a` and `b` are equal, ignoring case and treating
+// `-` as `_`.
+static bool BrokenAPI_matchesFilter(const char* a, const char* b) noexcept {
+ for (size_t i = 0; ; i++) {
+ int ca = (unsigned char)a[i];
+ int cb = (unsigned char)b[i];
+
+ // If filter is defined as wildcard the rest automatically matches.
+ if (cb == '*')
+ return true;
+
+ if (ca == '-') ca = '_';
+ if (cb == '-') cb = '_';
+
+ if (ca >= 'A' && ca <= 'Z') ca += 'a' - 'A';
+ if (cb >= 'A' && cb <= 'Z') cb += 'a' - 'A';
+
+ if (ca != cb)
+ return false;
+
+ if (ca == '\0')
+ return true;
+ }
+}
+
+static bool BrokenAPI_canRun(BrokenAPI::Unit* unit) noexcept {
+ BrokenGlobal& global = _brokenGlobal;
+
+ int i, argc = global._argc;
+ const char** argv = global._argv;
+
+ const char* unitName = unit->name;
+ bool hasFilter = false;
+
+ for (i = 1; i < argc; i++) {
+ const char* arg = argv[i];
+
+ if (BrokenAPI_startsWith(arg, "--run-") && strcmp(arg, "--run-all") != 0) {
+ hasFilter = true;
+
+ if (BrokenAPI_matchesFilter(unitName, arg + 6))
+ return true;
+ }
+ }
+
+ // If no filter has been specified the default is to run.
+ return !hasFilter;
+}
+
+static void BrokenAPI_runUnit(BrokenAPI::Unit* unit) noexcept {
+ BrokenAPI::info("Running %s", unit->name);
+
+ _brokenGlobal._unitRunning = unit;
+ unit->entry();
+ _brokenGlobal._unitRunning = NULL;
+}
+
+static void BrokenAPI_runAll() noexcept {
+ BrokenAPI::Unit* unit = _brokenGlobal._unitList;
+
+ bool hasUnits = unit != NULL;
+ size_t count = 0;
+ int currentPriority = 0;
+
+ while (unit != NULL) {
+ if (BrokenAPI_canRun(unit)) {
+ if (currentPriority != unit->priority) {
+ if (count)
+ INFO("");
+ INFO("[[Priority=%d]]", unit->priority);
+ }
+
+ currentPriority = unit->priority;
+ BrokenAPI_runUnit(unit);
+ count++;
+ }
+ unit = unit->next;
+ }
+
+ if (count) {
+ INFO("\nSuccess:");
+ INFO(" All tests passed!");
+ }
+ else {
+ INFO("\nWarning:");
+ INFO(" No units %s!", hasUnits ? "matched the filter" : "defined");
+ }
+}
+
+static void BrokenAPI_listAll() noexcept {
+ BrokenAPI::Unit* unit = _brokenGlobal._unitList;
+
+ if (unit != NULL) {
+ INFO("Units:");
+ do {
+ INFO(" %s [priority=%d]", unit->name, unit->priority);
+ unit = unit->next;
+ } while (unit != NULL);
+ }
+ else {
+ INFO("Warning:");
+ INFO(" No units defined!");
+ }
+}
+
+bool BrokenAPI::hasArg(const char* name) noexcept {
+ return _brokenGlobal.hasArg(name);
+}
+
+void BrokenAPI::add(Unit* unit) noexcept {
+ Unit** pPrev = &_brokenGlobal._unitList;
+ Unit* current = *pPrev;
+
+ // C++ static initialization doesn't guarantee anything. We sort all units by
+ // name so the execution will always happen in deterministic order.
+ while (current != NULL) {
+ if (BrokenAPI_compareUnits(current, unit) >= 0)
+ break;
+
+ pPrev = &current->next;
+ current = *pPrev;
+ }
+
+ *pPrev = unit;
+ unit->next = current;
+}
+
+void BrokenAPI::setOutputFile(FILE* file) noexcept {
+ BrokenGlobal& global = _brokenGlobal;
+
+ global._file = file;
+}
+
+int BrokenAPI::run(int argc, const char* argv[], Entry onBeforeRun, Entry onAfterRun) {
+ BrokenGlobal& global = _brokenGlobal;
+
+ global._argc = argc;
+ global._argv = argv;
+
+ if (global.hasArg("--help")) {
+ INFO("Options:");
+ INFO(" --help - print this usage");
+ INFO(" --list - list all tests");
+ INFO(" --run-... - run a test(s), trailing wildcards supported");
+ INFO(" --run-all - run all tests (default)");
+ return 0;
+ }
+
+ if (global.hasArg("--list")) {
+ BrokenAPI_listAll();
+ return 0;
+ }
+
+ if (onBeforeRun)
+ onBeforeRun();
+
+ // We don't care about filters here, it's implemented by `runAll`.
+ BrokenAPI_runAll();
+
+ if (onAfterRun)
+ onAfterRun();
+
+ return 0;
+}
+
+static void BrokenAPI_printMessage(const char* prefix, const char* fmt, va_list ap) noexcept {
+ BrokenGlobal& global = _brokenGlobal;
+ FILE* dst = global.file();
+
+ if (!fmt || fmt[0] == '\0') {
+ fprintf(dst, "\n");
+ }
+ else {
+ // This looks scary, but we really want to use only a single call to vfprintf()
+ // in multithreaded code. So we change the format a bit if necessary.
+ enum : unsigned { kBufferSize = 512 };
+ char staticBuffer[512];
+
+ size_t fmtSize = strlen(fmt);
+ size_t prefixSize = strlen(prefix);
+
+ char* fmtBuf = staticBuffer;
+ if (fmtSize > kBufferSize - 2 - prefixSize)
+ fmtBuf = static_cast<char*>(malloc(fmtSize + prefixSize + 2));
+
+ if (!fmtBuf) {
+ fprintf(dst, "%sCannot allocate buffer for vfprintf()\n", prefix);
+ }
+ else {
+ memcpy(fmtBuf, prefix, prefixSize);
+ memcpy(fmtBuf + prefixSize, fmt, fmtSize);
+
+ fmtSize += prefixSize;
+ if (fmtBuf[fmtSize - 1] != '\n')
+ fmtBuf[fmtSize++] = '\n';
+ fmtBuf[fmtSize] = '\0';
+
+ vfprintf(dst, fmtBuf, ap);
+
+ if (fmtBuf != staticBuffer)
+ free(fmtBuf);
+ }
+ }
+
+ fflush(dst);
+}
+
+void BrokenAPI::info(const char* fmt, ...) noexcept {
+ BrokenGlobal& global = _brokenGlobal;
+
+ va_list ap;
+ va_start(ap, fmt);
+ BrokenAPI_printMessage(global._unitRunning ? " " : "", fmt, ap);
+ va_end(ap);
+}
+
+void BrokenAPI::fail(const char* file, int line, const char* expression, const char* fmt, ...) noexcept {
+ BrokenGlobal& global = _brokenGlobal;
+ FILE* dst = global.file();
+
+ fprintf(dst, " FAILED: %s\n", expression);
+
+ if (fmt) {
+ va_list ap;
+ va_start(ap, fmt);
+ BrokenAPI_printMessage(" REASON: ", fmt, ap);
+ va_end(ap);
+ }
+
+ fprintf(dst, " SOURCE: %s (Line: %d)\n", file, line);
+ fflush(dst);
+
+ exit(1);
+}
diff --git a/3rdparty/asmjit/test/broken.h b/3rdparty/asmjit/test/broken.h
new file mode 100644
index 00000000000..701bc8b6e3c
--- /dev/null
+++ b/3rdparty/asmjit/test/broken.h
@@ -0,0 +1,148 @@
+// Broken - Lightweight unit testing for C++
+//
+// This is free and unencumbered software released into the public domain.
+//
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+//
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// For more information, please refer to <http://unlicense.org>
+
+#ifndef BROKEN_H_INCLUDED
+#define BROKEN_H_INCLUDED
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <utility>
+
+// Hide everything when using Doxygen. Ideally this can be protected by a macro,
+// but there is not globally and widely used one across multiple projects.
+
+//! \cond
+
+// ============================================================================
+// [Broken - API]
+// ============================================================================
+
+struct BrokenAPI {
+ //! Entry point of a unit test defined by `UNIT` macro.
+ typedef void (*Entry)(void);
+
+ enum Flags : unsigned {
+ kFlagFinished = 0x1
+ };
+
+ //! Test defined by `UNIT` macro.
+ struct Unit {
+ Entry entry;
+ const char* name;
+ int priority;
+ unsigned flags;
+ Unit* next;
+ };
+
+ //! Automatic unit registration by using static initialization.
+ struct AutoUnit : Unit {
+ inline AutoUnit(Entry entry_, const char* name_, int priority_ = 0, int dummy_ = 0) noexcept {
+ // Not used, only to trick `UNIT()` macro.
+ (void)dummy_;
+
+ this->entry = entry_;
+ this->name = name_;
+ this->priority = priority_;
+ this->flags = 0;
+ this->next = nullptr;
+ BrokenAPI::add(this);
+ }
+ };
+
+ static bool hasArg(const char* name) noexcept;
+
+ //! Register a new unit test (called automatically by `AutoUnit` and `UNIT`).
+ static void add(Unit* unit) noexcept;
+
+ //! Set output file to a `file`.
+ static void setOutputFile(FILE* file) noexcept;
+
+ //! Initialize `Broken` framework.
+ //!
+ //! Returns `true` if `run()` should be called.
+ static int run(int argc, const char* argv[], Entry onBeforeRun = nullptr, Entry onAfterRun = nullptr);
+
+ //! Log message, adds automatically new line if not present.
+ static void info(const char* fmt, ...) noexcept;
+
+ //! Called on `EXPECT()` failure.
+ static void fail(const char* file, int line, const char* expression, const char* fmt, ...) noexcept;
+
+ //! Used internally by `EXPECT` macro.
+ template<typename T>
+ static inline void expect(const char* file, int line, const char* expression, const T& result) noexcept {
+ if (!result)
+ fail(file, line, expression, nullptr);
+ }
+
+ //! Used internally by `EXPECT` macro.
+ template<typename T, typename... Args>
+ static inline void expect(const char* file, int line, const char* expression, const T& result, const char* fmt, Args&&... args) noexcept {
+ if (!result)
+ fail(file, line, expression, fmt, std::forward<Args>(args)...);
+ }
+};
+
+// ============================================================================
+// [Broken - Macros]
+// ============================================================================
+
+//! Internal macro used by `UNIT()`.
+#define BROKEN_UNIT_INTERNAL(NAME, PRIORITY) \
+ static void unit_##NAME##_entry(void); \
+ static ::BrokenAPI::AutoUnit unit_##NAME##_autoinit(unit_##NAME##_entry, #NAME, PRIORITY); \
+ static void unit_##NAME##_entry(void)
+
+//! Stringifies the expression used by EXPECT().
+#define BROKEN_STRINFIGY_EXPRESSION_INTERNAL(EXP, ...) #EXP
+
+//! \def UNIT(NAME [, PRIORITY])
+//!
+//! Define a unit test with an optional priority.
+//!
+//! `NAME` can only contain ASCII characters, numbers and underscore. It has
+//! the same rules as identifiers in C and C++.
+//!
+//! `PRIORITY` specifies the order in which unit tests are run. Lesses value
+//! increases the priority. At the moment all units are first sorted by
+//! priority and then by name - this makes the run always deterministic.
+#define UNIT(NAME, ...) BROKEN_UNIT_INTERNAL(NAME, __VA_ARGS__ + 0)
+
+//! #define INFO(FORMAT [, ...])
+//!
+//! Informative message printed to `stdout`.
+#define INFO(...) ::BrokenAPI::info(__VA_ARGS__)
+
+//! #define INFO(EXP [, FORMAT [, ...]])
+//!
+//! Expect `EXP` to be true or evaluates to true, fail otherwise.
+#define EXPECT(...) ::BrokenAPI::expect(__FILE__, __LINE__, BROKEN_STRINFIGY_EXPRESSION_INTERNAL(__VA_ARGS__), __VA_ARGS__)
+
+//! \endcond
+
+#endif // BROKEN_H_INCLUDED