package x86

avo – github.com/mmcloughlin/avo/x86 Index | Files

package x86

import "github.com/mmcloughlin/avo/x86"

Package x86 provides constructors for all x86-64 instructions.

Index ¶

func ADCB(imr, amr operand.Op) (*intrep.Instruction, error)
func ADCL(imr, emr operand.Op) (*intrep.Instruction, error)
func ADCQ(imr, mr operand.Op) (*intrep.Instruction, error)
func ADCW(imr, amr operand.Op) (*intrep.Instruction, error)
func ADCXL(mr, r operand.Op) (*intrep.Instruction, error)
func ADCXQ(mr, r operand.Op) (*intrep.Instruction, error)
func ADDB(imr, amr operand.Op) (*intrep.Instruction, error)
func ADDL(imr, emr operand.Op) (*intrep.Instruction, error)
func ADDPD(mx, x operand.Op) (*intrep.Instruction, error)
func ADDPS(mx, x operand.Op) (*intrep.Instruction, error)
func ADDQ(imr, mr operand.Op) (*intrep.Instruction, error)
func ADDSD(mx, x operand.Op) (*intrep.Instruction, error)
func ADDSS(mx, x operand.Op) (*intrep.Instruction, error)
func ADDSUBPD(mx, x operand.Op) (*intrep.Instruction, error)
func ADDSUBPS(mx, x operand.Op) (*intrep.Instruction, error)
func ADDW(imr, amr operand.Op) (*intrep.Instruction, error)
func ADOXL(mr, r operand.Op) (*intrep.Instruction, error)
func ADOXQ(mr, r operand.Op) (*intrep.Instruction, error)
func AESDEC(mx, x operand.Op) (*intrep.Instruction, error)
func AESDECLAST(mx, x operand.Op) (*intrep.Instruction, error)
func AESENC(mx, x operand.Op) (*intrep.Instruction, error)
func AESENCLAST(mx, x operand.Op) (*intrep.Instruction, error)
func AESIMC(mx, x operand.Op) (*intrep.Instruction, error)
func AESKEYGENASSIST(i, mx, x operand.Op) (*intrep.Instruction, error)
func ANDB(imr, amr operand.Op) (*intrep.Instruction, error)
func ANDL(imr, emr operand.Op) (*intrep.Instruction, error)
func ANDNL(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func ANDNPD(mx, x operand.Op) (*intrep.Instruction, error)
func ANDNPS(mx, x operand.Op) (*intrep.Instruction, error)
func ANDNQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func ANDPD(mx, x operand.Op) (*intrep.Instruction, error)
func ANDPS(mx, x operand.Op) (*intrep.Instruction, error)
func ANDQ(imr, mr operand.Op) (*intrep.Instruction, error)
func ANDW(imr, amr operand.Op) (*intrep.Instruction, error)
func BEXTRL(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func BEXTRQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func BLENDPD(i, mx, x operand.Op) (*intrep.Instruction, error)
func BLENDPS(i, mx, x operand.Op) (*intrep.Instruction, error)
func BLENDVPD(x, mx, x1 operand.Op) (*intrep.Instruction, error)
func BLENDVPS(x, mx, x1 operand.Op) (*intrep.Instruction, error)
func BLSIL(mr, r operand.Op) (*intrep.Instruction, error)
func BLSIQ(mr, r operand.Op) (*intrep.Instruction, error)
func BLSMSKL(mr, r operand.Op) (*intrep.Instruction, error)
func BLSMSKQ(mr, r operand.Op) (*intrep.Instruction, error)
func BLSRL(mr, r operand.Op) (*intrep.Instruction, error)
func BLSRQ(mr, r operand.Op) (*intrep.Instruction, error)
func BSFL(mr, r operand.Op) (*intrep.Instruction, error)
func BSFQ(mr, r operand.Op) (*intrep.Instruction, error)
func BSFW(mr, r operand.Op) (*intrep.Instruction, error)
func BSRL(mr, r operand.Op) (*intrep.Instruction, error)
func BSRQ(mr, r operand.Op) (*intrep.Instruction, error)
func BSRW(mr, r operand.Op) (*intrep.Instruction, error)
func BSWAPL(r operand.Op) (*intrep.Instruction, error)
func BSWAPQ(r operand.Op) (*intrep.Instruction, error)
func BTCL(ir, mr operand.Op) (*intrep.Instruction, error)
func BTCQ(ir, mr operand.Op) (*intrep.Instruction, error)
func BTCW(ir, mr operand.Op) (*intrep.Instruction, error)
func BTL(ir, mr operand.Op) (*intrep.Instruction, error)
func BTQ(ir, mr operand.Op) (*intrep.Instruction, error)
func BTRL(ir, mr operand.Op) (*intrep.Instruction, error)
func BTRQ(ir, mr operand.Op) (*intrep.Instruction, error)
func BTRW(ir, mr operand.Op) (*intrep.Instruction, error)
func BTSL(ir, mr operand.Op) (*intrep.Instruction, error)
func BTSQ(ir, mr operand.Op) (*intrep.Instruction, error)
func BTSW(ir, mr operand.Op) (*intrep.Instruction, error)
func BTW(ir, mr operand.Op) (*intrep.Instruction, error)
func BZHIL(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func BZHIQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func CALL(r operand.Op) (*intrep.Instruction, error)
func CBW() (*intrep.Instruction, error)
func CDQ() (*intrep.Instruction, error)
func CDQE() (*intrep.Instruction, error)
func CLC() (*intrep.Instruction, error)
func CLD() (*intrep.Instruction, error)
func CLFLUSH(m operand.Op) (*intrep.Instruction, error)
func CLFLUSHOPT(m operand.Op) (*intrep.Instruction, error)
func CMC() (*intrep.Instruction, error)
func CMOVLCC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLCS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLEQ(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLGE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLGT(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLHI(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLLE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLLS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLLT(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLMI(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLNE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLOC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLOS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLPC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLPL(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVLPS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQCC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQCS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQEQ(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQGE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQGT(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQHI(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQLE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQLS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQLT(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQMI(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQNE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQOC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQOS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQPC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQPL(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVQPS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWCC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWCS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWEQ(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWGE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWGT(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWHI(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWLE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWLS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWLT(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWMI(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWNE(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWOC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWOS(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWPC(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWPL(mr, r operand.Op) (*intrep.Instruction, error)
func CMOVWPS(mr, r operand.Op) (*intrep.Instruction, error)
func CMPB(amr, imr operand.Op) (*intrep.Instruction, error)
func CMPL(emr, imr operand.Op) (*intrep.Instruction, error)
func CMPPD(mx, x, i operand.Op) (*intrep.Instruction, error)
func CMPPS(mx, x, i operand.Op) (*intrep.Instruction, error)
func CMPQ(mr, imr operand.Op) (*intrep.Instruction, error)
func CMPSD(mx, x, i operand.Op) (*intrep.Instruction, error)
func CMPSS(mx, x, i operand.Op) (*intrep.Instruction, error)
func CMPW(amr, imr operand.Op) (*intrep.Instruction, error)
func CMPXCHG16B(m operand.Op) (*intrep.Instruction, error)
func CMPXCHG8B(m operand.Op) (*intrep.Instruction, error)
func CMPXCHGB(r, mr operand.Op) (*intrep.Instruction, error)
func CMPXCHGL(r, mr operand.Op) (*intrep.Instruction, error)
func CMPXCHGQ(r, mr operand.Op) (*intrep.Instruction, error)
func CMPXCHGW(r, mr operand.Op) (*intrep.Instruction, error)
func COMISD(mx, x operand.Op) (*intrep.Instruction, error)
func COMISS(mx, x operand.Op) (*intrep.Instruction, error)
func CPUID() (*intrep.Instruction, error)
func CQO() (*intrep.Instruction, error)
func CRC32B(mr, r operand.Op) (*intrep.Instruction, error)
func CRC32L(mr, r operand.Op) (*intrep.Instruction, error)
func CRC32Q(mr, r operand.Op) (*intrep.Instruction, error)
func CRC32W(mr, r operand.Op) (*intrep.Instruction, error)
func CVTPD2PL(mx, x operand.Op) (*intrep.Instruction, error)
func CVTPD2PS(mx, x operand.Op) (*intrep.Instruction, error)
func CVTPL2PD(mx, x operand.Op) (*intrep.Instruction, error)
func CVTPL2PS(mx, x operand.Op) (*intrep.Instruction, error)
func CVTPS2PD(mx, x operand.Op) (*intrep.Instruction, error)
func CVTPS2PL(mx, x operand.Op) (*intrep.Instruction, error)
func CVTSD2SL(mx, r operand.Op) (*intrep.Instruction, error)
func CVTSD2SS(mx, x operand.Op) (*intrep.Instruction, error)
func CVTSL2SD(mr, x operand.Op) (*intrep.Instruction, error)
func CVTSL2SS(mr, x operand.Op) (*intrep.Instruction, error)
func CVTSQ2SD(mr, x operand.Op) (*intrep.Instruction, error)
func CVTSQ2SS(mr, x operand.Op) (*intrep.Instruction, error)
func CVTSS2SD(mx, x operand.Op) (*intrep.Instruction, error)
func CVTSS2SL(mx, r operand.Op) (*intrep.Instruction, error)
func CVTTPD2PL(mx, x operand.Op) (*intrep.Instruction, error)
func CVTTPS2PL(mx, x operand.Op) (*intrep.Instruction, error)
func CVTTSD2SL(mx, r operand.Op) (*intrep.Instruction, error)
func CVTTSD2SQ(mx, r operand.Op) (*intrep.Instruction, error)
func CVTTSS2SL(mx, r operand.Op) (*intrep.Instruction, error)
func CWD() (*intrep.Instruction, error)
func CWDE() (*intrep.Instruction, error)
func DECB(mr operand.Op) (*intrep.Instruction, error)
func DECL(mr operand.Op) (*intrep.Instruction, error)
func DECQ(mr operand.Op) (*intrep.Instruction, error)
func DECW(mr operand.Op) (*intrep.Instruction, error)
func DIVB(mr operand.Op) (*intrep.Instruction, error)
func DIVL(mr operand.Op) (*intrep.Instruction, error)
func DIVPD(mx, x operand.Op) (*intrep.Instruction, error)
func DIVPS(mx, x operand.Op) (*intrep.Instruction, error)
func DIVQ(mr operand.Op) (*intrep.Instruction, error)
func DIVSD(mx, x operand.Op) (*intrep.Instruction, error)
func DIVSS(mx, x operand.Op) (*intrep.Instruction, error)
func DIVW(mr operand.Op) (*intrep.Instruction, error)
func DPPD(i, mx, x operand.Op) (*intrep.Instruction, error)
func DPPS(i, mx, x operand.Op) (*intrep.Instruction, error)
func EXTRACTPS(i, x, mr operand.Op) (*intrep.Instruction, error)
func HADDPD(mx, x operand.Op) (*intrep.Instruction, error)
func HADDPS(mx, x operand.Op) (*intrep.Instruction, error)
func HSUBPD(mx, x operand.Op) (*intrep.Instruction, error)
func HSUBPS(mx, x operand.Op) (*intrep.Instruction, error)
func IDIVB(mr operand.Op) (*intrep.Instruction, error)
func IDIVL(mr operand.Op) (*intrep.Instruction, error)
func IDIVQ(mr operand.Op) (*intrep.Instruction, error)
func IDIVW(mr operand.Op) (*intrep.Instruction, error)
func IMUL3L(i, mr, r operand.Op) (*intrep.Instruction, error)
func IMUL3Q(i, mr, r operand.Op) (*intrep.Instruction, error)
func IMUL3W(i, mr, r operand.Op) (*intrep.Instruction, error)
func IMULB(mr operand.Op) (*intrep.Instruction, error)
func IMULL(ops ...operand.Op) (*intrep.Instruction, error)
func IMULQ(ops ...operand.Op) (*intrep.Instruction, error)
func IMULW(ops ...operand.Op) (*intrep.Instruction, error)
func INCB(mr operand.Op) (*intrep.Instruction, error)
func INCL(mr operand.Op) (*intrep.Instruction, error)
func INCQ(mr operand.Op) (*intrep.Instruction, error)
func INCW(mr operand.Op) (*intrep.Instruction, error)
func INSERTPS(i, mx, x operand.Op) (*intrep.Instruction, error)
func INT(i operand.Op) (*intrep.Instruction, error)
func JA(r operand.Op) (*intrep.Instruction, error)
func JAE(r operand.Op) (*intrep.Instruction, error)
func JB(r operand.Op) (*intrep.Instruction, error)
func JBE(r operand.Op) (*intrep.Instruction, error)
func JC(r operand.Op) (*intrep.Instruction, error)
func JCC(r operand.Op) (*intrep.Instruction, error)
func JCS(r operand.Op) (*intrep.Instruction, error)
func JCXZL(r operand.Op) (*intrep.Instruction, error)
func JCXZQ(r operand.Op) (*intrep.Instruction, error)
func JE(r operand.Op) (*intrep.Instruction, error)
func JEQ(r operand.Op) (*intrep.Instruction, error)
func JG(r operand.Op) (*intrep.Instruction, error)
func JGE(r operand.Op) (*intrep.Instruction, error)
func JGT(r operand.Op) (*intrep.Instruction, error)
func JHI(r operand.Op) (*intrep.Instruction, error)
func JHS(r operand.Op) (*intrep.Instruction, error)
func JL(r operand.Op) (*intrep.Instruction, error)
func JLE(r operand.Op) (*intrep.Instruction, error)
func JLO(r operand.Op) (*intrep.Instruction, error)
func JLS(r operand.Op) (*intrep.Instruction, error)
func JLT(r operand.Op) (*intrep.Instruction, error)
func JMI(r operand.Op) (*intrep.Instruction, error)
func JMP(mr operand.Op) (*intrep.Instruction, error)
func JNA(r operand.Op) (*intrep.Instruction, error)
func JNAE(r operand.Op) (*intrep.Instruction, error)
func JNB(r operand.Op) (*intrep.Instruction, error)
func JNBE(r operand.Op) (*intrep.Instruction, error)
func JNC(r operand.Op) (*intrep.Instruction, error)
func JNE(r operand.Op) (*intrep.Instruction, error)
func JNG(r operand.Op) (*intrep.Instruction, error)
func JNGE(r operand.Op) (*intrep.Instruction, error)
func JNL(r operand.Op) (*intrep.Instruction, error)
func JNLE(r operand.Op) (*intrep.Instruction, error)
func JNO(r operand.Op) (*intrep.Instruction, error)
func JNP(r operand.Op) (*intrep.Instruction, error)
func JNS(r operand.Op) (*intrep.Instruction, error)
func JNZ(r operand.Op) (*intrep.Instruction, error)
func JO(r operand.Op) (*intrep.Instruction, error)
func JOC(r operand.Op) (*intrep.Instruction, error)
func JOS(r operand.Op) (*intrep.Instruction, error)
func JP(r operand.Op) (*intrep.Instruction, error)
func JPC(r operand.Op) (*intrep.Instruction, error)
func JPE(r operand.Op) (*intrep.Instruction, error)
func JPL(r operand.Op) (*intrep.Instruction, error)
func JPO(r operand.Op) (*intrep.Instruction, error)
func JPS(r operand.Op) (*intrep.Instruction, error)
func JS(r operand.Op) (*intrep.Instruction, error)
func JZ(r operand.Op) (*intrep.Instruction, error)
func LDDQU(m, x operand.Op) (*intrep.Instruction, error)
func LDMXCSR(m operand.Op) (*intrep.Instruction, error)
func LEAL(m, r operand.Op) (*intrep.Instruction, error)
func LEAQ(m, r operand.Op) (*intrep.Instruction, error)
func LEAW(m, r operand.Op) (*intrep.Instruction, error)
func LFENCE() (*intrep.Instruction, error)
func LZCNTL(mr, r operand.Op) (*intrep.Instruction, error)
func LZCNTQ(mr, r operand.Op) (*intrep.Instruction, error)
func LZCNTW(mr, r operand.Op) (*intrep.Instruction, error)
func MASKMOVDQU(x, x1 operand.Op) (*intrep.Instruction, error)
func MASKMOVOU(x, x1 operand.Op) (*intrep.Instruction, error)
func MAXPD(mx, x operand.Op) (*intrep.Instruction, error)
func MAXPS(mx, x operand.Op) (*intrep.Instruction, error)
func MAXSD(mx, x operand.Op) (*intrep.Instruction, error)
func MAXSS(mx, x operand.Op) (*intrep.Instruction, error)
func MFENCE() (*intrep.Instruction, error)
func MINPD(mx, x operand.Op) (*intrep.Instruction, error)
func MINPS(mx, x operand.Op) (*intrep.Instruction, error)
func MINSD(mx, x operand.Op) (*intrep.Instruction, error)
func MINSS(mx, x operand.Op) (*intrep.Instruction, error)
func MONITOR() (*intrep.Instruction, error)
func MOVAPD(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVAPS(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVB(imr, mr operand.Op) (*intrep.Instruction, error)
func MOVBELL(mr, mr1 operand.Op) (*intrep.Instruction, error)
func MOVBEQQ(mr, mr1 operand.Op) (*intrep.Instruction, error)
func MOVBEWW(mr, mr1 operand.Op) (*intrep.Instruction, error)
func MOVBLSX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVBLZX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVBQSX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVBQZX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVBWSX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVBWZX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVD(imrx, mrx operand.Op) (*intrep.Instruction, error)
func MOVDDUP(mx, x operand.Op) (*intrep.Instruction, error)
func MOVDQ2Q(imrx, mrx operand.Op) (*intrep.Instruction, error)
func MOVHLPS(x, x1 operand.Op) (*intrep.Instruction, error)
func MOVHPD(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVHPS(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVL(imr, mr operand.Op) (*intrep.Instruction, error)
func MOVLHPS(x, x1 operand.Op) (*intrep.Instruction, error)
func MOVLPD(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVLPS(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVLQSX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVLQZX(m, r operand.Op) (*intrep.Instruction, error)
func MOVMSKPD(x, r operand.Op) (*intrep.Instruction, error)
func MOVMSKPS(x, r operand.Op) (*intrep.Instruction, error)
func MOVNTDQ(x, m operand.Op) (*intrep.Instruction, error)
func MOVNTDQA(m, x operand.Op) (*intrep.Instruction, error)
func MOVNTIL(r, m operand.Op) (*intrep.Instruction, error)
func MOVNTIQ(r, m operand.Op) (*intrep.Instruction, error)
func MOVNTO(x, m operand.Op) (*intrep.Instruction, error)
func MOVNTPD(x, m operand.Op) (*intrep.Instruction, error)
func MOVNTPS(x, m operand.Op) (*intrep.Instruction, error)
func MOVO(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVOA(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVOU(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVQ(imrx, mrx operand.Op) (*intrep.Instruction, error)
func MOVSD(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVSHDUP(mx, x operand.Op) (*intrep.Instruction, error)
func MOVSLDUP(mx, x operand.Op) (*intrep.Instruction, error)
func MOVSS(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVUPD(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVUPS(mx, mx1 operand.Op) (*intrep.Instruction, error)
func MOVW(imr, mr operand.Op) (*intrep.Instruction, error)
func MOVWLSX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVWLZX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVWQSX(mr, r operand.Op) (*intrep.Instruction, error)
func MOVWQZX(mr, r operand.Op) (*intrep.Instruction, error)
func MPSADBW(i, mx, x operand.Op) (*intrep.Instruction, error)
func MULB(mr operand.Op) (*intrep.Instruction, error)
func MULL(mr operand.Op) (*intrep.Instruction, error)
func MULPD(mx, x operand.Op) (*intrep.Instruction, error)
func MULPS(mx, x operand.Op) (*intrep.Instruction, error)
func MULQ(mr operand.Op) (*intrep.Instruction, error)
func MULSD(mx, x operand.Op) (*intrep.Instruction, error)
func MULSS(mx, x operand.Op) (*intrep.Instruction, error)
func MULW(mr operand.Op) (*intrep.Instruction, error)
func MULXL(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func MULXQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func MWAIT() (*intrep.Instruction, error)
func NEGB(mr operand.Op) (*intrep.Instruction, error)
func NEGL(mr operand.Op) (*intrep.Instruction, error)
func NEGQ(mr operand.Op) (*intrep.Instruction, error)
func NEGW(mr operand.Op) (*intrep.Instruction, error)
func NOP() (*intrep.Instruction, error)
func NOTB(mr operand.Op) (*intrep.Instruction, error)
func NOTL(mr operand.Op) (*intrep.Instruction, error)
func NOTQ(mr operand.Op) (*intrep.Instruction, error)
func NOTW(mr operand.Op) (*intrep.Instruction, error)
func ORB(imr, amr operand.Op) (*intrep.Instruction, error)
func ORL(imr, emr operand.Op) (*intrep.Instruction, error)
func ORPD(mx, x operand.Op) (*intrep.Instruction, error)
func ORPS(mx, x operand.Op) (*intrep.Instruction, error)
func ORQ(imr, mr operand.Op) (*intrep.Instruction, error)
func ORW(imr, amr operand.Op) (*intrep.Instruction, error)
func PABSB(mx, x operand.Op) (*intrep.Instruction, error)
func PABSD(mx, x operand.Op) (*intrep.Instruction, error)
func PABSW(mx, x operand.Op) (*intrep.Instruction, error)
func PACKSSLW(mx, x operand.Op) (*intrep.Instruction, error)
func PACKSSWB(mx, x operand.Op) (*intrep.Instruction, error)
func PACKUSDW(mx, x operand.Op) (*intrep.Instruction, error)
func PACKUSWB(mx, x operand.Op) (*intrep.Instruction, error)
func PADDB(mx, x operand.Op) (*intrep.Instruction, error)
func PADDD(mx, x operand.Op) (*intrep.Instruction, error)
func PADDL(mx, x operand.Op) (*intrep.Instruction, error)
func PADDQ(mx, x operand.Op) (*intrep.Instruction, error)
func PADDSB(mx, x operand.Op) (*intrep.Instruction, error)
func PADDSW(mx, x operand.Op) (*intrep.Instruction, error)
func PADDUSB(mx, x operand.Op) (*intrep.Instruction, error)
func PADDUSW(mx, x operand.Op) (*intrep.Instruction, error)
func PADDW(mx, x operand.Op) (*intrep.Instruction, error)
func PALIGNR(i, mx, x operand.Op) (*intrep.Instruction, error)
func PAND(mx, x operand.Op) (*intrep.Instruction, error)
func PANDN(mx, x operand.Op) (*intrep.Instruction, error)
func PAUSE() (*intrep.Instruction, error)
func PAVGB(mx, x operand.Op) (*intrep.Instruction, error)
func PAVGW(mx, x operand.Op) (*intrep.Instruction, error)
func PBLENDVB(x, mx, x1 operand.Op) (*intrep.Instruction, error)
func PBLENDW(i, mx, x operand.Op) (*intrep.Instruction, error)
func PCLMULQDQ(i, mx, x operand.Op) (*intrep.Instruction, error)
func PCMPEQB(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPEQL(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPEQQ(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPEQW(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPESTRI(i, mx, x operand.Op) (*intrep.Instruction, error)
func PCMPESTRM(i, mx, x operand.Op) (*intrep.Instruction, error)
func PCMPGTB(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPGTL(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPGTQ(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPGTW(mx, x operand.Op) (*intrep.Instruction, error)
func PCMPISTRI(i, mx, x operand.Op) (*intrep.Instruction, error)
func PCMPISTRM(i, mx, x operand.Op) (*intrep.Instruction, error)
func PDEPL(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func PDEPQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func PEXTL(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func PEXTQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)
func PEXTRB(i, x, mr operand.Op) (*intrep.Instruction, error)
func PEXTRD(i, x, mr operand.Op) (*intrep.Instruction, error)
func PEXTRQ(i, x, mr operand.Op) (*intrep.Instruction, error)
func PEXTRW(i, x, mr operand.Op) (*intrep.Instruction, error)
func PHADDD(mx, x operand.Op) (*intrep.Instruction, error)
func PHADDSW(mx, x operand.Op) (*intrep.Instruction, error)
func PHADDW(mx, x operand.Op) (*intrep.Instruction, error)
func PHMINPOSUW(mx, x operand.Op) (*intrep.Instruction, error)
func PHSUBD(mx, x operand.Op) (*intrep.Instruction, error)
func PHSUBSW(mx, x operand.Op) (*intrep.Instruction, error)
func PHSUBW(mx, x operand.Op) (*intrep.Instruction, error)
func PINSRB(i, mr, x operand.Op) (*intrep.Instruction, error)
func PINSRD(i, mr, x operand.Op) (*intrep.Instruction, error)
func PINSRQ(i, mr, x operand.Op) (*intrep.Instruction, error)
func PINSRW(i, mr, x operand.Op) (*intrep.Instruction, error)
func PMADDUBSW(mx, x operand.Op) (*intrep.Instruction, error)
func PMADDWL(mx, x operand.Op) (*intrep.Instruction, error)
func PMAXSB(mx, x operand.Op) (*intrep.Instruction, error)
func PMAXSD(mx, x operand.Op) (*intrep.Instruction, error)
func PMAXSW(mx, x operand.Op) (*intrep.Instruction, error)
func PMAXUB(mx, x operand.Op) (*intrep.Instruction, error)
func PMAXUD(mx, x operand.Op) (*intrep.Instruction, error)
func PMAXUW(mx, x operand.Op) (*intrep.Instruction, error)
func PMINSB(mx, x operand.Op) (*intrep.Instruction, error)
func PMINSD(mx, x operand.Op) (*intrep.Instruction, error)
func PMINSW(mx, x operand.Op) (*intrep.Instruction, error)
func PMINUB(mx, x operand.Op) (*intrep.Instruction, error)
func PMINUD(mx, x operand.Op) (*intrep.Instruction, error)
func PMINUW(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVMSKB(x, r operand.Op) (*intrep.Instruction, error)
func PMOVSXBD(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVSXBQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVSXBW(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVSXDQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVSXWD(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVSXWQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVZXBD(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVZXBQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVZXBW(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVZXDQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVZXWD(mx, x operand.Op) (*intrep.Instruction, error)
func PMOVZXWQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMULDQ(mx, x operand.Op) (*intrep.Instruction, error)
func PMULHRSW(mx, x operand.Op) (*intrep.Instruction, error)
func PMULHUW(mx, x operand.Op) (*intrep.Instruction, error)
func PMULHW(mx, x operand.Op) (*intrep.Instruction, error)
func PMULLD(mx, x operand.Op) (*intrep.Instruction, error)
func PMULLW(mx, x operand.Op) (*intrep.Instruction, error)
func PMULULQ(mx, x operand.Op) (*intrep.Instruction, error)
func POPCNTL(mr, r operand.Op) (*intrep.Instruction, error)
func POPCNTQ(mr, r operand.Op) (*intrep.Instruction, error)
func POPCNTW(mr, r operand.Op) (*intrep.Instruction, error)
func POPQ(mr operand.Op) (*intrep.Instruction, error)
func POPW(mr operand.Op) (*intrep.Instruction, error)
func POR(mx, x operand.Op) (*intrep.Instruction, error)
func PREFETCHNTA(m operand.Op) (*intrep.Instruction, error)
func PREFETCHT0(m operand.Op) (*intrep.Instruction, error)
func PREFETCHT1(m operand.Op) (*intrep.Instruction, error)
func PREFETCHT2(m operand.Op) (*intrep.Instruction, error)
func PSADBW(mx, x operand.Op) (*intrep.Instruction, error)
func PSHUFB(mx, x operand.Op) (*intrep.Instruction, error)
func PSHUFD(i, mx, x operand.Op) (*intrep.Instruction, error)
func PSHUFHW(i, mx, x operand.Op) (*intrep.Instruction, error)
func PSHUFL(i, mx, x operand.Op) (*intrep.Instruction, error)
func PSHUFLW(i, mx, x operand.Op) (*intrep.Instruction, error)
func PSIGNB(mx, x operand.Op) (*intrep.Instruction, error)
func PSIGND(mx, x operand.Op) (*intrep.Instruction, error)
func PSIGNW(mx, x operand.Op) (*intrep.Instruction, error)
func PSLLDQ(i, x operand.Op) (*intrep.Instruction, error)
func PSLLL(imx, x operand.Op) (*intrep.Instruction, error)
func PSLLO(i, x operand.Op) (*intrep.Instruction, error)
func PSLLQ(imx, x operand.Op) (*intrep.Instruction, error)
func PSLLW(imx, x operand.Op) (*intrep.Instruction, error)
func PSRAL(imx, x operand.Op) (*intrep.Instruction, error)
func PSRAW(imx, x operand.Op) (*intrep.Instruction, error)
func PSRLDQ(i, x operand.Op) (*intrep.Instruction, error)
func PSRLL(imx, x operand.Op) (*intrep.Instruction, error)
func PSRLO(i, x operand.Op) (*intrep.Instruction, error)
func PSRLQ(imx, x operand.Op) (*intrep.Instruction, error)
func PSRLW(imx, x operand.Op) (*intrep.Instruction, error)
func PSUBB(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBL(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBQ(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBSB(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBSW(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBUSB(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBUSW(mx, x operand.Op) (*intrep.Instruction, error)
func PSUBW(mx, x operand.Op) (*intrep.Instruction, error)
func PTEST(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKHBW(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKHLQ(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKHQDQ(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKHWL(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKLBW(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKLLQ(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKLQDQ(mx, x operand.Op) (*intrep.Instruction, error)
func PUNPCKLWL(mx, x operand.Op) (*intrep.Instruction, error)
func PUSHQ(imr operand.Op) (*intrep.Instruction, error)
func PUSHW(mr operand.Op) (*intrep.Instruction, error)
func PXOR(mx, x operand.Op) (*intrep.Instruction, error)
func RCLB(ci, mr operand.Op) (*intrep.Instruction, error)
func RCLL(ci, mr operand.Op) (*intrep.Instruction, error)
func RCLQ(ci, mr operand.Op) (*intrep.Instruction, error)
func RCLW(ci, mr operand.Op) (*intrep.Instruction, error)
func RCPPS(mx, x operand.Op) (*intrep.Instruction, error)
func RCPSS(mx, x operand.Op) (*intrep.Instruction, error)
func RCRB(ci, mr operand.Op) (*intrep.Instruction, error)
func RCRL(ci, mr operand.Op) (*intrep.Instruction, error)
func RCRQ(ci, mr operand.Op) (*intrep.Instruction, error)
func RCRW(ci, mr operand.Op) (*intrep.Instruction, error)
func RDRANDL(r operand.Op) (*intrep.Instruction, error)
func RDRANDQ(r operand.Op) (*intrep.Instruction, error)
func RDRANDW(r operand.Op) (*intrep.Instruction, error)
func RDSEEDL(r operand.Op) (*intrep.Instruction, error)
func RDSEEDQ(r operand.Op) (*intrep.Instruction, error)
func RDSEEDW(r operand.Op) (*intrep.Instruction, error)
func RDTSC() (*intrep.Instruction, error)
func RDTSCP() (*intrep.Instruction, error)
func RET() (*intrep.Instruction, error)
func RETFL(i operand.Op) (*intrep.Instruction, error)
func RETFQ(i operand.Op) (*intrep.Instruction, error)
func RETFW(i operand.Op) (*intrep.Instruction, error)
func ROLB(ci, mr operand.Op) (*intrep.Instruction, error)
func ROLL(ci, mr operand.Op) (*intrep.Instruction, error)
func ROLQ(ci, mr operand.Op) (*intrep.Instruction, error)
func ROLW(ci, mr operand.Op) (*intrep.Instruction, error)
func RORB(ci, mr operand.Op) (*intrep.Instruction, error)
func RORL(ci, mr operand.Op) (*intrep.Instruction, error)
func RORQ(ci, mr operand.Op) (*intrep.Instruction, error)
func RORW(ci, mr operand.Op) (*intrep.Instruction, error)
func RORXL(i, mr, r operand.Op) (*intrep.Instruction, error)
func RORXQ(i, mr, r operand.Op) (*intrep.Instruction, error)
func ROUNDPD(i, mx, x operand.Op) (*intrep.Instruction, error)
func ROUNDPS(i, mx, x operand.Op) (*intrep.Instruction, error)
func ROUNDSD(i, mx, x operand.Op) (*intrep.Instruction, error)
func ROUNDSS(i, mx, x operand.Op) (*intrep.Instruction, error)
func RSQRTPS(mx, x operand.Op) (*intrep.Instruction, error)
func RSQRTSS(mx, x operand.Op) (*intrep.Instruction, error)
func SALB(ci, mr operand.Op) (*intrep.Instruction, error)
func SALL(ci, mr operand.Op) (*intrep.Instruction, error)
func SALQ(ci, mr operand.Op) (*intrep.Instruction, error)
func SALW(ci, mr operand.Op) (*intrep.Instruction, error)
func SARB(ci, mr operand.Op) (*intrep.Instruction, error)
func SARL(ci, mr operand.Op) (*intrep.Instruction, error)
func SARQ(ci, mr operand.Op) (*intrep.Instruction, error)
func SARW(ci, mr operand.Op) (*intrep.Instruction, error)
func SARXL(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func SARXQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func SBBB(imr, amr operand.Op) (*intrep.Instruction, error)
func SBBL(imr, emr operand.Op) (*intrep.Instruction, error)
func SBBQ(imr, mr operand.Op) (*intrep.Instruction, error)
func SBBW(imr, amr operand.Op) (*intrep.Instruction, error)
func SETCC(mr operand.Op) (*intrep.Instruction, error)
func SETCS(mr operand.Op) (*intrep.Instruction, error)
func SETEQ(mr operand.Op) (*intrep.Instruction, error)
func SETGE(mr operand.Op) (*intrep.Instruction, error)
func SETGT(mr operand.Op) (*intrep.Instruction, error)
func SETHI(mr operand.Op) (*intrep.Instruction, error)
func SETLE(mr operand.Op) (*intrep.Instruction, error)
func SETLS(mr operand.Op) (*intrep.Instruction, error)
func SETLT(mr operand.Op) (*intrep.Instruction, error)
func SETMI(mr operand.Op) (*intrep.Instruction, error)
func SETNE(mr operand.Op) (*intrep.Instruction, error)
func SETOC(mr operand.Op) (*intrep.Instruction, error)
func SETOS(mr operand.Op) (*intrep.Instruction, error)
func SETPC(mr operand.Op) (*intrep.Instruction, error)
func SETPL(mr operand.Op) (*intrep.Instruction, error)
func SETPS(mr operand.Op) (*intrep.Instruction, error)
func SFENCE() (*intrep.Instruction, error)
func SHA1MSG1(mx, x operand.Op) (*intrep.Instruction, error)
func SHA1MSG2(mx, x operand.Op) (*intrep.Instruction, error)
func SHA1NEXTE(mx, x operand.Op) (*intrep.Instruction, error)
func SHA1RNDS4(i, mx, x operand.Op) (*intrep.Instruction, error)
func SHA256MSG1(mx, x operand.Op) (*intrep.Instruction, error)
func SHA256MSG2(mx, x operand.Op) (*intrep.Instruction, error)
func SHA256RNDS2(x, mx, x1 operand.Op) (*intrep.Instruction, error)
func SHLB(ci, mr operand.Op) (*intrep.Instruction, error)
func SHLL(ops ...operand.Op) (*intrep.Instruction, error)
func SHLQ(ops ...operand.Op) (*intrep.Instruction, error)
func SHLW(ops ...operand.Op) (*intrep.Instruction, error)
func SHLXL(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func SHLXQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func SHRB(ci, mr operand.Op) (*intrep.Instruction, error)
func SHRL(ops ...operand.Op) (*intrep.Instruction, error)
func SHRQ(ops ...operand.Op) (*intrep.Instruction, error)
func SHRW(ops ...operand.Op) (*intrep.Instruction, error)
func SHRXL(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func SHRXQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)
func SHUFPD(i, mx, x operand.Op) (*intrep.Instruction, error)
func SHUFPS(i, mx, x operand.Op) (*intrep.Instruction, error)
func SQRTPD(mx, x operand.Op) (*intrep.Instruction, error)
func SQRTPS(mx, x operand.Op) (*intrep.Instruction, error)
func SQRTSD(mx, x operand.Op) (*intrep.Instruction, error)
func SQRTSS(mx, x operand.Op) (*intrep.Instruction, error)
func STC() (*intrep.Instruction, error)
func STD() (*intrep.Instruction, error)
func STMXCSR(m operand.Op) (*intrep.Instruction, error)
func SUBB(imr, amr operand.Op) (*intrep.Instruction, error)
func SUBL(imr, emr operand.Op) (*intrep.Instruction, error)
func SUBPD(mx, x operand.Op) (*intrep.Instruction, error)
func SUBPS(mx, x operand.Op) (*intrep.Instruction, error)
func SUBQ(imr, mr operand.Op) (*intrep.Instruction, error)
func SUBSD(mx, x operand.Op) (*intrep.Instruction, error)
func SUBSS(mx, x operand.Op) (*intrep.Instruction, error)
func SUBW(imr, amr operand.Op) (*intrep.Instruction, error)
func SYSCALL() (*intrep.Instruction, error)
func TESTB(ir, amr operand.Op) (*intrep.Instruction, error)
func TESTL(ir, emr operand.Op) (*intrep.Instruction, error)
func TESTQ(ir, mr operand.Op) (*intrep.Instruction, error)
func TESTW(ir, amr operand.Op) (*intrep.Instruction, error)
func TZCNTL(mr, r operand.Op) (*intrep.Instruction, error)
func TZCNTQ(mr, r operand.Op) (*intrep.Instruction, error)
func TZCNTW(mr, r operand.Op) (*intrep.Instruction, error)
func UCOMISD(mx, x operand.Op) (*intrep.Instruction, error)
func UCOMISS(mx, x operand.Op) (*intrep.Instruction, error)
func UD2() (*intrep.Instruction, error)
func UNPCKHPD(mx, x operand.Op) (*intrep.Instruction, error)
func UNPCKHPS(mx, x operand.Op) (*intrep.Instruction, error)
func UNPCKLPD(mx, x operand.Op) (*intrep.Instruction, error)
func UNPCKLPS(mx, x operand.Op) (*intrep.Instruction, error)
func VADDPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VADDPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VADDSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VADDSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VADDSUBPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VADDSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VAESDEC(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VAESDECLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VAESENC(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VAESENCLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VAESIMC(mx, x operand.Op) (*intrep.Instruction, error)
func VAESKEYGENASSIST(i, mx, x operand.Op) (*intrep.Instruction, error)
func VANDNPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VANDNPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VANDPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VANDPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VBLENDPD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VBLENDPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VBLENDVPD(xy, mxy, xy1, xy2 operand.Op) (*intrep.Instruction, error)
func VBLENDVPS(xy, mxy, xy1, xy2 operand.Op) (*intrep.Instruction, error)
func VBROADCASTF128(m, y operand.Op) (*intrep.Instruction, error)
func VBROADCASTI128(m, y operand.Op) (*intrep.Instruction, error)
func VBROADCASTSD(mx, y operand.Op) (*intrep.Instruction, error)
func VBROADCASTSS(mx, xy operand.Op) (*intrep.Instruction, error)
func VCMPPD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VCMPPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VCMPSD(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VCMPSS(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VCOMISD(mx, x operand.Op) (*intrep.Instruction, error)
func VCOMISS(mx, x operand.Op) (*intrep.Instruction, error)
func VCVTDQ2PD(mx, xy operand.Op) (*intrep.Instruction, error)
func VCVTDQ2PS(mxy, xy operand.Op) (*intrep.Instruction, error)
func VCVTPD2DQX(mx, x operand.Op) (*intrep.Instruction, error)
func VCVTPD2DQY(my, x operand.Op) (*intrep.Instruction, error)
func VCVTPD2PSX(mx, x operand.Op) (*intrep.Instruction, error)
func VCVTPD2PSY(my, x operand.Op) (*intrep.Instruction, error)
func VCVTPH2PS(mx, xy operand.Op) (*intrep.Instruction, error)
func VCVTPS2DQ(mxy, xy operand.Op) (*intrep.Instruction, error)
func VCVTPS2PD(mx, xy operand.Op) (*intrep.Instruction, error)
func VCVTPS2PH(i, xy, mx operand.Op) (*intrep.Instruction, error)
func VCVTSD2SI(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTSD2SIQ(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTSD2SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VCVTSI2SDL(mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VCVTSI2SDQ(mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VCVTSI2SSL(mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VCVTSI2SSQ(mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VCVTSS2SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VCVTSS2SI(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTSS2SIQ(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTTPD2DQX(mx, x operand.Op) (*intrep.Instruction, error)
func VCVTTPD2DQY(my, x operand.Op) (*intrep.Instruction, error)
func VCVTTPS2DQ(mxy, xy operand.Op) (*intrep.Instruction, error)
func VCVTTSD2SI(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTTSD2SIQ(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTTSS2SI(mx, r operand.Op) (*intrep.Instruction, error)
func VCVTTSS2SIQ(mx, r operand.Op) (*intrep.Instruction, error)
func VDIVPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VDIVPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VDIVSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VDIVSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VDPPD(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VDPPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VEXTRACTF128(i, y, mx operand.Op) (*intrep.Instruction, error)
func VEXTRACTI128(i, y, mx operand.Op) (*intrep.Instruction, error)
func VEXTRACTPS(i, x, mr operand.Op) (*intrep.Instruction, error)
func VFMADD132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADD132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADD132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMADD132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMADD213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADD213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADD213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMADD213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMADD231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADD231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADD231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMADD231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMADDSUB132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADDSUB132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADDSUB213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADDSUB213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADDSUB231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMADDSUB231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMSUB132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMSUB213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMSUB213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMSUB231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUB231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMSUB231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFMSUBADD132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUBADD132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUBADD213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUBADD213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUBADD231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFMSUBADD231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMADD132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMADD213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMADD213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMADD231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMADD231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMADD231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VFNMSUB231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VGATHERDPD(xy, v, xy1 operand.Op) (*intrep.Instruction, error)
func VGATHERDPS(xy, v, xy1 operand.Op) (*intrep.Instruction, error)
func VGATHERQPD(xy, v, xy1 operand.Op) (*intrep.Instruction, error)
func VGATHERQPS(x, v, x1 operand.Op) (*intrep.Instruction, error)
func VHADDPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VHADDPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VHSUBPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VHSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VINSERTF128(i, mx, y, y1 operand.Op) (*intrep.Instruction, error)
func VINSERTI128(i, mx, y, y1 operand.Op) (*intrep.Instruction, error)
func VINSERTPS(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VLDDQU(m, xy operand.Op) (*intrep.Instruction, error)
func VLDMXCSR(m operand.Op) (*intrep.Instruction, error)
func VMASKMOVDQU(x, x1 operand.Op) (*intrep.Instruction, error)
func VMASKMOVPD(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMASKMOVPS(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMAXPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMAXPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMAXSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VMAXSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VMINPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMINPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMINSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VMINSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VMOVAPD(mxy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMOVAPS(mxy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMOVD(mrx, mrx1 operand.Op) (*intrep.Instruction, error)
func VMOVDDUP(mxy, xy operand.Op) (*intrep.Instruction, error)
func VMOVDQA(mxy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMOVDQU(mxy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMOVHLPS(x, x1, x2 operand.Op) (*intrep.Instruction, error)
func VMOVHPD(ops ...operand.Op) (*intrep.Instruction, error)
func VMOVHPS(ops ...operand.Op) (*intrep.Instruction, error)
func VMOVLHPS(x, x1, x2 operand.Op) (*intrep.Instruction, error)
func VMOVLPD(ops ...operand.Op) (*intrep.Instruction, error)
func VMOVLPS(ops ...operand.Op) (*intrep.Instruction, error)
func VMOVMSKPD(xy, r operand.Op) (*intrep.Instruction, error)
func VMOVMSKPS(xy, r operand.Op) (*intrep.Instruction, error)
func VMOVNTDQ(xy, m operand.Op) (*intrep.Instruction, error)
func VMOVNTDQA(m, xy operand.Op) (*intrep.Instruction, error)
func VMOVNTPD(xy, m operand.Op) (*intrep.Instruction, error)
func VMOVNTPS(xy, m operand.Op) (*intrep.Instruction, error)
func VMOVQ(mrx, mrx1 operand.Op) (*intrep.Instruction, error)
func VMOVSD(ops ...operand.Op) (*intrep.Instruction, error)
func VMOVSHDUP(mxy, xy operand.Op) (*intrep.Instruction, error)
func VMOVSLDUP(mxy, xy operand.Op) (*intrep.Instruction, error)
func VMOVSS(ops ...operand.Op) (*intrep.Instruction, error)
func VMOVUPD(mxy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMOVUPS(mxy, mxy1 operand.Op) (*intrep.Instruction, error)
func VMPSADBW(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMULPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMULPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VMULSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VMULSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VORPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VORPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPABSB(mxy, xy operand.Op) (*intrep.Instruction, error)
func VPABSD(mxy, xy operand.Op) (*intrep.Instruction, error)
func VPABSW(mxy, xy operand.Op) (*intrep.Instruction, error)
func VPACKSSDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPACKSSWB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPACKUSDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPACKUSWB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDUSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDUSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPADDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPALIGNR(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPAND(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPANDN(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPAVGB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPAVGW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPBLENDD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPBLENDVB(xy, mxy, xy1, xy2 operand.Op) (*intrep.Instruction, error)
func VPBLENDW(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPBROADCASTB(mx, xy operand.Op) (*intrep.Instruction, error)
func VPBROADCASTD(mx, xy operand.Op) (*intrep.Instruction, error)
func VPBROADCASTQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPBROADCASTW(mx, xy operand.Op) (*intrep.Instruction, error)
func VPCLMULQDQ(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VPCMPEQB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPEQD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPEQQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPEQW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPESTRI(i, mx, x operand.Op) (*intrep.Instruction, error)
func VPCMPESTRM(i, mx, x operand.Op) (*intrep.Instruction, error)
func VPCMPGTB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPGTD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPGTQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPGTW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPCMPISTRI(i, mx, x operand.Op) (*intrep.Instruction, error)
func VPCMPISTRM(i, mx, x operand.Op) (*intrep.Instruction, error)
func VPERM2F128(i, my, y, y1 operand.Op) (*intrep.Instruction, error)
func VPERM2I128(i, my, y, y1 operand.Op) (*intrep.Instruction, error)
func VPERMD(my, y, y1 operand.Op) (*intrep.Instruction, error)
func VPERMILPD(imxy, mxy, xy operand.Op) (*intrep.Instruction, error)
func VPERMILPS(imxy, mxy, xy operand.Op) (*intrep.Instruction, error)
func VPERMPD(i, my, y operand.Op) (*intrep.Instruction, error)
func VPERMPS(my, y, y1 operand.Op) (*intrep.Instruction, error)
func VPERMQ(i, my, y operand.Op) (*intrep.Instruction, error)
func VPEXTRB(i, x, mr operand.Op) (*intrep.Instruction, error)
func VPEXTRD(i, x, mr operand.Op) (*intrep.Instruction, error)
func VPEXTRQ(i, x, mr operand.Op) (*intrep.Instruction, error)
func VPEXTRW(i, x, mr operand.Op) (*intrep.Instruction, error)
func VPGATHERDD(xy, v, xy1 operand.Op) (*intrep.Instruction, error)
func VPGATHERDQ(xy, v, xy1 operand.Op) (*intrep.Instruction, error)
func VPGATHERQD(x, v, x1 operand.Op) (*intrep.Instruction, error)
func VPGATHERQQ(xy, v, xy1 operand.Op) (*intrep.Instruction, error)
func VPHADDD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPHADDSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPHADDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPHMINPOSUW(mx, x operand.Op) (*intrep.Instruction, error)
func VPHSUBD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPHSUBSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPHSUBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPINSRB(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VPINSRD(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VPINSRQ(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VPINSRW(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)
func VPMADDUBSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMADDWD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMASKMOVD(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)
func VPMASKMOVQ(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)
func VPMAXSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMAXSD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMAXSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMAXUB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMAXUD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMAXUW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMINSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMINSD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMINSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMINUB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMINUD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMINUW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMOVMSKB(xy, r operand.Op) (*intrep.Instruction, error)
func VPMOVSXBD(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVSXBQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVSXBW(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVSXDQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVSXWD(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVSXWQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVZXBD(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVZXBQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVZXBW(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVZXDQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVZXWD(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMOVZXWQ(mx, xy operand.Op) (*intrep.Instruction, error)
func VPMULDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMULHRSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMULHUW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMULHW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMULLD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMULLW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPMULUDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPOR(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSADBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSHUFB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSHUFD(i, mxy, xy operand.Op) (*intrep.Instruction, error)
func VPSHUFHW(i, mxy, xy operand.Op) (*intrep.Instruction, error)
func VPSHUFLW(i, mxy, xy operand.Op) (*intrep.Instruction, error)
func VPSIGNB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSIGND(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSIGNW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSLLD(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSLLDQ(i, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSLLQ(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSLLVD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSLLVQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSLLW(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRAD(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRAVD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRAW(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRLD(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRLDQ(i, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRLQ(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRLVD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRLVQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSRLW(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBUSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBUSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPSUBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPTEST(mxy, xy operand.Op) (*intrep.Instruction, error)
func VPUNPCKHBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKHDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKHQDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKHWD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKLBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKLDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKLQDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPUNPCKLWD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VPXOR(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VRCPPS(mxy, xy operand.Op) (*intrep.Instruction, error)
func VRCPSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VROUNDPD(i, mxy, xy operand.Op) (*intrep.Instruction, error)
func VROUNDPS(i, mxy, xy operand.Op) (*intrep.Instruction, error)
func VROUNDSD(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VROUNDSS(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VRSQRTPS(mxy, xy operand.Op) (*intrep.Instruction, error)
func VRSQRTSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VSHUFPD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VSHUFPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VSQRTPD(mxy, xy operand.Op) (*intrep.Instruction, error)
func VSQRTPS(mxy, xy operand.Op) (*intrep.Instruction, error)
func VSQRTSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VSQRTSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VSTMXCSR(m operand.Op) (*intrep.Instruction, error)
func VSUBPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VSUBSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VSUBSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)
func VTESTPD(mxy, xy operand.Op) (*intrep.Instruction, error)
func VTESTPS(mxy, xy operand.Op) (*intrep.Instruction, error)
func VUCOMISD(mx, x operand.Op) (*intrep.Instruction, error)
func VUCOMISS(mx, x operand.Op) (*intrep.Instruction, error)
func VUNPCKHPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VUNPCKHPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VUNPCKLPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VUNPCKLPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VXORPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VXORPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)
func VZEROALL() (*intrep.Instruction, error)
func VZEROUPPER() (*intrep.Instruction, error)
func XADDB(r, mr operand.Op) (*intrep.Instruction, error)
func XADDL(r, mr operand.Op) (*intrep.Instruction, error)
func XADDQ(r, mr operand.Op) (*intrep.Instruction, error)
func XADDW(r, mr operand.Op) (*intrep.Instruction, error)
func XCHGB(mr, mr1 operand.Op) (*intrep.Instruction, error)
func XCHGL(emr, emr1 operand.Op) (*intrep.Instruction, error)
func XCHGQ(mr, mr1 operand.Op) (*intrep.Instruction, error)
func XCHGW(amr, amr1 operand.Op) (*intrep.Instruction, error)
func XGETBV() (*intrep.Instruction, error)
func XLAT() (*intrep.Instruction, error)
func XORB(imr, amr operand.Op) (*intrep.Instruction, error)
func XORL(imr, emr operand.Op) (*intrep.Instruction, error)
func XORPD(mx, x operand.Op) (*intrep.Instruction, error)
func XORPS(mx, x operand.Op) (*intrep.Instruction, error)
func XORQ(imr, mr operand.Op) (*intrep.Instruction, error)
func XORW(imr, amr operand.Op) (*intrep.Instruction, error)

Functions ¶

func ADCB ¶

func ADCB(imr, amr operand.Op) (*intrep.Instruction, error)

ADCB: Add with Carry.

Forms:

ADCB imm8 al
ADCB imm8 r8
ADCB r8   r8
ADCB m8   r8
ADCB imm8 m8
ADCB r8   m8

func ADCL ¶

func ADCL(imr, emr operand.Op) (*intrep.Instruction, error)

ADCL: Add with Carry.

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 ADCQ ¶

func ADCQ(imr, mr operand.Op) (*intrep.Instruction, error)

ADCQ: Add with Carry.

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 ADCW ¶

func ADCW(imr, amr operand.Op) (*intrep.Instruction, error)

ADCW: Add with Carry.

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 ADCXL ¶

func ADCXL(mr, r operand.Op) (*intrep.Instruction, error)

ADCXL: Unsigned Integer Addition of Two Operands with Carry Flag.

Forms:

ADCXL r32 r32
ADCXL m32 r32

func ADCXQ ¶

func ADCXQ(mr, r operand.Op) (*intrep.Instruction, error)

ADCXQ: Unsigned Integer Addition of Two Operands with Carry Flag.

Forms:

ADCXQ r64 r64
ADCXQ m64 r64

func ADDB ¶

func ADDB(imr, amr operand.Op) (*intrep.Instruction, error)

ADDB: Add.

Forms:

ADDB imm8 al
ADDB imm8 r8
ADDB r8   r8
ADDB m8   r8
ADDB imm8 m8
ADDB r8   m8

func ADDL ¶

func ADDL(imr, emr operand.Op) (*intrep.Instruction, error)

ADDL: Add.

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 ADDPD ¶

func ADDPD(mx, x operand.Op) (*intrep.Instruction, error)

ADDPD: Add Packed Double-Precision Floating-Point Values.

Forms:

ADDPD xmm  xmm
ADDPD m128 xmm

func ADDPS ¶

func ADDPS(mx, x operand.Op) (*intrep.Instruction, error)

ADDPS: Add Packed Single-Precision Floating-Point Values.

Forms:

ADDPS xmm  xmm
ADDPS m128 xmm

func ADDQ ¶

func ADDQ(imr, mr operand.Op) (*intrep.Instruction, error)

ADDQ: Add.

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 ADDSD ¶

func ADDSD(mx, x operand.Op) (*intrep.Instruction, error)

ADDSD: Add Scalar Double-Precision Floating-Point Values.

Forms:

ADDSD xmm xmm
ADDSD m64 xmm

func ADDSS ¶

func ADDSS(mx, x operand.Op) (*intrep.Instruction, error)

ADDSS: Add Scalar Single-Precision Floating-Point Values.

Forms:

ADDSS xmm xmm
ADDSS m32 xmm

func ADDSUBPD ¶

func ADDSUBPD(mx, x operand.Op) (*intrep.Instruction, error)

ADDSUBPD: Packed Double-FP Add/Subtract.

Forms:

ADDSUBPD xmm  xmm
ADDSUBPD m128 xmm

func ADDSUBPS ¶

func ADDSUBPS(mx, x operand.Op) (*intrep.Instruction, error)

ADDSUBPS: Packed Single-FP Add/Subtract.

Forms:

ADDSUBPS xmm  xmm
ADDSUBPS m128 xmm

func ADDW ¶

func ADDW(imr, amr operand.Op) (*intrep.Instruction, error)

ADDW: Add.

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 ADOXL ¶

func ADOXL(mr, r operand.Op) (*intrep.Instruction, error)

ADOXL: Unsigned Integer Addition of Two Operands with Overflow Flag.

Forms:

ADOXL r32 r32
ADOXL m32 r32

func ADOXQ ¶

func ADOXQ(mr, r operand.Op) (*intrep.Instruction, error)

ADOXQ: Unsigned Integer Addition of Two Operands with Overflow Flag.

Forms:

ADOXQ r64 r64
ADOXQ m64 r64

func AESDEC ¶

func AESDEC(mx, x operand.Op) (*intrep.Instruction, error)

AESDEC: Perform One Round of an AES Decryption Flow.

Forms:

AESDEC xmm  xmm
AESDEC m128 xmm

func AESDECLAST ¶

func AESDECLAST(mx, x operand.Op) (*intrep.Instruction, error)

AESDECLAST: Perform Last Round of an AES Decryption Flow.

Forms:

AESDECLAST xmm  xmm
AESDECLAST m128 xmm

func AESENC ¶

func AESENC(mx, x operand.Op) (*intrep.Instruction, error)

AESENC: Perform One Round of an AES Encryption Flow.

Forms:

AESENC xmm  xmm
AESENC m128 xmm

func AESENCLAST ¶

func AESENCLAST(mx, x operand.Op) (*intrep.Instruction, error)

AESENCLAST: Perform Last Round of an AES Encryption Flow.

Forms:

AESENCLAST xmm  xmm
AESENCLAST m128 xmm

func AESIMC ¶

func AESIMC(mx, x operand.Op) (*intrep.Instruction, error)

AESIMC: Perform the AES InvMixColumn Transformation.

Forms:

AESIMC xmm  xmm
AESIMC m128 xmm

func AESKEYGENASSIST ¶

func AESKEYGENASSIST(i, mx, x operand.Op) (*intrep.Instruction, error)

AESKEYGENASSIST: AES Round Key Generation Assist.

Forms:

AESKEYGENASSIST imm8 xmm  xmm
AESKEYGENASSIST imm8 m128 xmm

func ANDB ¶

func ANDB(imr, amr operand.Op) (*intrep.Instruction, error)

ANDB: Logical AND.

Forms:

ANDB imm8 al
ANDB imm8 r8
ANDB r8   r8
ANDB m8   r8
ANDB imm8 m8
ANDB r8   m8

func ANDL ¶

func ANDL(imr, emr operand.Op) (*intrep.Instruction, error)

ANDL: Logical AND.

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 ANDNL ¶

func ANDNL(mr, r, r1 operand.Op) (*intrep.Instruction, error)

ANDNL: Logical AND NOT.

Forms:

ANDNL r32 r32 r32
ANDNL m32 r32 r32

func ANDNPD ¶

func ANDNPD(mx, x operand.Op) (*intrep.Instruction, error)

ANDNPD: Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values.

Forms:

ANDNPD xmm  xmm
ANDNPD m128 xmm

func ANDNPS ¶

func ANDNPS(mx, x operand.Op) (*intrep.Instruction, error)

ANDNPS: Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values.

Forms:

ANDNPS xmm  xmm
ANDNPS m128 xmm

func ANDNQ ¶

func ANDNQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)

ANDNQ: Logical AND NOT.

Forms:

ANDNQ r64 r64 r64
ANDNQ m64 r64 r64

func ANDPD ¶

func ANDPD(mx, x operand.Op) (*intrep.Instruction, error)

ANDPD: Bitwise Logical AND of Packed Double-Precision Floating-Point Values.

Forms:

ANDPD xmm  xmm
ANDPD m128 xmm

func ANDPS ¶

func ANDPS(mx, x operand.Op) (*intrep.Instruction, error)

ANDPS: Bitwise Logical AND of Packed Single-Precision Floating-Point Values.

Forms:

ANDPS xmm  xmm
ANDPS m128 xmm

func ANDQ ¶

func ANDQ(imr, mr operand.Op) (*intrep.Instruction, error)

ANDQ: Logical AND.

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 ANDW ¶

func ANDW(imr, amr operand.Op) (*intrep.Instruction, error)

ANDW: Logical AND.

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 BEXTRL ¶

func BEXTRL(r, mr, r1 operand.Op) (*intrep.Instruction, error)

BEXTRL: Bit Field Extract.

Forms:

BEXTRL r32 r32 r32
BEXTRL r32 m32 r32

func BEXTRQ ¶

func BEXTRQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)

BEXTRQ: Bit Field Extract.

Forms:

BEXTRQ r64 r64 r64
BEXTRQ r64 m64 r64

func BLENDPD ¶

func BLENDPD(i, mx, x operand.Op) (*intrep.Instruction, error)

BLENDPD: Blend Packed Double Precision Floating-Point Values.

Forms:

BLENDPD imm8 xmm  xmm
BLENDPD imm8 m128 xmm

func BLENDPS ¶

func BLENDPS(i, mx, x operand.Op) (*intrep.Instruction, error)

BLENDPS: Blend Packed Single Precision Floating-Point Values.

Forms:

BLENDPS imm8 xmm  xmm
BLENDPS imm8 m128 xmm

func BLENDVPD ¶

func BLENDVPD(x, mx, x1 operand.Op) (*intrep.Instruction, error)

BLENDVPD: Variable Blend Packed Double Precision Floating-Point Values.

Forms:

BLENDVPD xmm0 xmm  xmm
BLENDVPD xmm0 m128 xmm

func BLENDVPS ¶

func BLENDVPS(x, mx, x1 operand.Op) (*intrep.Instruction, error)

BLENDVPS: Variable Blend Packed Single Precision Floating-Point Values.

Forms:

BLENDVPS xmm0 xmm  xmm
BLENDVPS xmm0 m128 xmm

func BLSIL ¶

func BLSIL(mr, r operand.Op) (*intrep.Instruction, error)

BLSIL: Isolate Lowest Set Bit.

Forms:

BLSIL r32 r32
BLSIL m32 r32

func BLSIQ ¶

func BLSIQ(mr, r operand.Op) (*intrep.Instruction, error)

BLSIQ: Isolate Lowest Set Bit.

Forms:

BLSIQ r64 r64
BLSIQ m64 r64

func BLSMSKL ¶

func BLSMSKL(mr, r operand.Op) (*intrep.Instruction, error)

BLSMSKL: Mask From Lowest Set Bit.

Forms:

BLSMSKL r32 r32
BLSMSKL m32 r32

func BLSMSKQ ¶

func BLSMSKQ(mr, r operand.Op) (*intrep.Instruction, error)

BLSMSKQ: Mask From Lowest Set Bit.

Forms:

BLSMSKQ r64 r64
BLSMSKQ m64 r64

func BLSRL ¶

func BLSRL(mr, r operand.Op) (*intrep.Instruction, error)

BLSRL: Reset Lowest Set Bit.

Forms:

BLSRL r32 r32
BLSRL m32 r32

func BLSRQ ¶

func BLSRQ(mr, r operand.Op) (*intrep.Instruction, error)

BLSRQ: Reset Lowest Set Bit.

Forms:

BLSRQ r64 r64
BLSRQ m64 r64

func BSFL ¶

func BSFL(mr, r operand.Op) (*intrep.Instruction, error)

BSFL: Bit Scan Forward.

Forms:

BSFL r32 r32
BSFL m32 r32

func BSFQ ¶

func BSFQ(mr, r operand.Op) (*intrep.Instruction, error)

BSFQ: Bit Scan Forward.

Forms:

BSFQ r64 r64
BSFQ m64 r64

func BSFW ¶

func BSFW(mr, r operand.Op) (*intrep.Instruction, error)

BSFW: Bit Scan Forward.

Forms:

BSFW r16 r16
BSFW m16 r16

func BSRL ¶

func BSRL(mr, r operand.Op) (*intrep.Instruction, error)

BSRL: Bit Scan Reverse.

Forms:

BSRL r32 r32
BSRL m32 r32

func BSRQ ¶

func BSRQ(mr, r operand.Op) (*intrep.Instruction, error)

BSRQ: Bit Scan Reverse.

Forms:

BSRQ r64 r64
BSRQ m64 r64

func BSRW ¶

func BSRW(mr, r operand.Op) (*intrep.Instruction, error)

BSRW: Bit Scan Reverse.

Forms:

BSRW r16 r16
BSRW m16 r16

func BSWAPL ¶

func BSWAPL(r operand.Op) (*intrep.Instruction, error)

BSWAPL: Byte Swap.

Forms:

BSWAPL r32

func BSWAPQ ¶

func BSWAPQ(r operand.Op) (*intrep.Instruction, error)

BSWAPQ: Byte Swap.

Forms:

BSWAPQ r64

func BTCL ¶

func BTCL(ir, mr operand.Op) (*intrep.Instruction, error)

BTCL: Bit Test and Complement.

Forms:

BTCL imm8 r32
BTCL r32  r32
BTCL imm8 m32
BTCL r32  m32

func BTCQ ¶

func BTCQ(ir, mr operand.Op) (*intrep.Instruction, error)

BTCQ: Bit Test and Complement.

Forms:

BTCQ imm8 r64
BTCQ r64  r64
BTCQ imm8 m64
BTCQ r64  m64

func BTCW ¶

func BTCW(ir, mr operand.Op) (*intrep.Instruction, error)

BTCW: Bit Test and Complement.

Forms:

BTCW imm8 r16
BTCW r16  r16
BTCW imm8 m16
BTCW r16  m16

func BTL ¶

func BTL(ir, mr operand.Op) (*intrep.Instruction, error)

BTL: Bit Test.

Forms:

BTL imm8 r32
BTL r32  r32
BTL imm8 m32
BTL r32  m32

func BTQ ¶

func BTQ(ir, mr operand.Op) (*intrep.Instruction, error)

BTQ: Bit Test.

Forms:

BTQ imm8 r64
BTQ r64  r64
BTQ imm8 m64
BTQ r64  m64

func BTRL ¶

func BTRL(ir, mr operand.Op) (*intrep.Instruction, error)

BTRL: Bit Test and Reset.

Forms:

BTRL imm8 r32
BTRL r32  r32
BTRL imm8 m32
BTRL r32  m32

func BTRQ ¶

func BTRQ(ir, mr operand.Op) (*intrep.Instruction, error)

BTRQ: Bit Test and Reset.

Forms:

BTRQ imm8 r64
BTRQ r64  r64
BTRQ imm8 m64
BTRQ r64  m64

func BTRW ¶

func BTRW(ir, mr operand.Op) (*intrep.Instruction, error)

BTRW: Bit Test and Reset.

Forms:

BTRW imm8 r16
BTRW r16  r16
BTRW imm8 m16
BTRW r16  m16

func BTSL ¶

func BTSL(ir, mr operand.Op) (*intrep.Instruction, error)

BTSL: Bit Test and Set.

Forms:

BTSL imm8 r32
BTSL r32  r32
BTSL imm8 m32
BTSL r32  m32

func BTSQ ¶

func BTSQ(ir, mr operand.Op) (*intrep.Instruction, error)

BTSQ: Bit Test and Set.

Forms:

BTSQ imm8 r64
BTSQ r64  r64
BTSQ imm8 m64
BTSQ r64  m64

func BTSW ¶

func BTSW(ir, mr operand.Op) (*intrep.Instruction, error)

BTSW: Bit Test and Set.

Forms:

BTSW imm8 r16
BTSW r16  r16
BTSW imm8 m16
BTSW r16  m16

func BTW ¶

func BTW(ir, mr operand.Op) (*intrep.Instruction, error)

BTW: Bit Test.

Forms:

BTW imm8 r16
BTW r16  r16
BTW imm8 m16
BTW r16  m16

func BZHIL ¶

func BZHIL(r, mr, r1 operand.Op) (*intrep.Instruction, error)

BZHIL: Zero High Bits Starting with Specified Bit Position.

Forms:

BZHIL r32 r32 r32
BZHIL r32 m32 r32

func BZHIQ ¶

func BZHIQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)

BZHIQ: Zero High Bits Starting with Specified Bit Position.

Forms:

BZHIQ r64 r64 r64
BZHIQ r64 m64 r64

func CALL ¶

func CALL(r operand.Op) (*intrep.Instruction, error)

CALL: Call Procedure.

Forms:

CALL rel32

func CBW ¶

func CBW() (*intrep.Instruction, error)

CBW: Convert Byte to Word.

Forms:

CBW

func CDQ ¶

func CDQ() (*intrep.Instruction, error)

CDQ: Convert Doubleword to Quadword.

Forms:

CDQ

func CDQE ¶

func CDQE() (*intrep.Instruction, error)

CDQE: Convert Doubleword to Quadword.

Forms:

CDQE

func CLC ¶

func CLC() (*intrep.Instruction, error)

CLC: Clear Carry Flag.

Forms:

CLC

func CLD ¶

func CLD() (*intrep.Instruction, error)

CLD: Clear Direction Flag.

Forms:

CLD

func CLFLUSH ¶

func CLFLUSH(m operand.Op) (*intrep.Instruction, error)

CLFLUSH: Flush Cache Line.

Forms:

CLFLUSH m8

func CLFLUSHOPT ¶

func CLFLUSHOPT(m operand.Op) (*intrep.Instruction, error)

CLFLUSHOPT: Flush Cache Line Optimized.

Forms:

CLFLUSHOPT m8

func CMC ¶

func CMC() (*intrep.Instruction, error)

CMC: Complement Carry Flag.

Forms:

CMC

func CMOVLCC ¶

func CMOVLCC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLCC: Move if above or equal (CF == 0).

Forms:

CMOVLCC r32 r32
CMOVLCC m32 r32

func CMOVLCS ¶

func CMOVLCS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLCS: Move if below (CF == 1).

Forms:

CMOVLCS r32 r32
CMOVLCS m32 r32

func CMOVLEQ ¶

func CMOVLEQ(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLEQ: Move if equal (ZF == 1).

Forms:

CMOVLEQ r32 r32
CMOVLEQ m32 r32

func CMOVLGE ¶

func CMOVLGE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLGE: Move if greater or equal (SF == OF).

Forms:

CMOVLGE r32 r32
CMOVLGE m32 r32

func CMOVLGT ¶

func CMOVLGT(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLGT: Move if greater (ZF == 0 and SF == OF).

Forms:

CMOVLGT r32 r32
CMOVLGT m32 r32

func CMOVLHI ¶

func CMOVLHI(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLHI: Move if above (CF == 0 and ZF == 0).

Forms:

CMOVLHI r32 r32
CMOVLHI m32 r32

func CMOVLLE ¶

func CMOVLLE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLLE: Move if less or equal (ZF == 1 or SF != OF).

Forms:

CMOVLLE r32 r32
CMOVLLE m32 r32

func CMOVLLS ¶

func CMOVLLS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLLS: Move if below or equal (CF == 1 or ZF == 1).

Forms:

CMOVLLS r32 r32
CMOVLLS m32 r32

func CMOVLLT ¶

func CMOVLLT(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLLT: Move if less (SF != OF).

Forms:

CMOVLLT r32 r32
CMOVLLT m32 r32

func CMOVLMI ¶

func CMOVLMI(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLMI: Move if sign (SF == 1).

Forms:

CMOVLMI r32 r32
CMOVLMI m32 r32

func CMOVLNE ¶

func CMOVLNE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLNE: Move if not equal (ZF == 0).

Forms:

CMOVLNE r32 r32
CMOVLNE m32 r32

func CMOVLOC ¶

func CMOVLOC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLOC: Move if not overflow (OF == 0).

Forms:

CMOVLOC r32 r32
CMOVLOC m32 r32

func CMOVLOS ¶

func CMOVLOS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLOS: Move if overflow (OF == 1).

Forms:

CMOVLOS r32 r32
CMOVLOS m32 r32

func CMOVLPC ¶

func CMOVLPC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLPC: Move if not parity (PF == 0).

Forms:

CMOVLPC r32 r32
CMOVLPC m32 r32

func CMOVLPL ¶

func CMOVLPL(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLPL: Move if not sign (SF == 0).

Forms:

CMOVLPL r32 r32
CMOVLPL m32 r32

func CMOVLPS ¶

func CMOVLPS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVLPS: Move if parity (PF == 1).

Forms:

CMOVLPS r32 r32
CMOVLPS m32 r32

func CMOVQCC ¶

func CMOVQCC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQCC: Move if above or equal (CF == 0).

Forms:

CMOVQCC r64 r64
CMOVQCC m64 r64

func CMOVQCS ¶

func CMOVQCS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQCS: Move if below (CF == 1).

Forms:

CMOVQCS r64 r64
CMOVQCS m64 r64

func CMOVQEQ ¶

func CMOVQEQ(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQEQ: Move if equal (ZF == 1).

Forms:

CMOVQEQ r64 r64
CMOVQEQ m64 r64

func CMOVQGE ¶

func CMOVQGE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQGE: Move if greater or equal (SF == OF).

Forms:

CMOVQGE r64 r64
CMOVQGE m64 r64

func CMOVQGT ¶

func CMOVQGT(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQGT: Move if greater (ZF == 0 and SF == OF).

Forms:

CMOVQGT r64 r64
CMOVQGT m64 r64

func CMOVQHI ¶

func CMOVQHI(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQHI: Move if above (CF == 0 and ZF == 0).

Forms:

CMOVQHI r64 r64
CMOVQHI m64 r64

func CMOVQLE ¶

func CMOVQLE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQLE: Move if less or equal (ZF == 1 or SF != OF).

Forms:

CMOVQLE r64 r64
CMOVQLE m64 r64

func CMOVQLS ¶

func CMOVQLS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQLS: Move if below or equal (CF == 1 or ZF == 1).

Forms:

CMOVQLS r64 r64
CMOVQLS m64 r64

func CMOVQLT ¶

func CMOVQLT(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQLT: Move if less (SF != OF).

Forms:

CMOVQLT r64 r64
CMOVQLT m64 r64

func CMOVQMI ¶

func CMOVQMI(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQMI: Move if sign (SF == 1).

Forms:

CMOVQMI r64 r64
CMOVQMI m64 r64

func CMOVQNE ¶

func CMOVQNE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQNE: Move if not equal (ZF == 0).

Forms:

CMOVQNE r64 r64
CMOVQNE m64 r64

func CMOVQOC ¶

func CMOVQOC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQOC: Move if not overflow (OF == 0).

Forms:

CMOVQOC r64 r64
CMOVQOC m64 r64

func CMOVQOS ¶

func CMOVQOS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQOS: Move if overflow (OF == 1).

Forms:

CMOVQOS r64 r64
CMOVQOS m64 r64

func CMOVQPC ¶

func CMOVQPC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQPC: Move if not parity (PF == 0).

Forms:

CMOVQPC r64 r64
CMOVQPC m64 r64

func CMOVQPL ¶

func CMOVQPL(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQPL: Move if not sign (SF == 0).

Forms:

CMOVQPL r64 r64
CMOVQPL m64 r64

func CMOVQPS ¶

func CMOVQPS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVQPS: Move if parity (PF == 1).

Forms:

CMOVQPS r64 r64
CMOVQPS m64 r64

func CMOVWCC ¶

func CMOVWCC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWCC: Move if above or equal (CF == 0).

Forms:

CMOVWCC r16 r16
CMOVWCC m16 r16

func CMOVWCS ¶

func CMOVWCS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWCS: Move if below (CF == 1).

Forms:

CMOVWCS r16 r16
CMOVWCS m16 r16

func CMOVWEQ ¶

func CMOVWEQ(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWEQ: Move if equal (ZF == 1).

Forms:

CMOVWEQ r16 r16
CMOVWEQ m16 r16

func CMOVWGE ¶

func CMOVWGE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWGE: Move if greater or equal (SF == OF).

Forms:

CMOVWGE r16 r16
CMOVWGE m16 r16

func CMOVWGT ¶

func CMOVWGT(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWGT: Move if greater (ZF == 0 and SF == OF).

Forms:

CMOVWGT r16 r16
CMOVWGT m16 r16

func CMOVWHI ¶

func CMOVWHI(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWHI: Move if above (CF == 0 and ZF == 0).

Forms:

CMOVWHI r16 r16
CMOVWHI m16 r16

func CMOVWLE ¶

func CMOVWLE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWLE: Move if less or equal (ZF == 1 or SF != OF).

Forms:

CMOVWLE r16 r16
CMOVWLE m16 r16

func CMOVWLS ¶

func CMOVWLS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWLS: Move if below or equal (CF == 1 or ZF == 1).

Forms:

CMOVWLS r16 r16
CMOVWLS m16 r16

func CMOVWLT ¶

func CMOVWLT(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWLT: Move if less (SF != OF).

Forms:

CMOVWLT r16 r16
CMOVWLT m16 r16

func CMOVWMI ¶

func CMOVWMI(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWMI: Move if sign (SF == 1).

Forms:

CMOVWMI r16 r16
CMOVWMI m16 r16

func CMOVWNE ¶

func CMOVWNE(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWNE: Move if not equal (ZF == 0).

Forms:

CMOVWNE r16 r16
CMOVWNE m16 r16

func CMOVWOC ¶

func CMOVWOC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWOC: Move if not overflow (OF == 0).

Forms:

CMOVWOC r16 r16
CMOVWOC m16 r16

func CMOVWOS ¶

func CMOVWOS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWOS: Move if overflow (OF == 1).

Forms:

CMOVWOS r16 r16
CMOVWOS m16 r16

func CMOVWPC ¶

func CMOVWPC(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWPC: Move if not parity (PF == 0).

Forms:

CMOVWPC r16 r16
CMOVWPC m16 r16

func CMOVWPL ¶

func CMOVWPL(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWPL: Move if not sign (SF == 0).

Forms:

CMOVWPL r16 r16
CMOVWPL m16 r16

func CMOVWPS ¶

func CMOVWPS(mr, r operand.Op) (*intrep.Instruction, error)

CMOVWPS: Move if parity (PF == 1).

Forms:

CMOVWPS r16 r16
CMOVWPS m16 r16

func CMPB ¶

func CMPB(amr, imr operand.Op) (*intrep.Instruction, error)

CMPB: Compare Two Operands.

Forms:

CMPB al imm8
CMPB r8 imm8
CMPB r8 r8
CMPB r8 m8
CMPB m8 imm8
CMPB m8 r8

func CMPL ¶

func CMPL(emr, imr operand.Op) (*intrep.Instruction, error)

CMPL: Compare Two Operands.

Forms:

CMPL eax imm32
CMPL r32 imm8
CMPL r32 imm32
CMPL r32 r32
CMPL r32 m32
CMPL m32 imm8
CMPL m32 imm32
CMPL m32 r32

func CMPPD ¶

func CMPPD(mx, x, i operand.Op) (*intrep.Instruction, error)

CMPPD: Compare Packed Double-Precision Floating-Point Values.

Forms:

CMPPD xmm  xmm imm8
CMPPD m128 xmm imm8

func CMPPS ¶

func CMPPS(mx, x, i operand.Op) (*intrep.Instruction, error)

CMPPS: Compare Packed Single-Precision Floating-Point Values.

Forms:

CMPPS xmm  xmm imm8
CMPPS m128 xmm imm8

func CMPQ ¶

func CMPQ(mr, imr operand.Op) (*intrep.Instruction, error)

CMPQ: Compare Two Operands.

Forms:

CMPQ rax imm32
CMPQ r64 imm8
CMPQ r64 imm32
CMPQ r64 r64
CMPQ r64 m64
CMPQ m64 imm8
CMPQ m64 imm32
CMPQ m64 r64

func CMPSD ¶

func CMPSD(mx, x, i operand.Op) (*intrep.Instruction, error)

CMPSD: Compare Scalar Double-Precision Floating-Point Values.

Forms:

CMPSD xmm xmm imm8
CMPSD m64 xmm imm8

func CMPSS ¶

func CMPSS(mx, x, i operand.Op) (*intrep.Instruction, error)

CMPSS: Compare Scalar Single-Precision Floating-Point Values.

Forms:

CMPSS xmm xmm imm8
CMPSS m32 xmm imm8

func CMPW ¶

func CMPW(amr, imr operand.Op) (*intrep.Instruction, error)

CMPW: Compare Two Operands.

Forms:

CMPW ax  imm16
CMPW r16 imm8
CMPW r16 imm16
CMPW r16 r16
CMPW r16 m16
CMPW m16 imm8
CMPW m16 imm16
CMPW m16 r16

func CMPXCHG16B ¶

func CMPXCHG16B(m operand.Op) (*intrep.Instruction, error)

CMPXCHG16B: Compare and Exchange 16 Bytes.

Forms:

CMPXCHG16B m128

func CMPXCHG8B ¶

func CMPXCHG8B(m operand.Op) (*intrep.Instruction, error)

CMPXCHG8B: Compare and Exchange 8 Bytes.

Forms:

CMPXCHG8B m64

func CMPXCHGB ¶

func CMPXCHGB(r, mr operand.Op) (*intrep.Instruction, error)

CMPXCHGB: Compare and Exchange.

Forms:

CMPXCHGB r8 r8
CMPXCHGB r8 m8

func CMPXCHGL ¶

func CMPXCHGL(r, mr operand.Op) (*intrep.Instruction, error)

CMPXCHGL: Compare and Exchange.

Forms:

CMPXCHGL r32 r32
CMPXCHGL r32 m32

func CMPXCHGQ ¶

func CMPXCHGQ(r, mr operand.Op) (*intrep.Instruction, error)

CMPXCHGQ: Compare and Exchange.

Forms:

CMPXCHGQ r64 r64
CMPXCHGQ r64 m64

func CMPXCHGW ¶

func CMPXCHGW(r, mr operand.Op) (*intrep.Instruction, error)

CMPXCHGW: Compare and Exchange.

Forms:

CMPXCHGW r16 r16
CMPXCHGW r16 m16

func COMISD ¶

func COMISD(mx, x operand.Op) (*intrep.Instruction, error)

COMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

COMISD xmm xmm
COMISD m64 xmm

func COMISS ¶

func COMISS(mx, x operand.Op) (*intrep.Instruction, error)

COMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

COMISS xmm xmm
COMISS m32 xmm

func CPUID ¶

func CPUID() (*intrep.Instruction, error)

CPUID: CPU Identification.

Forms:

CPUID

func CQO ¶

func CQO() (*intrep.Instruction, error)

CQO: Convert Quadword to Octaword.

Forms:

CQO

func CRC32B ¶

func CRC32B(mr, r operand.Op) (*intrep.Instruction, error)

CRC32B: Accumulate CRC32 Value.

Forms:

CRC32B r8 r32
CRC32B m8 r32
CRC32B r8 r64
CRC32B m8 r64

func CRC32L ¶

func CRC32L(mr, r operand.Op) (*intrep.Instruction, error)

CRC32L: Accumulate CRC32 Value.

Forms:

CRC32L r32 r32
CRC32L m32 r32

func CRC32Q ¶

func CRC32Q(mr, r operand.Op) (*intrep.Instruction, error)

CRC32Q: Accumulate CRC32 Value.

Forms:

CRC32Q r64 r64
CRC32Q m64 r64

func CRC32W ¶

func CRC32W(mr, r operand.Op) (*intrep.Instruction, error)

CRC32W: Accumulate CRC32 Value.

Forms:

CRC32W r16 r32
CRC32W m16 r32

func CVTPD2PL ¶

func CVTPD2PL(mx, x operand.Op) (*intrep.Instruction, error)

CVTPD2PL: Convert Packed Double-Precision FP Values to Packed Dword Integers.

Forms:

CVTPD2PL xmm  xmm
CVTPD2PL m128 xmm

func CVTPD2PS ¶

func CVTPD2PS(mx, x operand.Op) (*intrep.Instruction, error)

CVTPD2PS: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values.

Forms:

CVTPD2PS xmm  xmm
CVTPD2PS m128 xmm

func CVTPL2PD ¶

func CVTPL2PD(mx, x operand.Op) (*intrep.Instruction, error)

CVTPL2PD: Convert Packed Dword Integers to Packed Double-Precision FP Values.

Forms:

CVTPL2PD xmm xmm
CVTPL2PD m64 xmm

func CVTPL2PS ¶

func CVTPL2PS(mx, x operand.Op) (*intrep.Instruction, error)

CVTPL2PS: Convert Packed Dword Integers to Packed Single-Precision FP Values.

Forms:

CVTPL2PS xmm  xmm
CVTPL2PS m128 xmm

func CVTPS2PD ¶

func CVTPS2PD(mx, x operand.Op) (*intrep.Instruction, error)

CVTPS2PD: Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values.

Forms:

CVTPS2PD xmm xmm
CVTPS2PD m64 xmm

func CVTPS2PL ¶

func CVTPS2PL(mx, x operand.Op) (*intrep.Instruction, error)

CVTPS2PL: Convert Packed Single-Precision FP Values to Packed Dword Integers.

Forms:

CVTPS2PL xmm  xmm
CVTPS2PL m128 xmm

func CVTSD2SL ¶

func CVTSD2SL(mx, r operand.Op) (*intrep.Instruction, error)

CVTSD2SL: Convert Scalar Double-Precision FP Value to Integer.

Forms:

CVTSD2SL xmm r32
CVTSD2SL m64 r32
CVTSD2SL xmm r64
CVTSD2SL m64 r64

func CVTSD2SS ¶

func CVTSD2SS(mx, x operand.Op) (*intrep.Instruction, error)

CVTSD2SS: Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value.

Forms:

CVTSD2SS xmm xmm
CVTSD2SS m64 xmm

func CVTSL2SD ¶

func CVTSL2SD(mr, x operand.Op) (*intrep.Instruction, error)

CVTSL2SD: Convert Dword Integer to Scalar Double-Precision FP Value.

Forms:

CVTSL2SD r32 xmm
CVTSL2SD m32 xmm

func CVTSL2SS ¶

func CVTSL2SS(mr, x operand.Op) (*intrep.Instruction, error)

CVTSL2SS: Convert Dword Integer to Scalar Single-Precision FP Value.

Forms:

CVTSL2SS r32 xmm
CVTSL2SS m32 xmm

func CVTSQ2SD ¶

func CVTSQ2SD(mr, x operand.Op) (*intrep.Instruction, error)

CVTSQ2SD: Convert Dword Integer to Scalar Double-Precision FP Value.

Forms:

CVTSQ2SD r64 xmm
CVTSQ2SD m64 xmm

func CVTSQ2SS ¶

func CVTSQ2SS(mr, x operand.Op) (*intrep.Instruction, error)

CVTSQ2SS: Convert Dword Integer to Scalar Single-Precision FP Value.

Forms:

CVTSQ2SS r64 xmm
CVTSQ2SS m64 xmm

func CVTSS2SD ¶

func CVTSS2SD(mx, x operand.Op) (*intrep.Instruction, error)

CVTSS2SD: Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value.

Forms:

CVTSS2SD xmm xmm
CVTSS2SD m32 xmm

func CVTSS2SL ¶

func CVTSS2SL(mx, r operand.Op) (*intrep.Instruction, error)

CVTSS2SL: Convert Scalar Single-Precision FP Value to Dword Integer.

Forms:

CVTSS2SL xmm r32
CVTSS2SL m32 r32
CVTSS2SL xmm r64
CVTSS2SL m32 r64

func CVTTPD2PL ¶

func CVTTPD2PL(mx, x operand.Op) (*intrep.Instruction, error)

CVTTPD2PL: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers.

Forms:

CVTTPD2PL xmm  xmm
CVTTPD2PL m128 xmm

func CVTTPS2PL ¶

func CVTTPS2PL(mx, x operand.Op) (*intrep.Instruction, error)

CVTTPS2PL: Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers.

Forms:

CVTTPS2PL xmm  xmm
CVTTPS2PL m128 xmm

func CVTTSD2SL ¶

func CVTTSD2SL(mx, r operand.Op) (*intrep.Instruction, error)

CVTTSD2SL: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer.

Forms:

CVTTSD2SL xmm r32
CVTTSD2SL m64 r32

func CVTTSD2SQ ¶

func CVTTSD2SQ(mx, r operand.Op) (*intrep.Instruction, error)

CVTTSD2SQ: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer.

Forms:

CVTTSD2SQ xmm r64
CVTTSD2SQ m64 r64

func CVTTSS2SL ¶

func CVTTSS2SL(mx, r operand.Op) (*intrep.Instruction, error)

CVTTSS2SL: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer.

Forms:

CVTTSS2SL xmm r32
CVTTSS2SL m32 r32
CVTTSS2SL xmm r64
CVTTSS2SL m32 r64

func CWD ¶

func CWD() (*intrep.Instruction, error)

CWD: Convert Word to Doubleword.

Forms:

CWD

func CWDE ¶

func CWDE() (*intrep.Instruction, error)

CWDE: Convert Word to Doubleword.

Forms:

CWDE

func DECB ¶

func DECB(mr operand.Op) (*intrep.Instruction, error)

DECB: Decrement by 1.

Forms:

DECB r8
DECB m8

func DECL ¶

func DECL(mr operand.Op) (*intrep.Instruction, error)

DECL: Decrement by 1.

Forms:

DECL r32
DECL m32

func DECQ ¶

func DECQ(mr operand.Op) (*intrep.Instruction, error)

DECQ: Decrement by 1.

Forms:

DECQ r64
DECQ m64

func DECW ¶

func DECW(mr operand.Op) (*intrep.Instruction, error)

DECW: Decrement by 1.

Forms:

DECW r16
DECW m16

func DIVB ¶

func DIVB(mr operand.Op) (*intrep.Instruction, error)

DIVB: Unsigned Divide.

Forms:

DIVB r8
DIVB m8

func DIVL ¶

func DIVL(mr operand.Op) (*intrep.Instruction, error)

DIVL: Unsigned Divide.

Forms:

DIVL r32
DIVL m32

func DIVPD ¶

func DIVPD(mx, x operand.Op) (*intrep.Instruction, error)

DIVPD: Divide Packed Double-Precision Floating-Point Values.

Forms:

DIVPD xmm  xmm
DIVPD m128 xmm

func DIVPS ¶

func DIVPS(mx, x operand.Op) (*intrep.Instruction, error)

DIVPS: Divide Packed Single-Precision Floating-Point Values.

Forms:

DIVPS xmm  xmm
DIVPS m128 xmm

func DIVQ ¶

func DIVQ(mr operand.Op) (*intrep.Instruction, error)

DIVQ: Unsigned Divide.

Forms:

DIVQ r64
DIVQ m64

func DIVSD ¶

func DIVSD(mx, x operand.Op) (*intrep.Instruction, error)

DIVSD: Divide Scalar Double-Precision Floating-Point Values.

Forms:

DIVSD xmm xmm
DIVSD m64 xmm

func DIVSS ¶

func DIVSS(mx, x operand.Op) (*intrep.Instruction, error)

DIVSS: Divide Scalar Single-Precision Floating-Point Values.

Forms:

DIVSS xmm xmm
DIVSS m32 xmm

func DIVW ¶

func DIVW(mr operand.Op) (*intrep.Instruction, error)

DIVW: Unsigned Divide.

Forms:

DIVW r16
DIVW m16

func DPPD ¶

func DPPD(i, mx, x operand.Op) (*intrep.Instruction, error)

DPPD: Dot Product of Packed Double Precision Floating-Point Values.

Forms:

DPPD imm8 xmm  xmm
DPPD imm8 m128 xmm

func DPPS ¶

func DPPS(i, mx, x operand.Op) (*intrep.Instruction, error)

DPPS: Dot Product of Packed Single Precision Floating-Point Values.

Forms:

DPPS imm8 xmm  xmm
DPPS imm8 m128 xmm

func EXTRACTPS ¶

func EXTRACTPS(i, x, mr operand.Op) (*intrep.Instruction, error)

EXTRACTPS: Extract Packed Single Precision Floating-Point Value.

Forms:

EXTRACTPS imm2u xmm r32
EXTRACTPS imm2u xmm m32

func HADDPD ¶

func HADDPD(mx, x operand.Op) (*intrep.Instruction, error)

HADDPD: Packed Double-FP Horizontal Add.

Forms:

HADDPD xmm  xmm
HADDPD m128 xmm

func HADDPS ¶

func HADDPS(mx, x operand.Op) (*intrep.Instruction, error)

HADDPS: Packed Single-FP Horizontal Add.

Forms:

HADDPS xmm  xmm
HADDPS m128 xmm

func HSUBPD ¶

func HSUBPD(mx, x operand.Op) (*intrep.Instruction, error)

HSUBPD: Packed Double-FP Horizontal Subtract.

Forms:

HSUBPD xmm  xmm
HSUBPD m128 xmm

func HSUBPS ¶

func HSUBPS(mx, x operand.Op) (*intrep.Instruction, error)

HSUBPS: Packed Single-FP Horizontal Subtract.

Forms:

HSUBPS xmm  xmm
HSUBPS m128 xmm

func IDIVB ¶

func IDIVB(mr operand.Op) (*intrep.Instruction, error)

IDIVB: Signed Divide.

Forms:

IDIVB r8
IDIVB m8

func IDIVL ¶

func IDIVL(mr operand.Op) (*intrep.Instruction, error)

IDIVL: Signed Divide.

Forms:

IDIVL r32
IDIVL m32

func IDIVQ ¶

func IDIVQ(mr operand.Op) (*intrep.Instruction, error)

IDIVQ: Signed Divide.

Forms:

IDIVQ r64
IDIVQ m64

func IDIVW ¶

func IDIVW(mr operand.Op) (*intrep.Instruction, error)

IDIVW: Signed Divide.

Forms:

IDIVW r16
IDIVW m16

func IMUL3L ¶

func IMUL3L(i, mr, r operand.Op) (*intrep.Instruction, error)

IMUL3L: Signed Multiply.

Forms:

IMUL3L imm8  r32 r32
IMUL3L imm32 r32 r32
IMUL3L imm8  m32 r32
IMUL3L imm32 m32 r32

func IMUL3Q ¶

func IMUL3Q(i, mr, r operand.Op) (*intrep.Instruction, error)

IMUL3Q: Signed Multiply.

Forms:

IMUL3Q imm8  r64 r64
IMUL3Q imm32 r64 r64
IMUL3Q imm8  m64 r64
IMUL3Q imm32 m64 r64

func IMUL3W ¶

func IMUL3W(i, mr, r operand.Op) (*intrep.Instruction, error)

IMUL3W: Signed Multiply.

Forms:

IMUL3W imm8  r16 r16
IMUL3W imm16 r16 r16
IMUL3W imm8  m16 r16
IMUL3W imm16 m16 r16

func IMULB ¶

func IMULB(mr operand.Op) (*intrep.Instruction, error)

IMULB: Signed Multiply.

Forms:

IMULB r8
IMULB m8

func IMULL ¶

func IMULL(ops ...operand.Op) (*intrep.Instruction, error)

IMULL: Signed Multiply.

Forms:

IMULL r32
IMULL m32
IMULL r32 r32
IMULL m32 r32

func IMULQ ¶

func IMULQ(ops ...operand.Op) (*intrep.Instruction, error)

IMULQ: Signed Multiply.

Forms:

IMULQ r64
IMULQ m64
IMULQ r64 r64
IMULQ m64 r64

func IMULW ¶

func IMULW(ops ...operand.Op) (*intrep.Instruction, error)

IMULW: Signed Multiply.

Forms:

IMULW r16
IMULW m16
IMULW r16 r16
IMULW m16 r16

func INCB ¶

func INCB(mr operand.Op) (*intrep.Instruction, error)

INCB: Increment by 1.

Forms:

INCB r8
INCB m8

func INCL ¶

func INCL(mr operand.Op) (*intrep.Instruction, error)

INCL: Increment by 1.

Forms:

INCL r32
INCL m32

func INCQ ¶

func INCQ(mr operand.Op) (*intrep.Instruction, error)

INCQ: Increment by 1.

Forms:

INCQ r64
INCQ m64

func INCW ¶

func INCW(mr operand.Op) (*intrep.Instruction, error)

INCW: Increment by 1.

Forms:

INCW r16
INCW m16

func INSERTPS ¶

func INSERTPS(i, mx, x operand.Op) (*intrep.Instruction, error)

INSERTPS: Insert Packed Single Precision Floating-Point Value.

Forms:

INSERTPS imm8 xmm xmm
INSERTPS imm8 m32 xmm

func INT ¶

func INT(i operand.Op) (*intrep.Instruction, error)

INT: Call to Interrupt Procedure.

Forms:

INT 3
INT imm8

func JA ¶

func JA(r operand.Op) (*intrep.Instruction, error)

JA: Jump if above (CF == 0 and ZF == 0).

Forms:

JA rel8
JA rel32

func JAE ¶

func JAE(r operand.Op) (*intrep.Instruction, error)

JAE: Jump if above or equal (CF == 0).

Forms:

JAE rel8
JAE rel32

func JB ¶

func JB(r operand.Op) (*intrep.Instruction, error)

JB: Jump if below (CF == 1).

Forms:

JB rel8
JB rel32

func JBE ¶

func JBE(r operand.Op) (*intrep.Instruction, error)

JBE: Jump if below or equal (CF == 1 or ZF == 1).

Forms:

JBE rel8
JBE rel32

func JC ¶

func JC(r operand.Op) (*intrep.Instruction, error)

JC: Jump if below (CF == 1).

Forms:

JC rel8
JC rel32

func JCC ¶

func JCC(r operand.Op) (*intrep.Instruction, error)

JCC: Jump if above or equal (CF == 0).

Forms:

JCC rel8
JCC rel32

func JCS ¶

func JCS(r operand.Op) (*intrep.Instruction, error)

JCS: Jump if below (CF == 1).

Forms:

JCS rel8
JCS rel32

func JCXZL ¶

func JCXZL(r operand.Op) (*intrep.Instruction, error)

JCXZL: Jump if ECX register is 0.

Forms:

JCXZL rel8

func JCXZQ ¶

func JCXZQ(r operand.Op) (*intrep.Instruction, error)

JCXZQ: Jump if RCX register is 0.

Forms:

JCXZQ rel8

func JE ¶

func JE(r operand.Op) (*intrep.Instruction, error)

JE: Jump if equal (ZF == 1).

Forms:

JE rel8
JE rel32

func JEQ ¶

func JEQ(r operand.Op) (*intrep.Instruction, error)

JEQ: Jump if equal (ZF == 1).

Forms:

JEQ rel8
JEQ rel32

func JG ¶

func JG(r operand.Op) (*intrep.Instruction, error)

JG: Jump if greater (ZF == 0 and SF == OF).

Forms:

JG rel8
JG rel32

func JGE ¶

func JGE(r operand.Op) (*intrep.Instruction, error)

JGE: Jump if greater or equal (SF == OF).

Forms:

JGE rel8
JGE rel32

func JGT ¶

func JGT(r operand.Op) (*intrep.Instruction, error)

JGT: Jump if greater (ZF == 0 and SF == OF).

Forms:

JGT rel8
JGT rel32

func JHI ¶

func JHI(r operand.Op) (*intrep.Instruction, error)

JHI: Jump if above (CF == 0 and ZF == 0).

Forms:

JHI rel8
JHI rel32

func JHS ¶

func JHS(r operand.Op) (*intrep.Instruction, error)

JHS: Jump if above or equal (CF == 0).

Forms:

JHS rel8
JHS rel32

func JL ¶

func JL(r operand.Op) (*intrep.Instruction, error)

JL: Jump if less (SF != OF).

Forms:

JL rel8
JL rel32

func JLE ¶

func JLE(r operand.Op) (*intrep.Instruction, error)

JLE: Jump if less or equal (ZF == 1 or SF != OF).

Forms:

JLE rel8
JLE rel32

func JLO ¶

func JLO(r operand.Op) (*intrep.Instruction, error)

JLO: Jump if below (CF == 1).

Forms:

JLO rel8
JLO rel32

func JLS ¶

func JLS(r operand.Op) (*intrep.Instruction, error)

JLS: Jump if below or equal (CF == 1 or ZF == 1).

Forms:

JLS rel8
JLS rel32

func JLT ¶

func JLT(r operand.Op) (*intrep.Instruction, error)

JLT: Jump if less (SF != OF).

Forms:

JLT rel8
JLT rel32

func JMI ¶

func JMI(r operand.Op) (*intrep.Instruction, error)

JMI: Jump if sign (SF == 1).

Forms:

JMI rel8
JMI rel32

func JMP ¶

func JMP(mr operand.Op) (*intrep.Instruction, error)

JMP: Jump Unconditionally.

Forms:

JMP rel8
JMP rel32
JMP r64
JMP m64

func JNA ¶

func JNA(r operand.Op) (*intrep.Instruction, error)

JNA: Jump if below or equal (CF == 1 or ZF == 1).

Forms:

JNA rel8
JNA rel32

func JNAE ¶

func JNAE(r operand.Op) (*intrep.Instruction, error)

JNAE: Jump if below (CF == 1).

Forms:

JNAE rel8
JNAE rel32

func JNB ¶

func JNB(r operand.Op) (*intrep.Instruction, error)

JNB: Jump if above or equal (CF == 0).

Forms:

JNB rel8
JNB rel32

func JNBE ¶

func JNBE(r operand.Op) (*intrep.Instruction, error)

JNBE: Jump if above (CF == 0 and ZF == 0).

Forms:

JNBE rel8
JNBE rel32

func JNC ¶

func JNC(r operand.Op) (*intrep.Instruction, error)

JNC: Jump if above or equal (CF == 0).

Forms:

JNC rel8
JNC rel32

func JNE ¶

func JNE(r operand.Op) (*intrep.Instruction, error)

JNE: Jump if not equal (ZF == 0).

Forms:

JNE rel8
JNE rel32

func JNG ¶

func JNG(r operand.Op) (*intrep.Instruction, error)

JNG: Jump if less or equal (ZF == 1 or SF != OF).

Forms:

JNG rel8
JNG rel32

func JNGE ¶

func JNGE(r operand.Op) (*intrep.Instruction, error)

JNGE: Jump if less (SF != OF).

Forms:

JNGE rel8
JNGE rel32

func JNL ¶

func JNL(r operand.Op) (*intrep.Instruction, error)

JNL: Jump if greater or equal (SF == OF).

Forms:

JNL rel8
JNL rel32

func JNLE ¶

func JNLE(r operand.Op) (*intrep.Instruction, error)

JNLE: Jump if greater (ZF == 0 and SF == OF).

Forms:

JNLE rel8
JNLE rel32

func JNO ¶

func JNO(r operand.Op) (*intrep.Instruction, error)

JNO: Jump if not overflow (OF == 0).

Forms:

JNO rel8
JNO rel32

func JNP ¶

func JNP(r operand.Op) (*intrep.Instruction, error)

JNP: Jump if not parity (PF == 0).

Forms:

JNP rel8
JNP rel32

func JNS ¶

func JNS(r operand.Op) (*intrep.Instruction, error)

JNS: Jump if not sign (SF == 0).

Forms:

JNS rel8
JNS rel32

func JNZ ¶

func JNZ(r operand.Op) (*intrep.Instruction, error)

JNZ: Jump if not equal (ZF == 0).

Forms:

JNZ rel8
JNZ rel32

func JO ¶

func JO(r operand.Op) (*intrep.Instruction, error)

JO: Jump if overflow (OF == 1).

Forms:

JO rel8
JO rel32

func JOC ¶

func JOC(r operand.Op) (*intrep.Instruction, error)

JOC: Jump if not overflow (OF == 0).

Forms:

JOC rel8
JOC rel32

func JOS ¶

func JOS(r operand.Op) (*intrep.Instruction, error)

JOS: Jump if overflow (OF == 1).

Forms:

JOS rel8
JOS rel32

func JP ¶

func JP(r operand.Op) (*intrep.Instruction, error)

JP: Jump if parity (PF == 1).

Forms:

JP rel8
JP rel32

func JPC ¶

func JPC(r operand.Op) (*intrep.Instruction, error)

JPC: Jump if not parity (PF == 0).

Forms:

JPC rel8
JPC rel32

func JPE ¶

func JPE(r operand.Op) (*intrep.Instruction, error)

JPE: Jump if parity (PF == 1).

Forms:

JPE rel8
JPE rel32

func JPL ¶

func JPL(r operand.Op) (*intrep.Instruction, error)

JPL: Jump if not sign (SF == 0).

Forms:

JPL rel8
JPL rel32

func JPO ¶

func JPO(r operand.Op) (*intrep.Instruction, error)

JPO: Jump if not parity (PF == 0).

Forms:

JPO rel8
JPO rel32

func JPS ¶

func JPS(r operand.Op) (*intrep.Instruction, error)

JPS: Jump if parity (PF == 1).

Forms:

JPS rel8
JPS rel32

func JS ¶

func JS(r operand.Op) (*intrep.Instruction, error)

JS: Jump if sign (SF == 1).

Forms:

JS rel8
JS rel32

func JZ ¶

func JZ(r operand.Op) (*intrep.Instruction, error)

JZ: Jump if equal (ZF == 1).

Forms:

JZ rel8
JZ rel32

func LDDQU ¶

func LDDQU(m, x operand.Op) (*intrep.Instruction, error)

LDDQU: Load Unaligned Integer 128 Bits.

Forms:

LDDQU m128 xmm

func LDMXCSR ¶

func LDMXCSR(m operand.Op) (*intrep.Instruction, error)

LDMXCSR: Load MXCSR Register.

Forms:

LDMXCSR m32

func LEAL ¶

func LEAL(m, r operand.Op) (*intrep.Instruction, error)

LEAL: Load Effective Address.

Forms:

LEAL m r32

func LEAQ ¶

func LEAQ(m, r operand.Op) (*intrep.Instruction, error)

LEAQ: Load Effective Address.

Forms:

LEAQ m r64

func LEAW ¶

func LEAW(m, r operand.Op) (*intrep.Instruction, error)

LEAW: Load Effective Address.

Forms:

LEAW m r16

func LFENCE ¶

func LFENCE() (*intrep.Instruction, error)

LFENCE: Load Fence.

Forms:

LFENCE

func LZCNTL ¶

func LZCNTL(mr, r operand.Op) (*intrep.Instruction, error)

LZCNTL: Count the Number of Leading Zero Bits.

Forms:

LZCNTL r32 r32
LZCNTL m32 r32

func LZCNTQ ¶

func LZCNTQ(mr, r operand.Op) (*intrep.Instruction, error)

LZCNTQ: Count the Number of Leading Zero Bits.

Forms:

LZCNTQ r64 r64
LZCNTQ m64 r64

func LZCNTW ¶

func LZCNTW(mr, r operand.Op) (*intrep.Instruction, error)

LZCNTW: Count the Number of Leading Zero Bits.

Forms:

LZCNTW r16 r16
LZCNTW m16 r16

func MASKMOVDQU ¶

func MASKMOVDQU(x, x1 operand.Op) (*intrep.Instruction, error)

MASKMOVDQU: Store Selected Bytes of Double Quadword.

Forms:

MASKMOVDQU xmm xmm

func MASKMOVOU ¶

func MASKMOVOU(x, x1 operand.Op) (*intrep.Instruction, error)

MASKMOVOU: Store Selected Bytes of Double Quadword.

Forms:

MASKMOVOU xmm xmm

func MAXPD ¶

func MAXPD(mx, x operand.Op) (*intrep.Instruction, error)

MAXPD: Return Maximum Packed Double-Precision Floating-Point Values.

Forms:

MAXPD xmm  xmm
MAXPD m128 xmm

func MAXPS ¶

func MAXPS(mx, x operand.Op) (*intrep.Instruction, error)

MAXPS: Return Maximum Packed Single-Precision Floating-Point Values.

Forms:

MAXPS xmm  xmm
MAXPS m128 xmm

func MAXSD ¶

func MAXSD(mx, x operand.Op) (*intrep.Instruction, error)

MAXSD: Return Maximum Scalar Double-Precision Floating-Point Value.

Forms:

MAXSD xmm xmm
MAXSD m64 xmm

func MAXSS ¶

func MAXSS(mx, x operand.Op) (*intrep.Instruction, error)

MAXSS: Return Maximum Scalar Single-Precision Floating-Point Value.

Forms:

MAXSS xmm xmm
MAXSS m32 xmm

func MFENCE ¶

func MFENCE() (*intrep.Instruction, error)

MFENCE: Memory Fence.

Forms:

MFENCE

func MINPD ¶

func MINPD(mx, x operand.Op) (*intrep.Instruction, error)

MINPD: Return Minimum Packed Double-Precision Floating-Point Values.

Forms:

MINPD xmm  xmm
MINPD m128 xmm

func MINPS ¶

func MINPS(mx, x operand.Op) (*intrep.Instruction, error)

MINPS: Return Minimum Packed Single-Precision Floating-Point Values.

Forms:

MINPS xmm  xmm
MINPS m128 xmm

func MINSD ¶

func MINSD(mx, x operand.Op) (*intrep.Instruction, error)

MINSD: Return Minimum Scalar Double-Precision Floating-Point Value.

Forms:

MINSD xmm xmm
MINSD m64 xmm

func MINSS ¶

func MINSS(mx, x operand.Op) (*intrep.Instruction, error)

MINSS: Return Minimum Scalar Single-Precision Floating-Point Value.

Forms:

MINSS xmm xmm
MINSS m32 xmm

func MONITOR ¶

func MONITOR() (*intrep.Instruction, error)

MONITOR: Monitor a Linear Address Range.

Forms:

MONITOR

func MOVAPD ¶

func MOVAPD(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVAPD: Move Aligned Packed Double-Precision Floating-Point Values.

Forms:

MOVAPD xmm  xmm
MOVAPD m128 xmm
MOVAPD xmm  m128

func MOVAPS ¶

func MOVAPS(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVAPS: Move Aligned Packed Single-Precision Floating-Point Values.

Forms:

MOVAPS xmm  xmm
MOVAPS m128 xmm
MOVAPS xmm  m128

func MOVB ¶

func MOVB(imr, mr operand.Op) (*intrep.Instruction, error)

MOVB: Move.

Forms:

MOVB imm8 r8
MOVB r8   r8
MOVB m8   r8
MOVB imm8 m8
MOVB r8   m8

func MOVBELL ¶

func MOVBELL(mr, mr1 operand.Op) (*intrep.Instruction, error)

MOVBELL: Move Data After Swapping Bytes.

Forms:

MOVBELL m32 r32
MOVBELL r32 m32

func MOVBEQQ ¶

func MOVBEQQ(mr, mr1 operand.Op) (*intrep.Instruction, error)

MOVBEQQ: Move Data After Swapping Bytes.

Forms:

MOVBEQQ m64 r64
MOVBEQQ r64 m64

func MOVBEWW ¶

func MOVBEWW(mr, mr1 operand.Op) (*intrep.Instruction, error)

MOVBEWW: Move Data After Swapping Bytes.

Forms:

MOVBEWW m16 r16
MOVBEWW r16 m16

func MOVBLSX ¶

func MOVBLSX(mr, r operand.Op) (*intrep.Instruction, error)

MOVBLSX: Move with Sign-Extension.

Forms:

MOVBLSX r8 r32
MOVBLSX m8 r32

func MOVBLZX ¶

func MOVBLZX(mr, r operand.Op) (*intrep.Instruction, error)

MOVBLZX: Move with Zero-Extend.

Forms:

MOVBLZX r8 r32
MOVBLZX m8 r32

func MOVBQSX ¶

func MOVBQSX(mr, r operand.Op) (*intrep.Instruction, error)

MOVBQSX: Move with Sign-Extension.

Forms:

MOVBQSX r8 r64
MOVBQSX m8 r64

func MOVBQZX ¶

func MOVBQZX(mr, r operand.Op) (*intrep.Instruction, error)

MOVBQZX: Move with Zero-Extend.

Forms:

MOVBQZX r8 r64
MOVBQZX m8 r64

func MOVBWSX ¶

func MOVBWSX(mr, r operand.Op) (*intrep.Instruction, error)

MOVBWSX: Move with Sign-Extension.

Forms:

MOVBWSX r8 r16
MOVBWSX m8 r16

func MOVBWZX ¶

func MOVBWZX(mr, r operand.Op) (*intrep.Instruction, error)

MOVBWZX: Move with Zero-Extend.

Forms:

MOVBWZX r8 r16
MOVBWZX m8 r16

func MOVD ¶

func MOVD(imrx, mrx operand.Op) (*intrep.Instruction, error)

MOVD: Move.

Forms:

MOVD imm32 r64
MOVD imm64 r64
MOVD r64   r64
MOVD m64   r64
MOVD imm32 m64
MOVD r64   m64
MOVD xmm   r64
MOVD r64   xmm
MOVD xmm   xmm
MOVD m64   xmm
MOVD xmm   m64
MOVD xmm   r32
MOVD r32   xmm
MOVD m32   xmm
MOVD xmm   m32

func MOVDDUP ¶

func MOVDDUP(mx, x operand.Op) (*intrep.Instruction, error)

MOVDDUP: Move One Double-FP and Duplicate.

Forms:

MOVDDUP xmm xmm
MOVDDUP m64 xmm

func MOVDQ2Q ¶

func MOVDQ2Q(imrx, mrx operand.Op) (*intrep.Instruction, error)

MOVDQ2Q: Move.

Forms:

MOVDQ2Q imm32 r64
MOVDQ2Q imm64 r64
MOVDQ2Q r64   r64
MOVDQ2Q m64   r64
MOVDQ2Q imm32 m64
MOVDQ2Q r64   m64
MOVDQ2Q xmm   r64
MOVDQ2Q r64   xmm
MOVDQ2Q xmm   xmm
MOVDQ2Q m64   xmm
MOVDQ2Q xmm   m64
MOVDQ2Q xmm   r32
MOVDQ2Q r32   xmm
MOVDQ2Q m32   xmm
MOVDQ2Q xmm   m32

func MOVHLPS ¶

func MOVHLPS(x, x1 operand.Op) (*intrep.Instruction, error)

MOVHLPS: Move Packed Single-Precision Floating-Point Values High to Low.

Forms:

MOVHLPS xmm xmm

func MOVHPD ¶

func MOVHPD(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVHPD: Move High Packed Double-Precision Floating-Point Value.

Forms:

MOVHPD m64 xmm
MOVHPD xmm m64

func MOVHPS ¶

func MOVHPS(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVHPS: Move High Packed Single-Precision Floating-Point Values.

Forms:

MOVHPS m64 xmm
MOVHPS xmm m64

func MOVL ¶

func MOVL(imr, mr operand.Op) (*intrep.Instruction, error)

MOVL: Move.

Forms:

MOVL imm32 r32
MOVL r32   r32
MOVL m32   r32
MOVL imm32 m32
MOVL r32   m32

func MOVLHPS ¶

func MOVLHPS(x, x1 operand.Op) (*intrep.Instruction, error)

MOVLHPS: Move Packed Single-Precision Floating-Point Values Low to High.

Forms:

MOVLHPS xmm xmm

func MOVLPD ¶

func MOVLPD(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVLPD: Move Low Packed Double-Precision Floating-Point Value.

Forms:

MOVLPD m64 xmm
MOVLPD xmm m64

func MOVLPS ¶

func MOVLPS(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVLPS: Move Low Packed Single-Precision Floating-Point Values.

Forms:

MOVLPS m64 xmm
MOVLPS xmm m64

func MOVLQSX ¶

func MOVLQSX(mr, r operand.Op) (*intrep.Instruction, error)

MOVLQSX: Move Doubleword to Quadword with Sign-Extension.

Forms:

MOVLQSX r32 r64
MOVLQSX m32 r64

func MOVLQZX ¶

func MOVLQZX(m, r operand.Op) (*intrep.Instruction, error)

MOVLQZX: Move with Zero-Extend.

Forms:

MOVLQZX m32 r64

func MOVMSKPD ¶

func MOVMSKPD(x, r operand.Op) (*intrep.Instruction, error)

MOVMSKPD: Extract Packed Double-Precision Floating-Point Sign Mask.

Forms:

MOVMSKPD xmm r32

func MOVMSKPS ¶

func MOVMSKPS(x, r operand.Op) (*intrep.Instruction, error)

MOVMSKPS: Extract Packed Single-Precision Floating-Point Sign Mask.

Forms:

MOVMSKPS xmm r32

func MOVNTDQ ¶

func MOVNTDQ(x, m operand.Op) (*intrep.Instruction, error)

MOVNTDQ: Store Double Quadword Using Non-Temporal Hint.

Forms:

MOVNTDQ xmm m128

func MOVNTDQA ¶

func MOVNTDQA(m, x operand.Op) (*intrep.Instruction, error)

MOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint.

Forms:

MOVNTDQA m128 xmm

func MOVNTIL ¶

func MOVNTIL(r, m operand.Op) (*intrep.Instruction, error)

MOVNTIL: Store Doubleword Using Non-Temporal Hint.

Forms:

MOVNTIL r32 m32

func MOVNTIQ ¶

func MOVNTIQ(r, m operand.Op) (*intrep.Instruction, error)

MOVNTIQ: Store Doubleword Using Non-Temporal Hint.

Forms:

MOVNTIQ r64 m64

func MOVNTO ¶

func MOVNTO(x, m operand.Op) (*intrep.Instruction, error)

MOVNTO: Store Double Quadword Using Non-Temporal Hint.

Forms:

MOVNTO xmm m128

func MOVNTPD ¶

func MOVNTPD(x, m operand.Op) (*intrep.Instruction, error)

MOVNTPD: Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint.

Forms:

MOVNTPD xmm m128

func MOVNTPS ¶

func MOVNTPS(x, m operand.Op) (*intrep.Instruction, error)

MOVNTPS: Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint.

Forms:

MOVNTPS xmm m128

func MOVO ¶

func MOVO(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVO: Move Aligned Double Quadword.

Forms:

MOVO xmm  xmm
MOVO m128 xmm
MOVO xmm  m128

func MOVOA ¶

func MOVOA(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVOA: Move Aligned Double Quadword.

Forms:

MOVOA xmm  xmm
MOVOA m128 xmm
MOVOA xmm  m128

func MOVOU ¶

func MOVOU(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVOU: Move Unaligned Double Quadword.

Forms:

MOVOU xmm  xmm
MOVOU m128 xmm
MOVOU xmm  m128

func MOVQ ¶

func MOVQ(imrx, mrx operand.Op) (*intrep.Instruction, error)

MOVQ: Move.

Forms:

MOVQ imm32 r64
MOVQ imm64 r64
MOVQ r64   r64
MOVQ m64   r64
MOVQ imm32 m64
MOVQ r64   m64
MOVQ xmm   r64
MOVQ r64   xmm
MOVQ xmm   xmm
MOVQ m64   xmm
MOVQ xmm   m64
MOVQ xmm   r32
MOVQ r32   xmm
MOVQ m32   xmm
MOVQ xmm   m32

func MOVSD ¶

func MOVSD(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVSD: Move Scalar Double-Precision Floating-Point Value.

Forms:

MOVSD xmm xmm
MOVSD m64 xmm
MOVSD xmm m64

func MOVSHDUP ¶

func MOVSHDUP(mx, x operand.Op) (*intrep.Instruction, error)

MOVSHDUP: Move Packed Single-FP High and Duplicate.

Forms:

MOVSHDUP xmm  xmm
MOVSHDUP m128 xmm

func MOVSLDUP ¶

func MOVSLDUP(mx, x operand.Op) (*intrep.Instruction, error)

MOVSLDUP: Move Packed Single-FP Low and Duplicate.

Forms:

MOVSLDUP xmm  xmm
MOVSLDUP m128 xmm

func MOVSS ¶

func MOVSS(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVSS: Move Scalar Single-Precision Floating-Point Values.

Forms:

MOVSS xmm xmm
MOVSS m32 xmm
MOVSS xmm m32

func MOVUPD ¶

func MOVUPD(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVUPD: Move Unaligned Packed Double-Precision Floating-Point Values.

Forms:

MOVUPD xmm  xmm
MOVUPD m128 xmm
MOVUPD xmm  m128

func MOVUPS ¶

func MOVUPS(mx, mx1 operand.Op) (*intrep.Instruction, error)

MOVUPS: Move Unaligned Packed Single-Precision Floating-Point Values.

Forms:

MOVUPS xmm  xmm
MOVUPS m128 xmm
MOVUPS xmm  m128

func MOVW ¶

func MOVW(imr, mr operand.Op) (*intrep.Instruction, error)

MOVW: Move.

Forms:

MOVW imm16 r16
MOVW r16   r16
MOVW m16   r16
MOVW imm16 m16
MOVW r16   m16

func MOVWLSX ¶

func MOVWLSX(mr, r operand.Op) (*intrep.Instruction, error)

MOVWLSX: Move with Sign-Extension.

Forms:

MOVWLSX r16 r32
MOVWLSX m16 r32

func MOVWLZX ¶

func MOVWLZX(mr, r operand.Op) (*intrep.Instruction, error)

MOVWLZX: Move with Zero-Extend.

Forms:

MOVWLZX r16 r32
MOVWLZX m16 r32

func MOVWQSX ¶

func MOVWQSX(mr, r operand.Op) (*intrep.Instruction, error)

MOVWQSX: Move with Sign-Extension.

Forms:

MOVWQSX r16 r64
MOVWQSX m16 r64

func MOVWQZX ¶

func MOVWQZX(mr, r operand.Op) (*intrep.Instruction, error)

MOVWQZX: Move with Zero-Extend.

Forms:

MOVWQZX r16 r64
MOVWQZX m16 r64

func MPSADBW ¶

func MPSADBW(i, mx, x operand.Op) (*intrep.Instruction, error)

MPSADBW: Compute Multiple Packed Sums of Absolute Difference.

Forms:

MPSADBW imm8 xmm  xmm
MPSADBW imm8 m128 xmm

func MULB ¶

func MULB(mr operand.Op) (*intrep.Instruction, error)

MULB: Unsigned Multiply.

Forms:

MULB r8
MULB m8

func MULL ¶

func MULL(mr operand.Op) (*intrep.Instruction, error)

MULL: Unsigned Multiply.

Forms:

MULL r32
MULL m32

func MULPD ¶

func MULPD(mx, x operand.Op) (*intrep.Instruction, error)

MULPD: Multiply Packed Double-Precision Floating-Point Values.

Forms:

MULPD xmm  xmm
MULPD m128 xmm

func MULPS ¶

func MULPS(mx, x operand.Op) (*intrep.Instruction, error)

MULPS: Multiply Packed Single-Precision Floating-Point Values.

Forms:

MULPS xmm  xmm
MULPS m128 xmm

func MULQ ¶

func MULQ(mr operand.Op) (*intrep.Instruction, error)

MULQ: Unsigned Multiply.

Forms:

MULQ r64
MULQ m64

func MULSD ¶

func MULSD(mx, x operand.Op) (*intrep.Instruction, error)

MULSD: Multiply Scalar Double-Precision Floating-Point Values.

Forms:

MULSD xmm xmm
MULSD m64 xmm

func MULSS ¶

func MULSS(mx, x operand.Op) (*intrep.Instruction, error)

MULSS: Multiply Scalar Single-Precision Floating-Point Values.

Forms:

MULSS xmm xmm
MULSS m32 xmm

func MULW ¶

func MULW(mr operand.Op) (*intrep.Instruction, error)

MULW: Unsigned Multiply.

Forms:

MULW r16
MULW m16

func MULXL ¶

func MULXL(mr, r, r1 operand.Op) (*intrep.Instruction, error)

MULXL: Unsigned Multiply Without Affecting Flags.

Forms:

MULXL r32 r32 r32
MULXL m32 r32 r32

func MULXQ ¶

func MULXQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)

MULXQ: Unsigned Multiply Without Affecting Flags.

Forms:

MULXQ r64 r64 r64
MULXQ m64 r64 r64

func MWAIT ¶

func MWAIT() (*intrep.Instruction, error)

MWAIT: Monitor Wait.

Forms:

MWAIT

func NEGB ¶

func NEGB(mr operand.Op) (*intrep.Instruction, error)

NEGB: Two's Complement Negation.

Forms:

NEGB r8
NEGB m8

func NEGL ¶

func NEGL(mr operand.Op) (*intrep.Instruction, error)

NEGL: Two's Complement Negation.

Forms:

NEGL r32
NEGL m32

func NEGQ ¶

func NEGQ(mr operand.Op) (*intrep.Instruction, error)

NEGQ: Two's Complement Negation.

Forms:

NEGQ r64
NEGQ m64

func NEGW ¶

func NEGW(mr operand.Op) (*intrep.Instruction, error)

NEGW: Two's Complement Negation.

Forms:

NEGW r16
NEGW m16

func NOP ¶

func NOP() (*intrep.Instruction, error)

NOP: No Operation.

Forms:

NOP

func NOTB ¶

func NOTB(mr operand.Op) (*intrep.Instruction, error)

NOTB: One's Complement Negation.

Forms:

NOTB r8
NOTB m8

func NOTL ¶

func NOTL(mr operand.Op) (*intrep.Instruction, error)

NOTL: One's Complement Negation.

Forms:

NOTL r32
NOTL m32

func NOTQ ¶

func NOTQ(mr operand.Op) (*intrep.Instruction, error)

NOTQ: One's Complement Negation.

Forms:

NOTQ r64
NOTQ m64

func NOTW ¶

func NOTW(mr operand.Op) (*intrep.Instruction, error)

NOTW: One's Complement Negation.

Forms:

NOTW r16
NOTW m16

func ORB ¶

func ORB(imr, amr operand.Op) (*intrep.Instruction, error)

ORB: Logical Inclusive OR.

Forms:

ORB imm8 al
ORB imm8 r8
ORB r8   r8
ORB m8   r8
ORB imm8 m8
ORB r8   m8

func ORL ¶

func ORL(imr, emr operand.Op) (*intrep.Instruction, error)

ORL: Logical Inclusive OR.

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 ORPD ¶

func ORPD(mx, x operand.Op) (*intrep.Instruction, error)

ORPD: Bitwise Logical OR of Double-Precision Floating-Point Values.

Forms:

ORPD xmm  xmm
ORPD m128 xmm

func ORPS ¶

func ORPS(mx, x operand.Op) (*intrep.Instruction, error)

ORPS: Bitwise Logical OR of Single-Precision Floating-Point Values.

Forms:

ORPS xmm  xmm
ORPS m128 xmm

func ORQ ¶

func ORQ(imr, mr operand.Op) (*intrep.Instruction, error)

ORQ: Logical Inclusive OR.

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 ORW ¶

func ORW(imr, amr operand.Op) (*intrep.Instruction, error)

ORW: Logical Inclusive OR.

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 PABSB ¶

func PABSB(mx, x operand.Op) (*intrep.Instruction, error)

PABSB: Packed Absolute Value of Byte Integers.

Forms:

PABSB xmm  xmm
PABSB m128 xmm

func PABSD ¶

func PABSD(mx, x operand.Op) (*intrep.Instruction, error)

PABSD: Packed Absolute Value of Doubleword Integers.

Forms:

PABSD xmm  xmm
PABSD m128 xmm

func PABSW ¶

func PABSW(mx, x operand.Op) (*intrep.Instruction, error)

PABSW: Packed Absolute Value of Word Integers.

Forms:

PABSW xmm  xmm
PABSW m128 xmm

func PACKSSLW ¶

func PACKSSLW(mx, x operand.Op) (*intrep.Instruction, error)

PACKSSLW: Pack Doublewords into Words with Signed Saturation.

Forms:

PACKSSLW xmm  xmm
PACKSSLW m128 xmm

func PACKSSWB ¶

func PACKSSWB(mx, x operand.Op) (*intrep.Instruction, error)

PACKSSWB: Pack Words into Bytes with Signed Saturation.

Forms:

PACKSSWB xmm  xmm
PACKSSWB m128 xmm

func PACKUSDW ¶

func PACKUSDW(mx, x operand.Op) (*intrep.Instruction, error)

PACKUSDW: Pack Doublewords into Words with Unsigned Saturation.

Forms:

PACKUSDW xmm  xmm
PACKUSDW m128 xmm

func PACKUSWB ¶

func PACKUSWB(mx, x operand.Op) (*intrep.Instruction, error)

PACKUSWB: Pack Words into Bytes with Unsigned Saturation.

Forms:

PACKUSWB xmm  xmm
PACKUSWB m128 xmm

func PADDB ¶

func PADDB(mx, x operand.Op) (*intrep.Instruction, error)

PADDB: Add Packed Byte Integers.

Forms:

PADDB xmm  xmm
PADDB m128 xmm

func PADDD ¶

func PADDD(mx, x operand.Op) (*intrep.Instruction, error)

PADDD: Add Packed Doubleword Integers.

Forms:

PADDD xmm  xmm
PADDD m128 xmm

func PADDL ¶

func PADDL(mx, x operand.Op) (*intrep.Instruction, error)

PADDL: Add Packed Doubleword Integers.

Forms:

PADDL xmm  xmm
PADDL m128 xmm

func PADDQ ¶

func PADDQ(mx, x operand.Op) (*intrep.Instruction, error)

PADDQ: Add Packed Quadword Integers.

Forms:

PADDQ xmm  xmm
PADDQ m128 xmm

func PADDSB ¶

func PADDSB(mx, x operand.Op) (*intrep.Instruction, error)

PADDSB: Add Packed Signed Byte Integers with Signed Saturation.

Forms:

PADDSB xmm  xmm
PADDSB m128 xmm

func PADDSW ¶

func PADDSW(mx, x operand.Op) (*intrep.Instruction, error)

PADDSW: Add Packed Signed Word Integers with Signed Saturation.

Forms:

PADDSW xmm  xmm
PADDSW m128 xmm

func PADDUSB ¶

func PADDUSB(mx, x operand.Op) (*intrep.Instruction, error)

PADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

PADDUSB xmm  xmm
PADDUSB m128 xmm

func PADDUSW ¶

func PADDUSW(mx, x operand.Op) (*intrep.Instruction, error)

PADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

PADDUSW xmm  xmm
PADDUSW m128 xmm

func PADDW ¶

func PADDW(mx, x operand.Op) (*intrep.Instruction, error)

PADDW: Add Packed Word Integers.

Forms:

PADDW xmm  xmm
PADDW m128 xmm

func PALIGNR ¶

func PALIGNR(i, mx, x operand.Op) (*intrep.Instruction, error)

PALIGNR: Packed Align Right.

Forms:

PALIGNR imm8 xmm  xmm
PALIGNR imm8 m128 xmm

func PAND ¶

func PAND(mx, x operand.Op) (*intrep.Instruction, error)

PAND: Packed Bitwise Logical AND.

Forms:

PAND xmm  xmm
PAND m128 xmm

func PANDN ¶

func PANDN(mx, x operand.Op) (*intrep.Instruction, error)

PANDN: Packed Bitwise Logical AND NOT.

Forms:

PANDN xmm  xmm
PANDN m128 xmm

func PAUSE ¶

func PAUSE() (*intrep.Instruction, error)

PAUSE: Spin Loop Hint.

Forms:

PAUSE

func PAVGB ¶

func PAVGB(mx, x operand.Op) (*intrep.Instruction, error)

PAVGB: Average Packed Byte Integers.

Forms:

PAVGB xmm  xmm
PAVGB m128 xmm

func PAVGW ¶

func PAVGW(mx, x operand.Op) (*intrep.Instruction, error)

PAVGW: Average Packed Word Integers.

Forms:

PAVGW xmm  xmm
PAVGW m128 xmm

func PBLENDVB ¶

func PBLENDVB(x, mx, x1 operand.Op) (*intrep.Instruction, error)

PBLENDVB: Variable Blend Packed Bytes.

Forms:

PBLENDVB xmm0 xmm  xmm
PBLENDVB xmm0 m128 xmm

func PBLENDW ¶

func PBLENDW(i, mx, x operand.Op) (*intrep.Instruction, error)

PBLENDW: Blend Packed Words.

Forms:

PBLENDW imm8 xmm  xmm
PBLENDW imm8 m128 xmm

func PCLMULQDQ ¶

func PCLMULQDQ(i, mx, x operand.Op) (*intrep.Instruction, error)

PCLMULQDQ: Carry-Less Quadword Multiplication.

Forms:

PCLMULQDQ imm8 xmm  xmm
PCLMULQDQ imm8 m128 xmm

func PCMPEQB ¶

func PCMPEQB(mx, x operand.Op) (*intrep.Instruction, error)

PCMPEQB: Compare Packed Byte Data for Equality.

Forms:

PCMPEQB xmm  xmm
PCMPEQB m128 xmm

func PCMPEQL ¶

func PCMPEQL(mx, x operand.Op) (*intrep.Instruction, error)

PCMPEQL: Compare Packed Doubleword Data for Equality.

Forms:

PCMPEQL xmm  xmm
PCMPEQL m128 xmm

func PCMPEQQ ¶

func PCMPEQQ(mx, x operand.Op) (*intrep.Instruction, error)

PCMPEQQ: Compare Packed Quadword Data for Equality.

Forms:

PCMPEQQ xmm  xmm
PCMPEQQ m128 xmm

func PCMPEQW ¶

func PCMPEQW(mx, x operand.Op) (*intrep.Instruction, error)

PCMPEQW: Compare Packed Word Data for Equality.

Forms:

PCMPEQW xmm  xmm
PCMPEQW m128 xmm

func PCMPESTRI ¶

func PCMPESTRI(i, mx, x operand.Op) (*intrep.Instruction, error)

PCMPESTRI: Packed Compare Explicit Length Strings, Return Index.

Forms:

PCMPESTRI imm8 xmm  xmm
PCMPESTRI imm8 m128 xmm

func PCMPESTRM ¶

func PCMPESTRM(i, mx, x operand.Op) (*intrep.Instruction, error)

PCMPESTRM: Packed Compare Explicit Length Strings, Return Mask.

Forms:

PCMPESTRM imm8 xmm  xmm
PCMPESTRM imm8 m128 xmm

func PCMPGTB ¶

func PCMPGTB(mx, x operand.Op) (*intrep.Instruction, error)

PCMPGTB: Compare Packed Signed Byte Integers for Greater Than.

Forms:

PCMPGTB xmm  xmm
PCMPGTB m128 xmm

func PCMPGTL ¶

func PCMPGTL(mx, x operand.Op) (*intrep.Instruction, error)

PCMPGTL: Compare Packed Signed Doubleword Integers for Greater Than.

Forms:

PCMPGTL xmm  xmm
PCMPGTL m128 xmm

func PCMPGTQ ¶

func PCMPGTQ(mx, x operand.Op) (*intrep.Instruction, error)

PCMPGTQ: Compare Packed Data for Greater Than.

Forms:

PCMPGTQ xmm  xmm
PCMPGTQ m128 xmm

func PCMPGTW ¶

func PCMPGTW(mx, x operand.Op) (*intrep.Instruction, error)

PCMPGTW: Compare Packed Signed Word Integers for Greater Than.

Forms:

PCMPGTW xmm  xmm
PCMPGTW m128 xmm

func PCMPISTRI ¶

func PCMPISTRI(i, mx, x operand.Op) (*intrep.Instruction, error)

PCMPISTRI: Packed Compare Implicit Length Strings, Return Index.

Forms:

PCMPISTRI imm8 xmm  xmm
PCMPISTRI imm8 m128 xmm

func PCMPISTRM ¶

func PCMPISTRM(i, mx, x operand.Op) (*intrep.Instruction, error)

PCMPISTRM: Packed Compare Implicit Length Strings, Return Mask.

Forms:

PCMPISTRM imm8 xmm  xmm
PCMPISTRM imm8 m128 xmm

func PDEPL ¶

func PDEPL(mr, r, r1 operand.Op) (*intrep.Instruction, error)

PDEPL: Parallel Bits Deposit.

Forms:

PDEPL r32 r32 r32
PDEPL m32 r32 r32

func PDEPQ ¶

func PDEPQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)

PDEPQ: Parallel Bits Deposit.

Forms:

PDEPQ r64 r64 r64
PDEPQ m64 r64 r64

func PEXTL ¶

func PEXTL(mr, r, r1 operand.Op) (*intrep.Instruction, error)

PEXTL: Parallel Bits Extract.

Forms:

PEXTL r32 r32 r32
PEXTL m32 r32 r32

func PEXTQ ¶

func PEXTQ(mr, r, r1 operand.Op) (*intrep.Instruction, error)

PEXTQ: Parallel Bits Extract.

Forms:

PEXTQ r64 r64 r64
PEXTQ m64 r64 r64

func PEXTRB ¶

func PEXTRB(i, x, mr operand.Op) (*intrep.Instruction, error)

PEXTRB: Extract Byte.

Forms:

PEXTRB imm8 xmm r32
PEXTRB imm8 xmm m8

func PEXTRD ¶

func PEXTRD(i, x, mr operand.Op) (*intrep.Instruction, error)

PEXTRD: Extract Doubleword.

Forms:

PEXTRD imm8 xmm r32
PEXTRD imm8 xmm m32

func PEXTRQ ¶

func PEXTRQ(i, x, mr operand.Op) (*intrep.Instruction, error)

PEXTRQ: Extract Quadword.

Forms:

PEXTRQ imm8 xmm r64
PEXTRQ imm8 xmm m64

func PEXTRW ¶

func PEXTRW(i, x, mr operand.Op) (*intrep.Instruction, error)

PEXTRW: Extract Word.

Forms:

PEXTRW imm8 xmm r32
PEXTRW imm8 xmm m16

func PHADDD ¶

func PHADDD(mx, x operand.Op) (*intrep.Instruction, error)

PHADDD: Packed Horizontal Add Doubleword Integer.

Forms:

PHADDD xmm  xmm
PHADDD m128 xmm

func PHADDSW ¶

func PHADDSW(mx, x operand.Op) (*intrep.Instruction, error)

PHADDSW: Packed Horizontal Add Signed Word Integers with Signed Saturation.

Forms:

PHADDSW xmm  xmm
PHADDSW m128 xmm

func PHADDW ¶

func PHADDW(mx, x operand.Op) (*intrep.Instruction, error)

PHADDW: Packed Horizontal Add Word Integers.

Forms:

PHADDW xmm  xmm
PHADDW m128 xmm

func PHMINPOSUW ¶

func PHMINPOSUW(mx, x operand.Op) (*intrep.Instruction, error)

PHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers.

Forms:

PHMINPOSUW xmm  xmm
PHMINPOSUW m128 xmm

func PHSUBD ¶

func PHSUBD(mx, x operand.Op) (*intrep.Instruction, error)

PHSUBD: Packed Horizontal Subtract Doubleword Integers.

Forms:

PHSUBD xmm  xmm
PHSUBD m128 xmm

func PHSUBSW ¶

func PHSUBSW(mx, x operand.Op) (*intrep.Instruction, error)

PHSUBSW: Packed Horizontal Subtract Signed Word Integers with Signed Saturation.

Forms:

PHSUBSW xmm  xmm
PHSUBSW m128 xmm

func PHSUBW ¶

func PHSUBW(mx, x operand.Op) (*intrep.Instruction, error)

PHSUBW: Packed Horizontal Subtract Word Integers.

Forms:

PHSUBW xmm  xmm
PHSUBW m128 xmm

func PINSRB ¶

func PINSRB(i, mr, x operand.Op) (*intrep.Instruction, error)

PINSRB: Insert Byte.

Forms:

PINSRB imm8 r32 xmm
PINSRB imm8 m8  xmm

func PINSRD ¶

func PINSRD(i, mr, x operand.Op) (*intrep.Instruction, error)

PINSRD: Insert Doubleword.

Forms:

PINSRD imm8 r32 xmm
PINSRD imm8 m32 xmm

func PINSRQ ¶

func PINSRQ(i, mr, x operand.Op) (*intrep.Instruction, error)

PINSRQ: Insert Quadword.

Forms:

PINSRQ imm8 r64 xmm
PINSRQ imm8 m64 xmm

func PINSRW ¶

func PINSRW(i, mr, x operand.Op) (*intrep.Instruction, error)

PINSRW: Insert Word.

Forms:

PINSRW imm8 r32 xmm
PINSRW imm8 m16 xmm

func PMADDUBSW ¶

func PMADDUBSW(mx, x operand.Op) (*intrep.Instruction, error)

PMADDUBSW: Multiply and Add Packed Signed and Unsigned Byte Integers.

Forms:

PMADDUBSW xmm  xmm
PMADDUBSW m128 xmm

func PMADDWL ¶

func PMADDWL(mx, x operand.Op) (*intrep.Instruction, error)

PMADDWL: Multiply and Add Packed Signed Word Integers.

Forms:

PMADDWL xmm  xmm
PMADDWL m128 xmm

func PMAXSB ¶

func PMAXSB(mx, x operand.Op) (*intrep.Instruction, error)

PMAXSB: Maximum of Packed Signed Byte Integers.

Forms:

PMAXSB xmm  xmm
PMAXSB m128 xmm

func PMAXSD ¶

func PMAXSD(mx, x operand.Op) (*intrep.Instruction, error)

PMAXSD: Maximum of Packed Signed Doubleword Integers.

Forms:

PMAXSD xmm  xmm
PMAXSD m128 xmm

func PMAXSW ¶

func PMAXSW(mx, x operand.Op) (*intrep.Instruction, error)

PMAXSW: Maximum of Packed Signed Word Integers.

Forms:

PMAXSW xmm  xmm
PMAXSW m128 xmm

func PMAXUB ¶

func PMAXUB(mx, x operand.Op) (*intrep.Instruction, error)

PMAXUB: Maximum of Packed Unsigned Byte Integers.

Forms:

PMAXUB xmm  xmm
PMAXUB m128 xmm

func PMAXUD ¶

func PMAXUD(mx, x operand.Op) (*intrep.Instruction, error)

PMAXUD: Maximum of Packed Unsigned Doubleword Integers.

Forms:

PMAXUD xmm  xmm
PMAXUD m128 xmm

func PMAXUW ¶

func PMAXUW(mx, x operand.Op) (*intrep.Instruction, error)

PMAXUW: Maximum of Packed Unsigned Word Integers.

Forms:

PMAXUW xmm  xmm
PMAXUW m128 xmm

func PMINSB ¶

func PMINSB(mx, x operand.Op) (*intrep.Instruction, error)

PMINSB: Minimum of Packed Signed Byte Integers.

Forms:

PMINSB xmm  xmm
PMINSB m128 xmm

func PMINSD ¶

func PMINSD(mx, x operand.Op) (*intrep.Instruction, error)

PMINSD: Minimum of Packed Signed Doubleword Integers.

Forms:

PMINSD xmm  xmm
PMINSD m128 xmm

func PMINSW ¶

func PMINSW(mx, x operand.Op) (*intrep.Instruction, error)

PMINSW: Minimum of Packed Signed Word Integers.

Forms:

PMINSW xmm  xmm
PMINSW m128 xmm

func PMINUB ¶

func PMINUB(mx, x operand.Op) (*intrep.Instruction, error)

PMINUB: Minimum of Packed Unsigned Byte Integers.

Forms:

PMINUB xmm  xmm
PMINUB m128 xmm

func PMINUD ¶

func PMINUD(mx, x operand.Op) (*intrep.Instruction, error)

PMINUD: Minimum of Packed Unsigned Doubleword Integers.

Forms:

PMINUD xmm  xmm
PMINUD m128 xmm

func PMINUW ¶

func PMINUW(mx, x operand.Op) (*intrep.Instruction, error)

PMINUW: Minimum of Packed Unsigned Word Integers.

Forms:

PMINUW xmm  xmm
PMINUW m128 xmm

func PMOVMSKB ¶

func PMOVMSKB(x, r operand.Op) (*intrep.Instruction, error)

PMOVMSKB: Move Byte Mask.

Forms:

PMOVMSKB xmm r32

func PMOVSXBD ¶

func PMOVSXBD(mx, x operand.Op) (*intrep.Instruction, error)

PMOVSXBD: Move Packed Byte Integers to Doubleword Integers with Sign Extension.

Forms:

PMOVSXBD xmm xmm
PMOVSXBD m32 xmm

func PMOVSXBQ ¶

func PMOVSXBQ(mx, x operand.Op) (*intrep.Instruction, error)

PMOVSXBQ: Move Packed Byte Integers to Quadword Integers with Sign Extension.

Forms:

PMOVSXBQ xmm xmm
PMOVSXBQ m16 xmm

func PMOVSXBW ¶

func PMOVSXBW(mx, x operand.Op) (*intrep.Instruction, error)

PMOVSXBW: Move Packed Byte Integers to Word Integers with Sign Extension.

Forms:

PMOVSXBW xmm xmm
PMOVSXBW m64 xmm

func PMOVSXDQ ¶

func PMOVSXDQ(mx, x operand.Op) (*intrep.Instruction, error)

PMOVSXDQ: Move Packed Doubleword Integers to Quadword Integers with Sign Extension.

Forms:

PMOVSXDQ xmm xmm
PMOVSXDQ m64 xmm

func PMOVSXWD ¶

func PMOVSXWD(mx, x operand.Op) (*intrep.Instruction, error)

PMOVSXWD: Move Packed Word Integers to Doubleword Integers with Sign Extension.

Forms:

PMOVSXWD xmm xmm
PMOVSXWD m64 xmm

func PMOVSXWQ ¶

func PMOVSXWQ(mx, x operand.Op) (*intrep.Instruction, error)

PMOVSXWQ: Move Packed Word Integers to Quadword Integers with Sign Extension.

Forms:

PMOVSXWQ xmm xmm
PMOVSXWQ m32 xmm

func PMOVZXBD ¶

func PMOVZXBD(mx, x operand.Op) (*intrep.Instruction, error)

PMOVZXBD: Move Packed Byte Integers to Doubleword Integers with Zero Extension.

Forms:

PMOVZXBD xmm xmm
PMOVZXBD m32 xmm

func PMOVZXBQ ¶

func PMOVZXBQ(mx, x operand.Op) (*intrep.Instruction, error)

PMOVZXBQ: Move Packed Byte Integers to Quadword Integers with Zero Extension.

Forms:

PMOVZXBQ xmm xmm
PMOVZXBQ m16 xmm

func PMOVZXBW ¶

func PMOVZXBW(mx, x operand.Op) (*intrep.Instruction, error)

PMOVZXBW: Move Packed Byte Integers to Word Integers with Zero Extension.

Forms:

PMOVZXBW xmm xmm
PMOVZXBW m64 xmm

func PMOVZXDQ ¶

func PMOVZXDQ(mx, x operand.Op) (*intrep.Instruction, error)

PMOVZXDQ: Move Packed Doubleword Integers to Quadword Integers with Zero Extension.

Forms:

PMOVZXDQ xmm xmm
PMOVZXDQ m64 xmm

func PMOVZXWD ¶

func PMOVZXWD(mx, x operand.Op) (*intrep.Instruction, error)

PMOVZXWD: Move Packed Word Integers to Doubleword Integers with Zero Extension.

Forms:

PMOVZXWD xmm xmm
PMOVZXWD m64 xmm

func PMOVZXWQ ¶

func PMOVZXWQ(mx, x operand.Op) (*intrep.Instruction, error)

PMOVZXWQ: Move Packed Word Integers to Quadword Integers with Zero Extension.

Forms:

PMOVZXWQ xmm xmm
PMOVZXWQ m32 xmm

func PMULDQ ¶

func PMULDQ(mx, x operand.Op) (*intrep.Instruction, error)

PMULDQ: Multiply Packed Signed Doubleword Integers and Store Quadword Result.

Forms:

PMULDQ xmm  xmm
PMULDQ m128 xmm

func PMULHRSW ¶

func PMULHRSW(mx, x operand.Op) (*intrep.Instruction, error)

PMULHRSW: Packed Multiply Signed Word Integers and Store High Result with Round and Scale.

Forms:

PMULHRSW xmm  xmm
PMULHRSW m128 xmm

func PMULHUW ¶

func PMULHUW(mx, x operand.Op) (*intrep.Instruction, error)

PMULHUW: Multiply Packed Unsigned Word Integers and Store High Result.

Forms:

PMULHUW xmm  xmm
PMULHUW m128 xmm

func PMULHW ¶

func PMULHW(mx, x operand.Op) (*intrep.Instruction, error)

PMULHW: Multiply Packed Signed Word Integers and Store High Result.

Forms:

PMULHW xmm  xmm
PMULHW m128 xmm

func PMULLD ¶

func PMULLD(mx, x operand.Op) (*intrep.Instruction, error)

PMULLD: Multiply Packed Signed Doubleword Integers and Store Low Result.

Forms:

PMULLD xmm  xmm
PMULLD m128 xmm

func PMULLW ¶

func PMULLW(mx, x operand.Op) (*intrep.Instruction, error)

PMULLW: Multiply Packed Signed Word Integers and Store Low Result.

Forms:

PMULLW xmm  xmm
PMULLW m128 xmm

func PMULULQ ¶

func PMULULQ(mx, x operand.Op) (*intrep.Instruction, error)

PMULULQ: Multiply Packed Unsigned Doubleword Integers.

Forms:

PMULULQ xmm  xmm
PMULULQ m128 xmm

func POPCNTL ¶

func POPCNTL(mr, r operand.Op) (*intrep.Instruction, error)

POPCNTL: Count of Number of Bits Set to 1.

Forms:

POPCNTL r32 r32
POPCNTL m32 r32

func POPCNTQ ¶

func POPCNTQ(mr, r operand.Op) (*intrep.Instruction, error)

POPCNTQ: Count of Number of Bits Set to 1.

Forms:

POPCNTQ r64 r64
POPCNTQ m64 r64

func POPCNTW ¶

func POPCNTW(mr, r operand.Op) (*intrep.Instruction, error)

POPCNTW: Count of Number of Bits Set to 1.

Forms:

POPCNTW r16 r16
POPCNTW m16 r16

func POPQ ¶

func POPQ(mr operand.Op) (*intrep.Instruction, error)

POPQ: Pop a Value from the Stack.

Forms:

POPQ r64
POPQ m64

func POPW ¶

func POPW(mr operand.Op) (*intrep.Instruction, error)

POPW: Pop a Value from the Stack.

Forms:

POPW r16
POPW m16

func POR ¶

func POR(mx, x operand.Op) (*intrep.Instruction, error)

POR: Packed Bitwise Logical OR.

Forms:

POR xmm  xmm
POR m128 xmm

func PREFETCHNTA ¶

func PREFETCHNTA(m operand.Op) (*intrep.Instruction, error)

PREFETCHNTA: Prefetch Data Into Caches using NTA Hint.

Forms:

PREFETCHNTA m8

func PREFETCHT0 ¶

func PREFETCHT0(m operand.Op) (*intrep.Instruction, error)

PREFETCHT0: Prefetch Data Into Caches using T0 Hint.

Forms:

PREFETCHT0 m8

func PREFETCHT1 ¶

func PREFETCHT1(m operand.Op) (*intrep.Instruction, error)

PREFETCHT1: Prefetch Data Into Caches using T1 Hint.

Forms:

PREFETCHT1 m8

func PREFETCHT2 ¶

func PREFETCHT2(m operand.Op) (*intrep.Instruction, error)

PREFETCHT2: Prefetch Data Into Caches using T2 Hint.

Forms:

PREFETCHT2 m8

func PSADBW ¶

func PSADBW(mx, x operand.Op) (*intrep.Instruction, error)

PSADBW: Compute Sum of Absolute Differences.

Forms:

PSADBW xmm  xmm
PSADBW m128 xmm

func PSHUFB ¶

func PSHUFB(mx, x operand.Op) (*intrep.Instruction, error)

PSHUFB: Packed Shuffle Bytes.

Forms:

PSHUFB xmm  xmm
PSHUFB m128 xmm

func PSHUFD ¶

func PSHUFD(i, mx, x operand.Op) (*intrep.Instruction, error)

PSHUFD: Shuffle Packed Doublewords.

Forms:

PSHUFD imm8 xmm  xmm
PSHUFD imm8 m128 xmm

func PSHUFHW ¶

func PSHUFHW(i, mx, x operand.Op) (*intrep.Instruction, error)

PSHUFHW: Shuffle Packed High Words.

Forms:

PSHUFHW imm8 xmm  xmm
PSHUFHW imm8 m128 xmm

func PSHUFL ¶

func PSHUFL(i, mx, x operand.Op) (*intrep.Instruction, error)

PSHUFL: Shuffle Packed Doublewords.

Forms:

PSHUFL imm8 xmm  xmm
PSHUFL imm8 m128 xmm

func PSHUFLW ¶

func PSHUFLW(i, mx, x operand.Op) (*intrep.Instruction, error)

PSHUFLW: Shuffle Packed Low Words.

Forms:

PSHUFLW imm8 xmm  xmm
PSHUFLW imm8 m128 xmm

func PSIGNB ¶

func PSIGNB(mx, x operand.Op) (*intrep.Instruction, error)

PSIGNB: Packed Sign of Byte Integers.

Forms:

PSIGNB xmm  xmm
PSIGNB m128 xmm

func PSIGND ¶

func PSIGND(mx, x operand.Op) (*intrep.Instruction, error)

PSIGND: Packed Sign of Doubleword Integers.

Forms:

PSIGND xmm  xmm
PSIGND m128 xmm

func PSIGNW ¶

func PSIGNW(mx, x operand.Op) (*intrep.Instruction, error)

PSIGNW: Packed Sign of Word Integers.

Forms:

PSIGNW xmm  xmm
PSIGNW m128 xmm

func PSLLDQ ¶

func PSLLDQ(i, x operand.Op) (*intrep.Instruction, error)

PSLLDQ: Shift Packed Double Quadword Left Logical.

Forms:

PSLLDQ imm8 xmm

func PSLLL ¶

func PSLLL(imx, x operand.Op) (*intrep.Instruction, error)

PSLLL: Shift Packed Doubleword Data Left Logical.

Forms:

PSLLL imm8 xmm
PSLLL xmm  xmm
PSLLL m128 xmm

func PSLLO ¶

func PSLLO(i, x operand.Op) (*intrep.Instruction, error)

PSLLO: Shift Packed Double Quadword Left Logical.

Forms:

PSLLO imm8 xmm

func PSLLQ ¶

func PSLLQ(imx, x operand.Op) (*intrep.Instruction, error)

PSLLQ: Shift Packed Quadword Data Left Logical.

Forms:

PSLLQ imm8 xmm
PSLLQ xmm  xmm
PSLLQ m128 xmm

func PSLLW ¶

func PSLLW(imx, x operand.Op) (*intrep.Instruction, error)

PSLLW: Shift Packed Word Data Left Logical.

Forms:

PSLLW imm8 xmm
PSLLW xmm  xmm
PSLLW m128 xmm

func PSRAL ¶

func PSRAL(imx, x operand.Op) (*intrep.Instruction, error)

PSRAL: Shift Packed Doubleword Data Right Arithmetic.

Forms:

PSRAL imm8 xmm
PSRAL xmm  xmm
PSRAL m128 xmm

func PSRAW ¶

func PSRAW(imx, x operand.Op) (*intrep.Instruction, error)

PSRAW: Shift Packed Word Data Right Arithmetic.

Forms:

PSRAW imm8 xmm
PSRAW xmm  xmm
PSRAW m128 xmm

func PSRLDQ ¶

func PSRLDQ(i, x operand.Op) (*intrep.Instruction, error)

PSRLDQ: Shift Packed Double Quadword Right Logical.

Forms:

PSRLDQ imm8 xmm

func PSRLL ¶

func PSRLL(imx, x operand.Op) (*intrep.Instruction, error)

PSRLL: Shift Packed Doubleword Data Right Logical.

Forms:

PSRLL imm8 xmm
PSRLL xmm  xmm
PSRLL m128 xmm

func PSRLO ¶

func PSRLO(i, x operand.Op) (*intrep.Instruction, error)

PSRLO: Shift Packed Double Quadword Right Logical.

Forms:

PSRLO imm8 xmm

func PSRLQ ¶

func PSRLQ(imx, x operand.Op) (*intrep.Instruction, error)

PSRLQ: Shift Packed Quadword Data Right Logical.

Forms:

PSRLQ imm8 xmm
PSRLQ xmm  xmm
PSRLQ m128 xmm

func PSRLW ¶

func PSRLW(imx, x operand.Op) (*intrep.Instruction, error)

PSRLW: Shift Packed Word Data Right Logical.

Forms:

PSRLW imm8 xmm
PSRLW xmm  xmm
PSRLW m128 xmm

func PSUBB ¶

func PSUBB(mx, x operand.Op) (*intrep.Instruction, error)

PSUBB: Subtract Packed Byte Integers.

Forms:

PSUBB xmm  xmm
PSUBB m128 xmm

func PSUBL ¶

func PSUBL(mx, x operand.Op) (*intrep.Instruction, error)

PSUBL: Subtract Packed Doubleword Integers.

Forms:

PSUBL xmm  xmm
PSUBL m128 xmm

func PSUBQ ¶

func PSUBQ(mx, x operand.Op) (*intrep.Instruction, error)

PSUBQ: Subtract Packed Quadword Integers.

Forms:

PSUBQ xmm  xmm
PSUBQ m128 xmm

func PSUBSB ¶

func PSUBSB(mx, x operand.Op) (*intrep.Instruction, error)

PSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation.

Forms:

PSUBSB xmm  xmm
PSUBSB m128 xmm

func PSUBSW ¶

func PSUBSW(mx, x operand.Op) (*intrep.Instruction, error)

PSUBSW: Subtract Packed Signed Word Integers with Signed Saturation.

Forms:

PSUBSW xmm  xmm
PSUBSW m128 xmm

func PSUBUSB ¶

func PSUBUSB(mx, x operand.Op) (*intrep.Instruction, error)

PSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

PSUBUSB xmm  xmm
PSUBUSB m128 xmm

func PSUBUSW ¶

func PSUBUSW(mx, x operand.Op) (*intrep.Instruction, error)

PSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

PSUBUSW xmm  xmm
PSUBUSW m128 xmm

func PSUBW ¶

func PSUBW(mx, x operand.Op) (*intrep.Instruction, error)

PSUBW: Subtract Packed Word Integers.

Forms:

PSUBW xmm  xmm
PSUBW m128 xmm

func PTEST ¶

func PTEST(mx, x operand.Op) (*intrep.Instruction, error)

PTEST: Packed Logical Compare.

Forms:

PTEST xmm  xmm
PTEST m128 xmm

func PUNPCKHBW ¶

func PUNPCKHBW(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKHBW: Unpack and Interleave High-Order Bytes into Words.

Forms:

PUNPCKHBW xmm  xmm
PUNPCKHBW m128 xmm

func PUNPCKHLQ ¶

func PUNPCKHLQ(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKHLQ: Unpack and Interleave High-Order Doublewords into Quadwords.

Forms:

PUNPCKHLQ xmm  xmm
PUNPCKHLQ m128 xmm

func PUNPCKHQDQ ¶

func PUNPCKHQDQ(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKHQDQ: Unpack and Interleave High-Order Quadwords into Double Quadwords.

Forms:

PUNPCKHQDQ xmm  xmm
PUNPCKHQDQ m128 xmm

func PUNPCKHWL ¶

func PUNPCKHWL(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKHWL: Unpack and Interleave High-Order Words into Doublewords.

Forms:

PUNPCKHWL xmm  xmm
PUNPCKHWL m128 xmm

func PUNPCKLBW ¶

func PUNPCKLBW(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKLBW: Unpack and Interleave Low-Order Bytes into Words.

Forms:

PUNPCKLBW xmm  xmm
PUNPCKLBW m128 xmm

func PUNPCKLLQ ¶

func PUNPCKLLQ(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKLLQ: Unpack and Interleave Low-Order Doublewords into Quadwords.

Forms:

PUNPCKLLQ xmm  xmm
PUNPCKLLQ m128 xmm

func PUNPCKLQDQ ¶

func PUNPCKLQDQ(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKLQDQ: Unpack and Interleave Low-Order Quadwords into Double Quadwords.

Forms:

PUNPCKLQDQ xmm  xmm
PUNPCKLQDQ m128 xmm

func PUNPCKLWL ¶

func PUNPCKLWL(mx, x operand.Op) (*intrep.Instruction, error)

PUNPCKLWL: Unpack and Interleave Low-Order Words into Doublewords.

Forms:

PUNPCKLWL xmm  xmm
PUNPCKLWL m128 xmm

func PUSHQ ¶

func PUSHQ(imr operand.Op) (*intrep.Instruction, error)

PUSHQ: Push Value Onto the Stack.

Forms:

PUSHQ imm8
PUSHQ imm32
PUSHQ r64
PUSHQ m64

func PUSHW ¶

func PUSHW(mr operand.Op) (*intrep.Instruction, error)

PUSHW: Push Value Onto the Stack.

Forms:

PUSHW r16
PUSHW m16

func PXOR ¶

func PXOR(mx, x operand.Op) (*intrep.Instruction, error)

PXOR: Packed Bitwise Logical Exclusive OR.

Forms:

PXOR xmm  xmm
PXOR m128 xmm

func RCLB ¶

func RCLB(ci, mr operand.Op) (*intrep.Instruction, error)

RCLB: Rotate Left through Carry Flag.

Forms:

RCLB 1    r8
RCLB imm8 r8
RCLB cl   r8
RCLB 1    m8
RCLB imm8 m8
RCLB cl   m8

func RCLL ¶

func RCLL(ci, mr operand.Op) (*intrep.Instruction, error)

RCLL: Rotate Left through Carry Flag.

Forms:

RCLL 1    r32
RCLL imm8 r32
RCLL cl   r32
RCLL 1    m32
RCLL imm8 m32
RCLL cl   m32

func RCLQ ¶

func RCLQ(ci, mr operand.Op) (*intrep.Instruction, error)

RCLQ: Rotate Left through Carry Flag.

Forms:

RCLQ 1    r64
RCLQ imm8 r64
RCLQ cl   r64
RCLQ 1    m64
RCLQ imm8 m64
RCLQ cl   m64

func RCLW ¶

func RCLW(ci, mr operand.Op) (*intrep.Instruction, error)

RCLW: Rotate Left through Carry Flag.

Forms:

RCLW 1    r16
RCLW imm8 r16
RCLW cl   r16
RCLW 1    m16
RCLW imm8 m16
RCLW cl   m16

func RCPPS ¶

func RCPPS(mx, x operand.Op) (*intrep.Instruction, error)

RCPPS: Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values.

Forms:

RCPPS xmm  xmm
RCPPS m128 xmm

func RCPSS ¶

func RCPSS(mx, x operand.Op) (*intrep.Instruction, error)

RCPSS: Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values.

Forms:

RCPSS xmm xmm
RCPSS m32 xmm

func RCRB ¶

func RCRB(ci, mr operand.Op) (*intrep.Instruction, error)

RCRB: Rotate Right through Carry Flag.

Forms:

RCRB 1    r8
RCRB imm8 r8
RCRB cl   r8
RCRB 1    m8
RCRB imm8 m8
RCRB cl   m8

func RCRL ¶

func RCRL(ci, mr operand.Op) (*intrep.Instruction, error)

RCRL: Rotate Right through Carry Flag.

Forms:

RCRL 1    r32
RCRL imm8 r32
RCRL cl   r32
RCRL 1    m32
RCRL imm8 m32
RCRL cl   m32

func RCRQ ¶

func RCRQ(ci, mr operand.Op) (*intrep.Instruction, error)

RCRQ: Rotate Right through Carry Flag.

Forms:

RCRQ 1    r64
RCRQ imm8 r64
RCRQ cl   r64
RCRQ 1    m64
RCRQ imm8 m64
RCRQ cl   m64

func RCRW ¶

func RCRW(ci, mr operand.Op) (*intrep.Instruction, error)

RCRW: Rotate Right through Carry Flag.

Forms:

RCRW 1    r16
RCRW imm8 r16
RCRW cl   r16
RCRW 1    m16
RCRW imm8 m16
RCRW cl   m16

func RDRANDL ¶

func RDRANDL(r operand.Op) (*intrep.Instruction, error)

RDRANDL: Read Random Number.

Forms:

RDRANDL r32

func RDRANDQ ¶

func RDRANDQ(r operand.Op) (*intrep.Instruction, error)

RDRANDQ: Read Random Number.

Forms:

RDRANDQ r64

func RDRANDW ¶

func RDRANDW(r operand.Op) (*intrep.Instruction, error)

RDRANDW: Read Random Number.

Forms:

RDRANDW r16

func RDSEEDL ¶

func RDSEEDL(r operand.Op) (*intrep.Instruction, error)

RDSEEDL: Read Random SEED.

Forms:

RDSEEDL r32

func RDSEEDQ ¶

func RDSEEDQ(r operand.Op) (*intrep.Instruction, error)

RDSEEDQ: Read Random SEED.

Forms:

RDSEEDQ r64

func RDSEEDW ¶

func RDSEEDW(r operand.Op) (*intrep.Instruction, error)

RDSEEDW: Read Random SEED.

Forms:

RDSEEDW r16

func RDTSC ¶

func RDTSC() (*intrep.Instruction, error)

RDTSC: Read Time-Stamp Counter.

Forms:

RDTSC

func RDTSCP ¶

func RDTSCP() (*intrep.Instruction, error)

RDTSCP: Read Time-Stamp Counter and Processor ID.

Forms:

RDTSCP

func RET ¶

func RET() (*intrep.Instruction, error)

RET: Return from Procedure.

Forms:

RET

func RETFL ¶

func RETFL(i operand.Op) (*intrep.Instruction, error)

RETFL: Return from Procedure.

Forms:

RETFL imm16

func RETFQ ¶

func RETFQ(i operand.Op) (*intrep.Instruction, error)

RETFQ: Return from Procedure.

Forms:

RETFQ imm16

func RETFW ¶

func RETFW(i operand.Op) (*intrep.Instruction, error)

RETFW: Return from Procedure.

Forms:

RETFW imm16

func ROLB ¶

func ROLB(ci, mr operand.Op) (*intrep.Instruction, error)

ROLB: Rotate Left.

Forms:

ROLB 1    r8
ROLB imm8 r8
ROLB cl   r8
ROLB 1    m8
ROLB imm8 m8
ROLB cl   m8

func ROLL ¶

func ROLL(ci, mr operand.Op) (*intrep.Instruction, error)

ROLL: Rotate Left.

Forms:

ROLL 1    r32
ROLL imm8 r32
ROLL cl   r32
ROLL 1    m32
ROLL imm8 m32
ROLL cl   m32

func ROLQ ¶

func ROLQ(ci, mr operand.Op) (*intrep.Instruction, error)

ROLQ: Rotate Left.

Forms:

ROLQ 1    r64
ROLQ imm8 r64
ROLQ cl   r64
ROLQ 1    m64
ROLQ imm8 m64
ROLQ cl   m64

func ROLW ¶

func ROLW(ci, mr operand.Op) (*intrep.Instruction, error)

ROLW: Rotate Left.

Forms:

ROLW 1    r16
ROLW imm8 r16
ROLW cl   r16
ROLW 1    m16
ROLW imm8 m16
ROLW cl   m16

func RORB ¶

func RORB(ci, mr operand.Op) (*intrep.Instruction, error)

RORB: Rotate Right.

Forms:

RORB 1    r8
RORB imm8 r8
RORB cl   r8
RORB 1    m8
RORB imm8 m8
RORB cl   m8

func RORL ¶

func RORL(ci, mr operand.Op) (*intrep.Instruction, error)

RORL: Rotate Right.

Forms:

RORL 1    r32
RORL imm8 r32
RORL cl   r32
RORL 1    m32
RORL imm8 m32
RORL cl   m32

func RORQ ¶

func RORQ(ci, mr operand.Op) (*intrep.Instruction, error)

RORQ: Rotate Right.

Forms:

RORQ 1    r64
RORQ imm8 r64
RORQ cl   r64
RORQ 1    m64
RORQ imm8 m64
RORQ cl   m64

func RORW ¶

func RORW(ci, mr operand.Op) (*intrep.Instruction, error)

RORW: Rotate Right.

Forms:

RORW 1    r16
RORW imm8 r16
RORW cl   r16
RORW 1    m16
RORW imm8 m16
RORW cl   m16

func RORXL ¶

func RORXL(i, mr, r operand.Op) (*intrep.Instruction, error)

RORXL: Rotate Right Logical Without Affecting Flags.

Forms:

RORXL imm8 r32 r32
RORXL imm8 m32 r32

func RORXQ ¶

func RORXQ(i, mr, r operand.Op) (*intrep.Instruction, error)

RORXQ: Rotate Right Logical Without Affecting Flags.

Forms:

RORXQ imm8 r64 r64
RORXQ imm8 m64 r64

func ROUNDPD ¶

func ROUNDPD(i, mx, x operand.Op) (*intrep.Instruction, error)

ROUNDPD: Round Packed Double Precision Floating-Point Values.

Forms:

ROUNDPD imm8 xmm  xmm
ROUNDPD imm8 m128 xmm

func ROUNDPS ¶

func ROUNDPS(i, mx, x operand.Op) (*intrep.Instruction, error)

ROUNDPS: Round Packed Single Precision Floating-Point Values.

Forms:

ROUNDPS imm8 xmm  xmm
ROUNDPS imm8 m128 xmm

func ROUNDSD ¶

func ROUNDSD(i, mx, x operand.Op) (*intrep.Instruction, error)

ROUNDSD: Round Scalar Double Precision Floating-Point Values.

Forms:

ROUNDSD imm8 xmm xmm
ROUNDSD imm8 m64 xmm

func ROUNDSS ¶

func ROUNDSS(i, mx, x operand.Op) (*intrep.Instruction, error)

ROUNDSS: Round Scalar Single Precision Floating-Point Values.

Forms:

ROUNDSS imm8 xmm xmm
ROUNDSS imm8 m32 xmm

func RSQRTPS ¶

func RSQRTPS(mx, x operand.Op) (*intrep.Instruction, error)

RSQRTPS: Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values.

Forms:

RSQRTPS xmm  xmm
RSQRTPS m128 xmm

func RSQRTSS ¶

func RSQRTSS(mx, x operand.Op) (*intrep.Instruction, error)

RSQRTSS: Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value.

Forms:

RSQRTSS xmm xmm
RSQRTSS m32 xmm

func SALB ¶

func SALB(ci, mr operand.Op) (*intrep.Instruction, error)

SALB: Arithmetic Shift Left.

Forms:

SALB 1    r8
SALB imm8 r8
SALB cl   r8
SALB 1    m8
SALB imm8 m8
SALB cl   m8

func SALL ¶

func SALL(ci, mr operand.Op) (*intrep.Instruction, error)

SALL: Arithmetic Shift Left.

Forms:

SALL 1    r32
SALL imm8 r32
SALL cl   r32
SALL 1    m32
SALL imm8 m32
SALL cl   m32

func SALQ ¶

func SALQ(ci, mr operand.Op) (*intrep.Instruction, error)

SALQ: Arithmetic Shift Left.

Forms:

SALQ 1    r64
SALQ imm8 r64
SALQ cl   r64
SALQ 1    m64
SALQ imm8 m64
SALQ cl   m64

func SALW ¶

func SALW(ci, mr operand.Op) (*intrep.Instruction, error)

SALW: Arithmetic Shift Left.

Forms:

SALW 1    r16
SALW imm8 r16
SALW cl   r16
SALW 1    m16
SALW imm8 m16
SALW cl   m16

func SARB ¶

func SARB(ci, mr operand.Op) (*intrep.Instruction, error)

SARB: Arithmetic Shift Right.

Forms:

SARB 1    r8
SARB imm8 r8
SARB cl   r8
SARB 1    m8
SARB imm8 m8
SARB cl   m8

func SARL ¶

func SARL(ci, mr operand.Op) (*intrep.Instruction, error)

SARL: Arithmetic Shift Right.

Forms:

SARL 1    r32
SARL imm8 r32
SARL cl   r32
SARL 1    m32
SARL imm8 m32
SARL cl   m32

func SARQ ¶

func SARQ(ci, mr operand.Op) (*intrep.Instruction, error)

SARQ: Arithmetic Shift Right.

Forms:

SARQ 1    r64
SARQ imm8 r64
SARQ cl   r64
SARQ 1    m64
SARQ imm8 m64
SARQ cl   m64

func SARW ¶

func SARW(ci, mr operand.Op) (*intrep.Instruction, error)

SARW: Arithmetic Shift Right.

Forms:

SARW 1    r16
SARW imm8 r16
SARW cl   r16
SARW 1    m16
SARW imm8 m16
SARW cl   m16

func SARXL ¶

func SARXL(r, mr, r1 operand.Op) (*intrep.Instruction, error)

SARXL: Arithmetic Shift Right Without Affecting Flags.

Forms:

SARXL r32 r32 r32
SARXL r32 m32 r32

func SARXQ ¶

func SARXQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)

SARXQ: Arithmetic Shift Right Without Affecting Flags.

Forms:

SARXQ r64 r64 r64
SARXQ r64 m64 r64

func SBBB ¶

func SBBB(imr, amr operand.Op) (*intrep.Instruction, error)

SBBB: Subtract with Borrow.

Forms:

SBBB imm8 al
SBBB imm8 r8
SBBB r8   r8
SBBB m8   r8
SBBB imm8 m8
SBBB r8   m8

func SBBL ¶

func SBBL(imr, emr operand.Op) (*intrep.Instruction, error)

SBBL: Subtract with Borrow.

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 SBBQ ¶

func SBBQ(imr, mr operand.Op) (*intrep.Instruction, error)

SBBQ: Subtract with Borrow.

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 SBBW ¶

func SBBW(imr, amr operand.Op) (*intrep.Instruction, error)

SBBW: Subtract with Borrow.

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 SETCC ¶

func SETCC(mr operand.Op) (*intrep.Instruction, error)

SETCC: Set byte if above or equal (CF == 0).

Forms:

SETCC r8
SETCC m8

func SETCS ¶

func SETCS(mr operand.Op) (*intrep.Instruction, error)

SETCS: Set byte if below (CF == 1).

Forms:

SETCS r8
SETCS m8

func SETEQ ¶

func SETEQ(mr operand.Op) (*intrep.Instruction, error)

SETEQ: Set byte if equal (ZF == 1).

Forms:

SETEQ r8
SETEQ m8

func SETGE ¶

func SETGE(mr operand.Op) (*intrep.Instruction, error)

SETGE: Set byte if greater or equal (SF == OF).

Forms:

SETGE r8
SETGE m8

func SETGT ¶

func SETGT(mr operand.Op) (*intrep.Instruction, error)

SETGT: Set byte if greater (ZF == 0 and SF == OF).

Forms:

SETGT r8
SETGT m8

func SETHI ¶

func SETHI(mr operand.Op) (*intrep.Instruction, error)

SETHI: Set byte if above (CF == 0 and ZF == 0).

Forms:

SETHI r8
SETHI m8

func SETLE ¶

func SETLE(mr operand.Op) (*intrep.Instruction, error)

SETLE: Set byte if less or equal (ZF == 1 or SF != OF).

Forms:

SETLE r8
SETLE m8

func SETLS ¶

func SETLS(mr operand.Op) (*intrep.Instruction, error)

SETLS: Set byte if below or equal (CF == 1 or ZF == 1).

Forms:

SETLS r8
SETLS m8

func SETLT ¶

func SETLT(mr operand.Op) (*intrep.Instruction, error)

SETLT: Set byte if less (SF != OF).

Forms:

SETLT r8
SETLT m8

func SETMI ¶

func SETMI(mr operand.Op) (*intrep.Instruction, error)

SETMI: Set byte if sign (SF == 1).

Forms:

SETMI r8
SETMI m8

func SETNE ¶

func SETNE(mr operand.Op) (*intrep.Instruction, error)

SETNE: Set byte if not equal (ZF == 0).

Forms:

SETNE r8
SETNE m8

func SETOC ¶

func SETOC(mr operand.Op) (*intrep.Instruction, error)

SETOC: Set byte if not overflow (OF == 0).

Forms:

SETOC r8
SETOC m8

func SETOS ¶

func SETOS(mr operand.Op) (*intrep.Instruction, error)

SETOS: Set byte if overflow (OF == 1).

Forms:

SETOS r8
SETOS m8

func SETPC ¶

func SETPC(mr operand.Op) (*intrep.Instruction, error)

SETPC: Set byte if not parity (PF == 0).

Forms:

SETPC r8
SETPC m8

func SETPL ¶

func SETPL(mr operand.Op) (*intrep.Instruction, error)

SETPL: Set byte if not sign (SF == 0).

Forms:

SETPL r8
SETPL m8

func SETPS ¶

func SETPS(mr operand.Op) (*intrep.Instruction, error)

SETPS: Set byte if parity (PF == 1).

Forms:

SETPS r8
SETPS m8

func SFENCE ¶

func SFENCE() (*intrep.Instruction, error)

SFENCE: Store Fence.

Forms:

SFENCE

func SHA1MSG1 ¶

func SHA1MSG1(mx, x operand.Op) (*intrep.Instruction, error)

SHA1MSG1: Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords.

Forms:

SHA1MSG1 xmm  xmm
SHA1MSG1 m128 xmm

func SHA1MSG2 ¶

func SHA1MSG2(mx, x operand.Op) (*intrep.Instruction, error)

SHA1MSG2: Perform a Final Calculation for the Next Four SHA1 Message Doublewords.

Forms:

SHA1MSG2 xmm  xmm
SHA1MSG2 m128 xmm

func SHA1NEXTE ¶

func SHA1NEXTE(mx, x operand.Op) (*intrep.Instruction, error)

SHA1NEXTE: Calculate SHA1 State Variable E after Four Rounds.

Forms:

SHA1NEXTE xmm  xmm
SHA1NEXTE m128 xmm

func SHA1RNDS4 ¶

func SHA1RNDS4(i, mx, x operand.Op) (*intrep.Instruction, error)

SHA1RNDS4: Perform Four Rounds of SHA1 Operation.

Forms:

SHA1RNDS4 imm2u xmm  xmm
SHA1RNDS4 imm2u m128 xmm

func SHA256MSG1 ¶

func SHA256MSG1(mx, x operand.Op) (*intrep.Instruction, error)

SHA256MSG1: Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords.

Forms:

SHA256MSG1 xmm  xmm
SHA256MSG1 m128 xmm

func SHA256MSG2 ¶

func SHA256MSG2(mx, x operand.Op) (*intrep.Instruction, error)

SHA256MSG2: Perform a Final Calculation for the Next Four SHA256 Message Doublewords.

Forms:

SHA256MSG2 xmm  xmm
SHA256MSG2 m128 xmm

func SHA256RNDS2 ¶

func SHA256RNDS2(x, mx, x1 operand.Op) (*intrep.Instruction, error)

SHA256RNDS2: Perform Two Rounds of SHA256 Operation.

Forms:

SHA256RNDS2 xmm0 xmm  xmm
SHA256RNDS2 xmm0 m128 xmm

func SHLB ¶

func SHLB(ci, mr operand.Op) (*intrep.Instruction, error)

SHLB: Logical Shift Left.

Forms:

SHLB 1    r8
SHLB imm8 r8
SHLB cl   r8
SHLB 1    m8
SHLB imm8 m8
SHLB cl   m8

func SHLL ¶

func SHLL(ops ...operand.Op) (*intrep.Instruction, error)

SHLL: Logical Shift Left.

Forms:

SHLL 1    r32
SHLL imm8 r32
SHLL cl   r32
SHLL 1    m32
SHLL imm8 m32
SHLL cl   m32
SHLL imm8 r32 r32
SHLL cl   r32 r32
SHLL imm8 r32 m32
SHLL cl   r32 m32

func SHLQ ¶

func SHLQ(ops ...operand.Op) (*intrep.Instruction, error)

SHLQ: Logical Shift Left.

Forms:

SHLQ 1    r64
SHLQ imm8 r64
SHLQ cl   r64
SHLQ 1    m64
SHLQ imm8 m64
SHLQ cl   m64
SHLQ imm8 r64 r64
SHLQ cl   r64 r64
SHLQ imm8 r64 m64
SHLQ cl   r64 m64

func SHLW ¶

func SHLW(ops ...operand.Op) (*intrep.Instruction, error)

SHLW: Logical Shift Left.

Forms:

SHLW 1    r16
SHLW imm8 r16
SHLW cl   r16
SHLW 1    m16
SHLW imm8 m16
SHLW cl   m16
SHLW imm8 r16 r16
SHLW cl   r16 r16
SHLW imm8 r16 m16
SHLW cl   r16 m16

func SHLXL ¶

func SHLXL(r, mr, r1 operand.Op) (*intrep.Instruction, error)

SHLXL: Logical Shift Left Without Affecting Flags.

Forms:

SHLXL r32 r32 r32
SHLXL r32 m32 r32

func SHLXQ ¶

func SHLXQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)

SHLXQ: Logical Shift Left Without Affecting Flags.

Forms:

SHLXQ r64 r64 r64
SHLXQ r64 m64 r64

func SHRB ¶

func SHRB(ci, mr operand.Op) (*intrep.Instruction, error)

SHRB: Logical Shift Right.

Forms:

SHRB 1    r8
SHRB imm8 r8
SHRB cl   r8
SHRB 1    m8
SHRB imm8 m8
SHRB cl   m8

func SHRL ¶

func SHRL(ops ...operand.Op) (*intrep.Instruction, error)

SHRL: Logical Shift Right.

Forms:

SHRL 1    r32
SHRL imm8 r32
SHRL cl   r32
SHRL 1    m32
SHRL imm8 m32
SHRL cl   m32
SHRL imm8 r32 r32
SHRL cl   r32 r32
SHRL imm8 r32 m32
SHRL cl   r32 m32

func SHRQ ¶

func SHRQ(ops ...operand.Op) (*intrep.Instruction, error)

SHRQ: Logical Shift Right.

Forms:

SHRQ 1    r64
SHRQ imm8 r64
SHRQ cl   r64
SHRQ 1    m64
SHRQ imm8 m64
SHRQ cl   m64
SHRQ imm8 r64 r64
SHRQ cl   r64 r64
SHRQ imm8 r64 m64
SHRQ cl   r64 m64

func SHRW ¶

func SHRW(ops ...operand.Op) (*intrep.Instruction, error)

SHRW: Logical Shift Right.

Forms:

SHRW 1    r16
SHRW imm8 r16
SHRW cl   r16
SHRW 1    m16
SHRW imm8 m16
SHRW cl   m16
SHRW imm8 r16 r16
SHRW cl   r16 r16
SHRW imm8 r16 m16
SHRW cl   r16 m16

func SHRXL ¶

func SHRXL(r, mr, r1 operand.Op) (*intrep.Instruction, error)

SHRXL: Logical Shift Right Without Affecting Flags.

Forms:

SHRXL r32 r32 r32
SHRXL r32 m32 r32

func SHRXQ ¶

func SHRXQ(r, mr, r1 operand.Op) (*intrep.Instruction, error)

SHRXQ: Logical Shift Right Without Affecting Flags.

Forms:

SHRXQ r64 r64 r64
SHRXQ r64 m64 r64

func SHUFPD ¶

func SHUFPD(i, mx, x operand.Op) (*intrep.Instruction, error)

SHUFPD: Shuffle Packed Double-Precision Floating-Point Values.

Forms:

SHUFPD imm8 xmm  xmm
SHUFPD imm8 m128 xmm

func SHUFPS ¶

func SHUFPS(i, mx, x operand.Op) (*intrep.Instruction, error)

SHUFPS: Shuffle Packed Single-Precision Floating-Point Values.

Forms:

SHUFPS imm8 xmm  xmm
SHUFPS imm8 m128 xmm

func SQRTPD ¶

func SQRTPD(mx, x operand.Op) (*intrep.Instruction, error)

SQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values.

Forms:

SQRTPD xmm  xmm
SQRTPD m128 xmm

func SQRTPS ¶

func SQRTPS(mx, x operand.Op) (*intrep.Instruction, error)

SQRTPS: Compute Square Roots of Packed Single-Precision Floating-Point Values.

Forms:

SQRTPS xmm  xmm
SQRTPS m128 xmm

func SQRTSD ¶

func SQRTSD(mx, x operand.Op) (*intrep.Instruction, error)

SQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value.

Forms:

SQRTSD xmm xmm
SQRTSD m64 xmm

func SQRTSS ¶

func SQRTSS(mx, x operand.Op) (*intrep.Instruction, error)

SQRTSS: Compute Square Root of Scalar Single-Precision Floating-Point Value.

Forms:

SQRTSS xmm xmm
SQRTSS m32 xmm

func STC ¶

func STC() (*intrep.Instruction, error)

STC: Set Carry Flag.

Forms:

STC

func STD ¶

func STD() (*intrep.Instruction, error)

STD: Set Direction Flag.

Forms:

STD

func STMXCSR ¶

func STMXCSR(m operand.Op) (*intrep.Instruction, error)

STMXCSR: Store MXCSR Register State.

Forms:

STMXCSR m32

func SUBB ¶

func SUBB(imr, amr operand.Op) (*intrep.Instruction, error)

SUBB: Subtract.

Forms:

SUBB imm8 al
SUBB imm8 r8
SUBB r8   r8
SUBB m8   r8
SUBB imm8 m8
SUBB r8   m8

func SUBL ¶

func SUBL(imr, emr operand.Op) (*intrep.Instruction, error)

SUBL: Subtract.

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 SUBPD ¶

func SUBPD(mx, x operand.Op) (*intrep.Instruction, error)

SUBPD: Subtract Packed Double-Precision Floating-Point Values.

Forms:

SUBPD xmm  xmm
SUBPD m128 xmm

func SUBPS ¶

func SUBPS(mx, x operand.Op) (*intrep.Instruction, error)

SUBPS: Subtract Packed Single-Precision Floating-Point Values.

Forms:

SUBPS xmm  xmm
SUBPS m128 xmm

func SUBQ ¶

func SUBQ(imr, mr operand.Op) (*intrep.Instruction, error)

SUBQ: Subtract.

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 SUBSD ¶

func SUBSD(mx, x operand.Op) (*intrep.Instruction, error)

SUBSD: Subtract Scalar Double-Precision Floating-Point Values.

Forms:

SUBSD xmm xmm
SUBSD m64 xmm

func SUBSS ¶

func SUBSS(mx, x operand.Op) (*intrep.Instruction, error)

SUBSS: Subtract Scalar Single-Precision Floating-Point Values.

Forms:

SUBSS xmm xmm
SUBSS m32 xmm

func SUBW ¶

func SUBW(imr, amr operand.Op) (*intrep.Instruction, error)

SUBW: Subtract.

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 SYSCALL ¶

func SYSCALL() (*intrep.Instruction, error)

SYSCALL: Fast System Call.

Forms:

SYSCALL

func TESTB ¶

func TESTB(ir, amr operand.Op) (*intrep.Instruction, error)

TESTB: Logical Compare.

Forms:

TESTB imm8 al
TESTB imm8 r8
TESTB r8   r8
TESTB imm8 m8
TESTB r8   m8

func TESTL ¶

func TESTL(ir, emr operand.Op) (*intrep.Instruction, error)

TESTL: Logical Compare.

Forms:

TESTL imm32 eax
TESTL imm32 r32
TESTL r32   r32
TESTL imm32 m32
TESTL r32   m32

func TESTQ ¶

func TESTQ(ir, mr operand.Op) (*intrep.Instruction, error)

TESTQ: Logical Compare.

Forms:

TESTQ imm32 rax
TESTQ imm32 r64
TESTQ r64   r64
TESTQ imm32 m64
TESTQ r64   m64

func TESTW ¶

func TESTW(ir, amr operand.Op) (*intrep.Instruction, error)

TESTW: Logical Compare.

Forms:

TESTW imm16 ax
TESTW imm16 r16
TESTW r16   r16
TESTW imm16 m16
TESTW r16   m16

func TZCNTL ¶

func TZCNTL(mr, r operand.Op) (*intrep.Instruction, error)

TZCNTL: Count the Number of Trailing Zero Bits.

Forms:

TZCNTL r32 r32
TZCNTL m32 r32

func TZCNTQ ¶

func TZCNTQ(mr, r operand.Op) (*intrep.Instruction, error)

TZCNTQ: Count the Number of Trailing Zero Bits.

Forms:

TZCNTQ r64 r64
TZCNTQ m64 r64

func TZCNTW ¶

func TZCNTW(mr, r operand.Op) (*intrep.Instruction, error)

TZCNTW: Count the Number of Trailing Zero Bits.

Forms:

TZCNTW r16 r16
TZCNTW m16 r16

func UCOMISD ¶

func UCOMISD(mx, x operand.Op) (*intrep.Instruction, error)

UCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

UCOMISD xmm xmm
UCOMISD m64 xmm

func UCOMISS ¶

func UCOMISS(mx, x operand.Op) (*intrep.Instruction, error)

UCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

UCOMISS xmm xmm
UCOMISS m32 xmm

func UD2 ¶

func UD2() (*intrep.Instruction, error)

UD2: Undefined Instruction.

Forms:

UD2

func UNPCKHPD ¶

func UNPCKHPD(mx, x operand.Op) (*intrep.Instruction, error)

UNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values.

Forms:

UNPCKHPD xmm  xmm
UNPCKHPD m128 xmm

func UNPCKHPS ¶

func UNPCKHPS(mx, x operand.Op) (*intrep.Instruction, error)

UNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values.

Forms:

UNPCKHPS xmm  xmm
UNPCKHPS m128 xmm

func UNPCKLPD ¶

func UNPCKLPD(mx, x operand.Op) (*intrep.Instruction, error)

UNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values.

Forms:

UNPCKLPD xmm  xmm
UNPCKLPD m128 xmm

func UNPCKLPS ¶

func UNPCKLPS(mx, x operand.Op) (*intrep.Instruction, error)

UNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values.

Forms:

UNPCKLPS xmm  xmm
UNPCKLPS m128 xmm

func VADDPD ¶

func VADDPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VADDPD: Add Packed Double-Precision Floating-Point Values.

Forms:

VADDPD xmm  xmm xmm
VADDPD m128 xmm xmm
VADDPD ymm  ymm ymm
VADDPD m256 ymm ymm

func VADDPS ¶

func VADDPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VADDPS: Add Packed Single-Precision Floating-Point Values.

Forms:

VADDPS xmm  xmm xmm
VADDPS m128 xmm xmm
VADDPS ymm  ymm ymm
VADDPS m256 ymm ymm

func VADDSD ¶

func VADDSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VADDSD: Add Scalar Double-Precision Floating-Point Values.

Forms:

VADDSD xmm xmm xmm
VADDSD m64 xmm xmm

func VADDSS ¶

func VADDSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VADDSS: Add Scalar Single-Precision Floating-Point Values.

Forms:

VADDSS xmm xmm xmm
VADDSS m32 xmm xmm

func VADDSUBPD ¶

func VADDSUBPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VADDSUBPD: Packed Double-FP Add/Subtract.

Forms:

VADDSUBPD xmm  xmm xmm
VADDSUBPD m128 xmm xmm
VADDSUBPD ymm  ymm ymm
VADDSUBPD m256 ymm ymm

func VADDSUBPS ¶

func VADDSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VADDSUBPS: Packed Single-FP Add/Subtract.

Forms:

VADDSUBPS xmm  xmm xmm
VADDSUBPS m128 xmm xmm
VADDSUBPS ymm  ymm ymm
VADDSUBPS m256 ymm ymm

func VAESDEC ¶

func VAESDEC(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VAESDEC: Perform One Round of an AES Decryption Flow.

Forms:

VAESDEC xmm  xmm xmm
VAESDEC m128 xmm xmm

func VAESDECLAST ¶

func VAESDECLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VAESDECLAST: Perform Last Round of an AES Decryption Flow.

Forms:

VAESDECLAST xmm  xmm xmm
VAESDECLAST m128 xmm xmm

func VAESENC ¶

func VAESENC(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VAESENC: Perform One Round of an AES Encryption Flow.

Forms:

VAESENC xmm  xmm xmm
VAESENC m128 xmm xmm

func VAESENCLAST ¶

func VAESENCLAST(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VAESENCLAST: Perform Last Round of an AES Encryption Flow.

Forms:

VAESENCLAST xmm  xmm xmm
VAESENCLAST m128 xmm xmm

func VAESIMC ¶

func VAESIMC(mx, x operand.Op) (*intrep.Instruction, error)

VAESIMC: Perform the AES InvMixColumn Transformation.

Forms:

VAESIMC xmm  xmm
VAESIMC m128 xmm

func VAESKEYGENASSIST ¶

func VAESKEYGENASSIST(i, mx, x operand.Op) (*intrep.Instruction, error)

VAESKEYGENASSIST: AES Round Key Generation Assist.

Forms:

VAESKEYGENASSIST imm8 xmm  xmm
VAESKEYGENASSIST imm8 m128 xmm

func VANDNPD ¶

func VANDNPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VANDNPD: Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values.

Forms:

VANDNPD xmm  xmm xmm
VANDNPD m128 xmm xmm
VANDNPD ymm  ymm ymm
VANDNPD m256 ymm ymm

func VANDNPS ¶

func VANDNPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VANDNPS: Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values.

Forms:

VANDNPS xmm  xmm xmm
VANDNPS m128 xmm xmm
VANDNPS ymm  ymm ymm
VANDNPS m256 ymm ymm

func VANDPD ¶

func VANDPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VANDPD: Bitwise Logical AND of Packed Double-Precision Floating-Point Values.

Forms:

VANDPD xmm  xmm xmm
VANDPD m128 xmm xmm
VANDPD ymm  ymm ymm
VANDPD m256 ymm ymm

func VANDPS ¶

func VANDPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VANDPS: Bitwise Logical AND of Packed Single-Precision Floating-Point Values.

Forms:

VANDPS xmm  xmm xmm
VANDPS m128 xmm xmm
VANDPS ymm  ymm ymm
VANDPS m256 ymm ymm

func VBLENDPD ¶

func VBLENDPD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VBLENDPD: Blend Packed Double Precision Floating-Point Values.

Forms:

VBLENDPD imm8 xmm  xmm xmm
VBLENDPD imm8 m128 xmm xmm
VBLENDPD imm8 ymm  ymm ymm
VBLENDPD imm8 m256 ymm ymm

func VBLENDPS ¶

func VBLENDPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VBLENDPS: Blend Packed Single Precision Floating-Point Values.

Forms:

VBLENDPS imm8 xmm  xmm xmm
VBLENDPS imm8 m128 xmm xmm
VBLENDPS imm8 ymm  ymm ymm
VBLENDPS imm8 m256 ymm ymm

func VBLENDVPD ¶

func VBLENDVPD(xy, mxy, xy1, xy2 operand.Op) (*intrep.Instruction, error)

VBLENDVPD: Variable Blend Packed Double Precision Floating-Point Values.

Forms:

VBLENDVPD xmm xmm  xmm xmm
VBLENDVPD xmm m128 xmm xmm
VBLENDVPD ymm ymm  ymm ymm
VBLENDVPD ymm m256 ymm ymm

func VBLENDVPS ¶

func VBLENDVPS(xy, mxy, xy1, xy2 operand.Op) (*intrep.Instruction, error)

VBLENDVPS: Variable Blend Packed Single Precision Floating-Point Values.

Forms:

VBLENDVPS xmm xmm  xmm xmm
VBLENDVPS xmm m128 xmm xmm
VBLENDVPS ymm ymm  ymm ymm
VBLENDVPS ymm m256 ymm ymm

func VBROADCASTF128 ¶

func VBROADCASTF128(m, y operand.Op) (*intrep.Instruction, error)

VBROADCASTF128: Broadcast 128 Bit of Floating-Point Data.

Forms:

VBROADCASTF128 m128 ymm

func VBROADCASTI128 ¶

func VBROADCASTI128(m, y operand.Op) (*intrep.Instruction, error)

VBROADCASTI128: Broadcast 128 Bits of Integer Data.

Forms:

VBROADCASTI128 m128 ymm

func VBROADCASTSD ¶

func VBROADCASTSD(mx, y operand.Op) (*intrep.Instruction, error)

VBROADCASTSD: Broadcast Double-Precision Floating-Point Element.

Forms:

VBROADCASTSD xmm ymm
VBROADCASTSD m64 ymm

func VBROADCASTSS ¶

func VBROADCASTSS(mx, xy operand.Op) (*intrep.Instruction, error)

VBROADCASTSS: Broadcast Single-Precision Floating-Point Element.

Forms:

VBROADCASTSS xmm xmm
VBROADCASTSS m32 xmm
VBROADCASTSS xmm ymm
VBROADCASTSS m32 ymm

func VCMPPD ¶

func VCMPPD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VCMPPD: Compare Packed Double-Precision Floating-Point Values.

Forms:

VCMPPD imm8 xmm  xmm xmm
VCMPPD imm8 m128 xmm xmm
VCMPPD imm8 ymm  ymm ymm
VCMPPD imm8 m256 ymm ymm

func VCMPPS ¶

func VCMPPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VCMPPS: Compare Packed Single-Precision Floating-Point Values.

Forms:

VCMPPS imm8 xmm  xmm xmm
VCMPPS imm8 m128 xmm xmm
VCMPPS imm8 ymm  ymm ymm
VCMPPS imm8 m256 ymm ymm

func VCMPSD ¶

func VCMPSD(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VCMPSD: Compare Scalar Double-Precision Floating-Point Values.

Forms:

VCMPSD imm8 xmm xmm xmm
VCMPSD imm8 m64 xmm xmm

func VCMPSS ¶

func VCMPSS(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VCMPSS: Compare Scalar Single-Precision Floating-Point Values.

Forms:

VCMPSS imm8 xmm xmm xmm
VCMPSS imm8 m32 xmm xmm

func VCOMISD ¶

func VCOMISD(mx, x operand.Op) (*intrep.Instruction, error)

VCOMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

VCOMISD xmm xmm
VCOMISD m64 xmm

func VCOMISS ¶

func VCOMISS(mx, x operand.Op) (*intrep.Instruction, error)

VCOMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

VCOMISS xmm xmm
VCOMISS m32 xmm

func VCVTDQ2PD ¶

func VCVTDQ2PD(mx, xy operand.Op) (*intrep.Instruction, error)

VCVTDQ2PD: Convert Packed Dword Integers to Packed Double-Precision FP Values.

Forms:

VCVTDQ2PD xmm  xmm
VCVTDQ2PD m64  xmm
VCVTDQ2PD xmm  ymm
VCVTDQ2PD m128 ymm

func VCVTDQ2PS ¶

func VCVTDQ2PS(mxy, xy operand.Op) (*intrep.Instruction, error)

VCVTDQ2PS: Convert Packed Dword Integers to Packed Single-Precision FP Values.

Forms:

VCVTDQ2PS xmm  xmm
VCVTDQ2PS m128 xmm
VCVTDQ2PS ymm  ymm
VCVTDQ2PS m256 ymm

func VCVTPD2DQX ¶

func VCVTPD2DQX(mx, x operand.Op) (*intrep.Instruction, error)

VCVTPD2DQX: Convert Packed Double-Precision FP Values to Packed Dword Integers.

Forms:

VCVTPD2DQX xmm  xmm
VCVTPD2DQX m128 xmm

func VCVTPD2DQY ¶

func VCVTPD2DQY(my, x operand.Op) (*intrep.Instruction, error)

VCVTPD2DQY: Convert Packed Double-Precision FP Values to Packed Dword Integers.

Forms:

VCVTPD2DQY ymm  xmm
VCVTPD2DQY m256 xmm

func VCVTPD2PSX ¶

func VCVTPD2PSX(mx, x operand.Op) (*intrep.Instruction, error)

VCVTPD2PSX: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values.

Forms:

VCVTPD2PSX xmm  xmm
VCVTPD2PSX m128 xmm

func VCVTPD2PSY ¶

func VCVTPD2PSY(my, x operand.Op) (*intrep.Instruction, error)

VCVTPD2PSY: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values.

Forms:

VCVTPD2PSY ymm  xmm
VCVTPD2PSY m256 xmm

func VCVTPH2PS ¶

func VCVTPH2PS(mx, xy operand.Op) (*intrep.Instruction, error)

VCVTPH2PS: Convert Half-Precision FP Values to Single-Precision FP Values.

Forms:

VCVTPH2PS xmm  xmm
VCVTPH2PS m64  xmm
VCVTPH2PS xmm  ymm
VCVTPH2PS m128 ymm

func VCVTPS2DQ ¶

func VCVTPS2DQ(mxy, xy operand.Op) (*intrep.Instruction, error)

VCVTPS2DQ: Convert Packed Single-Precision FP Values to Packed Dword Integers.

Forms:

VCVTPS2DQ xmm  xmm
VCVTPS2DQ m128 xmm
VCVTPS2DQ ymm  ymm
VCVTPS2DQ m256 ymm

func VCVTPS2PD ¶

func VCVTPS2PD(mx, xy operand.Op) (*intrep.Instruction, error)

VCVTPS2PD: Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values.

Forms:

VCVTPS2PD xmm  xmm
VCVTPS2PD m64  xmm
VCVTPS2PD xmm  ymm
VCVTPS2PD m128 ymm

func VCVTPS2PH ¶

func VCVTPS2PH(i, xy, mx operand.Op) (*intrep.Instruction, error)

VCVTPS2PH: Convert Single-Precision FP value to Half-Precision FP value.

Forms:

VCVTPS2PH imm8 xmm xmm
VCVTPS2PH imm8 ymm xmm
VCVTPS2PH imm8 xmm m64
VCVTPS2PH imm8 ymm m128

func VCVTSD2SI ¶

func VCVTSD2SI(mx, r operand.Op) (*intrep.Instruction, error)

VCVTSD2SI: Convert Scalar Double-Precision FP Value to Integer.

Forms:

VCVTSD2SI xmm r32
VCVTSD2SI m64 r32

func VCVTSD2SIQ ¶

func VCVTSD2SIQ(mx, r operand.Op) (*intrep.Instruction, error)

VCVTSD2SIQ: Convert Scalar Double-Precision FP Value to Integer.

Forms:

VCVTSD2SIQ xmm r64
VCVTSD2SIQ m64 r64

func VCVTSD2SS ¶

func VCVTSD2SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VCVTSD2SS: Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value.

Forms:

VCVTSD2SS xmm xmm xmm
VCVTSD2SS m64 xmm xmm

func VCVTSI2SDL ¶

func VCVTSI2SDL(mr, x, x1 operand.Op) (*intrep.Instruction, error)

VCVTSI2SDL: Convert Dword Integer to Scalar Double-Precision FP Value.

Forms:

VCVTSI2SDL r32 xmm xmm
VCVTSI2SDL m32 xmm xmm

func VCVTSI2SDQ ¶

func VCVTSI2SDQ(mr, x, x1 operand.Op) (*intrep.Instruction, error)

VCVTSI2SDQ: Convert Dword Integer to Scalar Double-Precision FP Value.

Forms:

VCVTSI2SDQ r64 xmm xmm
VCVTSI2SDQ m64 xmm xmm

func VCVTSI2SSL ¶

func VCVTSI2SSL(mr, x, x1 operand.Op) (*intrep.Instruction, error)

VCVTSI2SSL: Convert Dword Integer to Scalar Single-Precision FP Value.

Forms:

VCVTSI2SSL r32 xmm xmm
VCVTSI2SSL m32 xmm xmm

func VCVTSI2SSQ ¶

func VCVTSI2SSQ(mr, x, x1 operand.Op) (*intrep.Instruction, error)

VCVTSI2SSQ: Convert Dword Integer to Scalar Single-Precision FP Value.

Forms:

VCVTSI2SSQ r64 xmm xmm
VCVTSI2SSQ m64 xmm xmm

func VCVTSS2SD ¶

func VCVTSS2SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VCVTSS2SD: Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value.

Forms:

VCVTSS2SD xmm xmm xmm
VCVTSS2SD m32 xmm xmm

func VCVTSS2SI ¶

func VCVTSS2SI(mx, r operand.Op) (*intrep.Instruction, error)

VCVTSS2SI: Convert Scalar Single-Precision FP Value to Dword Integer.

Forms:

VCVTSS2SI xmm r32
VCVTSS2SI m32 r32

func VCVTSS2SIQ ¶

func VCVTSS2SIQ(mx, r operand.Op) (*intrep.Instruction, error)

VCVTSS2SIQ: Convert Scalar Single-Precision FP Value to Dword Integer.

Forms:

VCVTSS2SIQ xmm r64
VCVTSS2SIQ m32 r64

func VCVTTPD2DQX ¶

func VCVTTPD2DQX(mx, x operand.Op) (*intrep.Instruction, error)

VCVTTPD2DQX: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers.

Forms:

VCVTTPD2DQX xmm  xmm
VCVTTPD2DQX m128 xmm

func VCVTTPD2DQY ¶

func VCVTTPD2DQY(my, x operand.Op) (*intrep.Instruction, error)

VCVTTPD2DQY: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers.

Forms:

VCVTTPD2DQY ymm  xmm
VCVTTPD2DQY m256 xmm

func VCVTTPS2DQ ¶

func VCVTTPS2DQ(mxy, xy operand.Op) (*intrep.Instruction, error)

VCVTTPS2DQ: Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers.

Forms:

VCVTTPS2DQ xmm  xmm
VCVTTPS2DQ m128 xmm
VCVTTPS2DQ ymm  ymm
VCVTTPS2DQ m256 ymm

func VCVTTSD2SI ¶

func VCVTTSD2SI(mx, r operand.Op) (*intrep.Instruction, error)

VCVTTSD2SI: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer.

Forms:

VCVTTSD2SI xmm r32
VCVTTSD2SI m64 r32

func VCVTTSD2SIQ ¶

func VCVTTSD2SIQ(mx, r operand.Op) (*intrep.Instruction, error)

VCVTTSD2SIQ: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer.

Forms:

VCVTTSD2SIQ xmm r64
VCVTTSD2SIQ m64 r64

func VCVTTSS2SI ¶

func VCVTTSS2SI(mx, r operand.Op) (*intrep.Instruction, error)

VCVTTSS2SI: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer.

Forms:

VCVTTSS2SI xmm r32
VCVTTSS2SI m32 r32

func VCVTTSS2SIQ ¶

func VCVTTSS2SIQ(mx, r operand.Op) (*intrep.Instruction, error)

VCVTTSS2SIQ: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer.

Forms:

VCVTTSS2SIQ xmm r64
VCVTTSS2SIQ m32 r64

func VDIVPD ¶

func VDIVPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VDIVPD: Divide Packed Double-Precision Floating-Point Values.

Forms:

VDIVPD xmm  xmm xmm
VDIVPD m128 xmm xmm
VDIVPD ymm  ymm ymm
VDIVPD m256 ymm ymm

func VDIVPS ¶

func VDIVPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VDIVPS: Divide Packed Single-Precision Floating-Point Values.

Forms:

VDIVPS xmm  xmm xmm
VDIVPS m128 xmm xmm
VDIVPS ymm  ymm ymm
VDIVPS m256 ymm ymm

func VDIVSD ¶

func VDIVSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VDIVSD: Divide Scalar Double-Precision Floating-Point Values.

Forms:

VDIVSD xmm xmm xmm
VDIVSD m64 xmm xmm

func VDIVSS ¶

func VDIVSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VDIVSS: Divide Scalar Single-Precision Floating-Point Values.

Forms:

VDIVSS xmm xmm xmm
VDIVSS m32 xmm xmm

func VDPPD ¶

func VDPPD(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VDPPD: Dot Product of Packed Double Precision Floating-Point Values.

Forms:

VDPPD imm8 xmm  xmm xmm
VDPPD imm8 m128 xmm xmm

func VDPPS ¶

func VDPPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VDPPS: Dot Product of Packed Single Precision Floating-Point Values.

Forms:

VDPPS imm8 xmm  xmm xmm
VDPPS imm8 m128 xmm xmm
VDPPS imm8 ymm  ymm ymm
VDPPS imm8 m256 ymm ymm

func VEXTRACTF128 ¶

func VEXTRACTF128(i, y, mx operand.Op) (*intrep.Instruction, error)

VEXTRACTF128: Extract Packed Floating-Point Values.

Forms:

VEXTRACTF128 imm8 ymm xmm
VEXTRACTF128 imm8 ymm m128

func VEXTRACTI128 ¶

func VEXTRACTI128(i, y, mx operand.Op) (*intrep.Instruction, error)

VEXTRACTI128: Extract Packed Integer Values.

Forms:

VEXTRACTI128 imm8 ymm xmm
VEXTRACTI128 imm8 ymm m128

func VEXTRACTPS ¶

func VEXTRACTPS(i, x, mr operand.Op) (*intrep.Instruction, error)

VEXTRACTPS: Extract Packed Single Precision Floating-Point Value.

Forms:

VEXTRACTPS imm8 xmm r32
VEXTRACTPS imm8 xmm m32

func VFMADD132PD ¶

func VFMADD132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADD132PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values.

Forms:

VFMADD132PD xmm  xmm xmm
VFMADD132PD m128 xmm xmm
VFMADD132PD ymm  ymm ymm
VFMADD132PD m256 ymm ymm

func VFMADD132PS ¶

func VFMADD132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADD132PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values.

Forms:

VFMADD132PS xmm  xmm xmm
VFMADD132PS m128 xmm xmm
VFMADD132PS ymm  ymm ymm
VFMADD132PS m256 ymm ymm

func VFMADD132SD ¶

func VFMADD132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMADD132SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD132SD xmm xmm xmm
VFMADD132SD m64 xmm xmm

func VFMADD132SS ¶

func VFMADD132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMADD132SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD132SS xmm xmm xmm
VFMADD132SS m32 xmm xmm

func VFMADD213PD ¶

func VFMADD213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADD213PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values.

Forms:

VFMADD213PD xmm  xmm xmm
VFMADD213PD m128 xmm xmm
VFMADD213PD ymm  ymm ymm
VFMADD213PD m256 ymm ymm

func VFMADD213PS ¶

func VFMADD213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADD213PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values.

Forms:

VFMADD213PS xmm  xmm xmm
VFMADD213PS m128 xmm xmm
VFMADD213PS ymm  ymm ymm
VFMADD213PS m256 ymm ymm

func VFMADD213SD ¶

func VFMADD213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMADD213SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD213SD xmm xmm xmm
VFMADD213SD m64 xmm xmm

func VFMADD213SS ¶

func VFMADD213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMADD213SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD213SS xmm xmm xmm
VFMADD213SS m32 xmm xmm

func VFMADD231PD ¶

func VFMADD231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADD231PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values.

Forms:

VFMADD231PD xmm  xmm xmm
VFMADD231PD m128 xmm xmm
VFMADD231PD ymm  ymm ymm
VFMADD231PD m256 ymm ymm

func VFMADD231PS ¶

func VFMADD231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADD231PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values.

Forms:

VFMADD231PS xmm  xmm xmm
VFMADD231PS m128 xmm xmm
VFMADD231PS ymm  ymm ymm
VFMADD231PS m256 ymm ymm

func VFMADD231SD ¶

func VFMADD231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMADD231SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD231SD xmm xmm xmm
VFMADD231SD m64 xmm xmm

func VFMADD231SS ¶

func VFMADD231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMADD231SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD231SS xmm xmm xmm
VFMADD231SS m32 xmm xmm

func VFMADDSUB132PD ¶

func VFMADDSUB132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADDSUB132PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFMADDSUB132PD xmm  xmm xmm
VFMADDSUB132PD m128 xmm xmm
VFMADDSUB132PD ymm  ymm ymm
VFMADDSUB132PD m256 ymm ymm

func VFMADDSUB132PS ¶

func VFMADDSUB132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADDSUB132PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFMADDSUB132PS xmm  xmm xmm
VFMADDSUB132PS m128 xmm xmm
VFMADDSUB132PS ymm  ymm ymm
VFMADDSUB132PS m256 ymm ymm

func VFMADDSUB213PD ¶

func VFMADDSUB213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADDSUB213PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFMADDSUB213PD xmm  xmm xmm
VFMADDSUB213PD m128 xmm xmm
VFMADDSUB213PD ymm  ymm ymm
VFMADDSUB213PD m256 ymm ymm

func VFMADDSUB213PS ¶

func VFMADDSUB213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADDSUB213PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFMADDSUB213PS xmm  xmm xmm
VFMADDSUB213PS m128 xmm xmm
VFMADDSUB213PS ymm  ymm ymm
VFMADDSUB213PS m256 ymm ymm

func VFMADDSUB231PD ¶

func VFMADDSUB231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADDSUB231PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFMADDSUB231PD xmm  xmm xmm
VFMADDSUB231PD m128 xmm xmm
VFMADDSUB231PD ymm  ymm ymm
VFMADDSUB231PD m256 ymm ymm

func VFMADDSUB231PS ¶

func VFMADDSUB231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMADDSUB231PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFMADDSUB231PS xmm  xmm xmm
VFMADDSUB231PS m128 xmm xmm
VFMADDSUB231PS ymm  ymm ymm
VFMADDSUB231PS m256 ymm ymm

func VFMSUB132PD ¶

func VFMSUB132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUB132PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFMSUB132PD xmm  xmm xmm
VFMSUB132PD m128 xmm xmm
VFMSUB132PD ymm  ymm ymm
VFMSUB132PD m256 ymm ymm

func VFMSUB132PS ¶

func VFMSUB132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUB132PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFMSUB132PS xmm  xmm xmm
VFMSUB132PS m128 xmm xmm
VFMSUB132PS ymm  ymm ymm
VFMSUB132PS m256 ymm ymm

func VFMSUB132SD ¶

func VFMSUB132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMSUB132SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB132SD xmm xmm xmm
VFMSUB132SD m64 xmm xmm

func VFMSUB132SS ¶

func VFMSUB132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMSUB132SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB132SS xmm xmm xmm
VFMSUB132SS m32 xmm xmm

func VFMSUB213PD ¶

func VFMSUB213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUB213PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFMSUB213PD xmm  xmm xmm
VFMSUB213PD m128 xmm xmm
VFMSUB213PD ymm  ymm ymm
VFMSUB213PD m256 ymm ymm

func VFMSUB213PS ¶

func VFMSUB213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUB213PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFMSUB213PS xmm  xmm xmm
VFMSUB213PS m128 xmm xmm
VFMSUB213PS ymm  ymm ymm
VFMSUB213PS m256 ymm ymm

func VFMSUB213SD ¶

func VFMSUB213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMSUB213SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB213SD xmm xmm xmm
VFMSUB213SD m64 xmm xmm

func VFMSUB213SS ¶

func VFMSUB213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMSUB213SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB213SS xmm xmm xmm
VFMSUB213SS m32 xmm xmm

func VFMSUB231PD ¶

func VFMSUB231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUB231PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFMSUB231PD xmm  xmm xmm
VFMSUB231PD m128 xmm xmm
VFMSUB231PD ymm  ymm ymm
VFMSUB231PD m256 ymm ymm

func VFMSUB231PS ¶

func VFMSUB231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUB231PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFMSUB231PS xmm  xmm xmm
VFMSUB231PS m128 xmm xmm
VFMSUB231PS ymm  ymm ymm
VFMSUB231PS m256 ymm ymm

func VFMSUB231SD ¶

func VFMSUB231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMSUB231SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB231SD xmm xmm xmm
VFMSUB231SD m64 xmm xmm

func VFMSUB231SS ¶

func VFMSUB231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFMSUB231SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB231SS xmm xmm xmm
VFMSUB231SS m32 xmm xmm

func VFMSUBADD132PD ¶

func VFMSUBADD132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUBADD132PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values.

Forms:

VFMSUBADD132PD xmm  xmm xmm
VFMSUBADD132PD m128 xmm xmm
VFMSUBADD132PD ymm  ymm ymm
VFMSUBADD132PD m256 ymm ymm

func VFMSUBADD132PS ¶

func VFMSUBADD132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUBADD132PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values.

Forms:

VFMSUBADD132PS xmm  xmm xmm
VFMSUBADD132PS m128 xmm xmm
VFMSUBADD132PS ymm  ymm ymm
VFMSUBADD132PS m256 ymm ymm

func VFMSUBADD213PD ¶

func VFMSUBADD213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUBADD213PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values.

Forms:

VFMSUBADD213PD xmm  xmm xmm
VFMSUBADD213PD m128 xmm xmm
VFMSUBADD213PD ymm  ymm ymm
VFMSUBADD213PD m256 ymm ymm

func VFMSUBADD213PS ¶

func VFMSUBADD213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUBADD213PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values.

Forms:

VFMSUBADD213PS xmm  xmm xmm
VFMSUBADD213PS m128 xmm xmm
VFMSUBADD213PS ymm  ymm ymm
VFMSUBADD213PS m256 ymm ymm

func VFMSUBADD231PD ¶

func VFMSUBADD231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUBADD231PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values.

Forms:

VFMSUBADD231PD xmm  xmm xmm
VFMSUBADD231PD m128 xmm xmm
VFMSUBADD231PD ymm  ymm ymm
VFMSUBADD231PD m256 ymm ymm

func VFMSUBADD231PS ¶

func VFMSUBADD231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFMSUBADD231PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values.

Forms:

VFMSUBADD231PS xmm  xmm xmm
VFMSUBADD231PS m128 xmm xmm
VFMSUBADD231PS ymm  ymm ymm
VFMSUBADD231PS m256 ymm ymm

func VFNMADD132PD ¶

func VFNMADD132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMADD132PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values.

Forms:

VFNMADD132PD xmm  xmm xmm
VFNMADD132PD m128 xmm xmm
VFNMADD132PD ymm  ymm ymm
VFNMADD132PD m256 ymm ymm

func VFNMADD132PS ¶

func VFNMADD132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMADD132PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values.

Forms:

VFNMADD132PS xmm  xmm xmm
VFNMADD132PS m128 xmm xmm
VFNMADD132PS ymm  ymm ymm
VFNMADD132PS m256 ymm ymm

func VFNMADD132SD ¶

func VFNMADD132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMADD132SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD132SD xmm xmm xmm
VFNMADD132SD m64 xmm xmm

func VFNMADD132SS ¶

func VFNMADD132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMADD132SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD132SS xmm xmm xmm
VFNMADD132SS m32 xmm xmm

func VFNMADD213PD ¶

func VFNMADD213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMADD213PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values.

Forms:

VFNMADD213PD xmm  xmm xmm
VFNMADD213PD m128 xmm xmm
VFNMADD213PD ymm  ymm ymm
VFNMADD213PD m256 ymm ymm

func VFNMADD213PS ¶

func VFNMADD213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMADD213PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values.

Forms:

VFNMADD213PS xmm  xmm xmm
VFNMADD213PS m128 xmm xmm
VFNMADD213PS ymm  ymm ymm
VFNMADD213PS m256 ymm ymm

func VFNMADD213SD ¶

func VFNMADD213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMADD213SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD213SD xmm xmm xmm
VFNMADD213SD m64 xmm xmm

func VFNMADD213SS ¶

func VFNMADD213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMADD213SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD213SS xmm xmm xmm
VFNMADD213SS m32 xmm xmm

func VFNMADD231PD ¶

func VFNMADD231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMADD231PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values.

Forms:

VFNMADD231PD xmm  xmm xmm
VFNMADD231PD m128 xmm xmm
VFNMADD231PD ymm  ymm ymm
VFNMADD231PD m256 ymm ymm

func VFNMADD231PS ¶

func VFNMADD231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMADD231PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values.

Forms:

VFNMADD231PS xmm  xmm xmm
VFNMADD231PS m128 xmm xmm
VFNMADD231PS ymm  ymm ymm
VFNMADD231PS m256 ymm ymm

func VFNMADD231SD ¶

func VFNMADD231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMADD231SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD231SD xmm xmm xmm
VFNMADD231SD m64 xmm xmm

func VFNMADD231SS ¶

func VFNMADD231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMADD231SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD231SS xmm xmm xmm
VFNMADD231SS m32 xmm xmm

func VFNMSUB132PD ¶

func VFNMSUB132PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMSUB132PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFNMSUB132PD xmm  xmm xmm
VFNMSUB132PD m128 xmm xmm
VFNMSUB132PD ymm  ymm ymm
VFNMSUB132PD m256 ymm ymm

func VFNMSUB132PS ¶

func VFNMSUB132PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMSUB132PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFNMSUB132PS xmm  xmm xmm
VFNMSUB132PS m128 xmm xmm
VFNMSUB132PS ymm  ymm ymm
VFNMSUB132PS m256 ymm ymm

func VFNMSUB132SD ¶

func VFNMSUB132SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMSUB132SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB132SD xmm xmm xmm
VFNMSUB132SD m64 xmm xmm

func VFNMSUB132SS ¶

func VFNMSUB132SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMSUB132SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB132SS xmm xmm xmm
VFNMSUB132SS m32 xmm xmm

func VFNMSUB213PD ¶

func VFNMSUB213PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMSUB213PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFNMSUB213PD xmm  xmm xmm
VFNMSUB213PD m128 xmm xmm
VFNMSUB213PD ymm  ymm ymm
VFNMSUB213PD m256 ymm ymm

func VFNMSUB213PS ¶

func VFNMSUB213PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMSUB213PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFNMSUB213PS xmm  xmm xmm
VFNMSUB213PS m128 xmm xmm
VFNMSUB213PS ymm  ymm ymm
VFNMSUB213PS m256 ymm ymm

func VFNMSUB213SD ¶

func VFNMSUB213SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMSUB213SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB213SD xmm xmm xmm
VFNMSUB213SD m64 xmm xmm

func VFNMSUB213SS ¶

func VFNMSUB213SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMSUB213SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB213SS xmm xmm xmm
VFNMSUB213SS m32 xmm xmm

func VFNMSUB231PD ¶

func VFNMSUB231PD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMSUB231PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values.

Forms:

VFNMSUB231PD xmm  xmm xmm
VFNMSUB231PD m128 xmm xmm
VFNMSUB231PD ymm  ymm ymm
VFNMSUB231PD m256 ymm ymm

func VFNMSUB231PS ¶

func VFNMSUB231PS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VFNMSUB231PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values.

Forms:

VFNMSUB231PS xmm  xmm xmm
VFNMSUB231PS m128 xmm xmm
VFNMSUB231PS ymm  ymm ymm
VFNMSUB231PS m256 ymm ymm

func VFNMSUB231SD ¶

func VFNMSUB231SD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMSUB231SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB231SD xmm xmm xmm
VFNMSUB231SD m64 xmm xmm

func VFNMSUB231SS ¶

func VFNMSUB231SS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VFNMSUB231SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB231SS xmm xmm xmm
VFNMSUB231SS m32 xmm xmm

func VGATHERDPD ¶

func VGATHERDPD(xy, v, xy1 operand.Op) (*intrep.Instruction, error)

VGATHERDPD: Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices.

Forms:

VGATHERDPD xmm vm32x xmm
VGATHERDPD ymm vm32x ymm

func VGATHERDPS ¶

func VGATHERDPS(xy, v, xy1 operand.Op) (*intrep.Instruction, error)

VGATHERDPS: Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices.

Forms:

VGATHERDPS xmm vm32x xmm
VGATHERDPS ymm vm32y ymm

func VGATHERQPD ¶

func VGATHERQPD(xy, v, xy1 operand.Op) (*intrep.Instruction, error)

VGATHERQPD: Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices.

Forms:

VGATHERQPD xmm vm64x xmm
VGATHERQPD ymm vm64y ymm

func VGATHERQPS ¶

func VGATHERQPS(x, v, x1 operand.Op) (*intrep.Instruction, error)

VGATHERQPS: Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices.

Forms:

VGATHERQPS xmm vm64x xmm
VGATHERQPS xmm vm64y xmm

func VHADDPD ¶

func VHADDPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VHADDPD: Packed Double-FP Horizontal Add.

Forms:

VHADDPD xmm  xmm xmm
VHADDPD m128 xmm xmm
VHADDPD ymm  ymm ymm
VHADDPD m256 ymm ymm

func VHADDPS ¶

func VHADDPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VHADDPS: Packed Single-FP Horizontal Add.

Forms:

VHADDPS xmm  xmm xmm
VHADDPS m128 xmm xmm
VHADDPS ymm  ymm ymm
VHADDPS m256 ymm ymm

func VHSUBPD ¶

func VHSUBPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VHSUBPD: Packed Double-FP Horizontal Subtract.

Forms:

VHSUBPD xmm  xmm xmm
VHSUBPD m128 xmm xmm
VHSUBPD ymm  ymm ymm
VHSUBPD m256 ymm ymm

func VHSUBPS ¶

func VHSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VHSUBPS: Packed Single-FP Horizontal Subtract.

Forms:

VHSUBPS xmm  xmm xmm
VHSUBPS m128 xmm xmm
VHSUBPS ymm  ymm ymm
VHSUBPS m256 ymm ymm

func VINSERTF128 ¶

func VINSERTF128(i, mx, y, y1 operand.Op) (*intrep.Instruction, error)

VINSERTF128: Insert Packed Floating-Point Values.

Forms:

VINSERTF128 imm8 xmm  ymm ymm
VINSERTF128 imm8 m128 ymm ymm

func VINSERTI128 ¶

func VINSERTI128(i, mx, y, y1 operand.Op) (*intrep.Instruction, error)

VINSERTI128: Insert Packed Integer Values.

Forms:

VINSERTI128 imm8 xmm  ymm ymm
VINSERTI128 imm8 m128 ymm ymm

func VINSERTPS ¶

func VINSERTPS(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VINSERTPS: Insert Packed Single Precision Floating-Point Value.

Forms:

VINSERTPS imm8 xmm xmm xmm
VINSERTPS imm8 m32 xmm xmm

func VLDDQU ¶

func VLDDQU(m, xy operand.Op) (*intrep.Instruction, error)

VLDDQU: Load Unaligned Integer 128 Bits.

Forms:

VLDDQU m128 xmm
VLDDQU m256 ymm

func VLDMXCSR ¶

func VLDMXCSR(m operand.Op) (*intrep.Instruction, error)

VLDMXCSR: Load MXCSR Register.

Forms:

VLDMXCSR m32

func VMASKMOVDQU ¶

func VMASKMOVDQU(x, x1 operand.Op) (*intrep.Instruction, error)

VMASKMOVDQU: Store Selected Bytes of Double Quadword.

Forms:

VMASKMOVDQU xmm xmm

func VMASKMOVPD ¶

func VMASKMOVPD(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)

VMASKMOVPD: Conditional Move Packed Double-Precision Floating-Point Values.

Forms:

VMASKMOVPD m128 xmm xmm
VMASKMOVPD m256 ymm ymm
VMASKMOVPD xmm  xmm m128
VMASKMOVPD ymm  ymm m256

func VMASKMOVPS ¶

func VMASKMOVPS(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)

VMASKMOVPS: Conditional Move Packed Single-Precision Floating-Point Values.

Forms:

VMASKMOVPS m128 xmm xmm
VMASKMOVPS m256 ymm ymm
VMASKMOVPS xmm  xmm m128
VMASKMOVPS ymm  ymm m256

func VMAXPD ¶

func VMAXPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMAXPD: Return Maximum Packed Double-Precision Floating-Point Values.

Forms:

VMAXPD xmm  xmm xmm
VMAXPD m128 xmm xmm
VMAXPD ymm  ymm ymm
VMAXPD m256 ymm ymm

func VMAXPS ¶

func VMAXPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMAXPS: Return Maximum Packed Single-Precision Floating-Point Values.

Forms:

VMAXPS xmm  xmm xmm
VMAXPS m128 xmm xmm
VMAXPS ymm  ymm ymm
VMAXPS m256 ymm ymm

func VMAXSD ¶

func VMAXSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VMAXSD: Return Maximum Scalar Double-Precision Floating-Point Value.

Forms:

VMAXSD xmm xmm xmm
VMAXSD m64 xmm xmm

func VMAXSS ¶

func VMAXSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VMAXSS: Return Maximum Scalar Single-Precision Floating-Point Value.

Forms:

VMAXSS xmm xmm xmm
VMAXSS m32 xmm xmm

func VMINPD ¶

func VMINPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMINPD: Return Minimum Packed Double-Precision Floating-Point Values.

Forms:

VMINPD xmm  xmm xmm
VMINPD m128 xmm xmm
VMINPD ymm  ymm ymm
VMINPD m256 ymm ymm

func VMINPS ¶

func VMINPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMINPS: Return Minimum Packed Single-Precision Floating-Point Values.

Forms:

VMINPS xmm  xmm xmm
VMINPS m128 xmm xmm
VMINPS ymm  ymm ymm
VMINPS m256 ymm ymm

func VMINSD ¶

func VMINSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VMINSD: Return Minimum Scalar Double-Precision Floating-Point Value.

Forms:

VMINSD xmm xmm xmm
VMINSD m64 xmm xmm

func VMINSS ¶

func VMINSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VMINSS: Return Minimum Scalar Single-Precision Floating-Point Value.

Forms:

VMINSS xmm xmm xmm
VMINSS m32 xmm xmm

func VMOVAPD ¶

func VMOVAPD(mxy, mxy1 operand.Op) (*intrep.Instruction, error)

VMOVAPD: Move Aligned Packed Double-Precision Floating-Point Values.

Forms:

VMOVAPD xmm  xmm
VMOVAPD m128 xmm
VMOVAPD ymm  ymm
VMOVAPD m256 ymm
VMOVAPD xmm  m128
VMOVAPD ymm  m256

func VMOVAPS ¶

func VMOVAPS(mxy, mxy1 operand.Op) (*intrep.Instruction, error)

VMOVAPS: Move Aligned Packed Single-Precision Floating-Point Values.

Forms:

VMOVAPS xmm  xmm
VMOVAPS m128 xmm
VMOVAPS ymm  ymm
VMOVAPS m256 ymm
VMOVAPS xmm  m128
VMOVAPS ymm  m256

func VMOVD ¶

func VMOVD(mrx, mrx1 operand.Op) (*intrep.Instruction, error)

VMOVD: Move Doubleword.

Forms:

VMOVD xmm r32
VMOVD r32 xmm
VMOVD m32 xmm
VMOVD xmm m32

func VMOVDDUP ¶

func VMOVDDUP(mxy, xy operand.Op) (*intrep.Instruction, error)

VMOVDDUP: Move One Double-FP and Duplicate.

Forms:

VMOVDDUP xmm  xmm
VMOVDDUP m64  xmm
VMOVDDUP ymm  ymm
VMOVDDUP m256 ymm

func VMOVDQA ¶

func VMOVDQA(mxy, mxy1 operand.Op) (*intrep.Instruction, error)

VMOVDQA: Move Aligned Double Quadword.

Forms:

VMOVDQA xmm  xmm
VMOVDQA m128 xmm
VMOVDQA ymm  ymm
VMOVDQA m256 ymm
VMOVDQA xmm  m128
VMOVDQA ymm  m256

func VMOVDQU ¶

func VMOVDQU(mxy, mxy1 operand.Op) (*intrep.Instruction, error)

VMOVDQU: Move Unaligned Double Quadword.

Forms:

VMOVDQU xmm  xmm
VMOVDQU m128 xmm
VMOVDQU ymm  ymm
VMOVDQU m256 ymm
VMOVDQU xmm  m128
VMOVDQU ymm  m256

func VMOVHLPS ¶

func VMOVHLPS(x, x1, x2 operand.Op) (*intrep.Instruction, error)

VMOVHLPS: Move Packed Single-Precision Floating-Point Values High to Low.

Forms:

VMOVHLPS xmm xmm xmm

func VMOVHPD ¶

func VMOVHPD(ops ...operand.Op) (*intrep.Instruction, error)

VMOVHPD: Move High Packed Double-Precision Floating-Point Value.

Forms:

VMOVHPD xmm m64
VMOVHPD m64 xmm xmm

func VMOVHPS ¶

func VMOVHPS(ops ...operand.Op) (*intrep.Instruction, error)

VMOVHPS: Move High Packed Single-Precision Floating-Point Values.

Forms:

VMOVHPS xmm m64
VMOVHPS m64 xmm xmm

func VMOVLHPS ¶

func VMOVLHPS(x, x1, x2 operand.Op) (*intrep.Instruction, error)

VMOVLHPS: Move Packed Single-Precision Floating-Point Values Low to High.

Forms:

VMOVLHPS xmm xmm xmm

func VMOVLPD ¶

func VMOVLPD(ops ...operand.Op) (*intrep.Instruction, error)

VMOVLPD: Move Low Packed Double-Precision Floating-Point Value.

Forms:

VMOVLPD xmm m64
VMOVLPD m64 xmm xmm

func VMOVLPS ¶

func VMOVLPS(ops ...operand.Op) (*intrep.Instruction, error)

VMOVLPS: Move Low Packed Single-Precision Floating-Point Values.

Forms:

VMOVLPS xmm m64
VMOVLPS m64 xmm xmm

func VMOVMSKPD ¶

func VMOVMSKPD(xy, r operand.Op) (*intrep.Instruction, error)

VMOVMSKPD: Extract Packed Double-Precision Floating-Point Sign Mask.

Forms:

VMOVMSKPD xmm r32
VMOVMSKPD ymm r32

func VMOVMSKPS ¶

func VMOVMSKPS(xy, r operand.Op) (*intrep.Instruction, error)

VMOVMSKPS: Extract Packed Single-Precision Floating-Point Sign Mask.

Forms:

VMOVMSKPS xmm r32
VMOVMSKPS ymm r32

func VMOVNTDQ ¶

func VMOVNTDQ(xy, m operand.Op) (*intrep.Instruction, error)

VMOVNTDQ: Store Double Quadword Using Non-Temporal Hint.

Forms:

VMOVNTDQ xmm m128
VMOVNTDQ ymm m256

func VMOVNTDQA ¶

func VMOVNTDQA(m, xy operand.Op) (*intrep.Instruction, error)

VMOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint.

Forms:

VMOVNTDQA m128 xmm
VMOVNTDQA m256 ymm

func VMOVNTPD ¶

func VMOVNTPD(xy, m operand.Op) (*intrep.Instruction, error)

VMOVNTPD: Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint.

Forms:

VMOVNTPD xmm m128
VMOVNTPD ymm m256

func VMOVNTPS ¶

func VMOVNTPS(xy, m operand.Op) (*intrep.Instruction, error)

VMOVNTPS: Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint.

Forms:

VMOVNTPS xmm m128
VMOVNTPS ymm m256

func VMOVQ ¶

func VMOVQ(mrx, mrx1 operand.Op) (*intrep.Instruction, error)

VMOVQ: Move Quadword.

Forms:

VMOVQ xmm r64
VMOVQ r64 xmm
VMOVQ xmm xmm
VMOVQ m64 xmm
VMOVQ xmm m64

func VMOVSD ¶

func VMOVSD(ops ...operand.Op) (*intrep.Instruction, error)

VMOVSD: Move Scalar Double-Precision Floating-Point Value.

Forms:

VMOVSD m64 xmm
VMOVSD xmm m64
VMOVSD xmm xmm xmm

func VMOVSHDUP ¶

func VMOVSHDUP(mxy, xy operand.Op) (*intrep.Instruction, error)

VMOVSHDUP: Move Packed Single-FP High and Duplicate.

Forms:

VMOVSHDUP xmm  xmm
VMOVSHDUP m128 xmm
VMOVSHDUP ymm  ymm
VMOVSHDUP m256 ymm

func VMOVSLDUP ¶

func VMOVSLDUP(mxy, xy operand.Op) (*intrep.Instruction, error)

VMOVSLDUP: Move Packed Single-FP Low and Duplicate.

Forms:

VMOVSLDUP xmm  xmm
VMOVSLDUP m128 xmm
VMOVSLDUP ymm  ymm
VMOVSLDUP m256 ymm

func VMOVSS ¶

func VMOVSS(ops ...operand.Op) (*intrep.Instruction, error)

VMOVSS: Move Scalar Single-Precision Floating-Point Values.

Forms:

VMOVSS m32 xmm
VMOVSS xmm m32
VMOVSS xmm xmm xmm

func VMOVUPD ¶

func VMOVUPD(mxy, mxy1 operand.Op) (*intrep.Instruction, error)

VMOVUPD: Move Unaligned Packed Double-Precision Floating-Point Values.

Forms:

VMOVUPD xmm  xmm
VMOVUPD m128 xmm
VMOVUPD ymm  ymm
VMOVUPD m256 ymm
VMOVUPD xmm  m128
VMOVUPD ymm  m256

func VMOVUPS ¶

func VMOVUPS(mxy, mxy1 operand.Op) (*intrep.Instruction, error)

VMOVUPS: Move Unaligned Packed Single-Precision Floating-Point Values.

Forms:

VMOVUPS xmm  xmm
VMOVUPS m128 xmm
VMOVUPS ymm  ymm
VMOVUPS m256 ymm
VMOVUPS xmm  m128
VMOVUPS ymm  m256

func VMPSADBW ¶

func VMPSADBW(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMPSADBW: Compute Multiple Packed Sums of Absolute Difference.

Forms:

VMPSADBW imm8 xmm  xmm xmm
VMPSADBW imm8 m128 xmm xmm
VMPSADBW imm8 ymm  ymm ymm
VMPSADBW imm8 m256 ymm ymm

func VMULPD ¶

func VMULPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMULPD: Multiply Packed Double-Precision Floating-Point Values.

Forms:

VMULPD xmm  xmm xmm
VMULPD m128 xmm xmm
VMULPD ymm  ymm ymm
VMULPD m256 ymm ymm

func VMULPS ¶

func VMULPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VMULPS: Multiply Packed Single-Precision Floating-Point Values.

Forms:

VMULPS xmm  xmm xmm
VMULPS m128 xmm xmm
VMULPS ymm  ymm ymm
VMULPS m256 ymm ymm

func VMULSD ¶

func VMULSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VMULSD: Multiply Scalar Double-Precision Floating-Point Values.

Forms:

VMULSD xmm xmm xmm
VMULSD m64 xmm xmm

func VMULSS ¶

func VMULSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VMULSS: Multiply Scalar Single-Precision Floating-Point Values.

Forms:

VMULSS xmm xmm xmm
VMULSS m32 xmm xmm

func VORPD ¶

func VORPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VORPD: Bitwise Logical OR of Double-Precision Floating-Point Values.

Forms:

VORPD xmm  xmm xmm
VORPD m128 xmm xmm
VORPD ymm  ymm ymm
VORPD m256 ymm ymm

func VORPS ¶

func VORPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VORPS: Bitwise Logical OR of Single-Precision Floating-Point Values.

Forms:

VORPS xmm  xmm xmm
VORPS m128 xmm xmm
VORPS ymm  ymm ymm
VORPS m256 ymm ymm

func VPABSB ¶

func VPABSB(mxy, xy operand.Op) (*intrep.Instruction, error)

VPABSB: Packed Absolute Value of Byte Integers.

Forms:

VPABSB xmm  xmm
VPABSB m128 xmm
VPABSB ymm  ymm
VPABSB m256 ymm

func VPABSD ¶

func VPABSD(mxy, xy operand.Op) (*intrep.Instruction, error)

VPABSD: Packed Absolute Value of Doubleword Integers.

Forms:

VPABSD xmm  xmm
VPABSD m128 xmm
VPABSD ymm  ymm
VPABSD m256 ymm

func VPABSW ¶

func VPABSW(mxy, xy operand.Op) (*intrep.Instruction, error)

VPABSW: Packed Absolute Value of Word Integers.

Forms:

VPABSW xmm  xmm
VPABSW m128 xmm
VPABSW ymm  ymm
VPABSW m256 ymm

func VPACKSSDW ¶

func VPACKSSDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPACKSSDW: Pack Doublewords into Words with Signed Saturation.

Forms:

VPACKSSDW xmm  xmm xmm
VPACKSSDW m128 xmm xmm
VPACKSSDW ymm  ymm ymm
VPACKSSDW m256 ymm ymm

func VPACKSSWB ¶

func VPACKSSWB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPACKSSWB: Pack Words into Bytes with Signed Saturation.

Forms:

VPACKSSWB xmm  xmm xmm
VPACKSSWB m128 xmm xmm
VPACKSSWB ymm  ymm ymm
VPACKSSWB m256 ymm ymm

func VPACKUSDW ¶

func VPACKUSDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPACKUSDW: Pack Doublewords into Words with Unsigned Saturation.

Forms:

VPACKUSDW xmm  xmm xmm
VPACKUSDW m128 xmm xmm
VPACKUSDW ymm  ymm ymm
VPACKUSDW m256 ymm ymm

func VPACKUSWB ¶

func VPACKUSWB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPACKUSWB: Pack Words into Bytes with Unsigned Saturation.

Forms:

VPACKUSWB xmm  xmm xmm
VPACKUSWB m128 xmm xmm
VPACKUSWB ymm  ymm ymm
VPACKUSWB m256 ymm ymm

func VPADDB ¶

func VPADDB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDB: Add Packed Byte Integers.

Forms:

VPADDB xmm  xmm xmm
VPADDB m128 xmm xmm
VPADDB ymm  ymm ymm
VPADDB m256 ymm ymm

func VPADDD ¶

func VPADDD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDD: Add Packed Doubleword Integers.

Forms:

VPADDD xmm  xmm xmm
VPADDD m128 xmm xmm
VPADDD ymm  ymm ymm
VPADDD m256 ymm ymm

func VPADDQ ¶

func VPADDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDQ: Add Packed Quadword Integers.

Forms:

VPADDQ xmm  xmm xmm
VPADDQ m128 xmm xmm
VPADDQ ymm  ymm ymm
VPADDQ m256 ymm ymm

func VPADDSB ¶

func VPADDSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDSB: Add Packed Signed Byte Integers with Signed Saturation.

Forms:

VPADDSB xmm  xmm xmm
VPADDSB m128 xmm xmm
VPADDSB ymm  ymm ymm
VPADDSB m256 ymm ymm

func VPADDSW ¶

func VPADDSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDSW: Add Packed Signed Word Integers with Signed Saturation.

Forms:

VPADDSW xmm  xmm xmm
VPADDSW m128 xmm xmm
VPADDSW ymm  ymm ymm
VPADDSW m256 ymm ymm

func VPADDUSB ¶

func VPADDUSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

VPADDUSB xmm  xmm xmm
VPADDUSB m128 xmm xmm
VPADDUSB ymm  ymm ymm
VPADDUSB m256 ymm ymm

func VPADDUSW ¶

func VPADDUSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

VPADDUSW xmm  xmm xmm
VPADDUSW m128 xmm xmm
VPADDUSW ymm  ymm ymm
VPADDUSW m256 ymm ymm

func VPADDW ¶

func VPADDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPADDW: Add Packed Word Integers.

Forms:

VPADDW xmm  xmm xmm
VPADDW m128 xmm xmm
VPADDW ymm  ymm ymm
VPADDW m256 ymm ymm

func VPALIGNR ¶

func VPALIGNR(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPALIGNR: Packed Align Right.

Forms:

VPALIGNR imm8 xmm  xmm xmm
VPALIGNR imm8 m128 xmm xmm
VPALIGNR imm8 ymm  ymm ymm
VPALIGNR imm8 m256 ymm ymm

func VPAND ¶

func VPAND(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPAND: Packed Bitwise Logical AND.

Forms:

VPAND xmm  xmm xmm
VPAND m128 xmm xmm
VPAND ymm  ymm ymm
VPAND m256 ymm ymm

func VPANDN ¶

func VPANDN(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPANDN: Packed Bitwise Logical AND NOT.

Forms:

VPANDN xmm  xmm xmm
VPANDN m128 xmm xmm
VPANDN ymm  ymm ymm
VPANDN m256 ymm ymm

func VPAVGB ¶

func VPAVGB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPAVGB: Average Packed Byte Integers.

Forms:

VPAVGB xmm  xmm xmm
VPAVGB m128 xmm xmm
VPAVGB ymm  ymm ymm
VPAVGB m256 ymm ymm

func VPAVGW ¶

func VPAVGW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPAVGW: Average Packed Word Integers.

Forms:

VPAVGW xmm  xmm xmm
VPAVGW m128 xmm xmm
VPAVGW ymm  ymm ymm
VPAVGW m256 ymm ymm

func VPBLENDD ¶

func VPBLENDD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPBLENDD: Blend Packed Doublewords.

Forms:

VPBLENDD imm8 xmm  xmm xmm
VPBLENDD imm8 m128 xmm xmm
VPBLENDD imm8 ymm  ymm ymm
VPBLENDD imm8 m256 ymm ymm

func VPBLENDVB ¶

func VPBLENDVB(xy, mxy, xy1, xy2 operand.Op) (*intrep.Instruction, error)

VPBLENDVB: Variable Blend Packed Bytes.

Forms:

VPBLENDVB xmm xmm  xmm xmm
VPBLENDVB xmm m128 xmm xmm
VPBLENDVB ymm ymm  ymm ymm
VPBLENDVB ymm m256 ymm ymm

func VPBLENDW ¶

func VPBLENDW(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPBLENDW: Blend Packed Words.

Forms:

VPBLENDW imm8 xmm  xmm xmm
VPBLENDW imm8 m128 xmm xmm
VPBLENDW imm8 ymm  ymm ymm
VPBLENDW imm8 m256 ymm ymm

func VPBROADCASTB ¶

func VPBROADCASTB(mx, xy operand.Op) (*intrep.Instruction, error)

VPBROADCASTB: Broadcast Byte Integer.

Forms:

VPBROADCASTB xmm xmm
VPBROADCASTB m8  xmm
VPBROADCASTB xmm ymm
VPBROADCASTB m8  ymm

func VPBROADCASTD ¶

func VPBROADCASTD(mx, xy operand.Op) (*intrep.Instruction, error)

VPBROADCASTD: Broadcast Doubleword Integer.

Forms:

VPBROADCASTD xmm xmm
VPBROADCASTD m32 xmm
VPBROADCASTD xmm ymm
VPBROADCASTD m32 ymm

func VPBROADCASTQ ¶

func VPBROADCASTQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPBROADCASTQ: Broadcast Quadword Integer.

Forms:

VPBROADCASTQ xmm xmm
VPBROADCASTQ m64 xmm
VPBROADCASTQ xmm ymm
VPBROADCASTQ m64 ymm

func VPBROADCASTW ¶

func VPBROADCASTW(mx, xy operand.Op) (*intrep.Instruction, error)

VPBROADCASTW: Broadcast Word Integer.

Forms:

VPBROADCASTW xmm xmm
VPBROADCASTW m16 xmm
VPBROADCASTW xmm ymm
VPBROADCASTW m16 ymm

func VPCLMULQDQ ¶

func VPCLMULQDQ(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VPCLMULQDQ: Carry-Less Quadword Multiplication.

Forms:

VPCLMULQDQ imm8 xmm  xmm xmm
VPCLMULQDQ imm8 m128 xmm xmm

func VPCMPEQB ¶

func VPCMPEQB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPEQB: Compare Packed Byte Data for Equality.

Forms:

VPCMPEQB xmm  xmm xmm
VPCMPEQB m128 xmm xmm
VPCMPEQB ymm  ymm ymm
VPCMPEQB m256 ymm ymm

func VPCMPEQD ¶

func VPCMPEQD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPEQD: Compare Packed Doubleword Data for Equality.

Forms:

VPCMPEQD xmm  xmm xmm
VPCMPEQD m128 xmm xmm
VPCMPEQD ymm  ymm ymm
VPCMPEQD m256 ymm ymm

func VPCMPEQQ ¶

func VPCMPEQQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPEQQ: Compare Packed Quadword Data for Equality.

Forms:

VPCMPEQQ xmm  xmm xmm
VPCMPEQQ m128 xmm xmm
VPCMPEQQ ymm  ymm ymm
VPCMPEQQ m256 ymm ymm

func VPCMPEQW ¶

func VPCMPEQW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPEQW: Compare Packed Word Data for Equality.

Forms:

VPCMPEQW xmm  xmm xmm
VPCMPEQW m128 xmm xmm
VPCMPEQW ymm  ymm ymm
VPCMPEQW m256 ymm ymm

func VPCMPESTRI ¶

func VPCMPESTRI(i, mx, x operand.Op) (*intrep.Instruction, error)

VPCMPESTRI: Packed Compare Explicit Length Strings, Return Index.

Forms:

VPCMPESTRI imm8 xmm  xmm
VPCMPESTRI imm8 m128 xmm

func VPCMPESTRM ¶

func VPCMPESTRM(i, mx, x operand.Op) (*intrep.Instruction, error)

VPCMPESTRM: Packed Compare Explicit Length Strings, Return Mask.

Forms:

VPCMPESTRM imm8 xmm  xmm
VPCMPESTRM imm8 m128 xmm

func VPCMPGTB ¶

func VPCMPGTB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPGTB: Compare Packed Signed Byte Integers for Greater Than.

Forms:

VPCMPGTB xmm  xmm xmm
VPCMPGTB m128 xmm xmm
VPCMPGTB ymm  ymm ymm
VPCMPGTB m256 ymm ymm

func VPCMPGTD ¶

func VPCMPGTD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPGTD: Compare Packed Signed Doubleword Integers for Greater Than.

Forms:

VPCMPGTD xmm  xmm xmm
VPCMPGTD m128 xmm xmm
VPCMPGTD ymm  ymm ymm
VPCMPGTD m256 ymm ymm

func VPCMPGTQ ¶

func VPCMPGTQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPGTQ: Compare Packed Data for Greater Than.

Forms:

VPCMPGTQ xmm  xmm xmm
VPCMPGTQ m128 xmm xmm
VPCMPGTQ ymm  ymm ymm
VPCMPGTQ m256 ymm ymm

func VPCMPGTW ¶

func VPCMPGTW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPCMPGTW: Compare Packed Signed Word Integers for Greater Than.

Forms:

VPCMPGTW xmm  xmm xmm
VPCMPGTW m128 xmm xmm
VPCMPGTW ymm  ymm ymm
VPCMPGTW m256 ymm ymm

func VPCMPISTRI ¶

func VPCMPISTRI(i, mx, x operand.Op) (*intrep.Instruction, error)

VPCMPISTRI: Packed Compare Implicit Length Strings, Return Index.

Forms:

VPCMPISTRI imm8 xmm  xmm
VPCMPISTRI imm8 m128 xmm

func VPCMPISTRM ¶

func VPCMPISTRM(i, mx, x operand.Op) (*intrep.Instruction, error)

VPCMPISTRM: Packed Compare Implicit Length Strings, Return Mask.

Forms:

VPCMPISTRM imm8 xmm  xmm
VPCMPISTRM imm8 m128 xmm

func VPERM2F128 ¶

func VPERM2F128(i, my, y, y1 operand.Op) (*intrep.Instruction, error)

VPERM2F128: Permute Floating-Point Values.

Forms:

VPERM2F128 imm8 ymm  ymm ymm
VPERM2F128 imm8 m256 ymm ymm

func VPERM2I128 ¶

func VPERM2I128(i, my, y, y1 operand.Op) (*intrep.Instruction, error)

VPERM2I128: Permute 128-Bit Integer Values.

Forms:

VPERM2I128 imm8 ymm  ymm ymm
VPERM2I128 imm8 m256 ymm ymm

func VPERMD ¶

func VPERMD(my, y, y1 operand.Op) (*intrep.Instruction, error)

VPERMD: Permute Doubleword Integers.

Forms:

VPERMD ymm  ymm ymm
VPERMD m256 ymm ymm

func VPERMILPD ¶

func VPERMILPD(imxy, mxy, xy operand.Op) (*intrep.Instruction, error)

VPERMILPD: Permute Double-Precision Floating-Point Values.

Forms:

VPERMILPD imm8 xmm  xmm
VPERMILPD xmm  xmm  xmm
VPERMILPD m128 xmm  xmm
VPERMILPD imm8 m128 xmm
VPERMILPD imm8 ymm  ymm
VPERMILPD ymm  ymm  ymm
VPERMILPD m256 ymm  ymm
VPERMILPD imm8 m256 ymm

func VPERMILPS ¶

func VPERMILPS(imxy, mxy, xy operand.Op) (*intrep.Instruction, error)

VPERMILPS: Permute Single-Precision Floating-Point Values.

Forms:

VPERMILPS imm8 xmm  xmm
VPERMILPS xmm  xmm  xmm
VPERMILPS m128 xmm  xmm
VPERMILPS imm8 m128 xmm
VPERMILPS imm8 ymm  ymm
VPERMILPS ymm  ymm  ymm
VPERMILPS m256 ymm  ymm
VPERMILPS imm8 m256 ymm

func VPERMPD ¶

func VPERMPD(i, my, y operand.Op) (*intrep.Instruction, error)

VPERMPD: Permute Double-Precision Floating-Point Elements.

Forms:

VPERMPD imm8 ymm  ymm
VPERMPD imm8 m256 ymm

func VPERMPS ¶

func VPERMPS(my, y, y1 operand.Op) (*intrep.Instruction, error)

VPERMPS: Permute Single-Precision Floating-Point Elements.

Forms:

VPERMPS ymm  ymm ymm
VPERMPS m256 ymm ymm

func VPERMQ ¶

func VPERMQ(i, my, y operand.Op) (*intrep.Instruction, error)

VPERMQ: Permute Quadword Integers.

Forms:

VPERMQ imm8 ymm  ymm
VPERMQ imm8 m256 ymm

func VPEXTRB ¶

func VPEXTRB(i, x, mr operand.Op) (*intrep.Instruction, error)

VPEXTRB: Extract Byte.

Forms:

VPEXTRB imm8 xmm r32
VPEXTRB imm8 xmm m8

func VPEXTRD ¶

func VPEXTRD(i, x, mr operand.Op) (*intrep.Instruction, error)

VPEXTRD: Extract Doubleword.

Forms:

VPEXTRD imm8 xmm r32
VPEXTRD imm8 xmm m32

func VPEXTRQ ¶

func VPEXTRQ(i, x, mr operand.Op) (*intrep.Instruction, error)

VPEXTRQ: Extract Quadword.

Forms:

VPEXTRQ imm8 xmm r64
VPEXTRQ imm8 xmm m64

func VPEXTRW ¶

func VPEXTRW(i, x, mr operand.Op) (*intrep.Instruction, error)

VPEXTRW: Extract Word.

Forms:

VPEXTRW imm8 xmm r32
VPEXTRW imm8 xmm m16

func VPGATHERDD ¶

func VPGATHERDD(xy, v, xy1 operand.Op) (*intrep.Instruction, error)

VPGATHERDD: Gather Packed Doubleword Values Using Signed Doubleword Indices.

Forms:

VPGATHERDD xmm vm32x xmm
VPGATHERDD ymm vm32y ymm

func VPGATHERDQ ¶

func VPGATHERDQ(xy, v, xy1 operand.Op) (*intrep.Instruction, error)

VPGATHERDQ: Gather Packed Quadword Values Using Signed Doubleword Indices.

Forms:

VPGATHERDQ xmm vm32x xmm
VPGATHERDQ ymm vm32x ymm

func VPGATHERQD ¶

func VPGATHERQD(x, v, x1 operand.Op) (*intrep.Instruction, error)

VPGATHERQD: Gather Packed Doubleword Values Using Signed Quadword Indices.

Forms:

VPGATHERQD xmm vm64x xmm
VPGATHERQD xmm vm64y xmm

func VPGATHERQQ ¶

func VPGATHERQQ(xy, v, xy1 operand.Op) (*intrep.Instruction, error)

VPGATHERQQ: Gather Packed Quadword Values Using Signed Quadword Indices.

Forms:

VPGATHERQQ xmm vm64x xmm
VPGATHERQQ ymm vm64y ymm

func VPHADDD ¶

func VPHADDD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPHADDD: Packed Horizontal Add Doubleword Integer.

Forms:

VPHADDD xmm  xmm xmm
VPHADDD m128 xmm xmm
VPHADDD ymm  ymm ymm
VPHADDD m256 ymm ymm

func VPHADDSW ¶

func VPHADDSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPHADDSW: Packed Horizontal Add Signed Word Integers with Signed Saturation.

Forms:

VPHADDSW xmm  xmm xmm
VPHADDSW m128 xmm xmm
VPHADDSW ymm  ymm ymm
VPHADDSW m256 ymm ymm

func VPHADDW ¶

func VPHADDW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPHADDW: Packed Horizontal Add Word Integers.

Forms:

VPHADDW xmm  xmm xmm
VPHADDW m128 xmm xmm
VPHADDW ymm  ymm ymm
VPHADDW m256 ymm ymm

func VPHMINPOSUW ¶

func VPHMINPOSUW(mx, x operand.Op) (*intrep.Instruction, error)

VPHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers.

Forms:

VPHMINPOSUW xmm  xmm
VPHMINPOSUW m128 xmm

func VPHSUBD ¶

func VPHSUBD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPHSUBD: Packed Horizontal Subtract Doubleword Integers.

Forms:

VPHSUBD xmm  xmm xmm
VPHSUBD m128 xmm xmm
VPHSUBD ymm  ymm ymm
VPHSUBD m256 ymm ymm

func VPHSUBSW ¶

func VPHSUBSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPHSUBSW: Packed Horizontal Subtract Signed Word Integers with Signed Saturation.

Forms:

VPHSUBSW xmm  xmm xmm
VPHSUBSW m128 xmm xmm
VPHSUBSW ymm  ymm ymm
VPHSUBSW m256 ymm ymm

func VPHSUBW ¶

func VPHSUBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPHSUBW: Packed Horizontal Subtract Word Integers.

Forms:

VPHSUBW xmm  xmm xmm
VPHSUBW m128 xmm xmm
VPHSUBW ymm  ymm ymm
VPHSUBW m256 ymm ymm

func VPINSRB ¶

func VPINSRB(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)

VPINSRB: Insert Byte.

Forms:

VPINSRB imm8 r32 xmm xmm
VPINSRB imm8 m8  xmm xmm

func VPINSRD ¶

func VPINSRD(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)

VPINSRD: Insert Doubleword.

Forms:

VPINSRD imm8 r32 xmm xmm
VPINSRD imm8 m32 xmm xmm

func VPINSRQ ¶

func VPINSRQ(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)

VPINSRQ: Insert Quadword.

Forms:

VPINSRQ imm8 r64 xmm xmm
VPINSRQ imm8 m64 xmm xmm

func VPINSRW ¶

func VPINSRW(i, mr, x, x1 operand.Op) (*intrep.Instruction, error)

VPINSRW: Insert Word.

Forms:

VPINSRW imm8 r32 xmm xmm
VPINSRW imm8 m16 xmm xmm

func VPMADDUBSW ¶

func VPMADDUBSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMADDUBSW: Multiply and Add Packed Signed and Unsigned Byte Integers.

Forms:

VPMADDUBSW xmm  xmm xmm
VPMADDUBSW m128 xmm xmm
VPMADDUBSW ymm  ymm ymm
VPMADDUBSW m256 ymm ymm

func VPMADDWD ¶

func VPMADDWD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMADDWD: Multiply and Add Packed Signed Word Integers.

Forms:

VPMADDWD xmm  xmm xmm
VPMADDWD m128 xmm xmm
VPMADDWD ymm  ymm ymm
VPMADDWD m256 ymm ymm

func VPMASKMOVD ¶

func VPMASKMOVD(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)

VPMASKMOVD: Conditional Move Packed Doubleword Integers.

Forms:

VPMASKMOVD m128 xmm xmm
VPMASKMOVD m256 ymm ymm
VPMASKMOVD xmm  xmm m128
VPMASKMOVD ymm  ymm m256

func VPMASKMOVQ ¶

func VPMASKMOVQ(mxy, xy, mxy1 operand.Op) (*intrep.Instruction, error)

VPMASKMOVQ: Conditional Move Packed Quadword Integers.

Forms:

VPMASKMOVQ m128 xmm xmm
VPMASKMOVQ m256 ymm ymm
VPMASKMOVQ xmm  xmm m128
VPMASKMOVQ ymm  ymm m256

func VPMAXSB ¶

func VPMAXSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMAXSB: Maximum of Packed Signed Byte Integers.

Forms:

VPMAXSB xmm  xmm xmm
VPMAXSB m128 xmm xmm
VPMAXSB ymm  ymm ymm
VPMAXSB m256 ymm ymm

func VPMAXSD ¶

func VPMAXSD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMAXSD: Maximum of Packed Signed Doubleword Integers.

Forms:

VPMAXSD xmm  xmm xmm
VPMAXSD m128 xmm xmm
VPMAXSD ymm  ymm ymm
VPMAXSD m256 ymm ymm

func VPMAXSW ¶

func VPMAXSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMAXSW: Maximum of Packed Signed Word Integers.

Forms:

VPMAXSW xmm  xmm xmm
VPMAXSW m128 xmm xmm
VPMAXSW ymm  ymm ymm
VPMAXSW m256 ymm ymm

func VPMAXUB ¶

func VPMAXUB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMAXUB: Maximum of Packed Unsigned Byte Integers.

Forms:

VPMAXUB xmm  xmm xmm
VPMAXUB m128 xmm xmm
VPMAXUB ymm  ymm ymm
VPMAXUB m256 ymm ymm

func VPMAXUD ¶

func VPMAXUD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMAXUD: Maximum of Packed Unsigned Doubleword Integers.

Forms:

VPMAXUD xmm  xmm xmm
VPMAXUD m128 xmm xmm
VPMAXUD ymm  ymm ymm
VPMAXUD m256 ymm ymm

func VPMAXUW ¶

func VPMAXUW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMAXUW: Maximum of Packed Unsigned Word Integers.

Forms:

VPMAXUW xmm  xmm xmm
VPMAXUW m128 xmm xmm
VPMAXUW ymm  ymm ymm
VPMAXUW m256 ymm ymm

func VPMINSB ¶

func VPMINSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMINSB: Minimum of Packed Signed Byte Integers.

Forms:

VPMINSB xmm  xmm xmm
VPMINSB m128 xmm xmm
VPMINSB ymm  ymm ymm
VPMINSB m256 ymm ymm

func VPMINSD ¶

func VPMINSD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMINSD: Minimum of Packed Signed Doubleword Integers.

Forms:

VPMINSD xmm  xmm xmm
VPMINSD m128 xmm xmm
VPMINSD ymm  ymm ymm
VPMINSD m256 ymm ymm

func VPMINSW ¶

func VPMINSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMINSW: Minimum of Packed Signed Word Integers.

Forms:

VPMINSW xmm  xmm xmm
VPMINSW m128 xmm xmm
VPMINSW ymm  ymm ymm
VPMINSW m256 ymm ymm

func VPMINUB ¶

func VPMINUB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMINUB: Minimum of Packed Unsigned Byte Integers.

Forms:

VPMINUB xmm  xmm xmm
VPMINUB m128 xmm xmm
VPMINUB ymm  ymm ymm
VPMINUB m256 ymm ymm

func VPMINUD ¶

func VPMINUD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMINUD: Minimum of Packed Unsigned Doubleword Integers.

Forms:

VPMINUD xmm  xmm xmm
VPMINUD m128 xmm xmm
VPMINUD ymm  ymm ymm
VPMINUD m256 ymm ymm

func VPMINUW ¶

func VPMINUW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMINUW: Minimum of Packed Unsigned Word Integers.

Forms:

VPMINUW xmm  xmm xmm
VPMINUW m128 xmm xmm
VPMINUW ymm  ymm ymm
VPMINUW m256 ymm ymm

func VPMOVMSKB ¶

func VPMOVMSKB(xy, r operand.Op) (*intrep.Instruction, error)

VPMOVMSKB: Move Byte Mask.

Forms:

VPMOVMSKB xmm r32
VPMOVMSKB ymm r32

func VPMOVSXBD ¶

func VPMOVSXBD(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVSXBD: Move Packed Byte Integers to Doubleword Integers with Sign Extension.

Forms:

VPMOVSXBD xmm xmm
VPMOVSXBD m32 xmm
VPMOVSXBD xmm ymm
VPMOVSXBD m64 ymm

func VPMOVSXBQ ¶

func VPMOVSXBQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVSXBQ: Move Packed Byte Integers to Quadword Integers with Sign Extension.

Forms:

VPMOVSXBQ xmm xmm
VPMOVSXBQ m16 xmm
VPMOVSXBQ xmm ymm
VPMOVSXBQ m32 ymm

func VPMOVSXBW ¶

func VPMOVSXBW(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVSXBW: Move Packed Byte Integers to Word Integers with Sign Extension.

Forms:

VPMOVSXBW xmm  xmm
VPMOVSXBW m64  xmm
VPMOVSXBW xmm  ymm
VPMOVSXBW m128 ymm

func VPMOVSXDQ ¶

func VPMOVSXDQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVSXDQ: Move Packed Doubleword Integers to Quadword Integers with Sign Extension.

Forms:

VPMOVSXDQ xmm  xmm
VPMOVSXDQ m64  xmm
VPMOVSXDQ xmm  ymm
VPMOVSXDQ m128 ymm

func VPMOVSXWD ¶

func VPMOVSXWD(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVSXWD: Move Packed Word Integers to Doubleword Integers with Sign Extension.

Forms:

VPMOVSXWD xmm  xmm
VPMOVSXWD m64  xmm
VPMOVSXWD xmm  ymm
VPMOVSXWD m128 ymm

func VPMOVSXWQ ¶

func VPMOVSXWQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVSXWQ: Move Packed Word Integers to Quadword Integers with Sign Extension.

Forms:

VPMOVSXWQ xmm xmm
VPMOVSXWQ m32 xmm
VPMOVSXWQ xmm ymm
VPMOVSXWQ m64 ymm

func VPMOVZXBD ¶

func VPMOVZXBD(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVZXBD: Move Packed Byte Integers to Doubleword Integers with Zero Extension.

Forms:

VPMOVZXBD xmm xmm
VPMOVZXBD m32 xmm
VPMOVZXBD xmm ymm
VPMOVZXBD m64 ymm

func VPMOVZXBQ ¶

func VPMOVZXBQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVZXBQ: Move Packed Byte Integers to Quadword Integers with Zero Extension.

Forms:

VPMOVZXBQ xmm xmm
VPMOVZXBQ m16 xmm
VPMOVZXBQ xmm ymm
VPMOVZXBQ m32 ymm

func VPMOVZXBW ¶

func VPMOVZXBW(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVZXBW: Move Packed Byte Integers to Word Integers with Zero Extension.

Forms:

VPMOVZXBW xmm  xmm
VPMOVZXBW m64  xmm
VPMOVZXBW xmm  ymm
VPMOVZXBW m128 ymm

func VPMOVZXDQ ¶

func VPMOVZXDQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVZXDQ: Move Packed Doubleword Integers to Quadword Integers with Zero Extension.

Forms:

VPMOVZXDQ xmm  xmm
VPMOVZXDQ m64  xmm
VPMOVZXDQ xmm  ymm
VPMOVZXDQ m128 ymm

func VPMOVZXWD ¶

func VPMOVZXWD(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVZXWD: Move Packed Word Integers to Doubleword Integers with Zero Extension.

Forms:

VPMOVZXWD xmm  xmm
VPMOVZXWD m64  xmm
VPMOVZXWD xmm  ymm
VPMOVZXWD m128 ymm

func VPMOVZXWQ ¶

func VPMOVZXWQ(mx, xy operand.Op) (*intrep.Instruction, error)

VPMOVZXWQ: Move Packed Word Integers to Quadword Integers with Zero Extension.

Forms:

VPMOVZXWQ xmm xmm
VPMOVZXWQ m32 xmm
VPMOVZXWQ xmm ymm
VPMOVZXWQ m64 ymm

func VPMULDQ ¶

func VPMULDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULDQ: Multiply Packed Signed Doubleword Integers and Store Quadword Result.

Forms:

VPMULDQ xmm  xmm xmm
VPMULDQ m128 xmm xmm
VPMULDQ ymm  ymm ymm
VPMULDQ m256 ymm ymm

func VPMULHRSW ¶

func VPMULHRSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULHRSW: Packed Multiply Signed Word Integers and Store High Result with Round and Scale.

Forms:

VPMULHRSW xmm  xmm xmm
VPMULHRSW m128 xmm xmm
VPMULHRSW ymm  ymm ymm
VPMULHRSW m256 ymm ymm

func VPMULHUW ¶

func VPMULHUW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULHUW: Multiply Packed Unsigned Word Integers and Store High Result.

Forms:

VPMULHUW xmm  xmm xmm
VPMULHUW m128 xmm xmm
VPMULHUW ymm  ymm ymm
VPMULHUW m256 ymm ymm

func VPMULHW ¶

func VPMULHW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULHW: Multiply Packed Signed Word Integers and Store High Result.

Forms:

VPMULHW xmm  xmm xmm
VPMULHW m128 xmm xmm
VPMULHW ymm  ymm ymm
VPMULHW m256 ymm ymm

func VPMULLD ¶

func VPMULLD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULLD: Multiply Packed Signed Doubleword Integers and Store Low Result.

Forms:

VPMULLD xmm  xmm xmm
VPMULLD m128 xmm xmm
VPMULLD ymm  ymm ymm
VPMULLD m256 ymm ymm

func VPMULLW ¶

func VPMULLW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULLW: Multiply Packed Signed Word Integers and Store Low Result.

Forms:

VPMULLW xmm  xmm xmm
VPMULLW m128 xmm xmm
VPMULLW ymm  ymm ymm
VPMULLW m256 ymm ymm

func VPMULUDQ ¶

func VPMULUDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPMULUDQ: Multiply Packed Unsigned Doubleword Integers.

Forms:

VPMULUDQ xmm  xmm xmm
VPMULUDQ m128 xmm xmm
VPMULUDQ ymm  ymm ymm
VPMULUDQ m256 ymm ymm

func VPOR ¶

func VPOR(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPOR: Packed Bitwise Logical OR.

Forms:

VPOR xmm  xmm xmm
VPOR m128 xmm xmm
VPOR ymm  ymm ymm
VPOR m256 ymm ymm

func VPSADBW ¶

func VPSADBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSADBW: Compute Sum of Absolute Differences.

Forms:

VPSADBW xmm  xmm xmm
VPSADBW m128 xmm xmm
VPSADBW ymm  ymm ymm
VPSADBW m256 ymm ymm

func VPSHUFB ¶

func VPSHUFB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSHUFB: Packed Shuffle Bytes.

Forms:

VPSHUFB xmm  xmm xmm
VPSHUFB m128 xmm xmm
VPSHUFB ymm  ymm ymm
VPSHUFB m256 ymm ymm

func VPSHUFD ¶

func VPSHUFD(i, mxy, xy operand.Op) (*intrep.Instruction, error)

VPSHUFD: Shuffle Packed Doublewords.

Forms:

VPSHUFD imm8 xmm  xmm
VPSHUFD imm8 m128 xmm
VPSHUFD imm8 ymm  ymm
VPSHUFD imm8 m256 ymm

func VPSHUFHW ¶

func VPSHUFHW(i, mxy, xy operand.Op) (*intrep.Instruction, error)

VPSHUFHW: Shuffle Packed High Words.

Forms:

VPSHUFHW imm8 xmm  xmm
VPSHUFHW imm8 m128 xmm
VPSHUFHW imm8 ymm  ymm
VPSHUFHW imm8 m256 ymm

func VPSHUFLW ¶

func VPSHUFLW(i, mxy, xy operand.Op) (*intrep.Instruction, error)

VPSHUFLW: Shuffle Packed Low Words.

Forms:

VPSHUFLW imm8 xmm  xmm
VPSHUFLW imm8 m128 xmm
VPSHUFLW imm8 ymm  ymm
VPSHUFLW imm8 m256 ymm

func VPSIGNB ¶

func VPSIGNB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSIGNB: Packed Sign of Byte Integers.

Forms:

VPSIGNB xmm  xmm xmm
VPSIGNB m128 xmm xmm
VPSIGNB ymm  ymm ymm
VPSIGNB m256 ymm ymm

func VPSIGND ¶

func VPSIGND(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSIGND: Packed Sign of Doubleword Integers.

Forms:

VPSIGND xmm  xmm xmm
VPSIGND m128 xmm xmm
VPSIGND ymm  ymm ymm
VPSIGND m256 ymm ymm

func VPSIGNW ¶

func VPSIGNW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSIGNW: Packed Sign of Word Integers.

Forms:

VPSIGNW xmm  xmm xmm
VPSIGNW m128 xmm xmm
VPSIGNW ymm  ymm ymm
VPSIGNW m256 ymm ymm

func VPSLLD ¶

func VPSLLD(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSLLD: Shift Packed Doubleword Data Left Logical.

Forms:

VPSLLD imm8 xmm xmm
VPSLLD xmm  xmm xmm
VPSLLD m128 xmm xmm
VPSLLD imm8 ymm ymm
VPSLLD xmm  ymm ymm
VPSLLD m128 ymm ymm

func VPSLLDQ ¶

func VPSLLDQ(i, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSLLDQ: Shift Packed Double Quadword Left Logical.

Forms:

VPSLLDQ imm8 xmm xmm
VPSLLDQ imm8 ymm ymm

func VPSLLQ ¶

func VPSLLQ(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSLLQ: Shift Packed Quadword Data Left Logical.

Forms:

VPSLLQ imm8 xmm xmm
VPSLLQ xmm  xmm xmm
VPSLLQ m128 xmm xmm
VPSLLQ imm8 ymm ymm
VPSLLQ xmm  ymm ymm
VPSLLQ m128 ymm ymm

func VPSLLVD ¶

func VPSLLVD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSLLVD: Variable Shift Packed Doubleword Data Left Logical.

Forms:

VPSLLVD xmm  xmm xmm
VPSLLVD m128 xmm xmm
VPSLLVD ymm  ymm ymm
VPSLLVD m256 ymm ymm

func VPSLLVQ ¶

func VPSLLVQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSLLVQ: Variable Shift Packed Quadword Data Left Logical.

Forms:

VPSLLVQ xmm  xmm xmm
VPSLLVQ m128 xmm xmm
VPSLLVQ ymm  ymm ymm
VPSLLVQ m256 ymm ymm

func VPSLLW ¶

func VPSLLW(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSLLW: Shift Packed Word Data Left Logical.

Forms:

VPSLLW imm8 xmm xmm
VPSLLW xmm  xmm xmm
VPSLLW m128 xmm xmm
VPSLLW imm8 ymm ymm
VPSLLW xmm  ymm ymm
VPSLLW m128 ymm ymm

func VPSRAD ¶

func VPSRAD(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRAD: Shift Packed Doubleword Data Right Arithmetic.

Forms:

VPSRAD imm8 xmm xmm
VPSRAD xmm  xmm xmm
VPSRAD m128 xmm xmm
VPSRAD imm8 ymm ymm
VPSRAD xmm  ymm ymm
VPSRAD m128 ymm ymm

func VPSRAVD ¶

func VPSRAVD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRAVD: Variable Shift Packed Doubleword Data Right Arithmetic.

Forms:

VPSRAVD xmm  xmm xmm
VPSRAVD m128 xmm xmm
VPSRAVD ymm  ymm ymm
VPSRAVD m256 ymm ymm

func VPSRAW ¶

func VPSRAW(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRAW: Shift Packed Word Data Right Arithmetic.

Forms:

VPSRAW imm8 xmm xmm
VPSRAW xmm  xmm xmm
VPSRAW m128 xmm xmm
VPSRAW imm8 ymm ymm
VPSRAW xmm  ymm ymm
VPSRAW m128 ymm ymm

func VPSRLD ¶

func VPSRLD(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRLD: Shift Packed Doubleword Data Right Logical.

Forms:

VPSRLD imm8 xmm xmm
VPSRLD xmm  xmm xmm
VPSRLD m128 xmm xmm
VPSRLD imm8 ymm ymm
VPSRLD xmm  ymm ymm
VPSRLD m128 ymm ymm

func VPSRLDQ ¶

func VPSRLDQ(i, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRLDQ: Shift Packed Double Quadword Right Logical.

Forms:

VPSRLDQ imm8 xmm xmm
VPSRLDQ imm8 ymm ymm

func VPSRLQ ¶

func VPSRLQ(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRLQ: Shift Packed Quadword Data Right Logical.

Forms:

VPSRLQ imm8 xmm xmm
VPSRLQ xmm  xmm xmm
VPSRLQ m128 xmm xmm
VPSRLQ imm8 ymm ymm
VPSRLQ xmm  ymm ymm
VPSRLQ m128 ymm ymm

func VPSRLVD ¶

func VPSRLVD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRLVD: Variable Shift Packed Doubleword Data Right Logical.

Forms:

VPSRLVD xmm  xmm xmm
VPSRLVD m128 xmm xmm
VPSRLVD ymm  ymm ymm
VPSRLVD m256 ymm ymm

func VPSRLVQ ¶

func VPSRLVQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRLVQ: Variable Shift Packed Quadword Data Right Logical.

Forms:

VPSRLVQ xmm  xmm xmm
VPSRLVQ m128 xmm xmm
VPSRLVQ ymm  ymm ymm
VPSRLVQ m256 ymm ymm

func VPSRLW ¶

func VPSRLW(imx, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSRLW: Shift Packed Word Data Right Logical.

Forms:

VPSRLW imm8 xmm xmm
VPSRLW xmm  xmm xmm
VPSRLW m128 xmm xmm
VPSRLW imm8 ymm ymm
VPSRLW xmm  ymm ymm
VPSRLW m128 ymm ymm

func VPSUBB ¶

func VPSUBB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBB: Subtract Packed Byte Integers.

Forms:

VPSUBB xmm  xmm xmm
VPSUBB m128 xmm xmm
VPSUBB ymm  ymm ymm
VPSUBB m256 ymm ymm

func VPSUBD ¶

func VPSUBD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBD: Subtract Packed Doubleword Integers.

Forms:

VPSUBD xmm  xmm xmm
VPSUBD m128 xmm xmm
VPSUBD ymm  ymm ymm
VPSUBD m256 ymm ymm

func VPSUBQ ¶

func VPSUBQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBQ: Subtract Packed Quadword Integers.

Forms:

VPSUBQ xmm  xmm xmm
VPSUBQ m128 xmm xmm
VPSUBQ ymm  ymm ymm
VPSUBQ m256 ymm ymm

func VPSUBSB ¶

func VPSUBSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation.

Forms:

VPSUBSB xmm  xmm xmm
VPSUBSB m128 xmm xmm
VPSUBSB ymm  ymm ymm
VPSUBSB m256 ymm ymm

func VPSUBSW ¶

func VPSUBSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBSW: Subtract Packed Signed Word Integers with Signed Saturation.

Forms:

VPSUBSW xmm  xmm xmm
VPSUBSW m128 xmm xmm
VPSUBSW ymm  ymm ymm
VPSUBSW m256 ymm ymm

func VPSUBUSB ¶

func VPSUBUSB(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

VPSUBUSB xmm  xmm xmm
VPSUBUSB m128 xmm xmm
VPSUBUSB ymm  ymm ymm
VPSUBUSB m256 ymm ymm

func VPSUBUSW ¶

func VPSUBUSW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

VPSUBUSW xmm  xmm xmm
VPSUBUSW m128 xmm xmm
VPSUBUSW ymm  ymm ymm
VPSUBUSW m256 ymm ymm

func VPSUBW ¶

func VPSUBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPSUBW: Subtract Packed Word Integers.

Forms:

VPSUBW xmm  xmm xmm
VPSUBW m128 xmm xmm
VPSUBW ymm  ymm ymm
VPSUBW m256 ymm ymm

func VPTEST ¶

func VPTEST(mxy, xy operand.Op) (*intrep.Instruction, error)

VPTEST: Packed Logical Compare.

Forms:

VPTEST xmm  xmm
VPTEST m128 xmm
VPTEST ymm  ymm
VPTEST m256 ymm

func VPUNPCKHBW ¶

func VPUNPCKHBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKHBW: Unpack and Interleave High-Order Bytes into Words.

Forms:

VPUNPCKHBW xmm  xmm xmm
VPUNPCKHBW m128 xmm xmm
VPUNPCKHBW ymm  ymm ymm
VPUNPCKHBW m256 ymm ymm

func VPUNPCKHDQ ¶

func VPUNPCKHDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKHDQ: Unpack and Interleave High-Order Doublewords into Quadwords.

Forms:

VPUNPCKHDQ xmm  xmm xmm
VPUNPCKHDQ m128 xmm xmm
VPUNPCKHDQ ymm  ymm ymm
VPUNPCKHDQ m256 ymm ymm

func VPUNPCKHQDQ ¶

func VPUNPCKHQDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKHQDQ: Unpack and Interleave High-Order Quadwords into Double Quadwords.

Forms:

VPUNPCKHQDQ xmm  xmm xmm
VPUNPCKHQDQ m128 xmm xmm
VPUNPCKHQDQ ymm  ymm ymm
VPUNPCKHQDQ m256 ymm ymm

func VPUNPCKHWD ¶

func VPUNPCKHWD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKHWD: Unpack and Interleave High-Order Words into Doublewords.

Forms:

VPUNPCKHWD xmm  xmm xmm
VPUNPCKHWD m128 xmm xmm
VPUNPCKHWD ymm  ymm ymm
VPUNPCKHWD m256 ymm ymm

func VPUNPCKLBW ¶

func VPUNPCKLBW(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKLBW: Unpack and Interleave Low-Order Bytes into Words.

Forms:

VPUNPCKLBW xmm  xmm xmm
VPUNPCKLBW m128 xmm xmm
VPUNPCKLBW ymm  ymm ymm
VPUNPCKLBW m256 ymm ymm

func VPUNPCKLDQ ¶

func VPUNPCKLDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKLDQ: Unpack and Interleave Low-Order Doublewords into Quadwords.

Forms:

VPUNPCKLDQ xmm  xmm xmm
VPUNPCKLDQ m128 xmm xmm
VPUNPCKLDQ ymm  ymm ymm
VPUNPCKLDQ m256 ymm ymm

func VPUNPCKLQDQ ¶

func VPUNPCKLQDQ(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKLQDQ: Unpack and Interleave Low-Order Quadwords into Double Quadwords.

Forms:

VPUNPCKLQDQ xmm  xmm xmm
VPUNPCKLQDQ m128 xmm xmm
VPUNPCKLQDQ ymm  ymm ymm
VPUNPCKLQDQ m256 ymm ymm

func VPUNPCKLWD ¶

func VPUNPCKLWD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPUNPCKLWD: Unpack and Interleave Low-Order Words into Doublewords.

Forms:

VPUNPCKLWD xmm  xmm xmm
VPUNPCKLWD m128 xmm xmm
VPUNPCKLWD ymm  ymm ymm
VPUNPCKLWD m256 ymm ymm

func VPXOR ¶

func VPXOR(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VPXOR: Packed Bitwise Logical Exclusive OR.

Forms:

VPXOR xmm  xmm xmm
VPXOR m128 xmm xmm
VPXOR ymm  ymm ymm
VPXOR m256 ymm ymm

func VRCPPS ¶

func VRCPPS(mxy, xy operand.Op) (*intrep.Instruction, error)

VRCPPS: Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values.

Forms:

VRCPPS xmm  xmm
VRCPPS m128 xmm
VRCPPS ymm  ymm
VRCPPS m256 ymm

func VRCPSS ¶

func VRCPSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VRCPSS: Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values.

Forms:

VRCPSS xmm xmm xmm
VRCPSS m32 xmm xmm

func VROUNDPD ¶

func VROUNDPD(i, mxy, xy operand.Op) (*intrep.Instruction, error)

VROUNDPD: Round Packed Double Precision Floating-Point Values.

Forms:

VROUNDPD imm8 xmm  xmm
VROUNDPD imm8 m128 xmm
VROUNDPD imm8 ymm  ymm
VROUNDPD imm8 m256 ymm

func VROUNDPS ¶

func VROUNDPS(i, mxy, xy operand.Op) (*intrep.Instruction, error)

VROUNDPS: Round Packed Single Precision Floating-Point Values.

Forms:

VROUNDPS imm8 xmm  xmm
VROUNDPS imm8 m128 xmm
VROUNDPS imm8 ymm  ymm
VROUNDPS imm8 m256 ymm

func VROUNDSD ¶

func VROUNDSD(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VROUNDSD: Round Scalar Double Precision Floating-Point Values.

Forms:

VROUNDSD imm8 xmm xmm xmm
VROUNDSD imm8 m64 xmm xmm

func VROUNDSS ¶

func VROUNDSS(i, mx, x, x1 operand.Op) (*intrep.Instruction, error)

VROUNDSS: Round Scalar Single Precision Floating-Point Values.

Forms:

VROUNDSS imm8 xmm xmm xmm
VROUNDSS imm8 m32 xmm xmm

func VRSQRTPS ¶

func VRSQRTPS(mxy, xy operand.Op) (*intrep.Instruction, error)

VRSQRTPS: Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values.

Forms:

VRSQRTPS xmm  xmm
VRSQRTPS m128 xmm
VRSQRTPS ymm  ymm
VRSQRTPS m256 ymm

func VRSQRTSS ¶

func VRSQRTSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VRSQRTSS: Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value.

Forms:

VRSQRTSS xmm xmm xmm
VRSQRTSS m32 xmm xmm

func VSHUFPD ¶

func VSHUFPD(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VSHUFPD: Shuffle Packed Double-Precision Floating-Point Values.

Forms:

VSHUFPD imm8 xmm  xmm xmm
VSHUFPD imm8 m128 xmm xmm
VSHUFPD imm8 ymm  ymm ymm
VSHUFPD imm8 m256 ymm ymm

func VSHUFPS ¶

func VSHUFPS(i, mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VSHUFPS: Shuffle Packed Single-Precision Floating-Point Values.

Forms:

VSHUFPS imm8 xmm  xmm xmm
VSHUFPS imm8 m128 xmm xmm
VSHUFPS imm8 ymm  ymm ymm
VSHUFPS imm8 m256 ymm ymm

func VSQRTPD ¶

func VSQRTPD(mxy, xy operand.Op) (*intrep.Instruction, error)

VSQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values.

Forms:

VSQRTPD xmm  xmm
VSQRTPD m128 xmm
VSQRTPD ymm  ymm
VSQRTPD m256 ymm

func VSQRTPS ¶

func VSQRTPS(mxy, xy operand.Op) (*intrep.Instruction, error)

VSQRTPS: Compute Square Roots of Packed Single-Precision Floating-Point Values.

Forms:

VSQRTPS xmm  xmm
VSQRTPS m128 xmm
VSQRTPS ymm  ymm
VSQRTPS m256 ymm

func VSQRTSD ¶

func VSQRTSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VSQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value.

Forms:

VSQRTSD xmm xmm xmm
VSQRTSD m64 xmm xmm

func VSQRTSS ¶

func VSQRTSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VSQRTSS: Compute Square Root of Scalar Single-Precision Floating-Point Value.

Forms:

VSQRTSS xmm xmm xmm
VSQRTSS m32 xmm xmm

func VSTMXCSR ¶

func VSTMXCSR(m operand.Op) (*intrep.Instruction, error)

VSTMXCSR: Store MXCSR Register State.

Forms:

VSTMXCSR m32

func VSUBPD ¶

func VSUBPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VSUBPD: Subtract Packed Double-Precision Floating-Point Values.

Forms:

VSUBPD xmm  xmm xmm
VSUBPD m128 xmm xmm
VSUBPD ymm  ymm ymm
VSUBPD m256 ymm ymm

func VSUBPS ¶

func VSUBPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VSUBPS: Subtract Packed Single-Precision Floating-Point Values.

Forms:

VSUBPS xmm  xmm xmm
VSUBPS m128 xmm xmm
VSUBPS ymm  ymm ymm
VSUBPS m256 ymm ymm

func VSUBSD ¶

func VSUBSD(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VSUBSD: Subtract Scalar Double-Precision Floating-Point Values.

Forms:

VSUBSD xmm xmm xmm
VSUBSD m64 xmm xmm

func VSUBSS ¶

func VSUBSS(mx, x, x1 operand.Op) (*intrep.Instruction, error)

VSUBSS: Subtract Scalar Single-Precision Floating-Point Values.

Forms:

VSUBSS xmm xmm xmm
VSUBSS m32 xmm xmm

func VTESTPD ¶

func VTESTPD(mxy, xy operand.Op) (*intrep.Instruction, error)

VTESTPD: Packed Double-Precision Floating-Point Bit Test.

Forms:

VTESTPD xmm  xmm
VTESTPD m128 xmm
VTESTPD ymm  ymm
VTESTPD m256 ymm

func VTESTPS ¶

func VTESTPS(mxy, xy operand.Op) (*intrep.Instruction, error)

VTESTPS: Packed Single-Precision Floating-Point Bit Test.

Forms:

VTESTPS xmm  xmm
VTESTPS m128 xmm
VTESTPS ymm  ymm
VTESTPS m256 ymm

func VUCOMISD ¶

func VUCOMISD(mx, x operand.Op) (*intrep.Instruction, error)

VUCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

VUCOMISD xmm xmm
VUCOMISD m64 xmm

func VUCOMISS ¶

func VUCOMISS(mx, x operand.Op) (*intrep.Instruction, error)

VUCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

VUCOMISS xmm xmm
VUCOMISS m32 xmm

func VUNPCKHPD ¶

func VUNPCKHPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VUNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values.

Forms:

VUNPCKHPD xmm  xmm xmm
VUNPCKHPD m128 xmm xmm
VUNPCKHPD ymm  ymm ymm
VUNPCKHPD m256 ymm ymm

func VUNPCKHPS ¶

func VUNPCKHPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VUNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values.

Forms:

VUNPCKHPS xmm  xmm xmm
VUNPCKHPS m128 xmm xmm
VUNPCKHPS ymm  ymm ymm
VUNPCKHPS m256 ymm ymm

func VUNPCKLPD ¶

func VUNPCKLPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VUNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values.

Forms:

VUNPCKLPD xmm  xmm xmm
VUNPCKLPD m128 xmm xmm
VUNPCKLPD ymm  ymm ymm
VUNPCKLPD m256 ymm ymm

func VUNPCKLPS ¶

func VUNPCKLPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VUNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values.

Forms:

VUNPCKLPS xmm  xmm xmm
VUNPCKLPS m128 xmm xmm
VUNPCKLPS ymm  ymm ymm
VUNPCKLPS m256 ymm ymm

func VXORPD ¶

func VXORPD(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VXORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values.

Forms:

VXORPD xmm  xmm xmm
VXORPD m128 xmm xmm
VXORPD ymm  ymm ymm
VXORPD m256 ymm ymm

func VXORPS ¶

func VXORPS(mxy, xy, xy1 operand.Op) (*intrep.Instruction, error)

VXORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values.

Forms:

VXORPS xmm  xmm xmm
VXORPS m128 xmm xmm
VXORPS ymm  ymm ymm
VXORPS m256 ymm ymm

func VZEROALL ¶

func VZEROALL() (*intrep.Instruction, error)

VZEROALL: Zero All YMM Registers.

Forms:

VZEROALL

func VZEROUPPER ¶

func VZEROUPPER() (*intrep.Instruction, error)

VZEROUPPER: Zero Upper Bits of YMM Registers.

Forms:

VZEROUPPER

func XADDB ¶

func XADDB(r, mr operand.Op) (*intrep.Instruction, error)

XADDB: Exchange and Add.

Forms:

XADDB r8 r8
XADDB r8 m8

func XADDL ¶

func XADDL(r, mr operand.Op) (*intrep.Instruction, error)

XADDL: Exchange and Add.

Forms:

XADDL r32 r32
XADDL r32 m32

func XADDQ ¶

func XADDQ(r, mr operand.Op) (*intrep.Instruction, error)

XADDQ: Exchange and Add.

Forms:

XADDQ r64 r64
XADDQ r64 m64

func XADDW ¶

func XADDW(r, mr operand.Op) (*intrep.Instruction, error)

XADDW: Exchange and Add.

Forms:

XADDW r16 r16
XADDW r16 m16

func XCHGB ¶

func XCHGB(mr, mr1 operand.Op) (*intrep.Instruction, error)

XCHGB: Exchange Register/Memory with Register.

Forms:

XCHGB r8 r8
XCHGB m8 r8
XCHGB r8 m8

func XCHGL ¶

func XCHGL(emr, emr1 operand.Op) (*intrep.Instruction, error)

XCHGL: Exchange Register/Memory with Register.

Forms:

XCHGL r32 eax
XCHGL eax r32
XCHGL r32 r32
XCHGL m32 r32
XCHGL r32 m32

func XCHGQ ¶

func XCHGQ(mr, mr1 operand.Op) (*intrep.Instruction, error)

XCHGQ: Exchange Register/Memory with Register.

Forms:

XCHGQ r64 rax
XCHGQ rax r64
XCHGQ r64 r64
XCHGQ m64 r64
XCHGQ r64 m64

func XCHGW ¶

func XCHGW(amr, amr1 operand.Op) (*intrep.Instruction, error)

XCHGW: Exchange Register/Memory with Register.

Forms:

XCHGW r16 ax
XCHGW ax  r16
XCHGW r16 r16
XCHGW m16 r16
XCHGW r16 m16

func XGETBV ¶

func XGETBV() (*intrep.Instruction, error)

XGETBV: Get Value of Extended Control Register.

Forms:

XGETBV

func XLAT ¶

func XLAT() (*intrep.Instruction, error)

XLAT: Table Look-up Translation.

Forms:

XLAT

func XORB ¶

func XORB(imr, amr operand.Op) (*intrep.Instruction, error)

XORB: Logical Exclusive OR.

Forms:

XORB imm8 al
XORB imm8 r8
XORB r8   r8
XORB m8   r8
XORB imm8 m8
XORB r8   m8

func XORL ¶

func XORL(imr, emr operand.Op) (*intrep.Instruction, error)

XORL: Logical Exclusive OR.

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 XORPD ¶

func XORPD(mx, x operand.Op) (*intrep.Instruction, error)

XORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values.

Forms:

XORPD xmm  xmm
XORPD m128 xmm

func XORPS ¶

func XORPS(mx, x operand.Op) (*intrep.Instruction, error)

XORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values.

Forms:

XORPS xmm  xmm
XORPS m128 xmm

func XORQ ¶

func XORQ(imr, mr operand.Op) (*intrep.Instruction, error)

XORQ: Logical Exclusive OR.

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 XORW ¶

func XORW(imr, amr operand.Op) (*intrep.Instruction, error)

XORW: Logical Exclusive OR.

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

Source Files ¶

doc.go gen.go zctors.go

Version: v0.2.0
Published: Apr 19, 2021
Platform: windows/amd64
Imports: 4 packages
Last checked: 1 month ago –

Tools for package owners.

?	: This menu
/	: Search site
f	: Jump to identifier
g then g	: Go to top of page
g then b	: Go to end of page
G	: Go to end of page
g then i	: Go to index
g then e	: Go to examples