mirrors/dmd
1
0
Fork 0
mirror of https://github.com/dlang/dmd.git synced 2025-04-26 05:00:16 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 5
dmd/compiler/test/runnable/iasm.d
Iain Buclaw 6374bb87b7 Move dmd files into compiler/
2022-07-09 18:53:07 +02:00

5002 lines
160 KiB
D
Raw Permalink 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)
{
struct M128 { int a,b,c,d; };
struct M64 { int a,b; };
/****************************************************/
void test1()
{
int foo;
int bar;
static const int x = 4;
asm
{
align x; ;
mov EAX, __LOCAL_SIZE ;
mov foo[EBP], EAX ;
}
assert(foo == 8);
}
/****************************************************/
void test2()
{
int foo;
int bar;
asm
{
even ;
mov EAX,0 ;
inc EAX ;
mov foo[EBP], EAX ;
}
assert(foo == 1);
}
/****************************************************/
void test3()
{
int foo;
int bar;
asm
{
mov EAX,5 ;
jmp $ + 1 ;
db 0x40,0x48 ; // inc EAX, dec EAX
mov foo[EBP],EAX ;
}
assert(foo == 4);
}
/****************************************************/
void test4()
{
int foo;
int bar;
asm
{
xor EAX,EAX ;
add EAX,5 ;
jne L1 ;
db 0x40,0x48 ; // inc EAX, dec EAX
L1:
db 0x48 ;
mov foo[EBP],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 0x40,0x48 ; // inc EAX, dec EAX
db "abc" ;
ds "def" ;
di "ghi" ;
dl 0x12345678ABCDEF ;
df 1.1 ;
dd 1.2 ;
de 1.3 ;
L1:
pop EBX ;
mov p[EBP],EBX ;
}
assert(p[0] == 0x40);
assert(p[1] == 0x48);
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,[ECX]
0x8B, 0x04, 0x19, // mov EAX,[EBX][ECX]
0x8B, 0x04, 0x4B, // mov EAX,[ECX*2][EBX]
0x8B, 0x04, 0x5A, // mov EAX,[EBX*2][EDX]
0x8B, 0x04, 0x8E, // mov EAX,[ECX*4][ESI]
0x8B, 0x04, 0xF9, // mov EAX,[EDI*8][ECX]
0x2B, 0x1C, 0x19, // sub EBX,[EBX][ECX]
0x3B, 0x0C, 0x4B, // cmp ECX,[ECX*2][EBX]
0x03, 0x14, 0x5A, // add EDX,[EBX*2][EDX]
0x33, 0x34, 0x8E, // xor ESI,[ECX*4][ESI]
0x29, 0x1C, 0x19, // sub [EBX][ECX],EBX
0x39, 0x0C, 0x4B, // cmp [ECX*2][EBX],ECX
0x01, 0x24, 0x5A, // add [EBX*2][EDX],ESP
0x31, 0x2C, 0x8E, // xor [ECX*4][ESI],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 [EDI*8][ECX],EDI
];
int i;
asm
{
call L1 ;
mov EAX,[ECX] ;
mov EAX,[ECX][EBX] ;
mov EAX,[ECX*2][EBX] ;
mov EAX,[EDX][EBX*2] ;
mov EAX,[ECX*4][ESI] ;
mov EAX,[ECX][EDI*8] ;
sub EBX,[ECX][EBX] ;
cmp ECX,[ECX*2][EBX] ;
add EDX,[EDX][EBX*2] ;
xor ESI,[ECX*4][ESI] ;
sub [ECX][EBX],EBX ;
cmp [ECX*2][EBX],ECX ;
add [EDX][EBX*2],ESP ;
xor [ECX*4][ESI],EBP ;
test AL,3 ;
test AX,4 ;
test EAX,5 ;
test [ECX][EDI*8],EDI ;
L1:
pop EBX ;
mov p[EBP],EBX ;
}
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 EBX ;
mov p[EBP],EBX ;
}
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 EBX ;
mov p[EBP],EBX ;
}
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] ;
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 EBX ;
mov p[EBP],EBX ;
}
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 ;
mov ESI,1 ;
mov baz10[ESI*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 =
[
0x37, // aaa
0xD5,0x0A, // aad
0xD4,0x0A, // aam
0x3F, // aas
0x67,0x63,0x3C, // arpl [SI],DI
0xF3,0x90, // pause
0x14,0x05, // adc AL,5
0x83,0xD0,0x14, // adc EAX,014h
0x80,0x55,0xF8,0x17, // adc byte ptr -8[EBP],017h
0x83,0x55,0xFC,0x17, // adc dword ptr -4[EBP],017h
0x81,0x55,0xFC,0x34,0x12,0x00,0x00, // adc dword ptr -4[EBP],01234h
0x10,0x7D,0xF8, // adc -8[EBP],BH
0x11,0x5D,0xFC, // adc -4[EBP],EBX
0x12,0x5D,0xF8, // adc BL,-8[EBP]
0x13,0x55,0xFC, // adc EDX,-4[EBP]
0x04,0x05, // add AL,5
0x83,0xC0,0x14, // add EAX,014h
0x80,0x45,0xF8,0x17, // add byte ptr -8[EBP],017h
0x83,0x45,0xFC,0x17, // add dword ptr -4[EBP],017h
0x81,0x45,0xFC,0x34,0x12,0x00,0x00, // add dword ptr -4[EBP],01234h
0x00,0x7D,0xF8, // add -8[EBP],BH
0x01,0x5D,0xFC, // add -4[EBP],EBX
0x02,0x5D,0xF8, // add BL,-8[EBP]
0x03,0x55,0xFC, // add EDX,-4[EBP]
0x24,0x05, // and AL,5
0x83,0xE0,0x14, // and EAX,014h
0x80,0x65,0xF8,0x17, // and byte ptr -8[EBP],017h
0x83,0x65,0xFC,0x17, // and dword ptr -4[EBP],017h
0x81,0x65,0xFC,0x34,0x12,0x00,0x00, // and dword ptr -4[EBP],01234h
0x20,0x7D,0xF8, // and -8[EBP],BH
0x21,0x5D,0xFC, // and -4[EBP],EBX
0x22,0x5D,0xF8, // and BL,-8[EBP]
0x23,0x55,0xFC, // and EDX,-4[EBP]
0x3C,0x05, // cmp AL,5
0x83,0xF8,0x14, // cmp EAX,014h
0x80,0x7D,0xF8,0x17, // cmp byte ptr -8[EBP],017h
0x83,0x7D,0xFC,0x17, // cmp dword ptr -4[EBP],017h
0x81,0x7D,0xFC,0x34,0x12,0x00,0x00, // cmp dword ptr -4[EBP],01234h
0x38,0x7D,0xF8, // cmp -8[EBP],BH
0x39,0x5D,0xFC, // cmp -4[EBP],EBX
0x3A,0x5D,0xF8, // cmp BL,-8[EBP]
0x3B,0x55,0xFC, // cmp EDX,-4[EBP]
0x0C,0x05, // or AL,5
0x83,0xC8,0x14, // or EAX,014h
0x80,0x4D,0xF8,0x17, // or byte ptr -8[EBP],017h
0x83,0x4D,0xFC,0x17, // or dword ptr -4[EBP],017h
0x81,0x4D,0xFC,0x34,0x12,0x00,0x00, // or dword ptr -4[EBP],01234h
0x08,0x7D,0xF8, // or -8[EBP],BH
0x09,0x5D,0xFC, // or -4[EBP],EBX
0x0A,0x5D,0xF8, // or BL,-8[EBP]
0x0B,0x55,0xFC, // or EDX,-4[EBP]
0x1C,0x05, // sbb AL,5
0x83,0xD8,0x14, // sbb EAX,014h
0x80,0x5D,0xF8,0x17, // sbb byte ptr -8[EBP],017h
0x83,0x5D,0xFC,0x17, // sbb dword ptr -4[EBP],017h
0x81,0x5D,0xFC,0x34,0x12,0x00,0x00, // sbb dword ptr -4[EBP],01234h
0x18,0x7D,0xF8, // sbb -8[EBP],BH
0x19,0x5D,0xFC, // sbb -4[EBP],EBX
0x1A,0x5D,0xF8, // sbb BL,-8[EBP]
0x1B,0x55,0xFC, // sbb EDX,-4[EBP]
0x2C,0x05, // sub AL,5
0x83,0xE8,0x14, // sub EAX,014h
0x80,0x6D,0xF8,0x17, // sub byte ptr -8[EBP],017h
0x83,0x6D,0xFC,0x17, // sub dword ptr -4[EBP],017h
0x81,0x6D,0xFC,0x34,0x12,0x00,0x00, // sub dword ptr -4[EBP],01234h
0x28,0x7D,0xF8, // sub -8[EBP],BH
0x29,0x5D,0xFC, // sub -4[EBP],EBX
0x2A,0x5D,0xF8, // sub BL,-8[EBP]
0x2B,0x55,0xFC, // sub EDX,-4[EBP]
0xA8,0x05, // test AL,5
0xA9,0x14,0x00,0x00,0x00, // test EAX,014h
0xF6,0x45,0xF8,0x17, // test byte ptr -8[EBP],017h
0xF7,0x45,0xFC,0x17,0x00,0x00,0x00, // test dword ptr -4[EBP],017h
0xF7,0x45,0xFC,0x34,0x12,0x00,0x00, // test dword ptr -4[EBP],01234h
0x84,0x7D,0xF8, // test -8[EBP],BH
0x85,0x5D,0xFC, // test -4[EBP],EBX
0x34,0x05, // xor AL,5
0x83,0xF0,0x14, // xor EAX,014h
0x80,0x75,0xF8,0x17, // xor byte ptr -8[EBP],017h
0x83,0x75,0xFC,0x17, // xor dword ptr -4[EBP],017h
0x81,0x75,0xFC,0x34,0x12,0x00,0x00, // xor dword ptr -4[EBP],01234h
0x30,0x7D,0xF8, // xor -8[EBP],BH
0x31,0x5D,0xFC, // xor -4[EBP],EBX
0x32,0x5D,0xF8, // xor BL,-8[EBP]
0x33,0x55,0xFC, // xor EDX,-4[EBP]
];
int i;
byte rm8;
int rm32;
static int m32;
asm
{
call L1 ;
aaa ;
aad ;
aam ;
aas ;
arpl [SI],DI ;
pause ;
adc AL,5 ;
adc EAX,20 ;
adc rm8[EBP],23 ;
adc rm32[EBP],23 ;
adc rm32[EBP],0x1234 ;
adc rm8[EBP],BH ;
adc rm32[EBP],EBX ;
adc BL,rm8[EBP] ;
adc EDX,rm32[EBP] ;
add AL,5 ;
add EAX,20 ;
add rm8[EBP],23 ;
add rm32[EBP],23 ;
add rm32[EBP],0x1234 ;
add rm8[EBP],BH ;
add rm32[EBP],EBX ;
add BL,rm8[EBP] ;
add EDX,rm32[EBP] ;
and AL,5 ;
and EAX,20 ;
and rm8[EBP],23 ;
and rm32[EBP],23 ;
and rm32[EBP],0x1234 ;
and rm8[EBP],BH ;
and rm32[EBP],EBX ;
and BL,rm8[EBP] ;
and EDX,rm32[EBP] ;
cmp AL,5 ;
cmp EAX,20 ;
cmp rm8[EBP],23 ;
cmp rm32[EBP],23 ;
cmp rm32[EBP],0x1234 ;
cmp rm8[EBP],BH ;
cmp rm32[EBP],EBX ;
cmp BL,rm8[EBP] ;
cmp EDX,rm32[EBP] ;
or AL,5 ;
or EAX,20 ;
or rm8[EBP],23 ;
or rm32[EBP],23 ;
or rm32[EBP],0x1234 ;
or rm8[EBP],BH ;
or rm32[EBP],EBX ;
or BL,rm8[EBP] ;
or EDX,rm32[EBP] ;
sbb AL,5 ;
sbb EAX,20 ;
sbb rm8[EBP],23 ;
sbb rm32[EBP],23 ;
sbb rm32[EBP],0x1234 ;
sbb rm8[EBP],BH ;
sbb rm32[EBP],EBX ;
sbb BL,rm8[EBP] ;
sbb EDX,rm32[EBP] ;
sub AL,5 ;
sub EAX,20 ;
sub rm8[EBP],23 ;
sub rm32[EBP],23 ;
sub rm32[EBP],0x1234 ;
sub rm8[EBP],BH ;
sub rm32[EBP],EBX ;
sub BL,rm8[EBP] ;
sub EDX,rm32[EBP] ;
test AL,5 ;
test EAX,20 ;
test rm8[EBP],23 ;
test rm32[EBP],23 ;
test rm32[EBP],0x1234 ;
test rm8[EBP],BH ;
test rm32[EBP],EBX ;
xor AL,5 ;
xor EAX,20 ;
xor rm8[EBP],23 ;
xor rm32[EBP],23 ;
xor rm32[EBP],0x1234 ;
xor rm8[EBP],BH ;
xor rm32[EBP],EBX ;
xor BL,rm8[EBP] ;
xor EDX,rm32[EBP] ;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
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 [EAX]
0x0F,0xAE,0x08, // fxrstor [EAX]
0x0F,0xAE,0x10, // ldmxcsr [EAX]
0x0F,0xAE,0x18, // stmxcsr [EAX]
0x0F,0xAE,0x38, // clflush [EAX]
0x0F,0x58,0x08, // addps XMM1,[EAX]
0x0F,0x58,0xCA, // addps XMM1,XMM2
0x66, 0x0F,0x58,0x03, // addpd XMM0,[EBX]
0x66, 0x0F,0x58,0xD1, // addpd XMM2,XMM1
0xF2,0x0F,0x58,0x08, // addsd XMM1,[EAX]
0xF2,0x0F,0x58,0xCA, // addsd XMM1,XMM2
0xF3,0x0F,0x58,0x2E, // addss XMM5,[ESI]
0xF3,0x0F,0x58,0xF7, // addss XMM6,XMM7
0x0F,0x54,0x08, // andps XMM1,[EAX]
0x0F,0x54,0xCA, // andps XMM1,XMM2
0x66, 0x0F,0x54,0x03, // andpd XMM0,[EBX]
0x66, 0x0F,0x54,0xD1, // andpd XMM2,XMM1
0x0F,0x55,0x08, // andnps XMM1,[EAX]
0x0F,0x55,0xCA, // andnps XMM1,XMM2
0x66, 0x0F,0x55,0x03, // andnpd XMM0,[EBX]
0x66, 0x0F,0x55,0xD1, // andnpd XMM2,XMM1
0xA7, // cmpsd
0x0F,0xC2,0x08,0x01, // cmpps XMM1,[EAX],1
0x0F,0xC2,0xCA,0x02, // cmpps XMM1,XMM2,2
0x66, 0x0F,0xC2,0x03,0x03, // cmppd XMM0,[EBX],3
0x66, 0x0F,0xC2,0xD1,0x04, // cmppd XMM2,XMM1,4
0xF2,0x0F,0xC2,0x08,0x05, // cmpsd XMM1,[EAX],5
0xF2,0x0F,0xC2,0xCA,0x06, // cmpsd XMM1,XMM2,6
0xF3,0x0F,0xC2,0x2E,0x07, // cmpss XMM5,[ESI],7
0xF3,0x0F,0xC2,0xF7,0x00, // cmpss XMM6,XMM7,0
0x66, 0x0F,0x2F,0x08, // comisd XMM1,[EAX]
0x66, 0x0F,0x2F,0x4D,0xE0, // comisd XMM1,-020h[EBP]
0x66, 0x0F,0x2F,0xCA, // comisd XMM1,XMM2
0x0F,0x2F,0x2E, // comiss XMM5,[ESI]
0x0F,0x2F,0xF7, // comiss XMM6,XMM7
0xF3,0x0F,0xE6,0xDC, // cvtdq2pd XMM3,XMM4
0xF3,0x0F,0xE6,0x5D,0xE0, // cvtdq2pd XMM3,-020h[EBP]
0x0F,0x5B,0xDC, // cvtdq2ps XMM3,XMM4
0x0F,0x5B,0x5D,0xE8, // cvtdq2ps XMM3,-018h[EBP]
0xF2,0x0F,0xE6,0xDC, // cvtpd2dq XMM3,XMM4
0xF2,0x0F,0xE6,0x5D,0xE8, // cvtpd2dq XMM3,-018h[EBP]
0x66, 0x0F,0x2D,0xDC, // cvtpd2pi MM3,XMM4
0x66, 0x0F,0x2D,0x5D,0xE8, // cvtpd2pi MM3,-018h[EBP]
0x66, 0x0F,0x5A,0xDC, // cvtpd2ps XMM3,XMM4
0x66, 0x0F,0x5A,0x5D,0xE8, // cvtpd2ps XMM3,-018h[EBP]
0x66, 0x0F,0x2A,0xDC, // cvtpi2pd XMM3,MM4
0x66, 0x0F,0x2A,0x5D,0xE0, // cvtpi2pd XMM3,-020h[EBP]
0x0F,0x2A,0xDC, // cvtpi2ps XMM3,MM4
0x0F,0x2A,0x5D,0xE0, // cvtpi2ps XMM3,-020h[EBP]
0x66, 0x0F,0x5B,0xDC, // cvtps2dq XMM3,XMM4
0x66, 0x0F,0x5B,0x5D,0xE8, // cvtps2dq XMM3,-018h[EBP]
0x0F,0x5A,0xDC, // cvtps2pd XMM3,XMM4
0x0F,0x5A,0x5D,0xE0, // cvtps2pd XMM3,-020h[EBP]
0x0F,0x2D,0xDC, // cvtps2pi MM3,XMM4
0x0F,0x2D,0x5D,0xE0, // cvtps2pi MM3,-020h[EBP]
0xF2,0x0F,0x2D,0xCC, // cvtsd2si XMM1,XMM4
0xF2,0x0F,0x2D,0x55,0xE0, // cvtsd2si XMM2,-020h[EBP]
0xF2,0x0F,0x5A,0xDC, // cvtsd2ss XMM3,XMM4
0xF2,0x0F,0x5A,0x5D,0xE0, // cvtsd2ss XMM3,-020h[EBP]
0xF2,0x0F,0x2A,0xDA, // cvtsi2sd XMM3,EDX
0xF2,0x0F,0x2A,0x5D,0xD8, // cvtsi2sd XMM3,-028h[EBP]
0xF3,0x0F,0x2A,0xDA, // cvtsi2ss XMM3,EDX
0xF3,0x0F,0x2A,0x5D,0xD8, // cvtsi2ss XMM3,-028h[EBP]
0xF3,0x0F,0x5A,0xDC, // cvtss2sd XMM3,XMM4
0xF3,0x0F,0x5A,0x5D,0xD8, // cvtss2sd XMM3,-028h[EBP]
0xF3,0x0F,0x2D,0xFC, // cvtss2si XMM7,XMM4
0xF3,0x0F,0x2D,0x7D,0xD8, // cvtss2si XMM7,-028h[EBP]
0x66, 0x0F,0x2C,0xDC, // cvttpd2pi MM3,XMM4
0x66, 0x0F,0x2C,0x7D,0xE8, // cvttpd2pi MM7,-018h[EBP]
0x66, 0x0F,0xE6,0xDC, // cvttpd2dq XMM3,XMM4
0x66, 0x0F,0xE6,0x7D,0xE8, // cvttpd2dq XMM7,-018h[EBP]
0xF3,0x0F,0x5B,0xDC, // cvttps2dq XMM3,XMM4
0xF3,0x0F,0x5B,0x7D,0xE8, // cvttps2dq XMM7,-018h[EBP]
0x0F,0x2C,0xDC, // cvttps2pi MM3,XMM4
0x0F,0x2C,0x7D,0xE0, // cvttps2pi MM7,-020h[EBP]
0xF2,0x0F,0x2C,0xC4, // cvttsd2si EAX,XMM4
0xF2,0x0F,0x2C,0x4D,0xE0, // cvttsd2si ECX,-020h[EBP]
0xF3,0x0F,0x2C,0xC4, // cvttss2si EAX,XMM4
0xF3,0x0F,0x2C,0x4D,0xD8, // cvttss2si ECX,-028h[EBP]
0x66, 0x0F,0x5E,0xE8, // divpd XMM5,XMM0
0x66, 0x0F,0x5E,0x6D,0xE8, // divpd XMM5,-018h[EBP]
0x0F,0x5E,0xE8, // divps XMM5,XMM0
0x0F,0x5E,0x6D,0xE8, // divps XMM5,-018h[EBP]
0xF2,0x0F,0x5E,0xE8, // divsd XMM5,XMM0
0xF2,0x0F,0x5E,0x6D,0xE0, // divsd XMM5,-020h[EBP]
0xF3,0x0F,0x5E,0xE8, // divss XMM5,XMM0
0xF3,0x0F,0x5E,0x6D,0xD8, // divss XMM5,-028h[EBP]
0x66, 0x0F,0xF7,0xD1, // maskmovdqu XMM2,XMM1
0x0F,0xF7,0xE3, // maskmovq MM4,MM3
0x66, 0x0F,0x5F,0xC0, // maxpd XMM0,XMM0
0x66, 0x0F,0x5F,0x4D,0xE8, // maxpd XMM1,-018h[EBP]
0x0F,0x5F,0xD1, // maxps XMM2,XMM1
0x0F,0x5F,0x5D,0xE8, // maxps XMM3,-018h[EBP]
0xF2,0x0F,0x5F,0xE2, // maxsd XMM4,XMM2
0xF2,0x0F,0x5F,0x6D,0xE0, // maxsd XMM5,-020h[EBP]
0xF3,0x0F,0x5F,0xF3, // maxss XMM6,XMM3
0xF3,0x0F,0x5F,0x7D,0xD8, // maxss XMM7,-028h[EBP]
0x66, 0x0F,0x5D,0xC0, // minpd XMM0,XMM0
0x66, 0x0F,0x5D,0x4D,0xE8, // minpd XMM1,-018h[EBP]
0x0F,0x5D,0xD1, // minps XMM2,XMM1
0x0F,0x5D,0x5D,0xE8, // minps XMM3,-018h[EBP]
0xF2,0x0F,0x5D,0xE2, // minsd XMM4,XMM2
0xF2,0x0F,0x5D,0x6D,0xE0, // minsd XMM5,-020h[EBP]
0xF3,0x0F,0x5D,0xF3, // minss XMM6,XMM3
0xF3,0x0F,0x5D,0x7D,0xD8, // minss XMM7,-028h[EBP]
0x66, 0x0F,0x28,0xCA, // movapd XMM1,XMM2
0x66, 0x0F,0x28,0x5D,0xE8, // movapd XMM3,-018h[EBP]
0x66, 0x0F,0x29,0x65,0xE8, // movapd -018h[EBP],XMM4
0x0F,0x28,0xCA, // movaps XMM1,XMM2
0x0F,0x28,0x5D,0xE8, // movaps XMM3,-018h[EBP]
0x0F,0x29,0x65,0xE8, // movaps -018h[EBP],XMM4
0x0F,0x6E,0xCB, // movd MM1,EBX
0x0F,0x6E,0x55,0xD8, // movd MM2,-028h[EBP]
0x0F,0x7E,0xDB, // movd EBX,MM3
0x0F,0x7E,0x65,0xD8, // movd -028h[EBP],MM4
0x66, 0x0F,0x6E,0xCB, // movd XMM1,EBX
0x66, 0x0F,0x6E,0x55,0xD8, // movd XMM2,-028h[EBP]
0x66, 0x0F,0x7E,0xDB, // movd EBX,XMM3
0x66, 0x0F,0x7E,0x65,0xD8, // movd -028h[EBP],XMM4
0x66, 0x0F,0x6F,0xCA, // movdqa XMM1,XMM2
0x66, 0x0F,0x6F,0x55,0xE8, // movdqa XMM2,-018h[EBP]
0x66, 0x0F,0x7F,0x65,0xE8, // movdqa -018h[EBP],XMM4
0xF3,0x0F,0x6F,0xCA, // movdqu XMM1,XMM2
0xF3,0x0F,0x6F,0x55,0xE8, // movdqu XMM2,-018h[EBP]
0xF3,0x0F,0x7F,0x65,0xE8, // movdqu -018h[EBP],XMM4
0xF2,0x0F,0xD6,0xDC, // movdq2q MM4,XMM3
0x0F,0x12,0xDC, // movhlps XMM4,XMM3
0x66, 0x0F,0x16,0x55,0xE0, // movhpd XMM2,-020h[EBP]
0x66, 0x0F,0x17,0x7D,0xE0, // movhpd -020h[EBP],XMM7
0x0F,0x16,0x55,0xE0, // movhps XMM2,-020h[EBP]
0x0F,0x17,0x7D,0xE0, // movhps -020h[EBP],XMM7
0x0F,0x16,0xDC, // movlhps XMM4,XMM3
0x66, 0x0F,0x12,0x55,0xE0, // movlpd XMM2,-020h[EBP]
0x66, 0x0F,0x13,0x7D,0xE0, // movlpd -020h[EBP],XMM7
0x0F,0x12,0x55,0xE0, // movlps XMM2,-020h[EBP]
0x0F,0x13,0x7D,0xE0, // movlps -020h[EBP],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,0xE8, // mulpd XMM1,-018h[EBP]
0x0F,0x59,0xD1, // mulps XMM2,XMM1
0x0F,0x59,0x5D,0xE8, // mulps XMM3,-018h[EBP]
0xF2,0x0F,0x59,0xE2, // mulsd XMM4,XMM2
0xF2,0x0F,0x59,0x6D,0xE0, // mulsd XMM5,-020h[EBP]
0xF3,0x0F,0x59,0xF3, // mulss XMM6,XMM3
0xF3,0x0F,0x59,0x7D,0xD8, // mulss XMM7,-028h[EBP]
0x66, 0x0F,0x51,0xC4, // sqrtpd XMM0,XMM4
0x66, 0x0F,0x51,0x4D,0xE8, // sqrtpd XMM1,-018h[EBP]
0x0F,0x51,0xD5, // sqrtps XMM2,XMM5
0x0F,0x51,0x5D,0xE8, // sqrtps XMM3,-018h[EBP]
0xF2,0x0F,0x51,0xE6, // sqrtsd XMM4,XMM6
0xF2,0x0F,0x51,0x6D,0xE0, // sqrtsd XMM5,-020h[EBP]
0xF3,0x0F,0x51,0xF7, // sqrtss XMM6,XMM7
0xF3,0x0F,0x51,0x7D,0xD8, // sqrtss XMM7,-028h[EBP]
0x66, 0x0F,0x5C,0xC4, // subpd XMM0,XMM4
0x66, 0x0F,0x5C,0x4D,0xE8, // subpd XMM1,-018h[EBP]
0x0F,0x5C,0xD5, // subps XMM2,XMM5
0x0F,0x5C,0x5D,0xE8, // subps XMM3,-018h[EBP]
0xF2,0x0F,0x5C,0xE6, // subsd XMM4,XMM6
0xF2,0x0F,0x5C,0x6D,0xE0, // subsd XMM5,-020h[EBP]
0xF3,0x0F,0x5C,0xF7, // subss XMM6,XMM7
0xF3,0x0F,0x5C,0x7D,0xD8, // subss XMM7,-028h[EBP]
0x0F,0x01,0xE0, // smsw EAX
];
int i;
asm
{
call L1 ;
ud2 ;
syscall ;
sysenter ;
sysexit ;
sysret ;
lfence ;
mfence ;
sfence ;
fxsave [EAX] ;
fxrstor [EAX] ;
ldmxcsr [EAX] ;
stmxcsr [EAX] ;
clflush [EAX] ;
addps XMM1,[EAX] ;
addps XMM1,XMM2 ;
addpd XMM0,[EBX] ;
addpd XMM2,XMM1 ;
addsd XMM1,[EAX] ;
addsd XMM1,XMM2 ;
addss XMM5,[ESI] ;
addss XMM6,XMM7 ;
andps XMM1,[EAX] ;
andps XMM1,XMM2 ;
andpd XMM0,[EBX] ;
andpd XMM2,XMM1 ;
andnps XMM1,[EAX] ;
andnps XMM1,XMM2 ;
andnpd XMM0,[EBX] ;
andnpd XMM2,XMM1 ;
cmpsd ;
cmpps XMM1,[EAX],1 ;
cmpps XMM1,XMM2,2 ;
cmppd XMM0,[EBX],3 ;
cmppd XMM2,XMM1,4 ;
cmpsd XMM1,[EAX],5 ;
cmpsd XMM1,XMM2,6 ;
cmpss XMM5,[ESI],7 ;
cmpss XMM6,XMM7,0 ;
comisd XMM1,[EAX] ;
comisd XMM1,m64[EBP] ;
comisd XMM1,XMM2 ;
comiss XMM5,[ESI] ;
comiss XMM6,XMM7 ;
cvtdq2pd XMM3,XMM4 ;
cvtdq2pd XMM3,m64[EBP] ;
cvtdq2ps XMM3,XMM4 ;
cvtdq2ps XMM3,m128[EBP] ;
cvtpd2dq XMM3,XMM4 ;
cvtpd2dq XMM3,m128[EBP] ;
cvtpd2pi MM3,XMM4 ;
cvtpd2pi MM3,m128[EBP] ;
cvtpd2ps XMM3,XMM4 ;
cvtpd2ps XMM3,m128[EBP] ;
cvtpi2pd XMM3,MM4 ;
cvtpi2pd XMM3,m64[EBP] ;
cvtpi2ps XMM3,MM4 ;
cvtpi2ps XMM3,m64[EBP] ;
cvtps2dq XMM3,XMM4 ;
cvtps2dq XMM3,m128[EBP] ;
cvtps2pd XMM3,XMM4 ;
cvtps2pd XMM3,m64[EBP] ;
cvtps2pi MM3,XMM4 ;
cvtps2pi MM3,m64[EBP] ;
cvtsd2si ECX,XMM4 ;
cvtsd2si EDX,m64[EBP] ;
cvtsd2ss XMM3,XMM4 ;
cvtsd2ss XMM3,m64[EBP] ;
cvtsi2sd XMM3,EDX ;
cvtsi2sd XMM3,m32[EBP] ;
cvtsi2ss XMM3,EDX ;
cvtsi2ss XMM3,m32[EBP] ;
cvtss2sd XMM3,XMM4 ;
cvtss2sd XMM3,m32[EBP] ;
cvtss2si EDI,XMM4 ;
cvtss2si EDI,m32[EBP] ;
cvttpd2pi MM3,XMM4 ;
cvttpd2pi MM7,m128[EBP] ;
cvttpd2dq XMM3,XMM4 ;
cvttpd2dq XMM7,m128[EBP] ;
cvttps2dq XMM3,XMM4 ;
cvttps2dq XMM7,m128[EBP] ;
cvttps2pi MM3,XMM4 ;
cvttps2pi MM7,m64[EBP] ;
cvttsd2si EAX,XMM4 ;
cvttsd2si ECX,m64[EBP] ;
cvttss2si EAX,XMM4 ;
cvttss2si ECX,m32[EBP] ;
divpd XMM5,XMM0 ;
divpd XMM5,m128[EBP] ;
divps XMM5,XMM0 ;
divps XMM5,m128[EBP] ;
divsd XMM5,XMM0 ;
divsd XMM5,m64[EBP] ;
divss XMM5,XMM0 ;
divss XMM5,m32[EBP] ;
maskmovdqu XMM1,XMM2 ;
maskmovq MM3,MM4 ;
maxpd XMM0,XMM0 ;
maxpd XMM1,m128[EBP] ;
maxps XMM2,XMM1 ;
maxps XMM3,m128[EBP] ;
maxsd XMM4,XMM2 ;
maxsd XMM5,m64[EBP] ;
maxss XMM6,XMM3 ;
maxss XMM7,m32[EBP] ;
minpd XMM0,XMM0 ;
minpd XMM1,m128[EBP] ;
minps XMM2,XMM1 ;
minps XMM3,m128[EBP] ;
minsd XMM4,XMM2 ;
minsd XMM5,m64[EBP] ;
minss XMM6,XMM3 ;
minss XMM7,m32[EBP] ;
movapd XMM1,XMM2 ;
movapd XMM3,m128[EBP] ;
movapd m128[EBP],XMM4 ;
movaps XMM1,XMM2 ;
movaps XMM3,m128[EBP] ;
movaps m128[EBP],XMM4 ;
movd MM1,EBX ;
movd MM2,m32[EBP] ;
movd EBX,MM3 ;
movd m32[EBP],MM4 ;
movd XMM1,EBX ;
movd XMM2,m32[EBP] ;
movd EBX,XMM3 ;
movd m32[EBP],XMM4 ;
movdqa XMM1,XMM2 ;
movdqa XMM2,m128[EBP] ;
movdqa m128[EBP],XMM4 ;
movdqu XMM1,XMM2 ;
movdqu XMM2,m128[EBP] ;
movdqu m128[EBP],XMM4 ;
movdq2q MM3,XMM4 ;
movhlps XMM3,XMM4 ;
movhpd XMM2,m64[EBP] ;
movhpd m64[EBP],XMM7 ;
movhps XMM2,m64[EBP] ;
movhps m64[EBP],XMM7 ;
movlhps XMM3,XMM4 ;
movlpd XMM2,m64[EBP] ;
movlpd m64[EBP],XMM7 ;
movlps XMM2,m64[EBP] ;
movlps m64[EBP],XMM7 ;
movmskpd ESI,XMM3 ;
movmskps ESI,XMM3 ;
mulpd XMM0,XMM0 ;
mulpd XMM1,m128[EBP] ;
mulps XMM2,XMM1 ;
mulps XMM3,m128[EBP] ;
mulsd XMM4,XMM2 ;
mulsd XMM5,m64[EBP] ;
mulss XMM6,XMM3 ;
mulss XMM7,m32[EBP] ;
sqrtpd XMM0,XMM4 ;
sqrtpd XMM1,m128[EBP] ;
sqrtps XMM2,XMM5 ;
sqrtps XMM3,m128[EBP] ;
sqrtsd XMM4,XMM6 ;
sqrtsd XMM5,m64[EBP] ;
sqrtss XMM6,XMM7 ;
sqrtss XMM7,m32[EBP] ;
subpd XMM0,XMM4 ;
subpd XMM1,m128[EBP] ;
subps XMM2,XMM5 ;
subps XMM3,m128[EBP] ;
subsd XMM4,XMM6 ;
subsd XMM5,m64[EBP] ;
subss XMM6,XMM7 ;
subss XMM7,m32[EBP] ;
smsw EAX ;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
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,0xE8, // movntdq -018h[EBP],XMM2
0x0F,0xC3,0x4D,0xDC, // movnti -024h[EBP],ECX
0x66, 0x0F,0x2B,0x5D,0xE8, // movntpd -018h[EBP],XMM3
0x0F,0x2B,0x65,0xE8, // movntps -018h[EBP],XMM4
0x0F,0xE7,0x6D,0xE0, // movntq -020h[EBP],MM5
0x0F,0x6F,0xCA, // movq MM1,MM2
0x0F,0x6F,0x55,0xE0, // movq MM2,-020h[EBP]
0x0F,0x7F,0x5D,0xE0, // movq -020h[EBP],MM3
0xF3,0x0F,0x7E,0xCA, // movq XMM1,XMM2
0xF3,0x0F,0x7E,0x55,0xE0, // movq XMM2,-020h[EBP]
0x66, 0x0F,0xD6,0x5D,0xE0, // movq -020h[EBP],XMM3
0xF3,0x0F,0xD6,0xDA, // movq2dq XMM3,MM2
0xA5, // movsd
0xF2,0x0F,0x10,0xCA, // movsd XMM1,XMM2
0xF2,0x0F,0x10,0x5D,0xE0, // movsd XMM3,-020h[EBP]
0xF2,0x0F,0x11,0x65,0xE0, // movsd -020h[EBP],XMM4
0xF3,0x0F,0x10,0xCA, // movss XMM1,XMM2
0xF3,0x0F,0x10,0x5D,0xDC, // movss XMM3,-024h[EBP]
0xF3,0x0F,0x11,0x65,0xDC, // movss -024h[EBP],XMM4
0x66, 0x0F,0x10,0xCA, // movupd XMM1,XMM2
0x66, 0x0F,0x10,0x5D,0xE8, // movupd XMM3,-018h[EBP]
0x66, 0x0F,0x11,0x65,0xE8, // movupd -018h[EBP],XMM4
0x0F,0x10,0xCA, // movups XMM1,XMM2
0x0F,0x10,0x5D,0xE8, // movups XMM3,-018h[EBP]
0x0F,0x11,0x65,0xE8, // movups -018h[EBP],XMM4
0x66, 0x0F,0x56,0xCA, // orpd XMM1,XMM2
0x66, 0x0F,0x56,0x5D,0xE8, // orpd XMM3,-018h[EBP]
0x0F,0x56,0xCA, // orps XMM1,XMM2
0x0F,0x56,0x5D,0xE8, // orps XMM3,-018h[EBP]
0x0F,0x63,0xCA, // packsswb MM1,MM2
0x0F,0x63,0x5D,0xE0, // packsswb MM3,-020h[EBP]
0x66, 0x0F,0x63,0xCA, // packsswb XMM1,XMM2
0x66, 0x0F,0x63,0x5D,0xE8, // packsswb XMM3,-018h[EBP]
0x0F,0x6B,0xCA, // packssdw MM1,MM2
0x0F,0x6B,0x5D,0xE0, // packssdw MM3,-020h[EBP]
0x66, 0x0F,0x6B,0xCA, // packssdw XMM1,XMM2
0x66, 0x0F,0x6B,0x5D,0xE8, // packssdw XMM3,-018h[EBP]
0x0F,0x67,0xCA, // packuswb MM1,MM2
0x0F,0x67,0x5D,0xE0, // packuswb MM3,-020h[EBP]
0x66, 0x0F,0x67,0xCA, // packuswb XMM1,XMM2
0x66, 0x0F,0x67,0x5D,0xE8, // packuswb XMM3,-018h[EBP]
0x0F,0xFC,0xCA, // paddb MM1,MM2
0x0F,0xFC,0x5D,0xE0, // paddb MM3,-020h[EBP]
0x66, 0x0F,0xFC,0xCA, // paddb XMM1,XMM2
0x66, 0x0F,0xFC,0x5D,0xE8, // paddb XMM3,-018h[EBP]
0x0F,0xFD,0xCA, // paddw MM1,MM2
0x0F,0xFD,0x5D,0xE0, // paddw MM3,-020h[EBP]
0x66, 0x0F,0xFD,0xCA, // paddw XMM1,XMM2
0x66, 0x0F,0xFD,0x5D,0xE8, // paddw XMM3,-018h[EBP]
0x0F,0xFE,0xCA, // paddd MM1,MM2
0x0F,0xFE,0x5D,0xE0, // paddd MM3,-020h[EBP]
0x66, 0x0F,0xFE,0xCA, // paddd XMM1,XMM2
0x66, 0x0F,0xFE,0x5D,0xE8, // paddd XMM3,-018h[EBP]
0x0F,0xD4,0xCA, // paddq MM1,MM2
0x0F,0xD4,0x5D,0xE0, // paddq MM3,-020h[EBP]
0x66, 0x0F,0xD4,0xCA, // paddq XMM1,XMM2
0x66, 0x0F,0xD4,0x5D,0xE8, // paddq XMM3,-018h[EBP]
0x0F,0xEC,0xCA, // paddsb MM1,MM2
0x0F,0xEC,0x5D,0xE0, // paddsb MM3,-020h[EBP]
0x66, 0x0F,0xEC,0xCA, // paddsb XMM1,XMM2
0x66, 0x0F,0xEC,0x5D,0xE8, // paddsb XMM3,-018h[EBP]
0x0F,0xED,0xCA, // paddsw MM1,MM2
0x0F,0xED,0x5D,0xE0, // paddsw MM3,-020h[EBP]
0x66, 0x0F,0xED,0xCA, // paddsw XMM1,XMM2
0x66, 0x0F,0xED,0x5D,0xE8, // paddsw XMM3,-018h[EBP]
0x0F,0xDC,0xCA, // paddusb MM1,MM2
0x0F,0xDC,0x5D,0xE0, // paddusb MM3,-020h[EBP]
0x66, 0x0F,0xDC,0xCA, // paddusb XMM1,XMM2
0x66, 0x0F,0xDC,0x5D,0xE8, // paddusb XMM3,-018h[EBP]
0x0F,0xDD,0xCA, // paddusw MM1,MM2
0x0F,0xDD,0x5D,0xE0, // paddusw MM3,-020h[EBP]
0x66, 0x0F,0xDD,0xCA, // paddusw XMM1,XMM2
0x66, 0x0F,0xDD,0x5D,0xE8, // paddusw XMM3,-018h[EBP]
0x0F,0xDB,0xCA, // pand MM1,MM2
0x0F,0xDB,0x5D,0xE0, // pand MM3,-020h[EBP]
0x66, 0x0F,0xDB,0xCA, // pand XMM1,XMM2
0x66, 0x0F,0xDB,0x5D,0xE8, // pand XMM3,-018h[EBP]
0x0F,0xDF,0xCA, // pandn MM1,MM2
0x0F,0xDF,0x5D,0xE0, // pandn MM3,-020h[EBP]
0x66, 0x0F,0xDF,0xCA, // pandn XMM1,XMM2
0x66, 0x0F,0xDF,0x5D,0xE8, // pandn XMM3,-018h[EBP]
0x0F,0xE0,0xCA, // pavgb MM1,MM2
0x0F,0xE0,0x5D,0xE0, // pavgb MM3,-020h[EBP]
0x66, 0x0F,0xE0,0xCA, // pavgb XMM1,XMM2
0x66, 0x0F,0xE0,0x5D,0xE8, // pavgb XMM3,-018h[EBP]
0x0F,0xE3,0xCA, // pavgw MM1,MM2
0x0F,0xE3,0x5D,0xE0, // pavgw MM3,-020h[EBP]
0x66, 0x0F,0xE3,0xCA, // pavgw XMM1,XMM2
0x66, 0x0F,0xE3,0x5D,0xE8, // pavgw XMM3,-018h[EBP]
0x0F,0x74,0xCA, // pcmpeqb MM1,MM2
0x0F,0x74,0x5D,0xE0, // pcmpeqb MM3,-020h[EBP]
0x66, 0x0F,0x74,0xCA, // pcmpeqb XMM1,XMM2
0x66, 0x0F,0x74,0x5D,0xE8, // pcmpeqb XMM3,-018h[EBP]
0x0F,0x75,0xCA, // pcmpeqw MM1,MM2
0x0F,0x75,0x5D,0xE0, // pcmpeqw MM3,-020h[EBP]
0x66, 0x0F,0x75,0xCA, // pcmpeqw XMM1,XMM2
0x66, 0x0F,0x75,0x5D,0xE8, // pcmpeqw XMM3,-018h[EBP]
0x0F,0x76,0xCA, // pcmpeqd MM1,MM2
0x0F,0x76,0x5D,0xE0, // pcmpeqd MM3,-020h[EBP]
0x66, 0x0F,0x76,0xCA, // pcmpeqd XMM1,XMM2
0x66, 0x0F,0x76,0x5D,0xE8, // pcmpeqd XMM3,-018h[EBP]
0x0F,0x64,0xCA, // pcmpgtb MM1,MM2
0x0F,0x64,0x5D,0xE0, // pcmpgtb MM3,-020h[EBP]
0x66, 0x0F,0x64,0xCA, // pcmpgtb XMM1,XMM2
0x66, 0x0F,0x64,0x5D,0xE8, // pcmpgtb XMM3,-018h[EBP]
0x0F,0x65,0xCA, // pcmpgtw MM1,MM2
0x0F,0x65,0x5D,0xE0, // pcmpgtw MM3,-020h[EBP]
0x66, 0x0F,0x65,0xCA, // pcmpgtw XMM1,XMM2
0x66, 0x0F,0x65,0x5D,0xE8, // pcmpgtw XMM3,-018h[EBP]
0x0F,0x66,0xCA, // pcmpgtd MM1,MM2
0x0F,0x66,0x5D,0xE0, // pcmpgtd MM3,-020h[EBP]
0x66, 0x0F,0x66,0xCA, // pcmpgtd XMM1,XMM2
0x66, 0x0F,0x66,0x5D,0xE8, // pcmpgtd XMM3,-018h[EBP]
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,0xDA,0x07, // pinsrw MM6,-026h[EBP],7
0x66, 0x0F,0xC4,0xF2,0x07, // pinsrw XMM6,EDX,7
0x66, 0x0F,0xC4,0x75,0xDA,0x07, // pinsrw XMM6,-026h[EBP],7
0x0F,0xF5,0xCA, // pmaddwd MM1,MM2
0x0F,0xF5,0x5D,0xE0, // pmaddwd MM3,-020h[EBP]
0x66, 0x0F,0xF5,0xCA, // pmaddwd XMM1,XMM2
0x66, 0x0F,0xF5,0x5D,0xE8, // pmaddwd XMM3,-018h[EBP]
0x0F,0xEE,0xCA, // pmaxsw MM1,XMM2
0x0F,0xEE,0x5D,0xE0, // pmaxsw MM3,-020h[EBP]
0x66, 0x0F,0xEE,0xCA, // pmaxsw XMM1,XMM2
0x66, 0x0F,0xEE,0x5D,0xE8, // pmaxsw XMM3,-018h[EBP]
0x0F,0xDE,0xCA, // pmaxub MM1,XMM2
0x0F,0xDE,0x5D,0xE0, // pmaxub MM3,-020h[EBP]
0x66, 0x0F,0xDE,0xCA, // pmaxub XMM1,XMM2
0x66, 0x0F,0xDE,0x5D,0xE8, // pmaxub XMM3,-018h[EBP]
0x0F,0xEA,0xCA, // pminsw MM1,MM2
0x0F,0xEA,0x5D,0xE0, // pminsw MM3,-020h[EBP]
0x66, 0x0F,0xEA,0xCA, // pminsw XMM1,XMM2
0x66, 0x0F,0xEA,0x5D,0xE8, // pminsw XMM3,-018h[EBP]
0x0F,0xDA,0xCA, // pminub MM1,MM2
0x0F,0xDA,0x5D,0xE0, // pminub MM3,-020h[EBP]
0x66, 0x0F,0xDA,0xCA, // pminub XMM1,XMM2
0x66, 0x0F,0xDA,0x5D,0xE8, // pminub XMM3,-018h[EBP]
0x0F,0xD7,0xC8, // pmovmskb ECX,MM0
0x66, 0x0F,0xD7,0xCE, // pmovmskb ECX,XMM6
0x0F,0xE4,0xCA, // pmulhuw MM1,MM2
0x0F,0xE4,0x5D,0xE0, // pmulhuw MM3,-020h[EBP]
0x66, 0x0F,0xE4,0xCA, // pmulhuw XMM1,XMM2
0x66, 0x0F,0xE4,0x5D,0xE8, // pmulhuw XMM3,-018h[EBP]
0x0F,0xE5,0xCA, // pmulhw MM1,MM2
0x0F,0xE5,0x5D,0xE0, // pmulhw MM3,-020h[EBP]
0x66, 0x0F,0xE5,0xCA, // pmulhw XMM1,XMM2
0x66, 0x0F,0xE5,0x5D,0xE8, // pmulhw XMM3,-018h[EBP]
0x0F,0xD5,0xCA, // pmullw MM1,MM2
0x0F,0xD5,0x5D,0xE0, // pmullw MM3,-020h[EBP]
0x66, 0x0F,0xD5,0xCA, // pmullw XMM1,XMM2
0x66, 0x0F,0xD5,0x5D,0xE8, // pmullw XMM3,-018h[EBP]
0x0F,0xF4,0xCA, // pmuludq MM1,MM2
0x0F,0xF4,0x5D,0xE0, // pmuludq MM3,-020h[EBP]
0x66, 0x0F,0xF4,0xCA, // pmuludq XMM1,XMM2
0x66, 0x0F,0xF4,0x5D,0xE8, // pmuludq XMM3,-018h[EBP]
0x0F,0xEB,0xCA, // por MM1,MM2
0x0F,0xEB,0x5D,0xE0, // por MM3,-020h[EBP]
0x66, 0x0F,0xEB,0xCA, // por XMM1,XMM2
0x66, 0x0F,0xEB,0x5D,0xE8, // por XMM3,-018h[EBP]
0x0F,0x18,0x4D,0xD8, // prefetcht0 -028h[EBP]
0x0F,0x18,0x55,0xD8, // prefetcht1 -028h[EBP]
0x0F,0x18,0x5D,0xD8, // prefetcht2 -028h[EBP]
0x0F,0x18,0x45,0xD8, // prefetchnta -028h[EBP]
0x0F,0x0D,0x4D,0xD8, // prefetchw -028h[RBP]
0x0F,0x0D,0x55,0xD8, // prefetchwt1 -028h[RBP]
0x0F,0xF6,0xCA, // psadbw MM1,MM2
0x0F,0xF6,0x5D,0xE0, // psadbw MM3,-020h[EBP]
0x66, 0x0F,0xF6,0xCA, // psadbw XMM1,XMM2
0x66, 0x0F,0xF6,0x5D,0xE8, // psadbw XMM3,-018h[EBP]
0x66, 0x0F,0x70,0xCA,0x03, // pshufd XMM1,XMM2
0x66, 0x0F,0x70,0x5D,0xE8,0x03, // pshufd XMM3,-018h[EBP]
0xF3,0x0F,0x70,0xCA,0x03, // pshufhw XMM1,XMM2
0xF3,0x0F,0x70,0x5D,0xE8,0x03, // pshufhw XMM3,-018h[EBP]
0xF2,0x0F,0x70,0xCA,0x03, // pshuflw XMM1,XMM2
0xF2,0x0F,0x70,0x5D,0xE8,0x03, // pshuflw XMM3,-018h[EBP]
0x0F,0x70,0xCA,0x03, // pshufw MM1,MM2
0x0F,0x70,0x5D,0xE0,0x03, // pshufw MM3,-020h[EBP]
0x66, 0x0F,0x73,0xF9,0x18, // pslldq XMM1,018h
0x0F,0xF1,0xCA, // psllw MM1,MM2
0x0F,0xF1,0x4D,0xE0, // psllw MM1,-020h[EBP]
0x66, 0x0F,0xF1,0xCA, // psllw XMM1,XMM2
0x66, 0x0F,0xF1,0x4D,0xE8, // psllw XMM1,-018h[EBP]
0x0F,0x71,0xF1,0x15, // psraw MM1,015h
0x66, 0x0F,0x71,0xF1,0x15, // psraw XMM1,015h
0x0F,0xF2,0xCA, // pslld MM1,MM2
0x0F,0xF2,0x4D,0xE0, // pslld MM1,-020h[EBP]
0x66, 0x0F,0xF2,0xCA, // pslld XMM1,XMM2
0x66, 0x0F,0xF2,0x4D,0xE8, // pslld XMM1,-018h[EBP]
0x0F,0x72,0xF1,0x15, // psrad MM1,015h
0x66, 0x0F,0x72,0xF1,0x15, // psrad XMM1,015h
0x0F,0xF3,0xCA, // psllq MM1,MM2
0x0F,0xF3,0x4D,0xE0, // psllq MM1,-020h[EBP]
0x66, 0x0F,0xF3,0xCA, // psllq XMM1,XMM2
0x66, 0x0F,0xF3,0x4D,0xE8, // psllq XMM1,-018h[EBP]
0x0F,0x73,0xF1,0x15, // psllq MM1,015h
0x66, 0x0F,0x73,0xF1,0x15, // psllq XMM1,015h
0x0F,0xE1,0xCA, // psraw MM1,MM2
0x0F,0xE1,0x4D,0xE0, // psraw MM1,-020h[EBP]
0x66, 0x0F,0xE1,0xCA, // psraw XMM1,XMM2
0x66, 0x0F,0xE1,0x4D,0xE8, // psraw XMM1,-018h[EBP]
0x0F,0x71,0xE1,0x15, // psraw MM1,015h
0x66, 0x0F,0x71,0xE1,0x15, // psraw XMM1,015h
0x0F,0xE2,0xCA, // psrad MM1,MM2
0x0F,0xE2,0x4D,0xE0, // psrad MM1,-020h[EBP]
0x66, 0x0F,0xE2,0xCA, // psrad XMM1,XMM2
0x66, 0x0F,0xE2,0x4D,0xE8, // psrad XMM1,-018h[EBP]
0x0F,0x72,0xE1,0x15, // psrad MM1,015h
0x66, 0x0F,0x72,0xE1,0x15, // psrad XMM1,015h
0x66, 0x0F,0x73,0xD9,0x18, // psrldq XMM1,018h
0x0F,0xD1,0xCA, // psrlw MM1,MM2
0x0F,0xD1,0x4D,0xE0, // psrlw MM1,-020h[EBP]
0x66, 0x0F,0xD1,0xCA, // psrlw XMM1,XMM2
0x66, 0x0F,0xD1,0x4D,0xE8, // psrlw XMM1,-018h[EBP]
0x0F,0x71,0xD1,0x15, // psrlw MM1,015h
0x66, 0x0F,0x71,0xD1,0x15, // psrlw XMM1,015h
0x0F,0xD2,0xCA, // psrld MM1,MM2
0x0F,0xD2,0x4D,0xE0, // psrld MM1,-020h[EBP]
0x66, 0x0F,0xD2,0xCA, // psrld XMM1,XMM2
0x66, 0x0F,0xD2,0x4D,0xE8, // psrld XMM1,-018h[EBP]
0x0F,0x72,0xD1,0x15, // psrld MM1,015h
0x66, 0x0F,0x72,0xD1,0x15, // psrld XMM1,015h
0x0F,0xD3,0xCA, // psrlq MM1,MM2
0x0F,0xD3,0x4D,0xE0, // psrlq MM1,-020h[EBP]
0x66, 0x0F,0xD3,0xCA, // psrlq XMM1,XMM2
0x66, 0x0F,0xD3,0x4D,0xE8, // psrlq XMM1,-018h[EBP]
0x0F,0x73,0xD1,0x15, // psrlq MM1,015h
0x66, 0x0F,0x73,0xD1,0x15, // psrlq XMM1,015h
0x0F,0xF8,0xCA, // psubb MM1,MM2
0x0F,0xF8,0x4D,0xE0, // psubb MM1,-020h[EBP]
0x66, 0x0F,0xF8,0xCA, // psubb XMM1,XMM2
0x66, 0x0F,0xF8,0x4D,0xE8, // psubb XMM1,-018h[EBP]
0x0F,0xF9,0xCA, // psubw MM1,MM2
0x0F,0xF9,0x4D,0xE0, // psubw MM1,-020h[EBP]
0x66, 0x0F,0xF9,0xCA, // psubw XMM1,XMM2
0x66, 0x0F,0xF9,0x4D,0xE8, // psubw XMM1,-018h[EBP]
0x0F,0xFA,0xCA, // psubd MM1,MM2
0x0F,0xFA,0x4D,0xE0, // psubd MM1,-020h[EBP]
0x66, 0x0F,0xFA,0xCA, // psubd XMM1,XMM2
0x66, 0x0F,0xFA,0x4D,0xE8, // psubd XMM1,-018h[EBP]
0x0F,0xFB,0xCA, // psubq MM1,MM2
0x0F,0xFB,0x4D,0xE0, // psubq MM1,-020h[EBP]
0x66, 0x0F,0xFB,0xCA, // psubq XMM1,XMM2
0x66, 0x0F,0xFB,0x4D,0xE8, // psubq XMM1,-018h[EBP]
0x0F,0xE8,0xCA, // psubsb MM1,MM2
0x0F,0xE8,0x4D,0xE0, // psubsb MM1,-020h[EBP]
0x66, 0x0F,0xE8,0xCA, // psubsb XMM1,XMM2
0x66, 0x0F,0xE8,0x4D,0xE8, // psubsb XMM1,-018h[EBP]
0x0F,0xE9,0xCA, // psubsw MM1,MM2
0x0F,0xE9,0x4D,0xE0, // psubsw MM1,-020h[EBP]
0x66, 0x0F,0xE9,0xCA, // psubsw XMM1,XMM2
0x66, 0x0F,0xE9,0x4D,0xE8, // psubsw XMM1,-018h[EBP]
0x0F,0xD8,0xCA, // psubusb MM1,MM2
0x0F,0xD8,0x4D,0xE0, // psubusb MM1,-020h[EBP]
0x66, 0x0F,0xD8,0xCA, // psubusb XMM1,XMM2
0x66, 0x0F,0xD8,0x4D,0xE8, // psubusb XMM1,-018h[EBP]
0x0F,0xD9,0xCA, // psubusw MM1,MM2
0x0F,0xD9,0x4D,0xE0, // psubusw MM1,-020h[EBP]
0x66, 0x0F,0xD9,0xCA, // psubusw XMM1,XMM2
0x66, 0x0F,0xD9,0x4D,0xE8, // psubusw XMM1,-018h[EBP]
0x0F,0x68,0xCA, // punpckhbw MM1,MM2
0x0F,0x68,0x4D,0xE0, // punpckhbw MM1,-020h[EBP]
0x66, 0x0F,0x68,0xCA, // punpckhbw XMM1,XMM2
0x66, 0x0F,0x68,0x4D,0xE8, // punpckhbw XMM1,-018h[EBP]
0x0F,0x69,0xCA, // punpckhwd MM1,MM2
0x0F,0x69,0x4D,0xE0, // punpckhwd MM1,-020h[EBP]
0x66, 0x0F,0x69,0xCA, // punpckhwd XMM1,XMM2
0x66, 0x0F,0x69,0x4D,0xE8, // punpckhwd XMM1,-018h[EBP]
0x0F,0x6A,0xCA, // punpckhdq MM1,MM2
0x0F,0x6A,0x4D,0xE0, // punpckhdq MM1,-020h[EBP]
0x66, 0x0F,0x6A,0xCA, // punpckhdq XMM1,XMM2
0x66, 0x0F,0x6A,0x4D,0xE8, // punpckhdq XMM1,-018h[EBP]
0x66, 0x0F,0x6D,0xCA, // punpckhqdq XMM1,XMM2
0x66, 0x0F,0x6D,0x4D,0xE8, // punpckhqdq XMM1,-018h[EBP]
0x0F,0x60,0xCA, // punpcklbw MM1,MM2
0x0F,0x60,0x4D,0xE0, // punpcklbw MM1,-020h[EBP]
0x66, 0x0F,0x60,0xCA, // punpcklbw XMM1,XMM2
0x66, 0x0F,0x60,0x4D,0xE8, // punpcklbw XMM1,-018h[EBP]
0x0F,0x61,0xCA, // punpcklwd MM1,MM2
0x0F,0x61,0x4D,0xE0, // punpcklwd MM1,-020h[EBP]
0x66, 0x0F,0x61,0xCA, // punpcklwd XMM1,XMM2
0x66, 0x0F,0x61,0x4D,0xE8, // punpcklwd XMM1,-018h[EBP]
0x0F,0x62,0xCA, // punpckldq MM1,MM2
0x0F,0x62,0x4D,0xE0, // punpckldq MM1,-020h[EBP]
0x66, 0x0F,0x62,0xCA, // punpckldq XMM1,XMM2
0x66, 0x0F,0x62,0x4D,0xE8, // punpckldq XMM1,-018h[EBP]
0x66, 0x0F,0x6C,0xCA, // punpcklqdq XMM1,XMM2
0x66, 0x0F,0x6C,0x4D,0xE8, // punpcklqdq XMM1,-018h[EBP]
0x0F,0xEF,0xCA, // pxor MM1,MM2
0x0F,0xEF,0x4D,0xE0, // pxor MM1,-020h[EBP]
0x66, 0x0F,0xEF,0xCA, // pxor XMM1,XMM2
0x66, 0x0F,0xEF,0x4D,0xE8, // pxor XMM1,-018h[EBP]
0x0F,0x53,0xCA, // rcpps XMM1,XMM2
0x0F,0x53,0x4D,0xE8, // rcpps XMM1,-018h[EBP]
0xF3,0x0F,0x53,0xCA, // rcpss XMM1,XMM2
0xF3,0x0F,0x53,0x4D,0xDC, // rcpss XMM1,-024h[EBP]
0x0F,0x52,0xCA, // rsqrtps XMM1,XMM2
0x0F,0x52,0x4D,0xE8, // rsqrtps XMM1,-018h[EBP]
0xF3,0x0F,0x52,0xCA, // rsqrtss XMM1,XMM2
0xF3,0x0F,0x52,0x4D,0xDC, // rsqrtss XMM1,-024h[EBP]
0x66, 0x0F,0xC6,0xCA,0x03, // shufpd XMM1,XMM2,3
0x66, 0x0F,0xC6,0x4D,0xE8,0x04, // shufpd XMM1,-018h[EBP],4
0x0F,0xC6,0xCA,0x03, // shufps XMM1,XMM2,3
0x0F,0xC6,0x4D,0xE8,0x04, // shufps XMM1,-018h[EBP],4
0x66, 0x0F,0x2E,0xE6, // ucimisd XMM4,XMM6
0x66, 0x0F,0x2E,0x6D,0xE0, // ucimisd XMM5,-020h[EBP]
0x0F,0x2E,0xF7, // ucomiss XMM6,XMM7
0x0F,0x2E,0x7D,0xDC, // ucomiss XMM7,-024h[EBP]
0x66, 0x0F,0x15,0xE6, // uppckhpd XMM4,XMM6
0x66, 0x0F,0x15,0x6D,0xE8, // uppckhpd XMM5,-018h[EBP]
0x0F,0x15,0xE6, // unpckhps XMM4,XMM6
0x0F,0x15,0x6D,0xE8, // unpckhps XMM5,-018h[EBP]
0x66, 0x0F,0x14,0xE6, // uppcklpd XMM4,XMM6
0x66, 0x0F,0x14,0x6D,0xE8, // uppcklpd XMM5,-018h[EBP]
0x0F,0x14,0xE6, // unpcklps XMM4,XMM6
0x0F,0x14,0x6D,0xE8, // unpcklps XMM5,-018h[EBP]
0x66, 0x0F,0x57,0xCA, // xorpd XMM1,XMM2
0x66, 0x0F,0x57,0x4D,0xE8, // xorpd XMM1,-018h[EBP]
0x0F,0x57,0xCA, // xorps XMM1,XMM2
0x0F,0x57,0x4D,0xE8, // xorps XMM1,-018h[EBP]
];
int i;
asm
{
call L1 ;
movmskpd ESI,XMM3 ;
movmskps ESI,XMM3 ;
movntdq m128[EBP],XMM2 ;
movnti m32[EBP],ECX ;
movntpd m128[EBP],XMM3 ;
movntps m128[EBP],XMM4 ;
movntq m64[EBP],MM5 ;
movq MM1,MM2 ;
movq MM2,m64[EBP] ;
movq m64[EBP],MM3 ;
movq XMM1,XMM2 ;
movq XMM2,m64[EBP] ;
movq m64[EBP],XMM3 ;
movq2dq XMM3,MM2 ;
movsd ;
movsd XMM1,XMM2 ;
movsd XMM3,m64[EBP] ;
movsd m64[EBP],XMM4 ;
movss XMM1,XMM2 ;
movss XMM3,m32[EBP] ;
movss m32[EBP],XMM4 ;
movupd XMM1,XMM2 ;
movupd XMM3,m128[EBP] ;
movupd m128[EBP],XMM4 ;
movups XMM1,XMM2 ;
movups XMM3,m128[EBP] ;
movups m128[EBP],XMM4 ;
orpd XMM1,XMM2 ;
orpd XMM3,m128[EBP] ;
orps XMM1,XMM2 ;
orps XMM3,m128[EBP] ;
packsswb MM1,MM2 ;
packsswb MM3,m64[EBP] ;
packsswb XMM1,XMM2 ;
packsswb XMM3,m128[EBP] ;
packssdw MM1,MM2 ;
packssdw MM3,m64[EBP] ;
packssdw XMM1,XMM2 ;
packssdw XMM3,m128[EBP] ;
packuswb MM1,MM2 ;
packuswb MM3,m64[EBP] ;
packuswb XMM1,XMM2 ;
packuswb XMM3,m128[EBP] ;
paddb MM1,MM2 ;
paddb MM3,m64[EBP] ;
paddb XMM1,XMM2 ;
paddb XMM3,m128[EBP] ;
paddw MM1,MM2 ;
paddw MM3,m64[EBP] ;
paddw XMM1,XMM2 ;
paddw XMM3,m128[EBP] ;
paddd MM1,MM2 ;
paddd MM3,m64[EBP] ;
paddd XMM1,XMM2 ;
paddd XMM3,m128[EBP] ;
paddq MM1,MM2 ;
paddq MM3,m64[EBP] ;
paddq XMM1,XMM2 ;
paddq XMM3,m128[EBP] ;
paddsb MM1,MM2 ;
paddsb MM3,m64[EBP] ;
paddsb XMM1,XMM2 ;
paddsb XMM3,m128[EBP] ;
paddsw MM1,MM2 ;
paddsw MM3,m64[EBP] ;
paddsw XMM1,XMM2 ;
paddsw XMM3,m128[EBP] ;
paddusb MM1,MM2 ;
paddusb MM3,m64[EBP] ;
paddusb XMM1,XMM2 ;
paddusb XMM3,m128[EBP] ;
paddusw MM1,MM2 ;
paddusw MM3,m64[EBP] ;
paddusw XMM1,XMM2 ;
paddusw XMM3,m128[EBP] ;
pand MM1,MM2 ;
pand MM3,m64[EBP] ;
pand XMM1,XMM2 ;
pand XMM3,m128[EBP] ;
pandn MM1,MM2 ;
pandn MM3,m64[EBP] ;
pandn XMM1,XMM2 ;
pandn XMM3,m128[EBP] ;
pavgb MM1,MM2 ;
pavgb MM3,m64[EBP] ;
pavgb XMM1,XMM2 ;
pavgb XMM3,m128[EBP] ;
pavgw MM1,MM2 ;
pavgw MM3,m64[EBP] ;
pavgw XMM1,XMM2 ;
pavgw XMM3,m128[EBP] ;
pcmpeqb MM1,MM2 ;
pcmpeqb MM3,m64[EBP] ;
pcmpeqb XMM1,XMM2 ;
pcmpeqb XMM3,m128[EBP] ;
pcmpeqw MM1,MM2 ;
pcmpeqw MM3,m64[EBP] ;
pcmpeqw XMM1,XMM2 ;
pcmpeqw XMM3,m128[EBP] ;
pcmpeqd MM1,MM2 ;
pcmpeqd MM3,m64[EBP] ;
pcmpeqd XMM1,XMM2 ;
pcmpeqd XMM3,m128[EBP] ;
pcmpgtb MM1,MM2 ;
pcmpgtb MM3,m64[EBP] ;
pcmpgtb XMM1,XMM2 ;
pcmpgtb XMM3,m128[EBP] ;
pcmpgtw MM1,MM2 ;
pcmpgtw MM3,m64[EBP] ;
pcmpgtw XMM1,XMM2 ;
pcmpgtw XMM3,m128[EBP] ;
pcmpgtd MM1,MM2 ;
pcmpgtd MM3,m64[EBP] ;
pcmpgtd XMM1,XMM2 ;
pcmpgtd XMM3,m128[EBP] ;
pextrw EDX,MM6,7 ;
pextrw EDX,XMM6,7 ;
pinsrw MM6,EDX,7 ;
pinsrw MM6,m16[EBP],7 ;
pinsrw XMM6,EDX,7 ;
pinsrw XMM6,m16[EBP],7 ;
pmaddwd MM1,MM2 ;
pmaddwd MM3,m64[EBP] ;
pmaddwd XMM1,XMM2 ;
pmaddwd XMM3,m128[EBP] ;
pmaxsw MM1,MM2 ;
pmaxsw MM3,m64[EBP] ;
pmaxsw XMM1,XMM2 ;
pmaxsw XMM3,m128[EBP] ;
pmaxub MM1,MM2 ;
pmaxub MM3,m64[EBP] ;
pmaxub XMM1,XMM2 ;
pmaxub XMM3,m128[EBP] ;
pminsw MM1,MM2 ;
pminsw MM3,m64[EBP] ;
pminsw XMM1,XMM2 ;
pminsw XMM3,m128[EBP] ;
pminub MM1,MM2 ;
pminub MM3,m64[EBP] ;
pminub XMM1,XMM2 ;
pminub XMM3,m128[EBP] ;
pmovmskb ECX,MM0 ;
pmovmskb ECX,XMM6 ;
pmulhuw MM1,MM2 ;
pmulhuw MM3,m64[EBP] ;
pmulhuw XMM1,XMM2 ;
pmulhuw XMM3,m128[EBP] ;
pmulhw MM1,MM2 ;
pmulhw MM3,m64[EBP] ;
pmulhw XMM1,XMM2 ;
pmulhw XMM3,m128[EBP] ;
pmullw MM1,MM2 ;
pmullw MM3,m64[EBP] ;
pmullw XMM1,XMM2 ;
pmullw XMM3,m128[EBP] ;
pmuludq MM1,MM2 ;
pmuludq MM3,m64[EBP] ;
pmuludq XMM1,XMM2 ;
pmuludq XMM3,m128[EBP] ;
por MM1,MM2 ;
por MM3,m64[EBP] ;
por XMM1,XMM2 ;
por XMM3,m128[EBP] ;
prefetcht0 m8[EBP] ;
prefetcht1 m8[EBP] ;
prefetcht2 m8[EBP] ;
prefetchnta m8[EBP] ;
prefetchw m8[EBP] ;
prefetchwt1 m8[EBP] ;
psadbw MM1,MM2 ;
psadbw MM3,m64[EBP] ;
psadbw XMM1,XMM2 ;
psadbw XMM3,m128[EBP] ;
pshufd XMM1,XMM2,3 ;
pshufd XMM3,m128[EBP],3 ;
pshufhw XMM1,XMM2,3 ;
pshufhw XMM3,m128[EBP],3 ;
pshuflw XMM1,XMM2,3 ;
pshuflw XMM3,m128[EBP],3 ;
pshufw MM1,MM2,3 ;
pshufw MM3,m64[EBP],3 ;
pslldq XMM1,0x18 ;
psllw MM1,MM2 ;
psllw MM1,m64[EBP] ;
psllw XMM1,XMM2 ;
psllw XMM1,m128[EBP] ;
psllw MM1,0x15 ;
psllw XMM1,0x15 ;
pslld MM1,MM2 ;
pslld MM1,m64[EBP] ;
pslld XMM1,XMM2 ;
pslld XMM1,m128[EBP] ;
pslld MM1,0x15 ;
pslld XMM1,0x15 ;
psllq MM1,MM2 ;
psllq MM1,m64[EBP] ;
psllq XMM1,XMM2 ;
psllq XMM1,m128[EBP] ;
psllq MM1,0x15 ;
psllq XMM1,0x15 ;
psraw MM1,MM2 ;
psraw MM1,m64[EBP] ;
psraw XMM1,XMM2 ;
psraw XMM1,m128[EBP] ;
psraw MM1,0x15 ;
psraw XMM1,0x15 ;
psrad MM1,MM2 ;
psrad MM1,m64[EBP] ;
psrad XMM1,XMM2 ;
psrad XMM1,m128[EBP] ;
psrad MM1,0x15 ;
psrad XMM1,0x15 ;
psrldq XMM1,0x18 ;
psrlw MM1,MM2 ;
psrlw MM1,m64[EBP] ;
psrlw XMM1,XMM2 ;
psrlw XMM1,m128[EBP] ;
psrlw MM1,0x15 ;
psrlw XMM1,0x15 ;
psrld MM1,MM2 ;
psrld MM1,m64[EBP] ;
psrld XMM1,XMM2 ;
psrld XMM1,m128[EBP] ;
psrld MM1,0x15 ;
psrld XMM1,0x15 ;
psrlq MM1,MM2 ;
psrlq MM1,m64[EBP] ;
psrlq XMM1,XMM2 ;
psrlq XMM1,m128[EBP] ;
psrlq MM1,0x15 ;
psrlq XMM1,0x15 ;
psubb MM1,MM2 ;
psubb MM1,m64[EBP] ;
psubb XMM1,XMM2 ;
psubb XMM1,m128[EBP] ;
psubw MM1,MM2 ;
psubw MM1,m64[EBP] ;
psubw XMM1,XMM2 ;
psubw XMM1,m128[EBP] ;
psubd MM1,MM2 ;
psubd MM1,m64[EBP] ;
psubd XMM1,XMM2 ;
psubd XMM1,m128[EBP] ;
psubq MM1,MM2 ;
psubq MM1,m64[EBP] ;
psubq XMM1,XMM2 ;
psubq XMM1,m128[EBP] ;
psubsb MM1,MM2 ;
psubsb MM1,m64[EBP] ;
psubsb XMM1,XMM2 ;
psubsb XMM1,m128[EBP] ;
psubsw MM1,MM2 ;
psubsw MM1,m64[EBP] ;
psubsw XMM1,XMM2 ;
psubsw XMM1,m128[EBP] ;
psubusb MM1,MM2 ;
psubusb MM1,m64[EBP] ;
psubusb XMM1,XMM2 ;
psubusb XMM1,m128[EBP] ;
psubusw MM1,MM2 ;
psubusw MM1,m64[EBP] ;
psubusw XMM1,XMM2 ;
psubusw XMM1,m128[EBP] ;
punpckhbw MM1,MM2 ;
punpckhbw MM1,m64[EBP] ;
punpckhbw XMM1,XMM2 ;
punpckhbw XMM1,m128[EBP] ;
punpckhwd MM1,MM2 ;
punpckhwd MM1,m64[EBP] ;
punpckhwd XMM1,XMM2 ;
punpckhwd XMM1,m128[EBP] ;
punpckhdq MM1,MM2 ;
punpckhdq MM1,m64[EBP] ;
punpckhdq XMM1,XMM2 ;
punpckhdq XMM1,m128[EBP] ;
punpckhqdq XMM1,XMM2 ;
punpckhqdq XMM1,m128[EBP] ;
punpcklbw MM1,MM2 ;
punpcklbw MM1,m64[EBP] ;
punpcklbw XMM1,XMM2 ;
punpcklbw XMM1,m128[EBP] ;
punpcklwd MM1,MM2 ;
punpcklwd MM1,m64[EBP] ;
punpcklwd XMM1,XMM2 ;
punpcklwd XMM1,m128[EBP] ;
punpckldq MM1,MM2 ;
punpckldq MM1,m64[EBP] ;
punpckldq XMM1,XMM2 ;
punpckldq XMM1,m128[EBP] ;
punpcklqdq XMM1,XMM2 ;
punpcklqdq XMM1,m128[EBP] ;
pxor MM1,MM2 ;
pxor MM1,m64[EBP] ;
pxor XMM1,XMM2 ;
pxor XMM1,m128[EBP] ;
rcpps XMM1,XMM2 ;
rcpps XMM1,m128[EBP] ;
rcpss XMM1,XMM2 ;
rcpss XMM1,m32[EBP] ;
rsqrtps XMM1,XMM2 ;
rsqrtps XMM1,m128[EBP] ;
rsqrtss XMM1,XMM2 ;
rsqrtss XMM1,m32[EBP] ;
shufpd XMM1,XMM2,3 ;
shufpd XMM1,m128[EBP],4 ;
shufps XMM1,XMM2,3 ;
shufps XMM1,m128[EBP],4 ;
ucomisd XMM4,XMM6 ;
ucomisd XMM5,m64[EBP] ;
ucomiss XMM6,XMM7 ;
ucomiss XMM7,m32[EBP] ;
unpckhpd XMM4,XMM6 ;
unpckhpd XMM5,m128[EBP] ;
unpckhps XMM4,XMM6 ;
unpckhps XMM5,m128[EBP] ;
unpcklpd XMM4,XMM6 ;
unpcklpd XMM5,m128[EBP] ;
unpcklps XMM4,XMM6 ;
unpcklps XMM5,m128[EBP] ;
xorpd XMM1,XMM2 ;
xorpd XMM1,m128[EBP] ;
xorps XMM1,XMM2 ;
xorps XMM1,m128[EBP] ;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
for (i = 0; i < data.length; 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,0xE0,0xBF, // pavgusb MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x1D, // pf2id MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x1D, // pf2id MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xAE, // pfacc MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xAE, // pfacc MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x9E, // pfadd MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x9E, // pfadd MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xB0, // pfcmpeq MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xB0, // pfcmpeq MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x90, // pfcmpge MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x90, // pfcmpge MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xA0, // pfcmpgt MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xA0, // pfcmpgt MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xA4, // pfmax MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x94, // pfmin MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xB4, // pfmul MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xB4, // pfmul MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x8A, // pfnacc MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x8E, // pfpnacc MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x96, // pfrcp MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x96, // pfrcp MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xA6, // pfrcpit1 MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xA6, // pfrcpit1 MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xB6, // pfrcpit2 MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xB6, // pfrcpit2 MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x97, // pfrsqrt MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xA7, // pfrsqit1 MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x9A, // pfsub MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x9A, // pfsub MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xAA, // pfsubr MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xAA, // pfsubr MM3,-020h[EBP]
0x0F,0x0F,0xDC,0x0D, // pi2fd MM3,MM4
0x0F,0x0F,0x5D,0xE0,0x0D, // pi2fd MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xB7, // pmulhrw MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xB7, // pmulhrw MM3,-020h[EBP]
0x0F,0x0F,0xDC,0xBB, // pswapd MM3,MM4
0x0F,0x0F,0x5D,0xE0,0xBB, // pswapd MM3,-020h[EBP]
];
int i;
asm
{
call L1 ;
pavgusb MM3,MM4 ;
pavgusb MM3,m64[EBP] ;
pf2id MM3,MM4 ;
pf2id MM3,m64[EBP] ;
pfacc MM3,MM4 ;
pfacc MM3,m64[EBP] ;
pfadd MM3,MM4 ;
pfadd MM3,m64[EBP] ;
pfcmpeq MM3,MM4 ;
pfcmpeq MM3,m64[EBP] ;
pfcmpge MM3,MM4 ;
pfcmpge MM3,m64[EBP] ;
pfcmpgt MM3,MM4 ;
pfcmpgt MM3,m64[EBP] ;
pfmax MM3,MM4 ;
pfmin MM3,m64[EBP] ;
pfmul MM3,MM4 ;
pfmul MM3,m64[EBP] ;
pfnacc MM3,MM4 ;
pfpnacc MM3,m64[EBP] ;
pfrcp MM3,MM4 ;
pfrcp MM3,m64[EBP] ;
pfrcpit1 MM3,MM4 ;
pfrcpit1 MM3,m64[EBP] ;
pfrcpit2 MM3,MM4 ;
pfrcpit2 MM3,m64[EBP] ;
pfrsqrt MM3,MM4 ;
pfrsqit1 MM3,m64[EBP] ;
pfsub MM3,MM4 ;
pfsub MM3,m64[EBP] ;
pfsubr MM3,MM4 ;
pfsubr MM3,m64[EBP] ;
pi2fd MM3,MM4 ;
pi2fd MM3,m64[EBP] ;
pmulhrw MM3,MM4 ;
pmulhrw MM3,m64[EBP] ;
pswapd MM3,MM4 ;
pswapd MM3,m64[EBP] ;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
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 [EAX] ;
lidt [EAX] ;
sgdt [EAX] ;
sidt [EAX] ;
lgdt xx17 ;
lidt xx17 ;
sgdt xx17 ;
sidt xx17 ;
L1:
pop EBX ;
mov p[EBP],EBX ;
}
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 EBX ;
mov p[EBP],EBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
extern (C) {
void foo19() { }
}
void test19()
{ void function() fp;
int x;
int *p;
asm
{
lea EAX, dword ptr [foo19];
mov fp, EAX;
mov x, EAX;
mov p, EAX;
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 EBX ;
mov p[EBP],EBX ;
}
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 EBX ;
mov p[EBP],EBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test22()
{
ubyte *p;
static ubyte[] data =
[
0x0F, 0xC7, 0x4D, 0xF8 // cmpxchg8b
];
int i;
M64 m64;
asm
{
call L1 ;
cmpxchg8b m64 ;
L1:
pop EBX ;
mov p[EBP],EBX ;
}
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, 0xD8, // fistp word ptr -018h[EBP]
0xDB, 0x5D, 0xDC, // fistp dword ptr -014h[EBP]
0xDF, 0x7D, 0xE0, // fistp long64 ptr -010h[EBP]
0xDF, 0x4D, 0xD8, // fisttp short ptr -018h[EBP]
0xDB, 0x4D, 0xDC, // fisttp word ptr -014h[EBP]
0xDD, 0x4D, 0xE0, // fisttp long64 ptr -010h[EBP]
0x0F, 0x01, 0xC8, // monitor
0x0F, 0x01, 0xC9, // mwait
0x0F, 0x01, 0xD0, // xgetbv
0x66, 0x0F, 0xD0, 0xCA, // addsubpd XMM1,XMM2
0x66, 0x0F, 0xD0, 0x4D, 0xE8, // addsubpd XMM1,-010h[EBP]
0xF2, 0x0F, 0xD0, 0xCA, // addsubps XMM1,XMM2
0xF2, 0x0F, 0xD0, 0x4D, 0xE8, // addsubps XMM1,-010h[EBP]
0x66, 0x0F, 0x7C, 0xCA, // haddpd XMM1,XMM2
0x66, 0x0F, 0x7C, 0x4D, 0xE8, // haddpd XMM1,-010h[EBP]
0xF2, 0x0F, 0x7C, 0xCA, // haddps XMM1,XMM2
0xF2, 0x0F, 0x7C, 0x4D, 0xE8, // haddps XMM1,-010h[EBP]
0x66, 0x0F, 0x7D, 0xCA, // hsubpd XMM1,XMM2
0x66, 0x0F, 0x7D, 0x4D, 0xE8, // hsubpd XMM1,-010h[EBP]
0xF2, 0x0F, 0x7D, 0xCA, // hsubps XMM1,XMM2
0xF2, 0x0F, 0x7D, 0x4D, 0xE8, // hsubps XMM1,-010h[EBP]
0xF2, 0x0F, 0xF0, 0x4D, 0xE8, // lddqu XMM1,-010h[EBP]
0xF2, 0x0F, 0x12, 0xCA, // movddup XMM1,XMM2
0xF2, 0x0F, 0x12, 0x4D, 0xE0, // movddup XMM1,-018h[EBP]
0xF3, 0x0F, 0x16, 0xCA, // movshdup XMM1,XMM2
0xF3, 0x0F, 0x16, 0x4D, 0xE8, // movshdup XMM1,-010h[EBP]
0xF3, 0x0F, 0x12, 0xCA, // movsldup XMM1,XMM2
0xF3, 0x0F, 0x12, 0x4D, 0xE8, // movsldup XMM1,-010h[EBP]
0xC4, 0xE3, 0x7D, 0x04, 0xC7, 0xAA, // vpermilps YMM0,YMM7,0AAh ;
];
int i;
asm
{
call L1 ;
fxch ST(1), ST(0) ;
fistp m16[EBP] ;
fistp m32[EBP] ;
fistp m64[EBP] ;
fisttp m16[EBP] ;
fisttp m32[EBP] ;
fisttp m64[EBP] ;
monitor ;
mwait ;
xgetbv ;
addsubpd XMM1,XMM2 ;
addsubpd XMM1,m128[EBP] ;
addsubps XMM1,XMM2 ;
addsubps XMM1,m128[EBP] ;
haddpd XMM1,XMM2 ;
haddpd XMM1,m128[EBP] ;
haddps XMM1,XMM2 ;
haddps XMM1,m128[EBP] ;
hsubpd XMM1,XMM2 ;
hsubpd XMM1,m128[EBP] ;
hsubps XMM1,XMM2 ;
hsubps XMM1,m128[EBP] ;
lddqu XMM1,m128[EBP] ;
movddup XMM1,XMM2 ;
movddup XMM1,m64[EBP] ;
movshdup XMM1,XMM2 ;
movshdup XMM1,m128[EBP] ;
movsldup XMM1,XMM2 ;
movsldup XMM1,m128[EBP] ;
vpermilps YMM0,YMM7,0xAA ;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void test24()
{
version(D_InlineAsm)
{
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 EBX ;
mov p[EBP],EBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
void fn26(ref byte val)
{
asm
{
mov EAX, val;
inc byte ptr [EAX];
}
}
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;
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, [EDX + 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
0x40, // inc EAX
];
int i;
asm
{
call L1 ;
neg EAX;
je L2;
L3:
neg EAX;
jne L3;
L2:
inc EAX;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
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 EAX; }
//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("");
asm { hlt; }
}
//*/
/* But this does: */
//*
for (;;)
{
asm { hlt; }
printf("");
}
//*/
/* The same loop that doesn't compile above
* /does/ compile after previous one:
*/
//*
for (;;)
{
printf("");
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;
uint q;
asm
{
mov ECX, foo35 ;
mov q, ECX ;
lea EDX, foo35 ;
mov p, EDX ;
}
assert(p == &foo35);
assert(q == *cast(uint *)p);
}
/****************************************************/
void func36()
{
}
int test36()
{
void* a = &func36;
uint* b = cast(uint*) a;
uint f = *b;
uint g;
asm{
mov EAX, func36;
mov g, EAX;
}
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,[EAX][ESI]
0x66,0x0F,0x28,0x0C,0x06, // movapd XMM1,[EAX][ESI]
0x66,0x0F,0x28,0x0C,0x46, // movapd XMM1,[EAX*2][ESI]
0x66,0x0F,0x28,0x0C,0x86, // movapd XMM1,[EAX*4][ESI]
0x66,0x0F,0x28,0x0C,0xC6, // movapd XMM1,[EAX*8][ESI]
];
int i;
asm
{
call L1 ;
movapd XMM1, [ESI+EAX];
movapd XMM1, [ESI+1*EAX];
movapd XMM1, [ESI+2*EAX];
movapd XMM1, [ESI+4*EAX];
movapd XMM1, [ESI+8*EAX];
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
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 EBX ;
mov p[EBP],EBX ;
}
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 EBX ;
mov p[EBP],EBX ;
}
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;
}
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 EBX ;
mov p[EBP],EBX ;
}
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
0x48, // 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
0x43, // inc EBX
0xCC, // int 3
0xCD, 0x67, // int 067h
0xCE, // into
0x66, 0xCF, // iret
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
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]
0x8B, 0xFB, // mov EDI,EBX
0xC4, 0x29, // les EBP,[ECX]
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
];
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 ;
L10: iret ;
ja L10 ;
jnbe L10 ;
jae L10 ;
jnb L10 ;
jnc L10 ;
jb L10 ;
jnae L10 ;
jbe L10 ;
jna L10 ;
jc L10 ;
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 ;
lds ESI,[EAX] ;
lea EDI,[EBX] ;
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 ;
L1: ;
pop EBX ;
mov p[EBP],EBX ;
}
for (i = 0; i < data.length; i++)
{
assert(p[i] == data[i]);
}
}
/****************************************************/
class Test51
{
void test(int n)
{ asm {
mov EAX, this;
}
}
}
/****************************************************/
void test52()
{ int x;
ubyte* p;
static ubyte[] data =
[
0xF6, 0xD8, // neg AL
0x66, 0xF7, 0xD8, // neg AX
0xF7, 0xD8, // neg EAX
0xF6, 0xDC, // neg AH
0xF7, 0x5D, 0xe8, // neg dword ptr -8[EBP]
0xF6, 0x1B, // neg byte ptr [EBX]
];
asm
{
call L1 ;
neg AL ;
neg AX ;
neg EAX ;
neg AH ;
// neg b ;
// neg w ;
// neg i ;
// neg l ;
neg x ;
neg byte ptr [EBX] ;
L1: pop EAX ;
mov p[EBP],EAX ;
}
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 =
[
0x8D, 0x04, 0x00, // lea EAX,[EAX][EAX]
0x8D, 0x04, 0x08, // lea EAX,[ECX][EAX]
0x8D, 0x04, 0x10, // lea EAX,[EDX][EAX]
0x8D, 0x04, 0x18, // lea EAX,[EBX][EAX]
0x8D, 0x04, 0x28, // lea EAX,[EBP][EAX]
0x8D, 0x04, 0x30, // lea EAX,[ESI][EAX]
0x8D, 0x04, 0x38, // lea EAX,[EDI][EAX]
0x8D, 0x04, 0x00, // lea EAX,[EAX][EAX]
0x8D, 0x04, 0x01, // lea EAX,[EAX][ECX]
0x8D, 0x04, 0x02, // lea EAX,[EAX][EDX]
0x8D, 0x04, 0x03, // lea EAX,[EAX][EBX]
0x8D, 0x04, 0x04, // lea EAX,[EAX][ESP]
0x8D, 0x44, 0x05, 0x00, // lea EAX,0[EAX][EBP]
0x8D, 0x04, 0x06, // lea EAX,[EAX][ESI]
0x8D, 0x04, 0x07, // lea EAX,[EAX][EDI]
0x8D, 0x44, 0x01, 0x12, // lea EAX,012h[EAX][ECX]
0x8D, 0x84, 0x01, 0x34, 0x12, 0x00, 0x00, // lea EAX,01234h[EAX][ECX]
0x8D, 0x84, 0x01, 0x78, 0x56, 0x34, 0x12, // lea EAX,012345678h[EAX][ECX]
0x8D, 0x44, 0x05, 0x12, // lea EAX,012h[EAX][EBP]
0x8D, 0x84, 0x05, 0x34, 0x12, 0x00, 0x00, // lea EAX,01234h[EAX][EBP]
0x8D, 0x84, 0x05, 0x78, 0x56, 0x34, 0x12, // lea EAX,012345678h[EAX][EBP]
];
asm
{
call L1 ;
// Right
lea EAX, [EAX+EAX];
lea EAX, [EAX+ECX];
lea EAX, [EAX+EDX];
lea EAX, [EAX+EBX];
//lea EAX, [EAX+ESP]; ESP can't be on the right
lea EAX, [EAX+EBP];
lea EAX, [EAX+ESI];
lea EAX, [EAX+EDI];
// Left
lea EAX, [EAX+EAX];
lea EAX, [ECX+EAX];
lea EAX, [EDX+EAX];
lea EAX, [EBX+EAX];
lea EAX, [ESP+EAX];
lea EAX, [EBP+EAX]; // Good gets disp+8 correctly
lea EAX, [ESI+EAX];
lea EAX, [EDI+EAX];
// Disp8/32 checks
lea EAX, [ECX+EAX+0x12];
lea EAX, [ECX+EAX+0x1234];
lea EAX, [ECX+EAX+0x1234_5678];
lea EAX, [EBP+EAX+0x12];
lea EAX, [EBP+EAX+0x1234];
lea EAX, [EBP+EAX+0x1234_5678];
L1: pop EAX ;
mov p[EBP],EAX ;
}
foreach (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, 0x48, // dec AX
0x48, // dec EAX
0xFE, 0xC0, // inc AL
0xFE, 0xC4, // inc AH
0x66, 0x40, // inc AX
0x40, // inc EAX
0x66, 0x0F, 0xA4, 0xC8, 0x04, // shld AX, CX, 4
0x66, 0x0F, 0xA5, 0xC8, // shld AX, CX, CL
0x0F, 0xA4, 0xC8, 0x04, // shld EAX, ECX, 4
0x0F, 0xA5, 0xC8, // shld EAX, ECX, CL
0x66, 0x0F, 0xAC, 0xC8, 0x04, // shrd AX, CX, 4
0x66, 0x0F, 0xAD, 0xC8, // shrd AX, CX, CL
0x0F, 0xAC, 0xC8, 0x04, // shrd EAX, ECX, 4
0x0F, 0xAD, 0xC8, // shrd EAX, ECX, CL
];
asm
{
call L1;
dec AL;
dec AH;
dec AX;
dec EAX;
inc AL;
inc AH;
inc AX;
inc EAX;
shld AX, CX, 4;
shld AX, CX, CL;
shld EAX, ECX, 4;
shld EAX, ECX, CL;
shrd AX, CX, 4;
shrd AX, CX, CL;
shrd EAX, ECX, 4;
shrd EAX, ECX, CL;
L1: pop EAX;
mov p[EBP],EAX;
}
foreach (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 EAX;
mov p[EBP],EAX;
}
foreach (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, 0xD8, 0x03, // palignr MM3, -0x28[EBP], 3
0x66, 0x0F, 0x3A, 0x0F, 0x5D, 0xE0, 0x03, // palignr XMM3, -0x20[EBP], 3
0x0F, 0x38, 0x02, 0xCA, // phaddd MM1, MM2
0x66, 0x0F, 0x38, 0x02, 0xCA, // phaddd XMM1, XMM2
0x0F, 0x38, 0x02, 0x5D, 0xD8, // phaddd MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x02, 0x5D, 0xE0, // phaddd XMM3, -0x20[EBP]
0x0F, 0x38, 0x01, 0xCA, // phaddw MM1, MM2
0x66, 0x0F, 0x38, 0x01, 0xCA, // phaddw XMM1, XMM2
0x0F, 0x38, 0x01, 0x5D, 0xD8, // phaddw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x01, 0x5D, 0xE0, // phaddw XMM3, -0x20[EBP]
0x0F, 0x38, 0x03, 0xCA, // phaddsw MM1, MM2
0x66, 0x0F, 0x38, 0x03, 0xCA, // phaddsw XMM1, XMM2
0x0F, 0x38, 0x03, 0x5D, 0xD8, // phaddsw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x03, 0x5D, 0xE0, // phaddsw XMM3, -0x20[EBP]
0x0F, 0x38, 0x06, 0xCA, // phsubd MM1, MM2
0x66, 0x0F, 0x38, 0x06, 0xCA, // phsubd XMM1, XMM2
0x0F, 0x38, 0x06, 0x5D, 0xD8, // phsubd MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x06, 0x5D, 0xE0, // phsubd XMM3, -0x20[EBP]
0x0F, 0x38, 0x05, 0xCA, // phsubw MM1, MM2
0x66, 0x0F, 0x38, 0x05, 0xCA, // phsubw XMM1, XMM2
0x0F, 0x38, 0x05, 0x5D, 0xD8, // phsubw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x05, 0x5D, 0xE0, // phsubw XMM3, -0x20[EBP]
0x0F, 0x38, 0x07, 0xCA, // phsubsw MM1, MM2
0x66, 0x0F, 0x38, 0x07, 0xCA, // phsubsw XMM1, XMM2
0x0F, 0x38, 0x07, 0x5D, 0xD8, // phsubsw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x07, 0x5D, 0xE0, // phsubsw XMM3, -0x20[EBP]
0x0F, 0x38, 0x04, 0xCA, // pmaddubsw MM1, MM2
0x66, 0x0F, 0x38, 0x04, 0xCA, // pmaddubsw XMM1, XMM2
0x0F, 0x38, 0x04, 0x5D, 0xD8, // pmaddubsw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x04, 0x5D, 0xE0, // pmaddubsw XMM3, -0x20[EBP]
0x0F, 0x38, 0x0B, 0xCA, // pmulhrsw MM1, MM2
0x66, 0x0F, 0x38, 0x0B, 0xCA, // pmulhrsw XMM1, XMM2
0x0F, 0x38, 0x0B, 0x5D, 0xD8, // pmulhrsw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x0B, 0x5D, 0xE0, // pmulhrsw XMM3, -0x20[EBP]
0x0F, 0x38, 0x00, 0xCA, // pshufb MM1, MM2
0x66, 0x0F, 0x38, 0x00, 0xCA, // pshufb XMM1, XMM2
0x0F, 0x38, 0x00, 0x5D, 0xD8, // pshufb MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x00, 0x5D, 0xE0, // pshufb XMM3, -0x20[EBP]
0x0F, 0x38, 0x1C, 0xCA, // pabsb MM1, MM2
0x66, 0x0F, 0x38, 0x1C, 0xCA, // pabsb XMM1, XMM2
0x0F, 0x38, 0x1C, 0x5D, 0xD8, // pabsb MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x1C, 0x5D, 0xE0, // pabsb XMM3, -0x20[EBP]
0x0F, 0x38, 0x1E, 0xCA, // pabsd MM1, MM2
0x66, 0x0F, 0x38, 0x1E, 0xCA, // pabsd XMM1, XMM2
0x0F, 0x38, 0x1E, 0x5D, 0xD8, // pabsd MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x1E, 0x5D, 0xE0, // pabsd XMM3, -0x20[EBP]
0x0F, 0x38, 0x1D, 0xCA, // pabsw MM1, MM2
0x66, 0x0F, 0x38, 0x1D, 0xCA, // pabsw XMM1, XMM2
0x0F, 0x38, 0x1D, 0x5D, 0xD8, // pabsw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x1D, 0x5D, 0xE0, // pabsw XMM3, -0x20[EBP]
0x0F, 0x38, 0x08, 0xCA, // psignb MM1, MM2
0x66, 0x0F, 0x38, 0x08, 0xCA, // psignb XMM1, XMM2
0x0F, 0x38, 0x08, 0x5D, 0xD8, // psignb MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x08, 0x5D, 0xE0, // psignb XMM3, -0x20[EBP]
0x0F, 0x38, 0x0A, 0xCA, // psignd MM1, MM2
0x66, 0x0F, 0x38, 0x0A, 0xCA, // psignd XMM1, XMM2
0x0F, 0x38, 0x0A, 0x5D, 0xD8, // psignd MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x0A, 0x5D, 0xE0, // psignd XMM3, -0x20[EBP]
0x0F, 0x38, 0x09, 0xCA, // psignw MM1, MM2
0x66, 0x0F, 0x38, 0x09, 0xCA, // psignw XMM1, XMM2
0x0F, 0x38, 0x09, 0x5D, 0xD8, // psignw MM3, -0x28[EBP]
0x66, 0x0F, 0x38, 0x09, 0x5D, 0xE0, // psignw XMM3, -0x20[EBP]
];
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 EAX;
mov p[EBP],EAX;
}
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, 0xE0, 3,// blendpd XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x3A, 0x0C, 0xCA, 3,// blendps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0C, 0x5D, 0xE0, 3,// blendps XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x38, 0x15, 0xCA, // blendvpd XMM1,XMM2,XMM0
0x66, 0x0F, 0x38, 0x15, 0x5D, 0xE0, // blendvpd XMM3,XMMWORD PTR [RBP-0x20],XMM0
0x66, 0x0F, 0x38, 0x14, 0xCA, // blendvps XMM1,XMM2,XMM0
0x66, 0x0F, 0x38, 0x14, 0x5D, 0xE0, // blendvps XMM3,XMMWORD PTR [RBP-0x20],XMM0
0x66, 0x0F, 0x3A, 0x41, 0xCA, 3,// dppd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x41, 0x5D, 0xE0, 3,// dppd XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x3A, 0x40, 0xCA, 3,// dpps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x40, 0x5D, 0xE0, 3,// dpps XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x3A, 0x17, 0xD2, 3,// extractps EDX,XMM2,0x3
0x66, 0x0F, 0x3A, 0x17, 0x55, 0xC8, 3,// extractps DWORD PTR [RBP-0x38],XMM2,0x3
0x66, 0x0F, 0x3A, 0x21, 0xCA, 3,// insertps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x21, 0x5D, 0xC8, 3,// insertps XMM3,DWORD PTR [RBP-0x38],0x3
0x66, 0x0F, 0x38, 0x2A, 0x4D, 0xE0, // movntdqa XMM1,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x3A, 0x42, 0xCA, 3,// mpsadbw XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x42, 0x5D, 0xE0, 3,// mpsadbw XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x38, 0x2B, 0xCA, // packusdw XMM1,XMM2
0x66, 0x0F, 0x38, 0x2B, 0x5D, 0xE0, // packusdw XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x10, 0xCA, // pblendvb XMM1,XMM2,XMM0
0x66, 0x0F, 0x38, 0x10, 0x5D, 0xE0, // pblendvb XMM3,XMMWORD PTR [RBP-0x20],XMM0
0x66, 0x0F, 0x3A, 0x0E, 0xCA, 3,// pblendw XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0E, 0x5D, 0xE0, 3,// pblendw XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x38, 0x29, 0xCA, // pcmpeqq XMM1,XMM2
0x66, 0x0F, 0x38, 0x29, 0x5D, 0xE0, // pcmpeqq XMM3,XMMWORD PTR [RBP-0x20]
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, 0x5D, 0xC4, 3,// pextrb BYTE PTR [RBP-0x3C],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, 0xC8, 3,// pextrd DWORD PTR [RBP-0x38],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, 0x3A, 0x15, 0x5D, 0xC6, 3,// pextrw WORD PTR [RBP-0x3A],XMM3,0x3
0x66, 0x0F, 0x38, 0x41, 0xCA, // phminposuw XMM1,XMM2
0x66, 0x0F, 0x38, 0x41, 0x5D, 0xE0, // phminposuw XMM3,XMMWORD PTR [RBP-0x20]
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, 0xC4, 3,// pinsrb XMM3,BYTE PTR [RBP-0x3C],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, 0xC8, 3,// pinsrd XMM3,DWORD PTR [RBP-0x38],0x3
0x66, 0x0F, 0x38, 0x3C, 0xCA, // pmaxsb XMM1,XMM2
0x66, 0x0F, 0x38, 0x3C, 0x5D, 0xE0, // pmaxsb XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x3D, 0xCA, // pmaxsd XMM1,XMM2
0x66, 0x0F, 0x38, 0x3D, 0x5D, 0xE0, // pmaxsd XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x3F, 0xCA, // pmaxud XMM1,XMM2
0x66, 0x0F, 0x38, 0x3F, 0x5D, 0xE0, // pmaxud XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x3E, 0xCA, // pmaxuw XMM1,XMM2
0x66, 0x0F, 0x38, 0x3E, 0x5D, 0xE0, // pmaxuw XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x38, 0xCA, // pminsb XMM1,XMM2
0x66, 0x0F, 0x38, 0x38, 0x5D, 0xE0, // pminsb XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x39, 0xCA, // pminsd XMM1,XMM2
0x66, 0x0F, 0x38, 0x39, 0x5D, 0xE0, // pminsd XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x3B, 0xCA, // pminud XMM1,XMM2
0x66, 0x0F, 0x38, 0x3B, 0x5D, 0xE0, // pminud XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x3A, 0xCA, // pminuw XMM1,XMM2
0x66, 0x0F, 0x38, 0x3A, 0x5D, 0xE0, // pminuw XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x20, 0xCA, // pmovsxbw XMM1,XMM2
0x66, 0x0F, 0x38, 0x20, 0x5D, 0xD0, // pmovsxbw XMM3,QWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x21, 0xCA, // pmovsxbd XMM1,XMM2
0x66, 0x0F, 0x38, 0x21, 0x5D, 0xC8, // pmovsxbd XMM3,DWORD PTR [RBP-0x38]
0x66, 0x0F, 0x38, 0x22, 0xCA, // pmovsxbq XMM1,XMM2
0x66, 0x0F, 0x38, 0x22, 0x5D, 0xC6, // pmovsxbq XMM3,WORD PTR [RBP-0x3A]
0x66, 0x0F, 0x38, 0x23, 0xCA, // pmovsxwd XMM1,XMM2
0x66, 0x0F, 0x38, 0x23, 0x5D, 0xD0, // pmovsxwd XMM3,QWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x24, 0xCA, // pmovsxwq XMM1,XMM2
0x66, 0x0F, 0x38, 0x24, 0x5D, 0xC8, // pmovsxwq XMM3,DWORD PTR [RBP-0x38]
0x66, 0x0F, 0x38, 0x25, 0xCA, // pmovsxdq XMM1,XMM2
0x66, 0x0F, 0x38, 0x25, 0x5D, 0xD0, // pmovsxdq XMM3,QWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x30, 0xCA, // pmovzxbw XMM1,XMM2
0x66, 0x0F, 0x38, 0x30, 0x5D, 0xD0, // pmovzxbw XMM3,QWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x31, 0xCA, // pmovzxbd XMM1,XMM2
0x66, 0x0F, 0x38, 0x31, 0x5D, 0xC8, // pmovzxbd XMM3,DWORD PTR [RBP-0x38]
0x66, 0x0F, 0x38, 0x32, 0xCA, // pmovzxbq XMM1,XMM2
0x66, 0x0F, 0x38, 0x32, 0x5D, 0xC6, // pmovzxbq XMM3,WORD PTR [RBP-0x3A]
0x66, 0x0F, 0x38, 0x33, 0xCA, // pmovzxwd XMM1,XMM2
0x66, 0x0F, 0x38, 0x33, 0x5D, 0xD0, // pmovzxwd XMM3,QWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x34, 0xCA, // pmovzxwq XMM1,XMM2
0x66, 0x0F, 0x38, 0x34, 0x5D, 0xC8, // pmovzxwq XMM3,DWORD PTR [RBP-0x38]
0x66, 0x0F, 0x38, 0x35, 0xCA, // pmovzxdq XMM1,XMM2
0x66, 0x0F, 0x38, 0x35, 0x5D, 0xD0, // pmovzxdq XMM3,QWORD PTR [RBP-0x30]
0x66, 0x0F, 0x38, 0x28, 0xCA, // pmuldq XMM1,XMM2
0x66, 0x0F, 0x38, 0x28, 0x5D, 0xE0, // pmuldq XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x40, 0xCA, // pmulld XMM1,XMM2
0x66, 0x0F, 0x38, 0x40, 0x5D, 0xE0, // pmulld XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x38, 0x17, 0xCA, // ptest XMM1,XMM2
0x66, 0x0F, 0x38, 0x17, 0x5D, 0xE0, // ptest XMM3,XMMWORD PTR [RBP-0x20]
0x66, 0x0F, 0x3A, 0x09, 0xCA, 3,// roundpd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x09, 0x5D, 0xE0, 3,// roundpd XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x3A, 0x08, 0xCA, 3,// roundps XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x08, 0x5D, 0xE0, 3,// roundps XMM3,XMMWORD PTR [RBP-0x20],0x3
0x66, 0x0F, 0x3A, 0x0B, 0xCA, 3,// roundsd XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0B, 0x5D, 0xD0, 3,// roundsd XMM3,QWORD PTR [RBP-0x30],0x3
0x66, 0x0F, 0x3A, 0x0A, 0xCA, 3,// roundss XMM1,XMM2,0x3
0x66, 0x0F, 0x3A, 0x0A, 0x4D, 0xC8, 3,// roundss xmm1,dword ptr [rbp-0x38],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 m8, XMM3, 3;
pextrd EAX, XMM2, 3;
pextrd EBX, XMM2, 3;
pextrd ECX, XMM2, 3;
pextrd EDX, XMM2, 3;
pextrd m32, XMM3, 3;
pextrw EAX, XMM2, 3;
pextrw EBX, XMM2, 3;
pextrw ECX, XMM2, 3;
pextrw EDX, 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;
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 EAX;
mov p[EBP],EAX;
}
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, 0x0F, 0x38, 0xF0, 0x55, 0xC4, // crc32 EDX, byte ptr [RBP-0x3C]
0x66, 0xF2, 0x0F, 0x38, 0xF1, 0x55, 0xC6, // crc32 EDX, word ptr [RBP-0x3A]
0xF2, 0x0F, 0x38, 0xF1, 0x55, 0xC8, // crc32 EDX,dword ptr [RBP-0x38]
0x66, 0x0F, 0x3A, 0x61, 0xCA, 2, // pcmpestri XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x61, 0x5D, 0xE0, 2, // pcmpestri XMM3,xmmword ptr [RBP-0x20], 2
0x66, 0x0F, 0x3A, 0x60, 0xCA, 2, // pcmpestrm XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x60, 0x5D, 0xE0, 2, // pcmpestrm XMM3,xmmword ptr [RBP-0x20], 2
0x66, 0x0F, 0x3A, 0x63, 0xCA, 2, // pcmpistri XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x63, 0x5D, 0xE0, 2, // pcmpistri XMM3,xmmword ptr [RBP-0x20], 2
0x66, 0x0F, 0x3A, 0x62, 0xCA, 2, // pcmpistrm XMM1,XMM2, 2
0x66, 0x0F, 0x3A, 0x62, 0x5D, 0xE0, 2, // pcmpistrm XMM3,xmmword ptr [RBP-0x20], 2
0x66, 0x0F, 0x38, 0x37, 0xCA, // pcmpgtq XMM1,XMM2
0x66, 0x0F, 0x38, 0x37, 0x5D, 0xE0, // pcmpgtq XMM3,xmmword ptr [RBP-0x20]
0x66, 0xF3, 0x0F, 0xB8, 0xC1, // popcnt AX, CX
0xF3, 0x0F, 0xB8, 0xC1, // popcnt EAX, ECX
0x66, 0xF3, 0x0F, 0xB8, 0x55, 0xC6, // popcnt DX, word ptr [RBP-0x3A]
0xF3, 0x0F, 0xB8, 0x55, 0xC8, // popcnt EDX,dword ptr [RBP-0x38]
];
asm
{
call L1;
crc32 EAX, CL;
crc32 EAX, CX;
crc32 EAX, ECX;
crc32 EDX, m8;
crc32 EDX, m16;
crc32 EDX, m32;
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 DX, m16;
popcnt EDX, m32;
L1: pop EAX;
mov p[EBP],EAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/* ======================= SHA ========================== */
void test60()
{
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, [EAX], 1;
sha1nexte XMM2, XMM1;
sha1nexte XMM2, [EAX];
sha1msg1 XMM2, XMM1;
sha1msg1 XMM2, [EAX];
sha1msg2 XMM2, XMM1;
sha1msg2 XMM2, [EAX];
sha256rnds2 XMM2, XMM1;
sha256rnds2 XMM2, [EAX];
sha256msg1 XMM2, XMM1;
sha256msg1 XMM2, [EAX];
sha256msg2 XMM2, XMM1;
sha256msg2 XMM2, [EAX];
L1: pop EAX;
mov p[EBP],EAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
void test9866()
{
ubyte* p;
static ubyte[] data =
[
0x66, 0x0f, 0xbe, 0xc0, // movsx AX, AL;
0x66, 0x0f, 0xbe, 0x00, // movsx AX, byte ptr [EAX];
0x0f, 0xbe, 0xc0, // movsx EAX, AL;
0x0f, 0xbe, 0x00, // movsx EAX, byte ptr [EAX];
0x66, 0x0f, 0xbf, 0xc0, // movsx AX, AX;
0x66, 0x0f, 0xbf, 0x00, // movsx AX, word ptr [EAX];
0x0f, 0xbf, 0xc0, // movsx EAX, AX;
0x0f, 0xbf, 0x00, // movsx EAX, word ptr [EAX];
0x66, 0x0f, 0xb6, 0xc0, // movzx AX, AL;
0x66, 0x0f, 0xb6, 0x00, // movzx AX, byte ptr [EAX];
0x0f, 0xb6, 0xc0, // movzx EAX, AL;
0x0f, 0xb6, 0x00, // movzx EAX, byte ptr [EAX];
0x66, 0x0f, 0xb7, 0xc0, // movzx AX, AX;
0x66, 0x0f, 0xb7, 0x00, // movzx AX, word ptr [EAX];
0x0f, 0xb7, 0xc0, // movzx EAX, AX;
0x0f, 0xb7, 0x00, // movzx EAX, word ptr [EAX];
0xEB, 0x00, //jmp $;
0xE9, 0xCD, 0xAB, 0x00, 0x00, // jmp $+0xABCD;
0xE8, 0x05, 0x00, 0x00, 0x00, // call $+5;
];
asm
{
call L1;
movsx AX, AL;
movsx AX, byte ptr [EAX];
movsx EAX, AL;
movsx EAX, byte ptr [EAX];
movsx AX, AX;
movsx AX, word ptr [EAX];
movsx EAX, AX;
movsx EAX, word ptr [EAX];
movzx AX, AL;
movzx AX, byte ptr [EAX];
movzx EAX, AL;
movzx EAX, byte ptr [EAX];
movzx AX, AX;
movzx AX, word ptr [EAX];
movzx EAX, AX;
movzx EAX, word ptr [EAX];
jmp $;
jmp $+0xABCD;
call $+5;
L1: pop EAX;
mov p[EBP],EAX;
}
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 EAX
}
/****************************************************/
void test5012()
{
void bar() {}
asm {
mov EAX, bar;
}
}
/****************************************************/
void test17027()
{
ubyte* p;
static ubyte[] data =
[
0xF3, 0x0F, 0xBC, 0x00,
0xF3, 0x0F, 0xBC, 0x40, 0x08,
0xF3, 0x0F, 0xBC, 0xC0,
0xF3, 0x0F, 0xBD, 0x00,
0xF3, 0x0F, 0xBD, 0x40, 0x08,
0xF3, 0x0F, 0xBD, 0xC0,
];
asm
{
call L1;
tzcnt EAX, [EAX];
tzcnt EAX, [EAX+8];
tzcnt EAX, EAX;
lzcnt EAX, [EAX];
lzcnt EAX, [EAX+8];
lzcnt EAX, EAX;
L1: pop EAX;
mov p[EBP],EAX;
}
foreach (ref i, b; data)
{
//printf("data[%d] = 0x%02x, should be 0x%02x\n", i, p[i], b);
assert(p[i] == b);
}
}
/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=16400
extern(C) void f16400(int, ...)
{
asm {naked; ret;}
}
void test16400()
{
assert(*(cast(ubyte*) &f16400) == 0xc3); // fails
f16400(0); // corrupts the stack
}
/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=16963
void bar16963() { assert(0); }
void test16963()
{
asm
{
jmp bar16963; // forward reference to label
hlt;
bar16963:
ret;
}
}
/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=5922
void test5922()
{
immutable size_t x = 10;
size_t y;
asm
{
mov EDI, x;
mov y, EDI;
}
assert(y == 10);
}
/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=21914
extern (C++) int insidx(int a, int b)
{
asm
{
naked ;
mov ECX,a-4+[ESP] ;
mov EAX,b-4+[ESP] ;
shl EAX,CL ;
ret ;
}
}
void test21914()
{
int x = insidx(5, 7);
assert(x == (7 << 5));
}
/****************************************************/
int main()
{
printf("Testing iasm.d\n");
test1();
test2();
test3();
test4();
version (OSX)
{
}
else version (linux)
{
// stack alignment throws the tests off
}
else
{
test5();
test6();
test7();
test8();
test9();
test10();
test11();
test12();
test13();
test14();
test15();
//test16(); // add this one from \cbx\test\iasm.c ?
test17();
test18();
test19();
//test20();
test21();
test22();
test23();
test24();
test25();
test26();
test27();
test28();
test29();
test30();
test31();
test32();
test33();
test34();
test35();
test36();
test37();
test38();
test39();
test40();
test41();
test42();
test43();
test44();
test45();
test46();
test47();
test48();
test49();
test50();
//Test51
test52();
test53();
test54();
test55();
test56();
test57();
test58();
test59();
test60();
test9866();
test17027();
test16400();
test16963();
test5922();
test21914();
}
printf("Success\n");
return 0;
}
}
else
{
int main() { return 0; }
}
Reference in a new issue View git blame Copy permalink