Documentation ¶
Index ¶
- Constants
- Variables
- type AddressType
- type Addressable
- type Arch
- type Assembler
- type Disposable
- type ExceptionControl
- type ISA
- type Instruction
- func (self *Instruction) CS() *Instruction
- func (self *Instruction) DS() *Instruction
- func (self *Instruction) Domain() InstructionDomain
- func (self *Instruction) ES() *Instruction
- func (self *Instruction) FS() *Instruction
- func (self *Instruction) GS() *Instruction
- func (self *Instruction) LOCK() *Instruction
- func (self *Instruction) Name() string
- func (self *Instruction) Operands() []interface{}
- func (self *Instruction) SS() *Instruction
- type InstructionDomain
- type InstructionPrefix
- type KRegister
- type Label
- type LabelKind
- type LineKind
- type MMRegister
- type MaskedRegister
- type MemoryAddress
- type MemoryOperand
- type OperandKind
- type Operands
- type Options
- type ParsedCommand
- type ParsedCommandArg
- type ParsedInstruction
- type ParsedLabel
- type ParsedLine
- type ParsedOperand
- type Parser
- type Program
- func (self *Program) ADCB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADCL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADCQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADCW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADCXL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADCXQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDSUBPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDSUBPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADOXL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ADOXQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) AESDEC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) AESDECLAST(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) AESENC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) AESENCLAST(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) AESIMC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) AESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ANDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDNL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ANDNPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDNPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ANDPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ANDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction)
- func (self *Program) Assemble(pc uintptr) (ret []byte)
- func (self *Program) AssembleAndFree(pc uintptr) (ret []byte)
- func (self *Program) BEXTR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) BLCFILL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLCI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLCIC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLCMSK(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLCS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLENDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) BLENDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) BLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) BLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) BLSFILL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLSI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLSIC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLSMSK(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BLSR(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSFL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSFQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSFW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSRL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSRQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSRW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BSWAPL(v0 interface{}) *Instruction
- func (self *Program) BSWAPQ(v0 interface{}) *Instruction
- func (self *Program) BTCL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTCQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTCW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTRL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTRQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTRW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTSL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTSQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) BZHI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) Byte(v *expr.Expr) (p *Instruction)
- func (self *Program) CALL(v0 interface{}) *Instruction
- func (self *Program) CALLQ(v0 interface{}) *Instruction
- func (self *Program) CBTW() *Instruction
- func (self *Program) CLC() *Instruction
- func (self *Program) CLD() *Instruction
- func (self *Program) CLFLUSH(v0 interface{}) *Instruction
- func (self *Program) CLFLUSHOPT(v0 interface{}) *Instruction
- func (self *Program) CLTD() *Instruction
- func (self *Program) CLTQ() *Instruction
- func (self *Program) CLWB(v0 interface{}) *Instruction
- func (self *Program) CLZERO() *Instruction
- func (self *Program) CMC() *Instruction
- func (self *Program) CMOVA(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVAE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVBE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVG(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVGE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVLE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNA(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNAE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNBE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNG(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNGE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNLE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNO(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVNZ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVO(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVPE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVPO(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMOVZ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) CMPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) CMPQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) CMPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) CMPW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPXCHG16B(v0 interface{}) *Instruction
- func (self *Program) CMPXCHG8B(v0 interface{}) *Instruction
- func (self *Program) CMPXCHGB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPXCHGL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPXCHGQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CMPXCHGW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) COMISD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) COMISS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CPUID() *Instruction
- func (self *Program) CQTO() *Instruction
- func (self *Program) CRC32B(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CRC32L(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CRC32Q(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CRC32W(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTDQ2PS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPD2DQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPD2PI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPD2PS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPI2PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPI2PS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPS2DQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPS2PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTPS2PI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTSD2SI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTSD2SS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTSI2SD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTSI2SS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTSS2SD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTSS2SI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTTPD2DQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTTPD2PI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTTPS2DQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTTPS2PI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTTSD2SI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CVTTSS2SI(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) CWTD() *Instruction
- func (self *Program) CWTL() *Instruction
- func (self *Program) DECB(v0 interface{}) *Instruction
- func (self *Program) DECL(v0 interface{}) *Instruction
- func (self *Program) DECQ(v0 interface{}) *Instruction
- func (self *Program) DECW(v0 interface{}) *Instruction
- func (self *Program) DIVB(v0 interface{}) *Instruction
- func (self *Program) DIVL(v0 interface{}) *Instruction
- func (self *Program) DIVPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) DIVPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) DIVQ(v0 interface{}) *Instruction
- func (self *Program) DIVSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) DIVSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) DIVW(v0 interface{}) *Instruction
- func (self *Program) DPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) DPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) Data(v []byte) (p *Instruction)
- func (self *Program) EMMS() *Instruction
- func (self *Program) EXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) EXTRQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) FEMMS() *Instruction
- func (self *Program) Free()
- func (self *Program) HADDPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) HADDPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) HSUBPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) HSUBPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) IDIVB(v0 interface{}) *Instruction
- func (self *Program) IDIVL(v0 interface{}) *Instruction
- func (self *Program) IDIVQ(v0 interface{}) *Instruction
- func (self *Program) IDIVW(v0 interface{}) *Instruction
- func (self *Program) IMULB(v0 interface{}) *Instruction
- func (self *Program) IMULL(v0 interface{}, vv ...interface{}) *Instruction
- func (self *Program) IMULQ(v0 interface{}, vv ...interface{}) *Instruction
- func (self *Program) IMULW(v0 interface{}, vv ...interface{}) *Instruction
- func (self *Program) INCB(v0 interface{}) *Instruction
- func (self *Program) INCL(v0 interface{}) *Instruction
- func (self *Program) INCQ(v0 interface{}) *Instruction
- func (self *Program) INCW(v0 interface{}) *Instruction
- func (self *Program) INSERTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) INSERTQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) INT(v0 interface{}) *Instruction
- func (self *Program) JA(v0 interface{}) *Instruction
- func (self *Program) JAE(v0 interface{}) *Instruction
- func (self *Program) JB(v0 interface{}) *Instruction
- func (self *Program) JBE(v0 interface{}) *Instruction
- func (self *Program) JC(v0 interface{}) *Instruction
- func (self *Program) JE(v0 interface{}) *Instruction
- func (self *Program) JECXZ(v0 interface{}) *Instruction
- func (self *Program) JG(v0 interface{}) *Instruction
- func (self *Program) JGE(v0 interface{}) *Instruction
- func (self *Program) JL(v0 interface{}) *Instruction
- func (self *Program) JLE(v0 interface{}) *Instruction
- func (self *Program) JMP(v0 interface{}) *Instruction
- func (self *Program) JMPQ(v0 interface{}) *Instruction
- func (self *Program) JNA(v0 interface{}) *Instruction
- func (self *Program) JNAE(v0 interface{}) *Instruction
- func (self *Program) JNB(v0 interface{}) *Instruction
- func (self *Program) JNBE(v0 interface{}) *Instruction
- func (self *Program) JNC(v0 interface{}) *Instruction
- func (self *Program) JNE(v0 interface{}) *Instruction
- func (self *Program) JNG(v0 interface{}) *Instruction
- func (self *Program) JNGE(v0 interface{}) *Instruction
- func (self *Program) JNL(v0 interface{}) *Instruction
- func (self *Program) JNLE(v0 interface{}) *Instruction
- func (self *Program) JNO(v0 interface{}) *Instruction
- func (self *Program) JNP(v0 interface{}) *Instruction
- func (self *Program) JNS(v0 interface{}) *Instruction
- func (self *Program) JNZ(v0 interface{}) *Instruction
- func (self *Program) JO(v0 interface{}) *Instruction
- func (self *Program) JP(v0 interface{}) *Instruction
- func (self *Program) JPE(v0 interface{}) *Instruction
- func (self *Program) JPO(v0 interface{}) *Instruction
- func (self *Program) JRCXZ(v0 interface{}) *Instruction
- func (self *Program) JS(v0 interface{}) *Instruction
- func (self *Program) JZ(v0 interface{}) *Instruction
- func (self *Program) KADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KANDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KMOVB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KMOVD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KMOVQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KMOVW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KNOTB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KNOTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KNOTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KNOTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KORTESTB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KORTESTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KORTESTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KORTESTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KSHIFTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KTESTB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KTESTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KTESTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KTESTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) KUNPCKBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KUNPCKDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KUNPCKWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXNORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXNORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXNORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXNORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) KXORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) LDDQU(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) LDMXCSR(v0 interface{}) *Instruction
- func (self *Program) LEAL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) LEAQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) LEAW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) LFENCE() *Instruction
- func (self *Program) LZCNTL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) LZCNTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) LZCNTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) Link(p *Label)
- func (self *Program) Long(v *expr.Expr) (p *Instruction)
- func (self *Program) MASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MASKMOVQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MAXPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MAXPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MAXSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MAXSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MFENCE() *Instruction
- func (self *Program) MINPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MINPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MINSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MINSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MONITOR() *Instruction
- func (self *Program) MONITORX() *Instruction
- func (self *Program) MOVAPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVAPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVBEL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVBEQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVBEW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVDDUP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVDQ2Q(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVDQA(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVDQU(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVHLPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVHPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVHPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVLHPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVLPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVLPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVMSKPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVMSKPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTDQA(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTIL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTIQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVNTSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVQ2DQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSBL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSHDUP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSLDUP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSLQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSWL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVSWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVUPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVUPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVZBL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVZBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVZBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVZWL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MOVZWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) MULB(v0 interface{}) *Instruction
- func (self *Program) MULL(v0 interface{}) *Instruction
- func (self *Program) MULPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MULPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MULQ(v0 interface{}) *Instruction
- func (self *Program) MULSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MULSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) MULW(v0 interface{}) *Instruction
- func (self *Program) MULXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) MULXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) MWAIT() *Instruction
- func (self *Program) MWAITX() *Instruction
- func (self *Program) NEGB(v0 interface{}) *Instruction
- func (self *Program) NEGL(v0 interface{}) *Instruction
- func (self *Program) NEGQ(v0 interface{}) *Instruction
- func (self *Program) NEGW(v0 interface{}) *Instruction
- func (self *Program) NOP() *Instruction
- func (self *Program) NOTB(v0 interface{}) *Instruction
- func (self *Program) NOTL(v0 interface{}) *Instruction
- func (self *Program) NOTQ(v0 interface{}) *Instruction
- func (self *Program) NOTW(v0 interface{}) *Instruction
- func (self *Program) ORB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ORL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ORPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ORPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ORQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ORW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PABSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PABSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PABSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PACKSSDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PACKSSWB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PACKUSDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PACKUSWB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDUSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDUSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PADDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PALIGNR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PAND(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PANDN(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PAUSE() *Instruction
- func (self *Program) PAVGB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PAVGUSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PAVGW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PBLENDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PCMPEQB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPEQD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPEQQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPEQW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PCMPGTB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPGTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPGTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPGTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PDEP(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PEXT(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PF2ID(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PF2IW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFACC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFADD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFCMPEQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFCMPGE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFCMPGT(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFMAX(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFMIN(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFMUL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFNACC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFPNACC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFRCP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFRCPIT1(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFRCPIT2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFRSQIT1(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFRSQRT(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFSUB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PFSUBR(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHADDD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHADDSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHADDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHSUBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHSUBSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PHSUBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PI2FD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PI2FW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PINSRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PINSRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PINSRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PINSRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PMADDUBSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMADDWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMAXSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMAXSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMAXSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMAXUB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMAXUD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMAXUW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMINSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMINSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMINSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMINUB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMINUD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMINUW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVMSKB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVSXBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVSXBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVSXWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVZXBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVZXBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVZXWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULHRSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULHRW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULHUW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULHW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULLD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULLW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PMULUDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) POPCNTL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) POPCNTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) POPCNTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) POPQ(v0 interface{}) *Instruction
- func (self *Program) POPW(v0 interface{}) *Instruction
- func (self *Program) POR(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PREFETCH(v0 interface{}) *Instruction
- func (self *Program) PREFETCHNTA(v0 interface{}) *Instruction
- func (self *Program) PREFETCHT0(v0 interface{}) *Instruction
- func (self *Program) PREFETCHT1(v0 interface{}) *Instruction
- func (self *Program) PREFETCHT2(v0 interface{}) *Instruction
- func (self *Program) PREFETCHW(v0 interface{}) *Instruction
- func (self *Program) PREFETCHWT1(v0 interface{}) *Instruction
- func (self *Program) PSADBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSHUFB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PSHUFW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) PSIGNB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSIGND(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSIGNW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSLLD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSLLDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSLLQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSLLW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSRAD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSRAW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSRLD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSRLDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSRLQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSRLW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBUSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBUSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSUBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PSWAPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PTEST(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKHBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKHDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKHQDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKHWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKLBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKLDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKLQDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUNPCKLWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) PUSHQ(v0 interface{}) *Instruction
- func (self *Program) PUSHW(v0 interface{}) *Instruction
- func (self *Program) PXOR(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) Quad(v *expr.Expr) (p *Instruction)
- func (self *Program) RCLB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCLL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCLQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCLW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCPPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCPSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCRB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCRL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCRQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RCRW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RDRAND(v0 interface{}) *Instruction
- func (self *Program) RDSEED(v0 interface{}) *Instruction
- func (self *Program) RDTSC() *Instruction
- func (self *Program) RDTSCP() *Instruction
- func (self *Program) RET(vv ...interface{}) *Instruction
- func (self *Program) ROLB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ROLL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ROLQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) ROLW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RORB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RORL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RORQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RORW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RORXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) RORXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) ROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) RSQRTPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) RSQRTSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SALB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SALL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SALQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SALW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SARB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SARL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SARQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SARW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SARXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SARXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SBBB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SBBL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SBBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SBBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SETA(v0 interface{}) *Instruction
- func (self *Program) SETAE(v0 interface{}) *Instruction
- func (self *Program) SETB(v0 interface{}) *Instruction
- func (self *Program) SETBE(v0 interface{}) *Instruction
- func (self *Program) SETC(v0 interface{}) *Instruction
- func (self *Program) SETE(v0 interface{}) *Instruction
- func (self *Program) SETG(v0 interface{}) *Instruction
- func (self *Program) SETGE(v0 interface{}) *Instruction
- func (self *Program) SETL(v0 interface{}) *Instruction
- func (self *Program) SETLE(v0 interface{}) *Instruction
- func (self *Program) SETNA(v0 interface{}) *Instruction
- func (self *Program) SETNAE(v0 interface{}) *Instruction
- func (self *Program) SETNB(v0 interface{}) *Instruction
- func (self *Program) SETNBE(v0 interface{}) *Instruction
- func (self *Program) SETNC(v0 interface{}) *Instruction
- func (self *Program) SETNE(v0 interface{}) *Instruction
- func (self *Program) SETNG(v0 interface{}) *Instruction
- func (self *Program) SETNGE(v0 interface{}) *Instruction
- func (self *Program) SETNL(v0 interface{}) *Instruction
- func (self *Program) SETNLE(v0 interface{}) *Instruction
- func (self *Program) SETNO(v0 interface{}) *Instruction
- func (self *Program) SETNP(v0 interface{}) *Instruction
- func (self *Program) SETNS(v0 interface{}) *Instruction
- func (self *Program) SETNZ(v0 interface{}) *Instruction
- func (self *Program) SETO(v0 interface{}) *Instruction
- func (self *Program) SETP(v0 interface{}) *Instruction
- func (self *Program) SETPE(v0 interface{}) *Instruction
- func (self *Program) SETPO(v0 interface{}) *Instruction
- func (self *Program) SETS(v0 interface{}) *Instruction
- func (self *Program) SETZ(v0 interface{}) *Instruction
- func (self *Program) SFENCE() *Instruction
- func (self *Program) SHA1MSG1(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHA1MSG2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHA1NEXTE(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHA1RNDS4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHA256MSG1(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHA256MSG2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHA256RNDS2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHLB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHLDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHLDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHLL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHLQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHLW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHLXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHLXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHRB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHRDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHRDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHRDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHRL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHRQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHRW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SHRXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHRXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHUFPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SHUFPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) SQRTPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SQRTPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SQRTSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SQRTSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) STC() *Instruction
- func (self *Program) STD() *Instruction
- func (self *Program) STMXCSR(v0 interface{}) *Instruction
- func (self *Program) SUBB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SUBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) SYSCALL() *Instruction
- func (self *Program) T1MSKC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TESTB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TESTL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TESTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TESTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TZCNTL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TZCNTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TZCNTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) TZMSK(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) UCOMISD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) UCOMISS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) UD2() *Instruction
- func (self *Program) UNPCKHPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) UNPCKHPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) UNPCKLPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) UNPCKLPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VADDPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VADDPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VADDSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VADDSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VAESDEC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VAESDECLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VAESENC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VAESENCLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VAESIMC(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VAESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VALIGND(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VALIGNQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VANDNPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VANDNPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VANDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VANDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VBLENDMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VBLENDMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VBLENDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VBLENDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VBLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VBLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VBROADCASTF128(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTF32X2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTF32X4(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTF32X8(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTF64X2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTF64X4(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTI128(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTI32X2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTI32X4(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTI32X8(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTI64X2(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTI64X4(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VBROADCASTSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VCMPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VCMPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VCMPSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VCMPSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCOMPRESSPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VCOMPRESSPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VCVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VCVTDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPD2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPH2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPS2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPS2PH(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSD2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSS2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTUDQ2PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VCVTUDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTUQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTUQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTUSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VCVTUSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VDBPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VDIVPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VDIVPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VDIVSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VDIVSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VDPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VDPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VEXP2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VEXP2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VEXPANDPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VEXPANDPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VEXTRACTF128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTF32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTF32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTF64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTF64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTI128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTI32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTI32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTI64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTI64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VEXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VFIXUPIMMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VFIXUPIMMPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VFIXUPIMMSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VFIXUPIMMSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VFMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMADDSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFMSUBADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMSUBADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VFNMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFNMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VFPCLASSPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VFPCLASSPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VFPCLASSSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VFPCLASSSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VFRCZPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VFRCZPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VFRCZSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VFRCZSS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VGATHERDPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGATHERDPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGATHERPF0DPD(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF0DPS(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF0QPD(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF0QPS(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF1DPD(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF1DPS(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF1QPD(v0 interface{}) *Instruction
- func (self *Program) VGATHERPF1QPS(v0 interface{}) *Instruction
- func (self *Program) VGATHERQPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGATHERQPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETEXPPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETEXPPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETEXPSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETEXPSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETMANTPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETMANTPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VGETMANTSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VGETMANTSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VHADDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VHADDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VHSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VHSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VINSERTF128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTF32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTF64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTI128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTI32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTI64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VINSERTPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VLDDQU(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VLDMXCSR(v0 interface{}) *Instruction
- func (self *Program) VMASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMASKMOVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VMASKMOVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VMAXPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMAXPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMAXSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMAXSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMINPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMINPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMINSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMINSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVAPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVAPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDDUP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQA(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQA32(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQA64(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQU(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQU16(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQU32(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQU64(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVDQU8(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVHLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VMOVHPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVHPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVLHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VMOVLPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVLPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVMSKPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVMSKPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVNTDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVNTDQA(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVNTPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVNTPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVSD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVSHDUP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVSLDUP(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVSS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMOVUPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMOVUPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VMPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VMULPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMULPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMULSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VMULSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPABSB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPABSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPABSQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPABSW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPACKSSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPACKSSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPACKUSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPACKUSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPALIGNR(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPAND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPANDN(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPAVGB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPAVGW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPBLENDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPBLENDMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPBLENDMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPBLENDMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPBLENDMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPBLENDW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPBROADCASTB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPBROADCASTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPBROADCASTMB2Q(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPBROADCASTMW2D(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPBROADCASTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPBROADCASTW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMOV(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPEQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPEQD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPEQQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPEQW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPGTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPGTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPGTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPGTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPCMPQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCMPW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMPRESSD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPCOMPRESSQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPCOMQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCOMW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPCONFLICTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPCONFLICTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPERM2F128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPERM2I128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPERMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMI2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMI2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMI2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMI2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMI2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMI2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMIL2PD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction
- func (self *Program) VPERMIL2PS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction
- func (self *Program) VPERMILPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMILPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMT2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMT2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMT2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMT2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMT2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMT2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPERMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPEXPANDD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPEXPANDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPGATHERDD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VPGATHERDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VPGATHERQD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VPGATHERQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VPHADDBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPHADDDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPHADDUBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDUBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDUBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDUDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDUWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDUWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPHADDWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHADDWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHSUBBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPHSUBDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPHSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPHSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPHSUBWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPINSRB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPINSRD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPINSRQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPINSRW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPLZCNTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPLZCNTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMACSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMACSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMADCSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMADCSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPMADD52HUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMADD52LUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMADDUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMADDWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMASKMOVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMASKMOVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMAXUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMINUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMOVB2M(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVD2M(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVM2B(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVM2D(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVM2Q(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVM2W(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVMSKB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVQ2M(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVQB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVQD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVQW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSQB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSQD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSQW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSWB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSXBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSXBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSXWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVUSDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVUSDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVUSQB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVUSQD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVUSQW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVUSWB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVW2M(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVWB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVZXBD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVZXBW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVZXWD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPMULDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULHRSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULHUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULTISHIFTQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPMULUDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPOPCNTD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPOPCNTQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPPERM(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPROLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPRORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPRORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPRORVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPRORVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPROTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSCATTERDD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPSCATTERDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPSCATTERQD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPSCATTERQQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPSHAB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHUFB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSIGNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSIGND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSIGNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSLLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRAVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRAVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRAVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSRLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTERNLOGD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPTERNLOGQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VPTEST(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VPTESTMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTNMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTNMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTNMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPTESTNMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKHBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKHDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKHQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKHWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKLBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKLQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPUNPCKLWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPXOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VPXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VRANGEPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VRANGEPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VRANGESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VRANGESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VRCP14PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VRCP14PS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VRCP14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VRCP14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VRCP28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRCP28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRCP28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRCP28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRCPPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VRCPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VREDUCEPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VREDUCEPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VREDUCESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VREDUCESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VRNDSCALEPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRNDSCALEPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRNDSCALESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VRNDSCALESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, ...) *Instruction
- func (self *Program) VROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VRSQRT14PD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VRSQRT14PS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VRSQRT14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VRSQRT14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VRSQRT28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRSQRT28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRSQRT28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRSQRT28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VRSQRTPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VRSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VSCALEFPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSCALEFPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSCALEFSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSCALEFSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSCATTERDPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VSCATTERDPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VSCATTERPF0DPD(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF0DPS(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF0QPD(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF0QPS(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF1DPD(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF1DPS(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF1QPD(v0 interface{}) *Instruction
- func (self *Program) VSCATTERPF1QPS(v0 interface{}) *Instruction
- func (self *Program) VSCATTERQPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VSCATTERQPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VSHUFF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VSHUFF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VSHUFI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VSHUFI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VSHUFPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VSHUFPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
- func (self *Program) VSQRTPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSQRTPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSQRTSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSTMXCSR(v0 interface{}) *Instruction
- func (self *Program) VSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VTESTPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VTESTPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) VUCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VUCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
- func (self *Program) VUNPCKHPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VUNPCKHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VUNPCKLPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VUNPCKLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VXORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VXORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
- func (self *Program) VZEROALL() *Instruction
- func (self *Program) VZEROUPPER() *Instruction
- func (self *Program) Word(v *expr.Expr) (p *Instruction)
- func (self *Program) XADDB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XADDL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XADDQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XADDW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XCHGB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XCHGL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XCHGQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XCHGW(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XGETBV() *Instruction
- func (self *Program) XLATB() *Instruction
- func (self *Program) XORB(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XORL(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XORPD(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XORPS(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XORQ(v0 interface{}, v1 interface{}) *Instruction
- func (self *Program) XORW(v0 interface{}, v1 interface{}) *Instruction
- type Register
- type Register16
- type Register32
- type Register64
- type Register8
- type RegisterMask
- type RelativeOffset
- type RoundingControl
- type SyntaxError
- type XMMRegister
- type YMMRegister
- type ZMMRegister
Constants ¶
const ( AH = SPL | 0x80 CH = BPL | 0x80 DH = SIL | 0x80 BH = DIL | 0x80 )
Variables ¶
var DefaultArch = CreateArch()
DefaultArch is the default architecture with all ISA enabled.
var Instructions = map[string]_InstructionEncoder{}/* 1364 elements not displayed */
Instructions maps all the instruction name to it's encoder function.
var Registers = map[string]Register{}/* 180 elements not displayed */
Registers maps register name into Register instances.
Functions ¶
This section is empty.
Types ¶
type AddressType ¶
type AddressType uint
AddressType indicates which kind of value that an Addressable object contains.
const ( // None indicates the Addressable does not contain any addressable value. None AddressType = iota // Memory indicates the Addressable contains a memory address. Memory // Offset indicates the Addressable contains an RIP-relative offset. Offset // Reference indicates the Addressable contains a label reference. Reference )
type Addressable ¶
type Addressable struct { Type AddressType Memory MemoryAddress Offset RelativeOffset Reference *Label }
Addressable is a union to represent an addressable operand.
func (*Addressable) String ¶
func (self *Addressable) String() string
String implements the fmt.Stringer interface.
type Arch ¶
type Arch struct {
// contains filtered or unexported fields
}
Arch represents the x86_64 architecture.
func (*Arch) CreateProgram ¶
CreateProgram creates a new empty program.
func (*Arch) DisableISA ¶
DisableISA disables a particular ISA.
type Assembler ¶
type Assembler struct {
// contains filtered or unexported fields
}
Assembler assembles the entire assembly program and generates the corresponding machine code representations.
func (*Assembler) Assemble ¶
Assemble assembles the assembly source and save the machine code to internal buffer.
func (*Assembler) Entry ¶
Entry returns the address of the specified entry point, or the origin if not specified.
type Disposable ¶
type Disposable interface {
Free()
}
Disposable is a type of object that can be Free'd manually.
type ExceptionControl ¶
type ExceptionControl uint8
ExceptionControl represents the "Suppress All Exceptions" flag.
const ( // SAE represents the flag "Suppress All Exceptions" for floating point operations. SAE ExceptionControl = iota )
func (ExceptionControl) String ¶
func (ExceptionControl) String() string
type ISA ¶
type ISA uint64
ISA represents an extension to x86-64 instruction set.
const ( ISA_CPUID ISA = 1 << iota ISA_RDTSC ISA_RDTSCP ISA_CMOV ISA_MOVBE ISA_POPCNT ISA_LZCNT ISA_TBM ISA_BMI ISA_BMI2 ISA_ADX ISA_MMX ISA_MMX_PLUS ISA_FEMMS ISA_3DNOW ISA_3DNOW_PLUS ISA_SSE ISA_SSE2 ISA_SSE3 ISA_SSSE3 ISA_SSE4A ISA_SSE4_1 ISA_SSE4_2 ISA_FMA3 ISA_FMA4 ISA_XOP ISA_F16C ISA_AVX ISA_AVX2 ISA_AVX512F ISA_AVX512BW ISA_AVX512DQ ISA_AVX512VL ISA_AVX512PF ISA_AVX512ER ISA_AVX512CD ISA_AVX512VBMI ISA_AVX512IFMA ISA_AVX512VPOPCNTDQ ISA_AVX512_4VNNIW ISA_AVX512_4FMAPS ISA_PREFETCH ISA_PREFETCHW ISA_PREFETCHWT1 ISA_CLFLUSH ISA_CLFLUSHOPT ISA_CLWB ISA_CLZERO ISA_RDRAND ISA_RDSEED ISA_PCLMULQDQ ISA_AES ISA_SHA ISA_MONITOR ISA_MONITORX ISA_ALL = ^ISA(0) )
type Instruction ¶
type Instruction struct {
// contains filtered or unexported fields
}
Instruction represents an unencoded instruction.
func (*Instruction) CS ¶
func (self *Instruction) CS() *Instruction
CS overrides the memory operation of this instruction to CS.
func (*Instruction) DS ¶
func (self *Instruction) DS() *Instruction
DS overrides the memory operation of this instruction to DS, this is the default section for most instructions if not specified.
func (*Instruction) Domain ¶
func (self *Instruction) Domain() InstructionDomain
Domain returns the domain of this instruction.
func (*Instruction) ES ¶
func (self *Instruction) ES() *Instruction
ES overrides the memory operation of this instruction to ES.
func (*Instruction) FS ¶
func (self *Instruction) FS() *Instruction
FS overrides the memory operation of this instruction to FS.
func (*Instruction) GS ¶
func (self *Instruction) GS() *Instruction
GS overrides the memory operation of this instruction to GS.
func (*Instruction) LOCK ¶
func (self *Instruction) LOCK() *Instruction
LOCK causes the processor's LOCK# signal to be asserted during execution of the accompanying instruction (turns the instruction into an atomic instruction). In a multiprocessor environment, the LOCK# signal insures that the processor has exclusive use of any shared memory while the signal is asserted.
func (*Instruction) Name ¶
func (self *Instruction) Name() string
Name returns the instruction name.
func (*Instruction) Operands ¶
func (self *Instruction) Operands() []interface{}
Operands returns the operands of this instruction.
func (*Instruction) SS ¶
func (self *Instruction) SS() *Instruction
SS overrides the memory operation of this instruction to SS.
type InstructionDomain ¶
type InstructionDomain uint8
InstructionDomain represents the domain of an instruction.
const ( DomainGeneric InstructionDomain = iota DomainMMXSSE DomainAVX DomainFMA DomainCrypto DomainMask DomainAMDSpecific DomainMisc DomainPseudo )
type InstructionPrefix ¶
type InstructionPrefix byte
InstructionPrefix indicates the prefix bytes prepended to the instruction.
const ( // PrefixLock causes the processor's LOCK# signal to be asserted during execution of // the accompanying instruction (turns the instruction into an atomic instruction). // In a multiprocessor environment, the LOCK# signal insures that the processor // has exclusive use of any shared memory while the signal is asserted. PrefixLock InstructionPrefix = iota // PrefixSegmentCS overrides the memory operation of this instruction to CS (Code Segment). PrefixSegmentCS // PrefixSegmentDS overrides the memory operation of this instruction to DS (Data Segment), // this is the default section for most instructions if not specified. PrefixSegmentDS // PrefixSegmentES overrides the memory operation of this instruction to ES (Extra Segment). PrefixSegmentES // PrefixSegmentFS overrides the memory operation of this instruction to FS. PrefixSegmentFS // PrefixSegmentGS overrides the memory operation of this instruction to GS. PrefixSegmentGS // PrefixSegmentSS overrides the memory operation of this instruction to SS (Stack Segment). PrefixSegmentSS )
type Label ¶
type Label struct { Name string Dest *Instruction // contains filtered or unexported fields }
Label represents a location within the program.
func CreateLabel ¶
CreateLabel creates a new Label, it may allocate a new one or grab one from a pool.
func (*Label) Free ¶
func (self *Label) Free()
Free decreases the reference count of a Label, if the refcount drops to 0, the Label will be recycled.
type LabelKind ¶
type LabelKind int
LabelKind indicates the type of label reference.
const ( // Declaration means the label is a declaration. Declaration LabelKind = iota + 1 // BranchTarget means the label should be treated as a branch target. BranchTarget // RelativeAddress means the label should be treated as a reference to // the code section (e.g. RIP-relative addressing). RelativeAddress )
type MMRegister ¶
type MMRegister byte
const ( MM0 MMRegister = iota MM1 MM2 MM3 MM4 MM5 MM6 MM7 )
func (MMRegister) String ¶
func (self MMRegister) String() string
type MaskedRegister ¶
type MaskedRegister struct { Reg Register Mask RegisterMask }
MaskedRegister is a Register masked by a RegisterMask.
func (MaskedRegister) String ¶
func (self MaskedRegister) String() string
String implements the fmt.Stringer interface.
type MemoryAddress ¶
MemoryAddress represents a memory address.
func (*MemoryAddress) EnsureValid ¶
func (self *MemoryAddress) EnsureValid()
EnsureValid checks if the memory address is valid, if not, it panics.
func (*MemoryAddress) String ¶
func (self *MemoryAddress) String() string
String implements the fmt.Stringer interface.
type MemoryOperand ¶
type MemoryOperand struct { Size int Addr Addressable Mask RegisterMask Masked bool Broadcast uint8 // contains filtered or unexported fields }
MemoryOperand represents a memory operand for an instruction.
func Abs ¶
func Abs(disp int32) *MemoryOperand
Abs construct a simple memory address that represents absolute addressing.
func CreateMemoryOperand ¶
func CreateMemoryOperand() *MemoryOperand
CreateMemoryOperand creates a new MemoryOperand, it may allocate a new one or grab one from a pool.
func Ptr ¶
func Ptr(base Register, disp int32) *MemoryOperand
Ptr constructs a simple memory operand with base and displacement.
func Sib ¶
func Sib(base Register, index Register, scale uint8, disp int32) (v *MemoryOperand)
Sib constructs a simple memory operand that represents a complete memory address.
func (*MemoryOperand) EnsureValid ¶
func (self *MemoryOperand) EnsureValid()
EnsureValid checks if the memory operand is valid, if not, it panics.
func (*MemoryOperand) Free ¶
func (self *MemoryOperand) Free()
Free decreases the reference count of a MemoryOperand, if the refcount drops to 0, the Label will be recycled.
func (*MemoryOperand) Retain ¶
func (self *MemoryOperand) Retain() *MemoryOperand
Retain increases the reference count of a MemoryOperand.
func (*MemoryOperand) String ¶
func (self *MemoryOperand) String() string
String implements the fmt.Stringer interface.
type OperandKind ¶
type OperandKind int
OperandKind indicates the type of the operand.
const ( // OpImm means the operand is an immediate value. OpImm OperandKind = 1 << iota // OpReg means the operand is a register. OpReg // OpMem means the operand is a memory address. OpMem // OpLabel means the operand is a label, specifically for // branch instructions. OpLabel )
type Operands ¶
type Operands [_N_args]interface{}
Operands represents a sequence of operand required by an instruction.
type Options ¶
type Options struct { // InstructionAliasing specifies whether to enable instruction aliasing. // Set to true enables instruction aliasing, and the Assembler will try harder to find instructions. InstructionAliasing bool // IgnoreUnknownDirectives specifies whether to report errors when encountered unknown directives. // Set to true ignores all unknwon directives silently, useful for parsing generated assembly. IgnoreUnknownDirectives bool }
Options controls the behavior of Assembler.
type ParsedCommand ¶
type ParsedCommand struct { Cmd string Args []ParsedCommandArg }
ParsedCommand represents a parsed assembly directive command.
type ParsedCommandArg ¶
ParsedCommandArg represents an argument of a ParsedCommand.
type ParsedInstruction ¶
type ParsedInstruction struct { Mnemonic string Operands []ParsedOperand Prefixes []InstructionPrefix }
ParsedInstruction represents an instruction in the source.
type ParsedLabel ¶
ParsedLabel represents a label in the source, either a jump target or an RIP-relative addressing.
type ParsedLine ¶
type ParsedLine struct { Row int Src []rune Kind LineKind Label ParsedLabel Command ParsedCommand Instruction ParsedInstruction }
ParsedLine represents a parsed source line.
type ParsedOperand ¶
type ParsedOperand struct { Op OperandKind Imm int64 Reg Register Label ParsedLabel Memory MemoryAddress }
ParsedOperand represents an operand of an instruction in the source.
type Parser ¶
type Parser struct {
// contains filtered or unexported fields
}
Parser parses the source, and generates a sequence of ParsedInstruction's.
func (*Parser) Feed ¶
func (self *Parser) Feed(src string) (ret *ParsedLine, err error)
Feed feeds the parser with one more line, and the parser parses it into a ParsedLine.
NOTE: Feed does not handle empty lines or multiple lines,
it panics when this happens. Use Parse to parse multiple lines of assembly source.
type Program ¶
type Program struct {
// contains filtered or unexported fields
}
Program represents a sequence of instructions.
func (*Program) ADCB ¶
func (self *Program) ADCB(v0 interface{}, v1 interface{}) *Instruction
ADCB performs "Add with Carry".
Mnemonic : ADC Supported forms : (6 forms)
- ADCB imm8, al
- ADCB imm8, r8
- ADCB r8, r8
- ADCB m8, r8
- ADCB imm8, m8
- ADCB r8, m8
func (*Program) ADCL ¶
func (self *Program) ADCL(v0 interface{}, v1 interface{}) *Instruction
ADCL performs "Add with Carry".
Mnemonic : ADC Supported forms : (8 forms)
- ADCL imm32, eax
- ADCL imm8, r32
- ADCL imm32, r32
- ADCL r32, r32
- ADCL m32, r32
- ADCL imm8, m32
- ADCL imm32, m32
- ADCL r32, m32
func (*Program) ADCQ ¶
func (self *Program) ADCQ(v0 interface{}, v1 interface{}) *Instruction
ADCQ performs "Add with Carry".
Mnemonic : ADC Supported forms : (8 forms)
- ADCQ imm32, rax
- ADCQ imm8, r64
- ADCQ imm32, r64
- ADCQ r64, r64
- ADCQ m64, r64
- ADCQ imm8, m64
- ADCQ imm32, m64
- ADCQ r64, m64
func (*Program) ADCW ¶
func (self *Program) ADCW(v0 interface{}, v1 interface{}) *Instruction
ADCW performs "Add with Carry".
Mnemonic : ADC Supported forms : (8 forms)
- ADCW imm16, ax
- ADCW imm8, r16
- ADCW imm16, r16
- ADCW r16, r16
- ADCW m16, r16
- ADCW imm8, m16
- ADCW imm16, m16
- ADCW r16, m16
func (*Program) ADCXL ¶
func (self *Program) ADCXL(v0 interface{}, v1 interface{}) *Instruction
ADCXL performs "Unsigned Integer Addition of Two Operands with Carry Flag".
Mnemonic : ADCX Supported forms : (2 forms)
- ADCXL r32, r32 [ADX]
- ADCXL m32, r32 [ADX]
func (*Program) ADCXQ ¶
func (self *Program) ADCXQ(v0 interface{}, v1 interface{}) *Instruction
ADCXQ performs "Unsigned Integer Addition of Two Operands with Carry Flag".
Mnemonic : ADCX Supported forms : (2 forms)
- ADCXQ r64, r64 [ADX]
- ADCXQ m64, r64 [ADX]
func (*Program) ADDB ¶
func (self *Program) ADDB(v0 interface{}, v1 interface{}) *Instruction
ADDB performs "Add".
Mnemonic : ADD Supported forms : (6 forms)
- ADDB imm8, al
- ADDB imm8, r8
- ADDB r8, r8
- ADDB m8, r8
- ADDB imm8, m8
- ADDB r8, m8
func (*Program) ADDL ¶
func (self *Program) ADDL(v0 interface{}, v1 interface{}) *Instruction
ADDL performs "Add".
Mnemonic : ADD Supported forms : (8 forms)
- ADDL imm32, eax
- ADDL imm8, r32
- ADDL imm32, r32
- ADDL r32, r32
- ADDL m32, r32
- ADDL imm8, m32
- ADDL imm32, m32
- ADDL r32, m32
func (*Program) ADDPD ¶
func (self *Program) ADDPD(v0 interface{}, v1 interface{}) *Instruction
ADDPD performs "Add Packed Double-Precision Floating-Point Values".
Mnemonic : ADDPD Supported forms : (2 forms)
- ADDPD xmm, xmm [SSE2]
- ADDPD m128, xmm [SSE2]
func (*Program) ADDPS ¶
func (self *Program) ADDPS(v0 interface{}, v1 interface{}) *Instruction
ADDPS performs "Add Packed Single-Precision Floating-Point Values".
Mnemonic : ADDPS Supported forms : (2 forms)
- ADDPS xmm, xmm [SSE]
- ADDPS m128, xmm [SSE]
func (*Program) ADDQ ¶
func (self *Program) ADDQ(v0 interface{}, v1 interface{}) *Instruction
ADDQ performs "Add".
Mnemonic : ADD Supported forms : (8 forms)
- ADDQ imm32, rax
- ADDQ imm8, r64
- ADDQ imm32, r64
- ADDQ r64, r64
- ADDQ m64, r64
- ADDQ imm8, m64
- ADDQ imm32, m64
- ADDQ r64, m64
func (*Program) ADDSD ¶
func (self *Program) ADDSD(v0 interface{}, v1 interface{}) *Instruction
ADDSD performs "Add Scalar Double-Precision Floating-Point Values".
Mnemonic : ADDSD Supported forms : (2 forms)
- ADDSD xmm, xmm [SSE2]
- ADDSD m64, xmm [SSE2]
func (*Program) ADDSS ¶
func (self *Program) ADDSS(v0 interface{}, v1 interface{}) *Instruction
ADDSS performs "Add Scalar Single-Precision Floating-Point Values".
Mnemonic : ADDSS Supported forms : (2 forms)
- ADDSS xmm, xmm [SSE]
- ADDSS m32, xmm [SSE]
func (*Program) ADDSUBPD ¶
func (self *Program) ADDSUBPD(v0 interface{}, v1 interface{}) *Instruction
ADDSUBPD performs "Packed Double-FP Add/Subtract".
Mnemonic : ADDSUBPD Supported forms : (2 forms)
- ADDSUBPD xmm, xmm [SSE3]
- ADDSUBPD m128, xmm [SSE3]
func (*Program) ADDSUBPS ¶
func (self *Program) ADDSUBPS(v0 interface{}, v1 interface{}) *Instruction
ADDSUBPS performs "Packed Single-FP Add/Subtract".
Mnemonic : ADDSUBPS Supported forms : (2 forms)
- ADDSUBPS xmm, xmm [SSE3]
- ADDSUBPS m128, xmm [SSE3]
func (*Program) ADDW ¶
func (self *Program) ADDW(v0 interface{}, v1 interface{}) *Instruction
ADDW performs "Add".
Mnemonic : ADD Supported forms : (8 forms)
- ADDW imm16, ax
- ADDW imm8, r16
- ADDW imm16, r16
- ADDW r16, r16
- ADDW m16, r16
- ADDW imm8, m16
- ADDW imm16, m16
- ADDW r16, m16
func (*Program) ADOXL ¶
func (self *Program) ADOXL(v0 interface{}, v1 interface{}) *Instruction
ADOXL performs "Unsigned Integer Addition of Two Operands with Overflow Flag".
Mnemonic : ADOX Supported forms : (2 forms)
- ADOXL r32, r32 [ADX]
- ADOXL m32, r32 [ADX]
func (*Program) ADOXQ ¶
func (self *Program) ADOXQ(v0 interface{}, v1 interface{}) *Instruction
ADOXQ performs "Unsigned Integer Addition of Two Operands with Overflow Flag".
Mnemonic : ADOX Supported forms : (2 forms)
- ADOXQ r64, r64 [ADX]
- ADOXQ m64, r64 [ADX]
func (*Program) AESDEC ¶
func (self *Program) AESDEC(v0 interface{}, v1 interface{}) *Instruction
AESDEC performs "Perform One Round of an AES Decryption Flow".
Mnemonic : AESDEC Supported forms : (2 forms)
- AESDEC xmm, xmm [AES]
- AESDEC m128, xmm [AES]
func (*Program) AESDECLAST ¶
func (self *Program) AESDECLAST(v0 interface{}, v1 interface{}) *Instruction
AESDECLAST performs "Perform Last Round of an AES Decryption Flow".
Mnemonic : AESDECLAST Supported forms : (2 forms)
- AESDECLAST xmm, xmm [AES]
- AESDECLAST m128, xmm [AES]
func (*Program) AESENC ¶
func (self *Program) AESENC(v0 interface{}, v1 interface{}) *Instruction
AESENC performs "Perform One Round of an AES Encryption Flow".
Mnemonic : AESENC Supported forms : (2 forms)
- AESENC xmm, xmm [AES]
- AESENC m128, xmm [AES]
func (*Program) AESENCLAST ¶
func (self *Program) AESENCLAST(v0 interface{}, v1 interface{}) *Instruction
AESENCLAST performs "Perform Last Round of an AES Encryption Flow".
Mnemonic : AESENCLAST Supported forms : (2 forms)
- AESENCLAST xmm, xmm [AES]
- AESENCLAST m128, xmm [AES]
func (*Program) AESIMC ¶
func (self *Program) AESIMC(v0 interface{}, v1 interface{}) *Instruction
AESIMC performs "Perform the AES InvMixColumn Transformation".
Mnemonic : AESIMC Supported forms : (2 forms)
- AESIMC xmm, xmm [AES]
- AESIMC m128, xmm [AES]
func (*Program) AESKEYGENASSIST ¶
func (self *Program) AESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
AESKEYGENASSIST performs "AES Round Key Generation Assist".
Mnemonic : AESKEYGENASSIST Supported forms : (2 forms)
- AESKEYGENASSIST imm8, xmm, xmm [AES]
- AESKEYGENASSIST imm8, m128, xmm [AES]
func (*Program) ANDB ¶
func (self *Program) ANDB(v0 interface{}, v1 interface{}) *Instruction
ANDB performs "Logical AND".
Mnemonic : AND Supported forms : (6 forms)
- ANDB imm8, al
- ANDB imm8, r8
- ANDB r8, r8
- ANDB m8, r8
- ANDB imm8, m8
- ANDB r8, m8
func (*Program) ANDL ¶
func (self *Program) ANDL(v0 interface{}, v1 interface{}) *Instruction
ANDL performs "Logical AND".
Mnemonic : AND Supported forms : (8 forms)
- ANDL imm32, eax
- ANDL imm8, r32
- ANDL imm32, r32
- ANDL r32, r32
- ANDL m32, r32
- ANDL imm8, m32
- ANDL imm32, m32
- ANDL r32, m32
func (*Program) ANDNL ¶
func (self *Program) ANDNL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
ANDNL performs "Logical AND NOT".
Mnemonic : ANDN Supported forms : (2 forms)
- ANDNL r32, r32, r32 [BMI]
- ANDNL m32, r32, r32 [BMI]
func (*Program) ANDNPD ¶
func (self *Program) ANDNPD(v0 interface{}, v1 interface{}) *Instruction
ANDNPD performs "Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values".
Mnemonic : ANDNPD Supported forms : (2 forms)
- ANDNPD xmm, xmm [SSE2]
- ANDNPD m128, xmm [SSE2]
func (*Program) ANDNPS ¶
func (self *Program) ANDNPS(v0 interface{}, v1 interface{}) *Instruction
ANDNPS performs "Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values".
Mnemonic : ANDNPS Supported forms : (2 forms)
- ANDNPS xmm, xmm [SSE]
- ANDNPS m128, xmm [SSE]
func (*Program) ANDNQ ¶
func (self *Program) ANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
ANDNQ performs "Logical AND NOT".
Mnemonic : ANDN Supported forms : (2 forms)
- ANDNQ r64, r64, r64 [BMI]
- ANDNQ m64, r64, r64 [BMI]
func (*Program) ANDPD ¶
func (self *Program) ANDPD(v0 interface{}, v1 interface{}) *Instruction
ANDPD performs "Bitwise Logical AND of Packed Double-Precision Floating-Point Values".
Mnemonic : ANDPD Supported forms : (2 forms)
- ANDPD xmm, xmm [SSE2]
- ANDPD m128, xmm [SSE2]
func (*Program) ANDPS ¶
func (self *Program) ANDPS(v0 interface{}, v1 interface{}) *Instruction
ANDPS performs "Bitwise Logical AND of Packed Single-Precision Floating-Point Values".
Mnemonic : ANDPS Supported forms : (2 forms)
- ANDPS xmm, xmm [SSE]
- ANDPS m128, xmm [SSE]
func (*Program) ANDQ ¶
func (self *Program) ANDQ(v0 interface{}, v1 interface{}) *Instruction
ANDQ performs "Logical AND".
Mnemonic : AND Supported forms : (8 forms)
- ANDQ imm32, rax
- ANDQ imm8, r64
- ANDQ imm32, r64
- ANDQ r64, r64
- ANDQ m64, r64
- ANDQ imm8, m64
- ANDQ imm32, m64
- ANDQ r64, m64
func (*Program) ANDW ¶
func (self *Program) ANDW(v0 interface{}, v1 interface{}) *Instruction
ANDW performs "Logical AND".
Mnemonic : AND Supported forms : (8 forms)
- ANDW imm16, ax
- ANDW imm8, r16
- ANDW imm16, r16
- ANDW r16, r16
- ANDW m16, r16
- ANDW imm8, m16
- ANDW imm16, m16
- ANDW r16, m16
func (*Program) Align ¶
func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction)
Align is a pseudo-instruction to ensure the PC is aligned to a certain value.
func (*Program) AssembleAndFree ¶
AssembleAndFree is like Assemble, but it frees the Program after assembling.
func (*Program) BEXTR ¶
func (self *Program) BEXTR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
BEXTR performs "Bit Field Extract".
Mnemonic : BEXTR Supported forms : (8 forms)
- BEXTR imm32, r32, r32 [TBM]
- BEXTR imm32, m32, r32 [TBM]
- BEXTR imm32, r64, r64 [TBM]
- BEXTR imm32, m64, r64 [TBM]
- BEXTR r32, r32, r32 [BMI]
- BEXTR r32, m32, r32 [BMI]
- BEXTR r64, r64, r64 [BMI]
- BEXTR r64, m64, r64 [BMI]
func (*Program) BLCFILL ¶
func (self *Program) BLCFILL(v0 interface{}, v1 interface{}) *Instruction
BLCFILL performs "Fill From Lowest Clear Bit".
Mnemonic : BLCFILL Supported forms : (4 forms)
- BLCFILL r32, r32 [TBM]
- BLCFILL m32, r32 [TBM]
- BLCFILL r64, r64 [TBM]
- BLCFILL m64, r64 [TBM]
func (*Program) BLCI ¶
func (self *Program) BLCI(v0 interface{}, v1 interface{}) *Instruction
BLCI performs "Isolate Lowest Clear Bit".
Mnemonic : BLCI Supported forms : (4 forms)
- BLCI r32, r32 [TBM]
- BLCI m32, r32 [TBM]
- BLCI r64, r64 [TBM]
- BLCI m64, r64 [TBM]
func (*Program) BLCIC ¶
func (self *Program) BLCIC(v0 interface{}, v1 interface{}) *Instruction
BLCIC performs "Isolate Lowest Set Bit and Complement".
Mnemonic : BLCIC Supported forms : (4 forms)
- BLCIC r32, r32 [TBM]
- BLCIC m32, r32 [TBM]
- BLCIC r64, r64 [TBM]
- BLCIC m64, r64 [TBM]
func (*Program) BLCMSK ¶
func (self *Program) BLCMSK(v0 interface{}, v1 interface{}) *Instruction
BLCMSK performs "Mask From Lowest Clear Bit".
Mnemonic : BLCMSK Supported forms : (4 forms)
- BLCMSK r32, r32 [TBM]
- BLCMSK m32, r32 [TBM]
- BLCMSK r64, r64 [TBM]
- BLCMSK m64, r64 [TBM]
func (*Program) BLCS ¶
func (self *Program) BLCS(v0 interface{}, v1 interface{}) *Instruction
BLCS performs "Set Lowest Clear Bit".
Mnemonic : BLCS Supported forms : (4 forms)
- BLCS r32, r32 [TBM]
- BLCS m32, r32 [TBM]
- BLCS r64, r64 [TBM]
- BLCS m64, r64 [TBM]
func (*Program) BLENDPD ¶
func (self *Program) BLENDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
BLENDPD performs "Blend Packed Double Precision Floating-Point Values".
Mnemonic : BLENDPD Supported forms : (2 forms)
- BLENDPD imm8, xmm, xmm [SSE4.1]
- BLENDPD imm8, m128, xmm [SSE4.1]
func (*Program) BLENDPS ¶
func (self *Program) BLENDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
BLENDPS performs " Blend Packed Single Precision Floating-Point Values".
Mnemonic : BLENDPS Supported forms : (2 forms)
- BLENDPS imm8, xmm, xmm [SSE4.1]
- BLENDPS imm8, m128, xmm [SSE4.1]
func (*Program) BLENDVPD ¶
func (self *Program) BLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
BLENDVPD performs " Variable Blend Packed Double Precision Floating-Point Values".
Mnemonic : BLENDVPD Supported forms : (2 forms)
- BLENDVPD xmm0, xmm, xmm [SSE4.1]
- BLENDVPD xmm0, m128, xmm [SSE4.1]
func (*Program) BLENDVPS ¶
func (self *Program) BLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
BLENDVPS performs " Variable Blend Packed Single Precision Floating-Point Values".
Mnemonic : BLENDVPS Supported forms : (2 forms)
- BLENDVPS xmm0, xmm, xmm [SSE4.1]
- BLENDVPS xmm0, m128, xmm [SSE4.1]
func (*Program) BLSFILL ¶
func (self *Program) BLSFILL(v0 interface{}, v1 interface{}) *Instruction
BLSFILL performs "Fill From Lowest Set Bit".
Mnemonic : BLSFILL Supported forms : (4 forms)
- BLSFILL r32, r32 [TBM]
- BLSFILL m32, r32 [TBM]
- BLSFILL r64, r64 [TBM]
- BLSFILL m64, r64 [TBM]
func (*Program) BLSI ¶
func (self *Program) BLSI(v0 interface{}, v1 interface{}) *Instruction
BLSI performs "Isolate Lowest Set Bit".
Mnemonic : BLSI Supported forms : (4 forms)
- BLSI r32, r32 [BMI]
- BLSI m32, r32 [BMI]
- BLSI r64, r64 [BMI]
- BLSI m64, r64 [BMI]
func (*Program) BLSIC ¶
func (self *Program) BLSIC(v0 interface{}, v1 interface{}) *Instruction
BLSIC performs "Isolate Lowest Set Bit and Complement".
Mnemonic : BLSIC Supported forms : (4 forms)
- BLSIC r32, r32 [TBM]
- BLSIC m32, r32 [TBM]
- BLSIC r64, r64 [TBM]
- BLSIC m64, r64 [TBM]
func (*Program) BLSMSK ¶
func (self *Program) BLSMSK(v0 interface{}, v1 interface{}) *Instruction
BLSMSK performs "Mask From Lowest Set Bit".
Mnemonic : BLSMSK Supported forms : (4 forms)
- BLSMSK r32, r32 [BMI]
- BLSMSK m32, r32 [BMI]
- BLSMSK r64, r64 [BMI]
- BLSMSK m64, r64 [BMI]
func (*Program) BLSR ¶
func (self *Program) BLSR(v0 interface{}, v1 interface{}) *Instruction
BLSR performs "Reset Lowest Set Bit".
Mnemonic : BLSR Supported forms : (4 forms)
- BLSR r32, r32 [BMI]
- BLSR m32, r32 [BMI]
- BLSR r64, r64 [BMI]
- BLSR m64, r64 [BMI]
func (*Program) BSFL ¶
func (self *Program) BSFL(v0 interface{}, v1 interface{}) *Instruction
BSFL performs "Bit Scan Forward".
Mnemonic : BSF Supported forms : (2 forms)
- BSFL r32, r32
- BSFL m32, r32
func (*Program) BSFQ ¶
func (self *Program) BSFQ(v0 interface{}, v1 interface{}) *Instruction
BSFQ performs "Bit Scan Forward".
Mnemonic : BSF Supported forms : (2 forms)
- BSFQ r64, r64
- BSFQ m64, r64
func (*Program) BSFW ¶
func (self *Program) BSFW(v0 interface{}, v1 interface{}) *Instruction
BSFW performs "Bit Scan Forward".
Mnemonic : BSF Supported forms : (2 forms)
- BSFW r16, r16
- BSFW m16, r16
func (*Program) BSRL ¶
func (self *Program) BSRL(v0 interface{}, v1 interface{}) *Instruction
BSRL performs "Bit Scan Reverse".
Mnemonic : BSR Supported forms : (2 forms)
- BSRL r32, r32
- BSRL m32, r32
func (*Program) BSRQ ¶
func (self *Program) BSRQ(v0 interface{}, v1 interface{}) *Instruction
BSRQ performs "Bit Scan Reverse".
Mnemonic : BSR Supported forms : (2 forms)
- BSRQ r64, r64
- BSRQ m64, r64
func (*Program) BSRW ¶
func (self *Program) BSRW(v0 interface{}, v1 interface{}) *Instruction
BSRW performs "Bit Scan Reverse".
Mnemonic : BSR Supported forms : (2 forms)
- BSRW r16, r16
- BSRW m16, r16
func (*Program) BSWAPL ¶
func (self *Program) BSWAPL(v0 interface{}) *Instruction
BSWAPL performs "Byte Swap".
Mnemonic : BSWAP Supported forms : (1 form)
- BSWAPL r32
func (*Program) BSWAPQ ¶
func (self *Program) BSWAPQ(v0 interface{}) *Instruction
BSWAPQ performs "Byte Swap".
Mnemonic : BSWAP Supported forms : (1 form)
- BSWAPQ r64
func (*Program) BTCL ¶
func (self *Program) BTCL(v0 interface{}, v1 interface{}) *Instruction
BTCL performs "Bit Test and Complement".
Mnemonic : BTC Supported forms : (4 forms)
- BTCL imm8, r32
- BTCL r32, r32
- BTCL imm8, m32
- BTCL r32, m32
func (*Program) BTCQ ¶
func (self *Program) BTCQ(v0 interface{}, v1 interface{}) *Instruction
BTCQ performs "Bit Test and Complement".
Mnemonic : BTC Supported forms : (4 forms)
- BTCQ imm8, r64
- BTCQ r64, r64
- BTCQ imm8, m64
- BTCQ r64, m64
func (*Program) BTCW ¶
func (self *Program) BTCW(v0 interface{}, v1 interface{}) *Instruction
BTCW performs "Bit Test and Complement".
Mnemonic : BTC Supported forms : (4 forms)
- BTCW imm8, r16
- BTCW r16, r16
- BTCW imm8, m16
- BTCW r16, m16
func (*Program) BTL ¶
func (self *Program) BTL(v0 interface{}, v1 interface{}) *Instruction
BTL performs "Bit Test".
Mnemonic : BT Supported forms : (4 forms)
- BTL imm8, r32
- BTL r32, r32
- BTL imm8, m32
- BTL r32, m32
func (*Program) BTQ ¶
func (self *Program) BTQ(v0 interface{}, v1 interface{}) *Instruction
BTQ performs "Bit Test".
Mnemonic : BT Supported forms : (4 forms)
- BTQ imm8, r64
- BTQ r64, r64
- BTQ imm8, m64
- BTQ r64, m64
func (*Program) BTRL ¶
func (self *Program) BTRL(v0 interface{}, v1 interface{}) *Instruction
BTRL performs "Bit Test and Reset".
Mnemonic : BTR Supported forms : (4 forms)
- BTRL imm8, r32
- BTRL r32, r32
- BTRL imm8, m32
- BTRL r32, m32
func (*Program) BTRQ ¶
func (self *Program) BTRQ(v0 interface{}, v1 interface{}) *Instruction
BTRQ performs "Bit Test and Reset".
Mnemonic : BTR Supported forms : (4 forms)
- BTRQ imm8, r64
- BTRQ r64, r64
- BTRQ imm8, m64
- BTRQ r64, m64
func (*Program) BTRW ¶
func (self *Program) BTRW(v0 interface{}, v1 interface{}) *Instruction
BTRW performs "Bit Test and Reset".
Mnemonic : BTR Supported forms : (4 forms)
- BTRW imm8, r16
- BTRW r16, r16
- BTRW imm8, m16
- BTRW r16, m16
func (*Program) BTSL ¶
func (self *Program) BTSL(v0 interface{}, v1 interface{}) *Instruction
BTSL performs "Bit Test and Set".
Mnemonic : BTS Supported forms : (4 forms)
- BTSL imm8, r32
- BTSL r32, r32
- BTSL imm8, m32
- BTSL r32, m32
func (*Program) BTSQ ¶
func (self *Program) BTSQ(v0 interface{}, v1 interface{}) *Instruction
BTSQ performs "Bit Test and Set".
Mnemonic : BTS Supported forms : (4 forms)
- BTSQ imm8, r64
- BTSQ r64, r64
- BTSQ imm8, m64
- BTSQ r64, m64
func (*Program) BTSW ¶
func (self *Program) BTSW(v0 interface{}, v1 interface{}) *Instruction
BTSW performs "Bit Test and Set".
Mnemonic : BTS Supported forms : (4 forms)
- BTSW imm8, r16
- BTSW r16, r16
- BTSW imm8, m16
- BTSW r16, m16
func (*Program) BTW ¶
func (self *Program) BTW(v0 interface{}, v1 interface{}) *Instruction
BTW performs "Bit Test".
Mnemonic : BT Supported forms : (4 forms)
- BTW imm8, r16
- BTW r16, r16
- BTW imm8, m16
- BTW r16, m16
func (*Program) BZHI ¶
func (self *Program) BZHI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
BZHI performs "Zero High Bits Starting with Specified Bit Position".
Mnemonic : BZHI Supported forms : (4 forms)
- BZHI r32, r32, r32 [BMI2]
- BZHI r32, m32, r32 [BMI2]
- BZHI r64, r64, r64 [BMI2]
- BZHI r64, m64, r64 [BMI2]
func (*Program) Byte ¶
func (self *Program) Byte(v *expr.Expr) (p *Instruction)
Byte is a pseudo-instruction to add raw byte to the assembled code.
func (*Program) CALL ¶
func (self *Program) CALL(v0 interface{}) *Instruction
CALL performs "Call Procedure".
Mnemonic : CALL Supported forms : (1 form)
- CALL rel32
func (*Program) CALLQ ¶
func (self *Program) CALLQ(v0 interface{}) *Instruction
CALLQ performs "Call Procedure".
Mnemonic : CALL Supported forms : (2 forms)
- CALLQ r64
- CALLQ m64
func (*Program) CBTW ¶
func (self *Program) CBTW() *Instruction
CBTW performs "Convert Byte to Word".
Mnemonic : CBW Supported forms : (1 form)
- CBTW
func (*Program) CLC ¶
func (self *Program) CLC() *Instruction
CLC performs "Clear Carry Flag".
Mnemonic : CLC Supported forms : (1 form)
- CLC
func (*Program) CLD ¶
func (self *Program) CLD() *Instruction
CLD performs "Clear Direction Flag".
Mnemonic : CLD Supported forms : (1 form)
- CLD
func (*Program) CLFLUSH ¶
func (self *Program) CLFLUSH(v0 interface{}) *Instruction
CLFLUSH performs "Flush Cache Line".
Mnemonic : CLFLUSH Supported forms : (1 form)
- CLFLUSH m8 [CLFLUSH]
func (*Program) CLFLUSHOPT ¶
func (self *Program) CLFLUSHOPT(v0 interface{}) *Instruction
CLFLUSHOPT performs "Flush Cache Line Optimized".
Mnemonic : CLFLUSHOPT Supported forms : (1 form)
- CLFLUSHOPT m8 [CLFLUSHOPT]
func (*Program) CLTD ¶
func (self *Program) CLTD() *Instruction
CLTD performs "Convert Doubleword to Quadword".
Mnemonic : CDQ Supported forms : (1 form)
- CLTD
func (*Program) CLTQ ¶
func (self *Program) CLTQ() *Instruction
CLTQ performs "Convert Doubleword to Quadword".
Mnemonic : CDQE Supported forms : (1 form)
- CLTQ
func (*Program) CLWB ¶
func (self *Program) CLWB(v0 interface{}) *Instruction
CLWB performs "Cache Line Write Back".
Mnemonic : CLWB Supported forms : (1 form)
- CLWB m8 [CLWB]
func (*Program) CLZERO ¶
func (self *Program) CLZERO() *Instruction
CLZERO performs "Zero-out 64-bit Cache Line".
Mnemonic : CLZERO Supported forms : (1 form)
- CLZERO [CLZERO]
func (*Program) CMC ¶
func (self *Program) CMC() *Instruction
CMC performs "Complement Carry Flag".
Mnemonic : CMC Supported forms : (1 form)
- CMC
func (*Program) CMOVA ¶
func (self *Program) CMOVA(v0 interface{}, v1 interface{}) *Instruction
CMOVA performs "Move if above (CF == 0 and ZF == 0)".
Mnemonic : CMOVA Supported forms : (6 forms)
- CMOVA r16, r16 [CMOV]
- CMOVA m16, r16 [CMOV]
- CMOVA r32, r32 [CMOV]
- CMOVA m32, r32 [CMOV]
- CMOVA r64, r64 [CMOV]
- CMOVA m64, r64 [CMOV]
func (*Program) CMOVAE ¶
func (self *Program) CMOVAE(v0 interface{}, v1 interface{}) *Instruction
CMOVAE performs "Move if above or equal (CF == 0)".
Mnemonic : CMOVAE Supported forms : (6 forms)
- CMOVAE r16, r16 [CMOV]
- CMOVAE m16, r16 [CMOV]
- CMOVAE r32, r32 [CMOV]
- CMOVAE m32, r32 [CMOV]
- CMOVAE r64, r64 [CMOV]
- CMOVAE m64, r64 [CMOV]
func (*Program) CMOVB ¶
func (self *Program) CMOVB(v0 interface{}, v1 interface{}) *Instruction
CMOVB performs "Move if below (CF == 1)".
Mnemonic : CMOVB Supported forms : (6 forms)
- CMOVB r16, r16 [CMOV]
- CMOVB m16, r16 [CMOV]
- CMOVB r32, r32 [CMOV]
- CMOVB m32, r32 [CMOV]
- CMOVB r64, r64 [CMOV]
- CMOVB m64, r64 [CMOV]
func (*Program) CMOVBE ¶
func (self *Program) CMOVBE(v0 interface{}, v1 interface{}) *Instruction
CMOVBE performs "Move if below or equal (CF == 1 or ZF == 1)".
Mnemonic : CMOVBE Supported forms : (6 forms)
- CMOVBE r16, r16 [CMOV]
- CMOVBE m16, r16 [CMOV]
- CMOVBE r32, r32 [CMOV]
- CMOVBE m32, r32 [CMOV]
- CMOVBE r64, r64 [CMOV]
- CMOVBE m64, r64 [CMOV]
func (*Program) CMOVC ¶
func (self *Program) CMOVC(v0 interface{}, v1 interface{}) *Instruction
CMOVC performs "Move if carry (CF == 1)".
Mnemonic : CMOVC Supported forms : (6 forms)
- CMOVC r16, r16 [CMOV]
- CMOVC m16, r16 [CMOV]
- CMOVC r32, r32 [CMOV]
- CMOVC m32, r32 [CMOV]
- CMOVC r64, r64 [CMOV]
- CMOVC m64, r64 [CMOV]
func (*Program) CMOVE ¶
func (self *Program) CMOVE(v0 interface{}, v1 interface{}) *Instruction
CMOVE performs "Move if equal (ZF == 1)".
Mnemonic : CMOVE Supported forms : (6 forms)
- CMOVE r16, r16 [CMOV]
- CMOVE m16, r16 [CMOV]
- CMOVE r32, r32 [CMOV]
- CMOVE m32, r32 [CMOV]
- CMOVE r64, r64 [CMOV]
- CMOVE m64, r64 [CMOV]
func (*Program) CMOVG ¶
func (self *Program) CMOVG(v0 interface{}, v1 interface{}) *Instruction
CMOVG performs "Move if greater (ZF == 0 and SF == OF)".
Mnemonic : CMOVG Supported forms : (6 forms)
- CMOVG r16, r16 [CMOV]
- CMOVG m16, r16 [CMOV]
- CMOVG r32, r32 [CMOV]
- CMOVG m32, r32 [CMOV]
- CMOVG r64, r64 [CMOV]
- CMOVG m64, r64 [CMOV]
func (*Program) CMOVGE ¶
func (self *Program) CMOVGE(v0 interface{}, v1 interface{}) *Instruction
CMOVGE performs "Move if greater or equal (SF == OF)".
Mnemonic : CMOVGE Supported forms : (6 forms)
- CMOVGE r16, r16 [CMOV]
- CMOVGE m16, r16 [CMOV]
- CMOVGE r32, r32 [CMOV]
- CMOVGE m32, r32 [CMOV]
- CMOVGE r64, r64 [CMOV]
- CMOVGE m64, r64 [CMOV]
func (*Program) CMOVL ¶
func (self *Program) CMOVL(v0 interface{}, v1 interface{}) *Instruction
CMOVL performs "Move if less (SF != OF)".
Mnemonic : CMOVL Supported forms : (6 forms)
- CMOVL r16, r16 [CMOV]
- CMOVL m16, r16 [CMOV]
- CMOVL r32, r32 [CMOV]
- CMOVL m32, r32 [CMOV]
- CMOVL r64, r64 [CMOV]
- CMOVL m64, r64 [CMOV]
func (*Program) CMOVLE ¶
func (self *Program) CMOVLE(v0 interface{}, v1 interface{}) *Instruction
CMOVLE performs "Move if less or equal (ZF == 1 or SF != OF)".
Mnemonic : CMOVLE Supported forms : (6 forms)
- CMOVLE r16, r16 [CMOV]
- CMOVLE m16, r16 [CMOV]
- CMOVLE r32, r32 [CMOV]
- CMOVLE m32, r32 [CMOV]
- CMOVLE r64, r64 [CMOV]
- CMOVLE m64, r64 [CMOV]
func (*Program) CMOVNA ¶
func (self *Program) CMOVNA(v0 interface{}, v1 interface{}) *Instruction
CMOVNA performs "Move if not above (CF == 1 or ZF == 1)".
Mnemonic : CMOVNA Supported forms : (6 forms)
- CMOVNA r16, r16 [CMOV]
- CMOVNA m16, r16 [CMOV]
- CMOVNA r32, r32 [CMOV]
- CMOVNA m32, r32 [CMOV]
- CMOVNA r64, r64 [CMOV]
- CMOVNA m64, r64 [CMOV]
func (*Program) CMOVNAE ¶
func (self *Program) CMOVNAE(v0 interface{}, v1 interface{}) *Instruction
CMOVNAE performs "Move if not above or equal (CF == 1)".
Mnemonic : CMOVNAE Supported forms : (6 forms)
- CMOVNAE r16, r16 [CMOV]
- CMOVNAE m16, r16 [CMOV]
- CMOVNAE r32, r32 [CMOV]
- CMOVNAE m32, r32 [CMOV]
- CMOVNAE r64, r64 [CMOV]
- CMOVNAE m64, r64 [CMOV]
func (*Program) CMOVNB ¶
func (self *Program) CMOVNB(v0 interface{}, v1 interface{}) *Instruction
CMOVNB performs "Move if not below (CF == 0)".
Mnemonic : CMOVNB Supported forms : (6 forms)
- CMOVNB r16, r16 [CMOV]
- CMOVNB m16, r16 [CMOV]
- CMOVNB r32, r32 [CMOV]
- CMOVNB m32, r32 [CMOV]
- CMOVNB r64, r64 [CMOV]
- CMOVNB m64, r64 [CMOV]
func (*Program) CMOVNBE ¶
func (self *Program) CMOVNBE(v0 interface{}, v1 interface{}) *Instruction
CMOVNBE performs "Move if not below or equal (CF == 0 and ZF == 0)".
Mnemonic : CMOVNBE Supported forms : (6 forms)
- CMOVNBE r16, r16 [CMOV]
- CMOVNBE m16, r16 [CMOV]
- CMOVNBE r32, r32 [CMOV]
- CMOVNBE m32, r32 [CMOV]
- CMOVNBE r64, r64 [CMOV]
- CMOVNBE m64, r64 [CMOV]
func (*Program) CMOVNC ¶
func (self *Program) CMOVNC(v0 interface{}, v1 interface{}) *Instruction
CMOVNC performs "Move if not carry (CF == 0)".
Mnemonic : CMOVNC Supported forms : (6 forms)
- CMOVNC r16, r16 [CMOV]
- CMOVNC m16, r16 [CMOV]
- CMOVNC r32, r32 [CMOV]
- CMOVNC m32, r32 [CMOV]
- CMOVNC r64, r64 [CMOV]
- CMOVNC m64, r64 [CMOV]
func (*Program) CMOVNE ¶
func (self *Program) CMOVNE(v0 interface{}, v1 interface{}) *Instruction
CMOVNE performs "Move if not equal (ZF == 0)".
Mnemonic : CMOVNE Supported forms : (6 forms)
- CMOVNE r16, r16 [CMOV]
- CMOVNE m16, r16 [CMOV]
- CMOVNE r32, r32 [CMOV]
- CMOVNE m32, r32 [CMOV]
- CMOVNE r64, r64 [CMOV]
- CMOVNE m64, r64 [CMOV]
func (*Program) CMOVNG ¶
func (self *Program) CMOVNG(v0 interface{}, v1 interface{}) *Instruction
CMOVNG performs "Move if not greater (ZF == 1 or SF != OF)".
Mnemonic : CMOVNG Supported forms : (6 forms)
- CMOVNG r16, r16 [CMOV]
- CMOVNG m16, r16 [CMOV]
- CMOVNG r32, r32 [CMOV]
- CMOVNG m32, r32 [CMOV]
- CMOVNG r64, r64 [CMOV]
- CMOVNG m64, r64 [CMOV]
func (*Program) CMOVNGE ¶
func (self *Program) CMOVNGE(v0 interface{}, v1 interface{}) *Instruction
CMOVNGE performs "Move if not greater or equal (SF != OF)".
Mnemonic : CMOVNGE Supported forms : (6 forms)
- CMOVNGE r16, r16 [CMOV]
- CMOVNGE m16, r16 [CMOV]
- CMOVNGE r32, r32 [CMOV]
- CMOVNGE m32, r32 [CMOV]
- CMOVNGE r64, r64 [CMOV]
- CMOVNGE m64, r64 [CMOV]
func (*Program) CMOVNL ¶
func (self *Program) CMOVNL(v0 interface{}, v1 interface{}) *Instruction
CMOVNL performs "Move if not less (SF == OF)".
Mnemonic : CMOVNL Supported forms : (6 forms)
- CMOVNL r16, r16 [CMOV]
- CMOVNL m16, r16 [CMOV]
- CMOVNL r32, r32 [CMOV]
- CMOVNL m32, r32 [CMOV]
- CMOVNL r64, r64 [CMOV]
- CMOVNL m64, r64 [CMOV]
func (*Program) CMOVNLE ¶
func (self *Program) CMOVNLE(v0 interface{}, v1 interface{}) *Instruction
CMOVNLE performs "Move if not less or equal (ZF == 0 and SF == OF)".
Mnemonic : CMOVNLE Supported forms : (6 forms)
- CMOVNLE r16, r16 [CMOV]
- CMOVNLE m16, r16 [CMOV]
- CMOVNLE r32, r32 [CMOV]
- CMOVNLE m32, r32 [CMOV]
- CMOVNLE r64, r64 [CMOV]
- CMOVNLE m64, r64 [CMOV]
func (*Program) CMOVNO ¶
func (self *Program) CMOVNO(v0 interface{}, v1 interface{}) *Instruction
CMOVNO performs "Move if not overflow (OF == 0)".
Mnemonic : CMOVNO Supported forms : (6 forms)
- CMOVNO r16, r16 [CMOV]
- CMOVNO m16, r16 [CMOV]
- CMOVNO r32, r32 [CMOV]
- CMOVNO m32, r32 [CMOV]
- CMOVNO r64, r64 [CMOV]
- CMOVNO m64, r64 [CMOV]
func (*Program) CMOVNP ¶
func (self *Program) CMOVNP(v0 interface{}, v1 interface{}) *Instruction
CMOVNP performs "Move if not parity (PF == 0)".
Mnemonic : CMOVNP Supported forms : (6 forms)
- CMOVNP r16, r16 [CMOV]
- CMOVNP m16, r16 [CMOV]
- CMOVNP r32, r32 [CMOV]
- CMOVNP m32, r32 [CMOV]
- CMOVNP r64, r64 [CMOV]
- CMOVNP m64, r64 [CMOV]
func (*Program) CMOVNS ¶
func (self *Program) CMOVNS(v0 interface{}, v1 interface{}) *Instruction
CMOVNS performs "Move if not sign (SF == 0)".
Mnemonic : CMOVNS Supported forms : (6 forms)
- CMOVNS r16, r16 [CMOV]
- CMOVNS m16, r16 [CMOV]
- CMOVNS r32, r32 [CMOV]
- CMOVNS m32, r32 [CMOV]
- CMOVNS r64, r64 [CMOV]
- CMOVNS m64, r64 [CMOV]
func (*Program) CMOVNZ ¶
func (self *Program) CMOVNZ(v0 interface{}, v1 interface{}) *Instruction
CMOVNZ performs "Move if not zero (ZF == 0)".
Mnemonic : CMOVNZ Supported forms : (6 forms)
- CMOVNZ r16, r16 [CMOV]
- CMOVNZ m16, r16 [CMOV]
- CMOVNZ r32, r32 [CMOV]
- CMOVNZ m32, r32 [CMOV]
- CMOVNZ r64, r64 [CMOV]
- CMOVNZ m64, r64 [CMOV]
func (*Program) CMOVO ¶
func (self *Program) CMOVO(v0 interface{}, v1 interface{}) *Instruction
CMOVO performs "Move if overflow (OF == 1)".
Mnemonic : CMOVO Supported forms : (6 forms)
- CMOVO r16, r16 [CMOV]
- CMOVO m16, r16 [CMOV]
- CMOVO r32, r32 [CMOV]
- CMOVO m32, r32 [CMOV]
- CMOVO r64, r64 [CMOV]
- CMOVO m64, r64 [CMOV]
func (*Program) CMOVP ¶
func (self *Program) CMOVP(v0 interface{}, v1 interface{}) *Instruction
CMOVP performs "Move if parity (PF == 1)".
Mnemonic : CMOVP Supported forms : (6 forms)
- CMOVP r16, r16 [CMOV]
- CMOVP m16, r16 [CMOV]
- CMOVP r32, r32 [CMOV]
- CMOVP m32, r32 [CMOV]
- CMOVP r64, r64 [CMOV]
- CMOVP m64, r64 [CMOV]
func (*Program) CMOVPE ¶
func (self *Program) CMOVPE(v0 interface{}, v1 interface{}) *Instruction
CMOVPE performs "Move if parity even (PF == 1)".
Mnemonic : CMOVPE Supported forms : (6 forms)
- CMOVPE r16, r16 [CMOV]
- CMOVPE m16, r16 [CMOV]
- CMOVPE r32, r32 [CMOV]
- CMOVPE m32, r32 [CMOV]
- CMOVPE r64, r64 [CMOV]
- CMOVPE m64, r64 [CMOV]
func (*Program) CMOVPO ¶
func (self *Program) CMOVPO(v0 interface{}, v1 interface{}) *Instruction
CMOVPO performs "Move if parity odd (PF == 0)".
Mnemonic : CMOVPO Supported forms : (6 forms)
- CMOVPO r16, r16 [CMOV]
- CMOVPO m16, r16 [CMOV]
- CMOVPO r32, r32 [CMOV]
- CMOVPO m32, r32 [CMOV]
- CMOVPO r64, r64 [CMOV]
- CMOVPO m64, r64 [CMOV]
func (*Program) CMOVS ¶
func (self *Program) CMOVS(v0 interface{}, v1 interface{}) *Instruction
CMOVS performs "Move if sign (SF == 1)".
Mnemonic : CMOVS Supported forms : (6 forms)
- CMOVS r16, r16 [CMOV]
- CMOVS m16, r16 [CMOV]
- CMOVS r32, r32 [CMOV]
- CMOVS m32, r32 [CMOV]
- CMOVS r64, r64 [CMOV]
- CMOVS m64, r64 [CMOV]
func (*Program) CMOVZ ¶
func (self *Program) CMOVZ(v0 interface{}, v1 interface{}) *Instruction
CMOVZ performs "Move if zero (ZF == 1)".
Mnemonic : CMOVZ Supported forms : (6 forms)
- CMOVZ r16, r16 [CMOV]
- CMOVZ m16, r16 [CMOV]
- CMOVZ r32, r32 [CMOV]
- CMOVZ m32, r32 [CMOV]
- CMOVZ r64, r64 [CMOV]
- CMOVZ m64, r64 [CMOV]
func (*Program) CMPB ¶
func (self *Program) CMPB(v0 interface{}, v1 interface{}) *Instruction
CMPB performs "Compare Two Operands".
Mnemonic : CMP Supported forms : (6 forms)
- CMPB imm8, al
- CMPB imm8, r8
- CMPB r8, r8
- CMPB m8, r8
- CMPB imm8, m8
- CMPB r8, m8
func (*Program) CMPL ¶
func (self *Program) CMPL(v0 interface{}, v1 interface{}) *Instruction
CMPL performs "Compare Two Operands".
Mnemonic : CMP Supported forms : (8 forms)
- CMPL imm32, eax
- CMPL imm8, r32
- CMPL imm32, r32
- CMPL r32, r32
- CMPL m32, r32
- CMPL imm8, m32
- CMPL imm32, m32
- CMPL r32, m32
func (*Program) CMPPD ¶
func (self *Program) CMPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
CMPPD performs "Compare Packed Double-Precision Floating-Point Values".
Mnemonic : CMPPD Supported forms : (2 forms)
- CMPPD imm8, xmm, xmm [SSE2]
- CMPPD imm8, m128, xmm [SSE2]
func (*Program) CMPPS ¶
func (self *Program) CMPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
CMPPS performs "Compare Packed Single-Precision Floating-Point Values".
Mnemonic : CMPPS Supported forms : (2 forms)
- CMPPS imm8, xmm, xmm [SSE]
- CMPPS imm8, m128, xmm [SSE]
func (*Program) CMPQ ¶
func (self *Program) CMPQ(v0 interface{}, v1 interface{}) *Instruction
CMPQ performs "Compare Two Operands".
Mnemonic : CMP Supported forms : (8 forms)
- CMPQ imm32, rax
- CMPQ imm8, r64
- CMPQ imm32, r64
- CMPQ r64, r64
- CMPQ m64, r64
- CMPQ imm8, m64
- CMPQ imm32, m64
- CMPQ r64, m64
func (*Program) CMPSD ¶
func (self *Program) CMPSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
CMPSD performs "Compare Scalar Double-Precision Floating-Point Values".
Mnemonic : CMPSD Supported forms : (2 forms)
- CMPSD imm8, xmm, xmm [SSE2]
- CMPSD imm8, m64, xmm [SSE2]
func (*Program) CMPSS ¶
func (self *Program) CMPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
CMPSS performs "Compare Scalar Single-Precision Floating-Point Values".
Mnemonic : CMPSS Supported forms : (2 forms)
- CMPSS imm8, xmm, xmm [SSE]
- CMPSS imm8, m32, xmm [SSE]
func (*Program) CMPW ¶
func (self *Program) CMPW(v0 interface{}, v1 interface{}) *Instruction
CMPW performs "Compare Two Operands".
Mnemonic : CMP Supported forms : (8 forms)
- CMPW imm16, ax
- CMPW imm8, r16
- CMPW imm16, r16
- CMPW r16, r16
- CMPW m16, r16
- CMPW imm8, m16
- CMPW imm16, m16
- CMPW r16, m16
func (*Program) CMPXCHG16B ¶
func (self *Program) CMPXCHG16B(v0 interface{}) *Instruction
CMPXCHG16B performs "Compare and Exchange 16 Bytes".
Mnemonic : CMPXCHG16B Supported forms : (1 form)
- CMPXCHG16B m128
func (*Program) CMPXCHG8B ¶
func (self *Program) CMPXCHG8B(v0 interface{}) *Instruction
CMPXCHG8B performs "Compare and Exchange 8 Bytes".
Mnemonic : CMPXCHG8B Supported forms : (1 form)
- CMPXCHG8B m64
func (*Program) CMPXCHGB ¶
func (self *Program) CMPXCHGB(v0 interface{}, v1 interface{}) *Instruction
CMPXCHGB performs "Compare and Exchange".
Mnemonic : CMPXCHG Supported forms : (2 forms)
- CMPXCHGB r8, r8
- CMPXCHGB r8, m8
func (*Program) CMPXCHGL ¶
func (self *Program) CMPXCHGL(v0 interface{}, v1 interface{}) *Instruction
CMPXCHGL performs "Compare and Exchange".
Mnemonic : CMPXCHG Supported forms : (2 forms)
- CMPXCHGL r32, r32
- CMPXCHGL r32, m32
func (*Program) CMPXCHGQ ¶
func (self *Program) CMPXCHGQ(v0 interface{}, v1 interface{}) *Instruction
CMPXCHGQ performs "Compare and Exchange".
Mnemonic : CMPXCHG Supported forms : (2 forms)
- CMPXCHGQ r64, r64
- CMPXCHGQ r64, m64
func (*Program) CMPXCHGW ¶
func (self *Program) CMPXCHGW(v0 interface{}, v1 interface{}) *Instruction
CMPXCHGW performs "Compare and Exchange".
Mnemonic : CMPXCHG Supported forms : (2 forms)
- CMPXCHGW r16, r16
- CMPXCHGW r16, m16
func (*Program) COMISD ¶
func (self *Program) COMISD(v0 interface{}, v1 interface{}) *Instruction
COMISD performs "Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : COMISD Supported forms : (2 forms)
- COMISD xmm, xmm [SSE2]
- COMISD m64, xmm [SSE2]
func (*Program) COMISS ¶
func (self *Program) COMISS(v0 interface{}, v1 interface{}) *Instruction
COMISS performs "Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : COMISS Supported forms : (2 forms)
- COMISS xmm, xmm [SSE]
- COMISS m32, xmm [SSE]
func (*Program) CPUID ¶
func (self *Program) CPUID() *Instruction
CPUID performs "CPU Identification".
Mnemonic : CPUID Supported forms : (1 form)
- CPUID [CPUID]
func (*Program) CQTO ¶
func (self *Program) CQTO() *Instruction
CQTO performs "Convert Quadword to Octaword".
Mnemonic : CQO Supported forms : (1 form)
- CQTO
func (*Program) CRC32B ¶
func (self *Program) CRC32B(v0 interface{}, v1 interface{}) *Instruction
CRC32B performs "Accumulate CRC32 Value".
Mnemonic : CRC32 Supported forms : (4 forms)
- CRC32B r8, r32 [SSE4.2]
- CRC32B m8, r32 [SSE4.2]
- CRC32B r8, r64 [SSE4.2]
- CRC32B m8, r64 [SSE4.2]
func (*Program) CRC32L ¶
func (self *Program) CRC32L(v0 interface{}, v1 interface{}) *Instruction
CRC32L performs "Accumulate CRC32 Value".
Mnemonic : CRC32 Supported forms : (2 forms)
- CRC32L r32, r32 [SSE4.2]
- CRC32L m32, r32 [SSE4.2]
func (*Program) CRC32Q ¶
func (self *Program) CRC32Q(v0 interface{}, v1 interface{}) *Instruction
CRC32Q performs "Accumulate CRC32 Value".
Mnemonic : CRC32 Supported forms : (2 forms)
- CRC32Q r64, r64 [SSE4.2]
- CRC32Q m64, r64 [SSE4.2]
func (*Program) CRC32W ¶
func (self *Program) CRC32W(v0 interface{}, v1 interface{}) *Instruction
CRC32W performs "Accumulate CRC32 Value".
Mnemonic : CRC32 Supported forms : (2 forms)
- CRC32W r16, r32 [SSE4.2]
- CRC32W m16, r32 [SSE4.2]
func (*Program) CVTDQ2PD ¶
func (self *Program) CVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction
CVTDQ2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".
Mnemonic : CVTDQ2PD Supported forms : (2 forms)
- CVTDQ2PD xmm, xmm [SSE2]
- CVTDQ2PD m64, xmm [SSE2]
func (*Program) CVTDQ2PS ¶
func (self *Program) CVTDQ2PS(v0 interface{}, v1 interface{}) *Instruction
CVTDQ2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".
Mnemonic : CVTDQ2PS Supported forms : (2 forms)
- CVTDQ2PS xmm, xmm [SSE2]
- CVTDQ2PS m128, xmm [SSE2]
func (*Program) CVTPD2DQ ¶
func (self *Program) CVTPD2DQ(v0 interface{}, v1 interface{}) *Instruction
CVTPD2DQ performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTPD2DQ Supported forms : (2 forms)
- CVTPD2DQ xmm, xmm [SSE2]
- CVTPD2DQ m128, xmm [SSE2]
func (*Program) CVTPD2PI ¶
func (self *Program) CVTPD2PI(v0 interface{}, v1 interface{}) *Instruction
CVTPD2PI performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTPD2PI Supported forms : (2 forms)
- CVTPD2PI xmm, mm [SSE]
- CVTPD2PI m128, mm [SSE]
func (*Program) CVTPD2PS ¶
func (self *Program) CVTPD2PS(v0 interface{}, v1 interface{}) *Instruction
CVTPD2PS performs "Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values".
Mnemonic : CVTPD2PS Supported forms : (2 forms)
- CVTPD2PS xmm, xmm [SSE2]
- CVTPD2PS m128, xmm [SSE2]
func (*Program) CVTPI2PD ¶
func (self *Program) CVTPI2PD(v0 interface{}, v1 interface{}) *Instruction
CVTPI2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".
Mnemonic : CVTPI2PD Supported forms : (2 forms)
- CVTPI2PD mm, xmm [SSE2]
- CVTPI2PD m64, xmm [SSE2]
func (*Program) CVTPI2PS ¶
func (self *Program) CVTPI2PS(v0 interface{}, v1 interface{}) *Instruction
CVTPI2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".
Mnemonic : CVTPI2PS Supported forms : (2 forms)
- CVTPI2PS mm, xmm [SSE]
- CVTPI2PS m64, xmm [SSE]
func (*Program) CVTPS2DQ ¶
func (self *Program) CVTPS2DQ(v0 interface{}, v1 interface{}) *Instruction
CVTPS2DQ performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTPS2DQ Supported forms : (2 forms)
- CVTPS2DQ xmm, xmm [SSE2]
- CVTPS2DQ m128, xmm [SSE2]
func (*Program) CVTPS2PD ¶
func (self *Program) CVTPS2PD(v0 interface{}, v1 interface{}) *Instruction
CVTPS2PD performs "Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values".
Mnemonic : CVTPS2PD Supported forms : (2 forms)
- CVTPS2PD xmm, xmm [SSE2]
- CVTPS2PD m64, xmm [SSE2]
func (*Program) CVTPS2PI ¶
func (self *Program) CVTPS2PI(v0 interface{}, v1 interface{}) *Instruction
CVTPS2PI performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTPS2PI Supported forms : (2 forms)
- CVTPS2PI xmm, mm [SSE]
- CVTPS2PI m64, mm [SSE]
func (*Program) CVTSD2SI ¶
func (self *Program) CVTSD2SI(v0 interface{}, v1 interface{}) *Instruction
CVTSD2SI performs "Convert Scalar Double-Precision FP Value to Integer".
Mnemonic : CVTSD2SI Supported forms : (4 forms)
- CVTSD2SI xmm, r32 [SSE2]
- CVTSD2SI m64, r32 [SSE2]
- CVTSD2SI xmm, r64 [SSE2]
- CVTSD2SI m64, r64 [SSE2]
func (*Program) CVTSD2SS ¶
func (self *Program) CVTSD2SS(v0 interface{}, v1 interface{}) *Instruction
CVTSD2SS performs "Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value".
Mnemonic : CVTSD2SS Supported forms : (2 forms)
- CVTSD2SS xmm, xmm [SSE2]
- CVTSD2SS m64, xmm [SSE2]
func (*Program) CVTSI2SD ¶
func (self *Program) CVTSI2SD(v0 interface{}, v1 interface{}) *Instruction
CVTSI2SD performs "Convert Dword Integer to Scalar Double-Precision FP Value".
Mnemonic : CVTSI2SD Supported forms : (4 forms)
- CVTSI2SD r32, xmm [SSE2]
- CVTSI2SD r64, xmm [SSE2]
- CVTSI2SD m32, xmm [SSE2]
- CVTSI2SD m64, xmm [SSE2]
func (*Program) CVTSI2SS ¶
func (self *Program) CVTSI2SS(v0 interface{}, v1 interface{}) *Instruction
CVTSI2SS performs "Convert Dword Integer to Scalar Single-Precision FP Value".
Mnemonic : CVTSI2SS Supported forms : (4 forms)
- CVTSI2SS r32, xmm [SSE]
- CVTSI2SS r64, xmm [SSE]
- CVTSI2SS m32, xmm [SSE]
- CVTSI2SS m64, xmm [SSE]
func (*Program) CVTSS2SD ¶
func (self *Program) CVTSS2SD(v0 interface{}, v1 interface{}) *Instruction
CVTSS2SD performs "Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value".
Mnemonic : CVTSS2SD Supported forms : (2 forms)
- CVTSS2SD xmm, xmm [SSE2]
- CVTSS2SD m32, xmm [SSE2]
func (*Program) CVTSS2SI ¶
func (self *Program) CVTSS2SI(v0 interface{}, v1 interface{}) *Instruction
CVTSS2SI performs "Convert Scalar Single-Precision FP Value to Dword Integer".
Mnemonic : CVTSS2SI Supported forms : (4 forms)
- CVTSS2SI xmm, r32 [SSE]
- CVTSS2SI m32, r32 [SSE]
- CVTSS2SI xmm, r64 [SSE]
- CVTSS2SI m32, r64 [SSE]
func (*Program) CVTTPD2DQ ¶
func (self *Program) CVTTPD2DQ(v0 interface{}, v1 interface{}) *Instruction
CVTTPD2DQ performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTTPD2DQ Supported forms : (2 forms)
- CVTTPD2DQ xmm, xmm [SSE2]
- CVTTPD2DQ m128, xmm [SSE2]
func (*Program) CVTTPD2PI ¶
func (self *Program) CVTTPD2PI(v0 interface{}, v1 interface{}) *Instruction
CVTTPD2PI performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTTPD2PI Supported forms : (2 forms)
- CVTTPD2PI xmm, mm [SSE2]
- CVTTPD2PI m128, mm [SSE2]
func (*Program) CVTTPS2DQ ¶
func (self *Program) CVTTPS2DQ(v0 interface{}, v1 interface{}) *Instruction
CVTTPS2DQ performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTTPS2DQ Supported forms : (2 forms)
- CVTTPS2DQ xmm, xmm [SSE2]
- CVTTPS2DQ m128, xmm [SSE2]
func (*Program) CVTTPS2PI ¶
func (self *Program) CVTTPS2PI(v0 interface{}, v1 interface{}) *Instruction
CVTTPS2PI performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".
Mnemonic : CVTTPS2PI Supported forms : (2 forms)
- CVTTPS2PI xmm, mm [SSE]
- CVTTPS2PI m64, mm [SSE]
func (*Program) CVTTSD2SI ¶
func (self *Program) CVTTSD2SI(v0 interface{}, v1 interface{}) *Instruction
CVTTSD2SI performs "Convert with Truncation Scalar Double-Precision FP Value to Signed Integer".
Mnemonic : CVTTSD2SI Supported forms : (4 forms)
- CVTTSD2SI xmm, r32 [SSE2]
- CVTTSD2SI m64, r32 [SSE2]
- CVTTSD2SI xmm, r64 [SSE2]
- CVTTSD2SI m64, r64 [SSE2]
func (*Program) CVTTSS2SI ¶
func (self *Program) CVTTSS2SI(v0 interface{}, v1 interface{}) *Instruction
CVTTSS2SI performs "Convert with Truncation Scalar Single-Precision FP Value to Dword Integer".
Mnemonic : CVTTSS2SI Supported forms : (4 forms)
- CVTTSS2SI xmm, r32 [SSE]
- CVTTSS2SI m32, r32 [SSE]
- CVTTSS2SI xmm, r64 [SSE]
- CVTTSS2SI m32, r64 [SSE]
func (*Program) CWTD ¶
func (self *Program) CWTD() *Instruction
CWTD performs "Convert Word to Doubleword".
Mnemonic : CWD Supported forms : (1 form)
- CWTD
func (*Program) CWTL ¶
func (self *Program) CWTL() *Instruction
CWTL performs "Convert Word to Doubleword".
Mnemonic : CWDE Supported forms : (1 form)
- CWTL
func (*Program) DECB ¶
func (self *Program) DECB(v0 interface{}) *Instruction
DECB performs "Decrement by 1".
Mnemonic : DEC Supported forms : (2 forms)
- DECB r8
- DECB m8
func (*Program) DECL ¶
func (self *Program) DECL(v0 interface{}) *Instruction
DECL performs "Decrement by 1".
Mnemonic : DEC Supported forms : (2 forms)
- DECL r32
- DECL m32
func (*Program) DECQ ¶
func (self *Program) DECQ(v0 interface{}) *Instruction
DECQ performs "Decrement by 1".
Mnemonic : DEC Supported forms : (2 forms)
- DECQ r64
- DECQ m64
func (*Program) DECW ¶
func (self *Program) DECW(v0 interface{}) *Instruction
DECW performs "Decrement by 1".
Mnemonic : DEC Supported forms : (2 forms)
- DECW r16
- DECW m16
func (*Program) DIVB ¶
func (self *Program) DIVB(v0 interface{}) *Instruction
DIVB performs "Unsigned Divide".
Mnemonic : DIV Supported forms : (2 forms)
- DIVB r8
- DIVB m8
func (*Program) DIVL ¶
func (self *Program) DIVL(v0 interface{}) *Instruction
DIVL performs "Unsigned Divide".
Mnemonic : DIV Supported forms : (2 forms)
- DIVL r32
- DIVL m32
func (*Program) DIVPD ¶
func (self *Program) DIVPD(v0 interface{}, v1 interface{}) *Instruction
DIVPD performs "Divide Packed Double-Precision Floating-Point Values".
Mnemonic : DIVPD Supported forms : (2 forms)
- DIVPD xmm, xmm [SSE2]
- DIVPD m128, xmm [SSE2]
func (*Program) DIVPS ¶
func (self *Program) DIVPS(v0 interface{}, v1 interface{}) *Instruction
DIVPS performs "Divide Packed Single-Precision Floating-Point Values".
Mnemonic : DIVPS Supported forms : (2 forms)
- DIVPS xmm, xmm [SSE]
- DIVPS m128, xmm [SSE]
func (*Program) DIVQ ¶
func (self *Program) DIVQ(v0 interface{}) *Instruction
DIVQ performs "Unsigned Divide".
Mnemonic : DIV Supported forms : (2 forms)
- DIVQ r64
- DIVQ m64
func (*Program) DIVSD ¶
func (self *Program) DIVSD(v0 interface{}, v1 interface{}) *Instruction
DIVSD performs "Divide Scalar Double-Precision Floating-Point Values".
Mnemonic : DIVSD Supported forms : (2 forms)
- DIVSD xmm, xmm [SSE2]
- DIVSD m64, xmm [SSE2]
func (*Program) DIVSS ¶
func (self *Program) DIVSS(v0 interface{}, v1 interface{}) *Instruction
DIVSS performs "Divide Scalar Single-Precision Floating-Point Values".
Mnemonic : DIVSS Supported forms : (2 forms)
- DIVSS xmm, xmm [SSE]
- DIVSS m32, xmm [SSE]
func (*Program) DIVW ¶
func (self *Program) DIVW(v0 interface{}) *Instruction
DIVW performs "Unsigned Divide".
Mnemonic : DIV Supported forms : (2 forms)
- DIVW r16
- DIVW m16
func (*Program) DPPD ¶
func (self *Program) DPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
DPPD performs "Dot Product of Packed Double Precision Floating-Point Values".
Mnemonic : DPPD Supported forms : (2 forms)
- DPPD imm8, xmm, xmm [SSE4.1]
- DPPD imm8, m128, xmm [SSE4.1]
func (*Program) DPPS ¶
func (self *Program) DPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
DPPS performs "Dot Product of Packed Single Precision Floating-Point Values".
Mnemonic : DPPS Supported forms : (2 forms)
- DPPS imm8, xmm, xmm [SSE4.1]
- DPPS imm8, m128, xmm [SSE4.1]
func (*Program) Data ¶
func (self *Program) Data(v []byte) (p *Instruction)
Data is a pseudo-instruction to add raw bytes to the assembled code.
func (*Program) EMMS ¶
func (self *Program) EMMS() *Instruction
EMMS performs "Exit MMX State".
Mnemonic : EMMS Supported forms : (1 form)
- EMMS [MMX]
func (*Program) EXTRACTPS ¶
func (self *Program) EXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
EXTRACTPS performs "Extract Packed Single Precision Floating-Point Value".
Mnemonic : EXTRACTPS Supported forms : (2 forms)
- EXTRACTPS imm8, xmm, r32 [SSE4.1]
- EXTRACTPS imm8, xmm, m32 [SSE4.1]
func (*Program) EXTRQ ¶
func (self *Program) EXTRQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
EXTRQ performs "Extract Field".
Mnemonic : EXTRQ Supported forms : (2 forms)
- EXTRQ xmm, xmm [SSE4A]
- EXTRQ imm8, imm8, xmm [SSE4A]
func (*Program) FEMMS ¶
func (self *Program) FEMMS() *Instruction
FEMMS performs "Fast Exit Multimedia State".
Mnemonic : FEMMS Supported forms : (1 form)
- FEMMS [FEMMS]
func (*Program) Free ¶
func (self *Program) Free()
Free returns the Program object into pool. Any operation performed after Free is undefined behavior.
NOTE: This also frees all the instructions, labels, memory
operands and expressions associated with this program.
func (*Program) HADDPD ¶
func (self *Program) HADDPD(v0 interface{}, v1 interface{}) *Instruction
HADDPD performs "Packed Double-FP Horizontal Add".
Mnemonic : HADDPD Supported forms : (2 forms)
- HADDPD xmm, xmm [SSE3]
- HADDPD m128, xmm [SSE3]
func (*Program) HADDPS ¶
func (self *Program) HADDPS(v0 interface{}, v1 interface{}) *Instruction
HADDPS performs "Packed Single-FP Horizontal Add".
Mnemonic : HADDPS Supported forms : (2 forms)
- HADDPS xmm, xmm [SSE3]
- HADDPS m128, xmm [SSE3]
func (*Program) HSUBPD ¶
func (self *Program) HSUBPD(v0 interface{}, v1 interface{}) *Instruction
HSUBPD performs "Packed Double-FP Horizontal Subtract".
Mnemonic : HSUBPD Supported forms : (2 forms)
- HSUBPD xmm, xmm [SSE3]
- HSUBPD m128, xmm [SSE3]
func (*Program) HSUBPS ¶
func (self *Program) HSUBPS(v0 interface{}, v1 interface{}) *Instruction
HSUBPS performs "Packed Single-FP Horizontal Subtract".
Mnemonic : HSUBPS Supported forms : (2 forms)
- HSUBPS xmm, xmm [SSE3]
- HSUBPS m128, xmm [SSE3]
func (*Program) IDIVB ¶
func (self *Program) IDIVB(v0 interface{}) *Instruction
IDIVB performs "Signed Divide".
Mnemonic : IDIV Supported forms : (2 forms)
- IDIVB r8
- IDIVB m8
func (*Program) IDIVL ¶
func (self *Program) IDIVL(v0 interface{}) *Instruction
IDIVL performs "Signed Divide".
Mnemonic : IDIV Supported forms : (2 forms)
- IDIVL r32
- IDIVL m32
func (*Program) IDIVQ ¶
func (self *Program) IDIVQ(v0 interface{}) *Instruction
IDIVQ performs "Signed Divide".
Mnemonic : IDIV Supported forms : (2 forms)
- IDIVQ r64
- IDIVQ m64
func (*Program) IDIVW ¶
func (self *Program) IDIVW(v0 interface{}) *Instruction
IDIVW performs "Signed Divide".
Mnemonic : IDIV Supported forms : (2 forms)
- IDIVW r16
- IDIVW m16
func (*Program) IMULB ¶
func (self *Program) IMULB(v0 interface{}) *Instruction
IMULB performs "Signed Multiply".
Mnemonic : IMUL Supported forms : (2 forms)
- IMULB r8
- IMULB m8
func (*Program) IMULL ¶
func (self *Program) IMULL(v0 interface{}, vv ...interface{}) *Instruction
IMULL performs "Signed Multiply".
Mnemonic : IMUL Supported forms : (8 forms)
- IMULL r32
- IMULL m32
- IMULL r32, r32
- IMULL m32, r32
- IMULL imm8, r32, r32
- IMULL imm32, r32, r32
- IMULL imm8, m32, r32
- IMULL imm32, m32, r32
func (*Program) IMULQ ¶
func (self *Program) IMULQ(v0 interface{}, vv ...interface{}) *Instruction
IMULQ performs "Signed Multiply".
Mnemonic : IMUL Supported forms : (8 forms)
- IMULQ r64
- IMULQ m64
- IMULQ r64, r64
- IMULQ m64, r64
- IMULQ imm8, r64, r64
- IMULQ imm32, r64, r64
- IMULQ imm8, m64, r64
- IMULQ imm32, m64, r64
func (*Program) IMULW ¶
func (self *Program) IMULW(v0 interface{}, vv ...interface{}) *Instruction
IMULW performs "Signed Multiply".
Mnemonic : IMUL Supported forms : (8 forms)
- IMULW r16
- IMULW m16
- IMULW r16, r16
- IMULW m16, r16
- IMULW imm8, r16, r16
- IMULW imm16, r16, r16
- IMULW imm8, m16, r16
- IMULW imm16, m16, r16
func (*Program) INCB ¶
func (self *Program) INCB(v0 interface{}) *Instruction
INCB performs "Increment by 1".
Mnemonic : INC Supported forms : (2 forms)
- INCB r8
- INCB m8
func (*Program) INCL ¶
func (self *Program) INCL(v0 interface{}) *Instruction
INCL performs "Increment by 1".
Mnemonic : INC Supported forms : (2 forms)
- INCL r32
- INCL m32
func (*Program) INCQ ¶
func (self *Program) INCQ(v0 interface{}) *Instruction
INCQ performs "Increment by 1".
Mnemonic : INC Supported forms : (2 forms)
- INCQ r64
- INCQ m64
func (*Program) INCW ¶
func (self *Program) INCW(v0 interface{}) *Instruction
INCW performs "Increment by 1".
Mnemonic : INC Supported forms : (2 forms)
- INCW r16
- INCW m16
func (*Program) INSERTPS ¶
func (self *Program) INSERTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
INSERTPS performs "Insert Packed Single Precision Floating-Point Value".
Mnemonic : INSERTPS Supported forms : (2 forms)
- INSERTPS imm8, xmm, xmm [SSE4.1]
- INSERTPS imm8, m32, xmm [SSE4.1]
func (*Program) INSERTQ ¶
func (self *Program) INSERTQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
INSERTQ performs "Insert Field".
Mnemonic : INSERTQ Supported forms : (2 forms)
- INSERTQ xmm, xmm [SSE4A]
- INSERTQ imm8, imm8, xmm, xmm [SSE4A]
func (*Program) INT ¶
func (self *Program) INT(v0 interface{}) *Instruction
INT performs "Call to Interrupt Procedure".
Mnemonic : INT Supported forms : (2 forms)
- INT 3
- INT imm8
func (*Program) JA ¶
func (self *Program) JA(v0 interface{}) *Instruction
JA performs "Jump if above (CF == 0 and ZF == 0)".
Mnemonic : JA Supported forms : (2 forms)
- JA rel8
- JA rel32
func (*Program) JAE ¶
func (self *Program) JAE(v0 interface{}) *Instruction
JAE performs "Jump if above or equal (CF == 0)".
Mnemonic : JAE Supported forms : (2 forms)
- JAE rel8
- JAE rel32
func (*Program) JB ¶
func (self *Program) JB(v0 interface{}) *Instruction
JB performs "Jump if below (CF == 1)".
Mnemonic : JB Supported forms : (2 forms)
- JB rel8
- JB rel32
func (*Program) JBE ¶
func (self *Program) JBE(v0 interface{}) *Instruction
JBE performs "Jump if below or equal (CF == 1 or ZF == 1)".
Mnemonic : JBE Supported forms : (2 forms)
- JBE rel8
- JBE rel32
func (*Program) JC ¶
func (self *Program) JC(v0 interface{}) *Instruction
JC performs "Jump if carry (CF == 1)".
Mnemonic : JC Supported forms : (2 forms)
- JC rel8
- JC rel32
func (*Program) JE ¶
func (self *Program) JE(v0 interface{}) *Instruction
JE performs "Jump if equal (ZF == 1)".
Mnemonic : JE Supported forms : (2 forms)
- JE rel8
- JE rel32
func (*Program) JECXZ ¶
func (self *Program) JECXZ(v0 interface{}) *Instruction
JECXZ performs "Jump if ECX register is 0".
Mnemonic : JECXZ Supported forms : (1 form)
- JECXZ rel8
func (*Program) JG ¶
func (self *Program) JG(v0 interface{}) *Instruction
JG performs "Jump if greater (ZF == 0 and SF == OF)".
Mnemonic : JG Supported forms : (2 forms)
- JG rel8
- JG rel32
func (*Program) JGE ¶
func (self *Program) JGE(v0 interface{}) *Instruction
JGE performs "Jump if greater or equal (SF == OF)".
Mnemonic : JGE Supported forms : (2 forms)
- JGE rel8
- JGE rel32
func (*Program) JL ¶
func (self *Program) JL(v0 interface{}) *Instruction
JL performs "Jump if less (SF != OF)".
Mnemonic : JL Supported forms : (2 forms)
- JL rel8
- JL rel32
func (*Program) JLE ¶
func (self *Program) JLE(v0 interface{}) *Instruction
JLE performs "Jump if less or equal (ZF == 1 or SF != OF)".
Mnemonic : JLE Supported forms : (2 forms)
- JLE rel8
- JLE rel32
func (*Program) JMP ¶
func (self *Program) JMP(v0 interface{}) *Instruction
JMP performs "Jump Unconditionally".
Mnemonic : JMP Supported forms : (2 forms)
- JMP rel8
- JMP rel32
func (*Program) JMPQ ¶
func (self *Program) JMPQ(v0 interface{}) *Instruction
JMPQ performs "Jump Unconditionally".
Mnemonic : JMP Supported forms : (2 forms)
- JMPQ r64
- JMPQ m64
func (*Program) JNA ¶
func (self *Program) JNA(v0 interface{}) *Instruction
JNA performs "Jump if not above (CF == 1 or ZF == 1)".
Mnemonic : JNA Supported forms : (2 forms)
- JNA rel8
- JNA rel32
func (*Program) JNAE ¶
func (self *Program) JNAE(v0 interface{}) *Instruction
JNAE performs "Jump if not above or equal (CF == 1)".
Mnemonic : JNAE Supported forms : (2 forms)
- JNAE rel8
- JNAE rel32
func (*Program) JNB ¶
func (self *Program) JNB(v0 interface{}) *Instruction
JNB performs "Jump if not below (CF == 0)".
Mnemonic : JNB Supported forms : (2 forms)
- JNB rel8
- JNB rel32
func (*Program) JNBE ¶
func (self *Program) JNBE(v0 interface{}) *Instruction
JNBE performs "Jump if not below or equal (CF == 0 and ZF == 0)".
Mnemonic : JNBE Supported forms : (2 forms)
- JNBE rel8
- JNBE rel32
func (*Program) JNC ¶
func (self *Program) JNC(v0 interface{}) *Instruction
JNC performs "Jump if not carry (CF == 0)".
Mnemonic : JNC Supported forms : (2 forms)
- JNC rel8
- JNC rel32
func (*Program) JNE ¶
func (self *Program) JNE(v0 interface{}) *Instruction
JNE performs "Jump if not equal (ZF == 0)".
Mnemonic : JNE Supported forms : (2 forms)
- JNE rel8
- JNE rel32
func (*Program) JNG ¶
func (self *Program) JNG(v0 interface{}) *Instruction
JNG performs "Jump if not greater (ZF == 1 or SF != OF)".
Mnemonic : JNG Supported forms : (2 forms)
- JNG rel8
- JNG rel32
func (*Program) JNGE ¶
func (self *Program) JNGE(v0 interface{}) *Instruction
JNGE performs "Jump if not greater or equal (SF != OF)".
Mnemonic : JNGE Supported forms : (2 forms)
- JNGE rel8
- JNGE rel32
func (*Program) JNL ¶
func (self *Program) JNL(v0 interface{}) *Instruction
JNL performs "Jump if not less (SF == OF)".
Mnemonic : JNL Supported forms : (2 forms)
- JNL rel8
- JNL rel32
func (*Program) JNLE ¶
func (self *Program) JNLE(v0 interface{}) *Instruction
JNLE performs "Jump if not less or equal (ZF == 0 and SF == OF)".
Mnemonic : JNLE Supported forms : (2 forms)
- JNLE rel8
- JNLE rel32
func (*Program) JNO ¶
func (self *Program) JNO(v0 interface{}) *Instruction
JNO performs "Jump if not overflow (OF == 0)".
Mnemonic : JNO Supported forms : (2 forms)
- JNO rel8
- JNO rel32
func (*Program) JNP ¶
func (self *Program) JNP(v0 interface{}) *Instruction
JNP performs "Jump if not parity (PF == 0)".
Mnemonic : JNP Supported forms : (2 forms)
- JNP rel8
- JNP rel32
func (*Program) JNS ¶
func (self *Program) JNS(v0 interface{}) *Instruction
JNS performs "Jump if not sign (SF == 0)".
Mnemonic : JNS Supported forms : (2 forms)
- JNS rel8
- JNS rel32
func (*Program) JNZ ¶
func (self *Program) JNZ(v0 interface{}) *Instruction
JNZ performs "Jump if not zero (ZF == 0)".
Mnemonic : JNZ Supported forms : (2 forms)
- JNZ rel8
- JNZ rel32
func (*Program) JO ¶
func (self *Program) JO(v0 interface{}) *Instruction
JO performs "Jump if overflow (OF == 1)".
Mnemonic : JO Supported forms : (2 forms)
- JO rel8
- JO rel32
func (*Program) JP ¶
func (self *Program) JP(v0 interface{}) *Instruction
JP performs "Jump if parity (PF == 1)".
Mnemonic : JP Supported forms : (2 forms)
- JP rel8
- JP rel32
func (*Program) JPE ¶
func (self *Program) JPE(v0 interface{}) *Instruction
JPE performs "Jump if parity even (PF == 1)".
Mnemonic : JPE Supported forms : (2 forms)
- JPE rel8
- JPE rel32
func (*Program) JPO ¶
func (self *Program) JPO(v0 interface{}) *Instruction
JPO performs "Jump if parity odd (PF == 0)".
Mnemonic : JPO Supported forms : (2 forms)
- JPO rel8
- JPO rel32
func (*Program) JRCXZ ¶
func (self *Program) JRCXZ(v0 interface{}) *Instruction
JRCXZ performs "Jump if RCX register is 0".
Mnemonic : JRCXZ Supported forms : (1 form)
- JRCXZ rel8
func (*Program) JS ¶
func (self *Program) JS(v0 interface{}) *Instruction
JS performs "Jump if sign (SF == 1)".
Mnemonic : JS Supported forms : (2 forms)
- JS rel8
- JS rel32
func (*Program) JZ ¶
func (self *Program) JZ(v0 interface{}) *Instruction
JZ performs "Jump if zero (ZF == 1)".
Mnemonic : JZ Supported forms : (2 forms)
- JZ rel8
- JZ rel32
func (*Program) KADDB ¶
func (self *Program) KADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KADDB performs "ADD Two 8-bit Masks".
Mnemonic : KADDB Supported forms : (1 form)
- KADDB k, k, k [AVX512DQ]
func (*Program) KADDD ¶
func (self *Program) KADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KADDD performs "ADD Two 32-bit Masks".
Mnemonic : KADDD Supported forms : (1 form)
- KADDD k, k, k [AVX512BW]
func (*Program) KADDQ ¶
func (self *Program) KADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KADDQ performs "ADD Two 64-bit Masks".
Mnemonic : KADDQ Supported forms : (1 form)
- KADDQ k, k, k [AVX512BW]
func (*Program) KADDW ¶
func (self *Program) KADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KADDW performs "ADD Two 16-bit Masks".
Mnemonic : KADDW Supported forms : (1 form)
- KADDW k, k, k [AVX512DQ]
func (*Program) KANDB ¶
func (self *Program) KANDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDB performs "Bitwise Logical AND 8-bit Masks".
Mnemonic : KANDB Supported forms : (1 form)
- KANDB k, k, k [AVX512DQ]
func (*Program) KANDD ¶
func (self *Program) KANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDD performs "Bitwise Logical AND 32-bit Masks".
Mnemonic : KANDD Supported forms : (1 form)
- KANDD k, k, k [AVX512BW]
func (*Program) KANDNB ¶
func (self *Program) KANDNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDNB performs "Bitwise Logical AND NOT 8-bit Masks".
Mnemonic : KANDNB Supported forms : (1 form)
- KANDNB k, k, k [AVX512DQ]
func (*Program) KANDND ¶
func (self *Program) KANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDND performs "Bitwise Logical AND NOT 32-bit Masks".
Mnemonic : KANDND Supported forms : (1 form)
- KANDND k, k, k [AVX512BW]
func (*Program) KANDNQ ¶
func (self *Program) KANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDNQ performs "Bitwise Logical AND NOT 64-bit Masks".
Mnemonic : KANDNQ Supported forms : (1 form)
- KANDNQ k, k, k [AVX512BW]
func (*Program) KANDNW ¶
func (self *Program) KANDNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDNW performs "Bitwise Logical AND NOT 16-bit Masks".
Mnemonic : KANDNW Supported forms : (1 form)
- KANDNW k, k, k [AVX512F]
func (*Program) KANDQ ¶
func (self *Program) KANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDQ performs "Bitwise Logical AND 64-bit Masks".
Mnemonic : KANDQ Supported forms : (1 form)
- KANDQ k, k, k [AVX512BW]
func (*Program) KANDW ¶
func (self *Program) KANDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KANDW performs "Bitwise Logical AND 16-bit Masks".
Mnemonic : KANDW Supported forms : (1 form)
- KANDW k, k, k [AVX512F]
func (*Program) KMOVB ¶
func (self *Program) KMOVB(v0 interface{}, v1 interface{}) *Instruction
KMOVB performs "Move 8-bit Mask".
Mnemonic : KMOVB Supported forms : (5 forms)
- KMOVB k, k [AVX512DQ]
- KMOVB r32, k [AVX512DQ]
- KMOVB m8, k [AVX512DQ]
- KMOVB k, r32 [AVX512DQ]
- KMOVB k, m8 [AVX512DQ]
func (*Program) KMOVD ¶
func (self *Program) KMOVD(v0 interface{}, v1 interface{}) *Instruction
KMOVD performs "Move 32-bit Mask".
Mnemonic : KMOVD Supported forms : (5 forms)
- KMOVD k, k [AVX512BW]
- KMOVD r32, k [AVX512BW]
- KMOVD m32, k [AVX512BW]
- KMOVD k, r32 [AVX512BW]
- KMOVD k, m32 [AVX512BW]
func (*Program) KMOVQ ¶
func (self *Program) KMOVQ(v0 interface{}, v1 interface{}) *Instruction
KMOVQ performs "Move 64-bit Mask".
Mnemonic : KMOVQ Supported forms : (5 forms)
- KMOVQ k, k [AVX512BW]
- KMOVQ r64, k [AVX512BW]
- KMOVQ m64, k [AVX512BW]
- KMOVQ k, r64 [AVX512BW]
- KMOVQ k, m64 [AVX512BW]
func (*Program) KMOVW ¶
func (self *Program) KMOVW(v0 interface{}, v1 interface{}) *Instruction
KMOVW performs "Move 16-bit Mask".
Mnemonic : KMOVW Supported forms : (5 forms)
- KMOVW k, k [AVX512F]
- KMOVW r32, k [AVX512F]
- KMOVW m16, k [AVX512F]
- KMOVW k, r32 [AVX512F]
- KMOVW k, m16 [AVX512F]
func (*Program) KNOTB ¶
func (self *Program) KNOTB(v0 interface{}, v1 interface{}) *Instruction
KNOTB performs "NOT 8-bit Mask Register".
Mnemonic : KNOTB Supported forms : (1 form)
- KNOTB k, k [AVX512DQ]
func (*Program) KNOTD ¶
func (self *Program) KNOTD(v0 interface{}, v1 interface{}) *Instruction
KNOTD performs "NOT 32-bit Mask Register".
Mnemonic : KNOTD Supported forms : (1 form)
- KNOTD k, k [AVX512BW]
func (*Program) KNOTQ ¶
func (self *Program) KNOTQ(v0 interface{}, v1 interface{}) *Instruction
KNOTQ performs "NOT 64-bit Mask Register".
Mnemonic : KNOTQ Supported forms : (1 form)
- KNOTQ k, k [AVX512BW]
func (*Program) KNOTW ¶
func (self *Program) KNOTW(v0 interface{}, v1 interface{}) *Instruction
KNOTW performs "NOT 16-bit Mask Register".
Mnemonic : KNOTW Supported forms : (1 form)
- KNOTW k, k [AVX512F]
func (*Program) KORB ¶
func (self *Program) KORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KORB performs "Bitwise Logical OR 8-bit Masks".
Mnemonic : KORB Supported forms : (1 form)
- KORB k, k, k [AVX512DQ]
func (*Program) KORD ¶
func (self *Program) KORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KORD performs "Bitwise Logical OR 32-bit Masks".
Mnemonic : KORD Supported forms : (1 form)
- KORD k, k, k [AVX512BW]
func (*Program) KORQ ¶
func (self *Program) KORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KORQ performs "Bitwise Logical OR 64-bit Masks".
Mnemonic : KORQ Supported forms : (1 form)
- KORQ k, k, k [AVX512BW]
func (*Program) KORTESTB ¶
func (self *Program) KORTESTB(v0 interface{}, v1 interface{}) *Instruction
KORTESTB performs "OR 8-bit Masks and Set Flags".
Mnemonic : KORTESTB Supported forms : (1 form)
- KORTESTB k, k [AVX512DQ]
func (*Program) KORTESTD ¶
func (self *Program) KORTESTD(v0 interface{}, v1 interface{}) *Instruction
KORTESTD performs "OR 32-bit Masks and Set Flags".
Mnemonic : KORTESTD Supported forms : (1 form)
- KORTESTD k, k [AVX512BW]
func (*Program) KORTESTQ ¶
func (self *Program) KORTESTQ(v0 interface{}, v1 interface{}) *Instruction
KORTESTQ performs "OR 64-bit Masks and Set Flags".
Mnemonic : KORTESTQ Supported forms : (1 form)
- KORTESTQ k, k [AVX512BW]
func (*Program) KORTESTW ¶
func (self *Program) KORTESTW(v0 interface{}, v1 interface{}) *Instruction
KORTESTW performs "OR 16-bit Masks and Set Flags".
Mnemonic : KORTESTW Supported forms : (1 form)
- KORTESTW k, k [AVX512F]
func (*Program) KORW ¶
func (self *Program) KORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KORW performs "Bitwise Logical OR 16-bit Masks".
Mnemonic : KORW Supported forms : (1 form)
- KORW k, k, k [AVX512F]
func (*Program) KSHIFTLB ¶
func (self *Program) KSHIFTLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTLB performs "Shift Left 8-bit Masks".
Mnemonic : KSHIFTLB Supported forms : (1 form)
- KSHIFTLB imm8, k, k [AVX512DQ]
func (*Program) KSHIFTLD ¶
func (self *Program) KSHIFTLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTLD performs "Shift Left 32-bit Masks".
Mnemonic : KSHIFTLD Supported forms : (1 form)
- KSHIFTLD imm8, k, k [AVX512BW]
func (*Program) KSHIFTLQ ¶
func (self *Program) KSHIFTLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTLQ performs "Shift Left 64-bit Masks".
Mnemonic : KSHIFTLQ Supported forms : (1 form)
- KSHIFTLQ imm8, k, k [AVX512BW]
func (*Program) KSHIFTLW ¶
func (self *Program) KSHIFTLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTLW performs "Shift Left 16-bit Masks".
Mnemonic : KSHIFTLW Supported forms : (1 form)
- KSHIFTLW imm8, k, k [AVX512F]
func (*Program) KSHIFTRB ¶
func (self *Program) KSHIFTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTRB performs "Shift Right 8-bit Masks".
Mnemonic : KSHIFTRB Supported forms : (1 form)
- KSHIFTRB imm8, k, k [AVX512DQ]
func (*Program) KSHIFTRD ¶
func (self *Program) KSHIFTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTRD performs "Shift Right 32-bit Masks".
Mnemonic : KSHIFTRD Supported forms : (1 form)
- KSHIFTRD imm8, k, k [AVX512BW]
func (*Program) KSHIFTRQ ¶
func (self *Program) KSHIFTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTRQ performs "Shift Right 64-bit Masks".
Mnemonic : KSHIFTRQ Supported forms : (1 form)
- KSHIFTRQ imm8, k, k [AVX512BW]
func (*Program) KSHIFTRW ¶
func (self *Program) KSHIFTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KSHIFTRW performs "Shift Right 16-bit Masks".
Mnemonic : KSHIFTRW Supported forms : (1 form)
- KSHIFTRW imm8, k, k [AVX512F]
func (*Program) KTESTB ¶
func (self *Program) KTESTB(v0 interface{}, v1 interface{}) *Instruction
KTESTB performs "Bit Test 8-bit Masks and Set Flags".
Mnemonic : KTESTB Supported forms : (1 form)
- KTESTB k, k [AVX512DQ]
func (*Program) KTESTD ¶
func (self *Program) KTESTD(v0 interface{}, v1 interface{}) *Instruction
KTESTD performs "Bit Test 32-bit Masks and Set Flags".
Mnemonic : KTESTD Supported forms : (1 form)
- KTESTD k, k [AVX512BW]
func (*Program) KTESTQ ¶
func (self *Program) KTESTQ(v0 interface{}, v1 interface{}) *Instruction
KTESTQ performs "Bit Test 64-bit Masks and Set Flags".
Mnemonic : KTESTQ Supported forms : (1 form)
- KTESTQ k, k [AVX512BW]
func (*Program) KTESTW ¶
func (self *Program) KTESTW(v0 interface{}, v1 interface{}) *Instruction
KTESTW performs "Bit Test 16-bit Masks and Set Flags".
Mnemonic : KTESTW Supported forms : (1 form)
- KTESTW k, k [AVX512DQ]
func (*Program) KUNPCKBW ¶
func (self *Program) KUNPCKBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KUNPCKBW performs "Unpack and Interleave 8-bit Masks".
Mnemonic : KUNPCKBW Supported forms : (1 form)
- KUNPCKBW k, k, k [AVX512F]
func (*Program) KUNPCKDQ ¶
func (self *Program) KUNPCKDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KUNPCKDQ performs "Unpack and Interleave 32-bit Masks".
Mnemonic : KUNPCKDQ Supported forms : (1 form)
- KUNPCKDQ k, k, k [AVX512BW]
func (*Program) KUNPCKWD ¶
func (self *Program) KUNPCKWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KUNPCKWD performs "Unpack and Interleave 16-bit Masks".
Mnemonic : KUNPCKWD Supported forms : (1 form)
- KUNPCKWD k, k, k [AVX512BW]
func (*Program) KXNORB ¶
func (self *Program) KXNORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXNORB performs "Bitwise Logical XNOR 8-bit Masks".
Mnemonic : KXNORB Supported forms : (1 form)
- KXNORB k, k, k [AVX512DQ]
func (*Program) KXNORD ¶
func (self *Program) KXNORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXNORD performs "Bitwise Logical XNOR 32-bit Masks".
Mnemonic : KXNORD Supported forms : (1 form)
- KXNORD k, k, k [AVX512BW]
func (*Program) KXNORQ ¶
func (self *Program) KXNORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXNORQ performs "Bitwise Logical XNOR 64-bit Masks".
Mnemonic : KXNORQ Supported forms : (1 form)
- KXNORQ k, k, k [AVX512BW]
func (*Program) KXNORW ¶
func (self *Program) KXNORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXNORW performs "Bitwise Logical XNOR 16-bit Masks".
Mnemonic : KXNORW Supported forms : (1 form)
- KXNORW k, k, k [AVX512F]
func (*Program) KXORB ¶
func (self *Program) KXORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXORB performs "Bitwise Logical XOR 8-bit Masks".
Mnemonic : KXORB Supported forms : (1 form)
- KXORB k, k, k [AVX512DQ]
func (*Program) KXORD ¶
func (self *Program) KXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXORD performs "Bitwise Logical XOR 32-bit Masks".
Mnemonic : KXORD Supported forms : (1 form)
- KXORD k, k, k [AVX512BW]
func (*Program) KXORQ ¶
func (self *Program) KXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXORQ performs "Bitwise Logical XOR 64-bit Masks".
Mnemonic : KXORQ Supported forms : (1 form)
- KXORQ k, k, k [AVX512BW]
func (*Program) KXORW ¶
func (self *Program) KXORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
KXORW performs "Bitwise Logical XOR 16-bit Masks".
Mnemonic : KXORW Supported forms : (1 form)
- KXORW k, k, k [AVX512F]
func (*Program) LDDQU ¶
func (self *Program) LDDQU(v0 interface{}, v1 interface{}) *Instruction
LDDQU performs "Load Unaligned Integer 128 Bits".
Mnemonic : LDDQU Supported forms : (1 form)
- LDDQU m128, xmm [SSE3]
func (*Program) LDMXCSR ¶
func (self *Program) LDMXCSR(v0 interface{}) *Instruction
LDMXCSR performs "Load MXCSR Register".
Mnemonic : LDMXCSR Supported forms : (1 form)
- LDMXCSR m32 [SSE]
func (*Program) LEAL ¶
func (self *Program) LEAL(v0 interface{}, v1 interface{}) *Instruction
LEAL performs "Load Effective Address".
Mnemonic : LEA Supported forms : (1 form)
- LEAL m, r32
func (*Program) LEAQ ¶
func (self *Program) LEAQ(v0 interface{}, v1 interface{}) *Instruction
LEAQ performs "Load Effective Address".
Mnemonic : LEA Supported forms : (1 form)
- LEAQ m, r64
func (*Program) LEAW ¶
func (self *Program) LEAW(v0 interface{}, v1 interface{}) *Instruction
LEAW performs "Load Effective Address".
Mnemonic : LEA Supported forms : (1 form)
- LEAW m, r16
func (*Program) LFENCE ¶
func (self *Program) LFENCE() *Instruction
LFENCE performs "Load Fence".
Mnemonic : LFENCE Supported forms : (1 form)
- LFENCE [SSE2]
func (*Program) LZCNTL ¶
func (self *Program) LZCNTL(v0 interface{}, v1 interface{}) *Instruction
LZCNTL performs "Count the Number of Leading Zero Bits".
Mnemonic : LZCNT Supported forms : (2 forms)
- LZCNTL r32, r32 [LZCNT]
- LZCNTL m32, r32 [LZCNT]
func (*Program) LZCNTQ ¶
func (self *Program) LZCNTQ(v0 interface{}, v1 interface{}) *Instruction
LZCNTQ performs "Count the Number of Leading Zero Bits".
Mnemonic : LZCNT Supported forms : (2 forms)
- LZCNTQ r64, r64 [LZCNT]
- LZCNTQ m64, r64 [LZCNT]
func (*Program) LZCNTW ¶
func (self *Program) LZCNTW(v0 interface{}, v1 interface{}) *Instruction
LZCNTW performs "Count the Number of Leading Zero Bits".
Mnemonic : LZCNT Supported forms : (2 forms)
- LZCNTW r16, r16 [LZCNT]
- LZCNTW m16, r16 [LZCNT]
func (*Program) Long ¶
func (self *Program) Long(v *expr.Expr) (p *Instruction)
Long is a pseudo-instruction to add raw uint32 as little-endian to the assembled code.
func (*Program) MASKMOVDQU ¶
func (self *Program) MASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction
MASKMOVDQU performs "Store Selected Bytes of Double Quadword".
Mnemonic : MASKMOVDQU Supported forms : (1 form)
- MASKMOVDQU xmm, xmm [SSE2]
func (*Program) MASKMOVQ ¶
func (self *Program) MASKMOVQ(v0 interface{}, v1 interface{}) *Instruction
MASKMOVQ performs "Store Selected Bytes of Quadword".
Mnemonic : MASKMOVQ Supported forms : (1 form)
- MASKMOVQ mm, mm [MMX+]
func (*Program) MAXPD ¶
func (self *Program) MAXPD(v0 interface{}, v1 interface{}) *Instruction
MAXPD performs "Return Maximum Packed Double-Precision Floating-Point Values".
Mnemonic : MAXPD Supported forms : (2 forms)
- MAXPD xmm, xmm [SSE2]
- MAXPD m128, xmm [SSE2]
func (*Program) MAXPS ¶
func (self *Program) MAXPS(v0 interface{}, v1 interface{}) *Instruction
MAXPS performs "Return Maximum Packed Single-Precision Floating-Point Values".
Mnemonic : MAXPS Supported forms : (2 forms)
- MAXPS xmm, xmm [SSE]
- MAXPS m128, xmm [SSE]
func (*Program) MAXSD ¶
func (self *Program) MAXSD(v0 interface{}, v1 interface{}) *Instruction
MAXSD performs "Return Maximum Scalar Double-Precision Floating-Point Value".
Mnemonic : MAXSD Supported forms : (2 forms)
- MAXSD xmm, xmm [SSE2]
- MAXSD m64, xmm [SSE2]
func (*Program) MAXSS ¶
func (self *Program) MAXSS(v0 interface{}, v1 interface{}) *Instruction
MAXSS performs "Return Maximum Scalar Single-Precision Floating-Point Value".
Mnemonic : MAXSS Supported forms : (2 forms)
- MAXSS xmm, xmm [SSE]
- MAXSS m32, xmm [SSE]
func (*Program) MFENCE ¶
func (self *Program) MFENCE() *Instruction
MFENCE performs "Memory Fence".
Mnemonic : MFENCE Supported forms : (1 form)
- MFENCE [SSE2]
func (*Program) MINPD ¶
func (self *Program) MINPD(v0 interface{}, v1 interface{}) *Instruction
MINPD performs "Return Minimum Packed Double-Precision Floating-Point Values".
Mnemonic : MINPD Supported forms : (2 forms)
- MINPD xmm, xmm [SSE2]
- MINPD m128, xmm [SSE2]
func (*Program) MINPS ¶
func (self *Program) MINPS(v0 interface{}, v1 interface{}) *Instruction
MINPS performs "Return Minimum Packed Single-Precision Floating-Point Values".
Mnemonic : MINPS Supported forms : (2 forms)
- MINPS xmm, xmm [SSE]
- MINPS m128, xmm [SSE]
func (*Program) MINSD ¶
func (self *Program) MINSD(v0 interface{}, v1 interface{}) *Instruction
MINSD performs "Return Minimum Scalar Double-Precision Floating-Point Value".
Mnemonic : MINSD Supported forms : (2 forms)
- MINSD xmm, xmm [SSE2]
- MINSD m64, xmm [SSE2]
func (*Program) MINSS ¶
func (self *Program) MINSS(v0 interface{}, v1 interface{}) *Instruction
MINSS performs "Return Minimum Scalar Single-Precision Floating-Point Value".
Mnemonic : MINSS Supported forms : (2 forms)
- MINSS xmm, xmm [SSE]
- MINSS m32, xmm [SSE]
func (*Program) MONITOR ¶
func (self *Program) MONITOR() *Instruction
MONITOR performs "Monitor a Linear Address Range".
Mnemonic : MONITOR Supported forms : (1 form)
- MONITOR [MONITOR]
func (*Program) MONITORX ¶
func (self *Program) MONITORX() *Instruction
MONITORX performs "Monitor a Linear Address Range with Timeout".
Mnemonic : MONITORX Supported forms : (1 form)
- MONITORX [MONITORX]
func (*Program) MOVAPD ¶
func (self *Program) MOVAPD(v0 interface{}, v1 interface{}) *Instruction
MOVAPD performs "Move Aligned Packed Double-Precision Floating-Point Values".
Mnemonic : MOVAPD Supported forms : (3 forms)
- MOVAPD xmm, xmm [SSE2]
- MOVAPD m128, xmm [SSE2]
- MOVAPD xmm, m128 [SSE2]
func (*Program) MOVAPS ¶
func (self *Program) MOVAPS(v0 interface{}, v1 interface{}) *Instruction
MOVAPS performs "Move Aligned Packed Single-Precision Floating-Point Values".
Mnemonic : MOVAPS Supported forms : (3 forms)
- MOVAPS xmm, xmm [SSE]
- MOVAPS m128, xmm [SSE]
- MOVAPS xmm, m128 [SSE]
func (*Program) MOVB ¶
func (self *Program) MOVB(v0 interface{}, v1 interface{}) *Instruction
MOVB performs "Move".
Mnemonic : MOV Supported forms : (5 forms)
- MOVB imm8, r8
- MOVB r8, r8
- MOVB m8, r8
- MOVB imm8, m8
- MOVB r8, m8
func (*Program) MOVBEL ¶
func (self *Program) MOVBEL(v0 interface{}, v1 interface{}) *Instruction
MOVBEL performs "Move Data After Swapping Bytes".
Mnemonic : MOVBE Supported forms : (2 forms)
- MOVBEL m32, r32 [MOVBE]
- MOVBEL r32, m32 [MOVBE]
func (*Program) MOVBEQ ¶
func (self *Program) MOVBEQ(v0 interface{}, v1 interface{}) *Instruction
MOVBEQ performs "Move Data After Swapping Bytes".
Mnemonic : MOVBE Supported forms : (2 forms)
- MOVBEQ m64, r64 [MOVBE]
- MOVBEQ r64, m64 [MOVBE]
func (*Program) MOVBEW ¶
func (self *Program) MOVBEW(v0 interface{}, v1 interface{}) *Instruction
MOVBEW performs "Move Data After Swapping Bytes".
Mnemonic : MOVBE Supported forms : (2 forms)
- MOVBEW m16, r16 [MOVBE]
- MOVBEW r16, m16 [MOVBE]
func (*Program) MOVD ¶
func (self *Program) MOVD(v0 interface{}, v1 interface{}) *Instruction
MOVD performs "Move Doubleword".
Mnemonic : MOVD Supported forms : (8 forms)
- MOVD mm, r32 [MMX]
- MOVD r32, mm [MMX]
- MOVD m32, mm [MMX]
- MOVD mm, m32 [MMX]
- MOVD xmm, r32 [SSE2]
- MOVD r32, xmm [SSE2]
- MOVD m32, xmm [SSE2]
- MOVD xmm, m32 [SSE2]
func (*Program) MOVDDUP ¶
func (self *Program) MOVDDUP(v0 interface{}, v1 interface{}) *Instruction
MOVDDUP performs "Move One Double-FP and Duplicate".
Mnemonic : MOVDDUP Supported forms : (2 forms)
- MOVDDUP xmm, xmm [SSE3]
- MOVDDUP m64, xmm [SSE3]
func (*Program) MOVDQ2Q ¶
func (self *Program) MOVDQ2Q(v0 interface{}, v1 interface{}) *Instruction
MOVDQ2Q performs "Move Quadword from XMM to MMX Technology Register".
Mnemonic : MOVDQ2Q Supported forms : (1 form)
- MOVDQ2Q xmm, mm [SSE2]
func (*Program) MOVDQA ¶
func (self *Program) MOVDQA(v0 interface{}, v1 interface{}) *Instruction
MOVDQA performs "Move Aligned Double Quadword".
Mnemonic : MOVDQA Supported forms : (3 forms)
- MOVDQA xmm, xmm [SSE2]
- MOVDQA m128, xmm [SSE2]
- MOVDQA xmm, m128 [SSE2]
func (*Program) MOVDQU ¶
func (self *Program) MOVDQU(v0 interface{}, v1 interface{}) *Instruction
MOVDQU performs "Move Unaligned Double Quadword".
Mnemonic : MOVDQU Supported forms : (3 forms)
- MOVDQU xmm, xmm [SSE2]
- MOVDQU m128, xmm [SSE2]
- MOVDQU xmm, m128 [SSE2]
func (*Program) MOVHLPS ¶
func (self *Program) MOVHLPS(v0 interface{}, v1 interface{}) *Instruction
MOVHLPS performs "Move Packed Single-Precision Floating-Point Values High to Low".
Mnemonic : MOVHLPS Supported forms : (1 form)
- MOVHLPS xmm, xmm [SSE]
func (*Program) MOVHPD ¶
func (self *Program) MOVHPD(v0 interface{}, v1 interface{}) *Instruction
MOVHPD performs "Move High Packed Double-Precision Floating-Point Value".
Mnemonic : MOVHPD Supported forms : (2 forms)
- MOVHPD m64, xmm [SSE2]
- MOVHPD xmm, m64 [SSE2]
func (*Program) MOVHPS ¶
func (self *Program) MOVHPS(v0 interface{}, v1 interface{}) *Instruction
MOVHPS performs "Move High Packed Single-Precision Floating-Point Values".
Mnemonic : MOVHPS Supported forms : (2 forms)
- MOVHPS m64, xmm [SSE]
- MOVHPS xmm, m64 [SSE]
func (*Program) MOVL ¶
func (self *Program) MOVL(v0 interface{}, v1 interface{}) *Instruction
MOVL performs "Move".
Mnemonic : MOV Supported forms : (5 forms)
- MOVL imm32, r32
- MOVL r32, r32
- MOVL m32, r32
- MOVL imm32, m32
- MOVL r32, m32
func (*Program) MOVLHPS ¶
func (self *Program) MOVLHPS(v0 interface{}, v1 interface{}) *Instruction
MOVLHPS performs "Move Packed Single-Precision Floating-Point Values Low to High".
Mnemonic : MOVLHPS Supported forms : (1 form)
- MOVLHPS xmm, xmm [SSE]
func (*Program) MOVLPD ¶
func (self *Program) MOVLPD(v0 interface{}, v1 interface{}) *Instruction
MOVLPD performs "Move Low Packed Double-Precision Floating-Point Value".
Mnemonic : MOVLPD Supported forms : (2 forms)
- MOVLPD m64, xmm [SSE2]
- MOVLPD xmm, m64 [SSE2]
func (*Program) MOVLPS ¶
func (self *Program) MOVLPS(v0 interface{}, v1 interface{}) *Instruction
MOVLPS performs "Move Low Packed Single-Precision Floating-Point Values".
Mnemonic : MOVLPS Supported forms : (2 forms)
- MOVLPS m64, xmm [SSE]
- MOVLPS xmm, m64 [SSE]
func (*Program) MOVMSKPD ¶
func (self *Program) MOVMSKPD(v0 interface{}, v1 interface{}) *Instruction
MOVMSKPD performs "Extract Packed Double-Precision Floating-Point Sign Mask".
Mnemonic : MOVMSKPD Supported forms : (1 form)
- MOVMSKPD xmm, r32 [SSE2]
func (*Program) MOVMSKPS ¶
func (self *Program) MOVMSKPS(v0 interface{}, v1 interface{}) *Instruction
MOVMSKPS performs "Extract Packed Single-Precision Floating-Point Sign Mask".
Mnemonic : MOVMSKPS Supported forms : (1 form)
- MOVMSKPS xmm, r32 [SSE]
func (*Program) MOVNTDQ ¶
func (self *Program) MOVNTDQ(v0 interface{}, v1 interface{}) *Instruction
MOVNTDQ performs "Store Double Quadword Using Non-Temporal Hint".
Mnemonic : MOVNTDQ Supported forms : (1 form)
- MOVNTDQ xmm, m128 [SSE2]
func (*Program) MOVNTDQA ¶
func (self *Program) MOVNTDQA(v0 interface{}, v1 interface{}) *Instruction
MOVNTDQA performs "Load Double Quadword Non-Temporal Aligned Hint".
Mnemonic : MOVNTDQA Supported forms : (1 form)
- MOVNTDQA m128, xmm [SSE4.1]
func (*Program) MOVNTIL ¶
func (self *Program) MOVNTIL(v0 interface{}, v1 interface{}) *Instruction
MOVNTIL performs "Store Doubleword Using Non-Temporal Hint".
Mnemonic : MOVNTI Supported forms : (1 form)
- MOVNTIL r32, m32 [SSE2]
func (*Program) MOVNTIQ ¶
func (self *Program) MOVNTIQ(v0 interface{}, v1 interface{}) *Instruction
MOVNTIQ performs "Store Doubleword Using Non-Temporal Hint".
Mnemonic : MOVNTI Supported forms : (1 form)
- MOVNTIQ r64, m64 [SSE2]
func (*Program) MOVNTPD ¶
func (self *Program) MOVNTPD(v0 interface{}, v1 interface{}) *Instruction
MOVNTPD performs "Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint".
Mnemonic : MOVNTPD Supported forms : (1 form)
- MOVNTPD xmm, m128 [SSE2]
func (*Program) MOVNTPS ¶
func (self *Program) MOVNTPS(v0 interface{}, v1 interface{}) *Instruction
MOVNTPS performs "Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint".
Mnemonic : MOVNTPS Supported forms : (1 form)
- MOVNTPS xmm, m128 [SSE]
func (*Program) MOVNTQ ¶
func (self *Program) MOVNTQ(v0 interface{}, v1 interface{}) *Instruction
MOVNTQ performs "Store of Quadword Using Non-Temporal Hint".
Mnemonic : MOVNTQ Supported forms : (1 form)
- MOVNTQ mm, m64 [MMX+]
func (*Program) MOVNTSD ¶
func (self *Program) MOVNTSD(v0 interface{}, v1 interface{}) *Instruction
MOVNTSD performs "Store Scalar Double-Precision Floating-Point Values Using Non-Temporal Hint".
Mnemonic : MOVNTSD Supported forms : (1 form)
- MOVNTSD xmm, m64 [SSE4A]
func (*Program) MOVNTSS ¶
func (self *Program) MOVNTSS(v0 interface{}, v1 interface{}) *Instruction
MOVNTSS performs "Store Scalar Single-Precision Floating-Point Values Using Non-Temporal Hint".
Mnemonic : MOVNTSS Supported forms : (1 form)
- MOVNTSS xmm, m32 [SSE4A]
func (*Program) MOVQ ¶
func (self *Program) MOVQ(v0 interface{}, v1 interface{}) *Instruction
MOVQ performs "Move".
Mnemonic : MOV Supported forms : (16 forms)
- MOVQ imm32, r64
- MOVQ imm64, r64
- MOVQ r64, r64
- MOVQ m64, r64
- MOVQ imm32, m64
- MOVQ r64, m64
- MOVQ mm, r64 [MMX]
- MOVQ r64, mm [MMX]
- MOVQ mm, mm [MMX]
- MOVQ m64, mm [MMX]
- MOVQ mm, m64 [MMX]
- MOVQ xmm, r64 [SSE2]
- MOVQ r64, xmm [SSE2]
- MOVQ xmm, xmm [SSE2]
- MOVQ m64, xmm [SSE2]
- MOVQ xmm, m64 [SSE2]
func (*Program) MOVQ2DQ ¶
func (self *Program) MOVQ2DQ(v0 interface{}, v1 interface{}) *Instruction
MOVQ2DQ performs "Move Quadword from MMX Technology to XMM Register".
Mnemonic : MOVQ2DQ Supported forms : (1 form)
- MOVQ2DQ mm, xmm [SSE2]
func (*Program) MOVSBL ¶
func (self *Program) MOVSBL(v0 interface{}, v1 interface{}) *Instruction
MOVSBL performs "Move with Sign-Extension".
Mnemonic : MOVSX Supported forms : (2 forms)
- MOVSBL r8, r32
- MOVSBL m8, r32
func (*Program) MOVSBQ ¶
func (self *Program) MOVSBQ(v0 interface{}, v1 interface{}) *Instruction
MOVSBQ performs "Move with Sign-Extension".
Mnemonic : MOVSX Supported forms : (2 forms)
- MOVSBQ r8, r64
- MOVSBQ m8, r64
func (*Program) MOVSBW ¶
func (self *Program) MOVSBW(v0 interface{}, v1 interface{}) *Instruction
MOVSBW performs "Move with Sign-Extension".
Mnemonic : MOVSX Supported forms : (2 forms)
- MOVSBW r8, r16
- MOVSBW m8, r16
func (*Program) MOVSD ¶
func (self *Program) MOVSD(v0 interface{}, v1 interface{}) *Instruction
MOVSD performs "Move Scalar Double-Precision Floating-Point Value".
Mnemonic : MOVSD Supported forms : (3 forms)
- MOVSD xmm, xmm [SSE2]
- MOVSD m64, xmm [SSE2]
- MOVSD xmm, m64 [SSE2]
func (*Program) MOVSHDUP ¶
func (self *Program) MOVSHDUP(v0 interface{}, v1 interface{}) *Instruction
MOVSHDUP performs "Move Packed Single-FP High and Duplicate".
Mnemonic : MOVSHDUP Supported forms : (2 forms)
- MOVSHDUP xmm, xmm [SSE3]
- MOVSHDUP m128, xmm [SSE3]
func (*Program) MOVSLDUP ¶
func (self *Program) MOVSLDUP(v0 interface{}, v1 interface{}) *Instruction
MOVSLDUP performs "Move Packed Single-FP Low and Duplicate".
Mnemonic : MOVSLDUP Supported forms : (2 forms)
- MOVSLDUP xmm, xmm [SSE3]
- MOVSLDUP m128, xmm [SSE3]
func (*Program) MOVSLQ ¶
func (self *Program) MOVSLQ(v0 interface{}, v1 interface{}) *Instruction
MOVSLQ performs "Move Doubleword to Quadword with Sign-Extension".
Mnemonic : MOVSXD Supported forms : (2 forms)
- MOVSLQ r32, r64
- MOVSLQ m32, r64
func (*Program) MOVSS ¶
func (self *Program) MOVSS(v0 interface{}, v1 interface{}) *Instruction
MOVSS performs "Move Scalar Single-Precision Floating-Point Values".
Mnemonic : MOVSS Supported forms : (3 forms)
- MOVSS xmm, xmm [SSE]
- MOVSS m32, xmm [SSE]
- MOVSS xmm, m32 [SSE]
func (*Program) MOVSWL ¶
func (self *Program) MOVSWL(v0 interface{}, v1 interface{}) *Instruction
MOVSWL performs "Move with Sign-Extension".
Mnemonic : MOVSX Supported forms : (2 forms)
- MOVSWL r16, r32
- MOVSWL m16, r32
func (*Program) MOVSWQ ¶
func (self *Program) MOVSWQ(v0 interface{}, v1 interface{}) *Instruction
MOVSWQ performs "Move with Sign-Extension".
Mnemonic : MOVSX Supported forms : (2 forms)
- MOVSWQ r16, r64
- MOVSWQ m16, r64
func (*Program) MOVUPD ¶
func (self *Program) MOVUPD(v0 interface{}, v1 interface{}) *Instruction
MOVUPD performs "Move Unaligned Packed Double-Precision Floating-Point Values".
Mnemonic : MOVUPD Supported forms : (3 forms)
- MOVUPD xmm, xmm [SSE2]
- MOVUPD m128, xmm [SSE2]
- MOVUPD xmm, m128 [SSE2]
func (*Program) MOVUPS ¶
func (self *Program) MOVUPS(v0 interface{}, v1 interface{}) *Instruction
MOVUPS performs "Move Unaligned Packed Single-Precision Floating-Point Values".
Mnemonic : MOVUPS Supported forms : (3 forms)
- MOVUPS xmm, xmm [SSE]
- MOVUPS m128, xmm [SSE]
- MOVUPS xmm, m128 [SSE]
func (*Program) MOVW ¶
func (self *Program) MOVW(v0 interface{}, v1 interface{}) *Instruction
MOVW performs "Move".
Mnemonic : MOV Supported forms : (5 forms)
- MOVW imm16, r16
- MOVW r16, r16
- MOVW m16, r16
- MOVW imm16, m16
- MOVW r16, m16
func (*Program) MOVZBL ¶
func (self *Program) MOVZBL(v0 interface{}, v1 interface{}) *Instruction
MOVZBL performs "Move with Zero-Extend".
Mnemonic : MOVZX Supported forms : (2 forms)
- MOVZBL r8, r32
- MOVZBL m8, r32
func (*Program) MOVZBQ ¶
func (self *Program) MOVZBQ(v0 interface{}, v1 interface{}) *Instruction
MOVZBQ performs "Move with Zero-Extend".
Mnemonic : MOVZX Supported forms : (2 forms)
- MOVZBQ r8, r64
- MOVZBQ m8, r64
func (*Program) MOVZBW ¶
func (self *Program) MOVZBW(v0 interface{}, v1 interface{}) *Instruction
MOVZBW performs "Move with Zero-Extend".
Mnemonic : MOVZX Supported forms : (2 forms)
- MOVZBW r8, r16
- MOVZBW m8, r16
func (*Program) MOVZWL ¶
func (self *Program) MOVZWL(v0 interface{}, v1 interface{}) *Instruction
MOVZWL performs "Move with Zero-Extend".
Mnemonic : MOVZX Supported forms : (2 forms)
- MOVZWL r16, r32
- MOVZWL m16, r32
func (*Program) MOVZWQ ¶
func (self *Program) MOVZWQ(v0 interface{}, v1 interface{}) *Instruction
MOVZWQ performs "Move with Zero-Extend".
Mnemonic : MOVZX Supported forms : (2 forms)
- MOVZWQ r16, r64
- MOVZWQ m16, r64
func (*Program) MPSADBW ¶
func (self *Program) MPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
MPSADBW performs "Compute Multiple Packed Sums of Absolute Difference".
Mnemonic : MPSADBW Supported forms : (2 forms)
- MPSADBW imm8, xmm, xmm [SSE4.1]
- MPSADBW imm8, m128, xmm [SSE4.1]
func (*Program) MULB ¶
func (self *Program) MULB(v0 interface{}) *Instruction
MULB performs "Unsigned Multiply".
Mnemonic : MUL Supported forms : (2 forms)
- MULB r8
- MULB m8
func (*Program) MULL ¶
func (self *Program) MULL(v0 interface{}) *Instruction
MULL performs "Unsigned Multiply".
Mnemonic : MUL Supported forms : (2 forms)
- MULL r32
- MULL m32
func (*Program) MULPD ¶
func (self *Program) MULPD(v0 interface{}, v1 interface{}) *Instruction
MULPD performs "Multiply Packed Double-Precision Floating-Point Values".
Mnemonic : MULPD Supported forms : (2 forms)
- MULPD xmm, xmm [SSE2]
- MULPD m128, xmm [SSE2]
func (*Program) MULPS ¶
func (self *Program) MULPS(v0 interface{}, v1 interface{}) *Instruction
MULPS performs "Multiply Packed Single-Precision Floating-Point Values".
Mnemonic : MULPS Supported forms : (2 forms)
- MULPS xmm, xmm [SSE]
- MULPS m128, xmm [SSE]
func (*Program) MULQ ¶
func (self *Program) MULQ(v0 interface{}) *Instruction
MULQ performs "Unsigned Multiply".
Mnemonic : MUL Supported forms : (2 forms)
- MULQ r64
- MULQ m64
func (*Program) MULSD ¶
func (self *Program) MULSD(v0 interface{}, v1 interface{}) *Instruction
MULSD performs "Multiply Scalar Double-Precision Floating-Point Values".
Mnemonic : MULSD Supported forms : (2 forms)
- MULSD xmm, xmm [SSE2]
- MULSD m64, xmm [SSE2]
func (*Program) MULSS ¶
func (self *Program) MULSS(v0 interface{}, v1 interface{}) *Instruction
MULSS performs "Multiply Scalar Single-Precision Floating-Point Values".
Mnemonic : MULSS Supported forms : (2 forms)
- MULSS xmm, xmm [SSE]
- MULSS m32, xmm [SSE]
func (*Program) MULW ¶
func (self *Program) MULW(v0 interface{}) *Instruction
MULW performs "Unsigned Multiply".
Mnemonic : MUL Supported forms : (2 forms)
- MULW r16
- MULW m16
func (*Program) MULXL ¶
func (self *Program) MULXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
MULXL performs "Unsigned Multiply Without Affecting Flags".
Mnemonic : MULX Supported forms : (2 forms)
- MULXL r32, r32, r32 [BMI2]
- MULXL m32, r32, r32 [BMI2]
func (*Program) MULXQ ¶
func (self *Program) MULXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
MULXQ performs "Unsigned Multiply Without Affecting Flags".
Mnemonic : MULX Supported forms : (2 forms)
- MULXQ r64, r64, r64 [BMI2]
- MULXQ m64, r64, r64 [BMI2]
func (*Program) MWAIT ¶
func (self *Program) MWAIT() *Instruction
MWAIT performs "Monitor Wait".
Mnemonic : MWAIT Supported forms : (1 form)
- MWAIT [MONITOR]
func (*Program) MWAITX ¶
func (self *Program) MWAITX() *Instruction
MWAITX performs "Monitor Wait with Timeout".
Mnemonic : MWAITX Supported forms : (1 form)
- MWAITX [MONITORX]
func (*Program) NEGB ¶
func (self *Program) NEGB(v0 interface{}) *Instruction
NEGB performs "Two's Complement Negation".
Mnemonic : NEG Supported forms : (2 forms)
- NEGB r8
- NEGB m8
func (*Program) NEGL ¶
func (self *Program) NEGL(v0 interface{}) *Instruction
NEGL performs "Two's Complement Negation".
Mnemonic : NEG Supported forms : (2 forms)
- NEGL r32
- NEGL m32
func (*Program) NEGQ ¶
func (self *Program) NEGQ(v0 interface{}) *Instruction
NEGQ performs "Two's Complement Negation".
Mnemonic : NEG Supported forms : (2 forms)
- NEGQ r64
- NEGQ m64
func (*Program) NEGW ¶
func (self *Program) NEGW(v0 interface{}) *Instruction
NEGW performs "Two's Complement Negation".
Mnemonic : NEG Supported forms : (2 forms)
- NEGW r16
- NEGW m16
func (*Program) NOP ¶
func (self *Program) NOP() *Instruction
NOP performs "No Operation".
Mnemonic : NOP Supported forms : (1 form)
- NOP
func (*Program) NOTB ¶
func (self *Program) NOTB(v0 interface{}) *Instruction
NOTB performs "One's Complement Negation".
Mnemonic : NOT Supported forms : (2 forms)
- NOTB r8
- NOTB m8
func (*Program) NOTL ¶
func (self *Program) NOTL(v0 interface{}) *Instruction
NOTL performs "One's Complement Negation".
Mnemonic : NOT Supported forms : (2 forms)
- NOTL r32
- NOTL m32
func (*Program) NOTQ ¶
func (self *Program) NOTQ(v0 interface{}) *Instruction
NOTQ performs "One's Complement Negation".
Mnemonic : NOT Supported forms : (2 forms)
- NOTQ r64
- NOTQ m64
func (*Program) NOTW ¶
func (self *Program) NOTW(v0 interface{}) *Instruction
NOTW performs "One's Complement Negation".
Mnemonic : NOT Supported forms : (2 forms)
- NOTW r16
- NOTW m16
func (*Program) ORB ¶
func (self *Program) ORB(v0 interface{}, v1 interface{}) *Instruction
ORB performs "Logical Inclusive OR".
Mnemonic : OR Supported forms : (6 forms)
- ORB imm8, al
- ORB imm8, r8
- ORB r8, r8
- ORB m8, r8
- ORB imm8, m8
- ORB r8, m8
func (*Program) ORL ¶
func (self *Program) ORL(v0 interface{}, v1 interface{}) *Instruction
ORL performs "Logical Inclusive OR".
Mnemonic : OR Supported forms : (8 forms)
- ORL imm32, eax
- ORL imm8, r32
- ORL imm32, r32
- ORL r32, r32
- ORL m32, r32
- ORL imm8, m32
- ORL imm32, m32
- ORL r32, m32
func (*Program) ORPD ¶
func (self *Program) ORPD(v0 interface{}, v1 interface{}) *Instruction
ORPD performs "Bitwise Logical OR of Double-Precision Floating-Point Values".
Mnemonic : ORPD Supported forms : (2 forms)
- ORPD xmm, xmm [SSE2]
- ORPD m128, xmm [SSE2]
func (*Program) ORPS ¶
func (self *Program) ORPS(v0 interface{}, v1 interface{}) *Instruction
ORPS performs "Bitwise Logical OR of Single-Precision Floating-Point Values".
Mnemonic : ORPS Supported forms : (2 forms)
- ORPS xmm, xmm [SSE]
- ORPS m128, xmm [SSE]
func (*Program) ORQ ¶
func (self *Program) ORQ(v0 interface{}, v1 interface{}) *Instruction
ORQ performs "Logical Inclusive OR".
Mnemonic : OR Supported forms : (8 forms)
- ORQ imm32, rax
- ORQ imm8, r64
- ORQ imm32, r64
- ORQ r64, r64
- ORQ m64, r64
- ORQ imm8, m64
- ORQ imm32, m64
- ORQ r64, m64
func (*Program) ORW ¶
func (self *Program) ORW(v0 interface{}, v1 interface{}) *Instruction
ORW performs "Logical Inclusive OR".
Mnemonic : OR Supported forms : (8 forms)
- ORW imm16, ax
- ORW imm8, r16
- ORW imm16, r16
- ORW r16, r16
- ORW m16, r16
- ORW imm8, m16
- ORW imm16, m16
- ORW r16, m16
func (*Program) PABSB ¶
func (self *Program) PABSB(v0 interface{}, v1 interface{}) *Instruction
PABSB performs "Packed Absolute Value of Byte Integers".
Mnemonic : PABSB Supported forms : (4 forms)
- PABSB mm, mm [SSSE3]
- PABSB m64, mm [SSSE3]
- PABSB xmm, xmm [SSSE3]
- PABSB m128, xmm [SSSE3]
func (*Program) PABSD ¶
func (self *Program) PABSD(v0 interface{}, v1 interface{}) *Instruction
PABSD performs "Packed Absolute Value of Doubleword Integers".
Mnemonic : PABSD Supported forms : (4 forms)
- PABSD mm, mm [SSSE3]
- PABSD m64, mm [SSSE3]
- PABSD xmm, xmm [SSSE3]
- PABSD m128, xmm [SSSE3]
func (*Program) PABSW ¶
func (self *Program) PABSW(v0 interface{}, v1 interface{}) *Instruction
PABSW performs "Packed Absolute Value of Word Integers".
Mnemonic : PABSW Supported forms : (4 forms)
- PABSW mm, mm [SSSE3]
- PABSW m64, mm [SSSE3]
- PABSW xmm, xmm [SSSE3]
- PABSW m128, xmm [SSSE3]
func (*Program) PACKSSDW ¶
func (self *Program) PACKSSDW(v0 interface{}, v1 interface{}) *Instruction
PACKSSDW performs "Pack Doublewords into Words with Signed Saturation".
Mnemonic : PACKSSDW Supported forms : (4 forms)
- PACKSSDW mm, mm [MMX]
- PACKSSDW m64, mm [MMX]
- PACKSSDW xmm, xmm [SSE2]
- PACKSSDW m128, xmm [SSE2]
func (*Program) PACKSSWB ¶
func (self *Program) PACKSSWB(v0 interface{}, v1 interface{}) *Instruction
PACKSSWB performs "Pack Words into Bytes with Signed Saturation".
Mnemonic : PACKSSWB Supported forms : (4 forms)
- PACKSSWB mm, mm [MMX]
- PACKSSWB m64, mm [MMX]
- PACKSSWB xmm, xmm [SSE2]
- PACKSSWB m128, xmm [SSE2]
func (*Program) PACKUSDW ¶
func (self *Program) PACKUSDW(v0 interface{}, v1 interface{}) *Instruction
PACKUSDW performs "Pack Doublewords into Words with Unsigned Saturation".
Mnemonic : PACKUSDW Supported forms : (2 forms)
- PACKUSDW xmm, xmm [SSE4.1]
- PACKUSDW m128, xmm [SSE4.1]
func (*Program) PACKUSWB ¶
func (self *Program) PACKUSWB(v0 interface{}, v1 interface{}) *Instruction
PACKUSWB performs "Pack Words into Bytes with Unsigned Saturation".
Mnemonic : PACKUSWB Supported forms : (4 forms)
- PACKUSWB mm, mm [MMX]
- PACKUSWB m64, mm [MMX]
- PACKUSWB xmm, xmm [SSE2]
- PACKUSWB m128, xmm [SSE2]
func (*Program) PADDB ¶
func (self *Program) PADDB(v0 interface{}, v1 interface{}) *Instruction
PADDB performs "Add Packed Byte Integers".
Mnemonic : PADDB Supported forms : (4 forms)
- PADDB mm, mm [MMX]
- PADDB m64, mm [MMX]
- PADDB xmm, xmm [SSE2]
- PADDB m128, xmm [SSE2]
func (*Program) PADDD ¶
func (self *Program) PADDD(v0 interface{}, v1 interface{}) *Instruction
PADDD performs "Add Packed Doubleword Integers".
Mnemonic : PADDD Supported forms : (4 forms)
- PADDD mm, mm [MMX]
- PADDD m64, mm [MMX]
- PADDD xmm, xmm [SSE2]
- PADDD m128, xmm [SSE2]
func (*Program) PADDQ ¶
func (self *Program) PADDQ(v0 interface{}, v1 interface{}) *Instruction
PADDQ performs "Add Packed Quadword Integers".
Mnemonic : PADDQ Supported forms : (4 forms)
- PADDQ mm, mm [SSE2]
- PADDQ m64, mm [SSE2]
- PADDQ xmm, xmm [SSE2]
- PADDQ m128, xmm [SSE2]
func (*Program) PADDSB ¶
func (self *Program) PADDSB(v0 interface{}, v1 interface{}) *Instruction
PADDSB performs "Add Packed Signed Byte Integers with Signed Saturation".
Mnemonic : PADDSB Supported forms : (4 forms)
- PADDSB mm, mm [MMX]
- PADDSB m64, mm [MMX]
- PADDSB xmm, xmm [SSE2]
- PADDSB m128, xmm [SSE2]
func (*Program) PADDSW ¶
func (self *Program) PADDSW(v0 interface{}, v1 interface{}) *Instruction
PADDSW performs "Add Packed Signed Word Integers with Signed Saturation".
Mnemonic : PADDSW Supported forms : (4 forms)
- PADDSW mm, mm [MMX]
- PADDSW m64, mm [MMX]
- PADDSW xmm, xmm [SSE2]
- PADDSW m128, xmm [SSE2]
func (*Program) PADDUSB ¶
func (self *Program) PADDUSB(v0 interface{}, v1 interface{}) *Instruction
PADDUSB performs "Add Packed Unsigned Byte Integers with Unsigned Saturation".
Mnemonic : PADDUSB Supported forms : (4 forms)
- PADDUSB mm, mm [MMX]
- PADDUSB m64, mm [MMX]
- PADDUSB xmm, xmm [SSE2]
- PADDUSB m128, xmm [SSE2]
func (*Program) PADDUSW ¶
func (self *Program) PADDUSW(v0 interface{}, v1 interface{}) *Instruction
PADDUSW performs "Add Packed Unsigned Word Integers with Unsigned Saturation".
Mnemonic : PADDUSW Supported forms : (4 forms)
- PADDUSW mm, mm [MMX]
- PADDUSW m64, mm [MMX]
- PADDUSW xmm, xmm [SSE2]
- PADDUSW m128, xmm [SSE2]
func (*Program) PADDW ¶
func (self *Program) PADDW(v0 interface{}, v1 interface{}) *Instruction
PADDW performs "Add Packed Word Integers".
Mnemonic : PADDW Supported forms : (4 forms)
- PADDW mm, mm [MMX]
- PADDW m64, mm [MMX]
- PADDW xmm, xmm [SSE2]
- PADDW m128, xmm [SSE2]
func (*Program) PALIGNR ¶
func (self *Program) PALIGNR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PALIGNR performs "Packed Align Right".
Mnemonic : PALIGNR Supported forms : (4 forms)
- PALIGNR imm8, mm, mm [SSSE3]
- PALIGNR imm8, m64, mm [SSSE3]
- PALIGNR imm8, xmm, xmm [SSSE3]
- PALIGNR imm8, m128, xmm [SSSE3]
func (*Program) PAND ¶
func (self *Program) PAND(v0 interface{}, v1 interface{}) *Instruction
PAND performs "Packed Bitwise Logical AND".
Mnemonic : PAND Supported forms : (4 forms)
- PAND mm, mm [MMX]
- PAND m64, mm [MMX]
- PAND xmm, xmm [SSE2]
- PAND m128, xmm [SSE2]
func (*Program) PANDN ¶
func (self *Program) PANDN(v0 interface{}, v1 interface{}) *Instruction
PANDN performs "Packed Bitwise Logical AND NOT".
Mnemonic : PANDN Supported forms : (4 forms)
- PANDN mm, mm [MMX]
- PANDN m64, mm [MMX]
- PANDN xmm, xmm [SSE2]
- PANDN m128, xmm [SSE2]
func (*Program) PAUSE ¶
func (self *Program) PAUSE() *Instruction
PAUSE performs "Spin Loop Hint".
Mnemonic : PAUSE Supported forms : (1 form)
- PAUSE
func (*Program) PAVGB ¶
func (self *Program) PAVGB(v0 interface{}, v1 interface{}) *Instruction
PAVGB performs "Average Packed Byte Integers".
Mnemonic : PAVGB Supported forms : (4 forms)
- PAVGB mm, mm [MMX+]
- PAVGB m64, mm [MMX+]
- PAVGB xmm, xmm [SSE2]
- PAVGB m128, xmm [SSE2]
func (*Program) PAVGUSB ¶
func (self *Program) PAVGUSB(v0 interface{}, v1 interface{}) *Instruction
PAVGUSB performs "Average Packed Byte Integers".
Mnemonic : PAVGUSB Supported forms : (2 forms)
- PAVGUSB mm, mm [3dnow!]
- PAVGUSB m64, mm [3dnow!]
func (*Program) PAVGW ¶
func (self *Program) PAVGW(v0 interface{}, v1 interface{}) *Instruction
PAVGW performs "Average Packed Word Integers".
Mnemonic : PAVGW Supported forms : (4 forms)
- PAVGW mm, mm [MMX+]
- PAVGW m64, mm [MMX+]
- PAVGW xmm, xmm [SSE2]
- PAVGW m128, xmm [SSE2]
func (*Program) PBLENDVB ¶
func (self *Program) PBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PBLENDVB performs "Variable Blend Packed Bytes".
Mnemonic : PBLENDVB Supported forms : (2 forms)
- PBLENDVB xmm0, xmm, xmm [SSE4.1]
- PBLENDVB xmm0, m128, xmm [SSE4.1]
func (*Program) PBLENDW ¶
func (self *Program) PBLENDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PBLENDW performs "Blend Packed Words".
Mnemonic : PBLENDW Supported forms : (2 forms)
- PBLENDW imm8, xmm, xmm [SSE4.1]
- PBLENDW imm8, m128, xmm [SSE4.1]
func (*Program) PCLMULQDQ ¶
func (self *Program) PCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PCLMULQDQ performs "Carry-Less Quadword Multiplication".
Mnemonic : PCLMULQDQ Supported forms : (2 forms)
- PCLMULQDQ imm8, xmm, xmm [PCLMULQDQ]
- PCLMULQDQ imm8, m128, xmm [PCLMULQDQ]
func (*Program) PCMPEQB ¶
func (self *Program) PCMPEQB(v0 interface{}, v1 interface{}) *Instruction
PCMPEQB performs "Compare Packed Byte Data for Equality".
Mnemonic : PCMPEQB Supported forms : (4 forms)
- PCMPEQB mm, mm [MMX]
- PCMPEQB m64, mm [MMX]
- PCMPEQB xmm, xmm [SSE2]
- PCMPEQB m128, xmm [SSE2]
func (*Program) PCMPEQD ¶
func (self *Program) PCMPEQD(v0 interface{}, v1 interface{}) *Instruction
PCMPEQD performs "Compare Packed Doubleword Data for Equality".
Mnemonic : PCMPEQD Supported forms : (4 forms)
- PCMPEQD mm, mm [MMX]
- PCMPEQD m64, mm [MMX]
- PCMPEQD xmm, xmm [SSE2]
- PCMPEQD m128, xmm [SSE2]
func (*Program) PCMPEQQ ¶
func (self *Program) PCMPEQQ(v0 interface{}, v1 interface{}) *Instruction
PCMPEQQ performs "Compare Packed Quadword Data for Equality".
Mnemonic : PCMPEQQ Supported forms : (2 forms)
- PCMPEQQ xmm, xmm [SSE4.1]
- PCMPEQQ m128, xmm [SSE4.1]
func (*Program) PCMPEQW ¶
func (self *Program) PCMPEQW(v0 interface{}, v1 interface{}) *Instruction
PCMPEQW performs "Compare Packed Word Data for Equality".
Mnemonic : PCMPEQW Supported forms : (4 forms)
- PCMPEQW mm, mm [MMX]
- PCMPEQW m64, mm [MMX]
- PCMPEQW xmm, xmm [SSE2]
- PCMPEQW m128, xmm [SSE2]
func (*Program) PCMPESTRI ¶
func (self *Program) PCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PCMPESTRI performs "Packed Compare Explicit Length Strings, Return Index".
Mnemonic : PCMPESTRI Supported forms : (2 forms)
- PCMPESTRI imm8, xmm, xmm [SSE4.2]
- PCMPESTRI imm8, m128, xmm [SSE4.2]
func (*Program) PCMPESTRM ¶
func (self *Program) PCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PCMPESTRM performs "Packed Compare Explicit Length Strings, Return Mask".
Mnemonic : PCMPESTRM Supported forms : (2 forms)
- PCMPESTRM imm8, xmm, xmm [SSE4.2]
- PCMPESTRM imm8, m128, xmm [SSE4.2]
func (*Program) PCMPGTB ¶
func (self *Program) PCMPGTB(v0 interface{}, v1 interface{}) *Instruction
PCMPGTB performs "Compare Packed Signed Byte Integers for Greater Than".
Mnemonic : PCMPGTB Supported forms : (4 forms)
- PCMPGTB mm, mm [MMX]
- PCMPGTB m64, mm [MMX]
- PCMPGTB xmm, xmm [SSE2]
- PCMPGTB m128, xmm [SSE2]
func (*Program) PCMPGTD ¶
func (self *Program) PCMPGTD(v0 interface{}, v1 interface{}) *Instruction
PCMPGTD performs "Compare Packed Signed Doubleword Integers for Greater Than".
Mnemonic : PCMPGTD Supported forms : (4 forms)
- PCMPGTD mm, mm [MMX]
- PCMPGTD m64, mm [MMX]
- PCMPGTD xmm, xmm [SSE2]
- PCMPGTD m128, xmm [SSE2]
func (*Program) PCMPGTQ ¶
func (self *Program) PCMPGTQ(v0 interface{}, v1 interface{}) *Instruction
PCMPGTQ performs "Compare Packed Data for Greater Than".
Mnemonic : PCMPGTQ Supported forms : (2 forms)
- PCMPGTQ xmm, xmm [SSE4.2]
- PCMPGTQ m128, xmm [SSE4.2]
func (*Program) PCMPGTW ¶
func (self *Program) PCMPGTW(v0 interface{}, v1 interface{}) *Instruction
PCMPGTW performs "Compare Packed Signed Word Integers for Greater Than".
Mnemonic : PCMPGTW Supported forms : (4 forms)
- PCMPGTW mm, mm [MMX]
- PCMPGTW m64, mm [MMX]
- PCMPGTW xmm, xmm [SSE2]
- PCMPGTW m128, xmm [SSE2]
func (*Program) PCMPISTRI ¶
func (self *Program) PCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PCMPISTRI performs "Packed Compare Implicit Length Strings, Return Index".
Mnemonic : PCMPISTRI Supported forms : (2 forms)
- PCMPISTRI imm8, xmm, xmm [SSE4.2]
- PCMPISTRI imm8, m128, xmm [SSE4.2]
func (*Program) PCMPISTRM ¶
func (self *Program) PCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PCMPISTRM performs "Packed Compare Implicit Length Strings, Return Mask".
Mnemonic : PCMPISTRM Supported forms : (2 forms)
- PCMPISTRM imm8, xmm, xmm [SSE4.2]
- PCMPISTRM imm8, m128, xmm [SSE4.2]
func (*Program) PDEP ¶
func (self *Program) PDEP(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PDEP performs "Parallel Bits Deposit".
Mnemonic : PDEP Supported forms : (4 forms)
- PDEP r32, r32, r32 [BMI2]
- PDEP m32, r32, r32 [BMI2]
- PDEP r64, r64, r64 [BMI2]
- PDEP m64, r64, r64 [BMI2]
func (*Program) PEXT ¶
func (self *Program) PEXT(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PEXT performs "Parallel Bits Extract".
Mnemonic : PEXT Supported forms : (4 forms)
- PEXT r32, r32, r32 [BMI2]
- PEXT m32, r32, r32 [BMI2]
- PEXT r64, r64, r64 [BMI2]
- PEXT m64, r64, r64 [BMI2]
func (*Program) PEXTRB ¶
func (self *Program) PEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PEXTRB performs "Extract Byte".
Mnemonic : PEXTRB Supported forms : (2 forms)
- PEXTRB imm8, xmm, r32 [SSE4.1]
- PEXTRB imm8, xmm, m8 [SSE4.1]
func (*Program) PEXTRD ¶
func (self *Program) PEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PEXTRD performs "Extract Doubleword".
Mnemonic : PEXTRD Supported forms : (2 forms)
- PEXTRD imm8, xmm, r32 [SSE4.1]
- PEXTRD imm8, xmm, m32 [SSE4.1]
func (*Program) PEXTRQ ¶
func (self *Program) PEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PEXTRQ performs "Extract Quadword".
Mnemonic : PEXTRQ Supported forms : (2 forms)
- PEXTRQ imm8, xmm, r64 [SSE4.1]
- PEXTRQ imm8, xmm, m64 [SSE4.1]
func (*Program) PEXTRW ¶
func (self *Program) PEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PEXTRW performs "Extract Word".
Mnemonic : PEXTRW Supported forms : (3 forms)
- PEXTRW imm8, mm, r32 [MMX+]
- PEXTRW imm8, xmm, r32 [SSE4.1]
- PEXTRW imm8, xmm, m16 [SSE4.1]
func (*Program) PF2ID ¶
func (self *Program) PF2ID(v0 interface{}, v1 interface{}) *Instruction
PF2ID performs "Packed Floating-Point to Integer Doubleword Converson".
Mnemonic : PF2ID Supported forms : (2 forms)
- PF2ID mm, mm [3dnow!]
- PF2ID m64, mm [3dnow!]
func (*Program) PF2IW ¶
func (self *Program) PF2IW(v0 interface{}, v1 interface{}) *Instruction
PF2IW performs "Packed Floating-Point to Integer Word Conversion".
Mnemonic : PF2IW Supported forms : (2 forms)
- PF2IW mm, mm [3dnow!+]
- PF2IW m64, mm [3dnow!+]
func (*Program) PFACC ¶
func (self *Program) PFACC(v0 interface{}, v1 interface{}) *Instruction
PFACC performs "Packed Floating-Point Accumulate".
Mnemonic : PFACC Supported forms : (2 forms)
- PFACC mm, mm [3dnow!]
- PFACC m64, mm [3dnow!]
func (*Program) PFADD ¶
func (self *Program) PFADD(v0 interface{}, v1 interface{}) *Instruction
PFADD performs "Packed Floating-Point Add".
Mnemonic : PFADD Supported forms : (2 forms)
- PFADD mm, mm [3dnow!]
- PFADD m64, mm [3dnow!]
func (*Program) PFCMPEQ ¶
func (self *Program) PFCMPEQ(v0 interface{}, v1 interface{}) *Instruction
PFCMPEQ performs "Packed Floating-Point Compare for Equal".
Mnemonic : PFCMPEQ Supported forms : (2 forms)
- PFCMPEQ mm, mm [3dnow!]
- PFCMPEQ m64, mm [3dnow!]
func (*Program) PFCMPGE ¶
func (self *Program) PFCMPGE(v0 interface{}, v1 interface{}) *Instruction
PFCMPGE performs "Packed Floating-Point Compare for Greater or Equal".
Mnemonic : PFCMPGE Supported forms : (2 forms)
- PFCMPGE mm, mm [3dnow!]
- PFCMPGE m64, mm [3dnow!]
func (*Program) PFCMPGT ¶
func (self *Program) PFCMPGT(v0 interface{}, v1 interface{}) *Instruction
PFCMPGT performs "Packed Floating-Point Compare for Greater Than".
Mnemonic : PFCMPGT Supported forms : (2 forms)
- PFCMPGT mm, mm [3dnow!]
- PFCMPGT m64, mm [3dnow!]
func (*Program) PFMAX ¶
func (self *Program) PFMAX(v0 interface{}, v1 interface{}) *Instruction
PFMAX performs "Packed Floating-Point Maximum".
Mnemonic : PFMAX Supported forms : (2 forms)
- PFMAX mm, mm [3dnow!]
- PFMAX m64, mm [3dnow!]
func (*Program) PFMIN ¶
func (self *Program) PFMIN(v0 interface{}, v1 interface{}) *Instruction
PFMIN performs "Packed Floating-Point Minimum".
Mnemonic : PFMIN Supported forms : (2 forms)
- PFMIN mm, mm [3dnow!]
- PFMIN m64, mm [3dnow!]
func (*Program) PFMUL ¶
func (self *Program) PFMUL(v0 interface{}, v1 interface{}) *Instruction
PFMUL performs "Packed Floating-Point Multiply".
Mnemonic : PFMUL Supported forms : (2 forms)
- PFMUL mm, mm [3dnow!]
- PFMUL m64, mm [3dnow!]
func (*Program) PFNACC ¶
func (self *Program) PFNACC(v0 interface{}, v1 interface{}) *Instruction
PFNACC performs "Packed Floating-Point Negative Accumulate".
Mnemonic : PFNACC Supported forms : (2 forms)
- PFNACC mm, mm [3dnow!+]
- PFNACC m64, mm [3dnow!+]
func (*Program) PFPNACC ¶
func (self *Program) PFPNACC(v0 interface{}, v1 interface{}) *Instruction
PFPNACC performs "Packed Floating-Point Positive-Negative Accumulate".
Mnemonic : PFPNACC Supported forms : (2 forms)
- PFPNACC mm, mm [3dnow!+]
- PFPNACC m64, mm [3dnow!+]
func (*Program) PFRCP ¶
func (self *Program) PFRCP(v0 interface{}, v1 interface{}) *Instruction
PFRCP performs "Packed Floating-Point Reciprocal Approximation".
Mnemonic : PFRCP Supported forms : (2 forms)
- PFRCP mm, mm [3dnow!]
- PFRCP m64, mm [3dnow!]
func (*Program) PFRCPIT1 ¶
func (self *Program) PFRCPIT1(v0 interface{}, v1 interface{}) *Instruction
PFRCPIT1 performs "Packed Floating-Point Reciprocal Iteration 1".
Mnemonic : PFRCPIT1 Supported forms : (2 forms)
- PFRCPIT1 mm, mm [3dnow!]
- PFRCPIT1 m64, mm [3dnow!]
func (*Program) PFRCPIT2 ¶
func (self *Program) PFRCPIT2(v0 interface{}, v1 interface{}) *Instruction
PFRCPIT2 performs "Packed Floating-Point Reciprocal Iteration 2".
Mnemonic : PFRCPIT2 Supported forms : (2 forms)
- PFRCPIT2 mm, mm [3dnow!]
- PFRCPIT2 m64, mm [3dnow!]
func (*Program) PFRSQIT1 ¶
func (self *Program) PFRSQIT1(v0 interface{}, v1 interface{}) *Instruction
PFRSQIT1 performs "Packed Floating-Point Reciprocal Square Root Iteration 1".
Mnemonic : PFRSQIT1 Supported forms : (2 forms)
- PFRSQIT1 mm, mm [3dnow!]
- PFRSQIT1 m64, mm [3dnow!]
func (*Program) PFRSQRT ¶
func (self *Program) PFRSQRT(v0 interface{}, v1 interface{}) *Instruction
PFRSQRT performs "Packed Floating-Point Reciprocal Square Root Approximation".
Mnemonic : PFRSQRT Supported forms : (2 forms)
- PFRSQRT mm, mm [3dnow!]
- PFRSQRT m64, mm [3dnow!]
func (*Program) PFSUB ¶
func (self *Program) PFSUB(v0 interface{}, v1 interface{}) *Instruction
PFSUB performs "Packed Floating-Point Subtract".
Mnemonic : PFSUB Supported forms : (2 forms)
- PFSUB mm, mm [3dnow!]
- PFSUB m64, mm [3dnow!]
func (*Program) PFSUBR ¶
func (self *Program) PFSUBR(v0 interface{}, v1 interface{}) *Instruction
PFSUBR performs "Packed Floating-Point Subtract Reverse".
Mnemonic : PFSUBR Supported forms : (2 forms)
- PFSUBR mm, mm [3dnow!]
- PFSUBR m64, mm [3dnow!]
func (*Program) PHADDD ¶
func (self *Program) PHADDD(v0 interface{}, v1 interface{}) *Instruction
PHADDD performs "Packed Horizontal Add Doubleword Integer".
Mnemonic : PHADDD Supported forms : (4 forms)
- PHADDD mm, mm [SSSE3]
- PHADDD m64, mm [SSSE3]
- PHADDD xmm, xmm [SSSE3]
- PHADDD m128, xmm [SSSE3]
func (*Program) PHADDSW ¶
func (self *Program) PHADDSW(v0 interface{}, v1 interface{}) *Instruction
PHADDSW performs "Packed Horizontal Add Signed Word Integers with Signed Saturation".
Mnemonic : PHADDSW Supported forms : (4 forms)
- PHADDSW mm, mm [SSSE3]
- PHADDSW m64, mm [SSSE3]
- PHADDSW xmm, xmm [SSSE3]
- PHADDSW m128, xmm [SSSE3]
func (*Program) PHADDW ¶
func (self *Program) PHADDW(v0 interface{}, v1 interface{}) *Instruction
PHADDW performs "Packed Horizontal Add Word Integers".
Mnemonic : PHADDW Supported forms : (4 forms)
- PHADDW mm, mm [SSSE3]
- PHADDW m64, mm [SSSE3]
- PHADDW xmm, xmm [SSSE3]
- PHADDW m128, xmm [SSSE3]
func (*Program) PHMINPOSUW ¶
func (self *Program) PHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction
PHMINPOSUW performs "Packed Horizontal Minimum of Unsigned Word Integers".
Mnemonic : PHMINPOSUW Supported forms : (2 forms)
- PHMINPOSUW xmm, xmm [SSE4.1]
- PHMINPOSUW m128, xmm [SSE4.1]
func (*Program) PHSUBD ¶
func (self *Program) PHSUBD(v0 interface{}, v1 interface{}) *Instruction
PHSUBD performs "Packed Horizontal Subtract Doubleword Integers".
Mnemonic : PHSUBD Supported forms : (4 forms)
- PHSUBD mm, mm [SSSE3]
- PHSUBD m64, mm [SSSE3]
- PHSUBD xmm, xmm [SSSE3]
- PHSUBD m128, xmm [SSSE3]
func (*Program) PHSUBSW ¶
func (self *Program) PHSUBSW(v0 interface{}, v1 interface{}) *Instruction
PHSUBSW performs "Packed Horizontal Subtract Signed Word Integers with Signed Saturation".
Mnemonic : PHSUBSW Supported forms : (4 forms)
- PHSUBSW mm, mm [SSSE3]
- PHSUBSW m64, mm [SSSE3]
- PHSUBSW xmm, xmm [SSSE3]
- PHSUBSW m128, xmm [SSSE3]
func (*Program) PHSUBW ¶
func (self *Program) PHSUBW(v0 interface{}, v1 interface{}) *Instruction
PHSUBW performs "Packed Horizontal Subtract Word Integers".
Mnemonic : PHSUBW Supported forms : (4 forms)
- PHSUBW mm, mm [SSSE3]
- PHSUBW m64, mm [SSSE3]
- PHSUBW xmm, xmm [SSSE3]
- PHSUBW m128, xmm [SSSE3]
func (*Program) PI2FD ¶
func (self *Program) PI2FD(v0 interface{}, v1 interface{}) *Instruction
PI2FD performs "Packed Integer to Floating-Point Doubleword Conversion".
Mnemonic : PI2FD Supported forms : (2 forms)
- PI2FD mm, mm [3dnow!]
- PI2FD m64, mm [3dnow!]
func (*Program) PI2FW ¶
func (self *Program) PI2FW(v0 interface{}, v1 interface{}) *Instruction
PI2FW performs "Packed Integer to Floating-Point Word Conversion".
Mnemonic : PI2FW Supported forms : (2 forms)
- PI2FW mm, mm [3dnow!+]
- PI2FW m64, mm [3dnow!+]
func (*Program) PINSRB ¶
func (self *Program) PINSRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PINSRB performs "Insert Byte".
Mnemonic : PINSRB Supported forms : (2 forms)
- PINSRB imm8, r32, xmm [SSE4.1]
- PINSRB imm8, m8, xmm [SSE4.1]
func (*Program) PINSRD ¶
func (self *Program) PINSRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PINSRD performs "Insert Doubleword".
Mnemonic : PINSRD Supported forms : (2 forms)
- PINSRD imm8, r32, xmm [SSE4.1]
- PINSRD imm8, m32, xmm [SSE4.1]
func (*Program) PINSRQ ¶
func (self *Program) PINSRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PINSRQ performs "Insert Quadword".
Mnemonic : PINSRQ Supported forms : (2 forms)
- PINSRQ imm8, r64, xmm [SSE4.1]
- PINSRQ imm8, m64, xmm [SSE4.1]
func (*Program) PINSRW ¶
func (self *Program) PINSRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PINSRW performs "Insert Word".
Mnemonic : PINSRW Supported forms : (4 forms)
- PINSRW imm8, r32, mm [MMX+]
- PINSRW imm8, m16, mm [MMX+]
- PINSRW imm8, r32, xmm [SSE2]
- PINSRW imm8, m16, xmm [SSE2]
func (*Program) PMADDUBSW ¶
func (self *Program) PMADDUBSW(v0 interface{}, v1 interface{}) *Instruction
PMADDUBSW performs "Multiply and Add Packed Signed and Unsigned Byte Integers".
Mnemonic : PMADDUBSW Supported forms : (4 forms)
- PMADDUBSW mm, mm [SSSE3]
- PMADDUBSW m64, mm [SSSE3]
- PMADDUBSW xmm, xmm [SSSE3]
- PMADDUBSW m128, xmm [SSSE3]
func (*Program) PMADDWD ¶
func (self *Program) PMADDWD(v0 interface{}, v1 interface{}) *Instruction
PMADDWD performs "Multiply and Add Packed Signed Word Integers".
Mnemonic : PMADDWD Supported forms : (4 forms)
- PMADDWD mm, mm [MMX]
- PMADDWD m64, mm [MMX]
- PMADDWD xmm, xmm [SSE2]
- PMADDWD m128, xmm [SSE2]
func (*Program) PMAXSB ¶
func (self *Program) PMAXSB(v0 interface{}, v1 interface{}) *Instruction
PMAXSB performs "Maximum of Packed Signed Byte Integers".
Mnemonic : PMAXSB Supported forms : (2 forms)
- PMAXSB xmm, xmm [SSE4.1]
- PMAXSB m128, xmm [SSE4.1]
func (*Program) PMAXSD ¶
func (self *Program) PMAXSD(v0 interface{}, v1 interface{}) *Instruction
PMAXSD performs "Maximum of Packed Signed Doubleword Integers".
Mnemonic : PMAXSD Supported forms : (2 forms)
- PMAXSD xmm, xmm [SSE4.1]
- PMAXSD m128, xmm [SSE4.1]
func (*Program) PMAXSW ¶
func (self *Program) PMAXSW(v0 interface{}, v1 interface{}) *Instruction
PMAXSW performs "Maximum of Packed Signed Word Integers".
Mnemonic : PMAXSW Supported forms : (4 forms)
- PMAXSW mm, mm [MMX+]
- PMAXSW m64, mm [MMX+]
- PMAXSW xmm, xmm [SSE2]
- PMAXSW m128, xmm [SSE2]
func (*Program) PMAXUB ¶
func (self *Program) PMAXUB(v0 interface{}, v1 interface{}) *Instruction
PMAXUB performs "Maximum of Packed Unsigned Byte Integers".
Mnemonic : PMAXUB Supported forms : (4 forms)
- PMAXUB mm, mm [MMX+]
- PMAXUB m64, mm [MMX+]
- PMAXUB xmm, xmm [SSE2]
- PMAXUB m128, xmm [SSE2]
func (*Program) PMAXUD ¶
func (self *Program) PMAXUD(v0 interface{}, v1 interface{}) *Instruction
PMAXUD performs "Maximum of Packed Unsigned Doubleword Integers".
Mnemonic : PMAXUD Supported forms : (2 forms)
- PMAXUD xmm, xmm [SSE4.1]
- PMAXUD m128, xmm [SSE4.1]
func (*Program) PMAXUW ¶
func (self *Program) PMAXUW(v0 interface{}, v1 interface{}) *Instruction
PMAXUW performs "Maximum of Packed Unsigned Word Integers".
Mnemonic : PMAXUW Supported forms : (2 forms)
- PMAXUW xmm, xmm [SSE4.1]
- PMAXUW m128, xmm [SSE4.1]
func (*Program) PMINSB ¶
func (self *Program) PMINSB(v0 interface{}, v1 interface{}) *Instruction
PMINSB performs "Minimum of Packed Signed Byte Integers".
Mnemonic : PMINSB Supported forms : (2 forms)
- PMINSB xmm, xmm [SSE4.1]
- PMINSB m128, xmm [SSE4.1]
func (*Program) PMINSD ¶
func (self *Program) PMINSD(v0 interface{}, v1 interface{}) *Instruction
PMINSD performs "Minimum of Packed Signed Doubleword Integers".
Mnemonic : PMINSD Supported forms : (2 forms)
- PMINSD xmm, xmm [SSE4.1]
- PMINSD m128, xmm [SSE4.1]
func (*Program) PMINSW ¶
func (self *Program) PMINSW(v0 interface{}, v1 interface{}) *Instruction
PMINSW performs "Minimum of Packed Signed Word Integers".
Mnemonic : PMINSW Supported forms : (4 forms)
- PMINSW mm, mm [MMX+]
- PMINSW m64, mm [MMX+]
- PMINSW xmm, xmm [SSE2]
- PMINSW m128, xmm [SSE2]
func (*Program) PMINUB ¶
func (self *Program) PMINUB(v0 interface{}, v1 interface{}) *Instruction
PMINUB performs "Minimum of Packed Unsigned Byte Integers".
Mnemonic : PMINUB Supported forms : (4 forms)
- PMINUB mm, mm [MMX+]
- PMINUB m64, mm [MMX+]
- PMINUB xmm, xmm [SSE2]
- PMINUB m128, xmm [SSE2]
func (*Program) PMINUD ¶
func (self *Program) PMINUD(v0 interface{}, v1 interface{}) *Instruction
PMINUD performs "Minimum of Packed Unsigned Doubleword Integers".
Mnemonic : PMINUD Supported forms : (2 forms)
- PMINUD xmm, xmm [SSE4.1]
- PMINUD m128, xmm [SSE4.1]
func (*Program) PMINUW ¶
func (self *Program) PMINUW(v0 interface{}, v1 interface{}) *Instruction
PMINUW performs "Minimum of Packed Unsigned Word Integers".
Mnemonic : PMINUW Supported forms : (2 forms)
- PMINUW xmm, xmm [SSE4.1]
- PMINUW m128, xmm [SSE4.1]
func (*Program) PMOVMSKB ¶
func (self *Program) PMOVMSKB(v0 interface{}, v1 interface{}) *Instruction
PMOVMSKB performs "Move Byte Mask".
Mnemonic : PMOVMSKB Supported forms : (2 forms)
- PMOVMSKB mm, r32 [MMX+]
- PMOVMSKB xmm, r32 [SSE2]
func (*Program) PMOVSXBD ¶
func (self *Program) PMOVSXBD(v0 interface{}, v1 interface{}) *Instruction
PMOVSXBD performs "Move Packed Byte Integers to Doubleword Integers with Sign Extension".
Mnemonic : PMOVSXBD Supported forms : (2 forms)
- PMOVSXBD xmm, xmm [SSE4.1]
- PMOVSXBD m32, xmm [SSE4.1]
func (*Program) PMOVSXBQ ¶
func (self *Program) PMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction
PMOVSXBQ performs "Move Packed Byte Integers to Quadword Integers with Sign Extension".
Mnemonic : PMOVSXBQ Supported forms : (2 forms)
- PMOVSXBQ xmm, xmm [SSE4.1]
- PMOVSXBQ m16, xmm [SSE4.1]
func (*Program) PMOVSXBW ¶
func (self *Program) PMOVSXBW(v0 interface{}, v1 interface{}) *Instruction
PMOVSXBW performs "Move Packed Byte Integers to Word Integers with Sign Extension".
Mnemonic : PMOVSXBW Supported forms : (2 forms)
- PMOVSXBW xmm, xmm [SSE4.1]
- PMOVSXBW m64, xmm [SSE4.1]
func (*Program) PMOVSXDQ ¶
func (self *Program) PMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction
PMOVSXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Sign Extension".
Mnemonic : PMOVSXDQ Supported forms : (2 forms)
- PMOVSXDQ xmm, xmm [SSE4.1]
- PMOVSXDQ m64, xmm [SSE4.1]
func (*Program) PMOVSXWD ¶
func (self *Program) PMOVSXWD(v0 interface{}, v1 interface{}) *Instruction
PMOVSXWD performs "Move Packed Word Integers to Doubleword Integers with Sign Extension".
Mnemonic : PMOVSXWD Supported forms : (2 forms)
- PMOVSXWD xmm, xmm [SSE4.1]
- PMOVSXWD m64, xmm [SSE4.1]
func (*Program) PMOVSXWQ ¶
func (self *Program) PMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction
PMOVSXWQ performs "Move Packed Word Integers to Quadword Integers with Sign Extension".
Mnemonic : PMOVSXWQ Supported forms : (2 forms)
- PMOVSXWQ xmm, xmm [SSE4.1]
- PMOVSXWQ m32, xmm [SSE4.1]
func (*Program) PMOVZXBD ¶
func (self *Program) PMOVZXBD(v0 interface{}, v1 interface{}) *Instruction
PMOVZXBD performs "Move Packed Byte Integers to Doubleword Integers with Zero Extension".
Mnemonic : PMOVZXBD Supported forms : (2 forms)
- PMOVZXBD xmm, xmm [SSE4.1]
- PMOVZXBD m32, xmm [SSE4.1]
func (*Program) PMOVZXBQ ¶
func (self *Program) PMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction
PMOVZXBQ performs "Move Packed Byte Integers to Quadword Integers with Zero Extension".
Mnemonic : PMOVZXBQ Supported forms : (2 forms)
- PMOVZXBQ xmm, xmm [SSE4.1]
- PMOVZXBQ m16, xmm [SSE4.1]
func (*Program) PMOVZXBW ¶
func (self *Program) PMOVZXBW(v0 interface{}, v1 interface{}) *Instruction
PMOVZXBW performs "Move Packed Byte Integers to Word Integers with Zero Extension".
Mnemonic : PMOVZXBW Supported forms : (2 forms)
- PMOVZXBW xmm, xmm [SSE4.1]
- PMOVZXBW m64, xmm [SSE4.1]
func (*Program) PMOVZXDQ ¶
func (self *Program) PMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction
PMOVZXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Zero Extension".
Mnemonic : PMOVZXDQ Supported forms : (2 forms)
- PMOVZXDQ xmm, xmm [SSE4.1]
- PMOVZXDQ m64, xmm [SSE4.1]
func (*Program) PMOVZXWD ¶
func (self *Program) PMOVZXWD(v0 interface{}, v1 interface{}) *Instruction
PMOVZXWD performs "Move Packed Word Integers to Doubleword Integers with Zero Extension".
Mnemonic : PMOVZXWD Supported forms : (2 forms)
- PMOVZXWD xmm, xmm [SSE4.1]
- PMOVZXWD m64, xmm [SSE4.1]
func (*Program) PMOVZXWQ ¶
func (self *Program) PMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction
PMOVZXWQ performs "Move Packed Word Integers to Quadword Integers with Zero Extension".
Mnemonic : PMOVZXWQ Supported forms : (2 forms)
- PMOVZXWQ xmm, xmm [SSE4.1]
- PMOVZXWQ m32, xmm [SSE4.1]
func (*Program) PMULDQ ¶
func (self *Program) PMULDQ(v0 interface{}, v1 interface{}) *Instruction
PMULDQ performs "Multiply Packed Signed Doubleword Integers and Store Quadword Result".
Mnemonic : PMULDQ Supported forms : (2 forms)
- PMULDQ xmm, xmm [SSE4.1]
- PMULDQ m128, xmm [SSE4.1]
func (*Program) PMULHRSW ¶
func (self *Program) PMULHRSW(v0 interface{}, v1 interface{}) *Instruction
PMULHRSW performs "Packed Multiply Signed Word Integers and Store High Result with Round and Scale".
Mnemonic : PMULHRSW Supported forms : (4 forms)
- PMULHRSW mm, mm [SSSE3]
- PMULHRSW m64, mm [SSSE3]
- PMULHRSW xmm, xmm [SSSE3]
- PMULHRSW m128, xmm [SSSE3]
func (*Program) PMULHRW ¶
func (self *Program) PMULHRW(v0 interface{}, v1 interface{}) *Instruction
PMULHRW performs "Packed Multiply High Rounded Word".
Mnemonic : PMULHRW Supported forms : (2 forms)
- PMULHRW mm, mm [3dnow!]
- PMULHRW m64, mm [3dnow!]
func (*Program) PMULHUW ¶
func (self *Program) PMULHUW(v0 interface{}, v1 interface{}) *Instruction
PMULHUW performs "Multiply Packed Unsigned Word Integers and Store High Result".
Mnemonic : PMULHUW Supported forms : (4 forms)
- PMULHUW mm, mm [MMX+]
- PMULHUW m64, mm [MMX+]
- PMULHUW xmm, xmm [SSE2]
- PMULHUW m128, xmm [SSE2]
func (*Program) PMULHW ¶
func (self *Program) PMULHW(v0 interface{}, v1 interface{}) *Instruction
PMULHW performs "Multiply Packed Signed Word Integers and Store High Result".
Mnemonic : PMULHW Supported forms : (4 forms)
- PMULHW mm, mm [MMX]
- PMULHW m64, mm [MMX]
- PMULHW xmm, xmm [SSE2]
- PMULHW m128, xmm [SSE2]
func (*Program) PMULLD ¶
func (self *Program) PMULLD(v0 interface{}, v1 interface{}) *Instruction
PMULLD performs "Multiply Packed Signed Doubleword Integers and Store Low Result".
Mnemonic : PMULLD Supported forms : (2 forms)
- PMULLD xmm, xmm [SSE4.1]
- PMULLD m128, xmm [SSE4.1]
func (*Program) PMULLW ¶
func (self *Program) PMULLW(v0 interface{}, v1 interface{}) *Instruction
PMULLW performs "Multiply Packed Signed Word Integers and Store Low Result".
Mnemonic : PMULLW Supported forms : (4 forms)
- PMULLW mm, mm [MMX]
- PMULLW m64, mm [MMX]
- PMULLW xmm, xmm [SSE2]
- PMULLW m128, xmm [SSE2]
func (*Program) PMULUDQ ¶
func (self *Program) PMULUDQ(v0 interface{}, v1 interface{}) *Instruction
PMULUDQ performs "Multiply Packed Unsigned Doubleword Integers".
Mnemonic : PMULUDQ Supported forms : (4 forms)
- PMULUDQ mm, mm [SSE2]
- PMULUDQ m64, mm [SSE2]
- PMULUDQ xmm, xmm [SSE2]
- PMULUDQ m128, xmm [SSE2]
func (*Program) POPCNTL ¶
func (self *Program) POPCNTL(v0 interface{}, v1 interface{}) *Instruction
POPCNTL performs "Count of Number of Bits Set to 1".
Mnemonic : POPCNT Supported forms : (2 forms)
- POPCNTL r32, r32 [POPCNT]
- POPCNTL m32, r32 [POPCNT]
func (*Program) POPCNTQ ¶
func (self *Program) POPCNTQ(v0 interface{}, v1 interface{}) *Instruction
POPCNTQ performs "Count of Number of Bits Set to 1".
Mnemonic : POPCNT Supported forms : (2 forms)
- POPCNTQ r64, r64 [POPCNT]
- POPCNTQ m64, r64 [POPCNT]
func (*Program) POPCNTW ¶
func (self *Program) POPCNTW(v0 interface{}, v1 interface{}) *Instruction
POPCNTW performs "Count of Number of Bits Set to 1".
Mnemonic : POPCNT Supported forms : (2 forms)
- POPCNTW r16, r16 [POPCNT]
- POPCNTW m16, r16 [POPCNT]
func (*Program) POPQ ¶
func (self *Program) POPQ(v0 interface{}) *Instruction
POPQ performs "Pop a Value from the Stack".
Mnemonic : POP Supported forms : (2 forms)
- POPQ r64
- POPQ m64
func (*Program) POPW ¶
func (self *Program) POPW(v0 interface{}) *Instruction
POPW performs "Pop a Value from the Stack".
Mnemonic : POP Supported forms : (2 forms)
- POPW r16
- POPW m16
func (*Program) POR ¶
func (self *Program) POR(v0 interface{}, v1 interface{}) *Instruction
POR performs "Packed Bitwise Logical OR".
Mnemonic : POR Supported forms : (4 forms)
- POR mm, mm [MMX]
- POR m64, mm [MMX]
- POR xmm, xmm [SSE2]
- POR m128, xmm [SSE2]
func (*Program) PREFETCH ¶
func (self *Program) PREFETCH(v0 interface{}) *Instruction
PREFETCH performs "Prefetch Data into Caches".
Mnemonic : PREFETCH Supported forms : (1 form)
- PREFETCH m8 [PREFETCH]
func (*Program) PREFETCHNTA ¶
func (self *Program) PREFETCHNTA(v0 interface{}) *Instruction
PREFETCHNTA performs "Prefetch Data Into Caches using NTA Hint".
Mnemonic : PREFETCHNTA Supported forms : (1 form)
- PREFETCHNTA m8 [MMX+]
func (*Program) PREFETCHT0 ¶
func (self *Program) PREFETCHT0(v0 interface{}) *Instruction
PREFETCHT0 performs "Prefetch Data Into Caches using T0 Hint".
Mnemonic : PREFETCHT0 Supported forms : (1 form)
- PREFETCHT0 m8 [MMX+]
func (*Program) PREFETCHT1 ¶
func (self *Program) PREFETCHT1(v0 interface{}) *Instruction
PREFETCHT1 performs "Prefetch Data Into Caches using T1 Hint".
Mnemonic : PREFETCHT1 Supported forms : (1 form)
- PREFETCHT1 m8 [MMX+]
func (*Program) PREFETCHT2 ¶
func (self *Program) PREFETCHT2(v0 interface{}) *Instruction
PREFETCHT2 performs "Prefetch Data Into Caches using T2 Hint".
Mnemonic : PREFETCHT2 Supported forms : (1 form)
- PREFETCHT2 m8 [MMX+]
func (*Program) PREFETCHW ¶
func (self *Program) PREFETCHW(v0 interface{}) *Instruction
PREFETCHW performs "Prefetch Data into Caches in Anticipation of a Write".
Mnemonic : PREFETCHW Supported forms : (1 form)
- PREFETCHW m8 [PREFETCHW]
func (*Program) PREFETCHWT1 ¶
func (self *Program) PREFETCHWT1(v0 interface{}) *Instruction
PREFETCHWT1 performs "Prefetch Vector Data Into Caches with Intent to Write and T1 Hint".
Mnemonic : PREFETCHWT1 Supported forms : (1 form)
- PREFETCHWT1 m8 [PREFETCHWT1]
func (*Program) PSADBW ¶
func (self *Program) PSADBW(v0 interface{}, v1 interface{}) *Instruction
PSADBW performs "Compute Sum of Absolute Differences".
Mnemonic : PSADBW Supported forms : (4 forms)
- PSADBW mm, mm [MMX+]
- PSADBW m64, mm [MMX+]
- PSADBW xmm, xmm [SSE2]
- PSADBW m128, xmm [SSE2]
func (*Program) PSHUFB ¶
func (self *Program) PSHUFB(v0 interface{}, v1 interface{}) *Instruction
PSHUFB performs "Packed Shuffle Bytes".
Mnemonic : PSHUFB Supported forms : (4 forms)
- PSHUFB mm, mm [SSSE3]
- PSHUFB m64, mm [SSSE3]
- PSHUFB xmm, xmm [SSSE3]
- PSHUFB m128, xmm [SSSE3]
func (*Program) PSHUFD ¶
func (self *Program) PSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PSHUFD performs "Shuffle Packed Doublewords".
Mnemonic : PSHUFD Supported forms : (2 forms)
- PSHUFD imm8, xmm, xmm [SSE2]
- PSHUFD imm8, m128, xmm [SSE2]
func (*Program) PSHUFHW ¶
func (self *Program) PSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PSHUFHW performs "Shuffle Packed High Words".
Mnemonic : PSHUFHW Supported forms : (2 forms)
- PSHUFHW imm8, xmm, xmm [SSE2]
- PSHUFHW imm8, m128, xmm [SSE2]
func (*Program) PSHUFLW ¶
func (self *Program) PSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PSHUFLW performs "Shuffle Packed Low Words".
Mnemonic : PSHUFLW Supported forms : (2 forms)
- PSHUFLW imm8, xmm, xmm [SSE2]
- PSHUFLW imm8, m128, xmm [SSE2]
func (*Program) PSHUFW ¶
func (self *Program) PSHUFW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
PSHUFW performs "Shuffle Packed Words".
Mnemonic : PSHUFW Supported forms : (2 forms)
- PSHUFW imm8, mm, mm [MMX+]
- PSHUFW imm8, m64, mm [MMX+]
func (*Program) PSIGNB ¶
func (self *Program) PSIGNB(v0 interface{}, v1 interface{}) *Instruction
PSIGNB performs "Packed Sign of Byte Integers".
Mnemonic : PSIGNB Supported forms : (4 forms)
- PSIGNB mm, mm [SSSE3]
- PSIGNB m64, mm [SSSE3]
- PSIGNB xmm, xmm [SSSE3]
- PSIGNB m128, xmm [SSSE3]
func (*Program) PSIGND ¶
func (self *Program) PSIGND(v0 interface{}, v1 interface{}) *Instruction
PSIGND performs "Packed Sign of Doubleword Integers".
Mnemonic : PSIGND Supported forms : (4 forms)
- PSIGND mm, mm [SSSE3]
- PSIGND m64, mm [SSSE3]
- PSIGND xmm, xmm [SSSE3]
- PSIGND m128, xmm [SSSE3]
func (*Program) PSIGNW ¶
func (self *Program) PSIGNW(v0 interface{}, v1 interface{}) *Instruction
PSIGNW performs "Packed Sign of Word Integers".
Mnemonic : PSIGNW Supported forms : (4 forms)
- PSIGNW mm, mm [SSSE3]
- PSIGNW m64, mm [SSSE3]
- PSIGNW xmm, xmm [SSSE3]
- PSIGNW m128, xmm [SSSE3]
func (*Program) PSLLD ¶
func (self *Program) PSLLD(v0 interface{}, v1 interface{}) *Instruction
PSLLD performs "Shift Packed Doubleword Data Left Logical".
Mnemonic : PSLLD Supported forms : (6 forms)
- PSLLD imm8, mm [MMX]
- PSLLD mm, mm [MMX]
- PSLLD m64, mm [MMX]
- PSLLD imm8, xmm [SSE2]
- PSLLD xmm, xmm [SSE2]
- PSLLD m128, xmm [SSE2]
func (*Program) PSLLDQ ¶
func (self *Program) PSLLDQ(v0 interface{}, v1 interface{}) *Instruction
PSLLDQ performs "Shift Packed Double Quadword Left Logical".
Mnemonic : PSLLDQ Supported forms : (1 form)
- PSLLDQ imm8, xmm [SSE2]
func (*Program) PSLLQ ¶
func (self *Program) PSLLQ(v0 interface{}, v1 interface{}) *Instruction
PSLLQ performs "Shift Packed Quadword Data Left Logical".
Mnemonic : PSLLQ Supported forms : (6 forms)
- PSLLQ imm8, mm [MMX]
- PSLLQ mm, mm [MMX]
- PSLLQ m64, mm [MMX]
- PSLLQ imm8, xmm [SSE2]
- PSLLQ xmm, xmm [SSE2]
- PSLLQ m128, xmm [SSE2]
func (*Program) PSLLW ¶
func (self *Program) PSLLW(v0 interface{}, v1 interface{}) *Instruction
PSLLW performs "Shift Packed Word Data Left Logical".
Mnemonic : PSLLW Supported forms : (6 forms)
- PSLLW imm8, mm [MMX]
- PSLLW mm, mm [MMX]
- PSLLW m64, mm [MMX]
- PSLLW imm8, xmm [SSE2]
- PSLLW xmm, xmm [SSE2]
- PSLLW m128, xmm [SSE2]
func (*Program) PSRAD ¶
func (self *Program) PSRAD(v0 interface{}, v1 interface{}) *Instruction
PSRAD performs "Shift Packed Doubleword Data Right Arithmetic".
Mnemonic : PSRAD Supported forms : (6 forms)
- PSRAD imm8, mm [MMX]
- PSRAD mm, mm [MMX]
- PSRAD m64, mm [MMX]
- PSRAD imm8, xmm [SSE2]
- PSRAD xmm, xmm [SSE2]
- PSRAD m128, xmm [SSE2]
func (*Program) PSRAW ¶
func (self *Program) PSRAW(v0 interface{}, v1 interface{}) *Instruction
PSRAW performs "Shift Packed Word Data Right Arithmetic".
Mnemonic : PSRAW Supported forms : (6 forms)
- PSRAW imm8, mm [MMX]
- PSRAW mm, mm [MMX]
- PSRAW m64, mm [MMX]
- PSRAW imm8, xmm [SSE2]
- PSRAW xmm, xmm [SSE2]
- PSRAW m128, xmm [SSE2]
func (*Program) PSRLD ¶
func (self *Program) PSRLD(v0 interface{}, v1 interface{}) *Instruction
PSRLD performs "Shift Packed Doubleword Data Right Logical".
Mnemonic : PSRLD Supported forms : (6 forms)
- PSRLD imm8, mm [MMX]
- PSRLD mm, mm [MMX]
- PSRLD m64, mm [MMX]
- PSRLD imm8, xmm [SSE2]
- PSRLD xmm, xmm [SSE2]
- PSRLD m128, xmm [SSE2]
func (*Program) PSRLDQ ¶
func (self *Program) PSRLDQ(v0 interface{}, v1 interface{}) *Instruction
PSRLDQ performs "Shift Packed Double Quadword Right Logical".
Mnemonic : PSRLDQ Supported forms : (1 form)
- PSRLDQ imm8, xmm [SSE2]
func (*Program) PSRLQ ¶
func (self *Program) PSRLQ(v0 interface{}, v1 interface{}) *Instruction
PSRLQ performs "Shift Packed Quadword Data Right Logical".
Mnemonic : PSRLQ Supported forms : (6 forms)
- PSRLQ imm8, mm [MMX]
- PSRLQ mm, mm [MMX]
- PSRLQ m64, mm [MMX]
- PSRLQ imm8, xmm [SSE2]
- PSRLQ xmm, xmm [SSE2]
- PSRLQ m128, xmm [SSE2]
func (*Program) PSRLW ¶
func (self *Program) PSRLW(v0 interface{}, v1 interface{}) *Instruction
PSRLW performs "Shift Packed Word Data Right Logical".
Mnemonic : PSRLW Supported forms : (6 forms)
- PSRLW imm8, mm [MMX]
- PSRLW mm, mm [MMX]
- PSRLW m64, mm [MMX]
- PSRLW imm8, xmm [SSE2]
- PSRLW xmm, xmm [SSE2]
- PSRLW m128, xmm [SSE2]
func (*Program) PSUBB ¶
func (self *Program) PSUBB(v0 interface{}, v1 interface{}) *Instruction
PSUBB performs "Subtract Packed Byte Integers".
Mnemonic : PSUBB Supported forms : (4 forms)
- PSUBB mm, mm [MMX]
- PSUBB m64, mm [MMX]
- PSUBB xmm, xmm [SSE2]
- PSUBB m128, xmm [SSE2]
func (*Program) PSUBD ¶
func (self *Program) PSUBD(v0 interface{}, v1 interface{}) *Instruction
PSUBD performs "Subtract Packed Doubleword Integers".
Mnemonic : PSUBD Supported forms : (4 forms)
- PSUBD mm, mm [MMX]
- PSUBD m64, mm [MMX]
- PSUBD xmm, xmm [SSE2]
- PSUBD m128, xmm [SSE2]
func (*Program) PSUBQ ¶
func (self *Program) PSUBQ(v0 interface{}, v1 interface{}) *Instruction
PSUBQ performs "Subtract Packed Quadword Integers".
Mnemonic : PSUBQ Supported forms : (4 forms)
- PSUBQ mm, mm [SSE2]
- PSUBQ m64, mm [SSE2]
- PSUBQ xmm, xmm [SSE2]
- PSUBQ m128, xmm [SSE2]
func (*Program) PSUBSB ¶
func (self *Program) PSUBSB(v0 interface{}, v1 interface{}) *Instruction
PSUBSB performs "Subtract Packed Signed Byte Integers with Signed Saturation".
Mnemonic : PSUBSB Supported forms : (4 forms)
- PSUBSB mm, mm [MMX]
- PSUBSB m64, mm [MMX]
- PSUBSB xmm, xmm [SSE2]
- PSUBSB m128, xmm [SSE2]
func (*Program) PSUBSW ¶
func (self *Program) PSUBSW(v0 interface{}, v1 interface{}) *Instruction
PSUBSW performs "Subtract Packed Signed Word Integers with Signed Saturation".
Mnemonic : PSUBSW Supported forms : (4 forms)
- PSUBSW mm, mm [MMX]
- PSUBSW m64, mm [MMX]
- PSUBSW xmm, xmm [SSE2]
- PSUBSW m128, xmm [SSE2]
func (*Program) PSUBUSB ¶
func (self *Program) PSUBUSB(v0 interface{}, v1 interface{}) *Instruction
PSUBUSB performs "Subtract Packed Unsigned Byte Integers with Unsigned Saturation".
Mnemonic : PSUBUSB Supported forms : (4 forms)
- PSUBUSB mm, mm [MMX]
- PSUBUSB m64, mm [MMX]
- PSUBUSB xmm, xmm [SSE2]
- PSUBUSB m128, xmm [SSE2]
func (*Program) PSUBUSW ¶
func (self *Program) PSUBUSW(v0 interface{}, v1 interface{}) *Instruction
PSUBUSW performs "Subtract Packed Unsigned Word Integers with Unsigned Saturation".
Mnemonic : PSUBUSW Supported forms : (4 forms)
- PSUBUSW mm, mm [MMX]
- PSUBUSW m64, mm [MMX]
- PSUBUSW xmm, xmm [SSE2]
- PSUBUSW m128, xmm [SSE2]
func (*Program) PSUBW ¶
func (self *Program) PSUBW(v0 interface{}, v1 interface{}) *Instruction
PSUBW performs "Subtract Packed Word Integers".
Mnemonic : PSUBW Supported forms : (4 forms)
- PSUBW mm, mm [MMX]
- PSUBW m64, mm [MMX]
- PSUBW xmm, xmm [SSE2]
- PSUBW m128, xmm [SSE2]
func (*Program) PSWAPD ¶
func (self *Program) PSWAPD(v0 interface{}, v1 interface{}) *Instruction
PSWAPD performs "Packed Swap Doubleword".
Mnemonic : PSWAPD Supported forms : (2 forms)
- PSWAPD mm, mm [3dnow!+]
- PSWAPD m64, mm [3dnow!+]
func (*Program) PTEST ¶
func (self *Program) PTEST(v0 interface{}, v1 interface{}) *Instruction
PTEST performs "Packed Logical Compare".
Mnemonic : PTEST Supported forms : (2 forms)
- PTEST xmm, xmm [SSE4.1]
- PTEST m128, xmm [SSE4.1]
func (*Program) PUNPCKHBW ¶
func (self *Program) PUNPCKHBW(v0 interface{}, v1 interface{}) *Instruction
PUNPCKHBW performs "Unpack and Interleave High-Order Bytes into Words".
Mnemonic : PUNPCKHBW Supported forms : (4 forms)
- PUNPCKHBW mm, mm [MMX]
- PUNPCKHBW m64, mm [MMX]
- PUNPCKHBW xmm, xmm [SSE2]
- PUNPCKHBW m128, xmm [SSE2]
func (*Program) PUNPCKHDQ ¶
func (self *Program) PUNPCKHDQ(v0 interface{}, v1 interface{}) *Instruction
PUNPCKHDQ performs "Unpack and Interleave High-Order Doublewords into Quadwords".
Mnemonic : PUNPCKHDQ Supported forms : (4 forms)
- PUNPCKHDQ mm, mm [MMX]
- PUNPCKHDQ m64, mm [MMX]
- PUNPCKHDQ xmm, xmm [SSE2]
- PUNPCKHDQ m128, xmm [SSE2]
func (*Program) PUNPCKHQDQ ¶
func (self *Program) PUNPCKHQDQ(v0 interface{}, v1 interface{}) *Instruction
PUNPCKHQDQ performs "Unpack and Interleave High-Order Quadwords into Double Quadwords".
Mnemonic : PUNPCKHQDQ Supported forms : (2 forms)
- PUNPCKHQDQ xmm, xmm [SSE2]
- PUNPCKHQDQ m128, xmm [SSE2]
func (*Program) PUNPCKHWD ¶
func (self *Program) PUNPCKHWD(v0 interface{}, v1 interface{}) *Instruction
PUNPCKHWD performs "Unpack and Interleave High-Order Words into Doublewords".
Mnemonic : PUNPCKHWD Supported forms : (4 forms)
- PUNPCKHWD mm, mm [MMX]
- PUNPCKHWD m64, mm [MMX]
- PUNPCKHWD xmm, xmm [SSE2]
- PUNPCKHWD m128, xmm [SSE2]
func (*Program) PUNPCKLBW ¶
func (self *Program) PUNPCKLBW(v0 interface{}, v1 interface{}) *Instruction
PUNPCKLBW performs "Unpack and Interleave Low-Order Bytes into Words".
Mnemonic : PUNPCKLBW Supported forms : (4 forms)
- PUNPCKLBW mm, mm [MMX]
- PUNPCKLBW m32, mm [MMX]
- PUNPCKLBW xmm, xmm [SSE2]
- PUNPCKLBW m128, xmm [SSE2]
func (*Program) PUNPCKLDQ ¶
func (self *Program) PUNPCKLDQ(v0 interface{}, v1 interface{}) *Instruction
PUNPCKLDQ performs "Unpack and Interleave Low-Order Doublewords into Quadwords".
Mnemonic : PUNPCKLDQ Supported forms : (4 forms)
- PUNPCKLDQ mm, mm [MMX]
- PUNPCKLDQ m32, mm [MMX]
- PUNPCKLDQ xmm, xmm [SSE2]
- PUNPCKLDQ m128, xmm [SSE2]
func (*Program) PUNPCKLQDQ ¶
func (self *Program) PUNPCKLQDQ(v0 interface{}, v1 interface{}) *Instruction
PUNPCKLQDQ performs "Unpack and Interleave Low-Order Quadwords into Double Quadwords".
Mnemonic : PUNPCKLQDQ Supported forms : (2 forms)
- PUNPCKLQDQ xmm, xmm [SSE2]
- PUNPCKLQDQ m128, xmm [SSE2]
func (*Program) PUNPCKLWD ¶
func (self *Program) PUNPCKLWD(v0 interface{}, v1 interface{}) *Instruction
PUNPCKLWD performs "Unpack and Interleave Low-Order Words into Doublewords".
Mnemonic : PUNPCKLWD Supported forms : (4 forms)
- PUNPCKLWD mm, mm [MMX]
- PUNPCKLWD m32, mm [MMX]
- PUNPCKLWD xmm, xmm [SSE2]
- PUNPCKLWD m128, xmm [SSE2]
func (*Program) PUSHQ ¶
func (self *Program) PUSHQ(v0 interface{}) *Instruction
PUSHQ performs "Push Value Onto the Stack".
Mnemonic : PUSH Supported forms : (4 forms)
- PUSHQ imm8
- PUSHQ imm32
- PUSHQ r64
- PUSHQ m64
func (*Program) PUSHW ¶
func (self *Program) PUSHW(v0 interface{}) *Instruction
PUSHW performs "Push Value Onto the Stack".
Mnemonic : PUSH Supported forms : (2 forms)
- PUSHW r16
- PUSHW m16
func (*Program) PXOR ¶
func (self *Program) PXOR(v0 interface{}, v1 interface{}) *Instruction
PXOR performs "Packed Bitwise Logical Exclusive OR".
Mnemonic : PXOR Supported forms : (4 forms)
- PXOR mm, mm [MMX]
- PXOR m64, mm [MMX]
- PXOR xmm, xmm [SSE2]
- PXOR m128, xmm [SSE2]
func (*Program) Quad ¶
func (self *Program) Quad(v *expr.Expr) (p *Instruction)
Quad is a pseudo-instruction to add raw uint64 as little-endian to the assembled code.
func (*Program) RCLB ¶
func (self *Program) RCLB(v0 interface{}, v1 interface{}) *Instruction
RCLB performs "Rotate Left through Carry Flag".
Mnemonic : RCL Supported forms : (6 forms)
- RCLB 1, r8
- RCLB imm8, r8
- RCLB cl, r8
- RCLB 1, m8
- RCLB imm8, m8
- RCLB cl, m8
func (*Program) RCLL ¶
func (self *Program) RCLL(v0 interface{}, v1 interface{}) *Instruction
RCLL performs "Rotate Left through Carry Flag".
Mnemonic : RCL Supported forms : (6 forms)
- RCLL 1, r32
- RCLL imm8, r32
- RCLL cl, r32
- RCLL 1, m32
- RCLL imm8, m32
- RCLL cl, m32
func (*Program) RCLQ ¶
func (self *Program) RCLQ(v0 interface{}, v1 interface{}) *Instruction
RCLQ performs "Rotate Left through Carry Flag".
Mnemonic : RCL Supported forms : (6 forms)
- RCLQ 1, r64
- RCLQ imm8, r64
- RCLQ cl, r64
- RCLQ 1, m64
- RCLQ imm8, m64
- RCLQ cl, m64
func (*Program) RCLW ¶
func (self *Program) RCLW(v0 interface{}, v1 interface{}) *Instruction
RCLW performs "Rotate Left through Carry Flag".
Mnemonic : RCL Supported forms : (6 forms)
- RCLW 1, r16
- RCLW imm8, r16
- RCLW cl, r16
- RCLW 1, m16
- RCLW imm8, m16
- RCLW cl, m16
func (*Program) RCPPS ¶
func (self *Program) RCPPS(v0 interface{}, v1 interface{}) *Instruction
RCPPS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".
Mnemonic : RCPPS Supported forms : (2 forms)
- RCPPS xmm, xmm [SSE]
- RCPPS m128, xmm [SSE]
func (*Program) RCPSS ¶
func (self *Program) RCPSS(v0 interface{}, v1 interface{}) *Instruction
RCPSS performs "Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values".
Mnemonic : RCPSS Supported forms : (2 forms)
- RCPSS xmm, xmm [SSE]
- RCPSS m32, xmm [SSE]
func (*Program) RCRB ¶
func (self *Program) RCRB(v0 interface{}, v1 interface{}) *Instruction
RCRB performs "Rotate Right through Carry Flag".
Mnemonic : RCR Supported forms : (6 forms)
- RCRB 1, r8
- RCRB imm8, r8
- RCRB cl, r8
- RCRB 1, m8
- RCRB imm8, m8
- RCRB cl, m8
func (*Program) RCRL ¶
func (self *Program) RCRL(v0 interface{}, v1 interface{}) *Instruction
RCRL performs "Rotate Right through Carry Flag".
Mnemonic : RCR Supported forms : (6 forms)
- RCRL 1, r32
- RCRL imm8, r32
- RCRL cl, r32
- RCRL 1, m32
- RCRL imm8, m32
- RCRL cl, m32
func (*Program) RCRQ ¶
func (self *Program) RCRQ(v0 interface{}, v1 interface{}) *Instruction
RCRQ performs "Rotate Right through Carry Flag".
Mnemonic : RCR Supported forms : (6 forms)
- RCRQ 1, r64
- RCRQ imm8, r64
- RCRQ cl, r64
- RCRQ 1, m64
- RCRQ imm8, m64
- RCRQ cl, m64
func (*Program) RCRW ¶
func (self *Program) RCRW(v0 interface{}, v1 interface{}) *Instruction
RCRW performs "Rotate Right through Carry Flag".
Mnemonic : RCR Supported forms : (6 forms)
- RCRW 1, r16
- RCRW imm8, r16
- RCRW cl, r16
- RCRW 1, m16
- RCRW imm8, m16
- RCRW cl, m16
func (*Program) RDRAND ¶
func (self *Program) RDRAND(v0 interface{}) *Instruction
RDRAND performs "Read Random Number".
Mnemonic : RDRAND Supported forms : (3 forms)
- RDRAND r16 [RDRAND]
- RDRAND r32 [RDRAND]
- RDRAND r64 [RDRAND]
func (*Program) RDSEED ¶
func (self *Program) RDSEED(v0 interface{}) *Instruction
RDSEED performs "Read Random SEED".
Mnemonic : RDSEED Supported forms : (3 forms)
- RDSEED r16 [RDSEED]
- RDSEED r32 [RDSEED]
- RDSEED r64 [RDSEED]
func (*Program) RDTSC ¶
func (self *Program) RDTSC() *Instruction
RDTSC performs "Read Time-Stamp Counter".
Mnemonic : RDTSC Supported forms : (1 form)
- RDTSC [RDTSC]
func (*Program) RDTSCP ¶
func (self *Program) RDTSCP() *Instruction
RDTSCP performs "Read Time-Stamp Counter and Processor ID".
Mnemonic : RDTSCP Supported forms : (1 form)
- RDTSCP [RDTSCP]
func (*Program) RET ¶
func (self *Program) RET(vv ...interface{}) *Instruction
RET performs "Return from Procedure".
Mnemonic : RET Supported forms : (2 forms)
- RET
- RET imm16
func (*Program) ROLB ¶
func (self *Program) ROLB(v0 interface{}, v1 interface{}) *Instruction
ROLB performs "Rotate Left".
Mnemonic : ROL Supported forms : (6 forms)
- ROLB 1, r8
- ROLB imm8, r8
- ROLB cl, r8
- ROLB 1, m8
- ROLB imm8, m8
- ROLB cl, m8
func (*Program) ROLL ¶
func (self *Program) ROLL(v0 interface{}, v1 interface{}) *Instruction
ROLL performs "Rotate Left".
Mnemonic : ROL Supported forms : (6 forms)
- ROLL 1, r32
- ROLL imm8, r32
- ROLL cl, r32
- ROLL 1, m32
- ROLL imm8, m32
- ROLL cl, m32
func (*Program) ROLQ ¶
func (self *Program) ROLQ(v0 interface{}, v1 interface{}) *Instruction
ROLQ performs "Rotate Left".
Mnemonic : ROL Supported forms : (6 forms)
- ROLQ 1, r64
- ROLQ imm8, r64
- ROLQ cl, r64
- ROLQ 1, m64
- ROLQ imm8, m64
- ROLQ cl, m64
func (*Program) ROLW ¶
func (self *Program) ROLW(v0 interface{}, v1 interface{}) *Instruction
ROLW performs "Rotate Left".
Mnemonic : ROL Supported forms : (6 forms)
- ROLW 1, r16
- ROLW imm8, r16
- ROLW cl, r16
- ROLW 1, m16
- ROLW imm8, m16
- ROLW cl, m16
func (*Program) RORB ¶
func (self *Program) RORB(v0 interface{}, v1 interface{}) *Instruction
RORB performs "Rotate Right".
Mnemonic : ROR Supported forms : (6 forms)
- RORB 1, r8
- RORB imm8, r8
- RORB cl, r8
- RORB 1, m8
- RORB imm8, m8
- RORB cl, m8
func (*Program) RORL ¶
func (self *Program) RORL(v0 interface{}, v1 interface{}) *Instruction
RORL performs "Rotate Right".
Mnemonic : ROR Supported forms : (6 forms)
- RORL 1, r32
- RORL imm8, r32
- RORL cl, r32
- RORL 1, m32
- RORL imm8, m32
- RORL cl, m32
func (*Program) RORQ ¶
func (self *Program) RORQ(v0 interface{}, v1 interface{}) *Instruction
RORQ performs "Rotate Right".
Mnemonic : ROR Supported forms : (6 forms)
- RORQ 1, r64
- RORQ imm8, r64
- RORQ cl, r64
- RORQ 1, m64
- RORQ imm8, m64
- RORQ cl, m64
func (*Program) RORW ¶
func (self *Program) RORW(v0 interface{}, v1 interface{}) *Instruction
RORW performs "Rotate Right".
Mnemonic : ROR Supported forms : (6 forms)
- RORW 1, r16
- RORW imm8, r16
- RORW cl, r16
- RORW 1, m16
- RORW imm8, m16
- RORW cl, m16
func (*Program) RORXL ¶
func (self *Program) RORXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
RORXL performs "Rotate Right Logical Without Affecting Flags".
Mnemonic : RORX Supported forms : (2 forms)
- RORXL imm8, r32, r32 [BMI2]
- RORXL imm8, m32, r32 [BMI2]
func (*Program) RORXQ ¶
func (self *Program) RORXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
RORXQ performs "Rotate Right Logical Without Affecting Flags".
Mnemonic : RORX Supported forms : (2 forms)
- RORXQ imm8, r64, r64 [BMI2]
- RORXQ imm8, m64, r64 [BMI2]
func (*Program) ROUNDPD ¶
func (self *Program) ROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
ROUNDPD performs "Round Packed Double Precision Floating-Point Values".
Mnemonic : ROUNDPD Supported forms : (2 forms)
- ROUNDPD imm8, xmm, xmm [SSE4.1]
- ROUNDPD imm8, m128, xmm [SSE4.1]
func (*Program) ROUNDPS ¶
func (self *Program) ROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
ROUNDPS performs "Round Packed Single Precision Floating-Point Values".
Mnemonic : ROUNDPS Supported forms : (2 forms)
- ROUNDPS imm8, xmm, xmm [SSE4.1]
- ROUNDPS imm8, m128, xmm [SSE4.1]
func (*Program) ROUNDSD ¶
func (self *Program) ROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
ROUNDSD performs "Round Scalar Double Precision Floating-Point Values".
Mnemonic : ROUNDSD Supported forms : (2 forms)
- ROUNDSD imm8, xmm, xmm [SSE4.1]
- ROUNDSD imm8, m64, xmm [SSE4.1]
func (*Program) ROUNDSS ¶
func (self *Program) ROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
ROUNDSS performs "Round Scalar Single Precision Floating-Point Values".
Mnemonic : ROUNDSS Supported forms : (2 forms)
- ROUNDSS imm8, xmm, xmm [SSE4.1]
- ROUNDSS imm8, m32, xmm [SSE4.1]
func (*Program) RSQRTPS ¶
func (self *Program) RSQRTPS(v0 interface{}, v1 interface{}) *Instruction
RSQRTPS performs "Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".
Mnemonic : RSQRTPS Supported forms : (2 forms)
- RSQRTPS xmm, xmm [SSE]
- RSQRTPS m128, xmm [SSE]
func (*Program) RSQRTSS ¶
func (self *Program) RSQRTSS(v0 interface{}, v1 interface{}) *Instruction
RSQRTSS performs "Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value".
Mnemonic : RSQRTSS Supported forms : (2 forms)
- RSQRTSS xmm, xmm [SSE]
- RSQRTSS m32, xmm [SSE]
func (*Program) SALB ¶
func (self *Program) SALB(v0 interface{}, v1 interface{}) *Instruction
SALB performs "Arithmetic Shift Left".
Mnemonic : SAL Supported forms : (6 forms)
- SALB 1, r8
- SALB imm8, r8
- SALB cl, r8
- SALB 1, m8
- SALB imm8, m8
- SALB cl, m8
func (*Program) SALL ¶
func (self *Program) SALL(v0 interface{}, v1 interface{}) *Instruction
SALL performs "Arithmetic Shift Left".
Mnemonic : SAL Supported forms : (6 forms)
- SALL 1, r32
- SALL imm8, r32
- SALL cl, r32
- SALL 1, m32
- SALL imm8, m32
- SALL cl, m32
func (*Program) SALQ ¶
func (self *Program) SALQ(v0 interface{}, v1 interface{}) *Instruction
SALQ performs "Arithmetic Shift Left".
Mnemonic : SAL Supported forms : (6 forms)
- SALQ 1, r64
- SALQ imm8, r64
- SALQ cl, r64
- SALQ 1, m64
- SALQ imm8, m64
- SALQ cl, m64
func (*Program) SALW ¶
func (self *Program) SALW(v0 interface{}, v1 interface{}) *Instruction
SALW performs "Arithmetic Shift Left".
Mnemonic : SAL Supported forms : (6 forms)
- SALW 1, r16
- SALW imm8, r16
- SALW cl, r16
- SALW 1, m16
- SALW imm8, m16
- SALW cl, m16
func (*Program) SARB ¶
func (self *Program) SARB(v0 interface{}, v1 interface{}) *Instruction
SARB performs "Arithmetic Shift Right".
Mnemonic : SAR Supported forms : (6 forms)
- SARB 1, r8
- SARB imm8, r8
- SARB cl, r8
- SARB 1, m8
- SARB imm8, m8
- SARB cl, m8
func (*Program) SARL ¶
func (self *Program) SARL(v0 interface{}, v1 interface{}) *Instruction
SARL performs "Arithmetic Shift Right".
Mnemonic : SAR Supported forms : (6 forms)
- SARL 1, r32
- SARL imm8, r32
- SARL cl, r32
- SARL 1, m32
- SARL imm8, m32
- SARL cl, m32
func (*Program) SARQ ¶
func (self *Program) SARQ(v0 interface{}, v1 interface{}) *Instruction
SARQ performs "Arithmetic Shift Right".
Mnemonic : SAR Supported forms : (6 forms)
- SARQ 1, r64
- SARQ imm8, r64
- SARQ cl, r64
- SARQ 1, m64
- SARQ imm8, m64
- SARQ cl, m64
func (*Program) SARW ¶
func (self *Program) SARW(v0 interface{}, v1 interface{}) *Instruction
SARW performs "Arithmetic Shift Right".
Mnemonic : SAR Supported forms : (6 forms)
- SARW 1, r16
- SARW imm8, r16
- SARW cl, r16
- SARW 1, m16
- SARW imm8, m16
- SARW cl, m16
func (*Program) SARXL ¶
func (self *Program) SARXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SARXL performs "Arithmetic Shift Right Without Affecting Flags".
Mnemonic : SARX Supported forms : (2 forms)
- SARXL r32, r32, r32 [BMI2]
- SARXL r32, m32, r32 [BMI2]
func (*Program) SARXQ ¶
func (self *Program) SARXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SARXQ performs "Arithmetic Shift Right Without Affecting Flags".
Mnemonic : SARX Supported forms : (2 forms)
- SARXQ r64, r64, r64 [BMI2]
- SARXQ r64, m64, r64 [BMI2]
func (*Program) SBBB ¶
func (self *Program) SBBB(v0 interface{}, v1 interface{}) *Instruction
SBBB performs "Subtract with Borrow".
Mnemonic : SBB Supported forms : (6 forms)
- SBBB imm8, al
- SBBB imm8, r8
- SBBB r8, r8
- SBBB m8, r8
- SBBB imm8, m8
- SBBB r8, m8
func (*Program) SBBL ¶
func (self *Program) SBBL(v0 interface{}, v1 interface{}) *Instruction
SBBL performs "Subtract with Borrow".
Mnemonic : SBB Supported forms : (8 forms)
- SBBL imm32, eax
- SBBL imm8, r32
- SBBL imm32, r32
- SBBL r32, r32
- SBBL m32, r32
- SBBL imm8, m32
- SBBL imm32, m32
- SBBL r32, m32
func (*Program) SBBQ ¶
func (self *Program) SBBQ(v0 interface{}, v1 interface{}) *Instruction
SBBQ performs "Subtract with Borrow".
Mnemonic : SBB Supported forms : (8 forms)
- SBBQ imm32, rax
- SBBQ imm8, r64
- SBBQ imm32, r64
- SBBQ r64, r64
- SBBQ m64, r64
- SBBQ imm8, m64
- SBBQ imm32, m64
- SBBQ r64, m64
func (*Program) SBBW ¶
func (self *Program) SBBW(v0 interface{}, v1 interface{}) *Instruction
SBBW performs "Subtract with Borrow".
Mnemonic : SBB Supported forms : (8 forms)
- SBBW imm16, ax
- SBBW imm8, r16
- SBBW imm16, r16
- SBBW r16, r16
- SBBW m16, r16
- SBBW imm8, m16
- SBBW imm16, m16
- SBBW r16, m16
func (*Program) SETA ¶
func (self *Program) SETA(v0 interface{}) *Instruction
SETA performs "Set byte if above (CF == 0 and ZF == 0)".
Mnemonic : SETA Supported forms : (2 forms)
- SETA r8
- SETA m8
func (*Program) SETAE ¶
func (self *Program) SETAE(v0 interface{}) *Instruction
SETAE performs "Set byte if above or equal (CF == 0)".
Mnemonic : SETAE Supported forms : (2 forms)
- SETAE r8
- SETAE m8
func (*Program) SETB ¶
func (self *Program) SETB(v0 interface{}) *Instruction
SETB performs "Set byte if below (CF == 1)".
Mnemonic : SETB Supported forms : (2 forms)
- SETB r8
- SETB m8
func (*Program) SETBE ¶
func (self *Program) SETBE(v0 interface{}) *Instruction
SETBE performs "Set byte if below or equal (CF == 1 or ZF == 1)".
Mnemonic : SETBE Supported forms : (2 forms)
- SETBE r8
- SETBE m8
func (*Program) SETC ¶
func (self *Program) SETC(v0 interface{}) *Instruction
SETC performs "Set byte if carry (CF == 1)".
Mnemonic : SETC Supported forms : (2 forms)
- SETC r8
- SETC m8
func (*Program) SETE ¶
func (self *Program) SETE(v0 interface{}) *Instruction
SETE performs "Set byte if equal (ZF == 1)".
Mnemonic : SETE Supported forms : (2 forms)
- SETE r8
- SETE m8
func (*Program) SETG ¶
func (self *Program) SETG(v0 interface{}) *Instruction
SETG performs "Set byte if greater (ZF == 0 and SF == OF)".
Mnemonic : SETG Supported forms : (2 forms)
- SETG r8
- SETG m8
func (*Program) SETGE ¶
func (self *Program) SETGE(v0 interface{}) *Instruction
SETGE performs "Set byte if greater or equal (SF == OF)".
Mnemonic : SETGE Supported forms : (2 forms)
- SETGE r8
- SETGE m8
func (*Program) SETL ¶
func (self *Program) SETL(v0 interface{}) *Instruction
SETL performs "Set byte if less (SF != OF)".
Mnemonic : SETL Supported forms : (2 forms)
- SETL r8
- SETL m8
func (*Program) SETLE ¶
func (self *Program) SETLE(v0 interface{}) *Instruction
SETLE performs "Set byte if less or equal (ZF == 1 or SF != OF)".
Mnemonic : SETLE Supported forms : (2 forms)
- SETLE r8
- SETLE m8
func (*Program) SETNA ¶
func (self *Program) SETNA(v0 interface{}) *Instruction
SETNA performs "Set byte if not above (CF == 1 or ZF == 1)".
Mnemonic : SETNA Supported forms : (2 forms)
- SETNA r8
- SETNA m8
func (*Program) SETNAE ¶
func (self *Program) SETNAE(v0 interface{}) *Instruction
SETNAE performs "Set byte if not above or equal (CF == 1)".
Mnemonic : SETNAE Supported forms : (2 forms)
- SETNAE r8
- SETNAE m8
func (*Program) SETNB ¶
func (self *Program) SETNB(v0 interface{}) *Instruction
SETNB performs "Set byte if not below (CF == 0)".
Mnemonic : SETNB Supported forms : (2 forms)
- SETNB r8
- SETNB m8
func (*Program) SETNBE ¶
func (self *Program) SETNBE(v0 interface{}) *Instruction
SETNBE performs "Set byte if not below or equal (CF == 0 and ZF == 0)".
Mnemonic : SETNBE Supported forms : (2 forms)
- SETNBE r8
- SETNBE m8
func (*Program) SETNC ¶
func (self *Program) SETNC(v0 interface{}) *Instruction
SETNC performs "Set byte if not carry (CF == 0)".
Mnemonic : SETNC Supported forms : (2 forms)
- SETNC r8
- SETNC m8
func (*Program) SETNE ¶
func (self *Program) SETNE(v0 interface{}) *Instruction
SETNE performs "Set byte if not equal (ZF == 0)".
Mnemonic : SETNE Supported forms : (2 forms)
- SETNE r8
- SETNE m8
func (*Program) SETNG ¶
func (self *Program) SETNG(v0 interface{}) *Instruction
SETNG performs "Set byte if not greater (ZF == 1 or SF != OF)".
Mnemonic : SETNG Supported forms : (2 forms)
- SETNG r8
- SETNG m8
func (*Program) SETNGE ¶
func (self *Program) SETNGE(v0 interface{}) *Instruction
SETNGE performs "Set byte if not greater or equal (SF != OF)".
Mnemonic : SETNGE Supported forms : (2 forms)
- SETNGE r8
- SETNGE m8
func (*Program) SETNL ¶
func (self *Program) SETNL(v0 interface{}) *Instruction
SETNL performs "Set byte if not less (SF == OF)".
Mnemonic : SETNL Supported forms : (2 forms)
- SETNL r8
- SETNL m8
func (*Program) SETNLE ¶
func (self *Program) SETNLE(v0 interface{}) *Instruction
SETNLE performs "Set byte if not less or equal (ZF == 0 and SF == OF)".
Mnemonic : SETNLE Supported forms : (2 forms)
- SETNLE r8
- SETNLE m8
func (*Program) SETNO ¶
func (self *Program) SETNO(v0 interface{}) *Instruction
SETNO performs "Set byte if not overflow (OF == 0)".
Mnemonic : SETNO Supported forms : (2 forms)
- SETNO r8
- SETNO m8
func (*Program) SETNP ¶
func (self *Program) SETNP(v0 interface{}) *Instruction
SETNP performs "Set byte if not parity (PF == 0)".
Mnemonic : SETNP Supported forms : (2 forms)
- SETNP r8
- SETNP m8
func (*Program) SETNS ¶
func (self *Program) SETNS(v0 interface{}) *Instruction
SETNS performs "Set byte if not sign (SF == 0)".
Mnemonic : SETNS Supported forms : (2 forms)
- SETNS r8
- SETNS m8
func (*Program) SETNZ ¶
func (self *Program) SETNZ(v0 interface{}) *Instruction
SETNZ performs "Set byte if not zero (ZF == 0)".
Mnemonic : SETNZ Supported forms : (2 forms)
- SETNZ r8
- SETNZ m8
func (*Program) SETO ¶
func (self *Program) SETO(v0 interface{}) *Instruction
SETO performs "Set byte if overflow (OF == 1)".
Mnemonic : SETO Supported forms : (2 forms)
- SETO r8
- SETO m8
func (*Program) SETP ¶
func (self *Program) SETP(v0 interface{}) *Instruction
SETP performs "Set byte if parity (PF == 1)".
Mnemonic : SETP Supported forms : (2 forms)
- SETP r8
- SETP m8
func (*Program) SETPE ¶
func (self *Program) SETPE(v0 interface{}) *Instruction
SETPE performs "Set byte if parity even (PF == 1)".
Mnemonic : SETPE Supported forms : (2 forms)
- SETPE r8
- SETPE m8
func (*Program) SETPO ¶
func (self *Program) SETPO(v0 interface{}) *Instruction
SETPO performs "Set byte if parity odd (PF == 0)".
Mnemonic : SETPO Supported forms : (2 forms)
- SETPO r8
- SETPO m8
func (*Program) SETS ¶
func (self *Program) SETS(v0 interface{}) *Instruction
SETS performs "Set byte if sign (SF == 1)".
Mnemonic : SETS Supported forms : (2 forms)
- SETS r8
- SETS m8
func (*Program) SETZ ¶
func (self *Program) SETZ(v0 interface{}) *Instruction
SETZ performs "Set byte if zero (ZF == 1)".
Mnemonic : SETZ Supported forms : (2 forms)
- SETZ r8
- SETZ m8
func (*Program) SFENCE ¶
func (self *Program) SFENCE() *Instruction
SFENCE performs "Store Fence".
Mnemonic : SFENCE Supported forms : (1 form)
- SFENCE [MMX+]
func (*Program) SHA1MSG1 ¶
func (self *Program) SHA1MSG1(v0 interface{}, v1 interface{}) *Instruction
SHA1MSG1 performs "Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords".
Mnemonic : SHA1MSG1 Supported forms : (2 forms)
- SHA1MSG1 xmm, xmm [SHA]
- SHA1MSG1 m128, xmm [SHA]
func (*Program) SHA1MSG2 ¶
func (self *Program) SHA1MSG2(v0 interface{}, v1 interface{}) *Instruction
SHA1MSG2 performs "Perform a Final Calculation for the Next Four SHA1 Message Doublewords".
Mnemonic : SHA1MSG2 Supported forms : (2 forms)
- SHA1MSG2 xmm, xmm [SHA]
- SHA1MSG2 m128, xmm [SHA]
func (*Program) SHA1NEXTE ¶
func (self *Program) SHA1NEXTE(v0 interface{}, v1 interface{}) *Instruction
SHA1NEXTE performs "Calculate SHA1 State Variable E after Four Rounds".
Mnemonic : SHA1NEXTE Supported forms : (2 forms)
- SHA1NEXTE xmm, xmm [SHA]
- SHA1NEXTE m128, xmm [SHA]
func (*Program) SHA1RNDS4 ¶
func (self *Program) SHA1RNDS4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHA1RNDS4 performs "Perform Four Rounds of SHA1 Operation".
Mnemonic : SHA1RNDS4 Supported forms : (2 forms)
- SHA1RNDS4 imm8, xmm, xmm [SHA]
- SHA1RNDS4 imm8, m128, xmm [SHA]
func (*Program) SHA256MSG1 ¶
func (self *Program) SHA256MSG1(v0 interface{}, v1 interface{}) *Instruction
SHA256MSG1 performs "Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords".
Mnemonic : SHA256MSG1 Supported forms : (2 forms)
- SHA256MSG1 xmm, xmm [SHA]
- SHA256MSG1 m128, xmm [SHA]
func (*Program) SHA256MSG2 ¶
func (self *Program) SHA256MSG2(v0 interface{}, v1 interface{}) *Instruction
SHA256MSG2 performs "Perform a Final Calculation for the Next Four SHA256 Message Doublewords".
Mnemonic : SHA256MSG2 Supported forms : (2 forms)
- SHA256MSG2 xmm, xmm [SHA]
- SHA256MSG2 m128, xmm [SHA]
func (*Program) SHA256RNDS2 ¶
func (self *Program) SHA256RNDS2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHA256RNDS2 performs "Perform Two Rounds of SHA256 Operation".
Mnemonic : SHA256RNDS2 Supported forms : (2 forms)
- SHA256RNDS2 xmm0, xmm, xmm [SHA]
- SHA256RNDS2 xmm0, m128, xmm [SHA]
func (*Program) SHLB ¶
func (self *Program) SHLB(v0 interface{}, v1 interface{}) *Instruction
SHLB performs "Logical Shift Left".
Mnemonic : SHL Supported forms : (6 forms)
- SHLB 1, r8
- SHLB imm8, r8
- SHLB cl, r8
- SHLB 1, m8
- SHLB imm8, m8
- SHLB cl, m8
func (*Program) SHLDL ¶
func (self *Program) SHLDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHLDL performs "Integer Double Precision Shift Left".
Mnemonic : SHLD Supported forms : (4 forms)
- SHLDL imm8, r32, r32
- SHLDL cl, r32, r32
- SHLDL imm8, r32, m32
- SHLDL cl, r32, m32
func (*Program) SHLDQ ¶
func (self *Program) SHLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHLDQ performs "Integer Double Precision Shift Left".
Mnemonic : SHLD Supported forms : (4 forms)
- SHLDQ imm8, r64, r64
- SHLDQ cl, r64, r64
- SHLDQ imm8, r64, m64
- SHLDQ cl, r64, m64
func (*Program) SHLDW ¶
func (self *Program) SHLDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHLDW performs "Integer Double Precision Shift Left".
Mnemonic : SHLD Supported forms : (4 forms)
- SHLDW imm8, r16, r16
- SHLDW cl, r16, r16
- SHLDW imm8, r16, m16
- SHLDW cl, r16, m16
func (*Program) SHLL ¶
func (self *Program) SHLL(v0 interface{}, v1 interface{}) *Instruction
SHLL performs "Logical Shift Left".
Mnemonic : SHL Supported forms : (6 forms)
- SHLL 1, r32
- SHLL imm8, r32
- SHLL cl, r32
- SHLL 1, m32
- SHLL imm8, m32
- SHLL cl, m32
func (*Program) SHLQ ¶
func (self *Program) SHLQ(v0 interface{}, v1 interface{}) *Instruction
SHLQ performs "Logical Shift Left".
Mnemonic : SHL Supported forms : (6 forms)
- SHLQ 1, r64
- SHLQ imm8, r64
- SHLQ cl, r64
- SHLQ 1, m64
- SHLQ imm8, m64
- SHLQ cl, m64
func (*Program) SHLW ¶
func (self *Program) SHLW(v0 interface{}, v1 interface{}) *Instruction
SHLW performs "Logical Shift Left".
Mnemonic : SHL Supported forms : (6 forms)
- SHLW 1, r16
- SHLW imm8, r16
- SHLW cl, r16
- SHLW 1, m16
- SHLW imm8, m16
- SHLW cl, m16
func (*Program) SHLXL ¶
func (self *Program) SHLXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHLXL performs "Logical Shift Left Without Affecting Flags".
Mnemonic : SHLX Supported forms : (2 forms)
- SHLXL r32, r32, r32 [BMI2]
- SHLXL r32, m32, r32 [BMI2]
func (*Program) SHLXQ ¶
func (self *Program) SHLXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHLXQ performs "Logical Shift Left Without Affecting Flags".
Mnemonic : SHLX Supported forms : (2 forms)
- SHLXQ r64, r64, r64 [BMI2]
- SHLXQ r64, m64, r64 [BMI2]
func (*Program) SHRB ¶
func (self *Program) SHRB(v0 interface{}, v1 interface{}) *Instruction
SHRB performs "Logical Shift Right".
Mnemonic : SHR Supported forms : (6 forms)
- SHRB 1, r8
- SHRB imm8, r8
- SHRB cl, r8
- SHRB 1, m8
- SHRB imm8, m8
- SHRB cl, m8
func (*Program) SHRDL ¶
func (self *Program) SHRDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHRDL performs "Integer Double Precision Shift Right".
Mnemonic : SHRD Supported forms : (4 forms)
- SHRDL imm8, r32, r32
- SHRDL cl, r32, r32
- SHRDL imm8, r32, m32
- SHRDL cl, r32, m32
func (*Program) SHRDQ ¶
func (self *Program) SHRDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHRDQ performs "Integer Double Precision Shift Right".
Mnemonic : SHRD Supported forms : (4 forms)
- SHRDQ imm8, r64, r64
- SHRDQ cl, r64, r64
- SHRDQ imm8, r64, m64
- SHRDQ cl, r64, m64
func (*Program) SHRDW ¶
func (self *Program) SHRDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHRDW performs "Integer Double Precision Shift Right".
Mnemonic : SHRD Supported forms : (4 forms)
- SHRDW imm8, r16, r16
- SHRDW cl, r16, r16
- SHRDW imm8, r16, m16
- SHRDW cl, r16, m16
func (*Program) SHRL ¶
func (self *Program) SHRL(v0 interface{}, v1 interface{}) *Instruction
SHRL performs "Logical Shift Right".
Mnemonic : SHR Supported forms : (6 forms)
- SHRL 1, r32
- SHRL imm8, r32
- SHRL cl, r32
- SHRL 1, m32
- SHRL imm8, m32
- SHRL cl, m32
func (*Program) SHRQ ¶
func (self *Program) SHRQ(v0 interface{}, v1 interface{}) *Instruction
SHRQ performs "Logical Shift Right".
Mnemonic : SHR Supported forms : (6 forms)
- SHRQ 1, r64
- SHRQ imm8, r64
- SHRQ cl, r64
- SHRQ 1, m64
- SHRQ imm8, m64
- SHRQ cl, m64
func (*Program) SHRW ¶
func (self *Program) SHRW(v0 interface{}, v1 interface{}) *Instruction
SHRW performs "Logical Shift Right".
Mnemonic : SHR Supported forms : (6 forms)
- SHRW 1, r16
- SHRW imm8, r16
- SHRW cl, r16
- SHRW 1, m16
- SHRW imm8, m16
- SHRW cl, m16
func (*Program) SHRXL ¶
func (self *Program) SHRXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHRXL performs "Logical Shift Right Without Affecting Flags".
Mnemonic : SHRX Supported forms : (2 forms)
- SHRXL r32, r32, r32 [BMI2]
- SHRXL r32, m32, r32 [BMI2]
func (*Program) SHRXQ ¶
func (self *Program) SHRXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHRXQ performs "Logical Shift Right Without Affecting Flags".
Mnemonic : SHRX Supported forms : (2 forms)
- SHRXQ r64, r64, r64 [BMI2]
- SHRXQ r64, m64, r64 [BMI2]
func (*Program) SHUFPD ¶
func (self *Program) SHUFPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHUFPD performs "Shuffle Packed Double-Precision Floating-Point Values".
Mnemonic : SHUFPD Supported forms : (2 forms)
- SHUFPD imm8, xmm, xmm [SSE2]
- SHUFPD imm8, m128, xmm [SSE2]
func (*Program) SHUFPS ¶
func (self *Program) SHUFPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
SHUFPS performs "Shuffle Packed Single-Precision Floating-Point Values".
Mnemonic : SHUFPS Supported forms : (2 forms)
- SHUFPS imm8, xmm, xmm [SSE]
- SHUFPS imm8, m128, xmm [SSE]
func (*Program) SQRTPD ¶
func (self *Program) SQRTPD(v0 interface{}, v1 interface{}) *Instruction
SQRTPD performs "Compute Square Roots of Packed Double-Precision Floating-Point Values".
Mnemonic : SQRTPD Supported forms : (2 forms)
- SQRTPD xmm, xmm [SSE2]
- SQRTPD m128, xmm [SSE2]
func (*Program) SQRTPS ¶
func (self *Program) SQRTPS(v0 interface{}, v1 interface{}) *Instruction
SQRTPS performs "Compute Square Roots of Packed Single-Precision Floating-Point Values".
Mnemonic : SQRTPS Supported forms : (2 forms)
- SQRTPS xmm, xmm [SSE]
- SQRTPS m128, xmm [SSE]
func (*Program) SQRTSD ¶
func (self *Program) SQRTSD(v0 interface{}, v1 interface{}) *Instruction
SQRTSD performs "Compute Square Root of Scalar Double-Precision Floating-Point Value".
Mnemonic : SQRTSD Supported forms : (2 forms)
- SQRTSD xmm, xmm [SSE2]
- SQRTSD m64, xmm [SSE2]
func (*Program) SQRTSS ¶
func (self *Program) SQRTSS(v0 interface{}, v1 interface{}) *Instruction
SQRTSS performs "Compute Square Root of Scalar Single-Precision Floating-Point Value".
Mnemonic : SQRTSS Supported forms : (2 forms)
- SQRTSS xmm, xmm [SSE]
- SQRTSS m32, xmm [SSE]
func (*Program) STC ¶
func (self *Program) STC() *Instruction
STC performs "Set Carry Flag".
Mnemonic : STC Supported forms : (1 form)
- STC
func (*Program) STD ¶
func (self *Program) STD() *Instruction
STD performs "Set Direction Flag".
Mnemonic : STD Supported forms : (1 form)
- STD
func (*Program) STMXCSR ¶
func (self *Program) STMXCSR(v0 interface{}) *Instruction
STMXCSR performs "Store MXCSR Register State".
Mnemonic : STMXCSR Supported forms : (1 form)
- STMXCSR m32 [SSE]
func (*Program) SUBB ¶
func (self *Program) SUBB(v0 interface{}, v1 interface{}) *Instruction
SUBB performs "Subtract".
Mnemonic : SUB Supported forms : (6 forms)
- SUBB imm8, al
- SUBB imm8, r8
- SUBB r8, r8
- SUBB m8, r8
- SUBB imm8, m8
- SUBB r8, m8
func (*Program) SUBL ¶
func (self *Program) SUBL(v0 interface{}, v1 interface{}) *Instruction
SUBL performs "Subtract".
Mnemonic : SUB Supported forms : (8 forms)
- SUBL imm32, eax
- SUBL imm8, r32
- SUBL imm32, r32
- SUBL r32, r32
- SUBL m32, r32
- SUBL imm8, m32
- SUBL imm32, m32
- SUBL r32, m32
func (*Program) SUBPD ¶
func (self *Program) SUBPD(v0 interface{}, v1 interface{}) *Instruction
SUBPD performs "Subtract Packed Double-Precision Floating-Point Values".
Mnemonic : SUBPD Supported forms : (2 forms)
- SUBPD xmm, xmm [SSE2]
- SUBPD m128, xmm [SSE2]
func (*Program) SUBPS ¶
func (self *Program) SUBPS(v0 interface{}, v1 interface{}) *Instruction
SUBPS performs "Subtract Packed Single-Precision Floating-Point Values".
Mnemonic : SUBPS Supported forms : (2 forms)
- SUBPS xmm, xmm [SSE]
- SUBPS m128, xmm [SSE]
func (*Program) SUBQ ¶
func (self *Program) SUBQ(v0 interface{}, v1 interface{}) *Instruction
SUBQ performs "Subtract".
Mnemonic : SUB Supported forms : (8 forms)
- SUBQ imm32, rax
- SUBQ imm8, r64
- SUBQ imm32, r64
- SUBQ r64, r64
- SUBQ m64, r64
- SUBQ imm8, m64
- SUBQ imm32, m64
- SUBQ r64, m64
func (*Program) SUBSD ¶
func (self *Program) SUBSD(v0 interface{}, v1 interface{}) *Instruction
SUBSD performs "Subtract Scalar Double-Precision Floating-Point Values".
Mnemonic : SUBSD Supported forms : (2 forms)
- SUBSD xmm, xmm [SSE2]
- SUBSD m64, xmm [SSE2]
func (*Program) SUBSS ¶
func (self *Program) SUBSS(v0 interface{}, v1 interface{}) *Instruction
SUBSS performs "Subtract Scalar Single-Precision Floating-Point Values".
Mnemonic : SUBSS Supported forms : (2 forms)
- SUBSS xmm, xmm [SSE]
- SUBSS m32, xmm [SSE]
func (*Program) SUBW ¶
func (self *Program) SUBW(v0 interface{}, v1 interface{}) *Instruction
SUBW performs "Subtract".
Mnemonic : SUB Supported forms : (8 forms)
- SUBW imm16, ax
- SUBW imm8, r16
- SUBW imm16, r16
- SUBW r16, r16
- SUBW m16, r16
- SUBW imm8, m16
- SUBW imm16, m16
- SUBW r16, m16
func (*Program) SYSCALL ¶
func (self *Program) SYSCALL() *Instruction
SYSCALL performs "Fast System Call".
Mnemonic : SYSCALL Supported forms : (1 form)
- SYSCALL
func (*Program) T1MSKC ¶
func (self *Program) T1MSKC(v0 interface{}, v1 interface{}) *Instruction
T1MSKC performs "Inverse Mask From Trailing Ones".
Mnemonic : T1MSKC Supported forms : (4 forms)
- T1MSKC r32, r32 [TBM]
- T1MSKC m32, r32 [TBM]
- T1MSKC r64, r64 [TBM]
- T1MSKC m64, r64 [TBM]
func (*Program) TESTB ¶
func (self *Program) TESTB(v0 interface{}, v1 interface{}) *Instruction
TESTB performs "Logical Compare".
Mnemonic : TEST Supported forms : (5 forms)
- TESTB imm8, al
- TESTB imm8, r8
- TESTB r8, r8
- TESTB imm8, m8
- TESTB r8, m8
func (*Program) TESTL ¶
func (self *Program) TESTL(v0 interface{}, v1 interface{}) *Instruction
TESTL performs "Logical Compare".
Mnemonic : TEST Supported forms : (5 forms)
- TESTL imm32, eax
- TESTL imm32, r32
- TESTL r32, r32
- TESTL imm32, m32
- TESTL r32, m32
func (*Program) TESTQ ¶
func (self *Program) TESTQ(v0 interface{}, v1 interface{}) *Instruction
TESTQ performs "Logical Compare".
Mnemonic : TEST Supported forms : (5 forms)
- TESTQ imm32, rax
- TESTQ imm32, r64
- TESTQ r64, r64
- TESTQ imm32, m64
- TESTQ r64, m64
func (*Program) TESTW ¶
func (self *Program) TESTW(v0 interface{}, v1 interface{}) *Instruction
TESTW performs "Logical Compare".
Mnemonic : TEST Supported forms : (5 forms)
- TESTW imm16, ax
- TESTW imm16, r16
- TESTW r16, r16
- TESTW imm16, m16
- TESTW r16, m16
func (*Program) TZCNTL ¶
func (self *Program) TZCNTL(v0 interface{}, v1 interface{}) *Instruction
TZCNTL performs "Count the Number of Trailing Zero Bits".
Mnemonic : TZCNT Supported forms : (2 forms)
- TZCNTL r32, r32 [BMI]
- TZCNTL m32, r32 [BMI]
func (*Program) TZCNTQ ¶
func (self *Program) TZCNTQ(v0 interface{}, v1 interface{}) *Instruction
TZCNTQ performs "Count the Number of Trailing Zero Bits".
Mnemonic : TZCNT Supported forms : (2 forms)
- TZCNTQ r64, r64 [BMI]
- TZCNTQ m64, r64 [BMI]
func (*Program) TZCNTW ¶
func (self *Program) TZCNTW(v0 interface{}, v1 interface{}) *Instruction
TZCNTW performs "Count the Number of Trailing Zero Bits".
Mnemonic : TZCNT Supported forms : (2 forms)
- TZCNTW r16, r16 [BMI]
- TZCNTW m16, r16 [BMI]
func (*Program) TZMSK ¶
func (self *Program) TZMSK(v0 interface{}, v1 interface{}) *Instruction
TZMSK performs "Mask From Trailing Zeros".
Mnemonic : TZMSK Supported forms : (4 forms)
- TZMSK r32, r32 [TBM]
- TZMSK m32, r32 [TBM]
- TZMSK r64, r64 [TBM]
- TZMSK m64, r64 [TBM]
func (*Program) UCOMISD ¶
func (self *Program) UCOMISD(v0 interface{}, v1 interface{}) *Instruction
UCOMISD performs "Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : UCOMISD Supported forms : (2 forms)
- UCOMISD xmm, xmm [SSE2]
- UCOMISD m64, xmm [SSE2]
func (*Program) UCOMISS ¶
func (self *Program) UCOMISS(v0 interface{}, v1 interface{}) *Instruction
UCOMISS performs "Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : UCOMISS Supported forms : (2 forms)
- UCOMISS xmm, xmm [SSE]
- UCOMISS m32, xmm [SSE]
func (*Program) UD2 ¶
func (self *Program) UD2() *Instruction
UD2 performs "Undefined Instruction".
Mnemonic : UD2 Supported forms : (1 form)
- UD2
func (*Program) UNPCKHPD ¶
func (self *Program) UNPCKHPD(v0 interface{}, v1 interface{}) *Instruction
UNPCKHPD performs "Unpack and Interleave High Packed Double-Precision Floating-Point Values".
Mnemonic : UNPCKHPD Supported forms : (2 forms)
- UNPCKHPD xmm, xmm [SSE2]
- UNPCKHPD m128, xmm [SSE2]
func (*Program) UNPCKHPS ¶
func (self *Program) UNPCKHPS(v0 interface{}, v1 interface{}) *Instruction
UNPCKHPS performs "Unpack and Interleave High Packed Single-Precision Floating-Point Values".
Mnemonic : UNPCKHPS Supported forms : (2 forms)
- UNPCKHPS xmm, xmm [SSE]
- UNPCKHPS m128, xmm [SSE]
func (*Program) UNPCKLPD ¶
func (self *Program) UNPCKLPD(v0 interface{}, v1 interface{}) *Instruction
UNPCKLPD performs "Unpack and Interleave Low Packed Double-Precision Floating-Point Values".
Mnemonic : UNPCKLPD Supported forms : (2 forms)
- UNPCKLPD xmm, xmm [SSE2]
- UNPCKLPD m128, xmm [SSE2]
func (*Program) UNPCKLPS ¶
func (self *Program) UNPCKLPS(v0 interface{}, v1 interface{}) *Instruction
UNPCKLPS performs "Unpack and Interleave Low Packed Single-Precision Floating-Point Values".
Mnemonic : UNPCKLPS Supported forms : (2 forms)
- UNPCKLPS xmm, xmm [SSE]
- UNPCKLPS m128, xmm [SSE]
func (*Program) VADDPD ¶
func (self *Program) VADDPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VADDPD performs "Add Packed Double-Precision Floating-Point Values".
Mnemonic : VADDPD Supported forms : (11 forms)
- VADDPD xmm, xmm, xmm [AVX]
- VADDPD m128, xmm, xmm [AVX]
- VADDPD ymm, ymm, ymm [AVX]
- VADDPD m256, ymm, ymm [AVX]
- VADDPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VADDPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VADDPD zmm, zmm, zmm{k}{z} [AVX512F]
- VADDPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VADDPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VADDPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VADDPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VADDPS ¶
func (self *Program) VADDPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VADDPS performs "Add Packed Single-Precision Floating-Point Values".
Mnemonic : VADDPS Supported forms : (11 forms)
- VADDPS xmm, xmm, xmm [AVX]
- VADDPS m128, xmm, xmm [AVX]
- VADDPS ymm, ymm, ymm [AVX]
- VADDPS m256, ymm, ymm [AVX]
- VADDPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VADDPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VADDPS zmm, zmm, zmm{k}{z} [AVX512F]
- VADDPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VADDPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VADDPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VADDPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VADDSD ¶
func (self *Program) VADDSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VADDSD performs "Add Scalar Double-Precision Floating-Point Values".
Mnemonic : VADDSD Supported forms : (5 forms)
- VADDSD xmm, xmm, xmm [AVX]
- VADDSD m64, xmm, xmm [AVX]
- VADDSD m64, xmm, xmm{k}{z} [AVX512F]
- VADDSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VADDSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VADDSS ¶
func (self *Program) VADDSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VADDSS performs "Add Scalar Single-Precision Floating-Point Values".
Mnemonic : VADDSS Supported forms : (5 forms)
- VADDSS xmm, xmm, xmm [AVX]
- VADDSS m32, xmm, xmm [AVX]
- VADDSS m32, xmm, xmm{k}{z} [AVX512F]
- VADDSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VADDSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VADDSUBPD ¶
func (self *Program) VADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VADDSUBPD performs "Packed Double-FP Add/Subtract".
Mnemonic : VADDSUBPD Supported forms : (4 forms)
- VADDSUBPD xmm, xmm, xmm [AVX]
- VADDSUBPD m128, xmm, xmm [AVX]
- VADDSUBPD ymm, ymm, ymm [AVX]
- VADDSUBPD m256, ymm, ymm [AVX]
func (*Program) VADDSUBPS ¶
func (self *Program) VADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VADDSUBPS performs "Packed Single-FP Add/Subtract".
Mnemonic : VADDSUBPS Supported forms : (4 forms)
- VADDSUBPS xmm, xmm, xmm [AVX]
- VADDSUBPS m128, xmm, xmm [AVX]
- VADDSUBPS ymm, ymm, ymm [AVX]
- VADDSUBPS m256, ymm, ymm [AVX]
func (*Program) VAESDEC ¶
func (self *Program) VAESDEC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VAESDEC performs "Perform One Round of an AES Decryption Flow".
Mnemonic : VAESDEC Supported forms : (2 forms)
- VAESDEC xmm, xmm, xmm [AES,AVX]
- VAESDEC m128, xmm, xmm [AES,AVX]
func (*Program) VAESDECLAST ¶
func (self *Program) VAESDECLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VAESDECLAST performs "Perform Last Round of an AES Decryption Flow".
Mnemonic : VAESDECLAST Supported forms : (2 forms)
- VAESDECLAST xmm, xmm, xmm [AES,AVX]
- VAESDECLAST m128, xmm, xmm [AES,AVX]
func (*Program) VAESENC ¶
func (self *Program) VAESENC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VAESENC performs "Perform One Round of an AES Encryption Flow".
Mnemonic : VAESENC Supported forms : (2 forms)
- VAESENC xmm, xmm, xmm [AES,AVX]
- VAESENC m128, xmm, xmm [AES,AVX]
func (*Program) VAESENCLAST ¶
func (self *Program) VAESENCLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VAESENCLAST performs "Perform Last Round of an AES Encryption Flow".
Mnemonic : VAESENCLAST Supported forms : (2 forms)
- VAESENCLAST xmm, xmm, xmm [AES,AVX]
- VAESENCLAST m128, xmm, xmm [AES,AVX]
func (*Program) VAESIMC ¶
func (self *Program) VAESIMC(v0 interface{}, v1 interface{}) *Instruction
VAESIMC performs "Perform the AES InvMixColumn Transformation".
Mnemonic : VAESIMC Supported forms : (2 forms)
- VAESIMC xmm, xmm [AES,AVX]
- VAESIMC m128, xmm [AES,AVX]
func (*Program) VAESKEYGENASSIST ¶
func (self *Program) VAESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VAESKEYGENASSIST performs "AES Round Key Generation Assist".
Mnemonic : VAESKEYGENASSIST Supported forms : (2 forms)
- VAESKEYGENASSIST imm8, xmm, xmm [AES,AVX]
- VAESKEYGENASSIST imm8, m128, xmm [AES,AVX]
func (*Program) VALIGND ¶
func (self *Program) VALIGND(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VALIGND performs "Align Doubleword Vectors".
Mnemonic : VALIGND Supported forms : (6 forms)
- VALIGND imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VALIGND imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VALIGND imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VALIGND imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VALIGND imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VALIGND imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VALIGNQ ¶
func (self *Program) VALIGNQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VALIGNQ performs "Align Quadword Vectors".
Mnemonic : VALIGNQ Supported forms : (6 forms)
- VALIGNQ imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VALIGNQ imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VALIGNQ imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VALIGNQ imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VALIGNQ imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VALIGNQ imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VANDNPD ¶
func (self *Program) VANDNPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VANDNPD performs "Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values".
Mnemonic : VANDNPD Supported forms : (10 forms)
- VANDNPD xmm, xmm, xmm [AVX]
- VANDNPD m128, xmm, xmm [AVX]
- VANDNPD ymm, ymm, ymm [AVX]
- VANDNPD m256, ymm, ymm [AVX]
- VANDNPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
- VANDNPD zmm, zmm, zmm{k}{z} [AVX512DQ]
- VANDNPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDNPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDNPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VANDNPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VANDNPS ¶
func (self *Program) VANDNPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VANDNPS performs "Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values".
Mnemonic : VANDNPS Supported forms : (10 forms)
- VANDNPS xmm, xmm, xmm [AVX]
- VANDNPS m128, xmm, xmm [AVX]
- VANDNPS ymm, ymm, ymm [AVX]
- VANDNPS m256, ymm, ymm [AVX]
- VANDNPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
- VANDNPS zmm, zmm, zmm{k}{z} [AVX512DQ]
- VANDNPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDNPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDNPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VANDNPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VANDPD ¶
func (self *Program) VANDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VANDPD performs "Bitwise Logical AND of Packed Double-Precision Floating-Point Values".
Mnemonic : VANDPD Supported forms : (10 forms)
- VANDPD xmm, xmm, xmm [AVX]
- VANDPD m128, xmm, xmm [AVX]
- VANDPD ymm, ymm, ymm [AVX]
- VANDPD m256, ymm, ymm [AVX]
- VANDPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
- VANDPD zmm, zmm, zmm{k}{z} [AVX512DQ]
- VANDPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VANDPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VANDPS ¶
func (self *Program) VANDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VANDPS performs "Bitwise Logical AND of Packed Single-Precision Floating-Point Values".
Mnemonic : VANDPS Supported forms : (10 forms)
- VANDPS xmm, xmm, xmm [AVX]
- VANDPS m128, xmm, xmm [AVX]
- VANDPS ymm, ymm, ymm [AVX]
- VANDPS m256, ymm, ymm [AVX]
- VANDPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
- VANDPS zmm, zmm, zmm{k}{z} [AVX512DQ]
- VANDPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VANDPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VANDPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VBLENDMPD ¶
func (self *Program) VBLENDMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VBLENDMPD performs "Blend Packed Double-Precision Floating-Point Vectors Using an OpMask Control".
Mnemonic : VBLENDMPD Supported forms : (6 forms)
- VBLENDMPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VBLENDMPD zmm, zmm, zmm{k}{z} [AVX512F]
- VBLENDMPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VBLENDMPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VBLENDMPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VBLENDMPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VBLENDMPS ¶
func (self *Program) VBLENDMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VBLENDMPS performs "Blend Packed Single-Precision Floating-Point Vectors Using an OpMask Control".
Mnemonic : VBLENDMPS Supported forms : (6 forms)
- VBLENDMPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VBLENDMPS zmm, zmm, zmm{k}{z} [AVX512F]
- VBLENDMPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VBLENDMPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VBLENDMPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VBLENDMPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VBLENDPD ¶
func (self *Program) VBLENDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VBLENDPD performs "Blend Packed Double Precision Floating-Point Values".
Mnemonic : VBLENDPD Supported forms : (4 forms)
- VBLENDPD imm8, xmm, xmm, xmm [AVX]
- VBLENDPD imm8, m128, xmm, xmm [AVX]
- VBLENDPD imm8, ymm, ymm, ymm [AVX]
- VBLENDPD imm8, m256, ymm, ymm [AVX]
func (*Program) VBLENDPS ¶
func (self *Program) VBLENDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VBLENDPS performs " Blend Packed Single Precision Floating-Point Values".
Mnemonic : VBLENDPS Supported forms : (4 forms)
- VBLENDPS imm8, xmm, xmm, xmm [AVX]
- VBLENDPS imm8, m128, xmm, xmm [AVX]
- VBLENDPS imm8, ymm, ymm, ymm [AVX]
- VBLENDPS imm8, m256, ymm, ymm [AVX]
func (*Program) VBLENDVPD ¶
func (self *Program) VBLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VBLENDVPD performs " Variable Blend Packed Double Precision Floating-Point Values".
Mnemonic : VBLENDVPD Supported forms : (4 forms)
- VBLENDVPD xmm, xmm, xmm, xmm [AVX]
- VBLENDVPD xmm, m128, xmm, xmm [AVX]
- VBLENDVPD ymm, ymm, ymm, ymm [AVX]
- VBLENDVPD ymm, m256, ymm, ymm [AVX]
func (*Program) VBLENDVPS ¶
func (self *Program) VBLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VBLENDVPS performs " Variable Blend Packed Single Precision Floating-Point Values".
Mnemonic : VBLENDVPS Supported forms : (4 forms)
- VBLENDVPS xmm, xmm, xmm, xmm [AVX]
- VBLENDVPS xmm, m128, xmm, xmm [AVX]
- VBLENDVPS ymm, ymm, ymm, ymm [AVX]
- VBLENDVPS ymm, m256, ymm, ymm [AVX]
func (*Program) VBROADCASTF128 ¶
func (self *Program) VBROADCASTF128(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTF128 performs "Broadcast 128 Bit of Floating-Point Data".
Mnemonic : VBROADCASTF128 Supported forms : (1 form)
- VBROADCASTF128 m128, ymm [AVX]
func (*Program) VBROADCASTF32X2 ¶
func (self *Program) VBROADCASTF32X2(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTF32X2 performs "Broadcast Two Single-Precision Floating-Point Elements".
Mnemonic : VBROADCASTF32X2 Supported forms : (4 forms)
- VBROADCASTF32X2 xmm, zmm{k}{z} [AVX512DQ]
- VBROADCASTF32X2 m64, zmm{k}{z} [AVX512DQ]
- VBROADCASTF32X2 xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VBROADCASTF32X2 m64, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VBROADCASTF32X4 ¶
func (self *Program) VBROADCASTF32X4(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTF32X4 performs "Broadcast Four Single-Precision Floating-Point Elements".
Mnemonic : VBROADCASTF32X4 Supported forms : (2 forms)
- VBROADCASTF32X4 m128, zmm{k}{z} [AVX512F]
- VBROADCASTF32X4 m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VBROADCASTF32X8 ¶
func (self *Program) VBROADCASTF32X8(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTF32X8 performs "Broadcast Eight Single-Precision Floating-Point Elements".
Mnemonic : VBROADCASTF32X8 Supported forms : (1 form)
- VBROADCASTF32X8 m256, zmm{k}{z} [AVX512DQ]
func (*Program) VBROADCASTF64X2 ¶
func (self *Program) VBROADCASTF64X2(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTF64X2 performs "Broadcast Two Double-Precision Floating-Point Elements".
Mnemonic : VBROADCASTF64X2 Supported forms : (2 forms)
- VBROADCASTF64X2 m128, zmm{k}{z} [AVX512DQ]
- VBROADCASTF64X2 m128, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VBROADCASTF64X4 ¶
func (self *Program) VBROADCASTF64X4(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTF64X4 performs "Broadcast Four Double-Precision Floating-Point Elements".
Mnemonic : VBROADCASTF64X4 Supported forms : (1 form)
- VBROADCASTF64X4 m256, zmm{k}{z} [AVX512F]
func (*Program) VBROADCASTI128 ¶
func (self *Program) VBROADCASTI128(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTI128 performs "Broadcast 128 Bits of Integer Data".
Mnemonic : VBROADCASTI128 Supported forms : (1 form)
- VBROADCASTI128 m128, ymm [AVX2]
func (*Program) VBROADCASTI32X2 ¶
func (self *Program) VBROADCASTI32X2(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTI32X2 performs "Broadcast Two Doubleword Elements".
Mnemonic : VBROADCASTI32X2 Supported forms : (6 forms)
- VBROADCASTI32X2 xmm, zmm{k}{z} [AVX512DQ]
- VBROADCASTI32X2 m64, zmm{k}{z} [AVX512DQ]
- VBROADCASTI32X2 xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VBROADCASTI32X2 xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VBROADCASTI32X2 m64, xmm{k}{z} [AVX512DQ,AVX512VL]
- VBROADCASTI32X2 m64, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VBROADCASTI32X4 ¶
func (self *Program) VBROADCASTI32X4(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTI32X4 performs "Broadcast Four Doubleword Elements".
Mnemonic : VBROADCASTI32X4 Supported forms : (2 forms)
- VBROADCASTI32X4 m128, zmm{k}{z} [AVX512F]
- VBROADCASTI32X4 m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VBROADCASTI32X8 ¶
func (self *Program) VBROADCASTI32X8(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTI32X8 performs "Broadcast Eight Doubleword Elements".
Mnemonic : VBROADCASTI32X8 Supported forms : (1 form)
- VBROADCASTI32X8 m256, zmm{k}{z} [AVX512DQ]
func (*Program) VBROADCASTI64X2 ¶
func (self *Program) VBROADCASTI64X2(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTI64X2 performs "Broadcast Two Quadword Elements".
Mnemonic : VBROADCASTI64X2 Supported forms : (2 forms)
- VBROADCASTI64X2 m128, zmm{k}{z} [AVX512DQ]
- VBROADCASTI64X2 m128, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VBROADCASTI64X4 ¶
func (self *Program) VBROADCASTI64X4(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTI64X4 performs "Broadcast Four Quadword Elements".
Mnemonic : VBROADCASTI64X4 Supported forms : (1 form)
- VBROADCASTI64X4 m256, zmm{k}{z} [AVX512F]
func (*Program) VBROADCASTSD ¶
func (self *Program) VBROADCASTSD(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTSD performs "Broadcast Double-Precision Floating-Point Element".
Mnemonic : VBROADCASTSD Supported forms : (6 forms)
- VBROADCASTSD m64, ymm [AVX]
- VBROADCASTSD xmm, ymm [AVX2]
- VBROADCASTSD xmm, zmm{k}{z} [AVX512F]
- VBROADCASTSD m64, zmm{k}{z} [AVX512F]
- VBROADCASTSD xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VBROADCASTSD m64, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VBROADCASTSS ¶
func (self *Program) VBROADCASTSS(v0 interface{}, v1 interface{}) *Instruction
VBROADCASTSS performs "Broadcast Single-Precision Floating-Point Element".
Mnemonic : VBROADCASTSS Supported forms : (8 forms)
- VBROADCASTSS m32, xmm [AVX]
- VBROADCASTSS m32, ymm [AVX]
- VBROADCASTSS xmm, xmm [AVX2]
- VBROADCASTSS xmm, ymm [AVX2]
- VBROADCASTSS xmm, zmm{k}{z} [AVX512F]
- VBROADCASTSS m32, zmm{k}{z} [AVX512F]
- VBROADCASTSS xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VBROADCASTSS m32, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCMPPD ¶
func (self *Program) VCMPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VCMPPD performs "Compare Packed Double-Precision Floating-Point Values".
Mnemonic : VCMPPD Supported forms : (11 forms)
- VCMPPD imm8, xmm, xmm, xmm [AVX]
- VCMPPD imm8, m128, xmm, xmm [AVX]
- VCMPPD imm8, ymm, ymm, ymm [AVX]
- VCMPPD imm8, m256, ymm, ymm [AVX]
- VCMPPD imm8, m512/m64bcst, zmm, k{k} [AVX512F]
- VCMPPD imm8, {sae}, zmm, zmm, k{k} [AVX512F]
- VCMPPD imm8, zmm, zmm, k{k} [AVX512F]
- VCMPPD imm8, m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VCMPPD imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
- VCMPPD imm8, m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VCMPPD imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VCMPPS ¶
func (self *Program) VCMPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VCMPPS performs "Compare Packed Single-Precision Floating-Point Values".
Mnemonic : VCMPPS Supported forms : (11 forms)
- VCMPPS imm8, xmm, xmm, xmm [AVX]
- VCMPPS imm8, m128, xmm, xmm [AVX]
- VCMPPS imm8, ymm, ymm, ymm [AVX]
- VCMPPS imm8, m256, ymm, ymm [AVX]
- VCMPPS imm8, m512/m32bcst, zmm, k{k} [AVX512F]
- VCMPPS imm8, {sae}, zmm, zmm, k{k} [AVX512F]
- VCMPPS imm8, zmm, zmm, k{k} [AVX512F]
- VCMPPS imm8, m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VCMPPS imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
- VCMPPS imm8, m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VCMPPS imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VCMPSD ¶
func (self *Program) VCMPSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VCMPSD performs "Compare Scalar Double-Precision Floating-Point Values".
Mnemonic : VCMPSD Supported forms : (5 forms)
- VCMPSD imm8, xmm, xmm, xmm [AVX]
- VCMPSD imm8, m64, xmm, xmm [AVX]
- VCMPSD imm8, m64, xmm, k{k} [AVX512F]
- VCMPSD imm8, {sae}, xmm, xmm, k{k} [AVX512F]
- VCMPSD imm8, xmm, xmm, k{k} [AVX512F]
func (*Program) VCMPSS ¶
func (self *Program) VCMPSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VCMPSS performs "Compare Scalar Single-Precision Floating-Point Values".
Mnemonic : VCMPSS Supported forms : (5 forms)
- VCMPSS imm8, xmm, xmm, xmm [AVX]
- VCMPSS imm8, m32, xmm, xmm [AVX]
- VCMPSS imm8, m32, xmm, k{k} [AVX512F]
- VCMPSS imm8, {sae}, xmm, xmm, k{k} [AVX512F]
- VCMPSS imm8, xmm, xmm, k{k} [AVX512F]
func (*Program) VCOMISD ¶
func (self *Program) VCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCOMISD performs "Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : VCOMISD Supported forms : (5 forms)
- VCOMISD xmm, xmm [AVX]
- VCOMISD m64, xmm [AVX]
- VCOMISD m64, xmm [AVX512F]
- VCOMISD {sae}, xmm, xmm [AVX512F]
- VCOMISD xmm, xmm [AVX512F]
func (*Program) VCOMISS ¶
func (self *Program) VCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCOMISS performs "Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : VCOMISS Supported forms : (5 forms)
- VCOMISS xmm, xmm [AVX]
- VCOMISS m32, xmm [AVX]
- VCOMISS m32, xmm [AVX512F]
- VCOMISS {sae}, xmm, xmm [AVX512F]
- VCOMISS xmm, xmm [AVX512F]
func (*Program) VCOMPRESSPD ¶
func (self *Program) VCOMPRESSPD(v0 interface{}, v1 interface{}) *Instruction
VCOMPRESSPD performs "Store Sparse Packed Double-Precision Floating-Point Values into Dense Memory/Register".
Mnemonic : VCOMPRESSPD Supported forms : (6 forms)
- VCOMPRESSPD zmm, zmm{k}{z} [AVX512F]
- VCOMPRESSPD zmm, m512{k}{z} [AVX512F]
- VCOMPRESSPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCOMPRESSPD xmm, m128{k}{z} [AVX512F,AVX512VL]
- VCOMPRESSPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VCOMPRESSPD ymm, m256{k}{z} [AVX512F,AVX512VL]
func (*Program) VCOMPRESSPS ¶
func (self *Program) VCOMPRESSPS(v0 interface{}, v1 interface{}) *Instruction
VCOMPRESSPS performs "Store Sparse Packed Single-Precision Floating-Point Values into Dense Memory/Register".
Mnemonic : VCOMPRESSPS Supported forms : (6 forms)
- VCOMPRESSPS zmm, zmm{k}{z} [AVX512F]
- VCOMPRESSPS zmm, m512{k}{z} [AVX512F]
- VCOMPRESSPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCOMPRESSPS xmm, m128{k}{z} [AVX512F,AVX512VL]
- VCOMPRESSPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VCOMPRESSPS ymm, m256{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTDQ2PD ¶
func (self *Program) VCVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction
VCVTDQ2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".
Mnemonic : VCVTDQ2PD Supported forms : (10 forms)
- VCVTDQ2PD xmm, xmm [AVX]
- VCVTDQ2PD m64, xmm [AVX]
- VCVTDQ2PD xmm, ymm [AVX]
- VCVTDQ2PD m128, ymm [AVX]
- VCVTDQ2PD m256/m32bcst, zmm{k}{z} [AVX512F]
- VCVTDQ2PD ymm, zmm{k}{z} [AVX512F]
- VCVTDQ2PD m64/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTDQ2PD m128/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTDQ2PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTDQ2PD xmm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTDQ2PS ¶
func (self *Program) VCVTDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTDQ2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".
Mnemonic : VCVTDQ2PS Supported forms : (11 forms)
- VCVTDQ2PS xmm, xmm [AVX]
- VCVTDQ2PS m128, xmm [AVX]
- VCVTDQ2PS ymm, ymm [AVX]
- VCVTDQ2PS m256, ymm [AVX]
- VCVTDQ2PS m512/m32bcst, zmm{k}{z} [AVX512F]
- VCVTDQ2PS {er}, zmm, zmm{k}{z} [AVX512F]
- VCVTDQ2PS zmm, zmm{k}{z} [AVX512F]
- VCVTDQ2PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTDQ2PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTDQ2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTDQ2PS ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPD2DQ ¶
func (self *Program) VCVTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPD2DQ performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".
Mnemonic : VCVTPD2DQ Supported forms : (11 forms)
- VCVTPD2DQ xmm, xmm [AVX]
- VCVTPD2DQ ymm, xmm [AVX]
- VCVTPD2DQ m128, xmm [AVX]
- VCVTPD2DQ m256, xmm [AVX]
- VCVTPD2DQ m512/m64bcst, ymm{k}{z} [AVX512F]
- VCVTPD2DQ {er}, zmm, ymm{k}{z} [AVX512F]
- VCVTPD2DQ zmm, ymm{k}{z} [AVX512F]
- VCVTPD2DQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2DQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2DQ ymm, xmm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPD2PS ¶
func (self *Program) VCVTPD2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPD2PS performs "Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values".
Mnemonic : VCVTPD2PS Supported forms : (11 forms)
- VCVTPD2PS xmm, xmm [AVX]
- VCVTPD2PS ymm, xmm [AVX]
- VCVTPD2PS m128, xmm [AVX]
- VCVTPD2PS m256, xmm [AVX]
- VCVTPD2PS m512/m64bcst, ymm{k}{z} [AVX512F]
- VCVTPD2PS {er}, zmm, ymm{k}{z} [AVX512F]
- VCVTPD2PS zmm, ymm{k}{z} [AVX512F]
- VCVTPD2PS m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2PS m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2PS ymm, xmm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPD2QQ ¶
func (self *Program) VCVTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPD2QQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Quadword Integers".
Mnemonic : VCVTPD2QQ Supported forms : (7 forms)
- VCVTPD2QQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VCVTPD2QQ {er}, zmm, zmm{k}{z} [AVX512DQ]
- VCVTPD2QQ zmm, zmm{k}{z} [AVX512DQ]
- VCVTPD2QQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPD2QQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPD2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPD2QQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTPD2UDQ ¶
func (self *Program) VCVTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPD2UDQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers".
Mnemonic : VCVTPD2UDQ Supported forms : (7 forms)
- VCVTPD2UDQ m512/m64bcst, ymm{k}{z} [AVX512F]
- VCVTPD2UDQ {er}, zmm, ymm{k}{z} [AVX512F]
- VCVTPD2UDQ zmm, ymm{k}{z} [AVX512F]
- VCVTPD2UDQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2UDQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPD2UDQ ymm, xmm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPD2UQQ ¶
func (self *Program) VCVTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPD2UQQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers".
Mnemonic : VCVTPD2UQQ Supported forms : (7 forms)
- VCVTPD2UQQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VCVTPD2UQQ {er}, zmm, zmm{k}{z} [AVX512DQ]
- VCVTPD2UQQ zmm, zmm{k}{z} [AVX512DQ]
- VCVTPD2UQQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPD2UQQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPD2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPD2UQQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTPH2PS ¶
func (self *Program) VCVTPH2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPH2PS performs "Convert Half-Precision FP Values to Single-Precision FP Values".
Mnemonic : VCVTPH2PS Supported forms : (11 forms)
- VCVTPH2PS xmm, xmm [F16C]
- VCVTPH2PS m64, xmm [F16C]
- VCVTPH2PS xmm, ymm [F16C]
- VCVTPH2PS m128, ymm [F16C]
- VCVTPH2PS m256, zmm{k}{z} [AVX512F]
- VCVTPH2PS {sae}, ymm, zmm{k}{z} [AVX512F]
- VCVTPH2PS ymm, zmm{k}{z} [AVX512F]
- VCVTPH2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPH2PS xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTPH2PS m64, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPH2PS m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPS2DQ ¶
func (self *Program) VCVTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPS2DQ performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".
Mnemonic : VCVTPS2DQ Supported forms : (11 forms)
- VCVTPS2DQ xmm, xmm [AVX]
- VCVTPS2DQ m128, xmm [AVX]
- VCVTPS2DQ ymm, ymm [AVX]
- VCVTPS2DQ m256, ymm [AVX]
- VCVTPS2DQ m512/m32bcst, zmm{k}{z} [AVX512F]
- VCVTPS2DQ {er}, zmm, zmm{k}{z} [AVX512F]
- VCVTPS2DQ zmm, zmm{k}{z} [AVX512F]
- VCVTPS2DQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2DQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2DQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPS2PD ¶
func (self *Program) VCVTPS2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPS2PD performs "Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values".
Mnemonic : VCVTPS2PD Supported forms : (11 forms)
- VCVTPS2PD xmm, xmm [AVX]
- VCVTPS2PD m64, xmm [AVX]
- VCVTPS2PD xmm, ymm [AVX]
- VCVTPS2PD m128, ymm [AVX]
- VCVTPS2PD m256/m32bcst, zmm{k}{z} [AVX512F]
- VCVTPS2PD {sae}, ymm, zmm{k}{z} [AVX512F]
- VCVTPS2PD ymm, zmm{k}{z} [AVX512F]
- VCVTPS2PD m64/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2PD m128/m32bcst, ymm{k}{z} [AVX512VL]
- VCVTPS2PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2PD xmm, ymm{k}{z} [AVX512VL]
func (*Program) VCVTPS2PH ¶
func (self *Program) VCVTPS2PH(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTPS2PH performs "Convert Single-Precision FP value to Half-Precision FP value".
Mnemonic : VCVTPS2PH Supported forms : (11 forms)
- VCVTPS2PH imm8, xmm, xmm [F16C]
- VCVTPS2PH imm8, ymm, xmm [F16C]
- VCVTPS2PH imm8, xmm, m64 [F16C]
- VCVTPS2PH imm8, ymm, m128 [F16C]
- VCVTPS2PH imm8, zmm, m256{k}{z} [AVX512F]
- VCVTPS2PH imm8, {sae}, zmm, ymm{k}{z} [AVX512F]
- VCVTPS2PH imm8, zmm, ymm{k}{z} [AVX512F]
- VCVTPS2PH imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2PH imm8, xmm, m64{k}{z} [AVX512F,AVX512VL]
- VCVTPS2PH imm8, ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2PH imm8, ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPS2QQ ¶
func (self *Program) VCVTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPS2QQ performs "Convert Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values".
Mnemonic : VCVTPS2QQ Supported forms : (7 forms)
- VCVTPS2QQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
- VCVTPS2QQ {er}, ymm, zmm{k}{z} [AVX512DQ]
- VCVTPS2QQ ymm, zmm{k}{z} [AVX512DQ]
- VCVTPS2QQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPS2QQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPS2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPS2QQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTPS2UDQ ¶
func (self *Program) VCVTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPS2UDQ performs "Convert Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values".
Mnemonic : VCVTPS2UDQ Supported forms : (7 forms)
- VCVTPS2UDQ m512/m32bcst, zmm{k}{z} [AVX512F]
- VCVTPS2UDQ {er}, zmm, zmm{k}{z} [AVX512F]
- VCVTPS2UDQ zmm, zmm{k}{z} [AVX512F]
- VCVTPS2UDQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2UDQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTPS2UDQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTPS2UQQ ¶
func (self *Program) VCVTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTPS2UQQ performs "Convert Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values".
Mnemonic : VCVTPS2UQQ Supported forms : (7 forms)
- VCVTPS2UQQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
- VCVTPS2UQQ {er}, ymm, zmm{k}{z} [AVX512DQ]
- VCVTPS2UQQ ymm, zmm{k}{z} [AVX512DQ]
- VCVTPS2UQQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPS2UQQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPS2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTPS2UQQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTQQ2PD ¶
func (self *Program) VCVTQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTQQ2PD performs "Convert Packed Quadword Integers to Packed Double-Precision Floating-Point Values".
Mnemonic : VCVTQQ2PD Supported forms : (7 forms)
- VCVTQQ2PD m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VCVTQQ2PD {er}, zmm, zmm{k}{z} [AVX512DQ]
- VCVTQQ2PD zmm, zmm{k}{z} [AVX512DQ]
- VCVTQQ2PD m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTQQ2PD m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTQQ2PD xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTQQ2PD ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTQQ2PS ¶
func (self *Program) VCVTQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTQQ2PS performs "Convert Packed Quadword Integers to Packed Single-Precision Floating-Point Values".
Mnemonic : VCVTQQ2PS Supported forms : (7 forms)
- VCVTQQ2PS m512/m64bcst, ymm{k}{z} [AVX512DQ]
- VCVTQQ2PS {er}, zmm, ymm{k}{z} [AVX512DQ]
- VCVTQQ2PS zmm, ymm{k}{z} [AVX512DQ]
- VCVTQQ2PS m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTQQ2PS m256/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTQQ2PS xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTQQ2PS ymm, xmm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTSD2SI ¶
func (self *Program) VCVTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTSD2SI performs "Convert Scalar Double-Precision FP Value to Integer".
Mnemonic : VCVTSD2SI Supported forms : (10 forms)
- VCVTSD2SI xmm, r32 [AVX]
- VCVTSD2SI m64, r32 [AVX]
- VCVTSD2SI xmm, r64 [AVX]
- VCVTSD2SI m64, r64 [AVX]
- VCVTSD2SI m64, r32 [AVX512F]
- VCVTSD2SI m64, r64 [AVX512F]
- VCVTSD2SI {er}, xmm, r32 [AVX512F]
- VCVTSD2SI {er}, xmm, r64 [AVX512F]
- VCVTSD2SI xmm, r32 [AVX512F]
- VCVTSD2SI xmm, r64 [AVX512F]
func (*Program) VCVTSD2SS ¶
func (self *Program) VCVTSD2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTSD2SS performs "Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value".
Mnemonic : VCVTSD2SS Supported forms : (5 forms)
- VCVTSD2SS xmm, xmm, xmm [AVX]
- VCVTSD2SS m64, xmm, xmm [AVX]
- VCVTSD2SS m64, xmm, xmm{k}{z} [AVX512F]
- VCVTSD2SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VCVTSD2SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VCVTSD2USI ¶
func (self *Program) VCVTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTSD2USI performs "Convert Scalar Double-Precision Floating-Point Value to Unsigned Doubleword Integer".
Mnemonic : VCVTSD2USI Supported forms : (6 forms)
- VCVTSD2USI m64, r32 [AVX512F]
- VCVTSD2USI m64, r64 [AVX512F]
- VCVTSD2USI {er}, xmm, r32 [AVX512F]
- VCVTSD2USI {er}, xmm, r64 [AVX512F]
- VCVTSD2USI xmm, r32 [AVX512F]
- VCVTSD2USI xmm, r64 [AVX512F]
func (*Program) VCVTSI2SD ¶
func (self *Program) VCVTSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTSI2SD performs "Convert Dword Integer to Scalar Double-Precision FP Value".
Mnemonic : VCVTSI2SD Supported forms : (9 forms)
- VCVTSI2SD r32, xmm, xmm [AVX]
- VCVTSI2SD r64, xmm, xmm [AVX]
- VCVTSI2SD m32, xmm, xmm [AVX]
- VCVTSI2SD m64, xmm, xmm [AVX]
- VCVTSI2SD r32, xmm, xmm [AVX512F]
- VCVTSI2SD m32, xmm, xmm [AVX512F]
- VCVTSI2SD m64, xmm, xmm [AVX512F]
- VCVTSI2SD {er}, r64, xmm, xmm [AVX512F]
- VCVTSI2SD r64, xmm, xmm [AVX512F]
func (*Program) VCVTSI2SS ¶
func (self *Program) VCVTSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTSI2SS performs "Convert Dword Integer to Scalar Single-Precision FP Value".
Mnemonic : VCVTSI2SS Supported forms : (10 forms)
- VCVTSI2SS r32, xmm, xmm [AVX]
- VCVTSI2SS r64, xmm, xmm [AVX]
- VCVTSI2SS m32, xmm, xmm [AVX]
- VCVTSI2SS m64, xmm, xmm [AVX]
- VCVTSI2SS m32, xmm, xmm [AVX512F]
- VCVTSI2SS m64, xmm, xmm [AVX512F]
- VCVTSI2SS {er}, r32, xmm, xmm [AVX512F]
- VCVTSI2SS {er}, r64, xmm, xmm [AVX512F]
- VCVTSI2SS r32, xmm, xmm [AVX512F]
- VCVTSI2SS r64, xmm, xmm [AVX512F]
func (*Program) VCVTSS2SD ¶
func (self *Program) VCVTSS2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTSS2SD performs "Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value".
Mnemonic : VCVTSS2SD Supported forms : (5 forms)
- VCVTSS2SD xmm, xmm, xmm [AVX]
- VCVTSS2SD m32, xmm, xmm [AVX]
- VCVTSS2SD m32, xmm, xmm{k}{z} [AVX512F]
- VCVTSS2SD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VCVTSS2SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VCVTSS2SI ¶
func (self *Program) VCVTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTSS2SI performs "Convert Scalar Single-Precision FP Value to Dword Integer".
Mnemonic : VCVTSS2SI Supported forms : (10 forms)
- VCVTSS2SI xmm, r32 [AVX]
- VCVTSS2SI m32, r32 [AVX]
- VCVTSS2SI xmm, r64 [AVX]
- VCVTSS2SI m32, r64 [AVX]
- VCVTSS2SI m32, r32 [AVX512F]
- VCVTSS2SI m32, r64 [AVX512F]
- VCVTSS2SI {er}, xmm, r32 [AVX512F]
- VCVTSS2SI {er}, xmm, r64 [AVX512F]
- VCVTSS2SI xmm, r32 [AVX512F]
- VCVTSS2SI xmm, r64 [AVX512F]
func (*Program) VCVTSS2USI ¶
func (self *Program) VCVTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTSS2USI performs "Convert Scalar Single-Precision Floating-Point Value to Unsigned Doubleword Integer".
Mnemonic : VCVTSS2USI Supported forms : (6 forms)
- VCVTSS2USI m32, r32 [AVX512F]
- VCVTSS2USI m32, r64 [AVX512F]
- VCVTSS2USI {er}, xmm, r32 [AVX512F]
- VCVTSS2USI {er}, xmm, r64 [AVX512F]
- VCVTSS2USI xmm, r32 [AVX512F]
- VCVTSS2USI xmm, r64 [AVX512F]
func (*Program) VCVTTPD2DQ ¶
func (self *Program) VCVTTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPD2DQ performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".
Mnemonic : VCVTTPD2DQ Supported forms : (11 forms)
- VCVTTPD2DQ xmm, xmm [AVX]
- VCVTTPD2DQ ymm, xmm [AVX]
- VCVTTPD2DQ m128, xmm [AVX]
- VCVTTPD2DQ m256, xmm [AVX]
- VCVTTPD2DQ m512/m64bcst, ymm{k}{z} [AVX512F]
- VCVTTPD2DQ {sae}, zmm, ymm{k}{z} [AVX512F]
- VCVTTPD2DQ zmm, ymm{k}{z} [AVX512F]
- VCVTTPD2DQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPD2DQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPD2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPD2DQ ymm, xmm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTTPD2QQ ¶
func (self *Program) VCVTTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPD2QQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Quadword Integers".
Mnemonic : VCVTTPD2QQ Supported forms : (7 forms)
- VCVTTPD2QQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VCVTTPD2QQ {sae}, zmm, zmm{k}{z} [AVX512DQ]
- VCVTTPD2QQ zmm, zmm{k}{z} [AVX512DQ]
- VCVTTPD2QQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPD2QQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPD2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPD2QQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTTPD2UDQ ¶
func (self *Program) VCVTTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPD2UDQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers".
Mnemonic : VCVTTPD2UDQ Supported forms : (7 forms)
- VCVTTPD2UDQ m512/m64bcst, ymm{k}{z} [AVX512F]
- VCVTTPD2UDQ {sae}, zmm, ymm{k}{z} [AVX512F]
- VCVTTPD2UDQ zmm, ymm{k}{z} [AVX512F]
- VCVTTPD2UDQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPD2UDQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPD2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPD2UDQ ymm, xmm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTTPD2UQQ ¶
func (self *Program) VCVTTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPD2UQQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers".
Mnemonic : VCVTTPD2UQQ Supported forms : (7 forms)
- VCVTTPD2UQQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VCVTTPD2UQQ {sae}, zmm, zmm{k}{z} [AVX512DQ]
- VCVTTPD2UQQ zmm, zmm{k}{z} [AVX512DQ]
- VCVTTPD2UQQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPD2UQQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPD2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPD2UQQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTTPS2DQ ¶
func (self *Program) VCVTTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPS2DQ performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".
Mnemonic : VCVTTPS2DQ Supported forms : (11 forms)
- VCVTTPS2DQ xmm, xmm [AVX]
- VCVTTPS2DQ m128, xmm [AVX]
- VCVTTPS2DQ ymm, ymm [AVX]
- VCVTTPS2DQ m256, ymm [AVX]
- VCVTTPS2DQ m512/m32bcst, zmm{k}{z} [AVX512F]
- VCVTTPS2DQ {sae}, zmm, zmm{k}{z} [AVX512F]
- VCVTTPS2DQ zmm, zmm{k}{z} [AVX512F]
- VCVTTPS2DQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPS2DQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTTPS2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPS2DQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTTPS2QQ ¶
func (self *Program) VCVTTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPS2QQ performs "Convert with Truncation Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values".
Mnemonic : VCVTTPS2QQ Supported forms : (7 forms)
- VCVTTPS2QQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
- VCVTTPS2QQ {sae}, ymm, zmm{k}{z} [AVX512DQ]
- VCVTTPS2QQ ymm, zmm{k}{z} [AVX512DQ]
- VCVTTPS2QQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPS2QQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPS2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPS2QQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTTPS2UDQ ¶
func (self *Program) VCVTTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPS2UDQ performs "Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values".
Mnemonic : VCVTTPS2UDQ Supported forms : (7 forms)
- VCVTTPS2UDQ m512/m32bcst, zmm{k}{z} [AVX512F]
- VCVTTPS2UDQ {sae}, zmm, zmm{k}{z} [AVX512F]
- VCVTTPS2UDQ zmm, zmm{k}{z} [AVX512F]
- VCVTTPS2UDQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPS2UDQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTTPS2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTTPS2UDQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTTPS2UQQ ¶
func (self *Program) VCVTTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTPS2UQQ performs "Convert with Truncation Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values".
Mnemonic : VCVTTPS2UQQ Supported forms : (7 forms)
- VCVTTPS2UQQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
- VCVTTPS2UQQ {sae}, ymm, zmm{k}{z} [AVX512DQ]
- VCVTTPS2UQQ ymm, zmm{k}{z} [AVX512DQ]
- VCVTTPS2UQQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPS2UQQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPS2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTTPS2UQQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTTSD2SI ¶
func (self *Program) VCVTTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTSD2SI performs "Convert with Truncation Scalar Double-Precision FP Value to Signed Integer".
Mnemonic : VCVTTSD2SI Supported forms : (10 forms)
- VCVTTSD2SI xmm, r32 [AVX]
- VCVTTSD2SI m64, r32 [AVX]
- VCVTTSD2SI xmm, r64 [AVX]
- VCVTTSD2SI m64, r64 [AVX]
- VCVTTSD2SI m64, r32 [AVX512F]
- VCVTTSD2SI m64, r64 [AVX512F]
- VCVTTSD2SI {sae}, xmm, r32 [AVX512F]
- VCVTTSD2SI {sae}, xmm, r64 [AVX512F]
- VCVTTSD2SI xmm, r32 [AVX512F]
- VCVTTSD2SI xmm, r64 [AVX512F]
func (*Program) VCVTTSD2USI ¶
func (self *Program) VCVTTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTSD2USI performs "Convert with Truncation Scalar Double-Precision Floating-Point Value to Unsigned Integer".
Mnemonic : VCVTTSD2USI Supported forms : (6 forms)
- VCVTTSD2USI m64, r32 [AVX512F]
- VCVTTSD2USI m64, r64 [AVX512F]
- VCVTTSD2USI {sae}, xmm, r32 [AVX512F]
- VCVTTSD2USI {sae}, xmm, r64 [AVX512F]
- VCVTTSD2USI xmm, r32 [AVX512F]
- VCVTTSD2USI xmm, r64 [AVX512F]
func (*Program) VCVTTSS2SI ¶
func (self *Program) VCVTTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTSS2SI performs "Convert with Truncation Scalar Single-Precision FP Value to Dword Integer".
Mnemonic : VCVTTSS2SI Supported forms : (10 forms)
- VCVTTSS2SI xmm, r32 [AVX]
- VCVTTSS2SI m32, r32 [AVX]
- VCVTTSS2SI xmm, r64 [AVX]
- VCVTTSS2SI m32, r64 [AVX]
- VCVTTSS2SI m32, r32 [AVX512F]
- VCVTTSS2SI m32, r64 [AVX512F]
- VCVTTSS2SI {sae}, xmm, r32 [AVX512F]
- VCVTTSS2SI {sae}, xmm, r64 [AVX512F]
- VCVTTSS2SI xmm, r32 [AVX512F]
- VCVTTSS2SI xmm, r64 [AVX512F]
func (*Program) VCVTTSS2USI ¶
func (self *Program) VCVTTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTTSS2USI performs "Convert with Truncation Scalar Single-Precision Floating-Point Value to Unsigned Integer".
Mnemonic : VCVTTSS2USI Supported forms : (6 forms)
- VCVTTSS2USI m32, r32 [AVX512F]
- VCVTTSS2USI m32, r64 [AVX512F]
- VCVTTSS2USI {sae}, xmm, r32 [AVX512F]
- VCVTTSS2USI {sae}, xmm, r64 [AVX512F]
- VCVTTSS2USI xmm, r32 [AVX512F]
- VCVTTSS2USI xmm, r64 [AVX512F]
func (*Program) VCVTUDQ2PD ¶
func (self *Program) VCVTUDQ2PD(v0 interface{}, v1 interface{}) *Instruction
VCVTUDQ2PD performs "Convert Packed Unsigned Doubleword Integers to Packed Double-Precision Floating-Point Values".
Mnemonic : VCVTUDQ2PD Supported forms : (6 forms)
- VCVTUDQ2PD m256/m32bcst, zmm{k}{z} [AVX512F]
- VCVTUDQ2PD ymm, zmm{k}{z} [AVX512F]
- VCVTUDQ2PD m64/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTUDQ2PD m128/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTUDQ2PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTUDQ2PD xmm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTUDQ2PS ¶
func (self *Program) VCVTUDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTUDQ2PS performs "Convert Packed Unsigned Doubleword Integers to Packed Single-Precision Floating-Point Values".
Mnemonic : VCVTUDQ2PS Supported forms : (7 forms)
- VCVTUDQ2PS m512/m32bcst, zmm{k}{z} [AVX512F]
- VCVTUDQ2PS {er}, zmm, zmm{k}{z} [AVX512F]
- VCVTUDQ2PS zmm, zmm{k}{z} [AVX512F]
- VCVTUDQ2PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTUDQ2PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VCVTUDQ2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VCVTUDQ2PS ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VCVTUQQ2PD ¶
func (self *Program) VCVTUQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTUQQ2PD performs "Convert Packed Unsigned Quadword Integers to Packed Double-Precision Floating-Point Values".
Mnemonic : VCVTUQQ2PD Supported forms : (7 forms)
- VCVTUQQ2PD m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VCVTUQQ2PD {er}, zmm, zmm{k}{z} [AVX512DQ]
- VCVTUQQ2PD zmm, zmm{k}{z} [AVX512DQ]
- VCVTUQQ2PD m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTUQQ2PD m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VCVTUQQ2PD xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTUQQ2PD ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTUQQ2PS ¶
func (self *Program) VCVTUQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VCVTUQQ2PS performs "Convert Packed Unsigned Quadword Integers to Packed Single-Precision Floating-Point Values".
Mnemonic : VCVTUQQ2PS Supported forms : (7 forms)
- VCVTUQQ2PS m512/m64bcst, ymm{k}{z} [AVX512DQ]
- VCVTUQQ2PS {er}, zmm, ymm{k}{z} [AVX512DQ]
- VCVTUQQ2PS zmm, ymm{k}{z} [AVX512DQ]
- VCVTUQQ2PS m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTUQQ2PS m256/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTUQQ2PS xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VCVTUQQ2PS ymm, xmm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VCVTUSI2SD ¶
func (self *Program) VCVTUSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTUSI2SD performs "Convert Unsigned Integer to Scalar Double-Precision Floating-Point Value".
Mnemonic : VCVTUSI2SD Supported forms : (5 forms)
- VCVTUSI2SD r32, xmm, xmm [AVX512F]
- VCVTUSI2SD m32, xmm, xmm [AVX512F]
- VCVTUSI2SD m64, xmm, xmm [AVX512F]
- VCVTUSI2SD {er}, r64, xmm, xmm [AVX512F]
- VCVTUSI2SD r64, xmm, xmm [AVX512F]
func (*Program) VCVTUSI2SS ¶
func (self *Program) VCVTUSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VCVTUSI2SS performs "Convert Unsigned Integer to Scalar Single-Precision Floating-Point Value".
Mnemonic : VCVTUSI2SS Supported forms : (6 forms)
- VCVTUSI2SS m32, xmm, xmm [AVX512F]
- VCVTUSI2SS m64, xmm, xmm [AVX512F]
- VCVTUSI2SS {er}, r32, xmm, xmm [AVX512F]
- VCVTUSI2SS {er}, r64, xmm, xmm [AVX512F]
- VCVTUSI2SS r32, xmm, xmm [AVX512F]
- VCVTUSI2SS r64, xmm, xmm [AVX512F]
func (*Program) VDBPSADBW ¶
func (self *Program) VDBPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VDBPSADBW performs "Double Block Packed Sum-Absolute-Differences on Unsigned Bytes".
Mnemonic : VDBPSADBW Supported forms : (6 forms)
- VDBPSADBW imm8, zmm, zmm, zmm{k}{z} [AVX512BW]
- VDBPSADBW imm8, m512, zmm, zmm{k}{z} [AVX512BW]
- VDBPSADBW imm8, xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VDBPSADBW imm8, m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VDBPSADBW imm8, ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VDBPSADBW imm8, m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VDIVPD ¶
func (self *Program) VDIVPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VDIVPD performs "Divide Packed Double-Precision Floating-Point Values".
Mnemonic : VDIVPD Supported forms : (11 forms)
- VDIVPD xmm, xmm, xmm [AVX]
- VDIVPD m128, xmm, xmm [AVX]
- VDIVPD ymm, ymm, ymm [AVX]
- VDIVPD m256, ymm, ymm [AVX]
- VDIVPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VDIVPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VDIVPD zmm, zmm, zmm{k}{z} [AVX512F]
- VDIVPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VDIVPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VDIVPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VDIVPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VDIVPS ¶
func (self *Program) VDIVPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VDIVPS performs "Divide Packed Single-Precision Floating-Point Values".
Mnemonic : VDIVPS Supported forms : (11 forms)
- VDIVPS xmm, xmm, xmm [AVX]
- VDIVPS m128, xmm, xmm [AVX]
- VDIVPS ymm, ymm, ymm [AVX]
- VDIVPS m256, ymm, ymm [AVX]
- VDIVPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VDIVPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VDIVPS zmm, zmm, zmm{k}{z} [AVX512F]
- VDIVPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VDIVPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VDIVPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VDIVPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VDIVSD ¶
func (self *Program) VDIVSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VDIVSD performs "Divide Scalar Double-Precision Floating-Point Values".
Mnemonic : VDIVSD Supported forms : (5 forms)
- VDIVSD xmm, xmm, xmm [AVX]
- VDIVSD m64, xmm, xmm [AVX]
- VDIVSD m64, xmm, xmm{k}{z} [AVX512F]
- VDIVSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VDIVSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VDIVSS ¶
func (self *Program) VDIVSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VDIVSS performs "Divide Scalar Single-Precision Floating-Point Values".
Mnemonic : VDIVSS Supported forms : (5 forms)
- VDIVSS xmm, xmm, xmm [AVX]
- VDIVSS m32, xmm, xmm [AVX]
- VDIVSS m32, xmm, xmm{k}{z} [AVX512F]
- VDIVSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VDIVSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VDPPD ¶
func (self *Program) VDPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VDPPD performs "Dot Product of Packed Double Precision Floating-Point Values".
Mnemonic : VDPPD Supported forms : (2 forms)
- VDPPD imm8, xmm, xmm, xmm [AVX]
- VDPPD imm8, m128, xmm, xmm [AVX]
func (*Program) VDPPS ¶
func (self *Program) VDPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VDPPS performs "Dot Product of Packed Single Precision Floating-Point Values".
Mnemonic : VDPPS Supported forms : (4 forms)
- VDPPS imm8, xmm, xmm, xmm [AVX]
- VDPPS imm8, m128, xmm, xmm [AVX]
- VDPPS imm8, ymm, ymm, ymm [AVX]
- VDPPS imm8, m256, ymm, ymm [AVX]
func (*Program) VEXP2PD ¶
func (self *Program) VEXP2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VEXP2PD performs "Approximation to the Exponential 2^x of Packed Double-Precision Floating-Point Values with Less Than 2^-23 Relative Error".
Mnemonic : VEXP2PD Supported forms : (3 forms)
- VEXP2PD m512/m64bcst, zmm{k}{z} [AVX512ER]
- VEXP2PD {sae}, zmm, zmm{k}{z} [AVX512ER]
- VEXP2PD zmm, zmm{k}{z} [AVX512ER]
func (*Program) VEXP2PS ¶
func (self *Program) VEXP2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VEXP2PS performs "Approximation to the Exponential 2^x of Packed Single-Precision Floating-Point Values with Less Than 2^-23 Relative Error".
Mnemonic : VEXP2PS Supported forms : (3 forms)
- VEXP2PS m512/m32bcst, zmm{k}{z} [AVX512ER]
- VEXP2PS {sae}, zmm, zmm{k}{z} [AVX512ER]
- VEXP2PS zmm, zmm{k}{z} [AVX512ER]
func (*Program) VEXPANDPD ¶
func (self *Program) VEXPANDPD(v0 interface{}, v1 interface{}) *Instruction
VEXPANDPD performs "Load Sparse Packed Double-Precision Floating-Point Values from Dense Memory".
Mnemonic : VEXPANDPD Supported forms : (6 forms)
- VEXPANDPD zmm, zmm{k}{z} [AVX512F]
- VEXPANDPD m512, zmm{k}{z} [AVX512F]
- VEXPANDPD xmm, xmm{k}{z} [AVX512VL]
- VEXPANDPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VEXPANDPD m128, xmm{k}{z} [AVX512VL]
- VEXPANDPD m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VEXPANDPS ¶
func (self *Program) VEXPANDPS(v0 interface{}, v1 interface{}) *Instruction
VEXPANDPS performs "Load Sparse Packed Single-Precision Floating-Point Values from Dense Memory".
Mnemonic : VEXPANDPS Supported forms : (6 forms)
- VEXPANDPS zmm, zmm{k}{z} [AVX512F]
- VEXPANDPS m512, zmm{k}{z} [AVX512F]
- VEXPANDPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VEXPANDPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VEXPANDPS m128, xmm{k}{z} [AVX512F,AVX512VL]
- VEXPANDPS m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VEXTRACTF128 ¶
func (self *Program) VEXTRACTF128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTF128 performs "Extract Packed Floating-Point Values".
Mnemonic : VEXTRACTF128 Supported forms : (2 forms)
- VEXTRACTF128 imm8, ymm, xmm [AVX]
- VEXTRACTF128 imm8, ymm, m128 [AVX]
func (*Program) VEXTRACTF32X4 ¶
func (self *Program) VEXTRACTF32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTF32X4 performs "Extract 128 Bits of Packed Single-Precision Floating-Point Values".
Mnemonic : VEXTRACTF32X4 Supported forms : (4 forms)
- VEXTRACTF32X4 imm8, zmm, xmm{k}{z} [AVX512F]
- VEXTRACTF32X4 imm8, zmm, m128{k}{z} [AVX512F]
- VEXTRACTF32X4 imm8, ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VEXTRACTF32X4 imm8, ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VEXTRACTF32X8 ¶
func (self *Program) VEXTRACTF32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTF32X8 performs "Extract 256 Bits of Packed Single-Precision Floating-Point Values".
Mnemonic : VEXTRACTF32X8 Supported forms : (2 forms)
- VEXTRACTF32X8 imm8, zmm, ymm{k}{z} [AVX512DQ]
- VEXTRACTF32X8 imm8, zmm, m256{k}{z} [AVX512DQ]
func (*Program) VEXTRACTF64X2 ¶
func (self *Program) VEXTRACTF64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTF64X2 performs "Extract 128 Bits of Packed Double-Precision Floating-Point Values".
Mnemonic : VEXTRACTF64X2 Supported forms : (4 forms)
- VEXTRACTF64X2 imm8, zmm, xmm{k}{z} [AVX512DQ]
- VEXTRACTF64X2 imm8, zmm, m128{k}{z} [AVX512DQ]
- VEXTRACTF64X2 imm8, ymm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VEXTRACTF64X2 imm8, ymm, m128{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VEXTRACTF64X4 ¶
func (self *Program) VEXTRACTF64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTF64X4 performs "Extract 256 Bits of Packed Double-Precision Floating-Point Values".
Mnemonic : VEXTRACTF64X4 Supported forms : (2 forms)
- VEXTRACTF64X4 imm8, zmm, ymm{k}{z} [AVX512F]
- VEXTRACTF64X4 imm8, zmm, m256{k}{z} [AVX512F]
func (*Program) VEXTRACTI128 ¶
func (self *Program) VEXTRACTI128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTI128 performs "Extract Packed Integer Values".
Mnemonic : VEXTRACTI128 Supported forms : (2 forms)
- VEXTRACTI128 imm8, ymm, xmm [AVX2]
- VEXTRACTI128 imm8, ymm, m128 [AVX2]
func (*Program) VEXTRACTI32X4 ¶
func (self *Program) VEXTRACTI32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTI32X4 performs "Extract 128 Bits of Packed Doubleword Integer Values".
Mnemonic : VEXTRACTI32X4 Supported forms : (4 forms)
- VEXTRACTI32X4 imm8, zmm, xmm{k}{z} [AVX512F]
- VEXTRACTI32X4 imm8, zmm, m128{k}{z} [AVX512F]
- VEXTRACTI32X4 imm8, ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VEXTRACTI32X4 imm8, ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VEXTRACTI32X8 ¶
func (self *Program) VEXTRACTI32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTI32X8 performs "Extract 256 Bits of Packed Doubleword Integer Values".
Mnemonic : VEXTRACTI32X8 Supported forms : (2 forms)
- VEXTRACTI32X8 imm8, zmm, ymm{k}{z} [AVX512DQ]
- VEXTRACTI32X8 imm8, zmm, m256{k}{z} [AVX512DQ]
func (*Program) VEXTRACTI64X2 ¶
func (self *Program) VEXTRACTI64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTI64X2 performs "Extract 128 Bits of Packed Quadword Integer Values".
Mnemonic : VEXTRACTI64X2 Supported forms : (4 forms)
- VEXTRACTI64X2 imm8, zmm, xmm{k}{z} [AVX512DQ]
- VEXTRACTI64X2 imm8, zmm, m128{k}{z} [AVX512DQ]
- VEXTRACTI64X2 imm8, ymm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VEXTRACTI64X2 imm8, ymm, m128{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VEXTRACTI64X4 ¶
func (self *Program) VEXTRACTI64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTI64X4 performs "Extract 256 Bits of Packed Quadword Integer Values".
Mnemonic : VEXTRACTI64X4 Supported forms : (2 forms)
- VEXTRACTI64X4 imm8, zmm, ymm{k}{z} [AVX512F]
- VEXTRACTI64X4 imm8, zmm, m256{k}{z} [AVX512F]
func (*Program) VEXTRACTPS ¶
func (self *Program) VEXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VEXTRACTPS performs "Extract Packed Single Precision Floating-Point Value".
Mnemonic : VEXTRACTPS Supported forms : (4 forms)
- VEXTRACTPS imm8, xmm, r32 [AVX]
- VEXTRACTPS imm8, xmm, m32 [AVX]
- VEXTRACTPS imm8, xmm, r32 [AVX512F]
- VEXTRACTPS imm8, xmm, m32 [AVX512F]
func (*Program) VFIXUPIMMPD ¶
func (self *Program) VFIXUPIMMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VFIXUPIMMPD performs "Fix Up Special Packed Double-Precision Floating-Point Values".
Mnemonic : VFIXUPIMMPD Supported forms : (7 forms)
- VFIXUPIMMPD imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFIXUPIMMPD imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFIXUPIMMPD imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VFIXUPIMMPD imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFIXUPIMMPD imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFIXUPIMMPD imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFIXUPIMMPD imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFIXUPIMMPS ¶
func (self *Program) VFIXUPIMMPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VFIXUPIMMPS performs "Fix Up Special Packed Single-Precision Floating-Point Values".
Mnemonic : VFIXUPIMMPS Supported forms : (7 forms)
- VFIXUPIMMPS imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFIXUPIMMPS imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFIXUPIMMPS imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VFIXUPIMMPS imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512VL]
- VFIXUPIMMPS imm8, xmm, xmm, xmm{k}{z} [AVX512VL]
- VFIXUPIMMPS imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFIXUPIMMPS imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFIXUPIMMSD ¶
func (self *Program) VFIXUPIMMSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VFIXUPIMMSD performs "Fix Up Special Scalar Double-Precision Floating-Point Value".
Mnemonic : VFIXUPIMMSD Supported forms : (3 forms)
- VFIXUPIMMSD imm8, m64, xmm, xmm{k}{z} [AVX512F]
- VFIXUPIMMSD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFIXUPIMMSD imm8, xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFIXUPIMMSS ¶
func (self *Program) VFIXUPIMMSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VFIXUPIMMSS performs "Fix Up Special Scalar Single-Precision Floating-Point Value".
Mnemonic : VFIXUPIMMSS Supported forms : (3 forms)
- VFIXUPIMMSS imm8, m32, xmm, xmm{k}{z} [AVX512F]
- VFIXUPIMMSS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFIXUPIMMSS imm8, xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADD132PD ¶
func (self *Program) VFMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD132PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADD132PD Supported forms : (11 forms)
- VFMADD132PD xmm, xmm, xmm [FMA3]
- VFMADD132PD m128, xmm, xmm [FMA3]
- VFMADD132PD ymm, ymm, ymm [FMA3]
- VFMADD132PD m256, ymm, ymm [FMA3]
- VFMADD132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADD132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD132PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADD132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADD132PS ¶
func (self *Program) VFMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD132PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADD132PS Supported forms : (11 forms)
- VFMADD132PS xmm, xmm, xmm [FMA3]
- VFMADD132PS m128, xmm, xmm [FMA3]
- VFMADD132PS ymm, ymm, ymm [FMA3]
- VFMADD132PS m256, ymm, ymm [FMA3]
- VFMADD132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADD132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD132PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADD132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADD132SD ¶
func (self *Program) VFMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD132SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMADD132SD Supported forms : (5 forms)
- VFMADD132SD xmm, xmm, xmm [FMA3]
- VFMADD132SD m64, xmm, xmm [FMA3]
- VFMADD132SD m64, xmm, xmm{k}{z} [AVX512F]
- VFMADD132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMADD132SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADD132SS ¶
func (self *Program) VFMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD132SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMADD132SS Supported forms : (5 forms)
- VFMADD132SS xmm, xmm, xmm [FMA3]
- VFMADD132SS m32, xmm, xmm [FMA3]
- VFMADD132SS m32, xmm, xmm{k}{z} [AVX512F]
- VFMADD132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMADD132SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADD213PD ¶
func (self *Program) VFMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD213PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADD213PD Supported forms : (11 forms)
- VFMADD213PD xmm, xmm, xmm [FMA3]
- VFMADD213PD m128, xmm, xmm [FMA3]
- VFMADD213PD ymm, ymm, ymm [FMA3]
- VFMADD213PD m256, ymm, ymm [FMA3]
- VFMADD213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADD213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD213PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADD213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADD213PS ¶
func (self *Program) VFMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD213PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADD213PS Supported forms : (11 forms)
- VFMADD213PS xmm, xmm, xmm [FMA3]
- VFMADD213PS m128, xmm, xmm [FMA3]
- VFMADD213PS ymm, ymm, ymm [FMA3]
- VFMADD213PS m256, ymm, ymm [FMA3]
- VFMADD213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADD213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD213PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADD213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADD213SD ¶
func (self *Program) VFMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD213SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMADD213SD Supported forms : (5 forms)
- VFMADD213SD xmm, xmm, xmm [FMA3]
- VFMADD213SD m64, xmm, xmm [FMA3]
- VFMADD213SD m64, xmm, xmm{k}{z} [AVX512F]
- VFMADD213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMADD213SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADD213SS ¶
func (self *Program) VFMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD213SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMADD213SS Supported forms : (5 forms)
- VFMADD213SS xmm, xmm, xmm [FMA3]
- VFMADD213SS m32, xmm, xmm [FMA3]
- VFMADD213SS m32, xmm, xmm{k}{z} [AVX512F]
- VFMADD213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMADD213SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADD231PD ¶
func (self *Program) VFMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD231PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADD231PD Supported forms : (11 forms)
- VFMADD231PD xmm, xmm, xmm [FMA3]
- VFMADD231PD m128, xmm, xmm [FMA3]
- VFMADD231PD ymm, ymm, ymm [FMA3]
- VFMADD231PD m256, ymm, ymm [FMA3]
- VFMADD231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADD231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD231PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADD231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADD231PS ¶
func (self *Program) VFMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD231PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADD231PS Supported forms : (11 forms)
- VFMADD231PS xmm, xmm, xmm [FMA3]
- VFMADD231PS m128, xmm, xmm [FMA3]
- VFMADD231PS ymm, ymm, ymm [FMA3]
- VFMADD231PS m256, ymm, ymm [FMA3]
- VFMADD231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADD231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD231PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADD231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADD231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADD231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADD231SD ¶
func (self *Program) VFMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD231SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMADD231SD Supported forms : (5 forms)
- VFMADD231SD xmm, xmm, xmm [FMA3]
- VFMADD231SD m64, xmm, xmm [FMA3]
- VFMADD231SD m64, xmm, xmm{k}{z} [AVX512F]
- VFMADD231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMADD231SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADD231SS ¶
func (self *Program) VFMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADD231SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMADD231SS Supported forms : (5 forms)
- VFMADD231SS xmm, xmm, xmm [FMA3]
- VFMADD231SS m32, xmm, xmm [FMA3]
- VFMADD231SS m32, xmm, xmm{k}{z} [AVX512F]
- VFMADD231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMADD231SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMADDPD ¶
func (self *Program) VFMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMADDPD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADDPD Supported forms : (6 forms)
- VFMADDPD xmm, xmm, xmm, xmm [FMA4]
- VFMADDPD m128, xmm, xmm, xmm [FMA4]
- VFMADDPD xmm, m128, xmm, xmm [FMA4]
- VFMADDPD ymm, ymm, ymm, ymm [FMA4]
- VFMADDPD m256, ymm, ymm, ymm [FMA4]
- VFMADDPD ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMADDPS ¶
func (self *Program) VFMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMADDPS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADDPS Supported forms : (6 forms)
- VFMADDPS xmm, xmm, xmm, xmm [FMA4]
- VFMADDPS m128, xmm, xmm, xmm [FMA4]
- VFMADDPS xmm, m128, xmm, xmm [FMA4]
- VFMADDPS ymm, ymm, ymm, ymm [FMA4]
- VFMADDPS m256, ymm, ymm, ymm [FMA4]
- VFMADDPS ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMADDSD ¶
func (self *Program) VFMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMADDSD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMADDSD Supported forms : (3 forms)
- VFMADDSD xmm, xmm, xmm, xmm [FMA4]
- VFMADDSD m64, xmm, xmm, xmm [FMA4]
- VFMADDSD xmm, m64, xmm, xmm [FMA4]
func (*Program) VFMADDSS ¶
func (self *Program) VFMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMADDSS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMADDSS Supported forms : (3 forms)
- VFMADDSS xmm, xmm, xmm, xmm [FMA4]
- VFMADDSS m32, xmm, xmm, xmm [FMA4]
- VFMADDSS xmm, m32, xmm, xmm [FMA4]
func (*Program) VFMADDSUB132PD ¶
func (self *Program) VFMADDSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADDSUB132PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADDSUB132PD Supported forms : (11 forms)
- VFMADDSUB132PD xmm, xmm, xmm [FMA3]
- VFMADDSUB132PD m128, xmm, xmm [FMA3]
- VFMADDSUB132PD ymm, ymm, ymm [FMA3]
- VFMADDSUB132PD m256, ymm, ymm [FMA3]
- VFMADDSUB132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB132PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADDSUB132PS ¶
func (self *Program) VFMADDSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADDSUB132PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADDSUB132PS Supported forms : (11 forms)
- VFMADDSUB132PS xmm, xmm, xmm [FMA3]
- VFMADDSUB132PS m128, xmm, xmm [FMA3]
- VFMADDSUB132PS ymm, ymm, ymm [FMA3]
- VFMADDSUB132PS m256, ymm, ymm [FMA3]
- VFMADDSUB132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB132PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADDSUB213PD ¶
func (self *Program) VFMADDSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADDSUB213PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADDSUB213PD Supported forms : (11 forms)
- VFMADDSUB213PD xmm, xmm, xmm [FMA3]
- VFMADDSUB213PD m128, xmm, xmm [FMA3]
- VFMADDSUB213PD ymm, ymm, ymm [FMA3]
- VFMADDSUB213PD m256, ymm, ymm [FMA3]
- VFMADDSUB213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB213PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADDSUB213PS ¶
func (self *Program) VFMADDSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADDSUB213PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADDSUB213PS Supported forms : (11 forms)
- VFMADDSUB213PS xmm, xmm, xmm [FMA3]
- VFMADDSUB213PS m128, xmm, xmm [FMA3]
- VFMADDSUB213PS ymm, ymm, ymm [FMA3]
- VFMADDSUB213PS m256, ymm, ymm [FMA3]
- VFMADDSUB213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB213PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADDSUB231PD ¶
func (self *Program) VFMADDSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADDSUB231PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADDSUB231PD Supported forms : (11 forms)
- VFMADDSUB231PD xmm, xmm, xmm [FMA3]
- VFMADDSUB231PD m128, xmm, xmm [FMA3]
- VFMADDSUB231PD ymm, ymm, ymm [FMA3]
- VFMADDSUB231PD m256, ymm, ymm [FMA3]
- VFMADDSUB231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB231PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADDSUB231PS ¶
func (self *Program) VFMADDSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMADDSUB231PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADDSUB231PS Supported forms : (11 forms)
- VFMADDSUB231PS xmm, xmm, xmm [FMA3]
- VFMADDSUB231PS m128, xmm, xmm [FMA3]
- VFMADDSUB231PS ymm, ymm, ymm [FMA3]
- VFMADDSUB231PS m256, ymm, ymm [FMA3]
- VFMADDSUB231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB231PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMADDSUB231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMADDSUB231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMADDSUBPD ¶
func (self *Program) VFMADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMADDSUBPD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMADDSUBPD Supported forms : (6 forms)
- VFMADDSUBPD xmm, xmm, xmm, xmm [FMA4]
- VFMADDSUBPD m128, xmm, xmm, xmm [FMA4]
- VFMADDSUBPD xmm, m128, xmm, xmm [FMA4]
- VFMADDSUBPD ymm, ymm, ymm, ymm [FMA4]
- VFMADDSUBPD m256, ymm, ymm, ymm [FMA4]
- VFMADDSUBPD ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMADDSUBPS ¶
func (self *Program) VFMADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMADDSUBPS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMADDSUBPS Supported forms : (6 forms)
- VFMADDSUBPS xmm, xmm, xmm, xmm [FMA4]
- VFMADDSUBPS m128, xmm, xmm, xmm [FMA4]
- VFMADDSUBPS xmm, m128, xmm, xmm [FMA4]
- VFMADDSUBPS ymm, ymm, ymm, ymm [FMA4]
- VFMADDSUBPS m256, ymm, ymm, ymm [FMA4]
- VFMADDSUBPS ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMSUB132PD ¶
func (self *Program) VFMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB132PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUB132PD Supported forms : (11 forms)
- VFMSUB132PD xmm, xmm, xmm [FMA3]
- VFMSUB132PD m128, xmm, xmm [FMA3]
- VFMSUB132PD ymm, ymm, ymm [FMA3]
- VFMSUB132PD m256, ymm, ymm [FMA3]
- VFMSUB132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUB132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB132PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUB132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUB132PS ¶
func (self *Program) VFMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB132PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUB132PS Supported forms : (11 forms)
- VFMSUB132PS xmm, xmm, xmm [FMA3]
- VFMSUB132PS m128, xmm, xmm [FMA3]
- VFMSUB132PS ymm, ymm, ymm [FMA3]
- VFMSUB132PS m256, ymm, ymm [FMA3]
- VFMSUB132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUB132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB132PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUB132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUB132SD ¶
func (self *Program) VFMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB132SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMSUB132SD Supported forms : (5 forms)
- VFMSUB132SD xmm, xmm, xmm [FMA3]
- VFMSUB132SD m64, xmm, xmm [FMA3]
- VFMSUB132SD m64, xmm, xmm{k}{z} [AVX512F]
- VFMSUB132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMSUB132SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMSUB132SS ¶
func (self *Program) VFMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB132SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMSUB132SS Supported forms : (5 forms)
- VFMSUB132SS xmm, xmm, xmm [FMA3]
- VFMSUB132SS m32, xmm, xmm [FMA3]
- VFMSUB132SS m32, xmm, xmm{k}{z} [AVX512F]
- VFMSUB132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMSUB132SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMSUB213PD ¶
func (self *Program) VFMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB213PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUB213PD Supported forms : (11 forms)
- VFMSUB213PD xmm, xmm, xmm [FMA3]
- VFMSUB213PD m128, xmm, xmm [FMA3]
- VFMSUB213PD ymm, ymm, ymm [FMA3]
- VFMSUB213PD m256, ymm, ymm [FMA3]
- VFMSUB213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUB213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB213PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUB213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUB213PS ¶
func (self *Program) VFMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB213PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUB213PS Supported forms : (11 forms)
- VFMSUB213PS xmm, xmm, xmm [FMA3]
- VFMSUB213PS m128, xmm, xmm [FMA3]
- VFMSUB213PS ymm, ymm, ymm [FMA3]
- VFMSUB213PS m256, ymm, ymm [FMA3]
- VFMSUB213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUB213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB213PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUB213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUB213SD ¶
func (self *Program) VFMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB213SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMSUB213SD Supported forms : (5 forms)
- VFMSUB213SD xmm, xmm, xmm [FMA3]
- VFMSUB213SD m64, xmm, xmm [FMA3]
- VFMSUB213SD m64, xmm, xmm{k}{z} [AVX512F]
- VFMSUB213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMSUB213SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMSUB213SS ¶
func (self *Program) VFMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB213SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMSUB213SS Supported forms : (5 forms)
- VFMSUB213SS xmm, xmm, xmm [FMA3]
- VFMSUB213SS m32, xmm, xmm [FMA3]
- VFMSUB213SS m32, xmm, xmm{k}{z} [AVX512F]
- VFMSUB213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMSUB213SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMSUB231PD ¶
func (self *Program) VFMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB231PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUB231PD Supported forms : (11 forms)
- VFMSUB231PD xmm, xmm, xmm [FMA3]
- VFMSUB231PD m128, xmm, xmm [FMA3]
- VFMSUB231PD ymm, ymm, ymm [FMA3]
- VFMSUB231PD m256, ymm, ymm [FMA3]
- VFMSUB231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUB231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB231PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUB231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUB231PS ¶
func (self *Program) VFMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB231PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUB231PS Supported forms : (11 forms)
- VFMSUB231PS xmm, xmm, xmm [FMA3]
- VFMSUB231PS m128, xmm, xmm [FMA3]
- VFMSUB231PS ymm, ymm, ymm [FMA3]
- VFMSUB231PS m256, ymm, ymm [FMA3]
- VFMSUB231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUB231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB231PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUB231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUB231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUB231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUB231SD ¶
func (self *Program) VFMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB231SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMSUB231SD Supported forms : (5 forms)
- VFMSUB231SD xmm, xmm, xmm [FMA3]
- VFMSUB231SD m64, xmm, xmm [FMA3]
- VFMSUB231SD m64, xmm, xmm{k}{z} [AVX512F]
- VFMSUB231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMSUB231SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMSUB231SS ¶
func (self *Program) VFMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUB231SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMSUB231SS Supported forms : (5 forms)
- VFMSUB231SS xmm, xmm, xmm [FMA3]
- VFMSUB231SS m32, xmm, xmm [FMA3]
- VFMSUB231SS m32, xmm, xmm{k}{z} [AVX512F]
- VFMSUB231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFMSUB231SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFMSUBADD132PD ¶
func (self *Program) VFMSUBADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUBADD132PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUBADD132PD Supported forms : (11 forms)
- VFMSUBADD132PD xmm, xmm, xmm [FMA3]
- VFMSUBADD132PD m128, xmm, xmm [FMA3]
- VFMSUBADD132PD ymm, ymm, ymm [FMA3]
- VFMSUBADD132PD m256, ymm, ymm [FMA3]
- VFMSUBADD132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD132PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUBADD132PS ¶
func (self *Program) VFMSUBADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUBADD132PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUBADD132PS Supported forms : (11 forms)
- VFMSUBADD132PS xmm, xmm, xmm [FMA3]
- VFMSUBADD132PS m128, xmm, xmm [FMA3]
- VFMSUBADD132PS ymm, ymm, ymm [FMA3]
- VFMSUBADD132PS m256, ymm, ymm [FMA3]
- VFMSUBADD132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD132PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUBADD213PD ¶
func (self *Program) VFMSUBADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUBADD213PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUBADD213PD Supported forms : (11 forms)
- VFMSUBADD213PD xmm, xmm, xmm [FMA3]
- VFMSUBADD213PD m128, xmm, xmm [FMA3]
- VFMSUBADD213PD ymm, ymm, ymm [FMA3]
- VFMSUBADD213PD m256, ymm, ymm [FMA3]
- VFMSUBADD213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD213PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUBADD213PS ¶
func (self *Program) VFMSUBADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUBADD213PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUBADD213PS Supported forms : (11 forms)
- VFMSUBADD213PS xmm, xmm, xmm [FMA3]
- VFMSUBADD213PS m128, xmm, xmm [FMA3]
- VFMSUBADD213PS ymm, ymm, ymm [FMA3]
- VFMSUBADD213PS m256, ymm, ymm [FMA3]
- VFMSUBADD213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD213PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUBADD231PD ¶
func (self *Program) VFMSUBADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUBADD231PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUBADD231PD Supported forms : (11 forms)
- VFMSUBADD231PD xmm, xmm, xmm [FMA3]
- VFMSUBADD231PD m128, xmm, xmm [FMA3]
- VFMSUBADD231PD ymm, ymm, ymm [FMA3]
- VFMSUBADD231PD m256, ymm, ymm [FMA3]
- VFMSUBADD231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD231PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUBADD231PS ¶
func (self *Program) VFMSUBADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFMSUBADD231PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUBADD231PS Supported forms : (11 forms)
- VFMSUBADD231PS xmm, xmm, xmm [FMA3]
- VFMSUBADD231PS m128, xmm, xmm [FMA3]
- VFMSUBADD231PS ymm, ymm, ymm [FMA3]
- VFMSUBADD231PS m256, ymm, ymm [FMA3]
- VFMSUBADD231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD231PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFMSUBADD231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFMSUBADD231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFMSUBADDPD ¶
func (self *Program) VFMSUBADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMSUBADDPD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUBADDPD Supported forms : (6 forms)
- VFMSUBADDPD xmm, xmm, xmm, xmm [FMA4]
- VFMSUBADDPD m128, xmm, xmm, xmm [FMA4]
- VFMSUBADDPD xmm, m128, xmm, xmm [FMA4]
- VFMSUBADDPD ymm, ymm, ymm, ymm [FMA4]
- VFMSUBADDPD m256, ymm, ymm, ymm [FMA4]
- VFMSUBADDPD ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMSUBADDPS ¶
func (self *Program) VFMSUBADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMSUBADDPS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUBADDPS Supported forms : (6 forms)
- VFMSUBADDPS xmm, xmm, xmm, xmm [FMA4]
- VFMSUBADDPS m128, xmm, xmm, xmm [FMA4]
- VFMSUBADDPS xmm, m128, xmm, xmm [FMA4]
- VFMSUBADDPS ymm, ymm, ymm, ymm [FMA4]
- VFMSUBADDPS m256, ymm, ymm, ymm [FMA4]
- VFMSUBADDPS ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMSUBPD ¶
func (self *Program) VFMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMSUBPD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFMSUBPD Supported forms : (6 forms)
- VFMSUBPD xmm, xmm, xmm, xmm [FMA4]
- VFMSUBPD m128, xmm, xmm, xmm [FMA4]
- VFMSUBPD xmm, m128, xmm, xmm [FMA4]
- VFMSUBPD ymm, ymm, ymm, ymm [FMA4]
- VFMSUBPD m256, ymm, ymm, ymm [FMA4]
- VFMSUBPD ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMSUBPS ¶
func (self *Program) VFMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMSUBPS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFMSUBPS Supported forms : (6 forms)
- VFMSUBPS xmm, xmm, xmm, xmm [FMA4]
- VFMSUBPS m128, xmm, xmm, xmm [FMA4]
- VFMSUBPS xmm, m128, xmm, xmm [FMA4]
- VFMSUBPS ymm, ymm, ymm, ymm [FMA4]
- VFMSUBPS m256, ymm, ymm, ymm [FMA4]
- VFMSUBPS ymm, m256, ymm, ymm [FMA4]
func (*Program) VFMSUBSD ¶
func (self *Program) VFMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMSUBSD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFMSUBSD Supported forms : (3 forms)
- VFMSUBSD xmm, xmm, xmm, xmm [FMA4]
- VFMSUBSD m64, xmm, xmm, xmm [FMA4]
- VFMSUBSD xmm, m64, xmm, xmm [FMA4]
func (*Program) VFMSUBSS ¶
func (self *Program) VFMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFMSUBSS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFMSUBSS Supported forms : (3 forms)
- VFMSUBSS xmm, xmm, xmm, xmm [FMA4]
- VFMSUBSS m32, xmm, xmm, xmm [FMA4]
- VFMSUBSS xmm, m32, xmm, xmm [FMA4]
func (*Program) VFNMADD132PD ¶
func (self *Program) VFNMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD132PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMADD132PD Supported forms : (11 forms)
- VFNMADD132PD xmm, xmm, xmm [FMA3]
- VFNMADD132PD m128, xmm, xmm [FMA3]
- VFNMADD132PD ymm, ymm, ymm [FMA3]
- VFNMADD132PD m256, ymm, ymm [FMA3]
- VFNMADD132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMADD132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD132PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMADD132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMADD132PS ¶
func (self *Program) VFNMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD132PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMADD132PS Supported forms : (11 forms)
- VFNMADD132PS xmm, xmm, xmm [FMA3]
- VFNMADD132PS m128, xmm, xmm [FMA3]
- VFNMADD132PS ymm, ymm, ymm [FMA3]
- VFNMADD132PS m256, ymm, ymm [FMA3]
- VFNMADD132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMADD132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD132PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMADD132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMADD132SD ¶
func (self *Program) VFNMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD132SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMADD132SD Supported forms : (5 forms)
- VFNMADD132SD xmm, xmm, xmm [FMA3]
- VFNMADD132SD m64, xmm, xmm [FMA3]
- VFNMADD132SD m64, xmm, xmm{k}{z} [AVX512F]
- VFNMADD132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMADD132SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMADD132SS ¶
func (self *Program) VFNMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD132SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMADD132SS Supported forms : (5 forms)
- VFNMADD132SS xmm, xmm, xmm [FMA3]
- VFNMADD132SS m32, xmm, xmm [FMA3]
- VFNMADD132SS m32, xmm, xmm{k}{z} [AVX512F]
- VFNMADD132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMADD132SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMADD213PD ¶
func (self *Program) VFNMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD213PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMADD213PD Supported forms : (11 forms)
- VFNMADD213PD xmm, xmm, xmm [FMA3]
- VFNMADD213PD m128, xmm, xmm [FMA3]
- VFNMADD213PD ymm, ymm, ymm [FMA3]
- VFNMADD213PD m256, ymm, ymm [FMA3]
- VFNMADD213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMADD213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD213PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMADD213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMADD213PS ¶
func (self *Program) VFNMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD213PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMADD213PS Supported forms : (11 forms)
- VFNMADD213PS xmm, xmm, xmm [FMA3]
- VFNMADD213PS m128, xmm, xmm [FMA3]
- VFNMADD213PS ymm, ymm, ymm [FMA3]
- VFNMADD213PS m256, ymm, ymm [FMA3]
- VFNMADD213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMADD213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD213PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMADD213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMADD213SD ¶
func (self *Program) VFNMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD213SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMADD213SD Supported forms : (5 forms)
- VFNMADD213SD xmm, xmm, xmm [FMA3]
- VFNMADD213SD m64, xmm, xmm [FMA3]
- VFNMADD213SD m64, xmm, xmm{k}{z} [AVX512F]
- VFNMADD213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMADD213SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMADD213SS ¶
func (self *Program) VFNMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD213SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMADD213SS Supported forms : (5 forms)
- VFNMADD213SS xmm, xmm, xmm [FMA3]
- VFNMADD213SS m32, xmm, xmm [FMA3]
- VFNMADD213SS m32, xmm, xmm{k}{z} [AVX512F]
- VFNMADD213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMADD213SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMADD231PD ¶
func (self *Program) VFNMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD231PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMADD231PD Supported forms : (11 forms)
- VFNMADD231PD xmm, xmm, xmm [FMA3]
- VFNMADD231PD m128, xmm, xmm [FMA3]
- VFNMADD231PD ymm, ymm, ymm [FMA3]
- VFNMADD231PD m256, ymm, ymm [FMA3]
- VFNMADD231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMADD231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD231PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMADD231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMADD231PS ¶
func (self *Program) VFNMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD231PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMADD231PS Supported forms : (11 forms)
- VFNMADD231PS xmm, xmm, xmm [FMA3]
- VFNMADD231PS m128, xmm, xmm [FMA3]
- VFNMADD231PS ymm, ymm, ymm [FMA3]
- VFNMADD231PS m256, ymm, ymm [FMA3]
- VFNMADD231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMADD231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD231PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMADD231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMADD231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMADD231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMADD231SD ¶
func (self *Program) VFNMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD231SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMADD231SD Supported forms : (5 forms)
- VFNMADD231SD xmm, xmm, xmm [FMA3]
- VFNMADD231SD m64, xmm, xmm [FMA3]
- VFNMADD231SD m64, xmm, xmm{k}{z} [AVX512F]
- VFNMADD231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMADD231SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMADD231SS ¶
func (self *Program) VFNMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMADD231SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMADD231SS Supported forms : (5 forms)
- VFNMADD231SS xmm, xmm, xmm [FMA3]
- VFNMADD231SS m32, xmm, xmm [FMA3]
- VFNMADD231SS m32, xmm, xmm{k}{z} [AVX512F]
- VFNMADD231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMADD231SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMADDPD ¶
func (self *Program) VFNMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMADDPD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMADDPD Supported forms : (6 forms)
- VFNMADDPD xmm, xmm, xmm, xmm [FMA4]
- VFNMADDPD m128, xmm, xmm, xmm [FMA4]
- VFNMADDPD xmm, m128, xmm, xmm [FMA4]
- VFNMADDPD ymm, ymm, ymm, ymm [FMA4]
- VFNMADDPD m256, ymm, ymm, ymm [FMA4]
- VFNMADDPD ymm, m256, ymm, ymm [FMA4]
func (*Program) VFNMADDPS ¶
func (self *Program) VFNMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMADDPS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMADDPS Supported forms : (6 forms)
- VFNMADDPS xmm, xmm, xmm, xmm [FMA4]
- VFNMADDPS m128, xmm, xmm, xmm [FMA4]
- VFNMADDPS xmm, m128, xmm, xmm [FMA4]
- VFNMADDPS ymm, ymm, ymm, ymm [FMA4]
- VFNMADDPS m256, ymm, ymm, ymm [FMA4]
- VFNMADDPS ymm, m256, ymm, ymm [FMA4]
func (*Program) VFNMADDSD ¶
func (self *Program) VFNMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMADDSD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMADDSD Supported forms : (3 forms)
- VFNMADDSD xmm, xmm, xmm, xmm [FMA4]
- VFNMADDSD m64, xmm, xmm, xmm [FMA4]
- VFNMADDSD xmm, m64, xmm, xmm [FMA4]
func (*Program) VFNMADDSS ¶
func (self *Program) VFNMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMADDSS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMADDSS Supported forms : (3 forms)
- VFNMADDSS xmm, xmm, xmm, xmm [FMA4]
- VFNMADDSS m32, xmm, xmm, xmm [FMA4]
- VFNMADDSS xmm, m32, xmm, xmm [FMA4]
func (*Program) VFNMSUB132PD ¶
func (self *Program) VFNMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB132PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMSUB132PD Supported forms : (11 forms)
- VFNMSUB132PD xmm, xmm, xmm [FMA3]
- VFNMSUB132PD m128, xmm, xmm [FMA3]
- VFNMSUB132PD ymm, ymm, ymm [FMA3]
- VFNMSUB132PD m256, ymm, ymm [FMA3]
- VFNMSUB132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB132PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMSUB132PS ¶
func (self *Program) VFNMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB132PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMSUB132PS Supported forms : (11 forms)
- VFNMSUB132PS xmm, xmm, xmm [FMA3]
- VFNMSUB132PS m128, xmm, xmm [FMA3]
- VFNMSUB132PS ymm, ymm, ymm [FMA3]
- VFNMSUB132PS m256, ymm, ymm [FMA3]
- VFNMSUB132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB132PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMSUB132SD ¶
func (self *Program) VFNMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB132SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMSUB132SD Supported forms : (5 forms)
- VFNMSUB132SD xmm, xmm, xmm [FMA3]
- VFNMSUB132SD m64, xmm, xmm [FMA3]
- VFNMSUB132SD m64, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB132SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMSUB132SS ¶
func (self *Program) VFNMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB132SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMSUB132SS Supported forms : (5 forms)
- VFNMSUB132SS xmm, xmm, xmm [FMA3]
- VFNMSUB132SS m32, xmm, xmm [FMA3]
- VFNMSUB132SS m32, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB132SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMSUB213PD ¶
func (self *Program) VFNMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB213PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMSUB213PD Supported forms : (11 forms)
- VFNMSUB213PD xmm, xmm, xmm [FMA3]
- VFNMSUB213PD m128, xmm, xmm [FMA3]
- VFNMSUB213PD ymm, ymm, ymm [FMA3]
- VFNMSUB213PD m256, ymm, ymm [FMA3]
- VFNMSUB213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB213PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMSUB213PS ¶
func (self *Program) VFNMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB213PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMSUB213PS Supported forms : (11 forms)
- VFNMSUB213PS xmm, xmm, xmm [FMA3]
- VFNMSUB213PS m128, xmm, xmm [FMA3]
- VFNMSUB213PS ymm, ymm, ymm [FMA3]
- VFNMSUB213PS m256, ymm, ymm [FMA3]
- VFNMSUB213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB213PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMSUB213SD ¶
func (self *Program) VFNMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB213SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMSUB213SD Supported forms : (5 forms)
- VFNMSUB213SD xmm, xmm, xmm [FMA3]
- VFNMSUB213SD m64, xmm, xmm [FMA3]
- VFNMSUB213SD m64, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB213SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMSUB213SS ¶
func (self *Program) VFNMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB213SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMSUB213SS Supported forms : (5 forms)
- VFNMSUB213SS xmm, xmm, xmm [FMA3]
- VFNMSUB213SS m32, xmm, xmm [FMA3]
- VFNMSUB213SS m32, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB213SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMSUB231PD ¶
func (self *Program) VFNMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB231PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMSUB231PD Supported forms : (11 forms)
- VFNMSUB231PD xmm, xmm, xmm [FMA3]
- VFNMSUB231PD m128, xmm, xmm [FMA3]
- VFNMSUB231PD ymm, ymm, ymm [FMA3]
- VFNMSUB231PD m256, ymm, ymm [FMA3]
- VFNMSUB231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB231PD zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMSUB231PS ¶
func (self *Program) VFNMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB231PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMSUB231PS Supported forms : (11 forms)
- VFNMSUB231PS xmm, xmm, xmm [FMA3]
- VFNMSUB231PS m128, xmm, xmm [FMA3]
- VFNMSUB231PS ymm, ymm, ymm [FMA3]
- VFNMSUB231PS m256, ymm, ymm [FMA3]
- VFNMSUB231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB231PS zmm, zmm, zmm{k}{z} [AVX512F]
- VFNMSUB231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VFNMSUB231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VFNMSUB231SD ¶
func (self *Program) VFNMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB231SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMSUB231SD Supported forms : (5 forms)
- VFNMSUB231SD xmm, xmm, xmm [FMA3]
- VFNMSUB231SD m64, xmm, xmm [FMA3]
- VFNMSUB231SD m64, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB231SD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMSUB231SS ¶
func (self *Program) VFNMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VFNMSUB231SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMSUB231SS Supported forms : (5 forms)
- VFNMSUB231SS xmm, xmm, xmm [FMA3]
- VFNMSUB231SS m32, xmm, xmm [FMA3]
- VFNMSUB231SS m32, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VFNMSUB231SS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VFNMSUBPD ¶
func (self *Program) VFNMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMSUBPD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".
Mnemonic : VFNMSUBPD Supported forms : (6 forms)
- VFNMSUBPD xmm, xmm, xmm, xmm [FMA4]
- VFNMSUBPD m128, xmm, xmm, xmm [FMA4]
- VFNMSUBPD xmm, m128, xmm, xmm [FMA4]
- VFNMSUBPD ymm, ymm, ymm, ymm [FMA4]
- VFNMSUBPD m256, ymm, ymm, ymm [FMA4]
- VFNMSUBPD ymm, m256, ymm, ymm [FMA4]
func (*Program) VFNMSUBPS ¶
func (self *Program) VFNMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMSUBPS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".
Mnemonic : VFNMSUBPS Supported forms : (6 forms)
- VFNMSUBPS xmm, xmm, xmm, xmm [FMA4]
- VFNMSUBPS m128, xmm, xmm, xmm [FMA4]
- VFNMSUBPS xmm, m128, xmm, xmm [FMA4]
- VFNMSUBPS ymm, ymm, ymm, ymm [FMA4]
- VFNMSUBPS m256, ymm, ymm, ymm [FMA4]
- VFNMSUBPS ymm, m256, ymm, ymm [FMA4]
func (*Program) VFNMSUBSD ¶
func (self *Program) VFNMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMSUBSD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".
Mnemonic : VFNMSUBSD Supported forms : (3 forms)
- VFNMSUBSD xmm, xmm, xmm, xmm [FMA4]
- VFNMSUBSD m64, xmm, xmm, xmm [FMA4]
- VFNMSUBSD xmm, m64, xmm, xmm [FMA4]
func (*Program) VFNMSUBSS ¶
func (self *Program) VFNMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VFNMSUBSS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".
Mnemonic : VFNMSUBSS Supported forms : (3 forms)
- VFNMSUBSS xmm, xmm, xmm, xmm [FMA4]
- VFNMSUBSS m32, xmm, xmm, xmm [FMA4]
- VFNMSUBSS xmm, m32, xmm, xmm [FMA4]
func (*Program) VFPCLASSPD ¶
func (self *Program) VFPCLASSPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VFPCLASSPD performs "Test Class of Packed Double-Precision Floating-Point Values".
Mnemonic : VFPCLASSPD Supported forms : (6 forms)
- VFPCLASSPD imm8, m512/m64bcst, k{k} [AVX512DQ]
- VFPCLASSPD imm8, zmm, k{k} [AVX512DQ]
- VFPCLASSPD imm8, m128/m64bcst, k{k} [AVX512DQ,AVX512VL]
- VFPCLASSPD imm8, m256/m64bcst, k{k} [AVX512DQ,AVX512VL]
- VFPCLASSPD imm8, xmm, k{k} [AVX512DQ,AVX512VL]
- VFPCLASSPD imm8, ymm, k{k} [AVX512DQ,AVX512VL]
func (*Program) VFPCLASSPS ¶
func (self *Program) VFPCLASSPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VFPCLASSPS performs "Test Class of Packed Single-Precision Floating-Point Values".
Mnemonic : VFPCLASSPS Supported forms : (6 forms)
- VFPCLASSPS imm8, m512/m32bcst, k{k} [AVX512DQ]
- VFPCLASSPS imm8, zmm, k{k} [AVX512DQ]
- VFPCLASSPS imm8, m128/m32bcst, k{k} [AVX512DQ,AVX512VL]
- VFPCLASSPS imm8, m256/m32bcst, k{k} [AVX512DQ,AVX512VL]
- VFPCLASSPS imm8, xmm, k{k} [AVX512DQ,AVX512VL]
- VFPCLASSPS imm8, ymm, k{k} [AVX512DQ,AVX512VL]
func (*Program) VFPCLASSSD ¶
func (self *Program) VFPCLASSSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VFPCLASSSD performs "Test Class of Scalar Double-Precision Floating-Point Value".
Mnemonic : VFPCLASSSD Supported forms : (2 forms)
- VFPCLASSSD imm8, xmm, k{k} [AVX512DQ]
- VFPCLASSSD imm8, m64, k{k} [AVX512DQ]
func (*Program) VFPCLASSSS ¶
func (self *Program) VFPCLASSSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VFPCLASSSS performs "Test Class of Scalar Single-Precision Floating-Point Value".
Mnemonic : VFPCLASSSS Supported forms : (2 forms)
- VFPCLASSSS imm8, xmm, k{k} [AVX512DQ]
- VFPCLASSSS imm8, m32, k{k} [AVX512DQ]
func (*Program) VFRCZPD ¶
func (self *Program) VFRCZPD(v0 interface{}, v1 interface{}) *Instruction
VFRCZPD performs "Extract Fraction Packed Double-Precision Floating-Point".
Mnemonic : VFRCZPD Supported forms : (4 forms)
- VFRCZPD xmm, xmm [XOP]
- VFRCZPD m128, xmm [XOP]
- VFRCZPD ymm, ymm [XOP]
- VFRCZPD m256, ymm [XOP]
func (*Program) VFRCZPS ¶
func (self *Program) VFRCZPS(v0 interface{}, v1 interface{}) *Instruction
VFRCZPS performs "Extract Fraction Packed Single-Precision Floating-Point".
Mnemonic : VFRCZPS Supported forms : (4 forms)
- VFRCZPS xmm, xmm [XOP]
- VFRCZPS m128, xmm [XOP]
- VFRCZPS ymm, ymm [XOP]
- VFRCZPS m256, ymm [XOP]
func (*Program) VFRCZSD ¶
func (self *Program) VFRCZSD(v0 interface{}, v1 interface{}) *Instruction
VFRCZSD performs "Extract Fraction Scalar Double-Precision Floating-Point".
Mnemonic : VFRCZSD Supported forms : (2 forms)
- VFRCZSD xmm, xmm [XOP]
- VFRCZSD m64, xmm [XOP]
func (*Program) VFRCZSS ¶
func (self *Program) VFRCZSS(v0 interface{}, v1 interface{}) *Instruction
VFRCZSS performs "Extract Fraction Scalar Single-Precision Floating Point".
Mnemonic : VFRCZSS Supported forms : (2 forms)
- VFRCZSS xmm, xmm [XOP]
- VFRCZSS m32, xmm [XOP]
func (*Program) VGATHERDPD ¶
func (self *Program) VGATHERDPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VGATHERDPD performs "Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices".
Mnemonic : VGATHERDPD Supported forms : (5 forms)
- VGATHERDPD xmm, vm32x, xmm [AVX2]
- VGATHERDPD ymm, vm32x, ymm [AVX2]
- VGATHERDPD vm32y, zmm{k} [AVX512F]
- VGATHERDPD vm32x, xmm{k} [AVX512F,AVX512VL]
- VGATHERDPD vm32x, ymm{k} [AVX512F,AVX512VL]
func (*Program) VGATHERDPS ¶
func (self *Program) VGATHERDPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VGATHERDPS performs "Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices".
Mnemonic : VGATHERDPS Supported forms : (5 forms)
- VGATHERDPS xmm, vm32x, xmm [AVX2]
- VGATHERDPS ymm, vm32y, ymm [AVX2]
- VGATHERDPS vm32z, zmm{k} [AVX512F]
- VGATHERDPS vm32x, xmm{k} [AVX512F,AVX512VL]
- VGATHERDPS vm32y, ymm{k} [AVX512F,AVX512VL]
func (*Program) VGATHERPF0DPD ¶
func (self *Program) VGATHERPF0DPD(v0 interface{}) *Instruction
VGATHERPF0DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint".
Mnemonic : VGATHERPF0DPD Supported forms : (1 form)
- VGATHERPF0DPD vm32y{k} [AVX512PF]
func (*Program) VGATHERPF0DPS ¶
func (self *Program) VGATHERPF0DPS(v0 interface{}) *Instruction
VGATHERPF0DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint".
Mnemonic : VGATHERPF0DPS Supported forms : (1 form)
- VGATHERPF0DPS vm32z{k} [AVX512PF]
func (*Program) VGATHERPF0QPD ¶
func (self *Program) VGATHERPF0QPD(v0 interface{}) *Instruction
VGATHERPF0QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint".
Mnemonic : VGATHERPF0QPD Supported forms : (1 form)
- VGATHERPF0QPD vm64z{k} [AVX512PF]
func (*Program) VGATHERPF0QPS ¶
func (self *Program) VGATHERPF0QPS(v0 interface{}) *Instruction
VGATHERPF0QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint".
Mnemonic : VGATHERPF0QPS Supported forms : (1 form)
- VGATHERPF0QPS vm64z{k} [AVX512PF]
func (*Program) VGATHERPF1DPD ¶
func (self *Program) VGATHERPF1DPD(v0 interface{}) *Instruction
VGATHERPF1DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint".
Mnemonic : VGATHERPF1DPD Supported forms : (1 form)
- VGATHERPF1DPD vm32y{k} [AVX512PF]
func (*Program) VGATHERPF1DPS ¶
func (self *Program) VGATHERPF1DPS(v0 interface{}) *Instruction
VGATHERPF1DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint".
Mnemonic : VGATHERPF1DPS Supported forms : (1 form)
- VGATHERPF1DPS vm32z{k} [AVX512PF]
func (*Program) VGATHERPF1QPD ¶
func (self *Program) VGATHERPF1QPD(v0 interface{}) *Instruction
VGATHERPF1QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint".
Mnemonic : VGATHERPF1QPD Supported forms : (1 form)
- VGATHERPF1QPD vm64z{k} [AVX512PF]
func (*Program) VGATHERPF1QPS ¶
func (self *Program) VGATHERPF1QPS(v0 interface{}) *Instruction
VGATHERPF1QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint".
Mnemonic : VGATHERPF1QPS Supported forms : (1 form)
- VGATHERPF1QPS vm64z{k} [AVX512PF]
func (*Program) VGATHERQPD ¶
func (self *Program) VGATHERQPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VGATHERQPD performs "Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices".
Mnemonic : VGATHERQPD Supported forms : (5 forms)
- VGATHERQPD xmm, vm64x, xmm [AVX2]
- VGATHERQPD ymm, vm64y, ymm [AVX2]
- VGATHERQPD vm64z, zmm{k} [AVX512F]
- VGATHERQPD vm64x, xmm{k} [AVX512F,AVX512VL]
- VGATHERQPD vm64y, ymm{k} [AVX512F,AVX512VL]
func (*Program) VGATHERQPS ¶
func (self *Program) VGATHERQPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VGATHERQPS performs "Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices".
Mnemonic : VGATHERQPS Supported forms : (5 forms)
- VGATHERQPS xmm, vm64x, xmm [AVX2]
- VGATHERQPS xmm, vm64y, xmm [AVX2]
- VGATHERQPS vm64z, ymm{k} [AVX512F]
- VGATHERQPS vm64x, xmm{k} [AVX512F,AVX512VL]
- VGATHERQPS vm64y, xmm{k} [AVX512F,AVX512VL]
func (*Program) VGETEXPPD ¶
func (self *Program) VGETEXPPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VGETEXPPD performs "Extract Exponents of Packed Double-Precision Floating-Point Values as Double-Precision Floating-Point Values".
Mnemonic : VGETEXPPD Supported forms : (7 forms)
- VGETEXPPD m512/m64bcst, zmm{k}{z} [AVX512F]
- VGETEXPPD {sae}, zmm, zmm{k}{z} [AVX512F]
- VGETEXPPD zmm, zmm{k}{z} [AVX512F]
- VGETEXPPD m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VGETEXPPD m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VGETEXPPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VGETEXPPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VGETEXPPS ¶
func (self *Program) VGETEXPPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VGETEXPPS performs "Extract Exponents of Packed Single-Precision Floating-Point Values as Single-Precision Floating-Point Values".
Mnemonic : VGETEXPPS Supported forms : (7 forms)
- VGETEXPPS m512/m32bcst, zmm{k}{z} [AVX512F]
- VGETEXPPS {sae}, zmm, zmm{k}{z} [AVX512F]
- VGETEXPPS zmm, zmm{k}{z} [AVX512F]
- VGETEXPPS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VGETEXPPS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VGETEXPPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VGETEXPPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VGETEXPSD ¶
func (self *Program) VGETEXPSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VGETEXPSD performs "Extract Exponent of Scalar Double-Precision Floating-Point Value as Double-Precision Floating-Point Value".
Mnemonic : VGETEXPSD Supported forms : (3 forms)
- VGETEXPSD m64, xmm, xmm{k}{z} [AVX512F]
- VGETEXPSD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VGETEXPSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VGETEXPSS ¶
func (self *Program) VGETEXPSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VGETEXPSS performs "Extract Exponent of Scalar Single-Precision Floating-Point Value as Single-Precision Floating-Point Value".
Mnemonic : VGETEXPSS Supported forms : (3 forms)
- VGETEXPSS m32, xmm, xmm{k}{z} [AVX512F]
- VGETEXPSS {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VGETEXPSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VGETMANTPD ¶
func (self *Program) VGETMANTPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VGETMANTPD performs "Extract Normalized Mantissas from Packed Double-Precision Floating-Point Values".
Mnemonic : VGETMANTPD Supported forms : (7 forms)
- VGETMANTPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VGETMANTPD imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
- VGETMANTPD imm8, zmm, zmm{k}{z} [AVX512F]
- VGETMANTPD imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VGETMANTPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VGETMANTPD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VGETMANTPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VGETMANTPS ¶
func (self *Program) VGETMANTPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VGETMANTPS performs "Extract Normalized Mantissas from Packed Single-Precision Floating-Point Values".
Mnemonic : VGETMANTPS Supported forms : (7 forms)
- VGETMANTPS imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VGETMANTPS imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
- VGETMANTPS imm8, zmm, zmm{k}{z} [AVX512F]
- VGETMANTPS imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VGETMANTPS imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VGETMANTPS imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VGETMANTPS imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VGETMANTSD ¶
func (self *Program) VGETMANTSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VGETMANTSD performs "Extract Normalized Mantissa from Scalar Double-Precision Floating-Point Value".
Mnemonic : VGETMANTSD Supported forms : (3 forms)
- VGETMANTSD imm8, m64, xmm, xmm{k}{z} [AVX512F]
- VGETMANTSD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VGETMANTSD imm8, xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VGETMANTSS ¶
func (self *Program) VGETMANTSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VGETMANTSS performs "Extract Normalized Mantissa from Scalar Single-Precision Floating-Point Value".
Mnemonic : VGETMANTSS Supported forms : (3 forms)
- VGETMANTSS imm8, m32, xmm, xmm{k}{z} [AVX512F]
- VGETMANTSS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VGETMANTSS imm8, xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VHADDPD ¶
func (self *Program) VHADDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VHADDPD performs "Packed Double-FP Horizontal Add".
Mnemonic : VHADDPD Supported forms : (4 forms)
- VHADDPD xmm, xmm, xmm [AVX]
- VHADDPD m128, xmm, xmm [AVX]
- VHADDPD ymm, ymm, ymm [AVX]
- VHADDPD m256, ymm, ymm [AVX]
func (*Program) VHADDPS ¶
func (self *Program) VHADDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VHADDPS performs "Packed Single-FP Horizontal Add".
Mnemonic : VHADDPS Supported forms : (4 forms)
- VHADDPS xmm, xmm, xmm [AVX]
- VHADDPS m128, xmm, xmm [AVX]
- VHADDPS ymm, ymm, ymm [AVX]
- VHADDPS m256, ymm, ymm [AVX]
func (*Program) VHSUBPD ¶
func (self *Program) VHSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VHSUBPD performs "Packed Double-FP Horizontal Subtract".
Mnemonic : VHSUBPD Supported forms : (4 forms)
- VHSUBPD xmm, xmm, xmm [AVX]
- VHSUBPD m128, xmm, xmm [AVX]
- VHSUBPD ymm, ymm, ymm [AVX]
- VHSUBPD m256, ymm, ymm [AVX]
func (*Program) VHSUBPS ¶
func (self *Program) VHSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VHSUBPS performs "Packed Single-FP Horizontal Subtract".
Mnemonic : VHSUBPS Supported forms : (4 forms)
- VHSUBPS xmm, xmm, xmm [AVX]
- VHSUBPS m128, xmm, xmm [AVX]
- VHSUBPS ymm, ymm, ymm [AVX]
- VHSUBPS m256, ymm, ymm [AVX]
func (*Program) VINSERTF128 ¶
func (self *Program) VINSERTF128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTF128 performs "Insert Packed Floating-Point Values".
Mnemonic : VINSERTF128 Supported forms : (2 forms)
- VINSERTF128 imm8, xmm, ymm, ymm [AVX]
- VINSERTF128 imm8, m128, ymm, ymm [AVX]
func (*Program) VINSERTF32X4 ¶
func (self *Program) VINSERTF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTF32X4 performs "Insert 128 Bits of Packed Single-Precision Floating-Point Values".
Mnemonic : VINSERTF32X4 Supported forms : (4 forms)
- VINSERTF32X4 imm8, xmm, zmm, zmm{k}{z} [AVX512F]
- VINSERTF32X4 imm8, m128, zmm, zmm{k}{z} [AVX512F]
- VINSERTF32X4 imm8, xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VINSERTF32X4 imm8, m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VINSERTF32X8 ¶
func (self *Program) VINSERTF32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTF32X8 performs "Insert 256 Bits of Packed Single-Precision Floating-Point Values".
Mnemonic : VINSERTF32X8 Supported forms : (2 forms)
- VINSERTF32X8 imm8, ymm, zmm, zmm{k}{z} [AVX512DQ]
- VINSERTF32X8 imm8, m256, zmm, zmm{k}{z} [AVX512DQ]
func (*Program) VINSERTF64X2 ¶
func (self *Program) VINSERTF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTF64X2 performs "Insert 128 Bits of Packed Double-Precision Floating-Point Values".
Mnemonic : VINSERTF64X2 Supported forms : (4 forms)
- VINSERTF64X2 imm8, xmm, zmm, zmm{k}{z} [AVX512DQ]
- VINSERTF64X2 imm8, m128, zmm, zmm{k}{z} [AVX512DQ]
- VINSERTF64X2 imm8, xmm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VINSERTF64X2 imm8, m128, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VINSERTF64X4 ¶
func (self *Program) VINSERTF64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTF64X4 performs "Insert 256 Bits of Packed Double-Precision Floating-Point Values".
Mnemonic : VINSERTF64X4 Supported forms : (2 forms)
- VINSERTF64X4 imm8, ymm, zmm, zmm{k}{z} [AVX512F]
- VINSERTF64X4 imm8, m256, zmm, zmm{k}{z} [AVX512F]
func (*Program) VINSERTI128 ¶
func (self *Program) VINSERTI128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTI128 performs "Insert Packed Integer Values".
Mnemonic : VINSERTI128 Supported forms : (2 forms)
- VINSERTI128 imm8, xmm, ymm, ymm [AVX2]
- VINSERTI128 imm8, m128, ymm, ymm [AVX2]
func (*Program) VINSERTI32X4 ¶
func (self *Program) VINSERTI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTI32X4 performs "Insert 128 Bits of Packed Doubleword Integer Values".
Mnemonic : VINSERTI32X4 Supported forms : (4 forms)
- VINSERTI32X4 imm8, xmm, zmm, zmm{k}{z} [AVX512F]
- VINSERTI32X4 imm8, m128, zmm, zmm{k}{z} [AVX512F]
- VINSERTI32X4 imm8, xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VINSERTI32X4 imm8, m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VINSERTI32X8 ¶
func (self *Program) VINSERTI32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTI32X8 performs "Insert 256 Bits of Packed Doubleword Integer Values".
Mnemonic : VINSERTI32X8 Supported forms : (2 forms)
- VINSERTI32X8 imm8, ymm, zmm, zmm{k}{z} [AVX512DQ]
- VINSERTI32X8 imm8, m256, zmm, zmm{k}{z} [AVX512DQ]
func (*Program) VINSERTI64X2 ¶
func (self *Program) VINSERTI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTI64X2 performs "Insert 128 Bits of Packed Quadword Integer Values".
Mnemonic : VINSERTI64X2 Supported forms : (4 forms)
- VINSERTI64X2 imm8, xmm, zmm, zmm{k}{z} [AVX512DQ]
- VINSERTI64X2 imm8, m128, zmm, zmm{k}{z} [AVX512DQ]
- VINSERTI64X2 imm8, xmm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VINSERTI64X2 imm8, m128, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VINSERTI64X4 ¶
func (self *Program) VINSERTI64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTI64X4 performs "Insert 256 Bits of Packed Quadword Integer Values".
Mnemonic : VINSERTI64X4 Supported forms : (2 forms)
- VINSERTI64X4 imm8, ymm, zmm, zmm{k}{z} [AVX512F]
- VINSERTI64X4 imm8, m256, zmm, zmm{k}{z} [AVX512F]
func (*Program) VINSERTPS ¶
func (self *Program) VINSERTPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VINSERTPS performs "Insert Packed Single Precision Floating-Point Value".
Mnemonic : VINSERTPS Supported forms : (4 forms)
- VINSERTPS imm8, xmm, xmm, xmm [AVX]
- VINSERTPS imm8, m32, xmm, xmm [AVX]
- VINSERTPS imm8, xmm, xmm, xmm [AVX512F]
- VINSERTPS imm8, m32, xmm, xmm [AVX512F]
func (*Program) VLDDQU ¶
func (self *Program) VLDDQU(v0 interface{}, v1 interface{}) *Instruction
VLDDQU performs "Load Unaligned Integer 128 Bits".
Mnemonic : VLDDQU Supported forms : (2 forms)
- VLDDQU m128, xmm [AVX]
- VLDDQU m256, ymm [AVX]
func (*Program) VLDMXCSR ¶
func (self *Program) VLDMXCSR(v0 interface{}) *Instruction
VLDMXCSR performs "Load MXCSR Register".
Mnemonic : VLDMXCSR Supported forms : (1 form)
- VLDMXCSR m32 [AVX]
func (*Program) VMASKMOVDQU ¶
func (self *Program) VMASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction
VMASKMOVDQU performs "Store Selected Bytes of Double Quadword".
Mnemonic : VMASKMOVDQU Supported forms : (1 form)
- VMASKMOVDQU xmm, xmm [AVX]
func (*Program) VMASKMOVPD ¶
func (self *Program) VMASKMOVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VMASKMOVPD performs "Conditional Move Packed Double-Precision Floating-Point Values".
Mnemonic : VMASKMOVPD Supported forms : (4 forms)
- VMASKMOVPD m128, xmm, xmm [AVX]
- VMASKMOVPD m256, ymm, ymm [AVX]
- VMASKMOVPD xmm, xmm, m128 [AVX]
- VMASKMOVPD ymm, ymm, m256 [AVX]
func (*Program) VMASKMOVPS ¶
func (self *Program) VMASKMOVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VMASKMOVPS performs "Conditional Move Packed Single-Precision Floating-Point Values".
Mnemonic : VMASKMOVPS Supported forms : (4 forms)
- VMASKMOVPS m128, xmm, xmm [AVX]
- VMASKMOVPS m256, ymm, ymm [AVX]
- VMASKMOVPS xmm, xmm, m128 [AVX]
- VMASKMOVPS ymm, ymm, m256 [AVX]
func (*Program) VMAXPD ¶
func (self *Program) VMAXPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMAXPD performs "Return Maximum Packed Double-Precision Floating-Point Values".
Mnemonic : VMAXPD Supported forms : (11 forms)
- VMAXPD xmm, xmm, xmm [AVX]
- VMAXPD m128, xmm, xmm [AVX]
- VMAXPD ymm, ymm, ymm [AVX]
- VMAXPD m256, ymm, ymm [AVX]
- VMAXPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VMAXPD {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
- VMAXPD zmm, zmm, zmm{k}{z} [AVX512F]
- VMAXPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMAXPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMAXPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMAXPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMAXPS ¶
func (self *Program) VMAXPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMAXPS performs "Return Maximum Packed Single-Precision Floating-Point Values".
Mnemonic : VMAXPS Supported forms : (11 forms)
- VMAXPS xmm, xmm, xmm [AVX]
- VMAXPS m128, xmm, xmm [AVX]
- VMAXPS ymm, ymm, ymm [AVX]
- VMAXPS m256, ymm, ymm [AVX]
- VMAXPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VMAXPS {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
- VMAXPS zmm, zmm, zmm{k}{z} [AVX512F]
- VMAXPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMAXPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMAXPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMAXPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMAXSD ¶
func (self *Program) VMAXSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMAXSD performs "Return Maximum Scalar Double-Precision Floating-Point Value".
Mnemonic : VMAXSD Supported forms : (5 forms)
- VMAXSD xmm, xmm, xmm [AVX]
- VMAXSD m64, xmm, xmm [AVX]
- VMAXSD m64, xmm, xmm{k}{z} [AVX512F]
- VMAXSD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VMAXSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMAXSS ¶
func (self *Program) VMAXSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMAXSS performs "Return Maximum Scalar Single-Precision Floating-Point Value".
Mnemonic : VMAXSS Supported forms : (5 forms)
- VMAXSS xmm, xmm, xmm [AVX]
- VMAXSS m32, xmm, xmm [AVX]
- VMAXSS m32, xmm, xmm{k}{z} [AVX512F]
- VMAXSS {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VMAXSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMINPD ¶
func (self *Program) VMINPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMINPD performs "Return Minimum Packed Double-Precision Floating-Point Values".
Mnemonic : VMINPD Supported forms : (11 forms)
- VMINPD xmm, xmm, xmm [AVX]
- VMINPD m128, xmm, xmm [AVX]
- VMINPD ymm, ymm, ymm [AVX]
- VMINPD m256, ymm, ymm [AVX]
- VMINPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VMINPD {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
- VMINPD zmm, zmm, zmm{k}{z} [AVX512F]
- VMINPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMINPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMINPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMINPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMINPS ¶
func (self *Program) VMINPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMINPS performs "Return Minimum Packed Single-Precision Floating-Point Values".
Mnemonic : VMINPS Supported forms : (11 forms)
- VMINPS xmm, xmm, xmm [AVX]
- VMINPS m128, xmm, xmm [AVX]
- VMINPS ymm, ymm, ymm [AVX]
- VMINPS m256, ymm, ymm [AVX]
- VMINPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VMINPS {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
- VMINPS zmm, zmm, zmm{k}{z} [AVX512F]
- VMINPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMINPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMINPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMINPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMINSD ¶
func (self *Program) VMINSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMINSD performs "Return Minimum Scalar Double-Precision Floating-Point Value".
Mnemonic : VMINSD Supported forms : (5 forms)
- VMINSD xmm, xmm, xmm [AVX]
- VMINSD m64, xmm, xmm [AVX]
- VMINSD m64, xmm, xmm{k}{z} [AVX512F]
- VMINSD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VMINSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMINSS ¶
func (self *Program) VMINSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMINSS performs "Return Minimum Scalar Single-Precision Floating-Point Value".
Mnemonic : VMINSS Supported forms : (5 forms)
- VMINSS xmm, xmm, xmm [AVX]
- VMINSS m32, xmm, xmm [AVX]
- VMINSS m32, xmm, xmm{k}{z} [AVX512F]
- VMINSS {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VMINSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMOVAPD ¶
func (self *Program) VMOVAPD(v0 interface{}, v1 interface{}) *Instruction
VMOVAPD performs "Move Aligned Packed Double-Precision Floating-Point Values".
Mnemonic : VMOVAPD Supported forms : (15 forms)
- VMOVAPD xmm, xmm [AVX]
- VMOVAPD m128, xmm [AVX]
- VMOVAPD ymm, ymm [AVX]
- VMOVAPD m256, ymm [AVX]
- VMOVAPD xmm, m128 [AVX]
- VMOVAPD ymm, m256 [AVX]
- VMOVAPD zmm, m512{k}{z} [AVX512F]
- VMOVAPD zmm, zmm{k}{z} [AVX512F]
- VMOVAPD m512, zmm{k}{z} [AVX512F]
- VMOVAPD xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVAPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVAPD ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVAPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVAPD m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVAPD m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVAPS ¶
func (self *Program) VMOVAPS(v0 interface{}, v1 interface{}) *Instruction
VMOVAPS performs "Move Aligned Packed Single-Precision Floating-Point Values".
Mnemonic : VMOVAPS Supported forms : (15 forms)
- VMOVAPS xmm, xmm [AVX]
- VMOVAPS m128, xmm [AVX]
- VMOVAPS ymm, ymm [AVX]
- VMOVAPS m256, ymm [AVX]
- VMOVAPS xmm, m128 [AVX]
- VMOVAPS ymm, m256 [AVX]
- VMOVAPS zmm, m512{k}{z} [AVX512F]
- VMOVAPS zmm, zmm{k}{z} [AVX512F]
- VMOVAPS m512, zmm{k}{z} [AVX512F]
- VMOVAPS xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVAPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVAPS ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVAPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVAPS m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVAPS m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVD ¶
func (self *Program) VMOVD(v0 interface{}, v1 interface{}) *Instruction
VMOVD performs "Move Doubleword".
Mnemonic : VMOVD Supported forms : (8 forms)
- VMOVD xmm, r32 [AVX]
- VMOVD r32, xmm [AVX]
- VMOVD m32, xmm [AVX]
- VMOVD xmm, m32 [AVX]
- VMOVD xmm, r32 [AVX512F]
- VMOVD r32, xmm [AVX512F]
- VMOVD m32, xmm [AVX512F]
- VMOVD xmm, m32 [AVX512F]
func (*Program) VMOVDDUP ¶
func (self *Program) VMOVDDUP(v0 interface{}, v1 interface{}) *Instruction
VMOVDDUP performs "Move One Double-FP and Duplicate".
Mnemonic : VMOVDDUP Supported forms : (10 forms)
- VMOVDDUP xmm, xmm [AVX]
- VMOVDDUP m64, xmm [AVX]
- VMOVDDUP ymm, ymm [AVX]
- VMOVDDUP m256, ymm [AVX]
- VMOVDDUP zmm, zmm{k}{z} [AVX512F]
- VMOVDDUP m512, zmm{k}{z} [AVX512F]
- VMOVDDUP xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDDUP ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVDDUP m64, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDDUP m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVDQA ¶
func (self *Program) VMOVDQA(v0 interface{}, v1 interface{}) *Instruction
VMOVDQA performs "Move Aligned Double Quadword".
Mnemonic : VMOVDQA Supported forms : (6 forms)
- VMOVDQA xmm, xmm [AVX]
- VMOVDQA m128, xmm [AVX]
- VMOVDQA ymm, ymm [AVX]
- VMOVDQA m256, ymm [AVX]
- VMOVDQA xmm, m128 [AVX]
- VMOVDQA ymm, m256 [AVX]
func (*Program) VMOVDQA32 ¶
func (self *Program) VMOVDQA32(v0 interface{}, v1 interface{}) *Instruction
VMOVDQA32 performs "Move Aligned Doubleword Values".
Mnemonic : VMOVDQA32 Supported forms : (9 forms)
- VMOVDQA32 zmm, m512{k}{z} [AVX512F]
- VMOVDQA32 zmm, zmm{k}{z} [AVX512F]
- VMOVDQA32 m512, zmm{k}{z} [AVX512F]
- VMOVDQA32 xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVDQA32 xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQA32 ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVDQA32 ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVDQA32 m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQA32 m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVDQA64 ¶
func (self *Program) VMOVDQA64(v0 interface{}, v1 interface{}) *Instruction
VMOVDQA64 performs "Move Aligned Quadword Values".
Mnemonic : VMOVDQA64 Supported forms : (9 forms)
- VMOVDQA64 zmm, m512{k}{z} [AVX512F]
- VMOVDQA64 zmm, zmm{k}{z} [AVX512F]
- VMOVDQA64 m512, zmm{k}{z} [AVX512F]
- VMOVDQA64 xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVDQA64 xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQA64 ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVDQA64 ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVDQA64 m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQA64 m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVDQU ¶
func (self *Program) VMOVDQU(v0 interface{}, v1 interface{}) *Instruction
VMOVDQU performs "Move Unaligned Double Quadword".
Mnemonic : VMOVDQU Supported forms : (6 forms)
- VMOVDQU xmm, xmm [AVX]
- VMOVDQU m128, xmm [AVX]
- VMOVDQU ymm, ymm [AVX]
- VMOVDQU m256, ymm [AVX]
- VMOVDQU xmm, m128 [AVX]
- VMOVDQU ymm, m256 [AVX]
func (*Program) VMOVDQU16 ¶
func (self *Program) VMOVDQU16(v0 interface{}, v1 interface{}) *Instruction
VMOVDQU16 performs "Move Unaligned Word Values".
Mnemonic : VMOVDQU16 Supported forms : (9 forms)
- VMOVDQU16 zmm, m512{k}{z} [AVX512BW]
- VMOVDQU16 zmm, zmm{k}{z} [AVX512BW]
- VMOVDQU16 m512, zmm{k}{z} [AVX512BW]
- VMOVDQU16 xmm, m128{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU16 xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU16 ymm, m256{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU16 ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU16 m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU16 m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VMOVDQU32 ¶
func (self *Program) VMOVDQU32(v0 interface{}, v1 interface{}) *Instruction
VMOVDQU32 performs "Move Unaligned Doubleword Values".
Mnemonic : VMOVDQU32 Supported forms : (9 forms)
- VMOVDQU32 zmm, m512{k}{z} [AVX512F]
- VMOVDQU32 zmm, zmm{k}{z} [AVX512F]
- VMOVDQU32 m512, zmm{k}{z} [AVX512F]
- VMOVDQU32 xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVDQU32 xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQU32 ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVDQU32 ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVDQU32 m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQU32 m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVDQU64 ¶
func (self *Program) VMOVDQU64(v0 interface{}, v1 interface{}) *Instruction
VMOVDQU64 performs "Move Unaligned Quadword Values".
Mnemonic : VMOVDQU64 Supported forms : (9 forms)
- VMOVDQU64 zmm, m512{k}{z} [AVX512F]
- VMOVDQU64 zmm, zmm{k}{z} [AVX512F]
- VMOVDQU64 m512, zmm{k}{z} [AVX512F]
- VMOVDQU64 xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVDQU64 xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQU64 ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVDQU64 ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVDQU64 m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVDQU64 m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVDQU8 ¶
func (self *Program) VMOVDQU8(v0 interface{}, v1 interface{}) *Instruction
VMOVDQU8 performs "Move Unaligned Byte Values".
Mnemonic : VMOVDQU8 Supported forms : (9 forms)
- VMOVDQU8 zmm, m512{k}{z} [AVX512BW]
- VMOVDQU8 zmm, zmm{k}{z} [AVX512BW]
- VMOVDQU8 m512, zmm{k}{z} [AVX512BW]
- VMOVDQU8 xmm, m128{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU8 xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU8 ymm, m256{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU8 ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU8 m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VMOVDQU8 m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VMOVHLPS ¶
func (self *Program) VMOVHLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VMOVHLPS performs "Move Packed Single-Precision Floating-Point Values High to Low".
Mnemonic : VMOVHLPS Supported forms : (2 forms)
- VMOVHLPS xmm, xmm, xmm [AVX]
- VMOVHLPS xmm, xmm, xmm [AVX512F]
func (*Program) VMOVHPD ¶
func (self *Program) VMOVHPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VMOVHPD performs "Move High Packed Double-Precision Floating-Point Value".
Mnemonic : VMOVHPD Supported forms : (4 forms)
- VMOVHPD xmm, m64 [AVX]
- VMOVHPD m64, xmm, xmm [AVX]
- VMOVHPD xmm, m64 [AVX512F]
- VMOVHPD m64, xmm, xmm [AVX512F]
func (*Program) VMOVHPS ¶
func (self *Program) VMOVHPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VMOVHPS performs "Move High Packed Single-Precision Floating-Point Values".
Mnemonic : VMOVHPS Supported forms : (4 forms)
- VMOVHPS xmm, m64 [AVX]
- VMOVHPS m64, xmm, xmm [AVX]
- VMOVHPS xmm, m64 [AVX512F]
- VMOVHPS m64, xmm, xmm [AVX512F]
func (*Program) VMOVLHPS ¶
func (self *Program) VMOVLHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VMOVLHPS performs "Move Packed Single-Precision Floating-Point Values Low to High".
Mnemonic : VMOVLHPS Supported forms : (2 forms)
- VMOVLHPS xmm, xmm, xmm [AVX]
- VMOVLHPS xmm, xmm, xmm [AVX512F]
func (*Program) VMOVLPD ¶
func (self *Program) VMOVLPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VMOVLPD performs "Move Low Packed Double-Precision Floating-Point Value".
Mnemonic : VMOVLPD Supported forms : (4 forms)
- VMOVLPD xmm, m64 [AVX]
- VMOVLPD m64, xmm, xmm [AVX]
- VMOVLPD xmm, m64 [AVX512F]
- VMOVLPD m64, xmm, xmm [AVX512F]
func (*Program) VMOVLPS ¶
func (self *Program) VMOVLPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VMOVLPS performs "Move Low Packed Single-Precision Floating-Point Values".
Mnemonic : VMOVLPS Supported forms : (4 forms)
- VMOVLPS xmm, m64 [AVX]
- VMOVLPS m64, xmm, xmm [AVX]
- VMOVLPS xmm, m64 [AVX512F]
- VMOVLPS m64, xmm, xmm [AVX512F]
func (*Program) VMOVMSKPD ¶
func (self *Program) VMOVMSKPD(v0 interface{}, v1 interface{}) *Instruction
VMOVMSKPD performs "Extract Packed Double-Precision Floating-Point Sign Mask".
Mnemonic : VMOVMSKPD Supported forms : (2 forms)
- VMOVMSKPD xmm, r32 [AVX]
- VMOVMSKPD ymm, r32 [AVX]
func (*Program) VMOVMSKPS ¶
func (self *Program) VMOVMSKPS(v0 interface{}, v1 interface{}) *Instruction
VMOVMSKPS performs "Extract Packed Single-Precision Floating-Point Sign Mask".
Mnemonic : VMOVMSKPS Supported forms : (2 forms)
- VMOVMSKPS xmm, r32 [AVX]
- VMOVMSKPS ymm, r32 [AVX]
func (*Program) VMOVNTDQ ¶
func (self *Program) VMOVNTDQ(v0 interface{}, v1 interface{}) *Instruction
VMOVNTDQ performs "Store Double Quadword Using Non-Temporal Hint".
Mnemonic : VMOVNTDQ Supported forms : (5 forms)
- VMOVNTDQ xmm, m128 [AVX]
- VMOVNTDQ ymm, m256 [AVX]
- VMOVNTDQ zmm, m512 [AVX512F]
- VMOVNTDQ xmm, m128 [AVX512F,AVX512VL]
- VMOVNTDQ ymm, m256 [AVX512F,AVX512VL]
func (*Program) VMOVNTDQA ¶
func (self *Program) VMOVNTDQA(v0 interface{}, v1 interface{}) *Instruction
VMOVNTDQA performs "Load Double Quadword Non-Temporal Aligned Hint".
Mnemonic : VMOVNTDQA Supported forms : (5 forms)
- VMOVNTDQA m128, xmm [AVX]
- VMOVNTDQA m256, ymm [AVX2]
- VMOVNTDQA m512, zmm [AVX512F]
- VMOVNTDQA m128, xmm [AVX512F,AVX512VL]
- VMOVNTDQA m256, ymm [AVX512F,AVX512VL]
func (*Program) VMOVNTPD ¶
func (self *Program) VMOVNTPD(v0 interface{}, v1 interface{}) *Instruction
VMOVNTPD performs "Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint".
Mnemonic : VMOVNTPD Supported forms : (5 forms)
- VMOVNTPD xmm, m128 [AVX]
- VMOVNTPD ymm, m256 [AVX]
- VMOVNTPD zmm, m512 [AVX512F]
- VMOVNTPD xmm, m128 [AVX512F,AVX512VL]
- VMOVNTPD ymm, m256 [AVX512F,AVX512VL]
func (*Program) VMOVNTPS ¶
func (self *Program) VMOVNTPS(v0 interface{}, v1 interface{}) *Instruction
VMOVNTPS performs "Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint".
Mnemonic : VMOVNTPS Supported forms : (5 forms)
- VMOVNTPS xmm, m128 [AVX]
- VMOVNTPS ymm, m256 [AVX]
- VMOVNTPS zmm, m512 [AVX512F]
- VMOVNTPS xmm, m128 [AVX512F,AVX512VL]
- VMOVNTPS ymm, m256 [AVX512F,AVX512VL]
func (*Program) VMOVQ ¶
func (self *Program) VMOVQ(v0 interface{}, v1 interface{}) *Instruction
VMOVQ performs "Move Quadword".
Mnemonic : VMOVQ Supported forms : (10 forms)
- VMOVQ xmm, r64 [AVX]
- VMOVQ r64, xmm [AVX]
- VMOVQ xmm, xmm [AVX]
- VMOVQ m64, xmm [AVX]
- VMOVQ xmm, m64 [AVX]
- VMOVQ xmm, r64 [AVX512F]
- VMOVQ r64, xmm [AVX512F]
- VMOVQ xmm, xmm [AVX512F]
- VMOVQ m64, xmm [AVX512F]
- VMOVQ xmm, m64 [AVX512F]
func (*Program) VMOVSD ¶
func (self *Program) VMOVSD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VMOVSD performs "Move Scalar Double-Precision Floating-Point Value".
Mnemonic : VMOVSD Supported forms : (6 forms)
- VMOVSD m64, xmm [AVX]
- VMOVSD xmm, m64 [AVX]
- VMOVSD xmm, xmm, xmm [AVX]
- VMOVSD xmm, m64{k} [AVX512F]
- VMOVSD m64, xmm{k}{z} [AVX512F]
- VMOVSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMOVSHDUP ¶
func (self *Program) VMOVSHDUP(v0 interface{}, v1 interface{}) *Instruction
VMOVSHDUP performs "Move Packed Single-FP High and Duplicate".
Mnemonic : VMOVSHDUP Supported forms : (10 forms)
- VMOVSHDUP xmm, xmm [AVX]
- VMOVSHDUP m128, xmm [AVX]
- VMOVSHDUP ymm, ymm [AVX]
- VMOVSHDUP m256, ymm [AVX]
- VMOVSHDUP zmm, zmm{k}{z} [AVX512F]
- VMOVSHDUP m512, zmm{k}{z} [AVX512F]
- VMOVSHDUP xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVSHDUP ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVSHDUP m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVSHDUP m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVSLDUP ¶
func (self *Program) VMOVSLDUP(v0 interface{}, v1 interface{}) *Instruction
VMOVSLDUP performs "Move Packed Single-FP Low and Duplicate".
Mnemonic : VMOVSLDUP Supported forms : (10 forms)
- VMOVSLDUP xmm, xmm [AVX]
- VMOVSLDUP m128, xmm [AVX]
- VMOVSLDUP ymm, ymm [AVX]
- VMOVSLDUP m256, ymm [AVX]
- VMOVSLDUP zmm, zmm{k}{z} [AVX512F]
- VMOVSLDUP m512, zmm{k}{z} [AVX512F]
- VMOVSLDUP xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVSLDUP ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVSLDUP m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVSLDUP m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVSS ¶
func (self *Program) VMOVSS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VMOVSS performs "Move Scalar Single-Precision Floating-Point Values".
Mnemonic : VMOVSS Supported forms : (6 forms)
- VMOVSS m32, xmm [AVX]
- VMOVSS xmm, m32 [AVX]
- VMOVSS xmm, xmm, xmm [AVX]
- VMOVSS xmm, m32{k} [AVX512F]
- VMOVSS m32, xmm{k}{z} [AVX512F]
- VMOVSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMOVUPD ¶
func (self *Program) VMOVUPD(v0 interface{}, v1 interface{}) *Instruction
VMOVUPD performs "Move Unaligned Packed Double-Precision Floating-Point Values".
Mnemonic : VMOVUPD Supported forms : (15 forms)
- VMOVUPD xmm, xmm [AVX]
- VMOVUPD m128, xmm [AVX]
- VMOVUPD ymm, ymm [AVX]
- VMOVUPD m256, ymm [AVX]
- VMOVUPD xmm, m128 [AVX]
- VMOVUPD ymm, m256 [AVX]
- VMOVUPD zmm, m512{k}{z} [AVX512F]
- VMOVUPD zmm, zmm{k}{z} [AVX512F]
- VMOVUPD m512, zmm{k}{z} [AVX512F]
- VMOVUPD xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVUPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVUPD ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVUPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVUPD m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVUPD m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMOVUPS ¶
func (self *Program) VMOVUPS(v0 interface{}, v1 interface{}) *Instruction
VMOVUPS performs "Move Unaligned Packed Single-Precision Floating-Point Values".
Mnemonic : VMOVUPS Supported forms : (15 forms)
- VMOVUPS xmm, xmm [AVX]
- VMOVUPS m128, xmm [AVX]
- VMOVUPS ymm, ymm [AVX]
- VMOVUPS m256, ymm [AVX]
- VMOVUPS xmm, m128 [AVX]
- VMOVUPS ymm, m256 [AVX]
- VMOVUPS zmm, m512{k}{z} [AVX512F]
- VMOVUPS zmm, zmm{k}{z} [AVX512F]
- VMOVUPS m512, zmm{k}{z} [AVX512F]
- VMOVUPS xmm, m128{k}{z} [AVX512F,AVX512VL]
- VMOVUPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVUPS ymm, m256{k}{z} [AVX512F,AVX512VL]
- VMOVUPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMOVUPS m128, xmm{k}{z} [AVX512F,AVX512VL]
- VMOVUPS m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMPSADBW ¶
func (self *Program) VMPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VMPSADBW performs "Compute Multiple Packed Sums of Absolute Difference".
Mnemonic : VMPSADBW Supported forms : (4 forms)
- VMPSADBW imm8, xmm, xmm, xmm [AVX]
- VMPSADBW imm8, m128, xmm, xmm [AVX]
- VMPSADBW imm8, ymm, ymm, ymm [AVX2]
- VMPSADBW imm8, m256, ymm, ymm [AVX2]
func (*Program) VMULPD ¶
func (self *Program) VMULPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMULPD performs "Multiply Packed Double-Precision Floating-Point Values".
Mnemonic : VMULPD Supported forms : (11 forms)
- VMULPD xmm, xmm, xmm [AVX]
- VMULPD m128, xmm, xmm [AVX]
- VMULPD ymm, ymm, ymm [AVX]
- VMULPD m256, ymm, ymm [AVX]
- VMULPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VMULPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VMULPD zmm, zmm, zmm{k}{z} [AVX512F]
- VMULPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMULPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMULPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMULPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMULPS ¶
func (self *Program) VMULPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMULPS performs "Multiply Packed Single-Precision Floating-Point Values".
Mnemonic : VMULPS Supported forms : (11 forms)
- VMULPS xmm, xmm, xmm [AVX]
- VMULPS m128, xmm, xmm [AVX]
- VMULPS ymm, ymm, ymm [AVX]
- VMULPS m256, ymm, ymm [AVX]
- VMULPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VMULPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VMULPS zmm, zmm, zmm{k}{z} [AVX512F]
- VMULPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMULPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VMULPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VMULPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VMULSD ¶
func (self *Program) VMULSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMULSD performs "Multiply Scalar Double-Precision Floating-Point Values".
Mnemonic : VMULSD Supported forms : (5 forms)
- VMULSD xmm, xmm, xmm [AVX]
- VMULSD m64, xmm, xmm [AVX]
- VMULSD m64, xmm, xmm{k}{z} [AVX512F]
- VMULSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VMULSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VMULSS ¶
func (self *Program) VMULSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VMULSS performs "Multiply Scalar Single-Precision Floating-Point Values".
Mnemonic : VMULSS Supported forms : (5 forms)
- VMULSS xmm, xmm, xmm [AVX]
- VMULSS m32, xmm, xmm [AVX]
- VMULSS m32, xmm, xmm{k}{z} [AVX512F]
- VMULSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VMULSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VORPD ¶
func (self *Program) VORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VORPD performs "Bitwise Logical OR of Double-Precision Floating-Point Values".
Mnemonic : VORPD Supported forms : (10 forms)
- VORPD xmm, xmm, xmm [AVX]
- VORPD m128, xmm, xmm [AVX]
- VORPD ymm, ymm, ymm [AVX]
- VORPD m256, ymm, ymm [AVX]
- VORPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
- VORPD zmm, zmm, zmm{k}{z} [AVX512DQ]
- VORPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VORPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VORPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VORPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VORPS ¶
func (self *Program) VORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VORPS performs "Bitwise Logical OR of Single-Precision Floating-Point Values".
Mnemonic : VORPS Supported forms : (10 forms)
- VORPS xmm, xmm, xmm [AVX]
- VORPS m128, xmm, xmm [AVX]
- VORPS ymm, ymm, ymm [AVX]
- VORPS m256, ymm, ymm [AVX]
- VORPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
- VORPS zmm, zmm, zmm{k}{z} [AVX512DQ]
- VORPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VORPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VORPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VORPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VPABSB ¶
func (self *Program) VPABSB(v0 interface{}, v1 interface{}) *Instruction
VPABSB performs "Packed Absolute Value of Byte Integers".
Mnemonic : VPABSB Supported forms : (10 forms)
- VPABSB xmm, xmm [AVX]
- VPABSB m128, xmm [AVX]
- VPABSB ymm, ymm [AVX2]
- VPABSB m256, ymm [AVX2]
- VPABSB zmm, zmm{k}{z} [AVX512BW]
- VPABSB m512, zmm{k}{z} [AVX512BW]
- VPABSB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPABSB ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPABSB m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPABSB m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPABSD ¶
func (self *Program) VPABSD(v0 interface{}, v1 interface{}) *Instruction
VPABSD performs "Packed Absolute Value of Doubleword Integers".
Mnemonic : VPABSD Supported forms : (10 forms)
- VPABSD xmm, xmm [AVX]
- VPABSD m128, xmm [AVX]
- VPABSD ymm, ymm [AVX2]
- VPABSD m256, ymm [AVX2]
- VPABSD m512/m32bcst, zmm{k}{z} [AVX512F]
- VPABSD zmm, zmm{k}{z} [AVX512F]
- VPABSD m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPABSD m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPABSD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPABSD ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPABSQ ¶
func (self *Program) VPABSQ(v0 interface{}, v1 interface{}) *Instruction
VPABSQ performs "Packed Absolute Value of Quadword Integers".
Mnemonic : VPABSQ Supported forms : (6 forms)
- VPABSQ m512/m64bcst, zmm{k}{z} [AVX512F]
- VPABSQ zmm, zmm{k}{z} [AVX512F]
- VPABSQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPABSQ m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPABSQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPABSQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPABSW ¶
func (self *Program) VPABSW(v0 interface{}, v1 interface{}) *Instruction
VPABSW performs "Packed Absolute Value of Word Integers".
Mnemonic : VPABSW Supported forms : (10 forms)
- VPABSW xmm, xmm [AVX]
- VPABSW m128, xmm [AVX]
- VPABSW ymm, ymm [AVX2]
- VPABSW m256, ymm [AVX2]
- VPABSW zmm, zmm{k}{z} [AVX512BW]
- VPABSW m512, zmm{k}{z} [AVX512BW]
- VPABSW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPABSW ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPABSW m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPABSW m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPACKSSDW ¶
func (self *Program) VPACKSSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPACKSSDW performs "Pack Doublewords into Words with Signed Saturation".
Mnemonic : VPACKSSDW Supported forms : (10 forms)
- VPACKSSDW xmm, xmm, xmm [AVX]
- VPACKSSDW m128, xmm, xmm [AVX]
- VPACKSSDW ymm, ymm, ymm [AVX2]
- VPACKSSDW m256, ymm, ymm [AVX2]
- VPACKSSDW m512/m32bcst, zmm, zmm{k}{z} [AVX512BW]
- VPACKSSDW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPACKSSDW m128/m32bcst, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKSSDW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKSSDW m256/m32bcst, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPACKSSDW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPACKSSWB ¶
func (self *Program) VPACKSSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPACKSSWB performs "Pack Words into Bytes with Signed Saturation".
Mnemonic : VPACKSSWB Supported forms : (10 forms)
- VPACKSSWB xmm, xmm, xmm [AVX]
- VPACKSSWB m128, xmm, xmm [AVX]
- VPACKSSWB ymm, ymm, ymm [AVX2]
- VPACKSSWB m256, ymm, ymm [AVX2]
- VPACKSSWB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPACKSSWB m512, zmm, zmm{k}{z} [AVX512BW]
- VPACKSSWB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKSSWB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKSSWB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPACKSSWB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPACKUSDW ¶
func (self *Program) VPACKUSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPACKUSDW performs "Pack Doublewords into Words with Unsigned Saturation".
Mnemonic : VPACKUSDW Supported forms : (10 forms)
- VPACKUSDW xmm, xmm, xmm [AVX]
- VPACKUSDW m128, xmm, xmm [AVX]
- VPACKUSDW ymm, ymm, ymm [AVX2]
- VPACKUSDW m256, ymm, ymm [AVX2]
- VPACKUSDW m512/m32bcst, zmm, zmm{k}{z} [AVX512BW]
- VPACKUSDW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPACKUSDW m128/m32bcst, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKUSDW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKUSDW m256/m32bcst, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPACKUSDW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPACKUSWB ¶
func (self *Program) VPACKUSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPACKUSWB performs "Pack Words into Bytes with Unsigned Saturation".
Mnemonic : VPACKUSWB Supported forms : (10 forms)
- VPACKUSWB xmm, xmm, xmm [AVX]
- VPACKUSWB m128, xmm, xmm [AVX]
- VPACKUSWB ymm, ymm, ymm [AVX2]
- VPACKUSWB m256, ymm, ymm [AVX2]
- VPACKUSWB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPACKUSWB m512, zmm, zmm{k}{z} [AVX512BW]
- VPACKUSWB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKUSWB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPACKUSWB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPACKUSWB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPADDB ¶
func (self *Program) VPADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDB performs "Add Packed Byte Integers".
Mnemonic : VPADDB Supported forms : (10 forms)
- VPADDB xmm, xmm, xmm [AVX]
- VPADDB m128, xmm, xmm [AVX]
- VPADDB ymm, ymm, ymm [AVX2]
- VPADDB m256, ymm, ymm [AVX2]
- VPADDB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPADDB m512, zmm, zmm{k}{z} [AVX512BW]
- VPADDB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPADDB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPADDD ¶
func (self *Program) VPADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDD performs "Add Packed Doubleword Integers".
Mnemonic : VPADDD Supported forms : (10 forms)
- VPADDD xmm, xmm, xmm [AVX]
- VPADDD m128, xmm, xmm [AVX]
- VPADDD ymm, ymm, ymm [AVX2]
- VPADDD m256, ymm, ymm [AVX2]
- VPADDD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPADDD zmm, zmm, zmm{k}{z} [AVX512F]
- VPADDD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPADDD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPADDD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPADDD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPADDQ ¶
func (self *Program) VPADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDQ performs "Add Packed Quadword Integers".
Mnemonic : VPADDQ Supported forms : (10 forms)
- VPADDQ xmm, xmm, xmm [AVX]
- VPADDQ m128, xmm, xmm [AVX]
- VPADDQ ymm, ymm, ymm [AVX2]
- VPADDQ m256, ymm, ymm [AVX2]
- VPADDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPADDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPADDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPADDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPADDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPADDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPADDSB ¶
func (self *Program) VPADDSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDSB performs "Add Packed Signed Byte Integers with Signed Saturation".
Mnemonic : VPADDSB Supported forms : (10 forms)
- VPADDSB xmm, xmm, xmm [AVX]
- VPADDSB m128, xmm, xmm [AVX]
- VPADDSB ymm, ymm, ymm [AVX2]
- VPADDSB m256, ymm, ymm [AVX2]
- VPADDSB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPADDSB m512, zmm, zmm{k}{z} [AVX512BW]
- VPADDSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPADDSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPADDSW ¶
func (self *Program) VPADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDSW performs "Add Packed Signed Word Integers with Signed Saturation".
Mnemonic : VPADDSW Supported forms : (10 forms)
- VPADDSW xmm, xmm, xmm [AVX]
- VPADDSW m128, xmm, xmm [AVX]
- VPADDSW ymm, ymm, ymm [AVX2]
- VPADDSW m256, ymm, ymm [AVX2]
- VPADDSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPADDSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPADDSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPADDSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPADDUSB ¶
func (self *Program) VPADDUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDUSB performs "Add Packed Unsigned Byte Integers with Unsigned Saturation".
Mnemonic : VPADDUSB Supported forms : (10 forms)
- VPADDUSB xmm, xmm, xmm [AVX]
- VPADDUSB m128, xmm, xmm [AVX]
- VPADDUSB ymm, ymm, ymm [AVX2]
- VPADDUSB m256, ymm, ymm [AVX2]
- VPADDUSB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPADDUSB m512, zmm, zmm{k}{z} [AVX512BW]
- VPADDUSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDUSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDUSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPADDUSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPADDUSW ¶
func (self *Program) VPADDUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDUSW performs "Add Packed Unsigned Word Integers with Unsigned Saturation".
Mnemonic : VPADDUSW Supported forms : (10 forms)
- VPADDUSW xmm, xmm, xmm [AVX]
- VPADDUSW m128, xmm, xmm [AVX]
- VPADDUSW ymm, ymm, ymm [AVX2]
- VPADDUSW m256, ymm, ymm [AVX2]
- VPADDUSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPADDUSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPADDUSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDUSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDUSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPADDUSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPADDW ¶
func (self *Program) VPADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPADDW performs "Add Packed Word Integers".
Mnemonic : VPADDW Supported forms : (10 forms)
- VPADDW xmm, xmm, xmm [AVX]
- VPADDW m128, xmm, xmm [AVX]
- VPADDW ymm, ymm, ymm [AVX2]
- VPADDW m256, ymm, ymm [AVX2]
- VPADDW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPADDW m512, zmm, zmm{k}{z} [AVX512BW]
- VPADDW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPADDW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPADDW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPALIGNR ¶
func (self *Program) VPALIGNR(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPALIGNR performs "Packed Align Right".
Mnemonic : VPALIGNR Supported forms : (10 forms)
- VPALIGNR imm8, xmm, xmm, xmm [AVX]
- VPALIGNR imm8, m128, xmm, xmm [AVX]
- VPALIGNR imm8, ymm, ymm, ymm [AVX2]
- VPALIGNR imm8, m256, ymm, ymm [AVX2]
- VPALIGNR imm8, zmm, zmm, zmm{k}{z} [AVX512BW]
- VPALIGNR imm8, m512, zmm, zmm{k}{z} [AVX512BW]
- VPALIGNR imm8, xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPALIGNR imm8, m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPALIGNR imm8, ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPALIGNR imm8, m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPAND ¶
func (self *Program) VPAND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPAND performs "Packed Bitwise Logical AND".
Mnemonic : VPAND Supported forms : (4 forms)
- VPAND xmm, xmm, xmm [AVX]
- VPAND m128, xmm, xmm [AVX]
- VPAND ymm, ymm, ymm [AVX2]
- VPAND m256, ymm, ymm [AVX2]
func (*Program) VPANDD ¶
func (self *Program) VPANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPANDD performs "Bitwise Logical AND of Packed Doubleword Integers".
Mnemonic : VPANDD Supported forms : (6 forms)
- VPANDD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPANDD zmm, zmm, zmm{k}{z} [AVX512F]
- VPANDD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPANDD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPANDN ¶
func (self *Program) VPANDN(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPANDN performs "Packed Bitwise Logical AND NOT".
Mnemonic : VPANDN Supported forms : (4 forms)
- VPANDN xmm, xmm, xmm [AVX]
- VPANDN m128, xmm, xmm [AVX]
- VPANDN ymm, ymm, ymm [AVX2]
- VPANDN m256, ymm, ymm [AVX2]
func (*Program) VPANDND ¶
func (self *Program) VPANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPANDND performs "Bitwise Logical AND NOT of Packed Doubleword Integers".
Mnemonic : VPANDND Supported forms : (6 forms)
- VPANDND m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPANDND zmm, zmm, zmm{k}{z} [AVX512F]
- VPANDND m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDND xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDND m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPANDND ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPANDNQ ¶
func (self *Program) VPANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPANDNQ performs "Bitwise Logical AND NOT of Packed Quadword Integers".
Mnemonic : VPANDNQ Supported forms : (6 forms)
- VPANDNQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPANDNQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPANDNQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDNQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDNQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPANDNQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPANDQ ¶
func (self *Program) VPANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPANDQ performs "Bitwise Logical AND of Packed Quadword Integers".
Mnemonic : VPANDQ Supported forms : (6 forms)
- VPANDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPANDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPANDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPANDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPANDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPAVGB ¶
func (self *Program) VPAVGB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPAVGB performs "Average Packed Byte Integers".
Mnemonic : VPAVGB Supported forms : (10 forms)
- VPAVGB xmm, xmm, xmm [AVX]
- VPAVGB m128, xmm, xmm [AVX]
- VPAVGB ymm, ymm, ymm [AVX2]
- VPAVGB m256, ymm, ymm [AVX2]
- VPAVGB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPAVGB m512, zmm, zmm{k}{z} [AVX512BW]
- VPAVGB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPAVGB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPAVGB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPAVGB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPAVGW ¶
func (self *Program) VPAVGW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPAVGW performs "Average Packed Word Integers".
Mnemonic : VPAVGW Supported forms : (10 forms)
- VPAVGW xmm, xmm, xmm [AVX]
- VPAVGW m128, xmm, xmm [AVX]
- VPAVGW ymm, ymm, ymm [AVX2]
- VPAVGW m256, ymm, ymm [AVX2]
- VPAVGW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPAVGW m512, zmm, zmm{k}{z} [AVX512BW]
- VPAVGW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPAVGW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPAVGW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPAVGW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPBLENDD ¶
func (self *Program) VPBLENDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPBLENDD performs "Blend Packed Doublewords".
Mnemonic : VPBLENDD Supported forms : (4 forms)
- VPBLENDD imm8, xmm, xmm, xmm [AVX2]
- VPBLENDD imm8, m128, xmm, xmm [AVX2]
- VPBLENDD imm8, ymm, ymm, ymm [AVX2]
- VPBLENDD imm8, m256, ymm, ymm [AVX2]
func (*Program) VPBLENDMB ¶
func (self *Program) VPBLENDMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPBLENDMB performs "Blend Byte Vectors Using an OpMask Control".
Mnemonic : VPBLENDMB Supported forms : (6 forms)
- VPBLENDMB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPBLENDMB m512, zmm, zmm{k}{z} [AVX512BW]
- VPBLENDMB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBLENDMB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBLENDMB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPBLENDMB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPBLENDMD ¶
func (self *Program) VPBLENDMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPBLENDMD performs "Blend Doubleword Vectors Using an OpMask Control".
Mnemonic : VPBLENDMD Supported forms : (6 forms)
- VPBLENDMD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPBLENDMD zmm, zmm, zmm{k}{z} [AVX512F]
- VPBLENDMD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPBLENDMD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPBLENDMD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPBLENDMD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPBLENDMQ ¶
func (self *Program) VPBLENDMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPBLENDMQ performs "Blend Quadword Vectors Using an OpMask Control".
Mnemonic : VPBLENDMQ Supported forms : (6 forms)
- VPBLENDMQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPBLENDMQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPBLENDMQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPBLENDMQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPBLENDMQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPBLENDMQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPBLENDMW ¶
func (self *Program) VPBLENDMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPBLENDMW performs "Blend Word Vectors Using an OpMask Control".
Mnemonic : VPBLENDMW Supported forms : (6 forms)
- VPBLENDMW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPBLENDMW m512, zmm, zmm{k}{z} [AVX512BW]
- VPBLENDMW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBLENDMW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBLENDMW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPBLENDMW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPBLENDVB ¶
func (self *Program) VPBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPBLENDVB performs "Variable Blend Packed Bytes".
Mnemonic : VPBLENDVB Supported forms : (4 forms)
- VPBLENDVB xmm, xmm, xmm, xmm [AVX]
- VPBLENDVB xmm, m128, xmm, xmm [AVX]
- VPBLENDVB ymm, ymm, ymm, ymm [AVX2]
- VPBLENDVB ymm, m256, ymm, ymm [AVX2]
func (*Program) VPBLENDW ¶
func (self *Program) VPBLENDW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPBLENDW performs "Blend Packed Words".
Mnemonic : VPBLENDW Supported forms : (4 forms)
- VPBLENDW imm8, xmm, xmm, xmm [AVX]
- VPBLENDW imm8, m128, xmm, xmm [AVX]
- VPBLENDW imm8, ymm, ymm, ymm [AVX2]
- VPBLENDW imm8, m256, ymm, ymm [AVX2]
func (*Program) VPBROADCASTB ¶
func (self *Program) VPBROADCASTB(v0 interface{}, v1 interface{}) *Instruction
VPBROADCASTB performs "Broadcast Byte Integer".
Mnemonic : VPBROADCASTB Supported forms : (13 forms)
- VPBROADCASTB xmm, xmm [AVX2]
- VPBROADCASTB m8, xmm [AVX2]
- VPBROADCASTB xmm, ymm [AVX2]
- VPBROADCASTB m8, ymm [AVX2]
- VPBROADCASTB r32, zmm{k}{z} [AVX512BW]
- VPBROADCASTB xmm, zmm{k}{z} [AVX512BW]
- VPBROADCASTB m8, zmm{k}{z} [AVX512BW]
- VPBROADCASTB r32, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTB r32, ymm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTB xmm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTB m8, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTB m8, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPBROADCASTD ¶
func (self *Program) VPBROADCASTD(v0 interface{}, v1 interface{}) *Instruction
VPBROADCASTD performs "Broadcast Doubleword Integer".
Mnemonic : VPBROADCASTD Supported forms : (13 forms)
- VPBROADCASTD xmm, xmm [AVX2]
- VPBROADCASTD m32, xmm [AVX2]
- VPBROADCASTD xmm, ymm [AVX2]
- VPBROADCASTD m32, ymm [AVX2]
- VPBROADCASTD r32, zmm{k}{z} [AVX512F]
- VPBROADCASTD xmm, zmm{k}{z} [AVX512F]
- VPBROADCASTD m32, zmm{k}{z} [AVX512F]
- VPBROADCASTD r32, xmm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTD r32, ymm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTD xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTD m32, xmm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTD m32, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPBROADCASTMB2Q ¶
func (self *Program) VPBROADCASTMB2Q(v0 interface{}, v1 interface{}) *Instruction
VPBROADCASTMB2Q performs "Broadcast Low Byte of Mask Register to Packed Quadword Values".
Mnemonic : VPBROADCASTMB2Q Supported forms : (3 forms)
- VPBROADCASTMB2Q k, xmm [AVX512CD,AVX512VL]
- VPBROADCASTMB2Q k, ymm [AVX512CD,AVX512VL]
- VPBROADCASTMB2Q k, zmm [AVX512CD]
func (*Program) VPBROADCASTMW2D ¶
func (self *Program) VPBROADCASTMW2D(v0 interface{}, v1 interface{}) *Instruction
VPBROADCASTMW2D performs "Broadcast Low Word of Mask Register to Packed Doubleword Values".
Mnemonic : VPBROADCASTMW2D Supported forms : (3 forms)
- VPBROADCASTMW2D k, xmm [AVX512CD,AVX512VL]
- VPBROADCASTMW2D k, ymm [AVX512CD,AVX512VL]
- VPBROADCASTMW2D k, zmm [AVX512CD]
func (*Program) VPBROADCASTQ ¶
func (self *Program) VPBROADCASTQ(v0 interface{}, v1 interface{}) *Instruction
VPBROADCASTQ performs "Broadcast Quadword Integer".
Mnemonic : VPBROADCASTQ Supported forms : (13 forms)
- VPBROADCASTQ xmm, xmm [AVX2]
- VPBROADCASTQ m64, xmm [AVX2]
- VPBROADCASTQ xmm, ymm [AVX2]
- VPBROADCASTQ m64, ymm [AVX2]
- VPBROADCASTQ r64, zmm{k}{z} [AVX512F]
- VPBROADCASTQ xmm, zmm{k}{z} [AVX512F]
- VPBROADCASTQ m64, zmm{k}{z} [AVX512F]
- VPBROADCASTQ r64, xmm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTQ r64, ymm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTQ m64, xmm{k}{z} [AVX512F,AVX512VL]
- VPBROADCASTQ m64, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPBROADCASTW ¶
func (self *Program) VPBROADCASTW(v0 interface{}, v1 interface{}) *Instruction
VPBROADCASTW performs "Broadcast Word Integer".
Mnemonic : VPBROADCASTW Supported forms : (13 forms)
- VPBROADCASTW xmm, xmm [AVX2]
- VPBROADCASTW m16, xmm [AVX2]
- VPBROADCASTW xmm, ymm [AVX2]
- VPBROADCASTW m16, ymm [AVX2]
- VPBROADCASTW r32, zmm{k}{z} [AVX512BW]
- VPBROADCASTW xmm, zmm{k}{z} [AVX512BW]
- VPBROADCASTW m16, zmm{k}{z} [AVX512BW]
- VPBROADCASTW r32, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTW r32, ymm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTW xmm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTW m16, xmm{k}{z} [AVX512BW,AVX512VL]
- VPBROADCASTW m16, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPCLMULQDQ ¶
func (self *Program) VPCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCLMULQDQ performs "Carry-Less Quadword Multiplication".
Mnemonic : VPCLMULQDQ Supported forms : (2 forms)
- VPCLMULQDQ imm8, xmm, xmm, xmm [AVX,PCLMULQDQ]
- VPCLMULQDQ imm8, m128, xmm, xmm [AVX,PCLMULQDQ]
func (*Program) VPCMOV ¶
func (self *Program) VPCMOV(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMOV performs "Packed Conditional Move".
Mnemonic : VPCMOV Supported forms : (6 forms)
- VPCMOV xmm, xmm, xmm, xmm [XOP]
- VPCMOV m128, xmm, xmm, xmm [XOP]
- VPCMOV xmm, m128, xmm, xmm [XOP]
- VPCMOV ymm, ymm, ymm, ymm [XOP]
- VPCMOV m256, ymm, ymm, ymm [XOP]
- VPCMOV ymm, m256, ymm, ymm [XOP]
func (*Program) VPCMPB ¶
func (self *Program) VPCMPB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPB performs "Compare Packed Signed Byte Values".
Mnemonic : VPCMPB Supported forms : (6 forms)
- VPCMPB imm8, zmm, zmm, k{k} [AVX512BW]
- VPCMPB imm8, m512, zmm, k{k} [AVX512BW]
- VPCMPB imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPB imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPB imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPB imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPD ¶
func (self *Program) VPCMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPD performs "Compare Packed Signed Doubleword Values".
Mnemonic : VPCMPD Supported forms : (6 forms)
- VPCMPD imm8, m512/m32bcst, zmm, k{k} [AVX512F]
- VPCMPD imm8, zmm, zmm, k{k} [AVX512F]
- VPCMPD imm8, m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPD imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPD imm8, m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPD imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPEQB ¶
func (self *Program) VPCMPEQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPEQB performs "Compare Packed Byte Data for Equality".
Mnemonic : VPCMPEQB Supported forms : (10 forms)
- VPCMPEQB xmm, xmm, xmm [AVX]
- VPCMPEQB m128, xmm, xmm [AVX]
- VPCMPEQB ymm, ymm, ymm [AVX2]
- VPCMPEQB m256, ymm, ymm [AVX2]
- VPCMPEQB zmm, zmm, k{k} [AVX512BW]
- VPCMPEQB m512, zmm, k{k} [AVX512BW]
- VPCMPEQB xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPEQB m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPEQB ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPEQB m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPEQD ¶
func (self *Program) VPCMPEQD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPEQD performs "Compare Packed Doubleword Data for Equality".
Mnemonic : VPCMPEQD Supported forms : (10 forms)
- VPCMPEQD xmm, xmm, xmm [AVX]
- VPCMPEQD m128, xmm, xmm [AVX]
- VPCMPEQD ymm, ymm, ymm [AVX2]
- VPCMPEQD m256, ymm, ymm [AVX2]
- VPCMPEQD m512/m32bcst, zmm, k{k} [AVX512F]
- VPCMPEQD zmm, zmm, k{k} [AVX512F]
- VPCMPEQD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPEQD xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPEQD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPEQD ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPEQQ ¶
func (self *Program) VPCMPEQQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPEQQ performs "Compare Packed Quadword Data for Equality".
Mnemonic : VPCMPEQQ Supported forms : (10 forms)
- VPCMPEQQ xmm, xmm, xmm [AVX]
- VPCMPEQQ m128, xmm, xmm [AVX]
- VPCMPEQQ ymm, ymm, ymm [AVX2]
- VPCMPEQQ m256, ymm, ymm [AVX2]
- VPCMPEQQ m512/m64bcst, zmm, k{k} [AVX512F]
- VPCMPEQQ zmm, zmm, k{k} [AVX512F]
- VPCMPEQQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPEQQ xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPEQQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPEQQ ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPEQW ¶
func (self *Program) VPCMPEQW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPEQW performs "Compare Packed Word Data for Equality".
Mnemonic : VPCMPEQW Supported forms : (10 forms)
- VPCMPEQW xmm, xmm, xmm [AVX]
- VPCMPEQW m128, xmm, xmm [AVX]
- VPCMPEQW ymm, ymm, ymm [AVX2]
- VPCMPEQW m256, ymm, ymm [AVX2]
- VPCMPEQW zmm, zmm, k{k} [AVX512BW]
- VPCMPEQW m512, zmm, k{k} [AVX512BW]
- VPCMPEQW xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPEQW m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPEQW ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPEQW m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPESTRI ¶
func (self *Program) VPCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPESTRI performs "Packed Compare Explicit Length Strings, Return Index".
Mnemonic : VPCMPESTRI Supported forms : (2 forms)
- VPCMPESTRI imm8, xmm, xmm [AVX]
- VPCMPESTRI imm8, m128, xmm [AVX]
func (*Program) VPCMPESTRM ¶
func (self *Program) VPCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPESTRM performs "Packed Compare Explicit Length Strings, Return Mask".
Mnemonic : VPCMPESTRM Supported forms : (2 forms)
- VPCMPESTRM imm8, xmm, xmm [AVX]
- VPCMPESTRM imm8, m128, xmm [AVX]
func (*Program) VPCMPGTB ¶
func (self *Program) VPCMPGTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPGTB performs "Compare Packed Signed Byte Integers for Greater Than".
Mnemonic : VPCMPGTB Supported forms : (10 forms)
- VPCMPGTB xmm, xmm, xmm [AVX]
- VPCMPGTB m128, xmm, xmm [AVX]
- VPCMPGTB ymm, ymm, ymm [AVX2]
- VPCMPGTB m256, ymm, ymm [AVX2]
- VPCMPGTB zmm, zmm, k{k} [AVX512BW]
- VPCMPGTB m512, zmm, k{k} [AVX512BW]
- VPCMPGTB xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPGTB m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPGTB ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPGTB m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPGTD ¶
func (self *Program) VPCMPGTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPGTD performs "Compare Packed Signed Doubleword Integers for Greater Than".
Mnemonic : VPCMPGTD Supported forms : (10 forms)
- VPCMPGTD xmm, xmm, xmm [AVX]
- VPCMPGTD m128, xmm, xmm [AVX]
- VPCMPGTD ymm, ymm, ymm [AVX2]
- VPCMPGTD m256, ymm, ymm [AVX2]
- VPCMPGTD m512/m32bcst, zmm, k{k} [AVX512F]
- VPCMPGTD zmm, zmm, k{k} [AVX512F]
- VPCMPGTD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPGTD xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPGTD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPGTD ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPGTQ ¶
func (self *Program) VPCMPGTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPGTQ performs "Compare Packed Data for Greater Than".
Mnemonic : VPCMPGTQ Supported forms : (10 forms)
- VPCMPGTQ xmm, xmm, xmm [AVX]
- VPCMPGTQ m128, xmm, xmm [AVX]
- VPCMPGTQ ymm, ymm, ymm [AVX2]
- VPCMPGTQ m256, ymm, ymm [AVX2]
- VPCMPGTQ m512/m64bcst, zmm, k{k} [AVX512F]
- VPCMPGTQ zmm, zmm, k{k} [AVX512F]
- VPCMPGTQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPGTQ xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPGTQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPGTQ ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPGTW ¶
func (self *Program) VPCMPGTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPGTW performs "Compare Packed Signed Word Integers for Greater Than".
Mnemonic : VPCMPGTW Supported forms : (10 forms)
- VPCMPGTW xmm, xmm, xmm [AVX]
- VPCMPGTW m128, xmm, xmm [AVX]
- VPCMPGTW ymm, ymm, ymm [AVX2]
- VPCMPGTW m256, ymm, ymm [AVX2]
- VPCMPGTW zmm, zmm, k{k} [AVX512BW]
- VPCMPGTW m512, zmm, k{k} [AVX512BW]
- VPCMPGTW xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPGTW m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPGTW ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPGTW m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPISTRI ¶
func (self *Program) VPCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPISTRI performs "Packed Compare Implicit Length Strings, Return Index".
Mnemonic : VPCMPISTRI Supported forms : (2 forms)
- VPCMPISTRI imm8, xmm, xmm [AVX]
- VPCMPISTRI imm8, m128, xmm [AVX]
func (*Program) VPCMPISTRM ¶
func (self *Program) VPCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPCMPISTRM performs "Packed Compare Implicit Length Strings, Return Mask".
Mnemonic : VPCMPISTRM Supported forms : (2 forms)
- VPCMPISTRM imm8, xmm, xmm [AVX]
- VPCMPISTRM imm8, m128, xmm [AVX]
func (*Program) VPCMPQ ¶
func (self *Program) VPCMPQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPQ performs "Compare Packed Signed Quadword Values".
Mnemonic : VPCMPQ Supported forms : (6 forms)
- VPCMPQ imm8, m512/m64bcst, zmm, k{k} [AVX512F]
- VPCMPQ imm8, zmm, zmm, k{k} [AVX512F]
- VPCMPQ imm8, m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPQ imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPQ imm8, m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPQ imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPUB ¶
func (self *Program) VPCMPUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPUB performs "Compare Packed Unsigned Byte Values".
Mnemonic : VPCMPUB Supported forms : (6 forms)
- VPCMPUB imm8, zmm, zmm, k{k} [AVX512BW]
- VPCMPUB imm8, m512, zmm, k{k} [AVX512BW]
- VPCMPUB imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPUB imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPUB imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPUB imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPUD ¶
func (self *Program) VPCMPUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPUD performs "Compare Packed Unsigned Doubleword Values".
Mnemonic : VPCMPUD Supported forms : (6 forms)
- VPCMPUD imm8, m512/m32bcst, zmm, k{k} [AVX512F]
- VPCMPUD imm8, zmm, zmm, k{k} [AVX512F]
- VPCMPUD imm8, m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPUD imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPUD imm8, m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPUD imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPUQ ¶
func (self *Program) VPCMPUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPUQ performs "Compare Packed Unsigned Quadword Values".
Mnemonic : VPCMPUQ Supported forms : (6 forms)
- VPCMPUQ imm8, m512/m64bcst, zmm, k{k} [AVX512F]
- VPCMPUQ imm8, zmm, zmm, k{k} [AVX512F]
- VPCMPUQ imm8, m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPUQ imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPCMPUQ imm8, m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPCMPUQ imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPCMPUW ¶
func (self *Program) VPCMPUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPUW performs "Compare Packed Unsigned Word Values".
Mnemonic : VPCMPUW Supported forms : (6 forms)
- VPCMPUW imm8, zmm, zmm, k{k} [AVX512BW]
- VPCMPUW imm8, m512, zmm, k{k} [AVX512BW]
- VPCMPUW imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPUW imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPUW imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPUW imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCMPW ¶
func (self *Program) VPCMPW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCMPW performs "Compare Packed Signed Word Values".
Mnemonic : VPCMPW Supported forms : (6 forms)
- VPCMPW imm8, zmm, zmm, k{k} [AVX512BW]
- VPCMPW imm8, m512, zmm, k{k} [AVX512BW]
- VPCMPW imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPW imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPCMPW imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPCMPW imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPCOMB ¶
func (self *Program) VPCOMB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMB performs "Compare Packed Signed Byte Integers".
Mnemonic : VPCOMB Supported forms : (2 forms)
- VPCOMB imm8, xmm, xmm, xmm [XOP]
- VPCOMB imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMD ¶
func (self *Program) VPCOMD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMD performs "Compare Packed Signed Doubleword Integers".
Mnemonic : VPCOMD Supported forms : (2 forms)
- VPCOMD imm8, xmm, xmm, xmm [XOP]
- VPCOMD imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMPRESSD ¶
func (self *Program) VPCOMPRESSD(v0 interface{}, v1 interface{}) *Instruction
VPCOMPRESSD performs "Store Sparse Packed Doubleword Integer Values into Dense Memory/Register".
Mnemonic : VPCOMPRESSD Supported forms : (6 forms)
- VPCOMPRESSD zmm, zmm{k}{z} [AVX512F]
- VPCOMPRESSD zmm, m512{k}{z} [AVX512F]
- VPCOMPRESSD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPCOMPRESSD xmm, m128{k}{z} [AVX512F,AVX512VL]
- VPCOMPRESSD ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPCOMPRESSD ymm, m256{k}{z} [AVX512F,AVX512VL]
func (*Program) VPCOMPRESSQ ¶
func (self *Program) VPCOMPRESSQ(v0 interface{}, v1 interface{}) *Instruction
VPCOMPRESSQ performs "Store Sparse Packed Quadword Integer Values into Dense Memory/Register".
Mnemonic : VPCOMPRESSQ Supported forms : (6 forms)
- VPCOMPRESSQ zmm, zmm{k}{z} [AVX512F]
- VPCOMPRESSQ zmm, m512{k}{z} [AVX512F]
- VPCOMPRESSQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPCOMPRESSQ xmm, m128{k}{z} [AVX512F,AVX512VL]
- VPCOMPRESSQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPCOMPRESSQ ymm, m256{k}{z} [AVX512F,AVX512VL]
func (*Program) VPCOMQ ¶
func (self *Program) VPCOMQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMQ performs "Compare Packed Signed Quadword Integers".
Mnemonic : VPCOMQ Supported forms : (2 forms)
- VPCOMQ imm8, xmm, xmm, xmm [XOP]
- VPCOMQ imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMUB ¶
func (self *Program) VPCOMUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMUB performs "Compare Packed Unsigned Byte Integers".
Mnemonic : VPCOMUB Supported forms : (2 forms)
- VPCOMUB imm8, xmm, xmm, xmm [XOP]
- VPCOMUB imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMUD ¶
func (self *Program) VPCOMUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMUD performs "Compare Packed Unsigned Doubleword Integers".
Mnemonic : VPCOMUD Supported forms : (2 forms)
- VPCOMUD imm8, xmm, xmm, xmm [XOP]
- VPCOMUD imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMUQ ¶
func (self *Program) VPCOMUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMUQ performs "Compare Packed Unsigned Quadword Integers".
Mnemonic : VPCOMUQ Supported forms : (2 forms)
- VPCOMUQ imm8, xmm, xmm, xmm [XOP]
- VPCOMUQ imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMUW ¶
func (self *Program) VPCOMUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMUW performs "Compare Packed Unsigned Word Integers".
Mnemonic : VPCOMUW Supported forms : (2 forms)
- VPCOMUW imm8, xmm, xmm, xmm [XOP]
- VPCOMUW imm8, m128, xmm, xmm [XOP]
func (*Program) VPCOMW ¶
func (self *Program) VPCOMW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPCOMW performs "Compare Packed Signed Word Integers".
Mnemonic : VPCOMW Supported forms : (2 forms)
- VPCOMW imm8, xmm, xmm, xmm [XOP]
- VPCOMW imm8, m128, xmm, xmm [XOP]
func (*Program) VPCONFLICTD ¶
func (self *Program) VPCONFLICTD(v0 interface{}, v1 interface{}) *Instruction
VPCONFLICTD performs "Detect Conflicts Within a Vector of Packed Doubleword Values into Dense Memory/Register".
Mnemonic : VPCONFLICTD Supported forms : (6 forms)
- VPCONFLICTD m128/m32bcst, xmm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTD m256/m32bcst, ymm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTD m512/m32bcst, zmm{k}{z} [AVX512CD]
- VPCONFLICTD xmm, xmm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTD ymm, ymm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTD zmm, zmm{k}{z} [AVX512CD]
func (*Program) VPCONFLICTQ ¶
func (self *Program) VPCONFLICTQ(v0 interface{}, v1 interface{}) *Instruction
VPCONFLICTQ performs "Detect Conflicts Within a Vector of Packed Quadword Values into Dense Memory/Register".
Mnemonic : VPCONFLICTQ Supported forms : (6 forms)
- VPCONFLICTQ m128/m64bcst, xmm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTQ m256/m64bcst, ymm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTQ m512/m64bcst, zmm{k}{z} [AVX512CD]
- VPCONFLICTQ xmm, xmm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTQ ymm, ymm{k}{z} [AVX512CD,AVX512VL]
- VPCONFLICTQ zmm, zmm{k}{z} [AVX512CD]
func (*Program) VPERM2F128 ¶
func (self *Program) VPERM2F128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPERM2F128 performs "Permute Floating-Point Values".
Mnemonic : VPERM2F128 Supported forms : (2 forms)
- VPERM2F128 imm8, ymm, ymm, ymm [AVX]
- VPERM2F128 imm8, m256, ymm, ymm [AVX]
func (*Program) VPERM2I128 ¶
func (self *Program) VPERM2I128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPERM2I128 performs "Permute 128-Bit Integer Values".
Mnemonic : VPERM2I128 Supported forms : (2 forms)
- VPERM2I128 imm8, ymm, ymm, ymm [AVX2]
- VPERM2I128 imm8, m256, ymm, ymm [AVX2]
func (*Program) VPERMB ¶
func (self *Program) VPERMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMB performs "Permute Byte Integers".
Mnemonic : VPERMB Supported forms : (6 forms)
- VPERMB xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMB m128, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMB ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMB m256, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMB zmm, zmm, zmm{k}{z} [AVX512VBMI]
- VPERMB m512, zmm, zmm{k}{z} [AVX512VBMI]
func (*Program) VPERMD ¶
func (self *Program) VPERMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMD performs "Permute Doubleword Integers".
Mnemonic : VPERMD Supported forms : (6 forms)
- VPERMD ymm, ymm, ymm [AVX2]
- VPERMD m256, ymm, ymm [AVX2]
- VPERMD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMD zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMI2B ¶
func (self *Program) VPERMI2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMI2B performs "Full Permute of Bytes From Two Tables Overwriting the Index".
Mnemonic : VPERMI2B Supported forms : (6 forms)
- VPERMI2B xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMI2B m128, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMI2B ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMI2B m256, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMI2B zmm, zmm, zmm{k}{z} [AVX512VBMI]
- VPERMI2B m512, zmm, zmm{k}{z} [AVX512VBMI]
func (*Program) VPERMI2D ¶
func (self *Program) VPERMI2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMI2D performs "Full Permute of Doublewords From Two Tables Overwriting the Index".
Mnemonic : VPERMI2D Supported forms : (6 forms)
- VPERMI2D m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMI2D zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMI2D m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2D xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2D m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMI2D ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMI2PD ¶
func (self *Program) VPERMI2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMI2PD performs "Full Permute of Double-Precision Floating-Point Values From Two Tables Overwriting the Index".
Mnemonic : VPERMI2PD Supported forms : (6 forms)
- VPERMI2PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMI2PD zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMI2PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMI2PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMI2PS ¶
func (self *Program) VPERMI2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMI2PS performs "Full Permute of Single-Precision Floating-Point Values From Two Tables Overwriting the Index".
Mnemonic : VPERMI2PS Supported forms : (6 forms)
- VPERMI2PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMI2PS zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMI2PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMI2PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMI2Q ¶
func (self *Program) VPERMI2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMI2Q performs "Full Permute of Quadwords From Two Tables Overwriting the Index".
Mnemonic : VPERMI2Q Supported forms : (6 forms)
- VPERMI2Q m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMI2Q zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMI2Q m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2Q xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMI2Q m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMI2Q ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMI2W ¶
func (self *Program) VPERMI2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMI2W performs "Full Permute of Words From Two Tables Overwriting the Index".
Mnemonic : VPERMI2W Supported forms : (6 forms)
- VPERMI2W zmm, zmm, zmm{k}{z} [AVX512BW]
- VPERMI2W m512, zmm, zmm{k}{z} [AVX512BW]
- VPERMI2W xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPERMI2W m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPERMI2W ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPERMI2W m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPERMIL2PD ¶
func (self *Program) VPERMIL2PD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction
VPERMIL2PD performs "Permute Two-Source Double-Precision Floating-Point Vectors".
Mnemonic : VPERMIL2PD Supported forms : (6 forms)
- VPERMIL2PD imm4, xmm, xmm, xmm, xmm [XOP]
- VPERMIL2PD imm4, m128, xmm, xmm, xmm [XOP]
- VPERMIL2PD imm4, xmm, m128, xmm, xmm [XOP]
- VPERMIL2PD imm4, ymm, ymm, ymm, ymm [XOP]
- VPERMIL2PD imm4, m256, ymm, ymm, ymm [XOP]
- VPERMIL2PD imm4, ymm, m256, ymm, ymm [XOP]
func (*Program) VPERMIL2PS ¶
func (self *Program) VPERMIL2PS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction
VPERMIL2PS performs "Permute Two-Source Single-Precision Floating-Point Vectors".
Mnemonic : VPERMIL2PS Supported forms : (6 forms)
- VPERMIL2PS imm4, xmm, xmm, xmm, xmm [XOP]
- VPERMIL2PS imm4, m128, xmm, xmm, xmm [XOP]
- VPERMIL2PS imm4, xmm, m128, xmm, xmm [XOP]
- VPERMIL2PS imm4, ymm, ymm, ymm, ymm [XOP]
- VPERMIL2PS imm4, m256, ymm, ymm, ymm [XOP]
- VPERMIL2PS imm4, ymm, m256, ymm, ymm [XOP]
func (*Program) VPERMILPD ¶
func (self *Program) VPERMILPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMILPD performs "Permute Double-Precision Floating-Point Values".
Mnemonic : VPERMILPD Supported forms : (20 forms)
- VPERMILPD imm8, xmm, xmm [AVX]
- VPERMILPD xmm, xmm, xmm [AVX]
- VPERMILPD m128, xmm, xmm [AVX]
- VPERMILPD imm8, m128, xmm [AVX]
- VPERMILPD imm8, ymm, ymm [AVX]
- VPERMILPD ymm, ymm, ymm [AVX]
- VPERMILPD m256, ymm, ymm [AVX]
- VPERMILPD imm8, m256, ymm [AVX]
- VPERMILPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPERMILPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMILPD imm8, zmm, zmm{k}{z} [AVX512F]
- VPERMILPD zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMILPD imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMILPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMILPS ¶
func (self *Program) VPERMILPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMILPS performs "Permute Single-Precision Floating-Point Values".
Mnemonic : VPERMILPS Supported forms : (20 forms)
- VPERMILPS imm8, xmm, xmm [AVX]
- VPERMILPS xmm, xmm, xmm [AVX]
- VPERMILPS m128, xmm, xmm [AVX]
- VPERMILPS imm8, m128, xmm [AVX]
- VPERMILPS imm8, ymm, ymm [AVX]
- VPERMILPS ymm, ymm, ymm [AVX]
- VPERMILPS m256, ymm, ymm [AVX]
- VPERMILPS imm8, m256, ymm [AVX]
- VPERMILPS imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPERMILPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMILPS imm8, zmm, zmm{k}{z} [AVX512F]
- VPERMILPS zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMILPS imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMILPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMPD ¶
func (self *Program) VPERMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMPD performs "Permute Double-Precision Floating-Point Elements".
Mnemonic : VPERMPD Supported forms : (10 forms)
- VPERMPD imm8, ymm, ymm [AVX2]
- VPERMPD imm8, m256, ymm [AVX2]
- VPERMPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPERMPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMPD imm8, zmm, zmm{k}{z} [AVX512F]
- VPERMPD zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMPS ¶
func (self *Program) VPERMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMPS performs "Permute Single-Precision Floating-Point Elements".
Mnemonic : VPERMPS Supported forms : (6 forms)
- VPERMPS ymm, ymm, ymm [AVX2]
- VPERMPS m256, ymm, ymm [AVX2]
- VPERMPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMPS zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMQ ¶
func (self *Program) VPERMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMQ performs "Permute Quadword Integers".
Mnemonic : VPERMQ Supported forms : (10 forms)
- VPERMQ imm8, ymm, ymm [AVX2]
- VPERMQ imm8, m256, ymm [AVX2]
- VPERMQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPERMQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMQ imm8, zmm, zmm{k}{z} [AVX512F]
- VPERMQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMT2B ¶
func (self *Program) VPERMT2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMT2B performs "Full Permute of Bytes From Two Tables Overwriting a Table".
Mnemonic : VPERMT2B Supported forms : (6 forms)
- VPERMT2B xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMT2B m128, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMT2B ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMT2B m256, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPERMT2B zmm, zmm, zmm{k}{z} [AVX512VBMI]
- VPERMT2B m512, zmm, zmm{k}{z} [AVX512VBMI]
func (*Program) VPERMT2D ¶
func (self *Program) VPERMT2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMT2D performs "Full Permute of Doublewords From Two Tables Overwriting a Table".
Mnemonic : VPERMT2D Supported forms : (6 forms)
- VPERMT2D m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMT2D zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMT2D m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2D xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2D m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMT2D ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMT2PD ¶
func (self *Program) VPERMT2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMT2PD performs "Full Permute of Double-Precision Floating-Point Values From Two Tables Overwriting a Table".
Mnemonic : VPERMT2PD Supported forms : (6 forms)
- VPERMT2PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMT2PD zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMT2PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMT2PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMT2PS ¶
func (self *Program) VPERMT2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMT2PS performs "Full Permute of Single-Precision Floating-Point Values From Two Tables Overwriting a Table".
Mnemonic : VPERMT2PS Supported forms : (6 forms)
- VPERMT2PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMT2PS zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMT2PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMT2PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMT2Q ¶
func (self *Program) VPERMT2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMT2Q performs "Full Permute of Quadwords From Two Tables Overwriting a Table".
Mnemonic : VPERMT2Q Supported forms : (6 forms)
- VPERMT2Q m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPERMT2Q zmm, zmm, zmm{k}{z} [AVX512F]
- VPERMT2Q m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2Q xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPERMT2Q m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPERMT2Q ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPERMT2W ¶
func (self *Program) VPERMT2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMT2W performs "Full Permute of Words From Two Tables Overwriting a Table".
Mnemonic : VPERMT2W Supported forms : (6 forms)
- VPERMT2W zmm, zmm, zmm{k}{z} [AVX512BW]
- VPERMT2W m512, zmm, zmm{k}{z} [AVX512BW]
- VPERMT2W xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPERMT2W m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPERMT2W ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPERMT2W m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPERMW ¶
func (self *Program) VPERMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPERMW performs "Permute Word Integers".
Mnemonic : VPERMW Supported forms : (6 forms)
- VPERMW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPERMW m512, zmm, zmm{k}{z} [AVX512BW]
- VPERMW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPERMW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPERMW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPERMW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPEXPANDD ¶
func (self *Program) VPEXPANDD(v0 interface{}, v1 interface{}) *Instruction
VPEXPANDD performs "Load Sparse Packed Doubleword Integer Values from Dense Memory/Register".
Mnemonic : VPEXPANDD Supported forms : (6 forms)
- VPEXPANDD zmm, zmm{k}{z} [AVX512F]
- VPEXPANDD m512, zmm{k}{z} [AVX512F]
- VPEXPANDD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPEXPANDD ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPEXPANDD m128, xmm{k}{z} [AVX512F,AVX512VL]
- VPEXPANDD m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPEXPANDQ ¶
func (self *Program) VPEXPANDQ(v0 interface{}, v1 interface{}) *Instruction
VPEXPANDQ performs "Load Sparse Packed Quadword Integer Values from Dense Memory/Register".
Mnemonic : VPEXPANDQ Supported forms : (6 forms)
- VPEXPANDQ zmm, zmm{k}{z} [AVX512F]
- VPEXPANDQ m512, zmm{k}{z} [AVX512F]
- VPEXPANDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPEXPANDQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPEXPANDQ m128, xmm{k}{z} [AVX512F,AVX512VL]
- VPEXPANDQ m256, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPEXTRB ¶
func (self *Program) VPEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPEXTRB performs "Extract Byte".
Mnemonic : VPEXTRB Supported forms : (4 forms)
- VPEXTRB imm8, xmm, r32 [AVX]
- VPEXTRB imm8, xmm, m8 [AVX]
- VPEXTRB imm8, xmm, r32 [AVX512BW]
- VPEXTRB imm8, xmm, m8 [AVX512BW]
func (*Program) VPEXTRD ¶
func (self *Program) VPEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPEXTRD performs "Extract Doubleword".
Mnemonic : VPEXTRD Supported forms : (4 forms)
- VPEXTRD imm8, xmm, r32 [AVX]
- VPEXTRD imm8, xmm, m32 [AVX]
- VPEXTRD imm8, xmm, r32 [AVX512DQ]
- VPEXTRD imm8, xmm, m32 [AVX512DQ]
func (*Program) VPEXTRQ ¶
func (self *Program) VPEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPEXTRQ performs "Extract Quadword".
Mnemonic : VPEXTRQ Supported forms : (4 forms)
- VPEXTRQ imm8, xmm, r64 [AVX]
- VPEXTRQ imm8, xmm, m64 [AVX]
- VPEXTRQ imm8, xmm, r64 [AVX512DQ]
- VPEXTRQ imm8, xmm, m64 [AVX512DQ]
func (*Program) VPEXTRW ¶
func (self *Program) VPEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPEXTRW performs "Extract Word".
Mnemonic : VPEXTRW Supported forms : (4 forms)
- VPEXTRW imm8, xmm, r32 [AVX]
- VPEXTRW imm8, xmm, m16 [AVX]
- VPEXTRW imm8, xmm, r32 [AVX512BW]
- VPEXTRW imm8, xmm, m16 [AVX512BW]
func (*Program) VPGATHERDD ¶
func (self *Program) VPGATHERDD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VPGATHERDD performs "Gather Packed Doubleword Values Using Signed Doubleword Indices".
Mnemonic : VPGATHERDD Supported forms : (5 forms)
- VPGATHERDD xmm, vm32x, xmm [AVX2]
- VPGATHERDD ymm, vm32y, ymm [AVX2]
- VPGATHERDD vm32z, zmm{k} [AVX512F]
- VPGATHERDD vm32x, xmm{k} [AVX512F,AVX512VL]
- VPGATHERDD vm32y, ymm{k} [AVX512F,AVX512VL]
func (*Program) VPGATHERDQ ¶
func (self *Program) VPGATHERDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VPGATHERDQ performs "Gather Packed Quadword Values Using Signed Doubleword Indices".
Mnemonic : VPGATHERDQ Supported forms : (5 forms)
- VPGATHERDQ xmm, vm32x, xmm [AVX2]
- VPGATHERDQ ymm, vm32x, ymm [AVX2]
- VPGATHERDQ vm32y, zmm{k} [AVX512F]
- VPGATHERDQ vm32x, xmm{k} [AVX512F,AVX512VL]
- VPGATHERDQ vm32x, ymm{k} [AVX512F,AVX512VL]
func (*Program) VPGATHERQD ¶
func (self *Program) VPGATHERQD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VPGATHERQD performs "Gather Packed Doubleword Values Using Signed Quadword Indices".
Mnemonic : VPGATHERQD Supported forms : (5 forms)
- VPGATHERQD xmm, vm64x, xmm [AVX2]
- VPGATHERQD xmm, vm64y, xmm [AVX2]
- VPGATHERQD vm64z, ymm{k} [AVX512F]
- VPGATHERQD vm64x, xmm{k} [AVX512F,AVX512VL]
- VPGATHERQD vm64y, xmm{k} [AVX512F,AVX512VL]
func (*Program) VPGATHERQQ ¶
func (self *Program) VPGATHERQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VPGATHERQQ performs "Gather Packed Quadword Values Using Signed Quadword Indices".
Mnemonic : VPGATHERQQ Supported forms : (5 forms)
- VPGATHERQQ xmm, vm64x, xmm [AVX2]
- VPGATHERQQ ymm, vm64y, ymm [AVX2]
- VPGATHERQQ vm64z, zmm{k} [AVX512F]
- VPGATHERQQ vm64x, xmm{k} [AVX512F,AVX512VL]
- VPGATHERQQ vm64y, ymm{k} [AVX512F,AVX512VL]
func (*Program) VPHADDBD ¶
func (self *Program) VPHADDBD(v0 interface{}, v1 interface{}) *Instruction
VPHADDBD performs "Packed Horizontal Add Signed Byte to Signed Doubleword".
Mnemonic : VPHADDBD Supported forms : (2 forms)
- VPHADDBD xmm, xmm [XOP]
- VPHADDBD m128, xmm [XOP]
func (*Program) VPHADDBQ ¶
func (self *Program) VPHADDBQ(v0 interface{}, v1 interface{}) *Instruction
VPHADDBQ performs "Packed Horizontal Add Signed Byte to Signed Quadword".
Mnemonic : VPHADDBQ Supported forms : (2 forms)
- VPHADDBQ xmm, xmm [XOP]
- VPHADDBQ m128, xmm [XOP]
func (*Program) VPHADDBW ¶
func (self *Program) VPHADDBW(v0 interface{}, v1 interface{}) *Instruction
VPHADDBW performs "Packed Horizontal Add Signed Byte to Signed Word".
Mnemonic : VPHADDBW Supported forms : (2 forms)
- VPHADDBW xmm, xmm [XOP]
- VPHADDBW m128, xmm [XOP]
func (*Program) VPHADDD ¶
func (self *Program) VPHADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPHADDD performs "Packed Horizontal Add Doubleword Integer".
Mnemonic : VPHADDD Supported forms : (4 forms)
- VPHADDD xmm, xmm, xmm [AVX]
- VPHADDD m128, xmm, xmm [AVX]
- VPHADDD ymm, ymm, ymm [AVX2]
- VPHADDD m256, ymm, ymm [AVX2]
func (*Program) VPHADDDQ ¶
func (self *Program) VPHADDDQ(v0 interface{}, v1 interface{}) *Instruction
VPHADDDQ performs "Packed Horizontal Add Signed Doubleword to Signed Quadword".
Mnemonic : VPHADDDQ Supported forms : (2 forms)
- VPHADDDQ xmm, xmm [XOP]
- VPHADDDQ m128, xmm [XOP]
func (*Program) VPHADDSW ¶
func (self *Program) VPHADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPHADDSW performs "Packed Horizontal Add Signed Word Integers with Signed Saturation".
Mnemonic : VPHADDSW Supported forms : (4 forms)
- VPHADDSW xmm, xmm, xmm [AVX]
- VPHADDSW m128, xmm, xmm [AVX]
- VPHADDSW ymm, ymm, ymm [AVX2]
- VPHADDSW m256, ymm, ymm [AVX2]
func (*Program) VPHADDUBD ¶
func (self *Program) VPHADDUBD(v0 interface{}, v1 interface{}) *Instruction
VPHADDUBD performs "Packed Horizontal Add Unsigned Byte to Doubleword".
Mnemonic : VPHADDUBD Supported forms : (2 forms)
- VPHADDUBD xmm, xmm [XOP]
- VPHADDUBD m128, xmm [XOP]
func (*Program) VPHADDUBQ ¶
func (self *Program) VPHADDUBQ(v0 interface{}, v1 interface{}) *Instruction
VPHADDUBQ performs "Packed Horizontal Add Unsigned Byte to Quadword".
Mnemonic : VPHADDUBQ Supported forms : (2 forms)
- VPHADDUBQ xmm, xmm [XOP]
- VPHADDUBQ m128, xmm [XOP]
func (*Program) VPHADDUBW ¶
func (self *Program) VPHADDUBW(v0 interface{}, v1 interface{}) *Instruction
VPHADDUBW performs "Packed Horizontal Add Unsigned Byte to Word".
Mnemonic : VPHADDUBW Supported forms : (2 forms)
- VPHADDUBW xmm, xmm [XOP]
- VPHADDUBW m128, xmm [XOP]
func (*Program) VPHADDUDQ ¶
func (self *Program) VPHADDUDQ(v0 interface{}, v1 interface{}) *Instruction
VPHADDUDQ performs "Packed Horizontal Add Unsigned Doubleword to Quadword".
Mnemonic : VPHADDUDQ Supported forms : (2 forms)
- VPHADDUDQ xmm, xmm [XOP]
- VPHADDUDQ m128, xmm [XOP]
func (*Program) VPHADDUWD ¶
func (self *Program) VPHADDUWD(v0 interface{}, v1 interface{}) *Instruction
VPHADDUWD performs "Packed Horizontal Add Unsigned Word to Doubleword".
Mnemonic : VPHADDUWD Supported forms : (2 forms)
- VPHADDUWD xmm, xmm [XOP]
- VPHADDUWD m128, xmm [XOP]
func (*Program) VPHADDUWQ ¶
func (self *Program) VPHADDUWQ(v0 interface{}, v1 interface{}) *Instruction
VPHADDUWQ performs "Packed Horizontal Add Unsigned Word to Quadword".
Mnemonic : VPHADDUWQ Supported forms : (2 forms)
- VPHADDUWQ xmm, xmm [XOP]
- VPHADDUWQ m128, xmm [XOP]
func (*Program) VPHADDW ¶
func (self *Program) VPHADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPHADDW performs "Packed Horizontal Add Word Integers".
Mnemonic : VPHADDW Supported forms : (4 forms)
- VPHADDW xmm, xmm, xmm [AVX]
- VPHADDW m128, xmm, xmm [AVX]
- VPHADDW ymm, ymm, ymm [AVX2]
- VPHADDW m256, ymm, ymm [AVX2]
func (*Program) VPHADDWD ¶
func (self *Program) VPHADDWD(v0 interface{}, v1 interface{}) *Instruction
VPHADDWD performs "Packed Horizontal Add Signed Word to Signed Doubleword".
Mnemonic : VPHADDWD Supported forms : (2 forms)
- VPHADDWD xmm, xmm [XOP]
- VPHADDWD m128, xmm [XOP]
func (*Program) VPHADDWQ ¶
func (self *Program) VPHADDWQ(v0 interface{}, v1 interface{}) *Instruction
VPHADDWQ performs "Packed Horizontal Add Signed Word to Signed Quadword".
Mnemonic : VPHADDWQ Supported forms : (2 forms)
- VPHADDWQ xmm, xmm [XOP]
- VPHADDWQ m128, xmm [XOP]
func (*Program) VPHMINPOSUW ¶
func (self *Program) VPHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction
VPHMINPOSUW performs "Packed Horizontal Minimum of Unsigned Word Integers".
Mnemonic : VPHMINPOSUW Supported forms : (2 forms)
- VPHMINPOSUW xmm, xmm [AVX]
- VPHMINPOSUW m128, xmm [AVX]
func (*Program) VPHSUBBW ¶
func (self *Program) VPHSUBBW(v0 interface{}, v1 interface{}) *Instruction
VPHSUBBW performs "Packed Horizontal Subtract Signed Byte to Signed Word".
Mnemonic : VPHSUBBW Supported forms : (2 forms)
- VPHSUBBW xmm, xmm [XOP]
- VPHSUBBW m128, xmm [XOP]
func (*Program) VPHSUBD ¶
func (self *Program) VPHSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPHSUBD performs "Packed Horizontal Subtract Doubleword Integers".
Mnemonic : VPHSUBD Supported forms : (4 forms)
- VPHSUBD xmm, xmm, xmm [AVX]
- VPHSUBD m128, xmm, xmm [AVX]
- VPHSUBD ymm, ymm, ymm [AVX2]
- VPHSUBD m256, ymm, ymm [AVX2]
func (*Program) VPHSUBDQ ¶
func (self *Program) VPHSUBDQ(v0 interface{}, v1 interface{}) *Instruction
VPHSUBDQ performs "Packed Horizontal Subtract Signed Doubleword to Signed Quadword".
Mnemonic : VPHSUBDQ Supported forms : (2 forms)
- VPHSUBDQ xmm, xmm [XOP]
- VPHSUBDQ m128, xmm [XOP]
func (*Program) VPHSUBSW ¶
func (self *Program) VPHSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPHSUBSW performs "Packed Horizontal Subtract Signed Word Integers with Signed Saturation".
Mnemonic : VPHSUBSW Supported forms : (4 forms)
- VPHSUBSW xmm, xmm, xmm [AVX]
- VPHSUBSW m128, xmm, xmm [AVX]
- VPHSUBSW ymm, ymm, ymm [AVX2]
- VPHSUBSW m256, ymm, ymm [AVX2]
func (*Program) VPHSUBW ¶
func (self *Program) VPHSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPHSUBW performs "Packed Horizontal Subtract Word Integers".
Mnemonic : VPHSUBW Supported forms : (4 forms)
- VPHSUBW xmm, xmm, xmm [AVX]
- VPHSUBW m128, xmm, xmm [AVX]
- VPHSUBW ymm, ymm, ymm [AVX2]
- VPHSUBW m256, ymm, ymm [AVX2]
func (*Program) VPHSUBWD ¶
func (self *Program) VPHSUBWD(v0 interface{}, v1 interface{}) *Instruction
VPHSUBWD performs "Packed Horizontal Subtract Signed Word to Signed Doubleword".
Mnemonic : VPHSUBWD Supported forms : (2 forms)
- VPHSUBWD xmm, xmm [XOP]
- VPHSUBWD m128, xmm [XOP]
func (*Program) VPINSRB ¶
func (self *Program) VPINSRB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPINSRB performs "Insert Byte".
Mnemonic : VPINSRB Supported forms : (4 forms)
- VPINSRB imm8, r32, xmm, xmm [AVX]
- VPINSRB imm8, m8, xmm, xmm [AVX]
- VPINSRB imm8, r32, xmm, xmm [AVX512BW]
- VPINSRB imm8, m8, xmm, xmm [AVX512BW]
func (*Program) VPINSRD ¶
func (self *Program) VPINSRD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPINSRD performs "Insert Doubleword".
Mnemonic : VPINSRD Supported forms : (4 forms)
- VPINSRD imm8, r32, xmm, xmm [AVX]
- VPINSRD imm8, m32, xmm, xmm [AVX]
- VPINSRD imm8, r32, xmm, xmm [AVX512DQ]
- VPINSRD imm8, m32, xmm, xmm [AVX512DQ]
func (*Program) VPINSRQ ¶
func (self *Program) VPINSRQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPINSRQ performs "Insert Quadword".
Mnemonic : VPINSRQ Supported forms : (4 forms)
- VPINSRQ imm8, r64, xmm, xmm [AVX]
- VPINSRQ imm8, m64, xmm, xmm [AVX]
- VPINSRQ imm8, r64, xmm, xmm [AVX512DQ]
- VPINSRQ imm8, m64, xmm, xmm [AVX512DQ]
func (*Program) VPINSRW ¶
func (self *Program) VPINSRW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPINSRW performs "Insert Word".
Mnemonic : VPINSRW Supported forms : (4 forms)
- VPINSRW imm8, r32, xmm, xmm [AVX]
- VPINSRW imm8, m16, xmm, xmm [AVX]
- VPINSRW imm8, r32, xmm, xmm [AVX512BW]
- VPINSRW imm8, m16, xmm, xmm [AVX512BW]
func (*Program) VPLZCNTD ¶
func (self *Program) VPLZCNTD(v0 interface{}, v1 interface{}) *Instruction
VPLZCNTD performs "Count the Number of Leading Zero Bits for Packed Doubleword Values".
Mnemonic : VPLZCNTD Supported forms : (6 forms)
- VPLZCNTD m128/m32bcst, xmm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTD m256/m32bcst, ymm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTD m512/m32bcst, zmm{k}{z} [AVX512CD]
- VPLZCNTD xmm, xmm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTD ymm, ymm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTD zmm, zmm{k}{z} [AVX512CD]
func (*Program) VPLZCNTQ ¶
func (self *Program) VPLZCNTQ(v0 interface{}, v1 interface{}) *Instruction
VPLZCNTQ performs "Count the Number of Leading Zero Bits for Packed Quadword Values".
Mnemonic : VPLZCNTQ Supported forms : (6 forms)
- VPLZCNTQ m128/m64bcst, xmm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTQ m256/m64bcst, ymm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTQ m512/m64bcst, zmm{k}{z} [AVX512CD]
- VPLZCNTQ xmm, xmm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTQ ymm, ymm{k}{z} [AVX512CD,AVX512VL]
- VPLZCNTQ zmm, zmm{k}{z} [AVX512CD]
func (*Program) VPMACSDD ¶
func (self *Program) VPMACSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSDD performs "Packed Multiply Accumulate Signed Doubleword to Signed Doubleword".
Mnemonic : VPMACSDD Supported forms : (2 forms)
- VPMACSDD xmm, xmm, xmm, xmm [XOP]
- VPMACSDD xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSDQH ¶
func (self *Program) VPMACSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSDQH performs "Packed Multiply Accumulate Signed High Doubleword to Signed Quadword".
Mnemonic : VPMACSDQH Supported forms : (2 forms)
- VPMACSDQH xmm, xmm, xmm, xmm [XOP]
- VPMACSDQH xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSDQL ¶
func (self *Program) VPMACSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSDQL performs "Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword".
Mnemonic : VPMACSDQL Supported forms : (2 forms)
- VPMACSDQL xmm, xmm, xmm, xmm [XOP]
- VPMACSDQL xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSSDD ¶
func (self *Program) VPMACSSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSSDD performs "Packed Multiply Accumulate with Saturation Signed Doubleword to Signed Doubleword".
Mnemonic : VPMACSSDD Supported forms : (2 forms)
- VPMACSSDD xmm, xmm, xmm, xmm [XOP]
- VPMACSSDD xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSSDQH ¶
func (self *Program) VPMACSSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSSDQH performs "Packed Multiply Accumulate with Saturation Signed High Doubleword to Signed Quadword".
Mnemonic : VPMACSSDQH Supported forms : (2 forms)
- VPMACSSDQH xmm, xmm, xmm, xmm [XOP]
- VPMACSSDQH xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSSDQL ¶
func (self *Program) VPMACSSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSSDQL performs "Packed Multiply Accumulate with Saturation Signed Low Doubleword to Signed Quadword".
Mnemonic : VPMACSSDQL Supported forms : (2 forms)
- VPMACSSDQL xmm, xmm, xmm, xmm [XOP]
- VPMACSSDQL xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSSWD ¶
func (self *Program) VPMACSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSSWD performs "Packed Multiply Accumulate with Saturation Signed Word to Signed Doubleword".
Mnemonic : VPMACSSWD Supported forms : (2 forms)
- VPMACSSWD xmm, xmm, xmm, xmm [XOP]
- VPMACSSWD xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSSWW ¶
func (self *Program) VPMACSSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSSWW performs "Packed Multiply Accumulate with Saturation Signed Word to Signed Word".
Mnemonic : VPMACSSWW Supported forms : (2 forms)
- VPMACSSWW xmm, xmm, xmm, xmm [XOP]
- VPMACSSWW xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSWD ¶
func (self *Program) VPMACSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSWD performs "Packed Multiply Accumulate Signed Word to Signed Doubleword".
Mnemonic : VPMACSWD Supported forms : (2 forms)
- VPMACSWD xmm, xmm, xmm, xmm [XOP]
- VPMACSWD xmm, m128, xmm, xmm [XOP]
func (*Program) VPMACSWW ¶
func (self *Program) VPMACSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMACSWW performs "Packed Multiply Accumulate Signed Word to Signed Word".
Mnemonic : VPMACSWW Supported forms : (2 forms)
- VPMACSWW xmm, xmm, xmm, xmm [XOP]
- VPMACSWW xmm, m128, xmm, xmm [XOP]
func (*Program) VPMADCSSWD ¶
func (self *Program) VPMADCSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMADCSSWD performs "Packed Multiply Add Accumulate with Saturation Signed Word to Signed Doubleword".
Mnemonic : VPMADCSSWD Supported forms : (2 forms)
- VPMADCSSWD xmm, xmm, xmm, xmm [XOP]
- VPMADCSSWD xmm, m128, xmm, xmm [XOP]
func (*Program) VPMADCSWD ¶
func (self *Program) VPMADCSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPMADCSWD performs "Packed Multiply Add Accumulate Signed Word to Signed Doubleword".
Mnemonic : VPMADCSWD Supported forms : (2 forms)
- VPMADCSWD xmm, xmm, xmm, xmm [XOP]
- VPMADCSWD xmm, m128, xmm, xmm [XOP]
func (*Program) VPMADD52HUQ ¶
func (self *Program) VPMADD52HUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMADD52HUQ performs "Packed Multiply of Unsigned 52-bit Unsigned Integers and Add High 52-bit Products to Quadword Accumulators".
Mnemonic : VPMADD52HUQ Supported forms : (6 forms)
- VPMADD52HUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52HUQ xmm, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52HUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52HUQ ymm, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52HUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512IFMA]
- VPMADD52HUQ zmm, zmm, zmm{k}{z} [AVX512IFMA]
func (*Program) VPMADD52LUQ ¶
func (self *Program) VPMADD52LUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMADD52LUQ performs "Packed Multiply of Unsigned 52-bit Integers and Add the Low 52-bit Products to Quadword Accumulators".
Mnemonic : VPMADD52LUQ Supported forms : (6 forms)
- VPMADD52LUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52LUQ xmm, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52LUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52LUQ ymm, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
- VPMADD52LUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512IFMA]
- VPMADD52LUQ zmm, zmm, zmm{k}{z} [AVX512IFMA]
func (*Program) VPMADDUBSW ¶
func (self *Program) VPMADDUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMADDUBSW performs "Multiply and Add Packed Signed and Unsigned Byte Integers".
Mnemonic : VPMADDUBSW Supported forms : (10 forms)
- VPMADDUBSW xmm, xmm, xmm [AVX]
- VPMADDUBSW m128, xmm, xmm [AVX]
- VPMADDUBSW ymm, ymm, ymm [AVX2]
- VPMADDUBSW m256, ymm, ymm [AVX2]
- VPMADDUBSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMADDUBSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMADDUBSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMADDUBSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMADDUBSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMADDUBSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMADDWD ¶
func (self *Program) VPMADDWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMADDWD performs "Multiply and Add Packed Signed Word Integers".
Mnemonic : VPMADDWD Supported forms : (10 forms)
- VPMADDWD xmm, xmm, xmm [AVX]
- VPMADDWD m128, xmm, xmm [AVX]
- VPMADDWD ymm, ymm, ymm [AVX2]
- VPMADDWD m256, ymm, ymm [AVX2]
- VPMADDWD zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMADDWD m512, zmm, zmm{k}{z} [AVX512BW]
- VPMADDWD xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMADDWD m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMADDWD ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMADDWD m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMASKMOVD ¶
func (self *Program) VPMASKMOVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMASKMOVD performs "Conditional Move Packed Doubleword Integers".
Mnemonic : VPMASKMOVD Supported forms : (4 forms)
- VPMASKMOVD m128, xmm, xmm [AVX2]
- VPMASKMOVD m256, ymm, ymm [AVX2]
- VPMASKMOVD xmm, xmm, m128 [AVX2]
- VPMASKMOVD ymm, ymm, m256 [AVX2]
func (*Program) VPMASKMOVQ ¶
func (self *Program) VPMASKMOVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMASKMOVQ performs "Conditional Move Packed Quadword Integers".
Mnemonic : VPMASKMOVQ Supported forms : (4 forms)
- VPMASKMOVQ m128, xmm, xmm [AVX2]
- VPMASKMOVQ m256, ymm, ymm [AVX2]
- VPMASKMOVQ xmm, xmm, m128 [AVX2]
- VPMASKMOVQ ymm, ymm, m256 [AVX2]
func (*Program) VPMAXSB ¶
func (self *Program) VPMAXSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXSB performs "Maximum of Packed Signed Byte Integers".
Mnemonic : VPMAXSB Supported forms : (10 forms)
- VPMAXSB xmm, xmm, xmm [AVX]
- VPMAXSB m128, xmm, xmm [AVX]
- VPMAXSB ymm, ymm, ymm [AVX2]
- VPMAXSB m256, ymm, ymm [AVX2]
- VPMAXSB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMAXSB m512, zmm, zmm{k}{z} [AVX512BW]
- VPMAXSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMAXSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMAXSD ¶
func (self *Program) VPMAXSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXSD performs "Maximum of Packed Signed Doubleword Integers".
Mnemonic : VPMAXSD Supported forms : (10 forms)
- VPMAXSD xmm, xmm, xmm [AVX]
- VPMAXSD m128, xmm, xmm [AVX]
- VPMAXSD ymm, ymm, ymm [AVX2]
- VPMAXSD m256, ymm, ymm [AVX2]
- VPMAXSD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPMAXSD zmm, zmm, zmm{k}{z} [AVX512F]
- VPMAXSD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXSD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXSD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMAXSD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMAXSQ ¶
func (self *Program) VPMAXSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXSQ performs "Maximum of Packed Signed Quadword Integers".
Mnemonic : VPMAXSQ Supported forms : (6 forms)
- VPMAXSQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPMAXSQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPMAXSQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXSQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXSQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMAXSQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMAXSW ¶
func (self *Program) VPMAXSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXSW performs "Maximum of Packed Signed Word Integers".
Mnemonic : VPMAXSW Supported forms : (10 forms)
- VPMAXSW xmm, xmm, xmm [AVX]
- VPMAXSW m128, xmm, xmm [AVX]
- VPMAXSW ymm, ymm, ymm [AVX2]
- VPMAXSW m256, ymm, ymm [AVX2]
- VPMAXSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMAXSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMAXSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMAXSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMAXUB ¶
func (self *Program) VPMAXUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXUB performs "Maximum of Packed Unsigned Byte Integers".
Mnemonic : VPMAXUB Supported forms : (10 forms)
- VPMAXUB xmm, xmm, xmm [AVX]
- VPMAXUB m128, xmm, xmm [AVX]
- VPMAXUB ymm, ymm, ymm [AVX2]
- VPMAXUB m256, ymm, ymm [AVX2]
- VPMAXUB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMAXUB m512, zmm, zmm{k}{z} [AVX512BW]
- VPMAXUB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXUB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXUB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMAXUB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMAXUD ¶
func (self *Program) VPMAXUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXUD performs "Maximum of Packed Unsigned Doubleword Integers".
Mnemonic : VPMAXUD Supported forms : (10 forms)
- VPMAXUD xmm, xmm, xmm [AVX]
- VPMAXUD m128, xmm, xmm [AVX]
- VPMAXUD ymm, ymm, ymm [AVX2]
- VPMAXUD m256, ymm, ymm [AVX2]
- VPMAXUD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPMAXUD zmm, zmm, zmm{k}{z} [AVX512F]
- VPMAXUD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXUD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXUD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMAXUD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMAXUQ ¶
func (self *Program) VPMAXUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXUQ performs "Maximum of Packed Unsigned Quadword Integers".
Mnemonic : VPMAXUQ Supported forms : (6 forms)
- VPMAXUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPMAXUQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPMAXUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXUQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMAXUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMAXUQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMAXUW ¶
func (self *Program) VPMAXUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMAXUW performs "Maximum of Packed Unsigned Word Integers".
Mnemonic : VPMAXUW Supported forms : (10 forms)
- VPMAXUW xmm, xmm, xmm [AVX]
- VPMAXUW m128, xmm, xmm [AVX]
- VPMAXUW ymm, ymm, ymm [AVX2]
- VPMAXUW m256, ymm, ymm [AVX2]
- VPMAXUW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMAXUW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMAXUW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXUW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMAXUW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMAXUW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMINSB ¶
func (self *Program) VPMINSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINSB performs "Minimum of Packed Signed Byte Integers".
Mnemonic : VPMINSB Supported forms : (10 forms)
- VPMINSB xmm, xmm, xmm [AVX]
- VPMINSB m128, xmm, xmm [AVX]
- VPMINSB ymm, ymm, ymm [AVX2]
- VPMINSB m256, ymm, ymm [AVX2]
- VPMINSB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMINSB m512, zmm, zmm{k}{z} [AVX512BW]
- VPMINSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMINSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMINSD ¶
func (self *Program) VPMINSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINSD performs "Minimum of Packed Signed Doubleword Integers".
Mnemonic : VPMINSD Supported forms : (10 forms)
- VPMINSD xmm, xmm, xmm [AVX]
- VPMINSD m128, xmm, xmm [AVX]
- VPMINSD ymm, ymm, ymm [AVX2]
- VPMINSD m256, ymm, ymm [AVX2]
- VPMINSD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPMINSD zmm, zmm, zmm{k}{z} [AVX512F]
- VPMINSD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINSD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINSD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMINSD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMINSQ ¶
func (self *Program) VPMINSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINSQ performs "Minimum of Packed Signed Quadword Integers".
Mnemonic : VPMINSQ Supported forms : (6 forms)
- VPMINSQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPMINSQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPMINSQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINSQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINSQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMINSQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMINSW ¶
func (self *Program) VPMINSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINSW performs "Minimum of Packed Signed Word Integers".
Mnemonic : VPMINSW Supported forms : (10 forms)
- VPMINSW xmm, xmm, xmm [AVX]
- VPMINSW m128, xmm, xmm [AVX]
- VPMINSW ymm, ymm, ymm [AVX2]
- VPMINSW m256, ymm, ymm [AVX2]
- VPMINSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMINSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMINSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMINSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMINUB ¶
func (self *Program) VPMINUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINUB performs "Minimum of Packed Unsigned Byte Integers".
Mnemonic : VPMINUB Supported forms : (10 forms)
- VPMINUB xmm, xmm, xmm [AVX]
- VPMINUB m128, xmm, xmm [AVX]
- VPMINUB ymm, ymm, ymm [AVX2]
- VPMINUB m256, ymm, ymm [AVX2]
- VPMINUB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMINUB m512, zmm, zmm{k}{z} [AVX512BW]
- VPMINUB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINUB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINUB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMINUB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMINUD ¶
func (self *Program) VPMINUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINUD performs "Minimum of Packed Unsigned Doubleword Integers".
Mnemonic : VPMINUD Supported forms : (10 forms)
- VPMINUD xmm, xmm, xmm [AVX]
- VPMINUD m128, xmm, xmm [AVX]
- VPMINUD ymm, ymm, ymm [AVX2]
- VPMINUD m256, ymm, ymm [AVX2]
- VPMINUD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPMINUD zmm, zmm, zmm{k}{z} [AVX512F]
- VPMINUD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINUD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINUD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMINUD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMINUQ ¶
func (self *Program) VPMINUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINUQ performs "Minimum of Packed Unsigned Quadword Integers".
Mnemonic : VPMINUQ Supported forms : (6 forms)
- VPMINUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPMINUQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPMINUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINUQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMINUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMINUQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMINUW ¶
func (self *Program) VPMINUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMINUW performs "Minimum of Packed Unsigned Word Integers".
Mnemonic : VPMINUW Supported forms : (10 forms)
- VPMINUW xmm, xmm, xmm [AVX]
- VPMINUW m128, xmm, xmm [AVX]
- VPMINUW ymm, ymm, ymm [AVX2]
- VPMINUW m256, ymm, ymm [AVX2]
- VPMINUW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMINUW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMINUW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINUW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMINUW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMINUW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMOVB2M ¶
func (self *Program) VPMOVB2M(v0 interface{}, v1 interface{}) *Instruction
VPMOVB2M performs "Move Signs of Packed Byte Integers to Mask Register".
Mnemonic : VPMOVB2M Supported forms : (3 forms)
- VPMOVB2M zmm, k [AVX512BW]
- VPMOVB2M xmm, k [AVX512BW,AVX512VL]
- VPMOVB2M ymm, k [AVX512BW,AVX512VL]
func (*Program) VPMOVD2M ¶
func (self *Program) VPMOVD2M(v0 interface{}, v1 interface{}) *Instruction
VPMOVD2M performs "Move Signs of Packed Doubleword Integers to Mask Register".
Mnemonic : VPMOVD2M Supported forms : (3 forms)
- VPMOVD2M zmm, k [AVX512DQ]
- VPMOVD2M xmm, k [AVX512DQ,AVX512VL]
- VPMOVD2M ymm, k [AVX512DQ,AVX512VL]
func (*Program) VPMOVDB ¶
func (self *Program) VPMOVDB(v0 interface{}, v1 interface{}) *Instruction
VPMOVDB performs "Down Convert Packed Doubleword Values to Byte Values with Truncation".
Mnemonic : VPMOVDB Supported forms : (6 forms)
- VPMOVDB zmm, xmm{k}{z} [AVX512F]
- VPMOVDB zmm, m128{k}{z} [AVX512F]
- VPMOVDB xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVDB xmm, m32{k}{z} [AVX512F,AVX512VL]
- VPMOVDB ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVDB ymm, m64{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVDW ¶
func (self *Program) VPMOVDW(v0 interface{}, v1 interface{}) *Instruction
VPMOVDW performs "Down Convert Packed Doubleword Values to Word Values with Truncation".
Mnemonic : VPMOVDW Supported forms : (6 forms)
- VPMOVDW zmm, ymm{k}{z} [AVX512F]
- VPMOVDW zmm, m256{k}{z} [AVX512F]
- VPMOVDW xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVDW xmm, m64{k}{z} [AVX512F,AVX512VL]
- VPMOVDW ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVDW ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVM2B ¶
func (self *Program) VPMOVM2B(v0 interface{}, v1 interface{}) *Instruction
VPMOVM2B performs "Expand Bits of Mask Register to Packed Byte Integers".
Mnemonic : VPMOVM2B Supported forms : (3 forms)
- VPMOVM2B k, zmm [AVX512BW]
- VPMOVM2B k, xmm [AVX512BW,AVX512VL]
- VPMOVM2B k, ymm [AVX512BW,AVX512VL]
func (*Program) VPMOVM2D ¶
func (self *Program) VPMOVM2D(v0 interface{}, v1 interface{}) *Instruction
VPMOVM2D performs "Expand Bits of Mask Register to Packed Doubleword Integers".
Mnemonic : VPMOVM2D Supported forms : (3 forms)
- VPMOVM2D k, zmm [AVX512DQ]
- VPMOVM2D k, xmm [AVX512DQ,AVX512VL]
- VPMOVM2D k, ymm [AVX512DQ,AVX512VL]
func (*Program) VPMOVM2Q ¶
func (self *Program) VPMOVM2Q(v0 interface{}, v1 interface{}) *Instruction
VPMOVM2Q performs "Expand Bits of Mask Register to Packed Quadword Integers".
Mnemonic : VPMOVM2Q Supported forms : (3 forms)
- VPMOVM2Q k, zmm [AVX512DQ]
- VPMOVM2Q k, xmm [AVX512DQ,AVX512VL]
- VPMOVM2Q k, ymm [AVX512DQ,AVX512VL]
func (*Program) VPMOVM2W ¶
func (self *Program) VPMOVM2W(v0 interface{}, v1 interface{}) *Instruction
VPMOVM2W performs "Expand Bits of Mask Register to Packed Word Integers".
Mnemonic : VPMOVM2W Supported forms : (3 forms)
- VPMOVM2W k, zmm [AVX512BW]
- VPMOVM2W k, xmm [AVX512BW,AVX512VL]
- VPMOVM2W k, ymm [AVX512BW,AVX512VL]
func (*Program) VPMOVMSKB ¶
func (self *Program) VPMOVMSKB(v0 interface{}, v1 interface{}) *Instruction
VPMOVMSKB performs "Move Byte Mask".
Mnemonic : VPMOVMSKB Supported forms : (2 forms)
- VPMOVMSKB xmm, r32 [AVX]
- VPMOVMSKB ymm, r32 [AVX2]
func (*Program) VPMOVQ2M ¶
func (self *Program) VPMOVQ2M(v0 interface{}, v1 interface{}) *Instruction
VPMOVQ2M performs "Move Signs of Packed Quadword Integers to Mask Register".
Mnemonic : VPMOVQ2M Supported forms : (3 forms)
- VPMOVQ2M zmm, k [AVX512DQ]
- VPMOVQ2M xmm, k [AVX512DQ,AVX512VL]
- VPMOVQ2M ymm, k [AVX512DQ,AVX512VL]
func (*Program) VPMOVQB ¶
func (self *Program) VPMOVQB(v0 interface{}, v1 interface{}) *Instruction
VPMOVQB performs "Down Convert Packed Quadword Values to Byte Values with Truncation".
Mnemonic : VPMOVQB Supported forms : (6 forms)
- VPMOVQB zmm, xmm{k}{z} [AVX512F]
- VPMOVQB zmm, m64{k}{z} [AVX512F]
- VPMOVQB xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVQB xmm, m16{k}{z} [AVX512F,AVX512VL]
- VPMOVQB ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVQB ymm, m32{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVQD ¶
func (self *Program) VPMOVQD(v0 interface{}, v1 interface{}) *Instruction
VPMOVQD performs "Down Convert Packed Quadword Values to Doubleword Values with Truncation".
Mnemonic : VPMOVQD Supported forms : (6 forms)
- VPMOVQD zmm, ymm{k}{z} [AVX512F]
- VPMOVQD zmm, m256{k}{z} [AVX512F]
- VPMOVQD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVQD xmm, m64{k}{z} [AVX512F,AVX512VL]
- VPMOVQD ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVQD ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVQW ¶
func (self *Program) VPMOVQW(v0 interface{}, v1 interface{}) *Instruction
VPMOVQW performs "Down Convert Packed Quadword Values to Word Values with Truncation".
Mnemonic : VPMOVQW Supported forms : (6 forms)
- VPMOVQW zmm, xmm{k}{z} [AVX512F]
- VPMOVQW zmm, m128{k}{z} [AVX512F]
- VPMOVQW xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVQW xmm, m32{k}{z} [AVX512F,AVX512VL]
- VPMOVQW ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVQW ymm, m64{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSDB ¶
func (self *Program) VPMOVSDB(v0 interface{}, v1 interface{}) *Instruction
VPMOVSDB performs "Down Convert Packed Doubleword Values to Byte Values with Signed Saturation".
Mnemonic : VPMOVSDB Supported forms : (6 forms)
- VPMOVSDB zmm, xmm{k}{z} [AVX512F]
- VPMOVSDB zmm, m128{k}{z} [AVX512F]
- VPMOVSDB xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSDB xmm, m32{k}{z} [AVX512F,AVX512VL]
- VPMOVSDB ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSDB ymm, m64{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSDW ¶
func (self *Program) VPMOVSDW(v0 interface{}, v1 interface{}) *Instruction
VPMOVSDW performs "Down Convert Packed Doubleword Values to Word Values with Signed Saturation".
Mnemonic : VPMOVSDW Supported forms : (6 forms)
- VPMOVSDW zmm, ymm{k}{z} [AVX512F]
- VPMOVSDW zmm, m256{k}{z} [AVX512F]
- VPMOVSDW xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSDW xmm, m64{k}{z} [AVX512F,AVX512VL]
- VPMOVSDW ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSDW ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSQB ¶
func (self *Program) VPMOVSQB(v0 interface{}, v1 interface{}) *Instruction
VPMOVSQB performs "Down Convert Packed Quadword Values to Byte Values with Signed Saturation".
Mnemonic : VPMOVSQB Supported forms : (6 forms)
- VPMOVSQB zmm, xmm{k}{z} [AVX512F]
- VPMOVSQB zmm, m64{k}{z} [AVX512F]
- VPMOVSQB xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSQB xmm, m16{k}{z} [AVX512F,AVX512VL]
- VPMOVSQB ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSQB ymm, m32{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSQD ¶
func (self *Program) VPMOVSQD(v0 interface{}, v1 interface{}) *Instruction
VPMOVSQD performs "Down Convert Packed Quadword Values to Doubleword Values with Signed Saturation".
Mnemonic : VPMOVSQD Supported forms : (6 forms)
- VPMOVSQD zmm, ymm{k}{z} [AVX512F]
- VPMOVSQD zmm, m256{k}{z} [AVX512F]
- VPMOVSQD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSQD xmm, m64{k}{z} [AVX512F,AVX512VL]
- VPMOVSQD ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSQD ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSQW ¶
func (self *Program) VPMOVSQW(v0 interface{}, v1 interface{}) *Instruction
VPMOVSQW performs "Down Convert Packed Quadword Values to Word Values with Signed Saturation".
Mnemonic : VPMOVSQW Supported forms : (6 forms)
- VPMOVSQW zmm, xmm{k}{z} [AVX512F]
- VPMOVSQW zmm, m128{k}{z} [AVX512F]
- VPMOVSQW xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSQW xmm, m32{k}{z} [AVX512F,AVX512VL]
- VPMOVSQW ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSQW ymm, m64{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSWB ¶
func (self *Program) VPMOVSWB(v0 interface{}, v1 interface{}) *Instruction
VPMOVSWB performs "Down Convert Packed Word Values to Byte Values with Signed Saturation".
Mnemonic : VPMOVSWB Supported forms : (6 forms)
- VPMOVSWB zmm, ymm{k}{z} [AVX512BW]
- VPMOVSWB zmm, m256{k}{z} [AVX512BW]
- VPMOVSWB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVSWB xmm, m64{k}{z} [AVX512BW,AVX512VL]
- VPMOVSWB ymm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVSWB ymm, m128{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMOVSXBD ¶
func (self *Program) VPMOVSXBD(v0 interface{}, v1 interface{}) *Instruction
VPMOVSXBD performs "Move Packed Byte Integers to Doubleword Integers with Sign Extension".
Mnemonic : VPMOVSXBD Supported forms : (10 forms)
- VPMOVSXBD xmm, xmm [AVX]
- VPMOVSXBD m32, xmm [AVX]
- VPMOVSXBD xmm, ymm [AVX2]
- VPMOVSXBD m64, ymm [AVX2]
- VPMOVSXBD xmm, zmm{k}{z} [AVX512F]
- VPMOVSXBD m128, zmm{k}{z} [AVX512F]
- VPMOVSXBD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXBD xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXBD m32, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXBD m64, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSXBQ ¶
func (self *Program) VPMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction
VPMOVSXBQ performs "Move Packed Byte Integers to Quadword Integers with Sign Extension".
Mnemonic : VPMOVSXBQ Supported forms : (10 forms)
- VPMOVSXBQ xmm, xmm [AVX]
- VPMOVSXBQ m16, xmm [AVX]
- VPMOVSXBQ xmm, ymm [AVX2]
- VPMOVSXBQ m32, ymm [AVX2]
- VPMOVSXBQ xmm, zmm{k}{z} [AVX512F]
- VPMOVSXBQ m64, zmm{k}{z} [AVX512F]
- VPMOVSXBQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXBQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXBQ m16, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXBQ m32, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSXBW ¶
func (self *Program) VPMOVSXBW(v0 interface{}, v1 interface{}) *Instruction
VPMOVSXBW performs "Move Packed Byte Integers to Word Integers with Sign Extension".
Mnemonic : VPMOVSXBW Supported forms : (10 forms)
- VPMOVSXBW xmm, xmm [AVX]
- VPMOVSXBW m64, xmm [AVX]
- VPMOVSXBW xmm, ymm [AVX2]
- VPMOVSXBW m128, ymm [AVX2]
- VPMOVSXBW ymm, zmm{k}{z} [AVX512BW]
- VPMOVSXBW m256, zmm{k}{z} [AVX512BW]
- VPMOVSXBW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVSXBW xmm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMOVSXBW m64, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVSXBW m128, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMOVSXDQ ¶
func (self *Program) VPMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction
VPMOVSXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Sign Extension".
Mnemonic : VPMOVSXDQ Supported forms : (10 forms)
- VPMOVSXDQ xmm, xmm [AVX]
- VPMOVSXDQ m64, xmm [AVX]
- VPMOVSXDQ xmm, ymm [AVX2]
- VPMOVSXDQ m128, ymm [AVX2]
- VPMOVSXDQ ymm, zmm{k}{z} [AVX512F]
- VPMOVSXDQ m256, zmm{k}{z} [AVX512F]
- VPMOVSXDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXDQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXDQ m64, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXDQ m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSXWD ¶
func (self *Program) VPMOVSXWD(v0 interface{}, v1 interface{}) *Instruction
VPMOVSXWD performs "Move Packed Word Integers to Doubleword Integers with Sign Extension".
Mnemonic : VPMOVSXWD Supported forms : (10 forms)
- VPMOVSXWD xmm, xmm [AVX]
- VPMOVSXWD m64, xmm [AVX]
- VPMOVSXWD xmm, ymm [AVX2]
- VPMOVSXWD m128, ymm [AVX2]
- VPMOVSXWD ymm, zmm{k}{z} [AVX512F]
- VPMOVSXWD m256, zmm{k}{z} [AVX512F]
- VPMOVSXWD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXWD xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXWD m64, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXWD m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVSXWQ ¶
func (self *Program) VPMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction
VPMOVSXWQ performs "Move Packed Word Integers to Quadword Integers with Sign Extension".
Mnemonic : VPMOVSXWQ Supported forms : (10 forms)
- VPMOVSXWQ xmm, xmm [AVX]
- VPMOVSXWQ m32, xmm [AVX]
- VPMOVSXWQ xmm, ymm [AVX2]
- VPMOVSXWQ m64, ymm [AVX2]
- VPMOVSXWQ xmm, zmm{k}{z} [AVX512F]
- VPMOVSXWQ m128, zmm{k}{z} [AVX512F]
- VPMOVSXWQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXWQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXWQ m32, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVSXWQ m64, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVUSDB ¶
func (self *Program) VPMOVUSDB(v0 interface{}, v1 interface{}) *Instruction
VPMOVUSDB performs "Down Convert Packed Doubleword Values to Byte Values with Unsigned Saturation".
Mnemonic : VPMOVUSDB Supported forms : (6 forms)
- VPMOVUSDB zmm, xmm{k}{z} [AVX512F]
- VPMOVUSDB zmm, m128{k}{z} [AVX512F]
- VPMOVUSDB xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSDB xmm, m32{k}{z} [AVX512F,AVX512VL]
- VPMOVUSDB ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSDB ymm, m64{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVUSDW ¶
func (self *Program) VPMOVUSDW(v0 interface{}, v1 interface{}) *Instruction
VPMOVUSDW performs "Down Convert Packed Doubleword Values to Word Values with Unsigned Saturation".
Mnemonic : VPMOVUSDW Supported forms : (6 forms)
- VPMOVUSDW zmm, ymm{k}{z} [AVX512F]
- VPMOVUSDW zmm, m256{k}{z} [AVX512F]
- VPMOVUSDW xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSDW xmm, m64{k}{z} [AVX512F,AVX512VL]
- VPMOVUSDW ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSDW ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVUSQB ¶
func (self *Program) VPMOVUSQB(v0 interface{}, v1 interface{}) *Instruction
VPMOVUSQB performs "Down Convert Packed Quadword Values to Byte Values with Unsigned Saturation".
Mnemonic : VPMOVUSQB Supported forms : (6 forms)
- VPMOVUSQB zmm, xmm{k}{z} [AVX512F]
- VPMOVUSQB zmm, m64{k}{z} [AVX512F]
- VPMOVUSQB xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQB xmm, m16{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQB ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQB ymm, m32{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVUSQD ¶
func (self *Program) VPMOVUSQD(v0 interface{}, v1 interface{}) *Instruction
VPMOVUSQD performs "Down Convert Packed Quadword Values to Doubleword Values with Unsigned Saturation".
Mnemonic : VPMOVUSQD Supported forms : (6 forms)
- VPMOVUSQD zmm, ymm{k}{z} [AVX512F]
- VPMOVUSQD zmm, m256{k}{z} [AVX512F]
- VPMOVUSQD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQD xmm, m64{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQD ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQD ymm, m128{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVUSQW ¶
func (self *Program) VPMOVUSQW(v0 interface{}, v1 interface{}) *Instruction
VPMOVUSQW performs "Down Convert Packed Quadword Values to Word Values with Unsigned Saturation".
Mnemonic : VPMOVUSQW Supported forms : (6 forms)
- VPMOVUSQW zmm, xmm{k}{z} [AVX512F]
- VPMOVUSQW zmm, m128{k}{z} [AVX512F]
- VPMOVUSQW xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQW xmm, m32{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQW ymm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVUSQW ymm, m64{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVUSWB ¶
func (self *Program) VPMOVUSWB(v0 interface{}, v1 interface{}) *Instruction
VPMOVUSWB performs "Down Convert Packed Word Values to Byte Values with Unsigned Saturation".
Mnemonic : VPMOVUSWB Supported forms : (6 forms)
- VPMOVUSWB zmm, ymm{k}{z} [AVX512BW]
- VPMOVUSWB zmm, m256{k}{z} [AVX512BW]
- VPMOVUSWB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVUSWB xmm, m64{k}{z} [AVX512BW,AVX512VL]
- VPMOVUSWB ymm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVUSWB ymm, m128{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMOVW2M ¶
func (self *Program) VPMOVW2M(v0 interface{}, v1 interface{}) *Instruction
VPMOVW2M performs "Move Signs of Packed Word Integers to Mask Register".
Mnemonic : VPMOVW2M Supported forms : (3 forms)
- VPMOVW2M zmm, k [AVX512BW]
- VPMOVW2M xmm, k [AVX512BW,AVX512VL]
- VPMOVW2M ymm, k [AVX512BW,AVX512VL]
func (*Program) VPMOVWB ¶
func (self *Program) VPMOVWB(v0 interface{}, v1 interface{}) *Instruction
VPMOVWB performs "Down Convert Packed Word Values to Byte Values with Truncation".
Mnemonic : VPMOVWB Supported forms : (6 forms)
- VPMOVWB zmm, ymm{k}{z} [AVX512BW]
- VPMOVWB zmm, m256{k}{z} [AVX512BW]
- VPMOVWB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVWB xmm, m64{k}{z} [AVX512BW,AVX512VL]
- VPMOVWB ymm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVWB ymm, m128{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMOVZXBD ¶
func (self *Program) VPMOVZXBD(v0 interface{}, v1 interface{}) *Instruction
VPMOVZXBD performs "Move Packed Byte Integers to Doubleword Integers with Zero Extension".
Mnemonic : VPMOVZXBD Supported forms : (10 forms)
- VPMOVZXBD xmm, xmm [AVX]
- VPMOVZXBD m32, xmm [AVX]
- VPMOVZXBD xmm, ymm [AVX2]
- VPMOVZXBD m64, ymm [AVX2]
- VPMOVZXBD xmm, zmm{k}{z} [AVX512F]
- VPMOVZXBD m128, zmm{k}{z} [AVX512F]
- VPMOVZXBD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXBD xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXBD m32, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXBD m64, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVZXBQ ¶
func (self *Program) VPMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction
VPMOVZXBQ performs "Move Packed Byte Integers to Quadword Integers with Zero Extension".
Mnemonic : VPMOVZXBQ Supported forms : (10 forms)
- VPMOVZXBQ xmm, xmm [AVX]
- VPMOVZXBQ m16, xmm [AVX]
- VPMOVZXBQ xmm, ymm [AVX2]
- VPMOVZXBQ m32, ymm [AVX2]
- VPMOVZXBQ xmm, zmm{k}{z} [AVX512F]
- VPMOVZXBQ m64, zmm{k}{z} [AVX512F]
- VPMOVZXBQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXBQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXBQ m16, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXBQ m32, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVZXBW ¶
func (self *Program) VPMOVZXBW(v0 interface{}, v1 interface{}) *Instruction
VPMOVZXBW performs "Move Packed Byte Integers to Word Integers with Zero Extension".
Mnemonic : VPMOVZXBW Supported forms : (10 forms)
- VPMOVZXBW xmm, xmm [AVX]
- VPMOVZXBW m64, xmm [AVX]
- VPMOVZXBW xmm, ymm [AVX2]
- VPMOVZXBW m128, ymm [AVX2]
- VPMOVZXBW ymm, zmm{k}{z} [AVX512BW]
- VPMOVZXBW m256, zmm{k}{z} [AVX512BW]
- VPMOVZXBW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVZXBW xmm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMOVZXBW m64, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMOVZXBW m128, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMOVZXDQ ¶
func (self *Program) VPMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction
VPMOVZXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Zero Extension".
Mnemonic : VPMOVZXDQ Supported forms : (10 forms)
- VPMOVZXDQ xmm, xmm [AVX]
- VPMOVZXDQ m64, xmm [AVX]
- VPMOVZXDQ xmm, ymm [AVX2]
- VPMOVZXDQ m128, ymm [AVX2]
- VPMOVZXDQ ymm, zmm{k}{z} [AVX512F]
- VPMOVZXDQ m256, zmm{k}{z} [AVX512F]
- VPMOVZXDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXDQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXDQ m64, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXDQ m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVZXWD ¶
func (self *Program) VPMOVZXWD(v0 interface{}, v1 interface{}) *Instruction
VPMOVZXWD performs "Move Packed Word Integers to Doubleword Integers with Zero Extension".
Mnemonic : VPMOVZXWD Supported forms : (10 forms)
- VPMOVZXWD xmm, xmm [AVX]
- VPMOVZXWD m64, xmm [AVX]
- VPMOVZXWD xmm, ymm [AVX2]
- VPMOVZXWD m128, ymm [AVX2]
- VPMOVZXWD ymm, zmm{k}{z} [AVX512F]
- VPMOVZXWD m256, zmm{k}{z} [AVX512F]
- VPMOVZXWD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXWD xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXWD m64, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXWD m128, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMOVZXWQ ¶
func (self *Program) VPMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction
VPMOVZXWQ performs "Move Packed Word Integers to Quadword Integers with Zero Extension".
Mnemonic : VPMOVZXWQ Supported forms : (10 forms)
- VPMOVZXWQ xmm, xmm [AVX]
- VPMOVZXWQ m32, xmm [AVX]
- VPMOVZXWQ xmm, ymm [AVX2]
- VPMOVZXWQ m64, ymm [AVX2]
- VPMOVZXWQ xmm, zmm{k}{z} [AVX512F]
- VPMOVZXWQ m128, zmm{k}{z} [AVX512F]
- VPMOVZXWQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXWQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXWQ m32, xmm{k}{z} [AVX512F,AVX512VL]
- VPMOVZXWQ m64, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMULDQ ¶
func (self *Program) VPMULDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULDQ performs "Multiply Packed Signed Doubleword Integers and Store Quadword Result".
Mnemonic : VPMULDQ Supported forms : (10 forms)
- VPMULDQ xmm, xmm, xmm [AVX]
- VPMULDQ m128, xmm, xmm [AVX]
- VPMULDQ ymm, ymm, ymm [AVX2]
- VPMULDQ m256, ymm, ymm [AVX2]
- VPMULDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPMULDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPMULDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMULDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMULDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMULDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMULHRSW ¶
func (self *Program) VPMULHRSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULHRSW performs "Packed Multiply Signed Word Integers and Store High Result with Round and Scale".
Mnemonic : VPMULHRSW Supported forms : (10 forms)
- VPMULHRSW xmm, xmm, xmm [AVX]
- VPMULHRSW m128, xmm, xmm [AVX]
- VPMULHRSW ymm, ymm, ymm [AVX2]
- VPMULHRSW m256, ymm, ymm [AVX2]
- VPMULHRSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMULHRSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMULHRSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULHRSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULHRSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMULHRSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMULHUW ¶
func (self *Program) VPMULHUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULHUW performs "Multiply Packed Unsigned Word Integers and Store High Result".
Mnemonic : VPMULHUW Supported forms : (10 forms)
- VPMULHUW xmm, xmm, xmm [AVX]
- VPMULHUW m128, xmm, xmm [AVX]
- VPMULHUW ymm, ymm, ymm [AVX2]
- VPMULHUW m256, ymm, ymm [AVX2]
- VPMULHUW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMULHUW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMULHUW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULHUW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULHUW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMULHUW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMULHW ¶
func (self *Program) VPMULHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULHW performs "Multiply Packed Signed Word Integers and Store High Result".
Mnemonic : VPMULHW Supported forms : (10 forms)
- VPMULHW xmm, xmm, xmm [AVX]
- VPMULHW m128, xmm, xmm [AVX]
- VPMULHW ymm, ymm, ymm [AVX2]
- VPMULHW m256, ymm, ymm [AVX2]
- VPMULHW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMULHW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMULHW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULHW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULHW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMULHW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMULLD ¶
func (self *Program) VPMULLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULLD performs "Multiply Packed Signed Doubleword Integers and Store Low Result".
Mnemonic : VPMULLD Supported forms : (10 forms)
- VPMULLD xmm, xmm, xmm [AVX]
- VPMULLD m128, xmm, xmm [AVX]
- VPMULLD ymm, ymm, ymm [AVX2]
- VPMULLD m256, ymm, ymm [AVX2]
- VPMULLD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPMULLD zmm, zmm, zmm{k}{z} [AVX512F]
- VPMULLD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMULLD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMULLD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMULLD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPMULLQ ¶
func (self *Program) VPMULLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULLQ performs "Multiply Packed Signed Quadword Integers and Store Low Result".
Mnemonic : VPMULLQ Supported forms : (6 forms)
- VPMULLQ m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
- VPMULLQ zmm, zmm, zmm{k}{z} [AVX512DQ]
- VPMULLQ m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VPMULLQ xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VPMULLQ m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VPMULLQ ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VPMULLW ¶
func (self *Program) VPMULLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULLW performs "Multiply Packed Signed Word Integers and Store Low Result".
Mnemonic : VPMULLW Supported forms : (10 forms)
- VPMULLW xmm, xmm, xmm [AVX]
- VPMULLW m128, xmm, xmm [AVX]
- VPMULLW ymm, ymm, ymm [AVX2]
- VPMULLW m256, ymm, ymm [AVX2]
- VPMULLW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPMULLW m512, zmm, zmm{k}{z} [AVX512BW]
- VPMULLW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULLW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPMULLW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPMULLW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPMULTISHIFTQB ¶
func (self *Program) VPMULTISHIFTQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULTISHIFTQB performs "Select Packed Unaligned Bytes from Quadword Sources".
Mnemonic : VPMULTISHIFTQB Supported forms : (6 forms)
- VPMULTISHIFTQB m128/m64bcst, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPMULTISHIFTQB xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
- VPMULTISHIFTQB m256/m64bcst, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPMULTISHIFTQB ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
- VPMULTISHIFTQB m512/m64bcst, zmm, zmm{k}{z} [AVX512VBMI]
- VPMULTISHIFTQB zmm, zmm, zmm{k}{z} [AVX512VBMI]
func (*Program) VPMULUDQ ¶
func (self *Program) VPMULUDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPMULUDQ performs "Multiply Packed Unsigned Doubleword Integers".
Mnemonic : VPMULUDQ Supported forms : (10 forms)
- VPMULUDQ xmm, xmm, xmm [AVX]
- VPMULUDQ m128, xmm, xmm [AVX]
- VPMULUDQ ymm, ymm, ymm [AVX2]
- VPMULUDQ m256, ymm, ymm [AVX2]
- VPMULUDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPMULUDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPMULUDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMULUDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPMULUDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPMULUDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPOPCNTD ¶
func (self *Program) VPOPCNTD(v0 interface{}, v1 interface{}) *Instruction
VPOPCNTD performs "Packed Population Count for Doubleword Integers".
Mnemonic : VPOPCNTD Supported forms : (2 forms)
- VPOPCNTD m512/m32bcst, zmm{k}{z} [AVX512VPOPCNTDQ]
- VPOPCNTD zmm, zmm{k}{z} [AVX512VPOPCNTDQ]
func (*Program) VPOPCNTQ ¶
func (self *Program) VPOPCNTQ(v0 interface{}, v1 interface{}) *Instruction
VPOPCNTQ performs "Packed Population Count for Quadword Integers".
Mnemonic : VPOPCNTQ Supported forms : (2 forms)
- VPOPCNTQ m512/m64bcst, zmm{k}{z} [AVX512VPOPCNTDQ]
- VPOPCNTQ zmm, zmm{k}{z} [AVX512VPOPCNTDQ]
func (*Program) VPOR ¶
func (self *Program) VPOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPOR performs "Packed Bitwise Logical OR".
Mnemonic : VPOR Supported forms : (4 forms)
- VPOR xmm, xmm, xmm [AVX]
- VPOR m128, xmm, xmm [AVX]
- VPOR ymm, ymm, ymm [AVX2]
- VPOR m256, ymm, ymm [AVX2]
func (*Program) VPORD ¶
func (self *Program) VPORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPORD performs "Bitwise Logical OR of Packed Doubleword Integers".
Mnemonic : VPORD Supported forms : (6 forms)
- VPORD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPORD zmm, zmm, zmm{k}{z} [AVX512F]
- VPORD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPORD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPORD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPORD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPORQ ¶
func (self *Program) VPORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPORQ performs "Bitwise Logical OR of Packed Quadword Integers".
Mnemonic : VPORQ Supported forms : (6 forms)
- VPORQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPORQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPORQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPORQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPORQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPORQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPPERM ¶
func (self *Program) VPPERM(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPPERM performs "Packed Permute Bytes".
Mnemonic : VPPERM Supported forms : (3 forms)
- VPPERM xmm, xmm, xmm, xmm [XOP]
- VPPERM m128, xmm, xmm, xmm [XOP]
- VPPERM xmm, m128, xmm, xmm [XOP]
func (*Program) VPROLD ¶
func (self *Program) VPROLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROLD performs "Rotate Packed Doubleword Left".
Mnemonic : VPROLD Supported forms : (6 forms)
- VPROLD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPROLD imm8, zmm, zmm{k}{z} [AVX512F]
- VPROLD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPROLD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPROLQ ¶
func (self *Program) VPROLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROLQ performs "Rotate Packed Quadword Left".
Mnemonic : VPROLQ Supported forms : (6 forms)
- VPROLQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPROLQ imm8, zmm, zmm{k}{z} [AVX512F]
- VPROLQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPROLQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPROLVD ¶
func (self *Program) VPROLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROLVD performs "Variable Rotate Packed Doubleword Left".
Mnemonic : VPROLVD Supported forms : (6 forms)
- VPROLVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPROLVD zmm, zmm, zmm{k}{z} [AVX512F]
- VPROLVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPROLVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPROLVQ ¶
func (self *Program) VPROLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROLVQ performs "Variable Rotate Packed Quadword Left".
Mnemonic : VPROLVQ Supported forms : (6 forms)
- VPROLVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPROLVQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPROLVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPROLVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPROLVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPRORD ¶
func (self *Program) VPRORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPRORD performs "Rotate Packed Doubleword Right".
Mnemonic : VPRORD Supported forms : (6 forms)
- VPRORD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPRORD imm8, zmm, zmm{k}{z} [AVX512F]
- VPRORD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPRORD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPRORQ ¶
func (self *Program) VPRORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPRORQ performs "Rotate Packed Quadword Right".
Mnemonic : VPRORQ Supported forms : (6 forms)
- VPRORQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPRORQ imm8, zmm, zmm{k}{z} [AVX512F]
- VPRORQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPRORQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPRORVD ¶
func (self *Program) VPRORVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPRORVD performs "Variable Rotate Packed Doubleword Right".
Mnemonic : VPRORVD Supported forms : (6 forms)
- VPRORVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPRORVD zmm, zmm, zmm{k}{z} [AVX512F]
- VPRORVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPRORVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPRORVQ ¶
func (self *Program) VPRORVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPRORVQ performs "Variable Rotate Packed Quadword Right".
Mnemonic : VPRORVQ Supported forms : (6 forms)
- VPRORVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPRORVQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPRORVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPRORVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPRORVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPROTB ¶
func (self *Program) VPROTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROTB performs "Packed Rotate Bytes".
Mnemonic : VPROTB Supported forms : (5 forms)
- VPROTB imm8, xmm, xmm [XOP]
- VPROTB xmm, xmm, xmm [XOP]
- VPROTB m128, xmm, xmm [XOP]
- VPROTB imm8, m128, xmm [XOP]
- VPROTB xmm, m128, xmm [XOP]
func (*Program) VPROTD ¶
func (self *Program) VPROTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROTD performs "Packed Rotate Doublewords".
Mnemonic : VPROTD Supported forms : (5 forms)
- VPROTD imm8, xmm, xmm [XOP]
- VPROTD xmm, xmm, xmm [XOP]
- VPROTD m128, xmm, xmm [XOP]
- VPROTD imm8, m128, xmm [XOP]
- VPROTD xmm, m128, xmm [XOP]
func (*Program) VPROTQ ¶
func (self *Program) VPROTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROTQ performs "Packed Rotate Quadwords".
Mnemonic : VPROTQ Supported forms : (5 forms)
- VPROTQ imm8, xmm, xmm [XOP]
- VPROTQ xmm, xmm, xmm [XOP]
- VPROTQ m128, xmm, xmm [XOP]
- VPROTQ imm8, m128, xmm [XOP]
- VPROTQ xmm, m128, xmm [XOP]
func (*Program) VPROTW ¶
func (self *Program) VPROTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPROTW performs "Packed Rotate Words".
Mnemonic : VPROTW Supported forms : (5 forms)
- VPROTW imm8, xmm, xmm [XOP]
- VPROTW xmm, xmm, xmm [XOP]
- VPROTW m128, xmm, xmm [XOP]
- VPROTW imm8, m128, xmm [XOP]
- VPROTW xmm, m128, xmm [XOP]
func (*Program) VPSADBW ¶
func (self *Program) VPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSADBW performs "Compute Sum of Absolute Differences".
Mnemonic : VPSADBW Supported forms : (10 forms)
- VPSADBW xmm, xmm, xmm [AVX]
- VPSADBW m128, xmm, xmm [AVX]
- VPSADBW ymm, ymm, ymm [AVX2]
- VPSADBW m256, ymm, ymm [AVX2]
- VPSADBW zmm, zmm, zmm [AVX512BW]
- VPSADBW m512, zmm, zmm [AVX512BW]
- VPSADBW xmm, xmm, xmm [AVX512BW,AVX512VL]
- VPSADBW m128, xmm, xmm [AVX512BW,AVX512VL]
- VPSADBW ymm, ymm, ymm [AVX512BW,AVX512VL]
- VPSADBW m256, ymm, ymm [AVX512BW,AVX512VL]
func (*Program) VPSCATTERDD ¶
func (self *Program) VPSCATTERDD(v0 interface{}, v1 interface{}) *Instruction
VPSCATTERDD performs "Scatter Packed Doubleword Values with Signed Doubleword Indices".
Mnemonic : VPSCATTERDD Supported forms : (3 forms)
- VPSCATTERDD zmm, vm32z{k} [AVX512F]
- VPSCATTERDD xmm, vm32x{k} [AVX512F,AVX512VL]
- VPSCATTERDD ymm, vm32y{k} [AVX512F,AVX512VL]
func (*Program) VPSCATTERDQ ¶
func (self *Program) VPSCATTERDQ(v0 interface{}, v1 interface{}) *Instruction
VPSCATTERDQ performs "Scatter Packed Quadword Values with Signed Doubleword Indices".
Mnemonic : VPSCATTERDQ Supported forms : (3 forms)
- VPSCATTERDQ zmm, vm32y{k} [AVX512F]
- VPSCATTERDQ xmm, vm32x{k} [AVX512F,AVX512VL]
- VPSCATTERDQ ymm, vm32x{k} [AVX512F,AVX512VL]
func (*Program) VPSCATTERQD ¶
func (self *Program) VPSCATTERQD(v0 interface{}, v1 interface{}) *Instruction
VPSCATTERQD performs "Scatter Packed Doubleword Values with Signed Quadword Indices".
Mnemonic : VPSCATTERQD Supported forms : (3 forms)
- VPSCATTERQD ymm, vm64z{k} [AVX512F]
- VPSCATTERQD xmm, vm64x{k} [AVX512F,AVX512VL]
- VPSCATTERQD xmm, vm64y{k} [AVX512F,AVX512VL]
func (*Program) VPSCATTERQQ ¶
func (self *Program) VPSCATTERQQ(v0 interface{}, v1 interface{}) *Instruction
VPSCATTERQQ performs "Scatter Packed Quadword Values with Signed Quadword Indices".
Mnemonic : VPSCATTERQQ Supported forms : (3 forms)
- VPSCATTERQQ zmm, vm64z{k} [AVX512F]
- VPSCATTERQQ xmm, vm64x{k} [AVX512F,AVX512VL]
- VPSCATTERQQ ymm, vm64y{k} [AVX512F,AVX512VL]
func (*Program) VPSHAB ¶
func (self *Program) VPSHAB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHAB performs "Packed Shift Arithmetic Bytes".
Mnemonic : VPSHAB Supported forms : (3 forms)
- VPSHAB xmm, xmm, xmm [XOP]
- VPSHAB m128, xmm, xmm [XOP]
- VPSHAB xmm, m128, xmm [XOP]
func (*Program) VPSHAD ¶
func (self *Program) VPSHAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHAD performs "Packed Shift Arithmetic Doublewords".
Mnemonic : VPSHAD Supported forms : (3 forms)
- VPSHAD xmm, xmm, xmm [XOP]
- VPSHAD m128, xmm, xmm [XOP]
- VPSHAD xmm, m128, xmm [XOP]
func (*Program) VPSHAQ ¶
func (self *Program) VPSHAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHAQ performs "Packed Shift Arithmetic Quadwords".
Mnemonic : VPSHAQ Supported forms : (3 forms)
- VPSHAQ xmm, xmm, xmm [XOP]
- VPSHAQ m128, xmm, xmm [XOP]
- VPSHAQ xmm, m128, xmm [XOP]
func (*Program) VPSHAW ¶
func (self *Program) VPSHAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHAW performs "Packed Shift Arithmetic Words".
Mnemonic : VPSHAW Supported forms : (3 forms)
- VPSHAW xmm, xmm, xmm [XOP]
- VPSHAW m128, xmm, xmm [XOP]
- VPSHAW xmm, m128, xmm [XOP]
func (*Program) VPSHLB ¶
func (self *Program) VPSHLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHLB performs "Packed Shift Logical Bytes".
Mnemonic : VPSHLB Supported forms : (3 forms)
- VPSHLB xmm, xmm, xmm [XOP]
- VPSHLB m128, xmm, xmm [XOP]
- VPSHLB xmm, m128, xmm [XOP]
func (*Program) VPSHLD ¶
func (self *Program) VPSHLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHLD performs "Packed Shift Logical Doublewords".
Mnemonic : VPSHLD Supported forms : (3 forms)
- VPSHLD xmm, xmm, xmm [XOP]
- VPSHLD m128, xmm, xmm [XOP]
- VPSHLD xmm, m128, xmm [XOP]
func (*Program) VPSHLQ ¶
func (self *Program) VPSHLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHLQ performs "Packed Shift Logical Quadwords".
Mnemonic : VPSHLQ Supported forms : (3 forms)
- VPSHLQ xmm, xmm, xmm [XOP]
- VPSHLQ m128, xmm, xmm [XOP]
- VPSHLQ xmm, m128, xmm [XOP]
func (*Program) VPSHLW ¶
func (self *Program) VPSHLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHLW performs "Packed Shift Logical Words".
Mnemonic : VPSHLW Supported forms : (3 forms)
- VPSHLW xmm, xmm, xmm [XOP]
- VPSHLW m128, xmm, xmm [XOP]
- VPSHLW xmm, m128, xmm [XOP]
func (*Program) VPSHUFB ¶
func (self *Program) VPSHUFB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHUFB performs "Packed Shuffle Bytes".
Mnemonic : VPSHUFB Supported forms : (10 forms)
- VPSHUFB xmm, xmm, xmm [AVX]
- VPSHUFB m128, xmm, xmm [AVX]
- VPSHUFB ymm, ymm, ymm [AVX2]
- VPSHUFB m256, ymm, ymm [AVX2]
- VPSHUFB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSHUFB m512, zmm, zmm{k}{z} [AVX512BW]
- VPSHUFB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSHUFD ¶
func (self *Program) VPSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHUFD performs "Shuffle Packed Doublewords".
Mnemonic : VPSHUFD Supported forms : (10 forms)
- VPSHUFD imm8, xmm, xmm [AVX]
- VPSHUFD imm8, m128, xmm [AVX]
- VPSHUFD imm8, ymm, ymm [AVX2]
- VPSHUFD imm8, m256, ymm [AVX2]
- VPSHUFD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPSHUFD imm8, zmm, zmm{k}{z} [AVX512F]
- VPSHUFD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSHUFD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSHUFD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSHUFD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSHUFHW ¶
func (self *Program) VPSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHUFHW performs "Shuffle Packed High Words".
Mnemonic : VPSHUFHW Supported forms : (10 forms)
- VPSHUFHW imm8, xmm, xmm [AVX]
- VPSHUFHW imm8, m128, xmm [AVX]
- VPSHUFHW imm8, ymm, ymm [AVX2]
- VPSHUFHW imm8, m256, ymm [AVX2]
- VPSHUFHW imm8, zmm, zmm{k}{z} [AVX512BW]
- VPSHUFHW imm8, m512, zmm{k}{z} [AVX512BW]
- VPSHUFHW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFHW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFHW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFHW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSHUFLW ¶
func (self *Program) VPSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSHUFLW performs "Shuffle Packed Low Words".
Mnemonic : VPSHUFLW Supported forms : (10 forms)
- VPSHUFLW imm8, xmm, xmm [AVX]
- VPSHUFLW imm8, m128, xmm [AVX]
- VPSHUFLW imm8, ymm, ymm [AVX2]
- VPSHUFLW imm8, m256, ymm [AVX2]
- VPSHUFLW imm8, zmm, zmm{k}{z} [AVX512BW]
- VPSHUFLW imm8, m512, zmm{k}{z} [AVX512BW]
- VPSHUFLW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFLW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFLW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSHUFLW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSIGNB ¶
func (self *Program) VPSIGNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSIGNB performs "Packed Sign of Byte Integers".
Mnemonic : VPSIGNB Supported forms : (4 forms)
- VPSIGNB xmm, xmm, xmm [AVX]
- VPSIGNB m128, xmm, xmm [AVX]
- VPSIGNB ymm, ymm, ymm [AVX2]
- VPSIGNB m256, ymm, ymm [AVX2]
func (*Program) VPSIGND ¶
func (self *Program) VPSIGND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSIGND performs "Packed Sign of Doubleword Integers".
Mnemonic : VPSIGND Supported forms : (4 forms)
- VPSIGND xmm, xmm, xmm [AVX]
- VPSIGND m128, xmm, xmm [AVX]
- VPSIGND ymm, ymm, ymm [AVX2]
- VPSIGND m256, ymm, ymm [AVX2]
func (*Program) VPSIGNW ¶
func (self *Program) VPSIGNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSIGNW performs "Packed Sign of Word Integers".
Mnemonic : VPSIGNW Supported forms : (4 forms)
- VPSIGNW xmm, xmm, xmm [AVX]
- VPSIGNW m128, xmm, xmm [AVX]
- VPSIGNW ymm, ymm, ymm [AVX2]
- VPSIGNW m256, ymm, ymm [AVX2]
func (*Program) VPSLLD ¶
func (self *Program) VPSLLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLD performs "Shift Packed Doubleword Data Left Logical".
Mnemonic : VPSLLD Supported forms : (18 forms)
- VPSLLD imm8, xmm, xmm [AVX]
- VPSLLD xmm, xmm, xmm [AVX]
- VPSLLD m128, xmm, xmm [AVX]
- VPSLLD imm8, ymm, ymm [AVX2]
- VPSLLD xmm, ymm, ymm [AVX2]
- VPSLLD m128, ymm, ymm [AVX2]
- VPSLLD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPSLLD imm8, zmm, zmm{k}{z} [AVX512F]
- VPSLLD xmm, zmm, zmm{k}{z} [AVX512F]
- VPSLLD m128, zmm, zmm{k}{z} [AVX512F]
- VPSLLD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLD m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLD xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLD m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSLLDQ ¶
func (self *Program) VPSLLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLDQ performs "Shift Packed Double Quadword Left Logical".
Mnemonic : VPSLLDQ Supported forms : (8 forms)
- VPSLLDQ imm8, xmm, xmm [AVX]
- VPSLLDQ imm8, ymm, ymm [AVX2]
- VPSLLDQ imm8, zmm, zmm [AVX512BW]
- VPSLLDQ imm8, m512, zmm [AVX512BW]
- VPSLLDQ imm8, xmm, xmm [AVX512BW,AVX512VL]
- VPSLLDQ imm8, m128, xmm [AVX512BW,AVX512VL]
- VPSLLDQ imm8, ymm, ymm [AVX512BW,AVX512VL]
- VPSLLDQ imm8, m256, ymm [AVX512BW,AVX512VL]
func (*Program) VPSLLQ ¶
func (self *Program) VPSLLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLQ performs "Shift Packed Quadword Data Left Logical".
Mnemonic : VPSLLQ Supported forms : (18 forms)
- VPSLLQ imm8, xmm, xmm [AVX]
- VPSLLQ xmm, xmm, xmm [AVX]
- VPSLLQ m128, xmm, xmm [AVX]
- VPSLLQ imm8, ymm, ymm [AVX2]
- VPSLLQ xmm, ymm, ymm [AVX2]
- VPSLLQ m128, ymm, ymm [AVX2]
- VPSLLQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPSLLQ imm8, zmm, zmm{k}{z} [AVX512F]
- VPSLLQ xmm, zmm, zmm{k}{z} [AVX512F]
- VPSLLQ m128, zmm, zmm{k}{z} [AVX512F]
- VPSLLQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLQ m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSLLVD ¶
func (self *Program) VPSLLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLVD performs "Variable Shift Packed Doubleword Data Left Logical".
Mnemonic : VPSLLVD Supported forms : (10 forms)
- VPSLLVD xmm, xmm, xmm [AVX2]
- VPSLLVD m128, xmm, xmm [AVX2]
- VPSLLVD ymm, ymm, ymm [AVX2]
- VPSLLVD m256, ymm, ymm [AVX2]
- VPSLLVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPSLLVD zmm, zmm, zmm{k}{z} [AVX512F]
- VPSLLVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSLLVQ ¶
func (self *Program) VPSLLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLVQ performs "Variable Shift Packed Quadword Data Left Logical".
Mnemonic : VPSLLVQ Supported forms : (10 forms)
- VPSLLVQ xmm, xmm, xmm [AVX2]
- VPSLLVQ m128, xmm, xmm [AVX2]
- VPSLLVQ ymm, ymm, ymm [AVX2]
- VPSLLVQ m256, ymm, ymm [AVX2]
- VPSLLVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPSLLVQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPSLLVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSLLVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSLLVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSLLVW ¶
func (self *Program) VPSLLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLVW performs "Variable Shift Packed Word Data Left Logical".
Mnemonic : VPSLLVW Supported forms : (6 forms)
- VPSLLVW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSLLVW m512, zmm, zmm{k}{z} [AVX512BW]
- VPSLLVW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSLLVW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSLLVW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSLLVW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSLLW ¶
func (self *Program) VPSLLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSLLW performs "Shift Packed Word Data Left Logical".
Mnemonic : VPSLLW Supported forms : (18 forms)
- VPSLLW imm8, xmm, xmm [AVX]
- VPSLLW xmm, xmm, xmm [AVX]
- VPSLLW m128, xmm, xmm [AVX]
- VPSLLW imm8, ymm, ymm [AVX2]
- VPSLLW xmm, ymm, ymm [AVX2]
- VPSLLW m128, ymm, ymm [AVX2]
- VPSLLW imm8, zmm, zmm{k}{z} [AVX512BW]
- VPSLLW xmm, zmm, zmm{k}{z} [AVX512BW]
- VPSLLW m128, zmm, zmm{k}{z} [AVX512BW]
- VPSLLW imm8, m512, zmm{k}{z} [AVX512BW]
- VPSLLW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW xmm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW m128, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSLLW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSRAD ¶
func (self *Program) VPSRAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRAD performs "Shift Packed Doubleword Data Right Arithmetic".
Mnemonic : VPSRAD Supported forms : (18 forms)
- VPSRAD imm8, xmm, xmm [AVX]
- VPSRAD xmm, xmm, xmm [AVX]
- VPSRAD m128, xmm, xmm [AVX]
- VPSRAD imm8, ymm, ymm [AVX2]
- VPSRAD xmm, ymm, ymm [AVX2]
- VPSRAD m128, ymm, ymm [AVX2]
- VPSRAD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPSRAD imm8, zmm, zmm{k}{z} [AVX512F]
- VPSRAD xmm, zmm, zmm{k}{z} [AVX512F]
- VPSRAD m128, zmm, zmm{k}{z} [AVX512F]
- VPSRAD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAD m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAD xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAD m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRAQ ¶
func (self *Program) VPSRAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRAQ performs "Shift Packed Quadword Data Right Arithmetic".
Mnemonic : VPSRAQ Supported forms : (12 forms)
- VPSRAQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPSRAQ imm8, zmm, zmm{k}{z} [AVX512F]
- VPSRAQ xmm, zmm, zmm{k}{z} [AVX512F]
- VPSRAQ m128, zmm, zmm{k}{z} [AVX512F]
- VPSRAQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAQ m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRAVD ¶
func (self *Program) VPSRAVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRAVD performs "Variable Shift Packed Doubleword Data Right Arithmetic".
Mnemonic : VPSRAVD Supported forms : (10 forms)
- VPSRAVD xmm, xmm, xmm [AVX2]
- VPSRAVD m128, xmm, xmm [AVX2]
- VPSRAVD ymm, ymm, ymm [AVX2]
- VPSRAVD m256, ymm, ymm [AVX2]
- VPSRAVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPSRAVD zmm, zmm, zmm{k}{z} [AVX512F]
- VPSRAVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRAVQ ¶
func (self *Program) VPSRAVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRAVQ performs "Variable Shift Packed Quadword Data Right Arithmetic".
Mnemonic : VPSRAVQ Supported forms : (6 forms)
- VPSRAVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPSRAVQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPSRAVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRAVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRAVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRAVW ¶
func (self *Program) VPSRAVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRAVW performs "Variable Shift Packed Word Data Right Arithmetic".
Mnemonic : VPSRAVW Supported forms : (6 forms)
- VPSRAVW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSRAVW m512, zmm, zmm{k}{z} [AVX512BW]
- VPSRAVW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRAVW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRAVW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRAVW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSRAW ¶
func (self *Program) VPSRAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRAW performs "Shift Packed Word Data Right Arithmetic".
Mnemonic : VPSRAW Supported forms : (18 forms)
- VPSRAW imm8, xmm, xmm [AVX]
- VPSRAW xmm, xmm, xmm [AVX]
- VPSRAW m128, xmm, xmm [AVX]
- VPSRAW imm8, ymm, ymm [AVX2]
- VPSRAW xmm, ymm, ymm [AVX2]
- VPSRAW m128, ymm, ymm [AVX2]
- VPSRAW imm8, zmm, zmm{k}{z} [AVX512BW]
- VPSRAW xmm, zmm, zmm{k}{z} [AVX512BW]
- VPSRAW m128, zmm, zmm{k}{z} [AVX512BW]
- VPSRAW imm8, m512, zmm{k}{z} [AVX512BW]
- VPSRAW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW xmm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW m128, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRAW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSRLD ¶
func (self *Program) VPSRLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLD performs "Shift Packed Doubleword Data Right Logical".
Mnemonic : VPSRLD Supported forms : (18 forms)
- VPSRLD imm8, xmm, xmm [AVX]
- VPSRLD xmm, xmm, xmm [AVX]
- VPSRLD m128, xmm, xmm [AVX]
- VPSRLD imm8, ymm, ymm [AVX2]
- VPSRLD xmm, ymm, ymm [AVX2]
- VPSRLD m128, ymm, ymm [AVX2]
- VPSRLD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VPSRLD imm8, zmm, zmm{k}{z} [AVX512F]
- VPSRLD xmm, zmm, zmm{k}{z} [AVX512F]
- VPSRLD m128, zmm, zmm{k}{z} [AVX512F]
- VPSRLD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLD m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLD xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLD m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRLDQ ¶
func (self *Program) VPSRLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLDQ performs "Shift Packed Double Quadword Right Logical".
Mnemonic : VPSRLDQ Supported forms : (8 forms)
- VPSRLDQ imm8, xmm, xmm [AVX]
- VPSRLDQ imm8, ymm, ymm [AVX2]
- VPSRLDQ imm8, zmm, zmm [AVX512BW]
- VPSRLDQ imm8, m512, zmm [AVX512BW]
- VPSRLDQ imm8, xmm, xmm [AVX512BW,AVX512VL]
- VPSRLDQ imm8, m128, xmm [AVX512BW,AVX512VL]
- VPSRLDQ imm8, ymm, ymm [AVX512BW,AVX512VL]
- VPSRLDQ imm8, m256, ymm [AVX512BW,AVX512VL]
func (*Program) VPSRLQ ¶
func (self *Program) VPSRLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLQ performs "Shift Packed Quadword Data Right Logical".
Mnemonic : VPSRLQ Supported forms : (18 forms)
- VPSRLQ imm8, xmm, xmm [AVX]
- VPSRLQ xmm, xmm, xmm [AVX]
- VPSRLQ m128, xmm, xmm [AVX]
- VPSRLQ imm8, ymm, ymm [AVX2]
- VPSRLQ xmm, ymm, ymm [AVX2]
- VPSRLQ m128, ymm, ymm [AVX2]
- VPSRLQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VPSRLQ imm8, zmm, zmm{k}{z} [AVX512F]
- VPSRLQ xmm, zmm, zmm{k}{z} [AVX512F]
- VPSRLQ m128, zmm, zmm{k}{z} [AVX512F]
- VPSRLQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLQ m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRLVD ¶
func (self *Program) VPSRLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLVD performs "Variable Shift Packed Doubleword Data Right Logical".
Mnemonic : VPSRLVD Supported forms : (10 forms)
- VPSRLVD xmm, xmm, xmm [AVX2]
- VPSRLVD m128, xmm, xmm [AVX2]
- VPSRLVD ymm, ymm, ymm [AVX2]
- VPSRLVD m256, ymm, ymm [AVX2]
- VPSRLVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPSRLVD zmm, zmm, zmm{k}{z} [AVX512F]
- VPSRLVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRLVQ ¶
func (self *Program) VPSRLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLVQ performs "Variable Shift Packed Quadword Data Right Logical".
Mnemonic : VPSRLVQ Supported forms : (10 forms)
- VPSRLVQ xmm, xmm, xmm [AVX2]
- VPSRLVQ m128, xmm, xmm [AVX2]
- VPSRLVQ ymm, ymm, ymm [AVX2]
- VPSRLVQ m256, ymm, ymm [AVX2]
- VPSRLVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPSRLVQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPSRLVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSRLVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSRLVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSRLVW ¶
func (self *Program) VPSRLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLVW performs "Variable Shift Packed Word Data Right Logical".
Mnemonic : VPSRLVW Supported forms : (6 forms)
- VPSRLVW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSRLVW m512, zmm, zmm{k}{z} [AVX512BW]
- VPSRLVW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRLVW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRLVW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRLVW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSRLW ¶
func (self *Program) VPSRLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSRLW performs "Shift Packed Word Data Right Logical".
Mnemonic : VPSRLW Supported forms : (18 forms)
- VPSRLW imm8, xmm, xmm [AVX]
- VPSRLW xmm, xmm, xmm [AVX]
- VPSRLW m128, xmm, xmm [AVX]
- VPSRLW imm8, ymm, ymm [AVX2]
- VPSRLW xmm, ymm, ymm [AVX2]
- VPSRLW m128, ymm, ymm [AVX2]
- VPSRLW imm8, zmm, zmm{k}{z} [AVX512BW]
- VPSRLW xmm, zmm, zmm{k}{z} [AVX512BW]
- VPSRLW m128, zmm, zmm{k}{z} [AVX512BW]
- VPSRLW imm8, m512, zmm{k}{z} [AVX512BW]
- VPSRLW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW xmm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW m128, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSRLW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSUBB ¶
func (self *Program) VPSUBB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBB performs "Subtract Packed Byte Integers".
Mnemonic : VPSUBB Supported forms : (10 forms)
- VPSUBB xmm, xmm, xmm [AVX]
- VPSUBB m128, xmm, xmm [AVX]
- VPSUBB ymm, ymm, ymm [AVX2]
- VPSUBB m256, ymm, ymm [AVX2]
- VPSUBB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSUBB m512, zmm, zmm{k}{z} [AVX512BW]
- VPSUBB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSUBB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSUBD ¶
func (self *Program) VPSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBD performs "Subtract Packed Doubleword Integers".
Mnemonic : VPSUBD Supported forms : (10 forms)
- VPSUBD xmm, xmm, xmm [AVX]
- VPSUBD m128, xmm, xmm [AVX]
- VPSUBD ymm, ymm, ymm [AVX2]
- VPSUBD m256, ymm, ymm [AVX2]
- VPSUBD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPSUBD zmm, zmm, zmm{k}{z} [AVX512F]
- VPSUBD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSUBD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSUBD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSUBD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSUBQ ¶
func (self *Program) VPSUBQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBQ performs "Subtract Packed Quadword Integers".
Mnemonic : VPSUBQ Supported forms : (10 forms)
- VPSUBQ xmm, xmm, xmm [AVX]
- VPSUBQ m128, xmm, xmm [AVX]
- VPSUBQ ymm, ymm, ymm [AVX2]
- VPSUBQ m256, ymm, ymm [AVX2]
- VPSUBQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPSUBQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPSUBQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSUBQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPSUBQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPSUBQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPSUBSB ¶
func (self *Program) VPSUBSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBSB performs "Subtract Packed Signed Byte Integers with Signed Saturation".
Mnemonic : VPSUBSB Supported forms : (10 forms)
- VPSUBSB xmm, xmm, xmm [AVX]
- VPSUBSB m128, xmm, xmm [AVX]
- VPSUBSB ymm, ymm, ymm [AVX2]
- VPSUBSB m256, ymm, ymm [AVX2]
- VPSUBSB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSUBSB m512, zmm, zmm{k}{z} [AVX512BW]
- VPSUBSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSUBSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSUBSW ¶
func (self *Program) VPSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBSW performs "Subtract Packed Signed Word Integers with Signed Saturation".
Mnemonic : VPSUBSW Supported forms : (10 forms)
- VPSUBSW xmm, xmm, xmm [AVX]
- VPSUBSW m128, xmm, xmm [AVX]
- VPSUBSW ymm, ymm, ymm [AVX2]
- VPSUBSW m256, ymm, ymm [AVX2]
- VPSUBSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSUBSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPSUBSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSUBSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSUBUSB ¶
func (self *Program) VPSUBUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBUSB performs "Subtract Packed Unsigned Byte Integers with Unsigned Saturation".
Mnemonic : VPSUBUSB Supported forms : (10 forms)
- VPSUBUSB xmm, xmm, xmm [AVX]
- VPSUBUSB m128, xmm, xmm [AVX]
- VPSUBUSB ymm, ymm, ymm [AVX2]
- VPSUBUSB m256, ymm, ymm [AVX2]
- VPSUBUSB zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSUBUSB m512, zmm, zmm{k}{z} [AVX512BW]
- VPSUBUSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBUSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBUSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSUBUSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSUBUSW ¶
func (self *Program) VPSUBUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBUSW performs "Subtract Packed Unsigned Word Integers with Unsigned Saturation".
Mnemonic : VPSUBUSW Supported forms : (10 forms)
- VPSUBUSW xmm, xmm, xmm [AVX]
- VPSUBUSW m128, xmm, xmm [AVX]
- VPSUBUSW ymm, ymm, ymm [AVX2]
- VPSUBUSW m256, ymm, ymm [AVX2]
- VPSUBUSW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSUBUSW m512, zmm, zmm{k}{z} [AVX512BW]
- VPSUBUSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBUSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBUSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSUBUSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPSUBW ¶
func (self *Program) VPSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPSUBW performs "Subtract Packed Word Integers".
Mnemonic : VPSUBW Supported forms : (10 forms)
- VPSUBW xmm, xmm, xmm [AVX]
- VPSUBW m128, xmm, xmm [AVX]
- VPSUBW ymm, ymm, ymm [AVX2]
- VPSUBW m256, ymm, ymm [AVX2]
- VPSUBW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPSUBW m512, zmm, zmm{k}{z} [AVX512BW]
- VPSUBW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPSUBW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPSUBW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPTERNLOGD ¶
func (self *Program) VPTERNLOGD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPTERNLOGD performs "Bitwise Ternary Logical Operation on Doubleword Values".
Mnemonic : VPTERNLOGD Supported forms : (6 forms)
- VPTERNLOGD imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPTERNLOGD imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VPTERNLOGD imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPTERNLOGD imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPTERNLOGD imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPTERNLOGD imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPTERNLOGQ ¶
func (self *Program) VPTERNLOGQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VPTERNLOGQ performs "Bitwise Ternary Logical Operation on Quadword Values".
Mnemonic : VPTERNLOGQ Supported forms : (6 forms)
- VPTERNLOGQ imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPTERNLOGQ imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VPTERNLOGQ imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPTERNLOGQ imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPTERNLOGQ imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPTERNLOGQ imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPTEST ¶
func (self *Program) VPTEST(v0 interface{}, v1 interface{}) *Instruction
VPTEST performs "Packed Logical Compare".
Mnemonic : VPTEST Supported forms : (4 forms)
- VPTEST xmm, xmm [AVX]
- VPTEST m128, xmm [AVX]
- VPTEST ymm, ymm [AVX]
- VPTEST m256, ymm [AVX]
func (*Program) VPTESTMB ¶
func (self *Program) VPTESTMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTMB performs "Logical AND of Packed Byte Integer Values and Set Mask".
Mnemonic : VPTESTMB Supported forms : (6 forms)
- VPTESTMB zmm, zmm, k{k} [AVX512BW]
- VPTESTMB m512, zmm, k{k} [AVX512BW]
- VPTESTMB xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTMB m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTMB ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPTESTMB m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPTESTMD ¶
func (self *Program) VPTESTMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTMD performs "Logical AND of Packed Doubleword Integer Values and Set Mask".
Mnemonic : VPTESTMD Supported forms : (6 forms)
- VPTESTMD m512/m32bcst, zmm, k{k} [AVX512F]
- VPTESTMD zmm, zmm, k{k} [AVX512F]
- VPTESTMD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTMD xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTMD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPTESTMD ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPTESTMQ ¶
func (self *Program) VPTESTMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTMQ performs "Logical AND of Packed Quadword Integer Values and Set Mask".
Mnemonic : VPTESTMQ Supported forms : (6 forms)
- VPTESTMQ m512/m64bcst, zmm, k{k} [AVX512F]
- VPTESTMQ zmm, zmm, k{k} [AVX512F]
- VPTESTMQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTMQ xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTMQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPTESTMQ ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPTESTMW ¶
func (self *Program) VPTESTMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTMW performs "Logical AND of Packed Word Integer Values and Set Mask".
Mnemonic : VPTESTMW Supported forms : (6 forms)
- VPTESTMW zmm, zmm, k{k} [AVX512BW]
- VPTESTMW m512, zmm, k{k} [AVX512BW]
- VPTESTMW xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTMW m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTMW ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPTESTMW m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPTESTNMB ¶
func (self *Program) VPTESTNMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTNMB performs "Logical NAND of Packed Byte Integer Values and Set Mask".
Mnemonic : VPTESTNMB Supported forms : (6 forms)
- VPTESTNMB zmm, zmm, k{k} [AVX512BW,AVX512F]
- VPTESTNMB m512, zmm, k{k} [AVX512BW,AVX512F]
- VPTESTNMB xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTNMB m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTNMB ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPTESTNMB m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPTESTNMD ¶
func (self *Program) VPTESTNMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTNMD performs "Logical NAND of Packed Doubleword Integer Values and Set Mask".
Mnemonic : VPTESTNMD Supported forms : (6 forms)
- VPTESTNMD m512/m32bcst, zmm, k{k} [AVX512F]
- VPTESTNMD zmm, zmm, k{k} [AVX512F]
- VPTESTNMD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTNMD xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTNMD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPTESTNMD ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPTESTNMQ ¶
func (self *Program) VPTESTNMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTNMQ performs "Logical NAND of Packed Quadword Integer Values and Set Mask".
Mnemonic : VPTESTNMQ Supported forms : (6 forms)
- VPTESTNMQ m512/m64bcst, zmm, k{k} [AVX512F]
- VPTESTNMQ zmm, zmm, k{k} [AVX512F]
- VPTESTNMQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTNMQ xmm, xmm, k{k} [AVX512F,AVX512VL]
- VPTESTNMQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
- VPTESTNMQ ymm, ymm, k{k} [AVX512F,AVX512VL]
func (*Program) VPTESTNMW ¶
func (self *Program) VPTESTNMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPTESTNMW performs "Logical NAND of Packed Word Integer Values and Set Mask".
Mnemonic : VPTESTNMW Supported forms : (6 forms)
- VPTESTNMW zmm, zmm, k{k} [AVX512BW,AVX512F]
- VPTESTNMW m512, zmm, k{k} [AVX512BW,AVX512F]
- VPTESTNMW xmm, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTNMW m128, xmm, k{k} [AVX512BW,AVX512VL]
- VPTESTNMW ymm, ymm, k{k} [AVX512BW,AVX512VL]
- VPTESTNMW m256, ymm, k{k} [AVX512BW,AVX512VL]
func (*Program) VPUNPCKHBW ¶
func (self *Program) VPUNPCKHBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKHBW performs "Unpack and Interleave High-Order Bytes into Words".
Mnemonic : VPUNPCKHBW Supported forms : (10 forms)
- VPUNPCKHBW xmm, xmm, xmm [AVX]
- VPUNPCKHBW m128, xmm, xmm [AVX]
- VPUNPCKHBW ymm, ymm, ymm [AVX2]
- VPUNPCKHBW m256, ymm, ymm [AVX2]
- VPUNPCKHBW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKHBW m512, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKHBW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKHBW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKHBW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKHBW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPUNPCKHDQ ¶
func (self *Program) VPUNPCKHDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKHDQ performs "Unpack and Interleave High-Order Doublewords into Quadwords".
Mnemonic : VPUNPCKHDQ Supported forms : (10 forms)
- VPUNPCKHDQ xmm, xmm, xmm [AVX]
- VPUNPCKHDQ m128, xmm, xmm [AVX]
- VPUNPCKHDQ ymm, ymm, ymm [AVX2]
- VPUNPCKHDQ m256, ymm, ymm [AVX2]
- VPUNPCKHDQ m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKHDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKHDQ m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKHDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKHDQ m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKHDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPUNPCKHQDQ ¶
func (self *Program) VPUNPCKHQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKHQDQ performs "Unpack and Interleave High-Order Quadwords into Double Quadwords".
Mnemonic : VPUNPCKHQDQ Supported forms : (10 forms)
- VPUNPCKHQDQ xmm, xmm, xmm [AVX]
- VPUNPCKHQDQ m128, xmm, xmm [AVX]
- VPUNPCKHQDQ ymm, ymm, ymm [AVX2]
- VPUNPCKHQDQ m256, ymm, ymm [AVX2]
- VPUNPCKHQDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKHQDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKHQDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKHQDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKHQDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKHQDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPUNPCKHWD ¶
func (self *Program) VPUNPCKHWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKHWD performs "Unpack and Interleave High-Order Words into Doublewords".
Mnemonic : VPUNPCKHWD Supported forms : (10 forms)
- VPUNPCKHWD xmm, xmm, xmm [AVX]
- VPUNPCKHWD m128, xmm, xmm [AVX]
- VPUNPCKHWD ymm, ymm, ymm [AVX2]
- VPUNPCKHWD m256, ymm, ymm [AVX2]
- VPUNPCKHWD zmm, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKHWD m512, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKHWD xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKHWD m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKHWD ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKHWD m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPUNPCKLBW ¶
func (self *Program) VPUNPCKLBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKLBW performs "Unpack and Interleave Low-Order Bytes into Words".
Mnemonic : VPUNPCKLBW Supported forms : (10 forms)
- VPUNPCKLBW xmm, xmm, xmm [AVX]
- VPUNPCKLBW m128, xmm, xmm [AVX]
- VPUNPCKLBW ymm, ymm, ymm [AVX2]
- VPUNPCKLBW m256, ymm, ymm [AVX2]
- VPUNPCKLBW zmm, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKLBW m512, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKLBW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKLBW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKLBW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKLBW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPUNPCKLDQ ¶
func (self *Program) VPUNPCKLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKLDQ performs "Unpack and Interleave Low-Order Doublewords into Quadwords".
Mnemonic : VPUNPCKLDQ Supported forms : (10 forms)
- VPUNPCKLDQ xmm, xmm, xmm [AVX]
- VPUNPCKLDQ m128, xmm, xmm [AVX]
- VPUNPCKLDQ ymm, ymm, ymm [AVX2]
- VPUNPCKLDQ m256, ymm, ymm [AVX2]
- VPUNPCKLDQ m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKLDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKLDQ m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKLDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKLDQ m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKLDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPUNPCKLQDQ ¶
func (self *Program) VPUNPCKLQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKLQDQ performs "Unpack and Interleave Low-Order Quadwords into Double Quadwords".
Mnemonic : VPUNPCKLQDQ Supported forms : (10 forms)
- VPUNPCKLQDQ xmm, xmm, xmm [AVX]
- VPUNPCKLQDQ m128, xmm, xmm [AVX]
- VPUNPCKLQDQ ymm, ymm, ymm [AVX2]
- VPUNPCKLQDQ m256, ymm, ymm [AVX2]
- VPUNPCKLQDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKLQDQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPUNPCKLQDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKLQDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKLQDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPUNPCKLQDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPUNPCKLWD ¶
func (self *Program) VPUNPCKLWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPUNPCKLWD performs "Unpack and Interleave Low-Order Words into Doublewords".
Mnemonic : VPUNPCKLWD Supported forms : (10 forms)
- VPUNPCKLWD xmm, xmm, xmm [AVX]
- VPUNPCKLWD m128, xmm, xmm [AVX]
- VPUNPCKLWD ymm, ymm, ymm [AVX2]
- VPUNPCKLWD m256, ymm, ymm [AVX2]
- VPUNPCKLWD zmm, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKLWD m512, zmm, zmm{k}{z} [AVX512BW]
- VPUNPCKLWD xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKLWD m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKLWD ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
- VPUNPCKLWD m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
func (*Program) VPXOR ¶
func (self *Program) VPXOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPXOR performs "Packed Bitwise Logical Exclusive OR".
Mnemonic : VPXOR Supported forms : (4 forms)
- VPXOR xmm, xmm, xmm [AVX]
- VPXOR m128, xmm, xmm [AVX]
- VPXOR ymm, ymm, ymm [AVX2]
- VPXOR m256, ymm, ymm [AVX2]
func (*Program) VPXORD ¶
func (self *Program) VPXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPXORD performs "Bitwise Logical Exclusive OR of Packed Doubleword Integers".
Mnemonic : VPXORD Supported forms : (6 forms)
- VPXORD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VPXORD zmm, zmm, zmm{k}{z} [AVX512F]
- VPXORD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPXORD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPXORD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPXORD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VPXORQ ¶
func (self *Program) VPXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VPXORQ performs "Bitwise Logical Exclusive OR of Packed Quadword Integers".
Mnemonic : VPXORQ Supported forms : (6 forms)
- VPXORQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VPXORQ zmm, zmm, zmm{k}{z} [AVX512F]
- VPXORQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPXORQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VPXORQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VPXORQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRANGEPD ¶
func (self *Program) VRANGEPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VRANGEPD performs "Range Restriction Calculation For Packed Pairs of Double-Precision Floating-Point Values".
Mnemonic : VRANGEPD Supported forms : (7 forms)
- VRANGEPD imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
- VRANGEPD imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512DQ]
- VRANGEPD imm8, zmm, zmm, zmm{k}{z} [AVX512DQ]
- VRANGEPD imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VRANGEPD imm8, xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VRANGEPD imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VRANGEPD imm8, ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VRANGEPS ¶
func (self *Program) VRANGEPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VRANGEPS performs "Range Restriction Calculation For Packed Pairs of Single-Precision Floating-Point Values".
Mnemonic : VRANGEPS Supported forms : (7 forms)
- VRANGEPS imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
- VRANGEPS imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512DQ]
- VRANGEPS imm8, zmm, zmm, zmm{k}{z} [AVX512DQ]
- VRANGEPS imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VRANGEPS imm8, xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VRANGEPS imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VRANGEPS imm8, ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VRANGESD ¶
func (self *Program) VRANGESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VRANGESD performs "Range Restriction Calculation For a pair of Scalar Double-Precision Floating-Point Values".
Mnemonic : VRANGESD Supported forms : (3 forms)
- VRANGESD imm8, m64, xmm, xmm{k}{z} [AVX512DQ]
- VRANGESD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512DQ]
- VRANGESD imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]
func (*Program) VRANGESS ¶
func (self *Program) VRANGESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VRANGESS performs "Range Restriction Calculation For a pair of Scalar Single-Precision Floating-Point Values".
Mnemonic : VRANGESS Supported forms : (3 forms)
- VRANGESS imm8, m32, xmm, xmm{k}{z} [AVX512DQ]
- VRANGESS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512DQ]
- VRANGESS imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]
func (*Program) VRCP14PD ¶
func (self *Program) VRCP14PD(v0 interface{}, v1 interface{}) *Instruction
VRCP14PD performs "Compute Approximate Reciprocals of Packed Double-Precision Floating-Point Values".
Mnemonic : VRCP14PD Supported forms : (6 forms)
- VRCP14PD m512/m64bcst, zmm{k}{z} [AVX512F]
- VRCP14PD zmm, zmm{k}{z} [AVX512F]
- VRCP14PD m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VRCP14PD m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VRCP14PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VRCP14PD ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRCP14PS ¶
func (self *Program) VRCP14PS(v0 interface{}, v1 interface{}) *Instruction
VRCP14PS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".
Mnemonic : VRCP14PS Supported forms : (6 forms)
- VRCP14PS m512/m32bcst, zmm{k}{z} [AVX512F]
- VRCP14PS zmm, zmm{k}{z} [AVX512F]
- VRCP14PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VRCP14PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VRCP14PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VRCP14PS ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRCP14SD ¶
func (self *Program) VRCP14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VRCP14SD performs "Compute Approximate Reciprocal of a Scalar Double-Precision Floating-Point Value".
Mnemonic : VRCP14SD Supported forms : (2 forms)
- VRCP14SD xmm, xmm, xmm{k}{z} [AVX512F]
- VRCP14SD m64, xmm, xmm{k}{z} [AVX512F]
func (*Program) VRCP14SS ¶
func (self *Program) VRCP14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VRCP14SS performs "Compute Approximate Reciprocal of a Scalar Single-Precision Floating-Point Value".
Mnemonic : VRCP14SS Supported forms : (2 forms)
- VRCP14SS xmm, xmm, xmm{k}{z} [AVX512F]
- VRCP14SS m32, xmm, xmm{k}{z} [AVX512F]
func (*Program) VRCP28PD ¶
func (self *Program) VRCP28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VRCP28PD performs "Approximation to the Reciprocal of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error".
Mnemonic : VRCP28PD Supported forms : (3 forms)
- VRCP28PD m512/m64bcst, zmm{k}{z} [AVX512ER]
- VRCP28PD {sae}, zmm, zmm{k}{z} [AVX512ER]
- VRCP28PD zmm, zmm{k}{z} [AVX512ER]
func (*Program) VRCP28PS ¶
func (self *Program) VRCP28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VRCP28PS performs "Approximation to the Reciprocal of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error".
Mnemonic : VRCP28PS Supported forms : (3 forms)
- VRCP28PS m512/m32bcst, zmm{k}{z} [AVX512ER]
- VRCP28PS {sae}, zmm, zmm{k}{z} [AVX512ER]
- VRCP28PS zmm, zmm{k}{z} [AVX512ER]
func (*Program) VRCP28SD ¶
func (self *Program) VRCP28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VRCP28SD performs "Approximation to the Reciprocal of a Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error".
Mnemonic : VRCP28SD Supported forms : (3 forms)
- VRCP28SD m64, xmm, xmm{k}{z} [AVX512ER]
- VRCP28SD {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
- VRCP28SD xmm, xmm, xmm{k}{z} [AVX512ER]
func (*Program) VRCP28SS ¶
func (self *Program) VRCP28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VRCP28SS performs "Approximation to the Reciprocal of a Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error".
Mnemonic : VRCP28SS Supported forms : (3 forms)
- VRCP28SS m32, xmm, xmm{k}{z} [AVX512ER]
- VRCP28SS {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
- VRCP28SS xmm, xmm, xmm{k}{z} [AVX512ER]
func (*Program) VRCPPS ¶
func (self *Program) VRCPPS(v0 interface{}, v1 interface{}) *Instruction
VRCPPS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".
Mnemonic : VRCPPS Supported forms : (4 forms)
- VRCPPS xmm, xmm [AVX]
- VRCPPS m128, xmm [AVX]
- VRCPPS ymm, ymm [AVX]
- VRCPPS m256, ymm [AVX]
func (*Program) VRCPSS ¶
func (self *Program) VRCPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VRCPSS performs "Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values".
Mnemonic : VRCPSS Supported forms : (2 forms)
- VRCPSS xmm, xmm, xmm [AVX]
- VRCPSS m32, xmm, xmm [AVX]
func (*Program) VREDUCEPD ¶
func (self *Program) VREDUCEPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VREDUCEPD performs "Perform Reduction Transformation on Packed Double-Precision Floating-Point Values".
Mnemonic : VREDUCEPD Supported forms : (6 forms)
- VREDUCEPD imm8, m512/m64bcst, zmm{k}{z} [AVX512DQ]
- VREDUCEPD imm8, zmm, zmm{k}{z} [AVX512DQ]
- VREDUCEPD imm8, m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VREDUCEPD imm8, m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VREDUCEPD imm8, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VREDUCEPD imm8, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VREDUCEPS ¶
func (self *Program) VREDUCEPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VREDUCEPS performs "Perform Reduction Transformation on Packed Single-Precision Floating-Point Values".
Mnemonic : VREDUCEPS Supported forms : (6 forms)
- VREDUCEPS imm8, m512/m32bcst, zmm{k}{z} [AVX512DQ]
- VREDUCEPS imm8, zmm, zmm{k}{z} [AVX512DQ]
- VREDUCEPS imm8, m128/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
- VREDUCEPS imm8, m256/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
- VREDUCEPS imm8, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VREDUCEPS imm8, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VREDUCESD ¶
func (self *Program) VREDUCESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VREDUCESD performs "Perform Reduction Transformation on a Scalar Double-Precision Floating-Point Value".
Mnemonic : VREDUCESD Supported forms : (2 forms)
- VREDUCESD imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]
- VREDUCESD imm8, m64, xmm, xmm{k}{z} [AVX512DQ]
func (*Program) VREDUCESS ¶
func (self *Program) VREDUCESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VREDUCESS performs "Perform Reduction Transformation on a Scalar Single-Precision Floating-Point Value".
Mnemonic : VREDUCESS Supported forms : (2 forms)
- VREDUCESS imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]
- VREDUCESS imm8, m32, xmm, xmm{k}{z} [AVX512DQ]
func (*Program) VRNDSCALEPD ¶
func (self *Program) VRNDSCALEPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VRNDSCALEPD performs "Round Packed Double-Precision Floating-Point Values To Include A Given Number Of Fraction Bits".
Mnemonic : VRNDSCALEPD Supported forms : (7 forms)
- VRNDSCALEPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
- VRNDSCALEPD imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
- VRNDSCALEPD imm8, zmm, zmm{k}{z} [AVX512F]
- VRNDSCALEPD imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VRNDSCALEPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VRNDSCALEPD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VRNDSCALEPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRNDSCALEPS ¶
func (self *Program) VRNDSCALEPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VRNDSCALEPS performs "Round Packed Single-Precision Floating-Point Values To Include A Given Number Of Fraction Bits".
Mnemonic : VRNDSCALEPS Supported forms : (7 forms)
- VRNDSCALEPS imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
- VRNDSCALEPS imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
- VRNDSCALEPS imm8, zmm, zmm{k}{z} [AVX512F]
- VRNDSCALEPS imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VRNDSCALEPS imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VRNDSCALEPS imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VRNDSCALEPS imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRNDSCALESD ¶
func (self *Program) VRNDSCALESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VRNDSCALESD performs "Round Scalar Double-Precision Floating-Point Value To Include A Given Number Of Fraction Bits".
Mnemonic : VRNDSCALESD Supported forms : (3 forms)
- VRNDSCALESD imm8, m64, xmm, xmm{k}{z} [AVX512F]
- VRNDSCALESD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VRNDSCALESD imm8, xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VRNDSCALESS ¶
func (self *Program) VRNDSCALESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction
VRNDSCALESS performs "Round Scalar Single-Precision Floating-Point Value To Include A Given Number Of Fraction Bits".
Mnemonic : VRNDSCALESS Supported forms : (3 forms)
- VRNDSCALESS imm8, m32, xmm, xmm{k}{z} [AVX512F]
- VRNDSCALESS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
- VRNDSCALESS imm8, xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VROUNDPD ¶
func (self *Program) VROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VROUNDPD performs "Round Packed Double Precision Floating-Point Values".
Mnemonic : VROUNDPD Supported forms : (4 forms)
- VROUNDPD imm8, xmm, xmm [AVX]
- VROUNDPD imm8, m128, xmm [AVX]
- VROUNDPD imm8, ymm, ymm [AVX]
- VROUNDPD imm8, m256, ymm [AVX]
func (*Program) VROUNDPS ¶
func (self *Program) VROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VROUNDPS performs "Round Packed Single Precision Floating-Point Values".
Mnemonic : VROUNDPS Supported forms : (4 forms)
- VROUNDPS imm8, xmm, xmm [AVX]
- VROUNDPS imm8, m128, xmm [AVX]
- VROUNDPS imm8, ymm, ymm [AVX]
- VROUNDPS imm8, m256, ymm [AVX]
func (*Program) VROUNDSD ¶
func (self *Program) VROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VROUNDSD performs "Round Scalar Double Precision Floating-Point Values".
Mnemonic : VROUNDSD Supported forms : (2 forms)
- VROUNDSD imm8, xmm, xmm, xmm [AVX]
- VROUNDSD imm8, m64, xmm, xmm [AVX]
func (*Program) VROUNDSS ¶
func (self *Program) VROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VROUNDSS performs "Round Scalar Single Precision Floating-Point Values".
Mnemonic : VROUNDSS Supported forms : (2 forms)
- VROUNDSS imm8, xmm, xmm, xmm [AVX]
- VROUNDSS imm8, m32, xmm, xmm [AVX]
func (*Program) VRSQRT14PD ¶
func (self *Program) VRSQRT14PD(v0 interface{}, v1 interface{}) *Instruction
VRSQRT14PD performs "Compute Approximate Reciprocals of Square Roots of Packed Double-Precision Floating-Point Values".
Mnemonic : VRSQRT14PD Supported forms : (6 forms)
- VRSQRT14PD m512/m64bcst, zmm{k}{z} [AVX512F]
- VRSQRT14PD zmm, zmm{k}{z} [AVX512F]
- VRSQRT14PD m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VRSQRT14PD m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VRSQRT14PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VRSQRT14PD ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRSQRT14PS ¶
func (self *Program) VRSQRT14PS(v0 interface{}, v1 interface{}) *Instruction
VRSQRT14PS performs "Compute Approximate Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".
Mnemonic : VRSQRT14PS Supported forms : (6 forms)
- VRSQRT14PS m512/m32bcst, zmm{k}{z} [AVX512F]
- VRSQRT14PS zmm, zmm{k}{z} [AVX512F]
- VRSQRT14PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VRSQRT14PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VRSQRT14PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VRSQRT14PS ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VRSQRT14SD ¶
func (self *Program) VRSQRT14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VRSQRT14SD performs "Compute Approximate Reciprocal of a Square Root of a Scalar Double-Precision Floating-Point Value".
Mnemonic : VRSQRT14SD Supported forms : (2 forms)
- VRSQRT14SD xmm, xmm, xmm{k}{z} [AVX512F]
- VRSQRT14SD m64, xmm, xmm{k}{z} [AVX512F]
func (*Program) VRSQRT14SS ¶
func (self *Program) VRSQRT14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VRSQRT14SS performs "Compute Approximate Reciprocal of a Square Root of a Scalar Single-Precision Floating-Point Value".
Mnemonic : VRSQRT14SS Supported forms : (2 forms)
- VRSQRT14SS xmm, xmm, xmm{k}{z} [AVX512F]
- VRSQRT14SS m32, xmm, xmm{k}{z} [AVX512F]
func (*Program) VRSQRT28PD ¶
func (self *Program) VRSQRT28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VRSQRT28PD performs "Approximation to the Reciprocal Square Root of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error".
Mnemonic : VRSQRT28PD Supported forms : (3 forms)
- VRSQRT28PD m512/m64bcst, zmm{k}{z} [AVX512ER]
- VRSQRT28PD {sae}, zmm, zmm{k}{z} [AVX512ER]
- VRSQRT28PD zmm, zmm{k}{z} [AVX512ER]
func (*Program) VRSQRT28PS ¶
func (self *Program) VRSQRT28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VRSQRT28PS performs "Approximation to the Reciprocal Square Root of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error".
Mnemonic : VRSQRT28PS Supported forms : (3 forms)
- VRSQRT28PS m512/m32bcst, zmm{k}{z} [AVX512ER]
- VRSQRT28PS {sae}, zmm, zmm{k}{z} [AVX512ER]
- VRSQRT28PS zmm, zmm{k}{z} [AVX512ER]
func (*Program) VRSQRT28SD ¶
func (self *Program) VRSQRT28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VRSQRT28SD performs "Approximation to the Reciprocal Square Root of a Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error".
Mnemonic : VRSQRT28SD Supported forms : (3 forms)
- VRSQRT28SD m64, xmm, xmm{k}{z} [AVX512ER]
- VRSQRT28SD {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
- VRSQRT28SD xmm, xmm, xmm{k}{z} [AVX512ER]
func (*Program) VRSQRT28SS ¶
func (self *Program) VRSQRT28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VRSQRT28SS performs "Approximation to the Reciprocal Square Root of a Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error".
Mnemonic : VRSQRT28SS Supported forms : (3 forms)
- VRSQRT28SS m32, xmm, xmm{k}{z} [AVX512ER]
- VRSQRT28SS {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
- VRSQRT28SS xmm, xmm, xmm{k}{z} [AVX512ER]
func (*Program) VRSQRTPS ¶
func (self *Program) VRSQRTPS(v0 interface{}, v1 interface{}) *Instruction
VRSQRTPS performs "Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".
Mnemonic : VRSQRTPS Supported forms : (4 forms)
- VRSQRTPS xmm, xmm [AVX]
- VRSQRTPS m128, xmm [AVX]
- VRSQRTPS ymm, ymm [AVX]
- VRSQRTPS m256, ymm [AVX]
func (*Program) VRSQRTSS ¶
func (self *Program) VRSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VRSQRTSS performs "Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value".
Mnemonic : VRSQRTSS Supported forms : (2 forms)
- VRSQRTSS xmm, xmm, xmm [AVX]
- VRSQRTSS m32, xmm, xmm [AVX]
func (*Program) VSCALEFPD ¶
func (self *Program) VSCALEFPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSCALEFPD performs "Scale Packed Double-Precision Floating-Point Values With Double-Precision Floating-Point Values".
Mnemonic : VSCALEFPD Supported forms : (7 forms)
- VSCALEFPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VSCALEFPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VSCALEFPD zmm, zmm, zmm{k}{z} [AVX512F]
- VSCALEFPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSCALEFPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSCALEFPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSCALEFPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSCALEFPS ¶
func (self *Program) VSCALEFPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSCALEFPS performs "Scale Packed Single-Precision Floating-Point Values With Single-Precision Floating-Point Values".
Mnemonic : VSCALEFPS Supported forms : (7 forms)
- VSCALEFPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VSCALEFPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VSCALEFPS zmm, zmm, zmm{k}{z} [AVX512F]
- VSCALEFPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSCALEFPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSCALEFPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSCALEFPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSCALEFSD ¶
func (self *Program) VSCALEFSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSCALEFSD performs "Scale Scalar Double-Precision Floating-Point Value With a Double-Precision Floating-Point Value".
Mnemonic : VSCALEFSD Supported forms : (3 forms)
- VSCALEFSD m64, xmm, xmm{k}{z} [AVX512F]
- VSCALEFSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VSCALEFSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VSCALEFSS ¶
func (self *Program) VSCALEFSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSCALEFSS performs "Scale Scalar Single-Precision Floating-Point Value With a Single-Precision Floating-Point Value".
Mnemonic : VSCALEFSS Supported forms : (3 forms)
- VSCALEFSS m32, xmm, xmm{k}{z} [AVX512F]
- VSCALEFSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VSCALEFSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VSCATTERDPD ¶
func (self *Program) VSCATTERDPD(v0 interface{}, v1 interface{}) *Instruction
VSCATTERDPD performs "Scatter Packed Double-Precision Floating-Point Values with Signed Doubleword Indices".
Mnemonic : VSCATTERDPD Supported forms : (3 forms)
- VSCATTERDPD zmm, vm32y{k} [AVX512F]
- VSCATTERDPD xmm, vm32x{k} [AVX512F,AVX512VL]
- VSCATTERDPD ymm, vm32x{k} [AVX512F,AVX512VL]
func (*Program) VSCATTERDPS ¶
func (self *Program) VSCATTERDPS(v0 interface{}, v1 interface{}) *Instruction
VSCATTERDPS performs "Scatter Packed Single-Precision Floating-Point Values with Signed Doubleword Indices".
Mnemonic : VSCATTERDPS Supported forms : (3 forms)
- VSCATTERDPS zmm, vm32z{k} [AVX512F]
- VSCATTERDPS xmm, vm32x{k} [AVX512F,AVX512VL]
- VSCATTERDPS ymm, vm32y{k} [AVX512F,AVX512VL]
func (*Program) VSCATTERPF0DPD ¶
func (self *Program) VSCATTERPF0DPD(v0 interface{}) *Instruction
VSCATTERPF0DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint with Intent to Write".
Mnemonic : VSCATTERPF0DPD Supported forms : (1 form)
- VSCATTERPF0DPD vm32y{k} [AVX512PF]
func (*Program) VSCATTERPF0DPS ¶
func (self *Program) VSCATTERPF0DPS(v0 interface{}) *Instruction
VSCATTERPF0DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint with Intent to Write".
Mnemonic : VSCATTERPF0DPS Supported forms : (1 form)
- VSCATTERPF0DPS vm32z{k} [AVX512PF]
func (*Program) VSCATTERPF0QPD ¶
func (self *Program) VSCATTERPF0QPD(v0 interface{}) *Instruction
VSCATTERPF0QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint with Intent to Write".
Mnemonic : VSCATTERPF0QPD Supported forms : (1 form)
- VSCATTERPF0QPD vm64z{k} [AVX512PF]
func (*Program) VSCATTERPF0QPS ¶
func (self *Program) VSCATTERPF0QPS(v0 interface{}) *Instruction
VSCATTERPF0QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint with Intent to Write".
Mnemonic : VSCATTERPF0QPS Supported forms : (1 form)
- VSCATTERPF0QPS vm64z{k} [AVX512PF]
func (*Program) VSCATTERPF1DPD ¶
func (self *Program) VSCATTERPF1DPD(v0 interface{}) *Instruction
VSCATTERPF1DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint with Intent to Write".
Mnemonic : VSCATTERPF1DPD Supported forms : (1 form)
- VSCATTERPF1DPD vm32y{k} [AVX512PF]
func (*Program) VSCATTERPF1DPS ¶
func (self *Program) VSCATTERPF1DPS(v0 interface{}) *Instruction
VSCATTERPF1DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint with Intent to Write".
Mnemonic : VSCATTERPF1DPS Supported forms : (1 form)
- VSCATTERPF1DPS vm32z{k} [AVX512PF]
func (*Program) VSCATTERPF1QPD ¶
func (self *Program) VSCATTERPF1QPD(v0 interface{}) *Instruction
VSCATTERPF1QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint with Intent to Write".
Mnemonic : VSCATTERPF1QPD Supported forms : (1 form)
- VSCATTERPF1QPD vm64z{k} [AVX512PF]
func (*Program) VSCATTERPF1QPS ¶
func (self *Program) VSCATTERPF1QPS(v0 interface{}) *Instruction
VSCATTERPF1QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint with Intent to Write".
Mnemonic : VSCATTERPF1QPS Supported forms : (1 form)
- VSCATTERPF1QPS vm64z{k} [AVX512PF]
func (*Program) VSCATTERQPD ¶
func (self *Program) VSCATTERQPD(v0 interface{}, v1 interface{}) *Instruction
VSCATTERQPD performs "Scatter Packed Double-Precision Floating-Point Values with Signed Quadword Indices".
Mnemonic : VSCATTERQPD Supported forms : (3 forms)
- VSCATTERQPD zmm, vm64z{k} [AVX512F]
- VSCATTERQPD xmm, vm64x{k} [AVX512F,AVX512VL]
- VSCATTERQPD ymm, vm64y{k} [AVX512F,AVX512VL]
func (*Program) VSCATTERQPS ¶
func (self *Program) VSCATTERQPS(v0 interface{}, v1 interface{}) *Instruction
VSCATTERQPS performs "Scatter Packed Single-Precision Floating-Point Values with Signed Quadword Indices".
Mnemonic : VSCATTERQPS Supported forms : (3 forms)
- VSCATTERQPS ymm, vm64z{k} [AVX512F]
- VSCATTERQPS xmm, vm64x{k} [AVX512F,AVX512VL]
- VSCATTERQPS xmm, vm64y{k} [AVX512F,AVX512VL]
func (*Program) VSHUFF32X4 ¶
func (self *Program) VSHUFF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VSHUFF32X4 performs "Shuffle 128-Bit Packed Single-Precision Floating-Point Values".
Mnemonic : VSHUFF32X4 Supported forms : (4 forms)
- VSHUFF32X4 imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VSHUFF32X4 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VSHUFF32X4 imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSHUFF32X4 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSHUFF64X2 ¶
func (self *Program) VSHUFF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VSHUFF64X2 performs "Shuffle 128-Bit Packed Double-Precision Floating-Point Values".
Mnemonic : VSHUFF64X2 Supported forms : (4 forms)
- VSHUFF64X2 imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VSHUFF64X2 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VSHUFF64X2 imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSHUFF64X2 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSHUFI32X4 ¶
func (self *Program) VSHUFI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VSHUFI32X4 performs "Shuffle 128-Bit Packed Doubleword Integer Values".
Mnemonic : VSHUFI32X4 Supported forms : (4 forms)
- VSHUFI32X4 imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VSHUFI32X4 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VSHUFI32X4 imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSHUFI32X4 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSHUFI64X2 ¶
func (self *Program) VSHUFI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VSHUFI64X2 performs "Shuffle 128-Bit Packed Quadword Integer Values".
Mnemonic : VSHUFI64X2 Supported forms : (4 forms)
- VSHUFI64X2 imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VSHUFI64X2 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VSHUFI64X2 imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSHUFI64X2 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSHUFPD ¶
func (self *Program) VSHUFPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VSHUFPD performs "Shuffle Packed Double-Precision Floating-Point Values".
Mnemonic : VSHUFPD Supported forms : (10 forms)
- VSHUFPD imm8, xmm, xmm, xmm [AVX]
- VSHUFPD imm8, m128, xmm, xmm [AVX]
- VSHUFPD imm8, ymm, ymm, ymm [AVX]
- VSHUFPD imm8, m256, ymm, ymm [AVX]
- VSHUFPD imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VSHUFPD imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VSHUFPD imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSHUFPD imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSHUFPD imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSHUFPD imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSHUFPS ¶
func (self *Program) VSHUFPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction
VSHUFPS performs "Shuffle Packed Single-Precision Floating-Point Values".
Mnemonic : VSHUFPS Supported forms : (10 forms)
- VSHUFPS imm8, xmm, xmm, xmm [AVX]
- VSHUFPS imm8, m128, xmm, xmm [AVX]
- VSHUFPS imm8, ymm, ymm, ymm [AVX]
- VSHUFPS imm8, m256, ymm, ymm [AVX]
- VSHUFPS imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VSHUFPS imm8, zmm, zmm, zmm{k}{z} [AVX512F]
- VSHUFPS imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSHUFPS imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSHUFPS imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSHUFPS imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSQRTPD ¶
func (self *Program) VSQRTPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VSQRTPD performs "Compute Square Roots of Packed Double-Precision Floating-Point Values".
Mnemonic : VSQRTPD Supported forms : (11 forms)
- VSQRTPD xmm, xmm [AVX]
- VSQRTPD m128, xmm [AVX]
- VSQRTPD ymm, ymm [AVX]
- VSQRTPD m256, ymm [AVX]
- VSQRTPD m512/m64bcst, zmm{k}{z} [AVX512F]
- VSQRTPD {er}, zmm, zmm{k}{z} [AVX512F]
- VSQRTPD zmm, zmm{k}{z} [AVX512F]
- VSQRTPD m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VSQRTPD m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VSQRTPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSQRTPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSQRTPS ¶
func (self *Program) VSQRTPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VSQRTPS performs "Compute Square Roots of Packed Single-Precision Floating-Point Values".
Mnemonic : VSQRTPS Supported forms : (11 forms)
- VSQRTPS xmm, xmm [AVX]
- VSQRTPS m128, xmm [AVX]
- VSQRTPS ymm, ymm [AVX]
- VSQRTPS m256, ymm [AVX]
- VSQRTPS m512/m32bcst, zmm{k}{z} [AVX512F]
- VSQRTPS {er}, zmm, zmm{k}{z} [AVX512F]
- VSQRTPS zmm, zmm{k}{z} [AVX512F]
- VSQRTPS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
- VSQRTPS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
- VSQRTPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSQRTPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSQRTSD ¶
func (self *Program) VSQRTSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSQRTSD performs "Compute Square Root of Scalar Double-Precision Floating-Point Value".
Mnemonic : VSQRTSD Supported forms : (5 forms)
- VSQRTSD xmm, xmm, xmm [AVX]
- VSQRTSD m64, xmm, xmm [AVX]
- VSQRTSD m64, xmm, xmm{k}{z} [AVX512F]
- VSQRTSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VSQRTSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VSQRTSS ¶
func (self *Program) VSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSQRTSS performs "Compute Square Root of Scalar Single-Precision Floating-Point Value".
Mnemonic : VSQRTSS Supported forms : (5 forms)
- VSQRTSS xmm, xmm, xmm [AVX]
- VSQRTSS m32, xmm, xmm [AVX]
- VSQRTSS m32, xmm, xmm{k}{z} [AVX512F]
- VSQRTSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VSQRTSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VSTMXCSR ¶
func (self *Program) VSTMXCSR(v0 interface{}) *Instruction
VSTMXCSR performs "Store MXCSR Register State".
Mnemonic : VSTMXCSR Supported forms : (1 form)
- VSTMXCSR m32 [AVX]
func (*Program) VSUBPD ¶
func (self *Program) VSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSUBPD performs "Subtract Packed Double-Precision Floating-Point Values".
Mnemonic : VSUBPD Supported forms : (11 forms)
- VSUBPD xmm, xmm, xmm [AVX]
- VSUBPD m128, xmm, xmm [AVX]
- VSUBPD ymm, ymm, ymm [AVX]
- VSUBPD m256, ymm, ymm [AVX]
- VSUBPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VSUBPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VSUBPD zmm, zmm, zmm{k}{z} [AVX512F]
- VSUBPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSUBPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSUBPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSUBPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSUBPS ¶
func (self *Program) VSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSUBPS performs "Subtract Packed Single-Precision Floating-Point Values".
Mnemonic : VSUBPS Supported forms : (11 forms)
- VSUBPS xmm, xmm, xmm [AVX]
- VSUBPS m128, xmm, xmm [AVX]
- VSUBPS ymm, ymm, ymm [AVX]
- VSUBPS m256, ymm, ymm [AVX]
- VSUBPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VSUBPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
- VSUBPS zmm, zmm, zmm{k}{z} [AVX512F]
- VSUBPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSUBPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VSUBPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VSUBPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VSUBSD ¶
func (self *Program) VSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSUBSD performs "Subtract Scalar Double-Precision Floating-Point Values".
Mnemonic : VSUBSD Supported forms : (5 forms)
- VSUBSD xmm, xmm, xmm [AVX]
- VSUBSD m64, xmm, xmm [AVX]
- VSUBSD m64, xmm, xmm{k}{z} [AVX512F]
- VSUBSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VSUBSD xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VSUBSS ¶
func (self *Program) VSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction
VSUBSS performs "Subtract Scalar Single-Precision Floating-Point Values".
Mnemonic : VSUBSS Supported forms : (5 forms)
- VSUBSS xmm, xmm, xmm [AVX]
- VSUBSS m32, xmm, xmm [AVX]
- VSUBSS m32, xmm, xmm{k}{z} [AVX512F]
- VSUBSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
- VSUBSS xmm, xmm, xmm{k}{z} [AVX512F]
func (*Program) VTESTPD ¶
func (self *Program) VTESTPD(v0 interface{}, v1 interface{}) *Instruction
VTESTPD performs "Packed Double-Precision Floating-Point Bit Test".
Mnemonic : VTESTPD Supported forms : (4 forms)
- VTESTPD xmm, xmm [AVX]
- VTESTPD m128, xmm [AVX]
- VTESTPD ymm, ymm [AVX]
- VTESTPD m256, ymm [AVX]
func (*Program) VTESTPS ¶
func (self *Program) VTESTPS(v0 interface{}, v1 interface{}) *Instruction
VTESTPS performs "Packed Single-Precision Floating-Point Bit Test".
Mnemonic : VTESTPS Supported forms : (4 forms)
- VTESTPS xmm, xmm [AVX]
- VTESTPS m128, xmm [AVX]
- VTESTPS ymm, ymm [AVX]
- VTESTPS m256, ymm [AVX]
func (*Program) VUCOMISD ¶
func (self *Program) VUCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VUCOMISD performs "Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : VUCOMISD Supported forms : (5 forms)
- VUCOMISD xmm, xmm [AVX]
- VUCOMISD m64, xmm [AVX]
- VUCOMISD m64, xmm [AVX512F]
- VUCOMISD {sae}, xmm, xmm [AVX512F]
- VUCOMISD xmm, xmm [AVX512F]
func (*Program) VUCOMISS ¶
func (self *Program) VUCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction
VUCOMISS performs "Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS".
Mnemonic : VUCOMISS Supported forms : (5 forms)
- VUCOMISS xmm, xmm [AVX]
- VUCOMISS m32, xmm [AVX]
- VUCOMISS m32, xmm [AVX512F]
- VUCOMISS {sae}, xmm, xmm [AVX512F]
- VUCOMISS xmm, xmm [AVX512F]
func (*Program) VUNPCKHPD ¶
func (self *Program) VUNPCKHPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VUNPCKHPD performs "Unpack and Interleave High Packed Double-Precision Floating-Point Values".
Mnemonic : VUNPCKHPD Supported forms : (10 forms)
- VUNPCKHPD xmm, xmm, xmm [AVX]
- VUNPCKHPD m128, xmm, xmm [AVX]
- VUNPCKHPD ymm, ymm, ymm [AVX]
- VUNPCKHPD m256, ymm, ymm [AVX]
- VUNPCKHPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VUNPCKHPD zmm, zmm, zmm{k}{z} [AVX512F]
- VUNPCKHPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKHPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKHPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VUNPCKHPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VUNPCKHPS ¶
func (self *Program) VUNPCKHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VUNPCKHPS performs "Unpack and Interleave High Packed Single-Precision Floating-Point Values".
Mnemonic : VUNPCKHPS Supported forms : (10 forms)
- VUNPCKHPS xmm, xmm, xmm [AVX]
- VUNPCKHPS m128, xmm, xmm [AVX]
- VUNPCKHPS ymm, ymm, ymm [AVX]
- VUNPCKHPS m256, ymm, ymm [AVX]
- VUNPCKHPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VUNPCKHPS zmm, zmm, zmm{k}{z} [AVX512F]
- VUNPCKHPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKHPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKHPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VUNPCKHPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VUNPCKLPD ¶
func (self *Program) VUNPCKLPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VUNPCKLPD performs "Unpack and Interleave Low Packed Double-Precision Floating-Point Values".
Mnemonic : VUNPCKLPD Supported forms : (10 forms)
- VUNPCKLPD xmm, xmm, xmm [AVX]
- VUNPCKLPD m128, xmm, xmm [AVX]
- VUNPCKLPD ymm, ymm, ymm [AVX]
- VUNPCKLPD m256, ymm, ymm [AVX]
- VUNPCKLPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
- VUNPCKLPD zmm, zmm, zmm{k}{z} [AVX512F]
- VUNPCKLPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKLPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKLPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VUNPCKLPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VUNPCKLPS ¶
func (self *Program) VUNPCKLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VUNPCKLPS performs "Unpack and Interleave Low Packed Single-Precision Floating-Point Values".
Mnemonic : VUNPCKLPS Supported forms : (10 forms)
- VUNPCKLPS xmm, xmm, xmm [AVX]
- VUNPCKLPS m128, xmm, xmm [AVX]
- VUNPCKLPS ymm, ymm, ymm [AVX]
- VUNPCKLPS m256, ymm, ymm [AVX]
- VUNPCKLPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
- VUNPCKLPS zmm, zmm, zmm{k}{z} [AVX512F]
- VUNPCKLPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKLPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
- VUNPCKLPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
- VUNPCKLPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
func (*Program) VXORPD ¶
func (self *Program) VXORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VXORPD performs "Bitwise Logical XOR for Double-Precision Floating-Point Values".
Mnemonic : VXORPD Supported forms : (10 forms)
- VXORPD xmm, xmm, xmm [AVX]
- VXORPD m128, xmm, xmm [AVX]
- VXORPD ymm, ymm, ymm [AVX]
- VXORPD m256, ymm, ymm [AVX]
- VXORPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
- VXORPD zmm, zmm, zmm{k}{z} [AVX512DQ]
- VXORPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VXORPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VXORPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VXORPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VXORPS ¶
func (self *Program) VXORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction
VXORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".
Mnemonic : VXORPS Supported forms : (10 forms)
- VXORPS xmm, xmm, xmm [AVX]
- VXORPS m128, xmm, xmm [AVX]
- VXORPS ymm, ymm, ymm [AVX]
- VXORPS m256, ymm, ymm [AVX]
- VXORPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
- VXORPS zmm, zmm, zmm{k}{z} [AVX512DQ]
- VXORPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VXORPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
- VXORPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
- VXORPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
func (*Program) VZEROALL ¶
func (self *Program) VZEROALL() *Instruction
VZEROALL performs "Zero All YMM Registers".
Mnemonic : VZEROALL Supported forms : (1 form)
- VZEROALL [AVX]
func (*Program) VZEROUPPER ¶
func (self *Program) VZEROUPPER() *Instruction
VZEROUPPER performs "Zero Upper Bits of YMM Registers".
Mnemonic : VZEROUPPER Supported forms : (1 form)
- VZEROUPPER [AVX]
func (*Program) Word ¶
func (self *Program) Word(v *expr.Expr) (p *Instruction)
Word is a pseudo-instruction to add raw uint16 as little-endian to the assembled code.
func (*Program) XADDB ¶
func (self *Program) XADDB(v0 interface{}, v1 interface{}) *Instruction
XADDB performs "Exchange and Add".
Mnemonic : XADD Supported forms : (2 forms)
- XADDB r8, r8
- XADDB r8, m8
func (*Program) XADDL ¶
func (self *Program) XADDL(v0 interface{}, v1 interface{}) *Instruction
XADDL performs "Exchange and Add".
Mnemonic : XADD Supported forms : (2 forms)
- XADDL r32, r32
- XADDL r32, m32
func (*Program) XADDQ ¶
func (self *Program) XADDQ(v0 interface{}, v1 interface{}) *Instruction
XADDQ performs "Exchange and Add".
Mnemonic : XADD Supported forms : (2 forms)
- XADDQ r64, r64
- XADDQ r64, m64
func (*Program) XADDW ¶
func (self *Program) XADDW(v0 interface{}, v1 interface{}) *Instruction
XADDW performs "Exchange and Add".
Mnemonic : XADD Supported forms : (2 forms)
- XADDW r16, r16
- XADDW r16, m16
func (*Program) XCHGB ¶
func (self *Program) XCHGB(v0 interface{}, v1 interface{}) *Instruction
XCHGB performs "Exchange Register/Memory with Register".
Mnemonic : XCHG Supported forms : (3 forms)
- XCHGB r8, r8
- XCHGB m8, r8
- XCHGB r8, m8
func (*Program) XCHGL ¶
func (self *Program) XCHGL(v0 interface{}, v1 interface{}) *Instruction
XCHGL performs "Exchange Register/Memory with Register".
Mnemonic : XCHG Supported forms : (5 forms)
- XCHGL r32, eax
- XCHGL eax, r32
- XCHGL r32, r32
- XCHGL m32, r32
- XCHGL r32, m32
func (*Program) XCHGQ ¶
func (self *Program) XCHGQ(v0 interface{}, v1 interface{}) *Instruction
XCHGQ performs "Exchange Register/Memory with Register".
Mnemonic : XCHG Supported forms : (5 forms)
- XCHGQ r64, rax
- XCHGQ rax, r64
- XCHGQ r64, r64
- XCHGQ m64, r64
- XCHGQ r64, m64
func (*Program) XCHGW ¶
func (self *Program) XCHGW(v0 interface{}, v1 interface{}) *Instruction
XCHGW performs "Exchange Register/Memory with Register".
Mnemonic : XCHG Supported forms : (5 forms)
- XCHGW r16, ax
- XCHGW ax, r16
- XCHGW r16, r16
- XCHGW m16, r16
- XCHGW r16, m16
func (*Program) XGETBV ¶
func (self *Program) XGETBV() *Instruction
XGETBV performs "Get Value of Extended Control Register".
Mnemonic : XGETBV Supported forms : (1 form)
- XGETBV
func (*Program) XLATB ¶
func (self *Program) XLATB() *Instruction
XLATB performs "Table Look-up Translation".
Mnemonic : XLATB Supported forms : (2 forms)
- XLATB
- XLATB
func (*Program) XORB ¶
func (self *Program) XORB(v0 interface{}, v1 interface{}) *Instruction
XORB performs "Logical Exclusive OR".
Mnemonic : XOR Supported forms : (6 forms)
- XORB imm8, al
- XORB imm8, r8
- XORB r8, r8
- XORB m8, r8
- XORB imm8, m8
- XORB r8, m8
func (*Program) XORL ¶
func (self *Program) XORL(v0 interface{}, v1 interface{}) *Instruction
XORL performs "Logical Exclusive OR".
Mnemonic : XOR Supported forms : (8 forms)
- XORL imm32, eax
- XORL imm8, r32
- XORL imm32, r32
- XORL r32, r32
- XORL m32, r32
- XORL imm8, m32
- XORL imm32, m32
- XORL r32, m32
func (*Program) XORPD ¶
func (self *Program) XORPD(v0 interface{}, v1 interface{}) *Instruction
XORPD performs "Bitwise Logical XOR for Double-Precision Floating-Point Values".
Mnemonic : XORPD Supported forms : (2 forms)
- XORPD xmm, xmm [SSE2]
- XORPD m128, xmm [SSE2]
func (*Program) XORPS ¶
func (self *Program) XORPS(v0 interface{}, v1 interface{}) *Instruction
XORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".
Mnemonic : XORPS Supported forms : (2 forms)
- XORPS xmm, xmm [SSE]
- XORPS m128, xmm [SSE]
func (*Program) XORQ ¶
func (self *Program) XORQ(v0 interface{}, v1 interface{}) *Instruction
XORQ performs "Logical Exclusive OR".
Mnemonic : XOR Supported forms : (8 forms)
- XORQ imm32, rax
- XORQ imm8, r64
- XORQ imm32, r64
- XORQ r64, r64
- XORQ m64, r64
- XORQ imm8, m64
- XORQ imm32, m64
- XORQ r64, m64
func (*Program) XORW ¶
func (self *Program) XORW(v0 interface{}, v1 interface{}) *Instruction
XORW performs "Logical Exclusive OR".
Mnemonic : XOR Supported forms : (8 forms)
- XORW imm16, ax
- XORW imm8, r16
- XORW imm16, r16
- XORW r16, r16
- XORW m16, r16
- XORW imm8, m16
- XORW imm16, m16
- XORW r16, m16
type Register16 ¶
type Register16 byte
const ( AX Register16 = iota CX DX BX SP BP SI DI R8w R9w R10w R11w R12w R13w R14w R15w )
func (Register16) String ¶
func (self Register16) String() string
type Register32 ¶
type Register32 byte
const ( EAX Register32 = iota ECX EDX EBX ESP EBP ESI EDI R8d R9d R10d R11d R12d R13d R14d R15d )
func (Register32) String ¶
func (self Register32) String() string
type Register64 ¶
type Register64 byte
const ( RAX Register64 = iota RCX RDX RBX RSP RBP RSI RDI R8 R9 R10 R11 R12 R13 R14 R15 )
func (Register64) String ¶
func (self Register64) String() string
type RegisterMask ¶
RegisterMask is a KRegister used to mask another register.
func (RegisterMask) String ¶
func (self RegisterMask) String() string
String implements the fmt.Stringer interface.
type RelativeOffset ¶
type RelativeOffset int32
RelativeOffset represents an RIP-relative offset.
func (RelativeOffset) String ¶
func (self RelativeOffset) String() string
String implements the fmt.Stringer interface.
type RoundingControl ¶
type RoundingControl uint8
RoundingControl represents a floating-point rounding option.
const ( // RN_SAE represents "Round Nearest", which is the default rounding option. RN_SAE RoundingControl = iota // RD_SAE represents "Round Down". RD_SAE // RU_SAE represents "Round Up". RU_SAE // RZ_SAE represents "Round towards Zero". RZ_SAE )
func (RoundingControl) String ¶
func (self RoundingControl) String() string
type SyntaxError ¶
SyntaxError represents an error in the assembly syntax.
func (*SyntaxError) Error ¶
func (self *SyntaxError) Error() string
Error implements the error interface.
type XMMRegister ¶
type XMMRegister byte
const ( XMM0 XMMRegister = iota XMM1 XMM2 XMM3 XMM4 XMM5 XMM6 XMM7 XMM8 XMM9 XMM10 XMM11 XMM12 XMM13 XMM14 XMM15 XMM16 XMM17 XMM18 XMM19 XMM20 XMM21 XMM22 XMM23 XMM24 XMM25 XMM26 XMM27 XMM28 XMM29 XMM30 XMM31 )
func (XMMRegister) String ¶
func (self XMMRegister) String() string
type YMMRegister ¶
type YMMRegister byte
const ( YMM0 YMMRegister = iota YMM1 YMM2 YMM3 YMM4 YMM5 YMM6 YMM7 YMM8 YMM9 YMM10 YMM11 YMM12 YMM13 YMM14 YMM15 YMM16 YMM17 YMM18 YMM19 YMM20 YMM21 YMM22 YMM23 YMM24 YMM25 YMM26 YMM27 YMM28 YMM29 YMM30 YMM31 )
func (YMMRegister) String ¶
func (self YMMRegister) String() string
type ZMMRegister ¶
type ZMMRegister byte
const ( ZMM0 ZMMRegister = iota ZMM1 ZMM2 ZMM3 ZMM4 ZMM5 ZMM6 ZMM7 ZMM8 ZMM9 ZMM10 ZMM11 ZMM12 ZMM13 ZMM14 ZMM15 ZMM16 ZMM17 ZMM18 ZMM19 ZMM20 ZMM21 ZMM22 ZMM23 ZMM24 ZMM25 ZMM26 ZMM27 ZMM28 ZMM29 ZMM30 ZMM31 )
func (ZMMRegister) String ¶
func (self ZMMRegister) String() string