mirrors/dmd
1
0
Fork 0
mirror of https://github.com/dlang/dmd.git synced 2025-04-26 13:10:12 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 5
dmd/compiler/test/runnable/iasm64.d

7028 lines
250 KiB
D
Raw Blame History

// PERMUTE_ARGS:
// Copyright (c) 1999-2016 by The D Language Foundation
// All Rights Reserved
// written by Walter Bright
// https://www.digitalmars.com
import core.stdc.stdio;
import core.stdc.config;
version (D_PIC)
{
int main() { return 0; }
}
else version (D_PIE)
{
int main() { return 0; }
}
else version (D_InlineAsm_X86_64)
{
struct M128 { int a,b,c,d; };
struct M64 { int a,b; };
/+
__gshared byte b;
__gshared short w;
__gshared int i;
__gshared long l;
+/
/****************************************************/
void test1()
{
int foo;
int bar;
static const int x = 4;
asm
{
align x; ;
mov EAX, __LOCAL_SIZE ;
mov foo[RBP], EAX ;
}
assert(foo == 16); // stack must be 16 byte aligned
}
/****************************************************/
void test2()
{
int foo;
int bar;
asm
{
even ;
mov EAX,0 ;
inc EAX ;
mov foo[RBP], EAX ;
}
assert(foo == 1);
}
/****************************************************/
void test3()
{
int foo;
int bar;
asm
{
mov EAX,5 ;
jmp $ + 2 ;
dw 0xC0FF,0xC8FF ; // inc EAX, dec EAX
mov foo[RBP],EAX ;
}
assert(foo == 4);
}
/****************************************************/
void test4()
{
int foo;
int bar;
asm
{
xor EAX,EAX ;
add EAX,5 ;
jne L1 ;
dw 0xC0FF,0xC8FF ; // inc EAX, dec EAX
L1:
dw 0xC8FF ;
mov foo[RBP],EAX ;
}
assert(foo == 4);
}
/****************************************************/
void test5()
{
int foo;
ubyte *p;
ushort *w;
uint *u;
ulong *ul;
float *f;
double *d;
real *e;
static float fs = 1.1;
static double ds = 1.2;
static real es = 1.3;
asm
{
call L1 ;
db 0xFF,0xC0; ; // inc EAX
db "abc" ;
ds "def" ;
di "ghi" ;
dl 0x12345678ABCDEF;
df 1.1 ;
dd 1.2 ;
de 1.3 ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
assert(p[0] == 0xFF);
assert(p[1] == 0xC0);
assert(p[2] == 'a');
assert(p[3] == 'b');
assert(p[4] == 'c');
w = cast(ushort *)(p + 5);
assert(w[0] == 'd');
assert(w[1] == 'e');
assert(w[2] == 'f');
u = cast(uint *)(w + 3);
assert(u[0] == 'g');
assert(u[1] == 'h');
assert(u[2] == 'i');
ul = cast(ulong *)(u + 3);
assert(ul[0] == 0x12345678ABCDEF);
f = cast(float *)(ul + 1);
assert(*f == fs);
d = cast(double *)(f + 1);
assert(*d == ds);
e = cast(real *)(d + 1);
assert(*e == es);
}
/****************************************************/
void test6()
{
ubyte *p;
static ubyte[] data =
[
0x8B, 0x01, // mov EAX,[RCX]
0x8B, 0x04, 0x19, // mov EAX,[RBX][RCX]
0x8B, 0x04, 0x4B, // mov EAX,[RCX*2][RBX]
0x8B, 0x04, 0x5A, // mov EAX,[RBX*2][RDX]
0x8B, 0x04, 0x8E, // mov EAX,[RCX*4][RSI]
0x8B, 0x04, 0xF9, // mov EAX,[RDI*8][RCX]
0x2B, 0x1C, 0x19, // sub EBX,[RBX][RCX]
0x3B, 0x0C, 0x4B, // cmp ECX,[RCX*2][RBX]
0x03, 0x14, 0x5A, // add EDX,[RBX*2][RDX]
0x33, 0x34, 0x8E, // xor ESI,[RCX*4][RSI]
0x29, 0x1C, 0x19, // sub [RBX][RCX],EBX
0x39, 0x0C, 0x4B, // cmp [RCX*2][RBX],ECX
0x01, 0x24, 0x5A, // add [RBX*2][RDX],ESP
0x31, 0x2C, 0x8E, // xor [RCX*4][RSI],EBP
0xA8, 0x03, // test AL,3
0x66, 0xA9, 0x04, 0x00, // test AX,4
0xA9, 0x05, 0x00, 0x00, 0x00, // test EAX,5
0x85, 0x3C, 0xF9, // test [RDI*8][RCX],EDI
0x49, 0x8B, 0x45, 0x00, // mov RAX,0[R13]
0x4A, 0x8B, 0x04, 0x1D, 0x00, 0x00, 0x00, 0x00, // mov RAX,[00h][R11]
0x49, 0x8B, 0x03, // mov RAX,[R11]
0x8B, 0x05, 0x00, 0x00, 0x00, 0x00, // mov EAX,[RIP]
0x8B, 0x05, 0x05, 0x00, 0x00, 0x00, // mov EAX,5[RIP]
];
int i;
asm
{
call L1 ;
mov EAX,[RCX] ;
mov EAX,[RCX][RBX] ;
mov EAX,[RCX*2][RBX] ;
mov EAX,[RDX][RBX*2] ;
mov EAX,[RCX*4][RSI] ;
mov EAX,[RCX][RDI*8] ;
sub EBX,[RCX][RBX] ;
cmp ECX,[RCX*2][RBX] ;
add EDX,[RDX][RBX*2] ;
xor ESI,[RCX*4][RSI] ;
sub [RCX][RBX],EBX ;
cmp [RCX*2][RBX],ECX ;
add [RDX][RBX*2],ESP ;
xor [RCX*4][RSI],EBP ;
test AL,3 ;
test AX,4 ;
test EAX,5 ;
test [RCX][RDI*8],EDI ;
mov RAX,[R13] ;
mov RAX,[0+1*R11] ;
mov RAX,[R11] ;
mov EAX,[RIP] ;
mov EAX,5[RIP] ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
/+
void test7()
{
ubyte *p;
static ubyte[] data =
[
0x26,0xA1,0x24,0x13,0x00,0x00, // mov EAX,ES:[01324h]
0x36,0x66,0xA1,0x78,0x56,0x00,0x00, // mov AX,SS:[05678h]
0xA0,0x78,0x56,0x00,0x00, // mov AL,[05678h]
0x2E,0x8A,0x25,0x78,0x56,0x00,0x00, // mov AH,CS:[05678h]
0x64,0x8A,0x1D,0x78,0x56,0x00,0x00, // mov BL,FS:[05678h]
0x65,0x8A,0x3D,0x78,0x56,0x00,0x00, // mov BH,GS:[05678h]
];
int i;
asm
{
call L1 ;
mov EAX,ES:[0x1324] ;
mov AX,SS:[0x5678] ;
mov AL,DS:[0x5678] ;
mov AH,CS:[0x5678] ;
mov BL,FS:[0x5678] ;
mov BH,GS:[0x5678] ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
+/
/****************************************************/
void test8()
{
ubyte *p;
static ubyte[] data =
[
0x8C,0xD0, // mov AX,SS
0x8C,0xDB, // mov BX,DS
0x8C,0xC1, // mov CX,ES
0x8C,0xCA, // mov DX,CS
0x8C,0xE6, // mov SI,FS
0x8C,0xEF, // mov DI,GS
0x8E,0xD0, // mov SS,AX
0x8E,0xDB, // mov DS,BX
0x8E,0xC1, // mov ES,CX
0x8E,0xCA, // mov CS,DX
0x8E,0xE6, // mov FS,SI
0x8E,0xEF, // mov GS,DI
0x0F,0x22,0xC0, // mov CR0,EAX
0x0F,0x22,0xD3, // mov CR2,EBX
0x0F,0x22,0xD9, // mov CR3,ECX
0x0F,0x22,0xE2, // mov CR4,EDX
0x0F,0x20,0xC0, // mov EAX,CR0
0x0F,0x20,0xD3, // mov EBX,CR2
0x0F,0x20,0xD9, // mov ECX,CR3
0x0F,0x20,0xE2, // mov EDX,CR4
0x0F,0x23,0xC0, // mov DR0,EAX
0x0F,0x23,0xCE, // mov DR1,ESI
0x0F,0x23,0xD3, // mov DR2,EBX
0x0F,0x23,0xD9, // mov DR3,ECX
0x0F,0x23,0xE2, // mov DR4,EDX
0x0F,0x23,0xEF, // mov DR5,EDI
0x0F,0x23,0xF4, // mov DR6,ESP
0x0F,0x23,0xFD, // mov DR7,EBP
0x0F,0x21,0xC4, // mov ESP,DR0
0x0F,0x21,0xCD, // mov EBP,DR1
0x0F,0x21,0xD0, // mov EAX,DR2
0x0F,0x21,0xDB, // mov EBX,DR3
0x0F,0x21,0xE1, // mov ECX,DR4
0x0F,0x21,0xEA, // mov EDX,DR5
0x0F,0x21,0xF6, // mov ESI,DR6
0x0F,0x21,0xFF, // mov EDI,DR7
0xA4, // movsb
0x66,0xA5, // movsw
0xA5, // movsd
];
int i;
asm
{
call L1 ;
mov AX,SS ;
mov BX,DS ;
mov CX,ES ;
mov DX,CS ;
mov SI,FS ;
mov DI,GS ;
mov SS,AX ;
mov DS,BX ;
mov ES,CX ;
mov CS,DX ;
mov FS,SI ;
mov GS,DI ;
mov CR0,EAX ;
mov CR2,EBX ;
mov CR3,ECX ;
mov CR4,EDX ;
mov EAX,CR0 ;
mov EBX,CR2 ;
mov ECX,CR3 ;
mov EDX,CR4 ;
mov DR0,EAX ;
mov DR1,ESI ;
mov DR2,EBX ;
mov DR3,ECX ;
mov DR4,EDX ;
mov DR5,EDI ;
mov DR6,ESP ;
mov DR7,EBP ;
mov ESP,DR0 ;
mov EBP,DR1 ;
mov EAX,DR2 ;
mov EBX,DR3 ;
mov ECX,DR4 ;
mov EDX,DR5 ;
mov ESI,DR6 ;
mov EDI,DR7 ;
movsb ;
movsw ;
movsd ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test9()
{
ubyte *p;
static ubyte[] data =
[
0x67,0x66,0x8B,0x00, // mov AX,[BX+SI]
0x67,0x66,0x8B,0x01, // mov AX,[BX+DI]
0x67,0x66,0x8B,0x02, // mov AX,[BP+SI]
0x67,0x66,0x8B,0x03, // mov AX,[BP+DI]
0x67,0x66,0x8B,0x04, // mov AX,[SI]
0x67,0x66,0x8B,0x05, // mov AX,[DI]
0x66,0xB8,0xD2,0x04, // mov AX,04D2h
0x67,0x66,0x8B,0x07, // mov AX,[BX]
0x67,0x66,0x8B,0x40,0x01, // mov AX,1[BX+SI]
0x67,0x66,0x8B,0x41,0x02, // mov AX,2[BX+DI]
0x67,0x66,0x8B,0x42,0x03, // mov AX,3[BP+SI]
0x67,0x66,0x8B,0x43,0x04, // mov AX,4[BP+DI]
0x67,0x66,0x8B,0x44,0x05, // mov AX,5[SI]
0x67,0x66,0x8B,0x45,0x06, // mov AX,6[DI]
0x67,0x66,0x8B,0x43,0x07, // mov AX,7[BP+DI]
0x67,0x66,0x8B,0x47,0x08, // mov AX,8[BX]
0x67,0x8B,0x80,0x21,0x01, // mov EAX,0121h[BX+SI]
0x67,0x66,0x8B,0x81,0x22,0x01, // mov AX,0122h[BX+DI]
0x67,0x66,0x8B,0x82,0x43,0x23, // mov AX,02343h[BP+SI]
0x67,0x66,0x8B,0x83,0x54,0x45, // mov AX,04554h[BP+DI]
0x67,0x66,0x8B,0x84,0x45,0x66, // mov AX,06645h[SI]
0x67,0x66,0x8B,0x85,0x36,0x12, // mov AX,01236h[DI]
0x67,0x66,0x8B,0x86,0x67,0x45, // mov AX,04567h[BP]
0x67,0x8A,0x87,0x08,0x01, // mov AL,0108h[BX]
];
int i;
asm
{
call L1 ;
mov AX,[BX+SI] ;
mov AX,[BX+DI] ;
mov AX,[BP+SI] ;
mov AX,[BP+DI] ;
mov AX,[SI] ;
// mov AX,[DI] ; Internal error: backend/cod3.c 4652
mov AX,[1234] ;
mov AX,[BX] ;
mov AX,1[BX+SI] ;
mov AX,2[BX+DI] ;
mov AX,3[BP+SI] ;
mov AX,4[BP+DI] ;
mov AX,5[SI] ;
mov AX,6[DI] ;
mov AX,7[DI+BP] ;
mov AX,8[BX] ;
mov EAX,0x121[BX+SI] ;
mov AX,0x122[BX+DI] ;
mov AX,0x2343[BP+SI] ;
mov AX,0x4554[BP+DI] ;
mov AX,0x6645[SI] ;
mov AX,0x1236[DI] ;
mov AX,0x4567[BP] ;
mov AL,0x108[BX] ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
shared int bar10 = 78;
shared int[2] baz10;
void test10()
{
ubyte *p;
int foo;
static ubyte[] data =
[
];
int i;
asm
{
mov bar10,0x12 ;
// mov baz10,0x13 ;// does not compile, ( should it? )
mov int ptr baz10,0x13 ;// but this does
mov ESI,1 ;
mov baz10[RSI*4],0x14 ;
}
assert(bar10 == 0x12);
assert(baz10[0] == 0x13);
assert(baz10[1] == 0x14);
}
/****************************************************/
struct Foo11
{
int c;
int a;
int b;
}
void test11()
{
ubyte *p;
int x1;
int x2;
int x3;
int x4;
asm
{
mov x1,Foo11.a.sizeof ;
mov x2,Foo11.b.offsetof ;
mov x3,Foo11.sizeof ;
mov x4,Foo11.sizeof + 7 ;
}
assert(x1 == int.sizeof);
assert(x2 == 8);
assert(x3 == 12);
assert(x4 == 19);
}
/****************************************************/
void test12()
{
ubyte *p;
static ubyte[] data =
[
0x14,0x05, // adc AL,5
0x83,0xD0,0x14, // adc EAX,014h
0x80,0x55,0xF8,0x17, // adc byte ptr -8[RBP],017h
0x83,0x55,0xFC,0x17, // adc dword ptr -4[RBP],017h
0x81,0x55,0xFC,0x34,0x12,0x00,0x00, // adc dword ptr -4[RBP],01234h
0x10,0x7D,0xF8, // adc -8[RBP],BH
0x11,0x5D,0xFC, // adc -4[RBP],EBX
0x12,0x5D,0xF8, // adc BL,-8[RBP]
0x13,0x55,0xFC, // adc EDX,-4[RBP]
0x04,0x05, // add AL,5
0x83,0xC0,0x14, // add EAX,014h
0x80,0x45,0xF8,0x17, // add byte ptr -8[RBP],017h
0x83,0x45,0xFC,0x17, // add dword ptr -4[RBP],017h
0x81,0x45,0xFC,0x34,0x12,0x00,0x00, // add dword ptr -4[RBP],01234h
0x00,0x7D,0xF8, // add -8[RBP],BH
0x01,0x5D,0xFC, // add -4[RBP],EBX
0x02,0x5D,0xF8, // add BL,-8[RBP]
0x03,0x55,0xFC, // add EDX,-4[RBP]
0x24,0x05, // and AL,5
0x83,0xE0,0x14, // and EAX,014h
0x80,0x65,0xF8,0x17, // and byte ptr -8[RBP],017h
0x83,0x65,0xFC,0x17, // and dword ptr -4[RBP],017h
0x81,0x65,0xFC,0x34,0x12,0x00,0x00, // and dword ptr -4[RBP],01234h
0x20,0x7D,0xF8, // and -8[RBP],BH
0x21,0x5D,0xFC, // and -4[RBP],EBX
0x22,0x5D,0xF8, // and BL,-8[RBP]
0x23,0x55,0xFC, // and EDX,-4[RBP]
0x3C,0x05, // cmp AL,5
0x83,0xF8,0x14, // cmp EAX,014h
0x80,0x7D,0xF8,0x17, // cmp byte ptr -8[RBP],017h
0x83,0x7D,0xFC,0x17, // cmp dword ptr -4[RBP],017h
0x81,0x7D,0xFC,0x34,0x12,0x00,0x00, // cmp dword ptr -4[RBP],01234h
0x38,0x7D,0xF8, // cmp -8[RBP],BH
0x39,0x5D,0xFC, // cmp -4[RBP],EBX
0x3A,0x5D,0xF8, // cmp BL,-8[RBP]
0x3B,0x55,0xFC, // cmp EDX,-4[RBP]
0x0C,0x05, // or AL,5
0x83,0xC8,0x14, // or EAX,014h
0x80,0x4D,0xF8,0x17, // or byte ptr -8[RBP],017h
0x83,0x4D,0xFC,0x17, // or dword ptr -4[RBP],017h
0x81,0x4D,0xFC,0x34,0x12,0x00,0x00, // or dword ptr -4[RBP],01234h
0x08,0x7D,0xF8, // or -8[RBP],BH
0x09,0x5D,0xFC, // or -4[RBP],EBX
0x0A,0x5D,0xF8, // or BL,-8[RBP]
0x0B,0x55,0xFC, // or EDX,-4[RBP]
0x1C,0x05, // sbb AL,5
0x83,0xD8,0x14, // sbb EAX,014h
0x80,0x5D,0xF8,0x17, // sbb byte ptr -8[RBP],017h
0x83,0x5D,0xFC,0x17, // sbb dword ptr -4[RBP],017h
0x81,0x5D,0xFC,0x34,0x12,0x00,0x00, // sbb dword ptr -4[RBP],01234h
0x18,0x7D,0xF8, // sbb -8[RBP],BH
0x19,0x5D,0xFC, // sbb -4[RBP],EBX
0x1A,0x5D,0xF8, // sbb BL,-8[RBP]
0x1B,0x55,0xFC, // sbb EDX,-4[RBP]
0x2C,0x05, // sub AL,5
0x83,0xE8,0x14, // sub EAX,014h
0x80,0x6D,0xF8,0x17, // sub byte ptr -8[RBP],017h
0x83,0x6D,0xFC,0x17, // sub dword ptr -4[RBP],017h
0x81,0x6D,0xFC,0x34,0x12,0x00,0x00, // sub dword ptr -4[RBP],01234h
0x28,0x7D,0xF8, // sub -8[RBP],BH
0x29,0x5D,0xFC, // sub -4[RBP],EBX
0x2A,0x5D,0xF8, // sub BL,-8[RBP]
0x2B,0x55,0xFC, // sub EDX,-4[RBP]
0xA8,0x05, // test AL,5
0xA9,0x14,0x00,0x00,0x00, // test EAX,014h
0xF6,0x45,0xF8,0x17, // test byte ptr -8[RBP],017h
0xF7,0x45,0xFC,0x17,0x00,0x00,0x00, // test dword ptr -4[RBP],017h
0xF7,0x45,0xFC,0x34,0x12,0x00,0x00, // test dword ptr -4[RBP],01234h
0x84,0x7D,0xF8, // test -8[RBP],BH
0x85,0x5D,0xFC, // test -4[RBP],EBX
0x34,0x05, // xor AL,5
0x83,0xF0,0x14, // xor EAX,014h
0x80,0x75,0xF8,0x17, // xor byte ptr -8[RBP],017h
0x83,0x75,0xFC,0x17, // xor dword ptr -4[RBP],017h
0x81,0x75,0xFC,0x34,0x12,0x00,0x00, // xor dword ptr -4[RBP],01234h
0x30,0x7D,0xF8, // xor -8[RBP],BH
0x31,0x5D,0xFC, // xor -4[RBP],EBX
0x32,0x5D,0xF8, // xor BL,-8[RBP]
0x33,0x55,0xFC, // xor EDX,-4[RBP]
];
int i;
int padding;
byte rm8;
int rm32;
static int m32;
asm
{
call L1 ;
/*
aaa ;
aad ;
aam ;
aas ;
arpl [SI],DI ;
*/
adc AL,5 ;
adc EAX,20 ;
adc rm8[RBP],23 ;
adc rm32[RBP],23 ;
adc rm32[RBP],0x1234 ;
adc rm8[RBP],BH ;
adc rm32[RBP],EBX ;
adc BL,rm8[RBP] ;
adc EDX,rm32[RBP] ;
add AL,5 ;
add EAX,20 ;
add rm8[RBP],23 ;
add rm32[RBP],23 ;
add rm32[RBP],0x1234 ;
add rm8[RBP],BH ;
add rm32[RBP],EBX ;
add BL,rm8[RBP] ;
add EDX,rm32[RBP] ;
and AL,5 ;
and EAX,20 ;
and rm8[RBP],23 ;
and rm32[RBP],23 ;
and rm32[RBP],0x1234 ;
and rm8[RBP],BH ;
and rm32[RBP],EBX ;
and BL,rm8[RBP] ;
and EDX,rm32[RBP] ;
cmp AL,5 ;
cmp EAX,20 ;
cmp rm8[RBP],23 ;
cmp rm32[RBP],23 ;
cmp rm32[RBP],0x1234 ;
cmp rm8[RBP],BH ;
cmp rm32[RBP],EBX ;
cmp BL,rm8[RBP] ;
cmp EDX,rm32[RBP] ;
or AL,5 ;
or EAX,20 ;
or rm8[RBP],23 ;
or rm32[RBP],23 ;
or rm32[RBP],0x1234 ;
or rm8[RBP],BH ;
or rm32[RBP],EBX ;
or BL,rm8[RBP] ;
or EDX,rm32[RBP] ;
sbb AL,5 ;
sbb EAX,20 ;
sbb rm8[RBP],23 ;
sbb rm32[RBP],23 ;
sbb rm32[RBP],0x1234 ;
sbb rm8[RBP],BH ;
sbb rm32[RBP],EBX ;
sbb BL,rm8[RBP] ;
sbb EDX,rm32[RBP] ;
sub AL,5 ;
sub EAX,20 ;
sub rm8[RBP],23 ;
sub rm32[RBP],23 ;
sub rm32[RBP],0x1234 ;
sub rm8[RBP],BH ;
sub rm32[RBP],EBX ;
sub BL,rm8[RBP] ;
sub EDX,rm32[RBP] ;
test AL,5 ;
test EAX,20 ;
test rm8[RBP],23 ;
test rm32[RBP],23 ;
test rm32[RBP],0x1234 ;
test rm8[RBP],BH ;
test rm32[RBP],EBX ;
xor AL,5 ;
xor EAX,20 ;
xor rm8[RBP],23 ;
xor rm32[RBP],23 ;
xor rm32[RBP],0x1234 ;
xor rm8[RBP],BH ;
xor rm32[RBP],EBX ;
xor BL,rm8[RBP] ;
xor EDX,rm32[RBP] ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
//printf("p[%d] = x%02x, data = x%02x\n", i, p[i], data[i]);
assert(p[i] == data[i]);
}
}
/****************************************************/
void test13()
{
int m32;
long m64;
M128 m128;
ubyte *p;
static ubyte[] data =
[
0x0F,0x0B, // ud2
0x0F,0x05, // syscall
0x0F,0x34, // sysenter
0x0F,0x35, // sysexit
0x0F,0x07, // sysret
0x0F,0xAE,0xE8, // lfence
0x0F,0xAE,0xF0, // mfence
0x0F,0xAE,0xF8, // sfence
0x0F,0xAE,0x00, // fxsave [RAX]
0x0F,0xAE,0x08, // fxrstor [RAX]
0x0F,0xAE,0x10, // ldmxcsr [RAX]
0x0F,0xAE,0x18, // stmxcsr [RAX]
0x0F,0xAE,0x38, // clflush [RAX]
0x0F,0x58,0x08, // addps XMM1,[RAX]
0x0F,0x58,0xCA, // addps XMM1,XMM2
0x66, 0x0F,0x58,0x03, // addpd XMM0,[RBX]
0x66, 0x0F,0x58,0xD1, // addpd XMM2,XMM1
0xF2,0x0F,0x58,0x08, // addsd XMM1,[RAX]
0xF2,0x0F,0x58,0xCA, // addsd XMM1,XMM2
0xF3,0x0F,0x58,0x2E, // addss XMM5,[RSI]
0xF3,0x0F,0x58,0xF7, // addss XMM6,XMM7
0x0F,0x54,0x08, // andps XMM1,[RAX]
0x0F,0x54,0xCA, // andps XMM1,XMM2
0x66, 0x0F,0x54,0x03, // andpd XMM0,[RBX]
0x66, 0x0F,0x54,0xD1, // andpd XMM2,XMM1
0x0F,0x55,0x08, // andnps XMM1,[RAX]
0x0F,0x55,0xCA, // andnps XMM1,XMM2
0x66, 0x0F,0x55,0x03, // andnpd XMM0,[RBX]
0x66, 0x0F,0x55,0xD1, // andnpd XMM2,XMM1
0xA7, // cmpsd
0x0F,0xC2,0x08,0x01, // cmpps XMM1,[RAX],1
0x0F,0xC2,0xCA,0x02, // cmpps XMM1,XMM2,2
0x66, 0x0F,0xC2,0x03,0x03, // cmppd XMM0,[RBX],3
0x66, 0x0F,0xC2,0xD1,0x04, // cmppd XMM2,XMM1,4
0xF2,0x0F,0xC2,0x08,0x05, // cmpsd XMM1,[RAX],5
0xF2,0x0F,0xC2,0xCA,0x06, // cmpsd XMM1,XMM2,6
0xF3,0x0F,0xC2,0x2E,0x07, // cmpss XMM5,[RSI],7
0xF3,0x0F,0xC2,0xF7,0x00, // cmpss XMM6,XMM7,0
0x66, 0x0F,0x2F,0x08, // comisd XMM1,[RAX]
0x66, 0x0F,0x2F,0x4D,0xD8, // comisd XMM1,-028h[RBP]
0x66, 0x0F,0x2F,0xCA, // comisd XMM1,XMM2
0x0F,0x2F,0x2E, // comiss XMM5,[RSI]
0x0F,0x2F,0xF7, // comiss XMM6,XMM7
0xF3,0x0F,0xE6,0xDC, // cvtdq2pd XMM3,XMM4
0xF3,0x0F,0xE6,0x5D,0xD8, // cvtdq2pd XMM3,-028h[RBP]
0x0F,0x5B,0xDC, // cvtdq2ps XMM3,XMM4
0x0F,0x5B,0x5D,0xE0, // cvtdq2ps XMM3,-020h[RBP]
0xF2,0x0F,0xE6,0xDC, // cvtpd2dq XMM3,XMM4
0xF2,0x0F,0xE6,0x5D,0xE0, // cvtpd2dq XMM3,-020h[RBP]
0x66, 0x0F,0x2D,0xDC, // cvtpd2pi MM3,XMM4
0x66, 0x0F,0x2D,0x5D,0xE0, // cvtpd2pi MM3,-020h[RBP]
0x66, 0x0F,0x5A,0xDC, // cvtpd2ps XMM3,XMM4
0x66, 0x0F,0x5A,0x5D,0xE0, // cvtpd2ps XMM3,-020h[RBP]
0x66, 0x0F,0x2A,0xDC, // cvtpi2pd XMM3,MM4
0x66, 0x0F,0x2A,0x5D,0xD8, // cvtpi2pd XMM3,-028h[RBP]
0x0F,0x2A,0xDC, // cvtpi2ps XMM3,MM4
0x0F,0x2A,0x5D,0xD8, // cvtpi2ps XMM3,-028h[RBP]
0x66, 0x0F,0x5B,0xDC, // cvtps2dq XMM3,XMM4
0x66, 0x0F,0x5B,0x5D,0xE0, // cvtps2dq XMM3,-020h[RBP]
0x0F,0x5A,0xDC, // cvtps2pd XMM3,XMM4
0x0F,0x5A,0x5D,0xD8, // cvtps2pd XMM3,-028h[RBP]
0x0F,0x2D,0xDC, // cvtps2pi MM3,XMM4
0x0F,0x2D,0x5D,0xD8, // cvtps2pi MM3,-030h[RBP]
0xF2,0x0F,0x2D,0xCC, // cvtsd2si XMM1,XMM4
0xF2,0x0F,0x2D,0x55,0xD8, // cvtsd2si XMM2,-028h[RBP]
0xF2,0x0F,0x5A,0xDC, // cvtsd2ss XMM3,XMM4
0xF2,0x0F,0x5A,0x5D,0xD8, // cvtsd2ss XMM3,-028h[RBP]
0xF2,0x0F,0x2A,0xDA, // cvtsi2sd XMM3,EDX
0xF2,0x0F,0x2A,0x5D,0xD0, // cvtsi2sd XMM3,-030h[RBP]
0xF3,0x0F,0x2A,0xDA, // cvtsi2ss XMM3,EDX
0xF3,0x0F,0x2A,0x5D,0xD0, // cvtsi2ss XMM3,-030h[RBP]
0xF3,0x0F,0x5A,0xDC, // cvtss2sd XMM3,XMM4
0xF3,0x0F,0x5A,0x5D,0xD0, // cvtss2sd XMM3,-030h[RBP]
0xF3,0x0F,0x2D,0xFC, // cvtss2si XMM7,XMM4
0xF3,0x0F,0x2D,0x7D,0xD0, // cvtss2si XMM7,-030h[RBP]
0x66, 0x0F,0x2C,0xDC, // cvttpd2pi MM3,XMM4
0x66, 0x0F,0x2C,0x7D,0xE0, // cvttpd2pi MM7,-020h[RBP]
0x66, 0x0F,0xE6,0xDC, // cvttpd2dq XMM3,XMM4
0x66, 0x0F,0xE6,0x7D,0xE0, // cvttpd2dq XMM7,-020h[RBP]
0xF3,0x0F,0x5B,0xDC, // cvttps2dq XMM3,XMM4
0xF3,0x0F,0x5B,0x7D,0xE0, // cvttps2dq XMM7,-020h[RBP]
0x0F,0x2C,0xDC, // cvttps2pi MM3,XMM4
0x0F,0x2C,0x7D,0xD8, // cvttps2pi MM7,-028h[RBP]
0xF2,0x0F,0x2C,0xC4, // cvttsd2si EAX,XMM4
0xF2,0x0F,0x2C,0x4D,0xD8, // cvttsd2si ECX,-028h[RBP]
0xF3,0x0F,0x2C,0xC4, // cvttss2si EAX,XMM4
0xF3,0x0F,0x2C,0x4D,0xD0, // cvttss2si ECX,-030h[RBP]
0x66, 0x0F,0x5E,0xE8, // divpd XMM5,XMM0
0x66, 0x0F,0x5E,0x6D,0xE0, // divpd XMM5,-020h[RBP]
0x0F,0x5E,0xE8, // divps XMM5,XMM0
0x0F,0x5E,0x6D,0xE0, // divps XMM5,-020h[RBP]
0xF2,0x0F,0x5E,0xE8, // divsd XMM5,XMM0
0xF2,0x0F,0x5E,0x6D,0xD8, // divsd XMM5,-028h[RBP]
0xF3,0x0F,0x5E,0xE8, // divss XMM5,XMM0
0xF3,0x0F,0x5E,0x6D,0xD0, // divss XMM5,-030h[RBP]
0x66, 0x0F,0xF7,0xD1, // maskmovdqu XMM2,XMM1
0x0F,0xF7,0xE3, // maskmovq MM4,MM3
0x66, 0x0F,0x5F,0xC0, // maxpd XMM0,XMM0
0x66, 0x0F,0x5F,0x4D,0xE0, // maxpd XMM1,-020h[RBP]
0x0F,0x5F,0xD1, // maxps XMM2,XMM1
0x0F,0x5F,0x5D,0xE0, // maxps XMM3,-020h[RBP]
0xF2,0x0F,0x5F,0xE2, // maxsd XMM4,XMM2
0xF2,0x0F,0x5F,0x6D,0xD8, // maxsd XMM5,-028h[RBP]
0xF3,0x0F,0x5F,0xF3, // maxss XMM6,XMM3
0xF3,0x0F,0x5F,0x7D,0xD0, // maxss XMM7,-030h[RBP]
0x66, 0x0F,0x5D,0xC0, // minpd XMM0,XMM0
0x66, 0x0F,0x5D,0x4D,0xE0, // minpd XMM1,-020h[RBP]
0x0F,0x5D,0xD1, // minps XMM2,XMM1
0x0F,0x5D,0x5D,0xE0, // minps XMM3,-020h[RBP]
0xF2,0x0F,0x5D,0xE2, // minsd XMM4,XMM2
0xF2,0x0F,0x5D,0x6D,0xD8, // minsd XMM5,-028h[RBP]
0xF3,0x0F,0x5D,0xF3, // minss XMM6,XMM3
0xF3,0x0F,0x5D,0x7D,0xD0, // minss XMM7,-030h[RBP]
0x66, 0x0F,0x28,0xCA, // movapd XMM1,XMM2
0x66, 0x0F,0x28,0x5D,0xE0, // movapd XMM3,-020h[RBP]
0x66, 0x0F,0x29,0x65,0xE0, // movapd -020h[RBP],XMM4
0x0F,0x28,0xCA, // movaps XMM1,XMM2
0x0F,0x28,0x5D,0xE0, // movaps XMM3,-020h[RBP]
0x0F,0x29,0x65,0xE0, // movaps -020h[RBP],XMM4
0x0F,0x6E,0xCB, // movd MM1,EBX
0x0F,0x6E,0x55,0xD0, // movd MM2,-030h[RBP]
0x0F,0x7E,0xDB, // movd EBX,MM3
0x0F,0x7E,0x65,0xD0, // movd -030h[RBP],MM4
0x66, 0x0F,0x6E,0xCB, // movd XMM1,EBX
0x66, 0x0F,0x6E,0x55,0xD0, // movd XMM2,-030h[RBP]
0x66, 0x0F,0x7E,0xDB, // movd EBX,XMM3
0x66, 0x0F,0x7E,0x65,0xD0, // movd -030h[RBP],XMM4
0x66, 0x0F,0x6F,0xCA, // movdqa XMM1,XMM2
0x66, 0x0F,0x6F,0x55,0xE0, // movdqa XMM2,-020h[RBP]
0x66, 0x0F,0x7F,0x65,0xE0, // movdqa -020h[RBP],XMM4
0xF3,0x0F,0x6F,0xCA, // movdqu XMM1,XMM2
0xF3,0x0F,0x6F,0x55,0xE0, // movdqu XMM2,-020h[RBP]
0xF3,0x0F,0x7F,0x65,0xE0, // movdqu -020h[RBP],XMM4
0xF2,0x0F,0xD6,0xDC, // movdq2q MM4,XMM3
0x0F,0x12,0xDC, // movhlps XMM4,XMM3
0x66, 0x0F,0x16,0x55,0xD8, // movhpd XMM2,-028h[RBP]
0x66, 0x0F,0x17,0x7D,0xD8, // movhpd -028h[RBP],XMM7
0x0F,0x16,0x55,0xD8, // movhps XMM2,-028h[RBP]
0x0F,0x17,0x7D,0xD8, // movhps -028h[RBP],XMM7
0x0F,0x16,0xDC, // movlhps XMM4,XMM3
0x66, 0x0F,0x12,0x55,0xD8, // movlpd XMM2,-028h[RBP]
0x66, 0x0F,0x13,0x7D,0xD8, // movlpd -028h[RBP],XMM7
0x0F,0x12,0x55,0xD8, // movlps XMM2,-028h[RBP]
0x0F,0x13,0x7D,0xD8, // movlps -028h[RBP],XMM7
0x66, 0x0F,0x50,0xF3, // movmskpd ESI,XMM3
0x0F,0x50,0xF3, // movmskps ESI,XMM3
0x66, 0x0F,0x59,0xC0, // mulpd XMM0,XMM0
0x66, 0x0F,0x59,0x4D,0xE0, // mulpd XMM1,-020h[RBP]
0x0F,0x59,0xD1, // mulps XMM2,XMM1
0x0F,0x59,0x5D,0xE0, // mulps XMM3,-020h[RBP]
0xF2,0x0F,0x59,0xE2, // mulsd XMM4,XMM2
0xF2,0x0F,0x59,0x6D,0xD8, // mulsd XMM5,-028h[RBP]
0xF3,0x0F,0x59,0xF3, // mulss XMM6,XMM3
0xF3,0x0F,0x59,0x7D,0xD0, // mulss XMM7,-030h[RBP]
0x66, 0x0F,0x51,0xC4, // sqrtpd XMM0,XMM4
0x66, 0x0F,0x51,0x4D,0xE0, // sqrtpd XMM1,-020h[RBP]
0x0F,0x51,0xD5, // sqrtps XMM2,XMM5
0x0F,0x51,0x5D,0xE0, // sqrtps XMM3,-020h[RBP]
0xF2,0x0F,0x51,0xE6, // sqrtsd XMM4,XMM6
0xF2,0x0F,0x51,0x6D,0xD8, // sqrtsd XMM5,-028h[RBP]
0xF3,0x0F,0x51,0xF7, // sqrtss XMM6,XMM7
0xF3,0x0F,0x51,0x7D,0xD0, // sqrtss XMM7,-030h[RBP]
0x66, 0x0F,0x5C,0xC4, // subpd XMM0,XMM4
0x66, 0x0F,0x5C,0x4D,0xE0, // subpd XMM1,-020h[RBP]
0x0F,0x5C,0xD5, // subps XMM2,XMM5
0x0F,0x5C,0x5D,0xE0, // subps XMM3,-020h[RBP]
0xF2,0x0F,0x5C,0xE6, // subsd XMM4,XMM6
0xF2,0x0F,0x5C,0x6D,0xD8, // subsd XMM5,-028h[RBP]
0xF3,0x0F,0x5C,0xF7, // subss XMM6,XMM7
0xF3,0x0F,0x5C,0x7D,0xD0, // subss XMM7,-030h[RBP]
0x0F,0x01,0xE0, // smsw EAX
];
int i;
asm
{
call L1 ;
ud2 ;
syscall ;
sysenter ;
sysexit ;
sysret ;
lfence ;
mfence ;
sfence ;
fxsave [RAX] ;
fxrstor [RAX] ;
ldmxcsr [RAX] ;
stmxcsr [RAX] ;
clflush [RAX] ;
addps XMM1,[RAX] ;
addps XMM1,XMM2 ;
addpd XMM0,[RBX] ;
addpd XMM2,XMM1 ;
addsd XMM1,[RAX] ;
addsd XMM1,XMM2 ;
addss XMM5,[RSI] ;
addss XMM6,XMM7 ;
andps XMM1,[RAX] ;
andps XMM1,XMM2 ;
andpd XMM0,[RBX] ;
andpd XMM2,XMM1 ;
andnps XMM1,[RAX] ;
andnps XMM1,XMM2 ;
andnpd XMM0,[RBX] ;
andnpd XMM2,XMM1 ;
cmpsd ;
cmpps XMM1,[RAX],1 ;
cmpps XMM1,XMM2,2 ;
cmppd XMM0,[RBX],3 ;
cmppd XMM2,XMM1,4 ;
cmpsd XMM1,[RAX],5 ;
cmpsd XMM1,XMM2,6 ;
cmpss XMM5,[RSI],7 ;
cmpss XMM6,XMM7,0 ;
comisd XMM1,[RAX] ;
comisd XMM1,m64[RBP] ;
comisd XMM1,XMM2 ;
comiss XMM5,[RSI] ;
comiss XMM6,XMM7 ;
cvtdq2pd XMM3,XMM4 ;
cvtdq2pd XMM3,m64[RBP] ;
cvtdq2ps XMM3,XMM4 ;
cvtdq2ps XMM3,m128[RBP] ;
cvtpd2dq XMM3,XMM4 ;
cvtpd2dq XMM3,m128[RBP] ;
cvtpd2pi MM3,XMM4 ;
cvtpd2pi MM3,m128[RBP] ;
cvtpd2ps XMM3,XMM4 ;
cvtpd2ps XMM3,m128[RBP] ;
cvtpi2pd XMM3,MM4 ;
cvtpi2pd XMM3,m64[RBP] ;
cvtpi2ps XMM3,MM4 ;
cvtpi2ps XMM3,m64[RBP] ;
cvtps2dq XMM3,XMM4 ;
cvtps2dq XMM3,m128[RBP] ;
cvtps2pd XMM3,XMM4 ;
cvtps2pd XMM3,m64[RBP] ;
cvtps2pi MM3,XMM4 ;
cvtps2pi MM3,m64[RBP] ;
cvtsd2si ECX,XMM4 ;
cvtsd2si EDX,m64[RBP] ;
cvtsd2ss XMM3,XMM4 ;
cvtsd2ss XMM3,m64[RBP] ;
cvtsi2sd XMM3,EDX ;
cvtsi2sd XMM3,m32[RBP] ;
cvtsi2ss XMM3,EDX ;
cvtsi2ss XMM3,m32[RBP] ;
cvtss2sd XMM3,XMM4 ;
cvtss2sd XMM3,m32[RBP] ;
cvtss2si EDI,XMM4 ;
cvtss2si EDI,m32[RBP] ;
cvttpd2pi MM3,XMM4 ;
cvttpd2pi MM7,m128[RBP] ;
cvttpd2dq XMM3,XMM4 ;
cvttpd2dq XMM7,m128[RBP] ;
cvttps2dq XMM3,XMM4 ;
cvttps2dq XMM7,m128[RBP] ;
cvttps2pi MM3,XMM4 ;
cvttps2pi MM7,m64[RBP] ;
cvttsd2si EAX,XMM4 ;
cvttsd2si ECX,m64[RBP] ;
cvttss2si EAX,XMM4 ;
cvttss2si ECX,m32[RBP] ;
divpd XMM5,XMM0 ;
divpd XMM5,m128[RBP] ;
divps XMM5,XMM0 ;
divps XMM5,m128[RBP] ;
divsd XMM5,XMM0 ;
divsd XMM5,m64[RBP] ;
divss XMM5,XMM0 ;
divss XMM5,m32[RBP] ;
maskmovdqu XMM1,XMM2 ;
maskmovq MM3,MM4 ;
maxpd XMM0,XMM0 ;
maxpd XMM1,m128[RBP] ;
maxps XMM2,XMM1 ;
maxps XMM3,m128[RBP] ;
maxsd XMM4,XMM2 ;
maxsd XMM5,m64[RBP] ;
maxss XMM6,XMM3 ;
maxss XMM7,m32[RBP] ;
minpd XMM0,XMM0 ;
minpd XMM1,m128[RBP] ;
minps XMM2,XMM1 ;
minps XMM3,m128[RBP] ;
minsd XMM4,XMM2 ;
minsd XMM5,m64[RBP] ;
minss XMM6,XMM3 ;
minss XMM7,m32[RBP] ;
movapd XMM1,XMM2 ;
movapd XMM3,m128[RBP] ;
movapd m128[RBP],XMM4 ;
movaps XMM1,XMM2 ;
movaps XMM3,m128[RBP] ;
movaps m128[RBP],XMM4 ;
movd MM1,EBX ;
movd MM2,m32[RBP] ;
movd EBX,MM3 ;
movd m32[RBP],MM4 ;
movd XMM1,EBX ;
movd XMM2,m32[RBP] ;
movd EBX,XMM3 ;
movd m32[RBP],XMM4 ;
movdqa XMM1,XMM2 ;
movdqa XMM2,m128[RBP] ;
movdqa m128[RBP],XMM4 ;
movdqu XMM1,XMM2 ;
movdqu XMM2,m128[RBP] ;
movdqu m128[RBP],XMM4 ;
movdq2q MM3,XMM4 ;
movhlps XMM3,XMM4 ;
movhpd XMM2,m64[RBP] ;
movhpd m64[RBP],XMM7 ;
movhps XMM2,m64[RBP] ;
movhps m64[RBP],XMM7 ;
movlhps XMM3,XMM4 ;
movlpd XMM2,m64[RBP] ;
movlpd m64[RBP],XMM7 ;
movlps XMM2,m64[RBP] ;
movlps m64[RBP],XMM7 ;
movmskpd ESI,XMM3 ;
movmskps ESI,XMM3 ;
mulpd XMM0,XMM0 ;
mulpd XMM1,m128[RBP] ;
mulps XMM2,XMM1 ;
mulps XMM3,m128[RBP] ;
mulsd XMM4,XMM2 ;
mulsd XMM5,m64[RBP] ;
mulss XMM6,XMM3 ;
mulss XMM7,m32[RBP] ;
sqrtpd XMM0,XMM4 ;
sqrtpd XMM1,m128[RBP] ;
sqrtps XMM2,XMM5 ;
sqrtps XMM3,m128[RBP] ;
sqrtsd XMM4,XMM6 ;
sqrtsd XMM5,m64[RBP] ;
sqrtss XMM6,XMM7 ;
sqrtss XMM7,m32[RBP] ;
subpd XMM0,XMM4 ;
subpd XMM1,m128[RBP] ;
subps XMM2,XMM5 ;
subps XMM3,m128[RBP] ;
subsd XMM4,XMM6 ;
subsd XMM5,m64[RBP] ;
subss XMM6,XMM7 ;
subss XMM7,m32[RBP] ;
smsw EAX ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
//printf("[%d] = %02x %02x\n", i, p[i], data[i]);
assert(p[i] == data[i]);
}
}
/****************************************************/
void test14()
{
byte m8;
short m16;
int m32;
long m64;
M128 m128;
ubyte *p;
static ubyte[] data =
[
0x66, 0x0F,0x50,0xF3, // movmskpd ESI,XMM3
0x0F,0x50,0xF3, // movmskps ESI,XMM3
0x66, 0x0F,0xE7,0x55,0xE0, // movntdq -020h[RBP],XMM2
0x0F,0xC3,0x4D,0xD4, // movnti -02Ch[RBP],ECX
0x66, 0x0F,0x2B,0x5D,0xE0, // movntpd -020h[RBP],XMM3
0x0F,0x2B,0x65,0xE0, // movntps -020h[RBP],XMM4
0x0F,0xE7,0x6D,0xD8, // movntq -028h[RBP],MM5
0x0F,0x6F,0xCA, // movq MM1,MM2
0x0F,0x6F,0x55,0xD8, // movq MM2,-028h[RBP]
0x0F,0x7F,0x5D,0xD8, // movq -028h[RBP],MM3
0xF3,0x0F,0x7E,0xCA, // movq XMM1,XMM2
0xF3,0x0F,0x7E,0x55,0xD8, // movq XMM2,-028h[RBP]
0x66, 0x0F,0xD6,0x5D,0xD8, // movq -028h[RBP],XMM3
0xF3,0x0F,0xD6,0xDA, // movq2dq XMM3,MM2
0xA5, // movsd
0xF2,0x0F,0x10,0xCA, // movsd XMM1,XMM2
0xF2,0x0F,0x10,0x5D,0xD8, // movsd XMM3,-028h[RBP]
0xF2,0x0F,0x11,0x65,0xD8, // movsd -028h[RBP],XMM4
0xF3,0x0F,0x10,0xCA, // movss XMM1,XMM2
0xF3,0x0F,0x10,0x5D,0xD4, // movss XMM3,-02Ch[RBP]
0xF3,0x0F,0x11,0x65,0xD4, // movss -02Ch[RBP],XMM4
0x66, 0x0F,0x10,0xCA, // movupd XMM1,XMM2
0x66, 0x0F,0x10,0x5D,0xE0, // movupd XMM3,-020h[RBP]
0x66, 0x0F,0x11,0x65,0xE0, // movupd -020h[RBP],XMM4
0x0F,0x10,0xCA, // movups XMM1,XMM2
0x0F,0x10,0x5D,0xE0, // movups XMM3,-020h[RBP]
0x0F,0x11,0x65,0xE0, // movups -020h[RBP],XMM4
0x66, 0x0F,0x56,0xCA, // orpd XMM1,XMM2
0x66, 0x0F,0x56,0x5D,0xE0, // orpd XMM3,-020h[RBP]
0x0F,0x56,0xCA, // orps XMM1,XMM2
0x0F,0x56,0x5D,0xE0, // orps XMM3,-020h[RBP]
0x0F,0x63,0xCA, // packsswb MM1,MM2
0x0F,0x63,0x5D,0xD8, // packsswb MM3,-028h[RBP]
0x66, 0x0F,0x63,0xCA, // packsswb XMM1,XMM2
0x66, 0x0F,0x63,0x5D,0xE0, // packsswb XMM3,-020h[RBP]
0x0F,0x6B,0xCA, // packssdw MM1,MM2
0x0F,0x6B,0x5D,0xD8, // packssdw MM3,-028h[RBP]
0x66, 0x0F,0x6B,0xCA, // packssdw XMM1,XMM2
0x66, 0x0F,0x6B,0x5D,0xE0, // packssdw XMM3,-020h[RBP]
0x0F,0x67,0xCA, // packuswb MM1,MM2
0x0F,0x67,0x5D,0xD8, // packuswb MM3,-028h[RBP]
0x66, 0x0F,0x67,0xCA, // packuswb XMM1,XMM2
0x66, 0x0F,0x67,0x5D,0xE0, // packuswb XMM3,-020h[RBP]
0x0F,0xFC,0xCA, // paddb MM1,MM2
0x0F,0xFC,0x5D,0xD8, // paddb MM3,-028h[RBP]
0x66, 0x0F,0xFC,0xCA, // paddb XMM1,XMM2
0x66, 0x0F,0xFC,0x5D,0xE0, // paddb XMM3,-020h[RBP]
0x0F,0xFD,0xCA, // paddw MM1,MM2
0x0F,0xFD,0x5D,0xD8, // paddw MM3,-028h[RBP]
0x66, 0x0F,0xFD,0xCA, // paddw XMM1,XMM2
0x66, 0x0F,0xFD,0x5D,0xE0, // paddw XMM3,-020h[RBP]
0x0F,0xFE,0xCA, // paddd MM1,MM2
0x0F,0xFE,0x5D,0xD8, // paddd MM3,-028h[RBP]
0x66, 0x0F,0xFE,0xCA, // paddd XMM1,XMM2
0x66, 0x0F,0xFE,0x5D,0xE0, // paddd XMM3,-020h[RBP]
0x0F,0xD4,0xCA, // paddq MM1,MM2
0x0F,0xD4,0x5D,0xD8, // paddq MM3,-028h[RBP]
0x66, 0x0F,0xD4,0xCA, // paddq XMM1,XMM2
0x66, 0x0F,0xD4,0x5D,0xE0, // paddq XMM3,-020h[RBP]
0x0F,0xEC,0xCA, // paddsb MM1,MM2
0x0F,0xEC,0x5D,0xD8, // paddsb MM3,-028h[RBP]
0x66, 0x0F,0xEC,0xCA, // paddsb XMM1,XMM2
0x66, 0x0F,0xEC,0x5D,0xE0, // paddsb XMM3,-020h[RBP]
0x0F,0xED,0xCA, // paddsw MM1,MM2
0x0F,0xED,0x5D,0xD8, // paddsw MM3,-028h[RBP]
0x66, 0x0F,0xED,0xCA, // paddsw XMM1,XMM2
0x66, 0x0F,0xED,0x5D,0xE0, // paddsw XMM3,-020h[RBP]
0x0F,0xDC,0xCA, // paddusb MM1,MM2
0x0F,0xDC,0x5D,0xD8, // paddusb MM3,-028h[RBP]
0x66, 0x0F,0xDC,0xCA, // paddusb XMM1,XMM2
0x66, 0x0F,0xDC,0x5D,0xE0, // paddusb XMM3,-020h[RBP]
0x0F,0xDD,0xCA, // paddusw MM1,MM2
0x0F,0xDD,0x5D,0xD8, // paddusw MM3,-028h[RBP]
0x66, 0x0F,0xDD,0xCA, // paddusw XMM1,XMM2
0x66, 0x0F,0xDD,0x5D,0xE0, // paddusw XMM3,-020h[RBP]
0x0F,0xDB,0xCA, // pand MM1,MM2
0x0F,0xDB,0x5D,0xD8, // pand MM3,-028h[RBP]
0x66, 0x0F,0xDB,0xCA, // pand XMM1,XMM2
0x66, 0x0F,0xDB,0x5D,0xE0, // pand XMM3,-020h[RBP]
0x0F,0xDF,0xCA, // pandn MM1,MM2
0x0F,0xDF,0x5D,0xD8, // pandn MM3,-028h[RBP]
0x66, 0x0F,0xDF,0xCA, // pandn XMM1,XMM2
0x66, 0x0F,0xDF,0x5D,0xE0, // pandn XMM3,-020h[RBP]
0x0F,0xE0,0xCA, // pavgb MM1,MM2
0x0F,0xE0,0x5D,0xD8, // pavgb MM3,-028h[RBP]
0x66, 0x0F,0xE0,0xCA, // pavgb XMM1,XMM2
0x66, 0x0F,0xE0,0x5D,0xE0, // pavgb XMM3,-020h[RBP]
0x0F,0xE3,0xCA, // pavgw MM1,MM2
0x0F,0xE3,0x5D,0xD8, // pavgw MM3,-028h[RBP]
0x66, 0x0F,0xE3,0xCA, // pavgw XMM1,XMM2
0x66, 0x0F,0xE3,0x5D,0xE0, // pavgw XMM3,-020h[RBP]
0x0F,0x74,0xCA, // pcmpeqb MM1,MM2
0x0F,0x74,0x5D,0xD8, // pcmpeqb MM3,-028h[RBP]
0x66, 0x0F,0x74,0xCA, // pcmpeqb XMM1,XMM2
0x66, 0x0F,0x74,0x5D,0xE0, // pcmpeqb XMM3,-020h[RBP]
0x0F,0x75,0xCA, // pcmpeqw MM1,MM2
0x0F,0x75,0x5D,0xD8, // pcmpeqw MM3,-028h[RBP]
0x66, 0x0F,0x75,0xCA, // pcmpeqw XMM1,XMM2
0x66, 0x0F,0x75,0x5D,0xE0, // pcmpeqw XMM3,-020h[RBP]
0x0F,0x76,0xCA, // pcmpeqd MM1,MM2
0x0F,0x76,0x5D,0xD8, // pcmpeqd MM3,-028h[RBP]
0x66, 0x0F,0x76,0xCA, // pcmpeqd XMM1,XMM2
0x66, 0x0F,0x76,0x5D,0xE0, // pcmpeqd XMM3,-020h[RBP]
0x0F,0x64,0xCA, // pcmpgtb MM1,MM2
0x0F,0x64,0x5D,0xD8, // pcmpgtb MM3,-028h[RBP]
0x66, 0x0F,0x64,0xCA, // pcmpgtb XMM1,XMM2
0x66, 0x0F,0x64,0x5D,0xE0, // pcmpgtb XMM3,-020h[RBP]
0x0F,0x65,0xCA, // pcmpgtw MM1,MM2
0x0F,0x65,0x5D,0xD8, // pcmpgtw MM3,-028h[RBP]
0x66, 0x0F,0x65,0xCA, // pcmpgtw XMM1,XMM2
0x66, 0x0F,0x65,0x5D,0xE0, // pcmpgtw XMM3,-020h[RBP]
0x0F,0x66,0xCA, // pcmpgtd MM1,MM2
0x0F,0x66,0x5D,0xD8, // pcmpgtd MM3,-028h[RBP]
0x66, 0x0F,0x66,0xCA, // pcmpgtd XMM1,XMM2
0x66, 0x0F,0x66,0x5D,0xE0, // pcmpgtd XMM3,-020h[RBP]
0x0F,0xC5,0xD6,0x07, // pextrw EDX,MM6,7
0x66, 0x0F,0xC5,0xD6,0x07, // pextrw EDX,XMM6,7
0x0F,0xC4,0xF2,0x07, // pinsrw MM6,EDX,7
0x0F,0xC4,0x75,0xD2,0x07, // pinsrw MM6,-02Eh[RBP],7
0x66, 0x0F,0xC4,0xF2,0x07, // pinsrw XMM6,EDX,7
0x66, 0x0F,0xC4,0x75,0xD2,0x07, // pinsrw XMM6,-02Eh[RBP],7
0x0F,0xF5,0xCA, // pmaddwd MM1,MM2
0x0F,0xF5,0x5D,0xD8, // pmaddwd MM3,-028h[RBP]
0x66, 0x0F,0xF5,0xCA, // pmaddwd XMM1,XMM2
0x66, 0x0F,0xF5,0x5D,0xE0, // pmaddwd XMM3,-020h[RBP]
0x0F,0xEE,0xCA, // pmaxsw MM1,XMM2
0x0F,0xEE,0x5D,0xD8, // pmaxsw MM3,-028h[RBP]
0x66, 0x0F,0xEE,0xCA, // pmaxsw XMM1,XMM2
0x66, 0x0F,0xEE,0x5D,0xE0, // pmaxsw XMM3,-020h[RBP]
0x0F,0xDE,0xCA, // pmaxub MM1,XMM2
0x0F,0xDE,0x5D,0xD8, // pmaxub MM3,-028h[RBP]
0x66, 0x0F,0xDE,0xCA, // pmaxub XMM1,XMM2
0x66, 0x0F,0xDE,0x5D,0xE0, // pmaxub XMM3,-020h[RBP]
0x0F,0xEA,0xCA, // pminsw MM1,MM2
0x0F,0xEA,0x5D,0xD8, // pminsw MM3,-028h[RBP]
0x66, 0x0F,0xEA,0xCA, // pminsw XMM1,XMM2
0x66, 0x0F,0xEA,0x5D,0xE0, // pminsw XMM3,-020h[RBP]
0x0F,0xDA,0xCA, // pminub MM1,MM2
0x0F,0xDA,0x5D,0xD8, // pminub MM3,-028h[RBP]
0x66, 0x0F,0xDA,0xCA, // pminub XMM1,XMM2
0x66, 0x0F,0xDA,0x5D,0xE0, // pminub XMM3,-020h[RBP]
0x0F,0xD7,0xC8, // pmovmskb ECX,MM0
0x66, 0x0F,0xD7,0xCE, // pmovmskb ECX,XMM6
0x0F,0xE4,0xCA, // pmulhuw MM1,MM2
0x0F,0xE4,0x5D,0xD8, // pmulhuw MM3,-028h[RBP]
0x66, 0x0F,0xE4,0xCA, // pmulhuw XMM1,XMM2
0x66, 0x0F,0xE4,0x5D,0xE0, // pmulhuw XMM3,-020h[RBP]
0x0F,0xE5,0xCA, // pmulhw MM1,MM2
0x0F,0xE5,0x5D,0xD8, // pmulhw MM3,-028h[RBP]
0x66, 0x0F,0xE5,0xCA, // pmulhw XMM1,XMM2
0x66, 0x0F,0xE5,0x5D,0xE0, // pmulhw XMM3,-020h[RBP]
0x0F,0xD5,0xCA, // pmullw MM1,MM2
0x0F,0xD5,0x5D,0xD8, // pmullw MM3,-028h[RBP]
0x66, 0x0F,0xD5,0xCA, // pmullw XMM1,XMM2
0x66, 0x0F,0xD5,0x5D,0xE0, // pmullw XMM3,-020h[RBP]
0x0F,0xF4,0xCA, // pmuludq MM1,MM2
0x0F,0xF4,0x5D,0xD8, // pmuludq MM3,-028h[RBP]
0x66, 0x0F,0xF4,0xCA, // pmuludq XMM1,XMM2
0x66, 0x0F,0xF4,0x5D,0xE0, // pmuludq XMM3,-020h[RBP]
0x0F,0xEB,0xCA, // por MM1,MM2
0x0F,0xEB,0x5D,0xD8, // por MM3,-028h[RBP]
0x66, 0x0F,0xEB,0xCA, // por XMM1,XMM2
0x66, 0x0F,0xEB,0x5D,0xE0, // por XMM3,-020h[RBP]
0x0F,0x18,0x4D,0xD0, // prefetcht0 -030h[RBP]
0x0F,0x18,0x55,0xD0, // prefetcht1 -030h[RBP]
0x0F,0x18,0x5D,0xD0, // prefetcht2 -030h[RBP]
0x0F,0x18,0x45,0xD0, // prefetchnta -030h[RBP]
0x0F,0x0D,0x4D,0xD0, // prefetchw -030h[RBP]
0x0F,0x0D,0x55,0xD0, // prefetchwt1 -030h[RBP]
0x0F,0xF6,0xCA, // psadbw MM1,MM2
0x0F,0xF6,0x5D,0xD8, // psadbw MM3,-028h[RBP]
0x66, 0x0F,0xF6,0xCA, // psadbw XMM1,XMM2
0x66, 0x0F,0xF6,0x5D,0xE0, // psadbw XMM3,-020h[RBP]
0x66, 0x0F,0x70,0xCA,0x03, // pshufd XMM1,XMM2,3
0x66, 0x0F,0x70,0x5D,0xE0,0x03, // pshufd XMM3,-020h[RBP],3
0xF3,0x0F,0x70,0xCA,0x03, // pshufhw XMM1,XMM2,3
0xF3,0x0F,0x70,0x5D,0xE0,0x03, // pshufhw XMM3,-020h[RBP],3
0xF2,0x0F,0x70,0xCA,0x03, // pshuflw XMM1,XMM2,3
0xF2,0x0F,0x70,0x5D,0xE0,0x03, // pshuflw XMM3,-020h[RBP],3
0x0F,0x70,0xCA,0x03, // pshufw MM1,MM2,3
0x0F,0x70,0x5D,0xD8,0x03, // pshufw MM3,-028h[RBP],3
0x66, 0x0F,0x73,0xF9,0x18, // pslldq XMM1,020h
0x0F,0xF1,0xCA, // psllw MM1,MM2
0x0F,0xF1,0x4D,0xD8, // psllw MM1,-028h[RBP]
0x66, 0x0F,0xF1,0xCA, // psllw XMM1,XMM2
0x66, 0x0F,0xF1,0x4D,0xE0, // psllw XMM1,-020h[RBP]
0x0F,0x71,0xF1,0x15, // psraw MM1,015h
0x66, 0x0F,0x71,0xF1,0x15, // psraw XMM1,015h
0x0F,0xF2,0xCA, // pslld MM1,MM2
0x0F,0xF2,0x4D,0xD8, // pslld MM1,-028h[RBP]
0x66, 0x0F,0xF2,0xCA, // pslld XMM1,XMM2
0x66, 0x0F,0xF2,0x4D,0xE0, // pslld XMM1,-020h[RBP]
0x0F,0x72,0xF1,0x15, // psrad MM1,015h
0x66, 0x0F,0x72,0xF1,0x15, // psrad XMM1,015h
0x0F,0xF3,0xCA, // psllq MM1,MM2
0x0F,0xF3,0x4D,0xD8, // psllq MM1,-028h[RBP]
0x66, 0x0F,0xF3,0xCA, // psllq XMM1,XMM2
0x66, 0x0F,0xF3,0x4D,0xE0, // psllq XMM1,-020h[RBP]
0x0F,0x73,0xF1,0x15, // psllq MM1,015h
0x66, 0x0F,0x73,0xF1,0x15, // psllq XMM1,015h
0x0F,0xE1,0xCA, // psraw MM1,MM2
0x0F,0xE1,0x4D,0xD8, // psraw MM1,-028h[RBP]
0x66, 0x0F,0xE1,0xCA, // psraw XMM1,XMM2
0x66, 0x0F,0xE1,0x4D,0xE0, // psraw XMM1,-020h[RBP]
0x0F,0x71,0xE1,0x15, // psraw MM1,015h
0x66, 0x0F,0x71,0xE1,0x15, // psraw XMM1,015h
0x0F,0xE2,0xCA, // psrad MM1,MM2
0x0F,0xE2,0x4D,0xD8, // psrad MM1,-028h[RBP]
0x66, 0x0F,0xE2,0xCA, // psrad XMM1,XMM2
0x66, 0x0F,0xE2,0x4D,0xE0, // psrad XMM1,-020h[RBP]
0x0F,0x72,0xE1,0x15, // psrad MM1,015h
0x66, 0x0F,0x72,0xE1,0x15, // psrad XMM1,015h
0x66, 0x0F,0x73,0xD9,0x18, // psrldq XMM1,020h
0x0F,0xD1,0xCA, // psrlw MM1,MM2
0x0F,0xD1,0x4D,0xD8, // psrlw MM1,-028h[RBP]
0x66, 0x0F,0xD1,0xCA, // psrlw XMM1,XMM2
0x66, 0x0F,0xD1,0x4D,0xE0, // psrlw XMM1,-020h[RBP]
0x0F,0x71,0xD1,0x15, // psrlw MM1,015h
0x66, 0x0F,0x71,0xD1,0x15, // psrlw XMM1,015h
0x0F,0xD2,0xCA, // psrld MM1,MM2
0x0F,0xD2,0x4D,0xD8, // psrld MM1,-028h[RBP]
0x66, 0x0F,0xD2,0xCA, // psrld XMM1,XMM2
0x66, 0x0F,0xD2,0x4D,0xE0, // psrld XMM1,-020h[RBP]
0x0F,0x72,0xD1,0x15, // psrld MM1,015h
0x66, 0x0F,0x72,0xD1,0x15, // psrld XMM1,015h
0x0F,0xD3,0xCA, // psrlq MM1,MM2
0x0F,0xD3,0x4D,0xD8, // psrlq MM1,-028h[RBP]
0x66, 0x0F,0xD3,0xCA, // psrlq XMM1,XMM2
0x66, 0x0F,0xD3,0x4D,0xE0, // psrlq XMM1,-020h[RBP]
0x0F,0x73,0xD1,0x15, // psrlq MM1,015h
0x66, 0x0F,0x73,0xD1,0x15, // psrlq XMM1,015h
0x0F,0xF8,0xCA, // psubb MM1,MM2
0x0F,0xF8,0x4D,0xD8, // psubb MM1,-028h[RBP]
0x66, 0x0F,0xF8,0xCA, // psubb XMM1,XMM2
0x66, 0x0F,0xF8,0x4D,0xE0, // psubb XMM1,-020h[RBP]
0x0F,0xF9,0xCA, // psubw MM1,MM2
0x0F,0xF9,0x4D,0xD8, // psubw MM1,-028h[RBP]
0x66, 0x0F,0xF9,0xCA, // psubw XMM1,XMM2
0x66, 0x0F,0xF9,0x4D,0xE0, // psubw XMM1,-020h[RBP]
0x0F,0xFA,0xCA, // psubd MM1,MM2
0x0F,0xFA,0x4D,0xD8, // psubd MM1,-028h[RBP]
0x66, 0x0F,0xFA,0xCA, // psubd XMM1,XMM2
0x66, 0x0F,0xFA,0x4D,0xE0, // psubd XMM1,-020h[RBP]
0x0F,0xFB,0xCA, // psubq MM1,MM2
0x0F,0xFB,0x4D,0xD8, // psubq MM1,-028h[RBP]
0x66, 0x0F,0xFB,0xCA, // psubq XMM1,XMM2
0x66, 0x0F,0xFB,0x4D,0xE0, // psubq XMM1,-020h[RBP]
0x0F,0xE8,0xCA, // psubsb MM1,MM2
0x0F,0xE8,0x4D,0xD8, // psubsb MM1,-028h[RBP]
0x66, 0x0F,0xE8,0xCA, // psubsb XMM1,XMM2
0x66, 0x0F,0xE8,0x4D,0xE0, // psubsb XMM1,-020h[RBP]
0x0F,0xE9,0xCA, // psubsw MM1,MM2
0x0F,0xE9,0x4D,0xD8, // psubsw MM1,-028h[RBP]
0x66, 0x0F,0xE9,0xCA, // psubsw XMM1,XMM2
0x66, 0x0F,0xE9,0x4D,0xE0, // psubsw XMM1,-020h[RBP]
0x0F,0xD8,0xCA, // psubusb MM1,MM2
0x0F,0xD8,0x4D,0xD8, // psubusb MM1,-028h[RBP]
0x66, 0x0F,0xD8,0xCA, // psubusb XMM1,XMM2
0x66, 0x0F,0xD8,0x4D,0xE0, // psubusb XMM1,-020h[RBP]
0x0F,0xD9,0xCA, // psubusw MM1,MM2
0x0F,0xD9,0x4D,0xD8, // psubusw MM1,-028h[RBP]
0x66, 0x0F,0xD9,0xCA, // psubusw XMM1,XMM2
0x66, 0x0F,0xD9,0x4D,0xE0, // psubusw XMM1,-020h[RBP]
0x0F,0x68,0xCA, // punpckhbw MM1,MM2
0x0F,0x68,0x4D,0xD8, // punpckhbw MM1,-028h[RBP]
0x66, 0x0F,0x68,0xCA, // punpckhbw XMM1,XMM2
0x66, 0x0F,0x68,0x4D,0xE0, // punpckhbw XMM1,-020h[RBP]
0x0F,0x69,0xCA, // punpckhwd MM1,MM2
0x0F,0x69,0x4D,0xD8, // punpckhwd MM1,-028h[RBP]
0x66, 0x0F,0x69,0xCA, // punpckhwd XMM1,XMM2
0x66, 0x0F,0x69,0x4D,0xE0, // punpckhwd XMM1,-020h[RBP]
0x0F,0x6A,0xCA, // punpckhdq MM1,MM2
0x0F,0x6A,0x4D,0xD8, // punpckhdq MM1,-028h[RBP]
0x66, 0x0F,0x6A,0xCA, // punpckhdq XMM1,XMM2
0x66, 0x0F,0x6A,0x4D,0xE0, // punpckhdq XMM1,-020h[RBP]
0x66, 0x0F,0x6D,0xCA, // punpckhqdq XMM1,XMM2
0x66, 0x0F,0x6D,0x4D,0xE0, // punpckhqdq XMM1,-020h[RBP]
0x0F,0x60,0xCA, // punpcklbw MM1,MM2
0x0F,0x60,0x4D,0xD8, // punpcklbw MM1,-028h[RBP]
0x66, 0x0F,0x60,0xCA, // punpcklbw XMM1,XMM2
0x66, 0x0F,0x60,0x4D,0xE0, // punpcklbw XMM1,-020h[RBP]
0x0F,0x61,0xCA, // punpcklwd MM1,MM2
0x0F,0x61,0x4D,0xD8, // punpcklwd MM1,-028h[RBP]
0x66, 0x0F,0x61,0xCA, // punpcklwd XMM1,XMM2
0x66, 0x0F,0x61,0x4D,0xE0, // punpcklwd XMM1,-020h[RBP]
0x0F,0x62,0xCA, // punpckldq MM1,MM2
0x0F,0x62,0x4D,0xD8, // punpckldq MM1,-028h[RBP]
0x66, 0x0F,0x62,0xCA, // punpckldq XMM1,XMM2
0x66, 0x0F,0x62,0x4D,0xE0, // punpckldq XMM1,-020h[RBP]
0x66, 0x0F,0x6C,0xCA, // punpcklqdq XMM1,XMM2
0x66, 0x0F,0x6C,0x4D,0xE0, // punpcklqdq XMM1,-020h[RBP]
0x0F,0xEF,0xCA, // pxor MM1,MM2
0x0F,0xEF,0x4D,0xD8, // pxor MM1,-028h[RBP]
0x66, 0x0F,0xEF,0xCA, // pxor XMM1,XMM2
0x66, 0x0F,0xEF,0x4D,0xE0, // pxor XMM1,-020h[RBP]
0x0F,0x53,0xCA, // rcpps XMM1,XMM2
0x0F,0x53,0x4D,0xE0, // rcpps XMM1,-020h[RBP]
0xF3,0x0F,0x53,0xCA, // rcpss XMM1,XMM2
0xF3,0x0F,0x53,0x4D,0xD4, // rcpss XMM1,-02Ch[RBP]
0x0F,0x52,0xCA, // rsqrtps XMM1,XMM2
0x0F,0x52,0x4D,0xE0, // rsqrtps XMM1,-020h[RBP]
0xF3,0x0F,0x52,0xCA, // rsqrtss XMM1,XMM2
0xF3,0x0F,0x52,0x4D,0xD4, // rsqrtss XMM1,-02Ch[RBP]
0x66, 0x0F,0xC6,0xCA,0x03, // shufpd XMM1,XMM2,3
0x66, 0x0F,0xC6,0x4D,0xE0,0x04, // shufpd XMM1,-020h[RBP],4
0x0F,0xC6,0xCA,0x03, // shufps XMM1,XMM2,3
0x0F,0xC6,0x4D,0xE0,0x04, // shufps XMM1,-020h[RBP],4
0x66, 0x0F,0x2E,0xE6, // ucimisd XMM4,XMM6
0x66, 0x0F,0x2E,0x6D,0xD8, // ucimisd XMM5,-028h[RBP]
0x0F,0x2E,0xF7, // ucomiss XMM6,XMM7
0x0F,0x2E,0x7D,0xD4, // ucomiss XMM7,-02Ch[RBP]
0x66, 0x0F,0x15,0xE6, // uppckhpd XMM4,XMM6
0x66, 0x0F,0x15,0x6D,0xE0, // uppckhpd XMM5,-020h[RBP]
0x0F,0x15,0xE6, // unpckhps XMM4,XMM6
0x0F,0x15,0x6D,0xE0, // unpckhps XMM5,-020h[RBP]
0x66, 0x0F,0x14,0xE6, // uppcklpd XMM4,XMM6
0x66, 0x0F,0x14,0x6D,0xE0, // uppcklpd XMM5,-020h[RBP]
0x0F,0x14,0xE6, // unpcklps XMM4,XMM6
0x0F,0x14,0x6D,0xE0, // unpcklps XMM5,-020h[RBP]
0x66, 0x0F,0x57,0xCA, // xorpd XMM1,XMM2
0x66, 0x0F,0x57,0x4D,0xE0, // xorpd XMM1,-020h[RBP]
0x0F,0x57,0xCA, // xorps XMM1,XMM2
0x0F,0x57,0x4D,0xE0, // xorps XMM1,-020h[RBP]
];
int i;
asm
{
call L1 ;
movmskpd ESI,XMM3 ;
movmskps ESI,XMM3 ;
movntdq m128[RBP],XMM2 ;
movnti m32[RBP],ECX ;
movntpd m128[RBP],XMM3 ;
movntps m128[RBP],XMM4 ;
movntq m64[RBP],MM5 ;
movq MM1,MM2 ;
movq MM2,m64[RBP] ;
movq m64[RBP],MM3 ;
movq XMM1,XMM2 ;
movq XMM2,m64[RBP] ;
movq m64[RBP],XMM3 ;
movq2dq XMM3,MM2 ;
movsd ;
movsd XMM1,XMM2 ;
movsd XMM3,m64[RBP] ;
movsd m64[RBP],XMM4 ;
movss XMM1,XMM2 ;
movss XMM3,m32[RBP] ;
movss m32[RBP],XMM4 ;
movupd XMM1,XMM2 ;
movupd XMM3,m128[RBP] ;
movupd m128[RBP],XMM4 ;
movups XMM1,XMM2 ;
movups XMM3,m128[RBP] ;
movups m128[RBP],XMM4 ;
orpd XMM1,XMM2 ;
orpd XMM3,m128[RBP] ;
orps XMM1,XMM2 ;
orps XMM3,m128[RBP] ;
packsswb MM1,MM2 ;
packsswb MM3,m64[RBP] ;
packsswb XMM1,XMM2 ;
packsswb XMM3,m128[RBP] ;
packssdw MM1,MM2 ;
packssdw MM3,m64[RBP] ;
packssdw XMM1,XMM2 ;
packssdw XMM3,m128[RBP] ;
packuswb MM1,MM2 ;
packuswb MM3,m64[RBP] ;
packuswb XMM1,XMM2 ;
packuswb XMM3,m128[RBP] ;
paddb MM1,MM2 ;
paddb MM3,m64[RBP] ;
paddb XMM1,XMM2 ;
paddb XMM3,m128[RBP] ;
paddw MM1,MM2 ;
paddw MM3,m64[RBP] ;
paddw XMM1,XMM2 ;
paddw XMM3,m128[RBP] ;
paddd MM1,MM2 ;
paddd MM3,m64[RBP] ;
paddd XMM1,XMM2 ;
paddd XMM3,m128[RBP] ;
paddq MM1,MM2 ;
paddq MM3,m64[RBP] ;
paddq XMM1,XMM2 ;
paddq XMM3,m128[RBP] ;
paddsb MM1,MM2 ;
paddsb MM3,m64[RBP] ;
paddsb XMM1,XMM2 ;
paddsb XMM3,m128[RBP] ;
paddsw MM1,MM2 ;
paddsw MM3,m64[RBP] ;
paddsw XMM1,XMM2 ;
paddsw XMM3,m128[RBP] ;
paddusb MM1,MM2 ;
paddusb MM3,m64[RBP] ;
paddusb XMM1,XMM2 ;
paddusb XMM3,m128[RBP] ;
paddusw MM1,MM2 ;
paddusw MM3,m64[RBP] ;
paddusw XMM1,XMM2 ;
paddusw XMM3,m128[RBP] ;
pand MM1,MM2 ;
pand MM3,m64[RBP] ;
pand XMM1,XMM2 ;
pand XMM3,m128[RBP] ;
pandn MM1,MM2 ;
pandn MM3,m64[RBP] ;
pandn XMM1,XMM2 ;
pandn XMM3,m128[RBP] ;
pavgb MM1,MM2 ;
pavgb MM3,m64[RBP] ;
pavgb XMM1,XMM2 ;
pavgb XMM3,m128[RBP] ;
pavgw MM1,MM2 ;
pavgw MM3,m64[RBP] ;
pavgw XMM1,XMM2 ;
pavgw XMM3,m128[RBP] ;
pcmpeqb MM1,MM2 ;
pcmpeqb MM3,m64[RBP] ;
pcmpeqb XMM1,XMM2 ;
pcmpeqb XMM3,m128[RBP] ;
pcmpeqw MM1,MM2 ;
pcmpeqw MM3,m64[RBP] ;
pcmpeqw XMM1,XMM2 ;
pcmpeqw XMM3,m128[RBP] ;
pcmpeqd MM1,MM2 ;
pcmpeqd MM3,m64[RBP] ;
pcmpeqd XMM1,XMM2 ;
pcmpeqd XMM3,m128[RBP] ;
pcmpgtb MM1,MM2 ;
pcmpgtb MM3,m64[RBP] ;
pcmpgtb XMM1,XMM2 ;
pcmpgtb XMM3,m128[RBP] ;
pcmpgtw MM1,MM2 ;
pcmpgtw MM3,m64[RBP] ;
pcmpgtw XMM1,XMM2 ;
pcmpgtw XMM3,m128[RBP] ;
pcmpgtd MM1,MM2 ;
pcmpgtd MM3,m64[RBP] ;
pcmpgtd XMM1,XMM2 ;
pcmpgtd XMM3,m128[RBP] ;
pextrw EDX,MM6,7 ;
pextrw EDX,XMM6,7 ;
pinsrw MM6,EDX,7 ;
pinsrw MM6,m16[RBP],7 ;
pinsrw XMM6,EDX,7 ;
pinsrw XMM6,m16[RBP],7 ;
pmaddwd MM1,MM2 ;
pmaddwd MM3,m64[RBP] ;
pmaddwd XMM1,XMM2 ;
pmaddwd XMM3,m128[RBP] ;
pmaxsw MM1,MM2 ;
pmaxsw MM3,m64[RBP] ;
pmaxsw XMM1,XMM2 ;
pmaxsw XMM3,m128[RBP] ;
pmaxub MM1,MM2 ;
pmaxub MM3,m64[RBP] ;
pmaxub XMM1,XMM2 ;
pmaxub XMM3,m128[RBP] ;
pminsw MM1,MM2 ;
pminsw MM3,m64[RBP] ;
pminsw XMM1,XMM2 ;
pminsw XMM3,m128[RBP] ;
pminub MM1,MM2 ;
pminub MM3,m64[RBP] ;
pminub XMM1,XMM2 ;
pminub XMM3,m128[RBP] ;
pmovmskb ECX,MM0 ;
pmovmskb ECX,XMM6 ;
pmulhuw MM1,MM2 ;
pmulhuw MM3,m64[RBP] ;
pmulhuw XMM1,XMM2 ;
pmulhuw XMM3,m128[RBP] ;
pmulhw MM1,MM2 ;
pmulhw MM3,m64[RBP] ;
pmulhw XMM1,XMM2 ;
pmulhw XMM3,m128[RBP] ;
pmullw MM1,MM2 ;
pmullw MM3,m64[RBP] ;
pmullw XMM1,XMM2 ;
pmullw XMM3,m128[RBP] ;
pmuludq MM1,MM2 ;
pmuludq MM3,m64[RBP] ;
pmuludq XMM1,XMM2 ;
pmuludq XMM3,m128[RBP] ;
por MM1,MM2 ;
por MM3,m64[RBP] ;
por XMM1,XMM2 ;
por XMM3,m128[RBP] ;
prefetcht0 m8[RBP] ;
prefetcht1 m8[RBP] ;
prefetcht2 m8[RBP] ;
prefetchnta m8[RBP] ;
prefetchw m8[EBP] ;
prefetchwt1 m8[EBP] ;
psadbw MM1,MM2 ;
psadbw MM3,m64[RBP] ;
psadbw XMM1,XMM2 ;
psadbw XMM3,m128[RBP] ;
pshufd XMM1,XMM2,3 ;
pshufd XMM3,m128[RBP],3 ;
pshufhw XMM1,XMM2,3 ;
pshufhw XMM3,m128[RBP],3 ;
pshuflw XMM1,XMM2,3 ;
pshuflw XMM3,m128[RBP],3 ;
pshufw MM1,MM2,3 ;
pshufw MM3,m64[RBP],3 ;
pslldq XMM1,0x18 ;
psllw MM1,MM2 ;
psllw MM1,m64[RBP] ;
psllw XMM1,XMM2 ;
psllw XMM1,m128[RBP] ;
psllw MM1,0x15 ;
psllw XMM1,0x15 ;
pslld MM1,MM2 ;
pslld MM1,m64[RBP] ;
pslld XMM1,XMM2 ;
pslld XMM1,m128[RBP] ;
pslld MM1,0x15 ;
pslld XMM1,0x15 ;
psllq MM1,MM2 ;
psllq MM1,m64[RBP] ;
psllq XMM1,XMM2 ;
psllq XMM1,m128[RBP] ;
psllq MM1,0x15 ;
psllq XMM1,0x15 ;
psraw MM1,MM2 ;
psraw MM1,m64[RBP] ;
psraw XMM1,XMM2 ;
psraw XMM1,m128[RBP] ;
psraw MM1,0x15 ;
psraw XMM1,0x15 ;
psrad MM1,MM2 ;
psrad MM1,m64[RBP] ;
psrad XMM1,XMM2 ;
psrad XMM1,m128[RBP] ;
psrad MM1,0x15 ;
psrad XMM1,0x15 ;
psrldq XMM1,0x18 ;
psrlw MM1,MM2 ;
psrlw MM1,m64[RBP] ;
psrlw XMM1,XMM2 ;
psrlw XMM1,m128[RBP] ;
psrlw MM1,0x15 ;
psrlw XMM1,0x15 ;
psrld MM1,MM2 ;
psrld MM1,m64[RBP] ;
psrld XMM1,XMM2 ;
psrld XMM1,m128[RBP] ;
psrld MM1,0x15 ;
psrld XMM1,0x15 ;
psrlq MM1,MM2 ;
psrlq MM1,m64[RBP] ;
psrlq XMM1,XMM2 ;
psrlq XMM1,m128[RBP] ;
psrlq MM1,0x15 ;
psrlq XMM1,0x15 ;
psubb MM1,MM2 ;
psubb MM1,m64[RBP] ;
psubb XMM1,XMM2 ;
psubb XMM1,m128[RBP] ;
psubw MM1,MM2 ;
psubw MM1,m64[RBP] ;
psubw XMM1,XMM2 ;
psubw XMM1,m128[RBP] ;
psubd MM1,MM2 ;
psubd MM1,m64[RBP] ;
psubd XMM1,XMM2 ;
psubd XMM1,m128[RBP] ;
psubq MM1,MM2 ;
psubq MM1,m64[RBP] ;
psubq XMM1,XMM2 ;
psubq XMM1,m128[RBP] ;
psubsb MM1,MM2 ;
psubsb MM1,m64[RBP] ;
psubsb XMM1,XMM2 ;
psubsb XMM1,m128[RBP] ;
psubsw MM1,MM2 ;
psubsw MM1,m64[RBP] ;
psubsw XMM1,XMM2 ;
psubsw XMM1,m128[RBP] ;
psubusb MM1,MM2 ;
psubusb MM1,m64[RBP] ;
psubusb XMM1,XMM2 ;
psubusb XMM1,m128[RBP] ;
psubusw MM1,MM2 ;
psubusw MM1,m64[RBP] ;
psubusw XMM1,XMM2 ;
psubusw XMM1,m128[RBP] ;
punpckhbw MM1,MM2 ;
punpckhbw MM1,m64[RBP] ;
punpckhbw XMM1,XMM2 ;
punpckhbw XMM1,m128[RBP] ;
punpckhwd MM1,MM2 ;
punpckhwd MM1,m64[RBP] ;
punpckhwd XMM1,XMM2 ;
punpckhwd XMM1,m128[RBP] ;
punpckhdq MM1,MM2 ;
punpckhdq MM1,m64[RBP] ;
punpckhdq XMM1,XMM2 ;
punpckhdq XMM1,m128[RBP] ;
punpckhqdq XMM1,XMM2 ;
punpckhqdq XMM1,m128[RBP] ;
punpcklbw MM1,MM2 ;
punpcklbw MM1,m64[RBP] ;
punpcklbw XMM1,XMM2 ;
punpcklbw XMM1,m128[RBP] ;
punpcklwd MM1,MM2 ;
punpcklwd MM1,m64[RBP] ;
punpcklwd XMM1,XMM2 ;
punpcklwd XMM1,m128[RBP] ;
punpckldq MM1,MM2 ;
punpckldq MM1,m64[RBP] ;
punpckldq XMM1,XMM2 ;
punpckldq XMM1,m128[RBP] ;
punpcklqdq XMM1,XMM2 ;
punpcklqdq XMM1,m128[RBP] ;
pxor MM1,MM2 ;
pxor MM1,m64[RBP] ;
pxor XMM1,XMM2 ;
pxor XMM1,m128[RBP] ;
rcpps XMM1,XMM2 ;
rcpps XMM1,m128[RBP] ;
rcpss XMM1,XMM2 ;
rcpss XMM1,m32[RBP] ;
rsqrtps XMM1,XMM2 ;
rsqrtps XMM1,m128[RBP] ;
rsqrtss XMM1,XMM2 ;
rsqrtss XMM1,m32[RBP] ;
shufpd XMM1,XMM2,3 ;
shufpd XMM1,m128[RBP],4 ;
shufps XMM1,XMM2,3 ;
shufps XMM1,m128[RBP],4 ;
ucomisd XMM4,XMM6 ;
ucomisd XMM5,m64[RBP] ;
ucomiss XMM6,XMM7 ;
ucomiss XMM7,m32[RBP] ;
unpckhpd XMM4,XMM6 ;
unpckhpd XMM5,m128[RBP] ;
unpckhps XMM4,XMM6 ;
unpckhps XMM5,m128[RBP] ;
unpcklpd XMM4,XMM6 ;
unpcklpd XMM5,m128[RBP] ;
unpcklps XMM4,XMM6 ;
unpcklps XMM5,m128[RBP] ;
xorpd XMM1,XMM2 ;
xorpd XMM1,m128[RBP] ;
xorps XMM1,XMM2 ;
xorps XMM1,m128[RBP] ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], data[i]);
assert(p[i] == data[i]);
}
}
/****************************************************/
void test15()
{
int m32;
long m64;
M128 m128;
ubyte *p;
static ubyte[] data =
[
0x0F,0x0F,0xDC,0xBF, // pavgusb MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xBF, // pavgusb MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x1D, // pf2id MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x1D, // pf2id MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xAE, // pfacc MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xAE, // pfacc MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x9E, // pfadd MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x9E, // pfadd MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xB0, // pfcmpeq MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xB0, // pfcmpeq MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x90, // pfcmpge MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x90, // pfcmpge MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xA0, // pfcmpgt MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xA0, // pfcmpgt MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xA4, // pfmax MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x94, // pfmin MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xB4, // pfmul MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xB4, // pfmul MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x8A, // pfnacc MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x8E, // pfpnacc MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x96, // pfrcp MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x96, // pfrcp MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xA6, // pfrcpit1 MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xA6, // pfrcpit1 MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xB6, // pfrcpit2 MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xB6, // pfrcpit2 MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x97, // pfrsqrt MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xA7, // pfrsqit1 MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x9A, // pfsub MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x9A, // pfsub MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xAA, // pfsubr MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xAA, // pfsubr MM3,-028h[RBP]
0x0F,0x0F,0xDC,0x0D, // pi2fd MM3,MM4
0x0F,0x0F,0x5D,0xD8,0x0D, // pi2fd MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xB7, // pmulhrw MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xB7, // pmulhrw MM3,-028h[RBP]
0x0F,0x0F,0xDC,0xBB, // pswapd MM3,MM4
0x0F,0x0F,0x5D,0xD8,0xBB, // pswapd MM3,-028h[RBP]
];
int i;
asm
{
call L1 ;
pavgusb MM3,MM4 ;
pavgusb MM3,m64[RBP] ;
pf2id MM3,MM4 ;
pf2id MM3,m64[RBP] ;
pfacc MM3,MM4 ;
pfacc MM3,m64[RBP] ;
pfadd MM3,MM4 ;
pfadd MM3,m64[RBP] ;
pfcmpeq MM3,MM4 ;
pfcmpeq MM3,m64[RBP] ;
pfcmpge MM3,MM4 ;
pfcmpge MM3,m64[RBP] ;
pfcmpgt MM3,MM4 ;
pfcmpgt MM3,m64[RBP] ;
pfmax MM3,MM4 ;
pfmin MM3,m64[RBP] ;
pfmul MM3,MM4 ;
pfmul MM3,m64[RBP] ;
pfnacc MM3,MM4 ;
pfpnacc MM3,m64[RBP] ;
pfrcp MM3,MM4 ;
pfrcp MM3,m64[RBP] ;
pfrcpit1 MM3,MM4 ;
pfrcpit1 MM3,m64[RBP] ;
pfrcpit2 MM3,MM4 ;
pfrcpit2 MM3,m64[RBP] ;
pfrsqrt MM3,MM4 ;
pfrsqit1 MM3,m64[RBP] ;
pfsub MM3,MM4 ;
pfsub MM3,m64[RBP] ;
pfsubr MM3,MM4 ;
pfsubr MM3,m64[RBP] ;
pi2fd MM3,MM4 ;
pi2fd MM3,m64[RBP] ;
pmulhrw MM3,MM4 ;
pmulhrw MM3,m64[RBP] ;
pswapd MM3,MM4 ;
pswapd MM3,m64[RBP] ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
struct S17 { char[6] x; }
__gshared S17 xx17;
void test17()
{
ubyte *p;
static ubyte[] data =
[
0x0F, 0x01, 0x10, // lgdt [EAX]
0x0F, 0x01, 0x18, // lidt [EAX]
0x0F, 0x01, 0x00, // sgdt [EAX]
0x0F, 0x01, 0x08, // sidt [EAX]
];
int i;
asm
{
call L1 ;
lgdt [RAX] ;
lidt [RAX] ;
sgdt [RAX] ;
sidt [RAX] ;
lgdt xx17 ;
lidt xx17 ;
sgdt xx17 ;
sidt xx17 ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test18()
{
ubyte *p;
static ubyte[] data =
[
0xDB, 0xF1, // fcomi ST,ST(1)
0xDB, 0xF0, // fcomi ST,ST(0)
0xDB, 0xF2, // fcomi ST,ST(2)
0xDF, 0xF1, // fcomip ST,ST(1)
0xDF, 0xF0, // fcomip ST,ST(0)
0xDF, 0xF2, // fcomip ST,ST(2)
0xDB, 0xE9, // fucomi ST,ST(1)
0xDB, 0xE8, // fucomi ST,ST(0)
0xDB, 0xEB, // fucomi ST,ST(3)
0xDF, 0xE9, // fucomip ST,ST(1)
0xDF, 0xED, // fucomip ST,ST(5)
0xDF, 0xEC, // fucomip ST,ST(4)
];
int i;
asm
{
call L1 ;
fcomi ;
fcomi ST(0) ;
fcomi ST,ST(2) ;
fcomip ;
fcomip ST(0) ;
fcomip ST,ST(2) ;
fucomi ;
fucomi ST(0) ;
fucomi ST,ST(3) ;
fucomip ;
fucomip ST(5) ;
fucomip ST,ST(4) ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
extern (C) {
void foo19() { }
}
void test19()
{ void function() fp;
ulong x;
ulong *p;
asm
{
lea RAX, qword ptr [foo19];
mov fp, RAX;
mov x, RAX;
mov p, RAX;
call fp;
}
(*fp)();
}
/****************************************************/
/+
void test20()
{
ubyte *p;
static ubyte[] data =
[
0x9B, 0xDB, 0xE0, // feni
0xDB, 0xE0, // fneni
0x9B, 0xDB, 0xE1, // fdisi
0xDB, 0xE1, // fndisi
0x9B, 0xDB, 0xE2, // fclex
0xDB, 0xE2, // fnclex
0x9B, 0xDB, 0xE3, // finit
0xDB, 0xE3, // fninit
0xDB, 0xE4, // fsetpm
];
int i;
asm
{
call L1 ;
feni ;
fneni ;
fdisi ;
fndisi ;
finit ;
fninit ;
fclex ;
fnclex ;
finit ;
fninit ;
fsetpm ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
+/
/****************************************************/
void test21()
{
ubyte *p;
static ubyte[] data =
[
0xE4, 0x06, // in AL,6
0x66, 0xE5, 0x07, // in AX,7
0xE5, 0x08, // in EAX,8
0xEC, // in AL,DX
0x66, 0xED, // in AX,DX
0xED, // in EAX,DX
0xE6, 0x06, // out 6,AL
0x66, 0xE7, 0x07, // out 7,AX
0xE7, 0x08, // out 8,EAX
0xEE, // out DX,AL
0x66, 0xEF, // out DX,AX
0xEF, // out DX,EAX
];
int i;
asm
{
call L1 ;
in AL,6 ;
in AX,7 ;
in EAX,8 ;
in AL,DX ;
in AX,DX ;
in EAX,DX ;
out 6,AL ;
out 7,AX ;
out 8,EAX ;
out DX,AL ;
out DX,AX ;
out DX,EAX ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test22()
{
ubyte *p;
static ubyte[] data =
[
0x0F, 0xC7, 0x4D, 0xE0, // cmpxchg8b
0x48, 0x0F, 0xC7, 0x4D, 0xF0, // cmpxchg16b
0x40, 0x0F, 0xB0, 0x3A // cmpxchg [RDX],DIL
];
int i;
M64 m64;
M128 m128;
asm
{
call L1 ;
cmpxchg8b m64 ;
cmpxchg16b m128 ;
cmpxchg [RDX],DIL ;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test23()
{
short m16;
int m32;
long m64;
M128 m128;
ubyte *p;
static ubyte[] data =
[
0xD9, 0xC9, // fxch ST(1), ST(0)
0xDF, 0x5D, 0xD0, // fistp word ptr -030h[RBP]
0xDB, 0x5D, 0xD4, // fistp dword ptr -02Ch[RBP]
0xDF, 0x7D, 0xD8, // fistp long64 ptr -028h[RBP]
0xDF, 0x4D, 0xD0, // fisttp short ptr -030h[RBP]
0xDB, 0x4D, 0xD4, // fisttp word ptr -02Ch[RBP]
0xDD, 0x4D, 0xD8, // fisttp long64 ptr -028h[RBP]
0x0F, 0x01, 0xC8, // monitor
0x0F, 0x01, 0xC9, // mwait
0x0F, 0x01, 0xD0, // xgetbv
0x66, 0x0F, 0xD0, 0xCA, // addsubpd XMM1,XMM2
0x66, 0x0F, 0xD0, 0x4D, 0xE0, // addsubpd XMM1,-020h[RBP]
0xF2, 0x0F, 0xD0, 0xCA, // addsubps XMM1,XMM2
0xF2, 0x0F, 0xD0, 0x4D, 0xE0, // addsubps XMM1,-020h[RBP]
0x66, 0x0F, 0x7C, 0xCA, // haddpd XMM1,XMM2
0x66, 0x0F, 0x7C, 0x4D, 0xE0, // haddpd XMM1,-020h[RBP]
0xF2, 0x0F, 0x7C, 0xCA, // haddps XMM1,XMM2
0xF2, 0x0F, 0x7C, 0x4D, 0xE0, // haddps XMM1,-020h[RBP]
0x66, 0x0F, 0x7D, 0xCA, // hsubpd XMM1,XMM2
0x66, 0x0F, 0x7D, 0x4D, 0xE0, // hsubpd XMM1,-020h[RBP]
0xF2, 0x0F, 0x7D, 0xCA, // hsubps XMM1,XMM2
0xF2, 0x0F, 0x7D, 0x4D, 0xE0, // hsubps XMM1,-020h[RBP]
0xF2, 0x0F, 0xF0, 0x4D, 0xE0, // lddqu XMM1,-020h[RBP]
0xF2, 0x0F, 0x12, 0xCA, // movddup XMM1,XMM2
0xF2, 0x0F, 0x12, 0x4D, 0xD8, // movddup XMM1,-028h[RBP]
0xF3, 0x0F, 0x16, 0xCA, // movshdup XMM1,XMM2
0xF3, 0x0F, 0x16, 0x4D, 0xE0, // movshdup XMM1,-020h[RBP]
0xF3, 0x0F, 0x12, 0xCA, // movsldup XMM1,XMM2
0xF3, 0x0F, 0x12, 0x4D, 0xE0, // movsldup XMM1,-020h[RBP]
];
int i;
asm
{
call L1 ;
fxch ST(1), ST(0) ;
fistp m16[RBP] ;
fistp m32[RBP] ;
fistp m64[RBP] ;
fisttp m16[RBP] ;
fisttp m32[RBP] ;
fisttp m64[RBP] ;
monitor ;
mwait ;
xgetbv ;
addsubpd XMM1,XMM2 ;
addsubpd XMM1,m128[RBP] ;
addsubps XMM1,XMM2 ;
addsubps XMM1,m128[RBP] ;
haddpd XMM1,XMM2 ;
haddpd XMM1,m128[RBP] ;
haddps XMM1,XMM2 ;
haddps XMM1,m128[RBP] ;
hsubpd XMM1,XMM2 ;
hsubpd XMM1,m128[RBP] ;
hsubps XMM1,XMM2 ;
hsubps XMM1,m128[RBP] ;
lddqu XMM1,m128[RBP] ;
movddup XMM1,XMM2 ;
movddup XMM1,m64[RBP] ;
movshdup XMM1,XMM2 ;
movshdup XMM1,m128[RBP] ;
movsldup XMM1,XMM2 ;
movsldup XMM1,m128[RBP] ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test24()
{
ushort i;
asm
{
lea AX, i;
mov i, AX;
}
assert(cast(ushort)&i == i);
}
/****************************************************/
void test25()
{
short m16;
int m32;
long m64;
M128 m128;
ubyte *p;
static ubyte[] data =
[
0x66, 0x0F, 0x7E, 0xC1, // movd ECX,XMM0
0x66, 0x0F, 0x7E, 0xC9, // movd ECX,XMM1
0x66, 0x0F, 0x7E, 0xD1, // movd ECX,XMM2
0x66, 0x0F, 0x7E, 0xD9, // movd ECX,XMM3
0x66, 0x0F, 0x7E, 0xE1, // movd ECX,XMM4
0x66, 0x0F, 0x7E, 0xE9, // movd ECX,XMM5
0x66, 0x0F, 0x7E, 0xF1, // movd ECX,XMM6
0x66, 0x0F, 0x7E, 0xF9, // movd ECX,XMM7
0x0F, 0x7E, 0xC1, // movd ECX,MM0
0x0F, 0x7E, 0xC9, // movd ECX,MM1
0x0F, 0x7E, 0xD1, // movd ECX,MM2
0x0F, 0x7E, 0xD9, // movd ECX,MM3
0x0F, 0x7E, 0xE1, // movd ECX,MM4
0x0F, 0x7E, 0xE9, // movd ECX,MM5
0x0F, 0x7E, 0xF1, // movd ECX,MM6
0x0F, 0x7E, 0xF9, // movd ECX,MM7
0x66, 0x0F, 0x6E, 0xC1, // movd XMM0,ECX
0x66, 0x0F, 0x6E, 0xC9, // movd XMM1,ECX
0x66, 0x0F, 0x6E, 0xD1, // movd XMM2,ECX
0x66, 0x0F, 0x6E, 0xD9, // movd XMM3,ECX
0x66, 0x0F, 0x6E, 0xE1, // movd XMM4,ECX
0x66, 0x0F, 0x6E, 0xE9, // movd XMM5,ECX
0x66, 0x0F, 0x6E, 0xF1, // movd XMM6,ECX
0x66, 0x0F, 0x6E, 0xF9, // movd XMM7,ECX
0x0F, 0x6E, 0xC1, // movd MM0,ECX
0x0F, 0x6E, 0xC9, // movd MM1,ECX
0x0F, 0x6E, 0xD1, // movd MM2,ECX
0x0F, 0x6E, 0xD9, // movd MM3,ECX
0x0F, 0x6E, 0xE1, // movd MM4,ECX
0x0F, 0x6E, 0xE9, // movd MM5,ECX
0x0F, 0x6E, 0xF1, // movd MM6,ECX
0x0F, 0x6E, 0xF9, // movd MM7,ECX
0x66, 0x0F, 0x7E, 0xC8, // movd EAX,XMM1
0x66, 0x0F, 0x7E, 0xCB, // movd EBX,XMM1
0x66, 0x0F, 0x7E, 0xC9, // movd ECX,XMM1
0x66, 0x0F, 0x7E, 0xCA, // movd EDX,XMM1
0x66, 0x0F, 0x7E, 0xCE, // movd ESI,XMM1
0x66, 0x0F, 0x7E, 0xCF, // movd EDI,XMM1
0x66, 0x0F, 0x7E, 0xCD, // movd EBP,XMM1
0x66, 0x0F, 0x7E, 0xCC, // movd ESP,XMM1
0x0F, 0x7E, 0xC8, // movd EAX,MM1
0x0F, 0x7E, 0xCB, // movd EBX,MM1
0x0F, 0x7E, 0xC9, // movd ECX,MM1
0x0F, 0x7E, 0xCA, // movd EDX,MM1
0x0F, 0x7E, 0xCE, // movd ESI,MM1
0x0F, 0x7E, 0xCF, // movd EDI,MM1
0x0F, 0x7E, 0xCD, // movd EBP,MM1
0x0F, 0x7E, 0xCC, // movd ESP,MM1
0x66, 0x0F, 0x6E, 0xC8, // movd XMM1,EAX
0x66, 0x0F, 0x6E, 0xCB, // movd XMM1,EBX
0x66, 0x0F, 0x6E, 0xC9, // movd XMM1,ECX
0x66, 0x0F, 0x6E, 0xCA, // movd XMM1,EDX
0x66, 0x0F, 0x6E, 0xCE, // movd XMM1,ESI
0x66, 0x0F, 0x6E, 0xCF, // movd XMM1,EDI
0x66, 0x0F, 0x6E, 0xCD, // movd XMM1,EBP
0x66, 0x0F, 0x6E, 0xCC, // movd XMM1,ESP
0x0F, 0x6E, 0xC8, // movd MM1,EAX
0x0F, 0x6E, 0xCB, // movd MM1,EBX
0x0F, 0x6E, 0xC9, // movd MM1,ECX
0x0F, 0x6E, 0xCA, // movd MM1,EDX
0x0F, 0x6E, 0xCE, // movd MM1,ESI
0x0F, 0x6E, 0xCF, // movd MM1,EDI
0x0F, 0x6E, 0xCD, // movd MM1,EBP
0x0F, 0x6E, 0xCC, // movd MM1,ESP
];
int i;
asm
{
call L1 ;
movd ECX, XMM0;
movd ECX, XMM1;
movd ECX, XMM2;
movd ECX, XMM3;
movd ECX, XMM4;
movd ECX, XMM5;
movd ECX, XMM6;
movd ECX, XMM7;
movd ECX, MM0;
movd ECX, MM1;
movd ECX, MM2;
movd ECX, MM3;
movd ECX, MM4;
movd ECX, MM5;
movd ECX, MM6;
movd ECX, MM7;
movd XMM0, ECX;
movd XMM1, ECX;
movd XMM2, ECX;
movd XMM3, ECX;
movd XMM4, ECX;
movd XMM5, ECX;
movd XMM6, ECX;
movd XMM7, ECX;
movd MM0, ECX;
movd MM1, ECX;
movd MM2, ECX;
movd MM3, ECX;
movd MM4, ECX;
movd MM5, ECX;
movd MM6, ECX;
movd MM7, ECX;
movd EAX, XMM1;
movd EBX, XMM1;
movd ECX, XMM1;
movd EDX, XMM1;
movd ESI, XMM1;
movd EDI, XMM1;
movd EBP, XMM1;
movd ESP, XMM1;
movd EAX, MM1;
movd EBX, MM1;
movd ECX, MM1;
movd EDX, MM1;
movd ESI, MM1;
movd EDI, MM1;
movd EBP, MM1;
movd ESP, MM1;
movd XMM1, EAX;
movd XMM1, EBX;
movd XMM1, ECX;
movd XMM1, EDX;
movd XMM1, ESI;
movd XMM1, EDI;
movd XMM1, EBP;
movd XMM1, ESP;
movd MM1, EAX;
movd MM1, EBX;
movd MM1, ECX;
movd MM1, EDX;
movd MM1, ESI;
movd MM1, EDI;
movd MM1, EBP;
movd MM1, ESP;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void fn26(ref byte val)
{
asm
{
mov RAX, val;
inc byte ptr [RAX];
}
}
void test26()
{
byte b;
//printf( "%i\n", b );
assert(b == 0);
fn26(b);
//printf( "%i\n", b );
assert(b == 1);
}
/****************************************************/
void test27()
{
static const ubyte[16] a =
[0, 1, 2, 3, 4, 5, 6, 7, 8 ,9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF];
version (Windows)
{
asm
{
movdqu XMM0, a;
pslldq XMM0, 2;
}
}
}
/****************************************************/
/*
PASS:
cfloat z;
cfloat[1] z;
double z;
double[1] b;
long z;
long[1] z;
FAIL: (bad type/size of operands 'movq')
byte[8] z;
char[8] z;
dchar[2] z;
float[2] z;
int[2] z;
short[4] z;
wchar[4] z;
XPASS: (too small, but accecpted by DMD)
cfloat[0] z;
double[0] z;
long[0] z;
*/
void test28()
{
// version (Windows)
// {
c_complex_float[4] z = void;
static const ubyte[8] A = [3, 4, 9, 0, 1, 3, 7, 2];
ubyte[8] b;
asm{
movq MM0, z;
movq MM0, A;
movq b, MM0;
}
for(size_t i = 0; i < A.length; i++)
{
if(A[i] != b[i])
{
assert(0);
}
}
// }
}
/****************************************************/
/+
shared int[5] bar29 = [3, 4, 5, 6, 7];
void test29()
{
int* x;
asm
{
push offsetof bar29;
pop EAX;
mov x, EAX;
}
assert(*x == 3);
asm
{
mov EAX, offsetof bar29;
mov x, EAX;
}
assert(*x == 3);
}
+/
/****************************************************/
const int CONST_OFFSET30 = 10;
void foo30()
{
asm
{
mov EDX, 10;
mov EAX, [RDX + CONST_OFFSET30];
}
}
void test30()
{
}
/****************************************************/
void test31()
{
ubyte *p;
static ubyte[] data =
[
0xF7, 0xD8, // neg EAX
0x74, 0x04, // je L8
0xF7, 0xD8, // neg EAX
0x75, 0xFC, // jne L4
0xFF, 0xC0, // inc EAX
];
int i;
asm
{
call L1 ;
neg EAX;
je L2;
L3:
neg EAX;
jne L3;
L2:
inc EAX;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void infiniteAsmLoops()
{
/* This crashes DMD 0.162: */
for (;;) asm { inc EAX; }
/* It doesn't seem to matter what you use. These all crash: */
//for (;;) asm { mov EAX, EBX; }
//for (;;) asm { xor EAX, EAX; }
//for (;;) asm { push 0; pop RAX; }
//for (;;) asm { jmp infiniteAsmLoops; }
/* This is a workaround: */
for (bool a = true; a;) asm { hlt; } // compiles
/* But this isn't: */
//for (const bool a = true; a;) asm{ hlt; } // crashes DMD
/* It's not restricted to for-statements: */
//while(1) asm { hlt; } // crashes DMD
/* This compiles: */
{
bool a = true;
while(a) asm { hlt; }
}
/* But again, this doesn't: */
/*
{
const bool a = true; // note the const
while(a) asm { hlt; }
}
//*/
//do { asm { hlt; } } while (1); // crashes DMD
/* This, of course, compiles: */
{
bool a = true;
do asm { hlt; } while (a);
}
/* But predicably, this doesn't: */
/*
{
const bool a = true;
do asm { hlt; } while (a);
}
//**/
/* Not even hand-coding the loop works: */
/*
{
label:
asm { hlt; } // commenting out this line to make it compile
goto label;
}
//*/
/* Unless you go all the way: (i.e. this compiles) */
asm
{
L1:
hlt;
jmp L1;
}
/* or like this (also compiles): */
static void test()
{
asm { naked; hlt; jmp test; }
}
test();
/* Wait... it gets weirder: */
/* This also doesn't compile: */
/*
for (;;)
{
printf("\n");
asm { hlt; }
}
//*/
/* But this does: */
//*
for (;;)
{
asm { hlt; }
printf("\n");
}
//*/
/* The same loop that doesn't compile above
* /does/ compile after previous one:
*/
//*
for (;;)
{
printf("\n");
asm { hlt; }
}
//*/
/* Note: this one is at the end because it seems to also trigger the
* "now it works" event of the loop above.
*/
/* There has to be /something/ in that asm block: */
for (;;) asm {} // compiles
}
void test32()
{
}
/****************************************************/
void test33()
{
int x = 1;
alias x y;
asm
{
mov EAX, x;
mov EAX, y;
}
}
/****************************************************/
int test34()
{
asm{
jmp label;
}
return 0;
label:
return 1;
}
/****************************************************/
/+
void foo35() { printf("hello\n"); }
void test35()
{
void function() p;
ulong q;
asm
{
mov ECX, foo35 ;
mov q, ECX ;
lea EDX, foo35 ;
mov p, EDX ;
}
assert(p == &foo35);
assert(q == *cast(ulong *)p);
}
/****************************************************/
void func36()
{
}
int test36()
{
void* a = &func36;
ulong* b = cast(ulong*) a;
ulong f = *b;
ulong g;
asm{
mov RAX, func36;
mov g, RAX;
}
if(f != g){
assert(0);
}
}
+/
/****************************************************/
void a37(X...)(X expr)
{
alias expr[0] var1;
asm {
fld double ptr expr[0];
fstp double ptr var1;
}
}
void test37()
{
a37(3.6);
}
/****************************************************/
int f38(X...)(X x)
{
asm {
mov EAX, int ptr x[1];
}
}
int g38(X...)(X x)
{
asm {
mov EAX, x[1];
}
}
void test38()
{
assert(456 == f38(123, 456));
assert(456 == g38(123, 456));
}
/****************************************************/
void test39()
{
const byte z = 35;
goto end;
asm { db z; }
end: ;
}
/****************************************************/
void test40()
{
printf("");
const string s = "abcdefghi";
asm
{ jmp L1;
ds s;
L1:;
}
end: ;
}
/****************************************************/
void test41()
{
ubyte *p;
static ubyte[] data =
[
0x66,0x0F,0x28,0x0C,0x06, // movapd XMM1,[RAX][RSI]
0x66,0x0F,0x28,0x0C,0x06, // movapd XMM1,[RAX][RSI]
0x66,0x0F,0x28,0x0C,0x46, // movapd XMM1,[RAX*2][RSI]
0x66,0x0F,0x28,0x0C,0x86, // movapd XMM1,[RAX*4][RSI]
0x66,0x0F,0x28,0x0C,0xC6, // movapd XMM1,[RAX*8][RSI]
];
int i;
asm
{
call L1 ;
movapd XMM1, [RSI+RAX];
movapd XMM1, [RSI+1*RAX];
movapd XMM1, [RSI+2*RAX];
movapd XMM1, [RSI+4*RAX];
movapd XMM1, [RSI+8*RAX];
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
enum
{
enumeration42 = 1,
}
void test42()
{
asm
{
mov EAX, enumeration42;
}
}
/****************************************************/
void foo43()
{
asm {lea EAX, [0*4+EAX]; }
asm {lea EAX, [4*0+EAX]; }
asm {lea EAX, [EAX+4*0]; }
asm {lea EAX, [0+EAX]; }
asm {lea EAX, [7*7+EAX]; }
}
void test43()
{
}
/****************************************************/
enum n1 = 42;
enum { n2 = 42 }
uint retN1() {
asm {
mov EAX,n1; // No! - mov EAX,-4[EBP]
}
}
uint retN2() {
asm {
mov EAX,n2; // OK - mov EAX,02Ah
}
}
void test44()
{
assert(retN1() == 42);
assert(retN2() == 42);
}
/****************************************************/
void test45()
{
ubyte *p;
static ubyte[] data =
[
0xDA, 0xC0, // fcmovb ST(0)
0xDA, 0xC1, // fcmovb
0xDA, 0xCA, // fcmove ST(2)
0xDA, 0xD3, // fcmovbe ST(3)
0xDA, 0xDC, // fcmovu ST(4)
0xDB, 0xC5, // fcmovnb ST(5)
0xDB, 0xCE, // fcmovne ST(6)
0xDB, 0xD7, // fcmovnbe ST(7)
0xDB, 0xD9, // fcmovnu
];
int i;
asm
{
call L1 ;
fcmovb ST, ST(0);
fcmovb ST, ST(1);
fcmove ST, ST(2);
fcmovbe ST, ST(3);
fcmovu ST, ST(4);
fcmovnb ST, ST(5);
fcmovne ST, ST(6);
fcmovnbe ST, ST(7);
fcmovnu ST, ST(1);
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test46()
{
ubyte *p;
static ubyte[] data =
[
0x66, 0x0F, 0x3A, 0x41, 0xCA, 0x08, // dppd XMM1,XMM2,8
0x66, 0x0F, 0x3A, 0x40, 0xDC, 0x07, // dpps XMM3,XMM4,7
0x66, 0x0F, 0x50, 0xF3, // movmskpd ESI,XMM3
0x66, 0x0F, 0x50, 0xC7, // movmskpd EAX,XMM7
0x0F, 0x50, 0xC7, // movmskps EAX,XMM7
0x0F, 0xD7, 0xC7, // pmovmskb EAX,MM7
0x66, 0x0F, 0xD7, 0xC7, // pmovmskb EAX,XMM7
];
int i;
asm
{
call L1 ;
dppd XMM1,XMM2,8 ;
dpps XMM3,XMM4,7 ;
movmskpd ESI,XMM3 ;
movmskpd EAX,XMM7 ;
movmskps EAX,XMM7 ;
pmovmskb EAX,MM7 ;
pmovmskb EAX,XMM7 ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
/+
struct Foo47
{
float x,y;
}
void bar47(Foo47 f)
{
int i;
asm
{
mov EAX, offsetof f;
mov i, EAX;
}
printf("%d\n",i);
assert(i == 8);
}
void test47()
{
Foo47 f;
bar47(f);
}
+/
/****************************************************/
void func48(void delegate () callback)
{
callback();
}
void test48()
{
func48(() { asm{ mov EAX,EAX; } });
}
/****************************************************/
void test49()
{
ubyte *p;
static ubyte[] data =
[
0x00, 0xC0, // add AL,AL
0x00, 0xD8, // add AL,BL
0x00, 0xC8, // add AL,CL
0x00, 0xD0, // add AL,DL
0x00, 0xE0, // add AL,AH
0x00, 0xF8, // add AL,BH
0x00, 0xE8, // add AL,CH
0x00, 0xF0, // add AL,DH
0x00, 0xC4, // add AH,AL
0x00, 0xDC, // add AH,BL
0x00, 0xCC, // add AH,CL
0x00, 0xD4, // add AH,DL
0x00, 0xE4, // add AH,AH
0x00, 0xFC, // add AH,BH
0x00, 0xEC, // add AH,CH
0x00, 0xF4, // add AH,DH
0x00, 0xC3, // add BL,AL
0x00, 0xDB, // add BL,BL
0x00, 0xCB, // add BL,CL
0x00, 0xD3, // add BL,DL
0x00, 0xE3, // add BL,AH
0x00, 0xFB, // add BL,BH
0x00, 0xEB, // add BL,CH
0x00, 0xF3, // add BL,DH
0x00, 0xC7, // add BH,AL
0x00, 0xDF, // add BH,BL
0x00, 0xCF, // add BH,CL
0x00, 0xD7, // add BH,DL
0x00, 0xE7, // add BH,AH
0x00, 0xFF, // add BH,BH
0x00, 0xEF, // add BH,CH
0x00, 0xF7, // add BH,DH
0x00, 0xC1, // add CL,AL
0x00, 0xD9, // add CL,BL
0x00, 0xC9, // add CL,CL
0x00, 0xD1, // add CL,DL
0x00, 0xE1, // add CL,AH
0x00, 0xF9, // add CL,BH
0x00, 0xE9, // add CL,CH
0x00, 0xF1, // add CL,DH
0x00, 0xC5, // add CH,AL
0x00, 0xDD, // add CH,BL
0x00, 0xCD, // add CH,CL
0x00, 0xD5, // add CH,DL
0x00, 0xE5, // add CH,AH
0x00, 0xFD, // add CH,BH
0x00, 0xED, // add CH,CH
0x00, 0xF5, // add CH,DH
0x00, 0xC2, // add DL,AL
0x00, 0xDA, // add DL,BL
0x00, 0xCA, // add DL,CL
0x00, 0xD2, // add DL,DL
0x00, 0xE2, // add DL,AH
0x00, 0xFA, // add DL,BH
0x00, 0xEA, // add DL,CH
0x00, 0xF2, // add DL,DH
0x00, 0xC6, // add DH,AL
0x00, 0xDE, // add DH,BL
0x00, 0xCE, // add DH,CL
0x00, 0xD6, // add DH,DL
0x00, 0xE6, // add DH,AH
0x00, 0xFE, // add DH,BH
0x00, 0xEE, // add DH,CH
0x00, 0xF6, // add DH,DH
0x66, 0x01, 0xC0, // add AX,AX
0x66, 0x01, 0xD8, // add AX,BX
0x66, 0x01, 0xC8, // add AX,CX
0x66, 0x01, 0xD0, // add AX,DX
0x66, 0x01, 0xF0, // add AX,SI
0x66, 0x01, 0xF8, // add AX,DI
0x66, 0x01, 0xE8, // add AX,BP
0x66, 0x01, 0xE0, // add AX,SP
0x66, 0x01, 0xC3, // add BX,AX
0x66, 0x01, 0xDB, // add BX,BX
0x66, 0x01, 0xCB, // add BX,CX
0x66, 0x01, 0xD3, // add BX,DX
0x66, 0x01, 0xF3, // add BX,SI
0x66, 0x01, 0xFB, // add BX,DI
0x66, 0x01, 0xEB, // add BX,BP
0x66, 0x01, 0xE3, // add BX,SP
0x66, 0x01, 0xC1, // add CX,AX
0x66, 0x01, 0xD9, // add CX,BX
0x66, 0x01, 0xC9, // add CX,CX
0x66, 0x01, 0xD1, // add CX,DX
0x66, 0x01, 0xF1, // add CX,SI
0x66, 0x01, 0xF9, // add CX,DI
0x66, 0x01, 0xE9, // add CX,BP
0x66, 0x01, 0xE1, // add CX,SP
0x66, 0x01, 0xC2, // add DX,AX
0x66, 0x01, 0xDA, // add DX,BX
0x66, 0x01, 0xCA, // add DX,CX
0x66, 0x01, 0xD2, // add DX,DX
0x66, 0x01, 0xF2, // add DX,SI
0x66, 0x01, 0xFA, // add DX,DI
0x66, 0x01, 0xEA, // add DX,BP
0x66, 0x01, 0xE2, // add DX,SP
0x66, 0x01, 0xC6, // add SI,AX
0x66, 0x01, 0xDE, // add SI,BX
0x66, 0x01, 0xCE, // add SI,CX
0x66, 0x01, 0xD6, // add SI,DX
0x66, 0x01, 0xF6, // add SI,SI
0x66, 0x01, 0xFE, // add SI,DI
0x66, 0x01, 0xEE, // add SI,BP
0x66, 0x01, 0xE6, // add SI,SP
0x66, 0x01, 0xC7, // add DI,AX
0x66, 0x01, 0xDF, // add DI,BX
0x66, 0x01, 0xCF, // add DI,CX
0x66, 0x01, 0xD7, // add DI,DX
0x66, 0x01, 0xF7, // add DI,SI
0x66, 0x01, 0xFF, // add DI,DI
0x66, 0x01, 0xEF, // add DI,BP
0x66, 0x01, 0xE7, // add DI,SP
0x66, 0x01, 0xC5, // add BP,AX
0x66, 0x01, 0xDD, // add BP,BX
0x66, 0x01, 0xCD, // add BP,CX
0x66, 0x01, 0xD5, // add BP,DX
0x66, 0x01, 0xF5, // add BP,SI
0x66, 0x01, 0xFD, // add BP,DI
0x66, 0x01, 0xED, // add BP,BP
0x66, 0x01, 0xE5, // add BP,SP
0x66, 0x01, 0xC4, // add SP,AX
0x66, 0x01, 0xDC, // add SP,BX
0x66, 0x01, 0xCC, // add SP,CX
0x66, 0x01, 0xD4, // add SP,DX
0x66, 0x01, 0xF4, // add SP,SI
0x66, 0x01, 0xFC, // add SP,DI
0x66, 0x01, 0xEC, // add SP,BP
0x66, 0x01, 0xE4, // add SP,SP
0x01, 0xC0, // add EAX,EAX
0x01, 0xD8, // add EAX,EBX
0x01, 0xC8, // add EAX,ECX
0x01, 0xD0, // add EAX,EDX
0x01, 0xF0, // add EAX,ESI
0x01, 0xF8, // add EAX,EDI
0x01, 0xE8, // add EAX,EBP
0x01, 0xE0, // add EAX,ESP
0x01, 0xC3, // add EBX,EAX
0x01, 0xDB, // add EBX,EBX
0x01, 0xCB, // add EBX,ECX
0x01, 0xD3, // add EBX,EDX
0x01, 0xF3, // add EBX,ESI
0x01, 0xFB, // add EBX,EDI
0x01, 0xEB, // add EBX,EBP
0x01, 0xE3, // add EBX,ESP
0x01, 0xC1, // add ECX,EAX
0x01, 0xD9, // add ECX,EBX
0x01, 0xC9, // add ECX,ECX
0x01, 0xD1, // add ECX,EDX
0x01, 0xF1, // add ECX,ESI
0x01, 0xF9, // add ECX,EDI
0x01, 0xE9, // add ECX,EBP
0x01, 0xE1, // add ECX,ESP
0x01, 0xC2, // add EDX,EAX
0x01, 0xDA, // add EDX,EBX
0x01, 0xCA, // add EDX,ECX
0x01, 0xD2, // add EDX,EDX
0x01, 0xF2, // add EDX,ESI
0x01, 0xFA, // add EDX,EDI
0x01, 0xEA, // add EDX,EBP
0x01, 0xE2, // add EDX,ESP
0x01, 0xC6, // add ESI,EAX
0x01, 0xDE, // add ESI,EBX
0x01, 0xCE, // add ESI,ECX
0x01, 0xD6, // add ESI,EDX
0x01, 0xF6, // add ESI,ESI
0x01, 0xFE, // add ESI,EDI
0x01, 0xEE, // add ESI,EBP
0x01, 0xE6, // add ESI,ESP
0x01, 0xC7, // add EDI,EAX
0x01, 0xDF, // add EDI,EBX
0x01, 0xCF, // add EDI,ECX
0x01, 0xD7, // add EDI,EDX
0x01, 0xF7, // add EDI,ESI
0x01, 0xFF, // add EDI,EDI
0x01, 0xEF, // add EDI,EBP
0x01, 0xE7, // add EDI,ESP
0x01, 0xC5, // add EBP,EAX
0x01, 0xDD, // add EBP,EBX
0x01, 0xCD, // add EBP,ECX
0x01, 0xD5, // add EBP,EDX
0x01, 0xF5, // add EBP,ESI
0x01, 0xFD, // add EBP,EDI
0x01, 0xED, // add EBP,EBP
0x01, 0xE5, // add EBP,ESP
0x01, 0xC4, // add ESP,EAX
0x01, 0xDC, // add ESP,EBX
0x01, 0xCC, // add ESP,ECX
0x01, 0xD4, // add ESP,EDX
0x01, 0xF4, // add ESP,ESI
0x01, 0xFC, // add ESP,EDI
0x01, 0xEC, // add ESP,EBP
0x01, 0xE4, // add ESP,ESP
];
int i;
asm
{
call L1 ;
add AL,AL ;
add AL,BL ;
add AL,CL ;
add AL,DL ;
add AL,AH ;
add AL,BH ;
add AL,CH ;
add AL,DH ;
add AH,AL ;
add AH,BL ;
add AH,CL ;
add AH,DL ;
add AH,AH ;
add AH,BH ;
add AH,CH ;
add AH,DH ;
add BL,AL ;
add BL,BL ;
add BL,CL ;
add BL,DL ;
add BL,AH ;
add BL,BH ;
add BL,CH ;
add BL,DH ;
add BH,AL ;
add BH,BL ;
add BH,CL ;
add BH,DL ;
add BH,AH ;
add BH,BH ;
add BH,CH ;
add BH,DH ;
add CL,AL ;
add CL,BL ;
add CL,CL ;
add CL,DL ;
add CL,AH ;
add CL,BH ;
add CL,CH ;
add CL,DH ;
add CH,AL ;
add CH,BL ;
add CH,CL ;
add CH,DL ;
add CH,AH ;
add CH,BH ;
add CH,CH ;
add CH,DH ;
add DL,AL ;
add DL,BL ;
add DL,CL ;
add DL,DL ;
add DL,AH ;
add DL,BH ;
add DL,CH ;
add DL,DH ;
add DH,AL ;
add DH,BL ;
add DH,CL ;
add DH,DL ;
add DH,AH ;
add DH,BH ;
add DH,CH ;
add DH,DH ;
add AX,AX ;
add AX,BX ;
add AX,CX ;
add AX,DX ;
add AX,SI ;
add AX,DI ;
add AX,BP ;
add AX,SP ;
add BX,AX ;
add BX,BX ;
add BX,CX ;
add BX,DX ;
add BX,SI ;
add BX,DI ;
add BX,BP ;
add BX,SP ;
add CX,AX ;
add CX,BX ;
add CX,CX ;
add CX,DX ;
add CX,SI ;
add CX,DI ;
add CX,BP ;
add CX,SP ;
add DX,AX ;
add DX,BX ;
add DX,CX ;
add DX,DX ;
add DX,SI ;
add DX,DI ;
add DX,BP ;
add DX,SP ;
add SI,AX ;
add SI,BX ;
add SI,CX ;
add SI,DX ;
add SI,SI ;
add SI,DI ;
add SI,BP ;
add SI,SP ;
add DI,AX ;
add DI,BX ;
add DI,CX ;
add DI,DX ;
add DI,SI ;
add DI,DI ;
add DI,BP ;
add DI,SP ;
add BP,AX ;
add BP,BX ;
add BP,CX ;
add BP,DX ;
add BP,SI ;
add BP,DI ;
add BP,BP ;
add BP,SP ;
add SP,AX ;
add SP,BX ;
add SP,CX ;
add SP,DX ;
add SP,SI ;
add SP,DI ;
add SP,BP ;
add SP,SP ;
add EAX,EAX ;
add EAX,EBX ;
add EAX,ECX ;
add EAX,EDX ;
add EAX,ESI ;
add EAX,EDI ;
add EAX,EBP ;
add EAX,ESP ;
add EBX,EAX ;
add EBX,EBX ;
add EBX,ECX ;
add EBX,EDX ;
add EBX,ESI ;
add EBX,EDI ;
add EBX,EBP ;
add EBX,ESP ;
add ECX,EAX ;
add ECX,EBX ;
add ECX,ECX ;
add ECX,EDX ;
add ECX,ESI ;
add ECX,EDI ;
add ECX,EBP ;
add ECX,ESP ;
add EDX,EAX ;
add EDX,EBX ;
add EDX,ECX ;
add EDX,EDX ;
add EDX,ESI ;
add EDX,EDI ;
add EDX,EBP ;
add EDX,ESP ;
add ESI,EAX ;
add ESI,EBX ;
add ESI,ECX ;
add ESI,EDX ;
add ESI,ESI ;
add ESI,EDI ;
add ESI,EBP ;
add ESI,ESP ;
add EDI,EAX ;
add EDI,EBX ;
add EDI,ECX ;
add EDI,EDX ;
add EDI,ESI ;
add EDI,EDI ;
add EDI,EBP ;
add EDI,ESP ;
add EBP,EAX ;
add EBP,EBX ;
add EBP,ECX ;
add EBP,EDX ;
add EBP,ESI ;
add EBP,EDI ;
add EBP,EBP ;
add EBP,ESP ;
add ESP,EAX ;
add ESP,EBX ;
add ESP,ECX ;
add ESP,EDX ;
add ESP,ESI ;
add ESP,EDI ;
add ESP,EBP ;
add ESP,ESP ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test50()
{
ubyte *p;
static ubyte[] data =
[
0x66, 0x98, // cbw
0xF8, // clc
0xFC, // cld
0xFA, // cli
0xF5, // cmc
0xA6, // cmpsb
0x66, 0xA7, // cmpsw
0xA7, // cmpsd
0x66, 0x99, // cwd
// 0x27, // daa
// 0x2F, // das
0xFF, 0xC8, // dec EAX
0xF6, 0xF1, // div CL
0x66, 0xF7, 0xF3, // div BX
0xF7, 0xF2, // div EDX
0xF4, // hlt
0xF6, 0xFB, // idiv BL
0x66, 0xF7, 0xFA, // idiv DX
0xF7, 0xFE, // idiv ESI
0xF6, 0xEB, // imul BL
0x66, 0xF7, 0xEA, // imul DX
0xF7, 0xEE, // imul ESI
0xEC, // in AL,DX
0x66, 0xED, // in AX,DX
0xFF, 0xC3, // inc EBX
0xCC, // int 3
0xCD, 0x67, // int 067h
// 0xCE, // into
0x66, 0xCF, // iret
0x48, 0xCF, // iretq
0x90, 0x90, // nop;nop - put instructions above this or L10 changes
// address, which changes all the jump
// instructions and breaks the test case.
0x77, 0xFC, // ja L30
0x77, 0xFA, // ja L30
0x73, 0xF8, // jae L30
0x73, 0xF6, // jae L30
0x73, 0xF4, // jae L30
0x72, 0xF2, // jb L30
0x72, 0xF0, // jb L30
0x76, 0xEE, // jbe L30
0x76, 0xEC, // jbe L30
0x72, 0xEA, // jb L30
// 0x67, 0xE3, 0xE7, // jcxz L30
0x90, 0x90, 0x90, // nop;nop;nop
0x74, 0xE5, // je L30
0x74, 0xE3, // je L30
0x7F, 0xE1, // jg L30
0x7F, 0xDF, // jg L30
0x7D, 0xDD, // jge L30
0x7D, 0xDB, // jge L30
0x7C, 0xD9, // jl L30
0x7C, 0xD7, // jl L30
0x7E, 0xD5, // jle L30
0x7E, 0xD3, // jle L30
0xEB, 0xD1, // jmp short L30
0x75, 0xCF, // jne L30
0x75, 0xCD, // jne L30
0x71, 0xCB, // jno L30
0x79, 0xC9, // jns L30
0x7B, 0xC7, // jnp L30
0x7B, 0xC5, // jnp L30
0x70, 0xC3, // jo L30
0x7A, 0xC1, // jp L30
0x7A, 0xBF, // jp L30
0x78, 0xBD, // js L30
0x9F, // lahf
// 0xC5, 0x30, // lds ESI,[EAX]
0x90, 0x90, // nop;nop
0x8B, 0xFB, // mov EDI,EBX
// 0xC4, 0x29, // les EBP,[ECX]
0x90, 0x90, // nop;nop
0xF0, // lock
0xAC, // lodsb
0x66, 0xAD, // lodsw
0xAD, // lodsd
0xE2, 0xAF, // loop L30
0xE1, 0xAD, // loope L30
0xE1, 0xAB, // loope L30
0xE0, 0xA9, // loopne L30
0xE0, 0xA7, // loopne L30
0xA4, // movsb
0x66, 0xA5, // movsw
0xA5, // movsd
0xF6, 0xE4, // mul AH
0x66, 0xF7, 0xE1, // mul CX
0xF7, 0xE5, // mul EBP
0x90, // nop
0xF7, 0xD7, // not EDI
0x66, 0xE7, 0x44, // out 044h,AX
0xEE, // out DX,AL
0x66, 0x9D, // popf
0x66, 0x9C, // pushf
0xD1, 0xDB, // rcr EBX,1
0xF3, // rep
0xF3, // rep
0xF2, // repne
0xF3, // rep
0xF2, // repne
0xC3, // ret
0xC2, 0x04, 0x00, // ret 4
0xD1, 0xC1, // rol ECX,1
0xD1, 0xCA, // ror EDX,1
0x9E, // sahf
0xD1, 0xE5, // shl EBP,1
0xD1, 0xE4, // shl ESP,1
0xD1, 0xFF, // sar EDI,1
0xAE, // scasb
0x66, 0xAF, // scasw
0xAF, // scasd
0xD1, 0xEE, // shr ESI,1
0xFD, // std
0xF9, // stc
0xFB, // sti
0xAA, // stosb
0x66, 0xAB, // stosw
0xAB, // stosd
0x9B, // wait
0x91, // xchg EAX,ECX
0xD7, // xlat
0xF3, 0x0F, 0x1E, 0xFB, // endbr32
0xF3, 0x0F, 0x1E, 0xFA, // endbr64
0x48, 0x8D, 0x1D, 0x02, 0x00, 0x00, 0x00, // lea RBX,L1;
0x89, 0xC0, // mov EAX,EAX
];
int i;
asm
{
call L1 ;
cbw ;
clc ;
cld ;
cli ;
cmc ;
cmpsb ;
cmpsw ;
cmpsd ;
cwd ;
//daa ;
//das ;
dec EAX ;
div CL ;
div BX ;
div EDX ;
hlt ;
idiv BL ;
idiv DX ;
idiv ESI ;
imul BL ;
imul DX ;
imul ESI ;
in AL,DX ;
in AX,DX ;
inc EBX ;
int 3 ;
int 0x67 ;
//into ;
iret ;
iretq ;
L10: nop; nop; // put instructions above this or L10 changes
// address, which changes all the jump instructions
// and breaks the test case.
ja L10 ;
jnbe L10 ;
jae L10 ;
jnb L10 ;
jnc L10 ;
jb L10 ;
jnae L10 ;
jbe L10 ;
jna L10 ;
jc L10 ;
nop;nop;nop; // jcxz L10;
je L10 ;
jz L10 ;
jg L10 ;
jnle L10 ;
jge L10 ;
jnl L10 ;
jl L10 ;
jnge L10 ;
jle L10 ;
jng L10 ;
jmp short L10 ;
jne L10 ;
jnz L10 ;
jno L10 ;
jns L10 ;
jnp L10 ;
jpo L10 ;
jo L10 ;
jp L10 ;
jpe L10 ;
js L10 ;
lahf ;
nop;nop; //lds ESI,[EAX];
lea EDI,[EBX];
nop;nop; //les EBP,[ECX];
lock ;
lodsb ;
lodsw ;
lodsd ;
loop L10 ;
loope L10 ;
loopz L10 ;
loopnz L10 ;
loopne L10 ;
movsb ;
movsw ;
movsd ;
mul AH ;
mul CX ;
mul EBP ;
nop ;
not EDI ;
out 0x44,AX ;
out DX,AL ;
popf ;
pushf ;
rcr EBX,1 ;
rep ;
repe ;
repne ;
repz ;
repnz ;
ret ;
ret 4 ;
rol ECX,1 ;
ror EDX,1 ;
sahf ;
sal EBP,1 ;
shl ESP,1 ;
sar EDI,1 ;
scasb ;
scasw ;
scasd ;
shr ESI,1 ;
std ;
stc ;
sti ;
stosb ;
stosw ;
stosd ;
wait ;
xchg EAX,ECX ;
xlat ;
endbr32 ;
endbr64 ;
lea RBX,L1 ;
mov EAX,EAX ;
L1: ;
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
//printf("[%d] %02x %02x\n", i, p[i], data[i]);
assert(p[i] == data[i]);
}
}
/****************************************************/
class Test51
{
void test(int n)
{ asm {
mov RAX, this;
}
}
}
/****************************************************/
void test52()
{ int x;
ubyte* p;
static ubyte[] data =
[
0xF6, 0xD8, // neg AL
0x66, 0xF7, 0xD8, // neg AX
0xF7, 0xD8, // neg EAX
0x48, 0xF7, 0xD8, // neg RAX
0xF6, 0xDC, // neg AH
0x41, 0xF6, 0xDC, // neg R12B
0x66, 0x41, 0xF7, 0xDC, // neg 12D
0x41, 0xF7, 0xDC, // neg R12D
0x49, 0xF7, 0xDB, // neg R11
// 0xF6, 0x1D, 0x00, 0x00, 0x00, 0x00, // neg byte ptr _D6iasm641bg@PC32[RIP]
//0x66, 0xF7, 0x1D, 0x00, 0x00, 0x00, 0x00, // neg word ptr _D6iasm641ws@PC32[RIP]
// 0xF7, 0x1D, 0x00, 0x00, 0x00, 0x00, // neg dword ptr _D6iasm641ii@PC32[RIP]
// 0x48, 0xF7, 0x1D, 0x00, 0x00, 0x00, 0x00, // neg qword ptr _D6iasm641ll@PC32[RIP]
0xF7, 0x5D, 0xD0, // neg dword ptr -8[RBP]
0xF6, 0x1B, // neg byte ptr [RBX]
0xF6, 0x1B, // neg byte ptr [RBX]
0x49, 0xF7, 0xD8, // neg R8
];
asm
{
call L1 ;
neg AL ;
neg AX ;
neg EAX ;
neg RAX ;
neg AH ;
neg R12B ;
neg R12W ;
neg R12D ;
neg R11 ;
// neg b ;
// neg w ;
// neg i ;
// neg l ;
neg x ;
neg byte ptr [EBX] ;
neg byte ptr [RBX] ;
neg R8 ;
L1: pop RAX ;
mov p[RBP],RAX ;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test53()
{ int x;
ubyte* p;
static ubyte[] data =
[
0x48, 0x8D, 0x04, 0x00, // lea RAX,[RAX][RAX]
0x48, 0x8D, 0x04, 0x08, // lea RAX,[RCX][RAX]
0x48, 0x8D, 0x04, 0x10, // lea RAX,[RDX][RAX]
0x48, 0x8D, 0x04, 0x18, // lea RAX,[RBX][RAX]
0x48, 0x8D, 0x04, 0x28, // lea RAX,[RBP][RAX]
0x48, 0x8D, 0x04, 0x30, // lea RAX,[RSI][RAX]
0x48, 0x8D, 0x04, 0x38, // lea RAX,[RDI][RAX]
0x4A, 0x8D, 0x04, 0x00, // lea RAX,[R8][RAX]
0x4A, 0x8D, 0x04, 0x08, // lea RAX,[R9][RAX]
0x4A, 0x8D, 0x04, 0x10, // lea RAX,[R10][RAX]
0x4A, 0x8D, 0x04, 0x18, // lea RAX,[R11][RAX]
0x4A, 0x8D, 0x04, 0x20, // lea RAX,[R12][RAX]
0x4A, 0x8D, 0x04, 0x28, // lea RAX,[R13][RAX]
0x4A, 0x8D, 0x04, 0x30, // lea RAX,[R14][RAX]
0x4A, 0x8D, 0x04, 0x38, // lea RAX,[R15][RAX]
0x48, 0x8D, 0x04, 0x00, // lea RAX,[RAX][RAX]
0x48, 0x8D, 0x04, 0x01, // lea RAX,[RAX][RCX]
0x48, 0x8D, 0x04, 0x02, // lea RAX,[RAX][RDX]
0x48, 0x8D, 0x04, 0x03, // lea RAX,[RAX][RBX]
0x48, 0x8D, 0x04, 0x04, // lea RAX,[RAX][RSP]
0x48, 0x8D, 0x44, 0x05, 0x00, // lea RAX,0[RAX][RBP]
0x48, 0x8D, 0x04, 0x06, // lea RAX,[RAX][RSI]
0x48, 0x8D, 0x04, 0x07, // lea RAX,[RAX][RDI]
0x49, 0x8D, 0x04, 0x00, // lea RAX,[RAX][R8]
0x49, 0x8D, 0x04, 0x01, // lea RAX,[RAX][R9]
0x49, 0x8D, 0x04, 0x02, // lea RAX,[RAX][R10]
0x49, 0x8D, 0x04, 0x03, // lea RAX,[RAX][R11]
0x49, 0x8D, 0x04, 0x04, // lea RAX,[RAX][R12]
0x49, 0x8D, 0x44, 0x05, 0x00, // lea RAX,0[RAX][R13]
0x49, 0x8D, 0x04, 0x06, // lea RAX,[RAX][R14]
0x49, 0x8D, 0x04, 0x07, // lea RAX,[RAX][R15]
0x4B, 0x8D, 0x04, 0x24, // lea RAX,[R12][R12]
0x4B, 0x8D, 0x44, 0x25, 0x00, // lea RAX,0[R12][R13]
0x4B, 0x8D, 0x04, 0x26, // lea RAX,[R12][R14]
0x4B, 0x8D, 0x04, 0x2C, // lea RAX,[R13][R12]
0x4B, 0x8D, 0x44, 0x2D, 0x00, // lea RAX,0[R13][R13]
0x4B, 0x8D, 0x04, 0x2E, // lea RAX,[R13][R14]
0x4B, 0x8D, 0x04, 0x34, // lea RAX,[R14][R12]
0x4B, 0x8D, 0x44, 0x35, 0x00, // lea RAX,0[R14][R13]
0x4B, 0x8D, 0x04, 0x36, // lea RAX,[R14][R14]
0x48, 0x8D, 0x44, 0x01, 0x12, // lea RAX,012h[RAX][RCX]
0x48, 0x8D, 0x84, 0x01, 0x34, 0x12, 0x00, 0x00, // lea RAX,01234h[RAX][RCX]
0x48, 0x8D, 0x84, 0x01, 0x78, 0x56, 0x34, 0x12, // lea RAX,012345678h[RAX][RCX]
0x48, 0x8D, 0x44, 0x05, 0x12, // lea RAX,012h[RAX][RBP]
0x48, 0x8D, 0x84, 0x05, 0x34, 0x12, 0x00, 0x00, // lea RAX,01234h[RAX][RBP]
0x48, 0x8D, 0x84, 0x05, 0x78, 0x56, 0x34, 0x12, // lea RAX,012345678h[RAX][RBP]
0x49, 0x8D, 0x44, 0x05, 0x12, // lea RAX,012h[RAX][R13]
0x49, 0x8D, 0x84, 0x05, 0x34, 0x12, 0x00, 0x00, // lea RAX,01234h[RAX][R13]
0x49, 0x8D, 0x84, 0x05, 0x78, 0x56, 0x34, 0x12, // lea RAX,012345678h[RAX][R13]
0x48, 0x8D, 0x04, 0x24, // lea RAX,[RSP]
0x49, 0x8D, 0x04, 0x24, // lea RAX,[R12]
];
asm
{
call L1 ;
// Right
lea RAX, [RAX+RAX];
lea RAX, [RAX+RCX];
lea RAX, [RAX+RDX];
lea RAX, [RAX+RBX];
//lea RAX, [RAX+RSP]; RSP can't be on the right
lea RAX, [RAX+RBP];
lea RAX, [RAX+RSI];
lea RAX, [RAX+RDI];
lea RAX, [RAX+R8];
lea RAX, [RAX+R9];
lea RAX, [RAX+R10];
lea RAX, [RAX+R11];
lea RAX, [RAX+R12];
lea RAX, [RAX+R13];
lea RAX, [RAX+R14];
lea RAX, [RAX+R15];
// Left
lea RAX, [RAX+RAX];
lea RAX, [RCX+RAX];
lea RAX, [RDX+RAX];
lea RAX, [RBX+RAX];
lea RAX, [RSP+RAX];
lea RAX, [RBP+RAX]; // Good gets disp+8 correctly
lea RAX, [RSI+RAX];
lea RAX, [RDI+RAX];
lea RAX, [R8+RAX];
lea RAX, [R9+RAX];
lea RAX, [R10+RAX];
lea RAX, [R11+RAX];
lea RAX, [R12+RAX];
lea RAX, [R13+RAX]; // Good disp+8
lea RAX, [R14+RAX];
lea RAX, [R15+RAX];
// Right and Left
lea RAX, [R12+R12];
lea RAX, [R13+R12];
lea RAX, [R14+R12];
lea RAX, [R12+R13];
lea RAX, [R13+R13];
lea RAX, [R14+R13];
lea RAX, [R12+R14];
lea RAX, [R13+R14];
lea RAX, [R14+R14];
// Disp8/32 checks
lea RAX, [RCX+RAX+0x12];
lea RAX, [RCX+RAX+0x1234];
lea RAX, [RCX+RAX+0x1234_5678];
lea RAX, [RBP+RAX+0x12];
lea RAX, [RBP+RAX+0x1234];
lea RAX, [RBP+RAX+0x1234_5678];
lea RAX, [R13+RAX+0x12];
lea RAX, [R13+RAX+0x1234];
lea RAX, [R13+RAX+0x1234_5678];
lea RAX, [RSP];
lea RAX, [R12];
L1: pop RAX ;
mov p[RBP],RAX ;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test54()
{ int x;
ubyte* p;
static ubyte[] data =
[
0xFE, 0xC8, // dec AL
0xFE, 0xCC, // dec AH
0x66, 0xFF, 0xC8, // dec AX
0xFF, 0xC8, // dec EAX
0x48, 0xFF, 0xC8, // dec RAX
0x49, 0xFF, 0xCA, // dec R10
0xFE, 0xC0, // inc AL
0xFE, 0xC4, // inc AH
0x66, 0xFF, 0xC0, // inc AX
0xFF, 0xC0, // inc EAX
0x48, 0xFF, 0xC0, // inc RAX
0x49, 0xFF, 0xC2, // inc R10
0x66, 0x44, 0x0F, 0xA4, 0xC0, 0x04, // shld AX, R8W, 4
0x66, 0x44, 0x0F, 0xA5, 0xC0, // shld AX, R8W, CL
0x44, 0x0F, 0xA4, 0xC0, 0x04, // shld EAX, R8D, 4
0x44, 0x0F, 0xA5, 0xC0, // shld EAX, R8D, CL
0x4C, 0x0F, 0xA4, 0xC0, 0x04, // shld RAX, R8 , 4
0x4C, 0x0F, 0xA5, 0xC0, // shld RAX, R8 , CL
0x66, 0x44, 0x0F, 0xAC, 0xC0, 0x04, // shrd AX, R8W, 4
0x66, 0x44, 0x0F, 0xAD, 0xC0, // shrd AX, R8W, CL
0x44, 0x0F, 0xAC, 0xC0, 0x04, // shrd EAX, R8D, 4
0x44, 0x0F, 0xAD, 0xC0, // shrd EAX, R8D, CL
0x4C, 0x0F, 0xAC, 0xC0, 0x04, // shrd RAX, R8 , 4
0x4C, 0x0F, 0xAD, 0xC0 // shrd RAX, R8 , CL
];
asm
{
call L1;
dec AL;
dec AH;
dec AX;
dec EAX;
dec RAX;
dec R10;
inc AL;
inc AH;
inc AX;
inc EAX;
inc RAX;
inc R10;
shld AX, R8W, 4;
shld AX, R8W, CL;
shld EAX, R8D, 4;
shld EAX, R8D, CL;
shld RAX, R8 , 4;
shld RAX, R8 , CL;
shrd AX, R8W, 4;
shrd AX, R8W, CL;
shrd EAX, R8D, 4;
shrd EAX, R8D, CL;
shrd RAX, R8 , 4;
shrd RAX, R8 , CL;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test55()
{ int x;
ubyte* p;
enum NOP = 0x9090_9090_9090_9090;
static ubyte[] data =
[
0x0F, 0x87, 0xFF, 0xFF, 0, 0, // ja $ + 0xFFFF
0x72, 0x18, // jb Lb
0x0F, 0x82, 0x92, 0x00, 0, 0, // jc Lc
0x0F, 0x84, 0x0C, 0x01, 0, 0, // je Le
0xEB, 0x0A, // jmp Lb
0xE9, 0x85, 0x00, 0x00, 0, // jmp Lc
0xE9, 0x00, 0x01, 0x00, 0, // jmp Le
];
asm
{
call L1;
ja $+0x0_FFFF;
jb Lb;
jc Lc;
je Le;
jmp Lb;
jmp Lc;
jmp Le;
Lb: dq NOP,NOP,NOP,NOP; // 32
dq NOP,NOP,NOP,NOP; // 64
dq NOP,NOP,NOP,NOP; // 96
dq NOP,NOP,NOP,NOP; // 128
Lc: dq NOP,NOP,NOP,NOP; // 160
dq NOP,NOP,NOP,NOP; // 192
dq NOP,NOP,NOP,NOP; // 224
dq NOP,NOP,NOP,NOP; // 256
Le: nop;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test56()
{ int x;
x = foo56();
assert(x == 42);
}
int foo56()
{
asm
{ naked;
xor EAX,EAX;
jz bar56;
ret;
}
}
void bar56()
{
asm
{ naked;
mov EAX, 42;
ret;
}
}
/****************************************************/
/* ======================= SSSE3 ======================= */
void test57()
{
ubyte* p;
M64 m64;
M128 m128;
static ubyte[] data =
[
0x0F, 0x3A, 0x0F, 0xCA, 0x03, // palignr MM1, MM2, 3
0x66, 0x0F, 0x3A, 0x0F, 0xCA, 0x03, // palignr XMM1, XMM2, 3
0x0F, 0x3A, 0x0F, 0x5D, 0xC8, 0x03, // palignr MM3, -0x38[RBP], 3
0x66, 0x0F, 0x3A, 0x0F, 0x5D, 0xD0, 0x03, // palignr XMM3, -0x30[RBP], 3
0x0F, 0x38, 0x02, 0xCA, // phaddd MM1, MM2
0x66, 0x0F, 0x38, 0x02, 0xCA, // phaddd XMM1, XMM2
0x0F, 0x38, 0x02, 0x5D, 0xC8, // phaddd MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x02, 0x5D, 0xD0, // phaddd XMM3, -0x30[RBP]
0x0F, 0x38, 0x01, 0xCA, // phaddw MM1, MM2
0x66, 0x0F, 0x38, 0x01, 0xCA, // phaddw XMM1, XMM2
0x0F, 0x38, 0x01, 0x5D, 0xC8, // phaddw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x01, 0x5D, 0xD0, // phaddw XMM3, -0x30[RBP]
0x0F, 0x38, 0x03, 0xCA, // phaddsw MM1, MM2
0x66, 0x0F, 0x38, 0x03, 0xCA, // phaddsw XMM1, XMM2
0x0F, 0x38, 0x03, 0x5D, 0xC8, // phaddsw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x03, 0x5D, 0xD0, // phaddsw XMM3, -0x30[RBP]
0x0F, 0x38, 0x06, 0xCA, // phsubd MM1, MM2
0x66, 0x0F, 0x38, 0x06, 0xCA, // phsubd XMM1, XMM2
0x0F, 0x38, 0x06, 0x5D, 0xC8, // phsubd MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x06, 0x5D, 0xD0, // phsubd XMM3, -0x30[RBP]
0x0F, 0x38, 0x05, 0xCA, // phsubw MM1, MM2
0x66, 0x0F, 0x38, 0x05, 0xCA, // phsubw XMM1, XMM2
0x0F, 0x38, 0x05, 0x5D, 0xC8, // phsubw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x05, 0x5D, 0xD0, // phsubw XMM3, -0x30[RBP]
0x0F, 0x38, 0x07, 0xCA, // phsubsw MM1, MM2
0x66, 0x0F, 0x38, 0x07, 0xCA, // phsubsw XMM1, XMM2
0x0F, 0x38, 0x07, 0x5D, 0xC8, // phsubsw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x07, 0x5D, 0xD0, // phsubsw XMM3, -0x30[RBP]
0x0F, 0x38, 0x04, 0xCA, // pmaddubsw MM1, MM2
0x66, 0x0F, 0x38, 0x04, 0xCA, // pmaddubsw XMM1, XMM2
0x0F, 0x38, 0x04, 0x5D, 0xC8, // pmaddubsw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x04, 0x5D, 0xD0, // pmaddubsw XMM3, -0x30[RBP]
0x0F, 0x38, 0x0B, 0xCA, // pmulhrsw MM1, MM2
0x66, 0x0F, 0x38, 0x0B, 0xCA, // pmulhrsw XMM1, XMM2
0x0F, 0x38, 0x0B, 0x5D, 0xC8, // pmulhrsw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x0B, 0x5D, 0xD0, // pmulhrsw XMM3, -0x30[RBP]
0x0F, 0x38, 0x00, 0xCA, // pshufb MM1, MM2
0x66, 0x0F, 0x38, 0x00, 0xCA, // pshufb XMM1, XMM2
0x0F, 0x38, 0x00, 0x5D, 0xC8, // pshufb MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x00, 0x5D, 0xD0, // pshufb XMM3, -0x30[RBP]
0x0F, 0x38, 0x1C, 0xCA, // pabsb MM1, MM2
0x66, 0x0F, 0x38, 0x1C, 0xCA, // pabsb XMM1, XMM2
0x0F, 0x38, 0x1C, 0x5D, 0xC8, // pabsb MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x1C, 0x5D, 0xD0, // pabsb XMM3, -0x30[RBP]
0x0F, 0x38, 0x1E, 0xCA, // pabsd MM1, MM2
0x66, 0x0F, 0x38, 0x1E, 0xCA, // pabsd XMM1, XMM2
0x0F, 0x38, 0x1E, 0x5D, 0xC8, // pabsd MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x1E, 0x5D, 0xD0, // pabsd XMM3, -0x30[RBP]
0x0F, 0x38, 0x1D, 0xCA, // pabsw MM1, MM2
0x66, 0x0F, 0x38, 0x1D, 0xCA, // pabsw XMM1, XMM2
0x0F, 0x38, 0x1D, 0x5D, 0xC8, // pabsw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x1D, 0x5D, 0xD0, // pabsw XMM3, -0x30[RBP]
0x0F, 0x38, 0x08, 0xCA, // psignb MM1, MM2
0x66, 0x0F, 0x38, 0x08, 0xCA, // psignb XMM1, XMM2
0x0F, 0x38, 0x08, 0x5D, 0xC8, // psignb MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x08, 0x5D, 0xD0, // psignb XMM3, -0x30[RBP]
0x0F, 0x38, 0x0A, 0xCA, // psignd MM1, MM2
0x66, 0x0F, 0x38, 0x0A, 0xCA, // psignd XMM1, XMM2
0x0F, 0x38, 0x0A, 0x5D, 0xC8, // psignd MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x0A, 0x5D, 0xD0, // psignd XMM3, -0x30[RBP]
0x0F, 0x38, 0x09, 0xCA, // psignw MM1, MM2
0x66, 0x0F, 0x38, 0x09, 0xCA, // psignw XMM1, XMM2
0x0F, 0x38, 0x09, 0x5D, 0xC8, // psignw MM3, -0x38[RBP]
0x66, 0x0F, 0x38, 0x09, 0x5D, 0xD0, // psignw XMM3, -0x30[RBP]
];
asm
{
call L1;
palignr MM1, MM2, 3;
palignr XMM1, XMM2, 3;
palignr MM3, m64 , 3;
palignr XMM3, m128, 3;
phaddd MM1, MM2;
phaddd XMM1, XMM2;
phaddd MM3, m64;
phaddd XMM3, m128;
phaddw MM1, MM2;
phaddw XMM1, XMM2;
phaddw MM3, m64;
phaddw XMM3, m128;
phaddsw MM1, MM2;
phaddsw XMM1, XMM2;
phaddsw MM3, m64;
phaddsw XMM3, m128;
phsubd MM1, MM2;
phsubd XMM1, XMM2;
phsubd MM3, m64;
phsubd XMM3, m128;
phsubw MM1, MM2;
phsubw XMM1, XMM2;
phsubw MM3, m64;
phsubw XMM3, m128;
phsubsw MM1, MM2;
phsubsw XMM1, XMM2;
phsubsw MM3, m64;
phsubsw XMM3, m128;
pmaddubsw MM1, MM2;
pmaddubsw XMM1, XMM2;
pmaddubsw MM3, m64;
pmaddubsw XMM3, m128;
pmulhrsw MM1, MM2;
pmulhrsw XMM1, XMM2;
pmulhrsw MM3, m64;
pmulhrsw XMM3, m128;
pshufb MM1, MM2;
pshufb XMM1, XMM2;
pshufb MM3, m64;
pshufb XMM3, m128;
pabsb MM1, MM2;
pabsb XMM1, XMM2;
pabsb MM3, m64;
pabsb XMM3, m128;
pabsd MM1, MM2;
pabsd XMM1, XMM2;
pabsd MM3, m64;
pabsd XMM3, m128;
pabsw MM1, MM2;
pabsw XMM1, XMM2;
pabsw MM3, m64;
pabsw XMM3, m128;
psignb MM1, MM2;
psignb XMM1, XMM2;
psignb MM3, m64;
psignb XMM3, m128;
psignd MM1, MM2;
psignd XMM1, XMM2;
psignd MM3, m64;
psignd XMM3, m128;
psignw MM1, MM2;
psignw XMM1, XMM2;
psignw MM3, m64;
psignw XMM3, m128;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
/* ======================= SSE4.1 ======================= */
void test58()
{
ubyte* p;
byte m8;
short m16;
int m32;
M64 m64;
M128 m128;
static ubyte[] data =
[
0x66, 0x0F, 0x3A, 0x0D, 0xCA, 3,// blendpd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0D, 0x5D, 0xD0, 3,// blendpd XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x3A, 0x0C, 0xCA, 3,// blendps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0C, 0x5D, 0xD0, 3,// blendps XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x38, 0x15, 0xCA, // blendvpd XMM1,XMM2,XMM0
0x66, 0x0F, 0x38, 0x15, 0x5D, 0xD0, // blendvpd XMM3,XMMWORD PTR [RBP-0x30],XMM0
0x66, 0x0F, 0x38, 0x14, 0xCA, // blendvps XMM1,XMM2,XMM0
0x66, 0x0F, 0x38, 0x14, 0x5D, 0xD0, // blendvps XMM3,XMMWORD PTR [RBP-0x30],XMM0
0x66, 0x0F, 0x3A, 0x41, 0xCA, 3,// dppd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x41, 0x5D, 0xD0, 3,// dppd XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x3A, 0x40, 0xCA, 3,// dpps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x40, 0x5D, 0xD0, 3,// dpps XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x3A, 0x17, 0xD2, 3,// extractps EDX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x17, 0x55, 0xBC, 3,// extractps DWORD PTR [RBP-0x44],XMM2,0x3
0x66, 0x0F, 0x3A, 0x21, 0xCA, 3,// insertps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x21, 0x5D, 0xBC, 3,// insertps XMM3,DWORD PTR [RBP-0x44],0x3
0x66, 0x0F, 0x38, 0x2A, 0x4D, 0xD0, // movntdqa XMM1,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x3A, 0x42, 0xCA, 3,// mpsadbw XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x42, 0x5D, 0xD0, 3,// mpsadbw XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x38, 0x2B, 0xCA, // packusdw XMM1,XMM2
0x66, 0x0F, 0x38, 0x2B, 0x5D, 0xD0, // packusdw XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x10, 0xCA, // pblendvb XMM1,XMM2,XMM0
0x66, 0x0F, 0x38, 0x10, 0x5D, 0xD0, // pblendvb XMM3,XMMWORD PTR [RBP-0x30],XMM0
0x66, 0x0F, 0x3A, 0x0E, 0xCA, 3,// pblendw XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0E, 0x5D, 0xD0, 3,// pblendw XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x38, 0x29, 0xCA, // pcmpeqq XMM1,XMM2
0x66, 0x0F, 0x38, 0x29, 0x5D, 0xD0, // pcmpeqq XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x3A, 0x14, 0xD0, 3,// pextrb EAX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x14, 0xD3, 3,// pextrb EBX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x14, 0xD1, 3,// pextrb ECX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x14, 0xD2, 3,// pextrb EDX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x14, 0xD0, 3,// pextrb EAX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x14, 0xD3, 3,// pextrb EBX,XMM2,0x3
0x66, 0x41, 0x0F, 0x3A, 0x14, 0xD0, 3,// pextrb R8D,XMM2,0x3
0x66, 0x41, 0x0F, 0x3A, 0x14, 0xD2, 3,// pextrb R10D,XMM2,0x3
0x66, 0x0F, 0x3A, 0x14, 0x5D, 0xB8, 3,// pextrb BYTE PTR [RBP-0x48],XMM3,0x3
0x66, 0x0F, 0x3A, 0x16, 0xD0, 3,// pextrd EAX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x16, 0xD3, 3,// pextrd EBX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x16, 0xD1, 3,// pextrd ECX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x16, 0xD2, 3,// pextrd EDX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x16, 0x5D, 0xBC, 3,// pextrd DWORD PTR [RBP-0x44],XMM3,0x3
0x66, 0x48, 0x0F, 0x3A, 0x16, 0xD0, 3,// pextrq RAX,XMM2,0x3
0x66, 0x48, 0x0F, 0x3A, 0x16, 0xD3, 3,// pextrq RBX,XMM2,0x3
0x66, 0x48, 0x0F, 0x3A, 0x16, 0xD1, 3,// pextrq RCX,XMM2,0x3
0x66, 0x48, 0x0F, 0x3A, 0x16, 0xD2, 3,// pextrq RDX,XMM2,0x3
0x66, 0x48, 0x0F, 0x3A, 0x16, 0x5D, 0xC0, 3,// pextrq QWORD PTR [RBP-0x40],XMM3,0x3
0x66, 0x0F, 0xC5, 0xC2, 3,// pextrw EAX,XMM2,0x3
0x66, 0x0F, 0xC5, 0xDA, 3,// pextrw EBX,XMM2,0x3
0x66, 0x0F, 0xC5, 0xCA, 3,// pextrw ECX,XMM2,0x3
0x66, 0x0F, 0xC5, 0xD2, 3,// pextrw EDX,XMM2,0x3
0x66, 0x0F, 0xC5, 0xC2, 3,// pextrw EAX,XMM2,0x3
0x66, 0x0F, 0xC5, 0xDA, 3,// pextrw EBX,XMM2,0x3
0x66, 0x44, 0x0F, 0xC5, 0xC2, 3,// pextrw R8D,XMM2,0x3
0x66, 0x44, 0x0F, 0xC5, 0xD2, 3,// pextrw R10D,XMM2,0x3
0x66, 0x0F, 0x3A, 0x15, 0x5D, 0xBA, 3,// pextrw WORD PTR [RBP-0x46],XMM3,0x3
0x66, 0x0F, 0x38, 0x41, 0xCA, // phminposuw XMM1,XMM2
0x66, 0x0F, 0x38, 0x41, 0x5D, 0xD0, // phminposuw XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x3A, 0x20, 0xC8, 3,// pinsrb XMM1,EAX,0x3
0x66, 0x0F, 0x3A, 0x20, 0xCB, 3,// pinsrb XMM1,EBX,0x3
0x66, 0x0F, 0x3A, 0x20, 0xC9, 3,// pinsrb XMM1,ECX,0x3
0x66, 0x0F, 0x3A, 0x20, 0xCA, 3,// pinsrb XMM1,EDX,0x3
0x66, 0x0F, 0x3A, 0x20, 0x5D, 0xB8, 3,// pinsrb XMM3,BYTE PTR [RBP-0x48],0x3
0x66, 0x0F, 0x3A, 0x22, 0xC8, 3,// pinsrd XMM1,EAX,0x3
0x66, 0x0F, 0x3A, 0x22, 0xCB, 3,// pinsrd XMM1,EBX,0x3
0x66, 0x0F, 0x3A, 0x22, 0xC9, 3,// pinsrd XMM1,ECX,0x3
0x66, 0x0F, 0x3A, 0x22, 0xCA, 3,// pinsrd XMM1,EDX,0x3
0x66, 0x0F, 0x3A, 0x22, 0x5D, 0xBC, 3,// pinsrd XMM3,DWORD PTR [RBP-0x44],0x3
0x66, 0x48, 0x0F, 0x3A, 0x22, 0xC8, 3,// pinsrq XMM1,RAX,0x3
0x66, 0x48, 0x0F, 0x3A, 0x22, 0xCB, 3,// pinsrq XMM1,RBX,0x3
0x66, 0x48, 0x0F, 0x3A, 0x22, 0xC9, 3,// pinsrq XMM1,RCX,0x3
0x66, 0x48, 0x0F, 0x3A, 0x22, 0xCA, 3,// pinsrq XMM1,RDX,0x3
0x66, 0x48, 0x0F, 0x3A, 0x22, 0x5D, 0xC0, 3,// pinsrq XMM3,QWORD PTR [RBP-0x40],0x3
0x66, 0x0F, 0x38, 0x3C, 0xCA, // pmaxsb XMM1,XMM2
0x66, 0x0F, 0x38, 0x3C, 0x5D, 0xD0, // pmaxsb XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x3D, 0xCA, // pmaxsd XMM1,XMM2
0x66, 0x0F, 0x38, 0x3D, 0x5D, 0xD0, // pmaxsd XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x3F, 0xCA, // pmaxud XMM1,XMM2
0x66, 0x0F, 0x38, 0x3F, 0x5D, 0xD0, // pmaxud XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x3E, 0xCA, // pmaxuw XMM1,XMM2
0x66, 0x0F, 0x38, 0x3E, 0x5D, 0xD0, // pmaxuw XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x38, 0xCA, // pminsb XMM1,XMM2
0x66, 0x0F, 0x38, 0x38, 0x5D, 0xD0, // pminsb XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x39, 0xCA, // pminsd XMM1,XMM2
0x66, 0x0F, 0x38, 0x39, 0x5D, 0xD0, // pminsd XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x3B, 0xCA, // pminud XMM1,XMM2
0x66, 0x0F, 0x38, 0x3B, 0x5D, 0xD0, // pminud XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x3A, 0xCA, // pminuw XMM1,XMM2
0x66, 0x0F, 0x38, 0x3A, 0x5D, 0xD0, // pminuw XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x20, 0xCA, // pmovsxbw XMM1,XMM2
0x66, 0x0F, 0x38, 0x20, 0x5D, 0xC0, // pmovsxbw XMM3,QWORD PTR [RBP-0x40]
0x66, 0x0F, 0x38, 0x21, 0xCA, // pmovsxbd XMM1,XMM2
0x66, 0x0F, 0x38, 0x21, 0x5D, 0xBC, // pmovsxbd XMM3,DWORD PTR [RBP-0x44]
0x66, 0x0F, 0x38, 0x22, 0xCA, // pmovsxbq XMM1,XMM2
0x66, 0x0F, 0x38, 0x22, 0x5D, 0xBA, // pmovsxbq XMM3,WORD PTR [RBP-0x46]
0x66, 0x0F, 0x38, 0x23, 0xCA, // pmovsxwd XMM1,XMM2
0x66, 0x0F, 0x38, 0x23, 0x5D, 0xC0, // pmovsxwd XMM3,QWORD PTR [RBP-0x40]
0x66, 0x0F, 0x38, 0x24, 0xCA, // pmovsxwq XMM1,XMM2
0x66, 0x0F, 0x38, 0x24, 0x5D, 0xBC, // pmovsxwq XMM3,DWORD PTR [RBP-0x44]
0x66, 0x0F, 0x38, 0x25, 0xCA, // pmovsxdq XMM1,XMM2
0x66, 0x0F, 0x38, 0x25, 0x5D, 0xC0, // pmovsxdq XMM3,QWORD PTR [RBP-0x40]
0x66, 0x0F, 0x38, 0x30, 0xCA, // pmovzxbw XMM1,XMM2
0x66, 0x0F, 0x38, 0x30, 0x5D, 0xC0, // pmovzxbw XMM3,QWORD PTR [RBP-0x40]
0x66, 0x0F, 0x38, 0x31, 0xCA, // pmovzxbd XMM1,XMM2
0x66, 0x0F, 0x38, 0x31, 0x5D, 0xBC, // pmovzxbd XMM3,DWORD PTR [RBP-0x44]
0x66, 0x0F, 0x38, 0x32, 0xCA, // pmovzxbq XMM1,XMM2
0x66, 0x0F, 0x38, 0x32, 0x5D, 0xBA, // pmovzxbq XMM3,WORD PTR [RBP-0x46]
0x66, 0x0F, 0x38, 0x33, 0xCA, // pmovzxwd XMM1,XMM2
0x66, 0x0F, 0x38, 0x33, 0x5D, 0xC0, // pmovzxwd XMM3,QWORD PTR [RBP-0x40]
0x66, 0x0F, 0x38, 0x34, 0xCA, // pmovzxwq XMM1,XMM2
0x66, 0x0F, 0x38, 0x34, 0x5D, 0xBC, // pmovzxwq XMM3,DWORD PTR [RBP-0x44]
0x66, 0x0F, 0x38, 0x35, 0xCA, // pmovzxdq XMM1,XMM2
0x66, 0x0F, 0x38, 0x35, 0x5D, 0xC0, // pmovzxdq XMM3,QWORD PTR [RBP-0x40]
0x66, 0x0F, 0x38, 0x28, 0xCA, // pmuldq XMM1,XMM2
0x66, 0x0F, 0x38, 0x28, 0x5D, 0xD0, // pmuldq XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x40, 0xCA, // pmulld XMM1,XMM2
0x66, 0x0F, 0x38, 0x40, 0x5D, 0xD0, // pmulld XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x17, 0xCA, // ptest XMM1,XMM2
0x66, 0x0F, 0x38, 0x17, 0x5D, 0xD0, // ptest XMM3,XMMWORD PTR [RBP-0x30]
0x66, 0x0F, 0x3A, 0x09, 0xCA, 3,// roundpd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x09, 0x5D, 0xD0, 3,// roundpd XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x3A, 0x08, 0xCA, 3,// roundps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x08, 0x5D, 0xD0, 3,// roundps XMM3,XMMWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x3A, 0x0B, 0xCA, 3,// roundsd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0B, 0x5D, 0xC0, 3,// roundsd XMM3,QWORD PTR [RBP-0x40],0x3
0x66, 0x0F, 0x3A, 0x0A, 0xCA, 3,// roundss XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0A, 0x4D, 0xBC, 3,// roundss xmm1,dword ptr [rbp-0x44],0x3
];
asm
{
call L1;
blendpd XMM1, XMM2, 3;
blendpd XMM3, m128, 3;
blendps XMM1, XMM2, 3;
blendps XMM3, m128, 3;
blendvpd XMM1, XMM2, XMM0;
blendvpd XMM3, m128, XMM0;
blendvps XMM1, XMM2, XMM0;
blendvps XMM3, m128, XMM0;
dppd XMM1, XMM2, 3;
dppd XMM3, m128, 3;
dpps XMM1, XMM2, 3;
dpps XMM3, m128, 3;
extractps EDX, XMM2, 3;
extractps m32, XMM2, 3;
insertps XMM1, XMM2, 3;
insertps XMM3, m32, 3;
movntdqa XMM1, m128;
mpsadbw XMM1, XMM2, 3;
mpsadbw XMM3, m128, 3;
packusdw XMM1, XMM2;
packusdw XMM3, m128;
pblendvb XMM1, XMM2, XMM0;
pblendvb XMM3, m128, XMM0;
pblendw XMM1, XMM2, 3;
pblendw XMM3, m128, 3;
pcmpeqq XMM1, XMM2;
pcmpeqq XMM3, m128;
pextrb EAX, XMM2, 3;
pextrb EBX, XMM2, 3;
pextrb ECX, XMM2, 3;
pextrb EDX, XMM2, 3;
pextrb RAX, XMM2, 3;
pextrb RBX, XMM2, 3;
pextrb R8 , XMM2, 3;
pextrb R10, XMM2, 3;
pextrb m8, XMM3, 3;
pextrd EAX, XMM2, 3;
pextrd EBX, XMM2, 3;
pextrd ECX, XMM2, 3;
pextrd EDX, XMM2, 3;
pextrd m32, XMM3, 3;
pextrq RAX, XMM2, 3;
pextrq RBX, XMM2, 3;
pextrq RCX, XMM2, 3;
pextrq RDX, XMM2, 3;
pextrq m64, XMM3, 3;
pextrw EAX, XMM2, 3;
pextrw EBX, XMM2, 3;
pextrw ECX, XMM2, 3;
pextrw EDX, XMM2, 3;
pextrw RAX, XMM2, 3;
pextrw RBX, XMM2, 3;
pextrw R8 , XMM2, 3;
pextrw R10, XMM2, 3;
pextrw m16, XMM3, 3;
phminposuw XMM1, XMM2;
phminposuw XMM3, m128;
pinsrb XMM1, EAX, 3;
pinsrb XMM1, EBX, 3;
pinsrb XMM1, ECX, 3;
pinsrb XMM1, EDX, 3;
pinsrb XMM3, m8, 3;
pinsrd XMM1, EAX, 3;
pinsrd XMM1, EBX, 3;
pinsrd XMM1, ECX, 3;
pinsrd XMM1, EDX, 3;
pinsrd XMM3, m32, 3;
pinsrq XMM1, RAX, 3;
pinsrq XMM1, RBX, 3;
pinsrq XMM1, RCX, 3;
pinsrq XMM1, RDX, 3;
pinsrq XMM3, m64, 3;
pmaxsb XMM1, XMM2;
pmaxsb XMM3, m128;
pmaxsd XMM1, XMM2;
pmaxsd XMM3, m128;
pmaxud XMM1, XMM2;
pmaxud XMM3, m128;
pmaxuw XMM1, XMM2;
pmaxuw XMM3, m128;
pminsb XMM1, XMM2;
pminsb XMM3, m128;
pminsd XMM1, XMM2;
pminsd XMM3, m128;
pminud XMM1, XMM2;
pminud XMM3, m128;
pminuw XMM1, XMM2;
pminuw XMM3, m128;
pmovsxbw XMM1, XMM2;
pmovsxbw XMM3, m64;
pmovsxbd XMM1, XMM2;
pmovsxbd XMM3, m32;
pmovsxbq XMM1, XMM2;
pmovsxbq XMM3, m16;
pmovsxwd XMM1, XMM2;
pmovsxwd XMM3, m64;
pmovsxwq XMM1, XMM2;
pmovsxwq XMM3, m32;
pmovsxdq XMM1, XMM2;
pmovsxdq XMM3, m64;
pmovzxbw XMM1, XMM2;
pmovzxbw XMM3, m64;
pmovzxbd XMM1, XMM2;
pmovzxbd XMM3, m32;
pmovzxbq XMM1, XMM2;
pmovzxbq XMM3, m16;
pmovzxwd XMM1, XMM2;
pmovzxwd XMM3, m64;
pmovzxwq XMM1, XMM2;
pmovzxwq XMM3, m32;
pmovzxdq XMM1, XMM2;
pmovzxdq XMM3, m64;
pmuldq XMM1, XMM2;
pmuldq XMM3, m128;
pmulld XMM1, XMM2;
pmulld XMM3, m128;
ptest XMM1, XMM2;
ptest XMM3, m128;
roundpd XMM1, XMM2, 3;
roundpd XMM3, m128, 3;
roundps XMM1, XMM2, 3;
roundps XMM3, m128, 3;
roundsd XMM1, XMM2, 3;
roundsd XMM3, m64, 3;
roundss XMM1, XMM2, 3;
roundss XMM1, m32, 3;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
/* ======================= SSE4.2 ======================= */
void test59()
{
ubyte* p;
byte m8;
short m16;
int m32;
M64 m64;
M128 m128;
static ubyte[] data =
[
0xF2, 0x0F, 0x38, 0xF0, 0xC1, // crc32 EAX, CL
0x66, 0xF2, 0x0F, 0x38, 0xF1, 0xC1, // crc32 EAX, CX
0xF2, 0x0F, 0x38, 0xF1, 0xC1, // crc32 EAX, ECX
0xF2, 0x48, 0x0F, 0x38, 0xF0, 0xC1, // crc32 RAX, CL
0xF2, 0x48, 0x0F, 0x38, 0xF1, 0xC1, // crc32 RAX, RCX
0xF2, 0x0F, 0x38, 0xF0, 0x55, 0xB8, // crc32 EDX, byte ptr [RBP-0x48]
0x66, 0xF2, 0x0F, 0x38, 0xF1, 0x55, 0xBA, // crc32 EDX, word ptr [RBP-0x46]
0xF2, 0x0F, 0x38, 0xF1, 0x55, 0xBC, // crc32 EDX,dword ptr [RBP-0x44]
0xF2, 0x48, 0x0F, 0x38, 0xF0, 0x55, 0xB8, // crc32 RDX, byte ptr [RBP-0x48]
0xF2, 0x48, 0x0F, 0x38, 0xF1, 0x55, 0xC0, // crc32 RDX,qword ptr [RBP-0x40]
0x66, 0x0F, 0x3A, 0x61, 0xCA, 2, // pcmpestri XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x61, 0x5D, 0xD0, 2, // pcmpestri XMM3,xmmword ptr [RBP-0x30], 2
0x66, 0x0F, 0x3A, 0x60, 0xCA, 2, // pcmpestrm XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x60, 0x5D, 0xD0, 2, // pcmpestrm XMM3,xmmword ptr [RBP-0x30], 2
0x66, 0x0F, 0x3A, 0x63, 0xCA, 2, // pcmpistri XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x63, 0x5D, 0xD0, 2, // pcmpistri XMM3,xmmword ptr [RBP-0x30], 2
0x66, 0x0F, 0x3A, 0x62, 0xCA, 2, // pcmpistrm XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x62, 0x5D, 0xD0, 2, // pcmpistrm XMM3,xmmword ptr [RBP-0x30], 2
0x66, 0x0F, 0x38, 0x37, 0xCA, // pcmpgtq XMM1,XMM2
0x66, 0x0F, 0x38, 0x37, 0x5D, 0xD0, // pcmpgtq XMM3,xmmword ptr [RBP-0x30]
0x66, 0xF3, 0x0F, 0xB8, 0xC1, // popcnt AX, CX
0xF3, 0x0F, 0xB8, 0xC1, // popcnt EAX, ECX
0xF3, 0x48, 0x0F, 0xB8, 0xC1, // popcnt RAX, RCX
0x66, 0xF3, 0x0F, 0xB8, 0x55, 0xBA, // popcnt DX, word ptr [RBP-0x46]
0xF3, 0x0F, 0xB8, 0x55, 0xBC, // popcnt EDX,dword ptr [RBP-0x44]
0xF3, 0x48, 0x0F, 0xB8, 0x55, 0xC0 // popcnt RDX,qword ptr [RBP-0x40]
];
asm
{
call L1;
crc32 EAX, CL;
crc32 EAX, CX;
crc32 EAX, ECX;
crc32 RAX, CL;
crc32 RAX, RCX;
crc32 EDX, m8;
crc32 EDX, m16;
crc32 EDX, m32;
crc32 RDX, m8;
crc32 RDX, m64;
pcmpestri XMM1, XMM2, 2;
pcmpestri XMM3, m128, 2;
pcmpestrm XMM1, XMM2, 2;
pcmpestrm XMM3, m128, 2;
pcmpistri XMM1, XMM2, 2;
pcmpistri XMM3, m128, 2;
pcmpistrm XMM1, XMM2, 2;
pcmpistrm XMM3, m128, 2;
pcmpgtq XMM1, XMM2;
pcmpgtq XMM3, m128;
popcnt AX, CX;
popcnt EAX, ECX;
popcnt RAX, RCX;
popcnt DX, m16;
popcnt EDX, m32;
popcnt RDX, m64;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
void test60()
{
ubyte *p;
static ubyte[] data =
[
0x49, 0x8B, 0x00, // mov RAX, [R8]
0x4D, 0x8B, 0x00, // mov R8, [R8]
0x49, 0x89, 0x00, // mov [R8], RAX
0x4D, 0x89, 0x00, // mov [R8], R8
0x41, 0x0F, 0x10, 0x00, // movups XMM0, [R8]
0x45, 0x0F, 0x10, 0x00, // movups XMM8, [R8]
];
asm
{
call L1;
mov RAX, [R8];
mov R8, [R8];
mov [R8], RAX;
mov [R8], R8;
movups XMM0, [R8];
movups XMM8, [R8];
L1:
pop RAX;
mov p[RBP], RAX;
}
foreach (ref i, b; data)
{
assert(p[i] == b);
}
}
/* ======================= AVX ======================= */
void test61()
{
ubyte* p;
static ubyte[] data =
[
0x0F, 0x01, 0xD0, // xgetbv
0x0F, 0x01, 0xD1, // xsetbv
0x0F, 0xAE, 0x28, // xrstor [RAX]
0x48, 0x0F, 0xAE, 0x28, // xrstor64 [RAX]
0x0F, 0xAE, 0x20, // xsave [RAX]
0x48, 0x0F, 0xAE, 0x20, // xsave64 [RAX]
0x0F, 0xC7, 0x21, // xsavec [RCX]
0x48, 0x0F, 0xC7, 0x21, // xsavec64 [RCX]
0x0F, 0xAE, 0x30, // xsaveopt [RAX]
0x48, 0x0F, 0xAE, 0x30, // xsaveopt64 [RAX]
0xC5, 0xF8, 0xAE, 0x10, // vldmxcsr [RAX]
0xC5, 0xF8, 0xAE, 0x18, // vstmxcsr [RAX]
0xC5, 0xF2, 0x58, 0xC2, // vaddss XMM0, XMM1, XMM2;
0xC5, 0x83, 0x58, 0x00, // vaddsd XMM0, XMM15, [RAX];
0xC5, 0x78, 0x58, 0xE0, // vaddps XMM12, XMM0, XMM0;
0xC4, 0x41, 0x39, 0x58, 0xC0, // vaddpd XMM8, XMM8, XMM8;
0xC5, 0xF2, 0x5C, 0xC2, // vsubss XMM0, XMM1, XMM2;
0xC5, 0x83, 0x5C, 0x00, // vsubsd XMM0, XMM1, [RAX];
0xC5, 0x78, 0x5C, 0xE0, // vsubps XMM12, XMM0, XMM0;
0xC4, 0x41, 0x39, 0x5C, 0xC0, // vsubpd XMM8, XMM8, XMM8;
0xC5, 0xF3, 0xD0, 0xC2, // vaddsubps XMM0, XMM1, XMM2;
0xC5, 0xF7, 0xD0, 0xC2, // vaddsubps YMM0, YMM1, YMM2;
0xC5, 0x75, 0xD0, 0xC2, // vaddsubpd YMM8, YMM1, YMM2;
0xC5, 0x05, 0xD0, 0x78, 0x40, // vaddsubpd YMM15, YMM15, 64[RAX];
0xC4, 0xE3, 0x7D, 0x40, 0xC0, 0x00, // vdpps YMM0, YMM0, YMM0, 0
0xC4, 0xE3, 0x79, 0x41, 0xC0, 0x88, // vdppd XMM0, XMM0, XMM0, 0x88
0xC5, 0xBD, 0x7C, 0x07, // vhaddpd YMM0, YMM8, [RDI];
0xC5, 0xBB, 0x7C, 0xC1, // vhaddps XMM0, XMM8, XMM1;
0xC5, 0xFD, 0x5F, 0xC1, // vmaxpd YMM0, YMM0, YMM1;
0xC5, 0xF9, 0x5F, 0x00, // vmaxpd XMM0, XMM0, [RAX];
0xC5, 0xFC, 0x5F, 0xC1, // vmaxps YMM0, YMM0, YMM1;
0xC5, 0xF8, 0x5F, 0x00, // vmaxps XMM0, XMM0, [RAX];
0xC5, 0xFB, 0x5F, 0x00, // vmaxsd XMM0, XMM0, [RAX];
0xC5, 0xFA, 0x5F, 0x00, // vmaxss XMM0, XMM0, [RAX];
0xC5, 0xFD, 0x5D, 0xC1, // vminpd YMM0, YMM0, YMM1;
0xC5, 0xF9, 0x5D, 0x00, // vminpd XMM0, XMM0, [RAX];
0xC5, 0xFC, 0x5D, 0xC1, // vminps YMM0, YMM0, YMM1;
0xC5, 0xF8, 0x5D, 0x00, // vminps XMM0, XMM0, [RAX];
0xC5, 0xFB, 0x5D, 0x00, // vminsd XMM0, XMM0, [RAX];
0xC5, 0xFA, 0x5D, 0x00, // vminss XMM0, XMM0, [RAX];
0xC5, 0xF9, 0x50, 0xC0, // vmovmskpd EAX, XMM0;
0xC5, 0xFD, 0x50, 0xF8, // vmovmskpd EDI, YMM0;
0xC4, 0xC1, 0x7C, 0x50, 0xC7, // vmovmskps EAX, YMM15;
0xC5, 0x7C, 0x50, 0xC0, // vmovmskps R8D, YMM0;
0xC5, 0xF9, 0xD7, 0xC0, // vpmovmskb EAX, XMM0;
0xC4, 0xE3, 0x71, 0x42, 0xC2, 0x00, // vmpsadbw XMM0, XMM1, XMM2, 0x00;
0xC4, 0x43, 0x31, 0x42, 0xC2, 0xFF, // vmpsadbw XMM8, XMM9, XMM10, 0xFF;
0xC4, 0xE2, 0x79, 0x1C, 0x00, // vpabsb XMM0, [RAX];
0xC4, 0xC2, 0x79, 0x1D, 0xCF, // vpabsw XMM1, XMM15;
0xC4, 0xE2, 0x79, 0x1E, 0x0B, // vpabsd XMM1, [RBX];
0xC5, 0xF9, 0xFC, 0x00, // vpaddb XMM0, XMM0, [RAX];
0xC4, 0x41, 0x39, 0xFD, 0xC7, // vpaddw XMM8, XMM8, XMM15;
0xC5, 0x39, 0xFE, 0x03, // vpaddd XMM8, XMM8, [RBX];
0xC5, 0xF9, 0xD4, 0xC0, // vpaddq XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xF8, 0x00, // vpsubb XMM0, XMM0, [RAX];
0xC4, 0x41, 0x39, 0xF9, 0xC7, // vpsubw XMM8, XMM8, XMM15;
0xC5, 0x39, 0xFA, 0x03, // vpsubd XMM8, XMM8, [RBX];
0xC5, 0xF9, 0xFB, 0xC0, // vpsubq XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xEC, 0xC0, // vpaddsb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xED, 0xC0, // vpaddsw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xDC, 0xC0, // vpaddusb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xDD, 0xC0, // vpaddusw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xE8, 0xC0, // vpsubsb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xE9, 0xC0, // vpsubsw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xD8, 0xC0, // vpsubusb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xD9, 0xC0, // vpsubusw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xE0, 0xC0, // vpavgb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xE3, 0xC0, // vpavgw XMM0, XMM0, XMM0;
0x66, 0x0F, 0x3A, 0x44, 0x44, 0x88, 0x40, 0x00, // pclmulqdq XMM0, 64[RAX + 4 * RCX], 0;
0xC4, 0xE3, 0x79, 0x44, 0x44, 0x88, 0x40, 0x00, // vpclmulqdq XMM0, XMM0, 64[RAX + 4 * RCX], 0;
0xC4, 0xE2, 0x79, 0x01, 0xC0, // vphaddw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x02, 0xC0, // vphaddd XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x05, 0xC0, // vphsubw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x06, 0xC0, // vphsubd XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x03, 0xC0, // vphaddsw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x07, 0xC0, // vphsubsw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x41, 0xC0, // vphminposuw XMM0, XMM0;
0xC5, 0xF9, 0xF5, 0xC0, // vpmaddwd XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x04, 0xC0, // vpmaddubsw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x3C, 0xC0, // vpmaxsb XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x3D, 0xC0, // vpmaxsd XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xEE, 0xC0, // vpmaxsw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xDE, 0xC0, // vpmaxub XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x3F, 0xC0, // vpmaxud XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x3E, 0xC0, // vpmaxuw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x38, 0xC0, // vpminsb XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x39, 0xC0, // vpminsd XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xEA, 0xC0, // vpminsw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xDA, 0xC0, // vpminub XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x3B, 0xC0, // vpminud XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x3A, 0xC0, // vpminuw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x0B, 0xC0, // vpmulhrsw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xE4, 0xC0, // vpmulhuw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xE5, 0xC0, // vpmulhw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x40, 0xC0, // vpmulld XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xD5, 0xC0, // vpmullw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xF4, 0xC0, // vpmuludq XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x28, 0xC0, // vpmuldq XMM0, XMM0, XMM0;
0xC5, 0xF9, 0xF6, 0xC0, // vpsadbw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x08, 0xC0, // vpsignb XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x09, 0xC0, // vpsignw XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x0A, 0xC0, // vpsignd XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x73, 0xF8, 0x00, // vpslldq XMM0, XMM0, 0;
0xC5, 0xF9, 0x71, 0xF0, 0x00, // vpsllw XMM0, XMM0, 0;
0xC5, 0xF9, 0xF1, 0xC0, // vpsllw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x72, 0xF0, 0x00, // vpslld XMM0, XMM0, 0;
0xC5, 0xF9, 0xF2, 0xC0, // vpslld XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x73, 0xF0, 0x00, // vpsllq XMM0, XMM0, 0;
0xC5, 0xF9, 0xF3, 0xC0, // vpsllq XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x71, 0xE0, 0x00, // vpsraw XMM0, XMM0, 0;
0xC5, 0xF9, 0xE1, 0xC0, // vpsraw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x72, 0xE0, 0x00, // vpsrad XMM0, XMM0, 0;
0xC5, 0xF9, 0xE2, 0xC0, // vpsrad XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x73, 0xD8, 0x00, // vpsrldq XMM0, XMM0, 0;
0xC5, 0xF9, 0x71, 0xD0, 0x00, // vpsrlw XMM0, XMM0, 0;
0xC5, 0xF9, 0xD1, 0xC0, // vpsrlw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x72, 0xD0, 0x00, // vpsrld XMM0, XMM0, 0;
0xC5, 0xF9, 0xD2, 0xC0, // vpsrld XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x73, 0xD0, 0x00, // vpsrlq XMM0, XMM0, 0;
0xC5, 0xF9, 0xD3, 0xC0, // vpsrlq XMM0, XMM0, XMM0;
0xC5, 0xF8, 0x53, 0xC1, // vrcpps XMM0, XMM1;
0xC5, 0xFC, 0x53, 0xC1, // vrcpps YMM0, YMM1;
0xC5, 0xFA, 0x53, 0xC1, // vrcpss XMM0, XMM0, XMM1;
0xC4, 0xE3, 0x79, 0x09, 0xC0, 0x00, // vroundpd XMM0, XMM0, 0;
0xC4, 0xE3, 0x7D, 0x09, 0xC0, 0x00, // vroundpd YMM0, YMM0, 0;
0xC4, 0xE3, 0x79, 0x08, 0xC0, 0x00, // vroundps XMM0, XMM0, 0;
0xC4, 0xE3, 0x7D, 0x08, 0xC0, 0x00, // vroundps YMM0, YMM0, 0;
0xC4, 0xE3, 0x79, 0x0B, 0xC0, 0x00, // vroundsd XMM0, XMM0, XMM0, 0;
0xC4, 0xE3, 0x79, 0x0A, 0xC0, 0x00, // vroundss XMM0, XMM0, XMM0, 0;
0xC5, 0xF9, 0x51, 0xC0, // vsqrtpd XMM0, XMM0;
0xC5, 0xFD, 0x51, 0xC0, // vsqrtpd YMM0, YMM0;
0xC5, 0xF8, 0x51, 0xC0, // vsqrtps XMM0, XMM0;
0xC5, 0xFC, 0x51, 0xC0, // vsqrtps YMM0, YMM0;
0xC5, 0xFB, 0x51, 0xC0, // vsqrtsd XMM0, XMM0, XMM0;
0xC5, 0xFA, 0x51, 0xC0, // vsqrtss XMM0, XMM0, XMM0;
0xC5, 0xFC, 0x77, // vzeroall
0xC5, 0xF8, 0x77, // vzeroupper
0xC5, 0xF9, 0xC2, 0xC0, 0x00, // vcmppd XMM0, XMM0, XMM0, 0;
0xC5, 0xFD, 0xC2, 0xC0, 0x00, // vcmppd YMM0, YMM0, YMM0, 0;
0xC5, 0xF8, 0xC2, 0xC0, 0x00, // vcmpps XMM0, XMM0, XMM0, 0;
0xC5, 0xFC, 0xC2, 0xC0, 0x00, // vcmpps YMM0, YMM0, YMM0, 0;
0xC5, 0xFB, 0xC2, 0xC0, 0x00, // vcmpsd XMM0, XMM0, XMM0, 0;
0xC5, 0xFA, 0xC2, 0xC0, 0x00, // vcmpss XMM0, XMM0, XMM0, 0;
0xC5, 0xF9, 0x2F, 0xC0, // vcomisd XMM0, XMM0;
0xC5, 0xF8, 0x2F, 0xC0, // vcomiss XMM0, XMM0;
0xC5, 0xF9, 0x74, 0xC0, // vpcmpeqb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x75, 0xC0, // vpcmpeqw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x76, 0xC0, // vpcmpeqd XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x29, 0xC0, // vpcmpeqq XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x64, 0xC0, // vpcmpgtb XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x65, 0xC0, // vpcmpgtw XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x66, 0xC0, // vpcmpgtd XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x37, 0xC0, // vpcmpgtq XMM0, XMM0, XMM0;
0xC4, 0xE3, 0x79, 0x61, 0xC0, 0x00, // vpcmpestri XMM0, XMM0, 0;
0xC4, 0xE3, 0x79, 0x60, 0xC0, 0x00, // vpcmpestrm XMM0, XMM0, 0;
0xC4, 0xE3, 0x79, 0x63, 0xC0, 0x00, // vpcmpistri XMM0, XMM0, 0;
0xC4, 0xE3, 0x79, 0x62, 0xC0, 0x00, // vpcmpistrm XMM0, XMM0, 0;
0xC5, 0xFA, 0xE6, 0xC0, // vcvtdq2pd XMM0, XMM0;
0xC5, 0xFE, 0xE6, 0xC0, // vcvtdq2pd YMM0, XMM0;
0xC5, 0xFE, 0xE6, 0x00, // vcvtdq2pd YMM0, [RAX];
0xC5, 0xF8, 0x5B, 0xC0, // vcvtdq2ps XMM0, XMM0;
0xC5, 0xFC, 0x5B, 0xC0, // vcvtdq2ps YMM0, YMM0;
0xC5, 0xFC, 0x5B, 0x00, // vcvtdq2ps YMM0, [RAX];
0xC5, 0xFB, 0xE6, 0xC0, // vcvtpd2dq XMM0, XMM0;
0xC5, 0xFF, 0xE6, 0xC0, // vcvtpd2dq XMM0, YMM0;
0xC5, 0xFB, 0xE6, 0x00, // vcvtpd2dq XMM0, [RAX];
0xC5, 0xF9, 0x5A, 0xC0, // vcvtpd2ps XMM0, XMM0;
0xC5, 0xFD, 0x5A, 0xC0, // vcvtpd2ps XMM0, YMM0;
0xC5, 0xF9, 0x5A, 0x00, // vcvtpd2ps XMM0, [RAX];
0xC5, 0xF9, 0x5B, 0xC0, // vcvtps2dq XMM0, XMM0;
0xC5, 0xFD, 0x5B, 0xC0, // vcvtps2dq YMM0, YMM0;
0xC5, 0xFD, 0x5B, 0x00, // vcvtps2dq YMM0, [RAX];
0xC5, 0xF8, 0x5A, 0xC0, // vcvtps2pd XMM0, XMM0;
0xC5, 0xFC, 0x5A, 0xC0, // vcvtps2pd YMM0, XMM0;
0xC5, 0xFC, 0x5A, 0x00, // vcvtps2pd YMM0, [RAX];
0xC5, 0xFB, 0x2D, 0xC0, // vcvtsd2si EAX, XMM0;
0xC4, 0xE1, 0xFB, 0x2D, 0xC0, // vcvtsd2si RAX, XMM0;
0xC4, 0xE1, 0xFB, 0x2D, 0x00, // vcvtsd2si RAX, [RAX];
0xC5, 0xFB, 0x5A, 0xC0, // vcvtsd2ss XMM0, XMM0, XMM0;
0xC5, 0xFB, 0x5A, 0x00, // vcvtsd2ss XMM0, XMM0, [RAX];
0xC5, 0xFB, 0x2A, 0xC0, // vcvtsi2sd XMM0, XMM0, EAX;
0xC4, 0xE1, 0xFB, 0x2A, 0xC0, // vcvtsi2sd XMM0, XMM0, RAX;
0xC5, 0xFB, 0x2A, 0x00, // vcvtsi2sd XMM0, XMM0, [RAX];
0xC5, 0xFA, 0x2A, 0xC0, // vcvtsi2ss XMM0, XMM0, EAX;
0xC4, 0xE1, 0xFA, 0x2A, 0xC0, // vcvtsi2ss XMM0, XMM0, RAX;
0xC5, 0xFA, 0x2A, 0x00, // vcvtsi2ss XMM0, XMM0, [RAX];
0xC5, 0xFB, 0x2A, 0xC0, // vcvtsi2sd XMM0, XMM0, EAX;
0xC4, 0xE1, 0xFB, 0x2A, 0xC0, // vcvtsi2sd XMM0, XMM0, RAX;
0xC5, 0xFB, 0x2A, 0x00, // vcvtsi2sd XMM0, XMM0, [RAX];
0xC5, 0xFA, 0x2D, 0xC0, // vcvtss2si EAX, XMM0;
0xC4, 0xE1, 0xFA, 0x2D, 0xC0, // vcvtss2si RAX, XMM0;
0xC4, 0xE1, 0xFA, 0x2D, 0x00, // vcvtss2si RAX, [RAX];
0xC5, 0xF9, 0xE6, 0xC0, // vcvttpd2dq XMM0, XMM0;
0xC5, 0xFD, 0xE6, 0xC0, // vcvttpd2dq XMM0, YMM0;
0xC5, 0xF9, 0xE6, 0x00, // vcvttpd2dq XMM0, [RAX];
0xC5, 0xFA, 0x5B, 0xC0, // vcvttps2dq XMM0, XMM0;
0xC5, 0xFE, 0x5B, 0xC0, // vcvttps2dq YMM0, YMM0;
0xC5, 0xFE, 0x5B, 0x00, // vcvttps2dq YMM0, [RAX];
0xC5, 0xFB, 0x2C, 0xC0, // vcvttsd2si EAX, XMM0;
0xC4, 0xE1, 0xFB, 0x2C, 0xC0, // vcvttsd2si RAX, XMM0;
0xC4, 0xE1, 0xFB, 0x2C, 0x00, // vcvttsd2si RAX, [RAX];
0xC5, 0xFA, 0x2C, 0xC0, // vcvttss2si EAX, XMM0;
0xC4, 0xE1, 0xFA, 0x2C, 0xC0, // vcvttss2si RAX, XMM0;
0xC4, 0xE1, 0xFA, 0x2C, 0x00, // vcvttss2si RAX, [RAX];
0xC4, 0xE2, 0x79, 0x18, 0x00, // vbroadcastss XMM0, [RAX];
0xC4, 0xE2, 0x7D, 0x18, 0x00, // vbroadcastss YMM0, [RAX];
0xC4, 0xE2, 0x7D, 0x19, 0x00, // vbroadcastsd YMM0, [RAX];
0xC4, 0xE2, 0x7D, 0x1A, 0x00, // vbroadcastf128 YMM0, [RAX];
0xC4, 0xE3, 0x7D, 0x19, 0xC0, 0x00, // vextractf128 XMM0, YMM0, 0;
0xC4, 0xE3, 0x7D, 0x19, 0x00, 0x00, // vextractf128 [RAX], YMM0, 0;
0xC4, 0xE3, 0x79, 0x17, 0xC0, 0x00, // vextractps EAX, XMM0, 0;
0xC4, 0xE3, 0x79, 0x17, 0x00, 0x00, // vextractps [RAX], XMM0, 0;
0xC4, 0xE3, 0x7D, 0x18, 0xC0, 0x00, // vinsertf128 YMM0, YMM0, XMM0, 0;
0xC4, 0xE3, 0x7D, 0x18, 0x00, 0x00, // vinsertf128 YMM0, YMM0, [RAX], 0;
0xC4, 0xE3, 0x79, 0x21, 0xC0, 0x00, // vinsertps XMM0, XMM0, XMM0, 0;
0xC4, 0xE3, 0x79, 0x21, 0x00, 0x00, // vinsertps XMM0, XMM0, [RAX], 0;
0xC4, 0xE3, 0x79, 0x20, 0xC0, 0x00, // vpinsrb XMM0, XMM0, EAX, 0;
0xC4, 0xE3, 0x79, 0x20, 0x00, 0x00, // vpinsrb XMM0, XMM0, [RAX], 0;
0xC5, 0xF9, 0xC4, 0xC0, 0x00, // vpinsrw XMM0, XMM0, EAX, 0;
0xC5, 0xF9, 0xC4, 0x00, 0x00, // vpinsrw XMM0, XMM0, [RAX], 0;
0xC4, 0xE3, 0x79, 0x22, 0xC0, 0x00, // vpinsrd XMM0, XMM0, EAX, 0;
0xC4, 0xE3, 0x79, 0x22, 0x00, 0x00, // vpinsrd XMM0, XMM0, [RAX], 0;
0xC4, 0xE3, 0xF9, 0x22, 0xC0, 0x00, // vpinsrq XMM0, XMM0, RAX, 0;
0xC4, 0xE3, 0xF9, 0x22, 0x00, 0x00, // vpinsrq XMM0, XMM0, [RAX], 0;
0xC5, 0xFB, 0xF0, 0x00, // vlddqu XMM0, [RAX];
0xC5, 0xFF, 0xF0, 0x00, // vlddqu YMM0, [RAX];
0xC5, 0xF9, 0xF7, 0xC0, // vmaskmovdqu XMM0, XMM0;
0xC4, 0xE2, 0x79, 0x2C, 0x00, // vmaskmovps XMM0, XMM0, [RAX];
0xC4, 0xE2, 0x79, 0x2E, 0x00, // vmaskmovps [RAX], XMM0, XMM0;
0xC4, 0xE2, 0x7D, 0x2C, 0x00, // vmaskmovps YMM0, YMM0, [RAX];
0xC4, 0xE2, 0x7D, 0x2E, 0x00, // vmaskmovps [RAX], YMM0, YMM0;
0xC4, 0xE2, 0x79, 0x2D, 0x00, // vmaskmovpd XMM0, XMM0, [RAX];
0xC4, 0xE2, 0x79, 0x2F, 0x00, // vmaskmovpd [RAX], XMM0, XMM0;
0xC4, 0xE2, 0x7D, 0x2D, 0x00, // vmaskmovpd YMM0, YMM0, [RAX];
0xC4, 0xE2, 0x7D, 0x2F, 0x00, // vmaskmovpd [RAX], YMM0, YMM0;
0xC5, 0xFD, 0x28, 0x00, // vmovapd YMM0, [RAX];
0xC5, 0x7D, 0x28, 0x00, // vmovapd YMM8, [RAX];
0xC5, 0x7D, 0x28, 0x47, 0x40, // vmovapd YMM8, 64[RDI];
0xC5, 0xFD, 0x29, 0x00, // vmovapd [RAX], YMM0;
0xC5, 0x7D, 0x29, 0x00, // vmovapd [RAX], YMM8;
0xC5, 0x7D, 0x29, 0x47, 0x40, // vmovapd 64[RDI], YMM8;
0xC5, 0xFC, 0x28, 0x00, // vmovaps YMM0, [RAX];
0xC5, 0x7C, 0x28, 0x00, // vmovaps YMM8, [RAX];
0xC5, 0x7C, 0x28, 0x47, 0x40, // vmovaps YMM8, 64[RDI];
0xC5, 0xFC, 0x29, 0x00, // vmovaps [RAX], YMM0;
0xC5, 0x7C, 0x29, 0x00, // vmovaps [RAX], YMM8;
0xC5, 0x7C, 0x29, 0x47, 0x40, // vmovaps 64[RDI], YMM8;
0xC5, 0xFD, 0x10, 0x00, // vmovupd YMM0, [RAX];
0xC5, 0x7D, 0x10, 0x00, // vmovupd YMM8, [RAX];
0xC5, 0x7D, 0x10, 0x47, 0x40, // vmovupd YMM8, 64[RDI];
0xC5, 0xFD, 0x11, 0x00, // vmovupd [RAX], YMM0;
0xC5, 0x7D, 0x11, 0x00, // vmovupd [RAX], YMM8;
0xC5, 0x7D, 0x11, 0x47, 0x40, // vmovupd 64[RDI], YMM8;
0xC5, 0xFC, 0x10, 0x00, // vmovups YMM0, [RAX];
0xC5, 0x7C, 0x10, 0x00, // vmovups YMM8, [RAX];
0xC5, 0x7C, 0x10, 0x47, 0x40, // vmovups YMM8, 64[RDI];
0xC5, 0xFC, 0x11, 0x00, // vmovups [RAX], YMM0;
0xC5, 0x7C, 0x11, 0x00, // vmovups [RAX], YMM8;
0xC5, 0x7C, 0x11, 0x47, 0x40, // vmovups 64[RDI], YMM8;
0xC5, 0xF9, 0x6E, 0xC0, // vmovd XMM0, EAX;
0xC5, 0xF9, 0x6E, 0x00, // vmovd XMM0, [RAX];
0xC5, 0xF9, 0x7E, 0xC0, // vmovd EAX, XMM0;
0xC5, 0xF9, 0x7E, 0x00, // vmovd [RAX], XMM0;
0xC4, 0xE1, 0xF9, 0x6E, 0xC0, // vmovq XMM0, RAX;
0xC4, 0xE1, 0xF9, 0x6E, 0x00, // vmovq XMM0, [RAX];
0xC4, 0xE1, 0xF9, 0x7E, 0xC0, // vmovq RAX, XMM0;
0xC4, 0xE1, 0xF9, 0x7E, 0x00, // vmovq [RAX], XMM0;
0xC5, 0xF9, 0x6F, 0xC0, // vmovdqa XMM0, XMM0;
0xC5, 0xF9, 0x6F, 0x00, // vmovdqa XMM0, [RAX];
0xC5, 0xFD, 0x6F, 0xC0, // vmovdqa YMM0, YMM0;
0xC5, 0xFD, 0x6F, 0x00, // vmovdqa YMM0, [RAX];
0xC5, 0xF9, 0x6F, 0xC0, // vmovdqa XMM0, XMM0;
0xC5, 0xF9, 0x7F, 0x00, // vmovdqa [RAX], XMM0;
0xC5, 0xFD, 0x6F, 0xC0, // vmovdqa YMM0, YMM0;
0xC5, 0xFD, 0x7F, 0x00, // vmovdqa [RAX],YMM0;
0xC5, 0xFA, 0x6F, 0xC0, // vmovdqu XMM0, XMM0;
0xC5, 0xFA, 0x6F, 0x00, // vmovdqu XMM0, [RAX];
0xC5, 0xFE, 0x6F, 0xC0, // vmovdqu YMM0, YMM0;
0xC5, 0xFE, 0x6F, 0x00, // vmovdqu YMM0, [RAX];
0xC5, 0xFA, 0x6F, 0xC0, // vmovdqu XMM0, XMM0;
0xC5, 0xFA, 0x7F, 0x00, // vmovdqu [RAX], XMM0;
0xC5, 0xFE, 0x6F, 0xC0, // vmovdqu YMM0, YMM0;
0xC5, 0xFE, 0x7F, 0x00, // vmovdqu [RAX],YMM0;
0xC5, 0xF8, 0x12, 0xC0, // vmovhlps XMM0, XMM0, XMM0;
0xC5, 0xF8, 0x16, 0xC0, // vmovlhps XMM0, XMM0, XMM0;
0xC5, 0xF9, 0x16, 0x00, // vmovhpd XMM0, XMM0, [RAX];
0xC5, 0xF9, 0x17, 0x00, // vmovhpd [RAX], XMM0;
0xC5, 0xF8, 0x16, 0x00, // vmovhps XMM0, XMM0, [RAX];
0xC5, 0xF8, 0x17, 0x00, // vmovhps [RAX], XMM0;
0xC5, 0xF9, 0x12, 0x00, // vmovlpd XMM0, XMM0, [RAX];
0xC5, 0xF9, 0x13, 0x00, // vmovlpd [RAX], XMM0;
0xC5, 0xF8, 0x12, 0x00, // vmovlps XMM0, XMM0, [RAX];
0xC5, 0xF8, 0x13, 0x00, // vmovlps [RAX], XMM0;
0xC5, 0xF9, 0xE7, 0x00, // vmovntdq [RAX], XMM0;
0xC5, 0x7D, 0xE7, 0x00, // vmovntdq [RAX], YMM8;
0xC5, 0xF9, 0x2B, 0x00, // vmovntpd [RAX], XMM0;
0xC5, 0x7D, 0x2B, 0x00, // vmovntpd [RAX], YMM8;
0xC5, 0xF8, 0x2B, 0x00, // vmovntps [RAX], XMM0;
0xC5, 0x7C, 0x2B, 0x00, // vmovntps [RAX], YMM8;
0xC4, 0xE2, 0x79, 0x2A, 0x00, // vmovntdqa XMM0, [RAX];
0xC5, 0xFB, 0x10, 0xC0, // vmovsd XMM0, XMM0, XMM0;
0xC4, 0x41, 0x3B, 0x10, 0xC0, // vmovsd XMM8, XMM8, XMM8;
0xC5, 0xFB, 0x11, 0x00, // vmovsd [RAX], XMM0;
0xC4, 0x41, 0x7B, 0x11, 0x00, // vmovsd [R8], XMM8;
0xC5, 0xFA, 0x10, 0xC0, // vmovss XMM0, XMM0, XMM0;
0xC4, 0x41, 0x3A, 0x10, 0xC0, // vmovss XMM8, XMM8, XMM8;
0xC5, 0xFA, 0x11, 0x00, // vmovss [RAX], XMM0;
0xC4, 0x41, 0x7A, 0x11, 0x00, // vmovss [R8], XMM8;
0xC5, 0x7A, 0x16, 0xC1, // vmovshdup XMM8, XMM1;
0xC4, 0xC1, 0x7E, 0x16, 0xC0, // vmovshdup YMM0, YMM8;
0xC5, 0xFE, 0x16, 0x00, // vmovshdup YMM0, [RAX];
0xC5, 0x7A, 0x12, 0xC1, // vmovsldup XMM8, XMM1;
0xC4, 0xC1, 0x7E, 0x12, 0xC0, // vmovsldup YMM0, YMM8;
0xC5, 0xFE, 0x12, 0x00, // vmovsldup YMM0, [RAX];
0xC5, 0xF1, 0x67, 0xC2, // vpackuswb XMM0, XMM1, XMM2;
0xC5, 0xB9, 0x67, 0x00, // vpackuswb XMM0, XMM8, [RAX];
0xC4, 0xE2, 0x71, 0x2B, 0xC2, // vpackusdw XMM0, XMM1, XMM2;
0xC4, 0xE2, 0x39, 0x2B, 0x00, // vpackusdw XMM0, XMM8, [RAX];
0xC5, 0xF1, 0x63, 0xC2, // vpacksswb XMM0, XMM1, XMM2;
0xC5, 0xB9, 0x63, 0x00, // vpacksswb XMM0, XMM8, [RAX];
0xC5, 0xF1, 0x6B, 0xC2, // vpackssdw XMM0, XMM1, XMM2;
0xC5, 0xB9, 0x6B, 0x00, // vpackssdw XMM0, XMM8, [RAX];
0xC4, 0xE3, 0x71, 0x0F, 0xC2, 0xFF, // vpalignr XMM0, XMM1, XMM2, 0xFF;
0xC4, 0x63, 0x39, 0x0F, 0x08, 0x10, // vpalignr XMM9, XMM8, [RAX], 0x10;
0xC4, 0xE3, 0x79, 0x14, 0xC0, 0x00, // vpextrb EAX, XMM0, 0x0;
0xC4, 0x43, 0x79, 0x14, 0xCA, 0x0F, // vpextrb R10, XMM9, 0xF;
0xC4, 0x43, 0x79, 0x14, 0x0A, 0x0F, // vpextrb [R10], XMM9, 0xF;
0xC4, 0xE3, 0x79, 0x16, 0xC0, 0x00, // vpextrd EAX, XMM0, 0x0;
0xC4, 0x43, 0x79, 0x16, 0xC8, 0x0F, // vpextrd R8D, XMM9, 0xF;
0xC4, 0x43, 0x79, 0x16, 0x0A, 0x0F, // vpextrd [R10], XMM9, 0xF;
0xC4, 0xE3, 0xF9, 0x16, 0xC0, 0x00, // vpextrq RAX, XMM0, 0x0;
0xC4, 0x43, 0xF9, 0x16, 0xCA, 0x0F, // vpextrq R10, XMM9, 0xF;
0xC4, 0x43, 0xF9, 0x16, 0x0A, 0x0F, // vpextrq [R10], XMM9, 0xF;
0xC5, 0xF9, 0xC5, 0xCA, 0x03, // vpextrw ECX, XMM2, 0x3;
0xC5, 0xF9, 0xC5, 0xC0, 0x00, // vpextrw EAX, XMM0, 0x0;
0xC4, 0x41, 0x79, 0xC5, 0xD1, 0x0F, // vpextrw R10, XMM9, 0xF;
0xC4, 0x43, 0x79, 0x15, 0x0A, 0x0F, // vpextrw [R10], XMM9, 0xF;
0xC4, 0xE2, 0x79, 0x20, 0xC0, // vpmovsxbw XMM0, XMM0;
0xC4, 0x42, 0x79, 0x20, 0x00, // vpmovsxbw XMM8, [R8];
0xC4, 0xE2, 0x79, 0x21, 0xC0, // vpmovsxbd XMM0, XMM0;
0xC4, 0x42, 0x79, 0x21, 0x00, // vpmovsxbd XMM8, [R8];
0xC4, 0xE2, 0x79, 0x22, 0xC0, // vpmovsxbq XMM0, XMM0;
0xC4, 0x42, 0x79, 0x22, 0x00, // vpmovsxbq XMM8, [R8];
0xC4, 0xE2, 0x79, 0x23, 0xC0, // vpmovsxwd XMM0, XMM0;
0xC4, 0x42, 0x79, 0x23, 0x00, // vpmovsxwd XMM8, [R8];
0xC4, 0xE2, 0x79, 0x24, 0xC0, // vpmovsxwq XMM0, XMM0;
0xC4, 0x42, 0x79, 0x24, 0x00, // vpmovsxwq XMM8, [R8];
0xC4, 0xE2, 0x79, 0x25, 0xC0, // vpmovsxdq XMM0, XMM0;
0xC4, 0x42, 0x79, 0x25, 0x00, // vpmovsxdq XMM8, [R8];
0xC4, 0xE2, 0x79, 0x30, 0xC0, // vpmovzxbw XMM0, XMM0;
0xC4, 0x42, 0x79, 0x30, 0x00, // vpmovzxbw XMM8, [R8];
0xC4, 0xE2, 0x79, 0x31, 0xC0, // vpmovzxbd XMM0, XMM0;
0xC4, 0x42, 0x79, 0x31, 0x00, // vpmovzxbd XMM8, [R8];
0xC4, 0xE2, 0x79, 0x32, 0xC0, // vpmovzxbq XMM0, XMM0;
0xC4, 0x42, 0x79, 0x32, 0x00, // vpmovzxbq XMM8, [R8];
0xC4, 0xE2, 0x79, 0x33, 0xC0, // vpmovzxwd XMM0, XMM0;
0xC4, 0x42, 0x79, 0x33, 0x00, // vpmovzxwd XMM8, [R8];
0xC4, 0xE2, 0x79, 0x34, 0xC0, // vpmovzxwq XMM0, XMM0;
0xC4, 0x42, 0x79, 0x34, 0x00, // vpmovzxwq XMM8, [R8];
0xC4, 0xE2, 0x79, 0x35, 0xC0, // vpmovzxdq XMM0, XMM0;
0xC4, 0x42, 0x79, 0x35, 0x00, // vpmovzxdq XMM8, [R8];
0xC5, 0xF9, 0x54, 0xC0, // vandpd XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0x54, 0x08, // vandpd XMM9, XMM8, [R8];
0xC5, 0xF8, 0x54, 0xC0, // vandps XMM0, XMM0, XMM0;
0xC4, 0x41, 0x38, 0x54, 0x08, // vandps XMM9, XMM8, [R8];
0xC5, 0xF9, 0x55, 0xC0, // vandnpd XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0x55, 0x08, // vandnpd XMM9, XMM8, [R8];
0xC5, 0xF8, 0x55, 0xC0, // vandnps XMM0, XMM0, XMM0;
0xC4, 0x41, 0x38, 0x55, 0x08, // vandnps XMM9, XMM8, [R8];
0xC5, 0xF9, 0x56, 0xC0, // vorpd XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0x56, 0x08, // vorpd XMM9, XMM8, [R8];
0xC5, 0xF8, 0x56, 0xC0, // vorps XMM0, XMM0, XMM0;
0xC4, 0x41, 0x38, 0x56, 0x08, // vorps XMM9, XMM8, [R8];
0xC5, 0xF9, 0xDB, 0xC0, // vpand XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0xDB, 0x08, // vpand XMM9, XMM8, [R8];
0xC5, 0xF9, 0xDF, 0xC0, // vpandn XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0xDF, 0x08, // vpandn XMM9, XMM8, [R8];
0xC5, 0xF9, 0xEB, 0xC0, // vpor XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0xEB, 0x0A, // vpor XMM9, XMM8, [R10];
0xC5, 0xF9, 0xEF, 0xC0, // vpxor XMM0, XMM0, XMM0;
0xC4, 0x41, 0x39, 0xEF, 0x0A, // vpxor XMM9, XMM8, [R10];
0xC4, 0xE2, 0x79, 0x17, 0xC0, // vptest XMM0, XMM0;
0xC4, 0x62, 0x79, 0x17, 0x00, // vptest XMM8, [RAX];
0xC4, 0x42, 0x7D, 0x17, 0xC0, // vptest YMM8, YMM8;
0xC4, 0xC2, 0x7D, 0x17, 0x00, // vptest YMM0, [R8];
0xC5, 0xF9, 0x2E, 0xC0, // vucomisd XMM0, XMM0;
0xC5, 0x79, 0x2E, 0x00, // vucomisd XMM8, [RAX]
0xC5, 0xF8, 0x2E, 0xC0, // vucomiss YMM8, YMM8;
0xC5, 0x78, 0x2E, 0x00, // vucomiss YMM0, [R8];
0xC5, 0xB9, 0x57, 0xC0, // vxorpd XMM0, XMM8, XMM0;
0xC5, 0x79, 0x57, 0x00, // vxorpd XMM8, XMM0, [RAX];
0xC5, 0xBD, 0x57, 0xC0, // vxorpd YMM0, YMM8, YMM0;
0xC5, 0x7D, 0x57, 0x00, // vxorpd YMM8, YMM0, [RAX];
0xC5, 0xB8, 0x57, 0xC0, // vxorps XMM0, XMM8, XMM0;
0xC5, 0x78, 0x57, 0x00, // vxorps XMM8, XMM0, [RAX];
0xC5, 0xBC, 0x57, 0xC0, // vxorps YMM0, YMM8, YMM0;
0xC5, 0x7C, 0x57, 0x00, // vxorps YMM8, YMM0, [RAX];
0xC4, 0xE3, 0x71, 0x0D, 0xC2, 0x00, // vblendpd XMM0, XMM1, XMM2, 0x00;
0xC4, 0x63, 0x39, 0x0D, 0x08, 0xFF, // vblendpd XMM9, XMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x75, 0x0D, 0xC2, 0x00, // vblendpd YMM0, YMM1, YMM2, 0x00;
0xC4, 0x63, 0x3D, 0x0D, 0x08, 0xFF, // vblendpd YMM9, YMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x71, 0x0C, 0xC2, 0x00, // vblendps XMM0, XMM1, XMM2, 0x00;
0xC4, 0x63, 0x39, 0x0C, 0x08, 0xFF, // vblendps XMM9, XMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x75, 0x0C, 0xC2, 0x00, // vblendps YMM0, YMM1, YMM2, 0x00;
0xC4, 0x63, 0x3D, 0x0C, 0x08, 0xFF, // vblendps YMM9, YMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x71, 0x4B, 0xC2, 0x00, // vblendvpd XMM0, XMM1, XMM2, 0x00;
0xC4, 0x63, 0x39, 0x4B, 0x08, 0xff, // vblendvpd XMM9, XMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x75, 0x4B, 0xC2, 0x00, // vblendvpd YMM0, YMM1, YMM2, 0x00;
0xC4, 0x63, 0x3D, 0x4B, 0x08, 0xff, // vblendvpd YMM9, YMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x71, 0x4A, 0xC2, 0x00, // vblendvps XMM0, XMM1, XMM2, 0x00;
0xC4, 0x63, 0x39, 0x4A, 0x08, 0xff, // vblendvps XMM9, XMM8, [RAX], 0xFF;
0xC4, 0xE3, 0x75, 0x4A, 0xC2, 0x00, // vblendvps YMM0, YMM1, YMM2, 0x00;
0xC4, 0x63, 0x3D, 0x4A, 0x08, 0xff, // vblendvps YMM9, YMM8, [RAX], 0xFF;
0xC5, 0x7B, 0x12, 0xC0, // vmovddup XMM8, XMM0;
0xC5, 0xFB, 0x12, 0x00, // vmovddup XMM0, [RAX];
0xC4, 0xC1, 0x7F, 0x12, 0xC0, // vmovddup YMM0, YMM8;
0xC4, 0xC1, 0x7F, 0x12, 0x02, // vmovddup YMM0, [R10];
0xC4, 0xE3, 0x39, 0x4C, 0xC0, 0x00, // vpblendvb XMM0, XMM8, XMM0, 0x00;
0xC4, 0x63, 0x79, 0x4C, 0x00, 0x00, // vpblendvb XMM8, XMM0, [RAX], 0x00;
0xC4, 0x43, 0x79, 0x4C, 0x02, 0x00, // vpblendvb XMM8, XMM0, [R10], 0x00;
0xC4, 0xE3, 0x39, 0x0E, 0xC0, 0x00, // vpblendw XMM0, XMM8, XMM0, 0x00;
0xC4, 0x63, 0x79, 0x0E, 0x00, 0x00, // vpblendw XMM8, XMM0, [RAX], 0x00;
0xC4, 0x43, 0x79, 0x0E, 0x02, 0x00, // vpblendw XMM8, XMM0, [R10], 0x00;
0xC4, 0xE2, 0x71, 0x0D, 0xC2, // vpermilpd XMM0, XMM1, XMM2;
0xC4, 0xE2, 0x71, 0x0D, 0x00, // vpermilpd XMM0, XMM1, [RAX];
0xC4, 0xE3, 0x79, 0x05, 0xC1, 0x00, // vpermilpd XMM0, XMM1, 0x00;
0xC4, 0xE3, 0x79, 0x05, 0x00, 0x00, // vpermilpd XMM0, [RAX], 0x00;
0xC4, 0xE2, 0x71, 0x0C, 0xC2, // vpermilps XMM0, XMM1, XMM2;
0xC4, 0xE2, 0x71, 0x0C, 0x00, // vpermilps XMM0, XMM1, [RAX];
0xC4, 0xE3, 0x79, 0x04, 0xC1, 0x00, // vpermilps XMM0, XMM1, 0x00;
0xC4, 0xE3, 0x79, 0x04, 0x00, 0x00, // vpermilps XMM0, [RAX], 0x00;
0xC4, 0xE3, 0x75, 0x06, 0xC2, 0x00, // vperm2f128 YMM0, YMM1, YMM2, 0x00;
0xC4, 0xE3, 0x75, 0x06, 0x00, 0x00, // vperm2f128 YMM0, YMM1, [RAX], 0x00;
0xC4, 0x43, 0x35, 0x06, 0x02, 0x00, // vperm2f128 YMM8, YMM9, [R10], 0x00;
0xC4, 0xE2, 0x79, 0x00, 0xC0, // vpshufb XMM0, XMM0, XMM0;
0xC4, 0x42, 0x39, 0x00, 0x08, // vpshufb XMM9, XMM8, [R8];
0xC5, 0xF9, 0x70, 0xC0, 0x00, // vpshufd XMM0, XMM0, 0x0;
0xC4, 0x41, 0x79, 0x70, 0x00, 0x00, // vpshufd XMM8, [R8], 0x0;
0xC5, 0xFA, 0x70, 0xC0, 0x00, // vpshufhw XMM0, XMM0, 0x0;
0xC4, 0x41, 0x7A, 0x70, 0x00, 0x00, // vpshufhw XMM8, [R8], 0x0;
0xC5, 0xFB, 0x70, 0xC0, 0x00, // vpshuflw XMM0, XMM0, 0x0;
0xC4, 0x41, 0x7B, 0x70, 0x00, 0x00, // vpshuflw XMM8, [R8], 0x0;
0xC5, 0xF1, 0x68, 0xC2, // vpunpckhbw XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x68, 0x00, // vpunpckhbw XMM8, XMM8, [R8];
0xC5, 0xF1, 0x69, 0xC2, // vpunpckhwd XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x69, 0x00, // vpunpckhwd XMM8, XMM8, [R8];
0xC5, 0xF1, 0x6A, 0xC2, // vpunpckhdq XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x6A, 0x00, // vpunpckhdq XMM8, XMM8, [R8];
0xC5, 0xF1, 0x6D, 0xC2, // vpunpckhqdq XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x6D, 0x00, // vpunpckhqdq XMM8, XMM8, [R8];
0xC5, 0xF1, 0x60, 0xC2, // vpunpcklbw XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x60, 0x00, // vpunpcklbw XMM8, XMM8, [R8];
0xC5, 0xF1, 0x61, 0xC2, // vpunpcklwd XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x61, 0x00, // vpunpcklwd XMM8, XMM8, [R8];
0xC5, 0xF1, 0x62, 0xC2, // vpunpckldq XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x62, 0x00, // vpunpckldq XMM8, XMM8, [R8];
0xC5, 0xF1, 0x6C, 0xC2, // vpunpcklqdq XMM0, XMM1, XMM2;
0xC4, 0x41, 0x39, 0x6C, 0x00, // vpunpcklqdq XMM8, XMM8, [R8];
0xC5, 0xF9, 0xC6, 0xC0, 0x00, // vshufpd XMM0, XMM0, XMM0, 0x00;
0xC4, 0xC1, 0x39, 0xC6, 0x00, 0x00, // vshufpd XMM0, XMM8, [R8], 0x00;
0xC4, 0x41, 0x7D, 0xC6, 0xC0, 0x00, // vshufpd YMM8, YMM0, YMM8, 0x00;
0xC5, 0x7D, 0xC6, 0x00, 0x00, // vshufpd YMM8, YMM0, [RAX], 0x00;
0xC5, 0xF8, 0xC6, 0xC0, 0x00, // vshufps XMM0, XMM0, XMM0, 0x00;
0xC4, 0xC1, 0x38, 0xC6, 0x00, 0x00, // vshufps XMM0, XMM8, [R8], 0x00;
0xC4, 0x41, 0x7C, 0xC6, 0xC0, 0x00, // vshufps YMM8, YMM0, YMM8, 0x00;
0xC5, 0x7C, 0xC6, 0x00, 0x00, // vshufps YMM8, YMM0, [RAX], 0x00;
0xC5, 0xF9, 0x15, 0xC0, // vunpckhpd XMM0, XMM0, XMM0;
0xC5, 0x39, 0x15, 0x00, // vunpckhpd XMM8, XMM8, [RAX];
0xC4, 0x41, 0x7D, 0x15, 0x00, // vunpckhpd YMM8, YMM0, [R8];
0xC4, 0xC1, 0x3D, 0x15, 0x00, // vunpckhpd YMM0, YMM8, [R8];
0xC5, 0xF8, 0x15, 0xC0, // vunpckhps XMM0, XMM0, XMM0;
0xC5, 0x38, 0x15, 0x00, // vunpckhps XMM8, XMM8, [RAX];
0xC4, 0x41, 0x7C, 0x15, 0x00, // vunpckhps YMM8, YMM0, [R8];
0xC4, 0xC1, 0x3C, 0x15, 0x00, // vunpckhps YMM0, YMM8, [R8];
0xC5, 0xF9, 0x14, 0xC0, // vunpcklpd XMM0, XMM0, XMM0;
0xC5, 0x39, 0x14, 0x00, // vunpcklpd XMM8, XMM8, [RAX];
0xC4, 0x41, 0x7D, 0x14, 0x00, // vunpcklpd YMM8, YMM0, [R8];
0xC4, 0xC1, 0x3D, 0x14, 0x00, // vunpcklpd YMM0, YMM8, [R8];
0xC5, 0xF8, 0x14, 0xC0, // vunpcklps XMM0, XMM0, XMM0;
0xC5, 0x38, 0x14, 0x00, // vunpcklps XMM8, XMM8, [RAX];
0xC4, 0x41, 0x7C, 0x14, 0x00, // vunpcklps YMM8, YMM0, [R8];
0xC4, 0xC1, 0x3C, 0x14, 0x00, // vunpcklps YMM0, YMM8, [R8];
/* AES */
0x66, 0x0F, 0x38, 0xDC, 0xC0, // aesenc XMM0, XMM0;
0x66, 0x0F, 0x38, 0xDC, 0x00, // aesenc XMM0, [RAX];
0xC4, 0xE2, 0x79, 0xDC, 0xC0, // vaesenc XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0xDC, 0x00, // vaesenc XMM0, XMM0, [RAX];
0x66, 0x0F, 0x38, 0xDD, 0xC0, // aesenclast XMM0, XMM0;
0x66, 0x0F, 0x38, 0xDD, 0x00, // aesenclast XMM0, [RAX];
0xC4, 0xE2, 0x79, 0xDD, 0xC0, // vaesenclast XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0xDD, 0x00, // vaesenclast XMM0, XMM0, [RAX];
0x66, 0x0F, 0x38, 0xDE, 0xC0, // aesdec XMM0, XMM0;
0x66, 0x0F, 0x38, 0xDE, 0x00, // aesdec XMM0, [RAX];
0xC4, 0xE2, 0x79, 0xDE, 0xC0, // vaesdec XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0xDE, 0x00, // vaesdec XMM0, XMM0, [RAX];
0x66, 0x0F, 0x38, 0xDF, 0xC0, // aesdeclast XMM0, XMM0;
0x66, 0x0F, 0x38, 0xDF, 0x00, // aesdeclast XMM0, [RAX];
0xC4, 0xE2, 0x79, 0xDF, 0xC0, // vaesdeclast XMM0, XMM0, XMM0;
0xC4, 0xE2, 0x79, 0xDF, 0x00, // vaesdeclast XMM0, XMM0, [RAX];
0x66, 0x0F, 0x38, 0xDB, 0xC0, // aesimc XMM0, XMM0;
0x66, 0x0F, 0x38, 0xDB, 0x00, // aesimc XMM0, [RAX];
0xC4, 0xE2, 0x79, 0xDB, 0xC0, // vaesimc XMM0, XMM0;
0xC4, 0xE2, 0x79, 0xDB, 0x00, // vaesimc XMM0, [RAX];
0x66, 0x0F, 0x3A, 0xDF, 0xC0, 0x00, // aeskeygenassist XMM0, XMM0, 0x0;
0x66, 0x0F, 0x3A, 0xDF, 0x00, 0x00, // aeskeygenassist XMM0, [RAX], 0x0;
0xC4, 0xE3, 0x79, 0xDF, 0xC0, 0x00, // vaeskeygenassist XMM0, XMM0, 0x0;
0xC4, 0xE3, 0x79, 0xDF, 0x00, 0x00, // vaeskeygenassist XMM0, [RAX], 0x0;
/* FSGSBASE */
0xf3, 0x48, 0x0f, 0xae, 0xc0, // rdfsbase RAX;
0xf3, 0x49, 0x0f, 0xae, 0xc7, // rdfsbase R15;
0xf3, 0x48, 0x0f, 0xae, 0xc8, // rdgsbase RAX;
0xf3, 0x49, 0x0f, 0xae, 0xcf, // rdgsbase R15;
0xf3, 0x48, 0x0f, 0xae, 0xd0, // wrfsbase RAX;
0xf3, 0x49, 0x0f, 0xae, 0xd7, // wrfsbase R15;
0xf3, 0x48, 0x0f, 0xae, 0xd8, // wrgsbase RAX;
0xf3, 0x49, 0x0f, 0xae, 0xdf, // wrgsbase R15;
/* RDRAND */
0x66, 0x0f, 0xc7, 0xf0, // rdrand AX;
0x0f, 0xc7, 0xf0, // rdrand EAX;
0x48, 0x0f, 0xc7, 0xf0, // rdrand RAX;
0x66, 0x41, 0x0f, 0xc7, 0xf7, // rdrand R15W;
0x41, 0x0f, 0xc7, 0xf7, // rdrand R15D;
0x49, 0x0f, 0xc7, 0xf7, // rdrand R15;
/* RDSEED */
0x66, 0x0f, 0xc7, 0xf8, // rdseed AX;
0x0f, 0xc7, 0xf8, // rdseed EAX;
0x48, 0x0f, 0xc7, 0xf8, // rdseed RAX;
0x66, 0x41, 0x0f, 0xc7, 0xff, // rdseed R15W;
0x41, 0x0f, 0xc7, 0xff, // rdseed R15D;
0x49, 0x0f, 0xc7, 0xff, // rdseed R15;
/* FP16C */
0xc4, 0xe2, 0x79, 0x13, 0xc0, // vcvtph2ps XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x13, 0x00, // vcvtph2ps XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0x13, 0xc0, // vcvtph2ps YMM0, XMM0;
0xc4, 0x42, 0x7d, 0x13, 0x00, // vcvtph2ps YMM8, [R8];
0xc4, 0xe3, 0x79, 0x1d, 0xc0, 0x00, // vcvtps2ph XMM0, XMM0, 0x0;
0xc4, 0xe3, 0x79, 0x1d, 0x00, 0x00, // vcvtps2ph [RAX], XMM0, 0x0;
0xc4, 0xe3, 0x7d, 0x1d, 0xc0, 0x00, // vcvtps2ph XMM0, YMM0, 0x0;
0xc4, 0x43, 0x7d, 0x1d, 0x00, 0x00, // vcvtps2ph [R8], YMM8, 0x0;
/* FMA */
0xc4, 0xe2, 0xf9, 0x98, 0xc0, // vfmadd132pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0x98, 0x00, // vfmadd132pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0x98, 0xc0, // vfmadd132pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0x98, 0x00, // vfmadd132pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0x98, 0xc0, // vfmadd132ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x98, 0x00, // vfmadd132ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0x98, 0xc0, // vfmadd132ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0x98, 0x00, // vfmadd132ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0x99, 0xc0, // vfmadd132sd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0x99, 0x00, // vfmadd132sd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x79, 0x99, 0xc0, // vfmadd132ss XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x99, 0x00, // vfmadd132ss XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xf9, 0xA8, 0xc0, // vfmadd213pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xA8, 0x00, // vfmadd213pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xA8, 0xc0, // vfmadd213pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xA8, 0x00, // vfmadd213pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xA8, 0xc0, // vfmadd213ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xA8, 0x00, // vfmadd213ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xA8, 0xc0, // vfmadd213ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xA8, 0x00, // vfmadd213ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xA9, 0xc0, // vfmadd213sd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xA9, 0x00, // vfmadd213sd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x79, 0xA9, 0xc0, // vfmadd213ss XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xA9, 0x00, // vfmadd213ss XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xf9, 0xB8, 0xc0, // vfmadd231pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xB8, 0x00, // vfmadd231pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xB8, 0xc0, // vfmadd231pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xB8, 0x00, // vfmadd231pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xB8, 0xc0, // vfmadd231ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xB8, 0x00, // vfmadd231ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xB8, 0xc0, // vfmadd231ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xB8, 0x00, // vfmadd231ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xB9, 0xc0, // vfmadd231sd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xB9, 0x00, // vfmadd231sd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x79, 0xB9, 0xc0, // vfmadd231ss XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xB9, 0x00, // vfmadd231ss XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xf9, 0x96, 0xc0, // vfmaddsub132pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0x96, 0x00, // vfmaddsub132pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0x96, 0xc0, // vfmaddsub132pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0x96, 0x00, // vfmaddsub132pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0x96, 0xc0, // vfmaddsub132ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x96, 0x00, // vfmaddsub132ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0x96, 0xc0, // vfmaddsub132ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0x96, 0x00, // vfmaddsub132ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xA6, 0xc0, // vfmaddsub213pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xA6, 0x00, // vfmaddsub213pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xA6, 0xc0, // vfmaddsub213pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xA6, 0x00, // vfmaddsub213pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xA6, 0xc0, // vfmaddsub213ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xA6, 0x00, // vfmaddsub213ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xA6, 0xc0, // vfmaddsub213ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xA6, 0x00, // vfmaddsub213ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xB6, 0xc0, // vfmaddsub231pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xB6, 0x00, // vfmaddsub231pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xB6, 0xc0, // vfmaddsub231pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xB6, 0x00, // vfmaddsub231pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xB6, 0xc0, // vfmaddsub231ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xB6, 0x00, // vfmaddsub231ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xB6, 0xc0, // vfmaddsub231ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xB6, 0x00, // vfmaddsub231ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0x97, 0xc0, // vfmsubadd132pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0x97, 0x00, // vfmsubadd132pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0x97, 0xc0, // vfmsubadd132pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0x97, 0x00, // vfmsubadd132pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0x97, 0xc0, // vfmsubadd132ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x97, 0x00, // vfmsubadd132ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0x97, 0xc0, // vfmsubadd132ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0x97, 0x00, // vfmsubadd132ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xA7, 0xc0, // vfmsubadd213pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xA7, 0x00, // vfmsubadd213pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xA7, 0xc0, // vfmsubadd213pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xA7, 0x00, // vfmsubadd213pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xA7, 0xc0, // vfmsubadd213ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xA7, 0x00, // vfmsubadd213ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xA7, 0xc0, // vfmsubadd213ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xA7, 0x00, // vfmsubadd213ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xB7, 0xc0, // vfmsubadd231pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xB7, 0x00, // vfmsubadd231pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xB7, 0xc0, // vfmsubadd231pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xB7, 0x00, // vfmsubadd231pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xB7, 0xc0, // vfmsubadd231ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xB7, 0x00, // vfmsubadd231ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xB7, 0xc0, // vfmsubadd231ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xB7, 0x00, // vfmsubadd231ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0x9A, 0xc0, // vfmsub132pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0x9A, 0x00, // vfmsub132pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0x9A, 0xc0, // vfmsub132pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0x9A, 0x00, // vfmsub132pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0x9A, 0xc0, // vfmsub132ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x9A, 0x00, // vfmsub132ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0x9A, 0xc0, // vfmsub132ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0x9A, 0x00, // vfmsub132ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0x9B, 0xc0, // vfmsub132sd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0x9B, 0x00, // vfmsub132sd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x79, 0x9B, 0xc0, // vfmsub132ss XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0x9B, 0x00, // vfmsub132ss XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xf9, 0xAA, 0xc0, // vfmsub213pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xAA, 0x00, // vfmsub213pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xAA, 0xc0, // vfmsub213pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xAA, 0x00, // vfmsub213pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xAA, 0xc0, // vfmsub213ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xAA, 0x00, // vfmsub213ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xAA, 0xc0, // vfmsub213ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xAA, 0x00, // vfmsub213ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xAB, 0xc0, // vfmsub213sd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xAB, 0x00, // vfmsub213sd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x79, 0xAB, 0xc0, // vfmsub213ss XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xAB, 0x00, // vfmsub213ss XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xf9, 0xBA, 0xc0, // vfmsub231pd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xBA, 0x00, // vfmsub231pd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0xfd, 0xBA, 0xc0, // vfmsub231pd YMM0, YMM0, YMM0;
0xc4, 0x42, 0xbd, 0xBA, 0x00, // vfmsub231pd YMM8, YMM8, [R8];
0xc4, 0xe2, 0x79, 0xBA, 0xc0, // vfmsub231ps XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xBA, 0x00, // vfmsub231ps XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x7d, 0xBA, 0xc0, // vfmsub231ps YMM0, YMM0, YMM0;
0xc4, 0x42, 0x3d, 0xBA, 0x00, // vfmsub231ps YMM8, YMM8, [R8];
0xc4, 0xe2, 0xf9, 0xBB, 0xc0, // vfmsub231sd XMM0, XMM0, XMM0;
0xc4, 0xe2, 0xf9, 0xBB, 0x00, // vfmsub231sd XMM0, XMM0, [RAX];
0xc4, 0xe2, 0x79, 0xBB, 0xc0, // vfmsub231ss XMM0, XMM0, XMM0;
0xc4, 0xe2, 0x79, 0xBB, 0x00, // vfmsub231ss XMM0, XMM0, [RAX];
// 0x58, // pop RAX
];
asm
{
call L1;
xgetbv;
xsetbv;
xrstor [RAX];
xrstor64 [RAX];
xsave [RAX];
xsave64 [RAX];
xsavec [RCX];
xsavec64 [RCX];
xsaveopt [RAX];
xsaveopt64 [RAX];
vldmxcsr [RAX];
vstmxcsr [RAX];
vaddss XMM0, XMM1, XMM2;
vaddsd XMM0, XMM15, [RAX];
vaddps XMM12, XMM0, XMM0;
vaddpd XMM8, XMM8, XMM8;
vsubss XMM0, XMM1, XMM2;
vsubsd XMM0, XMM15, [RAX];
vsubps XMM12, XMM0, XMM0;
vsubpd XMM8, XMM8, XMM8;
vaddsubps XMM0, XMM1, XMM2;
vaddsubps YMM0, YMM1, YMM2;
vaddsubpd YMM8, YMM1, YMM2;
vaddsubpd YMM15, YMM15, 64[RAX];
vdpps YMM0, YMM0, YMM0, 0;
vdppd XMM0, XMM0, XMM0, 0x88;
vhaddpd YMM0, YMM8, [RDI];
vhaddps XMM0, XMM8, XMM1;
vmaxpd YMM0, YMM0, YMM1;
vmaxpd XMM0, XMM0, [RAX];
vmaxps YMM0, YMM0, YMM1;
vmaxps XMM0, XMM0, [RAX];
vmaxsd XMM0, XMM0, [RAX];
vmaxss XMM0, XMM0, [RAX];
vminpd YMM0, YMM0, YMM1;
vminpd XMM0, XMM0, [RAX];
vminps YMM0, YMM0, YMM1;
vminps XMM0, XMM0, [RAX];
vminsd XMM0, XMM0, [RAX];
vminss XMM0, XMM0, [RAX];
vmovmskpd EAX, XMM0;
vmovmskpd EDI, YMM0;
vmovmskps EAX, YMM15;
vmovmskps R8D, YMM0;
vpmovmskb EAX, XMM0;
vmpsadbw XMM0, XMM1, XMM2, 0x00;
vmpsadbw XMM8, XMM9, XMM10, 0xFF;
vpabsb XMM0, [RAX];
vpabsw XMM1, XMM15;
vpabsd XMM1, [RBX];
vpaddb XMM0, XMM0, [RAX];
vpaddw XMM8, XMM8, XMM15;
vpaddd XMM8, XMM8, [RBX];
vpaddq XMM0, XMM0, XMM0;
vpsubb XMM0, XMM0, [RAX];
vpsubw XMM8, XMM8, XMM15;
vpsubd XMM8, XMM8, [RBX];
vpsubq XMM0, XMM0, XMM0;
vpaddsb XMM0, XMM0, XMM0;
vpaddsw XMM0, XMM0, XMM0;
vpaddusb XMM0, XMM0, XMM0;
vpaddusw XMM0, XMM0, XMM0;
vpsubsb XMM0, XMM0, XMM0;
vpsubsw XMM0, XMM0, XMM0;
vpsubusb XMM0, XMM0, XMM0;
vpsubusw XMM0, XMM0, XMM0;
vpavgb XMM0, XMM0, XMM0;
vpavgw XMM0, XMM0, XMM0;
pclmulqdq XMM0, 64[RAX + 4 * RCX], 0;
vpclmulqdq XMM0, XMM0, 64[RAX + 4 * RCX], 0;
vphaddw XMM0, XMM0, XMM0;
vphaddd XMM0, XMM0, XMM0;
vphsubw XMM0, XMM0, XMM0;
vphsubd XMM0, XMM0, XMM0;
vphaddsw XMM0, XMM0, XMM0;
vphsubsw XMM0, XMM0, XMM0;
vphminposuw XMM0, XMM0;
vpmaddwd XMM0, XMM0, XMM0;
vpmaddubsw XMM0, XMM0, XMM0;
vpmaxsb XMM0, XMM0, XMM0;
vpmaxsd XMM0, XMM0, XMM0;
vpmaxsw XMM0, XMM0, XMM0;
vpmaxub XMM0, XMM0, XMM0;
vpmaxud XMM0, XMM0, XMM0;
vpmaxuw XMM0, XMM0, XMM0;
vpminsb XMM0, XMM0, XMM0;
vpminsd XMM0, XMM0, XMM0;
vpminsw XMM0, XMM0, XMM0;
vpminub XMM0, XMM0, XMM0;
vpminud XMM0, XMM0, XMM0;
vpminuw XMM0, XMM0, XMM0;
vpmulhrsw XMM0, XMM0, XMM0;
vpmulhuw XMM0, XMM0, XMM0;
vpmulhw XMM0, XMM0, XMM0;
vpmulld XMM0, XMM0, XMM0;
vpmullw XMM0, XMM0, XMM0;
vpmuludq XMM0, XMM0, XMM0;
vpmuldq XMM0, XMM0, XMM0;
vpsadbw XMM0, XMM0, XMM0;
vpsignb XMM0, XMM0, XMM0;
vpsignw XMM0, XMM0, XMM0;
vpsignd XMM0, XMM0, XMM0;
vpslldq XMM0, XMM0, 0;
vpsllw XMM0, XMM0, 0;
vpsllw XMM0, XMM0, XMM0;
vpslld XMM0, XMM0, 0;
vpslld XMM0, XMM0, XMM0;
vpsllq XMM0, XMM0, 0;
vpsllq XMM0, XMM0, XMM0;
vpsraw XMM0, XMM0, 0;
vpsraw XMM0, XMM0, XMM0;
vpsrad XMM0, XMM0, 0;
vpsrad XMM0, XMM0, XMM0;
vpsrldq XMM0, XMM0, 0;
vpsrlw XMM0, XMM0, 0;
vpsrlw XMM0, XMM0, XMM0;
vpsrld XMM0, XMM0, 0;
vpsrld XMM0, XMM0, XMM0;
vpsrlq XMM0, XMM0, 0;
vpsrlq XMM0, XMM0, XMM0;
vrcpps XMM0, XMM1;
vrcpps YMM0, YMM1;
vrcpss XMM0, XMM0, XMM1;
vroundpd XMM0, XMM0, 0;
vroundpd YMM0, YMM0, 0;
vroundps XMM0, XMM0, 0;
vroundps YMM0, YMM0, 0;
vroundsd XMM0, XMM0, XMM0, 0;
vroundss XMM0, XMM0, XMM0, 0;
vsqrtpd XMM0, XMM0;
vsqrtpd YMM0, YMM0;
vsqrtps XMM0, XMM0;
vsqrtps YMM0, YMM0;
vsqrtsd XMM0, XMM0, XMM0;
vsqrtss XMM0, XMM0, XMM0;
vzeroall;
vzeroupper;
vcmppd XMM0, XMM0, XMM0, 0;
vcmppd YMM0, YMM0, YMM0, 0;
vcmpps XMM0, XMM0, XMM0, 0;
vcmpps YMM0, YMM0, YMM0, 0;
vcmpsd XMM0, XMM0, XMM0, 0;
vcmpss XMM0, XMM0, XMM0, 0;
vcomisd XMM0, XMM0;
vcomiss XMM0, XMM0;
vpcmpeqb XMM0, XMM0, XMM0;
vpcmpeqw XMM0, XMM0, XMM0;
vpcmpeqd XMM0, XMM0, XMM0;
vpcmpeqq XMM0, XMM0, XMM0;
vpcmpgtb XMM0, XMM0, XMM0;
vpcmpgtw XMM0, XMM0, XMM0;
vpcmpgtd XMM0, XMM0, XMM0;
vpcmpgtq XMM0, XMM0, XMM0;
vpcmpestri XMM0, XMM0, 0;
vpcmpestrm XMM0, XMM0, 0;
vpcmpistri XMM0, XMM0, 0;
vpcmpistrm XMM0, XMM0, 0;
vcvtdq2pd XMM0, XMM0;
vcvtdq2pd YMM0, XMM0;
vcvtdq2pd YMM0, [RAX];
vcvtdq2ps XMM0, XMM0;
vcvtdq2ps YMM0, YMM0;
vcvtdq2ps YMM0, [RAX];
vcvtpd2dq XMM0, XMM0;
vcvtpd2dq XMM0, YMM0;
vcvtpd2dq XMM0, [RAX];
vcvtpd2ps XMM0, XMM0;
vcvtpd2ps XMM0, YMM0;
vcvtpd2ps XMM0, [RAX];
vcvtps2dq XMM0, XMM0;
vcvtps2dq YMM0, YMM0;
vcvtps2dq YMM0, [RAX];
vcvtps2pd XMM0, XMM0;
vcvtps2pd YMM0, XMM0;
vcvtps2pd YMM0, [RAX];
vcvtsd2si EAX, XMM0;
vcvtsd2si RAX, XMM0;
vcvtsd2si RAX, [RAX];
vcvtsd2ss XMM0, XMM0, XMM0;
vcvtsd2ss XMM0, XMM0, [RAX];
vcvtsi2sd XMM0, XMM0, EAX;
vcvtsi2sd XMM0, XMM0, RAX;
vcvtsi2sd XMM0, XMM0, [RAX];
vcvtsi2ss XMM0, XMM0, EAX;
vcvtsi2ss XMM0, XMM0, RAX;
vcvtsi2ss XMM0, XMM0, [RAX];
vcvtsi2sd XMM0, XMM0, EAX;
vcvtsi2sd XMM0, XMM0, RAX;
vcvtsi2sd XMM0, XMM0, [RAX];
vcvtss2si EAX, XMM0;
vcvtss2si RAX, XMM0;
vcvtss2si RAX, [RAX];
vcvttpd2dq XMM0, XMM0;
vcvttpd2dq XMM0, YMM0;
vcvttpd2dq XMM0, [RAX];
vcvttps2dq XMM0, XMM0;
vcvttps2dq YMM0, YMM0;
vcvttps2dq YMM0, [RAX];
vcvttsd2si EAX, XMM0;
vcvttsd2si RAX, XMM0;
vcvttsd2si RAX, [RAX];
vcvttss2si EAX, XMM0;
vcvttss2si RAX, XMM0;
vcvttss2si RAX, [RAX];
vbroadcastss XMM0, [RAX];
vbroadcastss YMM0, [RAX];
vbroadcastsd YMM0, [RAX];
vbroadcastf128 YMM0, [RAX];
vextractf128 XMM0, YMM0, 0;
vextractf128 [RAX], YMM0, 0;
vextractps EAX, XMM0, 0;
vextractps [RAX], XMM0, 0;
vinsertf128 YMM0, YMM0, XMM0, 0;
vinsertf128 YMM0, YMM0, [RAX], 0;
vinsertps XMM0, XMM0, XMM0, 0;
vinsertps XMM0, XMM0, [RAX], 0;
vpinsrb XMM0, XMM0, EAX, 0;
vpinsrb XMM0, XMM0, [RAX], 0;
vpinsrw XMM0, XMM0, EAX, 0;
vpinsrw XMM0, XMM0, [RAX], 0;
vpinsrd XMM0, XMM0, EAX, 0;
vpinsrd XMM0, XMM0, [RAX], 0;
vpinsrq XMM0, XMM0, RAX, 0;
vpinsrq XMM0, XMM0, [RAX], 0;
vlddqu XMM0, [RAX];
vlddqu YMM0, [RAX];
vmaskmovdqu XMM0, XMM0;
vmaskmovps XMM0, XMM0, [RAX];
vmaskmovps [RAX], XMM0, XMM0;
vmaskmovps YMM0, YMM0, [RAX];
vmaskmovps [RAX], YMM0, YMM0;
vmaskmovpd XMM0, XMM0, [RAX];
vmaskmovpd [RAX], XMM0, XMM0;
vmaskmovpd YMM0, YMM0, [RAX];
vmaskmovpd [RAX], YMM0, YMM0;
vmovapd YMM0, [RAX];
vmovapd YMM8, [RAX];
vmovapd YMM8, 64[RDI];
vmovapd [RAX], YMM0;
vmovapd [RAX], YMM8;
vmovapd 64[RDI], YMM8;
vmovaps YMM0, [RAX];
vmovaps YMM8, [RAX];
vmovaps YMM8, 64[RDI];
vmovaps [RAX], YMM0;
vmovaps [RAX], YMM8;
vmovaps 64[RDI], YMM8;
vmovupd YMM0, [RAX];
vmovupd YMM8, [RAX];
vmovupd YMM8, 64[RDI];
vmovupd [RAX], YMM0;
vmovupd [RAX], YMM8;
vmovupd 64[RDI], YMM8;
vmovups YMM0, [RAX];
vmovups YMM8, [RAX];
vmovups YMM8, 64[RDI];
vmovups [RAX], YMM0;
vmovups [RAX], YMM8;
vmovups 64[RDI], YMM8;
vmovd XMM0, EAX;
vmovd XMM0, [RAX];
vmovd EAX, XMM0;
vmovd [RAX], XMM0;
vmovq XMM0, RAX;
vmovq XMM0, [RAX];
vmovq RAX, XMM0;
vmovq [RAX], XMM0;
vmovdqa XMM0, XMM0;
vmovdqa XMM0, [RAX];
vmovdqa YMM0, YMM0;
vmovdqa YMM0, [RAX];
vmovdqa XMM0, XMM0;
vmovdqa [RAX], XMM0;
vmovdqa YMM0, YMM0;
vmovdqa [RAX],YMM0;
vmovdqu XMM0, XMM0;
vmovdqu XMM0, [RAX];
vmovdqu YMM0, YMM0;
vmovdqu YMM0, [RAX];
vmovdqu XMM0, XMM0;
vmovdqu [RAX], XMM0;
vmovdqu YMM0, YMM0;
vmovdqu [RAX],YMM0;
vmovhlps XMM0, XMM0, XMM0;
vmovlhps XMM0, XMM0, XMM0;
vmovhpd XMM0, XMM0, [RAX];
vmovhpd [RAX], XMM0;
vmovhps XMM0, XMM0, [RAX];
vmovhps [RAX], XMM0;
vmovlpd XMM0, XMM0, [RAX];
vmovlpd [RAX], XMM0;
vmovlps XMM0, XMM0, [RAX];
vmovlps [RAX], XMM0;
vmovntdq [RAX], XMM0;
vmovntdq [RAX], YMM8;
vmovntpd [RAX], XMM0;
vmovntpd [RAX], YMM8;
vmovntps [RAX], XMM0;
vmovntps [RAX], YMM8;
vmovntdqa XMM0, [RAX];
vmovsd XMM0, XMM0, XMM0;
vmovsd XMM8, XMM8, XMM8;
vmovsd [RAX], XMM0;
vmovsd [R8], XMM8;
vmovss XMM0, XMM0, XMM0;
vmovss XMM8, XMM8, XMM8;
vmovss [RAX], XMM0;
vmovss [R8], XMM8;
vmovshdup XMM8, XMM1;
vmovshdup YMM0, YMM8;
vmovshdup YMM0, [RAX];
vmovsldup XMM8, XMM1;
vmovsldup YMM0, YMM8;
vmovsldup YMM0, [RAX];
vpackuswb XMM0, XMM1, XMM2;
vpackuswb XMM0, XMM8, [RAX];
vpackusdw XMM0, XMM1, XMM2;
vpackusdw XMM0, XMM8, [RAX];
vpacksswb XMM0, XMM1, XMM2;
vpacksswb XMM0, XMM8, [RAX];
vpackssdw XMM0, XMM1, XMM2;
vpackssdw XMM0, XMM8, [RAX];
vpalignr XMM0, XMM1, XMM2, 0xFF;
vpalignr XMM9, XMM8, [RAX], 0x10;
vpextrb EAX, XMM0, 0x0;
vpextrb R10, XMM9, 0xF;
vpextrb [R10], XMM9, 0xF;
vpextrd EAX, XMM0, 0x0;
vpextrd R8D, XMM9, 0xF;
vpextrd [R10], XMM9, 0xF;
vpextrq RAX, XMM0, 0x0;
vpextrq R10, XMM9, 0xF;
vpextrq [R10], XMM9, 0xF;
vpextrw ECX, XMM2, 0x3;
vpextrw EAX, XMM0, 0x0;
vpextrw R10, XMM9, 0xF;
vpextrw [R10], XMM9, 0xF;
vpmovsxbw XMM0, XMM0;
vpmovsxbw XMM8, [R8];
vpmovsxbd XMM0, XMM0;
vpmovsxbd XMM8, [R8];
vpmovsxbq XMM0, XMM0;
vpmovsxbq XMM8, [R8];
vpmovsxwd XMM0, XMM0;
vpmovsxwd XMM8, [R8];
vpmovsxwq XMM0, XMM0;
vpmovsxwq XMM8, [R8];
vpmovsxdq XMM0, XMM0;
vpmovsxdq XMM8, [R8];
vpmovzxbw XMM0, XMM0;
vpmovzxbw XMM8, [R8];
vpmovzxbd XMM0, XMM0;
vpmovzxbd XMM8, [R8];
vpmovzxbq XMM0, XMM0;
vpmovzxbq XMM8, [R8];
vpmovzxwd XMM0, XMM0;
vpmovzxwd XMM8, [R8];
vpmovzxwq XMM0, XMM0;
vpmovzxwq XMM8, [R8];
vpmovzxdq XMM0, XMM0;
vpmovzxdq XMM8, [R8];
vandpd XMM0, XMM0, XMM0;
vandpd XMM9, XMM8, [R8];
vandps XMM0, XMM0, XMM0;
vandps XMM9, XMM8, [R8];
vandnpd XMM0, XMM0, XMM0;
vandnpd XMM9, XMM8, [R8];
vandnps XMM0, XMM0, XMM0;
vandnps XMM9, XMM8, [R8];
vorpd XMM0, XMM0, XMM0;
vorpd XMM9, XMM8, [R8];
vorps XMM0, XMM0, XMM0;
vorps XMM9, XMM8, [R8];
vpand XMM0, XMM0, XMM0;
vpand XMM9, XMM8, [R8];
vpandn XMM0, XMM0, XMM0;
vpandn XMM9, XMM8, [R8];
vpor XMM0, XMM0, XMM0;
vpor XMM9, XMM8, [R10];
vpxor XMM0, XMM0, XMM0;
vpxor XMM9, XMM8, [R10];
vptest XMM0, XMM0;
vptest XMM8, [RAX];
vptest YMM8, YMM8;
vptest YMM0, [R8];
vucomisd XMM0, XMM0;
vucomisd XMM8, [RAX];
vucomiss XMM0, XMM0;
vucomiss XMM8, [RAX];
vxorpd XMM0, XMM8, XMM0;
vxorpd XMM8, XMM0, [RAX];
vxorpd YMM0, YMM8, YMM0;
vxorpd YMM8, YMM0, [RAX];
vxorps XMM0, XMM8, XMM0;
vxorps XMM8, XMM0, [RAX];
vxorps YMM0, YMM8, YMM0;
vxorps YMM8, YMM0, [RAX];
vblendpd XMM0, XMM1, XMM2, 0x00;
vblendpd XMM9, XMM8, [RAX], 0xFF;
vblendpd YMM0, YMM1, YMM2, 0x00;
vblendpd YMM9, YMM8, [RAX], 0xFF;
vblendps XMM0, XMM1, XMM2, 0x00;
vblendps XMM9, XMM8, [RAX], 0xFF;
vblendps YMM0, YMM1, YMM2, 0x00;
vblendps YMM9, YMM8, [RAX], 0xFF;
vblendvpd XMM0, XMM1, XMM2, 0x00;
vblendvpd XMM9, XMM8, [RAX], 0xFF;
vblendvpd YMM0, YMM1, YMM2, 0x00;
vblendvpd YMM9, YMM8, [RAX], 0xFF;
vblendvps XMM0, XMM1, XMM2, 0x00;
vblendvps XMM9, XMM8, [RAX], 0xFF;
vblendvps YMM0, YMM1, YMM2, 0x00;
vblendvps YMM9, YMM8, [RAX], 0xFF;
vmovddup XMM8, XMM0;
vmovddup XMM0, [RAX];
vmovddup YMM0, YMM8;
vmovddup YMM0, [R10];
vpblendvb XMM0, XMM8, XMM0, 0x00;
vpblendvb XMM8, XMM0, [RAX], 0x00;
vpblendvb XMM8, XMM0, [R10], 0x00;
vpblendw XMM0, XMM8, XMM0, 0x00;
vpblendw XMM8, XMM0, [RAX], 0x00;
vpblendw XMM8, XMM0, [R10], 0x00;
vpermilpd XMM0, XMM1, XMM2;
vpermilpd XMM0, XMM1, [RAX];
vpermilpd XMM0, XMM1, 0x00;
vpermilpd XMM0, [RAX], 0x00;
vpermilps XMM0, XMM1, XMM2;
vpermilps XMM0, XMM1, [RAX];
vpermilps XMM0, XMM1, 0x00;
vpermilps XMM0, [RAX], 0x00;
vperm2f128 YMM0, YMM1, YMM2, 0x00;
vperm2f128 YMM0, YMM1, [RAX], 0x00;
vperm2f128 YMM8, YMM9, [R10], 0x00;
vpshufb XMM0, XMM0, XMM0;
vpshufb XMM9, XMM8, [R8];
vpshufd XMM0, XMM0, 0x0;
vpshufd XMM8, [R8], 0x0;
vpshufhw XMM0, XMM0, 0x0;
vpshufhw XMM8, [R8], 0x0;
vpshuflw XMM0, XMM0, 0x0;
vpshuflw XMM8, [R8], 0x0;
vpunpckhbw XMM0, XMM1, XMM2;
vpunpckhbw XMM8, XMM8, [R8];
vpunpckhwd XMM0, XMM1, XMM2;
vpunpckhwd XMM8, XMM8, [R8];
vpunpckhdq XMM0, XMM1, XMM2;
vpunpckhdq XMM8, XMM8, [R8];
vpunpckhqdq XMM0, XMM1, XMM2;
vpunpckhqdq XMM8, XMM8, [R8];
vpunpcklbw XMM0, XMM1, XMM2;
vpunpcklbw XMM8, XMM8, [R8];
vpunpcklwd XMM0, XMM1, XMM2;
vpunpcklwd XMM8, XMM8, [R8];
vpunpckldq XMM0, XMM1, XMM2;
vpunpckldq XMM8, XMM8, [R8];
vpunpcklqdq XMM0, XMM1, XMM2;
vpunpcklqdq XMM8, XMM8, [R8];
vshufpd XMM0, XMM0, XMM0, 0x00;
vshufpd XMM0, XMM8, [R8], 0x00;
vshufpd YMM8, YMM0, YMM8, 0x00;
vshufpd YMM8, YMM0, [RAX], 0x00;
vshufps XMM0, XMM0, XMM0, 0x00;
vshufps XMM0, XMM8, [R8], 0x00;
vshufps YMM8, YMM0, YMM8, 0x00;
vshufps YMM8, YMM0, [RAX], 0x00;
vunpckhpd XMM0, XMM0, XMM0;
vunpckhpd XMM8, XMM8, [RAX];
vunpckhpd YMM8, YMM0, [R8];
vunpckhpd YMM0, YMM8, [R8];
vunpckhps XMM0, XMM0, XMM0;
vunpckhps XMM8, XMM8, [RAX];
vunpckhps YMM8, YMM0, [R8];
vunpckhps YMM0, YMM8, [R8];
vunpcklpd XMM0, XMM0, XMM0;
vunpcklpd XMM8, XMM8, [RAX];
vunpcklpd YMM8, YMM0, [R8];
vunpcklpd YMM0, YMM8, [R8];
vunpcklps XMM0, XMM0, XMM0;
vunpcklps XMM8, XMM8, [RAX];
vunpcklps YMM8, YMM0, [R8];
vunpcklps YMM0, YMM8, [R8];
/* AES */
aesenc XMM0, XMM0;
aesenc XMM0, [RAX];
vaesenc XMM0, XMM0, XMM0;
vaesenc XMM0, XMM0, [RAX];
aesenclast XMM0, XMM0;
aesenclast XMM0, [RAX];
vaesenclast XMM0, XMM0, XMM0;
vaesenclast XMM0, XMM0, [RAX];
aesdec XMM0, XMM0;
aesdec XMM0, [RAX];
vaesdec XMM0, XMM0, XMM0;
vaesdec XMM0, XMM0, [RAX];
aesdeclast XMM0, XMM0;
aesdeclast XMM0, [RAX];
vaesdeclast XMM0, XMM0, XMM0;
vaesdeclast XMM0, XMM0, [RAX];
aesimc XMM0, XMM0;
aesimc XMM0, [RAX];
vaesimc XMM0, XMM0;
vaesimc XMM0, [RAX];
aeskeygenassist XMM0, XMM0, 0x0;
aeskeygenassist XMM0, [RAX], 0x0;
vaeskeygenassist XMM0, XMM0, 0x0;
vaeskeygenassist XMM0, [RAX], 0x0;
/* FSGSBASE */
rdfsbase RAX;
rdfsbase R15;
rdgsbase RAX;
rdgsbase R15;
wrfsbase RAX;
wrfsbase R15;
wrgsbase RAX;
wrgsbase R15;
/* RDRAND */
rdrand AX;
rdrand EAX;
rdrand RAX;
rdrand R15W;
rdrand R15D;
rdrand R15;
/* RDSEED */
rdseed AX;
rdseed EAX;
rdseed RAX;
rdseed R15W;
rdseed R15D;
rdseed R15;
/* FP16C */
vcvtph2ps XMM0, XMM0;
vcvtph2ps XMM0, [RAX];
vcvtph2ps YMM0, XMM0;
vcvtph2ps YMM8, [R8];
vcvtps2ph XMM0, XMM0, 0x0;
vcvtps2ph [RAX], XMM0, 0x0;
vcvtps2ph XMM0, YMM0, 0x0;
vcvtps2ph [R8], YMM8, 0x0;
/* FMA */
vfmadd132pd XMM0, XMM0, XMM0;
vfmadd132pd XMM0, XMM0, [RAX];
vfmadd132pd YMM0, YMM0, YMM0;
vfmadd132pd YMM8, YMM8, [R8];
vfmadd132ps XMM0, XMM0, XMM0;
vfmadd132ps XMM0, XMM0, [RAX];
vfmadd132ps YMM0, YMM0, YMM0;
vfmadd132ps YMM8, YMM8, [R8];
vfmadd132sd XMM0, XMM0, XMM0;
vfmadd132sd XMM0, XMM0, [RAX];
vfmadd132ss XMM0, XMM0, XMM0;
vfmadd132ss XMM0, XMM0, [RAX];
vfmadd213pd XMM0, XMM0, XMM0;
vfmadd213pd XMM0, XMM0, [RAX];
vfmadd213pd YMM0, YMM0, YMM0;
vfmadd213pd YMM8, YMM8, [R8];
vfmadd213ps XMM0, XMM0, XMM0;
vfmadd213ps XMM0, XMM0, [RAX];
vfmadd213ps YMM0, YMM0, YMM0;
vfmadd213ps YMM8, YMM8, [R8];
vfmadd213sd XMM0, XMM0, XMM0;
vfmadd213sd XMM0, XMM0, [RAX];
vfmadd213ss XMM0, XMM0, XMM0;
vfmadd213ss XMM0, XMM0, [RAX];
vfmadd231pd XMM0, XMM0, XMM0;
vfmadd231pd XMM0, XMM0, [RAX];
vfmadd231pd YMM0, YMM0, YMM0;
vfmadd231pd YMM8, YMM8, [R8];
vfmadd231ps XMM0, XMM0, XMM0;
vfmadd231ps XMM0, XMM0, [RAX];
vfmadd231ps YMM0, YMM0, YMM0;
vfmadd231ps YMM8, YMM8, [R8];
vfmadd231sd XMM0, XMM0, XMM0;
vfmadd231sd XMM0, XMM0, [RAX];
vfmadd231ss XMM0, XMM0, XMM0;
vfmadd231ss XMM0, XMM0, [RAX];
vfmaddsub132pd XMM0, XMM0, XMM0;
vfmaddsub132pd XMM0, XMM0, [RAX];
vfmaddsub132pd YMM0, YMM0, YMM0;
vfmaddsub132pd YMM8, YMM8, [R8];
vfmaddsub132ps XMM0, XMM0, XMM0;
vfmaddsub132ps XMM0, XMM0, [RAX];
vfmaddsub132ps YMM0, YMM0, YMM0;
vfmaddsub132ps YMM8, YMM8, [R8];
vfmaddsub213pd XMM0, XMM0, XMM0;
vfmaddsub213pd XMM0, XMM0, [RAX];
vfmaddsub213pd YMM0, YMM0, YMM0;
vfmaddsub213pd YMM8, YMM8, [R8];
vfmaddsub213ps XMM0, XMM0, XMM0;
vfmaddsub213ps XMM0, XMM0, [RAX];
vfmaddsub213ps YMM0, YMM0, YMM0;
vfmaddsub213ps YMM8, YMM8, [R8];
vfmaddsub231pd XMM0, XMM0, XMM0;
vfmaddsub231pd XMM0, XMM0, [RAX];
vfmaddsub231pd YMM0, YMM0, YMM0;
vfmaddsub231pd YMM8, YMM8, [R8];
vfmaddsub231ps XMM0, XMM0, XMM0;
vfmaddsub231ps XMM0, XMM0, [RAX];
vfmaddsub231ps YMM0, YMM0, YMM0;
vfmaddsub231ps YMM8, YMM8, [R8];
vfmsubadd132pd XMM0, XMM0, XMM0;
vfmsubadd132pd XMM0, XMM0, [RAX];
vfmsubadd132pd YMM0, YMM0, YMM0;
vfmsubadd132pd YMM8, YMM8, [R8];
vfmsubadd132ps XMM0, XMM0, XMM0;
vfmsubadd132ps XMM0, XMM0, [RAX];
vfmsubadd132ps YMM0, YMM0, YMM0;
vfmsubadd132ps YMM8, YMM8, [R8];
vfmsubadd213pd XMM0, XMM0, XMM0;
vfmsubadd213pd XMM0, XMM0, [RAX];
vfmsubadd213pd YMM0, YMM0, YMM0;
vfmsubadd213pd YMM8, YMM8, [R8];
vfmsubadd213ps XMM0, XMM0, XMM0;
vfmsubadd213ps XMM0, XMM0, [RAX];
vfmsubadd213ps YMM0, YMM0, YMM0;
vfmsubadd213ps YMM8, YMM8, [R8];
vfmsubadd231pd XMM0, XMM0, XMM0;
vfmsubadd231pd XMM0, XMM0, [RAX];
vfmsubadd231pd YMM0, YMM0, YMM0;
vfmsubadd231pd YMM8, YMM8, [R8];
vfmsubadd231ps XMM0, XMM0, XMM0;
vfmsubadd231ps XMM0, XMM0, [RAX];
vfmsubadd231ps YMM0, YMM0, YMM0;
vfmsubadd231ps YMM8, YMM8, [R8];
vfmsub132pd XMM0, XMM0, XMM0;
vfmsub132pd XMM0, XMM0, [RAX];
vfmsub132pd YMM0, YMM0, YMM0;
vfmsub132pd YMM8, YMM8, [R8];
vfmsub132ps XMM0, XMM0, XMM0;
vfmsub132ps XMM0, XMM0, [RAX];
vfmsub132ps YMM0, YMM0, YMM0;
vfmsub132ps YMM8, YMM8, [R8];
vfmsub132sd XMM0, XMM0, XMM0;
vfmsub132sd XMM0, XMM0, [RAX];
vfmsub132ss XMM0, XMM0, XMM0;
vfmsub132ss XMM0, XMM0, [RAX];
vfmsub213pd XMM0, XMM0, XMM0;
vfmsub213pd XMM0, XMM0, [RAX];
vfmsub213pd YMM0, YMM0, YMM0;
vfmsub213pd YMM8, YMM8, [R8];
vfmsub213ps XMM0, XMM0, XMM0;
vfmsub213ps XMM0, XMM0, [RAX];
vfmsub213ps YMM0, YMM0, YMM0;
vfmsub213ps YMM8, YMM8, [R8];
vfmsub213sd XMM0, XMM0, XMM0;
vfmsub213sd XMM0, XMM0, [RAX];
vfmsub213ss XMM0, XMM0, XMM0;
vfmsub213ss XMM0, XMM0, [RAX];
vfmsub231pd XMM0, XMM0, XMM0;
vfmsub231pd XMM0, XMM0, [RAX];
vfmsub231pd YMM0, YMM0, YMM0;
vfmsub231pd YMM8, YMM8, [R8];
vfmsub231ps XMM0, XMM0, XMM0;
vfmsub231ps XMM0, XMM0, [RAX];
vfmsub231ps YMM0, YMM0, YMM0;
vfmsub231ps YMM8, YMM8, [R8];
vfmsub231sd XMM0, XMM0, XMM0;
vfmsub231sd XMM0, XMM0, [RAX];
vfmsub231ss XMM0, XMM0, XMM0;
vfmsub231ss XMM0, XMM0, [RAX];
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
assert(p[data.length] == 0x58); // pop RAX
}
/* ======================= SHA ========================== */
void test62()
{
ubyte* p;
byte m8;
short m16;
int m32;
M64 m64;
M128 m128;
static ubyte[] data =
[
0x0F, 0x3A, 0xCC, 0xD1, 0x01, // sha1rnds4 XMM2, XMM1, 1;
0x0F, 0x3A, 0xCC, 0x10, 0x01, // sha1rnds4 XMM2, [RAX], 1;
0x0F, 0x38, 0xC8, 0xD1, // sha1nexte XMM2, XMM1;
0x0F, 0x38, 0xC8, 0x10, // sha1nexte XMM2, [RAX];
0x0F, 0x38, 0xC9, 0xD1, // sha1msg1 XMM2, XMM1;
0x0F, 0x38, 0xC9, 0x10, // sha1msg1 XMM2, [RAX];
0x0F, 0x38, 0xCA, 0xD1, // sha1msg2 XMM2, XMM1;
0x0F, 0x38, 0xCA, 0x10, // sha1msg2 XMM2, [RAX];
0x0F, 0x38, 0xCB, 0xD1, // sha256rnds2 XMM2, XMM1;
0x0F, 0x38, 0xCB, 0x10, // sha256rnds2 XMM2, [RAX];
0x0F, 0x38, 0xCC, 0xD1, // sha256msg1 XMM2, XMM1;
0x0F, 0x38, 0xCC, 0x10, // sha256msg1 XMM2, [RAX];
0x0F, 0x38, 0xCD, 0xD1, // sha256msg2 XMM2, XMM1;
0x0F, 0x38, 0xCD, 0x10, // sha256msg2 XMM2, [RAX];
];
asm
{
call L1;
sha1rnds4 XMM2, XMM1, 1;
sha1rnds4 XMM2, [RAX], 1;
sha1nexte XMM2, XMM1;
sha1nexte XMM2, [RAX];
sha1msg1 XMM2, XMM1;
sha1msg1 XMM2, [RAX];
sha1msg2 XMM2, XMM1;
sha1msg2 XMM2, [RAX];
sha256rnds2 XMM2, XMM1;
sha256rnds2 XMM2, [RAX];
sha256msg1 XMM2, XMM1;
sha256msg1 XMM2, [RAX];
sha256msg2 XMM2, XMM1;
sha256msg2 XMM2, [RAX];
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
void test2941()
{
ubyte *p;
static ubyte[] data =
[
0x9B, 0xDF, 0xE0, // fstsw AX;
];
int i;
asm
{
call L1 ;
fstsw AX;
L1:
pop RBX ;
mov p[RBP],RBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
void test9866()
{
ubyte* p;
static ubyte[] data =
[
0x48, 0x0f, 0xbe, 0xc0, // movsx RAX, AL
0x48, 0x0f, 0xbe, 0x00, // movsx RAX, byte ptr [RAX]
0x48, 0x0f, 0xbf, 0xc0, // movsx RAX, AX
0x48, 0x0f, 0xbf, 0x00, // movsx RAX, word ptr [RAX]
0x48, 0x63, 0xc0, // movsxd RAX, EAX
0x48, 0x63, 0x00, // movsxd RAX, dword ptr [RAX]
];
asm
{
call L1;
movsx RAX, AL;
movsx RAX, byte ptr [RAX];
movsx RAX, AX;
movsx RAX, word ptr [RAX];
movsxd RAX, EAX;
movsxd RAX, dword ptr [RAX];
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
// printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
assert(p[data.length] == 0x58); // pop RAX
}
/****************************************************/
void testxadd()
{ int x;
ubyte* p;
static ubyte[] data =
[
0x0F, 0xC0, 0x10,
0x66, 0x0F, 0xC1, 0x10,
0x0F, 0xC1, 0x10,
0x48, 0x0F, 0xC1, 0x10,
];
asm
{
call L1 ;
xadd byte ptr [RAX],DL;
xadd word ptr [RAX],DX;
xadd dword ptr [RAX],EDX;
xadd qword ptr [RAX],RDX;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void testconst()
{
ulong result;
asm
{
mov RAX, 0xFFFF_FFFFu;
mov result, RAX;
}
assert (result == 0xFFFF_FFFFu);
}
/****************************************************/
void test9965()
{
ubyte* p;
static ubyte[] data =
[
0xB7, 0x01, // mov BH,1
0x40, 0xB6, 0x01, // mov SIL,1
0x40, 0xB7, 0x01, // mov DIL,1
0x40, 0xB5, 0x01, // mov BPL,1
0x40, 0xB4, 0x01, // mov SPL,1
0x41, 0xB0, 0x01, // mov R8B,1
0x40, 0x80, 0xE6, 0x01, // and SIL,1 (https://issues.dlang.org/show_bug.cgi?id=12971)
];
asm
{
call L1;
mov BH, 1;
mov SIL, 1;
mov DIL, 1;
mov BPL, 1;
mov SPL, 1;
mov R8B, 1;
and SIL, 1;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
// printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
assert(p[data.length] == 0x58); // pop RAX
}
/****************************************************/
void test12849()
{
ulong a = 0xff00ff00ff00ff00L;
ulong result;
ulong expected = 0b10101010;
asm
{
pxor XMM0, XMM0;
movq XMM0, a;
pmovmskb RAX, XMM0;
mov result, RAX;
}
assert (result == expected);
}
/****************************************************/
void test12968()
{
int x;
ubyte* p;
static ubyte[] data =
[
0x48, 0x89, 0xF8,
0x4C, 0x87, 0xC2,
0xC3
];
asm
{
call L1 ;
mov RAX, RDI;
xchg RDX, R8;
ret;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test15999()
{
int x;
ubyte* p;
static ubyte[] data =
[
0x48, 0x83, 0xE0, 0xFF,
0x83, 0xE0, 0xFF,
0x48, 0x25, 0x00, 0x00, 0x00, 0x80,
0xC3
];
asm
{
call L1 ;
and RAX, -1;
and EAX, -1;
and RAX, 0xFFFF_FFFF_8000_0000;
ret;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test17027()
{
ubyte* p;
static ubyte[] data =
[
0xF3, 0x48, 0x0F, 0xBC, 0xC0,
0xF3, 0x48, 0x0F, 0xBC, 0x00,
0xF3, 0x48, 0x0F, 0xBC, 0x40, 0x08,
0xF3, 0x0F, 0xBC, 0xC0,
0xF3, 0x48, 0x0F, 0xBD, 0xC0,
0xF3, 0x48, 0x0F, 0xBD, 0x00,
0xF3, 0x48, 0x0F, 0xBD, 0x40, 0x08,
0xF3, 0x0F, 0xBD, 0xC0,
];
asm
{
call L1;
tzcnt RAX, RAX;
tzcnt RAX, [RAX];
tzcnt RAX, [RAX+8];
tzcnt EAX, EAX;
lzcnt RAX, RAX;
lzcnt RAX, [RAX];
lzcnt RAX, [RAX+8];
lzcnt EAX, EAX;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
void test18553()
{
ubyte* p;
static ubyte[] data =
[
0x0F, 0x20, 0xC0,
0x0F, 0x20, 0xD0,
0x0F, 0x20, 0xD8,
0x0F, 0x20, 0xE0,
0x0F, 0x22, 0xC0,
0x0F, 0x22, 0xD0,
0x0F, 0x22, 0xD8,
0x0F, 0x22, 0xE0,
0x44, 0x0F, 0x22, 0xC0,
0x44, 0x0F, 0x20, 0xC0,
];
asm
{
call L1;
mov RAX, CR0;
mov RAX, CR2;
mov RAX, CR3;
mov RAX, CR4;
mov CR0, RAX;
mov CR2, RAX;
mov CR3, RAX;
mov CR4, RAX;
mov CR8, RAX;
mov RAX, CR8;
L1: pop RAX;
mov p[RBP],RAX;
}
foreach (ref i, b; data)
{
assert(p[i] == b);
}
}
/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=20126
extern(C) float floop(float* r, float x)
{
asm
{
mov EAX, x;
mov RCX, r;
xchg [RCX], EAX;
mov x, EAX;
}
return x;
}
void test20126()
{
float r = 1.0;
float x = 2.0;
float f = floop(&r, x);
assert(f == 1.0);
}
/****************************************************/
void test63()
{
asm
{
L1:
mov EAX,0;
jmp L2;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
db 0,0,0,0,0,0,0,0 ;
}
asm
{
jmp L1; // more than 128 bytes away
}
L2:
{
}
}
/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=6166
struct NRV { int[8] a; }
NRV rvo()
{
NRV v;
v.a[1] = 3;
asm @nogc pure
{
mov int ptr v+4,7;
}
return v;
}
void test6166()
{
auto n = rvo();
assert(n.a[1] == 7);
}
/****************************************************/
int main()
{
printf("Testing iasm64.d\n");
test1();
test2();
test3();
test4();
test5();
test6();
//test7(); TODO 16bit seg
test8();
//test9(); Fails
//test10(); Fails
test11();
test12();
test13();
test14();
test15();
//test16(); // add this one from \cbx\test\iasm.c ?
test17();
test18();
test19();
//test20(); 8087
test21();
test22();
test23();
test24();
test25();
test26();
test27();
test28();
//test29(); offsetof?
test30();
test31();
test32();
test33();
test34();
//test35(); RIP addressing?
//test36(); RIP addressing?
test37();
test38();
test39();
test40();
test41();
test42();
test43();
test44();
test45();
test46();
//test47(); RIP addressing?
test48();
test49();
test50();
//Test51
test52();
test53();
test54();
test55();
test56();
test57();
test58();
test59();
test60();
test61();
test62();
test2941();
test9866();
testxadd();
test9965();
test12849();
test12968();
test15999();
testconst();
test17027();
test18553();
test20126();
test63();
test6166();
printf("Success\n");
return 0;
}
}
else
{
int main() { return 0; }
}
Reference in a new issue View git blame Copy permalink