replace B[01]+ with hex value
diff --git a/gen/gen_code.cpp b/gen/gen_code.cpp
index eba0ffc..5983545 100644
--- a/gen/gen_code.cpp
+++ b/gen/gen_code.cpp
@@ -75,42 +75,42 @@
const char *name;
} tbl[] = {
// MMX
- { B01101011, "packssdw" },
- { B01100011, "packsswb" },
- { B01100111, "packuswb" },
+ { 0x6B, "packssdw" },
+ { 0x63, "packsswb" },
+ { 0x67, "packuswb" },
- { B11011011, "pand" },
- { B11011111, "pandn" },
+ { 0xDB, "pand" },
+ { 0xDF, "pandn" },
- { B11110101, "pmaddwd" },
- { B11100100, "pmulhuw" },
- { B11100101, "pmulhw" },
- { B11010101, "pmullw" },
+ { 0xF5, "pmaddwd" },
+ { 0xE4, "pmulhuw" },
+ { 0xE5, "pmulhw" },
+ { 0xD5, "pmullw" },
- { B11101011, "por" },
+ { 0xEB, "por" },
- { B01101000, "punpckhbw" },
- { B01101001, "punpckhwd" },
- { B01101010, "punpckhdq" },
+ { 0x68, "punpckhbw" },
+ { 0x69, "punpckhwd" },
+ { 0x6A, "punpckhdq" },
- { B01100000, "punpcklbw" },
- { B01100001, "punpcklwd" },
- { B01100010, "punpckldq" },
+ { 0x60, "punpcklbw" },
+ { 0x61, "punpcklwd" },
+ { 0x62, "punpckldq" },
- { B11101111, "pxor" },
+ { 0xEF, "pxor" },
// MMX2
- { B11100000, "pavgb" },
- { B11100011, "pavgw" },
- { B11101110, "pmaxsw" },
- { B11011110, "pmaxub" },
- { B11101010, "pminsw" },
- { B11011010, "pminub" },
- { B11110110, "psadbw" },
+ { 0xE0, "pavgb" },
+ { 0xE3, "pavgw" },
+ { 0xEE, "pmaxsw" },
+ { 0xDE, "pmaxub" },
+ { 0xEA, "pminsw" },
+ { 0xDA, "pminub" },
+ { 0xF6, "psadbw" },
//
- { B11010100, "paddq" },
- { B11110100, "pmuludq" },
- { B11111011, "psubq" },
+ { 0xD4, "paddq" },
+ { 0xF4, "pmuludq" },
+ { 0xFB, "psubq" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -125,17 +125,17 @@
int mode;
const char *name;
} tbl[] = {
- { B11111100, B|W|D, "padd" },
- { B11101100, B|W , "padds" },
- { B11011100, B|W , "paddus" },
- { B01110100, B|W|D, "pcmpeq" },
- { B01100100, B|W|D, "pcmpgt" },
- { B11110000, W|D|Q, "psll" },
- { B11100000, W|D , "psra" },
- { B11010000, W|D|Q, "psrl" },
- { B11111000, B|W|D, "psub" },
- { B11101000, B|W , "psubs" },
- { B11011000, B|W , "psubus" },
+ { 0xFC, B|W|D, "padd" },
+ { 0xEC, B|W , "padds" },
+ { 0xDC, B|W , "paddus" },
+ { 0x74, B|W|D, "pcmpeq" },
+ { 0x64, B|W|D, "pcmpgt" },
+ { 0xF0, W|D|Q, "psll" },
+ { 0xE0, W|D , "psra" },
+ { 0xD0, W|D|Q, "psrl" },
+ { 0xF8, B|W|D, "psub" },
+ { 0xE8, B|W , "psubs" },
+ { 0xD8, B|W , "psubus" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -160,9 +160,9 @@
int mode;
const char *name;
} tbl[] = {
- { B01110000, 6, W|D|Q, "psll" },
- { B01110000, 4, W|D , "psra" },
- { B01110000, 2, W|D|Q, "psrl" },
+ { 0x70, 6, W|D|Q, "psll" },
+ { 0x70, 4, W|D , "psra" },
+ { 0x70, 2, W|D|Q, "psrl" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -179,8 +179,8 @@
);
}
}
- printf("void pslldq(const Xmm& xmm, int imm8) { opMMX_IMM(xmm, imm8, 0x%02X, %d); }\n", B01110011, 7);
- printf("void psrldq(const Xmm& xmm, int imm8) { opMMX_IMM(xmm, imm8, 0x%02X, %d); }\n", B01110011, 3);
+ printf("void pslldq(const Xmm& xmm, int imm8) { opMMX_IMM(xmm, imm8, 0x%02X, %d); }\n", 0x73, 7);
+ printf("void psrldq(const Xmm& xmm, int imm8) { opMMX_IMM(xmm, imm8, 0x%02X, %d); }\n", 0x73, 3);
}
{
@@ -189,10 +189,10 @@
uint8 pref;
const char *name;
} tbl[] = {
- { B01110000, 0, "pshufw" },
- { B01110000, 0xF2, "pshuflw" },
- { B01110000, 0xF3, "pshufhw" },
- { B01110000, 0x66, "pshufd" },
+ { 0x70, 0, "pshufw" },
+ { 0x70, 0xF2, "pshuflw" },
+ { 0x70, 0xF3, "pshufhw" },
+ { 0x70, 0x66, "pshufd" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -206,15 +206,15 @@
int pref;
const char *name;
} mmxTbl6[] = {
- { B01101111, B01111111, 0x66, "movdqa" },
- { B01101111, B01111111, 0xF3, "movdqu" },
+ { 0x6F, 0x7F, 0x66, "movdqa" },
+ { 0x6F, 0x7F, 0xF3, "movdqu" },
// SSE2
- { B00101000, B00101001, NO, "movaps" },
- { B00010000, B00010001, 0xF3, "movss" },
- { B00010000, B00010001, NO, "movups" },
- { B00101000, B00101001, 0x66, "movapd" },
- { B00010000, B00010001, 0xF2, "movsd" },
- { B00010000, B00010001, 0x66, "movupd" },
+ { 0x28, 0x29, NO, "movaps" },
+ { 0x10, 0x11, 0xF3, "movss" },
+ { 0x10, 0x11, NO, "movups" },
+ { 0x28, 0x29, 0x66, "movapd" },
+ { 0x10, 0x11, 0xF2, "movsd" },
+ { 0x10, 0x11, 0x66, "movupd" },
};
for (int i = 0; i < NUM_OF_ARRAY(mmxTbl6); i++) {
const MmxTbl6 *p = &mmxTbl6[i];
@@ -246,23 +246,23 @@
const char *name;
bool hasImm;
} tbl[] = {
- { B01011000, PS|SS|PD|SD, "add" },
- { B01010101, PS|PD , "andn" },
- { B01010100, PS|PD , "and" },
- { B11000010, PS|SS|PD|SD, "cmp", true },
- { B01011110, PS|SS|PD|SD, "div" },
- { B01011111, PS|SS|PD|SD, "max" },
- { B01011101, PS|SS|PD|SD, "min" },
- { B01011001, PS|SS|PD|SD, "mul" },
- { B01010110, PS|PD , "or" },
- { B01010011, PS|SS , "rcp" },
- { B01010010, PS|SS , "rsqrt" },
- { B11000110, PS|PD , "shuf", true },
- { B01010001, PS|SS|PD|SD, "sqrt" },
- { B01011100, PS|SS|PD|SD, "sub" },
- { B00010101, PS|PD , "unpckh" },
- { B00010100, PS|PD , "unpckl" },
- { B01010111, PS|PD , "xor" },
+ { 0x58, PS|SS|PD|SD, "add" },
+ { 0x55, PS|PD , "andn" },
+ { 0x54, PS|PD , "and" },
+ { 0xC2, PS|SS|PD|SD, "cmp", true },
+ { 0x5E, PS|SS|PD|SD, "div" },
+ { 0x5F, PS|SS|PD|SD, "max" },
+ { 0x5D, PS|SS|PD|SD, "min" },
+ { 0x59, PS|SS|PD|SD, "mul" },
+ { 0x56, PS|PD , "or" },
+ { 0x53, PS|SS , "rcp" },
+ { 0x52, PS|SS , "rsqrt" },
+ { 0xC6, PS|PD , "shuf", true },
+ { 0x51, PS|SS|PD|SD, "sqrt" },
+ { 0x5C, PS|SS|PD|SD, "sub" },
+ { 0x15, PS|PD , "unpckh" },
+ { 0x14, PS|PD , "unpckl" },
+ { 0x57, PS|PD , "xor" },
//
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
@@ -285,9 +285,9 @@
uint8 pref;
const char *name;
} tbl[] = {
- { B11110111, 0x66, "maskmovdqu" },
- { B00010010, 0 , "movhlps" },
- { B00010110, 0 , "movlhps" },
+ { 0xF7, 0x66, "maskmovdqu" },
+ { 0x12, 0 , "movhlps" },
+ { 0x16, 0 , "movlhps" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -303,36 +303,36 @@
int pref;
const char *name;
} tbl[] = {
- { B01101101, 0x66, "punpckhqdq" },
- { B01101100, 0x66, "punpcklqdq" },
+ { 0x6D, 0x66, "punpckhqdq" },
+ { 0x6C, 0x66, "punpcklqdq" },
- { B00101111, NO , "comiss" },
- { B00101110, NO , "ucomiss" },
- { B00101111, 0x66, "comisd" },
- { B00101110, 0x66, "ucomisd" },
+ { 0x2F, NO , "comiss" },
+ { 0x2E, NO , "ucomiss" },
+ { 0x2F, 0x66, "comisd" },
+ { 0x2E, 0x66, "ucomisd" },
- { B01011010, 0x66, "cvtpd2ps" },
- { B01011010, NO , "cvtps2pd" },
- { B01011010, 0xF2, "cvtsd2ss" },
- { B01011010, 0xF3, "cvtss2sd" },
- { B11100110, 0xF2, "cvtpd2dq" },
- { B11100110, 0x66, "cvttpd2dq" },
- { B11100110, 0xF3, "cvtdq2pd" },
- { B01011011, 0x66, "cvtps2dq" },
- { B01011011, 0xF3, "cvttps2dq" },
- { B01011011, NO , "cvtdq2ps" },
+ { 0x5A, 0x66, "cvtpd2ps" },
+ { 0x5A, NO , "cvtps2pd" },
+ { 0x5A, 0xF2, "cvtsd2ss" },
+ { 0x5A, 0xF3, "cvtss2sd" },
+ { 0xE6, 0xF2, "cvtpd2dq" },
+ { 0xE6, 0x66, "cvttpd2dq" },
+ { 0xE6, 0xF3, "cvtdq2pd" },
+ { 0x5B, 0x66, "cvtps2dq" },
+ { 0x5B, 0xF3, "cvttps2dq" },
+ { 0x5B, NO , "cvtdq2ps" },
// SSE3
- { B11010000, 0x66, "addsubpd" },
- { B11010000, 0xF2, "addsubps" },
- { B01111100, 0x66, "haddpd" },
- { B01111100, 0xF2, "haddps" },
- { B01111101, 0x66, "hsubpd" },
- { B01111101, 0xF2, "hsubps" },
+ { 0xD0, 0x66, "addsubpd" },
+ { 0xD0, 0xF2, "addsubps" },
+ { 0x7C, 0x66, "haddpd" },
+ { 0x7C, 0xF2, "haddps" },
+ { 0x7D, 0x66, "hsubpd" },
+ { 0x7D, 0xF2, "hsubps" },
- { B00010010, 0xF2, "movddup" },
- { B00010110, 0xF3, "movshdup" },
- { B00010010, 0xF3, "movsldup" },
+ { 0x12, 0xF2, "movddup" },
+ { 0x16, 0xF3, "movshdup" },
+ { 0x12, 0xF3, "movsldup" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -348,18 +348,18 @@
const char *name;
const char *cond;
} tbl[] = {
- { B00101010, NO , "cvtpi2ps", "isXMM_MMXorMEM" },
- { B00101101, NO , "cvtps2pi", "isMMX_XMMorMEM" },
- { B00101010, 0xF3, "cvtsi2ss", "isXMM_REG32orMEM" },
- { B00101101, 0xF3, "cvtss2si", "isREG32_XMMorMEM" },
- { B00101100, NO , "cvttps2pi", "isMMX_XMMorMEM" },
- { B00101100, 0xF3, "cvttss2si", "isREG32_XMMorMEM" },
- { B00101010, 0x66, "cvtpi2pd", "isXMM_MMXorMEM" },
- { B00101101, 0x66, "cvtpd2pi", "isMMX_XMMorMEM" },
- { B00101010, 0xF2, "cvtsi2sd", "isXMM_REG32orMEM" },
- { B00101101, 0xF2, "cvtsd2si", "isREG32_XMMorMEM" },
- { B00101100, 0x66, "cvttpd2pi", "isMMX_XMMorMEM" },
- { B00101100, 0xF2, "cvttsd2si", "isREG32_XMMorMEM" },
+ { 0x2A, NO , "cvtpi2ps", "isXMM_MMXorMEM" },
+ { 0x2D, NO , "cvtps2pi", "isMMX_XMMorMEM" },
+ { 0x2A, 0xF3, "cvtsi2ss", "isXMM_REG32orMEM" },
+ { 0x2D, 0xF3, "cvtss2si", "isREG32_XMMorMEM" },
+ { 0x2C, NO , "cvttps2pi", "isMMX_XMMorMEM" },
+ { 0x2C, 0xF3, "cvttss2si", "isREG32_XMMorMEM" },
+ { 0x2A, 0x66, "cvtpi2pd", "isXMM_MMXorMEM" },
+ { 0x2D, 0x66, "cvtpd2pi", "isMMX_XMMorMEM" },
+ { 0x2A, 0xF2, "cvtsi2sd", "isXMM_REG32orMEM" },
+ { 0x2D, 0xF2, "cvtsd2si", "isREG32_XMMorMEM" },
+ { 0x2C, 0x66, "cvttpd2pi", "isMMX_XMMorMEM" },
+ { 0x2C, 0xF2, "cvttsd2si", "isREG32_XMMorMEM" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -379,7 +379,7 @@
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
- printf("void prefetch%s(const Address& addr) { opModM(addr, Reg32(%d), 0x0F, B00011000); }\n", p->name, p->ext);
+ printf("void prefetch%s(const Address& addr) { opModM(addr, Reg32(%d), 0x0F, 0x18); }\n", p->name, p->ext);
}
}
{
@@ -388,10 +388,10 @@
int pref;
const char *name;
} tbl[] = {
- { B00010110, NO, "movhps" },
- { B00010010, NO, "movlps" },
- { B00010110, 0x66, "movhpd" },
- { B00010010, 0x66, "movlpd" },
+ { 0x16, NO, "movhps" },
+ { 0x12, NO, "movlps" },
+ { 0x16, 0x66, "movhpd" },
+ { 0x12, 0x66, "movlpd" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -437,12 +437,12 @@
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
- printf("void cmov%s(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | %d); }\n", p->name, p->ext);
- printf("void j%s(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x%02X, 0x%02X, 0x%02X); }\n", p->name, p->ext | B01110000, p->ext | B10000000, 0x0F);
- printf("void j%s(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x%02X, 0x%02X, 0x%02X); }\n", p->name, p->ext | B01110000, p->ext | B10000000, 0x0F);
+ printf("void cmov%s(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | %d); }\n", p->name, p->ext);
+ printf("void j%s(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x%02X, 0x%02X, 0x%02X); }\n", p->name, p->ext | 0x70, p->ext | 0x80, 0x0F);
+ printf("void j%s(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x%02X, 0x%02X, 0x%02X); }\n", p->name, p->ext | 0x70, p->ext | 0x80, 0x0F);
printf("void j%s(const char *label, LabelType type = T_AUTO) { j%s(std::string(label), type); }\n", p->name, p->name);
- printf("void j%s(const void *addr) { opJmpAbs(addr, T_NEAR, 0x%02X, 0x%02X, 0x%02X); }\n", p->name, p->ext | B01110000, p->ext | B10000000, 0x0F);
- printf("void set%s(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | %d); }\n", p->name, p->ext);
+ printf("void j%s(const void *addr) { opJmpAbs(addr, T_NEAR, 0x%02X, 0x%02X, 0x%02X); }\n", p->name, p->ext | 0x70, p->ext | 0x80, 0x0F);
+ printf("void set%s(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | %d); }\n", p->name, p->ext);
}
puts("#ifdef XBYAK32");
put_jREGz("cx", true);
@@ -461,65 +461,65 @@
uint8 code3;
} tbl[] = {
// only 64-bit mode(from)
- { "cdqe", B01001000, B10011000 },
+ { "cdqe", 0x48, 0x98 },
{ "cqo", 0x48, 0x99 },
{ "@@@" }, /// here
// only 32-bit mode(from)
- { "aaa", B00110111 },
- { "aad", B11010101, B00001010 },
- { "aam", B11010100, B00001010 },
- { "aas", B00111111 },
- { "daa", B00100111 },
- { "das", B00101111 },
- { "popad", B01100001 },
- { "popfd", B10011101 },
- { "pusha", B01100000 },
- { "pushad", B01100000 },
- { "pushfd", B10011100 },
- { "popa", B01100001 },
+ { "aaa", 0x37 },
+ { "aad", 0xD5, 0x0A },
+ { "aam", 0xD4, 0x0A },
+ { "aas", 0x3F },
+ { "daa", 0x27 },
+ { "das", 0x2F },
+ { "popad", 0x61 },
+ { "popfd", 0x9D },
+ { "pusha", 0x60 },
+ { "pushad", 0x60 },
+ { "pushfd", 0x9C },
+ { "popa", 0x61 },
{ "@@@" }, /// here
- { "cbw", 0x66, B10011000 },
- { "cdq", B10011001 },
- { "clc", B11111000 },
- { "cld", B11111100 },
- { "cli", B11111010 },
- { "cmc", B11110101 },
+ { "cbw", 0x66, 0x98 },
+ { "cdq", 0x99 },
+ { "clc", 0xF8 },
+ { "cld", 0xFC },
+ { "cli", 0xFA },
+ { "cmc", 0xF5 },
- { "cpuid", 0x0F, B10100010 },
- { "cwd", 0x66, B10011001 },
- { "cwde", B10011000 },
+ { "cpuid", 0x0F, 0xA2 },
+ { "cwd", 0x66, 0x99 },
+ { "cwde", 0x98 },
- { "lahf", B10011111 },
- { "lock", B11110000 },
- { "nop", B10010000 },
+ { "lahf", 0x9F },
+ { "lock", 0xF0 },
+ { "nop", 0x90 },
- { "sahf", B10011110 },
- { "stc", B11111001 },
- { "std", B11111101 },
- { "sti", B11111011 },
+ { "sahf", 0x9E },
+ { "stc", 0xF9 },
+ { "std", 0xFD },
+ { "sti", 0xFB },
- { "emms", 0x0F, B01110111 },
- { "pause", 0xF3, B10010000 },
- { "sfence", 0x0F, B10101110, B11111000 },
- { "lfence", 0x0F, B10101110, B11101000 },
- { "mfence", 0x0F, B10101110, B11110000 },
- { "monitor", 0x0F, B00000001, B11001000 },
- { "mwait", 0x0F, B00000001, B11001001 },
+ { "emms", 0x0F, 0x77 },
+ { "pause", 0xF3, 0x90 },
+ { "sfence", 0x0F, 0xAE, 0xF8 },
+ { "lfence", 0x0F, 0xAE, 0xE8 },
+ { "mfence", 0x0F, 0xAE, 0xF0 },
+ { "monitor", 0x0F, 0x01, 0xC8 },
+ { "mwait", 0x0F, 0x01, 0xC9 },
- { "rdmsr", 0x0F, B00110010 },
- { "rdpmc", 0x0F, B00110011 },
- { "rdtsc", 0x0F, B00110001 },
+ { "rdmsr", 0x0F, 0x32 },
+ { "rdpmc", 0x0F, 0x33 },
+ { "rdtsc", 0x0F, 0x31 },
{ "rdtscp", 0x0F, 0x01, 0xF9 },
{ "ud2", 0x0F, 0x0B },
{ "wait", 0x9B },
{ "fwait", 0x9B },
- { "wbinvd", 0x0F, B00001001 },
- { "wrmsr", 0x0F, B00110000 },
+ { "wbinvd", 0x0F, 0x09 },
+ { "wrmsr", 0x0F, 0x30 },
{ "xlatb", 0xD7 },
- { "popf", B10011101 },
- { "pushf", B10011100 },
+ { "popf", 0x9D },
+ { "pushf", 0x9C },
{ "stac", 0x0F, 0x01, 0xCB },
{ "vzeroall", 0xC5, 0xFC, 0x77 },
@@ -597,14 +597,14 @@
uint8 ext; // (reg, imm)
const char *name;
} tbl[] = {
- { B00010000, 2, "adc" },
- { B00000000, 0, "add" },
- { B00100000, 4, "and" },
- { B00111000, 7, "cmp" },
- { B00001000, 1, "or" },
- { B00011000, 3, "sbb" },
- { B00101000, 5, "sub" },
- { B00110000, 6, "xor" },
+ { 0x10, 2, "adc" },
+ { 0x00, 0, "add" },
+ { 0x20, 4, "and" },
+ { 0x38, 7, "cmp" },
+ { 0x08, 1, "or" },
+ { 0x18, 3, "sbb" },
+ { 0x28, 5, "sub" },
+ { 0x30, 6, "xor" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -629,8 +629,8 @@
uint8 ext;
const char *name;
} tbl[] = {
- { B01001000, 1, "dec" },
- { B01000000, 0, "inc" },
+ { 0x48, 1, "dec" },
+ { 0x40, 0, "inc" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -660,12 +660,12 @@
uint8 ext;
const char *name;
} tbl[] = {
- { B11110110, 6, "div" },
- { B11110110, 7, "idiv" },
- { B11110110, 5, "imul" },
- { B11110110, 4, "mul" },
- { B11110110, 3, "neg" },
- { B11110110, 2, "not" },
+ { 0xF6, 6, "div" },
+ { 0xF6, 7, "idiv" },
+ { 0xF6, 5, "imul" },
+ { 0xF6, 4, "mul" },
+ { 0xF6, 3, "neg" },
+ { 0xF6, 2, "not" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -707,8 +707,8 @@
const char *name;
uint8 code;
} tbl[] = {
- { "shld", B10100100 },
- { "shrd", B10101100 },
+ { "shld", 0xA4 },
+ { "shrd", 0xAC },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -871,9 +871,9 @@
uint8 ext;
const char *name;
} tbl[] = {
- { 0x0F, B10101110, 2, "ldmxcsr" },
- { 0x0F, B10101110, 3, "stmxcsr" },
- { 0x0F, B10101110, 7, "clflush" }, // 0x80 is bug of nasm ?
+ { 0x0F, 0xAE, 2, "ldmxcsr" },
+ { 0x0F, 0xAE, 3, "stmxcsr" },
+ { 0x0F, 0xAE, 7, "clflush" }, // 0x80 is bug of nasm ?
{ 0xD9, NONE, 5, "fldcw" },
// { 0x9B, 0xD9, 7, "fstcw" }, // not correct order for fstcw [eax] on 64bit OS
};
@@ -888,8 +888,8 @@
uint8 code;
const char *name;
} tbl[] = {
- { B00101011, "movntpd" },
- { B11100111, "movntdq" },
+ { 0x2B, "movntpd" },
+ { 0xE7, "movntdq" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
@@ -902,8 +902,8 @@
uint8 code;
const char *name;
} tbl[] = {
- { B10111110, "movsx" },
- { B10110110, "movzx" },
+ { 0xBE, "movsx" },
+ { 0xB6, "movzx" },
};
for (int i = 0; i < NUM_OF_ARRAY(tbl); i++) {
const Tbl *p = &tbl[i];
diff --git a/xbyak/xbyak.h b/xbyak/xbyak.h
index 5d3f33d..d8bfa73 100644
--- a/xbyak/xbyak.h
+++ b/xbyak/xbyak.h
@@ -879,7 +879,7 @@
size_t getSize() const { return size_; }
void updateRegField(uint8 regIdx) const
{
- *top_ = (*top_ & B11000111) | ((regIdx << 3) & B00111000);
+ *top_ = (*top_ & 0xC7) | ((regIdx << 3) & 0x38);
}
void setVsib(bool isVsib) const { isVsib_ = isVsib; }
bool isVsib() const { return isVsib_; }
@@ -1444,9 +1444,9 @@
{
if (hasMMX2 && op.isREG(i32e)) { /* pextrw is special */
if (mmx.isXMM()) db(0x66);
- opModR(static_cast<const Reg&>(op), mmx, 0x0F, B11000101); db(imm);
+ opModR(static_cast<const Reg&>(op), mmx, 0x0F, 0xC5); db(imm);
} else {
- opGen(mmx, op, code, 0x66, isXMM_REG32orMEM, imm, B00111010);
+ opGen(mmx, op, code, 0x66, isXMM_REG32orMEM, imm, 0x3A);
}
}
void opR_ModM(const Operand& op, int bit, int ext, int code0, int code1 = NONE, int code2 = NONE, bool disableRex = false, int immSize = 0)
@@ -1464,13 +1464,13 @@
void opShift(const Operand& op, int imm, int ext)
{
verifyMemHasSize(op);
- opR_ModM(op, 0, ext, (B11000000 | ((imm == 1 ? 1 : 0) << 4)), NONE, NONE, false, (imm != 1) ? 1 : 0);
+ opR_ModM(op, 0, ext, (0xC0 | ((imm == 1 ? 1 : 0) << 4)), NONE, NONE, false, (imm != 1) ? 1 : 0);
if (imm != 1) db(imm);
}
void opShift(const Operand& op, const Reg8& _cl, int ext)
{
if (_cl.getIdx() != Operand::CL) throw Error(ERR_BAD_COMBINATION);
- opR_ModM(op, 0, ext, B11010010);
+ opR_ModM(op, 0, ext, 0xD2);
}
void opModRM(const Operand& op1, const Operand& op2, bool condR, bool condM, int code0, int code1 = NONE, int code2 = NONE, int immSize = 0)
{
@@ -1510,7 +1510,7 @@
db(code | 4 | (immBit == 8 ? 0 : 1));
} else {
int tmp = immBit < (std::min)(op.getBit(), 32U) ? 2 : 0;
- opR_ModM(op, 0, ext, B10000000 | tmp, NONE, NONE, false, immBit / 8);
+ opR_ModM(op, 0, ext, 0x80 | tmp, NONE, NONE, false, immBit / 8);
}
db(imm, immBit / 8);
}
@@ -1523,7 +1523,7 @@
return;
}
#endif
- code = B11111110;
+ code = 0xFE;
if (op.isREG()) {
opModR(Reg(ext, Operand::REG, op.getBit()), static_cast<const Reg&>(op), code);
} else {
@@ -1718,16 +1718,16 @@
void outLocalLabel() { labelMgr_.leaveLocal(); }
void jmp(std::string label, LabelType type = T_AUTO)
{
- opJmp(label, type, B11101011, B11101001, 0);
+ opJmp(label, type, 0xEB, 0xE9, 0);
}
void jmp(const Label& label, LabelType type = T_AUTO)
{
- opJmp(label, type, B11101011, B11101001, 0);
+ opJmp(label, type, 0xEB, 0xE9, 0);
}
void jmp(const char *label, LabelType type = T_AUTO) { jmp(std::string(label), type); }
void jmp(const void *addr, LabelType type = T_AUTO)
{
- opJmpAbs(addr, type, B11101011, B11101001);
+ opJmpAbs(addr, type, 0xEB, 0xE9);
}
void jmp(const Operand& op)
{
@@ -1740,7 +1740,7 @@
// (REG|MEM, REG)
void test(const Operand& op, const Reg& reg)
{
- opModRM(reg, op, op.isREG() && (op.getKind() == reg.getKind()), op.isMEM(), B10000100);
+ opModRM(reg, op, op.isREG() && (op.getKind() == reg.getKind()), op.isMEM(), 0x84);
}
// (REG|MEM, IMM)
void test(const Operand& op, uint32 imm)
@@ -1749,48 +1749,48 @@
int immSize = (std::min)(op.getBit() / 8, 4U);
if (op.isREG() && op.getIdx() == 0) { // al, ax, eax
rex(op);
- db(B10101000 | (op.isBit(8) ? 0 : 1));
+ db(0xA8 | (op.isBit(8) ? 0 : 1));
} else {
- opR_ModM(op, 0, 0, B11110110, NONE, NONE, false, immSize);
+ opR_ModM(op, 0, 0, 0xF6, NONE, NONE, false, immSize);
}
db(imm, immSize);
}
void ret(int imm = 0)
{
if (imm) {
- db(B11000010); dw(imm);
+ db(0xC2); dw(imm);
} else {
- db(B11000011);
+ db(0xC3);
}
}
// (REG16|REG32, REG16|REG32|MEM)
void imul(const Reg& reg, const Operand& op)
{
- opModRM(reg, op, op.isREG() && (reg.getKind() == op.getKind()), op.isMEM(), 0x0F, B10101111);
+ opModRM(reg, op, op.isREG() && (reg.getKind() == op.getKind()), op.isMEM(), 0x0F, 0xAF);
}
void imul(const Reg& reg, const Operand& op, int imm)
{
int s = inner::IsInDisp8(imm) ? 1 : 0;
int immSize = s ? 1 : reg.isREG(16) ? 2 : 4;
- opModRM(reg, op, op.isREG() && (reg.getKind() == op.getKind()), op.isMEM(), B01101001 | (s << 1), NONE, NONE, immSize);
+ opModRM(reg, op, op.isREG() && (reg.getKind() == op.getKind()), op.isMEM(), 0x69 | (s << 1), NONE, NONE, immSize);
db(imm, immSize);
}
void pop(const Operand& op)
{
- opPushPop(op, B10001111, 0, B01011000);
+ opPushPop(op, 0x8F, 0, 0x58);
}
void push(const Operand& op)
{
- opPushPop(op, B11111111, 6, B01010000);
+ opPushPop(op, 0xFF, 6, 0x50);
}
void push(const AddressFrame& af, uint32 imm)
{
if (af.bit_ == 8 && inner::IsInDisp8(imm)) {
- db(B01101010); db(imm);
+ db(0x6A); db(imm);
} else if (af.bit_ == 16 && isInDisp16(imm)) {
- db(0x66); db(B01101000); dw(imm);
+ db(0x66); db(0x68); dw(imm);
} else {
- db(B01101000); dd(imm);
+ db(0x68); dd(imm);
}
}
/* use "push(word, 4)" if you want "push word 4" */
@@ -1842,12 +1842,12 @@
if (reg1.isREG() && reg1.getIdx() == 0 && reg2.isMEM()) { // mov eax|ax|al, [disp]
reg = &static_cast<const Reg&>(reg1);
addr= &static_cast<const Address&>(reg2);
- code = B10100000;
+ code = 0xA0;
} else
if (reg1.isMEM() && reg2.isREG() && reg2.getIdx() == 0) { // mov [disp], eax|ax|al
reg = &static_cast<const Reg&>(reg2);
addr= &static_cast<const Address&>(reg1);
- code = B10100010;
+ code = 0xA2;
}
#ifdef XBYAK64
if (addr && addr->is64bitDisp()) {
@@ -1867,7 +1867,7 @@
} else
#endif
{
- opRM_RM(reg1, reg2, B10001000);
+ opRM_RM(reg1, reg2, 0x88);
}
}
private:
@@ -1878,15 +1878,15 @@
{
int bit = reg.getBit();
const int idx = reg.getIdx();
- int code = B10110000 | ((bit == 8 ? 0 : 1) << 3);
+ int code = 0xB0 | ((bit == 8 ? 0 : 1) << 3);
if (bit == 64 && (imm & ~size_t(0xffffffffu)) == 0) {
rex(Reg32(idx));
bit = 32;
} else {
rex(reg);
if (bit == 64 && inner::IsInInt32(imm)) {
- db(B11000111);
- code = B11000000;
+ db(0xC7);
+ code = 0xC0;
bit = 32;
}
}
@@ -1930,7 +1930,7 @@
if (!inner::IsInInt32(imm)) throw Error(ERR_IMM_IS_TOO_BIG);
immSize = 4;
}
- opModM(static_cast<const Address&>(op), Reg(0, Operand::REG, op.getBit()), B11000110, NONE, NONE, immSize);
+ opModM(static_cast<const Address&>(op), Reg(0, Operand::REG, op.getBit()), 0xC6, NONE, NONE, immSize);
db(static_cast<uint32>(imm), immSize);
} else {
throw Error(ERR_BAD_COMBINATION);
@@ -1983,17 +1983,17 @@
void putL(const Label& label) { putL_inner(label); }
void adcx(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0x66, isREG32_REG32orMEM, NONE, 0x38); }
void adox(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0xF3, isREG32_REG32orMEM, NONE, 0x38); }
- void cmpxchg8b(const Address& addr) { opModM(addr, Reg32(1), 0x0F, B11000111); }
+ void cmpxchg8b(const Address& addr) { opModM(addr, Reg32(1), 0x0F, 0xC7); }
#ifdef XBYAK64
- void cmpxchg16b(const Address& addr) { opModM(addr, Reg64(1), 0x0F, B11000111); }
+ void cmpxchg16b(const Address& addr) { opModM(addr, Reg64(1), 0x0F, 0xC7); }
#endif
void xadd(const Operand& op, const Reg& reg)
{
- opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, B11000000 | (reg.isBit(8) ? 0 : 1));
+ opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xC0 | (reg.isBit(8) ? 0 : 1));
}
void cmpxchg(const Operand& op, const Reg& reg)
{
- opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xb0 | (reg.isBit(8) ? 0 : 1));
+ opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xB0 | (reg.isBit(8) ? 0 : 1));
}
void xchg(const Operand& op1, const Operand& op2)
{
@@ -2010,77 +2010,77 @@
rex(*p2, *p1); db(0x90 | (p2->getIdx() & 7));
return;
}
- opModRM(*p1, *p2, (p1->isREG() && p2->isREG() && (p1->getBit() == p2->getBit())), p2->isMEM(), B10000110 | (p1->isBit(8) ? 0 : 1));
+ opModRM(*p1, *p2, (p1->isREG() && p2->isREG() && (p1->getBit() == p2->getBit())), p2->isMEM(), 0x86 | (p1->isBit(8) ? 0 : 1));
}
- void call(std::string label) { opJmp(label, T_NEAR, 0, B11101000, 0); }
+ void call(std::string label) { opJmp(label, T_NEAR, 0, 0xE8, 0); }
// call(string label)
void call(const char *label) { call(std::string(label)); }
- void call(const Label& label) { opJmp(label, T_NEAR, 0, B11101000, 0); }
+ void call(const Label& label) { opJmp(label, T_NEAR, 0, 0xE8, 0); }
// call(function pointer)
#ifdef XBYAK_VARIADIC_TEMPLATE
template<class Ret, class... Params>
void call(Ret(*func)(Params...)) { call(CastTo<const void*>(func)); }
#endif
- void call(const void *addr) { opJmpAbs(addr, T_NEAR, 0, B11101000); }
+ void call(const void *addr) { opJmpAbs(addr, T_NEAR, 0, 0xE8); }
// special case
void movd(const Address& addr, const Mmx& mmx)
{
if (mmx.isXMM()) db(0x66);
- opModM(addr, mmx, 0x0F, B01111110);
+ opModM(addr, mmx, 0x0F, 0x7E);
}
void movd(const Reg32& reg, const Mmx& mmx)
{
if (mmx.isXMM()) db(0x66);
- opModR(mmx, reg, 0x0F, B01111110);
+ opModR(mmx, reg, 0x0F, 0x7E);
}
void movd(const Mmx& mmx, const Address& addr)
{
if (mmx.isXMM()) db(0x66);
- opModM(addr, mmx, 0x0F, B01101110);
+ opModM(addr, mmx, 0x0F, 0x6E);
}
void movd(const Mmx& mmx, const Reg32& reg)
{
if (mmx.isXMM()) db(0x66);
- opModR(mmx, reg, 0x0F, B01101110);
+ opModR(mmx, reg, 0x0F, 0x6E);
}
void movq2dq(const Xmm& xmm, const Mmx& mmx)
{
- db(0xF3); opModR(xmm, mmx, 0x0F, B11010110);
+ db(0xF3); opModR(xmm, mmx, 0x0F, 0xD6);
}
void movdq2q(const Mmx& mmx, const Xmm& xmm)
{
- db(0xF2); opModR(mmx, xmm, 0x0F, B11010110);
+ db(0xF2); opModR(mmx, xmm, 0x0F, 0xD6);
}
void movq(const Mmx& mmx, const Operand& op)
{
if (mmx.isXMM()) db(0xF3);
- opModRM(mmx, op, (mmx.getKind() == op.getKind()), op.isMEM(), 0x0F, mmx.isXMM() ? B01111110 : B01101111);
+ opModRM(mmx, op, (mmx.getKind() == op.getKind()), op.isMEM(), 0x0F, mmx.isXMM() ? 0x7E : 0x6F);
}
void movq(const Address& addr, const Mmx& mmx)
{
if (mmx.isXMM()) db(0x66);
- opModM(addr, mmx, 0x0F, mmx.isXMM() ? B11010110 : B01111111);
+ opModM(addr, mmx, 0x0F, mmx.isXMM() ? 0xD6 : 0x7F);
}
#ifdef XBYAK64
void movq(const Reg64& reg, const Mmx& mmx)
{
if (mmx.isXMM()) db(0x66);
- opModR(mmx, reg, 0x0F, B01111110);
+ opModR(mmx, reg, 0x0F, 0x7E);
}
void movq(const Mmx& mmx, const Reg64& reg)
{
if (mmx.isXMM()) db(0x66);
- opModR(mmx, reg, 0x0F, B01101110);
+ opModR(mmx, reg, 0x0F, 0x6E);
}
void pextrq(const Operand& op, const Xmm& xmm, uint8 imm)
{
if (!op.isREG(64) && !op.isMEM()) throw Error(ERR_BAD_COMBINATION);
- opGen(Reg64(xmm.getIdx()), op, 0x16, 0x66, 0, imm, B00111010); // force to 64bit
+ opGen(Reg64(xmm.getIdx()), op, 0x16, 0x66, 0, imm, 0x3A); // force to 64bit
}
void pinsrq(const Xmm& xmm, const Operand& op, uint8 imm)
{
if (!op.isREG(64) && !op.isMEM()) throw Error(ERR_BAD_COMBINATION);
- opGen(Reg64(xmm.getIdx()), op, 0x22, 0x66, 0, imm, B00111010); // force to 64bit
+ opGen(Reg64(xmm.getIdx()), op, 0x22, 0x66, 0, imm, 0x3A); // force to 64bit
}
void movsxd(const Reg64& reg, const Operand& op)
{
@@ -2097,38 +2097,38 @@
void pinsrw(const Mmx& mmx, const Operand& op, int imm)
{
if (!op.isREG(32) && !op.isMEM()) throw Error(ERR_BAD_COMBINATION);
- opGen(mmx, op, B11000100, mmx.isXMM() ? 0x66 : NONE, 0, imm);
+ opGen(mmx, op, 0xC4, mmx.isXMM() ? 0x66 : NONE, 0, imm);
}
- void insertps(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x21, 0x66, isXMM_XMMorMEM, imm, B00111010); }
- void pinsrb(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x20, 0x66, isXMM_REG32orMEM, imm, B00111010); }
- void pinsrd(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x22, 0x66, isXMM_REG32orMEM, imm, B00111010); }
+ void insertps(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x21, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
+ void pinsrb(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x20, 0x66, isXMM_REG32orMEM, imm, 0x3A); }
+ void pinsrd(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x22, 0x66, isXMM_REG32orMEM, imm, 0x3A); }
void pmovmskb(const Reg32e& reg, const Mmx& mmx)
{
if (mmx.isXMM()) db(0x66);
- opModR(reg, mmx, 0x0F, B11010111);
+ opModR(reg, mmx, 0x0F, 0xD7);
}
void maskmovq(const Mmx& reg1, const Mmx& reg2)
{
if (!reg1.isMMX() || !reg2.isMMX()) throw Error(ERR_BAD_COMBINATION);
- opModR(reg1, reg2, 0x0F, B11110111);
+ opModR(reg1, reg2, 0x0F, 0xF7);
}
void lea(const Reg& reg, const Address& addr)
{
if (!reg.isBit(16 | i32e)) throw Error(ERR_BAD_SIZE_OF_REGISTER);
- opModM(addr, reg, B10001101);
+ opModM(addr, reg, 0x8D);
}
- void movmskps(const Reg32e& reg, const Xmm& xmm) { opModR(reg, xmm, 0x0F, B01010000); }
+ void movmskps(const Reg32e& reg, const Xmm& xmm) { opModR(reg, xmm, 0x0F, 0x50); }
void movmskpd(const Reg32e& reg, const Xmm& xmm) { db(0x66); movmskps(reg, xmm); }
- void movntps(const Address& addr, const Xmm& xmm) { opModM(addr, Mmx(xmm.getIdx()), 0x0F, B00101011); }
+ void movntps(const Address& addr, const Xmm& xmm) { opModM(addr, Mmx(xmm.getIdx()), 0x0F, 0x2B); }
void movntdqa(const Xmm& xmm, const Address& addr) { db(0x66); opModM(addr, xmm, 0x0F, 0x38, 0x2A); }
- void lddqu(const Xmm& xmm, const Address& addr) { db(0xF2); opModM(addr, xmm, 0x0F, B11110000); }
- void movnti(const Address& addr, const Reg32e& reg) { opModM(addr, reg, 0x0F, B11000011); }
+ void lddqu(const Xmm& xmm, const Address& addr) { db(0xF2); opModM(addr, xmm, 0x0F, 0xF0); }
+ void movnti(const Address& addr, const Reg32e& reg) { opModM(addr, reg, 0x0F, 0xC3); }
void movntq(const Address& addr, const Mmx& mmx)
{
if (!mmx.isMMX()) throw Error(ERR_BAD_COMBINATION);
- opModM(addr, mmx, 0x0F, B11100111);
+ opModM(addr, mmx, 0x0F, 0xE7);
}
void crc32(const Reg32e& reg, const Operand& op)
{
diff --git a/xbyak/xbyak_mnemonic.h b/xbyak/xbyak_mnemonic.h
index 98b7dd6..3479e9f 100644
--- a/xbyak/xbyak_mnemonic.h
+++ b/xbyak/xbyak_mnemonic.h
@@ -174,194 +174,194 @@
void cvtsd2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2D, 0xF2, isREG32_XMMorMEM); }
void cvttpd2pi(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0x66, isMMX_XMMorMEM); }
void cvttsd2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0xF2, isREG32_XMMorMEM); }
-void prefetcht0(const Address& addr) { opModM(addr, Reg32(1), 0x0F, B00011000); }
-void prefetcht1(const Address& addr) { opModM(addr, Reg32(2), 0x0F, B00011000); }
-void prefetcht2(const Address& addr) { opModM(addr, Reg32(3), 0x0F, B00011000); }
-void prefetchnta(const Address& addr) { opModM(addr, Reg32(0), 0x0F, B00011000); }
+void prefetcht0(const Address& addr) { opModM(addr, Reg32(1), 0x0F, 0x18); }
+void prefetcht1(const Address& addr) { opModM(addr, Reg32(2), 0x0F, 0x18); }
+void prefetcht2(const Address& addr) { opModM(addr, Reg32(3), 0x0F, 0x18); }
+void prefetchnta(const Address& addr) { opModM(addr, Reg32(0), 0x0F, 0x18); }
void movhps(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x16, 0x100); }
void movlps(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x12, 0x100); }
void movhpd(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x16, 0x66); }
void movlpd(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x12, 0x66); }
-void cmovo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 0); }
+void cmovo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 0); }
void jo(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x70, 0x80, 0x0F); }
void jo(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x70, 0x80, 0x0F); }
void jo(const char *label, LabelType type = T_AUTO) { jo(std::string(label), type); }
void jo(const void *addr) { opJmpAbs(addr, T_NEAR, 0x70, 0x80, 0x0F); }
-void seto(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 0); }
-void cmovno(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 1); }
+void seto(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 0); }
+void cmovno(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 1); }
void jno(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x71, 0x81, 0x0F); }
void jno(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x71, 0x81, 0x0F); }
void jno(const char *label, LabelType type = T_AUTO) { jno(std::string(label), type); }
void jno(const void *addr) { opJmpAbs(addr, T_NEAR, 0x71, 0x81, 0x0F); }
-void setno(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 1); }
-void cmovb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 2); }
+void setno(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 1); }
+void cmovb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }
void jb(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }
void jb(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }
void jb(const char *label, LabelType type = T_AUTO) { jb(std::string(label), type); }
void jb(const void *addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }
-void setb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 2); }
-void cmovc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 2); }
+void setb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }
+void cmovc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }
void jc(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }
void jc(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }
void jc(const char *label, LabelType type = T_AUTO) { jc(std::string(label), type); }
void jc(const void *addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }
-void setc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 2); }
-void cmovnae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 2); }
+void setc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }
+void cmovnae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }
void jnae(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }
void jnae(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x72, 0x82, 0x0F); }
void jnae(const char *label, LabelType type = T_AUTO) { jnae(std::string(label), type); }
void jnae(const void *addr) { opJmpAbs(addr, T_NEAR, 0x72, 0x82, 0x0F); }
-void setnae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 2); }
-void cmovnb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 3); }
+void setnae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 2); }
+void cmovnb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }
void jnb(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }
void jnb(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }
void jnb(const char *label, LabelType type = T_AUTO) { jnb(std::string(label), type); }
void jnb(const void *addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }
-void setnb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 3); }
-void cmovae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 3); }
+void setnb(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }
+void cmovae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }
void jae(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }
void jae(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }
void jae(const char *label, LabelType type = T_AUTO) { jae(std::string(label), type); }
void jae(const void *addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }
-void setae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 3); }
-void cmovnc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 3); }
+void setae(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }
+void cmovnc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }
void jnc(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }
void jnc(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x73, 0x83, 0x0F); }
void jnc(const char *label, LabelType type = T_AUTO) { jnc(std::string(label), type); }
void jnc(const void *addr) { opJmpAbs(addr, T_NEAR, 0x73, 0x83, 0x0F); }
-void setnc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 3); }
-void cmove(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 4); }
+void setnc(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 3); }
+void cmove(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4); }
void je(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }
void je(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }
void je(const char *label, LabelType type = T_AUTO) { je(std::string(label), type); }
void je(const void *addr) { opJmpAbs(addr, T_NEAR, 0x74, 0x84, 0x0F); }
-void sete(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 4); }
-void cmovz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 4); }
+void sete(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 4); }
+void cmovz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4); }
void jz(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }
void jz(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x74, 0x84, 0x0F); }
void jz(const char *label, LabelType type = T_AUTO) { jz(std::string(label), type); }
void jz(const void *addr) { opJmpAbs(addr, T_NEAR, 0x74, 0x84, 0x0F); }
-void setz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 4); }
-void cmovne(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 5); }
+void setz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 4); }
+void cmovne(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5); }
void jne(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }
void jne(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }
void jne(const char *label, LabelType type = T_AUTO) { jne(std::string(label), type); }
void jne(const void *addr) { opJmpAbs(addr, T_NEAR, 0x75, 0x85, 0x0F); }
-void setne(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 5); }
-void cmovnz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 5); }
+void setne(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 5); }
+void cmovnz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5); }
void jnz(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }
void jnz(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x75, 0x85, 0x0F); }
void jnz(const char *label, LabelType type = T_AUTO) { jnz(std::string(label), type); }
void jnz(const void *addr) { opJmpAbs(addr, T_NEAR, 0x75, 0x85, 0x0F); }
-void setnz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 5); }
-void cmovbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 6); }
+void setnz(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 5); }
+void cmovbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6); }
void jbe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }
void jbe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }
void jbe(const char *label, LabelType type = T_AUTO) { jbe(std::string(label), type); }
void jbe(const void *addr) { opJmpAbs(addr, T_NEAR, 0x76, 0x86, 0x0F); }
-void setbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 6); }
-void cmovna(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 6); }
+void setbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 6); }
+void cmovna(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6); }
void jna(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }
void jna(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x76, 0x86, 0x0F); }
void jna(const char *label, LabelType type = T_AUTO) { jna(std::string(label), type); }
void jna(const void *addr) { opJmpAbs(addr, T_NEAR, 0x76, 0x86, 0x0F); }
-void setna(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 6); }
-void cmovnbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 7); }
+void setna(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 6); }
+void cmovnbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7); }
void jnbe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }
void jnbe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }
void jnbe(const char *label, LabelType type = T_AUTO) { jnbe(std::string(label), type); }
void jnbe(const void *addr) { opJmpAbs(addr, T_NEAR, 0x77, 0x87, 0x0F); }
-void setnbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 7); }
-void cmova(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 7); }
+void setnbe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 7); }
+void cmova(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7); }
void ja(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }
void ja(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x77, 0x87, 0x0F); }
void ja(const char *label, LabelType type = T_AUTO) { ja(std::string(label), type); }
void ja(const void *addr) { opJmpAbs(addr, T_NEAR, 0x77, 0x87, 0x0F); }
-void seta(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 7); }
-void cmovs(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 8); }
+void seta(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 7); }
+void cmovs(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 8); }
void js(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x78, 0x88, 0x0F); }
void js(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x78, 0x88, 0x0F); }
void js(const char *label, LabelType type = T_AUTO) { js(std::string(label), type); }
void js(const void *addr) { opJmpAbs(addr, T_NEAR, 0x78, 0x88, 0x0F); }
-void sets(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 8); }
-void cmovns(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 9); }
+void sets(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 8); }
+void cmovns(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 9); }
void jns(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x79, 0x89, 0x0F); }
void jns(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x79, 0x89, 0x0F); }
void jns(const char *label, LabelType type = T_AUTO) { jns(std::string(label), type); }
void jns(const void *addr) { opJmpAbs(addr, T_NEAR, 0x79, 0x89, 0x0F); }
-void setns(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 9); }
-void cmovp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 10); }
+void setns(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 9); }
+void cmovp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10); }
void jp(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }
void jp(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }
void jp(const char *label, LabelType type = T_AUTO) { jp(std::string(label), type); }
void jp(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7A, 0x8A, 0x0F); }
-void setp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 10); }
-void cmovpe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 10); }
+void setp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 10); }
+void cmovpe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10); }
void jpe(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }
void jpe(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7A, 0x8A, 0x0F); }
void jpe(const char *label, LabelType type = T_AUTO) { jpe(std::string(label), type); }
void jpe(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7A, 0x8A, 0x0F); }
-void setpe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 10); }
-void cmovnp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 11); }
+void setpe(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 10); }
+void cmovnp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11); }
void jnp(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }
void jnp(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }
void jnp(const char *label, LabelType type = T_AUTO) { jnp(std::string(label), type); }
void jnp(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7B, 0x8B, 0x0F); }
-void setnp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 11); }
-void cmovpo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 11); }
+void setnp(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 11); }
+void cmovpo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11); }
void jpo(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }
void jpo(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7B, 0x8B, 0x0F); }
void jpo(const char *label, LabelType type = T_AUTO) { jpo(std::string(label), type); }
void jpo(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7B, 0x8B, 0x0F); }
-void setpo(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 11); }
-void cmovl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 12); }
+void setpo(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 11); }
+void cmovl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12); }
void jl(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }
void jl(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }
void jl(const char *label, LabelType type = T_AUTO) { jl(std::string(label), type); }
void jl(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7C, 0x8C, 0x0F); }
-void setl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 12); }
-void cmovnge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 12); }
+void setl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 12); }
+void cmovnge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12); }
void jnge(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }
void jnge(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7C, 0x8C, 0x0F); }
void jnge(const char *label, LabelType type = T_AUTO) { jnge(std::string(label), type); }
void jnge(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7C, 0x8C, 0x0F); }
-void setnge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 12); }
-void cmovnl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 13); }
+void setnge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 12); }
+void cmovnl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13); }
void jnl(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }
void jnl(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }
void jnl(const char *label, LabelType type = T_AUTO) { jnl(std::string(label), type); }
void jnl(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7D, 0x8D, 0x0F); }
-void setnl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 13); }
-void cmovge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 13); }
+void setnl(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 13); }
+void cmovge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13); }
void jge(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }
void jge(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7D, 0x8D, 0x0F); }
void jge(const char *label, LabelType type = T_AUTO) { jge(std::string(label), type); }
void jge(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7D, 0x8D, 0x0F); }
-void setge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 13); }
-void cmovle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 14); }
+void setge(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 13); }
+void cmovle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14); }
void jle(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }
void jle(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }
void jle(const char *label, LabelType type = T_AUTO) { jle(std::string(label), type); }
void jle(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7E, 0x8E, 0x0F); }
-void setle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 14); }
-void cmovng(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 14); }
+void setle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 14); }
+void cmovng(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14); }
void jng(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }
void jng(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7E, 0x8E, 0x0F); }
void jng(const char *label, LabelType type = T_AUTO) { jng(std::string(label), type); }
void jng(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7E, 0x8E, 0x0F); }
-void setng(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 14); }
-void cmovnle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 15); }
+void setng(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 14); }
+void cmovnle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15); }
void jnle(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }
void jnle(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }
void jnle(const char *label, LabelType type = T_AUTO) { jnle(std::string(label), type); }
void jnle(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7F, 0x8F, 0x0F); }
-void setnle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 15); }
-void cmovg(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, B01000000 | 15); }
+void setnle(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 15); }
+void cmovg(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15); }
void jg(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }
void jg(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x7F, 0x8F, 0x0F); }
void jg(const char *label, LabelType type = T_AUTO) { jg(std::string(label), type); }
void jg(const void *addr) { opJmpAbs(addr, T_NEAR, 0x7F, 0x8F, 0x0F); }
-void setg(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, B10010000 | 15); }
+void setg(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | 15); }
#ifdef XBYAK32
void jcxz(std::string label) { db(0x67); opJmp(label, T_SHORT, 0xe3, 0, 0); }
void jcxz(const Label& label) { db(0x67); opJmp(label, T_SHORT, 0xe3, 0, 0); }
