From bceaebdbe33aeff1db847b328af3d1bf16bfff62 Mon Sep 17 00:00:00 2001 From: kobalicekp Date: Sat, 3 May 2014 18:04:16 +0200 Subject: [PATCH] Added support for missing AMD instruction sets (FMA4 and XOP) to Assembler. --- src/app/test/genopcode.h | 247 ++++++++++ src/asmjit/x86/x86assembler.cpp | 363 +++++++++++++- src/asmjit/x86/x86assembler.h | 300 ++++++++++++ src/asmjit/x86/x86compiler.cpp | 6 + src/asmjit/x86/x86defs.cpp | 815 +++++++++++++++++++++----------- src/asmjit/x86/x86defs.h | 196 +++++++- 6 files changed, 1623 insertions(+), 304 deletions(-) diff --git a/src/app/test/genopcode.h b/src/app/test/genopcode.h index 16873cd..b51d06f 100644 --- a/src/app/test/genopcode.h +++ b/src/app/test/genopcode.h @@ -2300,6 +2300,253 @@ static void opcode(asmjit::host::Assembler& a) { a.vfnmsub231ss(xmm0, xmm1, ptr_gp0); a.vfnmsub231ss(xmm0, xmm1, xmm2); + // FMA4. + a.vfmaddpd(xmm0, xmm1, xmm2, xmm3); + a.vfmaddpd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmaddpd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmaddpd(ymm0, ymm1, ymm2, ymm3); + a.vfmaddpd(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmaddpd(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmaddps(xmm0, xmm1, xmm2, xmm3); + a.vfmaddps(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmaddps(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmaddps(ymm0, ymm1, ymm2, ymm3); + a.vfmaddps(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmaddps(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmaddsd(xmm0, xmm1, xmm2, xmm3); + a.vfmaddsd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmaddsd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmaddss(xmm0, xmm1, xmm2, xmm3); + a.vfmaddss(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmaddss(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmaddsubpd(xmm0, xmm1, xmm2, xmm3); + a.vfmaddsubpd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmaddsubpd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmaddsubpd(ymm0, ymm1, ymm2, ymm3); + a.vfmaddsubpd(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmaddsubpd(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmaddsubps(xmm0, xmm1, xmm2, xmm3); + a.vfmaddsubps(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmaddsubps(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmaddsubps(ymm0, ymm1, ymm2, ymm3); + a.vfmaddsubps(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmaddsubps(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmsubaddpd(xmm0, xmm1, xmm2, xmm3); + a.vfmsubaddpd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmsubaddpd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmsubaddpd(ymm0, ymm1, ymm2, ymm3); + a.vfmsubaddpd(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmsubaddpd(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmsubaddps(xmm0, xmm1, xmm2, xmm3); + a.vfmsubaddps(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmsubaddps(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmsubaddps(ymm0, ymm1, ymm2, ymm3); + a.vfmsubaddps(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmsubaddps(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmsubpd(xmm0, xmm1, xmm2, xmm3); + a.vfmsubpd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmsubpd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmsubpd(ymm0, ymm1, ymm2, ymm3); + a.vfmsubpd(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmsubpd(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmsubps(xmm0, xmm1, xmm2, xmm3); + a.vfmsubps(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmsubps(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmsubps(ymm0, ymm1, ymm2, ymm3); + a.vfmsubps(ymm0, ymm1, ptr_gp0, ymm3); + a.vfmsubps(ymm0, ymm1, ymm2, ptr_gp0); + a.vfmsubsd(xmm0, xmm1, xmm2, xmm3); + a.vfmsubsd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmsubsd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfmsubss(xmm0, xmm1, xmm2, xmm3); + a.vfmsubss(xmm0, xmm1, ptr_gp0, xmm3); + a.vfmsubss(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmaddpd(xmm0, xmm1, xmm2, xmm3); + a.vfnmaddpd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmaddpd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmaddpd(ymm0, ymm1, ymm2, ymm3); + a.vfnmaddpd(ymm0, ymm1, ptr_gp0, ymm3); + a.vfnmaddpd(ymm0, ymm1, ymm2, ptr_gp0); + a.vfnmaddps(xmm0, xmm1, xmm2, xmm3); + a.vfnmaddps(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmaddps(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmaddps(ymm0, ymm1, ymm2, ymm3); + a.vfnmaddps(ymm0, ymm1, ptr_gp0, ymm3); + a.vfnmaddps(ymm0, ymm1, ymm2, ptr_gp0); + a.vfnmaddsd(xmm0, xmm1, xmm2, xmm3); + a.vfnmaddsd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmaddsd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmaddss(xmm0, xmm1, xmm2, xmm3); + a.vfnmaddss(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmaddss(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmsubpd(xmm0, xmm1, xmm2, xmm3); + a.vfnmsubpd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmsubpd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmsubpd(ymm0, ymm1, ymm2, ymm3); + a.vfnmsubpd(ymm0, ymm1, ptr_gp0, ymm3); + a.vfnmsubpd(ymm0, ymm1, ymm2, ptr_gp0); + a.vfnmsubps(xmm0, xmm1, xmm2, xmm3); + a.vfnmsubps(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmsubps(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmsubps(ymm0, ymm1, ymm2, ymm3); + a.vfnmsubps(ymm0, ymm1, ptr_gp0, ymm3); + a.vfnmsubps(ymm0, ymm1, ymm2, ptr_gp0); + a.vfnmsubsd(xmm0, xmm1, xmm2, xmm3); + a.vfnmsubsd(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmsubsd(xmm0, xmm1, xmm2, ptr_gp0); + a.vfnmsubss(xmm0, xmm1, xmm2, xmm3); + a.vfnmsubss(xmm0, xmm1, ptr_gp0, xmm3); + a.vfnmsubss(xmm0, xmm1, xmm2, ptr_gp0); + + // XOP. + a.vfrczpd(xmm0, xmm1); + a.vfrczpd(xmm0, ptr_gp0); + a.vfrczpd(ymm0, ymm1); + a.vfrczpd(ymm0, ptr_gp0); + a.vfrczps(xmm0, xmm1); + a.vfrczps(xmm0, ptr_gp0); + a.vfrczps(ymm0, ymm1); + a.vfrczps(ymm0, ptr_gp0); + a.vfrczsd(xmm0, xmm1); + a.vfrczsd(xmm0, ptr_gp0); + a.vfrczss(xmm0, xmm1); + a.vfrczss(xmm0, ptr_gp0); + a.vpcmov(xmm0, xmm1, xmm2, xmm3); + a.vpcmov(xmm0, xmm1, ptr_gp0, xmm3); + a.vpcmov(xmm0, xmm1, xmm2, ptr_gp0); + a.vpcmov(ymm0, ymm1, ymm2, ymm3); + a.vpcmov(ymm0, ymm1, ptr_gp0, ymm3); + a.vpcmov(ymm0, ymm1, ymm2, ptr_gp0); + a.vpcomb(xmm0, xmm1, xmm2, 0); + a.vpcomb(xmm0, xmm1, ptr_gp0, 0); + a.vpcomd(xmm0, xmm1, xmm2, 0); + a.vpcomd(xmm0, xmm1, ptr_gp0, 0); + a.vpcomq(xmm0, xmm1, xmm2, 0); + a.vpcomq(xmm0, xmm1, ptr_gp0, 0); + a.vpcomw(xmm0, xmm1, xmm2, 0); + a.vpcomw(xmm0, xmm1, ptr_gp0, 0); + a.vpcomub(xmm0, xmm1, xmm2, 0); + a.vpcomub(xmm0, xmm1, ptr_gp0, 0); + a.vpcomud(xmm0, xmm1, xmm2, 0); + a.vpcomud(xmm0, xmm1, ptr_gp0, 0); + a.vpcomuq(xmm0, xmm1, xmm2, 0); + a.vpcomuq(xmm0, xmm1, ptr_gp0, 0); + a.vpcomuw(xmm0, xmm1, xmm2, 0); + a.vpcomuw(xmm0, xmm1, ptr_gp0, 0); + a.vpermil2pd(xmm0, xmm1, xmm2, xmm3); + a.vpermil2pd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpermil2pd(xmm0, xmm1, xmm2, ptr_gp0); + a.vpermil2pd(ymm0, ymm1, ymm2, ymm3); + a.vpermil2pd(ymm0, ymm1, ptr_gp0, ymm3); + a.vpermil2pd(ymm0, ymm1, ymm2, ptr_gp0); + a.vpermil2ps(xmm0, xmm1, xmm2, xmm3); + a.vpermil2ps(xmm0, xmm1, ptr_gp0, xmm3); + a.vpermil2ps(xmm0, xmm1, xmm2, ptr_gp0); + a.vpermil2ps(ymm0, ymm1, ymm2, ymm3); + a.vpermil2ps(ymm0, ymm1, ptr_gp0, ymm3); + a.vpermil2ps(ymm0, ymm1, ymm2, ptr_gp0); + a.vphaddbd(xmm0, xmm1); + a.vphaddbd(xmm0, ptr_gp0); + a.vphaddbq(xmm0, xmm1); + a.vphaddbq(xmm0, ptr_gp0); + a.vphaddbw(xmm0, xmm1); + a.vphaddbw(xmm0, ptr_gp0); + a.vphadddq(xmm0, xmm1); + a.vphadddq(xmm0, ptr_gp0); + a.vphaddwd(xmm0, xmm1); + a.vphaddwd(xmm0, ptr_gp0); + a.vphaddwq(xmm0, xmm1); + a.vphaddwq(xmm0, ptr_gp0); + a.vphaddubd(xmm0, xmm1); + a.vphaddubd(xmm0, ptr_gp0); + a.vphaddubq(xmm0, xmm1); + a.vphaddubq(xmm0, ptr_gp0); + a.vphaddubw(xmm0, xmm1); + a.vphaddubw(xmm0, ptr_gp0); + a.vphaddudq(xmm0, xmm1); + a.vphaddudq(xmm0, ptr_gp0); + a.vphadduwd(xmm0, xmm1); + a.vphadduwd(xmm0, ptr_gp0); + a.vphadduwq(xmm0, xmm1); + a.vphadduwq(xmm0, ptr_gp0); + a.vphsubbw(xmm0, xmm1); + a.vphsubbw(xmm0, ptr_gp0); + a.vphsubdq(xmm0, xmm1); + a.vphsubdq(xmm0, ptr_gp0); + a.vphsubwd(xmm0, xmm1); + a.vphsubwd(xmm0, ptr_gp0); + a.vpmacsdd(xmm0, xmm1, xmm2, xmm3); + a.vpmacsdd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacsdqh(xmm0, xmm1, xmm2, xmm3); + a.vpmacsdqh(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacsdql(xmm0, xmm1, xmm2, xmm3); + a.vpmacsdql(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacswd(xmm0, xmm1, xmm2, xmm3); + a.vpmacswd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacsww(xmm0, xmm1, xmm2, xmm3); + a.vpmacsww(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacssdd(xmm0, xmm1, xmm2, xmm3); + a.vpmacssdd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacssdqh(xmm0, xmm1, xmm2, xmm3); + a.vpmacssdqh(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacssdql(xmm0, xmm1, xmm2, xmm3); + a.vpmacssdql(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacsswd(xmm0, xmm1, xmm2, xmm3); + a.vpmacsswd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmacssww(xmm0, xmm1, xmm2, xmm3); + a.vpmacssww(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmadcsswd(xmm0, xmm1, xmm2, xmm3); + a.vpmadcsswd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpmadcswd(xmm0, xmm1, xmm2, xmm3); + a.vpmadcswd(xmm0, xmm1, ptr_gp0, xmm3); + a.vpperm(xmm0, xmm1, xmm2, xmm3); + a.vpperm(xmm0, xmm1, ptr_gp0, xmm3); + a.vpperm(xmm0, xmm1, xmm2, ptr_gp0); + a.vprotb(xmm0, xmm1, xmm2); + a.vprotb(xmm0, ptr_gp0, xmm2); + a.vprotb(xmm0, xmm1, ptr_gp0); + a.vprotb(xmm0, xmm1, 0); + a.vprotb(xmm0, ptr_gp0, 0); + a.vprotd(xmm0, xmm1, xmm2); + a.vprotd(xmm0, ptr_gp0, xmm2); + a.vprotd(xmm0, xmm1, ptr_gp0); + a.vprotd(xmm0, xmm1, 0); + a.vprotd(xmm0, ptr_gp0, 0); + a.vprotq(xmm0, xmm1, xmm2); + a.vprotq(xmm0, ptr_gp0, xmm2); + a.vprotq(xmm0, xmm1, ptr_gp0); + a.vprotq(xmm0, xmm1, 0); + a.vprotq(xmm0, ptr_gp0, 0); + a.vprotw(xmm0, xmm1, xmm2); + a.vprotw(xmm0, ptr_gp0, xmm2); + a.vprotw(xmm0, xmm1, ptr_gp0); + a.vprotw(xmm0, xmm1, 0); + a.vprotw(xmm0, ptr_gp0, 0); + a.vpshab(xmm0, xmm1, xmm2); + a.vpshab(xmm0, ptr_gp0, xmm2); + a.vpshab(xmm0, xmm1, ptr_gp0); + a.vpshad(xmm0, xmm1, xmm2); + a.vpshad(xmm0, ptr_gp0, xmm2); + a.vpshad(xmm0, xmm1, ptr_gp0); + a.vpshaq(xmm0, xmm1, xmm2); + a.vpshaq(xmm0, ptr_gp0, xmm2); + a.vpshaq(xmm0, xmm1, ptr_gp0); + a.vpshaw(xmm0, xmm1, xmm2); + a.vpshaw(xmm0, ptr_gp0, xmm2); + a.vpshaw(xmm0, xmm1, ptr_gp0); + a.vpshlb(xmm0, xmm1, xmm2); + a.vpshlb(xmm0, ptr_gp0, xmm2); + a.vpshlb(xmm0, xmm1, ptr_gp0); + a.vpshld(xmm0, xmm1, xmm2); + a.vpshld(xmm0, ptr_gp0, xmm2); + a.vpshld(xmm0, xmm1, ptr_gp0); + a.vpshlq(xmm0, xmm1, xmm2); + a.vpshlq(xmm0, ptr_gp0, xmm2); + a.vpshlq(xmm0, xmm1, ptr_gp0); + a.vpshlw(xmm0, xmm1, xmm2); + a.vpshlw(xmm0, ptr_gp0, xmm2); + a.vpshlw(xmm0, xmm1, ptr_gp0); + // BMI. a.andn(gp0, gp1, zcx); a.andn(gp0, gp1, ptr_gp1); diff --git a/src/asmjit/x86/x86assembler.cpp b/src/asmjit/x86/x86assembler.cpp index 7ca6802..5474a5a 100644 --- a/src/asmjit/x86/x86assembler.cpp +++ b/src/asmjit/x86/x86assembler.cpp @@ -46,6 +46,13 @@ enum { kVex2Byte = 0xC5 }; // [2] WvvvvLpp. enum { kVex3Byte = 0xC4 }; +// 3-byte XOP prefix. +// [0] kXopByte +// [1] RXBmmmmm +// [2] WvvvvLpp +enum { kXopByte = 0x8F }; + +// AsmJit specific (used to encode VVVV field in XOP/VEX). enum kVexVVVV { kVexVVVVShift = 12, kVexVVVVMask = 0xF << kVexVVVVShift @@ -146,6 +153,11 @@ struct X64TrampolineWriter { opX |= static_cast(_Reg_) >> 3; \ } while (0) +#define ADD_VEX_W(_Exp_) \ + do { \ + opX |= static_cast(_Exp_) << 3; \ + } while (0) + #define ADD_VEX_L(_Exp_) \ do { \ opCode |= static_cast(_Exp_) << kInstOpCode_L_Shift; \ @@ -2748,7 +2760,7 @@ _EmitAvxRvm: if (!o3->isReg()) goto _IllegalInst; - imVal = static_cast(o3)->getRegIndex() << 4;; + imVal = static_cast(o3)->getRegIndex() << 4; imLen = 1; if (encoded == ENC_OPS(Reg, Reg, Reg)) { @@ -3033,6 +3045,46 @@ _EmitAvxRvm: } break; + case kInstGroupAvxRvrmRvmr_P: + ADD_VEX_L(static_cast(o0)->isYmm() || static_cast(o1)->isYmm()); + // ... Fall through ... + + case kInstGroupAvxRvrmRvmr: + if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) { + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmReg = static_cast(o2)->getRegIndex(); + + goto _EmitAvxR; + } + + if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isMem()) { + imVal = static_cast(o2)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o3); + + ADD_VEX_W(true); + goto _EmitAvxM; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem) && o3->isReg()) { + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + + goto _EmitAvxM; + } + break; + case kInstGroupAvxMovSsSd: if (encoded == ENC_OPS(Reg, Reg, Reg)) { goto _EmitAvxRvm; @@ -3080,6 +3132,237 @@ _EmitAvxRvm: goto _EmitAvxV; } break; + + // ------------------------------------------------------------------------ + // [FMA4] + // ------------------------------------------------------------------------ + + case kInstGroupFma4_P: + // It's fine to just check the first operand, second is just for sanity. + ADD_VEX_L(static_cast(o0)->isYmm() || static_cast(o1)->isYmm()); + // ... Fall through ... + + case kInstGroupFma4: + if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) { + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmReg = static_cast(o2)->getRegIndex(); + + goto _EmitAvxR; + } + + if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isMem()) { + imVal = static_cast(o2)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o3); + + ADD_VEX_W(true); + goto _EmitAvxM; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem) && o3->isReg()) { + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + + goto _EmitAvxM; + } + break; + + // ------------------------------------------------------------------------ + // [XOP] + // ------------------------------------------------------------------------ + + case kInstGroupXopRm_P: + ADD_VEX_L(static_cast(o0)->isYmm() || static_cast(o1)->isYmm()); + // ... Fall through ... + + case kInstGroupXopRm: + if (encoded == ENC_OPS(Reg, Reg, None)) { + opReg = static_cast(o0)->getRegIndex(); + rmReg = static_cast(o1)->getRegIndex(); + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Mem, None)) { + opReg = static_cast(o0)->getRegIndex(); + rmMem = static_cast(o1); + goto _EmitXopM; + } + break; + + case kInstGroupXopRvmRmv: + if (encoded == ENC_OPS(Reg, Reg, Reg)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o2)->getRegIndex() << kVexVVVVShift; + rmReg = static_cast(o1)->getRegIndex(); + + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Mem, Reg)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o2)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o1); + + goto _EmitXopM; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + + ADD_VEX_W(true); + goto _EmitXopM; + } + + break; + + case kInstGroupXopRvmRmi: + if (encoded == ENC_OPS(Reg, Reg, Reg)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o2)->getRegIndex() << kVexVVVVShift; + rmReg = static_cast(o1)->getRegIndex(); + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Mem, Reg)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o2)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o1); + + goto _EmitXopM; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + + ADD_VEX_W(true); + goto _EmitXopM; + } + + // The following instructions use the secondary opcode. + opCode = info->_opCode[1]; + + imVal = static_cast(o2)->getInt64(); + imLen = 1; + + if (encoded == ENC_OPS(Reg, Reg, Imm)) { + opReg = static_cast(o0)->getRegIndex(); + rmReg = static_cast(o1)->getRegIndex(); + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Mem, Imm)) { + opReg = static_cast(o0)->getRegIndex(); + rmMem = static_cast(o1); + goto _EmitXopM; + } + break; + + case kInstGroupXopRvmr_P: + ADD_VEX_L(static_cast(o0)->isYmm() || static_cast(o1)->isYmm()); + // ... Fall through ... + + case kInstGroupXopRvmr: + if (!o3->isReg()) + goto _IllegalInst; + + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + if (encoded == ENC_OPS(Reg, Reg, Reg)) { + opReg = static_cast(o0)->getRegIndex(); + rmReg = static_cast(o2)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + goto _EmitXopM; + } + break; + + case kInstGroupXopRvmi_P: + ADD_VEX_L(static_cast(o0)->isYmm() || static_cast(o1)->isYmm()); + // ... Fall through ... + + case kInstGroupXopRvmi: + if (!o3->isImm()) + goto _IllegalInst; + + imVal = static_cast(o3)->getInt64(); + imLen = 1; + + if (encoded == ENC_OPS(Reg, Reg, Reg)) { + opReg = static_cast(o0)->getRegIndex(); + rmReg = static_cast(o2)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem)) { + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + goto _EmitXopM; + } + break; + + case kInstGroupXopRvrmRvmr_P: + ADD_VEX_L(static_cast(o0)->isYmm() || static_cast(o1)->isYmm()); + // ... Fall through ... + + case kInstGroupXopRvrmRvmr: + if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isReg()) { + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmReg = static_cast(o2)->getRegIndex(); + + goto _EmitXopR; + } + + if (encoded == ENC_OPS(Reg, Reg, Reg) && o3->isMem()) { + imVal = static_cast(o2)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o3); + + ADD_VEX_W(true); + goto _EmitXopM; + } + + if (encoded == ENC_OPS(Reg, Reg, Mem) && o3->isReg()) { + imVal = static_cast(o3)->getRegIndex() << 4; + imLen = 1; + + opReg = static_cast(o0)->getRegIndex(); + opX |= static_cast(o1)->getRegIndex() << kVexVVVVShift; + rmMem = static_cast(o2); + + goto _EmitXopM; + } + break; } // -------------------------------------------------------------------------- @@ -3604,6 +3887,84 @@ _EmitAvxV: } goto _EmitDone; + // -------------------------------------------------------------------------- + // [Xop] + // -------------------------------------------------------------------------- + +#define EMIT_XOP_M \ + ASMJIT_ASSERT(rmMem != NULL); \ + ASMJIT_ASSERT(rmMem->getOp() == kOperandTypeMem); \ + \ + if (rmMem->hasSegment()) { \ + EMIT_BYTE(x86SegmentPrefix[rmMem->getSegment()]); \ + } \ + \ + mBase = rmMem->getBase(); \ + mIndex = rmMem->getIndex(); \ + \ + { \ + uint32_t vex_XvvvvLpp; \ + uint32_t vex_rxbmmmmm; \ + \ + vex_XvvvvLpp = (opCode >> (kInstOpCode_L_Shift - 2)) & 0x04; \ + vex_XvvvvLpp += (opCode >> (kInstOpCode_PP_Shift)) & 0x03; \ + vex_XvvvvLpp += (opX >> (kVexVVVVShift - 3)); \ + vex_XvvvvLpp += (opX << 4) & 0x80; \ + \ + vex_rxbmmmmm = (opCode >> kInstOpCode_MM_Shift) & 0x1F; \ + vex_rxbmmmmm += static_cast(mBase - 8 < 8) << 5; \ + vex_rxbmmmmm += static_cast(mIndex - 8 < 8) << 6; \ + \ + vex_rxbmmmmm |= static_cast(opReg << 4) & 0x80; \ + vex_rxbmmmmm ^= 0xE0; \ + vex_XvvvvLpp ^= 0x78; \ + \ + EMIT_BYTE(kXopByte); \ + EMIT_BYTE(vex_rxbmmmmm); \ + EMIT_BYTE(vex_XvvvvLpp); \ + EMIT_OP(opCode); \ + } \ + \ + mBase &= 0x7; \ + opReg &= 0x7; + +_EmitXopR: + { + uint32_t xop_XvvvvLpp; + uint32_t xop_rxbmmmmm; + + xop_XvvvvLpp = (opCode >> (kInstOpCode_L_Shift - 2)) & 0x04; + xop_XvvvvLpp |= (opCode >> (kInstOpCode_PP_Shift)); + xop_XvvvvLpp |= (opX >> (kVexVVVVShift - 3)); + xop_XvvvvLpp |= (opX << 4) & 0x80; + + xop_rxbmmmmm = (opCode >> kInstOpCode_MM_Shift) & 0x1F; + xop_rxbmmmmm |= (rmReg << 2) & 0x20; + + xop_rxbmmmmm |= static_cast(opReg & 0x08) << 4; + xop_rxbmmmmm ^= 0xE0; + xop_XvvvvLpp ^= 0x78; + + EMIT_BYTE(kXopByte); + EMIT_OP(xop_rxbmmmmm); + EMIT_OP(xop_XvvvvLpp); + EMIT_OP(opCode); + + rmReg &= 0x07; + } + + EMIT_BYTE(x86EncodeMod(3, opReg, static_cast(rmReg))); + + if (imLen == 0) + goto _EmitDone; + + EMIT_BYTE(imVal & 0xFF); + goto _EmitDone; + +_EmitXopM: + EMIT_XOP_M + goto _EmitSib; + // -------------------------------------------------------------------------- // [Emit - Jump/Call to an Immediate] // -------------------------------------------------------------------------- diff --git a/src/asmjit/x86/x86assembler.h b/src/asmjit/x86/x86assembler.h index c8f8375..2e807ee 100644 --- a/src/asmjit/x86/x86assembler.h +++ b/src/asmjit/x86/x86assembler.h @@ -5072,6 +5072,306 @@ struct X86X64Assembler : public BaseAssembler { INST_3x(vfnmsub231ss, kInstVfnmsub231ss, XmmReg, XmmReg, Mem) INST_3x(vfnmsub231ss, kInstVfnmsub231ss, XmmReg, XmmReg, XmmReg) + // -------------------------------------------------------------------------- + // [FMA4] + // -------------------------------------------------------------------------- + + INST_4x(vfmaddpd, kInstVfmaddpd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmaddpd, kInstVfmaddpd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmaddpd, kInstVfmaddpd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmaddpd, kInstVfmaddpd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmaddpd, kInstVfmaddpd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmaddpd, kInstVfmaddpd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmaddps, kInstVfmaddps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmaddps, kInstVfmaddps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmaddps, kInstVfmaddps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmaddps, kInstVfmaddps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmaddps, kInstVfmaddps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmaddps, kInstVfmaddps, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmaddsd, kInstVfmaddsd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmaddsd, kInstVfmaddsd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmaddsd, kInstVfmaddsd, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfmaddss, kInstVfmaddss, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmaddss, kInstVfmaddss, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmaddss, kInstVfmaddss, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfmaddsubpd, kInstVfmaddsubpd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmaddsubpd, kInstVfmaddsubpd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmaddsubpd, kInstVfmaddsubpd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmaddsubpd, kInstVfmaddsubpd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmaddsubpd, kInstVfmaddsubpd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmaddsubpd, kInstVfmaddsubpd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmaddsubps, kInstVfmaddsubps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmaddsubps, kInstVfmaddsubps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmaddsubps, kInstVfmaddsubps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmaddsubps, kInstVfmaddsubps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmaddsubps, kInstVfmaddsubps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmaddsubps, kInstVfmaddsubps, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmsubaddpd, kInstVfmsubaddpd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmsubaddpd, kInstVfmsubaddpd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmsubaddpd, kInstVfmsubaddpd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmsubaddpd, kInstVfmsubaddpd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmsubaddpd, kInstVfmsubaddpd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmsubaddpd, kInstVfmsubaddpd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmsubaddps, kInstVfmsubaddps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmsubaddps, kInstVfmsubaddps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmsubaddps, kInstVfmsubaddps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmsubaddps, kInstVfmsubaddps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmsubaddps, kInstVfmsubaddps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmsubaddps, kInstVfmsubaddps, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmsubpd, kInstVfmsubpd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmsubpd, kInstVfmsubpd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmsubpd, kInstVfmsubpd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmsubpd, kInstVfmsubpd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmsubpd, kInstVfmsubpd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmsubpd, kInstVfmsubpd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmsubps, kInstVfmsubps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmsubps, kInstVfmsubps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmsubps, kInstVfmsubps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfmsubps, kInstVfmsubps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfmsubps, kInstVfmsubps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfmsubps, kInstVfmsubps, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfmsubsd, kInstVfmsubsd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmsubsd, kInstVfmsubsd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmsubsd, kInstVfmsubsd, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfmsubss, kInstVfmsubss, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfmsubss, kInstVfmsubss, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfmsubss, kInstVfmsubss, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfnmaddpd, kInstVfnmaddpd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmaddpd, kInstVfnmaddpd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmaddpd, kInstVfnmaddpd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfnmaddpd, kInstVfnmaddpd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfnmaddpd, kInstVfnmaddpd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfnmaddpd, kInstVfnmaddpd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfnmaddps, kInstVfnmaddps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmaddps, kInstVfnmaddps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmaddps, kInstVfnmaddps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfnmaddps, kInstVfnmaddps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfnmaddps, kInstVfnmaddps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfnmaddps, kInstVfnmaddps, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfnmaddsd, kInstVfnmaddsd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmaddsd, kInstVfnmaddsd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmaddsd, kInstVfnmaddsd, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfnmaddss, kInstVfnmaddss, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmaddss, kInstVfnmaddss, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmaddss, kInstVfnmaddss, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfnmsubpd, kInstVfnmsubpd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmsubpd, kInstVfnmsubpd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmsubpd, kInstVfnmsubpd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfnmsubpd, kInstVfnmsubpd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfnmsubpd, kInstVfnmsubpd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfnmsubpd, kInstVfnmsubpd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfnmsubps, kInstVfnmsubps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmsubps, kInstVfnmsubps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmsubps, kInstVfnmsubps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vfnmsubps, kInstVfnmsubps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vfnmsubps, kInstVfnmsubps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vfnmsubps, kInstVfnmsubps, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vfnmsubsd, kInstVfnmsubsd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmsubsd, kInstVfnmsubsd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmsubsd, kInstVfnmsubsd, XmmReg, XmmReg, XmmReg, Mem) + + INST_4x(vfnmsubss, kInstVfnmsubss, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vfnmsubss, kInstVfnmsubss, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vfnmsubss, kInstVfnmsubss, XmmReg, XmmReg, XmmReg, Mem) + + // -------------------------------------------------------------------------- + // [XOP] + // -------------------------------------------------------------------------- + + INST_2x(vfrczpd, kInstVfrczpd, XmmReg, XmmReg) + INST_2x(vfrczpd, kInstVfrczpd, XmmReg, Mem) + INST_2x(vfrczpd, kInstVfrczpd, YmmReg, YmmReg) + INST_2x(vfrczpd, kInstVfrczpd, YmmReg, Mem) + + INST_2x(vfrczps, kInstVfrczps, XmmReg, XmmReg) + INST_2x(vfrczps, kInstVfrczps, XmmReg, Mem) + INST_2x(vfrczps, kInstVfrczps, YmmReg, YmmReg) + INST_2x(vfrczps, kInstVfrczps, YmmReg, Mem) + + INST_2x(vfrczsd, kInstVfrczsd, XmmReg, XmmReg) + INST_2x(vfrczsd, kInstVfrczsd, XmmReg, Mem) + + INST_2x(vfrczss, kInstVfrczss, XmmReg, XmmReg) + INST_2x(vfrczss, kInstVfrczss, XmmReg, Mem) + + INST_4x(vpcmov, kInstVpcmov, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpcmov, kInstVpcmov, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpcmov, kInstVpcmov, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vpcmov, kInstVpcmov, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vpcmov, kInstVpcmov, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vpcmov, kInstVpcmov, YmmReg, YmmReg, YmmReg, Mem) + + INST_4i(vpcomb, kInstVpcomb, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomb, kInstVpcomb, XmmReg, XmmReg, Mem, Imm) + INST_4i(vpcomd, kInstVpcomd, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomd, kInstVpcomd, XmmReg, XmmReg, Mem, Imm) + INST_4i(vpcomq, kInstVpcomq, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomq, kInstVpcomq, XmmReg, XmmReg, Mem, Imm) + INST_4i(vpcomw, kInstVpcomw, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomw, kInstVpcomw, XmmReg, XmmReg, Mem, Imm) + + INST_4i(vpcomub, kInstVpcomub, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomub, kInstVpcomub, XmmReg, XmmReg, Mem, Imm) + INST_4i(vpcomud, kInstVpcomud, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomud, kInstVpcomud, XmmReg, XmmReg, Mem, Imm) + INST_4i(vpcomuq, kInstVpcomuq, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomuq, kInstVpcomuq, XmmReg, XmmReg, Mem, Imm) + INST_4i(vpcomuw, kInstVpcomuw, XmmReg, XmmReg, XmmReg, Imm) + INST_4i(vpcomuw, kInstVpcomuw, XmmReg, XmmReg, Mem, Imm) + + INST_4x(vpermil2pd, kInstVpermil2pd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpermil2pd, kInstVpermil2pd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpermil2pd, kInstVpermil2pd, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vpermil2pd, kInstVpermil2pd, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vpermil2pd, kInstVpermil2pd, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vpermil2pd, kInstVpermil2pd, YmmReg, YmmReg, YmmReg, Mem) + + INST_4x(vpermil2ps, kInstVpermil2ps, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpermil2ps, kInstVpermil2ps, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpermil2ps, kInstVpermil2ps, XmmReg, XmmReg, XmmReg, Mem) + INST_4x(vpermil2ps, kInstVpermil2ps, YmmReg, YmmReg, YmmReg, YmmReg) + INST_4x(vpermil2ps, kInstVpermil2ps, YmmReg, YmmReg, Mem, YmmReg) + INST_4x(vpermil2ps, kInstVpermil2ps, YmmReg, YmmReg, YmmReg, Mem) + + INST_2x(vphaddbd, kInstVphaddbd, XmmReg, XmmReg) + INST_2x(vphaddbd, kInstVphaddbd, XmmReg, Mem) + INST_2x(vphaddbq, kInstVphaddbq, XmmReg, XmmReg) + INST_2x(vphaddbq, kInstVphaddbq, XmmReg, Mem) + INST_2x(vphaddbw, kInstVphaddbw, XmmReg, XmmReg) + INST_2x(vphaddbw, kInstVphaddbw, XmmReg, Mem) + INST_2x(vphadddq, kInstVphadddq, XmmReg, XmmReg) + INST_2x(vphadddq, kInstVphadddq, XmmReg, Mem) + INST_2x(vphaddwd, kInstVphaddwd, XmmReg, XmmReg) + INST_2x(vphaddwd, kInstVphaddwd, XmmReg, Mem) + INST_2x(vphaddwq, kInstVphaddwq, XmmReg, XmmReg) + INST_2x(vphaddwq, kInstVphaddwq, XmmReg, Mem) + + INST_2x(vphaddubd, kInstVphaddubd, XmmReg, XmmReg) + INST_2x(vphaddubd, kInstVphaddubd, XmmReg, Mem) + INST_2x(vphaddubq, kInstVphaddubq, XmmReg, XmmReg) + INST_2x(vphaddubq, kInstVphaddubq, XmmReg, Mem) + INST_2x(vphaddubw, kInstVphaddubw, XmmReg, XmmReg) + INST_2x(vphaddubw, kInstVphaddubw, XmmReg, Mem) + INST_2x(vphaddudq, kInstVphaddudq, XmmReg, XmmReg) + INST_2x(vphaddudq, kInstVphaddudq, XmmReg, Mem) + INST_2x(vphadduwd, kInstVphadduwd, XmmReg, XmmReg) + INST_2x(vphadduwd, kInstVphadduwd, XmmReg, Mem) + INST_2x(vphadduwq, kInstVphadduwq, XmmReg, XmmReg) + INST_2x(vphadduwq, kInstVphadduwq, XmmReg, Mem) + + INST_2x(vphsubbw, kInstVphsubbw, XmmReg, XmmReg) + INST_2x(vphsubbw, kInstVphsubbw, XmmReg, Mem) + INST_2x(vphsubdq, kInstVphsubdq, XmmReg, XmmReg) + INST_2x(vphsubdq, kInstVphsubdq, XmmReg, Mem) + INST_2x(vphsubwd, kInstVphsubwd, XmmReg, XmmReg) + INST_2x(vphsubwd, kInstVphsubwd, XmmReg, Mem) + + INST_4x(vpmacsdd, kInstVpmacsdd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacsdd, kInstVpmacsdd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacsdqh, kInstVpmacsdqh, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacsdqh, kInstVpmacsdqh, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacsdql, kInstVpmacsdql, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacsdql, kInstVpmacsdql, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacswd, kInstVpmacswd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacswd, kInstVpmacswd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacsww, kInstVpmacsww, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacsww, kInstVpmacsww, XmmReg, XmmReg, Mem, XmmReg) + + INST_4x(vpmacssdd, kInstVpmacssdd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacssdd, kInstVpmacssdd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacssdqh, kInstVpmacssdqh, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacssdqh, kInstVpmacssdqh, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacssdql, kInstVpmacssdql, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacssdql, kInstVpmacssdql, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacsswd, kInstVpmacsswd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacsswd, kInstVpmacsswd, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpmacssww, kInstVpmacssww, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmacssww, kInstVpmacssww, XmmReg, XmmReg, Mem, XmmReg) + + INST_4x(vpmadcsswd, kInstVpmadcsswd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmadcsswd, kInstVpmadcsswd, XmmReg, XmmReg, Mem, XmmReg) + + INST_4x(vpmadcswd, kInstVpmadcswd, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpmadcswd, kInstVpmadcswd, XmmReg, XmmReg, Mem, XmmReg) + + INST_4x(vpperm, kInstVpperm, XmmReg, XmmReg, XmmReg, XmmReg) + INST_4x(vpperm, kInstVpperm, XmmReg, XmmReg, Mem, XmmReg) + INST_4x(vpperm, kInstVpperm, XmmReg, XmmReg, XmmReg, Mem) + + INST_3x(vprotb, kInstVprotb, XmmReg, XmmReg, XmmReg) + INST_3x(vprotb, kInstVprotb, XmmReg, Mem, XmmReg) + INST_3x(vprotb, kInstVprotb, XmmReg, XmmReg, Mem) + INST_3i(vprotb, kInstVprotb, XmmReg, XmmReg, Imm) + INST_3i(vprotb, kInstVprotb, XmmReg, Mem, Imm) + + INST_3x(vprotd, kInstVprotd, XmmReg, XmmReg, XmmReg) + INST_3x(vprotd, kInstVprotd, XmmReg, Mem, XmmReg) + INST_3x(vprotd, kInstVprotd, XmmReg, XmmReg, Mem) + INST_3i(vprotd, kInstVprotd, XmmReg, XmmReg, Imm) + INST_3i(vprotd, kInstVprotd, XmmReg, Mem, Imm) + + INST_3x(vprotq, kInstVprotq, XmmReg, XmmReg, XmmReg) + INST_3x(vprotq, kInstVprotq, XmmReg, Mem, XmmReg) + INST_3x(vprotq, kInstVprotq, XmmReg, XmmReg, Mem) + INST_3i(vprotq, kInstVprotq, XmmReg, XmmReg, Imm) + INST_3i(vprotq, kInstVprotq, XmmReg, Mem, Imm) + + INST_3x(vprotw, kInstVprotw, XmmReg, XmmReg, XmmReg) + INST_3x(vprotw, kInstVprotw, XmmReg, Mem, XmmReg) + INST_3x(vprotw, kInstVprotw, XmmReg, XmmReg, Mem) + INST_3i(vprotw, kInstVprotw, XmmReg, XmmReg, Imm) + INST_3i(vprotw, kInstVprotw, XmmReg, Mem, Imm) + + INST_3x(vpshab, kInstVpshab, XmmReg, XmmReg, XmmReg) + INST_3x(vpshab, kInstVpshab, XmmReg, Mem, XmmReg) + INST_3x(vpshab, kInstVpshab, XmmReg, XmmReg, Mem) + + INST_3x(vpshad, kInstVpshad, XmmReg, XmmReg, XmmReg) + INST_3x(vpshad, kInstVpshad, XmmReg, Mem, XmmReg) + INST_3x(vpshad, kInstVpshad, XmmReg, XmmReg, Mem) + + INST_3x(vpshaq, kInstVpshaq, XmmReg, XmmReg, XmmReg) + INST_3x(vpshaq, kInstVpshaq, XmmReg, Mem, XmmReg) + INST_3x(vpshaq, kInstVpshaq, XmmReg, XmmReg, Mem) + + INST_3x(vpshaw, kInstVpshaw, XmmReg, XmmReg, XmmReg) + INST_3x(vpshaw, kInstVpshaw, XmmReg, Mem, XmmReg) + INST_3x(vpshaw, kInstVpshaw, XmmReg, XmmReg, Mem) + + INST_3x(vpshlb, kInstVpshlb, XmmReg, XmmReg, XmmReg) + INST_3x(vpshlb, kInstVpshlb, XmmReg, Mem, XmmReg) + INST_3x(vpshlb, kInstVpshlb, XmmReg, XmmReg, Mem) + + INST_3x(vpshld, kInstVpshld, XmmReg, XmmReg, XmmReg) + INST_3x(vpshld, kInstVpshld, XmmReg, Mem, XmmReg) + INST_3x(vpshld, kInstVpshld, XmmReg, XmmReg, Mem) + + INST_3x(vpshlq, kInstVpshlq, XmmReg, XmmReg, XmmReg) + INST_3x(vpshlq, kInstVpshlq, XmmReg, Mem, XmmReg) + INST_3x(vpshlq, kInstVpshlq, XmmReg, XmmReg, Mem) + + INST_3x(vpshlw, kInstVpshlw, XmmReg, XmmReg, XmmReg) + INST_3x(vpshlw, kInstVpshlw, XmmReg, Mem, XmmReg) + INST_3x(vpshlw, kInstVpshlw, XmmReg, XmmReg, Mem) + // -------------------------------------------------------------------------- // [BMI] // -------------------------------------------------------------------------- diff --git a/src/asmjit/x86/x86compiler.cpp b/src/asmjit/x86/x86compiler.cpp index 039834b..3c6ab72 100644 --- a/src/asmjit/x86/x86compiler.cpp +++ b/src/asmjit/x86/x86compiler.cpp @@ -509,6 +509,12 @@ Error X86X64Compiler::_newVar(BaseVar* var, uint32_t vType, const char* name) { vType = _targetVarMapping[vType]; ASMJIT_ASSERT(vType != kVarTypeInvalid); + // There is not ASSERT in release mode and this should be checked. + if (vType == kVarTypeInvalid) { + static_cast(var)->reset(); + return kErrorInvalidArgument; + } + const VarInfo& vInfo = _varInfo[vType]; VarData* vd = _newVd(vType, vInfo.getSize(), vInfo.getClass(), name); diff --git a/src/asmjit/x86/x86defs.cpp b/src/asmjit/x86/x86defs.cpp index 009c4d6..a49d556 100644 --- a/src/asmjit/x86/x86defs.cpp +++ b/src/asmjit/x86/x86defs.cpp @@ -694,6 +694,12 @@ const char _instName[] = "vfmadd231ps\0" "vfmadd231sd\0" "vfmadd231ss\0" + "vfmaddpd\0" + "vfmaddps\0" + "vfmaddsd\0" + "vfmaddss\0" + "vfmaddsubpd\0" + "vfmaddsubps\0" "vfmaddsub132pd\0" "vfmaddsub132ps\0" "vfmaddsub213pd\0" @@ -718,6 +724,12 @@ const char _instName[] = "vfmsubadd213ps\0" "vfmsubadd231pd\0" "vfmsubadd231ps\0" + "vfmsubaddpd\0" + "vfmsubaddps\0" + "vfmsubpd\0" + "vfmsubps\0" + "vfmsubsd\0" + "vfmsubss\0" "vfnmadd132pd\0" "vfnmadd132ps\0" "vfnmadd132sd\0" @@ -730,6 +742,10 @@ const char _instName[] = "vfnmadd231ps\0" "vfnmadd231sd\0" "vfnmadd231ss\0" + "vfnmaddpd\0" + "vfnmaddps\0" + "vfnmaddsd\0" + "vfnmaddss\0" "vfnmsub132pd\0" "vfnmsub132ps\0" "vfnmsub132sd\0" @@ -742,6 +758,14 @@ const char _instName[] = "vfnmsub231ps\0" "vfnmsub231sd\0" "vfnmsub231ss\0" + "vfnmsubpd\0" + "vfnmsubps\0" + "vfnmsubsd\0" + "vfnmsubss\0" + "vfrczpd\0" + "vfrczps\0" + "vfrczsd\0" + "vfrczss\0" "vgatherdpd\0" "vgatherdps\0" "vgatherqpd\0" @@ -826,6 +850,7 @@ const char _instName[] = "vpbroadcastq\0" "vpbroadcastw\0" "vpclmulqdq\0" + "vpcmov\0" "vpcmpeqb\0" "vpcmpeqd\0" "vpcmpeqq\0" @@ -838,9 +863,19 @@ const char _instName[] = "vpcmpgtw\0" "vpcmpistri\0" "vpcmpistrm\0" + "vpcomb\0" + "vpcomd\0" + "vpcomq\0" + "vpcomub\0" + "vpcomud\0" + "vpcomuq\0" + "vpcomuw\0" + "vpcomw\0" "vperm2f128\0" "vperm2i128\0" "vpermd\0" + "vpermil2pd\0" + "vpermil2ps\0" "vpermilpd\0" "vpermilps\0" "vpermpd\0" @@ -854,17 +889,44 @@ const char _instName[] = "vpgatherdq\0" "vpgatherqd\0" "vpgatherqq\0" + "vphaddbd\0" + "vphaddbq\0" + "vphaddbw\0" "vphaddd\0" + "vphadddq\0" "vphaddsw\0" + "vphaddubd\0" + "vphaddubq\0" + "vphaddubw\0" + "vphaddudq\0" + "vphadduwd\0" + "vphadduwq\0" "vphaddw\0" + "vphaddwd\0" + "vphaddwq\0" "vphminposuw\0" + "vphsubbw\0" + "vphsubdq\0" "vphsubd\0" "vphsubsw\0" "vphsubw\0" + "vphsubwd\0" "vpinsrb\0" "vpinsrd\0" "vpinsrq\0" "vpinsrw\0" + "vpmacsdd\0" + "vpmacsdqh\0" + "vpmacsdql\0" + "vpmacssdd\0" + "vpmacssdqh\0" + "vpmacssdql\0" + "vpmacsswd\0" + "vpmacssww\0" + "vpmacswd\0" + "vpmacsww\0" + "vpmadcsswd\0" + "vpmadcswd\0" "vpmaddubsw\0" "vpmaddwd\0" "vpmaskmovd\0" @@ -902,7 +964,20 @@ const char _instName[] = "vpmullw\0" "vpmuludq\0" "vpor\0" + "vpperm\0" + "vprotb\0" + "vprotd\0" + "vprotq\0" + "vprotw\0" "vpsadbw\0" + "vpshab\0" + "vpshad\0" + "vpshaq\0" + "vpshaw\0" + "vpshlb\0" + "vpshld\0" + "vpshlq\0" + "vpshlw\0" "vpshufb\0" "vpshufd\0" "vpshufhw\0" @@ -1649,293 +1724,368 @@ enum kInstData_NameIndex { kInstVfmadd231ps_NameIndex = 4715, kInstVfmadd231sd_NameIndex = 4727, kInstVfmadd231ss_NameIndex = 4739, - kInstVfmaddsub132pd_NameIndex = 4751, - kInstVfmaddsub132ps_NameIndex = 4766, - kInstVfmaddsub213pd_NameIndex = 4781, - kInstVfmaddsub213ps_NameIndex = 4796, - kInstVfmaddsub231pd_NameIndex = 4811, - kInstVfmaddsub231ps_NameIndex = 4826, - kInstVfmsub132pd_NameIndex = 4841, - kInstVfmsub132ps_NameIndex = 4853, - kInstVfmsub132sd_NameIndex = 4865, - kInstVfmsub132ss_NameIndex = 4877, - kInstVfmsub213pd_NameIndex = 4889, - kInstVfmsub213ps_NameIndex = 4901, - kInstVfmsub213sd_NameIndex = 4913, - kInstVfmsub213ss_NameIndex = 4925, - kInstVfmsub231pd_NameIndex = 4937, - kInstVfmsub231ps_NameIndex = 4949, - kInstVfmsub231sd_NameIndex = 4961, - kInstVfmsub231ss_NameIndex = 4973, - kInstVfmsubadd132pd_NameIndex = 4985, - kInstVfmsubadd132ps_NameIndex = 5000, - kInstVfmsubadd213pd_NameIndex = 5015, - kInstVfmsubadd213ps_NameIndex = 5030, - kInstVfmsubadd231pd_NameIndex = 5045, - kInstVfmsubadd231ps_NameIndex = 5060, - kInstVfnmadd132pd_NameIndex = 5075, - kInstVfnmadd132ps_NameIndex = 5088, - kInstVfnmadd132sd_NameIndex = 5101, - kInstVfnmadd132ss_NameIndex = 5114, - kInstVfnmadd213pd_NameIndex = 5127, - kInstVfnmadd213ps_NameIndex = 5140, - kInstVfnmadd213sd_NameIndex = 5153, - kInstVfnmadd213ss_NameIndex = 5166, - kInstVfnmadd231pd_NameIndex = 5179, - kInstVfnmadd231ps_NameIndex = 5192, - kInstVfnmadd231sd_NameIndex = 5205, - kInstVfnmadd231ss_NameIndex = 5218, - kInstVfnmsub132pd_NameIndex = 5231, - kInstVfnmsub132ps_NameIndex = 5244, - kInstVfnmsub132sd_NameIndex = 5257, - kInstVfnmsub132ss_NameIndex = 5270, - kInstVfnmsub213pd_NameIndex = 5283, - kInstVfnmsub213ps_NameIndex = 5296, - kInstVfnmsub213sd_NameIndex = 5309, - kInstVfnmsub213ss_NameIndex = 5322, - kInstVfnmsub231pd_NameIndex = 5335, - kInstVfnmsub231ps_NameIndex = 5348, - kInstVfnmsub231sd_NameIndex = 5361, - kInstVfnmsub231ss_NameIndex = 5374, - kInstVgatherdpd_NameIndex = 5387, - kInstVgatherdps_NameIndex = 5398, - kInstVgatherqpd_NameIndex = 5409, - kInstVgatherqps_NameIndex = 5420, - kInstVhaddpd_NameIndex = 5431, - kInstVhaddps_NameIndex = 5439, - kInstVhsubpd_NameIndex = 5447, - kInstVhsubps_NameIndex = 5455, - kInstVinsertf128_NameIndex = 5463, - kInstVinserti128_NameIndex = 5475, - kInstVinsertps_NameIndex = 5487, - kInstVlddqu_NameIndex = 5497, - kInstVldmxcsr_NameIndex = 5504, - kInstVmaskmovdqu_NameIndex = 5513, - kInstVmaskmovpd_NameIndex = 5525, - kInstVmaskmovps_NameIndex = 5536, - kInstVmaxpd_NameIndex = 5547, - kInstVmaxps_NameIndex = 5554, - kInstVmaxsd_NameIndex = 5561, - kInstVmaxss_NameIndex = 5568, - kInstVminpd_NameIndex = 5575, - kInstVminps_NameIndex = 5582, - kInstVminsd_NameIndex = 5589, - kInstVminss_NameIndex = 5596, - kInstVmovapd_NameIndex = 5603, - kInstVmovaps_NameIndex = 5611, - kInstVmovd_NameIndex = 5619, - kInstVmovddup_NameIndex = 5625, - kInstVmovdqa_NameIndex = 5634, - kInstVmovdqu_NameIndex = 5642, - kInstVmovhlps_NameIndex = 5650, - kInstVmovhpd_NameIndex = 5659, - kInstVmovhps_NameIndex = 5667, - kInstVmovlhps_NameIndex = 5675, - kInstVmovlpd_NameIndex = 5684, - kInstVmovlps_NameIndex = 5692, - kInstVmovmskpd_NameIndex = 5700, - kInstVmovmskps_NameIndex = 5710, - kInstVmovntdq_NameIndex = 5720, - kInstVmovntdqa_NameIndex = 5729, - kInstVmovntpd_NameIndex = 5739, - kInstVmovntps_NameIndex = 5748, - kInstVmovq_NameIndex = 5757, - kInstVmovsd_NameIndex = 5763, - kInstVmovshdup_NameIndex = 5770, - kInstVmovsldup_NameIndex = 5780, - kInstVmovss_NameIndex = 5790, - kInstVmovupd_NameIndex = 5797, - kInstVmovups_NameIndex = 5805, - kInstVmpsadbw_NameIndex = 5813, - kInstVmulpd_NameIndex = 5822, - kInstVmulps_NameIndex = 5829, - kInstVmulsd_NameIndex = 5836, - kInstVmulss_NameIndex = 5843, - kInstVorpd_NameIndex = 5850, - kInstVorps_NameIndex = 5856, - kInstVpabsb_NameIndex = 5862, - kInstVpabsd_NameIndex = 5869, - kInstVpabsw_NameIndex = 5876, - kInstVpackssdw_NameIndex = 5883, - kInstVpacksswb_NameIndex = 5893, - kInstVpackusdw_NameIndex = 5903, - kInstVpackuswb_NameIndex = 5913, - kInstVpaddb_NameIndex = 5923, - kInstVpaddd_NameIndex = 5930, - kInstVpaddq_NameIndex = 5937, - kInstVpaddsb_NameIndex = 5944, - kInstVpaddsw_NameIndex = 5952, - kInstVpaddusb_NameIndex = 5960, - kInstVpaddusw_NameIndex = 5969, - kInstVpaddw_NameIndex = 5978, - kInstVpalignr_NameIndex = 5985, - kInstVpand_NameIndex = 5994, - kInstVpandn_NameIndex = 6000, - kInstVpavgb_NameIndex = 6007, - kInstVpavgw_NameIndex = 6014, - kInstVpblendd_NameIndex = 6021, - kInstVpblendvb_NameIndex = 6030, - kInstVpblendw_NameIndex = 6040, - kInstVpbroadcastb_NameIndex = 6049, - kInstVpbroadcastd_NameIndex = 6062, - kInstVpbroadcastq_NameIndex = 6075, - kInstVpbroadcastw_NameIndex = 6088, - kInstVpclmulqdq_NameIndex = 6101, - kInstVpcmpeqb_NameIndex = 6112, - kInstVpcmpeqd_NameIndex = 6121, - kInstVpcmpeqq_NameIndex = 6130, - kInstVpcmpeqw_NameIndex = 6139, - kInstVpcmpestri_NameIndex = 6148, - kInstVpcmpestrm_NameIndex = 6159, - kInstVpcmpgtb_NameIndex = 6170, - kInstVpcmpgtd_NameIndex = 6179, - kInstVpcmpgtq_NameIndex = 6188, - kInstVpcmpgtw_NameIndex = 6197, - kInstVpcmpistri_NameIndex = 6206, - kInstVpcmpistrm_NameIndex = 6217, - kInstVperm2f128_NameIndex = 6228, - kInstVperm2i128_NameIndex = 6239, - kInstVpermd_NameIndex = 6250, - kInstVpermilpd_NameIndex = 6257, - kInstVpermilps_NameIndex = 6267, - kInstVpermpd_NameIndex = 6277, - kInstVpermps_NameIndex = 6285, - kInstVpermq_NameIndex = 6293, - kInstVpextrb_NameIndex = 6300, - kInstVpextrd_NameIndex = 6308, - kInstVpextrq_NameIndex = 6316, - kInstVpextrw_NameIndex = 6324, - kInstVpgatherdd_NameIndex = 6332, - kInstVpgatherdq_NameIndex = 6343, - kInstVpgatherqd_NameIndex = 6354, - kInstVpgatherqq_NameIndex = 6365, - kInstVphaddd_NameIndex = 6376, - kInstVphaddsw_NameIndex = 6384, - kInstVphaddw_NameIndex = 6393, - kInstVphminposuw_NameIndex = 6401, - kInstVphsubd_NameIndex = 6413, - kInstVphsubsw_NameIndex = 6421, - kInstVphsubw_NameIndex = 6430, - kInstVpinsrb_NameIndex = 6438, - kInstVpinsrd_NameIndex = 6446, - kInstVpinsrq_NameIndex = 6454, - kInstVpinsrw_NameIndex = 6462, - kInstVpmaddubsw_NameIndex = 6470, - kInstVpmaddwd_NameIndex = 6481, - kInstVpmaskmovd_NameIndex = 6490, - kInstVpmaskmovq_NameIndex = 6501, - kInstVpmaxsb_NameIndex = 6512, - kInstVpmaxsd_NameIndex = 6520, - kInstVpmaxsw_NameIndex = 6528, - kInstVpmaxub_NameIndex = 6536, - kInstVpmaxud_NameIndex = 6544, - kInstVpmaxuw_NameIndex = 6552, - kInstVpminsb_NameIndex = 6560, - kInstVpminsd_NameIndex = 6568, - kInstVpminsw_NameIndex = 6576, - kInstVpminub_NameIndex = 6584, - kInstVpminud_NameIndex = 6592, - kInstVpminuw_NameIndex = 6600, - kInstVpmovmskb_NameIndex = 6608, - kInstVpmovsxbd_NameIndex = 6618, - kInstVpmovsxbq_NameIndex = 6628, - kInstVpmovsxbw_NameIndex = 6638, - kInstVpmovsxdq_NameIndex = 6648, - kInstVpmovsxwd_NameIndex = 6658, - kInstVpmovsxwq_NameIndex = 6668, - kInstVpmovzxbd_NameIndex = 6678, - kInstVpmovzxbq_NameIndex = 6688, - kInstVpmovzxbw_NameIndex = 6698, - kInstVpmovzxdq_NameIndex = 6708, - kInstVpmovzxwd_NameIndex = 6718, - kInstVpmovzxwq_NameIndex = 6728, - kInstVpmuldq_NameIndex = 6738, - kInstVpmulhrsw_NameIndex = 6746, - kInstVpmulhuw_NameIndex = 6756, - kInstVpmulhw_NameIndex = 6765, - kInstVpmulld_NameIndex = 6773, - kInstVpmullw_NameIndex = 6781, - kInstVpmuludq_NameIndex = 6789, - kInstVpor_NameIndex = 6798, - kInstVpsadbw_NameIndex = 6803, - kInstVpshufb_NameIndex = 6811, - kInstVpshufd_NameIndex = 6819, - kInstVpshufhw_NameIndex = 6827, - kInstVpshuflw_NameIndex = 6836, - kInstVpsignb_NameIndex = 6845, - kInstVpsignd_NameIndex = 6853, - kInstVpsignw_NameIndex = 6861, - kInstVpslld_NameIndex = 6869, - kInstVpslldq_NameIndex = 6876, - kInstVpsllq_NameIndex = 6884, - kInstVpsllvd_NameIndex = 6891, - kInstVpsllvq_NameIndex = 6899, - kInstVpsllw_NameIndex = 6907, - kInstVpsrad_NameIndex = 6914, - kInstVpsravd_NameIndex = 6921, - kInstVpsraw_NameIndex = 6929, - kInstVpsrld_NameIndex = 6936, - kInstVpsrldq_NameIndex = 6943, - kInstVpsrlq_NameIndex = 6951, - kInstVpsrlvd_NameIndex = 6958, - kInstVpsrlvq_NameIndex = 6966, - kInstVpsrlw_NameIndex = 6974, - kInstVpsubb_NameIndex = 6981, - kInstVpsubd_NameIndex = 6988, - kInstVpsubq_NameIndex = 6995, - kInstVpsubsb_NameIndex = 7002, - kInstVpsubsw_NameIndex = 7010, - kInstVpsubusb_NameIndex = 7018, - kInstVpsubusw_NameIndex = 7027, - kInstVpsubw_NameIndex = 7036, - kInstVptest_NameIndex = 7043, - kInstVpunpckhbw_NameIndex = 7050, - kInstVpunpckhdq_NameIndex = 7061, - kInstVpunpckhqdq_NameIndex = 7072, - kInstVpunpckhwd_NameIndex = 7084, - kInstVpunpcklbw_NameIndex = 7095, - kInstVpunpckldq_NameIndex = 7106, - kInstVpunpcklqdq_NameIndex = 7117, - kInstVpunpcklwd_NameIndex = 7129, - kInstVpxor_NameIndex = 7140, - kInstVrcpps_NameIndex = 7146, - kInstVrcpss_NameIndex = 7153, - kInstVroundpd_NameIndex = 7160, - kInstVroundps_NameIndex = 7169, - kInstVroundsd_NameIndex = 7178, - kInstVroundss_NameIndex = 7187, - kInstVrsqrtps_NameIndex = 7196, - kInstVrsqrtss_NameIndex = 7205, - kInstVshufpd_NameIndex = 7214, - kInstVshufps_NameIndex = 7222, - kInstVsqrtpd_NameIndex = 7230, - kInstVsqrtps_NameIndex = 7238, - kInstVsqrtsd_NameIndex = 7246, - kInstVsqrtss_NameIndex = 7254, - kInstVstmxcsr_NameIndex = 7262, - kInstVsubpd_NameIndex = 7271, - kInstVsubps_NameIndex = 7278, - kInstVsubsd_NameIndex = 7285, - kInstVsubss_NameIndex = 7292, - kInstVtestpd_NameIndex = 7299, - kInstVtestps_NameIndex = 7307, - kInstVucomisd_NameIndex = 7315, - kInstVucomiss_NameIndex = 7324, - kInstVunpckhpd_NameIndex = 7333, - kInstVunpckhps_NameIndex = 7343, - kInstVunpcklpd_NameIndex = 7353, - kInstVunpcklps_NameIndex = 7363, - kInstVxorpd_NameIndex = 7373, - kInstVxorps_NameIndex = 7380, - kInstVzeroall_NameIndex = 7387, - kInstVzeroupper_NameIndex = 7396, - kInstWrfsbase_NameIndex = 7407, - kInstWrgsbase_NameIndex = 7416, - kInstXadd_NameIndex = 7425, - kInstXchg_NameIndex = 7430, - kInstXor_NameIndex = 7435, - kInstXorpd_NameIndex = 7439, - kInstXorps_NameIndex = 7445 + kInstVfmaddpd_NameIndex = 4751, + kInstVfmaddps_NameIndex = 4760, + kInstVfmaddsd_NameIndex = 4769, + kInstVfmaddss_NameIndex = 4778, + kInstVfmaddsubpd_NameIndex = 4787, + kInstVfmaddsubps_NameIndex = 4799, + kInstVfmaddsub132pd_NameIndex = 4811, + kInstVfmaddsub132ps_NameIndex = 4826, + kInstVfmaddsub213pd_NameIndex = 4841, + kInstVfmaddsub213ps_NameIndex = 4856, + kInstVfmaddsub231pd_NameIndex = 4871, + kInstVfmaddsub231ps_NameIndex = 4886, + kInstVfmsub132pd_NameIndex = 4901, + kInstVfmsub132ps_NameIndex = 4913, + kInstVfmsub132sd_NameIndex = 4925, + kInstVfmsub132ss_NameIndex = 4937, + kInstVfmsub213pd_NameIndex = 4949, + kInstVfmsub213ps_NameIndex = 4961, + kInstVfmsub213sd_NameIndex = 4973, + kInstVfmsub213ss_NameIndex = 4985, + kInstVfmsub231pd_NameIndex = 4997, + kInstVfmsub231ps_NameIndex = 5009, + kInstVfmsub231sd_NameIndex = 5021, + kInstVfmsub231ss_NameIndex = 5033, + kInstVfmsubadd132pd_NameIndex = 5045, + kInstVfmsubadd132ps_NameIndex = 5060, + kInstVfmsubadd213pd_NameIndex = 5075, + kInstVfmsubadd213ps_NameIndex = 5090, + kInstVfmsubadd231pd_NameIndex = 5105, + kInstVfmsubadd231ps_NameIndex = 5120, + kInstVfmsubaddpd_NameIndex = 5135, + kInstVfmsubaddps_NameIndex = 5147, + kInstVfmsubpd_NameIndex = 5159, + kInstVfmsubps_NameIndex = 5168, + kInstVfmsubsd_NameIndex = 5177, + kInstVfmsubss_NameIndex = 5186, + kInstVfnmadd132pd_NameIndex = 5195, + kInstVfnmadd132ps_NameIndex = 5208, + kInstVfnmadd132sd_NameIndex = 5221, + kInstVfnmadd132ss_NameIndex = 5234, + kInstVfnmadd213pd_NameIndex = 5247, + kInstVfnmadd213ps_NameIndex = 5260, + kInstVfnmadd213sd_NameIndex = 5273, + kInstVfnmadd213ss_NameIndex = 5286, + kInstVfnmadd231pd_NameIndex = 5299, + kInstVfnmadd231ps_NameIndex = 5312, + kInstVfnmadd231sd_NameIndex = 5325, + kInstVfnmadd231ss_NameIndex = 5338, + kInstVfnmaddpd_NameIndex = 5351, + kInstVfnmaddps_NameIndex = 5361, + kInstVfnmaddsd_NameIndex = 5371, + kInstVfnmaddss_NameIndex = 5381, + kInstVfnmsub132pd_NameIndex = 5391, + kInstVfnmsub132ps_NameIndex = 5404, + kInstVfnmsub132sd_NameIndex = 5417, + kInstVfnmsub132ss_NameIndex = 5430, + kInstVfnmsub213pd_NameIndex = 5443, + kInstVfnmsub213ps_NameIndex = 5456, + kInstVfnmsub213sd_NameIndex = 5469, + kInstVfnmsub213ss_NameIndex = 5482, + kInstVfnmsub231pd_NameIndex = 5495, + kInstVfnmsub231ps_NameIndex = 5508, + kInstVfnmsub231sd_NameIndex = 5521, + kInstVfnmsub231ss_NameIndex = 5534, + kInstVfnmsubpd_NameIndex = 5547, + kInstVfnmsubps_NameIndex = 5557, + kInstVfnmsubsd_NameIndex = 5567, + kInstVfnmsubss_NameIndex = 5577, + kInstVfrczpd_NameIndex = 5587, + kInstVfrczps_NameIndex = 5595, + kInstVfrczsd_NameIndex = 5603, + kInstVfrczss_NameIndex = 5611, + kInstVgatherdpd_NameIndex = 5619, + kInstVgatherdps_NameIndex = 5630, + kInstVgatherqpd_NameIndex = 5641, + kInstVgatherqps_NameIndex = 5652, + kInstVhaddpd_NameIndex = 5663, + kInstVhaddps_NameIndex = 5671, + kInstVhsubpd_NameIndex = 5679, + kInstVhsubps_NameIndex = 5687, + kInstVinsertf128_NameIndex = 5695, + kInstVinserti128_NameIndex = 5707, + kInstVinsertps_NameIndex = 5719, + kInstVlddqu_NameIndex = 5729, + kInstVldmxcsr_NameIndex = 5736, + kInstVmaskmovdqu_NameIndex = 5745, + kInstVmaskmovpd_NameIndex = 5757, + kInstVmaskmovps_NameIndex = 5768, + kInstVmaxpd_NameIndex = 5779, + kInstVmaxps_NameIndex = 5786, + kInstVmaxsd_NameIndex = 5793, + kInstVmaxss_NameIndex = 5800, + kInstVminpd_NameIndex = 5807, + kInstVminps_NameIndex = 5814, + kInstVminsd_NameIndex = 5821, + kInstVminss_NameIndex = 5828, + kInstVmovapd_NameIndex = 5835, + kInstVmovaps_NameIndex = 5843, + kInstVmovd_NameIndex = 5851, + kInstVmovddup_NameIndex = 5857, + kInstVmovdqa_NameIndex = 5866, + kInstVmovdqu_NameIndex = 5874, + kInstVmovhlps_NameIndex = 5882, + kInstVmovhpd_NameIndex = 5891, + kInstVmovhps_NameIndex = 5899, + kInstVmovlhps_NameIndex = 5907, + kInstVmovlpd_NameIndex = 5916, + kInstVmovlps_NameIndex = 5924, + kInstVmovmskpd_NameIndex = 5932, + kInstVmovmskps_NameIndex = 5942, + kInstVmovntdq_NameIndex = 5952, + kInstVmovntdqa_NameIndex = 5961, + kInstVmovntpd_NameIndex = 5971, + kInstVmovntps_NameIndex = 5980, + kInstVmovq_NameIndex = 5989, + kInstVmovsd_NameIndex = 5995, + kInstVmovshdup_NameIndex = 6002, + kInstVmovsldup_NameIndex = 6012, + kInstVmovss_NameIndex = 6022, + kInstVmovupd_NameIndex = 6029, + kInstVmovups_NameIndex = 6037, + kInstVmpsadbw_NameIndex = 6045, + kInstVmulpd_NameIndex = 6054, + kInstVmulps_NameIndex = 6061, + kInstVmulsd_NameIndex = 6068, + kInstVmulss_NameIndex = 6075, + kInstVorpd_NameIndex = 6082, + kInstVorps_NameIndex = 6088, + kInstVpabsb_NameIndex = 6094, + kInstVpabsd_NameIndex = 6101, + kInstVpabsw_NameIndex = 6108, + kInstVpackssdw_NameIndex = 6115, + kInstVpacksswb_NameIndex = 6125, + kInstVpackusdw_NameIndex = 6135, + kInstVpackuswb_NameIndex = 6145, + kInstVpaddb_NameIndex = 6155, + kInstVpaddd_NameIndex = 6162, + kInstVpaddq_NameIndex = 6169, + kInstVpaddsb_NameIndex = 6176, + kInstVpaddsw_NameIndex = 6184, + kInstVpaddusb_NameIndex = 6192, + kInstVpaddusw_NameIndex = 6201, + kInstVpaddw_NameIndex = 6210, + kInstVpalignr_NameIndex = 6217, + kInstVpand_NameIndex = 6226, + kInstVpandn_NameIndex = 6232, + kInstVpavgb_NameIndex = 6239, + kInstVpavgw_NameIndex = 6246, + kInstVpblendd_NameIndex = 6253, + kInstVpblendvb_NameIndex = 6262, + kInstVpblendw_NameIndex = 6272, + kInstVpbroadcastb_NameIndex = 6281, + kInstVpbroadcastd_NameIndex = 6294, + kInstVpbroadcastq_NameIndex = 6307, + kInstVpbroadcastw_NameIndex = 6320, + kInstVpclmulqdq_NameIndex = 6333, + kInstVpcmov_NameIndex = 6344, + kInstVpcmpeqb_NameIndex = 6351, + kInstVpcmpeqd_NameIndex = 6360, + kInstVpcmpeqq_NameIndex = 6369, + kInstVpcmpeqw_NameIndex = 6378, + kInstVpcmpestri_NameIndex = 6387, + kInstVpcmpestrm_NameIndex = 6398, + kInstVpcmpgtb_NameIndex = 6409, + kInstVpcmpgtd_NameIndex = 6418, + kInstVpcmpgtq_NameIndex = 6427, + kInstVpcmpgtw_NameIndex = 6436, + kInstVpcmpistri_NameIndex = 6445, + kInstVpcmpistrm_NameIndex = 6456, + kInstVpcomb_NameIndex = 6467, + kInstVpcomd_NameIndex = 6474, + kInstVpcomq_NameIndex = 6481, + kInstVpcomub_NameIndex = 6488, + kInstVpcomud_NameIndex = 6496, + kInstVpcomuq_NameIndex = 6504, + kInstVpcomuw_NameIndex = 6512, + kInstVpcomw_NameIndex = 6520, + kInstVperm2f128_NameIndex = 6527, + kInstVperm2i128_NameIndex = 6538, + kInstVpermd_NameIndex = 6549, + kInstVpermil2pd_NameIndex = 6556, + kInstVpermil2ps_NameIndex = 6567, + kInstVpermilpd_NameIndex = 6578, + kInstVpermilps_NameIndex = 6588, + kInstVpermpd_NameIndex = 6598, + kInstVpermps_NameIndex = 6606, + kInstVpermq_NameIndex = 6614, + kInstVpextrb_NameIndex = 6621, + kInstVpextrd_NameIndex = 6629, + kInstVpextrq_NameIndex = 6637, + kInstVpextrw_NameIndex = 6645, + kInstVpgatherdd_NameIndex = 6653, + kInstVpgatherdq_NameIndex = 6664, + kInstVpgatherqd_NameIndex = 6675, + kInstVpgatherqq_NameIndex = 6686, + kInstVphaddbd_NameIndex = 6697, + kInstVphaddbq_NameIndex = 6706, + kInstVphaddbw_NameIndex = 6715, + kInstVphaddd_NameIndex = 6724, + kInstVphadddq_NameIndex = 6732, + kInstVphaddsw_NameIndex = 6741, + kInstVphaddubd_NameIndex = 6750, + kInstVphaddubq_NameIndex = 6760, + kInstVphaddubw_NameIndex = 6770, + kInstVphaddudq_NameIndex = 6780, + kInstVphadduwd_NameIndex = 6790, + kInstVphadduwq_NameIndex = 6800, + kInstVphaddw_NameIndex = 6810, + kInstVphaddwd_NameIndex = 6818, + kInstVphaddwq_NameIndex = 6827, + kInstVphminposuw_NameIndex = 6836, + kInstVphsubbw_NameIndex = 6848, + kInstVphsubdq_NameIndex = 6857, + kInstVphsubd_NameIndex = 6866, + kInstVphsubsw_NameIndex = 6874, + kInstVphsubw_NameIndex = 6883, + kInstVphsubwd_NameIndex = 6891, + kInstVpinsrb_NameIndex = 6900, + kInstVpinsrd_NameIndex = 6908, + kInstVpinsrq_NameIndex = 6916, + kInstVpinsrw_NameIndex = 6924, + kInstVpmacsdd_NameIndex = 6932, + kInstVpmacsdqh_NameIndex = 6941, + kInstVpmacsdql_NameIndex = 6951, + kInstVpmacssdd_NameIndex = 6961, + kInstVpmacssdqh_NameIndex = 6971, + kInstVpmacssdql_NameIndex = 6982, + kInstVpmacsswd_NameIndex = 6993, + kInstVpmacssww_NameIndex = 7003, + kInstVpmacswd_NameIndex = 7013, + kInstVpmacsww_NameIndex = 7022, + kInstVpmadcsswd_NameIndex = 7031, + kInstVpmadcswd_NameIndex = 7042, + kInstVpmaddubsw_NameIndex = 7052, + kInstVpmaddwd_NameIndex = 7063, + kInstVpmaskmovd_NameIndex = 7072, + kInstVpmaskmovq_NameIndex = 7083, + kInstVpmaxsb_NameIndex = 7094, + kInstVpmaxsd_NameIndex = 7102, + kInstVpmaxsw_NameIndex = 7110, + kInstVpmaxub_NameIndex = 7118, + kInstVpmaxud_NameIndex = 7126, + kInstVpmaxuw_NameIndex = 7134, + kInstVpminsb_NameIndex = 7142, + kInstVpminsd_NameIndex = 7150, + kInstVpminsw_NameIndex = 7158, + kInstVpminub_NameIndex = 7166, + kInstVpminud_NameIndex = 7174, + kInstVpminuw_NameIndex = 7182, + kInstVpmovmskb_NameIndex = 7190, + kInstVpmovsxbd_NameIndex = 7200, + kInstVpmovsxbq_NameIndex = 7210, + kInstVpmovsxbw_NameIndex = 7220, + kInstVpmovsxdq_NameIndex = 7230, + kInstVpmovsxwd_NameIndex = 7240, + kInstVpmovsxwq_NameIndex = 7250, + kInstVpmovzxbd_NameIndex = 7260, + kInstVpmovzxbq_NameIndex = 7270, + kInstVpmovzxbw_NameIndex = 7280, + kInstVpmovzxdq_NameIndex = 7290, + kInstVpmovzxwd_NameIndex = 7300, + kInstVpmovzxwq_NameIndex = 7310, + kInstVpmuldq_NameIndex = 7320, + kInstVpmulhrsw_NameIndex = 7328, + kInstVpmulhuw_NameIndex = 7338, + kInstVpmulhw_NameIndex = 7347, + kInstVpmulld_NameIndex = 7355, + kInstVpmullw_NameIndex = 7363, + kInstVpmuludq_NameIndex = 7371, + kInstVpor_NameIndex = 7380, + kInstVpperm_NameIndex = 7385, + kInstVprotb_NameIndex = 7392, + kInstVprotd_NameIndex = 7399, + kInstVprotq_NameIndex = 7406, + kInstVprotw_NameIndex = 7413, + kInstVpsadbw_NameIndex = 7420, + kInstVpshab_NameIndex = 7428, + kInstVpshad_NameIndex = 7435, + kInstVpshaq_NameIndex = 7442, + kInstVpshaw_NameIndex = 7449, + kInstVpshlb_NameIndex = 7456, + kInstVpshld_NameIndex = 7463, + kInstVpshlq_NameIndex = 7470, + kInstVpshlw_NameIndex = 7477, + kInstVpshufb_NameIndex = 7484, + kInstVpshufd_NameIndex = 7492, + kInstVpshufhw_NameIndex = 7500, + kInstVpshuflw_NameIndex = 7509, + kInstVpsignb_NameIndex = 7518, + kInstVpsignd_NameIndex = 7526, + kInstVpsignw_NameIndex = 7534, + kInstVpslld_NameIndex = 7542, + kInstVpslldq_NameIndex = 7549, + kInstVpsllq_NameIndex = 7557, + kInstVpsllvd_NameIndex = 7564, + kInstVpsllvq_NameIndex = 7572, + kInstVpsllw_NameIndex = 7580, + kInstVpsrad_NameIndex = 7587, + kInstVpsravd_NameIndex = 7594, + kInstVpsraw_NameIndex = 7602, + kInstVpsrld_NameIndex = 7609, + kInstVpsrldq_NameIndex = 7616, + kInstVpsrlq_NameIndex = 7624, + kInstVpsrlvd_NameIndex = 7631, + kInstVpsrlvq_NameIndex = 7639, + kInstVpsrlw_NameIndex = 7647, + kInstVpsubb_NameIndex = 7654, + kInstVpsubd_NameIndex = 7661, + kInstVpsubq_NameIndex = 7668, + kInstVpsubsb_NameIndex = 7675, + kInstVpsubsw_NameIndex = 7683, + kInstVpsubusb_NameIndex = 7691, + kInstVpsubusw_NameIndex = 7700, + kInstVpsubw_NameIndex = 7709, + kInstVptest_NameIndex = 7716, + kInstVpunpckhbw_NameIndex = 7723, + kInstVpunpckhdq_NameIndex = 7734, + kInstVpunpckhqdq_NameIndex = 7745, + kInstVpunpckhwd_NameIndex = 7757, + kInstVpunpcklbw_NameIndex = 7768, + kInstVpunpckldq_NameIndex = 7779, + kInstVpunpcklqdq_NameIndex = 7790, + kInstVpunpcklwd_NameIndex = 7802, + kInstVpxor_NameIndex = 7813, + kInstVrcpps_NameIndex = 7819, + kInstVrcpss_NameIndex = 7826, + kInstVroundpd_NameIndex = 7833, + kInstVroundps_NameIndex = 7842, + kInstVroundsd_NameIndex = 7851, + kInstVroundss_NameIndex = 7860, + kInstVrsqrtps_NameIndex = 7869, + kInstVrsqrtss_NameIndex = 7878, + kInstVshufpd_NameIndex = 7887, + kInstVshufps_NameIndex = 7895, + kInstVsqrtpd_NameIndex = 7903, + kInstVsqrtps_NameIndex = 7911, + kInstVsqrtsd_NameIndex = 7919, + kInstVsqrtss_NameIndex = 7927, + kInstVstmxcsr_NameIndex = 7935, + kInstVsubpd_NameIndex = 7944, + kInstVsubps_NameIndex = 7951, + kInstVsubsd_NameIndex = 7958, + kInstVsubss_NameIndex = 7965, + kInstVtestpd_NameIndex = 7972, + kInstVtestps_NameIndex = 7980, + kInstVucomisd_NameIndex = 7988, + kInstVucomiss_NameIndex = 7997, + kInstVunpckhpd_NameIndex = 8006, + kInstVunpckhps_NameIndex = 8016, + kInstVunpcklpd_NameIndex = 8026, + kInstVunpcklps_NameIndex = 8036, + kInstVxorpd_NameIndex = 8046, + kInstVxorps_NameIndex = 8053, + kInstVzeroall_NameIndex = 8060, + kInstVzeroupper_NameIndex = 8069, + kInstWrfsbase_NameIndex = 8080, + kInstWrgsbase_NameIndex = 8089, + kInstXadd_NameIndex = 8098, + kInstXchg_NameIndex = 8103, + kInstXor_NameIndex = 8108, + kInstXorpd_NameIndex = 8112, + kInstXorps_NameIndex = 8118 }; // ${kInstData:End} @@ -1969,6 +2119,14 @@ enum kInstData_NameIndex { #define O_F30F38(_OpCode_, _R_) (kInstOpCode_PP_F3 | kInstOpCode_MM_0F38 | (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) #define O_F30F3A(_OpCode_, _R_) (kInstOpCode_PP_F3 | kInstOpCode_MM_0F3A | (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) +#define O_00_M03(_OpCode_, _R_) (kInstOpCode_PP_00 | kInstOpCode_MM_00011| (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) +#define O_00_M08(_OpCode_, _R_) (kInstOpCode_PP_00 | kInstOpCode_MM_01000| (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) +#define O_00_M09(_OpCode_, _R_) (kInstOpCode_PP_00 | kInstOpCode_MM_01001| (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) + +#define O_66_M03(_OpCode_, _R_) (kInstOpCode_PP_66 | kInstOpCode_MM_00011| (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) +#define O_66_M08(_OpCode_, _R_) (kInstOpCode_PP_66 | kInstOpCode_MM_01000| (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) +#define O_66_M09(_OpCode_, _R_) (kInstOpCode_PP_66 | kInstOpCode_MM_01001| (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) + #define O_00_X(_OpCode_, _R_) (kInstOpCode_PP_00 | (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) #define O_9B_X(_OpCode_, _R_) (kInstOpCode_PP_9B | (0x##_OpCode_) | ((_R_) << kInstOpCode_O_Shift)) @@ -2640,6 +2798,12 @@ const InstInfo _instInfo[] = { INST(kInstVfmadd231ps , "vfmadd231ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(B8,U) , U ), INST(kInstVfmadd231sd , "vfmadd231sd" , G(AvxRvm) , F(None) |F(W), 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(B9,U) , U ), INST(kInstVfmadd231ss , "vfmadd231ss" , G(AvxRvm) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(B9,U) , U ), + INST(kInstVfmaddpd , "vfmaddpd" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(69,U) , U ), + INST(kInstVfmaddps , "vfmaddps" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(68,U) , U ), + INST(kInstVfmaddsd , "vfmaddsd" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(6B,U) , U ), + INST(kInstVfmaddss , "vfmaddss" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(6A,U) , U ), + INST(kInstVfmaddsubpd , "vfmaddsubpd" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(5D,U) , U ), + INST(kInstVfmaddsubps , "vfmaddsubps" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(5C,U) , U ), INST(kInstVfmaddsub132pd , "vfmaddsub132pd" , G(AvxRvm_P) , F(None) |F(W), 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(96,U) , U ), INST(kInstVfmaddsub132ps , "vfmaddsub132ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(96,U) , U ), INST(kInstVfmaddsub213pd , "vfmaddsub213pd" , G(AvxRvm_P) , F(None) |F(W), 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(A6,U) , U ), @@ -2664,6 +2828,12 @@ const InstInfo _instInfo[] = { INST(kInstVfmsubadd213ps , "vfmsubadd213ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(A7,U) , U ), INST(kInstVfmsubadd231pd , "vfmsubadd231pd" , G(AvxRvm_P) , F(None) |F(W), 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(B7,U) , U ), INST(kInstVfmsubadd231ps , "vfmsubadd231ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(B7,U) , U ), + INST(kInstVfmsubaddpd , "vfmsubaddpd" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(5F,U) , U ), + INST(kInstVfmsubaddps , "vfmsubaddps" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(5E,U) , U ), + INST(kInstVfmsubpd , "vfmsubpd" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(6D,U) , U ), + INST(kInstVfmsubps , "vfmsubps" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(6C,U) , U ), + INST(kInstVfmsubsd , "vfmsubsd" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(6F,U) , U ), + INST(kInstVfmsubss , "vfmsubss" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(6E,U) , U ), INST(kInstVfnmadd132pd , "vfnmadd132pd" , G(AvxRvm_P) , F(None) |F(W), 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(9C,U) , U ), INST(kInstVfnmadd132ps , "vfnmadd132ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(9C,U) , U ), INST(kInstVfnmadd132sd , "vfnmadd132sd" , G(AvxRvm) , F(None) |F(W), 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(9D,U) , U ), @@ -2676,6 +2846,10 @@ const InstInfo _instInfo[] = { INST(kInstVfnmadd231ps , "vfnmadd231ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(BC,U) , U ), INST(kInstVfnmadd231sd , "vfnmadd231sd" , G(AvxRvm) , F(None) |F(W), 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(BC,U) , U ), INST(kInstVfnmadd231ss , "vfnmadd231ss" , G(AvxRvm) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(BC,U) , U ), + INST(kInstVfnmaddpd , "vfnmaddpd" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(79,U) , U ), + INST(kInstVfnmaddps , "vfnmaddps" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(78,U) , U ), + INST(kInstVfnmaddsd , "vfnmaddsd" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(7B,U) , U ), + INST(kInstVfnmaddss , "vfnmaddss" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(7A,U) , U ), INST(kInstVfnmsub132pd , "vfnmsub132pd" , G(AvxRvm_P) , F(None) |F(W), 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(9E,U) , U ), INST(kInstVfnmsub132ps , "vfnmsub132ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(9E,U) , U ), INST(kInstVfnmsub132sd , "vfnmsub132sd" , G(AvxRvm) , F(None) |F(W), 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(9F,U) , U ), @@ -2688,6 +2862,14 @@ const InstInfo _instInfo[] = { INST(kInstVfnmsub231ps , "vfnmsub231ps" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(BE,U) , U ), INST(kInstVfnmsub231sd , "vfnmsub231sd" , G(AvxRvm) , F(None) |F(W), 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(BF,U) , U ), INST(kInstVfnmsub231ss , "vfnmsub231ss" , G(AvxRvm) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , U , O_660F38(BF,U) , U ), + INST(kInstVfnmsubpd , "vfnmsubpd" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(7D,U) , U ), + INST(kInstVfnmsubps , "vfnmsubps" , G(Fma4_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_660F3A(7C,U) , U ), + INST(kInstVfnmsubsd , "vfnmsubsd" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(7F,U) , U ), + INST(kInstVfnmsubss , "vfnmsubss" , G(Fma4) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_660F3A(7E,U) , U ), + INST(kInstVfrczpd , "vfrczpd" , G(XopRm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmmMem) , U , U , O_00_M09(81,U) , U ), + INST(kInstVfrczps , "vfrczps" , G(XopRm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmmMem) , U , U , O_00_M09(80,U) , U ), + INST(kInstVfrczsd , "vfrczsd" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(83,U) , U ), + INST(kInstVfrczss , "vfrczss" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(82,U) , U ), INST(kInstVgatherdpd , "vgatherdpd" , G(AvxGather) , F(None) |F(W), 0 , O(XmmYmm) , O(Mem) , O(XmmYmm) , U , O_660F38(92,U) , U ), INST(kInstVgatherdps , "vgatherdps" , G(AvxGather) , F(None) , 0 , O(XmmYmm) , O(Mem) , O(XmmYmm) , U , O_660F38(92,U) , U ), INST(kInstVgatherqpd , "vgatherqpd" , G(AvxGather) , F(None) |F(W), 0 , O(XmmYmm) , O(Mem) , O(XmmYmm) , U , O_660F38(93,U) , U ), @@ -2772,6 +2954,7 @@ const InstInfo _instInfo[] = { INST(kInstVpbroadcastq , "vpbroadcastq" , G(AvxRm_P) , F(None) , 0 , O(XmmYmm) , O(XmmMem) , U , U , O_660F38(59,U) , U ), INST(kInstVpbroadcastw , "vpbroadcastw" , G(AvxRm_P) , F(None) , 0 , O(XmmYmm) , O(XmmMem) , U , U , O_660F38(79,U) , U ), INST(kInstVpclmulqdq , "vpclmulqdq" , G(AvxRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_660F3A(44,U) , U ), + INST(kInstVpcmov , "vpcmov" , G(XopRvrmRvmr_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_00_M08(A2,U) , U ), INST(kInstVpcmpeqb , "vpcmpeqb" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(74,U) , U ), INST(kInstVpcmpeqd , "vpcmpeqd" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(76,U) , U ), INST(kInstVpcmpeqq , "vpcmpeqq" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(29,U) , U ), @@ -2784,9 +2967,19 @@ const InstInfo _instInfo[] = { INST(kInstVpcmpgtw , "vpcmpgtw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(65,U) , U ), INST(kInstVpcmpistri , "vpcmpistri" , G(AvxRmi) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(Imm) , U , O_660F3A(63,U) , U ), INST(kInstVpcmpistrm , "vpcmpistrm" , G(AvxRmi) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(Imm) , U , O_660F3A(62,U) , U ), + INST(kInstVpcomb , "vpcomb" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(CC,U) , U ), + INST(kInstVpcomd , "vpcomd" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(CE,U) , U ), + INST(kInstVpcomq , "vpcomq" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(CF,U) , U ), + INST(kInstVpcomub , "vpcomub" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(EC,U) , U ), + INST(kInstVpcomud , "vpcomud" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(EE,U) , U ), + INST(kInstVpcomuq , "vpcomuq" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(EF,U) , U ), + INST(kInstVpcomuw , "vpcomuw" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(ED,U) , U ), + INST(kInstVpcomw , "vpcomw" , G(XopRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Imm) , O_00_M08(CD,U) , U ), INST(kInstVperm2f128 , "vperm2f128" , G(AvxRvmi) , F(None) , 0 , O(Ymm) , O(Ymm) , O(YmmMem) , O(Imm) , O_660F3A(06,U)|L, U ), INST(kInstVperm2i128 , "vperm2i128" , G(AvxRvmi) , F(None) , 0 , O(Ymm) , O(Ymm) , O(YmmMem) , O(Imm) , O_660F3A(46,U)|L, U ), INST(kInstVpermd , "vpermd" , G(AvxRvm) , F(None) , 0 , O(Ymm) , O(Ymm) , O(YmmMem) , U , O_660F38(36,U)|L, U ), + INST(kInstVpermil2pd , "vpermil2pd" , G(AvxRvrmRvmr_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_66_M03(49,U) , U ), + INST(kInstVpermil2ps , "vpermil2ps" , G(AvxRvrmRvmr_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem) , O_66_M03(48,U) , U ), INST(kInstVpermilpd , "vpermilpd" , G(AvxRvmRmi_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem)|O(Imm) , U , O_660F38(0D,U) , O_660F3A(05,U) ), INST(kInstVpermilps , "vpermilps" , G(AvxRvmRmi_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmmMem) , O(XmmYmmMem)|O(Imm) , U , O_660F38(0C,U) , O_660F3A(04,U) ), INST(kInstVpermpd , "vpermpd" , G(AvxRmi) , F(None) |F(W), 0 , O(Ymm) , O(YmmMem) , O(Imm) , U , O_660F3A(01,U)|L, U ), @@ -2800,17 +2993,44 @@ const InstInfo _instInfo[] = { INST(kInstVpgatherdq , "vpgatherdq" , G(AvxGather) , F(None) |F(W), 0 , O(XmmYmm) , O(Mem) , O(XmmYmm) , U , O_660F38(90,U) , U ), INST(kInstVpgatherqd , "vpgatherqd" , G(AvxGatherEx) , F(None) , 0 , O(Xmm) , O(Mem) , O(Xmm) , U , O_660F38(91,U) , U ), INST(kInstVpgatherqq , "vpgatherqq" , G(AvxGather) , F(None) |F(W), 0 , O(XmmYmm) , O(Mem) , O(XmmYmm) , U , O_660F38(91,U) , U ), + INST(kInstVphaddbd , "vphaddbd" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(C2,U) , U ), + INST(kInstVphaddbq , "vphaddbq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(C3,U) , U ), + INST(kInstVphaddbw , "vphaddbw" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(C1,U) , U ), INST(kInstVphaddd , "vphaddd" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(02,U) , U ), + INST(kInstVphadddq , "vphadddq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(CB,U) , U ), INST(kInstVphaddsw , "vphaddsw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(03,U) , U ), + INST(kInstVphaddubd , "vphaddubd" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(D2,U) , U ), + INST(kInstVphaddubq , "vphaddubq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(D3,U) , U ), + INST(kInstVphaddubw , "vphaddubw" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(D1,U) , U ), + INST(kInstVphaddudq , "vphaddudq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(DB,U) , U ), + INST(kInstVphadduwd , "vphadduwd" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(D6,U) , U ), + INST(kInstVphadduwq , "vphadduwq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(D7,U) , U ), INST(kInstVphaddw , "vphaddw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(01,U) , U ), + INST(kInstVphaddwd , "vphaddwd" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(C6,U) , U ), + INST(kInstVphaddwq , "vphaddwq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(C7,U) , U ), INST(kInstVphminposuw , "vphminposuw" , G(AvxRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_660F38(41,U) , U ), + INST(kInstVphsubbw , "vphsubbw" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(E1,U) , U ), + INST(kInstVphsubdq , "vphsubdq" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(E3,U) , U ), INST(kInstVphsubd , "vphsubd" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(06,U) , U ), INST(kInstVphsubsw , "vphsubsw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(07,U) , U ), INST(kInstVphsubw , "vphsubw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(05,U) , U ), + INST(kInstVphsubwd , "vphsubwd" , G(XopRm) , F(None) , 0 , O(Xmm) , O(XmmMem) , U , U , O_00_M09(E2,U) , U ), INST(kInstVpinsrb , "vpinsrb" , G(AvxRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(GqdwbMem) , O(Imm) , O_660F3A(20,U) , U ), INST(kInstVpinsrd , "vpinsrd" , G(AvxRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(GqdMem) , O(Imm) , O_660F3A(22,U) , U ), INST(kInstVpinsrq , "vpinsrq" , G(AvxRvmi) , F(None) |F(W), 0 , O(Xmm) , O(Xmm) , O(GqMem) , O(Imm) , O_660F3A(22,U) , U ), INST(kInstVpinsrw , "vpinsrw" , G(AvxRvmi) , F(None) , 0 , O(Xmm) , O(Xmm) , O(GqdwMem) , O(Imm) , O_660F00(C4,U) , U ), + INST(kInstVpmacsdd , "vpmacsdd" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(9E,U) , U ), + INST(kInstVpmacsdqh , "vpmacsdqh" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(9F,U) , U ), + INST(kInstVpmacsdql , "vpmacsdql" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(97,U) , U ), + INST(kInstVpmacssdd , "vpmacssdd" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(8E,U) , U ), + INST(kInstVpmacssdqh , "vpmacssdqh" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(8F,U) , U ), + INST(kInstVpmacssdql , "vpmacssdql" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(87,U) , U ), + INST(kInstVpmacsswd , "vpmacsswd" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(86,U) , U ), + INST(kInstVpmacssww , "vpmacssww" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(85,U) , U ), + INST(kInstVpmacswd , "vpmacswd" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(96,U) , U ), + INST(kInstVpmacsww , "vpmacsww" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(95,U) , U ), + INST(kInstVpmadcsswd , "vpmadcsswd" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(A6,U) , U ), + INST(kInstVpmadcswd , "vpmadcswd" , G(XopRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(Xmm) , O_00_M08(B6,U) , U ), INST(kInstVpmaddubsw , "vpmaddubsw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(04,U) , U ), INST(kInstVpmaddwd , "vpmaddwd" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(F5,U) , U ), INST(kInstVpmaskmovd , "vpmaskmovd" , G(AvxRvmMvr_P) , F(None) , 0 , O(XmmYmmMem) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(8C,U) , O_660F38(8E,U) ), @@ -2848,7 +3068,20 @@ const InstInfo _instInfo[] = { INST(kInstVpmullw , "vpmullw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(D5,U) , U ), INST(kInstVpmuludq , "vpmuludq" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(F4,U) , U ), INST(kInstVpor , "vpor" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(EB,U) , U ), + INST(kInstVpperm , "vpperm" , G(XopRvrmRvmr) , F(None) , 0 , O(Xmm) , O(Xmm) , O(XmmMem) , O(XmmMem) , O_00_M08(A3,U) , U ), + INST(kInstVprotb , "vprotb" , G(XopRvmRmi) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem)|O(Imm) , U , O_00_M09(90,U) , O_00_M08(C0,U) ), + INST(kInstVprotd , "vprotd" , G(XopRvmRmi) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem)|O(Imm) , U , O_00_M09(92,U) , O_00_M08(C2,U) ), + INST(kInstVprotq , "vprotq" , G(XopRvmRmi) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem)|O(Imm) , U , O_00_M09(93,U) , O_00_M08(C3,U) ), + INST(kInstVprotw , "vprotw" , G(XopRvmRmi) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem)|O(Imm) , U , O_00_M09(91,U) , O_00_M08(C1,U) ), INST(kInstVpsadbw , "vpsadbw" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F00(F6,U) , U ), + INST(kInstVpshab , "vpshab" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(98,U) , U ), + INST(kInstVpshad , "vpshad" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(9A,U) , U ), + INST(kInstVpshaq , "vpshaq" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(9B,U) , U ), + INST(kInstVpshaw , "vpshaw" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(99,U) , U ), + INST(kInstVpshlb , "vpshlb" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(94,U) , U ), + INST(kInstVpshld , "vpshld" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(96,U) , U ), + INST(kInstVpshlq , "vpshlq" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(97,U) , U ), + INST(kInstVpshlw , "vpshlw" , G(XopRvmRmv) , F(None) , 0 , O(Xmm) , O(XmmMem) , O(XmmMem) , U , O_00_M09(95,U) , U ), INST(kInstVpshufb , "vpshufb" , G(AvxRvm_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmm) , O(XmmYmmMem) , U , O_660F38(00,U) , U ), INST(kInstVpshufd , "vpshufd" , G(AvxRmi_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmmMem) , O(Imm) , U , O_660F00(70,U) , U ), INST(kInstVpshufhw , "vpshufhw" , G(AvxRmi_P) , F(None) , 0 , O(XmmYmm) , O(XmmYmmMem) , O(Imm) , U , O_F30F00(70,U) , U ), @@ -2932,6 +3165,14 @@ const InstInfo _instInfo[] = { #undef O_00_X #undef O_9B_X +#undef O_66_M09 +#undef O_66_M08 +#undef O_66_M03 + +#undef O_00_M09 +#undef O_00_M08 +#undef O_00_M03 + #undef O_F30F3A #undef O_F30F38 #undef O_F30F00 diff --git a/src/asmjit/x86/x86defs.h b/src/asmjit/x86/x86defs.h index 9ce0d17..010d232 100644 --- a/src/asmjit/x86/x86defs.h +++ b/src/asmjit/x86/x86defs.h @@ -1114,6 +1114,12 @@ ASMJIT_ENUM(kInstCode) { kInstVfmadd231ps, // FMA3 kInstVfmadd231sd, // FMA3 kInstVfmadd231ss, // FMA3 + kInstVfmaddpd, // FMA4 + kInstVfmaddps, // FMA4 + kInstVfmaddsd, // FMA4 + kInstVfmaddss, // FMA4 + kInstVfmaddsubpd, // FMA4 + kInstVfmaddsubps, // FMA4 kInstVfmaddsub132pd, // FMA3 kInstVfmaddsub132ps, // FMA3 kInstVfmaddsub213pd, // FMA3 @@ -1138,6 +1144,12 @@ ASMJIT_ENUM(kInstCode) { kInstVfmsubadd213ps, // FMA3 kInstVfmsubadd231pd, // FMA3 kInstVfmsubadd231ps, // FMA3 + kInstVfmsubaddpd, // FMA4 + kInstVfmsubaddps, // FMA4 + kInstVfmsubpd, // FMA4 + kInstVfmsubps, // FMA4 + kInstVfmsubsd, // FMA4 + kInstVfmsubss, // FMA4 kInstVfnmadd132pd, // FMA3 kInstVfnmadd132ps, // FMA3 kInstVfnmadd132sd, // FMA3 @@ -1150,6 +1162,10 @@ ASMJIT_ENUM(kInstCode) { kInstVfnmadd231ps, // FMA3 kInstVfnmadd231sd, // FMA3 kInstVfnmadd231ss, // FMA3 + kInstVfnmaddpd, // FMA4 + kInstVfnmaddps, // FMA4 + kInstVfnmaddsd, // FMA4 + kInstVfnmaddss, // FMA4 kInstVfnmsub132pd, // FMA3 kInstVfnmsub132ps, // FMA3 kInstVfnmsub132sd, // FMA3 @@ -1162,6 +1178,14 @@ ASMJIT_ENUM(kInstCode) { kInstVfnmsub231ps, // FMA3 kInstVfnmsub231sd, // FMA3 kInstVfnmsub231ss, // FMA3 + kInstVfnmsubpd, // FMA4 + kInstVfnmsubps, // FMA4 + kInstVfnmsubsd, // FMA4 + kInstVfnmsubss, // FMA4 + kInstVfrczpd, // XOP + kInstVfrczps, // XOP + kInstVfrczsd, // XOP + kInstVfrczss, // XOP kInstVgatherdpd, // AVX2 kInstVgatherdps, // AVX2 kInstVgatherqpd, // AVX2 @@ -1246,6 +1270,7 @@ ASMJIT_ENUM(kInstCode) { kInstVpbroadcastq, // AVX2 kInstVpbroadcastw, // AVX2 kInstVpclmulqdq, // AVX+PCLMULQDQ + kInstVpcmov, // XOP kInstVpcmpeqb, // AVX2 kInstVpcmpeqd, // AVX2 kInstVpcmpeqq, // AVX2 @@ -1258,9 +1283,19 @@ ASMJIT_ENUM(kInstCode) { kInstVpcmpgtw, // AVX2 kInstVpcmpistri, // AVX kInstVpcmpistrm, // AVX + kInstVpcomb, // XOP + kInstVpcomd, // XOP + kInstVpcomq, // XOP + kInstVpcomub, // XOP + kInstVpcomud, // XOP + kInstVpcomuq, // XOP + kInstVpcomuw, // XOP + kInstVpcomw, // XOP kInstVperm2f128, // AVX kInstVperm2i128, // AVX2 kInstVpermd, // AVX2 + kInstVpermil2pd, // XOP + kInstVpermil2ps, // XOP kInstVpermilpd, // AVX kInstVpermilps, // AVX kInstVpermpd, // AVX2 @@ -1274,17 +1309,44 @@ ASMJIT_ENUM(kInstCode) { kInstVpgatherdq, // AVX2 kInstVpgatherqd, // AVX2 kInstVpgatherqq, // AVX2 + kInstVphaddbd, // XOP + kInstVphaddbq, // XOP + kInstVphaddbw, // XOP kInstVphaddd, // AVX2 + kInstVphadddq, // XOP kInstVphaddsw, // AVX2 + kInstVphaddubd, // XOP + kInstVphaddubq, // XOP + kInstVphaddubw, // XOP + kInstVphaddudq, // XOP + kInstVphadduwd, // XOP + kInstVphadduwq, // XOP kInstVphaddw, // AVX2 + kInstVphaddwd, // XOP + kInstVphaddwq, // XOP kInstVphminposuw, // AVX + kInstVphsubbw, // XOP + kInstVphsubdq, // XOP kInstVphsubd, // AVX2 kInstVphsubsw, // AVX2 kInstVphsubw, // AVX2 + kInstVphsubwd, // XOP kInstVpinsrb, // AVX kInstVpinsrd, // AVX kInstVpinsrq, // AVX (x64 only) kInstVpinsrw, // AVX + kInstVpmacsdd, // XOP + kInstVpmacsdqh, // XOP + kInstVpmacsdql, // XOP + kInstVpmacssdd, // XOP + kInstVpmacssdqh, // XOP + kInstVpmacssdql, // XOP + kInstVpmacsswd, // XOP + kInstVpmacssww, // XOP + kInstVpmacswd, // XOP + kInstVpmacsww, // XOP + kInstVpmadcsswd, // XOP + kInstVpmadcswd, // XOP kInstVpmaddubsw, // AVX/AVX2 kInstVpmaddwd, // AVX/AVX2 kInstVpmaskmovd, // AVX2 @@ -1322,7 +1384,20 @@ ASMJIT_ENUM(kInstCode) { kInstVpmullw, // AVX/AVX2 kInstVpmuludq, // AVX/AVX2 kInstVpor, // AVX/AVX2 + kInstVpperm, // XOP + kInstVprotb, // XOP + kInstVprotd, // XOP + kInstVprotq, // XOP + kInstVprotw, // XOP kInstVpsadbw, // AVX/AVX2 + kInstVpshab, // XOP + kInstVpshad, // XOP + kInstVpshaq, // XOP + kInstVpshaw, // XOP + kInstVpshlb, // XOP + kInstVpshld, // XOP + kInstVpshlq, // XOP + kInstVpshlw, // XOP kInstVpshufb, // AVX/AVX2 kInstVpshufd, // AVX/AVX2 kInstVpshufhw, // AVX/AVX2 @@ -1576,66 +1651,151 @@ ASMJIT_ENUM(kInstGroup) { kInstGroupAvxM, //! @brief AVX instruction encoded as 'MR'. kInstGroupAvxMr, - //! @brief AVX instruction encoded as 'MR' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'MR'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxMr_P, + //! @brief AVX instruction encoded as 'MRI'. kInstGroupAvxMri, - //! @brief AVX instruction encoded as 'MRI' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'MRI'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxMri_P, + //! @brief AVX instruction encoded as 'RM'. kInstGroupAvxRm, - //! @brief AVX instruction encoded as 'RM' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RM'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRm_P, + //! @brief AVX instruction encoded as 'RMI'. kInstGroupAvxRmi, - //! @brief AVX instruction encoded as 'RMI' (propagates AVX.L if the instruction uses YMM register).. + //! @brief AVX instruction encoded as 'RMI'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRmi_P, + //! @brief AVX instruction encoded as 'RVM'. kInstGroupAvxRvm, - //! @brief AVX instruction encoded as 'RVM' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RVM'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRvm_P, + //! @brief AVX instruction encoded as 'RVMR'. kInstGroupAvxRvmr, - //! @brief AVX instruction encoded as 'RVMR' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RVMR'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRvmr_P, //! @brief AVX instruction encoded as 'RVMI'. + kInstGroupAvxRvmi, - //! @brief AVX instruction encoded as 'RVMI' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RVMI'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRvmi_P, //! @brief AVX instruction encoded as 'RMV'. + kInstGroupAvxRmv, //! @brief AVX instruction encoded as 'RMVI'. kInstGroupAvxRmvi, + //! @brief AVX instruction encoded as 'RM' or 'MR'. kInstGroupAvxRmMr, - //! @brief AVX instruction encoded as 'RM' or 'MR' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RM' or 'MR'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRmMr_P, + //! @brief AVX instruction encoded as 'RVM' or 'RMI'. kInstGroupAvxRvmRmi, - //! @brief AVX instruction encoded as 'RVM' or 'RMI' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RVM' or 'RMI'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRvmRmi_P, + //! @brief AVX instruction encoded as 'RVM' or 'MR'. kInstGroupAvxRvmMr, + //! @brief AVX instruction encoded as 'RVM' or 'MVR'. kInstGroupAvxRvmMvr, - //! @brief AVX instruction encoded as 'RVM' or 'MVR' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RVM' or 'MVR'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRvmMvr_P, + //! @brief AVX instruction encoded as 'RVM' or 'VMI'. kInstGroupAvxRvmVmi, - //! @brief AVX instruction encoded as 'RVM' or 'VMI' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'RVM' or 'VMI'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxRvmVmi_P, + //! @brief AVX instruction encoded as 'VM'. kInstGroupAvxVm, //! @brief AVX instruction encoded as 'VMI'. kInstGroupAvxVmi, - //! @brief AVX instruction encoded as 'VMI' (propagates AVX.L if the instruction uses YMM register). + //! @brief AVX instruction encoded as 'VMI'. + //! + //! Propagates AVX.L if the instruction uses YMM register. kInstGroupAvxVmi_P, + + //! @brief AVX instruction encoded as 'RVRM' or 'RVMR'. + kInstGroupAvxRvrmRvmr, + //! @brief AVX instruction encoded as 'RVRM' or 'RVMR'. + //! + //! Propagates AVX.L if the instruction uses YMM register). + kInstGroupAvxRvrmRvmr_P, + //! @brief Vmovss/Vmovsd. kInstGroupAvxMovSsSd, + //! @brief AVX2 gather family instructions (VSIB). kInstGroupAvxGather, //! @brief AVX2 gather family instructions (VSIB), differs only in mem operand. - kInstGroupAvxGatherEx + kInstGroupAvxGatherEx, + + //! @brief FMA4 supporting XMM in form [R, R, R/M, R/M]. + kInstGroupFma4, + //! @brief FMA4 supporting XMM/YMM in form [R, R, R/M, R/M]. + kInstGroupFma4_P, + + //! @brief XOP instruction encoded as 'RM'. + kInstGroupXopRm, + //! @brief XOP instruction encoded as 'RM'. + //! + //! Propagates XOP.L if the instruction uses YMM register). + kInstGroupXopRm_P, + + //! @brief XOP instruction encoded as 'RVM' or 'RMV'. + kInstGroupXopRvmRmv, + + //! @brief XOP instruction encoded as 'RVM' or 'RMI'. + kInstGroupXopRvmRmi, + + //! @brief XOP instruction encoded as 'RVMR'. + kInstGroupXopRvmr, + //! @brief XOP instruction encoded as 'RVMR'. + //! + //! Propagates XOP.L if the instruction uses YMM register. + kInstGroupXopRvmr_P, + + //! @brief XOP instruction encoded as 'RVMI'. + kInstGroupXopRvmi, + //! @brief XOP instruction encoded as 'RVMI'. + //! + //! Propagates XOP.L if the instruction uses YMM register. + kInstGroupXopRvmi_P, + + //! @brief XOP instruction encoded as 'RVRM' or 'RVMR'. + kInstGroupXopRvrmRvmr, + //! @brief XOP instruction encoded as 'RVRM' or 'RVMR'. + //! + //! Propagates XOP.L if the instruction uses YMM register). + kInstGroupXopRvrmRvmr_P }; // ============================================================================ @@ -1646,7 +1806,7 @@ ASMJIT_ENUM(kInstGroup) { //! //! The schema was inspired by AVX/AVX2 features. ASMJIT_ENUM(kInstOpCode) { - // 'MMMMM' field in AVX instruction. + // 'MMMMM' field in AVX/XOP instruction. // 'OpCode' leading bytes in legacy encoding. kInstOpCode_MM_Shift = 16, kInstOpCode_MM_Mask = 0x0FU << kInstOpCode_MM_Shift, @@ -1656,7 +1816,11 @@ ASMJIT_ENUM(kInstOpCode) { kInstOpCode_MM_0F3A = 0x03U << kInstOpCode_MM_Shift, kInstOpCode_MM_0F01 = 0x0FU << kInstOpCode_MM_Shift, // Ext/Not part of AVX. - // 'PP' field in AVX instruction. + kInstOpCode_MM_00011 = 0x03U << kInstOpCode_MM_Shift, + kInstOpCode_MM_01000 = 0x08U << kInstOpCode_MM_Shift, + kInstOpCode_MM_01001 = 0x09U << kInstOpCode_MM_Shift, + + // 'PP' field in AVX/XOP instruction. // 'Mandatory Prefix' in legacy encoding. kInstOpCode_PP_Shift = 21, kInstOpCode_PP_Mask = 0x07U << kInstOpCode_PP_Shift, @@ -1666,7 +1830,7 @@ ASMJIT_ENUM(kInstOpCode) { kInstOpCode_PP_F2 = 0x03U << kInstOpCode_PP_Shift, kInstOpCode_PP_9B = 0x07U << kInstOpCode_PP_Shift, //Ext/Not part of AVX. - // 'L' field in AVX instruction. + // 'L' field in AVX/XOP instruction. kInstOpCode_L_Shift = 24, kInstOpCode_L_Mask = 0x01U << kInstOpCode_L_Shift, kInstOpCode_L_False = 0x00U << kInstOpCode_L_Shift,