early-access version 1255

externals/xbyak/test/Makefile

@@ -0,0 +1,104 @@
+TARGET = make_nm normalize_prefix bad_address misc cvt_test cvt_test32 noexception
+XBYAK_INC=../xbyak/xbyak.h
+UNAME_S=$(shell uname -s)
+BIT=32
+ifeq ($(shell uname -m),x86_64)
+BIT=64
+endif
+ONLY_64BIT=0
+ifeq ($(UNAME_S),Darwin)
+  # 32-bit binary is not supported
+  ONLY_64BIT=1
+endif
+ifeq ($(ONLY_64BIT),0)
+  TARGET += jmp address
+endif
+
+ifeq ($(BIT),64)
+	TARGET += jmp64 address64
+endif
+
+all: $(TARGET)
+
+CFLAGS_WARN=-Wall -Wextra -Wformat=2 -Wcast-qual -Wcast-align -Wwrite-strings -Wfloat-equal -Wpointer-arith
+
+CFLAGS=-O2 -fomit-frame-pointer -Wall -fno-operator-names -I../ -I./ $(CFLAGS_WARN) #-std=c++0x
+make_nm:
+	$(CXX) $(CFLAGS) make_nm.cpp -o $@
+normalize_prefix: normalize_prefix.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) normalize_prefix.cpp -o $@
+test_mmx: test_mmx.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) test_mmx.cpp -o $@ -lpthread
+jmp: jmp.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) jmp.cpp -o $@ -m32
+jmp64: jmp.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) jmp.cpp -o $@ -m64
+address: address.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) address.cpp -o $@ -m32
+address64: address.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) address.cpp -o $@ -m64
+bad_address: bad_address.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) bad_address.cpp -o $@
+misc: misc.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) misc.cpp -o $@
+cvt_test: cvt_test.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) $< -o $@
+cvt_test32: cvt_test.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) $< -o $@ -DXBYAK32
+noexception: noexception.cpp ../xbyak/xbyak.h
+	$(CXX) $(CFLAGS) $< -o $@ -fno-exceptions
+
+test_nm: normalize_prefix $(TARGET)
+	$(MAKE) -C ../gen
+ifneq ($(ONLY_64BIT),1)
+	./test_nm.sh
+	./test_nm.sh noexcept
+	./noexception
+	./test_nm.sh Y
+	./test_nm.sh avx512
+	./test_address.sh
+	./jmp
+	./cvt_test32
+endif
+	./bad_address
+	./misc
+	./cvt_test
+ifeq ($(BIT),64)
+	./test_address.sh 64
+	./test_nm.sh 64
+	./test_nm.sh Y64
+	./jmp64
+endif
+
+test_avx: normalize_prefix
+ifneq ($(ONLY_64BIT),0)
+	./test_avx.sh
+	./test_avx.sh Y
+endif
+ifeq ($(BIT),64)
+	./test_address.sh 64
+	./test_avx.sh 64
+	./test_avx.sh Y64
+endif
+
+test_avx512: normalize_prefix
+ifneq ($(ONLY_64BIT),0)
+	./test_avx512.sh
+endif
+ifeq ($(BIT),64)
+	./test_avx512.sh 64
+endif
+
+test:
+	$(MAKE) test_nm
+	$(MAKE) test_avx
+	$(MAKE) test_avx512
+
+clean:
+	rm -rf *.o $(TARGET) lib_run nm.cpp nm_frame make_512
+
+lib_run: lib_test.cpp lib_run.cpp lib.h
+	$(CXX) $(CFLAGS) lib_run.cpp lib_test.cpp -o lib_run
+make_nm: make_nm.cpp $(XBYAK_INC)
+
+

externals/xbyak/test/Makefile.win

@@ -0,0 +1,14 @@
+OPT=/EHsc -I../xbyak /W4 -D_CRT_SECURE_NO_WARNINGS
+../xbyak/xbyak_mnemonic.h: ../gen/gen_code.exe ../gen/gen_avx512.exe
+	../gen/gen_code.exe > $@
+	../gen/gen_avx512.exe >> $@
+
+../gen/gen_code.exe: ../gen/gen_code.cpp #../xbyak/xbyak.h
+	cl ../gen/gen_code.cpp $(OPT) /Fe:../gen/gen_code.exe
+
+../gen/gen_avx512.exe: ../gen/gen_avx512.cpp #../xbyak/xbyak.h
+	cl ../gen/gen_avx512.cpp $(OPT) /Fe:../gen/gen_avx512.exe
+
+SUB_HEADER=../xbyak/xbyak_mnemonic.h
+
+all: $(SUB_HEADER)

externals/xbyak/test/a.bat

@@ -0,0 +1,9 @@
+@echo off
+echo 32bit
+rm -rf a.lst b.lst
+echo nasm
+nasm -l a.lst -f win32 -DWIN32 test.asm
+cat a.lst
+echo yasm
+yasm -l b.lst -f win32 -DWIN32 test.asm
+cat b.lst

externals/xbyak/test/address.cpp

@@ -0,0 +1,155 @@
+#include <stdio.h>
+#include <string.h>
+
+#define NUM_OF_ARRAY(x) (sizeof(x) / sizeof(x[0]))
+
+void genVsibSub(bool isJIT, const char *name, const char *tbl[], size_t tblSize)
+{
+	for (size_t i = 0; i < tblSize; i++) {
+		if (isJIT) {
+			printf("%s (ymm7, ptr[", name);
+		} else {
+			printf("%s ymm7, [", name);
+		}
+		printf("%s", tbl[i]);
+		if (isJIT) {
+			printf("], ymm4); dump();\n");
+		} else {
+			printf("], ymm4\n");
+		}
+	}
+}
+void genVsib(bool isJIT)
+{
+	if (isJIT) puts("void genVsib() {");
+	const char *vm32xTbl[] = {
+		"xmm0",
+		"xmm0 * 1",
+		"xmm0 + 4",
+		"xmm0 + eax",
+		"xmm0 * 4 + ecx",
+		"xmm3 * 8 + edi + 123",
+		"xmm2 * 2 + 5",
+		"eax + xmm0",
+		"esp + xmm4",
+	};
+	const char *vm32yTbl[] = {
+		"ymm0",
+		"ymm0 * 1",
+		"ymm0 + 4",
+		"ymm0 + eax",
+		"ymm0 * 4 + ecx",
+		"ymm3 * 8 + edi + 123",
+		"ymm2 * 2 + 5",
+		"eax + ymm0",
+		"esp + ymm4",
+	};
+	genVsibSub(isJIT, "vgatherdpd", vm32xTbl, NUM_OF_ARRAY(vm32xTbl));
+	genVsibSub(isJIT, "vgatherqpd", vm32yTbl, NUM_OF_ARRAY(vm32yTbl));
+#ifdef XBYAK64
+	const char *vm32x64Tbl[] = {
+		"xmm0 + r11",
+		"r13 + xmm15",
+		"123 + rsi + xmm2 * 4",
+	};
+	genVsibSub(isJIT, "vgatherdpd", vm32x64Tbl, NUM_OF_ARRAY(vm32x64Tbl));
+#endif
+	if (isJIT) puts("}");
+}
+
+void genAddress(bool isJIT, const char regTbl[][5], size_t regTblNum)
+{
+	int count = 0;
+	int funcNum = 1;
+	if (isJIT) {
+		puts("void gen0(){");
+	}
+	for (size_t i = 0; i < regTblNum + 1; i++) {
+		const char *base = regTbl[i];
+		for (size_t j = 0; j < regTblNum + 1; j++) {
+			if (j == 4) continue; /* esp is not index register */
+			const char *index = regTbl[j];
+			static const int scaleTbl[] = { 0, 1, 2, 4, 8 };
+			for (size_t k = 0; k < NUM_OF_ARRAY(scaleTbl); k++) {
+				int scale = scaleTbl[k];
+				static const int dispTbl[] = { 0, 1, 1000, -1, -1000 };
+				for (size_t m = 0; m < NUM_OF_ARRAY(dispTbl); m++) {
+					int disp = dispTbl[m];
+					bool isFirst = true;
+					if (isJIT) {
+						printf("mov (ecx, ptr[");
+					} else {
+						printf("mov ecx, [");
+					}
+					if (i < regTblNum) {
+						printf("%s", base);
+						isFirst = false;
+					}
+					if (j < regTblNum) {
+						if (!isFirst) putchar('+');
+						printf("%s", index);
+						if (scale) printf("*%d", scale);
+						isFirst = false;
+					}
+					if (isFirst) {
+						if (isJIT) printf("(void*)");
+						printf("0x%08X", disp);
+					} else {
+						if (disp >= 0) {
+							putchar('+');
+						}
+						printf("%d", disp);
+						isFirst = false;
+					}
+					if (isJIT) {
+						printf("]); dump();\n");
+					} else {
+						printf("]\n");
+					}
+					if (isJIT) {
+						count++;
+						if ((count % 100) == 0) {
+							printf("}\n    void gen%d(){\n", funcNum++);
+						}
+					}
+				}
+			}
+		}
+	}
+	if (isJIT) puts("}");
+	genVsib(isJIT);
+	if (isJIT) {
+		printf("void gen(){\n");
+		for (int i = 0; i < funcNum; i++) {
+			printf("   gen%d();\n", i);
+		}
+		puts("genVsib();");
+		printf("}\n");
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	argc--, argv++;
+	bool phase = argc > 0 && strcmp(*argv, "1") == 0;
+	bool isJIT = (argc > 1);
+	fprintf(stderr, "phase:%c %s\n", phase ? '1' : '2', isJIT ? "jit" : "asm");
+	if (phase) {
+		fprintf(stderr, "32bit reg\n");
+		static const char reg32Tbl[][5] = {
+			"eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
+#ifdef XBYAK64
+			"r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d",
+#endif
+		};
+		genAddress(isJIT, reg32Tbl, NUM_OF_ARRAY(reg32Tbl));
+	} else {
+#ifdef XBYAK64
+		fprintf(stderr, "64bit reg\n");
+		static const char reg64Tbl[][5] = {
+			"rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+		};
+		genAddress(isJIT, reg64Tbl, NUM_OF_ARRAY(reg64Tbl));
+#endif
+	}
+}

externals/xbyak/test/bad_address.cpp

@@ -0,0 +1,28 @@
+#include <xbyak/xbyak.h>
+#include <cybozu/test.hpp>
+
+struct Code : Xbyak::CodeGenerator {
+	Code()
+	{
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [esp + esp]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [ax]), std::exception); // not support
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [esp * 4]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [eax * 16]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [eax + eax + eax]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [eax * 2 + ecx * 4]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [eax * 2 + ecx * 4]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [xmm0]), std::exception);
+		CYBOZU_TEST_EXCEPTION(fld(dword [xmm0]), std::exception);
+		CYBOZU_TEST_EXCEPTION(vgatherdpd(xmm0, ptr [eax * 2], ymm3), std::exception);
+		CYBOZU_TEST_EXCEPTION(vgatherdpd(xmm0, ptr [xmm0 + xmm1], ymm3), std::exception);
+#ifdef XBYAK64
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [rax + eax]), std::exception);
+		CYBOZU_TEST_EXCEPTION(mov(eax, ptr [xmm0 + ymm0]), std::exception);
+#endif
+	}
+};
+
+CYBOZU_TEST_AUTO(exception)
+{
+	Code c;
+}

externals/xbyak/test/cvt_test.cpp

@@ -0,0 +1,151 @@
+#define XBYAK_NO_OP_NAMES
+#include <xbyak/xbyak.h>
+#include <cybozu/inttype.hpp>
+#include <cybozu/test.hpp>
+
+using namespace Xbyak;
+using namespace Xbyak::util;
+
+#ifdef XBYAK64
+const struct Ptn {
+	const Reg8 *reg8;
+	Reg16 reg16;
+	Reg32 reg32;
+	Reg64 reg64;
+} tbl[] = {
+	{ &al, ax, eax, rax },
+	{ &bl, bx, ebx, rbx },
+	{ &cl, cx, ecx, rcx },
+	{ &dl, dx, edx, rdx },
+	{ &sil, si, esi, rsi },
+	{ &dil, di, edi, rdi },
+	{ &bpl, bp, ebp, rbp },
+	{ &spl, sp, esp, rsp },
+	{ &r8b, r8w, r8d, r8 },
+	{ &r9b, r9w, r9d, r9 },
+	{ &r10b, r10w, r10d, r10 },
+	{ &r11b, r11w, r11d, r11 },
+	{ &r12b, r12w, r12d, r12 },
+	{ &r13b, r13w, r13d, r13 },
+	{ &r14b, r14w, r14d, r14 },
+	{ &r15b, r15w, r15d, r15 },
+};
+#else
+const struct Ptn {
+	const Reg8 *reg8;
+	Reg16 reg16;
+	Reg32 reg32;
+} tbl[] = {
+	{ &al, ax, eax },
+	{ &bl, bx, ebx },
+	{ &cl, cx, ecx },
+	{ &dl, dx, edx },
+	{ 0, si, esi },
+	{ 0, di, edi },
+	{ 0, bp, ebp },
+	{ 0, sp, esp },
+};
+#endif
+
+CYBOZU_TEST_AUTO(cvt)
+{
+	for (size_t i = 0; i < sizeof(tbl) / sizeof(tbl[0]); i++) {
+		if (tbl[i].reg8) {
+			CYBOZU_TEST_ASSERT(tbl[i].reg8->cvt8() == *tbl[i].reg8);
+			CYBOZU_TEST_ASSERT(tbl[i].reg8->cvt16() == tbl[i].reg16);
+			CYBOZU_TEST_ASSERT(tbl[i].reg8->cvt32() == tbl[i].reg32);
+			CYBOZU_TEST_ASSERT(tbl[i].reg16.cvt8() == *tbl[i].reg8);
+			CYBOZU_TEST_ASSERT(tbl[i].reg32.cvt8() == *tbl[i].reg8);
+		}
+		CYBOZU_TEST_ASSERT(tbl[i].reg16.cvt16() == tbl[i].reg16);
+		CYBOZU_TEST_ASSERT(tbl[i].reg16.cvt32() == tbl[i].reg32);
+		CYBOZU_TEST_ASSERT(tbl[i].reg32.cvt16() == tbl[i].reg16);
+		CYBOZU_TEST_ASSERT(tbl[i].reg32.cvt32() == tbl[i].reg32);
+#ifdef XBYAK64
+		if (tbl[i].reg8) {
+			CYBOZU_TEST_ASSERT(tbl[i].reg64.cvt8() == *tbl[i].reg8);
+			CYBOZU_TEST_ASSERT(tbl[i].reg8->cvt64() == tbl[i].reg64);
+		}
+		CYBOZU_TEST_ASSERT(tbl[i].reg64.cvt16() == tbl[i].reg16);
+		CYBOZU_TEST_ASSERT(tbl[i].reg64.cvt32() == tbl[i].reg32);
+		CYBOZU_TEST_ASSERT(tbl[i].reg64.cvt64() == tbl[i].reg64);
+		CYBOZU_TEST_ASSERT(tbl[i].reg16.cvt64() == tbl[i].reg64);
+		CYBOZU_TEST_ASSERT(tbl[i].reg32.cvt64() == tbl[i].reg64);
+#endif
+	}
+	{
+		const Reg8 errTbl[] = {
+			ah, bh, ch, dh
+		};
+		for (size_t i = 0; i < sizeof(errTbl) / sizeof(errTbl[0]); i++) {
+			CYBOZU_TEST_EXCEPTION(errTbl[i].cvt16(), std::exception);
+		}
+	}
+#ifdef XBYAK32
+	{
+		const Reg16 errTbl[] = {
+			si, di, bp, sp
+		};
+		for (size_t i = 0; i < sizeof(errTbl) / sizeof(errTbl[0]); i++) {
+			CYBOZU_TEST_EXCEPTION(errTbl[i].cvt8(), std::exception);
+		}
+	}
+#endif
+}
+
+CYBOZU_TEST_AUTO(changeBit)
+{
+	using namespace Xbyak::util;
+#ifdef XBYAK64
+	const size_t N = 7;
+	const Reg* tbl[][N] = {
+		{ &al, &ax, &eax, &rax, &xmm0, &ymm0, &zmm0 },
+		{ &cl, &cx, &ecx, &rcx, &xmm1, &ymm1, &zmm1 },
+		{ &dl, &dx, &edx, &rdx, &xmm2, &ymm2, &zmm2 },
+		{ &bl, &bx, &ebx, &rbx, &xmm3, &ymm3, &zmm3 },
+		{ &spl, &sp, &esp, &rsp, &xmm4, &ymm4, &zmm4 },
+		{ &bpl, &bp, &ebp, &rbp, &xmm5, &ymm5, &zmm5 },
+		{ &sil, &si, &esi, &rsi, &xmm6, &ymm6, &zmm6 },
+		{ &dil, &di, &edi, &rdi, &xmm7, &ymm7, &zmm7 },
+		{ &r8b, &r8w, &r8d, &r8, &xmm8, &ymm8, &zmm8 },
+		{ &r15b, &r15w, &r15d, &r15, &xmm15, &ymm15, &zmm15 },
+		{ 0, 0, 0, 0, &xmm16, &ymm16, &zmm16 },
+		{ 0, 0, 0, 0, &xmm31, &ymm31, &zmm31 },
+	};
+	const int bitTbl[N] = { 8, 16, 32, 64, 128, 256, 512 };
+#else
+	const size_t N = 6;
+	const Reg* tbl[][N] = {
+		{ &al, &ax, &eax, &xmm0, &ymm0, &zmm0 },
+		{ &cl, &cx, &ecx, &xmm1, &ymm1, &zmm1 },
+		{ &dl, &dx, &edx, &xmm2, &ymm2, &zmm2 },
+		{ &bl, &bx, &ebx, &xmm3, &ymm3, &zmm3 },
+		{ 0, &sp, &esp, &xmm4, &ymm4, &zmm4 },
+		{ 0, &bp, &ebp, &xmm5, &ymm5, &zmm5 },
+		{ 0, &si, &esi, &xmm6, &ymm6, &zmm6 },
+		{ 0, &di, &edi,  &xmm7, &ymm7, &zmm7 },
+	};
+	const int bitTbl[N] = { 8, 16, 32, 128, 256, 512 };
+#endif
+
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+		for (size_t j = 0; j < N; j++) {
+			const Reg *r1 = tbl[i][j];
+			if (r1 == 0) continue;
+			for (size_t k = 0; k < N; k++) {
+				if (tbl[i][k]) {
+					CYBOZU_TEST_ASSERT(*tbl[i][k] == r1->changeBit(bitTbl[k]));
+// printf("%s->changeBit(%d)=%s %s\n", r1->toString(), bitTbl[k], r1->changeBit(bitTbl[k]).toString(), tbl[i][k]->toString());
+				} else {
+					CYBOZU_TEST_EXCEPTION(r1->changeBit(bitTbl[k]), std::exception);
+				}
+			}
+		}
+	}
+#ifdef XBYAK64
+	const Reg8 *special8bitTbl[] = { &ah, &bh, &ch, &dh };
+	for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(special8bitTbl); i++) {
+		CYBOZU_TEST_EXCEPTION(special8bitTbl[i]->changeBit(16), std::exception);
+	}
+#endif
+}

externals/xbyak/test/cybozu/inttype.hpp

@@ -0,0 +1,163 @@
+#pragma once
+/**
+	@file
+	@brief int type definition and macros
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#if defined(_MSC_VER) && (MSC_VER <= 1500) && !defined(CYBOZU_DEFINED_INTXX)
+	#define CYBOZU_DEFINED_INTXX
+	typedef __int64 int64_t;
+	typedef unsigned __int64 uint64_t;
+	typedef unsigned int uint32_t;
+	typedef int int32_t;
+	typedef unsigned short uint16_t;
+	typedef short int16_t;
+	typedef unsigned char uint8_t;
+	typedef signed char int8_t;
+#else
+	#include <stdint.h>
+#endif
+
+#ifdef _MSC_VER
+	#ifndef CYBOZU_DEFINED_SSIZE_T
+		#define CYBOZU_DEFINED_SSIZE_T
+		#ifdef _WIN64
+			typedef int64_t ssize_t;
+		#else
+			typedef int32_t ssize_t;
+		#endif
+	#endif
+#else
+	#include <unistd.h> // for ssize_t
+#endif
+
+#ifndef CYBOZU_ALIGN
+	#ifdef _MSC_VER
+		#define CYBOZU_ALIGN(x) __declspec(align(x))
+	#else
+		#define CYBOZU_ALIGN(x) __attribute__((aligned(x)))
+	#endif
+#endif
+#ifndef CYBOZU_FORCE_INLINE
+	#ifdef _MSC_VER
+		#define CYBOZU_FORCE_INLINE __forceinline
+	#else
+		#define CYBOZU_FORCE_INLINE __attribute__((always_inline))
+	#endif
+#endif
+#ifndef CYBOZU_UNUSED
+	#ifdef __GNUC__
+		#define CYBOZU_UNUSED __attribute__((unused))
+	#else
+		#define CYBOZU_UNUSED
+	#endif
+#endif
+#ifndef CYBOZU_ALLOCA
+	#ifdef _MSC_VER
+		#include <malloc.h>
+		#define CYBOZU_ALLOCA(x) _malloca(x)
+	#else
+		#define CYBOZU_ALLOCA(x) __builtin_alloca(x)
+	#endif
+#endif
+#ifndef CYBOZU_NUM_OF_ARRAY
+	#define CYBOZU_NUM_OF_ARRAY(x) (sizeof(x) / sizeof(*x))
+#endif
+#ifndef CYBOZU_SNPRINTF
+	#if defined(_MSC_VER) && (_MSC_VER < 1900)
+		#define CYBOZU_SNPRINTF(x, len, ...) (void)_snprintf_s(x, len, len - 1, __VA_ARGS__)
+	#else
+		#define CYBOZU_SNPRINTF(x, len, ...) (void)snprintf(x, len, __VA_ARGS__)
+	#endif
+#endif
+
+#define CYBOZU_CPP_VERSION_CPP03 0
+#define CYBOZU_CPP_VERSION_TR1 1
+#define CYBOZU_CPP_VERSION_CPP11 2
+#define CYBOZU_CPP_VERSION_CPP14 3
+#define CYBOZU_CPP_VERSION_CPP17 4
+
+#ifdef __GNUC__
+	#define CYBOZU_GNUC_PREREQ(major, minor) ((__GNUC__) * 100 + (__GNUC_MINOR__) >= (major) * 100 + (minor))
+#else
+	#define CYBOZU_GNUC_PREREQ(major, minor) 0
+#endif
+
+#if (__cplusplus >= 201703)
+	#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_CPP17
+#elif (__cplusplus >= 201402)
+	#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_CPP14
+#elif (__cplusplus >= 201103) || (_MSC_VER >= 1500) || defined(__GXX_EXPERIMENTAL_CXX0X__)
+	#if defined(_MSC_VER) && (_MSC_VER <= 1600)
+		#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_TR1
+	#else
+		#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_CPP11
+	#endif
+#elif CYBOZU_GNUC_PREREQ(4, 5) || (CYBOZU_GNUC_PREREQ(4, 2) && __GLIBCXX__ >= 20070719) || defined(__INTEL_COMPILER) || (__clang_major__ >= 3)
+	#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_TR1
+#else
+	#define CYBOZU_CPP_VERSION CYBOZU_CPP_VERSION_CPP03
+#endif
+
+#ifdef CYBOZU_USE_BOOST
+	#define CYBOZU_NAMESPACE_STD boost
+	#define CYBOZU_NAMESPACE_TR1_BEGIN
+	#define CYBOZU_NAMESPACE_TR1_END
+#elif (CYBOZU_CPP_VERSION == CYBOZU_CPP_VERSION_TR1) && !defined(__APPLE__)
+	#define CYBOZU_NAMESPACE_STD std::tr1
+	#define CYBOZU_NAMESPACE_TR1_BEGIN namespace tr1 {
+	#define CYBOZU_NAMESPACE_TR1_END }
+#else
+	#define CYBOZU_NAMESPACE_STD std
+	#define CYBOZU_NAMESPACE_TR1_BEGIN
+	#define CYBOZU_NAMESPACE_TR1_END
+#endif
+
+#ifndef CYBOZU_OS_BIT
+	#if defined(_WIN64) || defined(__x86_64__) || defined(__AARCH64EL__) || defined(__EMSCRIPTEN__)
+		#define CYBOZU_OS_BIT 64
+	#else
+		#define CYBOZU_OS_BIT 32
+	#endif
+#endif
+
+#ifndef CYBOZU_HOST
+	#define CYBOZU_HOST_UNKNOWN 0
+	#define CYBOZU_HOST_INTEL 1
+	#define CYBOZU_HOST_ARM 2
+	#if defined(_M_IX86) || defined(_M_AMD64) || defined(__x86_64__) || defined(__i386__)
+		#define CYBOZU_HOST CYBOZU_HOST_INTEL
+	#elif defined(__arm__) || defined(__AARCH64EL__)
+		#define CYBOZU_HOST CYBOZU_HOST_ARM
+	#else
+		#define CYBOZU_HOST CYBOZU_HOST_UNKNOWN
+	#endif
+#endif
+
+#ifndef CYBOZU_ENDIAN
+	#define CYBOZU_ENDIAN_UNKNOWN 0
+	#define CYBOZU_ENDIAN_LITTLE 1
+	#define CYBOZU_ENDIAN_BIG 2
+	#if (CYBOZU_HOST == CYBOZU_HOST_INTEL)
+		#define CYBOZU_ENDIAN CYBOZU_ENDIAN_LITTLE
+	#elif (CYBOZU_HOST == CYBOZU_HOST_ARM) && (defined(__ARM_EABI__) || defined(__AARCH64EL__))
+		#define CYBOZU_ENDIAN CYBOZU_ENDIAN_LITTLE
+	#else
+		#define CYBOZU_ENDIAN CYBOZU_ENDIAN_UNKNOWN
+	#endif
+#endif
+
+#if CYBOZU_CPP_VERSION >= CYBOZU_CPP_VERSION_CPP11
+	#define CYBOZU_NOEXCEPT noexcept
+#else
+	#define CYBOZU_NOEXCEPT throw()
+#endif
+namespace cybozu {
+template<class T>
+void disable_warning_unused_variable(const T&) { }
+template<class T, class S>
+T cast(const S* ptr) { return static_cast<T>(static_cast<const void*>(ptr)); }
+template<class T, class S>
+T cast(S* ptr) { return static_cast<T>(static_cast<void*>(ptr)); }
+} // cybozu

externals/xbyak/test/cybozu/test.hpp

@@ -0,0 +1,373 @@
+#pragma once
+/**
+	@file
+	@brief unit test class
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <list>
+#include <iostream>
+#include <utility>
+#if defined(_MSC_VER) && (MSC_VER <= 1500)
+	#include <cybozu/inttype.hpp>
+#else
+	#include <stdint.h>
+#endif
+
+namespace cybozu { namespace test {
+
+class AutoRun {
+	typedef void (*Func)();
+	typedef std::list<std::pair<const char*, Func> > UnitTestList;
+public:
+	AutoRun()
+		: init_(0)
+		, term_(0)
+		, okCount_(0)
+		, ngCount_(0)
+		, exceptionCount_(0)
+	{
+	}
+	void setup(Func init, Func term)
+	{
+		init_ = init;
+		term_ = term;
+	}
+	void append(const char *name, Func func)
+	{
+		list_.push_back(std::make_pair(name, func));
+	}
+	void set(bool isOK)
+	{
+		if (isOK) {
+			okCount_++;
+		} else {
+			ngCount_++;
+		}
+	}
+	std::string getBaseName(const std::string& name) const
+	{
+#ifdef _WIN32
+		const char sep = '\\';
+#else
+		const char sep = '/';
+#endif
+		size_t pos = name.find_last_of(sep);
+		std::string ret = name.substr(pos + 1);
+		pos = ret.find('.');
+		return ret.substr(0, pos);
+	}
+	int run(int, char *argv[])
+	{
+		std::string msg;
+		try {
+			if (init_) init_();
+			for (UnitTestList::const_iterator i = list_.begin(), ie = list_.end(); i != ie; ++i) {
+				std::cout << "ctest:module=" << i->first << std::endl;
+				try {
+					(i->second)();
+				} catch (std::exception& e) {
+					exceptionCount_++;
+					std::cout << "ctest:  " << i->first << " is stopped by exception " << e.what() << std::endl;
+				} catch (...) {
+					exceptionCount_++;
+					std::cout << "ctest:  " << i->first << " is stopped by unknown exception" << std::endl;
+				}
+			}
+			if (term_) term_();
+		} catch (std::exception& e) {
+			msg = std::string("ctest:err:") + e.what();
+		} catch (...) {
+			msg = "ctest:err: catch unknown exception";
+		}
+		fflush(stdout);
+		if (msg.empty()) {
+			int err = ngCount_ + exceptionCount_;
+			int total = okCount_ + err;
+			std::cout << "ctest:name=" << getBaseName(*argv)
+					  << ", module=" << list_.size()
+					  << ", total=" << total
+					  << ", ok=" << okCount_
+					  << ", ng=" << ngCount_
+					  << ", exception=" << exceptionCount_ << std::endl;
+			return err > 0 ? 1 : 0;
+		} else {
+			std::cout << msg << std::endl;
+			return 1;
+		}
+	}
+	static inline AutoRun& getInstance()
+	{
+		static AutoRun instance;
+		return instance;
+	}
+private:
+	Func init_;
+	Func term_;
+	int okCount_;
+	int ngCount_;
+	int exceptionCount_;
+	UnitTestList list_;
+};
+
+static AutoRun& autoRun = AutoRun::getInstance();
+
+inline void test(bool ret, const std::string& msg, const std::string& param, const char *file, int line)
+{
+	autoRun.set(ret);
+	if (!ret) {
+		printf("%s(%d):ctest:%s(%s);\n", file, line, msg.c_str(), param.c_str());
+	}
+}
+
+template<typename T, typename U>
+bool isEqual(const T& lhs, const U& rhs)
+{
+	return lhs == rhs;
+}
+
+// avoid warning of comparision of integers of different signs
+inline bool isEqual(size_t lhs, int rhs)
+{
+	return lhs == size_t(rhs);
+}
+inline bool isEqual(int lhs, size_t rhs)
+{
+	return size_t(lhs) == rhs;
+}
+inline bool isEqual(const char *lhs, const char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+inline bool isEqual(char *lhs, const char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+inline bool isEqual(const char *lhs, char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+inline bool isEqual(char *lhs, char *rhs)
+{
+	return strcmp(lhs, rhs) == 0;
+}
+// avoid to compare float directly
+inline bool isEqual(float lhs, float rhs)
+{
+	union fi {
+		float f;
+		uint32_t i;
+	} lfi, rfi;
+	lfi.f = lhs;
+	rfi.f = rhs;
+	return lfi.i == rfi.i;
+}
+// avoid to compare double directly
+inline bool isEqual(double lhs, double rhs)
+{
+	union di {
+		double d;
+		uint64_t i;
+	} ldi, rdi;
+	ldi.d = lhs;
+	rdi.d = rhs;
+	return ldi.i == rdi.i;
+}
+
+} } // cybozu::test
+
+#ifndef CYBOZU_TEST_DISABLE_AUTO_RUN
+int main(int argc, char *argv[])
+{
+	return cybozu::test::autoRun.run(argc, argv);
+}
+#endif
+
+/**
+	alert if !x
+	@param x [in]
+*/
+#define CYBOZU_TEST_ASSERT(x) cybozu::test::test(!!(x), "CYBOZU_TEST_ASSERT", #x, __FILE__, __LINE__)
+
+/**
+	alert if x != y
+	@param x [in]
+	@param y [in]
+*/
+#define CYBOZU_TEST_EQUAL(x, y) { \
+	bool _cybozu_eq = cybozu::test::isEqual(x, y); \
+	cybozu::test::test(_cybozu_eq, "CYBOZU_TEST_EQUAL", #x ", " #y, __FILE__, __LINE__); \
+	if (!_cybozu_eq) { \
+		std::cout << "ctest:  lhs=" << (x) << std::endl; \
+		std::cout << "ctest:  rhs=" << (y) << std::endl; \
+	} \
+}
+/**
+	alert if fabs(x, y) >= eps
+	@param x [in]
+	@param y [in]
+*/
+#define CYBOZU_TEST_NEAR(x, y, eps) { \
+	bool _cybozu_isNear = fabs((x) - (y)) < eps; \
+	cybozu::test::test(_cybozu_isNear, "CYBOZU_TEST_NEAR", #x ", " #y, __FILE__, __LINE__); \
+	if (!_cybozu_isNear) { \
+		std::cout << "ctest:  lhs=" << (x) << std::endl; \
+		std::cout << "ctest:  rhs=" << (y) << std::endl; \
+	} \
+}
+
+#define CYBOZU_TEST_EQUAL_POINTER(x, y) { \
+	bool _cybozu_eq = x == y; \
+	cybozu::test::test(_cybozu_eq, "CYBOZU_TEST_EQUAL_POINTER", #x ", " #y, __FILE__, __LINE__); \
+	if (!_cybozu_eq) { \
+		std::cout << "ctest:  lhs=" << static_cast<const void*>(x) << std::endl; \
+		std::cout << "ctest:  rhs=" << static_cast<const void*>(y) << std::endl; \
+	} \
+}
+/**
+	alert if x[] != y[]
+	@param x [in]
+	@param y [in]
+	@param n [in]
+*/
+#define CYBOZU_TEST_EQUAL_ARRAY(x, y, n) { \
+	for (size_t _cybozu_test_i = 0, _cybozu_ie = (size_t)(n); _cybozu_test_i < _cybozu_ie; _cybozu_test_i++) { \
+		bool _cybozu_eq = cybozu::test::isEqual((x)[_cybozu_test_i], (y)[_cybozu_test_i]); \
+		cybozu::test::test(_cybozu_eq, "CYBOZU_TEST_EQUAL_ARRAY", #x ", " #y ", " #n, __FILE__, __LINE__); \
+		if (!_cybozu_eq) { \
+			std::cout << "ctest:  i=" << _cybozu_test_i << std::endl; \
+			std::cout << "ctest:  lhs=" << (x)[_cybozu_test_i] << std::endl; \
+			std::cout << "ctest:  rhs=" << (y)[_cybozu_test_i] << std::endl; \
+		} \
+	} \
+}
+
+/**
+	always alert
+	@param msg [in]
+*/
+#define CYBOZU_TEST_FAIL(msg) cybozu::test::test(false, "CYBOZU_TEST_FAIL", msg, __FILE__, __LINE__)
+
+/**
+	verify message in exception
+*/
+#define CYBOZU_TEST_EXCEPTION_MESSAGE(statement, Exception, msg) \
+{ \
+	int _cybozu_ret = 0; \
+	std::string _cybozu_errMsg; \
+	try { \
+		statement; \
+		_cybozu_ret = 1; \
+	} catch (const Exception& _cybozu_e) { \
+		_cybozu_errMsg = _cybozu_e.what(); \
+		if (_cybozu_errMsg.find(msg) == std::string::npos) { \
+			_cybozu_ret = 2; \
+		} \
+	} catch (...) { \
+		_cybozu_ret = 3; \
+	} \
+	if (_cybozu_ret) { \
+		cybozu::test::test(false, "CYBOZU_TEST_EXCEPTION_MESSAGE", #statement ", " #Exception ", " #msg, __FILE__, __LINE__); \
+		if (_cybozu_ret == 1) { \
+			std::cout << "ctest:  no exception" << std::endl; \
+		} else if (_cybozu_ret == 2) { \
+			std::cout << "ctest:  bad exception msg:" << _cybozu_errMsg << std::endl; \
+		} else { \
+			std::cout << "ctest:  unexpected exception" << std::endl; \
+		} \
+	} else { \
+		cybozu::test::autoRun.set(true); \
+	} \
+}
+
+#define CYBOZU_TEST_EXCEPTION(statement, Exception) \
+{ \
+	int _cybozu_ret = 0; \
+	try { \
+		statement; \
+		_cybozu_ret = 1; \
+	} catch (const Exception&) { \
+	} catch (...) { \
+		_cybozu_ret = 2; \
+	} \
+	if (_cybozu_ret) { \
+		cybozu::test::test(false, "CYBOZU_TEST_EXCEPTION", #statement ", " #Exception, __FILE__, __LINE__); \
+		if (_cybozu_ret == 1) { \
+			std::cout << "ctest:  no exception" << std::endl; \
+		} else { \
+			std::cout << "ctest:  unexpected exception" << std::endl; \
+		} \
+	} else { \
+		cybozu::test::autoRun.set(true); \
+	} \
+}
+
+/**
+	verify statement does not throw
+*/
+#define CYBOZU_TEST_NO_EXCEPTION(statement) \
+try { \
+	statement; \
+	cybozu::test::autoRun.set(true); \
+} catch (...) { \
+	cybozu::test::test(false, "CYBOZU_TEST_NO_EXCEPTION", #statement, __FILE__, __LINE__); \
+}
+
+/**
+	append auto unit test
+	@param name [in] module name
+*/
+#define CYBOZU_TEST_AUTO(name) \
+void cybozu_test_ ## name(); \
+struct cybozu_test_local_ ## name { \
+	cybozu_test_local_ ## name() \
+	{ \
+		cybozu::test::autoRun.append(#name, cybozu_test_ ## name); \
+	} \
+} cybozu_test_local_instance_ ## name; \
+void cybozu_test_ ## name()
+
+/**
+	append auto unit test with fixture
+	@param name [in] module name
+*/
+#define CYBOZU_TEST_AUTO_WITH_FIXTURE(name, Fixture) \
+void cybozu_test_ ## name(); \
+void cybozu_test_real_ ## name() \
+{ \
+	Fixture f; \
+	cybozu_test_ ## name(); \
+} \
+struct cybozu_test_local_ ## name { \
+	cybozu_test_local_ ## name() \
+	{ \
+		cybozu::test::autoRun.append(#name, cybozu_test_real_ ## name); \
+	} \
+} cybozu_test_local_instance_ ## name; \
+void cybozu_test_ ## name()
+
+/**
+	setup fixture
+	@param Fixture [in] class name of fixture
+	@note cstr of Fixture is called before test and dstr of Fixture is called after test
+*/
+#define CYBOZU_TEST_SETUP_FIXTURE(Fixture) \
+Fixture *cybozu_test_local_fixture; \
+void cybozu_test_local_init() \
+{ \
+	cybozu_test_local_fixture = new Fixture(); \
+} \
+void cybozu_test_local_term() \
+{ \
+	delete cybozu_test_local_fixture; \
+} \
+struct cybozu_test_local_fixture_setup_ { \
+	cybozu_test_local_fixture_setup_() \
+	{ \
+		cybozu::test::autoRun.setup(cybozu_test_local_init, cybozu_test_local_term); \
+	} \
+} cybozu_test_local_fixture_setup_instance_;

externals/xbyak/test/jmp.sln

@@ -0,0 +1,20 @@
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jmp", "jmp.vcproj", "{AC0B3317-E988-44F8-954A-BCBE4B3BB2BF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{AC0B3317-E988-44F8-954A-BCBE4B3BB2BF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{AC0B3317-E988-44F8-954A-BCBE4B3BB2BF}.Debug|Win32.Build.0 = Debug|Win32
+		{AC0B3317-E988-44F8-954A-BCBE4B3BB2BF}.Release|Win32.ActiveCfg = Release|Win32
+		{AC0B3317-E988-44F8-954A-BCBE4B3BB2BF}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

externals/xbyak/test/jmp.vcproj

@@ -0,0 +1,195 @@
+<?xml version="1.0" encoding="shift_jis"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="jmp"
+	ProjectGUID="{AC0B3317-E988-44F8-954A-BCBE4B3BB2BF}"
+	RootNamespace="jmp"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="$(SolutionDir)/../"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="$(SolutionDir)/../"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ե<EFBFBD><D5A5><EFBFBD><EFBFBD><EFBFBD>"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\jmp.cpp"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="<22>إå<D8A5><C3A5><EFBFBD> <20>ե<EFBFBD><D5A5><EFBFBD><EFBFBD><EFBFBD>"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+		</Filter>
+		<Filter
+			Name="<22>꥽<EFBFBD><EAA5BD><EFBFBD><EFBFBD> <20>ե<EFBFBD><D5A5><EFBFBD><EFBFBD><EFBFBD>"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

externals/xbyak/test/lib.h

@@ -0,0 +1,63 @@
+#pragma once
+#include <stdio.h>
+
+struct Reg {
+	int r_;
+	Reg(int r) : r_(r) {}
+};
+
+inline const Reg& getReg0() { static const Reg r(0); return r; }
+inline const Reg& getReg1() { static const Reg r(1); return r; }
+inline const Reg& getReg2() { static const Reg r(2); return r; }
+
+static const Reg& r0 = getReg0();
+static const Reg& r1 = getReg1();
+static const Reg& r2 = getReg2();
+
+inline void putReg()
+{
+	puts("putReg");
+	printf("r0=%p, %d\n", &r0, r0.r_);
+	printf("r0=%p, %d\n", &r0, r1.r_);
+	printf("r0=%p, %d\n", &r0, r2.r_);
+}
+
+struct A {
+	int a;
+	A()
+		: a(5)
+	{
+		puts("A cstr");
+	}
+	~A()
+	{
+		puts("A dstr");
+	}
+	void put() const
+	{
+		printf("a=%d\n", a);
+	}
+};
+
+template<int dummy = 0>
+struct XT {
+	static A a;
+};
+
+template<int dummy>
+A XT<dummy>::a;
+
+typedef XT<0> X;
+
+void init();
+
+struct Init {
+	Init()
+	{
+		puts("Init");
+		init();
+		putReg();
+	}
+};
+static Init s_init;
+

externals/xbyak/test/lib_min.cpp

@@ -0,0 +1,51 @@
+#include <stdio.h>
+
+static const struct XXX {
+	XXX() { puts("XXX"); }
+} s_sss;
+
+struct A {
+	int aaa;
+	A()
+		: aaa(123)
+	{
+		puts("A cstr");
+	}
+	~A()
+	{
+		puts("A dstr");
+	}
+	void put() const
+	{
+		printf("aaa=%d\n", aaa);
+	}
+};
+
+template<int dummy = 0>
+struct XT {
+	static A sss;
+};
+
+template<int dummy>
+A XT<dummy>::sss;
+
+typedef XT<0> X;
+
+static struct Init {
+	Init()
+	{
+		puts("Init");
+		X::sss.put();
+	}
+} s_init;
+
+int f() { puts("f"); return 4; }
+
+static const int r = f();
+
+int main()
+{
+	puts("main");
+	printf("r=%d\n", r);
+	X::sss.put();
+}

externals/xbyak/test/lib_run.cpp

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+int main()
+{
+	puts("main");
+	X::a.put();
+	putReg();
+}
+

externals/xbyak/test/lib_test.cpp

@@ -0,0 +1,13 @@
+#include "lib.h"
+
+void init()
+{
+	static bool init = true;
+	printf("in lib_test %d\n", init);
+	if (!init) return;
+	init = false;
+	X::a.put();
+	putReg();
+}
+
+

externals/xbyak/test/misc.cpp

@@ -0,0 +1,818 @@
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#define XBYAK_NO_OP_NAMES
+#include <xbyak/xbyak.h>
+#include <cybozu/inttype.hpp>
+#include <cybozu/test.hpp>
+
+using namespace Xbyak;
+
+CYBOZU_TEST_AUTO(setSize)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code() : Xbyak::CodeGenerator(4096)
+		{
+			setSize(4095);
+			db(1);
+			size_t size = getSize();
+			CYBOZU_TEST_EQUAL(size, 4096u);
+			CYBOZU_TEST_NO_EXCEPTION(setSize(size));
+			CYBOZU_TEST_EXCEPTION(db(1), Xbyak::Error);
+		}
+	} code;
+}
+
+CYBOZU_TEST_AUTO(compOperand)
+{
+	using namespace Xbyak::util;
+	CYBOZU_TEST_ASSERT(eax == eax);
+	CYBOZU_TEST_ASSERT(ecx != xmm0);
+	CYBOZU_TEST_ASSERT(ptr[eax] == ptr[eax]);
+	CYBOZU_TEST_ASSERT(dword[eax] != ptr[eax]);
+	CYBOZU_TEST_ASSERT(ptr[eax] != ptr[eax+3]);
+}
+
+CYBOZU_TEST_AUTO(mov_const)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			const struct {
+				uint64_t v;
+				int bit;
+				bool error;
+			} tbl[] = {
+				{ uint64_t(-1), 8, false },
+				{ 0x12, 8, false },
+				{ 0x80, 8, false },
+				{ 0xff, 8, false },
+				{ 0x100, 8, true },
+
+				{ 1, 16, false },
+				{ uint64_t(-1), 16, false },
+				{ 0x7fff, 16, false },
+				{ 0xffff, 16, false },
+				{ 0x10000, 16, true },
+
+				{ uint64_t(-1), 32, false },
+				{ 0x7fffffff, 32, false },
+				{ uint64_t(-0x7fffffff), 32, false },
+				{ 0xffffffff, 32, false },
+				{ 0x100000000ull, 32, true },
+
+#ifdef XBYAK64
+				{ uint64_t(-1), 64, false },
+				{ 0x7fffffff, 64, false },
+				{ 0xffffffffffffffffull, 64, false },
+				{ 0x80000000, 64, true },
+				{ 0xffffffff, 64, true },
+#endif
+			};
+			for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) {
+				const int bit = tbl[i].bit;
+				const uint64_t v = tbl[i].v;
+				const Xbyak::AddressFrame& af = bit == 8 ? byte : bit == 16 ? word : bit == 32 ? dword : qword;
+				if (tbl[i].error) {
+					CYBOZU_TEST_EXCEPTION(mov(af[eax], v), Xbyak::Error);
+				} else {
+					CYBOZU_TEST_NO_EXCEPTION(mov(af[eax], v));
+				}
+			}
+		}
+	} code;
+}
+
+CYBOZU_TEST_AUTO(align)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			const size_t alignSize = 16;
+			for (int padding = 0; padding < 20; padding++) {
+				for (int i = 0; i < padding; i++) {
+					db(1);
+				}
+				align(alignSize);
+				CYBOZU_TEST_EQUAL(size_t(getCurr()) % alignSize, 0u);
+			}
+			align(alignSize);
+			const uint8 *p = getCurr();
+			// do nothing if aligned
+			align(alignSize);
+			CYBOZU_TEST_EQUAL(p, getCurr());
+		}
+	} c;
+}
+CYBOZU_TEST_AUTO(kmask)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			CYBOZU_TEST_EXCEPTION(kmovb(k1, ax), std::exception);
+			CYBOZU_TEST_EXCEPTION(kmovw(k1, ax), std::exception);
+			CYBOZU_TEST_EXCEPTION(kmovd(k1, ax), std::exception);
+			CYBOZU_TEST_EXCEPTION(kmovq(k1, eax), std::exception);
+#ifdef XBYAK64
+			CYBOZU_TEST_EXCEPTION(kmovb(k1, rax), std::exception);
+			CYBOZU_TEST_EXCEPTION(kmovw(k1, rax), std::exception);
+			CYBOZU_TEST_EXCEPTION(kmovd(k1, rax), std::exception);
+			CYBOZU_TEST_NO_EXCEPTION(kmovq(k1, rax));
+#endif
+			CYBOZU_TEST_NO_EXCEPTION(vmovaps(xm0|k0, ptr[eax]));
+			checkT_z();
+		}
+		void checkT_z()
+		{
+			const uint8_t *p1 = getCurr();
+			vmovaps(zm0, ptr[eax]);
+			const uint8_t *p2 = getCurr();
+			vmovaps(zm0|T_z, ptr[eax]);
+			const uint8_t *end = getCurr();
+			CYBOZU_TEST_EQUAL(p2 - p1, end - p2);
+			CYBOZU_TEST_EQUAL_ARRAY(p1, p2, end - p2);
+		}
+	} c;
+}
+
+#ifdef XBYAK64
+CYBOZU_TEST_AUTO(vfmaddps)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			v4fmaddps(zmm1, zmm8, ptr [rdx + 64]);
+			v4fmaddss(xmm15, xmm8, ptr [rax + 64]);
+			v4fnmaddps(zmm5 | k5, zmm2, ptr [rcx + 0x80]);
+			v4fnmaddss(xmm31, xmm2, ptr [rsp + 0x80]);
+			vp4dpwssd(zmm23 | k7 | T_z, zmm1, ptr [rax + 64]);
+			vp4dpwssds(zmm10 | k4, zmm3, ptr [rsp + rax * 4 + 64]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf2, 0x3f, 0x48, 0x9a, 0x4a, 0x04,
+		0x62, 0x72, 0x3f, 0x08, 0x9b, 0x78, 0x04,
+		0x62, 0xf2, 0x6f, 0x4d, 0xaa, 0x69, 0x08,
+		0x62, 0x62, 0x6f, 0x08, 0xab, 0x7c, 0x24, 0x08,
+		0x62, 0xe2, 0x77, 0xcf, 0x52, 0x78, 0x04,
+		0x62, 0x72, 0x67, 0x4c, 0x53, 0x54, 0x84, 0x04,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(vaes)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vaesdec(xmm20, xmm30, ptr [rcx + 64]);
+			vaesdec(ymm1, ymm2, ptr [rcx + 64]);
+			vaesdec(zmm1, zmm2, ptr [rcx + 64]);
+
+			vaesdeclast(xmm20, xmm30, ptr [rax + 64]);
+			vaesdeclast(ymm20, ymm30, ptr [rax + 64]);
+			vaesdeclast(zmm20, zmm30, ptr [rax + 64]);
+
+			vaesenc(xmm20, xmm30, ptr [rcx + 64]);
+			vaesenc(ymm1, ymm2, ptr [rcx + 64]);
+			vaesenc(zmm1, zmm2, ptr [rcx + 64]);
+
+			vaesenclast(xmm20, xmm30, ptr [rax + 64]);
+			vaesenclast(ymm20, ymm30, ptr [rax + 64]);
+			vaesenclast(zmm20, zmm30, ptr [rax + 64]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xE2, 0x0D, 0x00, 0xDE, 0x61, 0x04,
+		0xC4, 0xE2, 0x6D, 0xDE, 0x49, 0x40,
+		0x62, 0xF2, 0x6D, 0x48, 0xDE, 0x49, 0x01,
+
+		0x62, 0xE2, 0x0D, 0x00, 0xDF, 0x60, 0x04,
+		0x62, 0xE2, 0x0D, 0x20, 0xDF, 0x60, 0x02,
+		0x62, 0xE2, 0x0D, 0x40, 0xDF, 0x60, 0x01,
+
+		0x62, 0xE2, 0x0D, 0x00, 0xDC, 0x61, 0x04,
+		0xC4, 0xE2, 0x6D, 0xDC, 0x49, 0x40,
+		0x62, 0xF2, 0x6D, 0x48, 0xDC, 0x49, 0x01,
+
+		0x62, 0xE2, 0x0D, 0x00, 0xDD, 0x60, 0x04,
+		0x62, 0xE2, 0x0D, 0x20, 0xDD, 0x60, 0x02,
+		0x62, 0xE2, 0x0D, 0x40, 0xDD, 0x60, 0x01,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(vpclmulqdq)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vpclmulqdq(xmm2, xmm3, ptr [rax + 64], 3);
+			vpclmulqdq(ymm2, ymm3, ptr [rax + 64], 3);
+			vpclmulqdq(zmm2, zmm3, ptr [rax + 64], 3);
+
+			vpclmulqdq(xmm20, xmm3, ptr [rax + 64], 3);
+			vpclmulqdq(ymm20, ymm3, ptr [rax + 64], 3);
+			vpclmulqdq(zmm20, zmm3, ptr [rax + 64], 3);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0xc4, 0xe3, 0x61, 0x44, 0x50, 0x40, 0x03,
+		0xc4, 0xe3, 0x65, 0x44, 0x50, 0x40, 0x03,
+		0x62, 0xf3, 0x65, 0x48, 0x44, 0x50, 0x01, 0x03,
+		0x62, 0xe3, 0x65, 0x08, 0x44, 0x60, 0x04, 0x03,
+		0x62, 0xe3, 0x65, 0x28, 0x44, 0x60, 0x02, 0x03,
+		0x62, 0xe3, 0x65, 0x48, 0x44, 0x60, 0x01, 0x03,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(vcompressb_w)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vcompressb(ptr[rax + 64], xmm1);
+			vcompressb(xmm30 | k5, xmm1);
+			vcompressb(ptr[rax + 64], ymm1);
+			vcompressb(ymm30 | k3 |T_z, ymm1);
+			vcompressb(ptr[rax + 64], zmm1);
+			vcompressb(zmm30 | k2 |T_z, zmm1);
+
+			vcompressw(ptr[rax + 64], xmm1);
+			vcompressw(xmm30 | k5, xmm1);
+			vcompressw(ptr[rax + 64], ymm1);
+			vcompressw(ymm30 | k3 |T_z, ymm1);
+			vcompressw(ptr[rax + 64], zmm1);
+			vcompressw(zmm30 | k2 |T_z, zmm1);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf2, 0x7d, 0x08, 0x63, 0x48, 0x40,
+		0x62, 0x92, 0x7d, 0x0d, 0x63, 0xce,
+		0x62, 0xf2, 0x7d, 0x28, 0x63, 0x48, 0x40,
+		0x62, 0x92, 0x7d, 0xab, 0x63, 0xce,
+		0x62, 0xf2, 0x7d, 0x48, 0x63, 0x48, 0x40,
+		0x62, 0x92, 0x7d, 0xca, 0x63, 0xce,
+
+		0x62, 0xf2, 0xfd, 0x08, 0x63, 0x48, 0x20,
+		0x62, 0x92, 0xfd, 0x0d, 0x63, 0xce,
+		0x62, 0xf2, 0xfd, 0x28, 0x63, 0x48, 0x20,
+		0x62, 0x92, 0xfd, 0xab, 0x63, 0xce,
+		0x62, 0xf2, 0xfd, 0x48, 0x63, 0x48, 0x20,
+		0x62, 0x92, 0xfd, 0xca, 0x63, 0xce,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(shld)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vpshldw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5);
+			vpshldw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5);
+			vpshldw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5);
+
+			vpshldd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5);
+			vpshldd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5);
+			vpshldd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5);
+
+			vpshldq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5);
+			vpshldq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5);
+			vpshldq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5);
+
+			vpshldvw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]);
+			vpshldvw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]);
+			vpshldvw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]);
+
+			vpshldvd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]);
+			vpshldvd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]);
+			vpshldvd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]);
+
+			vpshldvq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]);
+			vpshldvq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]);
+			vpshldvq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf3, 0xed, 0x8b, 0x70, 0x68, 0x04, 0x05,
+		0x62, 0xf3, 0xed, 0xab, 0x70, 0x68, 0x02, 0x05,
+		0x62, 0xf3, 0xed, 0xcb, 0x70, 0x68, 0x01, 0x05,
+
+		0x62, 0xf3, 0x6d, 0x8b, 0x71, 0x68, 0x04, 0x05,
+		0x62, 0xf3, 0x6d, 0xab, 0x71, 0x68, 0x02, 0x05,
+		0x62, 0xf3, 0x6d, 0xcb, 0x71, 0x68, 0x01, 0x05,
+
+		0x62, 0xf3, 0xed, 0x8b, 0x71, 0x68, 0x04, 0x05,
+		0x62, 0xf3, 0xed, 0xab, 0x71, 0x68, 0x02, 0x05,
+		0x62, 0xf3, 0xed, 0xcb, 0x71, 0x68, 0x01, 0x05,
+
+		0x62, 0xf2, 0xed, 0x8b, 0x70, 0x68, 0x04,
+		0x62, 0xf2, 0xed, 0xab, 0x70, 0x68, 0x02,
+		0x62, 0xf2, 0xed, 0xcb, 0x70, 0x68, 0x01,
+
+		0x62, 0xf2, 0x6d, 0x8b, 0x71, 0x68, 0x04,
+		0x62, 0xf2, 0x6d, 0xab, 0x71, 0x68, 0x02,
+		0x62, 0xf2, 0x6d, 0xcb, 0x71, 0x68, 0x01,
+
+		0x62, 0xf2, 0xed, 0x8b, 0x71, 0x68, 0x04,
+		0x62, 0xf2, 0xed, 0xab, 0x71, 0x68, 0x02,
+		0x62, 0xf2, 0xed, 0xcb, 0x71, 0x68, 0x01,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(shrd)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vpshrdw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5);
+			vpshrdw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5);
+			vpshrdw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5);
+
+			vpshrdd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5);
+			vpshrdd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5);
+			vpshrdd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5);
+
+			vpshrdq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5);
+			vpshrdq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5);
+			vpshrdq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5);
+
+			vpshrdvw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]);
+			vpshrdvw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]);
+			vpshrdvw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]);
+
+			vpshrdvd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]);
+			vpshrdvd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]);
+			vpshrdvd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]);
+
+			vpshrdvq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]);
+			vpshrdvq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]);
+			vpshrdvq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]);
+
+			vpshrdd(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40], 5);
+			vpshrdd(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40], 5);
+			vpshrdd(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40], 5);
+
+			vpshrdq(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40], 5);
+			vpshrdq(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40], 5);
+			vpshrdq(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40], 5);
+
+			vpshrdvd(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40]);
+			vpshrdvd(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40]);
+			vpshrdvd(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40]);
+
+			vpshrdvq(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40]);
+			vpshrdvq(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40]);
+			vpshrdvq(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf3, 0xed, 0x8b, 0x72, 0x68, 0x04, 0x05,
+		0x62, 0xf3, 0xed, 0xab, 0x72, 0x68, 0x02, 0x05,
+		0x62, 0xf3, 0xed, 0xcb, 0x72, 0x68, 0x01, 0x05,
+
+		0x62, 0xf3, 0x6d, 0x8b, 0x73, 0x68, 0x04, 0x05,
+		0x62, 0xf3, 0x6d, 0xab, 0x73, 0x68, 0x02, 0x05,
+		0x62, 0xf3, 0x6d, 0xcb, 0x73, 0x68, 0x01, 0x05,
+
+		0x62, 0xf3, 0xed, 0x8b, 0x73, 0x68, 0x04, 0x05,
+		0x62, 0xf3, 0xed, 0xab, 0x73, 0x68, 0x02, 0x05,
+		0x62, 0xf3, 0xed, 0xcb, 0x73, 0x68, 0x01, 0x05,
+
+		0x62, 0xf2, 0xed, 0x8b, 0x72, 0x68, 0x04,
+		0x62, 0xf2, 0xed, 0xab, 0x72, 0x68, 0x02,
+		0x62, 0xf2, 0xed, 0xcb, 0x72, 0x68, 0x01,
+
+		0x62, 0xf2, 0x6d, 0x8b, 0x73, 0x68, 0x04,
+		0x62, 0xf2, 0x6d, 0xab, 0x73, 0x68, 0x02,
+		0x62, 0xf2, 0x6d, 0xcb, 0x73, 0x68, 0x01,
+
+		0x62, 0xf2, 0xed, 0x8b, 0x73, 0x68, 0x04,
+		0x62, 0xf2, 0xed, 0xab, 0x73, 0x68, 0x02,
+		0x62, 0xf2, 0xed, 0xcb, 0x73, 0x68, 0x01,
+
+		0x62, 0xf3, 0x6d, 0x9b, 0x73, 0x68, 0x10, 0x05,
+		0x62, 0xf3, 0x6d, 0xbb, 0x73, 0x68, 0x10, 0x05,
+		0x62, 0xf3, 0x6d, 0xdb, 0x73, 0x68, 0x10, 0x05,
+
+		0x62, 0xf3, 0xed, 0x9b, 0x73, 0x68, 0x08, 0x05,
+		0x62, 0xf3, 0xed, 0xbb, 0x73, 0x68, 0x08, 0x05,
+		0x62, 0xf3, 0xed, 0xdb, 0x73, 0x68, 0x08, 0x05,
+
+		0x62, 0xf2, 0x6d, 0x9b, 0x73, 0x68, 0x10,
+		0x62, 0xf2, 0x6d, 0xbb, 0x73, 0x68, 0x10,
+		0x62, 0xf2, 0x6d, 0xdb, 0x73, 0x68, 0x10,
+
+		0x62, 0xf2, 0xed, 0x9b, 0x73, 0x68, 0x08,
+		0x62, 0xf2, 0xed, 0xbb, 0x73, 0x68, 0x08,
+		0x62, 0xf2, 0xed, 0xdb, 0x73, 0x68, 0x08,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(vpopcnt)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vpopcntb(xmm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntb(ymm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntb(zmm5|k3|T_z, ptr [rax + 0x40]);
+
+			vpopcntw(xmm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntw(ymm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntw(zmm5|k3|T_z, ptr [rax + 0x40]);
+
+			vpopcntd(xmm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntd(ymm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntd(zmm5|k3|T_z, ptr [rax + 0x40]);
+
+			vpopcntd(xmm5|k3|T_z, ptr_b [rax + 0x40]);
+			vpopcntd(ymm5|k3|T_z, ptr_b [rax + 0x40]);
+			vpopcntd(zmm5|k3|T_z, ptr_b [rax + 0x40]);
+
+			vpopcntq(xmm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntq(ymm5|k3|T_z, ptr [rax + 0x40]);
+			vpopcntq(zmm5|k3|T_z, ptr [rax + 0x40]);
+
+			vpopcntq(xmm5|k3|T_z, ptr_b [rax + 0x40]);
+			vpopcntq(ymm5|k3|T_z, ptr_b [rax + 0x40]);
+			vpopcntq(zmm5|k3|T_z, ptr_b [rax + 0x40]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf2, 0x7d, 0x8b, 0x54, 0x68, 0x04,
+		0x62, 0xf2, 0x7d, 0xab, 0x54, 0x68, 0x02,
+		0x62, 0xf2, 0x7d, 0xcb, 0x54, 0x68, 0x01,
+
+		0x62, 0xf2, 0xfd, 0x8b, 0x54, 0x68, 0x04,
+		0x62, 0xf2, 0xfd, 0xab, 0x54, 0x68, 0x02,
+		0x62, 0xf2, 0xfd, 0xcb, 0x54, 0x68, 0x01,
+
+		0x62, 0xf2, 0x7d, 0x8b, 0x55, 0x68, 0x04,
+		0x62, 0xf2, 0x7d, 0xab, 0x55, 0x68, 0x02,
+		0x62, 0xf2, 0x7d, 0xcb, 0x55, 0x68, 0x01,
+
+		0x62, 0xf2, 0x7d, 0x9b, 0x55, 0x68, 0x10,
+		0x62, 0xf2, 0x7d, 0xbb, 0x55, 0x68, 0x10,
+		0x62, 0xf2, 0x7d, 0xdb, 0x55, 0x68, 0x10,
+
+		0x62, 0xf2, 0xfd, 0x8b, 0x55, 0x68, 0x04,
+		0x62, 0xf2, 0xfd, 0xab, 0x55, 0x68, 0x02,
+		0x62, 0xf2, 0xfd, 0xcb, 0x55, 0x68, 0x01,
+
+		0x62, 0xf2, 0xfd, 0x9b, 0x55, 0x68, 0x08,
+		0x62, 0xf2, 0xfd, 0xbb, 0x55, 0x68, 0x08,
+		0x62, 0xf2, 0xfd, 0xdb, 0x55, 0x68, 0x08,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(vpdpbus)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vpdpbusd(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]);
+			vpdpbusd(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]);
+			vpdpbusd(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]);
+
+			vpdpbusd(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]);
+			vpdpbusd(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]);
+			vpdpbusd(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]);
+
+			vpdpbusds(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]);
+			vpdpbusds(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]);
+			vpdpbusds(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]);
+
+			vpdpbusds(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]);
+			vpdpbusds(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]);
+			vpdpbusds(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]);
+
+			vpdpwssd(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]);
+			vpdpwssd(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]);
+			vpdpwssd(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]);
+
+			vpdpwssd(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]);
+			vpdpwssd(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]);
+			vpdpwssd(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]);
+
+			vpdpwssds(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]);
+			vpdpwssds(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]);
+			vpdpwssds(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]);
+
+			vpdpwssds(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]);
+			vpdpwssds(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]);
+			vpdpwssds(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf2, 0x5d, 0x83, 0x50, 0x68, 0x04,
+		0x62, 0xf2, 0x5d, 0xa3, 0x50, 0x68, 0x02,
+		0x62, 0xf2, 0x5d, 0xc3, 0x50, 0x68, 0x01,
+
+		0x62, 0xf2, 0x5d, 0x93, 0x50, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xb3, 0x50, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xd3, 0x50, 0x68, 0x10,
+
+		0x62, 0xf2, 0x5d, 0x83, 0x51, 0x68, 0x04,
+		0x62, 0xf2, 0x5d, 0xa3, 0x51, 0x68, 0x02,
+		0x62, 0xf2, 0x5d, 0xc3, 0x51, 0x68, 0x01,
+
+		0x62, 0xf2, 0x5d, 0x93, 0x51, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xb3, 0x51, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xd3, 0x51, 0x68, 0x10,
+
+		0x62, 0xf2, 0x5d, 0x83, 0x52, 0x68, 0x04,
+		0x62, 0xf2, 0x5d, 0xa3, 0x52, 0x68, 0x02,
+		0x62, 0xf2, 0x5d, 0xc3, 0x52, 0x68, 0x01,
+
+		0x62, 0xf2, 0x5d, 0x93, 0x52, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xb3, 0x52, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xd3, 0x52, 0x68, 0x10,
+
+		0x62, 0xf2, 0x5d, 0x83, 0x53, 0x68, 0x04,
+		0x62, 0xf2, 0x5d, 0xa3, 0x53, 0x68, 0x02,
+		0x62, 0xf2, 0x5d, 0xc3, 0x53, 0x68, 0x01,
+
+		0x62, 0xf2, 0x5d, 0x93, 0x53, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xb3, 0x53, 0x68, 0x10,
+		0x62, 0xf2, 0x5d, 0xd3, 0x53, 0x68, 0x10,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(vexpand_vpshufbitqmb)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vpexpandb(xmm5|k3|T_z, xmm30);
+			vpexpandb(ymm5|k3|T_z, ymm30);
+			vpexpandb(zmm5|k3|T_z, zmm30);
+			vpexpandb(xmm5|k3|T_z, ptr [rax + 0x40]);
+			vpexpandb(ymm5|k3|T_z, ptr [rax + 0x40]);
+			vpexpandb(zmm5|k3|T_z, ptr [rax + 0x40]);
+
+			vpexpandw(xmm5|k3|T_z, xmm30);
+			vpexpandw(ymm5|k3|T_z, ymm30);
+			vpexpandw(zmm5|k3|T_z, zmm30);
+			vpexpandw(xmm5|k3|T_z, ptr [rax + 0x40]);
+			vpexpandw(ymm5|k3|T_z, ptr [rax + 0x40]);
+			vpexpandw(zmm5|k3|T_z, ptr [rax + 0x40]);
+
+			vpshufbitqmb(k1|k2, xmm2, ptr [rax + 0x40]);
+			vpshufbitqmb(k1|k2, ymm2, ptr [rax + 0x40]);
+			vpshufbitqmb(k1|k2, zmm2, ptr [rax + 0x40]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0x92, 0x7d, 0x8b, 0x62, 0xee,
+		0x62, 0x92, 0x7d, 0xab, 0x62, 0xee,
+		0x62, 0x92, 0x7d, 0xcb, 0x62, 0xee,
+		0x62, 0xf2, 0x7d, 0x8b, 0x62, 0x68, 0x40,
+		0x62, 0xf2, 0x7d, 0xab, 0x62, 0x68, 0x40,
+		0x62, 0xf2, 0x7d, 0xcb, 0x62, 0x68, 0x40,
+
+		0x62, 0x92, 0xfd, 0x8b, 0x62, 0xee,
+		0x62, 0x92, 0xfd, 0xab, 0x62, 0xee,
+		0x62, 0x92, 0xfd, 0xcb, 0x62, 0xee,
+		0x62, 0xf2, 0xfd, 0x8b, 0x62, 0x68, 0x20,
+		0x62, 0xf2, 0xfd, 0xab, 0x62, 0x68, 0x20,
+		0x62, 0xf2, 0xfd, 0xcb, 0x62, 0x68, 0x20,
+
+		0x62, 0xf2, 0x6d, 0x0a, 0x8f, 0x48, 0x04,
+		0x62, 0xf2, 0x6d, 0x2a, 0x8f, 0x48, 0x02,
+		0x62, 0xf2, 0x6d, 0x4a, 0x8f, 0x48, 0x01,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+CYBOZU_TEST_AUTO(gf2)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			///
+			gf2p8affineinvqb(xmm1, xmm2, 3);
+			gf2p8affineinvqb(xmm1, ptr [rax + 0x40], 3);
+
+			vgf2p8affineinvqb(xmm1, xmm5, xmm2, 3);
+			vgf2p8affineinvqb(ymm1, ymm5, ymm2, 3);
+			vgf2p8affineinvqb(xmm1, xmm5, ptr [rax + 0x40], 3);
+			vgf2p8affineinvqb(ymm1, ymm5, ptr [rax + 0x40], 3);
+
+			vgf2p8affineinvqb(xmm30, xmm31, xmm4, 5);
+			vgf2p8affineinvqb(ymm30, ymm31, ymm4, 5);
+			vgf2p8affineinvqb(zmm30, zmm31, zmm4, 5);
+
+			vgf2p8affineinvqb(xmm30|k1|T_z, xmm5, ptr [rax + 0x40], 5);
+			vgf2p8affineinvqb(ymm30|k1|T_z, ymm5, ptr [rax + 0x40], 5);
+			vgf2p8affineinvqb(zmm30|k1|T_z, zmm5, ptr [rax + 0x40], 5);
+
+			vgf2p8affineinvqb(xmm30|k1|T_z, xmm5, ptr_b [rax + 0x40], 5);
+			vgf2p8affineinvqb(ymm30|k1|T_z, ymm5, ptr_b [rax + 0x40], 5);
+			vgf2p8affineinvqb(zmm30|k1|T_z, zmm5, ptr_b [rax + 0x40], 5);
+			///
+			gf2p8affineqb(xmm1, xmm2, 3);
+			gf2p8affineqb(xmm1, ptr [rax + 0x40], 3);
+
+			vgf2p8affineqb(xmm1, xmm5, xmm2, 3);
+			vgf2p8affineqb(ymm1, ymm5, ymm2, 3);
+			vgf2p8affineqb(xmm1, xmm5, ptr [rax + 0x40], 3);
+			vgf2p8affineqb(ymm1, ymm5, ptr [rax + 0x40], 3);
+
+			vgf2p8affineqb(xmm30, xmm31, xmm4, 5);
+			vgf2p8affineqb(ymm30, ymm31, ymm4, 5);
+			vgf2p8affineqb(zmm30, zmm31, zmm4, 5);
+
+			vgf2p8affineqb(xmm30|k1|T_z, xmm5, ptr [rax + 0x40], 5);
+			vgf2p8affineqb(ymm30|k1|T_z, ymm5, ptr [rax + 0x40], 5);
+			vgf2p8affineqb(zmm30|k1|T_z, zmm5, ptr [rax + 0x40], 5);
+
+			vgf2p8affineqb(xmm30|k1|T_z, xmm5, ptr_b [rax + 0x40], 5);
+			vgf2p8affineqb(ymm30|k1|T_z, ymm5, ptr_b [rax + 0x40], 5);
+			vgf2p8affineqb(zmm30|k1|T_z, zmm5, ptr_b [rax + 0x40], 5);
+			///
+			gf2p8mulb(xmm1, xmm2);
+			gf2p8mulb(xmm1, ptr [rax + 0x40]);
+
+			vgf2p8mulb(xmm1, xmm5, xmm2);
+			vgf2p8mulb(ymm1, ymm5, ymm2);
+			vgf2p8mulb(xmm1, xmm5, ptr [rax + 0x40]);
+			vgf2p8mulb(ymm1, ymm5, ptr [rax + 0x40]);
+
+			vgf2p8mulb(xmm30, xmm31, xmm4);
+			vgf2p8mulb(ymm30, ymm31, ymm4);
+			vgf2p8mulb(zmm30, zmm31, zmm4);
+
+			vgf2p8mulb(xmm30|k1|T_z, xmm5, ptr [rax + 0x40]);
+			vgf2p8mulb(ymm30|k1|T_z, ymm5, ptr [rax + 0x40]);
+			vgf2p8mulb(zmm30|k1|T_z, zmm5, ptr [rax + 0x40]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x66, 0x0f, 0x3a, 0xcf, 0xca, 0x03,
+		0x66, 0x0f, 0x3a, 0xcf, 0x48, 0x40, 0x03,
+		0xc4, 0xe3, 0xd1, 0xcf, 0xca, 0x03,
+		0xc4, 0xe3, 0xd5, 0xcf, 0xca, 0x03,
+		0xc4, 0xe3, 0xd1, 0xcf, 0x48, 0x40, 0x03,
+		0xc4, 0xe3, 0xd5, 0xcf, 0x48, 0x40, 0x03,
+		0x62, 0x63, 0x85, 0x00, 0xcf, 0xf4, 0x05,
+		0x62, 0x63, 0x85, 0x20, 0xcf, 0xf4, 0x05,
+		0x62, 0x63, 0x85, 0x40, 0xcf, 0xf4, 0x05,
+		0x62, 0x63, 0xd5, 0x89, 0xcf, 0x70, 0x04, 0x05,
+		0x62, 0x63, 0xd5, 0xa9, 0xcf, 0x70, 0x02, 0x05,
+		0x62, 0x63, 0xd5, 0xc9, 0xcf, 0x70, 0x01, 0x05,
+		0x62, 0x63, 0xd5, 0x99, 0xcf, 0x70, 0x08, 0x05,
+		0x62, 0x63, 0xd5, 0xb9, 0xcf, 0x70, 0x08, 0x05,
+		0x62, 0x63, 0xd5, 0xd9, 0xcf, 0x70, 0x08, 0x05,
+
+		0x66, 0x0f, 0x3a, 0xce, 0xca, 0x03,
+		0x66, 0x0f, 0x3a, 0xce, 0x48, 0x40, 0x03,
+		0xc4, 0xe3, 0xd1, 0xce, 0xca, 0x03,
+		0xc4, 0xe3, 0xd5, 0xce, 0xca, 0x03,
+		0xc4, 0xe3, 0xd1, 0xce, 0x48, 0x40, 0x03,
+		0xc4, 0xe3, 0xd5, 0xce, 0x48, 0x40, 0x03,
+		0x62, 0x63, 0x85, 0x00, 0xce, 0xf4, 0x05,
+		0x62, 0x63, 0x85, 0x20, 0xce, 0xf4, 0x05,
+		0x62, 0x63, 0x85, 0x40, 0xce, 0xf4, 0x05,
+		0x62, 0x63, 0xd5, 0x89, 0xce, 0x70, 0x04, 0x05,
+		0x62, 0x63, 0xd5, 0xa9, 0xce, 0x70, 0x02, 0x05,
+		0x62, 0x63, 0xd5, 0xc9, 0xce, 0x70, 0x01, 0x05,
+		0x62, 0x63, 0xd5, 0x99, 0xce, 0x70, 0x08, 0x05,
+		0x62, 0x63, 0xd5, 0xb9, 0xce, 0x70, 0x08, 0x05,
+		0x62, 0x63, 0xd5, 0xd9, 0xce, 0x70, 0x08, 0x05,
+
+		0x66, 0x0f, 0x38, 0xcf, 0xca,
+		0x66, 0x0f, 0x38, 0xcf, 0x48, 0x40,
+		0xc4, 0xe2, 0x51, 0xcf, 0xca,
+		0xc4, 0xe2, 0x55, 0xcf, 0xca,
+		0xc4, 0xe2, 0x51, 0xcf, 0x48, 0x40,
+		0xc4, 0xe2, 0x55, 0xcf, 0x48, 0x40,
+		0x62, 0x62, 0x05, 0x00, 0xcf, 0xf4,
+		0x62, 0x62, 0x05, 0x20, 0xcf, 0xf4,
+		0x62, 0x62, 0x05, 0x40, 0xcf, 0xf4,
+		0x62, 0x62, 0x55, 0x89, 0xcf, 0x70, 0x04,
+		0x62, 0x62, 0x55, 0xa9, 0xcf, 0x70, 0x02,
+		0x62, 0x62, 0x55, 0xc9, 0xcf, 0x70, 0x01,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+
+CYBOZU_TEST_AUTO(bf16)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			vcvtne2ps2bf16(xmm0 | k1, xmm1, ptr [rax + 64]);
+			vcvtne2ps2bf16(ymm0 | k1 | T_z, ymm0, ptr [rax + 64]);
+			vcvtne2ps2bf16(zmm0 | k1, zmm1, ptr [rax + 64]);
+
+			vcvtneps2bf16(xmm0, xword [rax + 64]);
+			vcvtneps2bf16(xmm0 | k1, yword [rax + 64]);
+			vcvtneps2bf16(ymm0 | k1, zword [rax + 64]);
+			vcvtneps2bf16(ymm0 | k1, ptr [rax + 64]);
+
+			vdpbf16ps(xmm0 | k1, xmm1, ptr [rax + 64]);
+			vdpbf16ps(ymm0 | k1, ymm1, ptr [rax + 64]);
+			vdpbf16ps(zmm0 | k1, zmm1, ptr [rax + 64]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0x62, 0xf2, 0x77, 0x09, 0x72, 0x40, 0x04,
+		0x62, 0xf2, 0x7f, 0xa9, 0x72, 0x40, 0x02,
+		0x62, 0xf2, 0x77, 0x49, 0x72, 0x40, 0x01,
+
+		0x62, 0xf2, 0x7e, 0x08, 0x72, 0x40, 0x04,
+		0x62, 0xf2, 0x7e, 0x29, 0x72, 0x40, 0x02,
+		0x62, 0xf2, 0x7e, 0x49, 0x72, 0x40, 0x01,
+		0x62, 0xf2, 0x7e, 0x49, 0x72, 0x40, 0x01,
+
+		0x62, 0xf2, 0x76, 0x09, 0x52, 0x40, 0x04,
+		0x62, 0xf2, 0x76, 0x29, 0x52, 0x40, 0x02,
+		0x62, 0xf2, 0x76, 0x49, 0x52, 0x40, 0x01,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	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[rax + rcx * 4 + 64]);
+			sttilecfg(ptr[rsp + rax * 8 + 128]);
+			tileloadd(tmm3, ptr[rdi + rdx * 2 + 8]);
+			tileloaddt1(tmm4, ptr[r8 + r9 + 32]);
+			tilerelease();
+			tilestored(ptr[r10 + r11 * 2 + 32], tmm2);
+			tilezero(tmm7);
+			tdpbssd(tmm1, tmm2, tmm3);
+			tdpbsud(tmm2, tmm3, tmm4);
+			tdpbusd(tmm3, tmm4, tmm5);
+			tdpbuud(tmm4, tmm5, tmm6);
+			tdpbf16ps(tmm5, tmm6, tmm7);
+		}
+	} c;
+	// generated code by patch
+	const uint8_t tbl[] = {
+		0xc4, 0xe2, 0x78, 0x49, 0x44, 0x88, 0x40, 0xc4, 0xe2, 0x79, 0x49, 0x84, 0xc4, 0x80, 0x00, 0x00,
+		0x00, 0xc4, 0xe2, 0x7b, 0x4b, 0x5c, 0x57, 0x08, 0xc4, 0x82, 0x79, 0x4b, 0x64, 0x08, 0x20, 0xc4,
+		0xe2, 0x78, 0x49, 0xc0, 0xc4, 0x82, 0x7a, 0x4b, 0x54, 0x5a, 0x20, 0xc4, 0xe2, 0x7b, 0x49, 0xf8,
+		0xc4, 0xe2, 0x63, 0x5e, 0xca, 0xc4, 0xe2, 0x5a, 0x5e, 0xd3, 0xc4, 0xe2, 0x51, 0x5e, 0xdc, 0xc4,
+		0xe2, 0x48, 0x5e, 0xe5, 0xc4, 0xe2, 0x42, 0x5c, 0xee,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+}
+
+CYBOZU_TEST_AUTO(tileloadd)
+{
+	struct Code : Xbyak::CodeGenerator {
+		Code()
+		{
+			tileloadd(tmm1, ptr[r8+r8]);
+			tileloadd(tmm1, ptr[rax+rcx*4]);
+			tileloadd(tmm1, ptr[r8+r9*1+0x40]);
+		}
+		void notSupported()
+		{
+			tileloadd(tmm1, ptr[r8]);
+		}
+		void notSupported2()
+		{
+			tileloadd(tmm1, ptr[r8*2]);
+		}
+	} c;
+	const uint8_t tbl[] = {
+		0xC4, 0x82, 0x7B, 0x4B, 0x0C, 0x00,
+		0xC4, 0xE2, 0x7B, 0x4B, 0x0C, 0x88,
+		0xC4, 0x82, 0x7B, 0x4B, 0x4C, 0x08, 0x40,
+	};
+	const size_t n = sizeof(tbl) / sizeof(tbl[0]);
+	CYBOZU_TEST_EQUAL(c.getSize(), n);
+	CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n);
+
+	// current version does not support this sibmem format
+	CYBOZU_TEST_EXCEPTION(c.notSupported(), std::exception);
+	CYBOZU_TEST_EXCEPTION(c.notSupported2(), std::exception);
+}
+#endif

externals/xbyak/test/mprotect_test.cpp

@@ -0,0 +1,37 @@
+#define XBYAK_NO_OP_NAMES
+#include "xbyak/xbyak.h"
+#include <string.h>
+#include <vector>
+
+struct Code : Xbyak::CodeGenerator {
+	Code(int x)
+	{
+		mov(eax, x);
+		ret();
+	}
+};
+
+int main()
+	try
+{
+#ifdef XBYAK_USE_MMAP_ALLOCATOR
+	puts("use Allocator with mmap");
+#else
+	puts("use Allocator with posix_memalign");
+#endif
+	const int N = 70000;
+	std::vector<Code*> v(N);
+	for (int i = 0; i < N; i++) {
+		v[i] = new Code(i);
+	}
+	long long sum = 0;
+	for (int i = 0; i < N; i++) {
+		sum += v[i]->getCode<int (*)()>()();
+	}
+	for (int i = 0; i < N; i++) {
+		delete v[i];
+	}
+	printf("sum=%lld\n", sum);
+} catch (std::exception& e) {
+	printf("ERR %s\n", e.what());
+}

externals/xbyak/test/nm_frame.cpp

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#define XBYAK_ENABLE_OMITTED_OPERAND
+#include "xbyak/xbyak.h"
+#define CYBOZU_TEST_DISABLE_AUTO_RUN
+#include "cybozu/test.hpp"
+
+using namespace Xbyak;
+
+#ifdef _MSC_VER
+	#pragma warning(disable : 4245)
+	#pragma warning(disable : 4312)
+#endif
+class Sample : public CodeGenerator {
+	void operator=(const Sample&);
+public:
+#include "nm.cpp"
+};
+
+
+class ErrorSample : public CodeGenerator {
+	void operator=(const ErrorSample&);
+public:
+	void gen()
+	{
+#ifndef XBYAK_NO_EXCEPTION
+		CYBOZU_TEST_EXCEPTION(mov(ptr[eax],1), std::exception);
+		CYBOZU_TEST_EXCEPTION(test(ptr[eax],1), std::exception);
+		CYBOZU_TEST_EXCEPTION(adc(ptr[eax],1), std::exception);
+		CYBOZU_TEST_EXCEPTION(setz(eax), std::exception);
+#endif
+	}
+};
+
+int main()
+{
+	// the size of Operand exceeds 32 bit.
+	CYBOZU_TEST_EQUAL(sizeof(Xbyak::Operand), 8u);
+	Sample s;
+	s.gen();
+	ErrorSample es;
+	es.gen();
+}

externals/xbyak/test/noexception.cpp

@@ -0,0 +1,111 @@
+#define XBYAK_NO_EXCEPTION
+#include <xbyak/xbyak.h>
+
+using namespace Xbyak;
+
+int g_err = 0;
+int g_test = 0;
+
+void assertEq(int x, int y)
+{
+	if (x != y) {
+		printf("ERR x=%d y=%d\n", x, y);
+		g_err++;
+	}
+	g_test++;
+}
+
+void assertBool(bool b)
+{
+	if (!b) {
+		printf("ERR assertBool\n");
+		g_err++;
+	}
+	g_test++;
+}
+
+void test1()
+{
+	const int v = 123;
+	struct Code : CodeGenerator {
+		Code()
+		{
+			mov(eax, v);
+			ret();
+		}
+	} c;
+	int (*f)() = c.getCode<int (*)()>();
+	assertEq(f(), v);
+	assertEq(Xbyak::GetError(), ERR_NONE);
+}
+
+void test2()
+{
+	struct Code : CodeGenerator {
+		Code()
+		{
+			Label lp;
+			L(lp);
+			L(lp);
+		}
+	} c;
+	assertEq(Xbyak::GetError(), ERR_LABEL_IS_REDEFINED);
+	Xbyak::ClearError();
+}
+
+void test3()
+{
+	static struct EmptyAllocator : Xbyak::Allocator {
+		uint8 *alloc() { return 0; }
+	} emptyAllocator;
+	struct Code : CodeGenerator {
+		Code() : CodeGenerator(8, 0, &emptyAllocator)
+		{
+			mov(eax, 3);
+			assertBool(Xbyak::GetError() == 0);
+			mov(eax, 3);
+			mov(eax, 3);
+			assertBool(Xbyak::GetError() != 0);
+			Xbyak::ClearError();
+			assertBool(Xbyak::GetError() == 0);
+		}
+	} c;
+}
+
+void test4()
+{
+	struct Code : CodeGenerator {
+		Code()
+		{
+			mov(ptr[eax], 1);
+			assertBool(Xbyak::GetError() != 0);
+			Xbyak::ClearError();
+
+			test(ptr[eax], 1);
+			assertBool(Xbyak::GetError() != 0);
+			Xbyak::ClearError();
+
+			adc(ptr[eax], 1);
+			assertBool(Xbyak::GetError() != 0);
+			Xbyak::ClearError();
+
+			setz(eax);
+			assertBool(Xbyak::GetError() != 0);
+			Xbyak::ClearError();
+		}
+	};
+}
+
+int main()
+{
+	test1();
+	test2();
+	test3();
+	test4();
+	if (g_err) {
+		printf("err %d/%d\n", g_err, g_test);
+	} else {
+		printf("all ok %d\n", g_test);
+	}
+	return g_err != 0;
+}

externals/xbyak/test/normalize_prefix.cpp

@@ -0,0 +1,45 @@
+/*
+	normalize prefix
+*/
+#include <string>
+#include <set>
+#include <iostream>
+#include <memory.h>
+
+typedef unsigned char uint8;
+
+std::string normalize(const std::string& line)
+{
+	static const char tbl[][3] = { "66", "67", "F2", "F3" };
+	size_t tblNum = sizeof(tbl) / sizeof(tbl[0]);
+	typedef std::set<std::string> StringSet;
+	StringSet suf;
+
+	size_t pos = 0;
+	for (; pos < line.size(); pos += 2) {
+		bool found = false;
+		for (size_t i = 0; i < tblNum; i++) {
+			if (::memcmp(&line[pos], tbl[i], 2) == 0) {
+				found = true;
+				suf.insert(tbl[i]);
+				break;
+			}
+		}
+		if (!found) break;
+	}
+	std::string ret;
+	for (StringSet::const_iterator i = suf.begin(), e = suf.end(); i != e; ++i) {
+		ret += *i;
+	}
+	ret += &line[pos];
+	return ret;
+}
+
+int main()
+{
+	std::string line;
+	while (std::getline(std::cin, line)) {
+		std::string normalizedLine = normalize(line);
+		std::cout << normalizedLine << '\n';//std::endl;
+	}
+}

externals/xbyak/test/readme.txt

@@ -0,0 +1,6 @@
+
+test script on Windows
+
+this test requires nasm.exe, yasm.exe, cl.exe, awk, diff
+
+test_all ; for all tests

externals/xbyak/test/rip-label-imm.cpp

@@ -0,0 +1,88 @@
+#define XBYAK_NO_OP_NAMES
+#include <xbyak/xbyak.h>
+/*
+dump of vc
+
+00000000003A0000 F3 0F C2 05 F1 00 00 00 00 cmpeqss     xmm0,dword ptr [3A00FAh]
+00000000003A0009 F7 05 E7 00 00 00 21 00 00 00 test        dword ptr [3A00FAh],21h
+00000000003A0013 0F BA 25 DF 00 00 00 03 bt          dword ptr [3A00FAh],3
+00000000003A001B C4 E3 79 0D 05 D5 00 00 00 03 vblendpd    xmm0,xmm0,xmmword ptr [3A00FAh],3
+00000000003A0025 C4 E3 79 0F 05 CB 00 00 00 04 vpalignr    xmm0,xmm0,xmmword ptr [3A00FAh],4
+00000000003A002F C4 E3 7D 19 1D C1 00 00 00 0C vextractf128 xmmword ptr [3A00FAh],ymm3,0Ch
+00000000003A0039 C4 E3 75 46 05 B7 00 00 00 0D vperm2i128  ymm0,ymm1,ymmword ptr [3A00FAh],0Dh
+00000000003A0043 C4 E3 79 1D 15 AD 00 00 00 2C vcvtps2ph   mmword ptr [3A00FAh],xmm2,2Ch
+00000000003A004D C7 05 A3 00 00 00 34 12 00 00 mov         dword ptr [3A00FAh],1234h
+00000000003A0057 C1 25 9C 00 00 00 03 shl         dword ptr [3A00FAh],3
+00000000003A005E D1 2D 96 00 00 00    shr         dword ptr [3A00FAh],1
+00000000003A0064 48 0F A4 05 8D 00 00 00 03 shld        qword ptr [3A00FAh],rax,3
+00000000003A006D 48 6B 05 85 00 00 00 15 imul        rax,qword ptr [3A00FAh],15h
+00000000003A0075 C4 E3 FB F0 05 7B 00 00 00 15 rorx        rax,qword ptr [3A00FAh],15h
+00000000003A007F F7 05 71 00 00 00 05 00 00 00 test        dword ptr [3A00FAh],5
+00000000003A0089 66 48 0F 3A 16 05 66 00 00 00 03 pextrq      qword ptr [3A00FAh],xmm0,3
+00000000003A0094 66 48 0F 3A 22 15 5B 00 00 00 05 pinsrq      xmm2,qword ptr [3A00FAh],5
+00000000003A009F 66 0F 3A 15 0D 51 00 00 00 04 pextrw      word ptr [3A00FAh],xmm1,4
+00000000003A00A9 81 15 47 00 00 00 45 23 01 00 adc         dword ptr [3A00FAh],12345h
+00000000003A00B3 0F BA 25 3F 00 00 00 34 bt          dword ptr [3A00FAh],34h
+00000000003A00BB 66 0F BA 3D 36 00 00 00 34 btc         word ptr [3A00FAh],34h
+00000000003A00C4 0F BA 35 2E 00 00 00 34 btr         dword ptr [3A00FAh],34h
+00000000003A00CC C1 15 27 00 00 00 04 rcl         dword ptr [3A00FAh],4
+00000000003A00D3 48 0F A4 05 1E 00 00 00 04 shld        qword ptr [3A00FAh],rax,4
+00000000003A00DC 0F 3A 0F 05 15 00 00 00 04 palignr     mm0,mmword ptr [3A00FAh],4
+00000000003A00E5 66 0F 3A DF 1D 0B 00 00 00 04 aeskeygenassist xmm3,xmmword ptr [3A00FAh],4
+00000000003A00EF C4 E3 79 60 15 01 00 00 00 07 vpcmpestrm  xmm2,xmmword ptr [3A00FAh],7
+00000000003A00F9 C3                   ret
+00000000003A00FA F0 DE BC 9A 78 56 34 12
+*/
+struct Code : Xbyak::CodeGenerator {
+	Code()
+	{
+		Xbyak::Label label;
+		cmpss(xmm0, ptr[rip + label], 0);
+		test(dword[rip + label], 33);
+		bt(dword[rip + label ], 3);
+		vblendpd(xmm0, xmm0, dword[rip + label], 3);
+		vpalignr(xmm0, xmm0, qword[rip + label], 4);
+		vextractf128(dword[rip + label], ymm3, 12);
+		vperm2i128(ymm0, ymm1, qword[rip + label], 13);
+		vcvtps2ph(ptr[rip + label], xmm2, 44);
+		mov(dword[rip + label], 0x1234);
+		shl(dword[rip + label], 3);
+		shr(dword[rip + label], 1);
+		shld(qword[rip + label], rax, 3);
+		imul(rax, qword[rip + label], 21);
+		rorx(rax, qword[rip + label], 21);
+		test(dword[rip + label], 5);
+		pextrq(ptr[rip + label], xmm0, 3);
+		pinsrq(xmm2, ptr[rip + label], 5);
+		pextrw(ptr[rip + label], xmm1, 4);
+		adc(dword[rip + label], 0x12345);
+		bt(byte[rip + label], 0x34);
+		btc(word[rip + label], 0x34);
+		btr(dword[rip + label], 0x34);
+		rcl(dword[rip + label], 4);
+		shld(qword[rip + label], rax, 4);
+		palignr(mm0, ptr[rip + label], 4);
+		aeskeygenassist(xmm3, ptr[rip + label], 4);
+		vpcmpestrm(xmm2, ptr[rip + label], 7);
+		ret();
+	L(label);
+		dq(0x123456789abcdef0ull);
+	};
+};
+
+void dump(const unsigned char *p, size_t n)
+{
+	for (int i = 0; i < n; i++) {
+		printf("%02x ", p[i]);
+		if ((i % 16) == 15) putchar('\n');
+	}
+	putchar('\n');
+}
+
+int main()
+{
+	Code code;
+	void (*f)() = code.getCode<void (*)()>();
+	dump(code.getCode(), code.getSize());
+	f();
+}

externals/xbyak/test/set_opt.bat

@@ -0,0 +1,2 @@
+@echo off
+set OPT=/EHsc -I../xbyak -I./ /W4 -D_CRT_SECURE_NO_WARNINGS /nologo

externals/xbyak/test/sf_test.cpp

@@ -0,0 +1,416 @@
+#define XBYAK_NO_OP_NAMES
+#include <xbyak/xbyak_util.h>
+
+#ifdef XBYAK32
+	#error "this sample is for only 64-bit mode"
+#endif
+
+using namespace Xbyak::util;
+
+struct Code : public Xbyak::CodeGenerator {
+	void gen1()
+	{
+		StackFrame sf(this, 1);
+		mov(rax, sf.p[0]);
+	}
+	void gen2()
+	{
+		StackFrame sf(this, 2);
+		lea(rax, ptr [sf.p[0] + sf.p[1]]);
+	}
+	void gen3()
+	{
+		StackFrame sf(this, 3);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+	}
+	void gen4()
+	{
+		StackFrame sf(this, 4);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+		add(rax, sf.p[3]);
+	}
+
+	void gen5()
+	{
+		StackFrame sf(this, 4, UseRCX);
+		xor_(rcx, rcx);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+		add(rax, sf.p[3]);
+	}
+
+	void gen6()
+	{
+		StackFrame sf(this, 4, UseRCX | UseRDX);
+		xor_(rcx, rcx);
+		xor_(rdx, rdx);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+		add(rax, sf.p[3]);
+	}
+
+	void gen7()
+	{
+		StackFrame sf(this, 3, UseRCX | UseRDX);
+		xor_(rcx, rcx);
+		xor_(rdx, rdx);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+	}
+
+	void gen8()
+	{
+		StackFrame sf(this, 3, 3 | UseRCX | UseRDX);
+		xor_(rcx, rcx);
+		xor_(rdx, rdx);
+		mov(sf.t[0], 1);
+		mov(sf.t[1], 2);
+		mov(sf.t[2], 3);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+	}
+
+	void gen9()
+	{
+		StackFrame sf(this, 3, 3 | UseRCX | UseRDX, 32);
+		xor_(rcx, rcx);
+		xor_(rdx, rdx);
+		mov(sf.t[0], 1);
+		mov(sf.t[1], 2);
+		mov(sf.t[2], 3);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+		mov(ptr [rsp + 8 * 0], rax);
+		mov(ptr [rsp + 8 * 1], rax);
+		mov(ptr [rsp + 8 * 2], rax);
+		mov(ptr [rsp + 8 * 3], rax);
+	}
+
+	void gen10()
+	{
+		StackFrame sf(this, 4, 8 | UseRCX | UseRDX, 32);
+		xor_(rcx, rcx);
+		xor_(rdx, rdx);
+		for (int i = 0; i < 8; i++) {
+			mov(sf.t[i], i);
+		}
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+		add(rax, sf.p[3]);
+		mov(ptr [rsp + 8 * 0], rax);
+		mov(ptr [rsp + 8 * 1], rax);
+		mov(ptr [rsp + 8 * 2], rax);
+		mov(ptr [rsp + 8 * 3], rax);
+	}
+
+	void gen11()
+	{
+		StackFrame sf(this, 0, UseRCX);
+		xor_(rcx, rcx);
+		mov(rax, 3);
+	}
+
+	void gen12()
+	{
+		StackFrame sf(this, 4, UseRDX);
+		xor_(rdx, rdx);
+		mov(rax, sf.p[0]);
+		add(rax, sf.p[1]);
+		add(rax, sf.p[2]);
+		add(rax, sf.p[3]);
+	}
+
+	/*
+		int64_t f(const int64_t a[13]) { return sum-of-a[]; }
+	*/
+	void gen13()
+	{
+		StackFrame sf(this, 1, 13);
+		for (int i = 0; i < 13; i++) {
+			mov(sf.t[i], ptr[sf.p[0] + i * 8]);
+		}
+		mov(rax, sf.t[0]);
+		for (int i = 1; i < 13; i++) {
+			add(rax, sf.t[i]);
+		}
+	}
+	/*
+		same as gen13
+	*/
+	void gen14()
+	{
+		StackFrame sf(this, 1, 11 | UseRCX | UseRDX);
+		Pack t = sf.t;
+		t.append(rcx);
+		t.append(rdx);
+		for (int i = 0; i < 13; i++) {
+			mov(t[i], ptr[sf.p[0] + i * 8]);
+		}
+		mov(rax, t[0]);
+		for (int i = 1; i < 13; i++) {
+			add(rax, t[i]);
+		}
+	}
+	/*
+		return (1 << 15) - 1;
+	*/
+	void gen15()
+	{
+		StackFrame sf(this, 0, 14, 8);
+		Pack t = sf.t;
+		t.append(rax);
+		for (int i = 0; i < 15; i++) {
+			mov(t[i], 1 << i);
+		}
+		mov(qword[rsp], 0);
+		for (int i = 0; i < 15; i++) {
+			add(ptr[rsp], t[i]);
+		}
+		mov(rax, ptr[rsp]);
+	}
+};
+
+struct Code2 : Xbyak::CodeGenerator {
+	Code2()
+		: Xbyak::CodeGenerator(4096 * 32)
+	{
+	}
+	void gen(int pNum, int tNum, int stackSizeByte)
+	{
+		StackFrame sf(this, pNum, tNum, stackSizeByte);
+		if (tNum & UseRCX) xor_(rcx, rcx);
+		if (tNum & UseRDX) xor_(rdx, rdx);
+		for (int i = 0, n = tNum & ~(UseRCX | UseRDX); i < n; i++) {
+			mov(sf.t[i], 5);
+		}
+		for (int i = 0; i < stackSizeByte; i++) {
+			mov(byte [rsp + i], 0);
+		}
+		mov(rax, 1);
+		for (int i = 0; i < pNum; i++) {
+			add(rax, sf.p[i]);
+		}
+	}
+	void gen2(int pNum, int tNum, int stackSizeByte)
+	{
+		StackFrame sf(this, pNum, tNum, stackSizeByte);
+		mov(rax, rsp);
+	}
+};
+
+
+static int errNum = 0;
+void check(int x, int y)
+{
+	if (x != y) {
+		printf("err x=%d, y=%d\n", x, y);
+		errNum++;
+	}
+}
+
+void verify(const Xbyak::uint8 *f, int pNum)
+{
+	switch (pNum) {
+	case 0:
+		check(1, reinterpret_cast<int (*)()>(f)());
+		return;
+	case 1:
+		check(11, reinterpret_cast<int (*)(int)>(f)(10));
+		return;
+	case 2:
+		check(111, reinterpret_cast<int (*)(int, int)>(f)(10, 100));
+		return;
+	case 3:
+		check(1111, reinterpret_cast<int (*)(int, int, int)>(f)(10, 100, 1000));
+		return;
+	case 4:
+		check(11111, reinterpret_cast<int (*)(int, int, int, int)>(f)(10, 100, 1000, 10000));
+		return;
+	default:
+		printf("ERR pNum=%d\n", pNum);
+		exit(1);
+	}
+}
+
+void testAll()
+{
+	Code2 code;
+	for (int stackSize = 0; stackSize < 32; stackSize += 7) {
+		for (int pNum = 0; pNum < 4; pNum++) {
+			for (int mode = 0; mode < 4; mode++) {
+				int maxNum = 0;
+				int opt = 0;
+				if (mode == 0) {
+					maxNum = 10;
+				} else if (mode == 1) {
+					maxNum = 9;
+					opt = UseRCX;
+				} else if (mode == 2) {
+					maxNum = 9;
+					opt = UseRDX;
+				} else {
+					maxNum = 8;
+					opt = UseRCX | UseRDX;
+				}
+				for (int tNum = 0; tNum < maxNum; tNum++) {
+//					printf("pNum=%d, tNum=%d, stackSize=%d\n", pNum, tNum | opt, stackSize);
+					const Xbyak::uint8 *f = code.getCurr();
+					code.gen(pNum, tNum | opt, stackSize);
+					verify(f, pNum);
+					/*
+						check rsp is 16-byte aligned if stackSize > 0
+					*/
+					if (stackSize > 0) {
+						Code2 c2;
+						c2.gen2(pNum, tNum | opt, stackSize);
+						uint64_t addr = c2.getCode<uint64_t (*)()>()();
+						check(addr % 16, 0);
+					}
+				}
+			}
+		}
+	}
+}
+
+void testPartial()
+{
+	Code code;
+	int (*f1)(int) = code.getCurr<int (*)(int)>();
+	code.gen1();
+	check(5, f1(5));
+
+	int (*f2)(int, int) = code.getCurr<int (*)(int, int)>();
+	code.gen2();
+	check(9, f2(3, 6));
+
+	int (*f3)(int, int, int) = code.getCurr<int (*)(int, int, int)>();
+	code.gen3();
+	check(14, f3(1, 4, 9));
+
+	int (*f4)(int, int, int, int) = code.getCurr<int (*)(int, int, int, int)>();
+	code.gen4();
+	check(30, f4(1, 4, 9, 16));
+
+	int (*f5)(int, int, int, int) = code.getCurr<int (*)(int, int, int, int)>();
+	code.gen5();
+	check(23, f5(2, 5, 7, 9));
+
+	int (*f6)(int, int, int, int) = code.getCurr<int (*)(int, int, int, int)>();
+	code.gen6();
+	check(18, f6(3, 4, 5, 6));
+
+	int (*f7)(int, int, int) = code.getCurr<int (*)(int, int, int)>();
+	code.gen7();
+	check(12, f7(3, 4, 5));
+
+	int (*f8)(int, int, int) = code.getCurr<int (*)(int, int, int)>();
+	code.gen8();
+	check(23, f8(5, 8, 10));
+
+	int (*f9)(int, int, int) = code.getCurr<int (*)(int, int, int)>();
+	code.gen9();
+	check(60, f9(10, 20, 30));
+
+	int (*f10)(int, int, int, int) = code.getCurr<int (*)(int, int, int, int)>();
+	code.gen10();
+	check(100, f10(10, 20, 30, 40));
+
+	int (*f11)() = code.getCurr<int (*)()>();
+	code.gen11();
+	check(3, f11());
+
+	int (*f12)(int, int, int, int) = code.getCurr<int (*)(int, int, int, int)>();
+	code.gen12();
+	check(24, f12(3, 5, 7, 9));
+
+	{
+		int64_t tbl[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
+		int64_t (*f13)(const int64_t*) = code.getCurr<int64_t (*)(const int64_t*)>();
+		code.gen13();
+		check(91, f13(tbl));
+
+		int64_t (*f14)(const int64_t*) = code.getCurr<int64_t (*)(const int64_t*)>();
+		code.gen14();
+		check(91, f14(tbl));
+	}
+	int (*f15)() = code.getCurr<int (*)()>();
+	code.gen15();
+	check((1 << 15) - 1, f15());
+}
+
+void put(const Xbyak::util::Pack& p)
+{
+	for (size_t i = 0, n = p.size(); i < n; i++) {
+		printf("%s ", p[i].toString());
+	}
+	printf("\n");
+}
+
+void verifyPack(const Xbyak::util::Pack& p, const int *tbl, size_t tblNum)
+{
+	for (size_t i = 0; i < tblNum; i++) {
+		check(p[i].getIdx(), tbl[i]);
+	}
+}
+
+void testPack()
+{
+	const int N = 10;
+	Xbyak::Reg64 regTbl[N];
+	for (int i = 0; i < N; i++) {
+		regTbl[i] = Xbyak::Reg64(i);
+	}
+	Xbyak::util::Pack p(regTbl, N);
+	const struct {
+		int pos;
+		int num;
+		int tbl[10];
+	} tbl[] = {
+		{ 0, 10, { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } },
+		{ 1, 9, { 1, 2, 3, 4, 5, 6, 7, 8, 9 } },
+		{ 2, 8, { 2, 3, 4, 5, 6, 7, 8, 9 } },
+		{ 3, 7, { 3, 4, 5, 6, 7, 8, 9 } },
+		{ 4, 6, { 4, 5, 6, 7, 8, 9 } },
+		{ 5, 5, { 5, 6, 7, 8, 9 } },
+		{ 6, 4, { 6, 7, 8, 9 } },
+		{ 7, 3, { 7, 8, 9 } },
+		{ 8, 2, { 8, 9 } },
+		{ 9, 1, { 9 } },
+		{ 3, 5, { 3, 4, 5, 6, 7 } },
+	};
+	for (size_t i = 0; i < sizeof(tbl) / sizeof(*tbl); i++) {
+		const int pos = tbl[i].pos;
+		const int num = tbl[i].num;
+		verifyPack(p.sub(pos, num), tbl[i].tbl, num);
+		if (pos + num == N) {
+			verifyPack(p.sub(pos), tbl[i].tbl, num);
+		}
+	}
+}
+
+int main()
+	try
+{
+	testAll();
+
+	testPartial();
+	testPack();
+	printf("errNum=%d\n", errNum);
+} catch (std::exception& e) {
+	printf("err %s\n", e.what());
+	return 1;
+} catch (...) {
+	puts("ERR");
+	return 1;
+}
+

externals/xbyak/test/test_address.bat

@@ -0,0 +1,37 @@
+@echo off
+set FILTER=grep -v warning
+if /i "%1"=="64" (
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+) else (
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+)
+
+call set_opt
+bmake -f Makefile.win all
+
+if /i "%1"=="64" (
+	call :sub 1
+	call :sub 2
+) else (
+	call :sub 1
+)
+goto end
+
+:sub
+echo cl address.cpp %OPT% %OPT2%
+cl address.cpp %OPT% %OPT2%
+address %1% > a.asm
+echo nasm -f %OPT3% -l a.lst a.asm
+nasm -f %OPT3% -l a.lst a.asm
+awk "{if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
+echo address %1% jit > nm.cpp
+address %1% jit > nm.cpp
+echo cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
+cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
+nm_frame > x.lst
+diff -w x.lst ok.lst
+wc x.lst
+
+:end

externals/xbyak/test/test_address.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+
+FILTER="grep -v warning"
+
+sub()
+{
+
+CFLAGS="-Wall -fno-operator-names -I../ $OPT2"
+echo "compile address.cpp"
+g++ $CFLAGS address.cpp -o address
+
+./address $1 > a.asm
+echo "asm"
+$EXE -f$OPT3 a.asm -l a.lst
+awk '{if (index($3, "-")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = "" }} ' < a.lst | $FILTER > ok.lst
+
+echo "xbyak"
+./address $1 jit > nm.cpp
+echo "compile nm_frame.cpp"
+g++ $CFLAGS -DXBYAK_TEST nm_frame.cpp -o nm_frame
+./nm_frame > x.lst
+diff ok.lst x.lst && echo "ok"
+
+}
+
+if [ "$1" = "64" ]; then
+	echo "nasm(64bit)"
+	EXE=nasm
+	OPT2=-DXBYAK64
+	OPT3=win64
+
+	sub 1
+	sub 2
+else
+	echo "nasm(32bit)"
+	EXE=nasm
+	OPT2=-DXBYAK32
+	OPT3=win32
+	sub 1
+fi
+

externals/xbyak/test/test_all.bat

@@ -0,0 +1,8 @@
+@echo off
+call test_nm_all
+echo *** test addressing ***
+call test_address
+call test_address 64
+echo *** test jmp address ***
+call test_jmp
+echo *** all test end ***

externals/xbyak/test/test_avx.bat

@@ -0,0 +1,42 @@
+@echo off
+set FILTER=cat
+set Y=0
+if /i "%1"=="Y" (
+	set Y=1
+	set EXE=yasm.exe
+	set OPT2=-DUSE_YASM -DXBYAK32
+	set OPT3=win32
+) else if /i "%1"=="64" (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+	set FILTER=normalize_prefix
+) else if /i "%1"=="Y64" (
+	set Y=1
+	set EXE=yasm.exe
+	set OPT2=-DUSE_YASM -DXBYAK64
+	set OPT3=win64
+	set FILTER=normalize_prefix
+) else (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+)
+call set_opt
+bmake -f Makefile.win all
+echo cl -I../ make_nm.cpp %OPT% %OPT2% /EHs /DUSE_AVX
+cl -I../ make_nm.cpp %OPT% %OPT2% /EHs /DUSE_AVX
+make_nm > a.asm
+%EXE% -f %OPT3% -l a.lst a.asm
+rem connect "?????-" and "??"
+if /i "%Y%"=="1" (
+	awk "NR > 1 {if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
+) else (
+	awk "{if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
+)
+make_nm jit > nm.cpp
+echo cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
+cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
+nm_frame |%FILTER% > x.lst
+diff -w x.lst ok.lst
+wc x.lst

externals/xbyak/test/test_avx.sh

@@ -0,0 +1,43 @@
+#!/bin/tcsh
+
+set FILTER="grep -v warning"
+
+if ($1 == "Y") then
+	echo "yasm(32bit)"
+	set EXE=yasm
+	set OPT2="-DUSE_YASM -DXBYAK32"
+	set OPT3=win32
+else if ($1 == "64") then
+	echo "nasm(64bit)"
+	set EXE=nasm
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+	set FILTER=./normalize_prefix
+else if ($1 == "Y64") then
+	echo "yasm(64bit)"
+	set EXE=yasm
+	set OPT2="-DUSE_YASM -DXBYAK64"
+	set OPT3=win64
+	set FILTER=./normalize_prefix
+else
+	echo "nasm(32bit)"
+	set EXE=nasm
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+endif
+
+set CFLAGS="-Wall -fno-operator-names -I../ $OPT2 -DUSE_AVX"
+echo "compile make_nm.cpp"
+g++ $CFLAGS make_nm.cpp -o make_nm
+
+./make_nm > a.asm
+echo "asm"
+$EXE -f$OPT3 a.asm -l a.lst
+awk '{if (index($3, "-")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = "" }} ' < a.lst | $FILTER | grep -v "1+1" > ok.lst
+
+echo "xbyak"
+./make_nm jit > nm.cpp
+echo "compile nm_frame.cpp"
+g++ $CFLAGS -DXBYAK_TEST nm_frame.cpp -o nm_frame
+./nm_frame | $FILTER > x.lst
+diff -B ok.lst x.lst && echo "ok"

externals/xbyak/test/test_avx512.bat

@@ -0,0 +1,31 @@
+@echo off
+set FILTER=cat
+set Y=0
+if /i "%1"=="min" (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK64 -DMIN_TEST
+	set OPT3=win64
+	set FILTER=normalize_prefix
+) else if /i "%1"=="64" (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+	set FILTER=normalize_prefix
+) else (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+)
+call set_opt
+bmake -f Makefile.win all
+echo cl -I../ make_512.cpp %OPT% %OPT2% /EHs /DUSE_AVX512
+cl -I../ make_512.cpp %OPT% %OPT2% /EHs /DUSE_AVX512
+make_512 > a.asm
+%EXE% -f %OPT3% -l a.lst a.asm
+rem connect "?????-" and "??"
+awk "{if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
+make_512 jit > nm.cpp
+cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2% /DXBYAK_AVX512
+nm_frame |%FILTER% > x.lst
+diff -w x.lst ok.lst
+wc x.lst

externals/xbyak/test/test_avx512.sh

@@ -0,0 +1,32 @@
+#!/bin/tcsh
+
+set FILTER="grep -v warning"
+
+if ($1 == "64") then
+	echo "nasm(64bit)"
+	set EXE=nasm
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+	set FILTER=./normalize_prefix
+else
+	echo "nasm(32bit)"
+	set EXE=nasm
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+endif
+
+set CFLAGS="-Wall -fno-operator-names -I../ $OPT2 -DUSE_AVX512"
+echo "compile make_512.cpp"
+g++ $CFLAGS make_512.cpp -o make_512
+
+./make_512 > a.asm
+echo "asm"
+$EXE -f$OPT3 a.asm -l a.lst
+awk '{if (index($3, "-")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = "" }} ' < a.lst | $FILTER > ok.lst
+
+echo "xbyak"
+./make_512 jit > nm.cpp
+echo "compile nm_frame.cpp"
+g++ $CFLAGS -DXBYAK_TEST nm_frame.cpp -o nm_frame -DXBYAK_AVX512
+./nm_frame | $FILTER > x.lst
+diff -B ok.lst x.lst && echo "ok"

externals/xbyak/test/test_avx_all.bat

@@ -0,0 +1,13 @@
+@echo off
+echo ** nasm-avx(32bit) ***
+call test_avx
+echo ** nasm-avx(64bit) ***
+call test_avx 64
+echo ** yasm-avx(32bit) ***
+call test_avx Y
+echo ** yasm-avx(64bit) ***
+call test_avx Y64
+echo ** nasm-avx512(32bit) ***
+call test_avx512
+echo ** nasm-avx512(64bit) ***
+call test_avx512 64

externals/xbyak/test/test_jmp.bat

@@ -0,0 +1,4 @@
+call set_opt
+bmake -f Makefile.win all
+cl -I../ -I./ -DXBYAK_TEST jmp.cpp %OPT% /Od /Zi
+jmp

externals/xbyak/test/test_misc.bat

@@ -0,0 +1,4 @@
+call set_opt
+bmake -f Makefile.win all
+cl -I../ -I./ -DXBYAK_TEST misc.cpp %OPT% /Od /Zi
+misc

externals/xbyak/test/test_mmx.cpp

@@ -0,0 +1,78 @@
+#if defined(_MSC_VER) && (_MSC_VER <= 1200)
+	#pragma warning(disable:4514)
+	#pragma warning(disable:4786)
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include "../../include.mie/mie_thread.h"
+#include "xbyak/xbyak.h"
+
+class WriteMMX : public Xbyak::CodeGenerator {
+public:
+	WriteMMX()
+	{
+#ifdef XBYAK32
+		mov(ecx, ptr [esp + 4]);
+#endif
+		movd(mm0, ecx);
+		ret();
+	}
+	void (*set() const)(int x) { return (void (*)(int x))getCode(); }
+};
+
+class ReadMMX : public Xbyak::CodeGenerator {
+public:
+	ReadMMX()
+	{
+		movd(eax, mm0);
+		ret();
+	}
+	int (*get() const)() { return (int (*)())getCode(); }
+};
+
+class Test : public MIE::ThreadBase<Test> {
+	int n_;
+public:
+	Test(int n)
+		: n_(n)
+	{
+	}
+	void threadEntry()
+	{
+		printf("n=%d\n", n_);
+		WriteMMX w;
+		w.set()(n_);
+		ReadMMX r;
+		for (;;) {
+			int b = r.get()();
+			printf("b=%d\n", b);
+			if (b != n_) {
+				printf("mm0 has changed!\n");
+			}
+			MIE::MIE_Sleep(1000);
+		}
+	}
+	void stopThread() { }
+};
+
+int main(int argc, char *argv[])
+{
+#ifdef XBYAK32
+	puts("32bit");
+#else
+	puts("64bit");
+#endif
+	try {
+		int n = atoi(argc == 1 ? "1223" : argv[1]);
+		Test test0(n), test1(n + 1);
+		test0.beginThread();
+		test1.beginThread();
+
+		test0.joinThread();
+		test1.joinThread();
+	} catch (std::exception& e) {
+		printf("ERR:%s\n", e.what());
+	} catch (...) {
+		printf("unknown error\n");
+	}
+}

externals/xbyak/test/test_nm.bat

@@ -0,0 +1,46 @@
+@echo off
+set FILTER=cat
+set Y=0
+if /i "%1"=="Y" (
+	set Y=1
+	set EXE=yasm.exe
+	set OPT2=-DUSE_YASM -DXBYAK32
+	set OPT3=win32
+) else if /i "%1"=="64" (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+	set FILTER=normalize_prefix
+) else if /i "%1"=="Y64" (
+	set Y=1
+	set EXE=yasm.exe
+	set OPT2=-DUSE_YASM -DXBYAK64
+	set OPT3=win64
+	set FILTER=normalize_prefix
+) else if /i "%1"=="noexcept" (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK32 -DXBYAK_NO_EXCEPTION
+	set OPT3=win32
+) else (
+	set EXE=nasm.exe
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+)
+call set_opt
+bmake -f Makefile.win all
+echo cl -I../ make_nm.cpp %OPT% %OPT2% /EHs
+cl -I../ make_nm.cpp %OPT% %OPT2% /EHs
+make_nm > a.asm
+rm -rf a.lst
+echo %EXE% -f %OPT3% -l a.lst a.asm
+%EXE% -f %OPT3% -l a.lst a.asm
+rem connect "?????-" and "??"
+if /i "%Y%"=="1" (
+	awk "NR > 1 {if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
+) else (
+	awk "{if (index($3, ""-"")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = """" }} " < a.lst |%FILTER% > ok.lst
+)
+make_nm jit > nm.cpp
+cl -I../ -DXBYAK_TEST nm_frame.cpp %OPT% %OPT2%
+nm_frame |%FILTER% > x.lst
+diff -wb x.lst ok.lst && echo "ok"

externals/xbyak/test/test_nm.sh

@@ -0,0 +1,54 @@
+#!/bin/tcsh
+
+set FILTER=cat
+
+if ($1 == "Y") then
+	echo "yasm(32bit)"
+	set EXE=yasm
+	set OPT2="-DUSE_YASM -DXBYAK32"
+	set OPT3=win32
+else if ($1 == "64") then
+	echo "nasm(64bit)"
+	set EXE=nasm
+	set OPT2=-DXBYAK64
+	set OPT3=win64
+	set FILTER=./normalize_prefix
+else if ($1 == "Y64") then
+	echo "yasm(64bit)"
+	set EXE=yasm
+	set OPT2="-DUSE_YASM -DXBYAK64"
+	set OPT3=win64
+	set FILTER=./normalize_prefix
+else if ($1 == "avx512") then
+	echo "nasm(64bit) + avx512"
+	set EXE=nasm
+	set OPT2="-DXBYAK64 -DUSE_AVX512"
+	set OPT3=win64
+	set FILTER=./normalize_prefix
+else if ($1 == "noexcept") then
+	echo "nasm(32bit) without exception"
+	set EXE=nasm
+	set OPT2="-DXBYAK32 -DXBYAK_NO_EXCEPTION"
+	set OPT3=win32
+else
+	echo "nasm(32bit)"
+	set EXE=nasm
+	set OPT2=-DXBYAK32
+	set OPT3=win32
+endif
+
+set CFLAGS="-Wall -fno-operator-names -I../ $OPT2"
+echo "compile make_nm.cpp with $CFLAGS"
+g++ $CFLAGS make_nm.cpp -o make_nm
+
+./make_nm > a.asm
+echo "asm"
+$EXE -f$OPT3 a.asm -l a.lst
+awk '{if (index($3, "-")) { conti=substr($3, 0, length($3) - 1) } else { conti = conti $3; print conti; conti = "" }} ' < a.lst | $FILTER | grep -v "1+1" > ok.lst
+
+echo "xbyak"
+./make_nm jit > nm.cpp
+echo "compile nm_frame.cpp"
+g++ $CFLAGS -DXBYAK_TEST nm_frame.cpp -o nm_frame
+./nm_frame | $FILTER > x.lst
+diff -B ok.lst x.lst && echo "ok"

externals/xbyak/test/test_nm_all.bat

@@ -0,0 +1,11 @@
+@echo off
+echo *** nasm(32bit) ***
+call test_nm
+echo *** yasm(32bit) ***
+call test_nm Y
+echo *** nasm(64bit) ***
+call test_nm 64
+echo *** yasm(64bit) ***
+call test_nm Y64
+
+call test_avx_all