yuzu/xbyak
1
0
Fork 0
mirror of https://github.com/herumi/xbyak synced 2024-11-21 16:09:11 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions
xbyak/test/apx.cpp
MITSUNARI Shigeo a7b02ac80d RAO_INT supports APX
2024-01-03 17:10:32 +09:00

1964 lines
68 KiB
C++
Raw Blame History

#include <stdio.h>
#include <string.h>
#include <xbyak/xbyak.h>
#include <xbyak/xbyak_util.h>
#include <cybozu/test.hpp>
#ifndef XBYAK64
#error "only 64-bit mode"
#endif
using namespace Xbyak;
CYBOZU_TEST_AUTO(reg_rm)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r17, ptr [rax]);
adc(ptr [r18], rdx);
adc(r30, rcx);
add(r17, ptr [rax]);
add(ptr [r18], rdx);
add(r30, rcx);
and_(r17, ptr [rax]);
and_(ptr [r18], rdx);
and_(r30, rcx);
cmp(r17, ptr [rax]);
cmp(ptr [r18], rdx);
cmp(r30, rcx);
or_(r17, ptr [rax]);
or_(ptr [r18], rdx);
or_(r30, rcx);
sbb(r17, ptr [rax]);
sbb(ptr [r18], rdx);
sbb(r30, rcx);
sub(r17, ptr [rax]);
sub(ptr [r18], rdx);
sub(r30, rcx);
xor_(r17, ptr [rax]);
xor_(ptr [r18], rdx);
xor_(r30, rcx);
add(r30, ptr [rbx+rcx*4]);
add(rax, ptr [r30+rcx*4]);
add(rax, ptr [rbx+r30*4]);
}
} c;
const uint8_t tbl[] = {
0xd5, 0x48, 0x13, 0x08, 0xd5, 0x18, 0x11, 0x12, 0xd5, 0x19, 0x11, 0xce, 0xd5, 0x48, 0x03, 0x08,
0xd5, 0x18, 0x01, 0x12, 0xd5, 0x19, 0x01, 0xce, 0xd5, 0x48, 0x23, 0x08, 0xd5, 0x18, 0x21, 0x12,
0xd5, 0x19, 0x21, 0xce, 0xd5, 0x48, 0x3b, 0x08, 0xd5, 0x18, 0x39, 0x12, 0xd5, 0x19, 0x39, 0xce,
0xd5, 0x48, 0x0b, 0x08, 0xd5, 0x18, 0x09, 0x12, 0xd5, 0x19, 0x09, 0xce, 0xd5, 0x48, 0x1b, 0x08,
0xd5, 0x18, 0x19, 0x12, 0xd5, 0x19, 0x19, 0xce, 0xd5, 0x48, 0x2b, 0x08, 0xd5, 0x18, 0x29, 0x12,
0xd5, 0x19, 0x29, 0xce, 0xd5, 0x48, 0x33, 0x08, 0xd5, 0x18, 0x31, 0x12, 0xd5, 0x19, 0x31, 0xce,
0xd5, 0x4c, 0x03, 0x34, 0x8b, 0xd5, 0x19, 0x03, 0x04, 0x8e, 0xd5, 0x2a, 0x03, 0x04, 0xb3,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(reg64)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r30, rax); adc(r30, rcx); adc(r30, rdx); adc(r30, rbx); adc(r30, rsp); adc(r30, rbp); adc(r30, rsi); adc(r30, rdi);
adc(r30, r8); adc(r30, r9); adc(r30, r10); adc(r30, r11); adc(r30, r12); adc(r30, r13); adc(r30, r14); adc(r30, r15);
adc(r30, r16); adc(r30, r17); adc(r30, r18); adc(r30, r19); adc(r30, r20); adc(r30, r21); adc(r30, r22); adc(r30, r23);
adc(r30, r24); adc(r30, r25); adc(r30, r26); adc(r30, r27); adc(r30, r28); adc(r30, r29); adc(r30, r30); adc(r30, r31);
adc(rax, r30); adc(rcx, r30); adc(rdx, r30); adc(rbx, r30); adc(rsp, r30); adc(rbp, r30); adc(rsi, r30); adc(rdi, r30);
adc(r8, r30); adc(r9, r30); adc(r10, r30); adc(r11, r30); adc(r12, r30); adc(r13, r30); adc(r14, r30); adc(r15, r30);
adc(r16, r30); adc(r17, r30); adc(r18, r30); adc(r19, r30); adc(r20, r30); adc(r21, r30); adc(r22, r30); adc(r23, r30);
adc(r24, r30); adc(r25, r30); adc(r26, r30); adc(r27, r30); adc(r28, r30); adc(r29, r30); adc(r30, r30); adc(r31, r30);
}
} c;
const uint8_t tbl[] = {
0xd5, 0x19, 0x11, 0xc6, 0xd5, 0x19, 0x11, 0xce, 0xd5, 0x19, 0x11, 0xd6, 0xd5, 0x19, 0x11, 0xde,
0xd5, 0x19, 0x11, 0xe6, 0xd5, 0x19, 0x11, 0xee, 0xd5, 0x19, 0x11, 0xf6, 0xd5, 0x19, 0x11, 0xfe,
0xd5, 0x1d, 0x11, 0xc6, 0xd5, 0x1d, 0x11, 0xce, 0xd5, 0x1d, 0x11, 0xd6, 0xd5, 0x1d, 0x11, 0xde,
0xd5, 0x1d, 0x11, 0xe6, 0xd5, 0x1d, 0x11, 0xee, 0xd5, 0x1d, 0x11, 0xf6, 0xd5, 0x1d, 0x11, 0xfe,
0xd5, 0x59, 0x11, 0xc6, 0xd5, 0x59, 0x11, 0xce, 0xd5, 0x59, 0x11, 0xd6, 0xd5, 0x59, 0x11, 0xde,
0xd5, 0x59, 0x11, 0xe6, 0xd5, 0x59, 0x11, 0xee, 0xd5, 0x59, 0x11, 0xf6, 0xd5, 0x59, 0x11, 0xfe,
0xd5, 0x5d, 0x11, 0xc6, 0xd5, 0x5d, 0x11, 0xce, 0xd5, 0x5d, 0x11, 0xd6, 0xd5, 0x5d, 0x11, 0xde,
0xd5, 0x5d, 0x11, 0xe6, 0xd5, 0x5d, 0x11, 0xee, 0xd5, 0x5d, 0x11, 0xf6, 0xd5, 0x5d, 0x11, 0xfe,
0xd5, 0x4c, 0x11, 0xf0, 0xd5, 0x4c, 0x11, 0xf1, 0xd5, 0x4c, 0x11, 0xf2, 0xd5, 0x4c, 0x11, 0xf3,
0xd5, 0x4c, 0x11, 0xf4, 0xd5, 0x4c, 0x11, 0xf5, 0xd5, 0x4c, 0x11, 0xf6, 0xd5, 0x4c, 0x11, 0xf7,
0xd5, 0x4d, 0x11, 0xf0, 0xd5, 0x4d, 0x11, 0xf1, 0xd5, 0x4d, 0x11, 0xf2, 0xd5, 0x4d, 0x11, 0xf3,
0xd5, 0x4d, 0x11, 0xf4, 0xd5, 0x4d, 0x11, 0xf5, 0xd5, 0x4d, 0x11, 0xf6, 0xd5, 0x4d, 0x11, 0xf7,
0xd5, 0x5c, 0x11, 0xf0, 0xd5, 0x5c, 0x11, 0xf1, 0xd5, 0x5c, 0x11, 0xf2, 0xd5, 0x5c, 0x11, 0xf3,
0xd5, 0x5c, 0x11, 0xf4, 0xd5, 0x5c, 0x11, 0xf5, 0xd5, 0x5c, 0x11, 0xf6, 0xd5, 0x5c, 0x11, 0xf7,
0xd5, 0x5d, 0x11, 0xf0, 0xd5, 0x5d, 0x11, 0xf1, 0xd5, 0x5d, 0x11, 0xf2, 0xd5, 0x5d, 0x11, 0xf3,
0xd5, 0x5d, 0x11, 0xf4, 0xd5, 0x5d, 0x11, 0xf5, 0xd5, 0x5d, 0x11, 0xf6, 0xd5, 0x5d, 0x11, 0xf7,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(reg32)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r30d, eax); adc(r30d, ecx); adc(r30d, edx); adc(r30d, ebx); adc(r30d, esp); adc(r30d, ebp); adc(r30d, esi); adc(r30d, edi);
adc(r30d, r8d); adc(r30d, r9d); adc(r30d, r10d); adc(r30d, r11d); adc(r30d, r12d); adc(r30d, r13d); adc(r30d, r14d); adc(r30d, r15d);
adc(r30d, r16d); adc(r30d, r17d); adc(r30d, r18d); adc(r30d, r19d); adc(r30d, r20d); adc(r30d, r21d); adc(r30d, r22d); adc(r30d, r23d);
adc(r30d, r24d); adc(r30d, r25d); adc(r30d, r26d); adc(r30d, r27d); adc(r30d, r28d); adc(r30d, r29d); adc(r30d, r30d); adc(r30d, r31d);
adc(eax, r29d); adc(ecx, r29d); adc(edx, r29d); adc(ebx, r29d); adc(esp, r29d); adc(ebp, r29d); adc(esi, r29d); adc(edi, r29d);
adc(r8d, r29d); adc(r9d, r29d); adc(r10d, r29d); adc(r11d, r29d); adc(r12d, r29d); adc(r13d, r29d); adc(r14d, r29d); adc(r15d, r29d);
adc(r16d, r29d); adc(r17d, r29d); adc(r18d, r29d); adc(r19d, r29d); adc(r20d, r29d); adc(r21d, r29d); adc(r22d, r29d); adc(r23d, r29d);
adc(r24d, r29d); adc(r25d, r29d); adc(r26d, r29d); adc(r27d, r29d); adc(r28d, r29d); adc(r29d, r29d); adc(r30d, r29d); adc(r31d, r29d);
}
} c;
const uint8_t tbl[] = {
0xd5, 0x11, 0x11, 0xc6, 0xd5, 0x11, 0x11, 0xce, 0xd5, 0x11, 0x11, 0xd6, 0xd5, 0x11, 0x11, 0xde,
0xd5, 0x11, 0x11, 0xe6, 0xd5, 0x11, 0x11, 0xee, 0xd5, 0x11, 0x11, 0xf6, 0xd5, 0x11, 0x11, 0xfe,
0xd5, 0x15, 0x11, 0xc6, 0xd5, 0x15, 0x11, 0xce, 0xd5, 0x15, 0x11, 0xd6, 0xd5, 0x15, 0x11, 0xde,
0xd5, 0x15, 0x11, 0xe6, 0xd5, 0x15, 0x11, 0xee, 0xd5, 0x15, 0x11, 0xf6, 0xd5, 0x15, 0x11, 0xfe,
0xd5, 0x51, 0x11, 0xc6, 0xd5, 0x51, 0x11, 0xce, 0xd5, 0x51, 0x11, 0xd6, 0xd5, 0x51, 0x11, 0xde,
0xd5, 0x51, 0x11, 0xe6, 0xd5, 0x51, 0x11, 0xee, 0xd5, 0x51, 0x11, 0xf6, 0xd5, 0x51, 0x11, 0xfe,
0xd5, 0x55, 0x11, 0xc6, 0xd5, 0x55, 0x11, 0xce, 0xd5, 0x55, 0x11, 0xd6, 0xd5, 0x55, 0x11, 0xde,
0xd5, 0x55, 0x11, 0xe6, 0xd5, 0x55, 0x11, 0xee, 0xd5, 0x55, 0x11, 0xf6, 0xd5, 0x55, 0x11, 0xfe,
0xd5, 0x44, 0x11, 0xe8, 0xd5, 0x44, 0x11, 0xe9, 0xd5, 0x44, 0x11, 0xea, 0xd5, 0x44, 0x11, 0xeb,
0xd5, 0x44, 0x11, 0xec, 0xd5, 0x44, 0x11, 0xed, 0xd5, 0x44, 0x11, 0xee, 0xd5, 0x44, 0x11, 0xef,
0xd5, 0x45, 0x11, 0xe8, 0xd5, 0x45, 0x11, 0xe9, 0xd5, 0x45, 0x11, 0xea, 0xd5, 0x45, 0x11, 0xeb,
0xd5, 0x45, 0x11, 0xec, 0xd5, 0x45, 0x11, 0xed, 0xd5, 0x45, 0x11, 0xee, 0xd5, 0x45, 0x11, 0xef,
0xd5, 0x54, 0x11, 0xe8, 0xd5, 0x54, 0x11, 0xe9, 0xd5, 0x54, 0x11, 0xea, 0xd5, 0x54, 0x11, 0xeb,
0xd5, 0x54, 0x11, 0xec, 0xd5, 0x54, 0x11, 0xed, 0xd5, 0x54, 0x11, 0xee, 0xd5, 0x54, 0x11, 0xef,
0xd5, 0x55, 0x11, 0xe8, 0xd5, 0x55, 0x11, 0xe9, 0xd5, 0x55, 0x11, 0xea, 0xd5, 0x55, 0x11, 0xeb,
0xd5, 0x55, 0x11, 0xec, 0xd5, 0x55, 0x11, 0xed, 0xd5, 0x55, 0x11, 0xee, 0xd5, 0x55, 0x11, 0xef,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(reg16)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r30w, ax); adc(r30w, cx); adc(r30w, dx); adc(r30w, bx); adc(r30w, sp); adc(r30w, bp); adc(r30w, si); adc(r30w, di);
adc(r30w, r8w); adc(r30w, r9w); adc(r30w, r10w); adc(r30w, r11w); adc(r30w, r12w); adc(r30w, r13w); adc(r30w, r14w); adc(r30w, r15w);
adc(r30w, r16w); adc(r30w, r17w); adc(r30w, r18w); adc(r30w, r19w); adc(r30w, r20w); adc(r30w, r21w); adc(r30w, r22w); adc(r30w, r23w);
adc(r30w, r24w); adc(r30w, r25w); adc(r30w, r26w); adc(r30w, r27w); adc(r30w, r28w); adc(r30w, r29w); adc(r30w, r30w); adc(r30w, r31w);
adc(ax, r29w); adc(cx, r29w); adc(dx, r29w); adc(bx, r29w); adc(sp, r29w); adc(bp, r29w); adc(si, r29w); adc(di, r29w);
adc(r8w, r29w); adc(r9w, r29w); adc(r10w, r29w); adc(r11w, r29w); adc(r12w, r29w); adc(r13w, r29w); adc(r14w, r29w); adc(r15w, r29w);
adc(r16w, r29w); adc(r17w, r29w); adc(r18w, r29w); adc(r19w, r29w); adc(r20w, r29w); adc(r21w, r29w); adc(r22w, r29w); adc(r23w, r29w);
adc(r24w, r29w); adc(r25w, r29w); adc(r26w, r29w); adc(r27w, r29w); adc(r28w, r29w); adc(r29w, r29w); adc(r30w, r29w); adc(r31w, r29w);
}
} c;
const uint8_t tbl[] = {
0x66, 0xd5, 0x11, 0x11, 0xc6, 0x66, 0xd5, 0x11, 0x11, 0xce, 0x66, 0xd5, 0x11, 0x11, 0xd6, 0x66,
0xd5, 0x11, 0x11, 0xde, 0x66, 0xd5, 0x11, 0x11, 0xe6, 0x66, 0xd5, 0x11, 0x11, 0xee, 0x66, 0xd5,
0x11, 0x11, 0xf6, 0x66, 0xd5, 0x11, 0x11, 0xfe, 0x66, 0xd5, 0x15, 0x11, 0xc6, 0x66, 0xd5, 0x15,
0x11, 0xce, 0x66, 0xd5, 0x15, 0x11, 0xd6, 0x66, 0xd5, 0x15, 0x11, 0xde, 0x66, 0xd5, 0x15, 0x11,
0xe6, 0x66, 0xd5, 0x15, 0x11, 0xee, 0x66, 0xd5, 0x15, 0x11, 0xf6, 0x66, 0xd5, 0x15, 0x11, 0xfe,
0x66, 0xd5, 0x51, 0x11, 0xc6, 0x66, 0xd5, 0x51, 0x11, 0xce, 0x66, 0xd5, 0x51, 0x11, 0xd6, 0x66,
0xd5, 0x51, 0x11, 0xde, 0x66, 0xd5, 0x51, 0x11, 0xe6, 0x66, 0xd5, 0x51, 0x11, 0xee, 0x66, 0xd5,
0x51, 0x11, 0xf6, 0x66, 0xd5, 0x51, 0x11, 0xfe, 0x66, 0xd5, 0x55, 0x11, 0xc6, 0x66, 0xd5, 0x55,
0x11, 0xce, 0x66, 0xd5, 0x55, 0x11, 0xd6, 0x66, 0xd5, 0x55, 0x11, 0xde, 0x66, 0xd5, 0x55, 0x11,
0xe6, 0x66, 0xd5, 0x55, 0x11, 0xee, 0x66, 0xd5, 0x55, 0x11, 0xf6, 0x66, 0xd5, 0x55, 0x11, 0xfe,
0x66, 0xd5, 0x44, 0x11, 0xe8, 0x66, 0xd5, 0x44, 0x11, 0xe9, 0x66, 0xd5, 0x44, 0x11, 0xea, 0x66,
0xd5, 0x44, 0x11, 0xeb, 0x66, 0xd5, 0x44, 0x11, 0xec, 0x66, 0xd5, 0x44, 0x11, 0xed, 0x66, 0xd5,
0x44, 0x11, 0xee, 0x66, 0xd5, 0x44, 0x11, 0xef, 0x66, 0xd5, 0x45, 0x11, 0xe8, 0x66, 0xd5, 0x45,
0x11, 0xe9, 0x66, 0xd5, 0x45, 0x11, 0xea, 0x66, 0xd5, 0x45, 0x11, 0xeb, 0x66, 0xd5, 0x45, 0x11,
0xec, 0x66, 0xd5, 0x45, 0x11, 0xed, 0x66, 0xd5, 0x45, 0x11, 0xee, 0x66, 0xd5, 0x45, 0x11, 0xef,
0x66, 0xd5, 0x54, 0x11, 0xe8, 0x66, 0xd5, 0x54, 0x11, 0xe9, 0x66, 0xd5, 0x54, 0x11, 0xea, 0x66,
0xd5, 0x54, 0x11, 0xeb, 0x66, 0xd5, 0x54, 0x11, 0xec, 0x66, 0xd5, 0x54, 0x11, 0xed, 0x66, 0xd5,
0x54, 0x11, 0xee, 0x66, 0xd5, 0x54, 0x11, 0xef, 0x66, 0xd5, 0x55, 0x11, 0xe8, 0x66, 0xd5, 0x55,
0x11, 0xe9, 0x66, 0xd5, 0x55, 0x11, 0xea, 0x66, 0xd5, 0x55, 0x11, 0xeb, 0x66, 0xd5, 0x55, 0x11,
0xec, 0x66, 0xd5, 0x55, 0x11, 0xed, 0x66, 0xd5, 0x55, 0x11, 0xee, 0x66, 0xd5, 0x55, 0x11, 0xef,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(reg8)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r17b, al); adc(r17b, cl); adc(r17b, dl); adc(r17b, bl); adc(r17b, spl); adc(r17b, bpl); adc(r17b, sil); adc(r17b, dil);
adc(r17b, r8b); adc(r17b, r9b); adc(r17b, r10b); adc(r17b, r11b); adc(r17b, r12b); adc(r17b, r13b); adc(r17b, r14b); adc(r17b, r15b);
adc(r17b, r16b); adc(r17b, r17b); adc(r17b, r18b); adc(r17b, r19b); adc(r17b, r20b); adc(r17b, r21b); adc(r17b, r22b); adc(r17b, r23b);
adc(r17b, r24b); adc(r17b, r25b); adc(r17b, r26b); adc(r17b, r27b); adc(r17b, r28b); adc(r17b, r29b); adc(r17b, r30b); adc(r17b, r31b);
adc(al, r20b); adc(cl, r20b); adc(dl, r20b); adc(bl, r20b); adc(spl, r20b); adc(bpl, r20b); adc(sil, r20b); adc(dil, r20b);
adc(r8b, r20b); adc(r9b, r20b); adc(r10b, r20b); adc(r11b, r20b); adc(r12b, r20b); adc(r13b, r20b); adc(r14b, r20b); adc(r15b, r20b);
adc(r16b, r20b); adc(r17b, r20b); adc(r18b, r20b); adc(r19b, r20b); adc(r20b, r20b); adc(r21b, r20b); adc(r22b, r20b); adc(r23b, r20b);
adc(r24b, r20b); adc(r25b, r20b); adc(r26b, r20b); adc(r27b, r20b); adc(r28b, r20b); adc(r29b, r20b); adc(r30b, r20b); adc(r31b, r20b);
}
} c;
const uint8_t tbl[] = {
0xd5, 0x10, 0x10, 0xc1, 0xd5, 0x10, 0x10, 0xc9, 0xd5, 0x10, 0x10, 0xd1, 0xd5, 0x10, 0x10, 0xd9,
0xd5, 0x10, 0x10, 0xe1, 0xd5, 0x10, 0x10, 0xe9, 0xd5, 0x10, 0x10, 0xf1, 0xd5, 0x10, 0x10, 0xf9,
0xd5, 0x14, 0x10, 0xc1, 0xd5, 0x14, 0x10, 0xc9, 0xd5, 0x14, 0x10, 0xd1, 0xd5, 0x14, 0x10, 0xd9,
0xd5, 0x14, 0x10, 0xe1, 0xd5, 0x14, 0x10, 0xe9, 0xd5, 0x14, 0x10, 0xf1, 0xd5, 0x14, 0x10, 0xf9,
0xd5, 0x50, 0x10, 0xc1, 0xd5, 0x50, 0x10, 0xc9, 0xd5, 0x50, 0x10, 0xd1, 0xd5, 0x50, 0x10, 0xd9,
0xd5, 0x50, 0x10, 0xe1, 0xd5, 0x50, 0x10, 0xe9, 0xd5, 0x50, 0x10, 0xf1, 0xd5, 0x50, 0x10, 0xf9,
0xd5, 0x54, 0x10, 0xc1, 0xd5, 0x54, 0x10, 0xc9, 0xd5, 0x54, 0x10, 0xd1, 0xd5, 0x54, 0x10, 0xd9,
0xd5, 0x54, 0x10, 0xe1, 0xd5, 0x54, 0x10, 0xe9, 0xd5, 0x54, 0x10, 0xf1, 0xd5, 0x54, 0x10, 0xf9,
0xd5, 0x40, 0x10, 0xe0, 0xd5, 0x40, 0x10, 0xe1, 0xd5, 0x40, 0x10, 0xe2, 0xd5, 0x40, 0x10, 0xe3,
0xd5, 0x40, 0x10, 0xe4, 0xd5, 0x40, 0x10, 0xe5, 0xd5, 0x40, 0x10, 0xe6, 0xd5, 0x40, 0x10, 0xe7,
0xd5, 0x41, 0x10, 0xe0, 0xd5, 0x41, 0x10, 0xe1, 0xd5, 0x41, 0x10, 0xe2, 0xd5, 0x41, 0x10, 0xe3,
0xd5, 0x41, 0x10, 0xe4, 0xd5, 0x41, 0x10, 0xe5, 0xd5, 0x41, 0x10, 0xe6, 0xd5, 0x41, 0x10, 0xe7,
0xd5, 0x50, 0x10, 0xe0, 0xd5, 0x50, 0x10, 0xe1, 0xd5, 0x50, 0x10, 0xe2, 0xd5, 0x50, 0x10, 0xe3,
0xd5, 0x50, 0x10, 0xe4, 0xd5, 0x50, 0x10, 0xe5, 0xd5, 0x50, 0x10, 0xe6, 0xd5, 0x50, 0x10, 0xe7,
0xd5, 0x51, 0x10, 0xe0, 0xd5, 0x51, 0x10, 0xe1, 0xd5, 0x51, 0x10, 0xe2, 0xd5, 0x51, 0x10, 0xe3,
0xd5, 0x51, 0x10, 0xe4, 0xd5, 0x51, 0x10, 0xe5, 0xd5, 0x51, 0x10, 0xe6, 0xd5, 0x51, 0x10, 0xe7,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(rm)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r16, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16);
adc(r16d, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16d);
adc(r16w, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16w);
adc(r16b, ptr [r17+0x40]);
adc(ptr [r17+0x40], r16b);
adc(r16, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16);
adc(r16d, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16d);
adc(r16w, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16w);
adc(r16b, ptr [r18*4+0x40]);
adc(ptr [r18*4+0x40], r16b);
adc(r16, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16);
adc(r16d, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16d);
adc(r16w, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16w);
adc(r16b, ptr [r17+r18*4+0x40]);
adc(ptr [r17+r18*4+0x40], r16b);
}
} c;
const uint8_t tbl[] = {
0xd5, 0x58, 0x13, 0x41, 0x40, 0xd5, 0x58, 0x11, 0x41, 0x40, 0xd5, 0x50, 0x13, 0x41, 0x40, 0xd5,
0x50, 0x11, 0x41, 0x40, 0x66, 0xd5, 0x50, 0x13, 0x41, 0x40, 0x66, 0xd5, 0x50, 0x11, 0x41, 0x40,
0xd5, 0x50, 0x12, 0x41, 0x40, 0xd5, 0x50, 0x10, 0x41, 0x40, 0xd5, 0x68, 0x13, 0x04, 0x95, 0x40,
0x00, 0x00, 0x00, 0xd5, 0x68, 0x11, 0x04, 0x95, 0x40, 0x00, 0x00, 0x00, 0xd5, 0x60, 0x13, 0x04,
0x95, 0x40, 0x00, 0x00, 0x00, 0xd5, 0x60, 0x11, 0x04, 0x95, 0x40, 0x00, 0x00, 0x00, 0x66, 0xd5,
0x60, 0x13, 0x04, 0x95, 0x40, 0x00, 0x00, 0x00, 0x66, 0xd5, 0x60, 0x11, 0x04, 0x95, 0x40, 0x00,
0x00, 0x00, 0xd5, 0x60, 0x12, 0x04, 0x95, 0x40, 0x00, 0x00, 0x00, 0xd5, 0x60, 0x10, 0x04, 0x95,
0x40, 0x00, 0x00, 0x00, 0xd5, 0x78, 0x13, 0x44, 0x91, 0x40, 0xd5, 0x78, 0x11, 0x44, 0x91, 0x40,
0xd5, 0x70, 0x13, 0x44, 0x91, 0x40, 0xd5, 0x70, 0x11, 0x44, 0x91, 0x40, 0x66, 0xd5, 0x70, 0x13,
0x44, 0x91, 0x40, 0x66, 0xd5, 0x70, 0x11, 0x44, 0x91, 0x40, 0xd5, 0x70, 0x12, 0x44, 0x91, 0x40,
0xd5, 0x70, 0x10, 0x44, 0x91, 0x40,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(r3)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r20b, r21b, r23b);
adc(r20w, r21w, r23w);
adc(r20d, r21d, r23d);
adc(r20, r21, r23);
}
} c;
const uint8_t tbl[] = {
0x62, 0xec, 0x5c, 0x10, 0x10, 0xfd, 0x62, 0xec, 0x5d, 0x10, 0x11, 0xfd, 0x62, 0xec, 0x5c, 0x10,
0x11, 0xfd, 0x62, 0xec, 0xdc, 0x10, 0x11, 0xfd,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(rm3)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(rax, r18, ptr [rbx+rcx*4+0x123]);
adc(rax, ptr [rbx+rcx*4+0x123], r20);
adc(rax, ptr [r30], r29);
adc(r11, r13, ptr [r10]);
adc(r11, r13, ptr [r10*4]);
adc(r11, ptr [r10*8], r9);
}
} c;
const uint8_t tbl[] = {
0x62, 0xe4, 0xfc, 0x18, 0x13, 0x94, 0x8b, 0x23, 0x01, 0x00, 0x00, 0x62, 0xe4, 0xfc, 0x18, 0x11,
0xa4, 0x8b, 0x23, 0x01, 0x00, 0x00, 0x62, 0x4c, 0xfc, 0x18, 0x11, 0x2e, 0x62, 0x54, 0xa4, 0x18,
0x13, 0x2a, 0x62, 0x34, 0xa4, 0x18, 0x13, 0x2c, 0x95, 0x00, 0x00, 0x00, 0x00, 0x62, 0x34, 0xa4,
0x18, 0x11, 0x0c, 0xd5, 0x00, 0x00, 0x00, 0x00,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(rm3_2)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adc(r20b, r21b, r23b);
adc(r20w, r21w, r23w);
adc(r20d, r21d, r23d);
adc(r20, r21, r23);
adc(r20b, ptr [rax+rcx*4+0x7fffffff], 0x12);
adc(r20w, ptr [rax+rcx*4+0x7fffffff], 0x1234);
adc(r20d, ptr [rax+rcx*4+0x7fffffff], 0x12345678);
adc(r20, ptr [rax+rcx*4+0x7fffffff], 0x12345678);
adc(r20b, al, 0x12);
adc(r20w, ax, 0x1234);
adc(r20d, eax, 0x12345678);
adc(r20, rax, 0x12345678);
}
} c;
const uint8_t tbl[] = {
0x62, 0xec, 0x5c, 0x10, 0x10, 0xfd, 0x62, 0xec, 0x5d, 0x10, 0x11, 0xfd, 0x62, 0xec, 0x5c, 0x10,
0x11, 0xfd, 0x62, 0xec, 0xdc, 0x10, 0x11, 0xfd, 0x62, 0xf4, 0x5c, 0x10, 0x80, 0x94, 0x88, 0xff,
0xff, 0xff, 0x7f, 0x12, 0x62, 0xf4, 0x5d, 0x10, 0x81, 0x94, 0x88, 0xff, 0xff, 0xff, 0x7f, 0x34,
0x12, 0x62, 0xf4, 0x5c, 0x10, 0x81, 0x94, 0x88, 0xff, 0xff, 0xff, 0x7f, 0x78, 0x56, 0x34, 0x12,
0x62, 0xf4, 0xdc, 0x10, 0x81, 0x94, 0x88, 0xff, 0xff, 0xff, 0x7f, 0x78, 0x56, 0x34, 0x12, 0x62,
0xf4, 0x5c, 0x10, 0x80, 0xd0, 0x12, 0x62, 0xf4, 0x5d, 0x10, 0x81, 0xd0, 0x34, 0x12, 0x62, 0xf4,
0x5c, 0x10, 0x81, 0xd0, 0x78, 0x56, 0x34, 0x12, 0x62, 0xf4, 0xdc, 0x10, 0x81, 0xd0, 0x78, 0x56,
0x34, 0x12,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(adcx_adox)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
adcx(rax, r30);
adcx(ecx, r20d);
adcx(ecx, ptr [r31+r29*4]);
adcx(r20d, ptr [rax]);
adcx(r16, ptr [r31+r29*4]);
adcx(r17, ptr [rax]);
adcx(rax, rcx, rdx);
adox(rax, r30);
adox(ecx, r20d);
adox(ecx, ptr [r31+r29*4]);
adox(r20d, ptr [rax]);
adox(r16, ptr [r31+r29*4]);
adox(r17, ptr [rax]);
adox(rax, rcx, rdx);
}
} c;
const uint8_t tbl[] = {
0x62, 0xdc, 0xfd, 0x08, 0x66, 0xc6, 0x62, 0xfc, 0x7d, 0x08, 0x66, 0xcc, 0x62, 0x9c, 0x79, 0x08,
0x66, 0x0c, 0xaf, 0x62, 0xe4, 0x7d, 0x08, 0x66, 0x20, 0x62, 0x8c, 0xf9, 0x08, 0x66, 0x04, 0xaf,
0x62, 0xe4, 0xfd, 0x08, 0x66, 0x08, 0x62, 0xf4, 0xfd, 0x18, 0x66, 0xca,
0x62, 0xdc, 0xfe, 0x08, 0x66, 0xc6, 0x62, 0xfc, 0x7e, 0x08, 0x66, 0xcc, 0x62, 0x9c, 0x7a, 0x08,
0x66, 0x0c, 0xaf, 0x62, 0xe4, 0x7e, 0x08, 0x66, 0x20, 0x62, 0x8c, 0xfa, 0x08, 0x66, 0x04, 0xaf,
0x62, 0xe4, 0xfe, 0x08, 0x66, 0x08, 0x62, 0xf4, 0xfe, 0x18, 0x66, 0xca,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(r3_2)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
add(rax, rcx, rdx);
adc(rax, rcx, rdx);
and_(rax, rcx, rdx);
or_(rax, rcx, rdx);
sbb(rax, rcx, rdx);
sub(rax, rcx, rdx);
xor_(rax, rcx, rdx);
add(r30, ptr [r20], r9);
adc(r30, ptr [r20], r9);
and_(r30, ptr [r20], r9);
or_(r30, ptr [r20], r9);
sbb(r30, ptr [r20], r9);
sub(r30, ptr [r20], r9);
xor_(r30, ptr [r20], r9);
}
} c;
const uint8_t tbl[] = {
0x62, 0xf4, 0xfc, 0x18, 0x01, 0xd1, 0x62, 0xf4, 0xfc, 0x18, 0x11, 0xd1, 0x62, 0xf4, 0xfc, 0x18,
0x21, 0xd1, 0x62, 0xf4, 0xfc, 0x18, 0x09, 0xd1, 0x62, 0xf4, 0xfc, 0x18, 0x19, 0xd1, 0x62, 0xf4,
0xfc, 0x18, 0x29, 0xd1, 0x62, 0xf4, 0xfc, 0x18, 0x31, 0xd1, 0x62, 0x7c, 0x8c, 0x10, 0x01, 0x0c,
0x24, 0x62, 0x7c, 0x8c, 0x10, 0x11, 0x0c, 0x24, 0x62, 0x7c, 0x8c, 0x10, 0x21, 0x0c, 0x24, 0x62,
0x7c, 0x8c, 0x10, 0x09, 0x0c, 0x24, 0x62, 0x7c, 0x8c, 0x10, 0x19, 0x0c, 0x24, 0x62, 0x7c, 0x8c,
0x10, 0x29, 0x0c, 0x24, 0x62, 0x7c, 0x8c, 0x10, 0x31, 0x0c, 0x24,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(NF)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
add(rax, rcx, rdx);
add(rax|T_nf, rcx, rdx);
and_(rax, rcx, rdx);
and_(rax|T_nf, rcx, rdx);
or_(rax, rcx, rdx);
or_(rax|T_nf, rcx, rdx);
sub(rax, rcx, rdx);
sub(rax|T_nf, rcx, rdx);
xor_(rax, rcx, rdx);
xor_(rax|T_nf, rcx, rdx);
add(rax, rcx, 3);
add(rax|T_nf, rcx, 3);
and_(rax, rcx, 3);
and_(rax|T_nf, rcx, 3);
or_(rax, rcx, 3);
or_(rax|T_nf, rcx, 3);
sub(rax, rcx, 3);
sub(rax|T_nf, rcx, 3);
xor_(rax, rcx, 3);
xor_(rax|T_nf, rcx, 3);
}
} c;
const uint8_t tbl[] = {
0x62, 0xf4, 0xfc, 0x18, 0x01, 0xd1,
0x62, 0xf4, 0xfc, 0x1c, 0x01, 0xd1,
0x62, 0xf4, 0xfc, 0x18, 0x21, 0xd1,
0x62, 0xf4, 0xfc, 0x1c, 0x21, 0xd1,
0x62, 0xf4, 0xfc, 0x18, 0x09, 0xd1,
0x62, 0xf4, 0xfc, 0x1c, 0x09, 0xd1,
0x62, 0xf4, 0xfc, 0x18, 0x29, 0xd1,
0x62, 0xf4, 0xfc, 0x1c, 0x29, 0xd1,
0x62, 0xf4, 0xfc, 0x18, 0x31, 0xd1,
0x62, 0xf4, 0xfc, 0x1c, 0x31, 0xd1,
0x62, 0xf4, 0xfc, 0x18, 0x83, 0xc1, 0x03,
0x62, 0xf4, 0xfc, 0x1c, 0x83, 0xc1, 0x03,
0x62, 0xf4, 0xfc, 0x18, 0x83, 0xe1, 0x03,
0x62, 0xf4, 0xfc, 0x1c, 0x83, 0xe1, 0x03,
0x62, 0xf4, 0xfc, 0x18, 0x83, 0xc9, 0x03,
0x62, 0xf4, 0xfc, 0x1c, 0x83, 0xc9, 0x03,
0x62, 0xf4, 0xfc, 0x18, 0x83, 0xe9, 0x03,
0x62, 0xf4, 0xfc, 0x1c, 0x83, 0xe9, 0x03,
0x62, 0xf4, 0xfc, 0x18, 0x83, 0xf1, 0x03,
0x62, 0xf4, 0xfc, 0x1c, 0x83, 0xf1, 0x03,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(andn_etc)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
andn(r29, r30, r31);
andn(r29|T_nf, r30, r31);
andn(eax, ecx, r17d); // 32bit
andn(r29, r30, ptr [r31+r20*4]);
mulx(eax, ecx, r17d);
mulx(r29, r30, r31);
mulx(r29, r30, ptr [r31+r20*4]);
pdep(eax, ecx, r17d);
pdep(r29, r30, r31);
pdep(r29, r30, ptr [r31+r20*4]);
pext(eax, ecx, r17d);
pext(r29, r30, r31);
pext(r29, r30, ptr [r31+r20*4]);
}
} c;
const uint8_t tbl[] = {
// andn
0x62, 0x4a, 0x8c, 0x00, 0xf2, 0xef,
0x62, 0x4a, 0x8c, 0x04, 0xf2, 0xef,
0x62, 0xfa, 0x74, 0x08, 0xf2, 0xc1,
0x62, 0x4a, 0x88, 0x00, 0xf2, 0x2c, 0xa7,
// mulx, pdep, pext
0x62, 0xfa, 0x77, 0x08, 0xf6, 0xc1, 0x62, 0x4a, 0x8f, 0x00, 0xf6, 0xef, 0x62, 0x4a, 0x8b, 0x00, 0xf6, 0x2c, 0xa7,
0x62, 0xfa, 0x77, 0x08, 0xf5, 0xc1, 0x62, 0x4a, 0x8f, 0x00, 0xf5, 0xef, 0x62, 0x4a, 0x8b, 0x00, 0xf5, 0x2c, 0xa7,
0x62, 0xfa, 0x76, 0x08, 0xf5, 0xc1, 0x62, 0x4a, 0x8e, 0x00, 0xf5, 0xef, 0x62, 0x4a, 0x8a, 0x00, 0xf5, 0x2c, 0xa7,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(bextr_etc)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
bextr(r29, r30, r31);
bextr(r29|T_nf, r30, r31);
bextr(eax, ecx, r17d);
bextr(r29, ptr [r31+r20*4], r30);
bzhi(r29, r30, r31);
bzhi(r29|T_nf, r30, r31);
bzhi(eax, ecx, r17d);
bzhi(r29, ptr [r31+r20*4], r30);
sarx(r29, r30, r31);
sarx(eax, ecx, r17d);
sarx(r29, ptr [r31+r20*4], r30);
shlx(r29, r30, r31);
shlx(eax, ecx, r17d);
shlx(r29, ptr [r31+r20*4], r30);
shrx(r29, r30, r31);
shrx(eax, ecx, r17d);
shrx(r29, ptr [r31+r20*4], r30);
blsi(r30, r31);
blsi(r30|T_nf, r31);
blsi(ecx, r17d);
blsi(r30, ptr [r31+r20*4]);
blsmsk(r30, r31);
blsmsk(r30|T_nf, r31);
blsmsk(ecx, r17d);
blsmsk(r30, ptr [r31+r20*4]);
blsr(r30, r31);
blsr(r30|T_nf, r31);
blsr(ecx, r17d);
blsr(r30, ptr [r31+r20*4]);
rorx(r30, r31, 3);
rorx(ecx, r17d, 5);
rorx(r30, ptr [r31+r20*4], 4);
}
} c;
const uint8_t tbl[] = {
// bextr
0x62, 0x4a, 0x84, 0x00, 0xf7, 0xee,
0x62, 0x4a, 0x84, 0x04, 0xf7, 0xee,
0x62, 0xf2, 0x74, 0x00, 0xf7, 0xc1,
0x62, 0x4a, 0x88, 0x00, 0xf7, 0x2c, 0xa7,
// bzhi
0x62, 0x4a, 0x84, 0x00, 0xf5, 0xee,
0x62, 0x4a, 0x84, 0x04, 0xf5, 0xee,
0x62, 0xf2, 0x74, 0x00, 0xf5, 0xc1,
0x62, 0x4a, 0x88, 0x00, 0xf5, 0x2c, 0xa7,
// sarx
0x62, 0x4a, 0x86, 0x00, 0xf7, 0xee,
0x62, 0xf2, 0x76, 0x00, 0xf7, 0xc1,
0x62, 0x4a, 0x8a, 0x00, 0xf7, 0x2c, 0xa7,
// shlx
0x62, 0x4a, 0x85, 0x00, 0xf7, 0xee,
0x62, 0xf2, 0x75, 0x00, 0xf7, 0xc1,
0x62, 0x4a, 0x89, 0x00, 0xf7, 0x2c, 0xa7,
// shrx
0x62, 0x4a, 0x87, 0x00, 0xf7, 0xee,
0x62, 0xf2, 0x77, 0x00, 0xf7, 0xc1,
0x62, 0x4a, 0x8b, 0x00, 0xf7, 0x2c, 0xa7,
// blsi
0x62, 0xda, 0x8c, 0x00, 0xf3, 0xdf,
0x62, 0xda, 0x8c, 0x04, 0xf3, 0xdf,
0x62, 0xfa, 0x74, 0x08, 0xf3, 0xd9,
0x62, 0xda, 0x88, 0x00, 0xf3, 0x1c, 0xa7,
// blsmsk
0x62, 0xda, 0x8c, 0x00, 0xf3, 0xd7,
0x62, 0xda, 0x8c, 0x04, 0xf3, 0xd7,
0x62, 0xfa, 0x74, 0x08, 0xf3, 0xd1,
0x62, 0xda, 0x88, 0x00, 0xf3, 0x14, 0xa7,
// blsr
0x62, 0xda, 0x8c, 0x00, 0xf3, 0xcf,
0x62, 0xda, 0x8c, 0x04, 0xf3, 0xcf,
0x62, 0xfa, 0x74, 0x08, 0xf3, 0xc9,
0x62, 0xda, 0x88, 0x00, 0xf3, 0x0c, 0xa7,
// rorx
0x62, 0x4b, 0xff, 0x08, 0xf0, 0xf7, 0x03,
0x62, 0xfb, 0x7f, 0x08, 0xf0, 0xc9, 0x05,
0x62, 0x4b, 0xfb, 0x08, 0xf0, 0x34, 0xa7, 0x04,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(bit)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
// adc
adc(r20b, r21b, r22b);
adc(r20w, r21w, r22w);
adc(r20d, r21d, r22d);
adc(r20, r21, r22);
adc(r20b, r21b);
adc(r20w, r21w);
adc(r20d, r21d);
adc(r20, r21);
adc(r20b, r21b, 0x3);
adc(r20w, r21w, 0x3);
adc(r20d, r21d, 0x3);
adc(r20, r21, 0x3);
adc(r20b, 0x3);
adc(r20w, 0x3);
adc(r20d, 0x3);
adc(r20, 0x3);
// add
add(r20b, r21b, r22b);
add(r20w, r21w, r22w);
add(r20d, r21d, r22d);
add(r20, r21, r22);
add(r20b, r21b);
add(r20w, r21w);
add(r20d, r21d);
add(r20, r21);
add(r20b, r21b, 0x3);
add(r20w, r21w, 0x3);
add(r20d, r21d, 0x3);
add(r20, r21, 0x3);
add(r20b, 0x3);
add(r20w, 0x3);
add(r20d, 0x3);
add(r20, 0x3);
}
} c;
const uint8_t tbl[] = {
// adc
0x62, 0xec, 0x5c, 0x10, 0x10, 0xf5, 0x62, 0xec, 0x5d, 0x10, 0x11, 0xf5, 0x62, 0xec, 0x5c, 0x10,
0x11, 0xf5, 0x62, 0xec, 0xdc, 0x10, 0x11, 0xf5, 0xd5, 0x50, 0x10, 0xec, 0x66, 0xd5, 0x50, 0x11,
0xec, 0xd5, 0x50, 0x11, 0xec, 0xd5, 0x58, 0x11, 0xec, 0x62, 0xfc, 0x5c, 0x10, 0x80, 0xd5, 0x03,
0x62, 0xfc, 0x5d, 0x10, 0x83, 0xd5, 0x03, 0x62, 0xfc, 0x5c, 0x10, 0x83, 0xd5, 0x03, 0x62, 0xfc,
0xdc, 0x10, 0x83, 0xd5, 0x03, 0xd5, 0x10, 0x80, 0xd4, 0x03, 0x66, 0xd5, 0x10, 0x83, 0xd4, 0x03,
0xd5, 0x10, 0x83, 0xd4, 0x03, 0xd5, 0x18, 0x83, 0xd4, 0x03,
// add
0x62, 0xec, 0x5c, 0x10, 0x00, 0xf5, 0x62, 0xec, 0x5d, 0x10, 0x01, 0xf5, 0x62, 0xec, 0x5c, 0x10,
0x01, 0xf5, 0x62, 0xec, 0xdc, 0x10, 0x01, 0xf5, 0xd5, 0x50, 0x00, 0xec, 0x66, 0xd5, 0x50, 0x01,
0xec, 0xd5, 0x50, 0x01, 0xec, 0xd5, 0x58, 0x01, 0xec, 0x62, 0xfc, 0x5c, 0x10, 0x80, 0xc5, 0x03,
0x62, 0xfc, 0x5d, 0x10, 0x83, 0xc5, 0x03, 0x62, 0xfc, 0x5c, 0x10, 0x83, 0xc5, 0x03, 0x62, 0xfc,
0xdc, 0x10, 0x83, 0xc5, 0x03, 0xd5, 0x10, 0x80, 0xc4, 0x03, 0x66, 0xd5, 0x10, 0x83, 0xc4, 0x03,
0xd5, 0x10, 0x83, 0xc4, 0x03, 0xd5, 0x18, 0x83, 0xc4, 0x03,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(inc_dec)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
inc(r30b);
inc(r30w);
inc(r30d);
inc(r30);
inc(r30b, r31b);
inc(r30w, r31w);
inc(r30w|T_nf, r31w);
inc(r30d, r31d);
inc(r30, r31);
inc(r30, ptr [r31]);
dec(r30b);
dec(r30w);
dec(r30d);
dec(r30);
dec(r30b, r31b);
dec(r30w, r31w);
dec(r30w|T_nf, r31w);
dec(r30d, r31d);
dec(r30, r31);
dec(r30, ptr [r31]);
}
} c;
const uint8_t tbl[] = {
// inc
0xd5, 0x11, 0xfe, 0xc6, 0x66, 0xd5, 0x11, 0xff, 0xc6, 0xd5, 0x11, 0xff, 0xc6, 0xd5, 0x19, 0xff,
0xc6, 0x62, 0xdc, 0x0c, 0x10, 0xfe, 0xc7,
0x62, 0xdc, 0x0d, 0x10, 0xff, 0xc7,
0x62, 0xdc, 0x0d, 0x14, 0xff, 0xc7, // T_nf
0x62, 0xdc, 0x0c, 0x10, 0xff, 0xc7, 0x62, 0xdc, 0x8c, 0x10, 0xff, 0xc7, 0x62,
0xdc, 0x8c, 0x10, 0xff, 0x07,
// decA
0xd5, 0x11, 0xfe, 0xce, 0x66, 0xd5, 0x11, 0xff, 0xce, 0xd5, 0x11, 0xff, 0xce, 0xd5, 0x19, 0xff,
0xce, 0x62, 0xdc, 0x0c, 0x10, 0xfe, 0xcf,
0x62, 0xdc, 0x0d, 0x10, 0xff, 0xcf,
0x62, 0xdc, 0x0d, 0x14, 0xff, 0xcf, // T_nf
0x62, 0xdc, 0x0c, 0x10, 0xff, 0xcf, 0x62, 0xdc, 0x8c, 0x10, 0xff, 0xcf, 0x62,
0xdc, 0x8c, 0x10, 0xff, 0x0f,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(div_op1)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
div(r20b);
div(r20d);
div(r20w);
div(r20);
div(r20|T_nf);
div(eax|T_nf);
div(byte [r20+r30*1]);
div(word [r20+r30*1]);
div(dword [r20+r30*1]);
div(qword [r20+r30*1]);
idiv(r20b);
idiv(r20d);
idiv(r20w);
idiv(r20);
idiv(r20|T_nf);
idiv(eax|T_nf);
idiv(byte [r20+r30*1]);
idiv(word [r20+r30*1]);
idiv(dword [r20+r30*1]);
idiv(qword [r20+r30*1]);
imul(r20b);
imul(r20d);
imul(r20w);
imul(r20);
imul(r20|T_nf);
imul(eax|T_nf);
imul(byte [r20+r30*1]);
imul(word [r20+r30*1]);
imul(dword [r20+r30*1]);
imul(qword [r20+r30*1]);
mul(r20b);
mul(r20d);
mul(r20w);
mul(r20);
mul(r20|T_nf);
mul(eax|T_nf);
mul(byte [r20+r30*1]);
mul(word [r20+r30*1]);
mul(dword [r20+r30*1]);
mul(qword [r20+r30*1]);
neg(r20b);
neg(r20d);
neg(r20w);
neg(r20);
neg(r20|T_nf);
neg(eax|T_nf);
neg(byte [r20+r30*1]);
neg(word [r20+r30*1]);
neg(dword [r20+r30*1]);
neg(qword [r20+r30*1]);
// not_ does not have NF=1
not_(r20b);
not_(r20d);
not_(r20w);
not_(r20);
not_(byte [r20+r30*1]);
not_(word [r20+r30*1]);
not_(dword [r20+r30*1]);
not_(qword [r20+r30*1]);
}
} c;
const uint8_t tbl[] = {
0x62, 0xfc, 0x7c, 0x08, 0xf6, 0xf4,
0x62, 0xfc, 0x7c, 0x08, 0xf7, 0xf4,
0x62, 0xfc, 0x7d, 0x08, 0xf7, 0xf4,
0x62, 0xfc, 0xfc, 0x08, 0xf7, 0xf4,
0x62, 0xfc, 0xfc, 0x0c, 0xf7, 0xf4, // r20|T_nf
0x62, 0xf4, 0x7c, 0x0c, 0xf7, 0xf0, // eax|T_nf
0x62, 0xbc, 0x78, 0x08, 0xf6, 0x34, 0x34,
0x62, 0xbc, 0x79, 0x08, 0xf7, 0x34, 0x34,
0x62, 0xbc, 0x78, 0x08, 0xf7, 0x34, 0x34,
0x62, 0xbc, 0xf8, 0x08, 0xf7, 0x34, 0x34,
0x62, 0xfc, 0x7c, 0x08, 0xf6, 0xfc, 0x62, 0xfc, 0x7c, 0x08, 0xf7, 0xfc, 0x62, 0xfc, 0x7d, 0x08,
0xf7, 0xfc, 0x62, 0xfc, 0xfc, 0x08, 0xf7, 0xfc, 0x62, 0xfc, 0xfc, 0x0c, 0xf7, 0xfc, 0x62, 0xf4,
0x7c, 0x0c, 0xf7, 0xf8, 0x62, 0xbc, 0x78, 0x08, 0xf6, 0x3c, 0x34, 0x62, 0xbc, 0x79, 0x08, 0xf7,
0x3c, 0x34, 0x62, 0xbc, 0x78, 0x08, 0xf7, 0x3c, 0x34, 0x62, 0xbc, 0xf8, 0x08, 0xf7, 0x3c, 0x34,
0x62, 0xfc, 0x7c, 0x08, 0xf6, 0xec, 0x62, 0xfc, 0x7c, 0x08, 0xf7, 0xec, 0x62, 0xfc, 0x7d, 0x08,
0xf7, 0xec, 0x62, 0xfc, 0xfc, 0x08, 0xf7, 0xec, 0x62, 0xfc, 0xfc, 0x0c, 0xf7, 0xec, 0x62, 0xf4,
0x7c, 0x0c, 0xf7, 0xe8, 0x62, 0xbc, 0x78, 0x08, 0xf6, 0x2c, 0x34, 0x62, 0xbc, 0x79, 0x08, 0xf7,
0x2c, 0x34, 0x62, 0xbc, 0x78, 0x08, 0xf7, 0x2c, 0x34, 0x62, 0xbc, 0xf8, 0x08, 0xf7, 0x2c, 0x34,
0x62, 0xfc, 0x7c, 0x08, 0xf6, 0xe4, 0x62, 0xfc, 0x7c, 0x08, 0xf7, 0xe4, 0x62, 0xfc, 0x7d, 0x08,
0xf7, 0xe4, 0x62, 0xfc, 0xfc, 0x08, 0xf7, 0xe4, 0x62, 0xfc, 0xfc, 0x0c, 0xf7, 0xe4, 0x62, 0xf4,
0x7c, 0x0c, 0xf7, 0xe0, 0x62, 0xbc, 0x78, 0x08, 0xf6, 0x24, 0x34, 0x62, 0xbc, 0x79, 0x08, 0xf7,
0x24, 0x34, 0x62, 0xbc, 0x78, 0x08, 0xf7, 0x24, 0x34, 0x62, 0xbc, 0xf8, 0x08, 0xf7, 0x24, 0x34,
0x62, 0xfc, 0x7c, 0x08, 0xf6, 0xdc, 0x62, 0xfc, 0x7c, 0x08, 0xf7, 0xdc, 0x62, 0xfc, 0x7d, 0x08,
0xf7, 0xdc, 0x62, 0xfc, 0xfc, 0x08, 0xf7, 0xdc, 0x62, 0xfc, 0xfc, 0x0c, 0xf7, 0xdc, 0x62, 0xf4,
0x7c, 0x0c, 0xf7, 0xd8, 0x62, 0xbc, 0x78, 0x08, 0xf6, 0x1c, 0x34, 0x62, 0xbc, 0x79, 0x08, 0xf7,
0x1c, 0x34, 0x62, 0xbc, 0x78, 0x08, 0xf7, 0x1c, 0x34, 0x62, 0xbc, 0xf8, 0x08, 0xf7, 0x1c, 0x34,
0x62, 0xfc, 0x7c, 0x08, 0xf6, 0xd4, 0x62, 0xfc, 0x7c, 0x08, 0xf7, 0xd4, 0x62, 0xfc, 0x7d, 0x08,
0xf7, 0xd4, 0x62, 0xfc, 0xfc, 0x08, 0xf7, 0xd4, 0x62, 0xbc, 0x78, 0x08, 0xf6, 0x14, 0x34, 0x62,
0xbc, 0x79, 0x08, 0xf7, 0x14, 0x34, 0x62, 0xbc, 0x78, 0x08, 0xf7, 0x14, 0x34, 0x62, 0xbc, 0xf8,
0x08, 0xf7, 0x14, 0x34,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(imul_2op)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
// imul(r30b, al); // QQQ : not supported?
imul(r30w, ax);
imul(r30d, eax);
imul(r30, rax);
imul(r30|T_nf, rax);
imul(rcx|T_nf, rax);
imul(rcx, ptr [r30]);
neg(r30b, al);
neg(r30w, ax);
neg(r30d, eax);
neg(r30, rax);
neg(r30|T_nf, rax);
neg(rcx|T_nf, rax);
neg(rcx, ptr [r30]);
not_(r30b, al);
not_(r30w, ax);
not_(r30d, eax);
not_(r30, rax);
not_(rcx, ptr [r30]);
}
} c;
const uint8_t tbl[] = {
// imul
0x62, 0x64, 0x7d, 0x08, 0xaf, 0xf0,
0x62, 0x64, 0x7c, 0x08, 0xaf, 0xf0,
0x62, 0x64, 0xfc, 0x08, 0xaf, 0xf0,
0x62, 0x64, 0xfc, 0x0c, 0xaf, 0xf0,
0x62, 0xf4, 0xfc, 0x0c, 0xaf, 0xc8,
0x62, 0xdc, 0xfc, 0x08, 0xaf, 0x0e,
// neg
0x62, 0xf4, 0x0c, 0x10, 0xf6, 0xd8, 0x62, 0xf4, 0x0d, 0x10, 0xf7, 0xd8, 0x62, 0xf4, 0x0c, 0x10,
0xf7, 0xd8, 0x62, 0xf4, 0x8c, 0x10, 0xf7, 0xd8, 0x62, 0xf4, 0x8c, 0x14, 0xf7, 0xd8, 0x62, 0xf4,
0xf4, 0x1c, 0xf7, 0xd8, 0x62, 0xdc, 0xf4, 0x18, 0xf7, 0x1e,
// not
0x62, 0xf4, 0x0c, 0x10, 0xf6, 0xd0, 0x62, 0xf4, 0x0d, 0x10, 0xf7, 0xd0, 0x62, 0xf4, 0x0c, 0x10,
0xf7, 0xd0, 0x62, 0xf4, 0x8c, 0x10, 0xf7, 0xd0, 0x62, 0xdc, 0xf4, 0x18, 0xf7, 0x16,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(imul_zu)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
imul(ax|T_zu, cx, 0x1234);
imul(ax|T_nf, cx, 0x1234);
imul(ax|T_zu|T_nf, cx, 0x1234);
imul(r30w, ax, 0x1234);
imul(r30d, eax, 0x12345678);
imul(r30, rax, 0x12345678);
imul(r30|T_zu, rax, 0x12345678);
imul(r30|T_nf, rax, 0x12345678);
imul(r30|T_nf|T_zu, rax, 0x12345678);
imul(rcx, ptr [r30], 0x12345678);
}
} c;
const uint8_t tbl[] = {
0x62, 0xf4, 0x7d, 0x18, 0x69, 0xc1, 0x34, 0x12, // T_zu
0x62, 0xf4, 0x7d, 0x0c, 0x69, 0xc1, 0x34, 0x12, // T_nf
0x62, 0xf4, 0x7d, 0x1c, 0x69, 0xc1, 0x34, 0x12, // T_zu|T_nf
0x62, 0x64, 0x7d, 0x08, 0x69, 0xf0, 0x34, 0x12, // w
0x62, 0x64, 0x7c, 0x08, 0x69, 0xf0, 0x78, 0x56, 0x34, 0x12, // d
0x62, 0x64, 0xfc, 0x08, 0x69, 0xf0, 0x78, 0x56, 0x34, 0x12,
0x62, 0x64, 0xfc, 0x18, 0x69, 0xf0, 0x78, 0x56, 0x34, 0x12, // T_zu
0x62, 0x64, 0xfc, 0x0c, 0x69, 0xf0, 0x78, 0x56, 0x34, 0x12, // T_nf
0x62, 0x64, 0xfc, 0x1c, 0x69, 0xf0, 0x78, 0x56, 0x34, 0x12, // T_nf|T_zu
0x62, 0xdc, 0xfc, 0x08, 0x69, 0x0e, 0x78, 0x56, 0x34, 0x12,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(lzcnt)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
lzcnt(r16w, r17w);
lzcnt(r16d, r17d);
lzcnt(r16, r17);
lzcnt(r16|T_nf, r17);
lzcnt(rax|T_nf, rcx);
lzcnt(rax, ptr [r18]);
tzcnt(r16w, r17w);
tzcnt(r16d, r17d);
tzcnt(r16, r17);
tzcnt(r16|T_nf, r17);
tzcnt(rax|T_nf, rcx);
tzcnt(rax, ptr [r18]);
}
} c;
const uint8_t tbl[] = {
// lzcnt
0x62, 0xec, 0x7d, 0x08, 0xf5, 0xc1, 0x62, 0xec, 0x7c, 0x08, 0xf5, 0xc1, 0x62, 0xec, 0xfc, 0x08,
0xf5, 0xc1, 0x62, 0xec, 0xfc, 0x0c, 0xf5, 0xc1, 0x62, 0xf4, 0xfc, 0x0c, 0xf5, 0xc1, 0x62, 0xfc,
0xfc, 0x08, 0xf5, 0x02,
// tzcnt
0x62, 0xec, 0x7d, 0x08, 0xf4, 0xc1, 0x62, 0xec, 0x7c, 0x08, 0xf4, 0xc1, 0x62, 0xec, 0xfc, 0x08,
0xf4, 0xc1, 0x62, 0xec, 0xfc, 0x0c, 0xf4, 0xc1, 0x62, 0xf4, 0xfc, 0x0c, 0xf4, 0xc1, 0x62, 0xfc,
0xfc, 0x08, 0xf4, 0x02,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(shld)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
shld(rax|T_nf, rcx, cl);
shld(r16, rcx, cl);
shld(r16, rcx, 0x9);
shld(r16|T_nf, rcx, 0x9);
shld(r20, r16, rcx, cl);
shld(r20|T_nf, r16, rcx, cl);
shld(r20, r16, rcx, 0x9);
shld(r20|T_nf, r16, rcx, 0x9);
shld(r20, ptr [r21], rcx, 0x9);
shrd(rax|T_nf, rcx, cl);
shrd(r16, rcx, cl);
shrd(r16, rcx, 0x9);
shrd(r16|T_nf, rcx, 0x9);
shrd(r20, r16, rcx, cl);
shrd(r20|T_nf, r16, rcx, cl);
shrd(r20, r16, rcx, 0x9);
shrd(r20|T_nf, r16, rcx, 0x9);
shrd(r20, ptr [r21], rcx, 0x9);
}
} c;
const uint8_t tbl[] = {
// shld
0x62, 0xf4, 0xfc, 0x0c, 0xa5, 0xc8, 0x62, 0xfc, 0xfc, 0x08, 0xa5, 0xc8, 0x62, 0xfc, 0xfc, 0x08,
0x24, 0xc8, 0x09, 0x62, 0xfc, 0xfc, 0x0c, 0x24, 0xc8, 0x09, 0x62, 0xfc, 0xdc, 0x10, 0xa5, 0xc8,
0x62, 0xfc, 0xdc, 0x14, 0xa5, 0xc8, 0x62, 0xfc, 0xdc, 0x10, 0x24, 0xc8, 0x09, 0x62, 0xfc, 0xdc,
0x14, 0x24, 0xc8, 0x09, 0x62, 0xfc, 0xdc, 0x10, 0x24, 0x4d, 0x00, 0x09,
// shrd
0x62, 0xf4, 0xfc, 0x0c, 0xad, 0xc8, 0x62, 0xfc, 0xfc, 0x08, 0xad, 0xc8, 0x62, 0xfc, 0xfc, 0x08,
0x2c, 0xc8, 0x09, 0x62, 0xfc, 0xfc, 0x0c, 0x2c, 0xc8, 0x09, 0x62, 0xfc, 0xdc, 0x10, 0xad, 0xc8,
0x62, 0xfc, 0xdc, 0x14, 0xad, 0xc8, 0x62, 0xfc, 0xdc, 0x10, 0x2c, 0xc8, 0x09, 0x62, 0xfc, 0xdc,
0x14, 0x2c, 0xc8, 0x09, 0x62, 0xfc, 0xdc, 0x10, 0x2c, 0x4d, 0x00, 0x09,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(base)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
lea(r30, ptr[r20+r21]);
add(r30, r20);
add(r30, ptr[r20]);
cmp(r30, ptr[r20]);
push(r16);
pop(r16);
}
} c;
const uint8_t tbl[] = {
// lea
0xd5, 0x7c, 0x8d, 0x34, 0x2c,
// add
0xd5, 0x59, 0x01, 0xe6,
0xd5, 0x5c, 0x03, 0x34, 0x24,
// cmp
0xd5, 0x5c, 0x3b, 0x34, 0x24,
// push
0xd5, 0x10, 0x50,
// pop
0xd5, 0x10, 0x58,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(mov_misc)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
movdir64b(r16, ptr [r20+r21*8+0x4]);
movdiri(ptr [r20+r21*8+0x4], r16);
movbe(ptr [r16], r30w);
movbe(ptr [r16], r30d);
movbe(ptr [r16], r30);
movbe(r30w, ptr [r16]);
movbe(r30d, ptr [r16]);
movbe(r30, ptr [r16]);
crc32(r30d, r8b);
crc32(r30d, r8w);
crc32(r30d, r8d);
crc32(r30, r8b);
crc32(r30, r8);
jmpabs(0x12345678aabbccdd);
cmpbexadd(ptr [r20+r30*8], r21, r22);
cmpbexadd(ptr [r20+r30*8], r21d, r22d);
cmovb(r8, r9, r10);
cmovb(r8d, r9d, r10d);
setb(r31b);
setb(r31b|T_zu);
setb(r15b|T_zu);
setb(ptr [r30]);
bswap(eax);
bswap(r8d);
bswap(r16d);
bswap(rcx);
bswap(r9);
bswap(r17);
}
} c;
const uint8_t tbl[] = {
// movdir64b
0x62, 0xec, 0x79, 0x08, 0xf8, 0x44, 0xec, 0x04,
// movdiri
0x62, 0xec, 0xf8, 0x08, 0xf9, 0x44, 0xec, 0x04,
// movbe
0x62, 0x6c, 0x7d, 0x08, 0x61, 0x30, 0x62, 0x6c, 0x7c, 0x08, 0x61, 0x30, 0x62, 0x6c, 0xfc, 0x08,
0x61, 0x30, 0x62, 0x6c, 0x7d, 0x08, 0x60, 0x30, 0x62, 0x6c, 0x7c, 0x08, 0x60, 0x30, 0x62, 0x6c,
0xfc, 0x08, 0x60, 0x30,
// crc32
0x62, 0x44, 0x7c, 0x08, 0xf0, 0xf0, 0x62, 0x44, 0x7d, 0x08, 0xf1, 0xf0, 0x62, 0x44, 0x7c, 0x08,
0xf1, 0xf0, 0x62, 0x44, 0xfc, 0x08, 0xf0, 0xf0, 0x62, 0x44, 0xfc, 0x08, 0xf1, 0xf0,
// jmpabs
0xd5, 0x00, 0xa1, 0xdd, 0xcc, 0xbb, 0xaa, 0x78, 0x56, 0x34, 0x12,
//cmpbexadd
0x62, 0xaa, 0xc9, 0x00, 0xe6, 0x2c, 0xf4,
0x62, 0xaa, 0x49, 0x00, 0xe6, 0x2c, 0xf4,
// cmovb
0x62, 0x54, 0xbc, 0x18, 0x42, 0xca,
0x62, 0x54, 0x3c, 0x18, 0x42, 0xca,
// setb
0x62, 0xdc, 0x7f, 0x08, 0x42, 0xc7,
0x62, 0xdc, 0x7f, 0x18, 0x42, 0xc7,
0x62, 0xd4, 0x7f, 0x18, 0x42, 0xc7,
0x62, 0xdc, 0x7f, 0x08, 0x42, 0x06,
// bswap
0x0f, 0xc8,
0x41, 0x0f, 0xc8,
0xd5, 0x90, 0xc8,
0x48, 0x0f, 0xc9,
0x49, 0x0f, 0xc9,
0xd5, 0x98, 0xc9,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(shift_2op)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
shl(r16b, cl);
shl(r16w, cl);
shl(r16d, cl);
shl(r16, cl);
shl(r16|T_nf, cl);
shl(r16b, 0x3);
shl(r16w, 0x5);
shl(r16d, 0x7);
shl(r16, 0x9);
shl(byte [r30], 0x3);
shl(word [r30], 0x5);
shl(dword [r30], 0x7);
shl(qword [r30], 0x9);
shr(r16b, cl);
shr(r16w, cl);
shr(r16d, cl);
shr(r16, cl);
shr(r16|T_nf, cl);
shr(r16b, 0x3);
shr(r16w, 0x5);
shr(r16d, 0x7);
shr(r16, 0x9);
shr(byte [r30], 0x3);
shr(word [r30], 0x5);
shr(dword [r30], 0x7);
shr(qword [r30], 0x9);
sar(r16b, cl);
sar(r16w, cl);
sar(r16d, cl);
sar(r16, cl);
sar(r16|T_nf, cl);
sar(r16b, 0x3);
sar(r16w, 0x5);
sar(r16d, 0x7);
sar(r16, 0x9);
sar(byte [r30], 0x3);
sar(word [r30], 0x5);
sar(dword [r30], 0x7);
sar(qword [r30], 0x9);
ror(r16b, cl);
ror(r16w, cl);
ror(r16d, cl);
ror(r16, cl);
ror(r16|T_nf, cl);
ror(r16b, 0x3);
ror(r16w, 0x5);
ror(r16d, 0x7);
ror(r16, 0x9);
ror(byte [r30], 0x3);
ror(word [r30], 0x5);
ror(dword [r30], 0x7);
ror(qword [r30], 0x9);
rol(r16b, cl);
rol(r16w, cl);
rol(r16d, cl);
rol(r16, cl);
rol(r16|T_nf, cl);
rol(r16b, 0x3);
rol(r16w, 0x5);
rol(r16d, 0x7);
rol(r16, 0x9);
rol(byte [r30], 0x3);
rol(word [r30], 0x5);
rol(dword [r30], 0x7);
rol(qword [r30], 0x9);
rcl(r16b, cl);
rcl(r16w, cl);
rcl(r16d, cl);
rcl(r16, cl);
rcl(r16b, 0x3);
rcl(r16w, 0x5);
rcl(r16d, 0x7);
rcl(r16, 0x9);
rcl(byte [r30], 0x3);
rcl(word [r30], 0x5);
rcl(dword [r30], 0x7);
rcl(qword [r30], 0x9);
rcr(r16b, cl);
rcr(r16w, cl);
rcr(r16d, cl);
rcr(r16, cl);
rcr(r16b, 0x3);
rcr(r16w, 0x5);
rcr(r16d, 0x7);
rcr(r16, 0x9);
rcr(byte [r30], 0x3);
rcr(word [r30], 0x5);
rcr(dword [r30], 0x7);
rcr(qword [r30], 0x9);
}
} c;
const uint8_t tbl[] = {
// shl
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xe0, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xe0, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xe0, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xe0, 0x62, 0xfc, 0xfc, 0x0c, 0xd3, 0xe0, 0x62, 0xfc,
0x7c, 0x08, 0xc0, 0xe0, 0x03, 0x62, 0xfc, 0x7d, 0x08, 0xc1, 0xe0, 0x05, 0x62, 0xfc, 0x7c, 0x08,
0xc1, 0xe0, 0x07, 0x62, 0xfc, 0xfc, 0x08, 0xc1, 0xe0, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x26,
0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1, 0x26, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x26, 0x07, 0x62,
0xdc, 0xfc, 0x08, 0xc1, 0x26, 0x09,
// shr
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xe8, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xe8, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xe8, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xe8, 0x62, 0xfc, 0xfc, 0x0c, 0xd3, 0xe8, 0x62, 0xfc,
0x7c, 0x08, 0xc0, 0xe8, 0x03, 0x62, 0xfc, 0x7d, 0x08, 0xc1, 0xe8, 0x05, 0x62, 0xfc, 0x7c, 0x08,
0xc1, 0xe8, 0x07, 0x62, 0xfc, 0xfc, 0x08, 0xc1, 0xe8, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x2e,
0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1, 0x2e, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x2e, 0x07, 0x62,
0xdc, 0xfc, 0x08, 0xc1, 0x2e, 0x09,
// sar
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xf8, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xf8, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xf8, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xf8, 0x62, 0xfc, 0xfc, 0x0c, 0xd3, 0xf8, 0x62, 0xfc,
0x7c, 0x08, 0xc0, 0xf8, 0x03, 0x62, 0xfc, 0x7d, 0x08, 0xc1, 0xf8, 0x05, 0x62, 0xfc, 0x7c, 0x08,
0xc1, 0xf8, 0x07, 0x62, 0xfc, 0xfc, 0x08, 0xc1, 0xf8, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x3e,
0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1, 0x3e, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x3e, 0x07, 0x62,
0xdc, 0xfc, 0x08, 0xc1, 0x3e, 0x09,
// ror
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xc8, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xc8, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xc8, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xc8, 0x62, 0xfc, 0xfc, 0x0c, 0xd3, 0xc8, 0x62, 0xfc,
0x7c, 0x08, 0xc0, 0xc8, 0x03, 0x62, 0xfc, 0x7d, 0x08, 0xc1, 0xc8, 0x05, 0x62, 0xfc, 0x7c, 0x08,
0xc1, 0xc8, 0x07, 0x62, 0xfc, 0xfc, 0x08, 0xc1, 0xc8, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x0e,
0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1, 0x0e, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x0e, 0x07, 0x62,
0xdc, 0xfc, 0x08, 0xc1, 0x0e, 0x09,
// rol
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xc0, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xc0, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xc0, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xc0, 0x62, 0xfc, 0xfc, 0x0c, 0xd3, 0xc0, 0x62, 0xfc,
0x7c, 0x08, 0xc0, 0xc0, 0x03, 0x62, 0xfc, 0x7d, 0x08, 0xc1, 0xc0, 0x05, 0x62, 0xfc, 0x7c, 0x08,
0xc1, 0xc0, 0x07, 0x62, 0xfc, 0xfc, 0x08, 0xc1, 0xc0, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x06,
0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1, 0x06, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x06, 0x07, 0x62,
0xdc, 0xfc, 0x08, 0xc1, 0x06, 0x09,
// rcl
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xd0, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xd0, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xd0, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xd0, 0x62, 0xfc, 0x7c, 0x08, 0xc0, 0xd0, 0x03, 0x62,
0xfc, 0x7d, 0x08, 0xc1, 0xd0, 0x05, 0x62, 0xfc, 0x7c, 0x08, 0xc1, 0xd0, 0x07, 0x62, 0xfc, 0xfc,
0x08, 0xc1, 0xd0, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x16, 0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1,
0x16, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x16, 0x07, 0x62, 0xdc, 0xfc, 0x08, 0xc1, 0x16, 0x09,
// rcr
0x62, 0xfc, 0x7c, 0x08, 0xd2, 0xd8, 0x62, 0xfc, 0x7d, 0x08, 0xd3, 0xd8, 0x62, 0xfc, 0x7c, 0x08,
0xd3, 0xd8, 0x62, 0xfc, 0xfc, 0x08, 0xd3, 0xd8, 0x62, 0xfc, 0x7c, 0x08, 0xc0, 0xd8, 0x03, 0x62,
0xfc, 0x7d, 0x08, 0xc1, 0xd8, 0x05, 0x62, 0xfc, 0x7c, 0x08, 0xc1, 0xd8, 0x07, 0x62, 0xfc, 0xfc,
0x08, 0xc1, 0xd8, 0x09, 0x62, 0xdc, 0x7c, 0x08, 0xc0, 0x1e, 0x03, 0x62, 0xdc, 0x7d, 0x08, 0xc1,
0x1e, 0x05, 0x62, 0xdc, 0x7c, 0x08, 0xc1, 0x1e, 0x07, 0x62, 0xdc, 0xfc, 0x08, 0xc1, 0x1e, 0x09,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(shift_3op)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
rcl(r20b, r16b, cl);
rcl(r20w, r16w, cl);
rcl(r20d, r16d, cl);
rcl(r20, r16, cl);
rcl(r20b, ptr [r16], cl);
rcl(r20w, ptr [r16], cl);
rcl(r20d, ptr [r16], cl);
rcl(r20, ptr [r16], cl);
rcl(r20b, r16b, 0x2);
rcl(r20w, r16w, 0x4);
rcl(r20d, r16d, 0x6);
rcl(r20, r16, 0x8);
rcl(r20b, ptr [r16], 0x2);
rcl(r20w, ptr [r16], 0x4);
rcl(r20d, ptr [r16], 0x6);
rcl(r20, ptr [r16], 0x8);
rcr(r20b, r16b, cl);
rcr(r20w, r16w, cl);
rcr(r20d, r16d, cl);
rcr(r20, r16, cl);
rcr(r20b, ptr [r16], cl);
rcr(r20w, ptr [r16], cl);
rcr(r20d, ptr [r16], cl);
rcr(r20, ptr [r16], cl);
rcr(r20b, r16b, 0x2);
rcr(r20w, r16w, 0x4);
rcr(r20d, r16d, 0x6);
rcr(r20, r16, 0x8);
rcr(r20b, ptr [r16], 0x2);
rcr(r20w, ptr [r16], 0x4);
rcr(r20d, ptr [r16], 0x6);
rcr(r20, ptr [r16], 0x8);
rol(r20b, r16b, cl);
rol(r20w, r16w, cl);
rol(r20d, r16d, cl);
rol(r20, r16, cl);
rol(r20b, ptr [r16], cl);
rol(r20w, ptr [r16], cl);
rol(r20d, ptr [r16], cl);
rol(r20, ptr [r16], cl);
rol(r20b, r16b, 0x2);
rol(r20w, r16w, 0x4);
rol(r20d, r16d, 0x6);
rol(r20, r16, 0x8);
rol(r20b, ptr [r16], 0x2);
rol(r20w, ptr [r16], 0x4);
rol(r20d, ptr [r16], 0x6);
rol(r20, ptr [r16], 0x8);
shl(r20b, r16b, cl);
shl(r20w, r16w, cl);
shl(r20d, r16d, cl);
shl(r20, r16, cl);
shl(r20b, ptr [r16], cl);
shl(r20w, ptr [r16], cl);
shl(r20d, ptr [r16], cl);
shl(r20, ptr [r16], cl);
shl(r20b, r16b, 0x2);
shl(r20w, r16w, 0x4);
shl(r20d, r16d, 0x6);
shl(r20, r16, 0x8);
shl(r20b, ptr [r16], 0x2);
shl(r20w, ptr [r16], 0x4);
shl(r20d, ptr [r16], 0x6);
shl(r20, ptr [r16], 0x8);
shr(r20b, r16b, cl);
shr(r20w, r16w, cl);
shr(r20d, r16d, cl);
shr(r20, r16, cl);
shr(r20b, ptr [r16], cl);
shr(r20w, ptr [r16], cl);
shr(r20d, ptr [r16], cl);
shr(r20, ptr [r16], cl);
shr(r20b, r16b, 0x2);
shr(r20w, r16w, 0x4);
shr(r20d, r16d, 0x6);
shr(r20, r16, 0x8);
shr(r20b, ptr [r16], 0x2);
shr(r20w, ptr [r16], 0x4);
shr(r20d, ptr [r16], 0x6);
shr(r20, ptr [r16], 0x8);
sar(r20b, r16b, cl);
sar(r20w, r16w, cl);
sar(r20d, r16d, cl);
sar(r20, r16, cl);
sar(r20b, ptr [r16], cl);
sar(r20w, ptr [r16], cl);
sar(r20d, ptr [r16], cl);
sar(r20, ptr [r16], cl);
sar(r20b, r16b, 0x2);
sar(r20w, r16w, 0x4);
sar(r20d, r16d, 0x6);
sar(r20, r16, 0x8);
sar(r20b, ptr [r16], 0x2);
sar(r20w, ptr [r16], 0x4);
sar(r20d, ptr [r16], 0x6);
sar(r20, ptr [r16], 0x8);
}
} c;
const uint8_t tbl[] = {
// rcl
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0xd0, 0x62, 0xfc, 0x5d, 0x10, 0xd3, 0xd0, 0x62, 0xfc, 0x5c, 0x10,
0xd3, 0xd0, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0xd0, 0x62, 0xfc, 0x5c, 0x10, 0xd2, 0x10, 0x62, 0xfc,
0x5d, 0x10, 0xd3, 0x10, 0x62, 0xfc, 0x5c, 0x10, 0xd3, 0x10, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0x10,
0x62, 0xfc, 0x5c, 0x10, 0xc0, 0xd0, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0xd0, 0x04, 0x62, 0xfc,
0x5c, 0x10, 0xc1, 0xd0, 0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0xd0, 0x08, 0x62, 0xfc, 0x5c, 0x10,
0xc0, 0x10, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0x10, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0x10,
0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0x10, 0x08,
// rcr
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0xd8, 0x62, 0xfc, 0x5d, 0x10, 0xd3, 0xd8, 0x62, 0xfc, 0x5c, 0x10,
0xd3, 0xd8, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0xd8, 0x62, 0xfc, 0x5c, 0x10, 0xd2, 0x18, 0x62, 0xfc,
0x5d, 0x10, 0xd3, 0x18, 0x62, 0xfc, 0x5c, 0x10, 0xd3, 0x18, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0x18,
0x62, 0xfc, 0x5c, 0x10, 0xc0, 0xd8, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0xd8, 0x04, 0x62, 0xfc,
0x5c, 0x10, 0xc1, 0xd8, 0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0xd8, 0x08, 0x62, 0xfc, 0x5c, 0x10,
0xc0, 0x18, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0x18, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0x18,
0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0x18, 0x08,
// rol
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0xc0, 0x62, 0xfc,
0x5d, 0x10, 0xd3, 0xc0, 0x62, 0xfc, 0x5c, 0x10, 0xd3, 0xc0, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0xc0,
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0x00, 0x62, 0xfc, 0x5d, 0x10, 0xd3, 0x00, 0x62, 0xfc, 0x5c, 0x10,
0xd3, 0x00, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0x00, 0x62, 0xfc, 0x5c, 0x10, 0xc0, 0xc0, 0x02, 0x62,
0xfc, 0x5d, 0x10, 0xc1, 0xc0, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0xc0, 0x06, 0x62, 0xfc, 0xdc,
0x10, 0xc1, 0xc0, 0x08, 0x62, 0xfc, 0x5c, 0x10, 0xc0, 0x00, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1,
0x00, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0x00, 0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0x00, 0x08,
// shl
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0xe0, 0x62, 0xfc, 0x5d, 0x10, 0xd3, 0xe0, 0x62, 0xfc, 0x5c, 0x10,
0xd3, 0xe0, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0xe0, 0x62, 0xfc, 0x5c, 0x10, 0xd2, 0x20, 0x62, 0xfc,
0x5d, 0x10, 0xd3, 0x20, 0x62, 0xfc, 0x5c, 0x10, 0xd3, 0x20, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0x20,
0x62, 0xfc, 0x5c, 0x10, 0xc0, 0xe0, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0xe0, 0x04, 0x62, 0xfc,
0x5c, 0x10, 0xc1, 0xe0, 0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0xe0, 0x08, 0x62, 0xfc, 0x5c, 0x10,
0xc0, 0x20, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0x20, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0x20,
0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0x20, 0x08,
// shr
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0xe8, 0x62, 0xfc,
0x5d, 0x10, 0xd3, 0xe8, 0x62, 0xfc, 0x5c, 0x10, 0xd3, 0xe8, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0xe8,
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0x28, 0x62, 0xfc, 0x5d, 0x10, 0xd3, 0x28, 0x62, 0xfc, 0x5c, 0x10,
0xd3, 0x28, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0x28, 0x62, 0xfc, 0x5c, 0x10, 0xc0, 0xe8, 0x02, 0x62,
0xfc, 0x5d, 0x10, 0xc1, 0xe8, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0xe8, 0x06, 0x62, 0xfc, 0xdc,
0x10, 0xc1, 0xe8, 0x08, 0x62, 0xfc, 0x5c, 0x10, 0xc0, 0x28, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1,
0x28, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0x28, 0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0x28, 0x08,
// sar
0x62, 0xfc, 0x5c, 0x10, 0xd2, 0xf8, 0x62, 0xfc, 0x5d, 0x10, 0xd3, 0xf8, 0x62, 0xfc, 0x5c, 0x10,
0xd3, 0xf8, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0xf8, 0x62, 0xfc, 0x5c, 0x10, 0xd2, 0x38, 0x62, 0xfc,
0x5d, 0x10, 0xd3, 0x38, 0x62, 0xfc, 0x5c, 0x10, 0xd3, 0x38, 0x62, 0xfc, 0xdc, 0x10, 0xd3, 0x38,
0x62, 0xfc, 0x5c, 0x10, 0xc0, 0xf8, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0xf8, 0x04, 0x62, 0xfc,
0x5c, 0x10, 0xc1, 0xf8, 0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0xf8, 0x08, 0x62, 0xfc, 0x5c, 0x10,
0xc0, 0x38, 0x02, 0x62, 0xfc, 0x5d, 0x10, 0xc1, 0x38, 0x04, 0x62, 0xfc, 0x5c, 0x10, 0xc1, 0x38,
0x06, 0x62, 0xfc, 0xdc, 0x10, 0xc1, 0x38, 0x08,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(push2_pop2)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
push2(r20, r30);
push2(rax, rcx);
push2p(r20, r30);
push2p(rdx, r8);
pop2(rax, rcx);
pop2(r20, r30);
pop2p(rax, rcx);
pop2p(r20, r30);
}
} c;
const uint8_t tbl[] = {
// push2
0x62, 0xdc, 0x5c, 0x10, 0xff, 0xf6,
0x62, 0xf4, 0x7c, 0x18, 0xff, 0xf1,
// push2p (What is this?)
0x62, 0xdc, 0xdc, 0x10, 0xff, 0xf6,
0x62, 0xd4, 0xec, 0x18, 0xff, 0xf0,
// pop2
0x62, 0xf4, 0x7c, 0x18, 0x8f, 0xc1,
0x62, 0xdc, 0x5c, 0x10, 0x8f, 0xc6,
// pop2p
0x62, 0xf4, 0xfc, 0x18, 0x8f, 0xc1,
0x62, 0xdc, 0xdc, 0x10, 0x8f, 0xc6,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(ccmp)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
ccmpb(rax, rbx, 0);
ccmpb(r30b, r31b, 1);
ccmpb(r30w, r31w, 2);
ccmpb(r30d, r31d, 3);
ccmpb(r30, r31, 4);
ccmpb(ptr [r30], r31b, 5);
ccmpb(ptr [r30], r31w, 6);
ccmpb(ptr [r30], r31d, 7);
ccmpb(ptr [r30], r31, 8);
ccmpb(r31b, ptr [r30], 9);
ccmpb(r31w, ptr [r30], 10);
ccmpb(r31d, ptr [r30], 11);
ccmpb(r31, ptr [r30], 12);
ccmpb(r20b, 0x12, 9);
ccmpb(r20w, 0x1234, 9);
ccmpb(r20d, 0x12345678, 9);
ccmpb(r20, 0x12345678, 9);
ccmpb(byte [r20], 0x12, 9);
ccmpb(word [r20], 0x1234, 9);
ccmpb(dword [r20], 0x12345678, 9);
ccmpb(qword [r20], 0x12345678, 9);
ccmpo(rax, rcx, 0);
ccmpno(rax, rcx, 1);
ccmpb(rax, rcx, 2);
ccmpnb(rax, rcx, 3);
ccmpz(rax, rcx, 4);
ccmpnz(rax, rcx, 5);
ccmpbe(rax, rcx, 6);
ccmpnbe(rax, rcx, 7);
ccmps(rax, rcx, 8);
ccmpns(rax, rcx, 9);
ccmpt(rax, rcx, 10);
ccmpf(rax, rcx, 11);
ccmpl(rax, rcx, 12);
ccmpnl(rax, rcx, 13);
ccmple(rax, rcx, 14);
ccmpnle(rax, rcx, 15);
}
} c;
const uint8_t tbl[] = {
// ccmpb
0x62, 0xf4, 0x84, 0x02, 0x39, 0xd8, 0x62, 0x4c, 0x0c, 0x02, 0x38, 0xfe, 0x62, 0x4c, 0x15, 0x02,
0x39, 0xfe, 0x62, 0x4c, 0x1c, 0x02, 0x39, 0xfe, 0x62, 0x4c, 0xa4, 0x02, 0x39, 0xfe, 0x62, 0x4c,
0x2c, 0x02, 0x38, 0x3e, 0x62, 0x4c, 0x35, 0x02, 0x39, 0x3e, 0x62, 0x4c, 0x3c, 0x02, 0x39, 0x3e,
0x62, 0x4c, 0xc4, 0x02, 0x39, 0x3e, 0x62, 0x4c, 0x4c, 0x02, 0x3a, 0x3e, 0x62, 0x4c, 0x55, 0x02,
0x3b, 0x3e, 0x62, 0x4c, 0x5c, 0x02, 0x3b, 0x3e, 0x62, 0x4c, 0xe4, 0x02, 0x3b, 0x3e,
// ccmpb imm
0x62, 0x7c, 0x4c, 0x02, 0x80, 0xfc, 0x12, 0x62, 0x7c, 0x4d, 0x02, 0x81, 0xfc, 0x34, 0x12, 0x62,
0x7c, 0x4c, 0x02, 0x81, 0xfc, 0x78, 0x56, 0x34, 0x12, 0x62, 0x7c, 0xcc, 0x02, 0x81, 0xfc, 0x78,
0x56, 0x34, 0x12, 0x62, 0x7c, 0x4c, 0x02, 0x80, 0x3c, 0x24, 0x12, 0x62, 0x7c, 0x4d, 0x02, 0x81,
0x3c, 0x24, 0x34, 0x12, 0x62, 0x7c, 0x4c, 0x02, 0x81, 0x3c, 0x24, 0x78, 0x56, 0x34, 0x12, 0x62,
0x7c, 0xcc, 0x02, 0x81, 0x3c, 0x24, 0x78, 0x56, 0x34, 0x12,
// all
0x62, 0xf4, 0x84, 0x00, 0x39, 0xc8, 0x62, 0xf4, 0x8c, 0x01, 0x39, 0xc8, 0x62, 0xf4, 0x94, 0x02,
0x39, 0xc8, 0x62, 0xf4, 0x9c, 0x03, 0x39, 0xc8, 0x62, 0xf4, 0xa4, 0x04, 0x39, 0xc8, 0x62, 0xf4,
0xac, 0x05, 0x39, 0xc8, 0x62, 0xf4, 0xb4, 0x06, 0x39, 0xc8, 0x62, 0xf4, 0xbc, 0x07, 0x39, 0xc8,
0x62, 0xf4, 0xc4, 0x08, 0x39, 0xc8, 0x62, 0xf4, 0xcc, 0x09, 0x39, 0xc8, 0x62, 0xf4, 0xd4, 0x0a,
0x39, 0xc8, 0x62, 0xf4, 0xdc, 0x0b, 0x39, 0xc8, 0x62, 0xf4, 0xe4, 0x0c, 0x39, 0xc8, 0x62, 0xf4,
0xec, 0x0d, 0x39, 0xc8, 0x62, 0xf4, 0xf4, 0x0e, 0x39, 0xc8, 0x62, 0xf4, 0xfc, 0x0f, 0x39, 0xc8,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(ctestb)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
ctestb(r30b, r31b, 0);
ctestb(r30w, r31w, 1);
ctestb(r30d, r31d, 2);
ctestb(r30, r31, 3);
ctestb(ptr [r30], r31b, 4);
ctestb(ptr [r30], r31w, 5);
ctestb(ptr [r30], r31d, 6);
ctestb(ptr [r30], r31, 7);
ctestb(r30b, 0x12, 8);
ctestb(r30w, 0x1234, 9);
ctestb(r30d, 0x12345678, 10);
ctestb(r30, 0x12345678, 11);
ctestb(byte [r30], 0x12, 12);
ctestb(word [r30], 0x1234, 13);
ctestb(dword [r30], 0x12345678, 14);
ctestb(qword [r30], 0x12345678, 15);
// all
ctesto(rax, rcx, 0);
ctestno(rax, rcx, 1);
ctestb(rax, rcx, 2);
ctestnb(rax, rcx, 3);
ctestz(rax, rcx, 4);
ctestnz(rax, rcx, 5);
ctestbe(rax, rcx, 6);
ctestnbe(rax, rcx, 7);
ctests(rax, rcx, 8);
ctestns(rax, rcx, 9);
ctestt(rax, rcx, 10);
ctestf(rax, rcx, 11);
ctestl(rax, rcx, 12);
ctestnl(rax, rcx, 13);
ctestle(rax, rcx, 14);
ctestnle(rax, rcx, 15);
}
} c;
const uint8_t tbl[] = {
// ctestb
0x62, 0x4c, 0x04, 0x02, 0x84, 0xfe, 0x62, 0x4c, 0x0d, 0x02, 0x85, 0xfe, 0x62, 0x4c, 0x14, 0x02,
0x85, 0xfe, 0x62, 0x4c, 0x9c, 0x02, 0x85, 0xfe, 0x62, 0x4c, 0x24, 0x02, 0x84, 0x3e, 0x62, 0x4c,
0x2d, 0x02, 0x85, 0x3e, 0x62, 0x4c, 0x34, 0x02, 0x85, 0x3e, 0x62, 0x4c, 0xbc, 0x02, 0x85, 0x3e,
0x62, 0xdc, 0x44, 0x02, 0xf6, 0xc6, 0x12, 0x62, 0xdc, 0x4d, 0x02, 0xf7, 0xc6, 0x34, 0x12, 0x62,
0xdc, 0x54, 0x02, 0xf7, 0xc6, 0x78, 0x56, 0x34, 0x12, 0x62, 0xdc, 0xdc, 0x02, 0xf7, 0xc6, 0x78,
0x56, 0x34, 0x12, 0x62, 0xdc, 0x64, 0x02, 0xf6, 0x06, 0x12, 0x62, 0xdc, 0x6d, 0x02, 0xf7, 0x06,
0x34, 0x12, 0x62, 0xdc, 0x74, 0x02, 0xf7, 0x06, 0x78, 0x56, 0x34, 0x12, 0x62, 0xdc, 0xfc, 0x02,
0xf7, 0x06, 0x78, 0x56, 0x34, 0x12,
// all
0x62, 0xf4, 0x84, 0x00, 0x85, 0xc8, 0x62, 0xf4, 0x8c, 0x01, 0x85, 0xc8, 0x62, 0xf4, 0x94, 0x02,
0x85, 0xc8, 0x62, 0xf4, 0x9c, 0x03, 0x85, 0xc8, 0x62, 0xf4, 0xa4, 0x04, 0x85, 0xc8, 0x62, 0xf4,
0xac, 0x05, 0x85, 0xc8, 0x62, 0xf4, 0xb4, 0x06, 0x85, 0xc8, 0x62, 0xf4, 0xbc, 0x07, 0x85, 0xc8,
0x62, 0xf4, 0xc4, 0x08, 0x85, 0xc8, 0x62, 0xf4, 0xcc, 0x09, 0x85, 0xc8, 0x62, 0xf4, 0xd4, 0x0a,
0x85, 0xc8, 0x62, 0xf4, 0xdc, 0x0b, 0x85, 0xc8, 0x62, 0xf4, 0xe4, 0x0c, 0x85, 0xc8, 0x62, 0xf4,
0xec, 0x0d, 0x85, 0xc8, 0x62, 0xf4, 0xf4, 0x0e, 0x85, 0xc8, 0x62, 0xf4, 0xfc, 0x0f, 0x85, 0xc8,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(cfcmov)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
cfcmovb(r30w, r31w);
cfcmovb(r30d, r31d);
cfcmovb(r30, r31);
cfcmovb(ptr [r8+r20*4+0x3], r19w);
cfcmovb(ptr [r8+r20*4+0x3], r19d);
cfcmovb(ptr [r8+r20*4+0x3], r19);
cfcmovb(r30w, ptr [r9]);
cfcmovb(r30d, ptr [r9]);
cfcmovb(r30, ptr [r9]);
cfcmovb(r20w, r30w, r31w);
cfcmovb(r20d, r30d, r31d);
cfcmovb(r20, r30, r31);
cfcmovb(r20w, r30w, ptr [r9]);
cfcmovb(r20d, r30d, ptr [r9]);
cfcmovb(r20, r30, ptr [r9]);
// all
cfcmovo(r20, r21, r22);
cfcmovo(r20, r21, ptr [r22]);
cfcmovno(r20, r21, r22);
cfcmovno(r20, r21, ptr [r22]);
cfcmovb(r20, r21, r22);
cfcmovb(r20, r21, ptr [r22]);
cfcmovnb(r20, r21, r22);
cfcmovnb(r20, r21, ptr [r22]);
cfcmovz(r20, r21, r22);
cfcmovz(r20, r21, ptr [r22]);
cfcmovnz(r20, r21, r22);
cfcmovnz(r20, r21, ptr [r22]);
cfcmovbe(r20, r21, r22);
cfcmovbe(r20, r21, ptr [r22]);
cfcmovnbe(r20, r21, r22);
cfcmovnbe(r20, r21, ptr [r22]);
cfcmovs(r20, r21, r22);
cfcmovs(r20, r21, ptr [r22]);
cfcmovns(r20, r21, r22);
cfcmovns(r20, r21, ptr [r22]);
cfcmovp(r20, r21, r22);
cfcmovp(r20, r21, ptr [r22]);
cfcmovnp(r20, r21, r22);
cfcmovnp(r20, r21, ptr [r22]);
cfcmovl(r20, r21, r22);
cfcmovl(r20, r21, ptr [r22]);
cfcmovnl(r20, r21, r22);
cfcmovnl(r20, r21, ptr [r22]);
cfcmovle(r20, r21, r22);
cfcmovle(r20, r21, ptr [r22]);
cfcmovnle(r20, r21, r22);
cfcmovnle(r20, r21, ptr [r22]);
}
} c;
const uint8_t tbl[] = {
0x62, 0x4c, 0x7d, 0x0c, 0x42, 0xfe, 0x62, 0x4c, 0x7c, 0x0c, 0x42, 0xfe, 0x62, 0x4c, 0xfc, 0x0c,
0x42, 0xfe, 0x62, 0xc4, 0x79, 0x0c, 0x42, 0x5c, 0xa0, 0x03, 0x62, 0xc4, 0x78, 0x0c, 0x42, 0x5c,
0xa0, 0x03, 0x62, 0xc4, 0xf8, 0x0c, 0x42, 0x5c, 0xa0, 0x03, 0x62, 0x44, 0x7d, 0x08, 0x42, 0x31,
0x62, 0x44, 0x7c, 0x08, 0x42, 0x31, 0x62, 0x44, 0xfc, 0x08, 0x42, 0x31, 0x62, 0x4c, 0x5d, 0x14,
0x42, 0xf7, 0x62, 0x4c, 0x5c, 0x14, 0x42, 0xf7, 0x62, 0x4c, 0xdc, 0x14, 0x42, 0xf7, 0x62, 0x44,
0x5d, 0x14, 0x42, 0x31, 0x62, 0x44, 0x5c, 0x14, 0x42, 0x31, 0x62, 0x44, 0xdc, 0x14, 0x42, 0x31,
// all
0x62, 0xec, 0xdc, 0x14, 0x40, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x40, 0x2e, 0x62, 0xec, 0xdc, 0x14,
0x41, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x41, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x42, 0xee, 0x62, 0xec,
0xdc, 0x14, 0x42, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x43, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x43, 0x2e,
0x62, 0xec, 0xdc, 0x14, 0x44, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x44, 0x2e, 0x62, 0xec, 0xdc, 0x14,
0x45, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x45, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x46, 0xee, 0x62, 0xec,
0xdc, 0x14, 0x46, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x47, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x47, 0x2e,
0x62, 0xec, 0xdc, 0x14, 0x48, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x48, 0x2e, 0x62, 0xec, 0xdc, 0x14,
0x49, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x49, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x4a, 0xee, 0x62, 0xec,
0xdc, 0x14, 0x4a, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x4b, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x4b, 0x2e,
0x62, 0xec, 0xdc, 0x14, 0x4c, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x4c, 0x2e, 0x62, 0xec, 0xdc, 0x14,
0x4d, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x4d, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x4e, 0xee, 0x62, 0xec,
0xdc, 0x14, 0x4e, 0x2e, 0x62, 0xec, 0xdc, 0x14, 0x4f, 0xee, 0x62, 0xec, 0xdc, 0x14, 0x4f, 0x2e,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(evex_misc)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
vmovaps(xmm31, ptr [r30+r26*8+0x40]);
vaddps(zmm30, zmm21, ptr [r20+r30*1]);
vcvtsd2si(r30d, ptr [r17+r31*4]);
test(ptr[r30], r31);
test(byte[r30], 0x12);
call(r20);
call(ptr[r20]);
}
} c;
const uint8_t tbl[] = {
0x62, 0x09, 0x78, 0x08, 0x28, 0x7c, 0xd6, 0x04,
0x62, 0x29, 0x50, 0x40, 0x58, 0x34, 0x34, 0x62,
0x29, 0x7b, 0x08, 0x2d, 0x34, 0xb9,
0xd5, 0x5d, 0x85, 0x3e,
0xd5, 0x11, 0xf6, 0x06, 0x12,
0xd5, 0x10, 0xff, 0xd4,
0xd5, 0x10, 0xff, 0x14, 0x24,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(kmov)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
kmovb(k1, ptr [r20]);
kmovb(k2, r21d);
kmovb(ptr [r22], k3);
kmovb(r23d, k4);
kmovw(k1, ptr [r20]);
kmovw(k2, r21d);
kmovw(ptr [r22], k3);
kmovw(r23d, k4);
kmovd(k1, ptr [r20]);
kmovd(k2, r21d);
kmovd(ptr [r22], k3);
kmovd(r23d, k4);
kmovq(k1, ptr [r20]);
kmovq(k2, r21);
kmovq(ptr [r22], k3);
kmovq(r23, k4);
}
} c;
const uint8_t tbl[] = {
0x62, 0xf9, 0x7d, 0x08, 0x90, 0x0c, 0x24, 0x62, 0xf9, 0x7d, 0x08, 0x92, 0xd5, 0x62, 0xf9, 0x7d,
0x08, 0x91, 0x1e, 0x62, 0xe1, 0x7d, 0x08, 0x93, 0xfc, 0x62, 0xf9, 0x7c, 0x08, 0x90, 0x0c, 0x24,
0x62, 0xf9, 0x7c, 0x08, 0x92, 0xd5, 0x62, 0xf9, 0x7c, 0x08, 0x91, 0x1e, 0x62, 0xe1, 0x7c, 0x08,
0x93, 0xfc, 0x62, 0xf9, 0xfd, 0x08, 0x90, 0x0c, 0x24, 0x62, 0xf9, 0x7f, 0x08, 0x92, 0xd5, 0x62,
0xf9, 0xfd, 0x08, 0x91, 0x1e, 0x62, 0xe1, 0x7f, 0x08, 0x93, 0xfc, 0x62, 0xf9, 0xfc, 0x08, 0x90,
0x0c, 0x24, 0x62, 0xf9, 0xff, 0x08, 0x92, 0xd5, 0x62, 0xf9, 0xfc, 0x08, 0x91, 0x1e, 0x62, 0xe1,
0xff, 0x08, 0x93, 0xfc,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(amx)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
ldtilecfg(ptr [r30+r29*4+0x12]);
sttilecfg(ptr [r30+r29*4+0x12]);
tileloadd(tmm1, ptr [r30+r29*4+0x12]);
tileloaddt1(tmm3, ptr [r30+r29*4+0x12]);
tilestored(ptr [r30+r29*4+0x12], tmm5);
}
} c;
const uint8_t tbl[] = {
0x62, 0x9a, 0x78, 0x08, 0x49, 0x44, 0xae, 0x12, 0x62, 0x9a, 0x79, 0x08, 0x49, 0x44, 0xae, 0x12,
0x62, 0x9a, 0x7b, 0x08, 0x4b, 0x4c, 0xae, 0x12, 0x62, 0x9a, 0x79, 0x08, 0x4b, 0x5c, 0xae, 0x12,
0x62, 0x9a, 0x7a, 0x08, 0x4b, 0x6c, 0xae, 0x12,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(aeskl)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
aesdec128kl(xmm15, ptr[rax+rcx*4+0x12]);
aesdec128kl(xmm15, ptr[r30+r29*8+0x34]);
aesdec256kl(xmm15, ptr[rax+rcx*4+0x12]);
aesdec256kl(xmm15, ptr[r30+r29*8+0x34]);
aesdecwide128kl(ptr[rax+rcx*4+0x12]);
aesdecwide128kl(ptr[r30+r29*8+0x34]);
aesdecwide256kl(ptr[rax+rcx*4+0x12]);
aesdecwide256kl(ptr[r30+r29*8+0x34]);
aesenc128kl(xmm15, ptr[rax+rcx*4+0x12]);
aesenc128kl(xmm15, ptr[r30+r29*8+0x34]);
aesenc256kl(xmm15, ptr[rax+rcx*4+0x12]);
aesenc256kl(xmm15, ptr[r30+r29*8+0x34]);
aesencwide128kl(ptr[rax+rcx*4+0x12]);
aesencwide128kl(ptr[r30+r29*8+0x34]);
aesencwide256kl(ptr[rax+rcx*4+0x12]);
aesencwide256kl(ptr[r30+r29*8+0x34]);
}
} c;
const uint8_t tbl[] = {
// aesdec128kl
0xf3, 0x44, 0x0f, 0x38, 0xdd, 0x7c, 0x88, 0x12,
0x62, 0x1c, 0x7a, 0x08, 0xdd, 0x7c, 0xee, 0x34,
// aesdec256kl
0xf3, 0x44, 0x0f, 0x38, 0xdf, 0x7c, 0x88, 0x12,
0x62, 0x1c, 0x7a, 0x08, 0xdf, 0x7c, 0xee, 0x34,
// aesdecwide128kl
0xf3, 0x0f, 0x38, 0xd8, 0x4c, 0x88, 0x12,
0x62, 0x9c, 0x7a, 0x08, 0xd8, 0x4c, 0xee, 0x34, 0xf3,
// aesdecwide256kl
0x0f, 0x38, 0xd8, 0x5c, 0x88, 0x12,
0x62, 0x9c, 0x7a, 0x08, 0xd8, 0x5c, 0xee, 0x34,
// aesenc128kl
0xf3, 0x44, 0x0f, 0x38, 0xdc, 0x7c, 0x88, 0x12,
0x62, 0x1c, 0x7a, 0x08, 0xdc, 0x7c, 0xee, 0x34,
// aesenc256kl
0xf3, 0x44, 0x0f, 0x38, 0xde, 0x7c, 0x88, 0x12,
0x62, 0x1c, 0x7a, 0x08, 0xde, 0x7c, 0xee, 0x34,
// aesencwide128kl
0xf3, 0x0f, 0x38, 0xd8, 0x44, 0x88, 0x12,
0x62, 0x9c, 0x7a, 0x08, 0xd8, 0x44, 0xee, 0x34,
// aesencwide256kl
0xf3, 0x0f, 0x38, 0xd8, 0x54, 0x88, 0x12,
0x62, 0x9c, 0x7a, 0x08, 0xd8, 0x54, 0xee, 0x34,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(encodekey)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
encodekey128(eax, ebx);
encodekey128(eax, r8d);
encodekey128(r8d, ebx);
encodekey128(r30d, r29d);
encodekey256(eax, ebx);
encodekey256(eax, r8d);
encodekey256(r8d, ebx);
encodekey256(r30d, r29d);
}
} c;
const uint8_t tbl[] = {
// encodekey128
0xf3, 0x0f, 0x38, 0xfa, 0xc3,
0x62, 0xd4, 0x7e, 0x08, 0xda, 0xc0,
0x62, 0x74, 0x7e, 0x08, 0xda, 0xc3,
0x62, 0x4c, 0x7e, 0x08, 0xda, 0xf5,
// encodekey256
0xf3, 0x0f, 0x38, 0xfb, 0xc3,
0x62, 0xd4, 0x7e, 0x08, 0xdb, 0xc0,
0x62, 0x74, 0x7e, 0x08, 0xdb, 0xc3,
0x62, 0x4c, 0x7e, 0x08, 0xdb, 0xf5,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(sha)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
sha1msg1(xmm15, ptr [r30+r29*8+0x12]);
sha1msg2(xmm15, ptr [r30+r29*8+0x12]);
sha1nexte(xmm15, ptr [r30+r29*8+0x12]);
sha256msg1(xmm15, ptr [r30+r29*8+0x12]);
sha256msg2(xmm15, ptr [r30+r29*8+0x12]);
sha256rnds2(xmm15, ptr [r30+r29*8+0x12]);
sha1rnds4(xmm15, ptr [r30+r29*8+0x12], 0x23);
}
} c;
const uint8_t tbl[] = {
0x62, 0x1c, 0x78, 0x08, 0xd9, 0x7c, 0xee, 0x12,
0x62, 0x1c, 0x78, 0x08, 0xda, 0x7c, 0xee, 0x12,
0x62, 0x1c, 0x78, 0x08, 0xd8, 0x7c, 0xee, 0x12,
0x62, 0x1c, 0x78, 0x08, 0xdc, 0x7c, 0xee, 0x12,
0x62, 0x1c, 0x78, 0x08, 0xdd, 0x7c, 0xee, 0x12,
0x62, 0x1c, 0x78, 0x08, 0xdb, 0x7c, 0xee, 0x12,
0x62, 0x1c, 0x78, 0x08, 0xd4, 0x7c, 0xee, 0x12, 0x23,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(0x0f_rex2)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
addps(xmm3, ptr [r30+r20*4+0x4]);
movups(xmm5, ptr [r16]);
movq(r31, xmm5);
cvtsd2si(r20, ptr [r30]);
bsr(r20, r30);
}
} c;
const uint8_t tbl[] = {
0xd5, 0xb1, 0x58, 0x5c, 0xa6, 0x04,
0xd5, 0x90, 0x10, 0x28, 0x66,
0xd5, 0x99, 0x7e, 0xef, 0xf2,
0xd5, 0xd9, 0x2d, 0x26,
0xd5, 0xd9, 0xbd, 0xe6,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
CYBOZU_TEST_AUTO(rao_int)
{
struct Code : Xbyak::CodeGenerator {
Code()
{
aadd(ptr [r16+r31*1], r17d);
aadd(ptr [r16+r31*1], r17);
aand(ptr [r16+r31*1], r17d);
aand(ptr [r16+r31*1], r17);
aor(ptr [r16+r31*1], r17d);
aor(ptr [r16+r31*1], r17);
axor(ptr [r16+r31*1], r17d);
axor(ptr [r16+r31*1], r17);
}
} c;
const uint8_t tbl[] = {
0x62, 0xac, 0x78, 0x08, 0xfc, 0x0c, 0x38, 0x62, 0xac, 0xf8, 0x08, 0xfc, 0x0c, 0x38, 0x62, 0xac,
0x79, 0x08, 0xfc, 0x0c, 0x38, 0x62, 0xac, 0xf9, 0x08, 0xfc, 0x0c, 0x38, 0x62, 0xac, 0x7b, 0x08,
0xfc, 0x0c, 0x38, 0x62, 0xac, 0xfb, 0x08, 0xfc, 0x0c, 0x38, 0x62, 0xac, 0x7a, 0x08, 0xfc, 0x0c,
0x38, 0x62, 0xac, 0xfa, 0x08, 0xfc, 0x0c, 0x38,
};
const size_t n = sizeof(tbl);
CYBOZU_TEST_EQUAL(c.getSize(), n);
CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
}
Reference in a new issue View git blame Copy permalink