#include #include #include #include #include #include "./asmtk.h" #include "./cmdline.h" using namespace asmjit; using namespace asmtk; struct TestEntry { uint64_t base_address; Arch arch; uint8_t must_pass; uint8_t asm_size; uint8_t machine_code_size; char machine_code[16]; char asm_string[64]; }; #define X86_PASS(BASE, MACHINE_CODE, ASM_STRING) { \ BASE, \ Arch::kX86, \ true, \ uint8_t(sizeof(ASM_STRING ) - 1), \ uint8_t(sizeof(MACHINE_CODE) - 1), \ MACHINE_CODE, \ ASM_STRING \ } #define X86_FAIL(BASE, ASM_STRING) { \ BASE, \ Arch::kX86, \ false, \ uint8_t(sizeof(ASM_STRING ) - 1), \ 0, \ "", \ ASM_STRING \ } #define X64_PASS(BASE, MACHINE_CODE, ASM_STRING) { \ BASE, \ Arch::kX64, \ true, \ uint8_t(sizeof(ASM_STRING ) - 1), \ uint8_t(sizeof(MACHINE_CODE) - 1), \ MACHINE_CODE, \ ASM_STRING \ } #define X64_FAIL(BASE, ASM_STRING) { \ BASE, \ Arch::kX64, \ false, \ uint8_t(sizeof(ASM_STRING ) - 1), \ 0, \ "", \ ASM_STRING \ } #define RELOC_BASE_ADDRESS Globals::kNoBaseAddress // Some tests are unique, some were derived from other assembler tests: // - Capstone - https://github.com/aquynh/capstone // - XEDParse - https://github.com/x64dbg/XEDParse // - LLVM - https://github.com/llvm/llvm-project/tree/master/llvm/test/MC/X86 static const TestEntry test_entries[] = { // Comments. X86_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "mov al, 0 ; Standard comment"), X86_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "mov al, 0 // C/C++ comment"), X86_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "; Standard comment\nmov al, 0"), X86_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "// C/C++ comment\nmov al, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "mov al, 0 ; Standard comment"), X64_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "mov al, 0 // C/C++ comment"), X64_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "; Standard comment\nmov al, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\xB0\x00" , "// C/C++ comment\nmov al, 0"), // 32-bit constants parsing. X86_PASS(RELOC_BASE_ADDRESS, "\xB8\x00\x00\x00\x00" , "mov eax, 0"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\x00\x00\x00\x00" , "mov eax, 00"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 1000"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, $3E8"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, $03E8"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 0x3E8"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 3E8h"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 03E8h"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 1750o"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 1750q"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 01750"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 01750o"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 01750q"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 1111101000b"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 01111101000b"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 0b1111101000"), // 64-bit constants parsing. X64_PASS(RELOC_BASE_ADDRESS, "\x48\xC7\xC3\x00\x00\x00\x00" , "mov rbx, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xBB\x88\x77\x66\x55\x44\x33\x22\x11" , "mov rbx, 0x001122334455667788"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xBB\x00\x00\x00\x00\x00\x00\x00\x00" , "long mov rbx, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xBB\x00\x00\x00\x00\x00\x00\x00\x00" , "movabs rbx, 0"), // 32-bit base instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x88\xC4" , "mov ah, al"), X86_PASS(RELOC_BASE_ADDRESS, "\x88\xC6" , "mov dh, al"), X86_PASS(RELOC_BASE_ADDRESS, "\x89\xD8" , "mov EAX, Ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\xC3" , "modrm mov eax, ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\xB8\xFF\xFF\xFF\xFF" , "mov eax, 0xFFFFFFFF"), X86_PASS(RELOC_BASE_ADDRESS, "\x8C\xE0" , "mov eax, fs"), X86_PASS(RELOC_BASE_ADDRESS, "\x8E\xE0" , "mov fs, eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x10" , "mov edx, [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x10" , "mov edx, [eax + 0]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x90\x80\x00\x00\x00" , "mov edx, [eax + 128]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x14\x08" , "mov edx, [eax + ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x94\x08\x80\x00\x00\x00" , "mov edx, [eax + ecx + 128]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x14\x08" , "mov edx, [eax + ecx * 1]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x54\x48\x20" , "mov edx, [eax + ecx * 2 + 32]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x54\x88\x40" , "mov edx, [eax + ecx * 4 + 64]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x94\xC8\x00\x01\x00\x00" , "mov edx, [eax + ecx * 8 + 128 + 128]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x14\x08" , "mov edx, [eax , ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x14\x08" , "mov edx, [eax + 0, ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x94\x08\x80\x00\x00\x00" , "mov edx, [eax + 128, ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x14\x08" , "mov edx, [eax , ecx * 1]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x14\x08" , "mov edx, [eax + 0, ecx * 1]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x54\x48\x20" , "mov edx, [eax + 32, ecx * 2]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x54\xC8\x02" , "mov edx, [eax + 1+1, ecx * 8]"), X86_PASS(RELOC_BASE_ADDRESS, "\x64\x8B\x10" , "mov edx, fs:[eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x64\xA1\x2C\x00\x00\x00" , "mov eax, fs:[0x2C]"), X86_PASS(RELOC_BASE_ADDRESS, "\x64\x8B\x15\x2C\x00\x00\x00" , "mov edx, fs:[0x2C]"), X86_PASS(RELOC_BASE_ADDRESS, "\x65\x8B\x15\x2C\x00\x00\x00" , "mov edx, gs:[0x2C]"), X86_PASS(RELOC_BASE_ADDRESS, "\x64\xA3\x2C\x00\x00\x00" , "mov fs:[0x2C], eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x64\x89\x15\x2C\x00\x00\x00" , "mov fs:[0x2C], edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x65\x89\x15\x2C\x00\x00\x00" , "mov gs:[0x2C], edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x20\xC0" , "mov eax, cr0"), X86_PASS(RELOC_BASE_ADDRESS, "\xF0\x0F\x20\xC0" , "mov eax, cr8"), X86_PASS(RELOC_BASE_ADDRESS, "\xA3\x44\x33\x22\x11" , "mov [0x11223344], eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x89\x05\x44\x33\x22\x11" , "modmr mov [0x11223344], eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x89\x1D\x44\x33\x22\x11" , "mov [0x11223344], ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xBE\x07" , "movsx eax, byte ptr [edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xBF\x07" , "movsx eax, word ptr [edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xB6\x07" , "movzx eax, byte ptr [edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xB6\xC6" , "movzx eax, dh"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xB7\x07" , "movzx eax, word ptr [edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8D\x05\x00\x00\x00\x00" , "lea eax, [0]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF0\x01\x18" , "lock add [eax], ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF0\x0F\xC1\x38" , "lock xadd [eax], edi"), X86_PASS(RELOC_BASE_ADDRESS, "\x50" , "push eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x51" , "push ecx"), X86_PASS(RELOC_BASE_ADDRESS, "\x52" , "push edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x53" , "push ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\x54" , "push esp"), X86_PASS(RELOC_BASE_ADDRESS, "\x55" , "push ebp"), X86_PASS(RELOC_BASE_ADDRESS, "\x56" , "push esi"), X86_PASS(RELOC_BASE_ADDRESS, "\x57" , "push edi"), X86_PASS(RELOC_BASE_ADDRESS, "\x0E" , "push cs"), X86_PASS(RELOC_BASE_ADDRESS, "\x16" , "push ss"), X86_PASS(RELOC_BASE_ADDRESS, "\x1E" , "push ds"), X86_PASS(RELOC_BASE_ADDRESS, "\x06" , "push es"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xA0" , "push fs"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xA8" , "push gs"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xBA\x20\x01" , "bt word ptr [eax], 1"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xBA\x20\x01" , "bt dword ptr [eax], 1"), X86_PASS(RELOC_BASE_ADDRESS, "\xFE\x00" , "inc byte ptr [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xFF\x00" , "inc word ptr [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\xFF\x00" , "inc dword ptr [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF6\xD8" , "neg al"), X86_PASS(RELOC_BASE_ADDRESS, "\xF6\xDC" , "neg ah"), X86_PASS(RELOC_BASE_ADDRESS, "\xF7\xD8" , "neg eax"), X86_PASS(RELOC_BASE_ADDRESS, "\xF7\xD0" , "not eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x95\xC3" , "setne bl"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x95\xC3" , "setnz bl"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x94\xC7" , "sete bh"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x94\xC7" , "setz bh"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF0\xC7" , "crc32 eax, bh"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xF2\x0F\x38\xF1\xC3" , "crc32 eax, bx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF1\xC1" , "crc32 eax, ecx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF0\x06" , "crc32 eax, byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xF2\x0F\x38\xF1\x06" , "crc32 eax, word ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF1\x06" , "crc32 eax, dword ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF6\x00\xFF" , "test byte ptr [eax], 0xFF"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xF7\x00\xFF\x00" , "test word ptr [eax], 0xFF"), X86_PASS(RELOC_BASE_ADDRESS, "\xF7\x00\xFF\x00\x00\x00" , "test dword ptr [eax], 0xFF"), X86_PASS(RELOC_BASE_ADDRESS, "\xA8\x36" , "test al, 0x36"), X86_PASS(RELOC_BASE_ADDRESS, "\xF6\xC4\x36" , "test ah, 0x36"), X86_PASS(RELOC_BASE_ADDRESS, "\xFF\x10" , "call [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\xFF\x10" , "call dword ptr [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xC5\x01" , "lds ax , [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\x01" , "lds eax, [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xC4\x01" , "les ax , [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC4\x01" , "les eax, [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xB4\x01" , "lfs ax , [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xB4\x01" , "lfs eax, [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xB5\x01" , "lgs ax , [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xB5\x01" , "lgs eax, [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xB2\x01" , "lss ax , [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xB2\x01" , "lss eax, [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC8\x01\x00\x02" , "enter 1, 2"), X86_PASS(RELOC_BASE_ADDRESS, "\xC9" , "leave"), // 64-bit base instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x88\xC4" , "mov ah, al"), X64_PASS(RELOC_BASE_ADDRESS, "\x88\xC6" , "mov dh, al"), X64_PASS(RELOC_BASE_ADDRESS, "\xB8\xE8\x03\x00\x00" , "mov eax, 1000"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x20\xC0" , "mov rax, cr0"), X64_PASS(RELOC_BASE_ADDRESS, "\x44\x0F\x20\xC0" , "mov rax, cr8"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x8B\x05\x00\x00\x00\x00" , "mov rax, [rip]"), X64_PASS(RELOC_BASE_ADDRESS, "\x4A\x8B\x04\x60" , "mov rax, [rax + r12 * 2]"), X64_PASS(RELOC_BASE_ADDRESS, "\x4A\x8B\x04\x68" , "mov rax, [rax + r13 * 2]"), X64_PASS(RELOC_BASE_ADDRESS, "\x4A\x8B\x84\x60\x00\x01\x00\x00" , "mov rax, [rax + r12 * 2 + 256]"), X64_PASS(RELOC_BASE_ADDRESS, "\x64\x8B\x04\x25\x2C\x00\x00\x00" , "mov eax, fs:[0x2C]"), X64_PASS(RELOC_BASE_ADDRESS, "\x64\x8B\x14\x25\x2C\x00\x00\x00" , "mov edx, fs:[0x2C]"), X64_PASS(RELOC_BASE_ADDRESS, "\x64\x89\x04\x25\x2C\x00\x00\x00" , "mov fs:[0x2C], eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x64\x89\x14\x25\x2C\x00\x00\x00" , "mov fs:[0x2C], edx"), X64_PASS(RELOC_BASE_ADDRESS, "\x89\x04\x25\x44\x33\x22\x11" , "mov [0x11223344], eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x89\x1C\x25\x44\x33\x22\x11" , "mov [0x11223344], ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\xA3\x88\x77\x66\x55\x44\x33\x22\x11" , "mov [0x1122334455667788], eax"), X64_PASS(0x1122334455667788, "\x89\x05\xFA\xFF\xFF\xFF" , "mov [0x1122334455667788], eax"), X64_PASS(0x1122334455667788, "\x89\x05\xFA\xFF\xFF\xFF" , "mov [rel 0x1122334455667788], eax"), X64_PASS(0x1122334455667788, "\xA3\x88\x77\x66\x55\x44\x33\x22\x11" , "mov [abs 0x1122334455667788], eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xA1\xEF\xCD\xAB\x89\x67\x45\x23\x01" , "movabs rax, [0x123456789ABCDEF]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xBE\x07" , "movsx eax, byte ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xBE\x07" , "movsx rax, byte ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xBF\x07" , "movsx eax, word ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xBF\x07" , "movsx rax, word ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x63\x07" , "movsxd rax, [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x63\x07" , "movsxd rax, dword ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x63\xC3" , "movsxd ax, bx"), X64_PASS(RELOC_BASE_ADDRESS, "\x63\xC3" , "movsxd eax, ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x63\xC3" , "movsxd rax, ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xB6\xC6" , "movzx eax, dh"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xB6\x07" , "movzx eax, byte ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xB6\x07" , "movzx rax, byte ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x44\x0F\xB6\xFA" , "movzx r15d, dl"), X64_PASS(RELOC_BASE_ADDRESS, "\x44\x0F\xB6\xFD" , "movzx r15d, bpl"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xB7\x07" , "movzx eax, word ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xB7\x07" , "movzx rax, word ptr [rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\x42\xC3" , "cmovc rax, rbx"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\x47\xC3" , "cmova rax, rbx"), X64_PASS(RELOC_BASE_ADDRESS, "\x8D\x04\x25\x00\x00\x00\x00" , "lea eax, [0]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x8D\x04\x25\x00\x00\x00\x00" , "lea rax, [0]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF0\x01\x18" , "lock add [rax], ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF0\x48\x0F\xC1\x38" , "lock xadd [rax], rdi"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xA0" , "push fs"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xA8" , "push gs"), X64_PASS(RELOC_BASE_ADDRESS, "\x40\x0F\xA8" , "rex push gs"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xC8" , "bswap ax"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xC8" , "bswap eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xC8" , "bswap rax"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xBA\x20\x01" , "bt word ptr [rax], 1"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xBA\x20\x01" , "bt dword ptr [rax], 1"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xBA\x20\x01" , "bt qword ptr [rax], 1"), X64_PASS(RELOC_BASE_ADDRESS, "\xFE\x00" , "inc byte ptr [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xFF\x00" , "inc word ptr [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\xFF\x00" , "inc dword ptr [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xFF\x00" , "inc qword ptr [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x41\x13\x51\xFD" , "adc edx, dword ptr ds:[r9-3]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF6\xD8" , "neg al"), X64_PASS(RELOC_BASE_ADDRESS, "\xF6\xDC" , "neg ah"), X64_PASS(RELOC_BASE_ADDRESS, "\x40\xF6\xDE" , "neg sil"), X64_PASS(RELOC_BASE_ADDRESS, "\xF7\xD8" , "neg eax"), X64_PASS(RELOC_BASE_ADDRESS, "\xF7\xD0" , "not eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x95\xC3" , "setnz bl"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x94\xC7" , "setz bh"), X64_PASS(RELOC_BASE_ADDRESS, "\x40\x0F\x94\xC0" , "rex setz al"), X64_PASS(RELOC_BASE_ADDRESS, "\x41\x0F\x94\xC7" , "setz r15b"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF0\xC7" , "crc32 eax, bh"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF2\x0F\x38\xF1\xC3" , "crc32 eax, bx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF1\xC1" , "crc32 eax, ecx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF0\x06" , "crc32 eax, byte ptr [rsi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF2\x0F\x38\xF1\x06" , "crc32 eax, word ptr [rsi]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF1\x06" , "crc32 eax, dword ptr [rsi]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x48\x0F\x38\xF0\xC3" , "crc32 rax, bl"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x48\x0F\x38\xF1\xC1" , "crc32 rax, rcx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x48\x0F\x38\xF0\x06" , "crc32 rax, byte ptr [rsi]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x48\x0F\x38\xF1\x06" , "crc32 rax, qword ptr [rsi]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF6\x00\xFF" , "test byte ptr [rax], 0xFF"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF7\x00\xFF\x00" , "test word ptr [rax], 0xFF"), X64_PASS(RELOC_BASE_ADDRESS, "\xF7\x00\xFF\x00\x00\x00" , "test dword ptr [rax], 0xFF"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xF7\x00\xFF\x00\x00\x00" , "test qword ptr [rax], 0xFF"), X64_PASS(RELOC_BASE_ADDRESS, "\xA8\x36" , "test al, 0x36"), X64_PASS(RELOC_BASE_ADDRESS, "\xF6\xC4\x36" , "test ah, 0x36"), X64_PASS(RELOC_BASE_ADDRESS, "\xFF\x10" , "call [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\xFF\x10" , "call qword ptr [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xB4\x01" , "lfs ax , [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xB4\x01" , "lfs eax, [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xB4\x01" , "lfs rax, [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xB5\x01" , "lgs ax , [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xB5\x01" , "lgs eax, [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xB5\x01" , "lgs rax, [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xB2\x01" , "lss ax , [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xB2\x01" , "lss eax, [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xB2\x01" , "lss rax, [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC8\x01\x00\x02" , "enter 1, 2"), X64_PASS(RELOC_BASE_ADDRESS, "\x40\xC8\x01\x00\x02" , "rex enter 1, 2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC9" , "leave"), // 32-bit NOP. X86_PASS(RELOC_BASE_ADDRESS, "\x90" , "nop"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1F\x04\x00" , "nop word ptr [eax+eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1F\x04\x00" , "nop word ptr [eax+eax], ax"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1F\x1C\x00" , "nop word ptr [eax+eax], bx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x1F\x04\x00" , "nop dword ptr [eax+eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x1F\x04\x00" , "nop dword ptr [eax+eax], eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x1F\x1C\x00" , "nop dword ptr [eax+eax], ebx"), // 64-bit NOP. X64_PASS(RELOC_BASE_ADDRESS, "\x90" , "nop"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1F\x04\x00" , "nop word ptr [rax+rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1F\x04\x00" , "nop word ptr [rax+rax], ax"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1F\x1C\x00" , "nop word ptr [rax+rax], bx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x1F\x04\x00" , "nop dword ptr [rax+rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x1F\x04\x00" , "nop dword ptr [rax+rax], eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x1F\x1C\x00" , "nop dword ptr [rax+rax], ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\x1F\x04\x00" , "nop qword ptr [rax+rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\x1F\x04\x00" , "nop qword ptr [rax+rax], rax"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\x1F\x1C\x00" , "nop qword ptr [rax+rax], rbx"), // 32-bit XACQUIRE|XRELEASE|RTM. X86_PASS(RELOC_BASE_ADDRESS, "\xC7\xF8\xFA\xFF\xFF\xFF" , "L1: xbegin L1"), X86_PASS(RELOC_BASE_ADDRESS, "\xC6\xF8\x11" , "xabort 0x11"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xF0\x01\x08" , "xacquire lock add dword [eax], ecx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xF0\x01\x08" , "xrelease lock add dword [eax], ecx"), // 64-bit XACQUIRE|XRELEASE|RTM. X64_PASS(RELOC_BASE_ADDRESS, "\xC7\xF8\xFA\xFF\xFF\xFF" , "L1: xbegin L1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC6\xF8\x11" , "xabort 0x11"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\xF0\x48\x01\x08" , "xacquire lock add qword [rax], rcx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\xF0\x48\x01\x08" , "xrelease lock add qword [rax], rcx"), // 32-bit BMI+ instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x0F\xB8\xC2" , "popcnt ax, dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xB8\xC2" , "popcnt eax, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x0F\xBD\xC2" , "lzcnt ax, dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xBD\xC2" , "lzcnt eax, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x0F\xBC\xC2" , "tzcnt ax, dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xBC\xC2" , "tzcnt eax, edx"), // 64-bit BMI+ instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x0F\xB8\xC2" , "popcnt ax, dx"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x45\x0F\xB8\xC1" , "popcnt r8w, r9w"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xB8\xC2" , "popcnt eax, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x48\x0F\xB8\xC2" , "popcnt rax, rdx"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x0F\xBD\xC2" , "lzcnt ax, dx"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x45\x0F\xBD\xC7" , "lzcnt r8w, r15w"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xBD\xC2" , "lzcnt eax, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x49\x0F\xBD\xC2" , "lzcnt rax, r10"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x0F\xBC\xC2" , "tzcnt ax, dx"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\xF3\x45\x0F\xBC\xC7" , "tzcnt r8w, r15w"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xBC\xC2" , "tzcnt eax, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x4D\x0F\xBC\xFA" , "tzcnt r15, r10"), // 32-bit LEA with various addressing options. X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x00" , "lea ax, [bx + si]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x01" , "lea ax, [bx + di]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x02" , "lea ax, [bp + si]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x03" , "lea ax, [bp + di]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x04" , "lea ax, [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x05" , "lea ax, [di]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x46\x00" , "lea ax, [bp]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x07" , "lea ax, [bx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x40\x10" , "lea ax, [bx + si + 0x10]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x41\x20" , "lea ax, [bx + di + 0x20]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x42\x40" , "lea ax, [bp + si + 0x40]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x43\x60" , "lea ax, [bp + di + 0x60]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x84\x80\x00" , "lea ax, [si + 0x80]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x85\xA0\x00" , "lea ax, [di + 0xA0]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x86\xC0\x00" , "lea ax, [bp + 0xC0]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x66\x8D\x87\xFF\x01" , "lea ax, [bx + 0x01FF]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x8D\x00" , "lea eax, [bx + si]"), X86_PASS(RELOC_BASE_ADDRESS, "\x67\x8D\x01" , "lea eax, [bx + di]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8D\x04\x33" , "lea eax, [ebx + esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\x8D\x04\x3B" , "lea eax, [ebx + edi]"), // 64-bit LEA with various addressing options. X64_PASS(RELOC_BASE_ADDRESS, "\x48\x8D\x04\x33" , "lea rax, [rbx + rsi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x8D\x04\x3B" , "lea rax, [rbx + rdi]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x8D\x84\x00\x00\x40\x00\x00" , "lea rax, [rax + rax * 1 + 0x4000]"), // 32-bit FPU instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x9B" , "fwait"), X86_PASS(RELOC_BASE_ADDRESS, "\xD8\x00" , "fadd dword ptr [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\xDC\x00" , "fadd qword ptr [eax]"), // 64-bit FPU instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x9B" , "fwait"), X64_PASS(RELOC_BASE_ADDRESS, "\xD8\x00" , "fadd dword ptr [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\xDC\x00" , "fadd qword ptr [rax]"), // 32-bit BND instructions X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1A\xCA" , "bndmov bnd1, bnd2"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x1A\xCF" , "bndcu bnd1, edi"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x1A\x04\x08" , "bndldx bnd0, [eax + ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x1B\x0C\x08" , "bndstx [eax + ecx], bnd1"), // 64-bit BND instructions X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x1A\xCA" , "bndmov bnd1, bnd2"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x1A\xCF" , "bndcu bnd1, rdi"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x1A\x04\x08" , "bndldx bnd0, [rax + rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x1B\x0C\x08" , "bndstx [rax + rcx], bnd1"), // 32-bit MMX+ and SSE+ instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x6F\xC1" , "movq mm0, mm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x6E\x00" , "movd mm0, [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x6F\x04\x18" , "movq mm0, [eax + ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x7E\x38" , "movd [eax], mm7"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x7F\x04\x18" , "movq [eax + ebx], mm0"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xDB\xC1" , "pand mm0, mm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x7E\xC1" , "movq xmm0, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x6E\x04\x18" , "movd xmm0, [eax + ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x7E\x04\x18" , "movq xmm0, [eax + ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x7E\x0C\x18" , "movd [eax + ebx], xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xD6\x0C\x18" , "movq [eax + ebx], xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xDB\xC1" , "pand xmm0, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xFD\xC1" , "paddw xmm0, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x28\x04\x98" , "movaps xmm0, [eax + ebx * 4]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x28\x04\x98" , "movapd xmm0, [eax + ebx * 4]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x6F\x04\x98" , "movdqa xmm0, [eax + ebx * 4]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x29\x0C\x98" , "movaps [eax + ebx * 4], xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x29\x0C\x98" , "movapd [eax + ebx * 4], xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x7F\x0C\x98" , "movdqa [eax + ebx * 4], xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x3A\x41\xC1\x00" , "dppd xmm0, xmm1, 0"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x2D\xC1" , "cvtss2si eax, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x2D\xC1" , "cvtsd2si eax, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x2A\xC2" , "cvtsi2ss xmm0, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x2A\xC2" , "cvtsi2sd xmm0, edx"), // 64-bit MMX+ and SSE+ instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x6F\xC1" , "movq mm0, mm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x6E\x00" , "movd mm0, [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x6F\x04\x18" , "movq mm0, [rax + rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x7E\x38" , "movd [rax], mm7"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x7F\x04\x18" , "movq [rax + rbx], mm0"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xDB\xC1" , "pand mm0, mm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x7E\xC1" , "movq xmm0, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x6E\x04\x18" , "movd xmm0, [rax + rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x7E\x04\x18" , "movq xmm0, [rax + rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x7E\x0C\x18" , "movd [rax + rbx], xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xD6\x0C\x18" , "movq [rax + rbx], xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xDB\xC1" , "pand xmm0, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xFD\xC1" , "paddw xmm0, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x28\x04\x98" , "movaps xmm0, [rax + rbx * 4]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x28\x04\x98" , "movapd xmm0, [rax + rbx * 4]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x6F\x04\x98" , "movdqa xmm0, [rax + rbx * 4]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x29\x0C\x98" , "movaps [rax + rbx * 4], xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x29\x0C\x98" , "movapd [rax + rbx * 4], xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x7F\x0C\x98" , "movdqa [rax + rbx * 4], xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x45\x0F\x3A\x41\xD3\x00" , "dppd xmm10, xmm11, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x2D\xC1" , "cvtss2si eax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x48\x0F\x2D\xC1" , "cvtss2si rax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x2D\xC1" , "cvtsd2si eax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x48\x0F\x2D\xC1" , "cvtsd2si rax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x2A\xC2" , "cvtsi2ss xmm0, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x48\x0F\x2A\xC2" , "cvtsi2ss xmm0, rdx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x2A\xC2" , "cvtsi2sd xmm0, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x48\x0F\x2A\xC2" , "cvtsi2sd xmm0, rdx"), // 32-bit AVX+ and AVX512+ instructions. X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x6E\x5A\x10" , "vmovd xmm3, dword ptr [edx+0x10]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFA\x7E\x5A\x10" , "vmovq xmm3, qword ptr [edx+0x10]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x7E\x5A\x10" , "vmovd dword ptr [edx+0x10], xmm3"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\xD6\x5A\x10" , "vmovq qword ptr [edx+0x10], xmm3"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x6E\xEB" , "vmovd xmm5, ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x7E\xEB" , "vmovd ebx, xmm5"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFA\x7E\xC1" , "vmovq xmm0, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x7D\x08\x6E\xC0" , "evex vmovd xmm0, eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x7D\x08\x7E\xC0" , "evex vmovd eax, xmm0"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF5\xFD\xC7" , "vpaddw ymm0, ymm1, ymm7"), X86_PASS(RELOC_BASE_ADDRESS, "\xC4\xE3\x71\x41\xC2\x00" , "vdppd xmm0, xmm1, xmm2, 0"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xF5\xD9\x58\x00" , "vaddpd zmm0 {k1}{z}, zmm1, [eax] {1to8}"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF0\x58\xC2" , "vaddps xmm0, xmm1, xmm2"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x74\x88\x58\xC2" , "vaddps xmm0 {z}, xmm1, xmm2"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x74\x89\x58\xC2" , "vaddps xmm0 {k1}{z}, xmm1, xmm2"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6C\x4F\xC2\x54\x98\x04\x0F" , "vcmpps k2 {k7}, zmm2, zmmword ptr [eax+ebx*4+256], 15"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6C\x5F\xC2\x54\x98\x40\x0F" , "vcmpps k2 {k7}, zmm2, dword ptr [eax+ebx*4+256] {1to16}, 15"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFA\x2D\xC1" , "vcvtss2si eax, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFB\x2D\xC1" , "vcvtsd2si eax, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF2\x2A\xC2" , "vcvtsi2ss xmm0, xmm1, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF3\x2A\xC2" , "vcvtsi2sd xmm0, xmm1, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFB\xE6\x3B" , "vcvtpd2dq xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFF\xE6\x3B" , "vcvtpd2dq xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x5A\x3B" , "vcvtpd2ps xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFD\x5A\x3B" , "vcvtpd2ps xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x5A\xC1" , "vcvtpd2ps xmm0, xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x5A\x03" , "vcvtpd2ps xmm0, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFD\x5A\xC1" , "vcvtpd2ps xmm0, ymm1"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFD\x5A\x03" , "vcvtpd2ps xmm0, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x48\x5A\xC1" , "vcvtpd2ps ymm0, zmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x48\x5A\x03" , "vcvtpd2ps ymm0, zmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFC\x08\x79\x3B" , "vcvtpd2udq xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFC\x28\x79\x3B" , "vcvtpd2udq xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFC\x08\x5B\x3B" , "vcvtqq2ps xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFC\x28\x5B\x3B" , "vcvtqq2ps xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\xE6\x3B" , "vcvttpd2dq xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xC5\xFD\xE6\x3B" , "vcvttpd2dq xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFC\x08\x78\x3B" , "vcvttpd2udq xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFC\x28\x78\x3B" , "vcvttpd2udq xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFF\x08\x7A\x3B" , "vcvtuqq2ps xmm7, xmmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFF\x28\x7A\x3B" , "vcvtuqq2ps xmm7, ymmword ptr [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x08\x66\x3F\x01" , "vfpclasspd k7, xmmword ptr [edi], 0x01"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x28\x66\x3F\x01" , "vfpclasspd k7, ymmword ptr [edi], 0x01"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x48\x66\x3F\x01" , "vfpclasspd k7, zmmword ptr [edi], 0x01"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x7D\x08\x66\x3F\x01" , "vfpclassps k7, xmmword ptr [edi], 0x01"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x7D\x28\x66\x3F\x01" , "vfpclassps k7, ymmword ptr [edi], 0x01"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x7D\x48\x66\x3F\x01" , "vfpclassps k7, zmmword ptr [edi], 0x01"), X86_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\xF9\x90\x04\x05\x00\x00\x00\x00" , "vpgatherdq xmm0, [xmm0], xmm0"), X86_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\xFD\x91\x04\x05\x00\x00\x00\x00" , "vpgatherqq ymm0, [ymm0], ymm0"), X86_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\xE9\x92\x0C\x00" , "vgatherdpd xmm1, [eax + xmm0], xmm2"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x6D\x08\x3E\xCB\x00" , "vpcmpub k1, xmm2, xmm3, 0x0"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x6D\x48\xCF\x4C\x11\x01" , "vgf2p8mulb zmm1, zmm2, zmmword ptr [ecx+edx+64]"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xED\x48\xCE\x4C\x11\x01\x0F" , "vgf2p8affineqb zmm1, zmm2, zmmword ptr [ecx+edx+64], 15"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xED\x48\xCF\x4C\x11\x01\x0F" , "vgf2p8affineinvqb zmm1, zmm2, zmmword ptr [ecx+edx+64], 15"), X86_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x67\x48\x68\x24\x6D\x00\xF8\xFF\xFF" , "vp2intersectd k4, k5, zmm3, zmmword ptr [ebp*2 - 2048]"), // 64-bit AVX+ and AVX512+ instructions. X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x6E\x5A\x10" , "vmovd xmm3, dword ptr [rdx+0x10]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xFA\x7E\x5A\x10" , "vmovq xmm3, qword ptr [rdx+0x10]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x7E\x5A\x10" , "vmovd dword ptr [rdx+0x10], xmm3"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\xD6\x5A\x10" , "vmovq qword ptr [rdx+0x10], xmm3"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x6E\xEB" , "vmovd xmm5, ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE1\xF9\x6E\xEB" , "vmovq xmm5, rbx"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x61\x7D\x08\x6E\xFB" , "vmovd xmm31, ebx"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x61\xFD\x08\x6E\xFB" , "vmovq xmm31, rbx"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x7E\xEB" , "vmovd ebx, xmm5"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE1\xF9\x7E\xEB" , "vmovq rbx, xmm5"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x61\x7D\x08\x7E\xFB" , "vmovd ebx, xmm31"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x61\xFD\x08\x7E\xFB" , "vmovq rbx, xmm31"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xFA\x7E\xC1" , "vmovq xmm0, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x7D\x08\x6E\xC0" , "evex vmovd xmm0, eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x08\x6E\xC0" , "evex vmovq xmm0, rax"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x7D\x08\x7E\xC0" , "evex vmovd eax, xmm0"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x08\x7E\xC0" , "evex vmovq rax, xmm0"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\x41\x35\xFD\xC7" , "vpaddw ymm8, ymm9, ymm15"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\x43\x21\x41\xD4\x00" , "vdppd xmm10, xmm11, xmm12, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xB5\xD9\x58\x08" , "vaddpd zmm9 {k1}{z}, zmm9, [rax] {1to8}"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF0\x58\xC2" , "vaddps xmm0, xmm1, xmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x74\x88\x58\xC2" , "vaddps xmm0 {z}, xmm1, xmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xFA\x2D\xC1" , "vcvtss2si eax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE1\xFA\x2D\xC1" , "vcvtss2si rax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xFB\x2D\xC1" , "vcvtsd2si eax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE1\xFB\x2D\xC1" , "vcvtsd2si rax, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF2\x2A\xC2" , "vcvtsi2ss xmm0, xmm1, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE1\xF2\x2A\xC2" , "vcvtsi2ss xmm0, xmm1, rdx"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF3\x2A\xC2" , "vcvtsi2sd xmm0, xmm1, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE1\xF3\x2A\xC2" , "vcvtsi2sd xmm0, xmm1, rdx"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\x7B\xE6\x3B" , "vcvtpd2dq xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\x7F\xE6\x3B" , "vcvtpd2dq xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\x79\x5A\x3B" , "vcvtpd2ps xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\x7D\x5A\x3B" , "vcvtpd2ps xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFC\x08\x79\x3B" , "vcvtpd2udq xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFC\x28\x79\x3B" , "vcvtpd2udq xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFC\x08\x5B\x3B" , "vcvtqq2ps xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFC\x28\x5B\x3B" , "vcvtqq2ps xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x5A\xC1" , "vcvtpd2ps xmm0, xmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xF9\x5A\x03" , "vcvtpd2ps xmm0, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xFD\x5A\xC1" , "vcvtpd2ps xmm0, ymm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xFD\x5A\x03" , "vcvtpd2ps xmm0, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x48\x5A\xC1" , "vcvtpd2ps ymm0, zmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x48\x5A\x03" , "vcvtpd2ps ymm0, zmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\x79\xE6\x3B" , "vcvttpd2dq xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\x7D\xE6\x3B" , "vcvttpd2dq xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFC\x08\x78\x3B" , "vcvttpd2udq xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFC\x28\x78\x3B" , "vcvttpd2udq xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFF\x08\x7A\x3B" , "vcvtuqq2ps xmm15, xmmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x71\xFF\x28\x7A\x3B" , "vcvtuqq2ps xmm15, ymmword ptr [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x08\x66\x3F\x01" , "vfpclasspd k7, xmmword ptr [rdi], 0x01"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x28\x66\x37\x01" , "vfpclasspd k6, ymmword ptr [rdi], 0x01"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x48\x66\x2F\x01" , "vfpclasspd k5, zmmword ptr [rdi], 0x01"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x7D\x08\x66\x27\x01" , "vfpclassps k4, xmmword ptr [rdi], 0x01"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x7D\x28\x66\x1F\x01" , "vfpclassps k3, ymmword ptr [rdi], 0x01"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x7D\x48\x66\x17\x01" , "vfpclassps k2, zmmword ptr [rdi], 0x01"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x10\x58\xF4" , "vaddpd zmm30, zmm29, zmm28 {rn-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x10\x58\xF4" , "vaddpd zmm30, zmm29, zmm28, {rn-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x30\x58\xF4" , "vaddpd zmm30, zmm29, zmm28 {rd-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x30\x58\xF4" , "vaddpd zmm30, zmm29, zmm28, {rd-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x50\x58\xF4" , "vaddpd zmm30, zmm29, zmm28 {ru-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x50\x58\xF4" , "vaddpd zmm30, zmm29, zmm28, {ru-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x70\x58\xF4" , "vaddpd zmm30, zmm29, zmm28 {rz-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x95\x70\x58\xF4" , "vaddpd zmm30, zmm29, zmm28, {rz-sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6C\x4F\xC2\x54\x98\x04\x0F" , "vcmpps k2 {k7}, zmm2, zmmword ptr [rax+rbx*4+256], 15"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6C\x1F\xC2\x54\x98\x40\x0F" , "vcmpps k2 {k7}, xmm2, dword ptr [rax+rbx*4+256] {1to4}, 15"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6C\x3F\xC2\x54\x98\x40\x0F" , "vcmpps k2 {k7}, ymm2, dword ptr [rax+rbx*4+256] {1to8}, 15"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6C\x5F\xC2\x54\x98\x40\x0F" , "vcmpps k2 {k7}, zmm2, dword ptr [rax+rbx*4+256] {1to16}, 15"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\xFD\x18\xC2\xC1\x00" , "vcmppd k0, zmm0, zmm1, 0x00, {sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\xFD\x18\x2E\xF5" , "vucomisd xmm30, xmm29 {sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\xFD\x18\x2E\xF5" , "vucomisd xmm30, xmm29, {sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x7C\x18\x2E\xF5" , "vucomiss xmm30, xmm29 {sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x01\x7C\x18\x2E\xF5" , "vucomiss xmm30, xmm29, {sae}"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\xFD\x91\x04\x05\x00\x00\x00\x00" , "vpgatherqq ymm0, [ymm0], ymm0"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\xE9\x92\x0C\x00" , "vgatherdpd xmm1, [rax + xmm0], xmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x69\x90\x44\x0D\x00" , "vpgatherdd xmm0, [rbp + xmm1], xmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xC2\x69\x90\x04\x0C" , "vpgatherdd xmm0, [r12 + xmm1], xmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xC2\x69\x90\x44\x0D\x00" , "vpgatherdd xmm0, [r13 + xmm1], xmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\x6D\x08\x3E\xCB\x00" , "vpcmpub k1, xmm2, xmm3, 0x0"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xE9\xFE\x4C\x11\x40" , "vpaddd xmm1, xmm2, [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC5\xED\xFE\x4C\x11\x40" , "vpaddd ymm1, ymm2, [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF1\x6D\x48\xFE\x4C\x11\x01" , "vpaddd zmm1, zmm2, [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xE2\x3D\x08\x50\x44\x11\x04" , "vpdpbusd xmm16, xmm8, [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xE2\x3D\x28\x50\x44\x11\x02" , "vpdpbusd ymm16, ymm8, [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xE2\x3D\x48\x50\x44\x11\x01" , "vpdpbusd zmm16, zmm8, [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x6D\x48\xCF\x4C\x11\x01" , "vgf2p8mulb zmm1, zmm2, zmmword ptr [rcx+rdx+64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xED\x48\xCE\x4C\x11\x01\x0F" , "vgf2p8affineqb zmm1, zmm2, zmmword ptr [rcx+rdx+64], 15"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xED\x48\xCF\x4C\x11\x01\x0F" , "vgf2p8affineinvqb zmm1, zmm2, zmmword ptr [rcx+rdx+64], 15"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x7D\x08\x7A\xC6" , "vpbroadcastb xmm0, esi"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x7D\x28\x7A\xC6" , "vpbroadcastb ymm0, esi"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x7D\x48\x7A\xC6" , "vpbroadcastb zmm0, esi"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\xCD\x08\x8D\xF8" , "vpermw xmm7, xmm6, xmm0"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE3\xFD\x01\xFE\x01" , "vpermpd ymm7, ymm6, 1"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF3\xFD\x48\x01\xFE\x01" , "vpermpd zmm7, zmm6, 1"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\xCD\x28\x16\xF8" , "vpermpd ymm7, ymm6, ymm0"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\xCD\x48\x16\xF8" , "vpermpd zmm7, zmm6, zmm0"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x4D\x16\xF9" , "vpermps ymm7, ymm6, ymm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x4D\x48\x16\xF9" , "vpermps zmm7, zmm6, zmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\x92\x47\x20\x68\xF0" , "vp2intersectd k6, k7, ymm23, ymm24"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xB2\x47\x20\x68\xB4\xF5\x00\x00\x00\x10" , "vp2intersectd k6, k7, ymm23, [rbp + r14*8 + 268435456]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x47\x30\x68\x35\x00\x00\x00\x00" , "vp2intersectd k6, k7, ymm23, dword ptr [rip]{1to8}"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x47\x20\x68\x34\x6D\x00\xFC\xFF\xFF" , "vp2intersectd k6, k7, ymm23, ymmword ptr [rbp*2 - 1024]"), X64_PASS(RELOC_BASE_ADDRESS, "\x62\xF2\x47\x20\x68\x71\x7F" , "vp2intersectd k6, k7, ymm23, ymmword ptr [rcx + 4064]"), // 32-bit jmp/call/ret. X86_PASS(0x0000000077513BEE, "\xEB\xFE" , "JMP SHORT 0x77513BEE"), X86_PASS(0x0000000077513BEE, "\xEB\x07" , "JMP SHORT 0x77513BF7"), X86_PASS(0x0000000077513BEE, "\xEB\xCF" , "JMP SHORT 0x77513BBF"), X86_PASS(0x0000000000405C5B, "\xE9\xCA\x70\x00\x00" , "JMP 0x0040CD2A"), X86_PASS(0x0000000000405C5B, "\xE9\x40\xFE\xFF\xFF" , "JMP 0x00405AA0"), X86_PASS(0x0000000000405C5B, "\xFF\x25\x00\x01\x00\x00" , "JMP DWORD PTR DS:[0x100]"), X86_PASS(0x0000000000405C5B, "\xE8\xCA\x70\x00\x00" , "CALL 0x0040CD2A"), X86_PASS(0x0000000000405EF0, "\xE8\x06\xFF\xFF\xFF" , "CALL 0x00405DFB"), X86_PASS(0x0000000000405CCC, "\xFF\x15\x10\x00\x00\x00" , "CALL DWORD PTR DS:[0x10]"), X86_PASS(0x0000000000405C5B, "\xF2\xE9\xC9\x70\x00\x00" , "bnd jmp 0x0040CD2A"), X86_PASS(RELOC_BASE_ADDRESS, "\xC3" , "ret"), X86_PASS(RELOC_BASE_ADDRESS, "\xC2\x10\x00" , "ret 16"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xC3" , "rep ret"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xC3" , "bnd ret"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xC3" , "repne ret"), // 64-bit jmp/call/ret. X64_PASS(0x00007FFCAA022104, "\xEB\xFE" , "JMP SHORT 0x7FFCAA022104"), X64_PASS(0x00007FFCAA022104, "\xEB\x22" , "JMP SHORT 0x7FFCAA022128"), X64_PASS(0x00007FFCAA022104, "\xEB\xF9" , "JMP SHORT 0x7FFCAA0220FF"), X64_PASS(0x00007FFCA9FF197C, "\xE9\x35\x64\x93\x53" , "JMP 0x7FFCFD927DB6"), X64_PASS(0x00007FFCAA022104, "\xE9\x7C\xF4\xFC\xFF" , "JMP 0x7FFCA9FF1585"), X64_PASS(0x0000000123456789, "\xFF\x25\xFA\xFF\xFF\xFF" , "JMP QWORD[0x123456789]"), X64_PASS(0x00007FFCA9FF1977, "\xFF\x25\xFA\x00\xFF\xFF" , "JMP QWORD PTR DS:[0x7FFCA9FE1A77]"), X64_PASS(0x00007FFCA9FF197C, "\xF2\xE9\x34\x64\x93\x53" , "bnd jmp 0x7FFCFD927DB6"), X64_PASS(RELOC_BASE_ADDRESS, "\xC3" , "ret"), X64_PASS(RELOC_BASE_ADDRESS, "\xC2\x10\x00" , "ret 16"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\xC3" , "rep ret"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\xC3" , "bnd ret"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\xC3" , "repne ret"), // 32-bit miscellaneous instructions. X86_PASS(0x0000000000405C6A, "\xFF\x35\xF4\x0A\x47\x00" , "PUSH DWORD PTR DS:[0x00000000470AF4]"), X86_PASS(0x0000000000405C92, "\x8B\x45\x08" , "MOV EAX,DWORD PTR SS:[EBP+8]"), X86_PASS(0x0000000000405CB8, "\xC7\x45\xF4\x00\x40\x99\x01" , "MOV DWORD PTR SS:[EBP-0x00000000C],0x000000001994000"), X86_PASS(0x0000000000405D4C, "\x8A\x14\x08" , "MOV DL,BYTE PTR DS:[EAX+ECX]"), X86_PASS(0x0000000000405D4C, "\x0F\xB7\x4C\x45\x98" , "MOVZX ECX,WORD PTR SS:[EAX*2+EBP-0x0000000068]"), X86_PASS(0x0000000000405D4C, "\xC6\x84\x30\x1D\x01\x00\x00\x00" , "MOV BYTE PTR DS:[EAX+ESI+0x0000000011D],0"), X86_PASS(RELOC_BASE_ADDRESS, "\x6A\x0D" , "PUSH 0x00000000D"), X86_PASS(RELOC_BASE_ADDRESS, "\x68\xFF\x00\x00\x00" , "PUSH 0x00000000FF"), X86_PASS(0x0000000000405FF9, "\x83\x60\x70\xFD" , "AND DWORD PTR DS:[EAX+0x0000000070],0x00000000FFFFFFFD"), X86_PASS(0x0000000000405FF9, "\x81\x60\x70\x0D\x00\x00\xF0" , "AND DWORD PTR DS:[EAX+0x0000000070],0x00000000F000000D"), X86_PASS(0x0000000000405C23, "\xf2\x0f\x11\x0d\x00\x00\x00\x00" , "MOVSD QWORD PTR ds:[0x000000000],xmm1"), X86_PASS(RELOC_BASE_ADDRESS, "\x8B\x04\xCD\x00\x00\x00\x00" , "MOV EAX,[ECX*8]"), X86_PASS(RELOC_BASE_ADDRESS, "\x60" , "PUSHAD"), X86_PASS(RELOC_BASE_ADDRESS, "\xCC" , "INT3"), X86_PASS(RELOC_BASE_ADDRESS, "\xCD\x03" , "INT 3"), X86_PASS(0x0000000000405C23, "\xE7\xE9" , "OUT 0x00000000E9, EAX"), X86_PASS(0x0000000000405C23, "\x69\xC0\xFF\x01\x00\x00" , "IMUL EAX, EAX, 0x000000001FF"), X86_PASS(0x0000000000405C23, "\x69\xC0\xFF\x00\x00\x00" , "IMUL EAX, EAX, 0x00000000FF"), X86_PASS(0x0000000000405C23, "\x69\xC0\xFE\x00\x00\x00" , "IMUL EAX, EAX, 0x00000000FE"), X86_PASS(0x0000000000405C23, "\x6B\xC0\x1E" , "IMUL EAX, EAX, 0x000000001E"), X86_PASS(0x0000000000405C23, "\xB8\x78\x56\x34\x12" , "MOV EAX, 0x0000000012345678"), X86_PASS(0x0000000000405C23, "\xB8\xFE\xFF\xFF\xFF" , "MOV EAX, 0x00000000FFFFFFFE"), X86_PASS(RELOC_BASE_ADDRESS, "\xDF\x3C\x24" , "FISTP QWORD PTR [ESP]"), X86_PASS(RELOC_BASE_ADDRESS, "\xD9\xF6" , "FDECSTP"), X86_PASS(RELOC_BASE_ADDRESS, "\xD9\xFF" , "FCOS"), X86_PASS(0x0000000000405C23, "\xC7\x85\xE8\xFD\xFF\xFF\x00\x00\x08\x02" , "MOV DWORD PTR [EBP-0x00000000218],0x000000002080000"), X86_PASS(0x0000000000405C23, "\xC7\x84\x24\xE8\xFD\xFF\xFF\x00\x00\x08\x02" , "MOV DWORD PTR [ESP-0x00000000218],0x000000002080000"), X86_PASS(RELOC_BASE_ADDRESS, "\xC7\x05\xBA\x55\x0F\x00\xFF\x00\x00\x00" , "MOV DWORD PTR [0x00000000F55BA], 0x00000000FF"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\xC7\x05\xBA\x55\x0F\x00\xFF\x00" , "MOV WORD PTR [0x00000000F55BA], 0x00000000FF"), X86_PASS(RELOC_BASE_ADDRESS, "\xC6\x05\xBA\x55\x0F\x00\xFF" , "MOV BYTE PTR [0x00000000F55BA], 0x00000000FF"), X86_PASS(RELOC_BASE_ADDRESS, "\x81\x38\x80\x07\x00\x00" , "CMP DWORD PTR [EAX], 0x00000000780"), // 64-bit miscellaneous instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x48\xB8\x90\x78\x56\x34\x12\x00\x00\x00" , "MOV RAX, 0x1234567890"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xC7\xC0\x00\x00\x00\x00" , "MOV RAX, 0"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xB8\x00\x00\x00\x00\x01\x00\x00\x00" , "MOV RAX, 0x0000100000000"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xC7\xC0\x8F\xFA\xFF\x00" , "MOV RAX, 0x0000FFFA8F"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xB8\x90\x78\x56\x34\x12\x00\x00\x00" , "MOVABS RAX, 0x00001234567890"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\xB8\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF" , "MOVABS RAX, 0x0000FFFFFFFFFFFFFFFE"), X64_PASS(RELOC_BASE_ADDRESS, "\x49\xB8\xF8\xFF\xFF\xFF\x01\x00\x00\x00" , "movabs r8,0x1fffffff8"), X64_PASS(0x00007FFCA9FF1977, "\x48\xA1\x90\x78\x56\x34\x12\x00\x00\x00" , "MOV RAX, QWORD PTR DS:[0x00001234567890]"), X64_PASS(RELOC_BASE_ADDRESS, "\xCC" , "INT3"), X64_PASS(RELOC_BASE_ADDRESS, "\xCD\x03" , "INT 3"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x63\xD0" , "MOVSXD RDX, EAX"), X64_PASS(0x00007FFCA9FF1977, "\x45\x0F\xBE\x24\x2F" , "MOVSX R12D, BYTE PTR [R15+RBP*1]"), X64_PASS(RELOC_BASE_ADDRESS, "\x4D\x69\xED\x10\x01\x00\x00" , "IMUL R13, R13, 0x0000110"), X64_PASS(RELOC_BASE_ADDRESS, "\x4D\x6B\xED\x11" , "IMUL R13, R13, 0x000011"), X64_PASS(0x00007FFCA9FF1977, "\x48\xC7\x05\xAF\x55\x0F\x00\xFF\x00\x00\x00" , "MOV QWORD PTR [RIP+0x0000F55AF], 0x0000FF"), X64_PASS(0x0000000000000000, "\x48\xC7\x05\xAF\x55\x0F\x00\xFF\x00\x00\x00" , "MOV QWORD PTR [0x0000F55BA], 0x0000FF"), X64_PASS(0x00007FFCA9FF1977, "\x48\xC7\x05\xAF\x55\x0F\x00\xFE\xFF\xFF\xFF" , "MOV QWORD PTR [RIP+0x0000F55AF], 0x0000FFFFFFFFFFFFFFFE"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xC7\x08" , "CMPXCHG8B [RAX]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x0F\xC7\x08" , "CMPXCHG16B [RAX]"), X64_PASS(0x00007FF6845CB974, "\x48\x8D\x15\xA5\x16\x25\x00" , "LEA RDX, QWORD PTR DS:[0x00007FF68481D020]"), X64_PASS(0x00007FF6845CB974, "\x48\x8D\x15\xA5\x16\x25\x00" , "LEA RDX, QWORD PTR DS:[RIP+0x00002516A5]"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x8D\x10" , "LEA RDX, [RAX]"), X64_PASS(0x00007FF6845CB982, "\x48\x83\x05\x63\x0F\x25\x00\x01" , "ADD QWORD PTR [0x00007FF68481C8ED], 0x00001"), X64_PASS(0x00007FF6845CB982, "\x48\x83\x05\x63\x0F\x25\x00\x01" , "ADD QWORD PTR [RIP+0x0000250F63], 0x00001"), X64_PASS(RELOC_BASE_ADDRESS, "\x48\x83\x05\xFF\xFF\xFF\xFF\x01" , "ADD QWORD PTR [RIP+0x0000FFFFFFFF], 0x00001"), X64_PASS(0x00007FFB65E2199E, "\x48\x83\x05\xFF\xFF\xFF\xFF\x48" , "ADD QWORD PTR [0x00007FFB65E219A5], 0x000048"), X64_PASS(0x000007FEF18BC878, "\xC7\x05\x5E\x3B\xD8\xFF\x00\x00\x00\x00" , "MOV DWORD PTR DS:[0x00007FEF16403E0],0"), X64_PASS(0x0000000000000000, "\x66\xC7\x05\x4B\xFF\x0F\x00\x00\x00" , "MOV WORD PTR DS:[0x0000FFF54],0"), X64_PASS(0x0000000000000000, "\xC6\x05\x4D\xFF\x0F\x00\x00" , "MOV BYTE PTR DS:[0x0000FFF54],0"), // 32-bit instruction aliases. X86_PASS(0x000000000040652A, "\xC0\x64\x18\x50\xFF" , "SAL BYTE PTR DS:[EAX+EBX+0x0000000050],0x00000000FF"), // 32-bit string instructions. X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\x6C" , "rep insb byte ptr es:[di], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\x6D" , "rep insd dword ptr es:[di], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\x6E" , "rep outsb dx, byte ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\x6F" , "rep outsd dx, dword ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xA4" , "rep movsb byte ptr es:[di], byte ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xA5" , "rep movsd dword ptr es:[di], dword ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xA6" , "repe cmpsb byte ptr [si], byte ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xA7" , "repe cmpsd dword ptr [si], dword ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAA" , "rep stosb byte ptr es:[di], al"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAB" , "rep stosd dword ptr es:[di], eax"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAC" , "rep lodsb al , byte ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAD" , "rep lodsd eax, dword ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAE" , "repe scasb al , byte ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAF" , "repe scasd eax, dword ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x6C" , "repne insb byte ptr es:[edi], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\x6D" , "repne insw word ptr es:[edi], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x6E" , "repne outsb dx, byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\x6F" , "repne outsw dx, word ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xA4" , "repne movsb byte ptr es:[edi], byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\xA5" , "repne movsw word ptr es:[edi], word ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xA6" , "repne cmpsb byte ptr [esi], byte ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\xA7" , "repne cmpsw word ptr [esi], word ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xAA" , "repne stosb byte ptr es:[edi], al"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\xAB" , "repne stosw word ptr es:[edi], ax"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xAC" , "repne lodsb al, byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\xAD" , "repne lodsw ax, word ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\xAE" , "repne scasb al, byte ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x66\xAF" , "repne scasw ax, word ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\x6C" , "rep insb byte ptr es:[di], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\x6D" , "rep insw word ptr es:[di], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\x6E" , "rep outsb dx, byte ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\x6F" , "rep outsw dx, word ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xA4" , "rep movsb byte ptr es:[di], byte ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\xA5" , "rep movsw word ptr es:[di], word ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xA6" , "repe cmpsb byte ptr [si], byte ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\xA7" , "repe cmpsw word ptr [si], word ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAA" , "rep stosb byte ptr es:[di], al"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\xAB" , "rep stosw word ptr es:[di], ax"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAC" , "rep lodsb al, byte ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\xAD" , "rep lodsw ax, word ptr [si]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x67\xAE" , "repe scasb al, byte ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x66\x67\xAF" , "repe scasw ax, word ptr es:[di]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x6C" , "rep insb byte ptr es:[edi], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x6D" , "rep insd dword ptr es:[edi], dx"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x6E" , "rep outsb dx, byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x6F" , "rep outsd dx, dword ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xA4" , "rep movsb byte ptr es:[edi], byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xA5" , "rep movsd dword ptr es:[edi], dword ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xA6" , "repe cmpsb byte ptr [esi], byte ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xA7" , "repe cmpsd dword ptr [esi], dword ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xAA" , "rep stosb byte ptr es:[edi], al"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xAB" , "rep stosd dword ptr es:[edi], eax"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xAC" , "rep lodsb al , byte ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xAD" , "rep lodsd eax, dword ptr [esi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xAE" , "repe scasb al , byte ptr es:[edi]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\xAF" , "repe scasd eax, dword ptr es:[edi]"), // 64-bit instructions that use extended low-byte registers. X64_PASS(RELOC_BASE_ADDRESS, "\x40\x86\x34\x24" , "xchg [rsp], sil"), X64_PASS(RELOC_BASE_ADDRESS, "\x40\x86\x3C\x24" , "xchg [rsp], dil"), // 32-bit instructions that use non-standard syntax. X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x38\xF8\x03" , "movdir64b [eax], [ebx]"), // 64-bit instructions that use non-standard syntax. X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x38\xF8\x03" , "movdir64b [rax], [rbx]"), // 32-bit instructions that use non-standard syntax (failure cases). X86_FAIL(RELOC_BASE_ADDRESS, "movdir64b [rax], [rbx]"), X86_FAIL(RELOC_BASE_ADDRESS, "movdir64b [eax + 1], [ebx]"), X86_FAIL(RELOC_BASE_ADDRESS, "movdir64b [eax + rbx], [ebx]"), // 64-bit instructions that use non-standard syntax (failure cases). X64_FAIL(RELOC_BASE_ADDRESS, "movdir64b [rax + 1], [rbx]"), X64_FAIL(RELOC_BASE_ADDRESS, "movdir64b [rax + rbx], [rbx]"), // 32-bit VMX instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x38\x80\x03" , "invept eax, [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x38\x81\x03" , "invvpid eax, [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC1" , "vmcall"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xC7\x32" , "vmclear [edx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xD4" , "vmfunc"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC2" , "vmlaunch"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xC7\x33" , "vmptrld [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xC7\x3B" , "vmptrst [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x78\x18" , "vmread [eax], ebx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC3" , "vmresume"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x79\x03" , "vmwrite eax, [ebx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xC7\x33" , "vmxon [ebx]"), // 64-bit VMX instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x38\x80\x03" , "invept rax, [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\x38\x81\x03" , "invvpid rax, [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC1" , "vmcall"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xC7\x32" , "vmclear [rdx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xD4" , "vmfunc"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC2" , "vmlaunch"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xC7\x33" , "vmptrld [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xC7\x3B" , "vmptrst [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x78\x18" , "vmread [rax], rbx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC3" , "vmresume"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x79\x03" , "vmwrite rax, [rbx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xC7\x33" , "vmxon [rbx]"), // 32-bit LWP instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x8F\xE9\x78\x12\xC2" , "llwpcb edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x8F\xE9\x78\x12\xC9" , "slwpcb ecx"), X86_PASS(RELOC_BASE_ADDRESS, "\x8F\xEA\x78\x12\x03\x04\x03\x02\x01" , "lwpins eax, [ebx], 0x01020304"), X86_PASS(RELOC_BASE_ADDRESS, "\x8F\xEA\x78\x12\x0B\x04\x03\x02\x01" , "lwpval eax, [ebx], 0x01020304"), // 64-bit LWP instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x8F\xE9\xF8\x12\xC2" , "llwpcb rdx"), X64_PASS(RELOC_BASE_ADDRESS, "\x8F\xE9\xF8\x12\xC9" , "slwpcb rcx"), X64_PASS(RELOC_BASE_ADDRESS, "\x8F\xEA\xF8\x12\x03\x04\x03\x02\x01" , "lwpins rax, [rbx], 0x01020304"), X64_PASS(RELOC_BASE_ADDRESS, "\x8F\xEA\xF8\x12\x0B\x04\x03\x02\x01" , "lwpval rax, [rbx], 0x01020304"), // 32-bit SVM|SKINIT instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDD" , "clgi"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDF" , "invlpga eax, ecx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDE" , "skinit eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDC" , "stgi"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDA" , "vmload eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xD9" , "vmmcall"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xD8" , "vmrun eax"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDB" , "vmsave eax"), // 64-bit SVM|SKINIT instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDD" , "clgi"), X64_PASS(RELOC_BASE_ADDRESS, "\x67\x0F\x01\xDF" , "invlpga eax, ecx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDF" , "invlpga rax, ecx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDE" , "skinit eax"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDC" , "stgi"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDA" , "vmload rax"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xD9" , "vmmcall"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xD8" , "vmrun rax"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xDB" , "vmsave rax"), // 32-bit MONITOR & MWAIT instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC8" , "monitor"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC8" , "monitor [eax], ecx, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFA" , "monitorx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFA" , "monitorx [eax], ecx, edx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC9" , "mwait"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC9" , "mwait eax, ecx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFB" , "mwaitx"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFB" , "mwaitx eax, ecx, ebx"), // 64-bit MONITOR & MWAIT instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC8" , "monitor"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC8" , "monitor [rax], ecx, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFA" , "monitorx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFA" , "monitorx [rax], ecx, edx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC9" , "mwait"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC9" , "mwait eax, ecx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFB" , "mwaitx"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFB" , "mwaitx eax, ecx, ebx"), // 32-bit WAITPKG instructions. X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xAE\xF0" , "umonitor [eax]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\xF7" , "tpause edi"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\xF7" , "tpause edi, edx, eax"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\xAE\xF7" , "umwait edi"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\xAE\xF7" , "umwait edi, edx, eax"), // 64-bit WAITPKG instructions. X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xAE\xF0" , "umonitor [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\xF7" , "tpause edi"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\xF7" , "tpause edi, edx, eax"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\xAE\xF7" , "umwait edi"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\xAE\xF7" , "umwait edi, edx, eax"), // 32-bit ENQCMD instructions. X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF8\x01" , "enqcmd [eax], [ecx]"), X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x38\xF8\x01" , "enqcmds [eax], [ecx]"), // 64-bit ENQCMD instructions. X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x38\xF8\x01" , "enqcmd [rax], [rcx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x38\xF8\x01" , "enqcmds [rax], [rcx]"), // 32-bit CL... instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFC" , "clzero"), X86_PASS(RELOC_BASE_ADDRESS, "\x0F\xAE\x7A\x40" , "clflush [edx + 64]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\x7A\x40" , "clflushopt [edx + 64]"), X86_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\x72\x40" , "clwb [edx + 64]"), // 64-bit CL... instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xFC" , "clzero"), X64_PASS(RELOC_BASE_ADDRESS, "\x0F\xAE\x7A\x40" , "clflush [rdx + 64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\x7A\x40" , "clflushopt [rdx + 64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x0F\xAE\x72\x40" , "clwb [rdx + 64]"), // 32-bit MCOMMIT instruction. X86_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\xFA" , "mcommit"), // 64-bit MCOMMIT instruction. X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\xFA" , "mcommit"), // 32-bit PCONFIG instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC5" , "pconfig"), // 64-bit PCONFIG instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xC5" , "pconfig"), // 32-bit SERIALIZE instructions. X86_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xE8" , "serialize"), // 64-bit SERIALIZE instructions. X64_PASS(RELOC_BASE_ADDRESS, "\x0F\x01\xE8" , "serialize"), // 32-bit TSXLDTRK instructions. X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x01\xE8" , "xsusldtrk"), X86_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x01\xE9" , "xresldtrk"), // 64-bit TSXLDTRK instructions. X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x01\xE8" , "xsusldtrk"), X64_PASS(RELOC_BASE_ADDRESS, "\xF2\x0F\x01\xE9" , "xresldtrk"), // 64-bit CET_SS instructions. X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xAE\x34\x25\xF0\x1C\xF0\x1C" , "clrssbsy [485498096]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xAE\x32" , "clrssbsy [rdx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\xAE\x72\x40" , "clrssbsy [rdx + 64]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\xE8" , "setssbsy"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\xEA" , "saveprevssp"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x41\x0F\x1E\xCD" , "rdsspd r13d"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x49\x0F\x1E\xCF" , "rdsspq r15"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x41\x0F\xAE\xED" , "incsspd r13d"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x49\x0F\xAE\xEF" , "incsspq r15"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\x2C\x25\xF0\x1C\xF0\x1C" , "rstorssp [485498096]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\x2A" , "rstorssp [rdx]"), X64_PASS(RELOC_BASE_ADDRESS, "\xF3\x0F\x01\x6A\x40" , "rstorssp [rdx + 64]"), X64_PASS(RELOC_BASE_ADDRESS, "\x4C\x0F\x38\xF6\x3C\x25\xF0\x1C\xF0\x1C" , "wrssq [485498096], r15"), X64_PASS(RELOC_BASE_ADDRESS, "\x4C\x0F\x38\xF6\x3A" , "wrssq [rdx], r15"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x4C\x0F\x38\xF5\x3C\x25\xF0\x1C\xF0\x1C" , "wrussq [485498096], r15"), X64_PASS(RELOC_BASE_ADDRESS, "\x66\x4C\x0F\x38\xF5\x3A" , "wrussq [rdx], r15"), // 64-bit AMX instructions. X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x78\x49\x00" , "ldtilecfg [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xA2\x78\x49\x84\xF5\x00\x00\x00\x10" , "ldtilecfg [rbp + r14*8 + 268435456]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xC2\x78\x49\x84\x80\x23\x01\x00\x00" , "ldtilecfg [r8 + rax*4 + 291]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x78\x49\x05\x00\x00\x00\x00" , "ldtilecfg [rip]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x79\x49\x00" , "sttilecfg [rax]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xA2\x79\x49\x84\xF5\x00\x00\x00\x10" , "sttilecfg [rbp + r14*8 + 268435456]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xC2\x79\x49\x84\x80\x23\x01\x00\x00" , "sttilecfg [r8 + rax*4 + 291]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x7B\x4B\x0C\x88" , "tileloadd tmm1, [rax + rcx*4]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\x82\x7B\x4B\x4C\x08\x01" , "tileloadd tmm1, [r8 + r9 + 1]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xA2\x7B\x4B\xB4\xF5\x00\x00\x00\x10" , "tileloadd tmm6, [rbp + r14*8 + 268435456]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xC2\x7B\x4B\x9C\x80\x23\x01\x00\x00" , "tileloadd tmm3, [r8 + rax*4 + 291]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x7B\x4B\x1C\x6D\xE0\xFF\xFF\xFF" , "tileloadd tmm3, [rbp*2 - 32]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x7B\x4B\x64\x23\x40" , "tileloadd tmm4, [rbx + 64]"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xA2\x7A\x4B\xB4\xF5\x00\x00\x00\x10" , "tilestored [rbp + r14*8 + 268435456], tmm6"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x7b\x49\xd8" , "tilezero tmm3"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x7b\x49\xf0" , "tilezero tmm6"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x6A\x5C\xC1" , "tdpbf16ps tmm0, tmm1, tmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x72\x5C\xDA" , "tdpbf16ps tmm3, tmm2, tmm1"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x5A\x5C\xF5" , "tdpbf16ps tmm6, tmm5, tmm4"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x6B\x5E\xC1" , "tdpbssd tmm0, tmm1, tmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x6A\x5E\xC1" , "tdpbsud tmm0, tmm1, tmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x69\x5E\xC1" , "tdpbusd tmm0, tmm1, tmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x68\x5E\xC1" , "tdpbuud tmm0, tmm1, tmm2"), X64_PASS(RELOC_BASE_ADDRESS, "\xC4\xE2\x78\x49\xC0" , "tilerelease"), // 32-bit malformed input - should cause either parsing or validation error. X86_FAIL(0x0000000000001000, "short jmp 0x2000"), X86_FAIL(RELOC_BASE_ADDRESS, "mov al,-129"), X86_FAIL(RELOC_BASE_ADDRESS, "mov al, 256"), X86_FAIL(RELOC_BASE_ADDRESS, "mov ax,-32769"), X86_FAIL(RELOC_BASE_ADDRESS, "mov ax, 65536"), X86_FAIL(RELOC_BASE_ADDRESS, "mov eax,-2147483649"), X86_FAIL(RELOC_BASE_ADDRESS, "mov eax, 4294967296"), X86_FAIL(RELOC_BASE_ADDRESS, "mov rax, 0x0"), X86_FAIL(RELOC_BASE_ADDRESS, "mov r15d, 0x0"), X86_FAIL(RELOC_BASE_ADDRESS, "mov r15w, 0x0"), X86_FAIL(RELOC_BASE_ADDRESS, "mov r15b, 0x0"), X86_FAIL(RELOC_BASE_ADDRESS, "mov [eax], 1"), X86_FAIL(RELOC_BASE_ADDRESS, "movzx eax, bpl"), X86_FAIL(RELOC_BASE_ADDRESS, "shr eax, 256"), X64_FAIL(RELOC_BASE_ADDRESS, "lfs al, [ecx]"), X86_FAIL(RELOC_BASE_ADDRESS, "MOV EAX, DWORD PTR ]["), X86_FAIL(RELOC_BASE_ADDRESS, "MOV EAX, DWORD PTR [RAX]"), X86_FAIL(RELOC_BASE_ADDRESS, "MOV EAX, DWORD PTR [0xFFFFFFFFF]"), X86_FAIL(RELOC_BASE_ADDRESS, "lock add eax, ecx"), X86_FAIL(RELOC_BASE_ADDRESS, "lock add eax, [ecx]"), X86_FAIL(RELOC_BASE_ADDRESS, "lock movd mm0, eax"), X86_FAIL(RELOC_BASE_ADDRESS, "lock lock add [eax], ecx"), X86_FAIL(RELOC_BASE_ADDRESS, "xacquire add [eax], ecx"), X86_FAIL(RELOC_BASE_ADDRESS, "xrelease add [eax], ecx"), X86_FAIL(RELOC_BASE_ADDRESS, "lock xacquire xrelease add [eax], ecx"), X86_FAIL(RELOC_BASE_ADDRESS, "vaddps xmm0 {k0}, xmm1, xmm2"), X86_FAIL(RELOC_BASE_ADDRESS, "vaddps xmm0 {k0}{z}, xmm1, xmm2"), // 64-bit malformed input - should cause either parsing or validation error. X64_FAIL(0x0000000000001000, "short jmp 0x2000"), X64_FAIL(RELOC_BASE_ADDRESS, "mov al,-129"), X64_FAIL(RELOC_BASE_ADDRESS, "mov al, 256"), X64_FAIL(RELOC_BASE_ADDRESS, "mov ax,-32769"), X64_FAIL(RELOC_BASE_ADDRESS, "mov ax, 65536"), X64_FAIL(RELOC_BASE_ADDRESS, "mov eax,-2147483649"), X64_FAIL(RELOC_BASE_ADDRESS, "mov eax, 4294967296"), X64_FAIL(RELOC_BASE_ADDRESS, "mov [rax], 1"), X64_FAIL(RELOC_BASE_ADDRESS, "movzx r15d, ah"), X64_FAIL(RELOC_BASE_ADDRESS, "neg [eax]"), X64_FAIL(RELOC_BASE_ADDRESS, "rex neg ah"), X64_FAIL(RELOC_BASE_ADDRESS, "shr eax, 256"), X64_FAIL(RELOC_BASE_ADDRESS, "shr rax, 256"), X64_FAIL(RELOC_BASE_ADDRESS, "lfs al, [rcx]"), X64_FAIL(RELOC_BASE_ADDRESS, "lock add rax, rcx"), X64_FAIL(RELOC_BASE_ADDRESS, "lock add rax, [rcx]"), X64_FAIL(RELOC_BASE_ADDRESS, "lock movd mm0, eax"), X64_FAIL(RELOC_BASE_ADDRESS, "lock lock add [rax], rcx"), X64_FAIL(RELOC_BASE_ADDRESS, "xacquire add [rax], rcx"), X64_FAIL(RELOC_BASE_ADDRESS, "xrelease add [rax], rcx"), X64_FAIL(RELOC_BASE_ADDRESS, "lock xacquire xrelease add [rax], rcx"), X64_FAIL(RELOC_BASE_ADDRESS, "vaddps xmm0 {k0}, xmm1, xmm2"), X64_FAIL(RELOC_BASE_ADDRESS, "vaddps xmm0 {k0}{z}, xmm1, xmm2"), X64_FAIL(RELOC_BASE_ADDRESS, "vpgatherdd xmm0, [rip + xmm1], xmm2") }; struct TestStats { uint32_t passed; uint32_t failed; uint32_t total; }; struct TestOptions { bool only_failures; inline TestOptions() { memset(this, 0, sizeof(*this)); } }; static void dump_hex(const char* s, size_t count) { for (size_t i = 0; i < count; i++) printf("%02X", unsigned(uint8_t(s[i]))); } static bool run_tests(TestStats& out, const TestOptions& options, Span entries) { out.passed = 0; out.failed = 0; out.total = uint32_t(entries.size()); for (const TestEntry& entry : entries) { const char* arch = entry.arch == Arch::kX86 ? "X86" : "X64"; // Initialize Environment with the requested architecture. Environment environment; environment.set_arch(entry.arch); // Initialize CodeHolder. CodeHolder code; Error err = code.init(environment, entry.base_address); if (err != Error::kOk) { printf("CodeHolder.init(): %s [FAILED]\n", DebugUtils::error_as_string(err)); out.failed++; continue; } x86::Assembler a(&code); err = AsmParser(&a).parse(entry.asm_string, entry.asm_size); if (err != Error::kOk) { if (!entry.must_pass) { if (!options.only_failures) { printf(" %s: %-55s -> %s [OK]\n", arch, entry.asm_string, DebugUtils::error_as_string(err)); } out.passed++; } else { printf("-%s: %-55s -> %s [FAILED]\n", arch, entry.asm_string, DebugUtils::error_as_string(err)); out.failed++; } } else { CodeBuffer& buf = code.section_by_id(0)->buffer(); if (entry.must_pass && buf.size() == entry.machine_code_size && memcmp(buf.data(), entry.machine_code, entry.machine_code_size) == 0) { if (!options.only_failures) { printf(" %s: %-55s -> ", arch, entry.asm_string); dump_hex(reinterpret_cast(buf.data()), buf.size()); printf(" [OK]\n"); } out.passed++; continue; } else { printf("-%s: %-55s -> ", arch, entry.asm_string); dump_hex(reinterpret_cast(buf.data()), buf.size()); if (entry.must_pass) { printf(" [FAILED]\n"); size_t num_spaces = 1 + strlen(arch) + 2 + 55; for (size_t j = 0; j < num_spaces; j++) printf(" "); printf(" != "); dump_hex(entry.machine_code, entry.machine_code_size); printf(" [EXPECTED]\n"); } else { printf(" [FAILED] Should have failed\n"); } out.failed++; } } } return out.failed == 0; } int main(int argc, char* argv[]) { CmdLine cmd_line(argc, argv); TestStats stats; TestOptions options; if (cmd_line.has_key("--only-failures")) options.only_failures = true; bool all_passed = run_tests(stats, options, Span::from_array(test_entries)); if (all_passed) { printf("All %u tests passed!\n", stats.total); return 0; } else { printf("Passed: %u out of %u\n", stats.passed, stats.total); printf("Failed: %u out of %u\n", stats.failed, stats.total); return 1; } }