2170 lines
151 KiB
C++
2170 lines
151 KiB
C++
// This file is part of AsmJit project <https://asmjit.com>
|
|
//
|
|
// See asmjit.h or LICENSE.md for license and copyright information
|
|
// SPDX-License-Identifier: Zlib
|
|
|
|
#ifndef ASMJIT_X86_X86GLOBALS_H_INCLUDED
|
|
#define ASMJIT_X86_X86GLOBALS_H_INCLUDED
|
|
|
|
#include "../core/archtraits.h"
|
|
#include "../core/inst.h"
|
|
|
|
//! \namespace asmjit::x86
|
|
//! \ingroup asmjit_x86
|
|
//!
|
|
//! X86/X64 API.
|
|
|
|
ASMJIT_BEGIN_SUB_NAMESPACE(x86)
|
|
|
|
//! \addtogroup asmjit_x86
|
|
//! \{
|
|
|
|
//! Condition code.
|
|
enum class CondCode : uint8_t {
|
|
kO = 0x00u, //!< OF==1
|
|
kNO = 0x01u, //!< OF==0
|
|
kC = 0x02u, //!< CF==1
|
|
kB = 0x02u, //!< CF==1 (unsigned < )
|
|
kNAE = 0x02u, //!< CF==1 (unsigned < )
|
|
kNC = 0x03u, //!< CF==0
|
|
kAE = 0x03u, //!< CF==0 (unsigned >=)
|
|
kNB = 0x03u, //!< CF==0 (unsigned >=)
|
|
kE = 0x04u, //!< ZF==1 (any_sign ==)
|
|
kZ = 0x04u, //!< ZF==1 (any_sign ==)
|
|
kNE = 0x05u, //!< ZF==0 (any_sign !=)
|
|
kNZ = 0x05u, //!< ZF==0 (any_sign !=)
|
|
kBE = 0x06u, //!< CF==1 | ZF==1 (unsigned <=)
|
|
kNA = 0x06u, //!< CF==1 | ZF==1 (unsigned <=)
|
|
kA = 0x07u, //!< CF==0 & ZF==0 (unsigned > )
|
|
kNBE = 0x07u, //!< CF==0 & ZF==0 (unsigned > )
|
|
kS = 0x08u, //!< SF==1 (is negative)
|
|
kNS = 0x09u, //!< SF==0 (is positive or zero)
|
|
kP = 0x0Au, //!< PF==1
|
|
kPE = 0x0Au, //!< PF==1
|
|
kPO = 0x0Bu, //!< PF==0
|
|
kNP = 0x0Bu, //!< PF==0
|
|
kL = 0x0Cu, //!< SF!=OF (signed < )
|
|
kNGE = 0x0Cu, //!< SF!=OF (signed < )
|
|
kGE = 0x0Du, //!< SF==OF (signed >=)
|
|
kNL = 0x0Du, //!< SF==OF (signed >=)
|
|
kLE = 0x0Eu, //!< ZF==1 | SF!=OF (signed <=)
|
|
kNG = 0x0Eu, //!< ZF==1 | SF!=OF (signed <=)
|
|
kG = 0x0Fu, //!< ZF==0 & SF==OF (signed > )
|
|
kNLE = 0x0Fu, //!< ZF==0 & SF==OF (signed > )
|
|
|
|
kZero = kZ, //!< Zero flag.
|
|
kNotZero = kNZ, //!< Non-zero flag.
|
|
|
|
kSign = kS, //!< Sign flag.
|
|
kNotSign = kNS, //!< No sign flag.
|
|
|
|
kNegative = kS, //!< Sign flag.
|
|
kPositive = kNS, //!< No sign flag.
|
|
|
|
kOverflow = kO, //!< Overflow (signed).
|
|
kNotOverflow = kNO, //!< Not overflow (signed).
|
|
|
|
kEqual = kE, //!< `a == b` (equal).
|
|
kNotEqual = kNE, //!< `a != b` (not equal).
|
|
|
|
kSignedLT = kL, //!< `a < b` (signed).
|
|
kSignedLE = kLE, //!< `a <= b` (signed).
|
|
kSignedGT = kG, //!< `a > b` (signed).
|
|
kSignedGE = kGE, //!< `a >= b` (signed).
|
|
|
|
kUnsignedLT = kB, //!< `a < b` (unsigned).
|
|
kUnsignedLE = kBE, //!< `a <= b` (unsigned).
|
|
kUnsignedGT = kA, //!< `a > b` (unsigned).
|
|
kUnsignedGE = kAE, //!< `a >= b` (unsigned).
|
|
|
|
kParityEven = kP, //!< Even parity flag.
|
|
kParityOdd = kPO, //!< Odd parity flag.
|
|
|
|
kMaxValue = 0x0Fu
|
|
};
|
|
|
|
//! \cond
|
|
static constexpr CondCode _reverseCondTable[] = {
|
|
CondCode::kO, // O <- O
|
|
CondCode::kNO, // NO <- NO
|
|
CondCode::kA , // A <- B
|
|
CondCode::kBE, // BE <- AE
|
|
CondCode::kE, // E <- E
|
|
CondCode::kNE, // NE <- NE
|
|
CondCode::kAE, // AE <- BE
|
|
CondCode::kB , // B <- A
|
|
CondCode::kS, // S <- S
|
|
CondCode::kNS, // NS <- NS
|
|
CondCode::kPE, // PE <- PE
|
|
CondCode::kPO, // PO <- PO
|
|
CondCode::kG, // G <- L
|
|
CondCode::kLE, // LE <- GE
|
|
CondCode::kGE, // GE <- LE
|
|
CondCode::kL // L <- G
|
|
};
|
|
//! \endcond
|
|
|
|
//! Reverses a condition code (reverses the corresponding operands of a comparison).
|
|
static inline constexpr CondCode reverseCond(CondCode cond) noexcept { return _reverseCondTable[uint8_t(cond)]; }
|
|
//! Negates a condition code.
|
|
static inline constexpr CondCode negateCond(CondCode cond) noexcept { return CondCode(uint8_t(cond) ^ 1u); }
|
|
|
|
//! Instruction.
|
|
//!
|
|
//! \note Only used to hold x86-specific instruction identifiers and some additional helper functions.
|
|
namespace Inst {
|
|
//! Instruction id.
|
|
enum Id : uint32_t {
|
|
// ${InstId:Begin}
|
|
kIdNone = 0, //!< Invalid instruction id.
|
|
kIdAaa, //!< Instruction 'aaa' (X86).
|
|
kIdAad, //!< Instruction 'aad' (X86).
|
|
kIdAam, //!< Instruction 'aam' (X86).
|
|
kIdAas, //!< Instruction 'aas' (X86).
|
|
kIdAdc, //!< Instruction 'adc'.
|
|
kIdAdcx, //!< Instruction 'adcx' {ADX}.
|
|
kIdAdd, //!< Instruction 'add'.
|
|
kIdAddpd, //!< Instruction 'addpd' {SSE2}.
|
|
kIdAddps, //!< Instruction 'addps' {SSE}.
|
|
kIdAddsd, //!< Instruction 'addsd' {SSE2}.
|
|
kIdAddss, //!< Instruction 'addss' {SSE}.
|
|
kIdAddsubpd, //!< Instruction 'addsubpd' {SSE3}.
|
|
kIdAddsubps, //!< Instruction 'addsubps' {SSE3}.
|
|
kIdAdox, //!< Instruction 'adox' {ADX}.
|
|
kIdAesdec, //!< Instruction 'aesdec' {AESNI}.
|
|
kIdAesdeclast, //!< Instruction 'aesdeclast' {AESNI}.
|
|
kIdAesenc, //!< Instruction 'aesenc' {AESNI}.
|
|
kIdAesenclast, //!< Instruction 'aesenclast' {AESNI}.
|
|
kIdAesimc, //!< Instruction 'aesimc' {AESNI}.
|
|
kIdAeskeygenassist, //!< Instruction 'aeskeygenassist' {AESNI}.
|
|
kIdAnd, //!< Instruction 'and'.
|
|
kIdAndn, //!< Instruction 'andn' {BMI}.
|
|
kIdAndnpd, //!< Instruction 'andnpd' {SSE2}.
|
|
kIdAndnps, //!< Instruction 'andnps' {SSE}.
|
|
kIdAndpd, //!< Instruction 'andpd' {SSE2}.
|
|
kIdAndps, //!< Instruction 'andps' {SSE}.
|
|
kIdArpl, //!< Instruction 'arpl' (X86).
|
|
kIdBextr, //!< Instruction 'bextr' {BMI}.
|
|
kIdBlcfill, //!< Instruction 'blcfill' {TBM}.
|
|
kIdBlci, //!< Instruction 'blci' {TBM}.
|
|
kIdBlcic, //!< Instruction 'blcic' {TBM}.
|
|
kIdBlcmsk, //!< Instruction 'blcmsk' {TBM}.
|
|
kIdBlcs, //!< Instruction 'blcs' {TBM}.
|
|
kIdBlendpd, //!< Instruction 'blendpd' {SSE4_1}.
|
|
kIdBlendps, //!< Instruction 'blendps' {SSE4_1}.
|
|
kIdBlendvpd, //!< Instruction 'blendvpd' {SSE4_1}.
|
|
kIdBlendvps, //!< Instruction 'blendvps' {SSE4_1}.
|
|
kIdBlsfill, //!< Instruction 'blsfill' {TBM}.
|
|
kIdBlsi, //!< Instruction 'blsi' {BMI}.
|
|
kIdBlsic, //!< Instruction 'blsic' {TBM}.
|
|
kIdBlsmsk, //!< Instruction 'blsmsk' {BMI}.
|
|
kIdBlsr, //!< Instruction 'blsr' {BMI}.
|
|
kIdBndcl, //!< Instruction 'bndcl' {MPX}.
|
|
kIdBndcn, //!< Instruction 'bndcn' {MPX}.
|
|
kIdBndcu, //!< Instruction 'bndcu' {MPX}.
|
|
kIdBndldx, //!< Instruction 'bndldx' {MPX}.
|
|
kIdBndmk, //!< Instruction 'bndmk' {MPX}.
|
|
kIdBndmov, //!< Instruction 'bndmov' {MPX}.
|
|
kIdBndstx, //!< Instruction 'bndstx' {MPX}.
|
|
kIdBound, //!< Instruction 'bound' (X86).
|
|
kIdBsf, //!< Instruction 'bsf'.
|
|
kIdBsr, //!< Instruction 'bsr'.
|
|
kIdBswap, //!< Instruction 'bswap'.
|
|
kIdBt, //!< Instruction 'bt'.
|
|
kIdBtc, //!< Instruction 'btc'.
|
|
kIdBtr, //!< Instruction 'btr'.
|
|
kIdBts, //!< Instruction 'bts'.
|
|
kIdBzhi, //!< Instruction 'bzhi' {BMI2}.
|
|
kIdCall, //!< Instruction 'call'.
|
|
kIdCbw, //!< Instruction 'cbw'.
|
|
kIdCdq, //!< Instruction 'cdq'.
|
|
kIdCdqe, //!< Instruction 'cdqe' (X64).
|
|
kIdClac, //!< Instruction 'clac' {SMAP}.
|
|
kIdClc, //!< Instruction 'clc'.
|
|
kIdCld, //!< Instruction 'cld'.
|
|
kIdCldemote, //!< Instruction 'cldemote' {CLDEMOTE}.
|
|
kIdClflush, //!< Instruction 'clflush' {CLFLUSH}.
|
|
kIdClflushopt, //!< Instruction 'clflushopt' {CLFLUSHOPT}.
|
|
kIdClgi, //!< Instruction 'clgi' {SVM}.
|
|
kIdCli, //!< Instruction 'cli'.
|
|
kIdClrssbsy, //!< Instruction 'clrssbsy' {CET_SS}.
|
|
kIdClts, //!< Instruction 'clts'.
|
|
kIdClui, //!< Instruction 'clui' {UINTR} (X64).
|
|
kIdClwb, //!< Instruction 'clwb' {CLWB}.
|
|
kIdClzero, //!< Instruction 'clzero' {CLZERO}.
|
|
kIdCmc, //!< Instruction 'cmc'.
|
|
kIdCmova, //!< Instruction 'cmova' {CMOV}.
|
|
kIdCmovae, //!< Instruction 'cmovae' {CMOV}.
|
|
kIdCmovb, //!< Instruction 'cmovb' {CMOV}.
|
|
kIdCmovbe, //!< Instruction 'cmovbe' {CMOV}.
|
|
kIdCmovc, //!< Instruction 'cmovc' {CMOV}.
|
|
kIdCmove, //!< Instruction 'cmove' {CMOV}.
|
|
kIdCmovg, //!< Instruction 'cmovg' {CMOV}.
|
|
kIdCmovge, //!< Instruction 'cmovge' {CMOV}.
|
|
kIdCmovl, //!< Instruction 'cmovl' {CMOV}.
|
|
kIdCmovle, //!< Instruction 'cmovle' {CMOV}.
|
|
kIdCmovna, //!< Instruction 'cmovna' {CMOV}.
|
|
kIdCmovnae, //!< Instruction 'cmovnae' {CMOV}.
|
|
kIdCmovnb, //!< Instruction 'cmovnb' {CMOV}.
|
|
kIdCmovnbe, //!< Instruction 'cmovnbe' {CMOV}.
|
|
kIdCmovnc, //!< Instruction 'cmovnc' {CMOV}.
|
|
kIdCmovne, //!< Instruction 'cmovne' {CMOV}.
|
|
kIdCmovng, //!< Instruction 'cmovng' {CMOV}.
|
|
kIdCmovnge, //!< Instruction 'cmovnge' {CMOV}.
|
|
kIdCmovnl, //!< Instruction 'cmovnl' {CMOV}.
|
|
kIdCmovnle, //!< Instruction 'cmovnle' {CMOV}.
|
|
kIdCmovno, //!< Instruction 'cmovno' {CMOV}.
|
|
kIdCmovnp, //!< Instruction 'cmovnp' {CMOV}.
|
|
kIdCmovns, //!< Instruction 'cmovns' {CMOV}.
|
|
kIdCmovnz, //!< Instruction 'cmovnz' {CMOV}.
|
|
kIdCmovo, //!< Instruction 'cmovo' {CMOV}.
|
|
kIdCmovp, //!< Instruction 'cmovp' {CMOV}.
|
|
kIdCmovpe, //!< Instruction 'cmovpe' {CMOV}.
|
|
kIdCmovpo, //!< Instruction 'cmovpo' {CMOV}.
|
|
kIdCmovs, //!< Instruction 'cmovs' {CMOV}.
|
|
kIdCmovz, //!< Instruction 'cmovz' {CMOV}.
|
|
kIdCmp, //!< Instruction 'cmp'.
|
|
kIdCmppd, //!< Instruction 'cmppd' {SSE2}.
|
|
kIdCmpps, //!< Instruction 'cmpps' {SSE}.
|
|
kIdCmps, //!< Instruction 'cmps'.
|
|
kIdCmpsd, //!< Instruction 'cmpsd' {SSE2}.
|
|
kIdCmpss, //!< Instruction 'cmpss' {SSE}.
|
|
kIdCmpxchg, //!< Instruction 'cmpxchg' {I486}.
|
|
kIdCmpxchg16b, //!< Instruction 'cmpxchg16b' {CMPXCHG16B} (X64).
|
|
kIdCmpxchg8b, //!< Instruction 'cmpxchg8b' {CMPXCHG8B}.
|
|
kIdComisd, //!< Instruction 'comisd' {SSE2}.
|
|
kIdComiss, //!< Instruction 'comiss' {SSE}.
|
|
kIdCpuid, //!< Instruction 'cpuid' {I486}.
|
|
kIdCqo, //!< Instruction 'cqo' (X64).
|
|
kIdCrc32, //!< Instruction 'crc32' {SSE4_2}.
|
|
kIdCvtdq2pd, //!< Instruction 'cvtdq2pd' {SSE2}.
|
|
kIdCvtdq2ps, //!< Instruction 'cvtdq2ps' {SSE2}.
|
|
kIdCvtpd2dq, //!< Instruction 'cvtpd2dq' {SSE2}.
|
|
kIdCvtpd2pi, //!< Instruction 'cvtpd2pi' {SSE2}.
|
|
kIdCvtpd2ps, //!< Instruction 'cvtpd2ps' {SSE2}.
|
|
kIdCvtpi2pd, //!< Instruction 'cvtpi2pd' {SSE2}.
|
|
kIdCvtpi2ps, //!< Instruction 'cvtpi2ps' {SSE}.
|
|
kIdCvtps2dq, //!< Instruction 'cvtps2dq' {SSE2}.
|
|
kIdCvtps2pd, //!< Instruction 'cvtps2pd' {SSE2}.
|
|
kIdCvtps2pi, //!< Instruction 'cvtps2pi' {SSE}.
|
|
kIdCvtsd2si, //!< Instruction 'cvtsd2si' {SSE2}.
|
|
kIdCvtsd2ss, //!< Instruction 'cvtsd2ss' {SSE2}.
|
|
kIdCvtsi2sd, //!< Instruction 'cvtsi2sd' {SSE2}.
|
|
kIdCvtsi2ss, //!< Instruction 'cvtsi2ss' {SSE}.
|
|
kIdCvtss2sd, //!< Instruction 'cvtss2sd' {SSE2}.
|
|
kIdCvtss2si, //!< Instruction 'cvtss2si' {SSE}.
|
|
kIdCvttpd2dq, //!< Instruction 'cvttpd2dq' {SSE2}.
|
|
kIdCvttpd2pi, //!< Instruction 'cvttpd2pi' {SSE2}.
|
|
kIdCvttps2dq, //!< Instruction 'cvttps2dq' {SSE2}.
|
|
kIdCvttps2pi, //!< Instruction 'cvttps2pi' {SSE}.
|
|
kIdCvttsd2si, //!< Instruction 'cvttsd2si' {SSE2}.
|
|
kIdCvttss2si, //!< Instruction 'cvttss2si' {SSE}.
|
|
kIdCwd, //!< Instruction 'cwd'.
|
|
kIdCwde, //!< Instruction 'cwde'.
|
|
kIdDaa, //!< Instruction 'daa' (X86).
|
|
kIdDas, //!< Instruction 'das' (X86).
|
|
kIdDec, //!< Instruction 'dec'.
|
|
kIdDiv, //!< Instruction 'div'.
|
|
kIdDivpd, //!< Instruction 'divpd' {SSE2}.
|
|
kIdDivps, //!< Instruction 'divps' {SSE}.
|
|
kIdDivsd, //!< Instruction 'divsd' {SSE2}.
|
|
kIdDivss, //!< Instruction 'divss' {SSE}.
|
|
kIdDppd, //!< Instruction 'dppd' {SSE4_1}.
|
|
kIdDpps, //!< Instruction 'dpps' {SSE4_1}.
|
|
kIdEmms, //!< Instruction 'emms' {MMX}.
|
|
kIdEndbr32, //!< Instruction 'endbr32' {CET_IBT}.
|
|
kIdEndbr64, //!< Instruction 'endbr64' {CET_IBT}.
|
|
kIdEnqcmd, //!< Instruction 'enqcmd' {ENQCMD}.
|
|
kIdEnqcmds, //!< Instruction 'enqcmds' {ENQCMD}.
|
|
kIdEnter, //!< Instruction 'enter'.
|
|
kIdExtractps, //!< Instruction 'extractps' {SSE4_1}.
|
|
kIdExtrq, //!< Instruction 'extrq' {SSE4A}.
|
|
kIdF2xm1, //!< Instruction 'f2xm1'.
|
|
kIdFabs, //!< Instruction 'fabs'.
|
|
kIdFadd, //!< Instruction 'fadd'.
|
|
kIdFaddp, //!< Instruction 'faddp'.
|
|
kIdFbld, //!< Instruction 'fbld'.
|
|
kIdFbstp, //!< Instruction 'fbstp'.
|
|
kIdFchs, //!< Instruction 'fchs'.
|
|
kIdFclex, //!< Instruction 'fclex'.
|
|
kIdFcmovb, //!< Instruction 'fcmovb' {CMOV}.
|
|
kIdFcmovbe, //!< Instruction 'fcmovbe' {CMOV}.
|
|
kIdFcmove, //!< Instruction 'fcmove' {CMOV}.
|
|
kIdFcmovnb, //!< Instruction 'fcmovnb' {CMOV}.
|
|
kIdFcmovnbe, //!< Instruction 'fcmovnbe' {CMOV}.
|
|
kIdFcmovne, //!< Instruction 'fcmovne' {CMOV}.
|
|
kIdFcmovnu, //!< Instruction 'fcmovnu' {CMOV}.
|
|
kIdFcmovu, //!< Instruction 'fcmovu' {CMOV}.
|
|
kIdFcom, //!< Instruction 'fcom'.
|
|
kIdFcomi, //!< Instruction 'fcomi'.
|
|
kIdFcomip, //!< Instruction 'fcomip'.
|
|
kIdFcomp, //!< Instruction 'fcomp'.
|
|
kIdFcompp, //!< Instruction 'fcompp'.
|
|
kIdFcos, //!< Instruction 'fcos'.
|
|
kIdFdecstp, //!< Instruction 'fdecstp'.
|
|
kIdFdiv, //!< Instruction 'fdiv'.
|
|
kIdFdivp, //!< Instruction 'fdivp'.
|
|
kIdFdivr, //!< Instruction 'fdivr'.
|
|
kIdFdivrp, //!< Instruction 'fdivrp'.
|
|
kIdFemms, //!< Instruction 'femms' {3DNOW}.
|
|
kIdFfree, //!< Instruction 'ffree'.
|
|
kIdFiadd, //!< Instruction 'fiadd'.
|
|
kIdFicom, //!< Instruction 'ficom'.
|
|
kIdFicomp, //!< Instruction 'ficomp'.
|
|
kIdFidiv, //!< Instruction 'fidiv'.
|
|
kIdFidivr, //!< Instruction 'fidivr'.
|
|
kIdFild, //!< Instruction 'fild'.
|
|
kIdFimul, //!< Instruction 'fimul'.
|
|
kIdFincstp, //!< Instruction 'fincstp'.
|
|
kIdFinit, //!< Instruction 'finit'.
|
|
kIdFist, //!< Instruction 'fist'.
|
|
kIdFistp, //!< Instruction 'fistp'.
|
|
kIdFisttp, //!< Instruction 'fisttp' {SSE3}.
|
|
kIdFisub, //!< Instruction 'fisub'.
|
|
kIdFisubr, //!< Instruction 'fisubr'.
|
|
kIdFld, //!< Instruction 'fld'.
|
|
kIdFld1, //!< Instruction 'fld1'.
|
|
kIdFldcw, //!< Instruction 'fldcw'.
|
|
kIdFldenv, //!< Instruction 'fldenv'.
|
|
kIdFldl2e, //!< Instruction 'fldl2e'.
|
|
kIdFldl2t, //!< Instruction 'fldl2t'.
|
|
kIdFldlg2, //!< Instruction 'fldlg2'.
|
|
kIdFldln2, //!< Instruction 'fldln2'.
|
|
kIdFldpi, //!< Instruction 'fldpi'.
|
|
kIdFldz, //!< Instruction 'fldz'.
|
|
kIdFmul, //!< Instruction 'fmul'.
|
|
kIdFmulp, //!< Instruction 'fmulp'.
|
|
kIdFnclex, //!< Instruction 'fnclex'.
|
|
kIdFninit, //!< Instruction 'fninit'.
|
|
kIdFnop, //!< Instruction 'fnop'.
|
|
kIdFnsave, //!< Instruction 'fnsave'.
|
|
kIdFnstcw, //!< Instruction 'fnstcw'.
|
|
kIdFnstenv, //!< Instruction 'fnstenv'.
|
|
kIdFnstsw, //!< Instruction 'fnstsw'.
|
|
kIdFpatan, //!< Instruction 'fpatan'.
|
|
kIdFprem, //!< Instruction 'fprem'.
|
|
kIdFprem1, //!< Instruction 'fprem1'.
|
|
kIdFptan, //!< Instruction 'fptan'.
|
|
kIdFrndint, //!< Instruction 'frndint'.
|
|
kIdFrstor, //!< Instruction 'frstor'.
|
|
kIdFsave, //!< Instruction 'fsave'.
|
|
kIdFscale, //!< Instruction 'fscale'.
|
|
kIdFsin, //!< Instruction 'fsin'.
|
|
kIdFsincos, //!< Instruction 'fsincos'.
|
|
kIdFsqrt, //!< Instruction 'fsqrt'.
|
|
kIdFst, //!< Instruction 'fst'.
|
|
kIdFstcw, //!< Instruction 'fstcw'.
|
|
kIdFstenv, //!< Instruction 'fstenv'.
|
|
kIdFstp, //!< Instruction 'fstp'.
|
|
kIdFstsw, //!< Instruction 'fstsw'.
|
|
kIdFsub, //!< Instruction 'fsub'.
|
|
kIdFsubp, //!< Instruction 'fsubp'.
|
|
kIdFsubr, //!< Instruction 'fsubr'.
|
|
kIdFsubrp, //!< Instruction 'fsubrp'.
|
|
kIdFtst, //!< Instruction 'ftst'.
|
|
kIdFucom, //!< Instruction 'fucom'.
|
|
kIdFucomi, //!< Instruction 'fucomi'.
|
|
kIdFucomip, //!< Instruction 'fucomip'.
|
|
kIdFucomp, //!< Instruction 'fucomp'.
|
|
kIdFucompp, //!< Instruction 'fucompp'.
|
|
kIdFwait, //!< Instruction 'fwait'.
|
|
kIdFxam, //!< Instruction 'fxam'.
|
|
kIdFxch, //!< Instruction 'fxch'.
|
|
kIdFxrstor, //!< Instruction 'fxrstor' {FXSR}.
|
|
kIdFxrstor64, //!< Instruction 'fxrstor64' {FXSR} (X64).
|
|
kIdFxsave, //!< Instruction 'fxsave' {FXSR}.
|
|
kIdFxsave64, //!< Instruction 'fxsave64' {FXSR} (X64).
|
|
kIdFxtract, //!< Instruction 'fxtract'.
|
|
kIdFyl2x, //!< Instruction 'fyl2x'.
|
|
kIdFyl2xp1, //!< Instruction 'fyl2xp1'.
|
|
kIdGetsec, //!< Instruction 'getsec' {SMX}.
|
|
kIdGf2p8affineinvqb, //!< Instruction 'gf2p8affineinvqb' {GFNI}.
|
|
kIdGf2p8affineqb, //!< Instruction 'gf2p8affineqb' {GFNI}.
|
|
kIdGf2p8mulb, //!< Instruction 'gf2p8mulb' {GFNI}.
|
|
kIdHaddpd, //!< Instruction 'haddpd' {SSE3}.
|
|
kIdHaddps, //!< Instruction 'haddps' {SSE3}.
|
|
kIdHlt, //!< Instruction 'hlt'.
|
|
kIdHreset, //!< Instruction 'hreset' {HRESET}.
|
|
kIdHsubpd, //!< Instruction 'hsubpd' {SSE3}.
|
|
kIdHsubps, //!< Instruction 'hsubps' {SSE3}.
|
|
kIdIdiv, //!< Instruction 'idiv'.
|
|
kIdImul, //!< Instruction 'imul'.
|
|
kIdIn, //!< Instruction 'in'.
|
|
kIdInc, //!< Instruction 'inc'.
|
|
kIdIncsspd, //!< Instruction 'incsspd' {CET_SS}.
|
|
kIdIncsspq, //!< Instruction 'incsspq' {CET_SS} (X64).
|
|
kIdIns, //!< Instruction 'ins'.
|
|
kIdInsertps, //!< Instruction 'insertps' {SSE4_1}.
|
|
kIdInsertq, //!< Instruction 'insertq' {SSE4A}.
|
|
kIdInt, //!< Instruction 'int'.
|
|
kIdInt3, //!< Instruction 'int3'.
|
|
kIdInto, //!< Instruction 'into' (X86).
|
|
kIdInvd, //!< Instruction 'invd' {I486}.
|
|
kIdInvept, //!< Instruction 'invept' {VMX}.
|
|
kIdInvlpg, //!< Instruction 'invlpg' {I486}.
|
|
kIdInvlpga, //!< Instruction 'invlpga' {SVM}.
|
|
kIdInvpcid, //!< Instruction 'invpcid' {I486}.
|
|
kIdInvvpid, //!< Instruction 'invvpid' {VMX}.
|
|
kIdIret, //!< Instruction 'iret'.
|
|
kIdIretd, //!< Instruction 'iretd'.
|
|
kIdIretq, //!< Instruction 'iretq' (X64).
|
|
kIdJa, //!< Instruction 'ja'.
|
|
kIdJae, //!< Instruction 'jae'.
|
|
kIdJb, //!< Instruction 'jb'.
|
|
kIdJbe, //!< Instruction 'jbe'.
|
|
kIdJc, //!< Instruction 'jc'.
|
|
kIdJe, //!< Instruction 'je'.
|
|
kIdJecxz, //!< Instruction 'jecxz'.
|
|
kIdJg, //!< Instruction 'jg'.
|
|
kIdJge, //!< Instruction 'jge'.
|
|
kIdJl, //!< Instruction 'jl'.
|
|
kIdJle, //!< Instruction 'jle'.
|
|
kIdJmp, //!< Instruction 'jmp'.
|
|
kIdJna, //!< Instruction 'jna'.
|
|
kIdJnae, //!< Instruction 'jnae'.
|
|
kIdJnb, //!< Instruction 'jnb'.
|
|
kIdJnbe, //!< Instruction 'jnbe'.
|
|
kIdJnc, //!< Instruction 'jnc'.
|
|
kIdJne, //!< Instruction 'jne'.
|
|
kIdJng, //!< Instruction 'jng'.
|
|
kIdJnge, //!< Instruction 'jnge'.
|
|
kIdJnl, //!< Instruction 'jnl'.
|
|
kIdJnle, //!< Instruction 'jnle'.
|
|
kIdJno, //!< Instruction 'jno'.
|
|
kIdJnp, //!< Instruction 'jnp'.
|
|
kIdJns, //!< Instruction 'jns'.
|
|
kIdJnz, //!< Instruction 'jnz'.
|
|
kIdJo, //!< Instruction 'jo'.
|
|
kIdJp, //!< Instruction 'jp'.
|
|
kIdJpe, //!< Instruction 'jpe'.
|
|
kIdJpo, //!< Instruction 'jpo'.
|
|
kIdJs, //!< Instruction 'js'.
|
|
kIdJz, //!< Instruction 'jz'.
|
|
kIdKaddb, //!< Instruction 'kaddb' {AVX512_DQ}.
|
|
kIdKaddd, //!< Instruction 'kaddd' {AVX512_BW}.
|
|
kIdKaddq, //!< Instruction 'kaddq' {AVX512_BW}.
|
|
kIdKaddw, //!< Instruction 'kaddw' {AVX512_DQ}.
|
|
kIdKandb, //!< Instruction 'kandb' {AVX512_DQ}.
|
|
kIdKandd, //!< Instruction 'kandd' {AVX512_BW}.
|
|
kIdKandnb, //!< Instruction 'kandnb' {AVX512_DQ}.
|
|
kIdKandnd, //!< Instruction 'kandnd' {AVX512_BW}.
|
|
kIdKandnq, //!< Instruction 'kandnq' {AVX512_BW}.
|
|
kIdKandnw, //!< Instruction 'kandnw' {AVX512_F}.
|
|
kIdKandq, //!< Instruction 'kandq' {AVX512_BW}.
|
|
kIdKandw, //!< Instruction 'kandw' {AVX512_F}.
|
|
kIdKmovb, //!< Instruction 'kmovb' {AVX512_DQ}.
|
|
kIdKmovd, //!< Instruction 'kmovd' {AVX512_BW}.
|
|
kIdKmovq, //!< Instruction 'kmovq' {AVX512_BW}.
|
|
kIdKmovw, //!< Instruction 'kmovw' {AVX512_F}.
|
|
kIdKnotb, //!< Instruction 'knotb' {AVX512_DQ}.
|
|
kIdKnotd, //!< Instruction 'knotd' {AVX512_BW}.
|
|
kIdKnotq, //!< Instruction 'knotq' {AVX512_BW}.
|
|
kIdKnotw, //!< Instruction 'knotw' {AVX512_F}.
|
|
kIdKorb, //!< Instruction 'korb' {AVX512_DQ}.
|
|
kIdKord, //!< Instruction 'kord' {AVX512_BW}.
|
|
kIdKorq, //!< Instruction 'korq' {AVX512_BW}.
|
|
kIdKortestb, //!< Instruction 'kortestb' {AVX512_DQ}.
|
|
kIdKortestd, //!< Instruction 'kortestd' {AVX512_BW}.
|
|
kIdKortestq, //!< Instruction 'kortestq' {AVX512_BW}.
|
|
kIdKortestw, //!< Instruction 'kortestw' {AVX512_F}.
|
|
kIdKorw, //!< Instruction 'korw' {AVX512_F}.
|
|
kIdKshiftlb, //!< Instruction 'kshiftlb' {AVX512_DQ}.
|
|
kIdKshiftld, //!< Instruction 'kshiftld' {AVX512_BW}.
|
|
kIdKshiftlq, //!< Instruction 'kshiftlq' {AVX512_BW}.
|
|
kIdKshiftlw, //!< Instruction 'kshiftlw' {AVX512_F}.
|
|
kIdKshiftrb, //!< Instruction 'kshiftrb' {AVX512_DQ}.
|
|
kIdKshiftrd, //!< Instruction 'kshiftrd' {AVX512_BW}.
|
|
kIdKshiftrq, //!< Instruction 'kshiftrq' {AVX512_BW}.
|
|
kIdKshiftrw, //!< Instruction 'kshiftrw' {AVX512_F}.
|
|
kIdKtestb, //!< Instruction 'ktestb' {AVX512_DQ}.
|
|
kIdKtestd, //!< Instruction 'ktestd' {AVX512_BW}.
|
|
kIdKtestq, //!< Instruction 'ktestq' {AVX512_BW}.
|
|
kIdKtestw, //!< Instruction 'ktestw' {AVX512_DQ}.
|
|
kIdKunpckbw, //!< Instruction 'kunpckbw' {AVX512_F}.
|
|
kIdKunpckdq, //!< Instruction 'kunpckdq' {AVX512_BW}.
|
|
kIdKunpckwd, //!< Instruction 'kunpckwd' {AVX512_BW}.
|
|
kIdKxnorb, //!< Instruction 'kxnorb' {AVX512_DQ}.
|
|
kIdKxnord, //!< Instruction 'kxnord' {AVX512_BW}.
|
|
kIdKxnorq, //!< Instruction 'kxnorq' {AVX512_BW}.
|
|
kIdKxnorw, //!< Instruction 'kxnorw' {AVX512_F}.
|
|
kIdKxorb, //!< Instruction 'kxorb' {AVX512_DQ}.
|
|
kIdKxord, //!< Instruction 'kxord' {AVX512_BW}.
|
|
kIdKxorq, //!< Instruction 'kxorq' {AVX512_BW}.
|
|
kIdKxorw, //!< Instruction 'kxorw' {AVX512_F}.
|
|
kIdLahf, //!< Instruction 'lahf' {LAHFSAHF}.
|
|
kIdLar, //!< Instruction 'lar'.
|
|
kIdLcall, //!< Instruction 'lcall'.
|
|
kIdLddqu, //!< Instruction 'lddqu' {SSE3}.
|
|
kIdLdmxcsr, //!< Instruction 'ldmxcsr' {SSE}.
|
|
kIdLds, //!< Instruction 'lds' (X86).
|
|
kIdLdtilecfg, //!< Instruction 'ldtilecfg' {AMX_TILE} (X64).
|
|
kIdLea, //!< Instruction 'lea'.
|
|
kIdLeave, //!< Instruction 'leave'.
|
|
kIdLes, //!< Instruction 'les' (X86).
|
|
kIdLfence, //!< Instruction 'lfence' {SSE2}.
|
|
kIdLfs, //!< Instruction 'lfs'.
|
|
kIdLgdt, //!< Instruction 'lgdt'.
|
|
kIdLgs, //!< Instruction 'lgs'.
|
|
kIdLidt, //!< Instruction 'lidt'.
|
|
kIdLjmp, //!< Instruction 'ljmp'.
|
|
kIdLldt, //!< Instruction 'lldt'.
|
|
kIdLlwpcb, //!< Instruction 'llwpcb' {LWP}.
|
|
kIdLmsw, //!< Instruction 'lmsw'.
|
|
kIdLods, //!< Instruction 'lods'.
|
|
kIdLoop, //!< Instruction 'loop'.
|
|
kIdLoope, //!< Instruction 'loope'.
|
|
kIdLoopne, //!< Instruction 'loopne'.
|
|
kIdLsl, //!< Instruction 'lsl'.
|
|
kIdLss, //!< Instruction 'lss'.
|
|
kIdLtr, //!< Instruction 'ltr'.
|
|
kIdLwpins, //!< Instruction 'lwpins' {LWP}.
|
|
kIdLwpval, //!< Instruction 'lwpval' {LWP}.
|
|
kIdLzcnt, //!< Instruction 'lzcnt' {LZCNT}.
|
|
kIdMaskmovdqu, //!< Instruction 'maskmovdqu' {SSE2}.
|
|
kIdMaskmovq, //!< Instruction 'maskmovq' {MMX2}.
|
|
kIdMaxpd, //!< Instruction 'maxpd' {SSE2}.
|
|
kIdMaxps, //!< Instruction 'maxps' {SSE}.
|
|
kIdMaxsd, //!< Instruction 'maxsd' {SSE2}.
|
|
kIdMaxss, //!< Instruction 'maxss' {SSE}.
|
|
kIdMcommit, //!< Instruction 'mcommit' {MCOMMIT}.
|
|
kIdMfence, //!< Instruction 'mfence' {SSE2}.
|
|
kIdMinpd, //!< Instruction 'minpd' {SSE2}.
|
|
kIdMinps, //!< Instruction 'minps' {SSE}.
|
|
kIdMinsd, //!< Instruction 'minsd' {SSE2}.
|
|
kIdMinss, //!< Instruction 'minss' {SSE}.
|
|
kIdMonitor, //!< Instruction 'monitor' {MONITOR}.
|
|
kIdMonitorx, //!< Instruction 'monitorx' {MONITORX}.
|
|
kIdMov, //!< Instruction 'mov'.
|
|
kIdMovabs, //!< Instruction 'movabs' (X64).
|
|
kIdMovapd, //!< Instruction 'movapd' {SSE2}.
|
|
kIdMovaps, //!< Instruction 'movaps' {SSE}.
|
|
kIdMovbe, //!< Instruction 'movbe' {MOVBE}.
|
|
kIdMovd, //!< Instruction 'movd' {MMX|SSE2}.
|
|
kIdMovddup, //!< Instruction 'movddup' {SSE3}.
|
|
kIdMovdir64b, //!< Instruction 'movdir64b' {MOVDIR64B}.
|
|
kIdMovdiri, //!< Instruction 'movdiri' {MOVDIRI}.
|
|
kIdMovdq2q, //!< Instruction 'movdq2q' {SSE2}.
|
|
kIdMovdqa, //!< Instruction 'movdqa' {SSE2}.
|
|
kIdMovdqu, //!< Instruction 'movdqu' {SSE2}.
|
|
kIdMovhlps, //!< Instruction 'movhlps' {SSE}.
|
|
kIdMovhpd, //!< Instruction 'movhpd' {SSE2}.
|
|
kIdMovhps, //!< Instruction 'movhps' {SSE}.
|
|
kIdMovlhps, //!< Instruction 'movlhps' {SSE}.
|
|
kIdMovlpd, //!< Instruction 'movlpd' {SSE2}.
|
|
kIdMovlps, //!< Instruction 'movlps' {SSE}.
|
|
kIdMovmskpd, //!< Instruction 'movmskpd' {SSE2}.
|
|
kIdMovmskps, //!< Instruction 'movmskps' {SSE}.
|
|
kIdMovntdq, //!< Instruction 'movntdq' {SSE2}.
|
|
kIdMovntdqa, //!< Instruction 'movntdqa' {SSE4_1}.
|
|
kIdMovnti, //!< Instruction 'movnti' {SSE2}.
|
|
kIdMovntpd, //!< Instruction 'movntpd' {SSE2}.
|
|
kIdMovntps, //!< Instruction 'movntps' {SSE}.
|
|
kIdMovntq, //!< Instruction 'movntq' {MMX2}.
|
|
kIdMovntsd, //!< Instruction 'movntsd' {SSE4A}.
|
|
kIdMovntss, //!< Instruction 'movntss' {SSE4A}.
|
|
kIdMovq, //!< Instruction 'movq' {MMX|SSE2}.
|
|
kIdMovq2dq, //!< Instruction 'movq2dq' {SSE2}.
|
|
kIdMovs, //!< Instruction 'movs'.
|
|
kIdMovsd, //!< Instruction 'movsd' {SSE2}.
|
|
kIdMovshdup, //!< Instruction 'movshdup' {SSE3}.
|
|
kIdMovsldup, //!< Instruction 'movsldup' {SSE3}.
|
|
kIdMovss, //!< Instruction 'movss' {SSE}.
|
|
kIdMovsx, //!< Instruction 'movsx'.
|
|
kIdMovsxd, //!< Instruction 'movsxd' (X64).
|
|
kIdMovupd, //!< Instruction 'movupd' {SSE2}.
|
|
kIdMovups, //!< Instruction 'movups' {SSE}.
|
|
kIdMovzx, //!< Instruction 'movzx'.
|
|
kIdMpsadbw, //!< Instruction 'mpsadbw' {SSE4_1}.
|
|
kIdMul, //!< Instruction 'mul'.
|
|
kIdMulpd, //!< Instruction 'mulpd' {SSE2}.
|
|
kIdMulps, //!< Instruction 'mulps' {SSE}.
|
|
kIdMulsd, //!< Instruction 'mulsd' {SSE2}.
|
|
kIdMulss, //!< Instruction 'mulss' {SSE}.
|
|
kIdMulx, //!< Instruction 'mulx' {BMI2}.
|
|
kIdMwait, //!< Instruction 'mwait' {MONITOR}.
|
|
kIdMwaitx, //!< Instruction 'mwaitx' {MONITORX}.
|
|
kIdNeg, //!< Instruction 'neg'.
|
|
kIdNop, //!< Instruction 'nop'.
|
|
kIdNot, //!< Instruction 'not'.
|
|
kIdOr, //!< Instruction 'or'.
|
|
kIdOrpd, //!< Instruction 'orpd' {SSE2}.
|
|
kIdOrps, //!< Instruction 'orps' {SSE}.
|
|
kIdOut, //!< Instruction 'out'.
|
|
kIdOuts, //!< Instruction 'outs'.
|
|
kIdPabsb, //!< Instruction 'pabsb' {SSSE3}.
|
|
kIdPabsd, //!< Instruction 'pabsd' {SSSE3}.
|
|
kIdPabsw, //!< Instruction 'pabsw' {SSSE3}.
|
|
kIdPackssdw, //!< Instruction 'packssdw' {MMX|SSE2}.
|
|
kIdPacksswb, //!< Instruction 'packsswb' {MMX|SSE2}.
|
|
kIdPackusdw, //!< Instruction 'packusdw' {SSE4_1}.
|
|
kIdPackuswb, //!< Instruction 'packuswb' {MMX|SSE2}.
|
|
kIdPaddb, //!< Instruction 'paddb' {MMX|SSE2}.
|
|
kIdPaddd, //!< Instruction 'paddd' {MMX|SSE2}.
|
|
kIdPaddq, //!< Instruction 'paddq' {SSE2}.
|
|
kIdPaddsb, //!< Instruction 'paddsb' {MMX|SSE2}.
|
|
kIdPaddsw, //!< Instruction 'paddsw' {MMX|SSE2}.
|
|
kIdPaddusb, //!< Instruction 'paddusb' {MMX|SSE2}.
|
|
kIdPaddusw, //!< Instruction 'paddusw' {MMX|SSE2}.
|
|
kIdPaddw, //!< Instruction 'paddw' {MMX|SSE2}.
|
|
kIdPalignr, //!< Instruction 'palignr' {SSE3}.
|
|
kIdPand, //!< Instruction 'pand' {MMX|SSE2}.
|
|
kIdPandn, //!< Instruction 'pandn' {MMX|SSE2}.
|
|
kIdPause, //!< Instruction 'pause'.
|
|
kIdPavgb, //!< Instruction 'pavgb' {MMX2|SSE2}.
|
|
kIdPavgusb, //!< Instruction 'pavgusb' {3DNOW}.
|
|
kIdPavgw, //!< Instruction 'pavgw' {MMX2|SSE2}.
|
|
kIdPblendvb, //!< Instruction 'pblendvb' {SSE4_1}.
|
|
kIdPblendw, //!< Instruction 'pblendw' {SSE4_1}.
|
|
kIdPclmulqdq, //!< Instruction 'pclmulqdq' {PCLMULQDQ}.
|
|
kIdPcmpeqb, //!< Instruction 'pcmpeqb' {MMX|SSE2}.
|
|
kIdPcmpeqd, //!< Instruction 'pcmpeqd' {MMX|SSE2}.
|
|
kIdPcmpeqq, //!< Instruction 'pcmpeqq' {SSE4_1}.
|
|
kIdPcmpeqw, //!< Instruction 'pcmpeqw' {MMX|SSE2}.
|
|
kIdPcmpestri, //!< Instruction 'pcmpestri' {SSE4_2}.
|
|
kIdPcmpestrm, //!< Instruction 'pcmpestrm' {SSE4_2}.
|
|
kIdPcmpgtb, //!< Instruction 'pcmpgtb' {MMX|SSE2}.
|
|
kIdPcmpgtd, //!< Instruction 'pcmpgtd' {MMX|SSE2}.
|
|
kIdPcmpgtq, //!< Instruction 'pcmpgtq' {SSE4_2}.
|
|
kIdPcmpgtw, //!< Instruction 'pcmpgtw' {MMX|SSE2}.
|
|
kIdPcmpistri, //!< Instruction 'pcmpistri' {SSE4_2}.
|
|
kIdPcmpistrm, //!< Instruction 'pcmpistrm' {SSE4_2}.
|
|
kIdPconfig, //!< Instruction 'pconfig' {PCONFIG}.
|
|
kIdPdep, //!< Instruction 'pdep' {BMI2}.
|
|
kIdPext, //!< Instruction 'pext' {BMI2}.
|
|
kIdPextrb, //!< Instruction 'pextrb' {SSE4_1}.
|
|
kIdPextrd, //!< Instruction 'pextrd' {SSE4_1}.
|
|
kIdPextrq, //!< Instruction 'pextrq' {SSE4_1} (X64).
|
|
kIdPextrw, //!< Instruction 'pextrw' {MMX2|SSE2|SSE4_1}.
|
|
kIdPf2id, //!< Instruction 'pf2id' {3DNOW}.
|
|
kIdPf2iw, //!< Instruction 'pf2iw' {3DNOW2}.
|
|
kIdPfacc, //!< Instruction 'pfacc' {3DNOW}.
|
|
kIdPfadd, //!< Instruction 'pfadd' {3DNOW}.
|
|
kIdPfcmpeq, //!< Instruction 'pfcmpeq' {3DNOW}.
|
|
kIdPfcmpge, //!< Instruction 'pfcmpge' {3DNOW}.
|
|
kIdPfcmpgt, //!< Instruction 'pfcmpgt' {3DNOW}.
|
|
kIdPfmax, //!< Instruction 'pfmax' {3DNOW}.
|
|
kIdPfmin, //!< Instruction 'pfmin' {3DNOW}.
|
|
kIdPfmul, //!< Instruction 'pfmul' {3DNOW}.
|
|
kIdPfnacc, //!< Instruction 'pfnacc' {3DNOW2}.
|
|
kIdPfpnacc, //!< Instruction 'pfpnacc' {3DNOW2}.
|
|
kIdPfrcp, //!< Instruction 'pfrcp' {3DNOW}.
|
|
kIdPfrcpit1, //!< Instruction 'pfrcpit1' {3DNOW}.
|
|
kIdPfrcpit2, //!< Instruction 'pfrcpit2' {3DNOW}.
|
|
kIdPfrcpv, //!< Instruction 'pfrcpv' {GEODE}.
|
|
kIdPfrsqit1, //!< Instruction 'pfrsqit1' {3DNOW}.
|
|
kIdPfrsqrt, //!< Instruction 'pfrsqrt' {3DNOW}.
|
|
kIdPfrsqrtv, //!< Instruction 'pfrsqrtv' {GEODE}.
|
|
kIdPfsub, //!< Instruction 'pfsub' {3DNOW}.
|
|
kIdPfsubr, //!< Instruction 'pfsubr' {3DNOW}.
|
|
kIdPhaddd, //!< Instruction 'phaddd' {SSSE3}.
|
|
kIdPhaddsw, //!< Instruction 'phaddsw' {SSSE3}.
|
|
kIdPhaddw, //!< Instruction 'phaddw' {SSSE3}.
|
|
kIdPhminposuw, //!< Instruction 'phminposuw' {SSE4_1}.
|
|
kIdPhsubd, //!< Instruction 'phsubd' {SSSE3}.
|
|
kIdPhsubsw, //!< Instruction 'phsubsw' {SSSE3}.
|
|
kIdPhsubw, //!< Instruction 'phsubw' {SSSE3}.
|
|
kIdPi2fd, //!< Instruction 'pi2fd' {3DNOW}.
|
|
kIdPi2fw, //!< Instruction 'pi2fw' {3DNOW2}.
|
|
kIdPinsrb, //!< Instruction 'pinsrb' {SSE4_1}.
|
|
kIdPinsrd, //!< Instruction 'pinsrd' {SSE4_1}.
|
|
kIdPinsrq, //!< Instruction 'pinsrq' {SSE4_1} (X64).
|
|
kIdPinsrw, //!< Instruction 'pinsrw' {MMX2|SSE2}.
|
|
kIdPmaddubsw, //!< Instruction 'pmaddubsw' {SSSE3}.
|
|
kIdPmaddwd, //!< Instruction 'pmaddwd' {MMX|SSE2}.
|
|
kIdPmaxsb, //!< Instruction 'pmaxsb' {SSE4_1}.
|
|
kIdPmaxsd, //!< Instruction 'pmaxsd' {SSE4_1}.
|
|
kIdPmaxsw, //!< Instruction 'pmaxsw' {MMX2|SSE2}.
|
|
kIdPmaxub, //!< Instruction 'pmaxub' {MMX2|SSE2}.
|
|
kIdPmaxud, //!< Instruction 'pmaxud' {SSE4_1}.
|
|
kIdPmaxuw, //!< Instruction 'pmaxuw' {SSE4_1}.
|
|
kIdPminsb, //!< Instruction 'pminsb' {SSE4_1}.
|
|
kIdPminsd, //!< Instruction 'pminsd' {SSE4_1}.
|
|
kIdPminsw, //!< Instruction 'pminsw' {MMX2|SSE2}.
|
|
kIdPminub, //!< Instruction 'pminub' {MMX2|SSE2}.
|
|
kIdPminud, //!< Instruction 'pminud' {SSE4_1}.
|
|
kIdPminuw, //!< Instruction 'pminuw' {SSE4_1}.
|
|
kIdPmovmskb, //!< Instruction 'pmovmskb' {MMX2|SSE2}.
|
|
kIdPmovsxbd, //!< Instruction 'pmovsxbd' {SSE4_1}.
|
|
kIdPmovsxbq, //!< Instruction 'pmovsxbq' {SSE4_1}.
|
|
kIdPmovsxbw, //!< Instruction 'pmovsxbw' {SSE4_1}.
|
|
kIdPmovsxdq, //!< Instruction 'pmovsxdq' {SSE4_1}.
|
|
kIdPmovsxwd, //!< Instruction 'pmovsxwd' {SSE4_1}.
|
|
kIdPmovsxwq, //!< Instruction 'pmovsxwq' {SSE4_1}.
|
|
kIdPmovzxbd, //!< Instruction 'pmovzxbd' {SSE4_1}.
|
|
kIdPmovzxbq, //!< Instruction 'pmovzxbq' {SSE4_1}.
|
|
kIdPmovzxbw, //!< Instruction 'pmovzxbw' {SSE4_1}.
|
|
kIdPmovzxdq, //!< Instruction 'pmovzxdq' {SSE4_1}.
|
|
kIdPmovzxwd, //!< Instruction 'pmovzxwd' {SSE4_1}.
|
|
kIdPmovzxwq, //!< Instruction 'pmovzxwq' {SSE4_1}.
|
|
kIdPmuldq, //!< Instruction 'pmuldq' {SSE4_1}.
|
|
kIdPmulhrsw, //!< Instruction 'pmulhrsw' {SSSE3}.
|
|
kIdPmulhrw, //!< Instruction 'pmulhrw' {3DNOW}.
|
|
kIdPmulhuw, //!< Instruction 'pmulhuw' {MMX2|SSE2}.
|
|
kIdPmulhw, //!< Instruction 'pmulhw' {MMX|SSE2}.
|
|
kIdPmulld, //!< Instruction 'pmulld' {SSE4_1}.
|
|
kIdPmullw, //!< Instruction 'pmullw' {MMX|SSE2}.
|
|
kIdPmuludq, //!< Instruction 'pmuludq' {SSE2}.
|
|
kIdPop, //!< Instruction 'pop'.
|
|
kIdPopa, //!< Instruction 'popa' (X86).
|
|
kIdPopad, //!< Instruction 'popad' (X86).
|
|
kIdPopcnt, //!< Instruction 'popcnt' {POPCNT}.
|
|
kIdPopf, //!< Instruction 'popf'.
|
|
kIdPopfd, //!< Instruction 'popfd' (X86).
|
|
kIdPopfq, //!< Instruction 'popfq' (X64).
|
|
kIdPor, //!< Instruction 'por' {MMX|SSE2}.
|
|
kIdPrefetch, //!< Instruction 'prefetch' {3DNOW}.
|
|
kIdPrefetchnta, //!< Instruction 'prefetchnta' {MMX2}.
|
|
kIdPrefetcht0, //!< Instruction 'prefetcht0' {MMX2}.
|
|
kIdPrefetcht1, //!< Instruction 'prefetcht1' {MMX2}.
|
|
kIdPrefetcht2, //!< Instruction 'prefetcht2' {MMX2}.
|
|
kIdPrefetchw, //!< Instruction 'prefetchw' {PREFETCHW}.
|
|
kIdPrefetchwt1, //!< Instruction 'prefetchwt1' {PREFETCHWT1}.
|
|
kIdPsadbw, //!< Instruction 'psadbw' {MMX2|SSE2}.
|
|
kIdPshufb, //!< Instruction 'pshufb' {SSSE3}.
|
|
kIdPshufd, //!< Instruction 'pshufd' {SSE2}.
|
|
kIdPshufhw, //!< Instruction 'pshufhw' {SSE2}.
|
|
kIdPshuflw, //!< Instruction 'pshuflw' {SSE2}.
|
|
kIdPshufw, //!< Instruction 'pshufw' {MMX2}.
|
|
kIdPsignb, //!< Instruction 'psignb' {SSSE3}.
|
|
kIdPsignd, //!< Instruction 'psignd' {SSSE3}.
|
|
kIdPsignw, //!< Instruction 'psignw' {SSSE3}.
|
|
kIdPslld, //!< Instruction 'pslld' {MMX|SSE2}.
|
|
kIdPslldq, //!< Instruction 'pslldq' {SSE2}.
|
|
kIdPsllq, //!< Instruction 'psllq' {MMX|SSE2}.
|
|
kIdPsllw, //!< Instruction 'psllw' {MMX|SSE2}.
|
|
kIdPsmash, //!< Instruction 'psmash' {SNP} (X64).
|
|
kIdPsrad, //!< Instruction 'psrad' {MMX|SSE2}.
|
|
kIdPsraw, //!< Instruction 'psraw' {MMX|SSE2}.
|
|
kIdPsrld, //!< Instruction 'psrld' {MMX|SSE2}.
|
|
kIdPsrldq, //!< Instruction 'psrldq' {SSE2}.
|
|
kIdPsrlq, //!< Instruction 'psrlq' {MMX|SSE2}.
|
|
kIdPsrlw, //!< Instruction 'psrlw' {MMX|SSE2}.
|
|
kIdPsubb, //!< Instruction 'psubb' {MMX|SSE2}.
|
|
kIdPsubd, //!< Instruction 'psubd' {MMX|SSE2}.
|
|
kIdPsubq, //!< Instruction 'psubq' {SSE2}.
|
|
kIdPsubsb, //!< Instruction 'psubsb' {MMX|SSE2}.
|
|
kIdPsubsw, //!< Instruction 'psubsw' {MMX|SSE2}.
|
|
kIdPsubusb, //!< Instruction 'psubusb' {MMX|SSE2}.
|
|
kIdPsubusw, //!< Instruction 'psubusw' {MMX|SSE2}.
|
|
kIdPsubw, //!< Instruction 'psubw' {MMX|SSE2}.
|
|
kIdPswapd, //!< Instruction 'pswapd' {3DNOW2}.
|
|
kIdPtest, //!< Instruction 'ptest' {SSE4_1}.
|
|
kIdPtwrite, //!< Instruction 'ptwrite' {PTWRITE}.
|
|
kIdPunpckhbw, //!< Instruction 'punpckhbw' {MMX|SSE2}.
|
|
kIdPunpckhdq, //!< Instruction 'punpckhdq' {MMX|SSE2}.
|
|
kIdPunpckhqdq, //!< Instruction 'punpckhqdq' {SSE2}.
|
|
kIdPunpckhwd, //!< Instruction 'punpckhwd' {MMX|SSE2}.
|
|
kIdPunpcklbw, //!< Instruction 'punpcklbw' {MMX|SSE2}.
|
|
kIdPunpckldq, //!< Instruction 'punpckldq' {MMX|SSE2}.
|
|
kIdPunpcklqdq, //!< Instruction 'punpcklqdq' {SSE2}.
|
|
kIdPunpcklwd, //!< Instruction 'punpcklwd' {MMX|SSE2}.
|
|
kIdPush, //!< Instruction 'push'.
|
|
kIdPusha, //!< Instruction 'pusha' (X86).
|
|
kIdPushad, //!< Instruction 'pushad' (X86).
|
|
kIdPushf, //!< Instruction 'pushf'.
|
|
kIdPushfd, //!< Instruction 'pushfd' (X86).
|
|
kIdPushfq, //!< Instruction 'pushfq' (X64).
|
|
kIdPvalidate, //!< Instruction 'pvalidate' {SNP}.
|
|
kIdPxor, //!< Instruction 'pxor' {MMX|SSE2}.
|
|
kIdRcl, //!< Instruction 'rcl'.
|
|
kIdRcpps, //!< Instruction 'rcpps' {SSE}.
|
|
kIdRcpss, //!< Instruction 'rcpss' {SSE}.
|
|
kIdRcr, //!< Instruction 'rcr'.
|
|
kIdRdfsbase, //!< Instruction 'rdfsbase' {FSGSBASE} (X64).
|
|
kIdRdgsbase, //!< Instruction 'rdgsbase' {FSGSBASE} (X64).
|
|
kIdRdmsr, //!< Instruction 'rdmsr' {MSR}.
|
|
kIdRdpid, //!< Instruction 'rdpid' {RDPID}.
|
|
kIdRdpkru, //!< Instruction 'rdpkru' {OSPKE}.
|
|
kIdRdpmc, //!< Instruction 'rdpmc'.
|
|
kIdRdpru, //!< Instruction 'rdpru' {RDPRU}.
|
|
kIdRdrand, //!< Instruction 'rdrand' {RDRAND}.
|
|
kIdRdseed, //!< Instruction 'rdseed' {RDSEED}.
|
|
kIdRdsspd, //!< Instruction 'rdsspd' {CET_SS}.
|
|
kIdRdsspq, //!< Instruction 'rdsspq' {CET_SS} (X64).
|
|
kIdRdtsc, //!< Instruction 'rdtsc' {RDTSC}.
|
|
kIdRdtscp, //!< Instruction 'rdtscp' {RDTSCP}.
|
|
kIdRet, //!< Instruction 'ret'.
|
|
kIdRetf, //!< Instruction 'retf'.
|
|
kIdRmpadjust, //!< Instruction 'rmpadjust' {SNP} (X64).
|
|
kIdRmpupdate, //!< Instruction 'rmpupdate' {SNP} (X64).
|
|
kIdRol, //!< Instruction 'rol'.
|
|
kIdRor, //!< Instruction 'ror'.
|
|
kIdRorx, //!< Instruction 'rorx' {BMI2}.
|
|
kIdRoundpd, //!< Instruction 'roundpd' {SSE4_1}.
|
|
kIdRoundps, //!< Instruction 'roundps' {SSE4_1}.
|
|
kIdRoundsd, //!< Instruction 'roundsd' {SSE4_1}.
|
|
kIdRoundss, //!< Instruction 'roundss' {SSE4_1}.
|
|
kIdRsm, //!< Instruction 'rsm' (X86).
|
|
kIdRsqrtps, //!< Instruction 'rsqrtps' {SSE}.
|
|
kIdRsqrtss, //!< Instruction 'rsqrtss' {SSE}.
|
|
kIdRstorssp, //!< Instruction 'rstorssp' {CET_SS}.
|
|
kIdSahf, //!< Instruction 'sahf' {LAHFSAHF}.
|
|
kIdSal, //!< Instruction 'sal'.
|
|
kIdSar, //!< Instruction 'sar'.
|
|
kIdSarx, //!< Instruction 'sarx' {BMI2}.
|
|
kIdSaveprevssp, //!< Instruction 'saveprevssp' {CET_SS}.
|
|
kIdSbb, //!< Instruction 'sbb'.
|
|
kIdScas, //!< Instruction 'scas'.
|
|
kIdSenduipi, //!< Instruction 'senduipi' {UINTR} (X64).
|
|
kIdSerialize, //!< Instruction 'serialize' {SERIALIZE}.
|
|
kIdSeta, //!< Instruction 'seta'.
|
|
kIdSetae, //!< Instruction 'setae'.
|
|
kIdSetb, //!< Instruction 'setb'.
|
|
kIdSetbe, //!< Instruction 'setbe'.
|
|
kIdSetc, //!< Instruction 'setc'.
|
|
kIdSete, //!< Instruction 'sete'.
|
|
kIdSetg, //!< Instruction 'setg'.
|
|
kIdSetge, //!< Instruction 'setge'.
|
|
kIdSetl, //!< Instruction 'setl'.
|
|
kIdSetle, //!< Instruction 'setle'.
|
|
kIdSetna, //!< Instruction 'setna'.
|
|
kIdSetnae, //!< Instruction 'setnae'.
|
|
kIdSetnb, //!< Instruction 'setnb'.
|
|
kIdSetnbe, //!< Instruction 'setnbe'.
|
|
kIdSetnc, //!< Instruction 'setnc'.
|
|
kIdSetne, //!< Instruction 'setne'.
|
|
kIdSetng, //!< Instruction 'setng'.
|
|
kIdSetnge, //!< Instruction 'setnge'.
|
|
kIdSetnl, //!< Instruction 'setnl'.
|
|
kIdSetnle, //!< Instruction 'setnle'.
|
|
kIdSetno, //!< Instruction 'setno'.
|
|
kIdSetnp, //!< Instruction 'setnp'.
|
|
kIdSetns, //!< Instruction 'setns'.
|
|
kIdSetnz, //!< Instruction 'setnz'.
|
|
kIdSeto, //!< Instruction 'seto'.
|
|
kIdSetp, //!< Instruction 'setp'.
|
|
kIdSetpe, //!< Instruction 'setpe'.
|
|
kIdSetpo, //!< Instruction 'setpo'.
|
|
kIdSets, //!< Instruction 'sets'.
|
|
kIdSetssbsy, //!< Instruction 'setssbsy' {CET_SS}.
|
|
kIdSetz, //!< Instruction 'setz'.
|
|
kIdSfence, //!< Instruction 'sfence' {MMX2}.
|
|
kIdSgdt, //!< Instruction 'sgdt'.
|
|
kIdSha1msg1, //!< Instruction 'sha1msg1' {SHA}.
|
|
kIdSha1msg2, //!< Instruction 'sha1msg2' {SHA}.
|
|
kIdSha1nexte, //!< Instruction 'sha1nexte' {SHA}.
|
|
kIdSha1rnds4, //!< Instruction 'sha1rnds4' {SHA}.
|
|
kIdSha256msg1, //!< Instruction 'sha256msg1' {SHA}.
|
|
kIdSha256msg2, //!< Instruction 'sha256msg2' {SHA}.
|
|
kIdSha256rnds2, //!< Instruction 'sha256rnds2' {SHA}.
|
|
kIdShl, //!< Instruction 'shl'.
|
|
kIdShld, //!< Instruction 'shld'.
|
|
kIdShlx, //!< Instruction 'shlx' {BMI2}.
|
|
kIdShr, //!< Instruction 'shr'.
|
|
kIdShrd, //!< Instruction 'shrd'.
|
|
kIdShrx, //!< Instruction 'shrx' {BMI2}.
|
|
kIdShufpd, //!< Instruction 'shufpd' {SSE2}.
|
|
kIdShufps, //!< Instruction 'shufps' {SSE}.
|
|
kIdSidt, //!< Instruction 'sidt'.
|
|
kIdSkinit, //!< Instruction 'skinit' {SKINIT}.
|
|
kIdSldt, //!< Instruction 'sldt'.
|
|
kIdSlwpcb, //!< Instruction 'slwpcb' {LWP}.
|
|
kIdSmsw, //!< Instruction 'smsw'.
|
|
kIdSqrtpd, //!< Instruction 'sqrtpd' {SSE2}.
|
|
kIdSqrtps, //!< Instruction 'sqrtps' {SSE}.
|
|
kIdSqrtsd, //!< Instruction 'sqrtsd' {SSE2}.
|
|
kIdSqrtss, //!< Instruction 'sqrtss' {SSE}.
|
|
kIdStac, //!< Instruction 'stac' {SMAP}.
|
|
kIdStc, //!< Instruction 'stc'.
|
|
kIdStd, //!< Instruction 'std'.
|
|
kIdStgi, //!< Instruction 'stgi' {SKINIT}.
|
|
kIdSti, //!< Instruction 'sti'.
|
|
kIdStmxcsr, //!< Instruction 'stmxcsr' {SSE}.
|
|
kIdStos, //!< Instruction 'stos'.
|
|
kIdStr, //!< Instruction 'str'.
|
|
kIdSttilecfg, //!< Instruction 'sttilecfg' {AMX_TILE} (X64).
|
|
kIdStui, //!< Instruction 'stui' {UINTR} (X64).
|
|
kIdSub, //!< Instruction 'sub'.
|
|
kIdSubpd, //!< Instruction 'subpd' {SSE2}.
|
|
kIdSubps, //!< Instruction 'subps' {SSE}.
|
|
kIdSubsd, //!< Instruction 'subsd' {SSE2}.
|
|
kIdSubss, //!< Instruction 'subss' {SSE}.
|
|
kIdSwapgs, //!< Instruction 'swapgs' (X64).
|
|
kIdSyscall, //!< Instruction 'syscall' (X64).
|
|
kIdSysenter, //!< Instruction 'sysenter'.
|
|
kIdSysexit, //!< Instruction 'sysexit'.
|
|
kIdSysexitq, //!< Instruction 'sysexitq'.
|
|
kIdSysret, //!< Instruction 'sysret' (X64).
|
|
kIdSysretq, //!< Instruction 'sysretq' (X64).
|
|
kIdT1mskc, //!< Instruction 't1mskc' {TBM}.
|
|
kIdTdpbf16ps, //!< Instruction 'tdpbf16ps' {AMX_BF16} (X64).
|
|
kIdTdpbssd, //!< Instruction 'tdpbssd' {AMX_INT8} (X64).
|
|
kIdTdpbsud, //!< Instruction 'tdpbsud' {AMX_INT8} (X64).
|
|
kIdTdpbusd, //!< Instruction 'tdpbusd' {AMX_INT8} (X64).
|
|
kIdTdpbuud, //!< Instruction 'tdpbuud' {AMX_INT8} (X64).
|
|
kIdTest, //!< Instruction 'test'.
|
|
kIdTestui, //!< Instruction 'testui' {UINTR} (X64).
|
|
kIdTileloadd, //!< Instruction 'tileloadd' {AMX_TILE} (X64).
|
|
kIdTileloaddt1, //!< Instruction 'tileloaddt1' {AMX_TILE} (X64).
|
|
kIdTilerelease, //!< Instruction 'tilerelease' {AMX_TILE} (X64).
|
|
kIdTilestored, //!< Instruction 'tilestored' {AMX_TILE} (X64).
|
|
kIdTilezero, //!< Instruction 'tilezero' {AMX_TILE} (X64).
|
|
kIdTpause, //!< Instruction 'tpause' {WAITPKG}.
|
|
kIdTzcnt, //!< Instruction 'tzcnt' {BMI}.
|
|
kIdTzmsk, //!< Instruction 'tzmsk' {TBM}.
|
|
kIdUcomisd, //!< Instruction 'ucomisd' {SSE2}.
|
|
kIdUcomiss, //!< Instruction 'ucomiss' {SSE}.
|
|
kIdUd0, //!< Instruction 'ud0'.
|
|
kIdUd1, //!< Instruction 'ud1'.
|
|
kIdUd2, //!< Instruction 'ud2'.
|
|
kIdUiret, //!< Instruction 'uiret' {UINTR} (X64).
|
|
kIdUmonitor, //!< Instruction 'umonitor' {WAITPKG}.
|
|
kIdUmwait, //!< Instruction 'umwait' {WAITPKG}.
|
|
kIdUnpckhpd, //!< Instruction 'unpckhpd' {SSE2}.
|
|
kIdUnpckhps, //!< Instruction 'unpckhps' {SSE}.
|
|
kIdUnpcklpd, //!< Instruction 'unpcklpd' {SSE2}.
|
|
kIdUnpcklps, //!< Instruction 'unpcklps' {SSE}.
|
|
kIdV4fmaddps, //!< Instruction 'v4fmaddps' {AVX512_4FMAPS}.
|
|
kIdV4fmaddss, //!< Instruction 'v4fmaddss' {AVX512_4FMAPS}.
|
|
kIdV4fnmaddps, //!< Instruction 'v4fnmaddps' {AVX512_4FMAPS}.
|
|
kIdV4fnmaddss, //!< Instruction 'v4fnmaddss' {AVX512_4FMAPS}.
|
|
kIdVaddpd, //!< Instruction 'vaddpd' {AVX|AVX512_F+VL}.
|
|
kIdVaddph, //!< Instruction 'vaddph' {AVX512_FP16+VL}.
|
|
kIdVaddps, //!< Instruction 'vaddps' {AVX|AVX512_F+VL}.
|
|
kIdVaddsd, //!< Instruction 'vaddsd' {AVX|AVX512_F}.
|
|
kIdVaddsh, //!< Instruction 'vaddsh' {AVX512_FP16}.
|
|
kIdVaddss, //!< Instruction 'vaddss' {AVX|AVX512_F}.
|
|
kIdVaddsubpd, //!< Instruction 'vaddsubpd' {AVX}.
|
|
kIdVaddsubps, //!< Instruction 'vaddsubps' {AVX}.
|
|
kIdVaesdec, //!< Instruction 'vaesdec' {AVX|AVX512_F+VL & AESNI|VAES}.
|
|
kIdVaesdeclast, //!< Instruction 'vaesdeclast' {AVX|AVX512_F+VL & AESNI|VAES}.
|
|
kIdVaesenc, //!< Instruction 'vaesenc' {AVX|AVX512_F+VL & AESNI|VAES}.
|
|
kIdVaesenclast, //!< Instruction 'vaesenclast' {AVX|AVX512_F+VL & AESNI|VAES}.
|
|
kIdVaesimc, //!< Instruction 'vaesimc' {AVX & AESNI}.
|
|
kIdVaeskeygenassist, //!< Instruction 'vaeskeygenassist' {AVX & AESNI}.
|
|
kIdValignd, //!< Instruction 'valignd' {AVX512_F+VL}.
|
|
kIdValignq, //!< Instruction 'valignq' {AVX512_F+VL}.
|
|
kIdVandnpd, //!< Instruction 'vandnpd' {AVX|AVX512_DQ+VL}.
|
|
kIdVandnps, //!< Instruction 'vandnps' {AVX|AVX512_DQ+VL}.
|
|
kIdVandpd, //!< Instruction 'vandpd' {AVX|AVX512_DQ+VL}.
|
|
kIdVandps, //!< Instruction 'vandps' {AVX|AVX512_DQ+VL}.
|
|
kIdVblendmpd, //!< Instruction 'vblendmpd' {AVX512_F+VL}.
|
|
kIdVblendmps, //!< Instruction 'vblendmps' {AVX512_F+VL}.
|
|
kIdVblendpd, //!< Instruction 'vblendpd' {AVX}.
|
|
kIdVblendps, //!< Instruction 'vblendps' {AVX}.
|
|
kIdVblendvpd, //!< Instruction 'vblendvpd' {AVX}.
|
|
kIdVblendvps, //!< Instruction 'vblendvps' {AVX}.
|
|
kIdVbroadcastf128, //!< Instruction 'vbroadcastf128' {AVX}.
|
|
kIdVbroadcastf32x2, //!< Instruction 'vbroadcastf32x2' {AVX512_DQ+VL}.
|
|
kIdVbroadcastf32x4, //!< Instruction 'vbroadcastf32x4' {AVX512_F}.
|
|
kIdVbroadcastf32x8, //!< Instruction 'vbroadcastf32x8' {AVX512_DQ}.
|
|
kIdVbroadcastf64x2, //!< Instruction 'vbroadcastf64x2' {AVX512_DQ+VL}.
|
|
kIdVbroadcastf64x4, //!< Instruction 'vbroadcastf64x4' {AVX512_F}.
|
|
kIdVbroadcasti128, //!< Instruction 'vbroadcasti128' {AVX2}.
|
|
kIdVbroadcasti32x2, //!< Instruction 'vbroadcasti32x2' {AVX512_DQ+VL}.
|
|
kIdVbroadcasti32x4, //!< Instruction 'vbroadcasti32x4' {AVX512_F+VL}.
|
|
kIdVbroadcasti32x8, //!< Instruction 'vbroadcasti32x8' {AVX512_DQ}.
|
|
kIdVbroadcasti64x2, //!< Instruction 'vbroadcasti64x2' {AVX512_DQ+VL}.
|
|
kIdVbroadcasti64x4, //!< Instruction 'vbroadcasti64x4' {AVX512_F}.
|
|
kIdVbroadcastsd, //!< Instruction 'vbroadcastsd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVbroadcastss, //!< Instruction 'vbroadcastss' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVcmppd, //!< Instruction 'vcmppd' {AVX|AVX512_F+VL}.
|
|
kIdVcmpph, //!< Instruction 'vcmpph' {AVX512_FP16+VL}.
|
|
kIdVcmpps, //!< Instruction 'vcmpps' {AVX|AVX512_F+VL}.
|
|
kIdVcmpsd, //!< Instruction 'vcmpsd' {AVX|AVX512_F}.
|
|
kIdVcmpsh, //!< Instruction 'vcmpsh' {AVX512_FP16}.
|
|
kIdVcmpss, //!< Instruction 'vcmpss' {AVX|AVX512_F}.
|
|
kIdVcomisd, //!< Instruction 'vcomisd' {AVX|AVX512_F}.
|
|
kIdVcomish, //!< Instruction 'vcomish' {AVX512_FP16}.
|
|
kIdVcomiss, //!< Instruction 'vcomiss' {AVX|AVX512_F}.
|
|
kIdVcompresspd, //!< Instruction 'vcompresspd' {AVX512_F+VL}.
|
|
kIdVcompressps, //!< Instruction 'vcompressps' {AVX512_F+VL}.
|
|
kIdVcvtdq2pd, //!< Instruction 'vcvtdq2pd' {AVX|AVX512_F+VL}.
|
|
kIdVcvtdq2ph, //!< Instruction 'vcvtdq2ph' {AVX512_FP16+VL}.
|
|
kIdVcvtdq2ps, //!< Instruction 'vcvtdq2ps' {AVX|AVX512_F+VL}.
|
|
kIdVcvtne2ps2bf16, //!< Instruction 'vcvtne2ps2bf16' {AVX512_BF16+VL}.
|
|
kIdVcvtneps2bf16, //!< Instruction 'vcvtneps2bf16' {AVX512_BF16+VL}.
|
|
kIdVcvtpd2dq, //!< Instruction 'vcvtpd2dq' {AVX|AVX512_F+VL}.
|
|
kIdVcvtpd2ph, //!< Instruction 'vcvtpd2ph' {AVX512_FP16+VL}.
|
|
kIdVcvtpd2ps, //!< Instruction 'vcvtpd2ps' {AVX|AVX512_F+VL}.
|
|
kIdVcvtpd2qq, //!< Instruction 'vcvtpd2qq' {AVX512_DQ+VL}.
|
|
kIdVcvtpd2udq, //!< Instruction 'vcvtpd2udq' {AVX512_F+VL}.
|
|
kIdVcvtpd2uqq, //!< Instruction 'vcvtpd2uqq' {AVX512_DQ+VL}.
|
|
kIdVcvtph2dq, //!< Instruction 'vcvtph2dq' {AVX512_FP16+VL}.
|
|
kIdVcvtph2pd, //!< Instruction 'vcvtph2pd' {AVX512_FP16+VL}.
|
|
kIdVcvtph2ps, //!< Instruction 'vcvtph2ps' {AVX512_F+VL & F16C}.
|
|
kIdVcvtph2psx, //!< Instruction 'vcvtph2psx' {AVX512_FP16+VL}.
|
|
kIdVcvtph2qq, //!< Instruction 'vcvtph2qq' {AVX512_FP16+VL}.
|
|
kIdVcvtph2udq, //!< Instruction 'vcvtph2udq' {AVX512_FP16+VL}.
|
|
kIdVcvtph2uqq, //!< Instruction 'vcvtph2uqq' {AVX512_FP16+VL}.
|
|
kIdVcvtph2uw, //!< Instruction 'vcvtph2uw' {AVX512_FP16+VL}.
|
|
kIdVcvtph2w, //!< Instruction 'vcvtph2w' {AVX512_FP16+VL}.
|
|
kIdVcvtps2dq, //!< Instruction 'vcvtps2dq' {AVX|AVX512_F+VL}.
|
|
kIdVcvtps2pd, //!< Instruction 'vcvtps2pd' {AVX|AVX512_F+VL}.
|
|
kIdVcvtps2ph, //!< Instruction 'vcvtps2ph' {AVX512_F+VL & F16C}.
|
|
kIdVcvtps2phx, //!< Instruction 'vcvtps2phx' {AVX512_FP16+VL}.
|
|
kIdVcvtps2qq, //!< Instruction 'vcvtps2qq' {AVX512_DQ+VL}.
|
|
kIdVcvtps2udq, //!< Instruction 'vcvtps2udq' {AVX512_F+VL}.
|
|
kIdVcvtps2uqq, //!< Instruction 'vcvtps2uqq' {AVX512_DQ+VL}.
|
|
kIdVcvtqq2pd, //!< Instruction 'vcvtqq2pd' {AVX512_DQ+VL}.
|
|
kIdVcvtqq2ph, //!< Instruction 'vcvtqq2ph' {AVX512_FP16+VL}.
|
|
kIdVcvtqq2ps, //!< Instruction 'vcvtqq2ps' {AVX512_DQ+VL}.
|
|
kIdVcvtsd2sh, //!< Instruction 'vcvtsd2sh' {AVX512_FP16}.
|
|
kIdVcvtsd2si, //!< Instruction 'vcvtsd2si' {AVX|AVX512_F}.
|
|
kIdVcvtsd2ss, //!< Instruction 'vcvtsd2ss' {AVX|AVX512_F}.
|
|
kIdVcvtsd2usi, //!< Instruction 'vcvtsd2usi' {AVX512_F}.
|
|
kIdVcvtsh2sd, //!< Instruction 'vcvtsh2sd' {AVX512_FP16}.
|
|
kIdVcvtsh2si, //!< Instruction 'vcvtsh2si' {AVX512_FP16}.
|
|
kIdVcvtsh2ss, //!< Instruction 'vcvtsh2ss' {AVX512_FP16}.
|
|
kIdVcvtsh2usi, //!< Instruction 'vcvtsh2usi' {AVX512_FP16}.
|
|
kIdVcvtsi2sd, //!< Instruction 'vcvtsi2sd' {AVX|AVX512_F}.
|
|
kIdVcvtsi2sh, //!< Instruction 'vcvtsi2sh' {AVX512_FP16}.
|
|
kIdVcvtsi2ss, //!< Instruction 'vcvtsi2ss' {AVX|AVX512_F}.
|
|
kIdVcvtss2sd, //!< Instruction 'vcvtss2sd' {AVX|AVX512_F}.
|
|
kIdVcvtss2sh, //!< Instruction 'vcvtss2sh' {AVX512_FP16}.
|
|
kIdVcvtss2si, //!< Instruction 'vcvtss2si' {AVX|AVX512_F}.
|
|
kIdVcvtss2usi, //!< Instruction 'vcvtss2usi' {AVX512_F}.
|
|
kIdVcvttpd2dq, //!< Instruction 'vcvttpd2dq' {AVX|AVX512_F+VL}.
|
|
kIdVcvttpd2qq, //!< Instruction 'vcvttpd2qq' {AVX512_F+VL}.
|
|
kIdVcvttpd2udq, //!< Instruction 'vcvttpd2udq' {AVX512_F+VL}.
|
|
kIdVcvttpd2uqq, //!< Instruction 'vcvttpd2uqq' {AVX512_DQ+VL}.
|
|
kIdVcvttph2dq, //!< Instruction 'vcvttph2dq' {AVX512_FP16+VL}.
|
|
kIdVcvttph2qq, //!< Instruction 'vcvttph2qq' {AVX512_FP16+VL}.
|
|
kIdVcvttph2udq, //!< Instruction 'vcvttph2udq' {AVX512_FP16+VL}.
|
|
kIdVcvttph2uqq, //!< Instruction 'vcvttph2uqq' {AVX512_FP16+VL}.
|
|
kIdVcvttph2uw, //!< Instruction 'vcvttph2uw' {AVX512_FP16+VL}.
|
|
kIdVcvttph2w, //!< Instruction 'vcvttph2w' {AVX512_FP16+VL}.
|
|
kIdVcvttps2dq, //!< Instruction 'vcvttps2dq' {AVX|AVX512_F+VL}.
|
|
kIdVcvttps2qq, //!< Instruction 'vcvttps2qq' {AVX512_DQ+VL}.
|
|
kIdVcvttps2udq, //!< Instruction 'vcvttps2udq' {AVX512_F+VL}.
|
|
kIdVcvttps2uqq, //!< Instruction 'vcvttps2uqq' {AVX512_DQ+VL}.
|
|
kIdVcvttsd2si, //!< Instruction 'vcvttsd2si' {AVX|AVX512_F}.
|
|
kIdVcvttsd2usi, //!< Instruction 'vcvttsd2usi' {AVX512_F}.
|
|
kIdVcvttsh2si, //!< Instruction 'vcvttsh2si' {AVX512_FP16}.
|
|
kIdVcvttsh2usi, //!< Instruction 'vcvttsh2usi' {AVX512_FP16}.
|
|
kIdVcvttss2si, //!< Instruction 'vcvttss2si' {AVX|AVX512_F}.
|
|
kIdVcvttss2usi, //!< Instruction 'vcvttss2usi' {AVX512_F}.
|
|
kIdVcvtudq2pd, //!< Instruction 'vcvtudq2pd' {AVX512_F+VL}.
|
|
kIdVcvtudq2ph, //!< Instruction 'vcvtudq2ph' {AVX512_FP16+VL}.
|
|
kIdVcvtudq2ps, //!< Instruction 'vcvtudq2ps' {AVX512_F+VL}.
|
|
kIdVcvtuqq2pd, //!< Instruction 'vcvtuqq2pd' {AVX512_DQ+VL}.
|
|
kIdVcvtuqq2ph, //!< Instruction 'vcvtuqq2ph' {AVX512_FP16+VL}.
|
|
kIdVcvtuqq2ps, //!< Instruction 'vcvtuqq2ps' {AVX512_DQ+VL}.
|
|
kIdVcvtusi2sd, //!< Instruction 'vcvtusi2sd' {AVX512_F}.
|
|
kIdVcvtusi2sh, //!< Instruction 'vcvtusi2sh' {AVX512_FP16}.
|
|
kIdVcvtusi2ss, //!< Instruction 'vcvtusi2ss' {AVX512_F}.
|
|
kIdVcvtuw2ph, //!< Instruction 'vcvtuw2ph' {AVX512_FP16+VL}.
|
|
kIdVcvtw2ph, //!< Instruction 'vcvtw2ph' {AVX512_FP16+VL}.
|
|
kIdVdbpsadbw, //!< Instruction 'vdbpsadbw' {AVX512_BW+VL}.
|
|
kIdVdivpd, //!< Instruction 'vdivpd' {AVX|AVX512_F+VL}.
|
|
kIdVdivph, //!< Instruction 'vdivph' {AVX512_FP16+VL}.
|
|
kIdVdivps, //!< Instruction 'vdivps' {AVX|AVX512_F+VL}.
|
|
kIdVdivsd, //!< Instruction 'vdivsd' {AVX|AVX512_F}.
|
|
kIdVdivsh, //!< Instruction 'vdivsh' {AVX512_FP16}.
|
|
kIdVdivss, //!< Instruction 'vdivss' {AVX|AVX512_F}.
|
|
kIdVdpbf16ps, //!< Instruction 'vdpbf16ps' {AVX512_BF16+VL}.
|
|
kIdVdppd, //!< Instruction 'vdppd' {AVX}.
|
|
kIdVdpps, //!< Instruction 'vdpps' {AVX}.
|
|
kIdVerr, //!< Instruction 'verr'.
|
|
kIdVerw, //!< Instruction 'verw'.
|
|
kIdVexp2pd, //!< Instruction 'vexp2pd' {AVX512_ERI}.
|
|
kIdVexp2ps, //!< Instruction 'vexp2ps' {AVX512_ERI}.
|
|
kIdVexpandpd, //!< Instruction 'vexpandpd' {AVX512_F+VL}.
|
|
kIdVexpandps, //!< Instruction 'vexpandps' {AVX512_F+VL}.
|
|
kIdVextractf128, //!< Instruction 'vextractf128' {AVX}.
|
|
kIdVextractf32x4, //!< Instruction 'vextractf32x4' {AVX512_F+VL}.
|
|
kIdVextractf32x8, //!< Instruction 'vextractf32x8' {AVX512_DQ}.
|
|
kIdVextractf64x2, //!< Instruction 'vextractf64x2' {AVX512_DQ+VL}.
|
|
kIdVextractf64x4, //!< Instruction 'vextractf64x4' {AVX512_F}.
|
|
kIdVextracti128, //!< Instruction 'vextracti128' {AVX2}.
|
|
kIdVextracti32x4, //!< Instruction 'vextracti32x4' {AVX512_F+VL}.
|
|
kIdVextracti32x8, //!< Instruction 'vextracti32x8' {AVX512_DQ}.
|
|
kIdVextracti64x2, //!< Instruction 'vextracti64x2' {AVX512_DQ+VL}.
|
|
kIdVextracti64x4, //!< Instruction 'vextracti64x4' {AVX512_F}.
|
|
kIdVextractps, //!< Instruction 'vextractps' {AVX|AVX512_F}.
|
|
kIdVfcmaddcph, //!< Instruction 'vfcmaddcph' {AVX512_FP16+VL}.
|
|
kIdVfcmaddcsh, //!< Instruction 'vfcmaddcsh' {AVX512_FP16+VL}.
|
|
kIdVfcmulcph, //!< Instruction 'vfcmulcph' {AVX512_FP16+VL}.
|
|
kIdVfcmulcsh, //!< Instruction 'vfcmulcsh' {AVX512_FP16+VL}.
|
|
kIdVfixupimmpd, //!< Instruction 'vfixupimmpd' {AVX512_F+VL}.
|
|
kIdVfixupimmps, //!< Instruction 'vfixupimmps' {AVX512_F+VL}.
|
|
kIdVfixupimmsd, //!< Instruction 'vfixupimmsd' {AVX512_F}.
|
|
kIdVfixupimmss, //!< Instruction 'vfixupimmss' {AVX512_F}.
|
|
kIdVfmadd132pd, //!< Instruction 'vfmadd132pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmadd132ph, //!< Instruction 'vfmadd132ph' {AVX512_FP16+VL}.
|
|
kIdVfmadd132ps, //!< Instruction 'vfmadd132ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmadd132sd, //!< Instruction 'vfmadd132sd' {FMA|AVX512_F}.
|
|
kIdVfmadd132sh, //!< Instruction 'vfmadd132sh' {AVX512_FP16}.
|
|
kIdVfmadd132ss, //!< Instruction 'vfmadd132ss' {FMA|AVX512_F}.
|
|
kIdVfmadd213pd, //!< Instruction 'vfmadd213pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmadd213ph, //!< Instruction 'vfmadd213ph' {AVX512_FP16+VL}.
|
|
kIdVfmadd213ps, //!< Instruction 'vfmadd213ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmadd213sd, //!< Instruction 'vfmadd213sd' {FMA|AVX512_F}.
|
|
kIdVfmadd213sh, //!< Instruction 'vfmadd213sh' {AVX512_FP16}.
|
|
kIdVfmadd213ss, //!< Instruction 'vfmadd213ss' {FMA|AVX512_F}.
|
|
kIdVfmadd231pd, //!< Instruction 'vfmadd231pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmadd231ph, //!< Instruction 'vfmadd231ph' {AVX512_FP16+VL}.
|
|
kIdVfmadd231ps, //!< Instruction 'vfmadd231ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmadd231sd, //!< Instruction 'vfmadd231sd' {FMA|AVX512_F}.
|
|
kIdVfmadd231sh, //!< Instruction 'vfmadd231sh' {AVX512_FP16}.
|
|
kIdVfmadd231ss, //!< Instruction 'vfmadd231ss' {FMA|AVX512_F}.
|
|
kIdVfmaddcph, //!< Instruction 'vfmaddcph' {AVX512_FP16+VL}.
|
|
kIdVfmaddcsh, //!< Instruction 'vfmaddcsh' {AVX512_FP16+VL}.
|
|
kIdVfmaddpd, //!< Instruction 'vfmaddpd' {FMA4}.
|
|
kIdVfmaddps, //!< Instruction 'vfmaddps' {FMA4}.
|
|
kIdVfmaddsd, //!< Instruction 'vfmaddsd' {FMA4}.
|
|
kIdVfmaddss, //!< Instruction 'vfmaddss' {FMA4}.
|
|
kIdVfmaddsub132pd, //!< Instruction 'vfmaddsub132pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmaddsub132ph, //!< Instruction 'vfmaddsub132ph' {AVX512_FP16+VL}.
|
|
kIdVfmaddsub132ps, //!< Instruction 'vfmaddsub132ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmaddsub213pd, //!< Instruction 'vfmaddsub213pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmaddsub213ph, //!< Instruction 'vfmaddsub213ph' {AVX512_FP16+VL}.
|
|
kIdVfmaddsub213ps, //!< Instruction 'vfmaddsub213ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmaddsub231pd, //!< Instruction 'vfmaddsub231pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmaddsub231ph, //!< Instruction 'vfmaddsub231ph' {AVX512_FP16+VL}.
|
|
kIdVfmaddsub231ps, //!< Instruction 'vfmaddsub231ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmaddsubpd, //!< Instruction 'vfmaddsubpd' {FMA4}.
|
|
kIdVfmaddsubps, //!< Instruction 'vfmaddsubps' {FMA4}.
|
|
kIdVfmsub132pd, //!< Instruction 'vfmsub132pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmsub132ph, //!< Instruction 'vfmsub132ph' {AVX512_FP16+VL}.
|
|
kIdVfmsub132ps, //!< Instruction 'vfmsub132ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmsub132sd, //!< Instruction 'vfmsub132sd' {FMA|AVX512_F}.
|
|
kIdVfmsub132sh, //!< Instruction 'vfmsub132sh' {AVX512_FP16}.
|
|
kIdVfmsub132ss, //!< Instruction 'vfmsub132ss' {FMA|AVX512_F}.
|
|
kIdVfmsub213pd, //!< Instruction 'vfmsub213pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmsub213ph, //!< Instruction 'vfmsub213ph' {AVX512_FP16+VL}.
|
|
kIdVfmsub213ps, //!< Instruction 'vfmsub213ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmsub213sd, //!< Instruction 'vfmsub213sd' {FMA|AVX512_F}.
|
|
kIdVfmsub213sh, //!< Instruction 'vfmsub213sh' {AVX512_FP16}.
|
|
kIdVfmsub213ss, //!< Instruction 'vfmsub213ss' {FMA|AVX512_F}.
|
|
kIdVfmsub231pd, //!< Instruction 'vfmsub231pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmsub231ph, //!< Instruction 'vfmsub231ph' {AVX512_FP16+VL}.
|
|
kIdVfmsub231ps, //!< Instruction 'vfmsub231ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmsub231sd, //!< Instruction 'vfmsub231sd' {FMA|AVX512_F}.
|
|
kIdVfmsub231sh, //!< Instruction 'vfmsub231sh' {AVX512_FP16}.
|
|
kIdVfmsub231ss, //!< Instruction 'vfmsub231ss' {FMA|AVX512_F}.
|
|
kIdVfmsubadd132pd, //!< Instruction 'vfmsubadd132pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmsubadd132ph, //!< Instruction 'vfmsubadd132ph' {AVX512_FP16+VL}.
|
|
kIdVfmsubadd132ps, //!< Instruction 'vfmsubadd132ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmsubadd213pd, //!< Instruction 'vfmsubadd213pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmsubadd213ph, //!< Instruction 'vfmsubadd213ph' {AVX512_FP16+VL}.
|
|
kIdVfmsubadd213ps, //!< Instruction 'vfmsubadd213ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmsubadd231pd, //!< Instruction 'vfmsubadd231pd' {FMA|AVX512_F+VL}.
|
|
kIdVfmsubadd231ph, //!< Instruction 'vfmsubadd231ph' {AVX512_FP16+VL}.
|
|
kIdVfmsubadd231ps, //!< Instruction 'vfmsubadd231ps' {FMA|AVX512_F+VL}.
|
|
kIdVfmsubaddpd, //!< Instruction 'vfmsubaddpd' {FMA4}.
|
|
kIdVfmsubaddps, //!< Instruction 'vfmsubaddps' {FMA4}.
|
|
kIdVfmsubpd, //!< Instruction 'vfmsubpd' {FMA4}.
|
|
kIdVfmsubps, //!< Instruction 'vfmsubps' {FMA4}.
|
|
kIdVfmsubsd, //!< Instruction 'vfmsubsd' {FMA4}.
|
|
kIdVfmsubss, //!< Instruction 'vfmsubss' {FMA4}.
|
|
kIdVfmulcph, //!< Instruction 'vfmulcph' {AVX512_FP16+VL}.
|
|
kIdVfmulcsh, //!< Instruction 'vfmulcsh' {AVX512_FP16+VL}.
|
|
kIdVfnmadd132pd, //!< Instruction 'vfnmadd132pd' {FMA|AVX512_F+VL}.
|
|
kIdVfnmadd132ph, //!< Instruction 'vfnmadd132ph' {AVX512_FP16+VL}.
|
|
kIdVfnmadd132ps, //!< Instruction 'vfnmadd132ps' {FMA|AVX512_F+VL}.
|
|
kIdVfnmadd132sd, //!< Instruction 'vfnmadd132sd' {FMA|AVX512_F}.
|
|
kIdVfnmadd132sh, //!< Instruction 'vfnmadd132sh' {AVX512_FP16}.
|
|
kIdVfnmadd132ss, //!< Instruction 'vfnmadd132ss' {FMA|AVX512_F}.
|
|
kIdVfnmadd213pd, //!< Instruction 'vfnmadd213pd' {FMA|AVX512_F+VL}.
|
|
kIdVfnmadd213ph, //!< Instruction 'vfnmadd213ph' {AVX512_FP16+VL}.
|
|
kIdVfnmadd213ps, //!< Instruction 'vfnmadd213ps' {FMA|AVX512_F+VL}.
|
|
kIdVfnmadd213sd, //!< Instruction 'vfnmadd213sd' {FMA|AVX512_F}.
|
|
kIdVfnmadd213sh, //!< Instruction 'vfnmadd213sh' {AVX512_FP16}.
|
|
kIdVfnmadd213ss, //!< Instruction 'vfnmadd213ss' {FMA|AVX512_F}.
|
|
kIdVfnmadd231pd, //!< Instruction 'vfnmadd231pd' {FMA|AVX512_F+VL}.
|
|
kIdVfnmadd231ph, //!< Instruction 'vfnmadd231ph' {AVX512_FP16+VL}.
|
|
kIdVfnmadd231ps, //!< Instruction 'vfnmadd231ps' {FMA|AVX512_F+VL}.
|
|
kIdVfnmadd231sd, //!< Instruction 'vfnmadd231sd' {FMA|AVX512_F}.
|
|
kIdVfnmadd231sh, //!< Instruction 'vfnmadd231sh' {AVX512_FP16}.
|
|
kIdVfnmadd231ss, //!< Instruction 'vfnmadd231ss' {FMA|AVX512_F}.
|
|
kIdVfnmaddpd, //!< Instruction 'vfnmaddpd' {FMA4}.
|
|
kIdVfnmaddps, //!< Instruction 'vfnmaddps' {FMA4}.
|
|
kIdVfnmaddsd, //!< Instruction 'vfnmaddsd' {FMA4}.
|
|
kIdVfnmaddss, //!< Instruction 'vfnmaddss' {FMA4}.
|
|
kIdVfnmsub132pd, //!< Instruction 'vfnmsub132pd' {FMA|AVX512_F+VL}.
|
|
kIdVfnmsub132ph, //!< Instruction 'vfnmsub132ph' {AVX512_FP16+VL}.
|
|
kIdVfnmsub132ps, //!< Instruction 'vfnmsub132ps' {FMA|AVX512_F+VL}.
|
|
kIdVfnmsub132sd, //!< Instruction 'vfnmsub132sd' {FMA|AVX512_F}.
|
|
kIdVfnmsub132sh, //!< Instruction 'vfnmsub132sh' {AVX512_FP16}.
|
|
kIdVfnmsub132ss, //!< Instruction 'vfnmsub132ss' {FMA|AVX512_F}.
|
|
kIdVfnmsub213pd, //!< Instruction 'vfnmsub213pd' {FMA|AVX512_F+VL}.
|
|
kIdVfnmsub213ph, //!< Instruction 'vfnmsub213ph' {AVX512_FP16+VL}.
|
|
kIdVfnmsub213ps, //!< Instruction 'vfnmsub213ps' {FMA|AVX512_F+VL}.
|
|
kIdVfnmsub213sd, //!< Instruction 'vfnmsub213sd' {FMA|AVX512_F}.
|
|
kIdVfnmsub213sh, //!< Instruction 'vfnmsub213sh' {AVX512_FP16}.
|
|
kIdVfnmsub213ss, //!< Instruction 'vfnmsub213ss' {FMA|AVX512_F}.
|
|
kIdVfnmsub231pd, //!< Instruction 'vfnmsub231pd' {FMA|AVX512_F+VL}.
|
|
kIdVfnmsub231ph, //!< Instruction 'vfnmsub231ph' {AVX512_FP16+VL}.
|
|
kIdVfnmsub231ps, //!< Instruction 'vfnmsub231ps' {FMA|AVX512_F+VL}.
|
|
kIdVfnmsub231sd, //!< Instruction 'vfnmsub231sd' {FMA|AVX512_F}.
|
|
kIdVfnmsub231sh, //!< Instruction 'vfnmsub231sh' {AVX512_FP16}.
|
|
kIdVfnmsub231ss, //!< Instruction 'vfnmsub231ss' {FMA|AVX512_F}.
|
|
kIdVfnmsubpd, //!< Instruction 'vfnmsubpd' {FMA4}.
|
|
kIdVfnmsubps, //!< Instruction 'vfnmsubps' {FMA4}.
|
|
kIdVfnmsubsd, //!< Instruction 'vfnmsubsd' {FMA4}.
|
|
kIdVfnmsubss, //!< Instruction 'vfnmsubss' {FMA4}.
|
|
kIdVfpclasspd, //!< Instruction 'vfpclasspd' {AVX512_DQ+VL}.
|
|
kIdVfpclassph, //!< Instruction 'vfpclassph' {AVX512_FP16+VL}.
|
|
kIdVfpclassps, //!< Instruction 'vfpclassps' {AVX512_DQ+VL}.
|
|
kIdVfpclasssd, //!< Instruction 'vfpclasssd' {AVX512_DQ}.
|
|
kIdVfpclasssh, //!< Instruction 'vfpclasssh' {AVX512_FP16}.
|
|
kIdVfpclassss, //!< Instruction 'vfpclassss' {AVX512_DQ}.
|
|
kIdVfrczpd, //!< Instruction 'vfrczpd' {XOP}.
|
|
kIdVfrczps, //!< Instruction 'vfrczps' {XOP}.
|
|
kIdVfrczsd, //!< Instruction 'vfrczsd' {XOP}.
|
|
kIdVfrczss, //!< Instruction 'vfrczss' {XOP}.
|
|
kIdVgatherdpd, //!< Instruction 'vgatherdpd' {AVX2|AVX512_F+VL}.
|
|
kIdVgatherdps, //!< Instruction 'vgatherdps' {AVX2|AVX512_F+VL}.
|
|
kIdVgatherpf0dpd, //!< Instruction 'vgatherpf0dpd' {AVX512_PFI}.
|
|
kIdVgatherpf0dps, //!< Instruction 'vgatherpf0dps' {AVX512_PFI}.
|
|
kIdVgatherpf0qpd, //!< Instruction 'vgatherpf0qpd' {AVX512_PFI}.
|
|
kIdVgatherpf0qps, //!< Instruction 'vgatherpf0qps' {AVX512_PFI}.
|
|
kIdVgatherpf1dpd, //!< Instruction 'vgatherpf1dpd' {AVX512_PFI}.
|
|
kIdVgatherpf1dps, //!< Instruction 'vgatherpf1dps' {AVX512_PFI}.
|
|
kIdVgatherpf1qpd, //!< Instruction 'vgatherpf1qpd' {AVX512_PFI}.
|
|
kIdVgatherpf1qps, //!< Instruction 'vgatherpf1qps' {AVX512_PFI}.
|
|
kIdVgatherqpd, //!< Instruction 'vgatherqpd' {AVX2|AVX512_F+VL}.
|
|
kIdVgatherqps, //!< Instruction 'vgatherqps' {AVX2|AVX512_F+VL}.
|
|
kIdVgetexppd, //!< Instruction 'vgetexppd' {AVX512_F+VL}.
|
|
kIdVgetexpph, //!< Instruction 'vgetexpph' {AVX512_FP16+VL}.
|
|
kIdVgetexpps, //!< Instruction 'vgetexpps' {AVX512_F+VL}.
|
|
kIdVgetexpsd, //!< Instruction 'vgetexpsd' {AVX512_F}.
|
|
kIdVgetexpsh, //!< Instruction 'vgetexpsh' {AVX512_FP16}.
|
|
kIdVgetexpss, //!< Instruction 'vgetexpss' {AVX512_F}.
|
|
kIdVgetmantpd, //!< Instruction 'vgetmantpd' {AVX512_F+VL}.
|
|
kIdVgetmantph, //!< Instruction 'vgetmantph' {AVX512_FP16+VL}.
|
|
kIdVgetmantps, //!< Instruction 'vgetmantps' {AVX512_F+VL}.
|
|
kIdVgetmantsd, //!< Instruction 'vgetmantsd' {AVX512_F}.
|
|
kIdVgetmantsh, //!< Instruction 'vgetmantsh' {AVX512_FP16}.
|
|
kIdVgetmantss, //!< Instruction 'vgetmantss' {AVX512_F}.
|
|
kIdVgf2p8affineinvqb, //!< Instruction 'vgf2p8affineinvqb' {AVX|AVX512_F+VL & GFNI}.
|
|
kIdVgf2p8affineqb, //!< Instruction 'vgf2p8affineqb' {AVX|AVX512_F+VL & GFNI}.
|
|
kIdVgf2p8mulb, //!< Instruction 'vgf2p8mulb' {AVX|AVX512_F+VL & GFNI}.
|
|
kIdVhaddpd, //!< Instruction 'vhaddpd' {AVX}.
|
|
kIdVhaddps, //!< Instruction 'vhaddps' {AVX}.
|
|
kIdVhsubpd, //!< Instruction 'vhsubpd' {AVX}.
|
|
kIdVhsubps, //!< Instruction 'vhsubps' {AVX}.
|
|
kIdVinsertf128, //!< Instruction 'vinsertf128' {AVX}.
|
|
kIdVinsertf32x4, //!< Instruction 'vinsertf32x4' {AVX512_F+VL}.
|
|
kIdVinsertf32x8, //!< Instruction 'vinsertf32x8' {AVX512_DQ}.
|
|
kIdVinsertf64x2, //!< Instruction 'vinsertf64x2' {AVX512_DQ+VL}.
|
|
kIdVinsertf64x4, //!< Instruction 'vinsertf64x4' {AVX512_F}.
|
|
kIdVinserti128, //!< Instruction 'vinserti128' {AVX2}.
|
|
kIdVinserti32x4, //!< Instruction 'vinserti32x4' {AVX512_F+VL}.
|
|
kIdVinserti32x8, //!< Instruction 'vinserti32x8' {AVX512_DQ}.
|
|
kIdVinserti64x2, //!< Instruction 'vinserti64x2' {AVX512_DQ+VL}.
|
|
kIdVinserti64x4, //!< Instruction 'vinserti64x4' {AVX512_F}.
|
|
kIdVinsertps, //!< Instruction 'vinsertps' {AVX|AVX512_F}.
|
|
kIdVlddqu, //!< Instruction 'vlddqu' {AVX}.
|
|
kIdVldmxcsr, //!< Instruction 'vldmxcsr' {AVX}.
|
|
kIdVmaskmovdqu, //!< Instruction 'vmaskmovdqu' {AVX}.
|
|
kIdVmaskmovpd, //!< Instruction 'vmaskmovpd' {AVX}.
|
|
kIdVmaskmovps, //!< Instruction 'vmaskmovps' {AVX}.
|
|
kIdVmaxpd, //!< Instruction 'vmaxpd' {AVX|AVX512_F+VL}.
|
|
kIdVmaxph, //!< Instruction 'vmaxph' {AVX512_FP16+VL}.
|
|
kIdVmaxps, //!< Instruction 'vmaxps' {AVX|AVX512_F+VL}.
|
|
kIdVmaxsd, //!< Instruction 'vmaxsd' {AVX|AVX512_F+VL}.
|
|
kIdVmaxsh, //!< Instruction 'vmaxsh' {AVX512_FP16}.
|
|
kIdVmaxss, //!< Instruction 'vmaxss' {AVX|AVX512_F+VL}.
|
|
kIdVmcall, //!< Instruction 'vmcall' {VMX}.
|
|
kIdVmclear, //!< Instruction 'vmclear' {VMX}.
|
|
kIdVmfunc, //!< Instruction 'vmfunc' {VMX}.
|
|
kIdVminpd, //!< Instruction 'vminpd' {AVX|AVX512_F+VL}.
|
|
kIdVminph, //!< Instruction 'vminph' {AVX512_FP16+VL}.
|
|
kIdVminps, //!< Instruction 'vminps' {AVX|AVX512_F+VL}.
|
|
kIdVminsd, //!< Instruction 'vminsd' {AVX|AVX512_F+VL}.
|
|
kIdVminsh, //!< Instruction 'vminsh' {AVX512_FP16}.
|
|
kIdVminss, //!< Instruction 'vminss' {AVX|AVX512_F+VL}.
|
|
kIdVmlaunch, //!< Instruction 'vmlaunch' {VMX}.
|
|
kIdVmload, //!< Instruction 'vmload' {SVM}.
|
|
kIdVmmcall, //!< Instruction 'vmmcall' {SVM}.
|
|
kIdVmovapd, //!< Instruction 'vmovapd' {AVX|AVX512_F+VL}.
|
|
kIdVmovaps, //!< Instruction 'vmovaps' {AVX|AVX512_F+VL}.
|
|
kIdVmovd, //!< Instruction 'vmovd' {AVX|AVX512_F}.
|
|
kIdVmovddup, //!< Instruction 'vmovddup' {AVX|AVX512_F+VL}.
|
|
kIdVmovdqa, //!< Instruction 'vmovdqa' {AVX}.
|
|
kIdVmovdqa32, //!< Instruction 'vmovdqa32' {AVX512_F+VL}.
|
|
kIdVmovdqa64, //!< Instruction 'vmovdqa64' {AVX512_F+VL}.
|
|
kIdVmovdqu, //!< Instruction 'vmovdqu' {AVX}.
|
|
kIdVmovdqu16, //!< Instruction 'vmovdqu16' {AVX512_BW+VL}.
|
|
kIdVmovdqu32, //!< Instruction 'vmovdqu32' {AVX512_F+VL}.
|
|
kIdVmovdqu64, //!< Instruction 'vmovdqu64' {AVX512_F+VL}.
|
|
kIdVmovdqu8, //!< Instruction 'vmovdqu8' {AVX512_BW+VL}.
|
|
kIdVmovhlps, //!< Instruction 'vmovhlps' {AVX|AVX512_F}.
|
|
kIdVmovhpd, //!< Instruction 'vmovhpd' {AVX|AVX512_F}.
|
|
kIdVmovhps, //!< Instruction 'vmovhps' {AVX|AVX512_F}.
|
|
kIdVmovlhps, //!< Instruction 'vmovlhps' {AVX|AVX512_F}.
|
|
kIdVmovlpd, //!< Instruction 'vmovlpd' {AVX|AVX512_F}.
|
|
kIdVmovlps, //!< Instruction 'vmovlps' {AVX|AVX512_F}.
|
|
kIdVmovmskpd, //!< Instruction 'vmovmskpd' {AVX}.
|
|
kIdVmovmskps, //!< Instruction 'vmovmskps' {AVX}.
|
|
kIdVmovntdq, //!< Instruction 'vmovntdq' {AVX|AVX512_F+VL}.
|
|
kIdVmovntdqa, //!< Instruction 'vmovntdqa' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVmovntpd, //!< Instruction 'vmovntpd' {AVX|AVX512_F+VL}.
|
|
kIdVmovntps, //!< Instruction 'vmovntps' {AVX|AVX512_F+VL}.
|
|
kIdVmovq, //!< Instruction 'vmovq' {AVX|AVX512_F}.
|
|
kIdVmovsd, //!< Instruction 'vmovsd' {AVX|AVX512_F}.
|
|
kIdVmovsh, //!< Instruction 'vmovsh' {AVX512_FP16}.
|
|
kIdVmovshdup, //!< Instruction 'vmovshdup' {AVX|AVX512_F+VL}.
|
|
kIdVmovsldup, //!< Instruction 'vmovsldup' {AVX|AVX512_F+VL}.
|
|
kIdVmovss, //!< Instruction 'vmovss' {AVX|AVX512_F}.
|
|
kIdVmovupd, //!< Instruction 'vmovupd' {AVX|AVX512_F+VL}.
|
|
kIdVmovups, //!< Instruction 'vmovups' {AVX|AVX512_F+VL}.
|
|
kIdVmovw, //!< Instruction 'vmovw' {AVX512_FP16}.
|
|
kIdVmpsadbw, //!< Instruction 'vmpsadbw' {AVX|AVX2}.
|
|
kIdVmptrld, //!< Instruction 'vmptrld' {VMX}.
|
|
kIdVmptrst, //!< Instruction 'vmptrst' {VMX}.
|
|
kIdVmread, //!< Instruction 'vmread' {VMX}.
|
|
kIdVmresume, //!< Instruction 'vmresume' {VMX}.
|
|
kIdVmrun, //!< Instruction 'vmrun' {SVM}.
|
|
kIdVmsave, //!< Instruction 'vmsave' {SVM}.
|
|
kIdVmulpd, //!< Instruction 'vmulpd' {AVX|AVX512_F+VL}.
|
|
kIdVmulph, //!< Instruction 'vmulph' {AVX512_FP16+VL}.
|
|
kIdVmulps, //!< Instruction 'vmulps' {AVX|AVX512_F+VL}.
|
|
kIdVmulsd, //!< Instruction 'vmulsd' {AVX|AVX512_F}.
|
|
kIdVmulsh, //!< Instruction 'vmulsh' {AVX512_FP16}.
|
|
kIdVmulss, //!< Instruction 'vmulss' {AVX|AVX512_F}.
|
|
kIdVmwrite, //!< Instruction 'vmwrite' {VMX}.
|
|
kIdVmxon, //!< Instruction 'vmxon' {VMX}.
|
|
kIdVorpd, //!< Instruction 'vorpd' {AVX|AVX512_DQ+VL}.
|
|
kIdVorps, //!< Instruction 'vorps' {AVX|AVX512_DQ+VL}.
|
|
kIdVp2intersectd, //!< Instruction 'vp2intersectd' {AVX512_VP2INTERSECT}.
|
|
kIdVp2intersectq, //!< Instruction 'vp2intersectq' {AVX512_VP2INTERSECT}.
|
|
kIdVp4dpwssd, //!< Instruction 'vp4dpwssd' {AVX512_4VNNIW}.
|
|
kIdVp4dpwssds, //!< Instruction 'vp4dpwssds' {AVX512_4VNNIW}.
|
|
kIdVpabsb, //!< Instruction 'vpabsb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpabsd, //!< Instruction 'vpabsd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpabsq, //!< Instruction 'vpabsq' {AVX512_F+VL}.
|
|
kIdVpabsw, //!< Instruction 'vpabsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpackssdw, //!< Instruction 'vpackssdw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpacksswb, //!< Instruction 'vpacksswb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpackusdw, //!< Instruction 'vpackusdw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpackuswb, //!< Instruction 'vpackuswb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpaddb, //!< Instruction 'vpaddb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpaddd, //!< Instruction 'vpaddd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpaddq, //!< Instruction 'vpaddq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpaddsb, //!< Instruction 'vpaddsb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpaddsw, //!< Instruction 'vpaddsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpaddusb, //!< Instruction 'vpaddusb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpaddusw, //!< Instruction 'vpaddusw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpaddw, //!< Instruction 'vpaddw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpalignr, //!< Instruction 'vpalignr' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpand, //!< Instruction 'vpand' {AVX|AVX2}.
|
|
kIdVpandd, //!< Instruction 'vpandd' {AVX512_F+VL}.
|
|
kIdVpandn, //!< Instruction 'vpandn' {AVX|AVX2}.
|
|
kIdVpandnd, //!< Instruction 'vpandnd' {AVX512_F+VL}.
|
|
kIdVpandnq, //!< Instruction 'vpandnq' {AVX512_F+VL}.
|
|
kIdVpandq, //!< Instruction 'vpandq' {AVX512_F+VL}.
|
|
kIdVpavgb, //!< Instruction 'vpavgb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpavgw, //!< Instruction 'vpavgw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpblendd, //!< Instruction 'vpblendd' {AVX2}.
|
|
kIdVpblendmb, //!< Instruction 'vpblendmb' {AVX512_BW+VL}.
|
|
kIdVpblendmd, //!< Instruction 'vpblendmd' {AVX512_F+VL}.
|
|
kIdVpblendmq, //!< Instruction 'vpblendmq' {AVX512_F+VL}.
|
|
kIdVpblendmw, //!< Instruction 'vpblendmw' {AVX512_BW+VL}.
|
|
kIdVpblendvb, //!< Instruction 'vpblendvb' {AVX|AVX2}.
|
|
kIdVpblendw, //!< Instruction 'vpblendw' {AVX|AVX2}.
|
|
kIdVpbroadcastb, //!< Instruction 'vpbroadcastb' {AVX2|AVX512_BW+VL}.
|
|
kIdVpbroadcastd, //!< Instruction 'vpbroadcastd' {AVX2|AVX512_F+VL}.
|
|
kIdVpbroadcastmb2q, //!< Instruction 'vpbroadcastmb2q' {AVX512_CDI+VL}.
|
|
kIdVpbroadcastmw2d, //!< Instruction 'vpbroadcastmw2d' {AVX512_CDI+VL}.
|
|
kIdVpbroadcastq, //!< Instruction 'vpbroadcastq' {AVX2|AVX512_F+VL}.
|
|
kIdVpbroadcastw, //!< Instruction 'vpbroadcastw' {AVX2|AVX512_BW+VL}.
|
|
kIdVpclmulqdq, //!< Instruction 'vpclmulqdq' {AVX|AVX512_F+VL & PCLMULQDQ|VPCLMULQDQ}.
|
|
kIdVpcmov, //!< Instruction 'vpcmov' {XOP}.
|
|
kIdVpcmpb, //!< Instruction 'vpcmpb' {AVX512_BW+VL}.
|
|
kIdVpcmpd, //!< Instruction 'vpcmpd' {AVX512_F+VL}.
|
|
kIdVpcmpeqb, //!< Instruction 'vpcmpeqb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpcmpeqd, //!< Instruction 'vpcmpeqd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpcmpeqq, //!< Instruction 'vpcmpeqq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpcmpeqw, //!< Instruction 'vpcmpeqw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpcmpestri, //!< Instruction 'vpcmpestri' {AVX}.
|
|
kIdVpcmpestrm, //!< Instruction 'vpcmpestrm' {AVX}.
|
|
kIdVpcmpgtb, //!< Instruction 'vpcmpgtb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpcmpgtd, //!< Instruction 'vpcmpgtd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpcmpgtq, //!< Instruction 'vpcmpgtq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpcmpgtw, //!< Instruction 'vpcmpgtw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpcmpistri, //!< Instruction 'vpcmpistri' {AVX}.
|
|
kIdVpcmpistrm, //!< Instruction 'vpcmpistrm' {AVX}.
|
|
kIdVpcmpq, //!< Instruction 'vpcmpq' {AVX512_F+VL}.
|
|
kIdVpcmpub, //!< Instruction 'vpcmpub' {AVX512_BW+VL}.
|
|
kIdVpcmpud, //!< Instruction 'vpcmpud' {AVX512_F+VL}.
|
|
kIdVpcmpuq, //!< Instruction 'vpcmpuq' {AVX512_F+VL}.
|
|
kIdVpcmpuw, //!< Instruction 'vpcmpuw' {AVX512_BW+VL}.
|
|
kIdVpcmpw, //!< Instruction 'vpcmpw' {AVX512_BW+VL}.
|
|
kIdVpcomb, //!< Instruction 'vpcomb' {XOP}.
|
|
kIdVpcomd, //!< Instruction 'vpcomd' {XOP}.
|
|
kIdVpcompressb, //!< Instruction 'vpcompressb' {AVX512_VBMI2+VL}.
|
|
kIdVpcompressd, //!< Instruction 'vpcompressd' {AVX512_F+VL}.
|
|
kIdVpcompressq, //!< Instruction 'vpcompressq' {AVX512_F+VL}.
|
|
kIdVpcompressw, //!< Instruction 'vpcompressw' {AVX512_VBMI2+VL}.
|
|
kIdVpcomq, //!< Instruction 'vpcomq' {XOP}.
|
|
kIdVpcomub, //!< Instruction 'vpcomub' {XOP}.
|
|
kIdVpcomud, //!< Instruction 'vpcomud' {XOP}.
|
|
kIdVpcomuq, //!< Instruction 'vpcomuq' {XOP}.
|
|
kIdVpcomuw, //!< Instruction 'vpcomuw' {XOP}.
|
|
kIdVpcomw, //!< Instruction 'vpcomw' {XOP}.
|
|
kIdVpconflictd, //!< Instruction 'vpconflictd' {AVX512_CDI+VL}.
|
|
kIdVpconflictq, //!< Instruction 'vpconflictq' {AVX512_CDI+VL}.
|
|
kIdVpdpbusd, //!< Instruction 'vpdpbusd' {AVX_VNNI|AVX512_VNNI+VL}.
|
|
kIdVpdpbusds, //!< Instruction 'vpdpbusds' {AVX_VNNI|AVX512_VNNI+VL}.
|
|
kIdVpdpwssd, //!< Instruction 'vpdpwssd' {AVX_VNNI|AVX512_VNNI+VL}.
|
|
kIdVpdpwssds, //!< Instruction 'vpdpwssds' {AVX_VNNI|AVX512_VNNI+VL}.
|
|
kIdVperm2f128, //!< Instruction 'vperm2f128' {AVX}.
|
|
kIdVperm2i128, //!< Instruction 'vperm2i128' {AVX2}.
|
|
kIdVpermb, //!< Instruction 'vpermb' {AVX512_VBMI+VL}.
|
|
kIdVpermd, //!< Instruction 'vpermd' {AVX2|AVX512_F+VL}.
|
|
kIdVpermi2b, //!< Instruction 'vpermi2b' {AVX512_VBMI+VL}.
|
|
kIdVpermi2d, //!< Instruction 'vpermi2d' {AVX512_F+VL}.
|
|
kIdVpermi2pd, //!< Instruction 'vpermi2pd' {AVX512_F+VL}.
|
|
kIdVpermi2ps, //!< Instruction 'vpermi2ps' {AVX512_F+VL}.
|
|
kIdVpermi2q, //!< Instruction 'vpermi2q' {AVX512_F+VL}.
|
|
kIdVpermi2w, //!< Instruction 'vpermi2w' {AVX512_BW+VL}.
|
|
kIdVpermil2pd, //!< Instruction 'vpermil2pd' {XOP}.
|
|
kIdVpermil2ps, //!< Instruction 'vpermil2ps' {XOP}.
|
|
kIdVpermilpd, //!< Instruction 'vpermilpd' {AVX|AVX512_F+VL}.
|
|
kIdVpermilps, //!< Instruction 'vpermilps' {AVX|AVX512_F+VL}.
|
|
kIdVpermpd, //!< Instruction 'vpermpd' {AVX2|AVX512_F+VL}.
|
|
kIdVpermps, //!< Instruction 'vpermps' {AVX2|AVX512_F+VL}.
|
|
kIdVpermq, //!< Instruction 'vpermq' {AVX2|AVX512_F+VL}.
|
|
kIdVpermt2b, //!< Instruction 'vpermt2b' {AVX512_VBMI+VL}.
|
|
kIdVpermt2d, //!< Instruction 'vpermt2d' {AVX512_F+VL}.
|
|
kIdVpermt2pd, //!< Instruction 'vpermt2pd' {AVX512_F+VL}.
|
|
kIdVpermt2ps, //!< Instruction 'vpermt2ps' {AVX512_F+VL}.
|
|
kIdVpermt2q, //!< Instruction 'vpermt2q' {AVX512_F+VL}.
|
|
kIdVpermt2w, //!< Instruction 'vpermt2w' {AVX512_BW+VL}.
|
|
kIdVpermw, //!< Instruction 'vpermw' {AVX512_BW+VL}.
|
|
kIdVpexpandb, //!< Instruction 'vpexpandb' {AVX512_VBMI2+VL}.
|
|
kIdVpexpandd, //!< Instruction 'vpexpandd' {AVX512_F+VL}.
|
|
kIdVpexpandq, //!< Instruction 'vpexpandq' {AVX512_F+VL}.
|
|
kIdVpexpandw, //!< Instruction 'vpexpandw' {AVX512_VBMI2+VL}.
|
|
kIdVpextrb, //!< Instruction 'vpextrb' {AVX|AVX512_BW}.
|
|
kIdVpextrd, //!< Instruction 'vpextrd' {AVX|AVX512_DQ}.
|
|
kIdVpextrq, //!< Instruction 'vpextrq' {AVX|AVX512_DQ} (X64).
|
|
kIdVpextrw, //!< Instruction 'vpextrw' {AVX|AVX512_BW}.
|
|
kIdVpgatherdd, //!< Instruction 'vpgatherdd' {AVX2|AVX512_F+VL}.
|
|
kIdVpgatherdq, //!< Instruction 'vpgatherdq' {AVX2|AVX512_F+VL}.
|
|
kIdVpgatherqd, //!< Instruction 'vpgatherqd' {AVX2|AVX512_F+VL}.
|
|
kIdVpgatherqq, //!< Instruction 'vpgatherqq' {AVX2|AVX512_F+VL}.
|
|
kIdVphaddbd, //!< Instruction 'vphaddbd' {XOP}.
|
|
kIdVphaddbq, //!< Instruction 'vphaddbq' {XOP}.
|
|
kIdVphaddbw, //!< Instruction 'vphaddbw' {XOP}.
|
|
kIdVphaddd, //!< Instruction 'vphaddd' {AVX|AVX2}.
|
|
kIdVphadddq, //!< Instruction 'vphadddq' {XOP}.
|
|
kIdVphaddsw, //!< Instruction 'vphaddsw' {AVX|AVX2}.
|
|
kIdVphaddubd, //!< Instruction 'vphaddubd' {XOP}.
|
|
kIdVphaddubq, //!< Instruction 'vphaddubq' {XOP}.
|
|
kIdVphaddubw, //!< Instruction 'vphaddubw' {XOP}.
|
|
kIdVphaddudq, //!< Instruction 'vphaddudq' {XOP}.
|
|
kIdVphadduwd, //!< Instruction 'vphadduwd' {XOP}.
|
|
kIdVphadduwq, //!< Instruction 'vphadduwq' {XOP}.
|
|
kIdVphaddw, //!< Instruction 'vphaddw' {AVX|AVX2}.
|
|
kIdVphaddwd, //!< Instruction 'vphaddwd' {XOP}.
|
|
kIdVphaddwq, //!< Instruction 'vphaddwq' {XOP}.
|
|
kIdVphminposuw, //!< Instruction 'vphminposuw' {AVX}.
|
|
kIdVphsubbw, //!< Instruction 'vphsubbw' {XOP}.
|
|
kIdVphsubd, //!< Instruction 'vphsubd' {AVX|AVX2}.
|
|
kIdVphsubdq, //!< Instruction 'vphsubdq' {XOP}.
|
|
kIdVphsubsw, //!< Instruction 'vphsubsw' {AVX|AVX2}.
|
|
kIdVphsubw, //!< Instruction 'vphsubw' {AVX|AVX2}.
|
|
kIdVphsubwd, //!< Instruction 'vphsubwd' {XOP}.
|
|
kIdVpinsrb, //!< Instruction 'vpinsrb' {AVX|AVX512_BW}.
|
|
kIdVpinsrd, //!< Instruction 'vpinsrd' {AVX|AVX512_DQ}.
|
|
kIdVpinsrq, //!< Instruction 'vpinsrq' {AVX|AVX512_DQ} (X64).
|
|
kIdVpinsrw, //!< Instruction 'vpinsrw' {AVX|AVX512_BW}.
|
|
kIdVplzcntd, //!< Instruction 'vplzcntd' {AVX512_CDI+VL}.
|
|
kIdVplzcntq, //!< Instruction 'vplzcntq' {AVX512_CDI+VL}.
|
|
kIdVpmacsdd, //!< Instruction 'vpmacsdd' {XOP}.
|
|
kIdVpmacsdqh, //!< Instruction 'vpmacsdqh' {XOP}.
|
|
kIdVpmacsdql, //!< Instruction 'vpmacsdql' {XOP}.
|
|
kIdVpmacssdd, //!< Instruction 'vpmacssdd' {XOP}.
|
|
kIdVpmacssdqh, //!< Instruction 'vpmacssdqh' {XOP}.
|
|
kIdVpmacssdql, //!< Instruction 'vpmacssdql' {XOP}.
|
|
kIdVpmacsswd, //!< Instruction 'vpmacsswd' {XOP}.
|
|
kIdVpmacssww, //!< Instruction 'vpmacssww' {XOP}.
|
|
kIdVpmacswd, //!< Instruction 'vpmacswd' {XOP}.
|
|
kIdVpmacsww, //!< Instruction 'vpmacsww' {XOP}.
|
|
kIdVpmadcsswd, //!< Instruction 'vpmadcsswd' {XOP}.
|
|
kIdVpmadcswd, //!< Instruction 'vpmadcswd' {XOP}.
|
|
kIdVpmadd52huq, //!< Instruction 'vpmadd52huq' {AVX512_IFMA+VL}.
|
|
kIdVpmadd52luq, //!< Instruction 'vpmadd52luq' {AVX512_IFMA+VL}.
|
|
kIdVpmaddubsw, //!< Instruction 'vpmaddubsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmaddwd, //!< Instruction 'vpmaddwd' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmaskmovd, //!< Instruction 'vpmaskmovd' {AVX2}.
|
|
kIdVpmaskmovq, //!< Instruction 'vpmaskmovq' {AVX2}.
|
|
kIdVpmaxsb, //!< Instruction 'vpmaxsb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmaxsd, //!< Instruction 'vpmaxsd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmaxsq, //!< Instruction 'vpmaxsq' {AVX512_F+VL}.
|
|
kIdVpmaxsw, //!< Instruction 'vpmaxsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmaxub, //!< Instruction 'vpmaxub' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmaxud, //!< Instruction 'vpmaxud' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmaxuq, //!< Instruction 'vpmaxuq' {AVX512_F+VL}.
|
|
kIdVpmaxuw, //!< Instruction 'vpmaxuw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpminsb, //!< Instruction 'vpminsb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpminsd, //!< Instruction 'vpminsd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpminsq, //!< Instruction 'vpminsq' {AVX512_F+VL}.
|
|
kIdVpminsw, //!< Instruction 'vpminsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpminub, //!< Instruction 'vpminub' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpminud, //!< Instruction 'vpminud' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpminuq, //!< Instruction 'vpminuq' {AVX512_F+VL}.
|
|
kIdVpminuw, //!< Instruction 'vpminuw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmovb2m, //!< Instruction 'vpmovb2m' {AVX512_BW+VL}.
|
|
kIdVpmovd2m, //!< Instruction 'vpmovd2m' {AVX512_DQ+VL}.
|
|
kIdVpmovdb, //!< Instruction 'vpmovdb' {AVX512_F+VL}.
|
|
kIdVpmovdw, //!< Instruction 'vpmovdw' {AVX512_F+VL}.
|
|
kIdVpmovm2b, //!< Instruction 'vpmovm2b' {AVX512_BW+VL}.
|
|
kIdVpmovm2d, //!< Instruction 'vpmovm2d' {AVX512_DQ+VL}.
|
|
kIdVpmovm2q, //!< Instruction 'vpmovm2q' {AVX512_DQ+VL}.
|
|
kIdVpmovm2w, //!< Instruction 'vpmovm2w' {AVX512_BW+VL}.
|
|
kIdVpmovmskb, //!< Instruction 'vpmovmskb' {AVX|AVX2}.
|
|
kIdVpmovq2m, //!< Instruction 'vpmovq2m' {AVX512_DQ+VL}.
|
|
kIdVpmovqb, //!< Instruction 'vpmovqb' {AVX512_F+VL}.
|
|
kIdVpmovqd, //!< Instruction 'vpmovqd' {AVX512_F+VL}.
|
|
kIdVpmovqw, //!< Instruction 'vpmovqw' {AVX512_F+VL}.
|
|
kIdVpmovsdb, //!< Instruction 'vpmovsdb' {AVX512_F+VL}.
|
|
kIdVpmovsdw, //!< Instruction 'vpmovsdw' {AVX512_F+VL}.
|
|
kIdVpmovsqb, //!< Instruction 'vpmovsqb' {AVX512_F+VL}.
|
|
kIdVpmovsqd, //!< Instruction 'vpmovsqd' {AVX512_F+VL}.
|
|
kIdVpmovsqw, //!< Instruction 'vpmovsqw' {AVX512_F+VL}.
|
|
kIdVpmovswb, //!< Instruction 'vpmovswb' {AVX512_BW+VL}.
|
|
kIdVpmovsxbd, //!< Instruction 'vpmovsxbd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovsxbq, //!< Instruction 'vpmovsxbq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovsxbw, //!< Instruction 'vpmovsxbw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmovsxdq, //!< Instruction 'vpmovsxdq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovsxwd, //!< Instruction 'vpmovsxwd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovsxwq, //!< Instruction 'vpmovsxwq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovusdb, //!< Instruction 'vpmovusdb' {AVX512_F+VL}.
|
|
kIdVpmovusdw, //!< Instruction 'vpmovusdw' {AVX512_F+VL}.
|
|
kIdVpmovusqb, //!< Instruction 'vpmovusqb' {AVX512_F+VL}.
|
|
kIdVpmovusqd, //!< Instruction 'vpmovusqd' {AVX512_F+VL}.
|
|
kIdVpmovusqw, //!< Instruction 'vpmovusqw' {AVX512_F+VL}.
|
|
kIdVpmovuswb, //!< Instruction 'vpmovuswb' {AVX512_BW+VL}.
|
|
kIdVpmovw2m, //!< Instruction 'vpmovw2m' {AVX512_BW+VL}.
|
|
kIdVpmovwb, //!< Instruction 'vpmovwb' {AVX512_BW+VL}.
|
|
kIdVpmovzxbd, //!< Instruction 'vpmovzxbd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovzxbq, //!< Instruction 'vpmovzxbq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovzxbw, //!< Instruction 'vpmovzxbw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmovzxdq, //!< Instruction 'vpmovzxdq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovzxwd, //!< Instruction 'vpmovzxwd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmovzxwq, //!< Instruction 'vpmovzxwq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmuldq, //!< Instruction 'vpmuldq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmulhrsw, //!< Instruction 'vpmulhrsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmulhuw, //!< Instruction 'vpmulhuw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmulhw, //!< Instruction 'vpmulhw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmulld, //!< Instruction 'vpmulld' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpmullq, //!< Instruction 'vpmullq' {AVX512_DQ+VL}.
|
|
kIdVpmullw, //!< Instruction 'vpmullw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpmultishiftqb, //!< Instruction 'vpmultishiftqb' {AVX512_VBMI+VL}.
|
|
kIdVpmuludq, //!< Instruction 'vpmuludq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpopcntb, //!< Instruction 'vpopcntb' {AVX512_BITALG+VL}.
|
|
kIdVpopcntd, //!< Instruction 'vpopcntd' {AVX512_VPOPCNTDQ+VL}.
|
|
kIdVpopcntq, //!< Instruction 'vpopcntq' {AVX512_VPOPCNTDQ+VL}.
|
|
kIdVpopcntw, //!< Instruction 'vpopcntw' {AVX512_BITALG+VL}.
|
|
kIdVpor, //!< Instruction 'vpor' {AVX|AVX2}.
|
|
kIdVpord, //!< Instruction 'vpord' {AVX512_F+VL}.
|
|
kIdVporq, //!< Instruction 'vporq' {AVX512_F+VL}.
|
|
kIdVpperm, //!< Instruction 'vpperm' {XOP}.
|
|
kIdVprold, //!< Instruction 'vprold' {AVX512_F+VL}.
|
|
kIdVprolq, //!< Instruction 'vprolq' {AVX512_F+VL}.
|
|
kIdVprolvd, //!< Instruction 'vprolvd' {AVX512_F+VL}.
|
|
kIdVprolvq, //!< Instruction 'vprolvq' {AVX512_F+VL}.
|
|
kIdVprord, //!< Instruction 'vprord' {AVX512_F+VL}.
|
|
kIdVprorq, //!< Instruction 'vprorq' {AVX512_F+VL}.
|
|
kIdVprorvd, //!< Instruction 'vprorvd' {AVX512_F+VL}.
|
|
kIdVprorvq, //!< Instruction 'vprorvq' {AVX512_F+VL}.
|
|
kIdVprotb, //!< Instruction 'vprotb' {XOP}.
|
|
kIdVprotd, //!< Instruction 'vprotd' {XOP}.
|
|
kIdVprotq, //!< Instruction 'vprotq' {XOP}.
|
|
kIdVprotw, //!< Instruction 'vprotw' {XOP}.
|
|
kIdVpsadbw, //!< Instruction 'vpsadbw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpscatterdd, //!< Instruction 'vpscatterdd' {AVX512_F+VL}.
|
|
kIdVpscatterdq, //!< Instruction 'vpscatterdq' {AVX512_F+VL}.
|
|
kIdVpscatterqd, //!< Instruction 'vpscatterqd' {AVX512_F+VL}.
|
|
kIdVpscatterqq, //!< Instruction 'vpscatterqq' {AVX512_F+VL}.
|
|
kIdVpshab, //!< Instruction 'vpshab' {XOP}.
|
|
kIdVpshad, //!< Instruction 'vpshad' {XOP}.
|
|
kIdVpshaq, //!< Instruction 'vpshaq' {XOP}.
|
|
kIdVpshaw, //!< Instruction 'vpshaw' {XOP}.
|
|
kIdVpshlb, //!< Instruction 'vpshlb' {XOP}.
|
|
kIdVpshld, //!< Instruction 'vpshld' {XOP}.
|
|
kIdVpshldd, //!< Instruction 'vpshldd' {AVX512_VBMI2+VL}.
|
|
kIdVpshldq, //!< Instruction 'vpshldq' {AVX512_VBMI2+VL}.
|
|
kIdVpshldvd, //!< Instruction 'vpshldvd' {AVX512_VBMI2+VL}.
|
|
kIdVpshldvq, //!< Instruction 'vpshldvq' {AVX512_VBMI2+VL}.
|
|
kIdVpshldvw, //!< Instruction 'vpshldvw' {AVX512_VBMI2+VL}.
|
|
kIdVpshldw, //!< Instruction 'vpshldw' {AVX512_VBMI2+VL}.
|
|
kIdVpshlq, //!< Instruction 'vpshlq' {XOP}.
|
|
kIdVpshlw, //!< Instruction 'vpshlw' {XOP}.
|
|
kIdVpshrdd, //!< Instruction 'vpshrdd' {AVX512_VBMI2+VL}.
|
|
kIdVpshrdq, //!< Instruction 'vpshrdq' {AVX512_VBMI2+VL}.
|
|
kIdVpshrdvd, //!< Instruction 'vpshrdvd' {AVX512_VBMI2+VL}.
|
|
kIdVpshrdvq, //!< Instruction 'vpshrdvq' {AVX512_VBMI2+VL}.
|
|
kIdVpshrdvw, //!< Instruction 'vpshrdvw' {AVX512_VBMI2+VL}.
|
|
kIdVpshrdw, //!< Instruction 'vpshrdw' {AVX512_VBMI2+VL}.
|
|
kIdVpshufb, //!< Instruction 'vpshufb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpshufbitqmb, //!< Instruction 'vpshufbitqmb' {AVX512_BITALG+VL}.
|
|
kIdVpshufd, //!< Instruction 'vpshufd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpshufhw, //!< Instruction 'vpshufhw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpshuflw, //!< Instruction 'vpshuflw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsignb, //!< Instruction 'vpsignb' {AVX|AVX2}.
|
|
kIdVpsignd, //!< Instruction 'vpsignd' {AVX|AVX2}.
|
|
kIdVpsignw, //!< Instruction 'vpsignw' {AVX|AVX2}.
|
|
kIdVpslld, //!< Instruction 'vpslld' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpslldq, //!< Instruction 'vpslldq' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsllq, //!< Instruction 'vpsllq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpsllvd, //!< Instruction 'vpsllvd' {AVX2|AVX512_F+VL}.
|
|
kIdVpsllvq, //!< Instruction 'vpsllvq' {AVX2|AVX512_F+VL}.
|
|
kIdVpsllvw, //!< Instruction 'vpsllvw' {AVX512_BW+VL}.
|
|
kIdVpsllw, //!< Instruction 'vpsllw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsrad, //!< Instruction 'vpsrad' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpsraq, //!< Instruction 'vpsraq' {AVX512_F+VL}.
|
|
kIdVpsravd, //!< Instruction 'vpsravd' {AVX2|AVX512_F+VL}.
|
|
kIdVpsravq, //!< Instruction 'vpsravq' {AVX512_F+VL}.
|
|
kIdVpsravw, //!< Instruction 'vpsravw' {AVX512_BW+VL}.
|
|
kIdVpsraw, //!< Instruction 'vpsraw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsrld, //!< Instruction 'vpsrld' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpsrldq, //!< Instruction 'vpsrldq' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsrlq, //!< Instruction 'vpsrlq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpsrlvd, //!< Instruction 'vpsrlvd' {AVX2|AVX512_F+VL}.
|
|
kIdVpsrlvq, //!< Instruction 'vpsrlvq' {AVX2|AVX512_F+VL}.
|
|
kIdVpsrlvw, //!< Instruction 'vpsrlvw' {AVX512_BW+VL}.
|
|
kIdVpsrlw, //!< Instruction 'vpsrlw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsubb, //!< Instruction 'vpsubb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsubd, //!< Instruction 'vpsubd' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpsubq, //!< Instruction 'vpsubq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpsubsb, //!< Instruction 'vpsubsb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsubsw, //!< Instruction 'vpsubsw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsubusb, //!< Instruction 'vpsubusb' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsubusw, //!< Instruction 'vpsubusw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpsubw, //!< Instruction 'vpsubw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpternlogd, //!< Instruction 'vpternlogd' {AVX512_F+VL}.
|
|
kIdVpternlogq, //!< Instruction 'vpternlogq' {AVX512_F+VL}.
|
|
kIdVptest, //!< Instruction 'vptest' {AVX}.
|
|
kIdVptestmb, //!< Instruction 'vptestmb' {AVX512_BW+VL}.
|
|
kIdVptestmd, //!< Instruction 'vptestmd' {AVX512_F+VL}.
|
|
kIdVptestmq, //!< Instruction 'vptestmq' {AVX512_F+VL}.
|
|
kIdVptestmw, //!< Instruction 'vptestmw' {AVX512_BW+VL}.
|
|
kIdVptestnmb, //!< Instruction 'vptestnmb' {AVX512_BW+VL}.
|
|
kIdVptestnmd, //!< Instruction 'vptestnmd' {AVX512_F+VL}.
|
|
kIdVptestnmq, //!< Instruction 'vptestnmq' {AVX512_F+VL}.
|
|
kIdVptestnmw, //!< Instruction 'vptestnmw' {AVX512_BW+VL}.
|
|
kIdVpunpckhbw, //!< Instruction 'vpunpckhbw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpunpckhdq, //!< Instruction 'vpunpckhdq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpunpckhqdq, //!< Instruction 'vpunpckhqdq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpunpckhwd, //!< Instruction 'vpunpckhwd' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpunpcklbw, //!< Instruction 'vpunpcklbw' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpunpckldq, //!< Instruction 'vpunpckldq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpunpcklqdq, //!< Instruction 'vpunpcklqdq' {AVX|AVX2|AVX512_F+VL}.
|
|
kIdVpunpcklwd, //!< Instruction 'vpunpcklwd' {AVX|AVX2|AVX512_BW+VL}.
|
|
kIdVpxor, //!< Instruction 'vpxor' {AVX|AVX2}.
|
|
kIdVpxord, //!< Instruction 'vpxord' {AVX512_F+VL}.
|
|
kIdVpxorq, //!< Instruction 'vpxorq' {AVX512_F+VL}.
|
|
kIdVrangepd, //!< Instruction 'vrangepd' {AVX512_DQ+VL}.
|
|
kIdVrangeps, //!< Instruction 'vrangeps' {AVX512_DQ+VL}.
|
|
kIdVrangesd, //!< Instruction 'vrangesd' {AVX512_DQ}.
|
|
kIdVrangess, //!< Instruction 'vrangess' {AVX512_DQ}.
|
|
kIdVrcp14pd, //!< Instruction 'vrcp14pd' {AVX512_F+VL}.
|
|
kIdVrcp14ps, //!< Instruction 'vrcp14ps' {AVX512_F+VL}.
|
|
kIdVrcp14sd, //!< Instruction 'vrcp14sd' {AVX512_F}.
|
|
kIdVrcp14ss, //!< Instruction 'vrcp14ss' {AVX512_F}.
|
|
kIdVrcp28pd, //!< Instruction 'vrcp28pd' {AVX512_ERI}.
|
|
kIdVrcp28ps, //!< Instruction 'vrcp28ps' {AVX512_ERI}.
|
|
kIdVrcp28sd, //!< Instruction 'vrcp28sd' {AVX512_ERI}.
|
|
kIdVrcp28ss, //!< Instruction 'vrcp28ss' {AVX512_ERI}.
|
|
kIdVrcpph, //!< Instruction 'vrcpph' {AVX512_FP16}.
|
|
kIdVrcpps, //!< Instruction 'vrcpps' {AVX}.
|
|
kIdVrcpsh, //!< Instruction 'vrcpsh' {AVX512_FP16}.
|
|
kIdVrcpss, //!< Instruction 'vrcpss' {AVX}.
|
|
kIdVreducepd, //!< Instruction 'vreducepd' {AVX512_DQ+VL}.
|
|
kIdVreduceph, //!< Instruction 'vreduceph' {AVX512_FP16+VL}.
|
|
kIdVreduceps, //!< Instruction 'vreduceps' {AVX512_DQ+VL}.
|
|
kIdVreducesd, //!< Instruction 'vreducesd' {AVX512_DQ}.
|
|
kIdVreducesh, //!< Instruction 'vreducesh' {AVX512_FP16}.
|
|
kIdVreducess, //!< Instruction 'vreducess' {AVX512_DQ}.
|
|
kIdVrndscalepd, //!< Instruction 'vrndscalepd' {AVX512_F+VL}.
|
|
kIdVrndscaleph, //!< Instruction 'vrndscaleph' {AVX512_FP16+VL}.
|
|
kIdVrndscaleps, //!< Instruction 'vrndscaleps' {AVX512_F+VL}.
|
|
kIdVrndscalesd, //!< Instruction 'vrndscalesd' {AVX512_F}.
|
|
kIdVrndscalesh, //!< Instruction 'vrndscalesh' {AVX512_FP16}.
|
|
kIdVrndscaless, //!< Instruction 'vrndscaless' {AVX512_F}.
|
|
kIdVroundpd, //!< Instruction 'vroundpd' {AVX}.
|
|
kIdVroundps, //!< Instruction 'vroundps' {AVX}.
|
|
kIdVroundsd, //!< Instruction 'vroundsd' {AVX}.
|
|
kIdVroundss, //!< Instruction 'vroundss' {AVX}.
|
|
kIdVrsqrt14pd, //!< Instruction 'vrsqrt14pd' {AVX512_F+VL}.
|
|
kIdVrsqrt14ps, //!< Instruction 'vrsqrt14ps' {AVX512_F+VL}.
|
|
kIdVrsqrt14sd, //!< Instruction 'vrsqrt14sd' {AVX512_F}.
|
|
kIdVrsqrt14ss, //!< Instruction 'vrsqrt14ss' {AVX512_F}.
|
|
kIdVrsqrt28pd, //!< Instruction 'vrsqrt28pd' {AVX512_ERI}.
|
|
kIdVrsqrt28ps, //!< Instruction 'vrsqrt28ps' {AVX512_ERI}.
|
|
kIdVrsqrt28sd, //!< Instruction 'vrsqrt28sd' {AVX512_ERI}.
|
|
kIdVrsqrt28ss, //!< Instruction 'vrsqrt28ss' {AVX512_ERI}.
|
|
kIdVrsqrtph, //!< Instruction 'vrsqrtph' {AVX512_FP16+VL}.
|
|
kIdVrsqrtps, //!< Instruction 'vrsqrtps' {AVX}.
|
|
kIdVrsqrtsh, //!< Instruction 'vrsqrtsh' {AVX512_FP16}.
|
|
kIdVrsqrtss, //!< Instruction 'vrsqrtss' {AVX}.
|
|
kIdVscalefpd, //!< Instruction 'vscalefpd' {AVX512_F+VL}.
|
|
kIdVscalefph, //!< Instruction 'vscalefph' {AVX512_FP16+VL}.
|
|
kIdVscalefps, //!< Instruction 'vscalefps' {AVX512_F+VL}.
|
|
kIdVscalefsd, //!< Instruction 'vscalefsd' {AVX512_F}.
|
|
kIdVscalefsh, //!< Instruction 'vscalefsh' {AVX512_FP16}.
|
|
kIdVscalefss, //!< Instruction 'vscalefss' {AVX512_F}.
|
|
kIdVscatterdpd, //!< Instruction 'vscatterdpd' {AVX512_F+VL}.
|
|
kIdVscatterdps, //!< Instruction 'vscatterdps' {AVX512_F+VL}.
|
|
kIdVscatterpf0dpd, //!< Instruction 'vscatterpf0dpd' {AVX512_PFI}.
|
|
kIdVscatterpf0dps, //!< Instruction 'vscatterpf0dps' {AVX512_PFI}.
|
|
kIdVscatterpf0qpd, //!< Instruction 'vscatterpf0qpd' {AVX512_PFI}.
|
|
kIdVscatterpf0qps, //!< Instruction 'vscatterpf0qps' {AVX512_PFI}.
|
|
kIdVscatterpf1dpd, //!< Instruction 'vscatterpf1dpd' {AVX512_PFI}.
|
|
kIdVscatterpf1dps, //!< Instruction 'vscatterpf1dps' {AVX512_PFI}.
|
|
kIdVscatterpf1qpd, //!< Instruction 'vscatterpf1qpd' {AVX512_PFI}.
|
|
kIdVscatterpf1qps, //!< Instruction 'vscatterpf1qps' {AVX512_PFI}.
|
|
kIdVscatterqpd, //!< Instruction 'vscatterqpd' {AVX512_F+VL}.
|
|
kIdVscatterqps, //!< Instruction 'vscatterqps' {AVX512_F+VL}.
|
|
kIdVshuff32x4, //!< Instruction 'vshuff32x4' {AVX512_F+VL}.
|
|
kIdVshuff64x2, //!< Instruction 'vshuff64x2' {AVX512_F+VL}.
|
|
kIdVshufi32x4, //!< Instruction 'vshufi32x4' {AVX512_F+VL}.
|
|
kIdVshufi64x2, //!< Instruction 'vshufi64x2' {AVX512_F+VL}.
|
|
kIdVshufpd, //!< Instruction 'vshufpd' {AVX|AVX512_F+VL}.
|
|
kIdVshufps, //!< Instruction 'vshufps' {AVX|AVX512_F+VL}.
|
|
kIdVsqrtpd, //!< Instruction 'vsqrtpd' {AVX|AVX512_F+VL}.
|
|
kIdVsqrtph, //!< Instruction 'vsqrtph' {AVX512_FP16+VL}.
|
|
kIdVsqrtps, //!< Instruction 'vsqrtps' {AVX|AVX512_F+VL}.
|
|
kIdVsqrtsd, //!< Instruction 'vsqrtsd' {AVX|AVX512_F}.
|
|
kIdVsqrtsh, //!< Instruction 'vsqrtsh' {AVX512_FP16}.
|
|
kIdVsqrtss, //!< Instruction 'vsqrtss' {AVX|AVX512_F}.
|
|
kIdVstmxcsr, //!< Instruction 'vstmxcsr' {AVX}.
|
|
kIdVsubpd, //!< Instruction 'vsubpd' {AVX|AVX512_F+VL}.
|
|
kIdVsubph, //!< Instruction 'vsubph' {AVX512_FP16+VL}.
|
|
kIdVsubps, //!< Instruction 'vsubps' {AVX|AVX512_F+VL}.
|
|
kIdVsubsd, //!< Instruction 'vsubsd' {AVX|AVX512_F}.
|
|
kIdVsubsh, //!< Instruction 'vsubsh' {AVX512_FP16}.
|
|
kIdVsubss, //!< Instruction 'vsubss' {AVX|AVX512_F}.
|
|
kIdVtestpd, //!< Instruction 'vtestpd' {AVX}.
|
|
kIdVtestps, //!< Instruction 'vtestps' {AVX}.
|
|
kIdVucomisd, //!< Instruction 'vucomisd' {AVX|AVX512_F}.
|
|
kIdVucomish, //!< Instruction 'vucomish' {AVX512_FP16}.
|
|
kIdVucomiss, //!< Instruction 'vucomiss' {AVX|AVX512_F}.
|
|
kIdVunpckhpd, //!< Instruction 'vunpckhpd' {AVX|AVX512_F+VL}.
|
|
kIdVunpckhps, //!< Instruction 'vunpckhps' {AVX|AVX512_F+VL}.
|
|
kIdVunpcklpd, //!< Instruction 'vunpcklpd' {AVX|AVX512_F+VL}.
|
|
kIdVunpcklps, //!< Instruction 'vunpcklps' {AVX|AVX512_F+VL}.
|
|
kIdVxorpd, //!< Instruction 'vxorpd' {AVX|AVX512_DQ+VL}.
|
|
kIdVxorps, //!< Instruction 'vxorps' {AVX|AVX512_DQ+VL}.
|
|
kIdVzeroall, //!< Instruction 'vzeroall' {AVX}.
|
|
kIdVzeroupper, //!< Instruction 'vzeroupper' {AVX}.
|
|
kIdWbinvd, //!< Instruction 'wbinvd'.
|
|
kIdWbnoinvd, //!< Instruction 'wbnoinvd' {WBNOINVD}.
|
|
kIdWrfsbase, //!< Instruction 'wrfsbase' {FSGSBASE} (X64).
|
|
kIdWrgsbase, //!< Instruction 'wrgsbase' {FSGSBASE} (X64).
|
|
kIdWrmsr, //!< Instruction 'wrmsr' {MSR}.
|
|
kIdWrssd, //!< Instruction 'wrssd' {CET_SS}.
|
|
kIdWrssq, //!< Instruction 'wrssq' {CET_SS} (X64).
|
|
kIdWrussd, //!< Instruction 'wrussd' {CET_SS}.
|
|
kIdWrussq, //!< Instruction 'wrussq' {CET_SS} (X64).
|
|
kIdXabort, //!< Instruction 'xabort' {RTM}.
|
|
kIdXadd, //!< Instruction 'xadd' {I486}.
|
|
kIdXbegin, //!< Instruction 'xbegin' {RTM}.
|
|
kIdXchg, //!< Instruction 'xchg'.
|
|
kIdXend, //!< Instruction 'xend' {RTM}.
|
|
kIdXgetbv, //!< Instruction 'xgetbv' {XSAVE}.
|
|
kIdXlatb, //!< Instruction 'xlatb'.
|
|
kIdXor, //!< Instruction 'xor'.
|
|
kIdXorpd, //!< Instruction 'xorpd' {SSE2}.
|
|
kIdXorps, //!< Instruction 'xorps' {SSE}.
|
|
kIdXresldtrk, //!< Instruction 'xresldtrk' {TSXLDTRK}.
|
|
kIdXrstor, //!< Instruction 'xrstor' {XSAVE}.
|
|
kIdXrstor64, //!< Instruction 'xrstor64' {XSAVE} (X64).
|
|
kIdXrstors, //!< Instruction 'xrstors' {XSAVES}.
|
|
kIdXrstors64, //!< Instruction 'xrstors64' {XSAVES} (X64).
|
|
kIdXsave, //!< Instruction 'xsave' {XSAVE}.
|
|
kIdXsave64, //!< Instruction 'xsave64' {XSAVE} (X64).
|
|
kIdXsavec, //!< Instruction 'xsavec' {XSAVEC}.
|
|
kIdXsavec64, //!< Instruction 'xsavec64' {XSAVEC} (X64).
|
|
kIdXsaveopt, //!< Instruction 'xsaveopt' {XSAVEOPT}.
|
|
kIdXsaveopt64, //!< Instruction 'xsaveopt64' {XSAVEOPT} (X64).
|
|
kIdXsaves, //!< Instruction 'xsaves' {XSAVES}.
|
|
kIdXsaves64, //!< Instruction 'xsaves64' {XSAVES} (X64).
|
|
kIdXsetbv, //!< Instruction 'xsetbv' {XSAVE}.
|
|
kIdXsusldtrk, //!< Instruction 'xsusldtrk' {TSXLDTRK}.
|
|
kIdXtest, //!< Instruction 'xtest' {TSX}.
|
|
_kIdCount
|
|
// ${InstId:End}
|
|
};
|
|
|
|
//! Tests whether the `instId` is defined.
|
|
static inline constexpr bool isDefinedId(InstId instId) noexcept { return instId < _kIdCount; }
|
|
|
|
//! \cond
|
|
#define ASMJIT_INST_FROM_COND(ID) \
|
|
ID##o, ID##no, ID##b , ID##ae, \
|
|
ID##e, ID##ne, ID##be, ID##a , \
|
|
ID##s, ID##ns, ID##pe, ID##po, \
|
|
ID##l, ID##ge, ID##le, ID##g
|
|
|
|
static constexpr uint16_t _jccTable[] = { ASMJIT_INST_FROM_COND(Inst::kIdJ) };
|
|
static constexpr uint16_t _setccTable[] = { ASMJIT_INST_FROM_COND(Inst::kIdSet) };
|
|
static constexpr uint16_t _cmovccTable[] = { ASMJIT_INST_FROM_COND(Inst::kIdCmov) };
|
|
|
|
#undef ASMJIT_INST_FROM_COND
|
|
//! \endcond
|
|
|
|
//! Translates a condition code `cond` to a `jcc` instruction id.
|
|
static constexpr InstId jccFromCond(CondCode cond) noexcept { return _jccTable[uint8_t(cond)]; }
|
|
//! Translates a condition code `cond` to a `setcc` instruction id.
|
|
static constexpr InstId setccFromCond(CondCode cond) noexcept { return _setccTable[uint8_t(cond)]; }
|
|
//! Translates a condition code `cond` to a `cmovcc` instruction id.
|
|
static constexpr InstId cmovccFromCond(CondCode cond) noexcept { return _cmovccTable[uint8_t(cond)]; }
|
|
} // {Inst}
|
|
|
|
//! FPU status word bits.
|
|
enum class FpuStatusWord : uint16_t {
|
|
kNone = 0x0000u, //!< No bits set.
|
|
|
|
kInvalid = 0x0001u, //!< Invalid operation.
|
|
kDenormalized = 0x0002u, //!< Denormalized operand.
|
|
kDivByZero = 0x0004u, //!< Division by zero.
|
|
kOverflow = 0x0008u, //!< Overflown.
|
|
kUnderflow = 0x0010u, //!< Underflown.
|
|
kPrecision = 0x0020u, //!< Precision lost.
|
|
kStackFault = 0x0040u, //!< Stack fault.
|
|
kInterrupt = 0x0080u, //!< Interrupt.
|
|
kC0 = 0x0100u, //!< C0 flag.
|
|
kC1 = 0x0200u, //!< C1 flag.
|
|
kC2 = 0x0400u, //!< C2 flag.
|
|
kTopMask = 0x3800u, //!< Top of the stack (mask).
|
|
kC3 = 0x4000u, //!< C3 flag.
|
|
kBusy = 0x8000u //!< FPU is busy.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(FpuStatusWord)
|
|
|
|
//! FPU control word bits.
|
|
enum class FpuControlWord : uint16_t {
|
|
kNone = 0x0000u, //!< No bits set.
|
|
|
|
// Bits 0-5
|
|
// --------
|
|
|
|
kEM_Mask = 0x003Fu, //!< Exception mask (0x3F).
|
|
kEM_Invalid = 0x0001u, //!< Invalid operation exception.
|
|
kEM_Denormal = 0x0002u, //!< Denormalized operand exception.
|
|
kEM_DivByZero = 0x0004u, //!< Division by zero exception.
|
|
kEM_Overflow = 0x0008u, //!< Overflow exception.
|
|
kEM_Underflow = 0x0010u, //!< Underflow exception.
|
|
kEM_Inexact = 0x0020u, //!< Inexact operation exception.
|
|
|
|
// Bits 8-9
|
|
// --------
|
|
|
|
kPC_Mask = 0x0300u, //!< Precision control mask.
|
|
kPC_Float = 0x0000u, //!< Single precision (24 bits).
|
|
kPC_Reserved = 0x0100u, //!< Reserved.
|
|
kPC_Double = 0x0200u, //!< Double precision (53 bits).
|
|
kPC_Extended = 0x0300u, //!< Extended precision (64 bits).
|
|
|
|
// Bits 10-11
|
|
// ----------
|
|
|
|
kRC_Mask = 0x0C00u, //!< Rounding control mask.
|
|
kRC_Nearest = 0x0000u, //!< Round to nearest even.
|
|
kRC_Down = 0x0400u, //!< Round down (floor).
|
|
kRC_Up = 0x0800u, //!< Round up (ceil).
|
|
kRC_Truncate = 0x0C00u, //!< Round towards zero (truncate).
|
|
|
|
// Bit 12
|
|
// ------
|
|
|
|
kIC_Mask = 0x1000u, //!< Infinity control.
|
|
kIC_Projective = 0x0000u, //!< Projective (not supported on X64).
|
|
kIC_Affine = 0x1000u //!< Affine (default).
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(FpuControlWord)
|
|
|
|
//! An immediate value that can be used with CMP[PD|PS|SD|SS] instructions.
|
|
enum class CmpImm : uint8_t {
|
|
kEQ = 0x00u, //!< Equal (Quiet), same as \ref VCmpImm::kEQ_OQ.
|
|
kLT = 0x01u, //!< Less (Signaling), same as \ref VCmpImm::kLT_OS.
|
|
kLE = 0x02u, //!< Less/Equal (Signaling), same as \ref VCmpImm::kLE_OS.
|
|
kUNORD = 0x03u, //!< Unordered (Quiet), same as \ref VCmpImm::kUNORD_Q.
|
|
kNEQ = 0x04u, //!< Not Equal (Quiet), same as \ref VCmpImm::kNEQ_UQ.
|
|
kNLT = 0x05u, //!< Not Less (Signaling), same as \ref VCmpImm::kNLT_US.
|
|
kNLE = 0x06u, //!< Not Less/Equal (Signaling), same as \ref VCmpImm::kNLE_US.
|
|
kORD = 0x07u //!< Ordered (Quiet), same as \ref VCmpImm::kORD_Q.
|
|
};
|
|
|
|
//! An immediate value that can be used with [V]PCMP[I|E]STR[I|M] instructions.
|
|
enum class PCmpStrImm : uint8_t {
|
|
// Source Data Format
|
|
// ------------------
|
|
|
|
kUB = 0x00u << 0, //!< The source data format is unsigned bytes.
|
|
kUW = 0x01u << 0, //!< The source data format is unsigned words.
|
|
kSB = 0x02u << 0, //!< The source data format is signed bytes.
|
|
kSW = 0x03u << 0, //!< The source data format is signed words.
|
|
|
|
// Aggregation Operation
|
|
// ---------------------
|
|
|
|
kEqualAny = 0x00u << 2, //!< The arithmetic comparison is "equal".
|
|
kRanges = 0x01u << 2, //!< The arithmetic comparison is "greater than or equal" between even indexed
|
|
//!< elements and "less than or equal" between odd indexed elements.
|
|
kEqualEach = 0x02u << 2, //!< The arithmetic comparison is "equal".
|
|
kEqualOrdered = 0x03u << 2, //!< The arithmetic comparison is "equal".
|
|
|
|
// Polarity
|
|
// --------
|
|
|
|
kPosPolarity = 0x00u << 4, //!< IntRes2 = IntRes1.
|
|
kNegPolarity = 0x01u << 4, //!< IntRes2 = -1 XOR IntRes1.
|
|
kPosMasked = 0x02u << 4, //!< IntRes2 = IntRes1.
|
|
kNegMasked = 0x03u << 4, //!< IntRes2[i] = second[i] == invalid ? IntRes1[i] : ~IntRes1[i].
|
|
|
|
// Output Selection (pcmpstri)
|
|
// ---------------------------
|
|
|
|
kOutputLSI = 0x00u << 6, //!< The index returned to ECX is of the least significant set bit in IntRes2.
|
|
kOutputMSI = 0x01u << 6, //!< The index returned to ECX is of the most significant set bit in IntRes2.
|
|
|
|
// Output Selection (pcmpstrm)
|
|
// ---------------------------
|
|
|
|
kBitMask = 0x00u << 6, //!< IntRes2 is returned as the mask to the least significant bits of XMM0.
|
|
kIndexMask = 0x01u << 6 //!< IntRes2 is expanded into a byte/word mask and placed in XMM0.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(PCmpStrImm)
|
|
|
|
//! An immediate value that can be used with ROUND[PD|PS|SD|SS] instructions.
|
|
//!
|
|
//! \note `kSuppress` is a mask that can be used with any other value.
|
|
enum class RoundImm : uint8_t {
|
|
kNearest = 0x00u, //!< Round to nearest (even).
|
|
kDown = 0x01u, //!< Round to down toward -INF (floor),
|
|
kUp = 0x02u, //!< Round to up toward +INF (ceil).
|
|
kTrunc = 0x03u, //!< Round toward zero (truncate).
|
|
kCurrent = 0x04u, //!< Round to the current rounding mode set (ignores other RC bits).
|
|
kSuppress = 0x08u //!< Suppress exceptions (avoids inexact exception, if set).
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(RoundImm)
|
|
|
|
//! An immediate value that can be used with VCMP[PD|PS|SD|SS] instructions (AVX).
|
|
//!
|
|
//! The first 8 values are compatible with \ref CmpImm.
|
|
enum class VCmpImm : uint8_t {
|
|
kEQ_OQ = 0x00u, //!< Equal (Quiet , Ordered) , same as \ref CmpImm::kEQ.
|
|
kLT_OS = 0x01u, //!< Less (Signaling, Ordered) , same as \ref CmpImm::kLT.
|
|
kLE_OS = 0x02u, //!< Less/Equal (Signaling, Ordered) , same as \ref CmpImm::kLE.
|
|
kUNORD_Q = 0x03u, //!< Unordered (Quiet) , same as \ref CmpImm::kUNORD.
|
|
kNEQ_UQ = 0x04u, //!< Not Equal (Quiet , Unordered), same as \ref CmpImm::kNEQ.
|
|
kNLT_US = 0x05u, //!< Not Less (Signaling, Unordered), same as \ref CmpImm::kNLT.
|
|
kNLE_US = 0x06u, //!< Not Less/Equal (Signaling, Unordered), same as \ref CmpImm::kNLE.
|
|
kORD_Q = 0x07u, //!< Ordered (Quiet) , same as \ref CmpImm::kORD.
|
|
kEQ_UQ = 0x08u, //!< Equal (Quiet , Unordered).
|
|
kNGE_US = 0x09u, //!< Not Greater/Equal (Signaling, Unordered).
|
|
kNGT_US = 0x0Au, //!< Not Greater (Signaling, Unordered).
|
|
kFALSE_OQ = 0x0Bu, //!< False (Quiet , Ordered).
|
|
kNEQ_OQ = 0x0Cu, //!< Not Equal (Quiet , Ordered).
|
|
kGE_OS = 0x0Du, //!< Greater/Equal (Signaling, Ordered).
|
|
kGT_OS = 0x0Eu, //!< Greater (Signaling, Ordered).
|
|
kTRUE_UQ = 0x0Fu, //!< True (Quiet , Unordered).
|
|
kEQ_OS = 0x10u, //!< Equal (Signaling, Ordered).
|
|
kLT_OQ = 0x11u, //!< Less (Quiet , Ordered).
|
|
kLE_OQ = 0x12u, //!< Less/Equal (Quiet , Ordered).
|
|
kUNORD_S = 0x13u, //!< Unordered (Signaling).
|
|
kNEQ_US = 0x14u, //!< Not Equal (Signaling, Unordered).
|
|
kNLT_UQ = 0x15u, //!< Not Less (Quiet , Unordered).
|
|
kNLE_UQ = 0x16u, //!< Not Less/Equal (Quiet , Unordered).
|
|
kORD_S = 0x17u, //!< Ordered (Signaling).
|
|
kEQ_US = 0x18u, //!< Equal (Signaling, Unordered).
|
|
kNGE_UQ = 0x19u, //!< Not Greater/Equal (Quiet , Unordered).
|
|
kNGT_UQ = 0x1Au, //!< Not Greater (Quiet , Unordered).
|
|
kFALSE_OS = 0x1Bu, //!< False (Signaling, Ordered).
|
|
kNEQ_OS = 0x1Cu, //!< Not Equal (Signaling, Ordered).
|
|
kGE_OQ = 0x1Du, //!< Greater/Equal (Quiet , Ordered).
|
|
kGT_OQ = 0x1Eu, //!< Greater (Quiet , Ordered).
|
|
kTRUE_US = 0x1Fu //!< True (Signaling, Unordered).
|
|
};
|
|
|
|
//! An immediate value that can be used with VFIXUPIMM[PD|PS|SD|SS] instructions (AVX-512).
|
|
//!
|
|
//! The final immediate is a combination of all possible control bits.
|
|
enum class VFixupImm : uint8_t {
|
|
kNone = 0x00u,
|
|
kZEOnZero = 0x01u,
|
|
kIEOnZero = 0x02u,
|
|
kZEOnOne = 0x04u,
|
|
kIEOnOne = 0x08u,
|
|
kIEOnSNaN = 0x10u,
|
|
kIEOnNInf = 0x20u,
|
|
kIEOnNegative = 0x40u,
|
|
kIEOnPInf = 0x80u
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(VFixupImm)
|
|
|
|
//! An immediate value that can be used with VFPCLASS[PD|PS|SD|SS] instructions (AVX-512).
|
|
//!
|
|
//! The values can be combined together to form the final 8-bit mask.
|
|
enum class VFPClassImm : uint8_t {
|
|
kNone = 0x00u,
|
|
kQNaN = 0x01u, //!< Checks for QNaN.
|
|
kPZero = 0x02u, //!< Checks for +0.
|
|
kNZero = 0x04u, //!< Checks for -0.
|
|
kPInf = 0x08u, //!< Checks for +Inf.
|
|
kNInf = 0x10u, //!< Checks for -Inf.
|
|
kDenormal = 0x20u, //!< Checks for denormal.
|
|
kNegative = 0x40u, //!< Checks for negative finite value.
|
|
kSNaN = 0x80u //!< Checks for SNaN.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(VFPClassImm)
|
|
|
|
//! An immediate value that can be used with VGETMANT[PD|PS|SD|SS] instructions (AVX-512).
|
|
//!
|
|
//! The value is a combination of a normalization interval and a sign control.
|
|
enum class VGetMantImm : uint8_t {
|
|
// Normalization Interval
|
|
// ----------------------
|
|
|
|
k1To2 = 0x00u, //!< Normalization interval is [1, 2)
|
|
k1Div2To2 = 0x01u, //!< Normalization interval is [0.5, 2)
|
|
k1Div2To1 = 0x02u, //!< Normalization interval is [0.5, 1)
|
|
k3Div4To3Div2 = 0x03u, //!< Normalization interval is [3/4, 3/2)
|
|
|
|
// Sign Control
|
|
// ------------
|
|
|
|
kSrcSign = 0x00u, //!< Source sign.
|
|
kNoSign = 0x04u, //!< Zero sign
|
|
kQNaNIfSign = 0x08u //!< QNAN_Indefinite if sign(src) != 0, regardless of `kSignSrc` or `kNoSign`.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(VGetMantImm)
|
|
|
|
//! A predicate used by VPCMP[U][B|W|D|Q] instructions (AVX-512).
|
|
enum class VPCmpImm : uint8_t {
|
|
kEQ = 0x00u, //!< Equal.
|
|
kLT = 0x01u, //!< Less.
|
|
kLE = 0x02u, //!< Less/Equal.
|
|
kFALSE = 0x03u, //!< False.
|
|
kNE = 0x04u, //!< Not Equal.
|
|
kGE = 0x05u, //!< Greater/Equal.
|
|
kGT = 0x06u, //!< Greater.
|
|
kTRUE = 0x07u //!< True.
|
|
};
|
|
|
|
//! A predicate used by VPCOM[U][B|W|D|Q] instructions (XOP).
|
|
enum class VPComImm : uint8_t {
|
|
kLT = 0x00u, //!< Less.
|
|
kLE = 0x01u, //!< Less/Equal
|
|
kGT = 0x02u, //!< Greater.
|
|
kGE = 0x03u, //!< Greater/Equal.
|
|
kEQ = 0x04u, //!< Equal.
|
|
kNE = 0x05u, //!< Not Equal.
|
|
kFALSE = 0x06u, //!< False.
|
|
kTRUE = 0x07u //!< True.
|
|
};
|
|
|
|
//! A predicate used by VRANGE[PD|PS|SD|SS] instructions (AVX-512).
|
|
enum class VRangeImm : uint8_t {
|
|
// Selector
|
|
// --------
|
|
|
|
kSelectMin = 0x00u, //!< Select minimum value.
|
|
kSelectMax = 0x01u, //!< Select maximum value.
|
|
kSelectAbsMin = 0x02u, //!< Select minimum absolute value.
|
|
kSelectAbsMax = 0x03u, //!< Select maximum absolute value.
|
|
|
|
// Sign
|
|
// ----
|
|
|
|
kSignSrc1 = 0x00u, //!< Select sign of SRC1.
|
|
kSignSrc2 = 0x04u, //!< Select sign of SRC2.
|
|
kSign0 = 0x08u, //!< Set sign to 0.
|
|
kSign1 = 0x0Cu //!< Set sign to 1.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(VRangeImm)
|
|
|
|
//! A predicate used by VREDUCE[PD|PS|SD|SS] instructions (AVX-512).
|
|
enum class VReduceImm : uint8_t {
|
|
kRoundEven = 0x00u, //!< Round to nearest even.
|
|
kRoundDown = 0x01u, //!< Round down.
|
|
kRoundUp = 0x02u, //!< Round up.
|
|
kRoundTrunc = 0x03u, //!< Truncate.
|
|
kRoundCurrent = 0x04u, //!< Round to the current mode set.
|
|
kSuppress = 0x08u, //!< Suppress exceptions.
|
|
kFixedImmMask = 0xF0u //!< Fixed length value mask.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(VReduceImm)
|
|
|
|
//! Creates a \ref VReduceImm from a combination of `flags` and `fixedPointLength`.
|
|
static inline constexpr VReduceImm vReduceImm(VReduceImm flags, uint32_t fixedPointLength) noexcept {
|
|
return flags | VReduceImm(fixedPointLength << 4);
|
|
}
|
|
|
|
//! A predicate that can be used as an immediate value with VPTERNLOG[D|Q] instruction.
|
|
//!
|
|
//! There are 3 inputs to the instruction (\ref kA, \ref kB, \ref kC). Ternary logic can define any combination
|
|
//! that would be performed on these 3 inputs to get the desired output - any combination of AND, OR, XOR, NOT
|
|
//! is possible.
|
|
//!
|
|
//! \sa \ref tLogFromBits and \ref fLogIfElse
|
|
enum class TLogImm : uint8_t {
|
|
k0 = 0x00u, //!< 0 value.
|
|
k1 = 0xFFu, //!< 1 value.
|
|
kA = 0xF0u, //!< A value.
|
|
kB = 0xCCu, //!< B value.
|
|
kC = 0xAAu, //!< C value.
|
|
|
|
kNotA = kA ^ k1, //!< `!A` expression.
|
|
kNotB = kB ^ k1, //!< `!B` expression.
|
|
kNotC = kC ^ k1, //!< `!C` expression.
|
|
|
|
kAB = kA & kB, //!< `A & B` expression.
|
|
kAC = kA & kC, //!< `A & C` expression.
|
|
kBC = kB & kC, //!< `B & C` expression.
|
|
kNotAB = kAB ^ k1, //!< `!(A & B)` expression.
|
|
kNotAC = kAC ^ k1, //!< `!(A & C)` expression.
|
|
kNotBC = kBC ^ k1, //!< `!(B & C)` expression.
|
|
|
|
kABC = kAB & kC, //!< `A & B & C` expression.
|
|
kNotABC = kABC ^ k1 //!< `!(A & B & C)` expression.
|
|
};
|
|
ASMJIT_DEFINE_ENUM_FLAGS(TLogImm)
|
|
|
|
//! Creates an immediate that can be used by VPTERNLOG[D|Q] instructions.
|
|
static inline constexpr TLogImm tLogFromBits(uint8_t b000, uint8_t b001, uint8_t b010, uint8_t b011, uint8_t b100, uint8_t b101, uint8_t b110, uint8_t b111) noexcept {
|
|
return TLogImm(uint8_t(b000 << 0) |
|
|
uint8_t(b001 << 1) |
|
|
uint8_t(b010 << 2) |
|
|
uint8_t(b011 << 3) |
|
|
uint8_t(b100 << 4) |
|
|
uint8_t(b101 << 5) |
|
|
uint8_t(b110 << 6) |
|
|
uint8_t(b111 << 7));
|
|
}
|
|
|
|
//! Creates an if/else logic that can be used by VPTERNLOG[D|Q] instructions.
|
|
static inline constexpr TLogImm fLogIfElse(TLogImm condition, TLogImm a, TLogImm b) noexcept { return (condition & a) | (~condition & b); }
|
|
|
|
//! Creates a shuffle immediate value that be used with SSE/AVX/AVX-512 instructions to shuffle 2 elements in a vector.
|
|
//!
|
|
//! \param a Position of the first component [0, 1].
|
|
//! \param b Position of the second component [0, 1].
|
|
//!
|
|
//! Shuffle constants can be used to encode an immediate for these instructions:
|
|
//! - `shufpd|vshufpd`
|
|
static inline constexpr uint32_t shuffleImm(uint32_t a, uint32_t b) noexcept {
|
|
return (a << 1) | b;
|
|
}
|
|
|
|
//! Creates a shuffle immediate value that be used with SSE/AVX/AVX-512 instructions to shuffle 4 elements in a vector.
|
|
//!
|
|
//! \param a Position of the first component [0, 3].
|
|
//! \param b Position of the second component [0, 3].
|
|
//! \param c Position of the third component [0, 3].
|
|
//! \param d Position of the fourth component [0, 3].
|
|
//!
|
|
//! Shuffle constants can be used to encode an immediate for these instructions:
|
|
//! - `pshufw`
|
|
//! - `pshuflw|vpshuflw`
|
|
//! - `pshufhw|vpshufhw`
|
|
//! - `pshufd|vpshufd`
|
|
//! - `shufps|vshufps`
|
|
static inline constexpr uint32_t shuffleImm(uint32_t a, uint32_t b, uint32_t c, uint32_t d) noexcept {
|
|
return (a << 6) | (b << 4) | (c << 2) | d;
|
|
}
|
|
|
|
//! \}
|
|
|
|
ASMJIT_END_SUB_NAMESPACE
|
|
|
|
#endif // ASMJIT_X86_X86GLOBALS_H_INCLUDED
|