package build

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

package build

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

Package build provides an assembly-like interface for incremental building of avo Files.

Index ¶

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

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

type Error

func (e Error) Error() string

type ErrorList

func (e *ErrorList) Add(err Error)
func (e *ErrorList) AddAt(p src.Position, err error)
func (e ErrorList) Err() error
func (e ErrorList) Error() string

type Flags

func NewFlags(fs *flag.FlagSet) *Flags
func (f *Flags) Config() *Config

Constants ¶

const (
	NOPROF        = attr.NOPROF
	DUPOK         = attr.DUPOK
	NOSPLIT       = attr.NOSPLIT
	RODATA        = attr.RODATA
	NOPTR         = attr.NOPTR
	WRAPPER       = attr.WRAPPER
	NEEDCTXT      = attr.NEEDCTXT
	TLSBSS        = attr.TLSBSS
	NOFRAME       = attr.NOFRAME
	REFLECTMETHOD = attr.REFLECTMETHOD
	TOPFRAME      = attr.TOPFRAME
)

TEXT and DATA attribute values included for convenience.

Functions ¶

func ADCB ¶

func ADCB(imr, amr operand.Op)

ADCB: Add with Carry.

Forms:

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

Construct and append a ADCB instruction to the active function. Operates on the global context.

func ADCL ¶

func ADCL(imr, emr operand.Op)

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

Construct and append a ADCL instruction to the active function. Operates on the global context.

func ADCQ ¶

func ADCQ(imr, mr operand.Op)

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

Construct and append a ADCQ instruction to the active function. Operates on the global context.

func ADCW ¶

func ADCW(imr, amr operand.Op)

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

Construct and append a ADCW instruction to the active function. Operates on the global context.

func ADCXL ¶

func ADCXL(mr, r operand.Op)

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

Forms:

ADCXL r32 r32
ADCXL m32 r32

Construct and append a ADCXL instruction to the active function. Operates on the global context.

func ADCXQ ¶

func ADCXQ(mr, r operand.Op)

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

Forms:

ADCXQ r64 r64
ADCXQ m64 r64

Construct and append a ADCXQ instruction to the active function. Operates on the global context.

func ADDB ¶

func ADDB(imr, amr operand.Op)

ADDB: Add.

Forms:

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

Construct and append a ADDB instruction to the active function. Operates on the global context.

func ADDL ¶

func ADDL(imr, emr operand.Op)

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

Construct and append a ADDL instruction to the active function. Operates on the global context.

func ADDPD ¶

func ADDPD(mx, x operand.Op)

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

Forms:

ADDPD xmm  xmm
ADDPD m128 xmm

Construct and append a ADDPD instruction to the active function. Operates on the global context.

func ADDPS ¶

func ADDPS(mx, x operand.Op)

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

Forms:

ADDPS xmm  xmm
ADDPS m128 xmm

Construct and append a ADDPS instruction to the active function. Operates on the global context.

func ADDQ ¶

func ADDQ(imr, mr operand.Op)

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

Construct and append a ADDQ instruction to the active function. Operates on the global context.

func ADDSD ¶

func ADDSD(mx, x operand.Op)

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

Forms:

ADDSD xmm xmm
ADDSD m64 xmm

Construct and append a ADDSD instruction to the active function. Operates on the global context.

func ADDSS ¶

func ADDSS(mx, x operand.Op)

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

Forms:

ADDSS xmm xmm
ADDSS m32 xmm

Construct and append a ADDSS instruction to the active function. Operates on the global context.

func ADDSUBPD ¶

func ADDSUBPD(mx, x operand.Op)

ADDSUBPD: Packed Double-FP Add/Subtract.

Forms:

ADDSUBPD xmm  xmm
ADDSUBPD m128 xmm

Construct and append a ADDSUBPD instruction to the active function. Operates on the global context.

func ADDSUBPS ¶

func ADDSUBPS(mx, x operand.Op)

ADDSUBPS: Packed Single-FP Add/Subtract.

Forms:

ADDSUBPS xmm  xmm
ADDSUBPS m128 xmm

Construct and append a ADDSUBPS instruction to the active function. Operates on the global context.

func ADDW ¶

func ADDW(imr, amr operand.Op)

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

Construct and append a ADDW instruction to the active function. Operates on the global context.

func ADOXL ¶

func ADOXL(mr, r operand.Op)

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

Forms:

ADOXL r32 r32
ADOXL m32 r32

Construct and append a ADOXL instruction to the active function. Operates on the global context.

func ADOXQ ¶

func ADOXQ(mr, r operand.Op)

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

Forms:

ADOXQ r64 r64
ADOXQ m64 r64

Construct and append a ADOXQ instruction to the active function. Operates on the global context.

func AESDEC ¶

func AESDEC(mx, x operand.Op)

AESDEC: Perform One Round of an AES Decryption Flow.

Forms:

AESDEC xmm  xmm
AESDEC m128 xmm

Construct and append a AESDEC instruction to the active function. Operates on the global context.

func AESDECLAST ¶

func AESDECLAST(mx, x operand.Op)

AESDECLAST: Perform Last Round of an AES Decryption Flow.

Forms:

AESDECLAST xmm  xmm
AESDECLAST m128 xmm

Construct and append a AESDECLAST instruction to the active function. Operates on the global context.

func AESENC ¶

func AESENC(mx, x operand.Op)

AESENC: Perform One Round of an AES Encryption Flow.

Forms:

AESENC xmm  xmm
AESENC m128 xmm

Construct and append a AESENC instruction to the active function. Operates on the global context.

func AESENCLAST ¶

func AESENCLAST(mx, x operand.Op)

AESENCLAST: Perform Last Round of an AES Encryption Flow.

Forms:

AESENCLAST xmm  xmm
AESENCLAST m128 xmm

Construct and append a AESENCLAST instruction to the active function. Operates on the global context.

func AESIMC ¶

func AESIMC(mx, x operand.Op)

AESIMC: Perform the AES InvMixColumn Transformation.

Forms:

AESIMC xmm  xmm
AESIMC m128 xmm

Construct and append a AESIMC instruction to the active function. Operates on the global context.

func AESKEYGENASSIST ¶

func AESKEYGENASSIST(i, mx, x operand.Op)

AESKEYGENASSIST: AES Round Key Generation Assist.

Forms:

AESKEYGENASSIST imm8 xmm  xmm
AESKEYGENASSIST imm8 m128 xmm

Construct and append a AESKEYGENASSIST instruction to the active function. Operates on the global context.

func ANDB ¶

func ANDB(imr, amr operand.Op)

ANDB: Logical AND.

Forms:

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

Construct and append a ANDB instruction to the active function. Operates on the global context.

func ANDL ¶

func ANDL(imr, emr operand.Op)

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

Construct and append a ANDL instruction to the active function. Operates on the global context.

func ANDNL ¶

func ANDNL(mr, r, r1 operand.Op)

ANDNL: Logical AND NOT.

Forms:

ANDNL r32 r32 r32
ANDNL m32 r32 r32

Construct and append a ANDNL instruction to the active function. Operates on the global context.

func ANDNPD ¶

func ANDNPD(mx, x operand.Op)

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

Forms:

ANDNPD xmm  xmm
ANDNPD m128 xmm

Construct and append a ANDNPD instruction to the active function. Operates on the global context.

func ANDNPS ¶

func ANDNPS(mx, x operand.Op)

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

Forms:

ANDNPS xmm  xmm
ANDNPS m128 xmm

Construct and append a ANDNPS instruction to the active function. Operates on the global context.

func ANDNQ ¶

func ANDNQ(mr, r, r1 operand.Op)

ANDNQ: Logical AND NOT.

Forms:

ANDNQ r64 r64 r64
ANDNQ m64 r64 r64

Construct and append a ANDNQ instruction to the active function. Operates on the global context.

func ANDPD ¶

func ANDPD(mx, x operand.Op)

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

Forms:

ANDPD xmm  xmm
ANDPD m128 xmm

Construct and append a ANDPD instruction to the active function. Operates on the global context.

func ANDPS ¶

func ANDPS(mx, x operand.Op)

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

Forms:

ANDPS xmm  xmm
ANDPS m128 xmm

Construct and append a ANDPS instruction to the active function. Operates on the global context.

func ANDQ ¶

func ANDQ(imr, mr operand.Op)

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

Construct and append a ANDQ instruction to the active function. Operates on the global context.

func ANDW ¶

func ANDW(imr, amr operand.Op)

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

Construct and append a ANDW instruction to the active function. Operates on the global context.

func AllocLocal ¶

func AllocLocal(size int) operand.Mem

AllocLocal allocates size bytes in the stack of the currently active function. Returns a reference to the base pointer for the newly allocated region.

func Attributes ¶

func Attributes(a attr.Attribute)

Attributes sets function attributes for the currently active function.

func BEXTRL ¶

func BEXTRL(r, mr, r1 operand.Op)

BEXTRL: Bit Field Extract.

Forms:

BEXTRL r32 r32 r32
BEXTRL r32 m32 r32

Construct and append a BEXTRL instruction to the active function. Operates on the global context.

func BEXTRQ ¶

func BEXTRQ(r, mr, r1 operand.Op)

BEXTRQ: Bit Field Extract.

Forms:

BEXTRQ r64 r64 r64
BEXTRQ r64 m64 r64

Construct and append a BEXTRQ instruction to the active function. Operates on the global context.

func BLENDPD ¶

func BLENDPD(i, mx, x operand.Op)

BLENDPD: Blend Packed Double Precision Floating-Point Values.

Forms:

BLENDPD imm8 xmm  xmm
BLENDPD imm8 m128 xmm

Construct and append a BLENDPD instruction to the active function. Operates on the global context.

func BLENDPS ¶

func BLENDPS(i, mx, x operand.Op)

BLENDPS: Blend Packed Single Precision Floating-Point Values.

Forms:

BLENDPS imm8 xmm  xmm
BLENDPS imm8 m128 xmm

Construct and append a BLENDPS instruction to the active function. Operates on the global context.

func BLENDVPD ¶

func BLENDVPD(x, mx, x1 operand.Op)

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

Forms:

BLENDVPD xmm0 xmm  xmm
BLENDVPD xmm0 m128 xmm

Construct and append a BLENDVPD instruction to the active function. Operates on the global context.

func BLENDVPS ¶

func BLENDVPS(x, mx, x1 operand.Op)

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

Forms:

BLENDVPS xmm0 xmm  xmm
BLENDVPS xmm0 m128 xmm

Construct and append a BLENDVPS instruction to the active function. Operates on the global context.

func BLSIL ¶

func BLSIL(mr, r operand.Op)

BLSIL: Isolate Lowest Set Bit.

Forms:

BLSIL r32 r32
BLSIL m32 r32

Construct and append a BLSIL instruction to the active function. Operates on the global context.

func BLSIQ ¶

func BLSIQ(mr, r operand.Op)

BLSIQ: Isolate Lowest Set Bit.

Forms:

BLSIQ r64 r64
BLSIQ m64 r64

Construct and append a BLSIQ instruction to the active function. Operates on the global context.

func BLSMSKL ¶

func BLSMSKL(mr, r operand.Op)

BLSMSKL: Mask From Lowest Set Bit.

Forms:

BLSMSKL r32 r32
BLSMSKL m32 r32

Construct and append a BLSMSKL instruction to the active function. Operates on the global context.

func BLSMSKQ ¶

func BLSMSKQ(mr, r operand.Op)

BLSMSKQ: Mask From Lowest Set Bit.

Forms:

BLSMSKQ r64 r64
BLSMSKQ m64 r64

Construct and append a BLSMSKQ instruction to the active function. Operates on the global context.

func BLSRL ¶

func BLSRL(mr, r operand.Op)

BLSRL: Reset Lowest Set Bit.

Forms:

BLSRL r32 r32
BLSRL m32 r32

Construct and append a BLSRL instruction to the active function. Operates on the global context.

func BLSRQ ¶

func BLSRQ(mr, r operand.Op)

BLSRQ: Reset Lowest Set Bit.

Forms:

BLSRQ r64 r64
BLSRQ m64 r64

Construct and append a BLSRQ instruction to the active function. Operates on the global context.

func BSFL ¶

func BSFL(mr, r operand.Op)

BSFL: Bit Scan Forward.

Forms:

BSFL r32 r32
BSFL m32 r32

Construct and append a BSFL instruction to the active function. Operates on the global context.

func BSFQ ¶

func BSFQ(mr, r operand.Op)

BSFQ: Bit Scan Forward.

Forms:

BSFQ r64 r64
BSFQ m64 r64

Construct and append a BSFQ instruction to the active function. Operates on the global context.

func BSFW ¶

func BSFW(mr, r operand.Op)

BSFW: Bit Scan Forward.

Forms:

BSFW r16 r16
BSFW m16 r16

Construct and append a BSFW instruction to the active function. Operates on the global context.

func BSRL ¶

func BSRL(mr, r operand.Op)

BSRL: Bit Scan Reverse.

Forms:

BSRL r32 r32
BSRL m32 r32

Construct and append a BSRL instruction to the active function. Operates on the global context.

func BSRQ ¶

func BSRQ(mr, r operand.Op)

BSRQ: Bit Scan Reverse.

Forms:

BSRQ r64 r64
BSRQ m64 r64

Construct and append a BSRQ instruction to the active function. Operates on the global context.

func BSRW ¶

func BSRW(mr, r operand.Op)

BSRW: Bit Scan Reverse.

Forms:

BSRW r16 r16
BSRW m16 r16

Construct and append a BSRW instruction to the active function. Operates on the global context.

func BSWAPL ¶

func BSWAPL(r operand.Op)

BSWAPL: Byte Swap.

Forms:

BSWAPL r32

Construct and append a BSWAPL instruction to the active function. Operates on the global context.

func BSWAPQ ¶

func BSWAPQ(r operand.Op)

BSWAPQ: Byte Swap.

Forms:

BSWAPQ r64

Construct and append a BSWAPQ instruction to the active function. Operates on the global context.

func BTCL ¶

func BTCL(ir, mr operand.Op)

BTCL: Bit Test and Complement.

Forms:

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

Construct and append a BTCL instruction to the active function. Operates on the global context.

func BTCQ ¶

func BTCQ(ir, mr operand.Op)

BTCQ: Bit Test and Complement.

Forms:

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

Construct and append a BTCQ instruction to the active function. Operates on the global context.

func BTCW ¶

func BTCW(ir, mr operand.Op)

BTCW: Bit Test and Complement.

Forms:

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

Construct and append a BTCW instruction to the active function. Operates on the global context.

func BTL ¶

func BTL(ir, mr operand.Op)

BTL: Bit Test.

Forms:

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

Construct and append a BTL instruction to the active function. Operates on the global context.

func BTQ ¶

func BTQ(ir, mr operand.Op)

BTQ: Bit Test.

Forms:

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

Construct and append a BTQ instruction to the active function. Operates on the global context.

func BTRL ¶

func BTRL(ir, mr operand.Op)

BTRL: Bit Test and Reset.

Forms:

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

Construct and append a BTRL instruction to the active function. Operates on the global context.

func BTRQ ¶

func BTRQ(ir, mr operand.Op)

BTRQ: Bit Test and Reset.

Forms:

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

Construct and append a BTRQ instruction to the active function. Operates on the global context.

func BTRW ¶

func BTRW(ir, mr operand.Op)

BTRW: Bit Test and Reset.

Forms:

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

Construct and append a BTRW instruction to the active function. Operates on the global context.

func BTSL ¶

func BTSL(ir, mr operand.Op)

BTSL: Bit Test and Set.

Forms:

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

Construct and append a BTSL instruction to the active function. Operates on the global context.

func BTSQ ¶

func BTSQ(ir, mr operand.Op)

BTSQ: Bit Test and Set.

Forms:

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

Construct and append a BTSQ instruction to the active function. Operates on the global context.

func BTSW ¶

func BTSW(ir, mr operand.Op)

BTSW: Bit Test and Set.

Forms:

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

Construct and append a BTSW instruction to the active function. Operates on the global context.

func BTW ¶

func BTW(ir, mr operand.Op)

BTW: Bit Test.

Forms:

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

Construct and append a BTW instruction to the active function. Operates on the global context.

func BZHIL ¶

func BZHIL(r, mr, r1 operand.Op)

BZHIL: Zero High Bits Starting with Specified Bit Position.

Forms:

BZHIL r32 r32 r32
BZHIL r32 m32 r32

Construct and append a BZHIL instruction to the active function. Operates on the global context.

func BZHIQ ¶

func BZHIQ(r, mr, r1 operand.Op)

BZHIQ: Zero High Bits Starting with Specified Bit Position.

Forms:

BZHIQ r64 r64 r64
BZHIQ r64 m64 r64

Construct and append a BZHIQ instruction to the active function. Operates on the global context.

func CALL ¶

func CALL(r operand.Op)

CALL: Call Procedure.

Forms:

CALL rel32

Construct and append a CALL instruction to the active function. Operates on the global context.

func CBW ¶

func CBW()

CBW: Convert Byte to Word.

Forms:

CBW

Construct and append a CBW instruction to the active function. Operates on the global context.

func CDQ ¶

func CDQ()

CDQ: Convert Doubleword to Quadword.

Forms:

CDQ

Construct and append a CDQ instruction to the active function. Operates on the global context.

func CDQE ¶

func CDQE()

CDQE: Convert Doubleword to Quadword.

Forms:

CDQE

Construct and append a CDQE instruction to the active function. Operates on the global context.

func CLC ¶

func CLC()

CLC: Clear Carry Flag.

Forms:

CLC

Construct and append a CLC instruction to the active function. Operates on the global context.

func CLD ¶

func CLD()

CLD: Clear Direction Flag.

Forms:

CLD

Construct and append a CLD instruction to the active function. Operates on the global context.

func CLFLUSH ¶

func CLFLUSH(m operand.Op)

CLFLUSH: Flush Cache Line.

Forms:

CLFLUSH m8

Construct and append a CLFLUSH instruction to the active function. Operates on the global context.

func CLFLUSHOPT ¶

func CLFLUSHOPT(m operand.Op)

CLFLUSHOPT: Flush Cache Line Optimized.

Forms:

CLFLUSHOPT m8

Construct and append a CLFLUSHOPT instruction to the active function. Operates on the global context.

func CMC ¶

func CMC()

CMC: Complement Carry Flag.

Forms:

CMC

Construct and append a CMC instruction to the active function. Operates on the global context.

func CMOVLCC ¶

func CMOVLCC(mr, r operand.Op)

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

Forms:

CMOVLCC r32 r32
CMOVLCC m32 r32

Construct and append a CMOVLCC instruction to the active function. Operates on the global context.

func CMOVLCS ¶

func CMOVLCS(mr, r operand.Op)

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

Forms:

CMOVLCS r32 r32
CMOVLCS m32 r32

Construct and append a CMOVLCS instruction to the active function. Operates on the global context.

func CMOVLEQ ¶

func CMOVLEQ(mr, r operand.Op)

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

Forms:

CMOVLEQ r32 r32
CMOVLEQ m32 r32

Construct and append a CMOVLEQ instruction to the active function. Operates on the global context.

func CMOVLGE ¶

func CMOVLGE(mr, r operand.Op)

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

Forms:

CMOVLGE r32 r32
CMOVLGE m32 r32

Construct and append a CMOVLGE instruction to the active function. Operates on the global context.

func CMOVLGT ¶

func CMOVLGT(mr, r operand.Op)

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

Forms:

CMOVLGT r32 r32
CMOVLGT m32 r32

Construct and append a CMOVLGT instruction to the active function. Operates on the global context.

func CMOVLHI ¶

func CMOVLHI(mr, r operand.Op)

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

Forms:

CMOVLHI r32 r32
CMOVLHI m32 r32

Construct and append a CMOVLHI instruction to the active function. Operates on the global context.

func CMOVLLE ¶

func CMOVLLE(mr, r operand.Op)

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

Forms:

CMOVLLE r32 r32
CMOVLLE m32 r32

Construct and append a CMOVLLE instruction to the active function. Operates on the global context.

func CMOVLLS ¶

func CMOVLLS(mr, r operand.Op)

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

Forms:

CMOVLLS r32 r32
CMOVLLS m32 r32

Construct and append a CMOVLLS instruction to the active function. Operates on the global context.

func CMOVLLT ¶

func CMOVLLT(mr, r operand.Op)

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

Forms:

CMOVLLT r32 r32
CMOVLLT m32 r32

Construct and append a CMOVLLT instruction to the active function. Operates on the global context.

func CMOVLMI ¶

func CMOVLMI(mr, r operand.Op)

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

Forms:

CMOVLMI r32 r32
CMOVLMI m32 r32

Construct and append a CMOVLMI instruction to the active function. Operates on the global context.

func CMOVLNE ¶

func CMOVLNE(mr, r operand.Op)

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

Forms:

CMOVLNE r32 r32
CMOVLNE m32 r32

Construct and append a CMOVLNE instruction to the active function. Operates on the global context.

func CMOVLOC ¶

func CMOVLOC(mr, r operand.Op)

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

Forms:

CMOVLOC r32 r32
CMOVLOC m32 r32

Construct and append a CMOVLOC instruction to the active function. Operates on the global context.

func CMOVLOS ¶

func CMOVLOS(mr, r operand.Op)

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

Forms:

CMOVLOS r32 r32
CMOVLOS m32 r32

Construct and append a CMOVLOS instruction to the active function. Operates on the global context.

func CMOVLPC ¶

func CMOVLPC(mr, r operand.Op)

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

Forms:

CMOVLPC r32 r32
CMOVLPC m32 r32

Construct and append a CMOVLPC instruction to the active function. Operates on the global context.

func CMOVLPL ¶

func CMOVLPL(mr, r operand.Op)

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

Forms:

CMOVLPL r32 r32
CMOVLPL m32 r32

Construct and append a CMOVLPL instruction to the active function. Operates on the global context.

func CMOVLPS ¶

func CMOVLPS(mr, r operand.Op)

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

Forms:

CMOVLPS r32 r32
CMOVLPS m32 r32

Construct and append a CMOVLPS instruction to the active function. Operates on the global context.

func CMOVQCC ¶

func CMOVQCC(mr, r operand.Op)

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

Forms:

CMOVQCC r64 r64
CMOVQCC m64 r64

Construct and append a CMOVQCC instruction to the active function. Operates on the global context.

func CMOVQCS ¶

func CMOVQCS(mr, r operand.Op)

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

Forms:

CMOVQCS r64 r64
CMOVQCS m64 r64

Construct and append a CMOVQCS instruction to the active function. Operates on the global context.

func CMOVQEQ ¶

func CMOVQEQ(mr, r operand.Op)

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

Forms:

CMOVQEQ r64 r64
CMOVQEQ m64 r64

Construct and append a CMOVQEQ instruction to the active function. Operates on the global context.

func CMOVQGE ¶

func CMOVQGE(mr, r operand.Op)

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

Forms:

CMOVQGE r64 r64
CMOVQGE m64 r64

Construct and append a CMOVQGE instruction to the active function. Operates on the global context.

func CMOVQGT ¶

func CMOVQGT(mr, r operand.Op)

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

Forms:

CMOVQGT r64 r64
CMOVQGT m64 r64

Construct and append a CMOVQGT instruction to the active function. Operates on the global context.

func CMOVQHI ¶

func CMOVQHI(mr, r operand.Op)

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

Forms:

CMOVQHI r64 r64
CMOVQHI m64 r64

Construct and append a CMOVQHI instruction to the active function. Operates on the global context.

func CMOVQLE ¶

func CMOVQLE(mr, r operand.Op)

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

Forms:

CMOVQLE r64 r64
CMOVQLE m64 r64

Construct and append a CMOVQLE instruction to the active function. Operates on the global context.

func CMOVQLS ¶

func CMOVQLS(mr, r operand.Op)

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

Forms:

CMOVQLS r64 r64
CMOVQLS m64 r64

Construct and append a CMOVQLS instruction to the active function. Operates on the global context.

func CMOVQLT ¶

func CMOVQLT(mr, r operand.Op)

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

Forms:

CMOVQLT r64 r64
CMOVQLT m64 r64

Construct and append a CMOVQLT instruction to the active function. Operates on the global context.

func CMOVQMI ¶

func CMOVQMI(mr, r operand.Op)

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

Forms:

CMOVQMI r64 r64
CMOVQMI m64 r64

Construct and append a CMOVQMI instruction to the active function. Operates on the global context.

func CMOVQNE ¶

func CMOVQNE(mr, r operand.Op)

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

Forms:

CMOVQNE r64 r64
CMOVQNE m64 r64

Construct and append a CMOVQNE instruction to the active function. Operates on the global context.

func CMOVQOC ¶

func CMOVQOC(mr, r operand.Op)

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

Forms:

CMOVQOC r64 r64
CMOVQOC m64 r64

Construct and append a CMOVQOC instruction to the active function. Operates on the global context.

func CMOVQOS ¶

func CMOVQOS(mr, r operand.Op)

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

Forms:

CMOVQOS r64 r64
CMOVQOS m64 r64

Construct and append a CMOVQOS instruction to the active function. Operates on the global context.

func CMOVQPC ¶

func CMOVQPC(mr, r operand.Op)

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

Forms:

CMOVQPC r64 r64
CMOVQPC m64 r64

Construct and append a CMOVQPC instruction to the active function. Operates on the global context.

func CMOVQPL ¶

func CMOVQPL(mr, r operand.Op)

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

Forms:

CMOVQPL r64 r64
CMOVQPL m64 r64

Construct and append a CMOVQPL instruction to the active function. Operates on the global context.

func CMOVQPS ¶

func CMOVQPS(mr, r operand.Op)

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

Forms:

CMOVQPS r64 r64
CMOVQPS m64 r64

Construct and append a CMOVQPS instruction to the active function. Operates on the global context.

func CMOVWCC ¶

func CMOVWCC(mr, r operand.Op)

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

Forms:

CMOVWCC r16 r16
CMOVWCC m16 r16

Construct and append a CMOVWCC instruction to the active function. Operates on the global context.

func CMOVWCS ¶

func CMOVWCS(mr, r operand.Op)

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

Forms:

CMOVWCS r16 r16
CMOVWCS m16 r16

Construct and append a CMOVWCS instruction to the active function. Operates on the global context.

func CMOVWEQ ¶

func CMOVWEQ(mr, r operand.Op)

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

Forms:

CMOVWEQ r16 r16
CMOVWEQ m16 r16

Construct and append a CMOVWEQ instruction to the active function. Operates on the global context.

func CMOVWGE ¶

func CMOVWGE(mr, r operand.Op)

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

Forms:

CMOVWGE r16 r16
CMOVWGE m16 r16

Construct and append a CMOVWGE instruction to the active function. Operates on the global context.

func CMOVWGT ¶

func CMOVWGT(mr, r operand.Op)

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

Forms:

CMOVWGT r16 r16
CMOVWGT m16 r16

Construct and append a CMOVWGT instruction to the active function. Operates on the global context.

func CMOVWHI ¶

func CMOVWHI(mr, r operand.Op)

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

Forms:

CMOVWHI r16 r16
CMOVWHI m16 r16

Construct and append a CMOVWHI instruction to the active function. Operates on the global context.

func CMOVWLE ¶

func CMOVWLE(mr, r operand.Op)

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

Forms:

CMOVWLE r16 r16
CMOVWLE m16 r16

Construct and append a CMOVWLE instruction to the active function. Operates on the global context.

func CMOVWLS ¶

func CMOVWLS(mr, r operand.Op)

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

Forms:

CMOVWLS r16 r16
CMOVWLS m16 r16

Construct and append a CMOVWLS instruction to the active function. Operates on the global context.

func CMOVWLT ¶

func CMOVWLT(mr, r operand.Op)

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

Forms:

CMOVWLT r16 r16
CMOVWLT m16 r16

Construct and append a CMOVWLT instruction to the active function. Operates on the global context.

func CMOVWMI ¶

func CMOVWMI(mr, r operand.Op)

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

Forms:

CMOVWMI r16 r16
CMOVWMI m16 r16

Construct and append a CMOVWMI instruction to the active function. Operates on the global context.

func CMOVWNE ¶

func CMOVWNE(mr, r operand.Op)

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

Forms:

CMOVWNE r16 r16
CMOVWNE m16 r16

Construct and append a CMOVWNE instruction to the active function. Operates on the global context.

func CMOVWOC ¶

func CMOVWOC(mr, r operand.Op)

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

Forms:

CMOVWOC r16 r16
CMOVWOC m16 r16

Construct and append a CMOVWOC instruction to the active function. Operates on the global context.

func CMOVWOS ¶

func CMOVWOS(mr, r operand.Op)

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

Forms:

CMOVWOS r16 r16
CMOVWOS m16 r16

Construct and append a CMOVWOS instruction to the active function. Operates on the global context.

func CMOVWPC ¶

func CMOVWPC(mr, r operand.Op)

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

Forms:

CMOVWPC r16 r16
CMOVWPC m16 r16

Construct and append a CMOVWPC instruction to the active function. Operates on the global context.

func CMOVWPL ¶

func CMOVWPL(mr, r operand.Op)

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

Forms:

CMOVWPL r16 r16
CMOVWPL m16 r16

Construct and append a CMOVWPL instruction to the active function. Operates on the global context.

func CMOVWPS ¶

func CMOVWPS(mr, r operand.Op)

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

Forms:

CMOVWPS r16 r16
CMOVWPS m16 r16

Construct and append a CMOVWPS instruction to the active function. Operates on the global context.

func CMPB ¶

func CMPB(amr, imr operand.Op)

CMPB: Compare Two Operands.

Forms:

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

Construct and append a CMPB instruction to the active function. Operates on the global context.

func CMPL ¶

func CMPL(emr, imr operand.Op)

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

Construct and append a CMPL instruction to the active function. Operates on the global context.

func CMPPD ¶

func CMPPD(mx, x, i operand.Op)

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

Forms:

CMPPD xmm  xmm imm8
CMPPD m128 xmm imm8

Construct and append a CMPPD instruction to the active function. Operates on the global context.

func CMPPS ¶

func CMPPS(mx, x, i operand.Op)

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

Forms:

CMPPS xmm  xmm imm8
CMPPS m128 xmm imm8

Construct and append a CMPPS instruction to the active function. Operates on the global context.

func CMPQ ¶

func CMPQ(mr, imr operand.Op)

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

Construct and append a CMPQ instruction to the active function. Operates on the global context.

func CMPSD ¶

func CMPSD(mx, x, i operand.Op)

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

Forms:

CMPSD xmm xmm imm8
CMPSD m64 xmm imm8

Construct and append a CMPSD instruction to the active function. Operates on the global context.

func CMPSS ¶

func CMPSS(mx, x, i operand.Op)

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

Forms:

CMPSS xmm xmm imm8
CMPSS m32 xmm imm8

Construct and append a CMPSS instruction to the active function. Operates on the global context.

func CMPW ¶

func CMPW(amr, imr operand.Op)

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

Construct and append a CMPW instruction to the active function. Operates on the global context.

func CMPXCHG16B ¶

func CMPXCHG16B(m operand.Op)

CMPXCHG16B: Compare and Exchange 16 Bytes.

Forms:

CMPXCHG16B m128

Construct and append a CMPXCHG16B instruction to the active function. Operates on the global context.

func CMPXCHG8B ¶

func CMPXCHG8B(m operand.Op)

CMPXCHG8B: Compare and Exchange 8 Bytes.

Forms:

CMPXCHG8B m64

Construct and append a CMPXCHG8B instruction to the active function. Operates on the global context.

func CMPXCHGB ¶

func CMPXCHGB(r, mr operand.Op)

CMPXCHGB: Compare and Exchange.

Forms:

CMPXCHGB r8 r8
CMPXCHGB r8 m8

Construct and append a CMPXCHGB instruction to the active function. Operates on the global context.

func CMPXCHGL ¶

func CMPXCHGL(r, mr operand.Op)

CMPXCHGL: Compare and Exchange.

Forms:

CMPXCHGL r32 r32
CMPXCHGL r32 m32

Construct and append a CMPXCHGL instruction to the active function. Operates on the global context.

func CMPXCHGQ ¶

func CMPXCHGQ(r, mr operand.Op)

CMPXCHGQ: Compare and Exchange.

Forms:

CMPXCHGQ r64 r64
CMPXCHGQ r64 m64

Construct and append a CMPXCHGQ instruction to the active function. Operates on the global context.

func CMPXCHGW ¶

func CMPXCHGW(r, mr operand.Op)

CMPXCHGW: Compare and Exchange.

Forms:

CMPXCHGW r16 r16
CMPXCHGW r16 m16

Construct and append a CMPXCHGW instruction to the active function. Operates on the global context.

func COMISD ¶

func COMISD(mx, x operand.Op)

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

Forms:

COMISD xmm xmm
COMISD m64 xmm

Construct and append a COMISD instruction to the active function. Operates on the global context.

func COMISS ¶

func COMISS(mx, x operand.Op)

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

Forms:

COMISS xmm xmm
COMISS m32 xmm

Construct and append a COMISS instruction to the active function. Operates on the global context.

func CPUID ¶

func CPUID()

CPUID: CPU Identification.

Forms:

CPUID

Construct and append a CPUID instruction to the active function. Operates on the global context.

func CQO ¶

func CQO()

CQO: Convert Quadword to Octaword.

Forms:

CQO

Construct and append a CQO instruction to the active function. Operates on the global context.

func CRC32B ¶

func CRC32B(mr, r operand.Op)

CRC32B: Accumulate CRC32 Value.

Forms:

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

Construct and append a CRC32B instruction to the active function. Operates on the global context.

func CRC32L ¶

func CRC32L(mr, r operand.Op)

CRC32L: Accumulate CRC32 Value.

Forms:

CRC32L r32 r32
CRC32L m32 r32

Construct and append a CRC32L instruction to the active function. Operates on the global context.

func CRC32Q ¶

func CRC32Q(mr, r operand.Op)

CRC32Q: Accumulate CRC32 Value.

Forms:

CRC32Q r64 r64
CRC32Q m64 r64

Construct and append a CRC32Q instruction to the active function. Operates on the global context.

func CRC32W ¶

func CRC32W(mr, r operand.Op)

CRC32W: Accumulate CRC32 Value.

Forms:

CRC32W r16 r32
CRC32W m16 r32

Construct and append a CRC32W instruction to the active function. Operates on the global context.

func CVTPD2PL ¶

func CVTPD2PL(mx, x operand.Op)

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

Forms:

CVTPD2PL xmm  xmm
CVTPD2PL m128 xmm

Construct and append a CVTPD2PL instruction to the active function. Operates on the global context.

func CVTPD2PS ¶

func CVTPD2PS(mx, x operand.Op)

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

Forms:

CVTPD2PS xmm  xmm
CVTPD2PS m128 xmm

Construct and append a CVTPD2PS instruction to the active function. Operates on the global context.

func CVTPL2PD ¶

func CVTPL2PD(mx, x operand.Op)

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

Forms:

CVTPL2PD xmm xmm
CVTPL2PD m64 xmm

Construct and append a CVTPL2PD instruction to the active function. Operates on the global context.

func CVTPL2PS ¶

func CVTPL2PS(mx, x operand.Op)

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

Forms:

CVTPL2PS xmm  xmm
CVTPL2PS m128 xmm

Construct and append a CVTPL2PS instruction to the active function. Operates on the global context.

func CVTPS2PD ¶

func CVTPS2PD(mx, x operand.Op)

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

Forms:

CVTPS2PD xmm xmm
CVTPS2PD m64 xmm

Construct and append a CVTPS2PD instruction to the active function. Operates on the global context.

func CVTPS2PL ¶

func CVTPS2PL(mx, x operand.Op)

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

Forms:

CVTPS2PL xmm  xmm
CVTPS2PL m128 xmm

Construct and append a CVTPS2PL instruction to the active function. Operates on the global context.

func CVTSD2SL ¶

func CVTSD2SL(mx, r operand.Op)

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

Forms:

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

Construct and append a CVTSD2SL instruction to the active function. Operates on the global context.

func CVTSD2SS ¶

func CVTSD2SS(mx, x operand.Op)

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

Forms:

CVTSD2SS xmm xmm
CVTSD2SS m64 xmm

Construct and append a CVTSD2SS instruction to the active function. Operates on the global context.

func CVTSL2SD ¶

func CVTSL2SD(mr, x operand.Op)

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

Forms:

CVTSL2SD r32 xmm
CVTSL2SD m32 xmm

Construct and append a CVTSL2SD instruction to the active function. Operates on the global context.

func CVTSL2SS ¶

func CVTSL2SS(mr, x operand.Op)

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

Forms:

CVTSL2SS r32 xmm
CVTSL2SS m32 xmm

Construct and append a CVTSL2SS instruction to the active function. Operates on the global context.

func CVTSQ2SD ¶

func CVTSQ2SD(mr, x operand.Op)

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

Forms:

CVTSQ2SD r64 xmm
CVTSQ2SD m64 xmm

Construct and append a CVTSQ2SD instruction to the active function. Operates on the global context.

func CVTSQ2SS ¶

func CVTSQ2SS(mr, x operand.Op)

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

Forms:

CVTSQ2SS r64 xmm
CVTSQ2SS m64 xmm

Construct and append a CVTSQ2SS instruction to the active function. Operates on the global context.

func CVTSS2SD ¶

func CVTSS2SD(mx, x operand.Op)

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

Forms:

CVTSS2SD xmm xmm
CVTSS2SD m32 xmm

Construct and append a CVTSS2SD instruction to the active function. Operates on the global context.

func CVTSS2SL ¶

func CVTSS2SL(mx, r operand.Op)

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

Forms:

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

Construct and append a CVTSS2SL instruction to the active function. Operates on the global context.

func CVTTPD2PL ¶

func CVTTPD2PL(mx, x operand.Op)

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

Forms:

CVTTPD2PL xmm  xmm
CVTTPD2PL m128 xmm

Construct and append a CVTTPD2PL instruction to the active function. Operates on the global context.

func CVTTPS2PL ¶

func CVTTPS2PL(mx, x operand.Op)

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

Forms:

CVTTPS2PL xmm  xmm
CVTTPS2PL m128 xmm

Construct and append a CVTTPS2PL instruction to the active function. Operates on the global context.

func CVTTSD2SL ¶

func CVTTSD2SL(mx, r operand.Op)

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

Forms:

CVTTSD2SL xmm r32
CVTTSD2SL m64 r32

Construct and append a CVTTSD2SL instruction to the active function. Operates on the global context.

func CVTTSD2SQ ¶

func CVTTSD2SQ(mx, r operand.Op)

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

Forms:

CVTTSD2SQ xmm r64
CVTTSD2SQ m64 r64

Construct and append a CVTTSD2SQ instruction to the active function. Operates on the global context.

func CVTTSS2SL ¶

func CVTTSS2SL(mx, r operand.Op)

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

Construct and append a CVTTSS2SL instruction to the active function. Operates on the global context.

func CWD ¶

func CWD()

CWD: Convert Word to Doubleword.

Forms:

CWD

Construct and append a CWD instruction to the active function. Operates on the global context.

func CWDE ¶

func CWDE()

CWDE: Convert Word to Doubleword.

Forms:

CWDE

Construct and append a CWDE instruction to the active function. Operates on the global context.

func Comment ¶

func Comment(lines ...string)

Comment adds comment lines to the active function.

func ConstData ¶

func ConstData(name string, v operand.Constant) operand.Mem

ConstData builds a static data section containing just the given constant.

func Constraint ¶

func Constraint(t buildtags.ConstraintConvertable)

Constraint appends a constraint to the file's build constraints.

func ConstraintExpr ¶

func ConstraintExpr(expr string)

ConstraintExpr appends a constraint to the file's build constraints. The constraint to add is parsed from the given expression. The expression should look the same as the content following "// +build " in regular build constraint comments.

func Constraints ¶

func Constraints(t buildtags.ConstraintsConvertable)

Constraints sets build constraints for the file.

func DATA ¶

func DATA(offset int, v operand.Constant)

DATA adds a data value to the active data section.

func DECB ¶

func DECB(mr operand.Op)

DECB: Decrement by 1.

Forms:

DECB r8
DECB m8

Construct and append a DECB instruction to the active function. Operates on the global context.

func DECL ¶

func DECL(mr operand.Op)

DECL: Decrement by 1.

Forms:

DECL r32
DECL m32

Construct and append a DECL instruction to the active function. Operates on the global context.

func DECQ ¶

func DECQ(mr operand.Op)

DECQ: Decrement by 1.

Forms:

DECQ r64
DECQ m64

Construct and append a DECQ instruction to the active function. Operates on the global context.

func DECW ¶

func DECW(mr operand.Op)

DECW: Decrement by 1.

Forms:

DECW r16
DECW m16

Construct and append a DECW instruction to the active function. Operates on the global context.

func DIVB ¶

func DIVB(mr operand.Op)

DIVB: Unsigned Divide.

Forms:

DIVB r8
DIVB m8

Construct and append a DIVB instruction to the active function. Operates on the global context.

func DIVL ¶

func DIVL(mr operand.Op)

DIVL: Unsigned Divide.

Forms:

DIVL r32
DIVL m32

Construct and append a DIVL instruction to the active function. Operates on the global context.

func DIVPD ¶

func DIVPD(mx, x operand.Op)

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

Forms:

DIVPD xmm  xmm
DIVPD m128 xmm

Construct and append a DIVPD instruction to the active function. Operates on the global context.

func DIVPS ¶

func DIVPS(mx, x operand.Op)

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

Forms:

DIVPS xmm  xmm
DIVPS m128 xmm

Construct and append a DIVPS instruction to the active function. Operates on the global context.

func DIVQ ¶

func DIVQ(mr operand.Op)

DIVQ: Unsigned Divide.

Forms:

DIVQ r64
DIVQ m64

Construct and append a DIVQ instruction to the active function. Operates on the global context.

func DIVSD ¶

func DIVSD(mx, x operand.Op)

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

Forms:

DIVSD xmm xmm
DIVSD m64 xmm

Construct and append a DIVSD instruction to the active function. Operates on the global context.

func DIVSS ¶

func DIVSS(mx, x operand.Op)

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

Forms:

DIVSS xmm xmm
DIVSS m32 xmm

Construct and append a DIVSS instruction to the active function. Operates on the global context.

func DIVW ¶

func DIVW(mr operand.Op)

DIVW: Unsigned Divide.

Forms:

DIVW r16
DIVW m16

Construct and append a DIVW instruction to the active function. Operates on the global context.

func DPPD ¶

func DPPD(i, mx, x operand.Op)

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

Forms:

DPPD imm8 xmm  xmm
DPPD imm8 m128 xmm

Construct and append a DPPD instruction to the active function. Operates on the global context.

func DPPS ¶

func DPPS(i, mx, x operand.Op)

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

Forms:

DPPS imm8 xmm  xmm
DPPS imm8 m128 xmm

Construct and append a DPPS instruction to the active function. Operates on the global context.

func Dereference ¶

func Dereference(ptr gotypes.Component) gotypes.Component

Dereference loads a pointer and returns its element type.

func Doc ¶

func Doc(lines ...string)

Doc sets documentation comment lines for the currently active function.

func EXTRACTPS ¶

func EXTRACTPS(i, x, mr operand.Op)

EXTRACTPS: Extract Packed Single Precision Floating-Point Value.

Forms:

EXTRACTPS imm2u xmm r32
EXTRACTPS imm2u xmm m32

Construct and append a EXTRACTPS instruction to the active function. Operates on the global context.

func GLOBL ¶

func GLOBL(name string, a attr.Attribute) operand.Mem

GLOBL declares a new static global data section with the given attributes.

func GP16 ¶

func GP16() reg.GPVirtual

GP16 allocates and returns a general-purpose 16-bit register.

func GP32 ¶

func GP32() reg.GPVirtual

GP32 allocates and returns a general-purpose 32-bit register.

func GP64 ¶

func GP64() reg.GPVirtual

GP64 allocates and returns a general-purpose 64-bit register.

func GP8 ¶

func GP8() reg.GPVirtual

GP8 allocates and returns a general-purpose 8-bit register (low byte).

func GP8H ¶

func GP8H() reg.GPVirtual

GP8H allocates and returns a general-purpose 8-bit register (high byte).

func GP8L ¶

func GP8L() reg.GPVirtual

GP8L allocates and returns a general-purpose 8-bit register (low byte).

func Generate ¶

func Generate()

Generate builds and compiles the avo file built with the global context. This should be the final line of any avo program. Configuration is determined from command-line flags.

func HADDPD ¶

func HADDPD(mx, x operand.Op)

HADDPD: Packed Double-FP Horizontal Add.

Forms:

HADDPD xmm  xmm
HADDPD m128 xmm

Construct and append a HADDPD instruction to the active function. Operates on the global context.

func HADDPS ¶

func HADDPS(mx, x operand.Op)

HADDPS: Packed Single-FP Horizontal Add.

Forms:

HADDPS xmm  xmm
HADDPS m128 xmm

Construct and append a HADDPS instruction to the active function. Operates on the global context.

func HSUBPD ¶

func HSUBPD(mx, x operand.Op)

HSUBPD: Packed Double-FP Horizontal Subtract.

Forms:

HSUBPD xmm  xmm
HSUBPD m128 xmm

Construct and append a HSUBPD instruction to the active function. Operates on the global context.

func HSUBPS ¶

func HSUBPS(mx, x operand.Op)

HSUBPS: Packed Single-FP Horizontal Subtract.

Forms:

HSUBPS xmm  xmm
HSUBPS m128 xmm

Construct and append a HSUBPS instruction to the active function. Operates on the global context.

func IDIVB ¶

func IDIVB(mr operand.Op)

IDIVB: Signed Divide.

Forms:

IDIVB r8
IDIVB m8

Construct and append a IDIVB instruction to the active function. Operates on the global context.

func IDIVL ¶

func IDIVL(mr operand.Op)

IDIVL: Signed Divide.

Forms:

IDIVL r32
IDIVL m32

Construct and append a IDIVL instruction to the active function. Operates on the global context.

func IDIVQ ¶

func IDIVQ(mr operand.Op)

IDIVQ: Signed Divide.

Forms:

IDIVQ r64
IDIVQ m64

Construct and append a IDIVQ instruction to the active function. Operates on the global context.

func IDIVW ¶

func IDIVW(mr operand.Op)

IDIVW: Signed Divide.

Forms:

IDIVW r16
IDIVW m16

Construct and append a IDIVW instruction to the active function. Operates on the global context.

func IMUL3L ¶

func IMUL3L(i, mr, r operand.Op)

IMUL3L: Signed Multiply.

Forms:

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

Construct and append a IMUL3L instruction to the active function. Operates on the global context.

func IMUL3Q ¶

func IMUL3Q(i, mr, r operand.Op)

IMUL3Q: Signed Multiply.

Forms:

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

Construct and append a IMUL3Q instruction to the active function. Operates on the global context.

func IMUL3W ¶

func IMUL3W(i, mr, r operand.Op)

IMUL3W: Signed Multiply.

Forms:

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

Construct and append a IMUL3W instruction to the active function. Operates on the global context.

func IMULB ¶

func IMULB(mr operand.Op)

IMULB: Signed Multiply.

Forms:

IMULB r8
IMULB m8

Construct and append a IMULB instruction to the active function. Operates on the global context.

func IMULL ¶

func IMULL(ops ...operand.Op)

IMULL: Signed Multiply.

Forms:

IMULL r32
IMULL m32
IMULL r32 r32
IMULL m32 r32

Construct and append a IMULL instruction to the active function. Operates on the global context.

func IMULQ ¶

func IMULQ(ops ...operand.Op)

IMULQ: Signed Multiply.

Forms:

IMULQ r64
IMULQ m64
IMULQ r64 r64
IMULQ m64 r64

Construct and append a IMULQ instruction to the active function. Operates on the global context.

func IMULW ¶

func IMULW(ops ...operand.Op)

IMULW: Signed Multiply.

Forms:

IMULW r16
IMULW m16
IMULW r16 r16
IMULW m16 r16

Construct and append a IMULW instruction to the active function. Operates on the global context.

func INCB ¶

func INCB(mr operand.Op)

INCB: Increment by 1.

Forms:

INCB r8
INCB m8

Construct and append a INCB instruction to the active function. Operates on the global context.

func INCL ¶

func INCL(mr operand.Op)

INCL: Increment by 1.

Forms:

INCL r32
INCL m32

Construct and append a INCL instruction to the active function. Operates on the global context.

func INCQ ¶

func INCQ(mr operand.Op)

INCQ: Increment by 1.

Forms:

INCQ r64
INCQ m64

Construct and append a INCQ instruction to the active function. Operates on the global context.

func INCW ¶

func INCW(mr operand.Op)

INCW: Increment by 1.

Forms:

INCW r16
INCW m16

Construct and append a INCW instruction to the active function. Operates on the global context.

func INSERTPS ¶

func INSERTPS(i, mx, x operand.Op)

INSERTPS: Insert Packed Single Precision Floating-Point Value.

Forms:

INSERTPS imm8 xmm xmm
INSERTPS imm8 m32 xmm

Construct and append a INSERTPS instruction to the active function. Operates on the global context.

func INT ¶

func INT(i operand.Op)

INT: Call to Interrupt Procedure.

Forms:

INT 3
INT imm8

Construct and append a INT instruction to the active function. Operates on the global context.

func Implement ¶

func Implement(name string)

Implement starts building a function of the given name, whose type is specified by a stub in the containing package.

func Instruction ¶

func Instruction(i *ir.Instruction)

Instruction adds an instruction to the active function.

func JA ¶

func JA(r operand.Op)

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

Forms:

JA rel8
JA rel32

Construct and append a JA instruction to the active function. Operates on the global context.

func JAE ¶

func JAE(r operand.Op)

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

Forms:

JAE rel8
JAE rel32

Construct and append a JAE instruction to the active function. Operates on the global context.

func JB ¶

func JB(r operand.Op)

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

Forms:

JB rel8
JB rel32

Construct and append a JB instruction to the active function. Operates on the global context.

func JBE ¶

func JBE(r operand.Op)

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

Forms:

JBE rel8
JBE rel32

Construct and append a JBE instruction to the active function. Operates on the global context.

func JC ¶

func JC(r operand.Op)

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

Forms:

JC rel8
JC rel32

Construct and append a JC instruction to the active function. Operates on the global context.

func JCC ¶

func JCC(r operand.Op)

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

Forms:

JCC rel8
JCC rel32

Construct and append a JCC instruction to the active function. Operates on the global context.

func JCS ¶

func JCS(r operand.Op)

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

Forms:

JCS rel8
JCS rel32

Construct and append a JCS instruction to the active function. Operates on the global context.

func JCXZL ¶

func JCXZL(r operand.Op)

JCXZL: Jump if ECX register is 0.

Forms:

JCXZL rel8

Construct and append a JCXZL instruction to the active function. Operates on the global context.

func JCXZQ ¶

func JCXZQ(r operand.Op)

JCXZQ: Jump if RCX register is 0.

Forms:

JCXZQ rel8

Construct and append a JCXZQ instruction to the active function. Operates on the global context.

func JE ¶

func JE(r operand.Op)

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

Forms:

JE rel8
JE rel32

Construct and append a JE instruction to the active function. Operates on the global context.

func JEQ ¶

func JEQ(r operand.Op)

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

Forms:

JEQ rel8
JEQ rel32

Construct and append a JEQ instruction to the active function. Operates on the global context.

func JG ¶

func JG(r operand.Op)

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

Forms:

JG rel8
JG rel32

Construct and append a JG instruction to the active function. Operates on the global context.

func JGE ¶

func JGE(r operand.Op)

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

Forms:

JGE rel8
JGE rel32

Construct and append a JGE instruction to the active function. Operates on the global context.

func JGT ¶

func JGT(r operand.Op)

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

Forms:

JGT rel8
JGT rel32

Construct and append a JGT instruction to the active function. Operates on the global context.

func JHI ¶

func JHI(r operand.Op)

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

Forms:

JHI rel8
JHI rel32

Construct and append a JHI instruction to the active function. Operates on the global context.

func JHS ¶

func JHS(r operand.Op)

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

Forms:

JHS rel8
JHS rel32

Construct and append a JHS instruction to the active function. Operates on the global context.

func JL ¶

func JL(r operand.Op)

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

Forms:

JL rel8
JL rel32

Construct and append a JL instruction to the active function. Operates on the global context.

func JLE ¶

func JLE(r operand.Op)

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

Forms:

JLE rel8
JLE rel32

Construct and append a JLE instruction to the active function. Operates on the global context.

func JLO ¶

func JLO(r operand.Op)

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

Forms:

JLO rel8
JLO rel32

Construct and append a JLO instruction to the active function. Operates on the global context.

func JLS ¶

func JLS(r operand.Op)

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

Forms:

JLS rel8
JLS rel32

Construct and append a JLS instruction to the active function. Operates on the global context.

func JLT ¶

func JLT(r operand.Op)

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

Forms:

JLT rel8
JLT rel32

Construct and append a JLT instruction to the active function. Operates on the global context.

func JMI ¶

func JMI(r operand.Op)

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

Forms:

JMI rel8
JMI rel32

Construct and append a JMI instruction to the active function. Operates on the global context.

func JMP ¶

func JMP(mr operand.Op)

JMP: Jump Unconditionally.

Forms:

JMP rel8
JMP rel32
JMP r64
JMP m64

Construct and append a JMP instruction to the active function. Operates on the global context.

func JNA ¶

func JNA(r operand.Op)

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

Forms:

JNA rel8
JNA rel32

Construct and append a JNA instruction to the active function. Operates on the global context.

func JNAE ¶

func JNAE(r operand.Op)

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

Forms:

JNAE rel8
JNAE rel32

Construct and append a JNAE instruction to the active function. Operates on the global context.

func JNB ¶

func JNB(r operand.Op)

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

Forms:

JNB rel8
JNB rel32

Construct and append a JNB instruction to the active function. Operates on the global context.

func JNBE ¶

func JNBE(r operand.Op)

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

Forms:

JNBE rel8
JNBE rel32

Construct and append a JNBE instruction to the active function. Operates on the global context.

func JNC ¶

func JNC(r operand.Op)

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

Forms:

JNC rel8
JNC rel32

Construct and append a JNC instruction to the active function. Operates on the global context.

func JNE ¶

func JNE(r operand.Op)

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

Forms:

JNE rel8
JNE rel32

Construct and append a JNE instruction to the active function. Operates on the global context.

func JNG ¶

func JNG(r operand.Op)

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

Forms:

JNG rel8
JNG rel32

Construct and append a JNG instruction to the active function. Operates on the global context.

func JNGE ¶

func JNGE(r operand.Op)

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

Forms:

JNGE rel8
JNGE rel32

Construct and append a JNGE instruction to the active function. Operates on the global context.

func JNL ¶

func JNL(r operand.Op)

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

Forms:

JNL rel8
JNL rel32

Construct and append a JNL instruction to the active function. Operates on the global context.

func JNLE ¶

func JNLE(r operand.Op)

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

Forms:

JNLE rel8
JNLE rel32

Construct and append a JNLE instruction to the active function. Operates on the global context.

func JNO ¶

func JNO(r operand.Op)

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

Forms:

JNO rel8
JNO rel32

Construct and append a JNO instruction to the active function. Operates on the global context.

func JNP ¶

func JNP(r operand.Op)

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

Forms:

JNP rel8
JNP rel32

Construct and append a JNP instruction to the active function. Operates on the global context.

func JNS ¶

func JNS(r operand.Op)

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

Forms:

JNS rel8
JNS rel32

Construct and append a JNS instruction to the active function. Operates on the global context.

func JNZ ¶

func JNZ(r operand.Op)

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

Forms:

JNZ rel8
JNZ rel32

Construct and append a JNZ instruction to the active function. Operates on the global context.

func JO ¶

func JO(r operand.Op)

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

Forms:

JO rel8
JO rel32

Construct and append a JO instruction to the active function. Operates on the global context.

func JOC ¶

func JOC(r operand.Op)

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

Forms:

JOC rel8
JOC rel32

Construct and append a JOC instruction to the active function. Operates on the global context.

func JOS ¶

func JOS(r operand.Op)

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

Forms:

JOS rel8
JOS rel32

Construct and append a JOS instruction to the active function. Operates on the global context.

func JP ¶

func JP(r operand.Op)

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

Forms:

JP rel8
JP rel32

Construct and append a JP instruction to the active function. Operates on the global context.

func JPC ¶

func JPC(r operand.Op)

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

Forms:

JPC rel8
JPC rel32

Construct and append a JPC instruction to the active function. Operates on the global context.

func JPE ¶

func JPE(r operand.Op)

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

Forms:

JPE rel8
JPE rel32

Construct and append a JPE instruction to the active function. Operates on the global context.

func JPL ¶

func JPL(r operand.Op)

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

Forms:

JPL rel8
JPL rel32

Construct and append a JPL instruction to the active function. Operates on the global context.

func JPO ¶

func JPO(r operand.Op)

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

Forms:

JPO rel8
JPO rel32

Construct and append a JPO instruction to the active function. Operates on the global context.

func JPS ¶

func JPS(r operand.Op)

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

Forms:

JPS rel8
JPS rel32

Construct and append a JPS instruction to the active function. Operates on the global context.

func JS ¶

func JS(r operand.Op)

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

Forms:

JS rel8
JS rel32

Construct and append a JS instruction to the active function. Operates on the global context.

func JZ ¶

func JZ(r operand.Op)

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

Forms:

JZ rel8
JZ rel32

Construct and append a JZ instruction to the active function. Operates on the global context.

func LDDQU ¶

func LDDQU(m, x operand.Op)

LDDQU: Load Unaligned Integer 128 Bits.

Forms:

LDDQU m128 xmm

Construct and append a LDDQU instruction to the active function. Operates on the global context.

func LDMXCSR ¶

func LDMXCSR(m operand.Op)

LDMXCSR: Load MXCSR Register.

Forms:

LDMXCSR m32

Construct and append a LDMXCSR instruction to the active function. Operates on the global context.

func LEAL ¶

func LEAL(m, r operand.Op)

LEAL: Load Effective Address.

Forms:

LEAL m r32

Construct and append a LEAL instruction to the active function. Operates on the global context.

func LEAQ ¶

func LEAQ(m, r operand.Op)

LEAQ: Load Effective Address.

Forms:

LEAQ m r64

Construct and append a LEAQ instruction to the active function. Operates on the global context.

func LEAW ¶

func LEAW(m, r operand.Op)

LEAW: Load Effective Address.

Forms:

LEAW m r16

Construct and append a LEAW instruction to the active function. Operates on the global context.

func LFENCE ¶

func LFENCE()

LFENCE: Load Fence.

Forms:

LFENCE

Construct and append a LFENCE instruction to the active function. Operates on the global context.

func LZCNTL ¶

func LZCNTL(mr, r operand.Op)

LZCNTL: Count the Number of Leading Zero Bits.

Forms:

LZCNTL r32 r32
LZCNTL m32 r32

Construct and append a LZCNTL instruction to the active function. Operates on the global context.

func LZCNTQ ¶

func LZCNTQ(mr, r operand.Op)

LZCNTQ: Count the Number of Leading Zero Bits.

Forms:

LZCNTQ r64 r64
LZCNTQ m64 r64

Construct and append a LZCNTQ instruction to the active function. Operates on the global context.

func LZCNTW ¶

func LZCNTW(mr, r operand.Op)

LZCNTW: Count the Number of Leading Zero Bits.

Forms:

LZCNTW r16 r16
LZCNTW m16 r16

Construct and append a LZCNTW instruction to the active function. Operates on the global context.

func Label ¶

func Label(name string)

Label adds a label to the active function.

func Load ¶

func Load(src gotypes.Component, dst reg.Register) reg.Register

Load the function argument src into register dst. Returns the destination register. This is syntactic sugar: it will attempt to select the right MOV instruction based on the types involved.

func LogError ¶

func LogError(l *log.Logger, err error, max int)

LogError logs a list of errors, one error per line, if the err parameter is an ErrorList. Otherwise it just logs the err string. Reports at most max errors, or unlimited if max is 0.

func MASKMOVDQU ¶

func MASKMOVDQU(x, x1 operand.Op)

MASKMOVDQU: Store Selected Bytes of Double Quadword.

Forms:

MASKMOVDQU xmm xmm

Construct and append a MASKMOVDQU instruction to the active function. Operates on the global context.

func MASKMOVOU ¶

func MASKMOVOU(x, x1 operand.Op)

MASKMOVOU: Store Selected Bytes of Double Quadword.

Forms:

MASKMOVOU xmm xmm

Construct and append a MASKMOVOU instruction to the active function. Operates on the global context.

func MAXPD ¶

func MAXPD(mx, x operand.Op)

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

Forms:

MAXPD xmm  xmm
MAXPD m128 xmm

Construct and append a MAXPD instruction to the active function. Operates on the global context.

func MAXPS ¶

func MAXPS(mx, x operand.Op)

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

Forms:

MAXPS xmm  xmm
MAXPS m128 xmm

Construct and append a MAXPS instruction to the active function. Operates on the global context.

func MAXSD ¶

func MAXSD(mx, x operand.Op)

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

Forms:

MAXSD xmm xmm
MAXSD m64 xmm

Construct and append a MAXSD instruction to the active function. Operates on the global context.

func MAXSS ¶

func MAXSS(mx, x operand.Op)

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

Forms:

MAXSS xmm xmm
MAXSS m32 xmm

Construct and append a MAXSS instruction to the active function. Operates on the global context.

func MFENCE ¶

func MFENCE()

MFENCE: Memory Fence.

Forms:

MFENCE

Construct and append a MFENCE instruction to the active function. Operates on the global context.

func MINPD ¶

func MINPD(mx, x operand.Op)

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

Forms:

MINPD xmm  xmm
MINPD m128 xmm

Construct and append a MINPD instruction to the active function. Operates on the global context.

func MINPS ¶

func MINPS(mx, x operand.Op)

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

Forms:

MINPS xmm  xmm
MINPS m128 xmm

Construct and append a MINPS instruction to the active function. Operates on the global context.

func MINSD ¶

func MINSD(mx, x operand.Op)

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

Forms:

MINSD xmm xmm
MINSD m64 xmm

Construct and append a MINSD instruction to the active function. Operates on the global context.

func MINSS ¶

func MINSS(mx, x operand.Op)

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

Forms:

MINSS xmm xmm
MINSS m32 xmm

Construct and append a MINSS instruction to the active function. Operates on the global context.

func MONITOR ¶

func MONITOR()

MONITOR: Monitor a Linear Address Range.

Forms:

MONITOR

Construct and append a MONITOR instruction to the active function. Operates on the global context.

func MOVAPD ¶

func MOVAPD(mx, mx1 operand.Op)

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

Forms:

MOVAPD xmm  xmm
MOVAPD m128 xmm
MOVAPD xmm  m128

Construct and append a MOVAPD instruction to the active function. Operates on the global context.

func MOVAPS ¶

func MOVAPS(mx, mx1 operand.Op)

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

Forms:

MOVAPS xmm  xmm
MOVAPS m128 xmm
MOVAPS xmm  m128

Construct and append a MOVAPS instruction to the active function. Operates on the global context.

func MOVB ¶

func MOVB(imr, mr operand.Op)

MOVB: Move.

Forms:

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

Construct and append a MOVB instruction to the active function. Operates on the global context.

func MOVBELL ¶

func MOVBELL(mr, mr1 operand.Op)

MOVBELL: Move Data After Swapping Bytes.

Forms:

MOVBELL m32 r32
MOVBELL r32 m32

Construct and append a MOVBELL instruction to the active function. Operates on the global context.

func MOVBEQQ ¶

func MOVBEQQ(mr, mr1 operand.Op)

MOVBEQQ: Move Data After Swapping Bytes.

Forms:

MOVBEQQ m64 r64
MOVBEQQ r64 m64

Construct and append a MOVBEQQ instruction to the active function. Operates on the global context.

func MOVBEWW ¶

func MOVBEWW(mr, mr1 operand.Op)

MOVBEWW: Move Data After Swapping Bytes.

Forms:

MOVBEWW m16 r16
MOVBEWW r16 m16

Construct and append a MOVBEWW instruction to the active function. Operates on the global context.

func MOVBLSX ¶

func MOVBLSX(mr, r operand.Op)

MOVBLSX: Move with Sign-Extension.

Forms:

MOVBLSX r8 r32
MOVBLSX m8 r32

Construct and append a MOVBLSX instruction to the active function. Operates on the global context.

func MOVBLZX ¶

func MOVBLZX(mr, r operand.Op)

MOVBLZX: Move with Zero-Extend.

Forms:

MOVBLZX r8 r32
MOVBLZX m8 r32

Construct and append a MOVBLZX instruction to the active function. Operates on the global context.

func MOVBQSX ¶

func MOVBQSX(mr, r operand.Op)

MOVBQSX: Move with Sign-Extension.

Forms:

MOVBQSX r8 r64
MOVBQSX m8 r64

Construct and append a MOVBQSX instruction to the active function. Operates on the global context.

func MOVBQZX ¶

func MOVBQZX(mr, r operand.Op)

MOVBQZX: Move with Zero-Extend.

Forms:

MOVBQZX r8 r64
MOVBQZX m8 r64

Construct and append a MOVBQZX instruction to the active function. Operates on the global context.

func MOVBWSX ¶

func MOVBWSX(mr, r operand.Op)

MOVBWSX: Move with Sign-Extension.

Forms:

MOVBWSX r8 r16
MOVBWSX m8 r16

Construct and append a MOVBWSX instruction to the active function. Operates on the global context.

func MOVBWZX ¶

func MOVBWZX(mr, r operand.Op)

MOVBWZX: Move with Zero-Extend.

Forms:

MOVBWZX r8 r16
MOVBWZX m8 r16

Construct and append a MOVBWZX instruction to the active function. Operates on the global context.

func MOVD ¶

func MOVD(imrx, mrx operand.Op)

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

Construct and append a MOVD instruction to the active function. Operates on the global context.

func MOVDDUP ¶

func MOVDDUP(mx, x operand.Op)

MOVDDUP: Move One Double-FP and Duplicate.

Forms:

MOVDDUP xmm xmm
MOVDDUP m64 xmm

Construct and append a MOVDDUP instruction to the active function. Operates on the global context.

func MOVDQ2Q ¶

func MOVDQ2Q(imrx, mrx operand.Op)

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

Construct and append a MOVDQ2Q instruction to the active function. Operates on the global context.

func MOVHLPS ¶

func MOVHLPS(x, x1 operand.Op)

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

Forms:

MOVHLPS xmm xmm

Construct and append a MOVHLPS instruction to the active function. Operates on the global context.

func MOVHPD ¶

func MOVHPD(mx, mx1 operand.Op)

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

Forms:

MOVHPD m64 xmm
MOVHPD xmm m64

Construct and append a MOVHPD instruction to the active function. Operates on the global context.

func MOVHPS ¶

func MOVHPS(mx, mx1 operand.Op)

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

Forms:

MOVHPS m64 xmm
MOVHPS xmm m64

Construct and append a MOVHPS instruction to the active function. Operates on the global context.

func MOVL ¶

func MOVL(imr, mr operand.Op)

MOVL: Move.

Forms:

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

Construct and append a MOVL instruction to the active function. Operates on the global context.

func MOVLHPS ¶

func MOVLHPS(x, x1 operand.Op)

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

Forms:

MOVLHPS xmm xmm

Construct and append a MOVLHPS instruction to the active function. Operates on the global context.

func MOVLPD ¶

func MOVLPD(mx, mx1 operand.Op)

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

Forms:

MOVLPD m64 xmm
MOVLPD xmm m64

Construct and append a MOVLPD instruction to the active function. Operates on the global context.

func MOVLPS ¶

func MOVLPS(mx, mx1 operand.Op)

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

Forms:

MOVLPS m64 xmm
MOVLPS xmm m64

Construct and append a MOVLPS instruction to the active function. Operates on the global context.

func MOVLQSX ¶

func MOVLQSX(mr, r operand.Op)

MOVLQSX: Move Doubleword to Quadword with Sign-Extension.

Forms:

MOVLQSX r32 r64
MOVLQSX m32 r64

Construct and append a MOVLQSX instruction to the active function. Operates on the global context.

func MOVLQZX ¶

func MOVLQZX(m, r operand.Op)

MOVLQZX: Move with Zero-Extend.

Forms:

MOVLQZX m32 r64

Construct and append a MOVLQZX instruction to the active function. Operates on the global context.

func MOVMSKPD ¶

func MOVMSKPD(x, r operand.Op)

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

Forms:

MOVMSKPD xmm r32

Construct and append a MOVMSKPD instruction to the active function. Operates on the global context.

func MOVMSKPS ¶

func MOVMSKPS(x, r operand.Op)

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

Forms:

MOVMSKPS xmm r32

Construct and append a MOVMSKPS instruction to the active function. Operates on the global context.

func MOVNTDQ ¶

func MOVNTDQ(x, m operand.Op)

MOVNTDQ: Store Double Quadword Using Non-Temporal Hint.

Forms:

MOVNTDQ xmm m128

Construct and append a MOVNTDQ instruction to the active function. Operates on the global context.

func MOVNTDQA ¶

func MOVNTDQA(m, x operand.Op)

MOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint.

Forms:

MOVNTDQA m128 xmm

Construct and append a MOVNTDQA instruction to the active function. Operates on the global context.

func MOVNTIL ¶

func MOVNTIL(r, m operand.Op)

MOVNTIL: Store Doubleword Using Non-Temporal Hint.

Forms:

MOVNTIL r32 m32

Construct and append a MOVNTIL instruction to the active function. Operates on the global context.

func MOVNTIQ ¶

func MOVNTIQ(r, m operand.Op)

MOVNTIQ: Store Doubleword Using Non-Temporal Hint.

Forms:

MOVNTIQ r64 m64

Construct and append a MOVNTIQ instruction to the active function. Operates on the global context.

func MOVNTO ¶

func MOVNTO(x, m operand.Op)

MOVNTO: Store Double Quadword Using Non-Temporal Hint.

Forms:

MOVNTO xmm m128

Construct and append a MOVNTO instruction to the active function. Operates on the global context.

func MOVNTPD ¶

func MOVNTPD(x, m operand.Op)

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

Forms:

MOVNTPD xmm m128

Construct and append a MOVNTPD instruction to the active function. Operates on the global context.

func MOVNTPS ¶

func MOVNTPS(x, m operand.Op)

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

Forms:

MOVNTPS xmm m128

Construct and append a MOVNTPS instruction to the active function. Operates on the global context.

func MOVO ¶

func MOVO(mx, mx1 operand.Op)

MOVO: Move Aligned Double Quadword.

Forms:

MOVO xmm  xmm
MOVO m128 xmm
MOVO xmm  m128

Construct and append a MOVO instruction to the active function. Operates on the global context.

func MOVOA ¶

func MOVOA(mx, mx1 operand.Op)

MOVOA: Move Aligned Double Quadword.

Forms:

MOVOA xmm  xmm
MOVOA m128 xmm
MOVOA xmm  m128

Construct and append a MOVOA instruction to the active function. Operates on the global context.

func MOVOU ¶

func MOVOU(mx, mx1 operand.Op)

MOVOU: Move Unaligned Double Quadword.

Forms:

MOVOU xmm  xmm
MOVOU m128 xmm
MOVOU xmm  m128

Construct and append a MOVOU instruction to the active function. Operates on the global context.

func MOVQ ¶

func MOVQ(imrx, mrx operand.Op)

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

Construct and append a MOVQ instruction to the active function. Operates on the global context.

func MOVSD ¶

func MOVSD(mx, mx1 operand.Op)

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

Forms:

MOVSD xmm xmm
MOVSD m64 xmm
MOVSD xmm m64

Construct and append a MOVSD instruction to the active function. Operates on the global context.

func MOVSHDUP ¶

func MOVSHDUP(mx, x operand.Op)

MOVSHDUP: Move Packed Single-FP High and Duplicate.

Forms:

MOVSHDUP xmm  xmm
MOVSHDUP m128 xmm

Construct and append a MOVSHDUP instruction to the active function. Operates on the global context.

func MOVSLDUP ¶

func MOVSLDUP(mx, x operand.Op)

MOVSLDUP: Move Packed Single-FP Low and Duplicate.

Forms:

MOVSLDUP xmm  xmm
MOVSLDUP m128 xmm

Construct and append a MOVSLDUP instruction to the active function. Operates on the global context.

func MOVSS ¶

func MOVSS(mx, mx1 operand.Op)

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

Forms:

MOVSS xmm xmm
MOVSS m32 xmm
MOVSS xmm m32

Construct and append a MOVSS instruction to the active function. Operates on the global context.

func MOVUPD ¶

func MOVUPD(mx, mx1 operand.Op)

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

Forms:

MOVUPD xmm  xmm
MOVUPD m128 xmm
MOVUPD xmm  m128

Construct and append a MOVUPD instruction to the active function. Operates on the global context.

func MOVUPS ¶

func MOVUPS(mx, mx1 operand.Op)

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

Forms:

MOVUPS xmm  xmm
MOVUPS m128 xmm
MOVUPS xmm  m128

Construct and append a MOVUPS instruction to the active function. Operates on the global context.

func MOVW ¶

func MOVW(imr, mr operand.Op)

MOVW: Move.

Forms:

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

Construct and append a MOVW instruction to the active function. Operates on the global context.

func MOVWLSX ¶

func MOVWLSX(mr, r operand.Op)

MOVWLSX: Move with Sign-Extension.

Forms:

MOVWLSX r16 r32
MOVWLSX m16 r32

Construct and append a MOVWLSX instruction to the active function. Operates on the global context.

func MOVWLZX ¶

func MOVWLZX(mr, r operand.Op)

MOVWLZX: Move with Zero-Extend.

Forms:

MOVWLZX r16 r32
MOVWLZX m16 r32

Construct and append a MOVWLZX instruction to the active function. Operates on the global context.

func MOVWQSX ¶

func MOVWQSX(mr, r operand.Op)

MOVWQSX: Move with Sign-Extension.

Forms:

MOVWQSX r16 r64
MOVWQSX m16 r64

Construct and append a MOVWQSX instruction to the active function. Operates on the global context.

func MOVWQZX ¶

func MOVWQZX(mr, r operand.Op)

MOVWQZX: Move with Zero-Extend.

Forms:

MOVWQZX r16 r64
MOVWQZX m16 r64

Construct and append a MOVWQZX instruction to the active function. Operates on the global context.

func MPSADBW ¶

func MPSADBW(i, mx, x operand.Op)

MPSADBW: Compute Multiple Packed Sums of Absolute Difference.

Forms:

MPSADBW imm8 xmm  xmm
MPSADBW imm8 m128 xmm

Construct and append a MPSADBW instruction to the active function. Operates on the global context.

func MULB ¶

func MULB(mr operand.Op)

MULB: Unsigned Multiply.

Forms:

MULB r8
MULB m8

Construct and append a MULB instruction to the active function. Operates on the global context.

func MULL ¶

func MULL(mr operand.Op)

MULL: Unsigned Multiply.

Forms:

MULL r32
MULL m32

Construct and append a MULL instruction to the active function. Operates on the global context.

func MULPD ¶

func MULPD(mx, x operand.Op)

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

Forms:

MULPD xmm  xmm
MULPD m128 xmm

Construct and append a MULPD instruction to the active function. Operates on the global context.

func MULPS ¶

func MULPS(mx, x operand.Op)

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

Forms:

MULPS xmm  xmm
MULPS m128 xmm

Construct and append a MULPS instruction to the active function. Operates on the global context.

func MULQ ¶

func MULQ(mr operand.Op)

MULQ: Unsigned Multiply.

Forms:

MULQ r64
MULQ m64

Construct and append a MULQ instruction to the active function. Operates on the global context.

func MULSD ¶

func MULSD(mx, x operand.Op)

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

Forms:

MULSD xmm xmm
MULSD m64 xmm

Construct and append a MULSD instruction to the active function. Operates on the global context.

func MULSS ¶

func MULSS(mx, x operand.Op)

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

Forms:

MULSS xmm xmm
MULSS m32 xmm

Construct and append a MULSS instruction to the active function. Operates on the global context.

func MULW ¶

func MULW(mr operand.Op)

MULW: Unsigned Multiply.

Forms:

MULW r16
MULW m16

Construct and append a MULW instruction to the active function. Operates on the global context.

func MULXL ¶

func MULXL(mr, r, r1 operand.Op)

MULXL: Unsigned Multiply Without Affecting Flags.

Forms:

MULXL r32 r32 r32
MULXL m32 r32 r32

Construct and append a MULXL instruction to the active function. Operates on the global context.

func MULXQ ¶

func MULXQ(mr, r, r1 operand.Op)

MULXQ: Unsigned Multiply Without Affecting Flags.

Forms:

MULXQ r64 r64 r64
MULXQ m64 r64 r64

Construct and append a MULXQ instruction to the active function. Operates on the global context.

func MWAIT ¶

func MWAIT()

MWAIT: Monitor Wait.

Forms:

MWAIT

Construct and append a MWAIT instruction to the active function. Operates on the global context.

func Main ¶

func Main(cfg *Config, context *Context) int

Main is the standard main function for an avo program. This extracts the result from the build Context (logging and exiting on error), and performs configured passes.

func NEGB ¶

func NEGB(mr operand.Op)

NEGB: Two's Complement Negation.

Forms:

NEGB r8
NEGB m8

Construct and append a NEGB instruction to the active function. Operates on the global context.

func NEGL ¶

func NEGL(mr operand.Op)

NEGL: Two's Complement Negation.

Forms:

NEGL r32
NEGL m32

Construct and append a NEGL instruction to the active function. Operates on the global context.

func NEGQ ¶

func NEGQ(mr operand.Op)

NEGQ: Two's Complement Negation.

Forms:

NEGQ r64
NEGQ m64

Construct and append a NEGQ instruction to the active function. Operates on the global context.

func NEGW ¶

func NEGW(mr operand.Op)

NEGW: Two's Complement Negation.

Forms:

NEGW r16
NEGW m16

Construct and append a NEGW instruction to the active function. Operates on the global context.

func NOP ¶

func NOP()

NOP: No Operation.

Forms:

NOP

Construct and append a NOP instruction to the active function. Operates on the global context.

func NOTB ¶

func NOTB(mr operand.Op)

NOTB: One's Complement Negation.

Forms:

NOTB r8
NOTB m8

Construct and append a NOTB instruction to the active function. Operates on the global context.

func NOTL ¶

func NOTL(mr operand.Op)

NOTL: One's Complement Negation.

Forms:

NOTL r32
NOTL m32

Construct and append a NOTL instruction to the active function. Operates on the global context.

func NOTQ ¶

func NOTQ(mr operand.Op)

NOTQ: One's Complement Negation.

Forms:

NOTQ r64
NOTQ m64

Construct and append a NOTQ instruction to the active function. Operates on the global context.

func NOTW ¶

func NOTW(mr operand.Op)

NOTW: One's Complement Negation.

Forms:

NOTW r16
NOTW m16

Construct and append a NOTW instruction to the active function. Operates on the global context.

func ORB ¶

func ORB(imr, amr operand.Op)

ORB: Logical Inclusive OR.

Forms:

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

Construct and append a ORB instruction to the active function. Operates on the global context.

func ORL ¶

func ORL(imr, emr operand.Op)

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

Construct and append a ORL instruction to the active function. Operates on the global context.

func ORPD ¶

func ORPD(mx, x operand.Op)

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

Forms:

ORPD xmm  xmm
ORPD m128 xmm

Construct and append a ORPD instruction to the active function. Operates on the global context.

func ORPS ¶

func ORPS(mx, x operand.Op)

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

Forms:

ORPS xmm  xmm
ORPS m128 xmm

Construct and append a ORPS instruction to the active function. Operates on the global context.

func ORQ ¶

func ORQ(imr, mr operand.Op)

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

Construct and append a ORQ instruction to the active function. Operates on the global context.

func ORW ¶

func ORW(imr, amr operand.Op)

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

Construct and append a ORW instruction to the active function. Operates on the global context.

func PABSB ¶

func PABSB(mx, x operand.Op)

PABSB: Packed Absolute Value of Byte Integers.

Forms:

PABSB xmm  xmm
PABSB m128 xmm

Construct and append a PABSB instruction to the active function. Operates on the global context.

func PABSD ¶

func PABSD(mx, x operand.Op)

PABSD: Packed Absolute Value of Doubleword Integers.

Forms:

PABSD xmm  xmm
PABSD m128 xmm

Construct and append a PABSD instruction to the active function. Operates on the global context.

func PABSW ¶

func PABSW(mx, x operand.Op)

PABSW: Packed Absolute Value of Word Integers.

Forms:

PABSW xmm  xmm
PABSW m128 xmm

Construct and append a PABSW instruction to the active function. Operates on the global context.

func PACKSSLW ¶

func PACKSSLW(mx, x operand.Op)

PACKSSLW: Pack Doublewords into Words with Signed Saturation.

Forms:

PACKSSLW xmm  xmm
PACKSSLW m128 xmm

Construct and append a PACKSSLW instruction to the active function. Operates on the global context.

func PACKSSWB ¶

func PACKSSWB(mx, x operand.Op)

PACKSSWB: Pack Words into Bytes with Signed Saturation.

Forms:

PACKSSWB xmm  xmm
PACKSSWB m128 xmm

Construct and append a PACKSSWB instruction to the active function. Operates on the global context.

func PACKUSDW ¶

func PACKUSDW(mx, x operand.Op)

PACKUSDW: Pack Doublewords into Words with Unsigned Saturation.

Forms:

PACKUSDW xmm  xmm
PACKUSDW m128 xmm

Construct and append a PACKUSDW instruction to the active function. Operates on the global context.

func PACKUSWB ¶

func PACKUSWB(mx, x operand.Op)

PACKUSWB: Pack Words into Bytes with Unsigned Saturation.

Forms:

PACKUSWB xmm  xmm
PACKUSWB m128 xmm

Construct and append a PACKUSWB instruction to the active function. Operates on the global context.

func PADDB ¶

func PADDB(mx, x operand.Op)

PADDB: Add Packed Byte Integers.

Forms:

PADDB xmm  xmm
PADDB m128 xmm

Construct and append a PADDB instruction to the active function. Operates on the global context.

func PADDD ¶

func PADDD(mx, x operand.Op)

PADDD: Add Packed Doubleword Integers.

Forms:

PADDD xmm  xmm
PADDD m128 xmm

Construct and append a PADDD instruction to the active function. Operates on the global context.

func PADDL ¶

func PADDL(mx, x operand.Op)

PADDL: Add Packed Doubleword Integers.

Forms:

PADDL xmm  xmm
PADDL m128 xmm

Construct and append a PADDL instruction to the active function. Operates on the global context.

func PADDQ ¶

func PADDQ(mx, x operand.Op)

PADDQ: Add Packed Quadword Integers.

Forms:

PADDQ xmm  xmm
PADDQ m128 xmm

Construct and append a PADDQ instruction to the active function. Operates on the global context.

func PADDSB ¶

func PADDSB(mx, x operand.Op)

PADDSB: Add Packed Signed Byte Integers with Signed Saturation.

Forms:

PADDSB xmm  xmm
PADDSB m128 xmm

Construct and append a PADDSB instruction to the active function. Operates on the global context.

func PADDSW ¶

func PADDSW(mx, x operand.Op)

PADDSW: Add Packed Signed Word Integers with Signed Saturation.

Forms:

PADDSW xmm  xmm
PADDSW m128 xmm

Construct and append a PADDSW instruction to the active function. Operates on the global context.

func PADDUSB ¶

func PADDUSB(mx, x operand.Op)

PADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

PADDUSB xmm  xmm
PADDUSB m128 xmm

Construct and append a PADDUSB instruction to the active function. Operates on the global context.

func PADDUSW ¶

func PADDUSW(mx, x operand.Op)

PADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

PADDUSW xmm  xmm
PADDUSW m128 xmm

Construct and append a PADDUSW instruction to the active function. Operates on the global context.

func PADDW ¶

func PADDW(mx, x operand.Op)

PADDW: Add Packed Word Integers.

Forms:

PADDW xmm  xmm
PADDW m128 xmm

Construct and append a PADDW instruction to the active function. Operates on the global context.

func PALIGNR ¶

func PALIGNR(i, mx, x operand.Op)

PALIGNR: Packed Align Right.

Forms:

PALIGNR imm8 xmm  xmm
PALIGNR imm8 m128 xmm

Construct and append a PALIGNR instruction to the active function. Operates on the global context.

func PAND ¶

func PAND(mx, x operand.Op)

PAND: Packed Bitwise Logical AND.

Forms:

PAND xmm  xmm
PAND m128 xmm

Construct and append a PAND instruction to the active function. Operates on the global context.

func PANDN ¶

func PANDN(mx, x operand.Op)

PANDN: Packed Bitwise Logical AND NOT.

Forms:

PANDN xmm  xmm
PANDN m128 xmm

Construct and append a PANDN instruction to the active function. Operates on the global context.

func PAUSE ¶

func PAUSE()

PAUSE: Spin Loop Hint.

Forms:

PAUSE

Construct and append a PAUSE instruction to the active function. Operates on the global context.

func PAVGB ¶

func PAVGB(mx, x operand.Op)

PAVGB: Average Packed Byte Integers.

Forms:

PAVGB xmm  xmm
PAVGB m128 xmm

Construct and append a PAVGB instruction to the active function. Operates on the global context.

func PAVGW ¶

func PAVGW(mx, x operand.Op)

PAVGW: Average Packed Word Integers.

Forms:

PAVGW xmm  xmm
PAVGW m128 xmm

Construct and append a PAVGW instruction to the active function. Operates on the global context.

func PBLENDVB ¶

func PBLENDVB(x, mx, x1 operand.Op)

PBLENDVB: Variable Blend Packed Bytes.

Forms:

PBLENDVB xmm0 xmm  xmm
PBLENDVB xmm0 m128 xmm

Construct and append a PBLENDVB instruction to the active function. Operates on the global context.

func PBLENDW ¶

func PBLENDW(i, mx, x operand.Op)

PBLENDW: Blend Packed Words.

Forms:

PBLENDW imm8 xmm  xmm
PBLENDW imm8 m128 xmm

Construct and append a PBLENDW instruction to the active function. Operates on the global context.

func PCLMULQDQ ¶

func PCLMULQDQ(i, mx, x operand.Op)

PCLMULQDQ: Carry-Less Quadword Multiplication.

Forms:

PCLMULQDQ imm8 xmm  xmm
PCLMULQDQ imm8 m128 xmm

Construct and append a PCLMULQDQ instruction to the active function. Operates on the global context.

func PCMPEQB ¶

func PCMPEQB(mx, x operand.Op)

PCMPEQB: Compare Packed Byte Data for Equality.

Forms:

PCMPEQB xmm  xmm
PCMPEQB m128 xmm

Construct and append a PCMPEQB instruction to the active function. Operates on the global context.

func PCMPEQL ¶

func PCMPEQL(mx, x operand.Op)

PCMPEQL: Compare Packed Doubleword Data for Equality.

Forms:

PCMPEQL xmm  xmm
PCMPEQL m128 xmm

Construct and append a PCMPEQL instruction to the active function. Operates on the global context.

func PCMPEQQ ¶

func PCMPEQQ(mx, x operand.Op)

PCMPEQQ: Compare Packed Quadword Data for Equality.

Forms:

PCMPEQQ xmm  xmm
PCMPEQQ m128 xmm

Construct and append a PCMPEQQ instruction to the active function. Operates on the global context.

func PCMPEQW ¶

func PCMPEQW(mx, x operand.Op)

PCMPEQW: Compare Packed Word Data for Equality.

Forms:

PCMPEQW xmm  xmm
PCMPEQW m128 xmm

Construct and append a PCMPEQW instruction to the active function. Operates on the global context.

func PCMPESTRI ¶

func PCMPESTRI(i, mx, x operand.Op)

PCMPESTRI: Packed Compare Explicit Length Strings, Return Index.

Forms:

PCMPESTRI imm8 xmm  xmm
PCMPESTRI imm8 m128 xmm

Construct and append a PCMPESTRI instruction to the active function. Operates on the global context.

func PCMPESTRM ¶

func PCMPESTRM(i, mx, x operand.Op)

PCMPESTRM: Packed Compare Explicit Length Strings, Return Mask.

Forms:

PCMPESTRM imm8 xmm  xmm
PCMPESTRM imm8 m128 xmm

Construct and append a PCMPESTRM instruction to the active function. Operates on the global context.

func PCMPGTB ¶

func PCMPGTB(mx, x operand.Op)

PCMPGTB: Compare Packed Signed Byte Integers for Greater Than.

Forms:

PCMPGTB xmm  xmm
PCMPGTB m128 xmm

Construct and append a PCMPGTB instruction to the active function. Operates on the global context.

func PCMPGTL ¶

func PCMPGTL(mx, x operand.Op)

PCMPGTL: Compare Packed Signed Doubleword Integers for Greater Than.

Forms:

PCMPGTL xmm  xmm
PCMPGTL m128 xmm

Construct and append a PCMPGTL instruction to the active function. Operates on the global context.

func PCMPGTQ ¶

func PCMPGTQ(mx, x operand.Op)

PCMPGTQ: Compare Packed Data for Greater Than.

Forms:

PCMPGTQ xmm  xmm
PCMPGTQ m128 xmm

Construct and append a PCMPGTQ instruction to the active function. Operates on the global context.

func PCMPGTW ¶

func PCMPGTW(mx, x operand.Op)

PCMPGTW: Compare Packed Signed Word Integers for Greater Than.

Forms:

PCMPGTW xmm  xmm
PCMPGTW m128 xmm

Construct and append a PCMPGTW instruction to the active function. Operates on the global context.

func PCMPISTRI ¶

func PCMPISTRI(i, mx, x operand.Op)

PCMPISTRI: Packed Compare Implicit Length Strings, Return Index.

Forms:

PCMPISTRI imm8 xmm  xmm
PCMPISTRI imm8 m128 xmm

Construct and append a PCMPISTRI instruction to the active function. Operates on the global context.

func PCMPISTRM ¶

func PCMPISTRM(i, mx, x operand.Op)

PCMPISTRM: Packed Compare Implicit Length Strings, Return Mask.

Forms:

PCMPISTRM imm8 xmm  xmm
PCMPISTRM imm8 m128 xmm

Construct and append a PCMPISTRM instruction to the active function. Operates on the global context.

func PDEPL ¶

func PDEPL(mr, r, r1 operand.Op)

PDEPL: Parallel Bits Deposit.

Forms:

PDEPL r32 r32 r32
PDEPL m32 r32 r32

Construct and append a PDEPL instruction to the active function. Operates on the global context.

func PDEPQ ¶

func PDEPQ(mr, r, r1 operand.Op)

PDEPQ: Parallel Bits Deposit.

Forms:

PDEPQ r64 r64 r64
PDEPQ m64 r64 r64

Construct and append a PDEPQ instruction to the active function. Operates on the global context.

func PEXTL ¶

func PEXTL(mr, r, r1 operand.Op)

PEXTL: Parallel Bits Extract.

Forms:

PEXTL r32 r32 r32
PEXTL m32 r32 r32

Construct and append a PEXTL instruction to the active function. Operates on the global context.

func PEXTQ ¶

func PEXTQ(mr, r, r1 operand.Op)

PEXTQ: Parallel Bits Extract.

Forms:

PEXTQ r64 r64 r64
PEXTQ m64 r64 r64

Construct and append a PEXTQ instruction to the active function. Operates on the global context.

func PEXTRB ¶

func PEXTRB(i, x, mr operand.Op)

PEXTRB: Extract Byte.

Forms:

PEXTRB imm8 xmm r32
PEXTRB imm8 xmm m8

Construct and append a PEXTRB instruction to the active function. Operates on the global context.

func PEXTRD ¶

func PEXTRD(i, x, mr operand.Op)

PEXTRD: Extract Doubleword.

Forms:

PEXTRD imm8 xmm r32
PEXTRD imm8 xmm m32

Construct and append a PEXTRD instruction to the active function. Operates on the global context.

func PEXTRQ ¶

func PEXTRQ(i, x, mr operand.Op)

PEXTRQ: Extract Quadword.

Forms:

PEXTRQ imm8 xmm r64
PEXTRQ imm8 xmm m64

Construct and append a PEXTRQ instruction to the active function. Operates on the global context.

func PEXTRW ¶

func PEXTRW(i, x, mr operand.Op)

PEXTRW: Extract Word.

Forms:

PEXTRW imm8 xmm r32
PEXTRW imm8 xmm m16

Construct and append a PEXTRW instruction to the active function. Operates on the global context.

func PHADDD ¶

func PHADDD(mx, x operand.Op)

PHADDD: Packed Horizontal Add Doubleword Integer.

Forms:

PHADDD xmm  xmm
PHADDD m128 xmm

Construct and append a PHADDD instruction to the active function. Operates on the global context.

func PHADDSW ¶

func PHADDSW(mx, x operand.Op)

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

Forms:

PHADDSW xmm  xmm
PHADDSW m128 xmm

Construct and append a PHADDSW instruction to the active function. Operates on the global context.

func PHADDW ¶

func PHADDW(mx, x operand.Op)

PHADDW: Packed Horizontal Add Word Integers.

Forms:

PHADDW xmm  xmm
PHADDW m128 xmm

Construct and append a PHADDW instruction to the active function. Operates on the global context.

func PHMINPOSUW ¶

func PHMINPOSUW(mx, x operand.Op)

PHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers.

Forms:

PHMINPOSUW xmm  xmm
PHMINPOSUW m128 xmm

Construct and append a PHMINPOSUW instruction to the active function. Operates on the global context.

func PHSUBD ¶

func PHSUBD(mx, x operand.Op)

PHSUBD: Packed Horizontal Subtract Doubleword Integers.

Forms:

PHSUBD xmm  xmm
PHSUBD m128 xmm

Construct and append a PHSUBD instruction to the active function. Operates on the global context.

func PHSUBSW ¶

func PHSUBSW(mx, x operand.Op)

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

Forms:

PHSUBSW xmm  xmm
PHSUBSW m128 xmm

Construct and append a PHSUBSW instruction to the active function. Operates on the global context.

func PHSUBW ¶

func PHSUBW(mx, x operand.Op)

PHSUBW: Packed Horizontal Subtract Word Integers.

Forms:

PHSUBW xmm  xmm
PHSUBW m128 xmm

Construct and append a PHSUBW instruction to the active function. Operates on the global context.

func PINSRB ¶

func PINSRB(i, mr, x operand.Op)

PINSRB: Insert Byte.

Forms:

PINSRB imm8 r32 xmm
PINSRB imm8 m8  xmm

Construct and append a PINSRB instruction to the active function. Operates on the global context.

func PINSRD ¶

func PINSRD(i, mr, x operand.Op)

PINSRD: Insert Doubleword.

Forms:

PINSRD imm8 r32 xmm
PINSRD imm8 m32 xmm

Construct and append a PINSRD instruction to the active function. Operates on the global context.

func PINSRQ ¶

func PINSRQ(i, mr, x operand.Op)

PINSRQ: Insert Quadword.

Forms:

PINSRQ imm8 r64 xmm
PINSRQ imm8 m64 xmm

Construct and append a PINSRQ instruction to the active function. Operates on the global context.

func PINSRW ¶

func PINSRW(i, mr, x operand.Op)

PINSRW: Insert Word.

Forms:

PINSRW imm8 r32 xmm
PINSRW imm8 m16 xmm

Construct and append a PINSRW instruction to the active function. Operates on the global context.

func PMADDUBSW ¶

func PMADDUBSW(mx, x operand.Op)

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

Forms:

PMADDUBSW xmm  xmm
PMADDUBSW m128 xmm

Construct and append a PMADDUBSW instruction to the active function. Operates on the global context.

func PMADDWL ¶

func PMADDWL(mx, x operand.Op)

PMADDWL: Multiply and Add Packed Signed Word Integers.

Forms:

PMADDWL xmm  xmm
PMADDWL m128 xmm

Construct and append a PMADDWL instruction to the active function. Operates on the global context.

func PMAXSB ¶

func PMAXSB(mx, x operand.Op)

PMAXSB: Maximum of Packed Signed Byte Integers.

Forms:

PMAXSB xmm  xmm
PMAXSB m128 xmm

Construct and append a PMAXSB instruction to the active function. Operates on the global context.

func PMAXSD ¶

func PMAXSD(mx, x operand.Op)

PMAXSD: Maximum of Packed Signed Doubleword Integers.

Forms:

PMAXSD xmm  xmm
PMAXSD m128 xmm

Construct and append a PMAXSD instruction to the active function. Operates on the global context.

func PMAXSW ¶

func PMAXSW(mx, x operand.Op)

PMAXSW: Maximum of Packed Signed Word Integers.

Forms:

PMAXSW xmm  xmm
PMAXSW m128 xmm

Construct and append a PMAXSW instruction to the active function. Operates on the global context.

func PMAXUB ¶

func PMAXUB(mx, x operand.Op)

PMAXUB: Maximum of Packed Unsigned Byte Integers.

Forms:

PMAXUB xmm  xmm
PMAXUB m128 xmm

Construct and append a PMAXUB instruction to the active function. Operates on the global context.

func PMAXUD ¶

func PMAXUD(mx, x operand.Op)

PMAXUD: Maximum of Packed Unsigned Doubleword Integers.

Forms:

PMAXUD xmm  xmm
PMAXUD m128 xmm

Construct and append a PMAXUD instruction to the active function. Operates on the global context.

func PMAXUW ¶

func PMAXUW(mx, x operand.Op)

PMAXUW: Maximum of Packed Unsigned Word Integers.

Forms:

PMAXUW xmm  xmm
PMAXUW m128 xmm

Construct and append a PMAXUW instruction to the active function. Operates on the global context.

func PMINSB ¶

func PMINSB(mx, x operand.Op)

PMINSB: Minimum of Packed Signed Byte Integers.

Forms:

PMINSB xmm  xmm
PMINSB m128 xmm

Construct and append a PMINSB instruction to the active function. Operates on the global context.

func PMINSD ¶

func PMINSD(mx, x operand.Op)

PMINSD: Minimum of Packed Signed Doubleword Integers.

Forms:

PMINSD xmm  xmm
PMINSD m128 xmm

Construct and append a PMINSD instruction to the active function. Operates on the global context.

func PMINSW ¶

func PMINSW(mx, x operand.Op)

PMINSW: Minimum of Packed Signed Word Integers.

Forms:

PMINSW xmm  xmm
PMINSW m128 xmm

Construct and append a PMINSW instruction to the active function. Operates on the global context.

func PMINUB ¶

func PMINUB(mx, x operand.Op)

PMINUB: Minimum of Packed Unsigned Byte Integers.

Forms:

PMINUB xmm  xmm
PMINUB m128 xmm

Construct and append a PMINUB instruction to the active function. Operates on the global context.

func PMINUD ¶

func PMINUD(mx, x operand.Op)

PMINUD: Minimum of Packed Unsigned Doubleword Integers.

Forms:

PMINUD xmm  xmm
PMINUD m128 xmm

Construct and append a PMINUD instruction to the active function. Operates on the global context.

func PMINUW ¶

func PMINUW(mx, x operand.Op)

PMINUW: Minimum of Packed Unsigned Word Integers.

Forms:

PMINUW xmm  xmm
PMINUW m128 xmm

Construct and append a PMINUW instruction to the active function. Operates on the global context.

func PMOVMSKB ¶

func PMOVMSKB(x, r operand.Op)

PMOVMSKB: Move Byte Mask.

Forms:

PMOVMSKB xmm r32

Construct and append a PMOVMSKB instruction to the active function. Operates on the global context.

func PMOVSXBD ¶

func PMOVSXBD(mx, x operand.Op)

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

Forms:

PMOVSXBD xmm xmm
PMOVSXBD m32 xmm

Construct and append a PMOVSXBD instruction to the active function. Operates on the global context.

func PMOVSXBQ ¶

func PMOVSXBQ(mx, x operand.Op)

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

Forms:

PMOVSXBQ xmm xmm
PMOVSXBQ m16 xmm

Construct and append a PMOVSXBQ instruction to the active function. Operates on the global context.

func PMOVSXBW ¶

func PMOVSXBW(mx, x operand.Op)

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

Forms:

PMOVSXBW xmm xmm
PMOVSXBW m64 xmm

Construct and append a PMOVSXBW instruction to the active function. Operates on the global context.

func PMOVSXDQ ¶

func PMOVSXDQ(mx, x operand.Op)

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

Forms:

PMOVSXDQ xmm xmm
PMOVSXDQ m64 xmm

Construct and append a PMOVSXDQ instruction to the active function. Operates on the global context.

func PMOVSXWD ¶

func PMOVSXWD(mx, x operand.Op)

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

Forms:

PMOVSXWD xmm xmm
PMOVSXWD m64 xmm

Construct and append a PMOVSXWD instruction to the active function. Operates on the global context.

func PMOVSXWQ ¶

func PMOVSXWQ(mx, x operand.Op)

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

Forms:

PMOVSXWQ xmm xmm
PMOVSXWQ m32 xmm

Construct and append a PMOVSXWQ instruction to the active function. Operates on the global context.

func PMOVZXBD ¶

func PMOVZXBD(mx, x operand.Op)

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

Forms:

PMOVZXBD xmm xmm
PMOVZXBD m32 xmm

Construct and append a PMOVZXBD instruction to the active function. Operates on the global context.

func PMOVZXBQ ¶

func PMOVZXBQ(mx, x operand.Op)

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

Forms:

PMOVZXBQ xmm xmm
PMOVZXBQ m16 xmm

Construct and append a PMOVZXBQ instruction to the active function. Operates on the global context.

func PMOVZXBW ¶

func PMOVZXBW(mx, x operand.Op)

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

Forms:

PMOVZXBW xmm xmm
PMOVZXBW m64 xmm

Construct and append a PMOVZXBW instruction to the active function. Operates on the global context.

func PMOVZXDQ ¶

func PMOVZXDQ(mx, x operand.Op)

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

Forms:

PMOVZXDQ xmm xmm
PMOVZXDQ m64 xmm

Construct and append a PMOVZXDQ instruction to the active function. Operates on the global context.

func PMOVZXWD ¶

func PMOVZXWD(mx, x operand.Op)

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

Forms:

PMOVZXWD xmm xmm
PMOVZXWD m64 xmm

Construct and append a PMOVZXWD instruction to the active function. Operates on the global context.

func PMOVZXWQ ¶

func PMOVZXWQ(mx, x operand.Op)

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

Forms:

PMOVZXWQ xmm xmm
PMOVZXWQ m32 xmm

Construct and append a PMOVZXWQ instruction to the active function. Operates on the global context.

func PMULDQ ¶

func PMULDQ(mx, x operand.Op)

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

Forms:

PMULDQ xmm  xmm
PMULDQ m128 xmm

Construct and append a PMULDQ instruction to the active function. Operates on the global context.

func PMULHRSW ¶

func PMULHRSW(mx, x operand.Op)

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

Forms:

PMULHRSW xmm  xmm
PMULHRSW m128 xmm

Construct and append a PMULHRSW instruction to the active function. Operates on the global context.

func PMULHUW ¶

func PMULHUW(mx, x operand.Op)

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

Forms:

PMULHUW xmm  xmm
PMULHUW m128 xmm

Construct and append a PMULHUW instruction to the active function. Operates on the global context.

func PMULHW ¶

func PMULHW(mx, x operand.Op)

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

Forms:

PMULHW xmm  xmm
PMULHW m128 xmm

Construct and append a PMULHW instruction to the active function. Operates on the global context.

func PMULLD ¶

func PMULLD(mx, x operand.Op)

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

Forms:

PMULLD xmm  xmm
PMULLD m128 xmm

Construct and append a PMULLD instruction to the active function. Operates on the global context.

func PMULLW ¶

func PMULLW(mx, x operand.Op)

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

Forms:

PMULLW xmm  xmm
PMULLW m128 xmm

Construct and append a PMULLW instruction to the active function. Operates on the global context.

func PMULULQ ¶

func PMULULQ(mx, x operand.Op)

PMULULQ: Multiply Packed Unsigned Doubleword Integers.

Forms:

PMULULQ xmm  xmm
PMULULQ m128 xmm

Construct and append a PMULULQ instruction to the active function. Operates on the global context.

func POPCNTL ¶

func POPCNTL(mr, r operand.Op)

POPCNTL: Count of Number of Bits Set to 1.

Forms:

POPCNTL r32 r32
POPCNTL m32 r32

Construct and append a POPCNTL instruction to the active function. Operates on the global context.

func POPCNTQ ¶

func POPCNTQ(mr, r operand.Op)

POPCNTQ: Count of Number of Bits Set to 1.

Forms:

POPCNTQ r64 r64
POPCNTQ m64 r64

Construct and append a POPCNTQ instruction to the active function. Operates on the global context.

func POPCNTW ¶

func POPCNTW(mr, r operand.Op)

POPCNTW: Count of Number of Bits Set to 1.

Forms:

POPCNTW r16 r16
POPCNTW m16 r16

Construct and append a POPCNTW instruction to the active function. Operates on the global context.

func POPQ ¶

func POPQ(mr operand.Op)

POPQ: Pop a Value from the Stack.

Forms:

POPQ r64
POPQ m64

Construct and append a POPQ instruction to the active function. Operates on the global context.

func POPW ¶

func POPW(mr operand.Op)

POPW: Pop a Value from the Stack.

Forms:

POPW r16
POPW m16

Construct and append a POPW instruction to the active function. Operates on the global context.

func POR ¶

func POR(mx, x operand.Op)

POR: Packed Bitwise Logical OR.

Forms:

POR xmm  xmm
POR m128 xmm

Construct and append a POR instruction to the active function. Operates on the global context.

func PREFETCHNTA ¶

func PREFETCHNTA(m operand.Op)

PREFETCHNTA: Prefetch Data Into Caches using NTA Hint.

Forms:

PREFETCHNTA m8

Construct and append a PREFETCHNTA instruction to the active function. Operates on the global context.

func PREFETCHT0 ¶

func PREFETCHT0(m operand.Op)

PREFETCHT0: Prefetch Data Into Caches using T0 Hint.

Forms:

PREFETCHT0 m8

Construct and append a PREFETCHT0 instruction to the active function. Operates on the global context.

func PREFETCHT1 ¶

func PREFETCHT1(m operand.Op)

PREFETCHT1: Prefetch Data Into Caches using T1 Hint.

Forms:

PREFETCHT1 m8

Construct and append a PREFETCHT1 instruction to the active function. Operates on the global context.

func PREFETCHT2 ¶

func PREFETCHT2(m operand.Op)

PREFETCHT2: Prefetch Data Into Caches using T2 Hint.

Forms:

PREFETCHT2 m8

Construct and append a PREFETCHT2 instruction to the active function. Operates on the global context.

func PSADBW ¶

func PSADBW(mx, x operand.Op)

PSADBW: Compute Sum of Absolute Differences.

Forms:

PSADBW xmm  xmm
PSADBW m128 xmm

Construct and append a PSADBW instruction to the active function. Operates on the global context.

func PSHUFB ¶

func PSHUFB(mx, x operand.Op)

PSHUFB: Packed Shuffle Bytes.

Forms:

PSHUFB xmm  xmm
PSHUFB m128 xmm

Construct and append a PSHUFB instruction to the active function. Operates on the global context.

func PSHUFD ¶

func PSHUFD(i, mx, x operand.Op)

PSHUFD: Shuffle Packed Doublewords.

Forms:

PSHUFD imm8 xmm  xmm
PSHUFD imm8 m128 xmm

Construct and append a PSHUFD instruction to the active function. Operates on the global context.

func PSHUFHW ¶

func PSHUFHW(i, mx, x operand.Op)

PSHUFHW: Shuffle Packed High Words.

Forms:

PSHUFHW imm8 xmm  xmm
PSHUFHW imm8 m128 xmm

Construct and append a PSHUFHW instruction to the active function. Operates on the global context.

func PSHUFL ¶

func PSHUFL(i, mx, x operand.Op)

PSHUFL: Shuffle Packed Doublewords.

Forms:

PSHUFL imm8 xmm  xmm
PSHUFL imm8 m128 xmm

Construct and append a PSHUFL instruction to the active function. Operates on the global context.

func PSHUFLW ¶

func PSHUFLW(i, mx, x operand.Op)

PSHUFLW: Shuffle Packed Low Words.

Forms:

PSHUFLW imm8 xmm  xmm
PSHUFLW imm8 m128 xmm

Construct and append a PSHUFLW instruction to the active function. Operates on the global context.

func PSIGNB ¶

func PSIGNB(mx, x operand.Op)

PSIGNB: Packed Sign of Byte Integers.

Forms:

PSIGNB xmm  xmm
PSIGNB m128 xmm

Construct and append a PSIGNB instruction to the active function. Operates on the global context.

func PSIGND ¶

func PSIGND(mx, x operand.Op)

PSIGND: Packed Sign of Doubleword Integers.

Forms:

PSIGND xmm  xmm
PSIGND m128 xmm

Construct and append a PSIGND instruction to the active function. Operates on the global context.

func PSIGNW ¶

func PSIGNW(mx, x operand.Op)

PSIGNW: Packed Sign of Word Integers.

Forms:

PSIGNW xmm  xmm
PSIGNW m128 xmm

Construct and append a PSIGNW instruction to the active function. Operates on the global context.

func PSLLDQ ¶

func PSLLDQ(i, x operand.Op)

PSLLDQ: Shift Packed Double Quadword Left Logical.

Forms:

PSLLDQ imm8 xmm

Construct and append a PSLLDQ instruction to the active function. Operates on the global context.

func PSLLL ¶

func PSLLL(imx, x operand.Op)

PSLLL: Shift Packed Doubleword Data Left Logical.

Forms:

PSLLL imm8 xmm
PSLLL xmm  xmm
PSLLL m128 xmm

Construct and append a PSLLL instruction to the active function. Operates on the global context.

func PSLLO ¶

func PSLLO(i, x operand.Op)

PSLLO: Shift Packed Double Quadword Left Logical.

Forms:

PSLLO imm8 xmm

Construct and append a PSLLO instruction to the active function. Operates on the global context.

func PSLLQ ¶

func PSLLQ(imx, x operand.Op)

PSLLQ: Shift Packed Quadword Data Left Logical.

Forms:

PSLLQ imm8 xmm
PSLLQ xmm  xmm
PSLLQ m128 xmm

Construct and append a PSLLQ instruction to the active function. Operates on the global context.

func PSLLW ¶

func PSLLW(imx, x operand.Op)

PSLLW: Shift Packed Word Data Left Logical.

Forms:

PSLLW imm8 xmm
PSLLW xmm  xmm
PSLLW m128 xmm

Construct and append a PSLLW instruction to the active function. Operates on the global context.

func PSRAL ¶

func PSRAL(imx, x operand.Op)

PSRAL: Shift Packed Doubleword Data Right Arithmetic.

Forms:

PSRAL imm8 xmm
PSRAL xmm  xmm
PSRAL m128 xmm

Construct and append a PSRAL instruction to the active function. Operates on the global context.

func PSRAW ¶

func PSRAW(imx, x operand.Op)

PSRAW: Shift Packed Word Data Right Arithmetic.

Forms:

PSRAW imm8 xmm
PSRAW xmm  xmm
PSRAW m128 xmm

Construct and append a PSRAW instruction to the active function. Operates on the global context.

func PSRLDQ ¶

func PSRLDQ(i, x operand.Op)

PSRLDQ: Shift Packed Double Quadword Right Logical.

Forms:

PSRLDQ imm8 xmm

Construct and append a PSRLDQ instruction to the active function. Operates on the global context.

func PSRLL ¶

func PSRLL(imx, x operand.Op)

PSRLL: Shift Packed Doubleword Data Right Logical.

Forms:

PSRLL imm8 xmm
PSRLL xmm  xmm
PSRLL m128 xmm

Construct and append a PSRLL instruction to the active function. Operates on the global context.

func PSRLO ¶

func PSRLO(i, x operand.Op)

PSRLO: Shift Packed Double Quadword Right Logical.

Forms:

PSRLO imm8 xmm

Construct and append a PSRLO instruction to the active function. Operates on the global context.

func PSRLQ ¶

func PSRLQ(imx, x operand.Op)

PSRLQ: Shift Packed Quadword Data Right Logical.

Forms:

PSRLQ imm8 xmm
PSRLQ xmm  xmm
PSRLQ m128 xmm

Construct and append a PSRLQ instruction to the active function. Operates on the global context.

func PSRLW ¶

func PSRLW(imx, x operand.Op)

PSRLW: Shift Packed Word Data Right Logical.

Forms:

PSRLW imm8 xmm
PSRLW xmm  xmm
PSRLW m128 xmm

Construct and append a PSRLW instruction to the active function. Operates on the global context.

func PSUBB ¶

func PSUBB(mx, x operand.Op)

PSUBB: Subtract Packed Byte Integers.

Forms:

PSUBB xmm  xmm
PSUBB m128 xmm

Construct and append a PSUBB instruction to the active function. Operates on the global context.

func PSUBL ¶

func PSUBL(mx, x operand.Op)

PSUBL: Subtract Packed Doubleword Integers.

Forms:

PSUBL xmm  xmm
PSUBL m128 xmm

Construct and append a PSUBL instruction to the active function. Operates on the global context.

func PSUBQ ¶

func PSUBQ(mx, x operand.Op)

PSUBQ: Subtract Packed Quadword Integers.

Forms:

PSUBQ xmm  xmm
PSUBQ m128 xmm

Construct and append a PSUBQ instruction to the active function. Operates on the global context.

func PSUBSB ¶

func PSUBSB(mx, x operand.Op)

PSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation.

Forms:

PSUBSB xmm  xmm
PSUBSB m128 xmm

Construct and append a PSUBSB instruction to the active function. Operates on the global context.

func PSUBSW ¶

func PSUBSW(mx, x operand.Op)

PSUBSW: Subtract Packed Signed Word Integers with Signed Saturation.

Forms:

PSUBSW xmm  xmm
PSUBSW m128 xmm

Construct and append a PSUBSW instruction to the active function. Operates on the global context.

func PSUBUSB ¶

func PSUBUSB(mx, x operand.Op)

PSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

PSUBUSB xmm  xmm
PSUBUSB m128 xmm

Construct and append a PSUBUSB instruction to the active function. Operates on the global context.

func PSUBUSW ¶

func PSUBUSW(mx, x operand.Op)

PSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

PSUBUSW xmm  xmm
PSUBUSW m128 xmm

Construct and append a PSUBUSW instruction to the active function. Operates on the global context.

func PSUBW ¶

func PSUBW(mx, x operand.Op)

PSUBW: Subtract Packed Word Integers.

Forms:

PSUBW xmm  xmm
PSUBW m128 xmm

Construct and append a PSUBW instruction to the active function. Operates on the global context.

func PTEST ¶

func PTEST(mx, x operand.Op)

PTEST: Packed Logical Compare.

Forms:

PTEST xmm  xmm
PTEST m128 xmm

Construct and append a PTEST instruction to the active function. Operates on the global context.

func PUNPCKHBW ¶

func PUNPCKHBW(mx, x operand.Op)

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

Forms:

PUNPCKHBW xmm  xmm
PUNPCKHBW m128 xmm

Construct and append a PUNPCKHBW instruction to the active function. Operates on the global context.

func PUNPCKHLQ ¶

func PUNPCKHLQ(mx, x operand.Op)

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

Forms:

PUNPCKHLQ xmm  xmm
PUNPCKHLQ m128 xmm

Construct and append a PUNPCKHLQ instruction to the active function. Operates on the global context.

func PUNPCKHQDQ ¶

func PUNPCKHQDQ(mx, x operand.Op)

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

Forms:

PUNPCKHQDQ xmm  xmm
PUNPCKHQDQ m128 xmm

Construct and append a PUNPCKHQDQ instruction to the active function. Operates on the global context.

func PUNPCKHWL ¶

func PUNPCKHWL(mx, x operand.Op)

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

Forms:

PUNPCKHWL xmm  xmm
PUNPCKHWL m128 xmm

Construct and append a PUNPCKHWL instruction to the active function. Operates on the global context.

func PUNPCKLBW ¶

func PUNPCKLBW(mx, x operand.Op)

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

Forms:

PUNPCKLBW xmm  xmm
PUNPCKLBW m128 xmm

Construct and append a PUNPCKLBW instruction to the active function. Operates on the global context.

func PUNPCKLLQ ¶

func PUNPCKLLQ(mx, x operand.Op)

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

Forms:

PUNPCKLLQ xmm  xmm
PUNPCKLLQ m128 xmm

Construct and append a PUNPCKLLQ instruction to the active function. Operates on the global context.

func PUNPCKLQDQ ¶

func PUNPCKLQDQ(mx, x operand.Op)

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

Forms:

PUNPCKLQDQ xmm  xmm
PUNPCKLQDQ m128 xmm

Construct and append a PUNPCKLQDQ instruction to the active function. Operates on the global context.

func PUNPCKLWL ¶

func PUNPCKLWL(mx, x operand.Op)

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

Forms:

PUNPCKLWL xmm  xmm
PUNPCKLWL m128 xmm

Construct and append a PUNPCKLWL instruction to the active function. Operates on the global context.

func PUSHQ ¶

func PUSHQ(imr operand.Op)

PUSHQ: Push Value Onto the Stack.

Forms:

PUSHQ imm8
PUSHQ imm32
PUSHQ r64
PUSHQ m64

Construct and append a PUSHQ instruction to the active function. Operates on the global context.

func PUSHW ¶

func PUSHW(mr operand.Op)

PUSHW: Push Value Onto the Stack.

Forms:

PUSHW r16
PUSHW m16

Construct and append a PUSHW instruction to the active function. Operates on the global context.

func PXOR ¶

func PXOR(mx, x operand.Op)

PXOR: Packed Bitwise Logical Exclusive OR.

Forms:

PXOR xmm  xmm
PXOR m128 xmm

Construct and append a PXOR instruction to the active function. Operates on the global context.

func Package ¶

func Package(path string)

Package sets the package the generated file will belong to. Required to be able to reference types in the package.

func Param ¶

func Param(name string) gotypes.Component

Param returns a the named argument of the active function.

func ParamIndex ¶

func ParamIndex(i int) gotypes.Component

ParamIndex returns the ith argument of the active function.

func Pragma ¶

func Pragma(directive string, args ...string)

Pragma adds a compiler directive to the currently active function.

func RCLB ¶

func RCLB(ci, mr operand.Op)

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

Construct and append a RCLB instruction to the active function. Operates on the global context.

func RCLL ¶

func RCLL(ci, mr operand.Op)

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

Construct and append a RCLL instruction to the active function. Operates on the global context.

func RCLQ ¶

func RCLQ(ci, mr operand.Op)

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

Construct and append a RCLQ instruction to the active function. Operates on the global context.

func RCLW ¶

func RCLW(ci, mr operand.Op)

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

Construct and append a RCLW instruction to the active function. Operates on the global context.

func RCPPS ¶

func RCPPS(mx, x operand.Op)

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

Forms:

RCPPS xmm  xmm
RCPPS m128 xmm

Construct and append a RCPPS instruction to the active function. Operates on the global context.

func RCPSS ¶

func RCPSS(mx, x operand.Op)

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

Forms:

RCPSS xmm xmm
RCPSS m32 xmm

Construct and append a RCPSS instruction to the active function. Operates on the global context.

func RCRB ¶

func RCRB(ci, mr operand.Op)

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

Construct and append a RCRB instruction to the active function. Operates on the global context.

func RCRL ¶

func RCRL(ci, mr operand.Op)

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

Construct and append a RCRL instruction to the active function. Operates on the global context.

func RCRQ ¶

func RCRQ(ci, mr operand.Op)

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

Construct and append a RCRQ instruction to the active function. Operates on the global context.

func RCRW ¶

func RCRW(ci, mr operand.Op)

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

Construct and append a RCRW instruction to the active function. Operates on the global context.

func RDRANDL ¶

func RDRANDL(r operand.Op)

RDRANDL: Read Random Number.

Forms:

RDRANDL r32

Construct and append a RDRANDL instruction to the active function. Operates on the global context.

func RDRANDQ ¶

func RDRANDQ(r operand.Op)

RDRANDQ: Read Random Number.

Forms:

RDRANDQ r64

Construct and append a RDRANDQ instruction to the active function. Operates on the global context.

func RDRANDW ¶

func RDRANDW(r operand.Op)

RDRANDW: Read Random Number.

Forms:

RDRANDW r16

Construct and append a RDRANDW instruction to the active function. Operates on the global context.

func RDSEEDL ¶

func RDSEEDL(r operand.Op)

RDSEEDL: Read Random SEED.

Forms:

RDSEEDL r32

Construct and append a RDSEEDL instruction to the active function. Operates on the global context.

func RDSEEDQ ¶

func RDSEEDQ(r operand.Op)

RDSEEDQ: Read Random SEED.

Forms:

RDSEEDQ r64

Construct and append a RDSEEDQ instruction to the active function. Operates on the global context.

func RDSEEDW ¶

func RDSEEDW(r operand.Op)

RDSEEDW: Read Random SEED.

Forms:

RDSEEDW r16

Construct and append a RDSEEDW instruction to the active function. Operates on the global context.

func RDTSC ¶

func RDTSC()

RDTSC: Read Time-Stamp Counter.

Forms:

RDTSC

Construct and append a RDTSC instruction to the active function. Operates on the global context.

func RDTSCP ¶

func RDTSCP()

RDTSCP: Read Time-Stamp Counter and Processor ID.

Forms:

RDTSCP

Construct and append a RDTSCP instruction to the active function. Operates on the global context.

func RET ¶

func RET()

RET: Return from Procedure.

Forms:

RET

Construct and append a RET instruction to the active function. Operates on the global context.

func RETFL ¶

func RETFL(i operand.Op)

RETFL: Return from Procedure.

Forms:

RETFL imm16

Construct and append a RETFL instruction to the active function. Operates on the global context.

func RETFQ ¶

func RETFQ(i operand.Op)

RETFQ: Return from Procedure.

Forms:

RETFQ imm16

Construct and append a RETFQ instruction to the active function. Operates on the global context.

func RETFW ¶

func RETFW(i operand.Op)

RETFW: Return from Procedure.

Forms:

RETFW imm16

Construct and append a RETFW instruction to the active function. Operates on the global context.

func ROLB ¶

func ROLB(ci, mr operand.Op)

ROLB: Rotate Left.

Forms:

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

Construct and append a ROLB instruction to the active function. Operates on the global context.

func ROLL ¶

func ROLL(ci, mr operand.Op)

ROLL: Rotate Left.

Forms:

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

Construct and append a ROLL instruction to the active function. Operates on the global context.

func ROLQ ¶

func ROLQ(ci, mr operand.Op)

ROLQ: Rotate Left.

Forms:

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

Construct and append a ROLQ instruction to the active function. Operates on the global context.

func ROLW ¶

func ROLW(ci, mr operand.Op)

ROLW: Rotate Left.

Forms:

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

Construct and append a ROLW instruction to the active function. Operates on the global context.

func RORB ¶

func RORB(ci, mr operand.Op)

RORB: Rotate Right.

Forms:

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

Construct and append a RORB instruction to the active function. Operates on the global context.

func RORL ¶

func RORL(ci, mr operand.Op)

RORL: Rotate Right.

Forms:

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

Construct and append a RORL instruction to the active function. Operates on the global context.

func RORQ ¶

func RORQ(ci, mr operand.Op)

RORQ: Rotate Right.

Forms:

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

Construct and append a RORQ instruction to the active function. Operates on the global context.

func RORW ¶

func RORW(ci, mr operand.Op)

RORW: Rotate Right.

Forms:

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

Construct and append a RORW instruction to the active function. Operates on the global context.

func RORXL ¶

func RORXL(i, mr, r operand.Op)

RORXL: Rotate Right Logical Without Affecting Flags.

Forms:

RORXL imm8 r32 r32
RORXL imm8 m32 r32

Construct and append a RORXL instruction to the active function. Operates on the global context.

func RORXQ ¶

func RORXQ(i, mr, r operand.Op)

RORXQ: Rotate Right Logical Without Affecting Flags.

Forms:

RORXQ imm8 r64 r64
RORXQ imm8 m64 r64

Construct and append a RORXQ instruction to the active function. Operates on the global context.

func ROUNDPD ¶

func ROUNDPD(i, mx, x operand.Op)

ROUNDPD: Round Packed Double Precision Floating-Point Values.

Forms:

ROUNDPD imm8 xmm  xmm
ROUNDPD imm8 m128 xmm

Construct and append a ROUNDPD instruction to the active function. Operates on the global context.

func ROUNDPS ¶

func ROUNDPS(i, mx, x operand.Op)

ROUNDPS: Round Packed Single Precision Floating-Point Values.

Forms:

ROUNDPS imm8 xmm  xmm
ROUNDPS imm8 m128 xmm

Construct and append a ROUNDPS instruction to the active function. Operates on the global context.

func ROUNDSD ¶

func ROUNDSD(i, mx, x operand.Op)

ROUNDSD: Round Scalar Double Precision Floating-Point Values.

Forms:

ROUNDSD imm8 xmm xmm
ROUNDSD imm8 m64 xmm

Construct and append a ROUNDSD instruction to the active function. Operates on the global context.

func ROUNDSS ¶

func ROUNDSS(i, mx, x operand.Op)

ROUNDSS: Round Scalar Single Precision Floating-Point Values.

Forms:

ROUNDSS imm8 xmm xmm
ROUNDSS imm8 m32 xmm

Construct and append a ROUNDSS instruction to the active function. Operates on the global context.

func RSQRTPS ¶

func RSQRTPS(mx, x operand.Op)

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

Forms:

RSQRTPS xmm  xmm
RSQRTPS m128 xmm

Construct and append a RSQRTPS instruction to the active function. Operates on the global context.

func RSQRTSS ¶

func RSQRTSS(mx, x operand.Op)

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

Forms:

RSQRTSS xmm xmm
RSQRTSS m32 xmm

Construct and append a RSQRTSS instruction to the active function. Operates on the global context.

func Return ¶

func Return(name string) gotypes.Component

Return returns a the named return value of the active function.

func ReturnIndex ¶

func ReturnIndex(i int) gotypes.Component

ReturnIndex returns the ith argument of the active function.

func SALB ¶

func SALB(ci, mr operand.Op)

SALB: Arithmetic Shift Left.

Forms:

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

Construct and append a SALB instruction to the active function. Operates on the global context.

func SALL ¶

func SALL(ci, mr operand.Op)

SALL: Arithmetic Shift Left.

Forms:

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

Construct and append a SALL instruction to the active function. Operates on the global context.

func SALQ ¶

func SALQ(ci, mr operand.Op)

SALQ: Arithmetic Shift Left.

Forms:

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

Construct and append a SALQ instruction to the active function. Operates on the global context.

func SALW ¶

func SALW(ci, mr operand.Op)

SALW: Arithmetic Shift Left.

Forms:

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

Construct and append a SALW instruction to the active function. Operates on the global context.

func SARB ¶

func SARB(ci, mr operand.Op)

SARB: Arithmetic Shift Right.

Forms:

SARB 1    r8
SARB imm8 r8
SARB cl   r8
SARB 1    m8
SARB imm8 m8
SARB cl   m8

Construct and append a SARB instruction to the active function. Operates on the global context.

func SARL ¶

func SARL(ci, mr operand.Op)

SARL: Arithmetic Shift Right.

Forms:

SARL 1    r32
SARL imm8 r32
SARL cl   r32
SARL 1    m32
SARL imm8 m32
SARL cl   m32

Construct and append a SARL instruction to the active function. Operates on the global context.

func SARQ ¶

func SARQ(ci, mr operand.Op)

SARQ: Arithmetic Shift Right.

Forms:

SARQ 1    r64
SARQ imm8 r64
SARQ cl   r64
SARQ 1    m64
SARQ imm8 m64
SARQ cl   m64

Construct and append a SARQ instruction to the active function. Operates on the global context.

func SARW ¶

func SARW(ci, mr operand.Op)

SARW: Arithmetic Shift Right.

Forms:

SARW 1    r16
SARW imm8 r16
SARW cl   r16
SARW 1    m16
SARW imm8 m16
SARW cl   m16

Construct and append a SARW instruction to the active function. Operates on the global context.

func SARXL ¶

func SARXL(r, mr, r1 operand.Op)

SARXL: Arithmetic Shift Right Without Affecting Flags.

Forms:

SARXL r32 r32 r32
SARXL r32 m32 r32

Construct and append a SARXL instruction to the active function. Operates on the global context.

func SARXQ ¶

func SARXQ(r, mr, r1 operand.Op)

SARXQ: Arithmetic Shift Right Without Affecting Flags.

Forms:

SARXQ r64 r64 r64
SARXQ r64 m64 r64

Construct and append a SARXQ instruction to the active function. Operates on the global context.

func SBBB ¶

func SBBB(imr, amr operand.Op)

SBBB: Subtract with Borrow.

Forms:

SBBB imm8 al
SBBB imm8 r8
SBBB r8   r8
SBBB m8   r8
SBBB imm8 m8
SBBB r8   m8

Construct and append a SBBB instruction to the active function. Operates on the global context.

func SBBL ¶

func SBBL(imr, emr operand.Op)

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

Construct and append a SBBL instruction to the active function. Operates on the global context.

func SBBQ ¶

func SBBQ(imr, mr operand.Op)

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

Construct and append a SBBQ instruction to the active function. Operates on the global context.

func SBBW ¶

func SBBW(imr, amr operand.Op)

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

Construct and append a SBBW instruction to the active function. Operates on the global context.

func SETCC ¶

func SETCC(mr operand.Op)

SETCC: Set byte if above or equal (CF == 0).

Forms:

SETCC r8
SETCC m8

Construct and append a SETCC instruction to the active function. Operates on the global context.

func SETCS ¶

func SETCS(mr operand.Op)

SETCS: Set byte if below (CF == 1).

Forms:

SETCS r8
SETCS m8

Construct and append a SETCS instruction to the active function. Operates on the global context.

func SETEQ ¶

func SETEQ(mr operand.Op)

SETEQ: Set byte if equal (ZF == 1).

Forms:

SETEQ r8
SETEQ m8

Construct and append a SETEQ instruction to the active function. Operates on the global context.

func SETGE ¶

func SETGE(mr operand.Op)

SETGE: Set byte if greater or equal (SF == OF).

Forms:

SETGE r8
SETGE m8

Construct and append a SETGE instruction to the active function. Operates on the global context.

func SETGT ¶

func SETGT(mr operand.Op)

SETGT: Set byte if greater (ZF == 0 and SF == OF).

Forms:

SETGT r8
SETGT m8

Construct and append a SETGT instruction to the active function. Operates on the global context.

func SETHI ¶

func SETHI(mr operand.Op)

SETHI: Set byte if above (CF == 0 and ZF == 0).

Forms:

SETHI r8
SETHI m8

Construct and append a SETHI instruction to the active function. Operates on the global context.

func SETLE ¶

func SETLE(mr operand.Op)

SETLE: Set byte if less or equal (ZF == 1 or SF != OF).

Forms:

SETLE r8
SETLE m8

Construct and append a SETLE instruction to the active function. Operates on the global context.

func SETLS ¶

func SETLS(mr operand.Op)

SETLS: Set byte if below or equal (CF == 1 or ZF == 1).

Forms:

SETLS r8
SETLS m8

Construct and append a SETLS instruction to the active function. Operates on the global context.

func SETLT ¶

func SETLT(mr operand.Op)

SETLT: Set byte if less (SF != OF).

Forms:

SETLT r8
SETLT m8

Construct and append a SETLT instruction to the active function. Operates on the global context.

func SETMI ¶

func SETMI(mr operand.Op)

SETMI: Set byte if sign (SF == 1).

Forms:

SETMI r8
SETMI m8

Construct and append a SETMI instruction to the active function. Operates on the global context.

func SETNE ¶

func SETNE(mr operand.Op)

SETNE: Set byte if not equal (ZF == 0).

Forms:

SETNE r8
SETNE m8

Construct and append a SETNE instruction to the active function. Operates on the global context.

func SETOC ¶

func SETOC(mr operand.Op)

SETOC: Set byte if not overflow (OF == 0).

Forms:

SETOC r8
SETOC m8

Construct and append a SETOC instruction to the active function. Operates on the global context.

func SETOS ¶

func SETOS(mr operand.Op)

SETOS: Set byte if overflow (OF == 1).

Forms:

SETOS r8
SETOS m8

Construct and append a SETOS instruction to the active function. Operates on the global context.

func SETPC ¶

func SETPC(mr operand.Op)

SETPC: Set byte if not parity (PF == 0).

Forms:

SETPC r8
SETPC m8

Construct and append a SETPC instruction to the active function. Operates on the global context.

func SETPL ¶

func SETPL(mr operand.Op)

SETPL: Set byte if not sign (SF == 0).

Forms:

SETPL r8
SETPL m8

Construct and append a SETPL instruction to the active function. Operates on the global context.

func SETPS ¶

func SETPS(mr operand.Op)

SETPS: Set byte if parity (PF == 1).

Forms:

SETPS r8
SETPS m8

Construct and append a SETPS instruction to the active function. Operates on the global context.

func SFENCE ¶

func SFENCE()

SFENCE: Store Fence.

Forms:

SFENCE

Construct and append a SFENCE instruction to the active function. Operates on the global context.

func SHA1MSG1 ¶

func SHA1MSG1(mx, x operand.Op)

SHA1MSG1: Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords.

Forms:

SHA1MSG1 xmm  xmm
SHA1MSG1 m128 xmm

Construct and append a SHA1MSG1 instruction to the active function. Operates on the global context.

func SHA1MSG2 ¶

func SHA1MSG2(mx, x operand.Op)

SHA1MSG2: Perform a Final Calculation for the Next Four SHA1 Message Doublewords.

Forms:

SHA1MSG2 xmm  xmm
SHA1MSG2 m128 xmm

Construct and append a SHA1MSG2 instruction to the active function. Operates on the global context.

func SHA1NEXTE ¶

func SHA1NEXTE(mx, x operand.Op)

SHA1NEXTE: Calculate SHA1 State Variable E after Four Rounds.

Forms:

SHA1NEXTE xmm  xmm
SHA1NEXTE m128 xmm

Construct and append a SHA1NEXTE instruction to the active function. Operates on the global context.

func SHA1RNDS4 ¶

func SHA1RNDS4(i, mx, x operand.Op)

SHA1RNDS4: Perform Four Rounds of SHA1 Operation.

Forms:

SHA1RNDS4 imm2u xmm  xmm
SHA1RNDS4 imm2u m128 xmm

Construct and append a SHA1RNDS4 instruction to the active function. Operates on the global context.

func SHA256MSG1 ¶

func SHA256MSG1(mx, x operand.Op)

SHA256MSG1: Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords.

Forms:

SHA256MSG1 xmm  xmm
SHA256MSG1 m128 xmm

Construct and append a SHA256MSG1 instruction to the active function. Operates on the global context.

func SHA256MSG2 ¶

func SHA256MSG2(mx, x operand.Op)

SHA256MSG2: Perform a Final Calculation for the Next Four SHA256 Message Doublewords.

Forms:

SHA256MSG2 xmm  xmm
SHA256MSG2 m128 xmm

Construct and append a SHA256MSG2 instruction to the active function. Operates on the global context.

func SHA256RNDS2 ¶

func SHA256RNDS2(x, mx, x1 operand.Op)

SHA256RNDS2: Perform Two Rounds of SHA256 Operation.

Forms:

SHA256RNDS2 xmm0 xmm  xmm
SHA256RNDS2 xmm0 m128 xmm

Construct and append a SHA256RNDS2 instruction to the active function. Operates on the global context.

func SHLB ¶

func SHLB(ci, mr operand.Op)

SHLB: Logical Shift Left.

Forms:

SHLB 1    r8
SHLB imm8 r8
SHLB cl   r8
SHLB 1    m8
SHLB imm8 m8
SHLB cl   m8

Construct and append a SHLB instruction to the active function. Operates on the global context.

func SHLL ¶

func SHLL(ops ...operand.Op)

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

Construct and append a SHLL instruction to the active function. Operates on the global context.

func SHLQ ¶

func SHLQ(ops ...operand.Op)

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

Construct and append a SHLQ instruction to the active function. Operates on the global context.

func SHLW ¶

func SHLW(ops ...operand.Op)

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

Construct and append a SHLW instruction to the active function. Operates on the global context.

func SHLXL ¶

func SHLXL(r, mr, r1 operand.Op)

SHLXL: Logical Shift Left Without Affecting Flags.

Forms:

SHLXL r32 r32 r32
SHLXL r32 m32 r32

Construct and append a SHLXL instruction to the active function. Operates on the global context.

func SHLXQ ¶

func SHLXQ(r, mr, r1 operand.Op)

SHLXQ: Logical Shift Left Without Affecting Flags.

Forms:

SHLXQ r64 r64 r64
SHLXQ r64 m64 r64

Construct and append a SHLXQ instruction to the active function. Operates on the global context.

func SHRB ¶

func SHRB(ci, mr operand.Op)

SHRB: Logical Shift Right.

Forms:

SHRB 1    r8
SHRB imm8 r8
SHRB cl   r8
SHRB 1    m8
SHRB imm8 m8
SHRB cl   m8

Construct and append a SHRB instruction to the active function. Operates on the global context.

func SHRL ¶

func SHRL(ops ...operand.Op)

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

Construct and append a SHRL instruction to the active function. Operates on the global context.

func SHRQ ¶

func SHRQ(ops ...operand.Op)

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

Construct and append a SHRQ instruction to the active function. Operates on the global context.

func SHRW ¶

func SHRW(ops ...operand.Op)

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

Construct and append a SHRW instruction to the active function. Operates on the global context.

func SHRXL ¶

func SHRXL(r, mr, r1 operand.Op)

SHRXL: Logical Shift Right Without Affecting Flags.

Forms:

SHRXL r32 r32 r32
SHRXL r32 m32 r32

Construct and append a SHRXL instruction to the active function. Operates on the global context.

func SHRXQ ¶

func SHRXQ(r, mr, r1 operand.Op)

SHRXQ: Logical Shift Right Without Affecting Flags.

Forms:

SHRXQ r64 r64 r64
SHRXQ r64 m64 r64

Construct and append a SHRXQ instruction to the active function. Operates on the global context.

func SHUFPD ¶

func SHUFPD(i, mx, x operand.Op)

SHUFPD: Shuffle Packed Double-Precision Floating-Point Values.

Forms:

SHUFPD imm8 xmm  xmm
SHUFPD imm8 m128 xmm

Construct and append a SHUFPD instruction to the active function. Operates on the global context.

func SHUFPS ¶

func SHUFPS(i, mx, x operand.Op)

SHUFPS: Shuffle Packed Single-Precision Floating-Point Values.

Forms:

SHUFPS imm8 xmm  xmm
SHUFPS imm8 m128 xmm

Construct and append a SHUFPS instruction to the active function. Operates on the global context.

func SQRTPD ¶

func SQRTPD(mx, x operand.Op)

SQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values.

Forms:

SQRTPD xmm  xmm
SQRTPD m128 xmm

Construct and append a SQRTPD instruction to the active function. Operates on the global context.

func SQRTPS ¶

func SQRTPS(mx, x operand.Op)

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

Forms:

SQRTPS xmm  xmm
SQRTPS m128 xmm

Construct and append a SQRTPS instruction to the active function. Operates on the global context.

func SQRTSD ¶

func SQRTSD(mx, x operand.Op)

SQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value.

Forms:

SQRTSD xmm xmm
SQRTSD m64 xmm

Construct and append a SQRTSD instruction to the active function. Operates on the global context.

func SQRTSS ¶

func SQRTSS(mx, x operand.Op)

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

Forms:

SQRTSS xmm xmm
SQRTSS m32 xmm

Construct and append a SQRTSS instruction to the active function. Operates on the global context.

func STC ¶

func STC()

STC: Set Carry Flag.

Forms:

STC

Construct and append a STC instruction to the active function. Operates on the global context.

func STD ¶

func STD()

STD: Set Direction Flag.

Forms:

STD

Construct and append a STD instruction to the active function. Operates on the global context.

func STMXCSR ¶

func STMXCSR(m operand.Op)

STMXCSR: Store MXCSR Register State.

Forms:

STMXCSR m32

Construct and append a STMXCSR instruction to the active function. Operates on the global context.

func SUBB ¶

func SUBB(imr, amr operand.Op)

SUBB: Subtract.

Forms:

SUBB imm8 al
SUBB imm8 r8
SUBB r8   r8
SUBB m8   r8
SUBB imm8 m8
SUBB r8   m8

Construct and append a SUBB instruction to the active function. Operates on the global context.

func SUBL ¶

func SUBL(imr, emr operand.Op)

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

Construct and append a SUBL instruction to the active function. Operates on the global context.

func SUBPD ¶

func SUBPD(mx, x operand.Op)

SUBPD: Subtract Packed Double-Precision Floating-Point Values.

Forms:

SUBPD xmm  xmm
SUBPD m128 xmm

Construct and append a SUBPD instruction to the active function. Operates on the global context.

func SUBPS ¶

func SUBPS(mx, x operand.Op)

SUBPS: Subtract Packed Single-Precision Floating-Point Values.

Forms:

SUBPS xmm  xmm
SUBPS m128 xmm

Construct and append a SUBPS instruction to the active function. Operates on the global context.

func SUBQ ¶

func SUBQ(imr, mr operand.Op)

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

Construct and append a SUBQ instruction to the active function. Operates on the global context.

func SUBSD ¶

func SUBSD(mx, x operand.Op)

SUBSD: Subtract Scalar Double-Precision Floating-Point Values.

Forms:

SUBSD xmm xmm
SUBSD m64 xmm

Construct and append a SUBSD instruction to the active function. Operates on the global context.

func SUBSS ¶

func SUBSS(mx, x operand.Op)

SUBSS: Subtract Scalar Single-Precision Floating-Point Values.

Forms:

SUBSS xmm xmm
SUBSS m32 xmm

Construct and append a SUBSS instruction to the active function. Operates on the global context.

func SUBW ¶

func SUBW(imr, amr operand.Op)

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

Construct and append a SUBW instruction to the active function. Operates on the global context.

func SYSCALL ¶

func SYSCALL()

SYSCALL: Fast System Call.

Forms:

SYSCALL

Construct and append a SYSCALL instruction to the active function. Operates on the global context.

func Store ¶

func Store(src reg.Register, dst gotypes.Component)

Store register src into return value dst. This is syntactic sugar: it will attempt to select the right MOV instruction based on the types involved.

func TESTB ¶

func TESTB(ir, amr operand.Op)

TESTB: Logical Compare.

Forms:

TESTB imm8 al
TESTB imm8 r8
TESTB r8   r8
TESTB imm8 m8
TESTB r8   m8

Construct and append a TESTB instruction to the active function. Operates on the global context.

func TESTL ¶

func TESTL(ir, emr operand.Op)

TESTL: Logical Compare.

Forms:

TESTL imm32 eax
TESTL imm32 r32
TESTL r32   r32
TESTL imm32 m32
TESTL r32   m32

Construct and append a TESTL instruction to the active function. Operates on the global context.

func TESTQ ¶

func TESTQ(ir, mr operand.Op)

TESTQ: Logical Compare.

Forms:

TESTQ imm32 rax
TESTQ imm32 r64
TESTQ r64   r64
TESTQ imm32 m64
TESTQ r64   m64

Construct and append a TESTQ instruction to the active function. Operates on the global context.

func TESTW ¶

func TESTW(ir, amr operand.Op)

TESTW: Logical Compare.

Forms:

TESTW imm16 ax
TESTW imm16 r16
TESTW r16   r16
TESTW imm16 m16
TESTW r16   m16

Construct and append a TESTW instruction to the active function. Operates on the global context.

func TEXT ¶

func TEXT(name string, a attr.Attribute, signature string)

TEXT starts building a new function called name, with attributes a, and sets its signature (see SignatureExpr).

func TZCNTL ¶

func TZCNTL(mr, r operand.Op)

TZCNTL: Count the Number of Trailing Zero Bits.

Forms:

TZCNTL r32 r32
TZCNTL m32 r32

Construct and append a TZCNTL instruction to the active function. Operates on the global context.

func TZCNTQ ¶

func TZCNTQ(mr, r operand.Op)

TZCNTQ: Count the Number of Trailing Zero Bits.

Forms:

TZCNTQ r64 r64
TZCNTQ m64 r64

Construct and append a TZCNTQ instruction to the active function. Operates on the global context.

func TZCNTW ¶

func TZCNTW(mr, r operand.Op)

TZCNTW: Count the Number of Trailing Zero Bits.

Forms:

TZCNTW r16 r16
TZCNTW m16 r16

Construct and append a TZCNTW instruction to the active function. Operates on the global context.

func UCOMISD ¶

func UCOMISD(mx, x operand.Op)

UCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

UCOMISD xmm xmm
UCOMISD m64 xmm

Construct and append a UCOMISD instruction to the active function. Operates on the global context.

func UCOMISS ¶

func UCOMISS(mx, x operand.Op)

UCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

UCOMISS xmm xmm
UCOMISS m32 xmm

Construct and append a UCOMISS instruction to the active function. Operates on the global context.

func UD2 ¶

func UD2()

UD2: Undefined Instruction.

Forms:

UD2

Construct and append a UD2 instruction to the active function. Operates on the global context.

func UNPCKHPD ¶

func UNPCKHPD(mx, x operand.Op)

UNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values.

Forms:

UNPCKHPD xmm  xmm
UNPCKHPD m128 xmm

Construct and append a UNPCKHPD instruction to the active function. Operates on the global context.

func UNPCKHPS ¶

func UNPCKHPS(mx, x operand.Op)

UNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values.

Forms:

UNPCKHPS xmm  xmm
UNPCKHPS m128 xmm

Construct and append a UNPCKHPS instruction to the active function. Operates on the global context.

func UNPCKLPD ¶

func UNPCKLPD(mx, x operand.Op)

UNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values.

Forms:

UNPCKLPD xmm  xmm
UNPCKLPD m128 xmm

Construct and append a UNPCKLPD instruction to the active function. Operates on the global context.

func UNPCKLPS ¶

func UNPCKLPS(mx, x operand.Op)

UNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values.

Forms:

UNPCKLPS xmm  xmm
UNPCKLPS m128 xmm

Construct and append a UNPCKLPS instruction to the active function. Operates on the global context.

func VADDPD ¶

func VADDPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VADDPD instruction to the active function. Operates on the global context.

func VADDPS ¶

func VADDPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VADDPS instruction to the active function. Operates on the global context.

func VADDSD ¶

func VADDSD(mx, x, x1 operand.Op)

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

Forms:

VADDSD xmm xmm xmm
VADDSD m64 xmm xmm

Construct and append a VADDSD instruction to the active function. Operates on the global context.

func VADDSS ¶

func VADDSS(mx, x, x1 operand.Op)

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

Forms:

VADDSS xmm xmm xmm
VADDSS m32 xmm xmm

Construct and append a VADDSS instruction to the active function. Operates on the global context.

func VADDSUBPD ¶

func VADDSUBPD(mxy, xy, xy1 operand.Op)

VADDSUBPD: Packed Double-FP Add/Subtract.

Forms:

VADDSUBPD xmm  xmm xmm
VADDSUBPD m128 xmm xmm
VADDSUBPD ymm  ymm ymm
VADDSUBPD m256 ymm ymm

Construct and append a VADDSUBPD instruction to the active function. Operates on the global context.

func VADDSUBPS ¶

func VADDSUBPS(mxy, xy, xy1 operand.Op)

VADDSUBPS: Packed Single-FP Add/Subtract.

Forms:

VADDSUBPS xmm  xmm xmm
VADDSUBPS m128 xmm xmm
VADDSUBPS ymm  ymm ymm
VADDSUBPS m256 ymm ymm

Construct and append a VADDSUBPS instruction to the active function. Operates on the global context.

func VAESDEC ¶

func VAESDEC(mx, x, x1 operand.Op)

VAESDEC: Perform One Round of an AES Decryption Flow.

Forms:

VAESDEC xmm  xmm xmm
VAESDEC m128 xmm xmm

Construct and append a VAESDEC instruction to the active function. Operates on the global context.

func VAESDECLAST ¶

func VAESDECLAST(mx, x, x1 operand.Op)

VAESDECLAST: Perform Last Round of an AES Decryption Flow.

Forms:

VAESDECLAST xmm  xmm xmm
VAESDECLAST m128 xmm xmm

Construct and append a VAESDECLAST instruction to the active function. Operates on the global context.

func VAESENC ¶

func VAESENC(mx, x, x1 operand.Op)

VAESENC: Perform One Round of an AES Encryption Flow.

Forms:

VAESENC xmm  xmm xmm
VAESENC m128 xmm xmm

Construct and append a VAESENC instruction to the active function. Operates on the global context.

func VAESENCLAST ¶

func VAESENCLAST(mx, x, x1 operand.Op)

VAESENCLAST: Perform Last Round of an AES Encryption Flow.

Forms:

VAESENCLAST xmm  xmm xmm
VAESENCLAST m128 xmm xmm

Construct and append a VAESENCLAST instruction to the active function. Operates on the global context.

func VAESIMC ¶

func VAESIMC(mx, x operand.Op)

VAESIMC: Perform the AES InvMixColumn Transformation.

Forms:

VAESIMC xmm  xmm
VAESIMC m128 xmm

Construct and append a VAESIMC instruction to the active function. Operates on the global context.

func VAESKEYGENASSIST ¶

func VAESKEYGENASSIST(i, mx, x operand.Op)

VAESKEYGENASSIST: AES Round Key Generation Assist.

Forms:

VAESKEYGENASSIST imm8 xmm  xmm
VAESKEYGENASSIST imm8 m128 xmm

Construct and append a VAESKEYGENASSIST instruction to the active function. Operates on the global context.

func VANDNPD ¶

func VANDNPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDNPD instruction to the active function. Operates on the global context.

func VANDNPS ¶

func VANDNPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDNPS instruction to the active function. Operates on the global context.

func VANDPD ¶

func VANDPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDPD instruction to the active function. Operates on the global context.

func VANDPS ¶

func VANDPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDPS instruction to the active function. Operates on the global context.

func VBLENDPD ¶

func VBLENDPD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VBLENDPD instruction to the active function. Operates on the global context.

func VBLENDPS ¶

func VBLENDPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VBLENDPS instruction to the active function. Operates on the global context.

func VBLENDVPD ¶

func VBLENDVPD(xy, mxy, xy1, xy2 operand.Op)

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

Construct and append a VBLENDVPD instruction to the active function. Operates on the global context.

func VBLENDVPS ¶

func VBLENDVPS(xy, mxy, xy1, xy2 operand.Op)

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

Construct and append a VBLENDVPS instruction to the active function. Operates on the global context.

func VBROADCASTF128 ¶

func VBROADCASTF128(m, y operand.Op)

VBROADCASTF128: Broadcast 128 Bit of Floating-Point Data.

Forms:

VBROADCASTF128 m128 ymm

Construct and append a VBROADCASTF128 instruction to the active function. Operates on the global context.

func VBROADCASTI128 ¶

func VBROADCASTI128(m, y operand.Op)

VBROADCASTI128: Broadcast 128 Bits of Integer Data.

Forms:

VBROADCASTI128 m128 ymm

Construct and append a VBROADCASTI128 instruction to the active function. Operates on the global context.

func VBROADCASTSD ¶

func VBROADCASTSD(mx, y operand.Op)

VBROADCASTSD: Broadcast Double-Precision Floating-Point Element.

Forms:

VBROADCASTSD xmm ymm
VBROADCASTSD m64 ymm

Construct and append a VBROADCASTSD instruction to the active function. Operates on the global context.

func VBROADCASTSS ¶

func VBROADCASTSS(mx, xy operand.Op)

VBROADCASTSS: Broadcast Single-Precision Floating-Point Element.

Forms:

VBROADCASTSS xmm xmm
VBROADCASTSS m32 xmm
VBROADCASTSS xmm ymm
VBROADCASTSS m32 ymm

Construct and append a VBROADCASTSS instruction to the active function. Operates on the global context.

func VCMPPD ¶

func VCMPPD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VCMPPD instruction to the active function. Operates on the global context.

func VCMPPS ¶

func VCMPPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VCMPPS instruction to the active function. Operates on the global context.

func VCMPSD ¶

func VCMPSD(i, mx, x, x1 operand.Op)

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

Forms:

VCMPSD imm8 xmm xmm xmm
VCMPSD imm8 m64 xmm xmm

Construct and append a VCMPSD instruction to the active function. Operates on the global context.

func VCMPSS ¶

func VCMPSS(i, mx, x, x1 operand.Op)

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

Forms:

VCMPSS imm8 xmm xmm xmm
VCMPSS imm8 m32 xmm xmm

Construct and append a VCMPSS instruction to the active function. Operates on the global context.

func VCOMISD ¶

func VCOMISD(mx, x operand.Op)

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

Forms:

VCOMISD xmm xmm
VCOMISD m64 xmm

Construct and append a VCOMISD instruction to the active function. Operates on the global context.

func VCOMISS ¶

func VCOMISS(mx, x operand.Op)

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

Forms:

VCOMISS xmm xmm
VCOMISS m32 xmm

Construct and append a VCOMISS instruction to the active function. Operates on the global context.

func VCVTDQ2PD ¶

func VCVTDQ2PD(mx, xy operand.Op)

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

Forms:

VCVTDQ2PD xmm  xmm
VCVTDQ2PD m64  xmm
VCVTDQ2PD xmm  ymm
VCVTDQ2PD m128 ymm

Construct and append a VCVTDQ2PD instruction to the active function. Operates on the global context.

func VCVTDQ2PS ¶

func VCVTDQ2PS(mxy, xy operand.Op)

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

Forms:

VCVTDQ2PS xmm  xmm
VCVTDQ2PS m128 xmm
VCVTDQ2PS ymm  ymm
VCVTDQ2PS m256 ymm

Construct and append a VCVTDQ2PS instruction to the active function. Operates on the global context.

func VCVTPD2DQX ¶

func VCVTPD2DQX(mx, x operand.Op)

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

Forms:

VCVTPD2DQX xmm  xmm
VCVTPD2DQX m128 xmm

Construct and append a VCVTPD2DQX instruction to the active function. Operates on the global context.

func VCVTPD2DQY ¶

func VCVTPD2DQY(my, x operand.Op)

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

Forms:

VCVTPD2DQY ymm  xmm
VCVTPD2DQY m256 xmm

Construct and append a VCVTPD2DQY instruction to the active function. Operates on the global context.

func VCVTPD2PSX ¶

func VCVTPD2PSX(mx, x operand.Op)

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

Forms:

VCVTPD2PSX xmm  xmm
VCVTPD2PSX m128 xmm

Construct and append a VCVTPD2PSX instruction to the active function. Operates on the global context.

func VCVTPD2PSY ¶

func VCVTPD2PSY(my, x operand.Op)

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

Forms:

VCVTPD2PSY ymm  xmm
VCVTPD2PSY m256 xmm

Construct and append a VCVTPD2PSY instruction to the active function. Operates on the global context.

func VCVTPH2PS ¶

func VCVTPH2PS(mx, xy operand.Op)

VCVTPH2PS: Convert Half-Precision FP Values to Single-Precision FP Values.

Forms:

VCVTPH2PS xmm  xmm
VCVTPH2PS m64  xmm
VCVTPH2PS xmm  ymm
VCVTPH2PS m128 ymm

Construct and append a VCVTPH2PS instruction to the active function. Operates on the global context.

func VCVTPS2DQ ¶

func VCVTPS2DQ(mxy, xy operand.Op)

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

Forms:

VCVTPS2DQ xmm  xmm
VCVTPS2DQ m128 xmm
VCVTPS2DQ ymm  ymm
VCVTPS2DQ m256 ymm

Construct and append a VCVTPS2DQ instruction to the active function. Operates on the global context.

func VCVTPS2PD ¶

func VCVTPS2PD(mx, xy operand.Op)

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

Construct and append a VCVTPS2PD instruction to the active function. Operates on the global context.

func VCVTPS2PH ¶

func VCVTPS2PH(i, xy, mx operand.Op)

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

Construct and append a VCVTPS2PH instruction to the active function. Operates on the global context.

func VCVTSD2SI ¶

func VCVTSD2SI(mx, r operand.Op)

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

Forms:

VCVTSD2SI xmm r32
VCVTSD2SI m64 r32

Construct and append a VCVTSD2SI instruction to the active function. Operates on the global context.

func VCVTSD2SIQ ¶

func VCVTSD2SIQ(mx, r operand.Op)

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

Forms:

VCVTSD2SIQ xmm r64
VCVTSD2SIQ m64 r64

Construct and append a VCVTSD2SIQ instruction to the active function. Operates on the global context.

func VCVTSD2SS ¶

func VCVTSD2SS(mx, x, x1 operand.Op)

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

Forms:

VCVTSD2SS xmm xmm xmm
VCVTSD2SS m64 xmm xmm

Construct and append a VCVTSD2SS instruction to the active function. Operates on the global context.

func VCVTSI2SDL ¶

func VCVTSI2SDL(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SDL r32 xmm xmm
VCVTSI2SDL m32 xmm xmm

Construct and append a VCVTSI2SDL instruction to the active function. Operates on the global context.

func VCVTSI2SDQ ¶

func VCVTSI2SDQ(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SDQ r64 xmm xmm
VCVTSI2SDQ m64 xmm xmm

Construct and append a VCVTSI2SDQ instruction to the active function. Operates on the global context.

func VCVTSI2SSL ¶

func VCVTSI2SSL(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SSL r32 xmm xmm
VCVTSI2SSL m32 xmm xmm

Construct and append a VCVTSI2SSL instruction to the active function. Operates on the global context.

func VCVTSI2SSQ ¶

func VCVTSI2SSQ(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SSQ r64 xmm xmm
VCVTSI2SSQ m64 xmm xmm

Construct and append a VCVTSI2SSQ instruction to the active function. Operates on the global context.

func VCVTSS2SD ¶

func VCVTSS2SD(mx, x, x1 operand.Op)

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

Forms:

VCVTSS2SD xmm xmm xmm
VCVTSS2SD m32 xmm xmm

Construct and append a VCVTSS2SD instruction to the active function. Operates on the global context.

func VCVTSS2SI ¶

func VCVTSS2SI(mx, r operand.Op)

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

Forms:

VCVTSS2SI xmm r32
VCVTSS2SI m32 r32

Construct and append a VCVTSS2SI instruction to the active function. Operates on the global context.

func VCVTSS2SIQ ¶

func VCVTSS2SIQ(mx, r operand.Op)

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

Forms:

VCVTSS2SIQ xmm r64
VCVTSS2SIQ m32 r64

Construct and append a VCVTSS2SIQ instruction to the active function. Operates on the global context.

func VCVTTPD2DQX ¶

func VCVTTPD2DQX(mx, x operand.Op)

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

Forms:

VCVTTPD2DQX xmm  xmm
VCVTTPD2DQX m128 xmm

Construct and append a VCVTTPD2DQX instruction to the active function. Operates on the global context.

func VCVTTPD2DQY ¶

func VCVTTPD2DQY(my, x operand.Op)

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

Forms:

VCVTTPD2DQY ymm  xmm
VCVTTPD2DQY m256 xmm

Construct and append a VCVTTPD2DQY instruction to the active function. Operates on the global context.

func VCVTTPS2DQ ¶

func VCVTTPS2DQ(mxy, xy operand.Op)

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

Construct and append a VCVTTPS2DQ instruction to the active function. Operates on the global context.

func VCVTTSD2SI ¶

func VCVTTSD2SI(mx, r operand.Op)

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

Forms:

VCVTTSD2SI xmm r32
VCVTTSD2SI m64 r32

Construct and append a VCVTTSD2SI instruction to the active function. Operates on the global context.

func VCVTTSD2SIQ ¶

func VCVTTSD2SIQ(mx, r operand.Op)

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

Forms:

VCVTTSD2SIQ xmm r64
VCVTTSD2SIQ m64 r64

Construct and append a VCVTTSD2SIQ instruction to the active function. Operates on the global context.

func VCVTTSS2SI ¶

func VCVTTSS2SI(mx, r operand.Op)

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

Forms:

VCVTTSS2SI xmm r32
VCVTTSS2SI m32 r32

Construct and append a VCVTTSS2SI instruction to the active function. Operates on the global context.

func VCVTTSS2SIQ ¶

func VCVTTSS2SIQ(mx, r operand.Op)

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

Forms:

VCVTTSS2SIQ xmm r64
VCVTTSS2SIQ m32 r64

Construct and append a VCVTTSS2SIQ instruction to the active function. Operates on the global context.

func VDIVPD ¶

func VDIVPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VDIVPD instruction to the active function. Operates on the global context.

func VDIVPS ¶

func VDIVPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VDIVPS instruction to the active function. Operates on the global context.

func VDIVSD ¶

func VDIVSD(mx, x, x1 operand.Op)

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

Forms:

VDIVSD xmm xmm xmm
VDIVSD m64 xmm xmm

Construct and append a VDIVSD instruction to the active function. Operates on the global context.

func VDIVSS ¶

func VDIVSS(mx, x, x1 operand.Op)

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

Forms:

VDIVSS xmm xmm xmm
VDIVSS m32 xmm xmm

Construct and append a VDIVSS instruction to the active function. Operates on the global context.

func VDPPD ¶

func VDPPD(i, mx, x, x1 operand.Op)

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

Forms:

VDPPD imm8 xmm  xmm xmm
VDPPD imm8 m128 xmm xmm

Construct and append a VDPPD instruction to the active function. Operates on the global context.

func VDPPS ¶

func VDPPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VDPPS instruction to the active function. Operates on the global context.

func VEXTRACTF128 ¶

func VEXTRACTF128(i, y, mx operand.Op)

VEXTRACTF128: Extract Packed Floating-Point Values.

Forms:

VEXTRACTF128 imm8 ymm xmm
VEXTRACTF128 imm8 ymm m128

Construct and append a VEXTRACTF128 instruction to the active function. Operates on the global context.

func VEXTRACTI128 ¶

func VEXTRACTI128(i, y, mx operand.Op)

VEXTRACTI128: Extract Packed Integer Values.

Forms:

VEXTRACTI128 imm8 ymm xmm
VEXTRACTI128 imm8 ymm m128

Construct and append a VEXTRACTI128 instruction to the active function. Operates on the global context.

func VEXTRACTPS ¶

func VEXTRACTPS(i, x, mr operand.Op)

VEXTRACTPS: Extract Packed Single Precision Floating-Point Value.

Forms:

VEXTRACTPS imm8 xmm r32
VEXTRACTPS imm8 xmm m32

Construct and append a VEXTRACTPS instruction to the active function. Operates on the global context.

func VFMADD132PD ¶

func VFMADD132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD132PD instruction to the active function. Operates on the global context.

func VFMADD132PS ¶

func VFMADD132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD132PS instruction to the active function. Operates on the global context.

func VFMADD132SD ¶

func VFMADD132SD(mx, x, x1 operand.Op)

VFMADD132SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD132SD xmm xmm xmm
VFMADD132SD m64 xmm xmm

Construct and append a VFMADD132SD instruction to the active function. Operates on the global context.

func VFMADD132SS ¶

func VFMADD132SS(mx, x, x1 operand.Op)

VFMADD132SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD132SS xmm xmm xmm
VFMADD132SS m32 xmm xmm

Construct and append a VFMADD132SS instruction to the active function. Operates on the global context.

func VFMADD213PD ¶

func VFMADD213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD213PD instruction to the active function. Operates on the global context.

func VFMADD213PS ¶

func VFMADD213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD213PS instruction to the active function. Operates on the global context.

func VFMADD213SD ¶

func VFMADD213SD(mx, x, x1 operand.Op)

VFMADD213SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD213SD xmm xmm xmm
VFMADD213SD m64 xmm xmm

Construct and append a VFMADD213SD instruction to the active function. Operates on the global context.

func VFMADD213SS ¶

func VFMADD213SS(mx, x, x1 operand.Op)

VFMADD213SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD213SS xmm xmm xmm
VFMADD213SS m32 xmm xmm

Construct and append a VFMADD213SS instruction to the active function. Operates on the global context.

func VFMADD231PD ¶

func VFMADD231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD231PD instruction to the active function. Operates on the global context.

func VFMADD231PS ¶

func VFMADD231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD231PS instruction to the active function. Operates on the global context.

func VFMADD231SD ¶

func VFMADD231SD(mx, x, x1 operand.Op)

VFMADD231SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD231SD xmm xmm xmm
VFMADD231SD m64 xmm xmm

Construct and append a VFMADD231SD instruction to the active function. Operates on the global context.

func VFMADD231SS ¶

func VFMADD231SS(mx, x, x1 operand.Op)

VFMADD231SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD231SS xmm xmm xmm
VFMADD231SS m32 xmm xmm

Construct and append a VFMADD231SS instruction to the active function. Operates on the global context.

func VFMADDSUB132PD ¶

func VFMADDSUB132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB132PD instruction to the active function. Operates on the global context.

func VFMADDSUB132PS ¶

func VFMADDSUB132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB132PS instruction to the active function. Operates on the global context.

func VFMADDSUB213PD ¶

func VFMADDSUB213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB213PD instruction to the active function. Operates on the global context.

func VFMADDSUB213PS ¶

func VFMADDSUB213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB213PS instruction to the active function. Operates on the global context.

func VFMADDSUB231PD ¶

func VFMADDSUB231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB231PD instruction to the active function. Operates on the global context.

func VFMADDSUB231PS ¶

func VFMADDSUB231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB231PS instruction to the active function. Operates on the global context.

func VFMSUB132PD ¶

func VFMSUB132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB132PD instruction to the active function. Operates on the global context.

func VFMSUB132PS ¶

func VFMSUB132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB132PS instruction to the active function. Operates on the global context.

func VFMSUB132SD ¶

func VFMSUB132SD(mx, x, x1 operand.Op)

VFMSUB132SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB132SD xmm xmm xmm
VFMSUB132SD m64 xmm xmm

Construct and append a VFMSUB132SD instruction to the active function. Operates on the global context.

func VFMSUB132SS ¶

func VFMSUB132SS(mx, x, x1 operand.Op)

VFMSUB132SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB132SS xmm xmm xmm
VFMSUB132SS m32 xmm xmm

Construct and append a VFMSUB132SS instruction to the active function. Operates on the global context.

func VFMSUB213PD ¶

func VFMSUB213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB213PD instruction to the active function. Operates on the global context.

func VFMSUB213PS ¶

func VFMSUB213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB213PS instruction to the active function. Operates on the global context.

func VFMSUB213SD ¶

func VFMSUB213SD(mx, x, x1 operand.Op)

VFMSUB213SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB213SD xmm xmm xmm
VFMSUB213SD m64 xmm xmm

Construct and append a VFMSUB213SD instruction to the active function. Operates on the global context.

func VFMSUB213SS ¶

func VFMSUB213SS(mx, x, x1 operand.Op)

VFMSUB213SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB213SS xmm xmm xmm
VFMSUB213SS m32 xmm xmm

Construct and append a VFMSUB213SS instruction to the active function. Operates on the global context.

func VFMSUB231PD ¶

func VFMSUB231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB231PD instruction to the active function. Operates on the global context.

func VFMSUB231PS ¶

func VFMSUB231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB231PS instruction to the active function. Operates on the global context.

func VFMSUB231SD ¶

func VFMSUB231SD(mx, x, x1 operand.Op)

VFMSUB231SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB231SD xmm xmm xmm
VFMSUB231SD m64 xmm xmm

Construct and append a VFMSUB231SD instruction to the active function. Operates on the global context.

func VFMSUB231SS ¶

func VFMSUB231SS(mx, x, x1 operand.Op)

VFMSUB231SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB231SS xmm xmm xmm
VFMSUB231SS m32 xmm xmm

Construct and append a VFMSUB231SS instruction to the active function. Operates on the global context.

func VFMSUBADD132PD ¶

func VFMSUBADD132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD132PD instruction to the active function. Operates on the global context.

func VFMSUBADD132PS ¶

func VFMSUBADD132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD132PS instruction to the active function. Operates on the global context.

func VFMSUBADD213PD ¶

func VFMSUBADD213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD213PD instruction to the active function. Operates on the global context.

func VFMSUBADD213PS ¶

func VFMSUBADD213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD213PS instruction to the active function. Operates on the global context.

func VFMSUBADD231PD ¶

func VFMSUBADD231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD231PD instruction to the active function. Operates on the global context.

func VFMSUBADD231PS ¶

func VFMSUBADD231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD231PS instruction to the active function. Operates on the global context.

func VFNMADD132PD ¶

func VFNMADD132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD132PD instruction to the active function. Operates on the global context.

func VFNMADD132PS ¶

func VFNMADD132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD132PS instruction to the active function. Operates on the global context.

func VFNMADD132SD ¶

func VFNMADD132SD(mx, x, x1 operand.Op)

VFNMADD132SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD132SD xmm xmm xmm
VFNMADD132SD m64 xmm xmm

Construct and append a VFNMADD132SD instruction to the active function. Operates on the global context.

func VFNMADD132SS ¶

func VFNMADD132SS(mx, x, x1 operand.Op)

VFNMADD132SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD132SS xmm xmm xmm
VFNMADD132SS m32 xmm xmm

Construct and append a VFNMADD132SS instruction to the active function. Operates on the global context.

func VFNMADD213PD ¶

func VFNMADD213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD213PD instruction to the active function. Operates on the global context.

func VFNMADD213PS ¶

func VFNMADD213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD213PS instruction to the active function. Operates on the global context.

func VFNMADD213SD ¶

func VFNMADD213SD(mx, x, x1 operand.Op)

VFNMADD213SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD213SD xmm xmm xmm
VFNMADD213SD m64 xmm xmm

Construct and append a VFNMADD213SD instruction to the active function. Operates on the global context.

func VFNMADD213SS ¶

func VFNMADD213SS(mx, x, x1 operand.Op)

VFNMADD213SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD213SS xmm xmm xmm
VFNMADD213SS m32 xmm xmm

Construct and append a VFNMADD213SS instruction to the active function. Operates on the global context.

func VFNMADD231PD ¶

func VFNMADD231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD231PD instruction to the active function. Operates on the global context.

func VFNMADD231PS ¶

func VFNMADD231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD231PS instruction to the active function. Operates on the global context.

func VFNMADD231SD ¶

func VFNMADD231SD(mx, x, x1 operand.Op)

VFNMADD231SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD231SD xmm xmm xmm
VFNMADD231SD m64 xmm xmm

Construct and append a VFNMADD231SD instruction to the active function. Operates on the global context.

func VFNMADD231SS ¶

func VFNMADD231SS(mx, x, x1 operand.Op)

VFNMADD231SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD231SS xmm xmm xmm
VFNMADD231SS m32 xmm xmm

Construct and append a VFNMADD231SS instruction to the active function. Operates on the global context.

func VFNMSUB132PD ¶

func VFNMSUB132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB132PD instruction to the active function. Operates on the global context.

func VFNMSUB132PS ¶

func VFNMSUB132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB132PS instruction to the active function. Operates on the global context.

func VFNMSUB132SD ¶

func VFNMSUB132SD(mx, x, x1 operand.Op)

VFNMSUB132SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB132SD xmm xmm xmm
VFNMSUB132SD m64 xmm xmm

Construct and append a VFNMSUB132SD instruction to the active function. Operates on the global context.

func VFNMSUB132SS ¶

func VFNMSUB132SS(mx, x, x1 operand.Op)

VFNMSUB132SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB132SS xmm xmm xmm
VFNMSUB132SS m32 xmm xmm

Construct and append a VFNMSUB132SS instruction to the active function. Operates on the global context.

func VFNMSUB213PD ¶

func VFNMSUB213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB213PD instruction to the active function. Operates on the global context.

func VFNMSUB213PS ¶

func VFNMSUB213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB213PS instruction to the active function. Operates on the global context.

func VFNMSUB213SD ¶

func VFNMSUB213SD(mx, x, x1 operand.Op)

VFNMSUB213SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB213SD xmm xmm xmm
VFNMSUB213SD m64 xmm xmm

Construct and append a VFNMSUB213SD instruction to the active function. Operates on the global context.

func VFNMSUB213SS ¶

func VFNMSUB213SS(mx, x, x1 operand.Op)

VFNMSUB213SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB213SS xmm xmm xmm
VFNMSUB213SS m32 xmm xmm

Construct and append a VFNMSUB213SS instruction to the active function. Operates on the global context.

func VFNMSUB231PD ¶

func VFNMSUB231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB231PD instruction to the active function. Operates on the global context.

func VFNMSUB231PS ¶

func VFNMSUB231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB231PS instruction to the active function. Operates on the global context.

func VFNMSUB231SD ¶

func VFNMSUB231SD(mx, x, x1 operand.Op)

VFNMSUB231SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB231SD xmm xmm xmm
VFNMSUB231SD m64 xmm xmm

Construct and append a VFNMSUB231SD instruction to the active function. Operates on the global context.

func VFNMSUB231SS ¶

func VFNMSUB231SS(mx, x, x1 operand.Op)

VFNMSUB231SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB231SS xmm xmm xmm
VFNMSUB231SS m32 xmm xmm

Construct and append a VFNMSUB231SS instruction to the active function. Operates on the global context.

func VGATHERDPD ¶

func VGATHERDPD(xy, v, xy1 operand.Op)

VGATHERDPD: Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices.

Forms:

VGATHERDPD xmm vm32x xmm
VGATHERDPD ymm vm32x ymm

Construct and append a VGATHERDPD instruction to the active function. Operates on the global context.

func VGATHERDPS ¶

func VGATHERDPS(xy, v, xy1 operand.Op)

VGATHERDPS: Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices.

Forms:

VGATHERDPS xmm vm32x xmm
VGATHERDPS ymm vm32y ymm

Construct and append a VGATHERDPS instruction to the active function. Operates on the global context.

func VGATHERQPD ¶

func VGATHERQPD(xy, v, xy1 operand.Op)

VGATHERQPD: Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices.

Forms:

VGATHERQPD xmm vm64x xmm
VGATHERQPD ymm vm64y ymm

Construct and append a VGATHERQPD instruction to the active function. Operates on the global context.

func VGATHERQPS ¶

func VGATHERQPS(x, v, x1 operand.Op)

VGATHERQPS: Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices.

Forms:

VGATHERQPS xmm vm64x xmm
VGATHERQPS xmm vm64y xmm

Construct and append a VGATHERQPS instruction to the active function. Operates on the global context.

func VHADDPD ¶

func VHADDPD(mxy, xy, xy1 operand.Op)

VHADDPD: Packed Double-FP Horizontal Add.

Forms:

VHADDPD xmm  xmm xmm
VHADDPD m128 xmm xmm
VHADDPD ymm  ymm ymm
VHADDPD m256 ymm ymm

Construct and append a VHADDPD instruction to the active function. Operates on the global context.

func VHADDPS ¶

func VHADDPS(mxy, xy, xy1 operand.Op)

VHADDPS: Packed Single-FP Horizontal Add.

Forms:

VHADDPS xmm  xmm xmm
VHADDPS m128 xmm xmm
VHADDPS ymm  ymm ymm
VHADDPS m256 ymm ymm

Construct and append a VHADDPS instruction to the active function. Operates on the global context.

func VHSUBPD ¶

func VHSUBPD(mxy, xy, xy1 operand.Op)

VHSUBPD: Packed Double-FP Horizontal Subtract.

Forms:

VHSUBPD xmm  xmm xmm
VHSUBPD m128 xmm xmm
VHSUBPD ymm  ymm ymm
VHSUBPD m256 ymm ymm

Construct and append a VHSUBPD instruction to the active function. Operates on the global context.

func VHSUBPS ¶

func VHSUBPS(mxy, xy, xy1 operand.Op)

VHSUBPS: Packed Single-FP Horizontal Subtract.

Forms:

VHSUBPS xmm  xmm xmm
VHSUBPS m128 xmm xmm
VHSUBPS ymm  ymm ymm
VHSUBPS m256 ymm ymm

Construct and append a VHSUBPS instruction to the active function. Operates on the global context.

func VINSERTF128 ¶

func VINSERTF128(i, mx, y, y1 operand.Op)

VINSERTF128: Insert Packed Floating-Point Values.

Forms:

VINSERTF128 imm8 xmm  ymm ymm
VINSERTF128 imm8 m128 ymm ymm

Construct and append a VINSERTF128 instruction to the active function. Operates on the global context.

func VINSERTI128 ¶

func VINSERTI128(i, mx, y, y1 operand.Op)

VINSERTI128: Insert Packed Integer Values.

Forms:

VINSERTI128 imm8 xmm  ymm ymm
VINSERTI128 imm8 m128 ymm ymm

Construct and append a VINSERTI128 instruction to the active function. Operates on the global context.

func VINSERTPS ¶

func VINSERTPS(i, mx, x, x1 operand.Op)

VINSERTPS: Insert Packed Single Precision Floating-Point Value.

Forms:

VINSERTPS imm8 xmm xmm xmm
VINSERTPS imm8 m32 xmm xmm

Construct and append a VINSERTPS instruction to the active function. Operates on the global context.

func VLDDQU ¶

func VLDDQU(m, xy operand.Op)

VLDDQU: Load Unaligned Integer 128 Bits.

Forms:

VLDDQU m128 xmm
VLDDQU m256 ymm

Construct and append a VLDDQU instruction to the active function. Operates on the global context.

func VLDMXCSR ¶

func VLDMXCSR(m operand.Op)

VLDMXCSR: Load MXCSR Register.

Forms:

VLDMXCSR m32

Construct and append a VLDMXCSR instruction to the active function. Operates on the global context.

func VMASKMOVDQU ¶

func VMASKMOVDQU(x, x1 operand.Op)

VMASKMOVDQU: Store Selected Bytes of Double Quadword.

Forms:

VMASKMOVDQU xmm xmm

Construct and append a VMASKMOVDQU instruction to the active function. Operates on the global context.

func VMASKMOVPD ¶

func VMASKMOVPD(mxy, xy, mxy1 operand.Op)

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

Construct and append a VMASKMOVPD instruction to the active function. Operates on the global context.

func VMASKMOVPS ¶

func VMASKMOVPS(mxy, xy, mxy1 operand.Op)

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

Construct and append a VMASKMOVPS instruction to the active function. Operates on the global context.

func VMAXPD ¶

func VMAXPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VMAXPD instruction to the active function. Operates on the global context.

func VMAXPS ¶

func VMAXPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VMAXPS instruction to the active function. Operates on the global context.

func VMAXSD ¶

func VMAXSD(mx, x, x1 operand.Op)

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

Forms:

VMAXSD xmm xmm xmm
VMAXSD m64 xmm xmm

Construct and append a VMAXSD instruction to the active function. Operates on the global context.

func VMAXSS ¶

func VMAXSS(mx, x, x1 operand.Op)

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

Forms:

VMAXSS xmm xmm xmm
VMAXSS m32 xmm xmm

Construct and append a VMAXSS instruction to the active function. Operates on the global context.

func VMINPD ¶

func VMINPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VMINPD instruction to the active function. Operates on the global context.

func VMINPS ¶

func VMINPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VMINPS instruction to the active function. Operates on the global context.

func VMINSD ¶

func VMINSD(mx, x, x1 operand.Op)

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

Forms:

VMINSD xmm xmm xmm
VMINSD m64 xmm xmm

Construct and append a VMINSD instruction to the active function. Operates on the global context.

func VMINSS ¶

func VMINSS(mx, x, x1 operand.Op)

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

Forms:

VMINSS xmm xmm xmm
VMINSS m32 xmm xmm

Construct and append a VMINSS instruction to the active function. Operates on the global context.

func VMOVAPD ¶

func VMOVAPD(mxy, mxy1 operand.Op)

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

Construct and append a VMOVAPD instruction to the active function. Operates on the global context.

func VMOVAPS ¶

func VMOVAPS(mxy, mxy1 operand.Op)

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

Construct and append a VMOVAPS instruction to the active function. Operates on the global context.

func VMOVD ¶

func VMOVD(mrx, mrx1 operand.Op)

VMOVD: Move Doubleword.

Forms:

VMOVD xmm r32
VMOVD r32 xmm
VMOVD m32 xmm
VMOVD xmm m32

Construct and append a VMOVD instruction to the active function. Operates on the global context.

func VMOVDDUP ¶

func VMOVDDUP(mxy, xy operand.Op)

VMOVDDUP: Move One Double-FP and Duplicate.

Forms:

VMOVDDUP xmm  xmm
VMOVDDUP m64  xmm
VMOVDDUP ymm  ymm
VMOVDDUP m256 ymm

Construct and append a VMOVDDUP instruction to the active function. Operates on the global context.

func VMOVDQA ¶

func VMOVDQA(mxy, mxy1 operand.Op)

VMOVDQA: Move Aligned Double Quadword.

Forms:

VMOVDQA xmm  xmm
VMOVDQA m128 xmm
VMOVDQA ymm  ymm
VMOVDQA m256 ymm
VMOVDQA xmm  m128
VMOVDQA ymm  m256

Construct and append a VMOVDQA instruction to the active function. Operates on the global context.

func VMOVDQU ¶

func VMOVDQU(mxy, mxy1 operand.Op)

VMOVDQU: Move Unaligned Double Quadword.

Forms:

VMOVDQU xmm  xmm
VMOVDQU m128 xmm
VMOVDQU ymm  ymm
VMOVDQU m256 ymm
VMOVDQU xmm  m128
VMOVDQU ymm  m256

Construct and append a VMOVDQU instruction to the active function. Operates on the global context.

func VMOVHLPS ¶

func VMOVHLPS(x, x1, x2 operand.Op)

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

Forms:

VMOVHLPS xmm xmm xmm

Construct and append a VMOVHLPS instruction to the active function. Operates on the global context.

func VMOVHPD ¶

func VMOVHPD(ops ...operand.Op)

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

Forms:

VMOVHPD xmm m64
VMOVHPD m64 xmm xmm

Construct and append a VMOVHPD instruction to the active function. Operates on the global context.

func VMOVHPS ¶

func VMOVHPS(ops ...operand.Op)

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

Forms:

VMOVHPS xmm m64
VMOVHPS m64 xmm xmm

Construct and append a VMOVHPS instruction to the active function. Operates on the global context.

func VMOVLHPS ¶

func VMOVLHPS(x, x1, x2 operand.Op)

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

Forms:

VMOVLHPS xmm xmm xmm

Construct and append a VMOVLHPS instruction to the active function. Operates on the global context.

func VMOVLPD ¶

func VMOVLPD(ops ...operand.Op)

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

Forms:

VMOVLPD xmm m64
VMOVLPD m64 xmm xmm

Construct and append a VMOVLPD instruction to the active function. Operates on the global context.

func VMOVLPS ¶

func VMOVLPS(ops ...operand.Op)

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

Forms:

VMOVLPS xmm m64
VMOVLPS m64 xmm xmm

Construct and append a VMOVLPS instruction to the active function. Operates on the global context.

func VMOVMSKPD ¶

func VMOVMSKPD(xy, r operand.Op)

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

Forms:

VMOVMSKPD xmm r32
VMOVMSKPD ymm r32

Construct and append a VMOVMSKPD instruction to the active function. Operates on the global context.

func VMOVMSKPS ¶

func VMOVMSKPS(xy, r operand.Op)

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

Forms:

VMOVMSKPS xmm r32
VMOVMSKPS ymm r32

Construct and append a VMOVMSKPS instruction to the active function. Operates on the global context.

func VMOVNTDQ ¶

func VMOVNTDQ(xy, m operand.Op)

VMOVNTDQ: Store Double Quadword Using Non-Temporal Hint.

Forms:

VMOVNTDQ xmm m128
VMOVNTDQ ymm m256

Construct and append a VMOVNTDQ instruction to the active function. Operates on the global context.

func VMOVNTDQA ¶

func VMOVNTDQA(m, xy operand.Op)

VMOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint.

Forms:

VMOVNTDQA m128 xmm
VMOVNTDQA m256 ymm

Construct and append a VMOVNTDQA instruction to the active function. Operates on the global context.

func VMOVNTPD ¶

func VMOVNTPD(xy, m operand.Op)

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

Forms:

VMOVNTPD xmm m128
VMOVNTPD ymm m256

Construct and append a VMOVNTPD instruction to the active function. Operates on the global context.

func VMOVNTPS ¶

func VMOVNTPS(xy, m operand.Op)

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

Forms:

VMOVNTPS xmm m128
VMOVNTPS ymm m256

Construct and append a VMOVNTPS instruction to the active function. Operates on the global context.

func VMOVQ ¶

func VMOVQ(mrx, mrx1 operand.Op)

VMOVQ: Move Quadword.

Forms:

VMOVQ xmm r64
VMOVQ r64 xmm
VMOVQ xmm xmm
VMOVQ m64 xmm
VMOVQ xmm m64

Construct and append a VMOVQ instruction to the active function. Operates on the global context.

func VMOVSD ¶

func VMOVSD(ops ...operand.Op)

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

Forms:

VMOVSD m64 xmm
VMOVSD xmm m64
VMOVSD xmm xmm xmm

Construct and append a VMOVSD instruction to the active function. Operates on the global context.

func VMOVSHDUP ¶

func VMOVSHDUP(mxy, xy operand.Op)

VMOVSHDUP: Move Packed Single-FP High and Duplicate.

Forms:

VMOVSHDUP xmm  xmm
VMOVSHDUP m128 xmm
VMOVSHDUP ymm  ymm
VMOVSHDUP m256 ymm

Construct and append a VMOVSHDUP instruction to the active function. Operates on the global context.

func VMOVSLDUP ¶

func VMOVSLDUP(mxy, xy operand.Op)

VMOVSLDUP: Move Packed Single-FP Low and Duplicate.

Forms:

VMOVSLDUP xmm  xmm
VMOVSLDUP m128 xmm
VMOVSLDUP ymm  ymm
VMOVSLDUP m256 ymm

Construct and append a VMOVSLDUP instruction to the active function. Operates on the global context.

func VMOVSS ¶

func VMOVSS(ops ...operand.Op)

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

Forms:

VMOVSS m32 xmm
VMOVSS xmm m32
VMOVSS xmm xmm xmm

Construct and append a VMOVSS instruction to the active function. Operates on the global context.

func VMOVUPD ¶

func VMOVUPD(mxy, mxy1 operand.Op)

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

Construct and append a VMOVUPD instruction to the active function. Operates on the global context.

func VMOVUPS ¶

func VMOVUPS(mxy, mxy1 operand.Op)

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

Construct and append a VMOVUPS instruction to the active function. Operates on the global context.

func VMPSADBW ¶

func VMPSADBW(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VMPSADBW instruction to the active function. Operates on the global context.

func VMULPD ¶

func VMULPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VMULPD instruction to the active function. Operates on the global context.

func VMULPS ¶

func VMULPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VMULPS instruction to the active function. Operates on the global context.

func VMULSD ¶

func VMULSD(mx, x, x1 operand.Op)

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

Forms:

VMULSD xmm xmm xmm
VMULSD m64 xmm xmm

Construct and append a VMULSD instruction to the active function. Operates on the global context.

func VMULSS ¶

func VMULSS(mx, x, x1 operand.Op)

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

Forms:

VMULSS xmm xmm xmm
VMULSS m32 xmm xmm

Construct and append a VMULSS instruction to the active function. Operates on the global context.

func VORPD ¶

func VORPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VORPD instruction to the active function. Operates on the global context.

func VORPS ¶

func VORPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VORPS instruction to the active function. Operates on the global context.

func VPABSB ¶

func VPABSB(mxy, xy operand.Op)

VPABSB: Packed Absolute Value of Byte Integers.

Forms:

VPABSB xmm  xmm
VPABSB m128 xmm
VPABSB ymm  ymm
VPABSB m256 ymm

Construct and append a VPABSB instruction to the active function. Operates on the global context.

func VPABSD ¶

func VPABSD(mxy, xy operand.Op)

VPABSD: Packed Absolute Value of Doubleword Integers.

Forms:

VPABSD xmm  xmm
VPABSD m128 xmm
VPABSD ymm  ymm
VPABSD m256 ymm

Construct and append a VPABSD instruction to the active function. Operates on the global context.

func VPABSW ¶

func VPABSW(mxy, xy operand.Op)

VPABSW: Packed Absolute Value of Word Integers.

Forms:

VPABSW xmm  xmm
VPABSW m128 xmm
VPABSW ymm  ymm
VPABSW m256 ymm

Construct and append a VPABSW instruction to the active function. Operates on the global context.

func VPACKSSDW ¶

func VPACKSSDW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKSSDW instruction to the active function. Operates on the global context.

func VPACKSSWB ¶

func VPACKSSWB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKSSWB instruction to the active function. Operates on the global context.

func VPACKUSDW ¶

func VPACKUSDW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKUSDW instruction to the active function. Operates on the global context.

func VPACKUSWB ¶

func VPACKUSWB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKUSWB instruction to the active function. Operates on the global context.

func VPADDB ¶

func VPADDB(mxy, xy, xy1 operand.Op)

VPADDB: Add Packed Byte Integers.

Forms:

VPADDB xmm  xmm xmm
VPADDB m128 xmm xmm
VPADDB ymm  ymm ymm
VPADDB m256 ymm ymm

Construct and append a VPADDB instruction to the active function. Operates on the global context.

func VPADDD ¶

func VPADDD(mxy, xy, xy1 operand.Op)

VPADDD: Add Packed Doubleword Integers.

Forms:

VPADDD xmm  xmm xmm
VPADDD m128 xmm xmm
VPADDD ymm  ymm ymm
VPADDD m256 ymm ymm

Construct and append a VPADDD instruction to the active function. Operates on the global context.

func VPADDQ ¶

func VPADDQ(mxy, xy, xy1 operand.Op)

VPADDQ: Add Packed Quadword Integers.

Forms:

VPADDQ xmm  xmm xmm
VPADDQ m128 xmm xmm
VPADDQ ymm  ymm ymm
VPADDQ m256 ymm ymm

Construct and append a VPADDQ instruction to the active function. Operates on the global context.

func VPADDSB ¶

func VPADDSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDSB instruction to the active function. Operates on the global context.

func VPADDSW ¶

func VPADDSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDSW instruction to the active function. Operates on the global context.

func VPADDUSB ¶

func VPADDUSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDUSB instruction to the active function. Operates on the global context.

func VPADDUSW ¶

func VPADDUSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDUSW instruction to the active function. Operates on the global context.

func VPADDW ¶

func VPADDW(mxy, xy, xy1 operand.Op)

VPADDW: Add Packed Word Integers.

Forms:

VPADDW xmm  xmm xmm
VPADDW m128 xmm xmm
VPADDW ymm  ymm ymm
VPADDW m256 ymm ymm

Construct and append a VPADDW instruction to the active function. Operates on the global context.

func VPALIGNR ¶

func VPALIGNR(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VPALIGNR instruction to the active function. Operates on the global context.

func VPAND ¶

func VPAND(mxy, xy, xy1 operand.Op)

VPAND: Packed Bitwise Logical AND.

Forms:

VPAND xmm  xmm xmm
VPAND m128 xmm xmm
VPAND ymm  ymm ymm
VPAND m256 ymm ymm

Construct and append a VPAND instruction to the active function. Operates on the global context.

func VPANDN ¶

func VPANDN(mxy, xy, xy1 operand.Op)

VPANDN: Packed Bitwise Logical AND NOT.

Forms:

VPANDN xmm  xmm xmm
VPANDN m128 xmm xmm
VPANDN ymm  ymm ymm
VPANDN m256 ymm ymm

Construct and append a VPANDN instruction to the active function. Operates on the global context.

func VPAVGB ¶

func VPAVGB(mxy, xy, xy1 operand.Op)

VPAVGB: Average Packed Byte Integers.

Forms:

VPAVGB xmm  xmm xmm
VPAVGB m128 xmm xmm
VPAVGB ymm  ymm ymm
VPAVGB m256 ymm ymm

Construct and append a VPAVGB instruction to the active function. Operates on the global context.

func VPAVGW ¶

func VPAVGW(mxy, xy, xy1 operand.Op)

VPAVGW: Average Packed Word Integers.

Forms:

VPAVGW xmm  xmm xmm
VPAVGW m128 xmm xmm
VPAVGW ymm  ymm ymm
VPAVGW m256 ymm ymm

Construct and append a VPAVGW instruction to the active function. Operates on the global context.

func VPBLENDD ¶

func VPBLENDD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VPBLENDD instruction to the active function. Operates on the global context.

func VPBLENDVB ¶

func VPBLENDVB(xy, mxy, xy1, xy2 operand.Op)

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

Construct and append a VPBLENDVB instruction to the active function. Operates on the global context.

func VPBLENDW ¶

func VPBLENDW(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VPBLENDW instruction to the active function. Operates on the global context.

func VPBROADCASTB ¶

func VPBROADCASTB(mx, xy operand.Op)

VPBROADCASTB: Broadcast Byte Integer.

Forms:

VPBROADCASTB xmm xmm
VPBROADCASTB m8  xmm
VPBROADCASTB xmm ymm
VPBROADCASTB m8  ymm

Construct and append a VPBROADCASTB instruction to the active function. Operates on the global context.

func VPBROADCASTD ¶

func VPBROADCASTD(mx, xy operand.Op)

VPBROADCASTD: Broadcast Doubleword Integer.

Forms:

VPBROADCASTD xmm xmm
VPBROADCASTD m32 xmm
VPBROADCASTD xmm ymm
VPBROADCASTD m32 ymm

Construct and append a VPBROADCASTD instruction to the active function. Operates on the global context.

func VPBROADCASTQ ¶

func VPBROADCASTQ(mx, xy operand.Op)

VPBROADCASTQ: Broadcast Quadword Integer.

Forms:

VPBROADCASTQ xmm xmm
VPBROADCASTQ m64 xmm
VPBROADCASTQ xmm ymm
VPBROADCASTQ m64 ymm

Construct and append a VPBROADCASTQ instruction to the active function. Operates on the global context.

func VPBROADCASTW ¶

func VPBROADCASTW(mx, xy operand.Op)

VPBROADCASTW: Broadcast Word Integer.

Forms:

VPBROADCASTW xmm xmm
VPBROADCASTW m16 xmm
VPBROADCASTW xmm ymm
VPBROADCASTW m16 ymm

Construct and append a VPBROADCASTW instruction to the active function. Operates on the global context.

func VPCLMULQDQ ¶

func VPCLMULQDQ(i, mx, x, x1 operand.Op)

VPCLMULQDQ: Carry-Less Quadword Multiplication.

Forms:

VPCLMULQDQ imm8 xmm  xmm xmm
VPCLMULQDQ imm8 m128 xmm xmm

Construct and append a VPCLMULQDQ instruction to the active function. Operates on the global context.

func VPCMPEQB ¶

func VPCMPEQB(mxy, xy, xy1 operand.Op)

VPCMPEQB: Compare Packed Byte Data for Equality.

Forms:

VPCMPEQB xmm  xmm xmm
VPCMPEQB m128 xmm xmm
VPCMPEQB ymm  ymm ymm
VPCMPEQB m256 ymm ymm

Construct and append a VPCMPEQB instruction to the active function. Operates on the global context.

func VPCMPEQD ¶

func VPCMPEQD(mxy, xy, xy1 operand.Op)

VPCMPEQD: Compare Packed Doubleword Data for Equality.

Forms:

VPCMPEQD xmm  xmm xmm
VPCMPEQD m128 xmm xmm
VPCMPEQD ymm  ymm ymm
VPCMPEQD m256 ymm ymm

Construct and append a VPCMPEQD instruction to the active function. Operates on the global context.

func VPCMPEQQ ¶

func VPCMPEQQ(mxy, xy, xy1 operand.Op)

VPCMPEQQ: Compare Packed Quadword Data for Equality.

Forms:

VPCMPEQQ xmm  xmm xmm
VPCMPEQQ m128 xmm xmm
VPCMPEQQ ymm  ymm ymm
VPCMPEQQ m256 ymm ymm

Construct and append a VPCMPEQQ instruction to the active function. Operates on the global context.

func VPCMPEQW ¶

func VPCMPEQW(mxy, xy, xy1 operand.Op)

VPCMPEQW: Compare Packed Word Data for Equality.

Forms:

VPCMPEQW xmm  xmm xmm
VPCMPEQW m128 xmm xmm
VPCMPEQW ymm  ymm ymm
VPCMPEQW m256 ymm ymm

Construct and append a VPCMPEQW instruction to the active function. Operates on the global context.

func VPCMPESTRI ¶

func VPCMPESTRI(i, mx, x operand.Op)

VPCMPESTRI: Packed Compare Explicit Length Strings, Return Index.

Forms:

VPCMPESTRI imm8 xmm  xmm
VPCMPESTRI imm8 m128 xmm

Construct and append a VPCMPESTRI instruction to the active function. Operates on the global context.

func VPCMPESTRM ¶

func VPCMPESTRM(i, mx, x operand.Op)

VPCMPESTRM: Packed Compare Explicit Length Strings, Return Mask.

Forms:

VPCMPESTRM imm8 xmm  xmm
VPCMPESTRM imm8 m128 xmm

Construct and append a VPCMPESTRM instruction to the active function. Operates on the global context.

func VPCMPGTB ¶

func VPCMPGTB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPCMPGTB instruction to the active function. Operates on the global context.

func VPCMPGTD ¶

func VPCMPGTD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPCMPGTD instruction to the active function. Operates on the global context.

func VPCMPGTQ ¶

func VPCMPGTQ(mxy, xy, xy1 operand.Op)

VPCMPGTQ: Compare Packed Data for Greater Than.

Forms:

VPCMPGTQ xmm  xmm xmm
VPCMPGTQ m128 xmm xmm
VPCMPGTQ ymm  ymm ymm
VPCMPGTQ m256 ymm ymm

Construct and append a VPCMPGTQ instruction to the active function. Operates on the global context.

func VPCMPGTW ¶

func VPCMPGTW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPCMPGTW instruction to the active function. Operates on the global context.

func VPCMPISTRI ¶

func VPCMPISTRI(i, mx, x operand.Op)

VPCMPISTRI: Packed Compare Implicit Length Strings, Return Index.

Forms:

VPCMPISTRI imm8 xmm  xmm
VPCMPISTRI imm8 m128 xmm

Construct and append a VPCMPISTRI instruction to the active function. Operates on the global context.

func VPCMPISTRM ¶

func VPCMPISTRM(i, mx, x operand.Op)

VPCMPISTRM: Packed Compare Implicit Length Strings, Return Mask.

Forms:

VPCMPISTRM imm8 xmm  xmm
VPCMPISTRM imm8 m128 xmm

Construct and append a VPCMPISTRM instruction to the active function. Operates on the global context.

func VPERM2F128 ¶

func VPERM2F128(i, my, y, y1 operand.Op)

VPERM2F128: Permute Floating-Point Values.

Forms:

VPERM2F128 imm8 ymm  ymm ymm
VPERM2F128 imm8 m256 ymm ymm

Construct and append a VPERM2F128 instruction to the active function. Operates on the global context.

func VPERM2I128 ¶

func VPERM2I128(i, my, y, y1 operand.Op)

VPERM2I128: Permute 128-Bit Integer Values.

Forms:

VPERM2I128 imm8 ymm  ymm ymm
VPERM2I128 imm8 m256 ymm ymm

Construct and append a VPERM2I128 instruction to the active function. Operates on the global context.

func VPERMD ¶

func VPERMD(my, y, y1 operand.Op)

VPERMD: Permute Doubleword Integers.

Forms:

VPERMD ymm  ymm ymm
VPERMD m256 ymm ymm

Construct and append a VPERMD instruction to the active function. Operates on the global context.

func VPERMILPD ¶

func VPERMILPD(imxy, mxy, xy operand.Op)

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

Construct and append a VPERMILPD instruction to the active function. Operates on the global context.

func VPERMILPS ¶

func VPERMILPS(imxy, mxy, xy operand.Op)

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

Construct and append a VPERMILPS instruction to the active function. Operates on the global context.

func VPERMPD ¶

func VPERMPD(i, my, y operand.Op)

VPERMPD: Permute Double-Precision Floating-Point Elements.

Forms:

VPERMPD imm8 ymm  ymm
VPERMPD imm8 m256 ymm

Construct and append a VPERMPD instruction to the active function. Operates on the global context.

func VPERMPS ¶

func VPERMPS(my, y, y1 operand.Op)

VPERMPS: Permute Single-Precision Floating-Point Elements.

Forms:

VPERMPS ymm  ymm ymm
VPERMPS m256 ymm ymm

Construct and append a VPERMPS instruction to the active function. Operates on the global context.

func VPERMQ ¶

func VPERMQ(i, my, y operand.Op)

VPERMQ: Permute Quadword Integers.

Forms:

VPERMQ imm8 ymm  ymm
VPERMQ imm8 m256 ymm

Construct and append a VPERMQ instruction to the active function. Operates on the global context.

func VPEXTRB ¶

func VPEXTRB(i, x, mr operand.Op)

VPEXTRB: Extract Byte.

Forms:

VPEXTRB imm8 xmm r32
VPEXTRB imm8 xmm m8

Construct and append a VPEXTRB instruction to the active function. Operates on the global context.

func VPEXTRD ¶

func VPEXTRD(i, x, mr operand.Op)

VPEXTRD: Extract Doubleword.

Forms:

VPEXTRD imm8 xmm r32
VPEXTRD imm8 xmm m32

Construct and append a VPEXTRD instruction to the active function. Operates on the global context.

func VPEXTRQ ¶

func VPEXTRQ(i, x, mr operand.Op)

VPEXTRQ: Extract Quadword.

Forms:

VPEXTRQ imm8 xmm r64
VPEXTRQ imm8 xmm m64

Construct and append a VPEXTRQ instruction to the active function. Operates on the global context.

func VPEXTRW ¶

func VPEXTRW(i, x, mr operand.Op)

VPEXTRW: Extract Word.

Forms:

VPEXTRW imm8 xmm r32
VPEXTRW imm8 xmm m16

Construct and append a VPEXTRW instruction to the active function. Operates on the global context.

func VPGATHERDD ¶

func VPGATHERDD(xy, v, xy1 operand.Op)

VPGATHERDD: Gather Packed Doubleword Values Using Signed Doubleword Indices.

Forms:

VPGATHERDD xmm vm32x xmm
VPGATHERDD ymm vm32y ymm

Construct and append a VPGATHERDD instruction to the active function. Operates on the global context.

func VPGATHERDQ ¶

func VPGATHERDQ(xy, v, xy1 operand.Op)

VPGATHERDQ: Gather Packed Quadword Values Using Signed Doubleword Indices.

Forms:

VPGATHERDQ xmm vm32x xmm
VPGATHERDQ ymm vm32x ymm

Construct and append a VPGATHERDQ instruction to the active function. Operates on the global context.

func VPGATHERQD ¶

func VPGATHERQD(x, v, x1 operand.Op)

VPGATHERQD: Gather Packed Doubleword Values Using Signed Quadword Indices.

Forms:

VPGATHERQD xmm vm64x xmm
VPGATHERQD xmm vm64y xmm

Construct and append a VPGATHERQD instruction to the active function. Operates on the global context.

func VPGATHERQQ ¶

func VPGATHERQQ(xy, v, xy1 operand.Op)

VPGATHERQQ: Gather Packed Quadword Values Using Signed Quadword Indices.

Forms:

VPGATHERQQ xmm vm64x xmm
VPGATHERQQ ymm vm64y ymm

Construct and append a VPGATHERQQ instruction to the active function. Operates on the global context.

func VPHADDD ¶

func VPHADDD(mxy, xy, xy1 operand.Op)

VPHADDD: Packed Horizontal Add Doubleword Integer.

Forms:

VPHADDD xmm  xmm xmm
VPHADDD m128 xmm xmm
VPHADDD ymm  ymm ymm
VPHADDD m256 ymm ymm

Construct and append a VPHADDD instruction to the active function. Operates on the global context.

func VPHADDSW ¶

func VPHADDSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPHADDSW instruction to the active function. Operates on the global context.

func VPHADDW ¶

func VPHADDW(mxy, xy, xy1 operand.Op)

VPHADDW: Packed Horizontal Add Word Integers.

Forms:

VPHADDW xmm  xmm xmm
VPHADDW m128 xmm xmm
VPHADDW ymm  ymm ymm
VPHADDW m256 ymm ymm

Construct and append a VPHADDW instruction to the active function. Operates on the global context.

func VPHMINPOSUW ¶

func VPHMINPOSUW(mx, x operand.Op)

VPHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers.

Forms:

VPHMINPOSUW xmm  xmm
VPHMINPOSUW m128 xmm

Construct and append a VPHMINPOSUW instruction to the active function. Operates on the global context.

func VPHSUBD ¶

func VPHSUBD(mxy, xy, xy1 operand.Op)

VPHSUBD: Packed Horizontal Subtract Doubleword Integers.

Forms:

VPHSUBD xmm  xmm xmm
VPHSUBD m128 xmm xmm
VPHSUBD ymm  ymm ymm
VPHSUBD m256 ymm ymm

Construct and append a VPHSUBD instruction to the active function. Operates on the global context.

func VPHSUBSW ¶

func VPHSUBSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPHSUBSW instruction to the active function. Operates on the global context.

func VPHSUBW ¶

func VPHSUBW(mxy, xy, xy1 operand.Op)

VPHSUBW: Packed Horizontal Subtract Word Integers.

Forms:

VPHSUBW xmm  xmm xmm
VPHSUBW m128 xmm xmm
VPHSUBW ymm  ymm ymm
VPHSUBW m256 ymm ymm

Construct and append a VPHSUBW instruction to the active function. Operates on the global context.

func VPINSRB ¶

func VPINSRB(i, mr, x, x1 operand.Op)

VPINSRB: Insert Byte.

Forms:

VPINSRB imm8 r32 xmm xmm
VPINSRB imm8 m8  xmm xmm

Construct and append a VPINSRB instruction to the active function. Operates on the global context.

func VPINSRD ¶

func VPINSRD(i, mr, x, x1 operand.Op)

VPINSRD: Insert Doubleword.

Forms:

VPINSRD imm8 r32 xmm xmm
VPINSRD imm8 m32 xmm xmm

Construct and append a VPINSRD instruction to the active function. Operates on the global context.

func VPINSRQ ¶

func VPINSRQ(i, mr, x, x1 operand.Op)

VPINSRQ: Insert Quadword.

Forms:

VPINSRQ imm8 r64 xmm xmm
VPINSRQ imm8 m64 xmm xmm

Construct and append a VPINSRQ instruction to the active function. Operates on the global context.

func VPINSRW ¶

func VPINSRW(i, mr, x, x1 operand.Op)

VPINSRW: Insert Word.

Forms:

VPINSRW imm8 r32 xmm xmm
VPINSRW imm8 m16 xmm xmm

Construct and append a VPINSRW instruction to the active function. Operates on the global context.

func VPMADDUBSW ¶

func VPMADDUBSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMADDUBSW instruction to the active function. Operates on the global context.

func VPMADDWD ¶

func VPMADDWD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMADDWD instruction to the active function. Operates on the global context.

func VPMASKMOVD ¶

func VPMASKMOVD(mxy, xy, mxy1 operand.Op)

VPMASKMOVD: Conditional Move Packed Doubleword Integers.

Forms:

VPMASKMOVD m128 xmm xmm
VPMASKMOVD m256 ymm ymm
VPMASKMOVD xmm  xmm m128
VPMASKMOVD ymm  ymm m256

Construct and append a VPMASKMOVD instruction to the active function. Operates on the global context.

func VPMASKMOVQ ¶

func VPMASKMOVQ(mxy, xy, mxy1 operand.Op)

VPMASKMOVQ: Conditional Move Packed Quadword Integers.

Forms:

VPMASKMOVQ m128 xmm xmm
VPMASKMOVQ m256 ymm ymm
VPMASKMOVQ xmm  xmm m128
VPMASKMOVQ ymm  ymm m256

Construct and append a VPMASKMOVQ instruction to the active function. Operates on the global context.

func VPMAXSB ¶

func VPMAXSB(mxy, xy, xy1 operand.Op)

VPMAXSB: Maximum of Packed Signed Byte Integers.

Forms:

VPMAXSB xmm  xmm xmm
VPMAXSB m128 xmm xmm
VPMAXSB ymm  ymm ymm
VPMAXSB m256 ymm ymm

Construct and append a VPMAXSB instruction to the active function. Operates on the global context.

func VPMAXSD ¶

func VPMAXSD(mxy, xy, xy1 operand.Op)

VPMAXSD: Maximum of Packed Signed Doubleword Integers.

Forms:

VPMAXSD xmm  xmm xmm
VPMAXSD m128 xmm xmm
VPMAXSD ymm  ymm ymm
VPMAXSD m256 ymm ymm

Construct and append a VPMAXSD instruction to the active function. Operates on the global context.

func VPMAXSW ¶

func VPMAXSW(mxy, xy, xy1 operand.Op)

VPMAXSW: Maximum of Packed Signed Word Integers.

Forms:

VPMAXSW xmm  xmm xmm
VPMAXSW m128 xmm xmm
VPMAXSW ymm  ymm ymm
VPMAXSW m256 ymm ymm

Construct and append a VPMAXSW instruction to the active function. Operates on the global context.

func VPMAXUB ¶

func VPMAXUB(mxy, xy, xy1 operand.Op)

VPMAXUB: Maximum of Packed Unsigned Byte Integers.

Forms:

VPMAXUB xmm  xmm xmm
VPMAXUB m128 xmm xmm
VPMAXUB ymm  ymm ymm
VPMAXUB m256 ymm ymm

Construct and append a VPMAXUB instruction to the active function. Operates on the global context.

func VPMAXUD ¶

func VPMAXUD(mxy, xy, xy1 operand.Op)

VPMAXUD: Maximum of Packed Unsigned Doubleword Integers.

Forms:

VPMAXUD xmm  xmm xmm
VPMAXUD m128 xmm xmm
VPMAXUD ymm  ymm ymm
VPMAXUD m256 ymm ymm

Construct and append a VPMAXUD instruction to the active function. Operates on the global context.

func VPMAXUW ¶

func VPMAXUW(mxy, xy, xy1 operand.Op)

VPMAXUW: Maximum of Packed Unsigned Word Integers.

Forms:

VPMAXUW xmm  xmm xmm
VPMAXUW m128 xmm xmm
VPMAXUW ymm  ymm ymm
VPMAXUW m256 ymm ymm

Construct and append a VPMAXUW instruction to the active function. Operates on the global context.

func VPMINSB ¶

func VPMINSB(mxy, xy, xy1 operand.Op)

VPMINSB: Minimum of Packed Signed Byte Integers.

Forms:

VPMINSB xmm  xmm xmm
VPMINSB m128 xmm xmm
VPMINSB ymm  ymm ymm
VPMINSB m256 ymm ymm

Construct and append a VPMINSB instruction to the active function. Operates on the global context.

func VPMINSD ¶

func VPMINSD(mxy, xy, xy1 operand.Op)

VPMINSD: Minimum of Packed Signed Doubleword Integers.

Forms:

VPMINSD xmm  xmm xmm
VPMINSD m128 xmm xmm
VPMINSD ymm  ymm ymm
VPMINSD m256 ymm ymm

Construct and append a VPMINSD instruction to the active function. Operates on the global context.

func VPMINSW ¶

func VPMINSW(mxy, xy, xy1 operand.Op)

VPMINSW: Minimum of Packed Signed Word Integers.

Forms:

VPMINSW xmm  xmm xmm
VPMINSW m128 xmm xmm
VPMINSW ymm  ymm ymm
VPMINSW m256 ymm ymm

Construct and append a VPMINSW instruction to the active function. Operates on the global context.

func VPMINUB ¶

func VPMINUB(mxy, xy, xy1 operand.Op)

VPMINUB: Minimum of Packed Unsigned Byte Integers.

Forms:

VPMINUB xmm  xmm xmm
VPMINUB m128 xmm xmm
VPMINUB ymm  ymm ymm
VPMINUB m256 ymm ymm

Construct and append a VPMINUB instruction to the active function. Operates on the global context.

func VPMINUD ¶

func VPMINUD(mxy, xy, xy1 operand.Op)

VPMINUD: Minimum of Packed Unsigned Doubleword Integers.

Forms:

VPMINUD xmm  xmm xmm
VPMINUD m128 xmm xmm
VPMINUD ymm  ymm ymm
VPMINUD m256 ymm ymm

Construct and append a VPMINUD instruction to the active function. Operates on the global context.

func VPMINUW ¶

func VPMINUW(mxy, xy, xy1 operand.Op)

VPMINUW: Minimum of Packed Unsigned Word Integers.

Forms:

VPMINUW xmm  xmm xmm
VPMINUW m128 xmm xmm
VPMINUW ymm  ymm ymm
VPMINUW m256 ymm ymm

Construct and append a VPMINUW instruction to the active function. Operates on the global context.

func VPMOVMSKB ¶

func VPMOVMSKB(xy, r operand.Op)

VPMOVMSKB: Move Byte Mask.

Forms:

VPMOVMSKB xmm r32
VPMOVMSKB ymm r32

Construct and append a VPMOVMSKB instruction to the active function. Operates on the global context.

func VPMOVSXBD ¶

func VPMOVSXBD(mx, xy operand.Op)

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

Forms:

VPMOVSXBD xmm xmm
VPMOVSXBD m32 xmm
VPMOVSXBD xmm ymm
VPMOVSXBD m64 ymm

Construct and append a VPMOVSXBD instruction to the active function. Operates on the global context.

func VPMOVSXBQ ¶

func VPMOVSXBQ(mx, xy operand.Op)

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

Forms:

VPMOVSXBQ xmm xmm
VPMOVSXBQ m16 xmm
VPMOVSXBQ xmm ymm
VPMOVSXBQ m32 ymm

Construct and append a VPMOVSXBQ instruction to the active function. Operates on the global context.

func VPMOVSXBW ¶

func VPMOVSXBW(mx, xy operand.Op)

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

Forms:

VPMOVSXBW xmm  xmm
VPMOVSXBW m64  xmm
VPMOVSXBW xmm  ymm
VPMOVSXBW m128 ymm

Construct and append a VPMOVSXBW instruction to the active function. Operates on the global context.

func VPMOVSXDQ ¶

func VPMOVSXDQ(mx, xy operand.Op)

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

Forms:

VPMOVSXDQ xmm  xmm
VPMOVSXDQ m64  xmm
VPMOVSXDQ xmm  ymm
VPMOVSXDQ m128 ymm

Construct and append a VPMOVSXDQ instruction to the active function. Operates on the global context.

func VPMOVSXWD ¶

func VPMOVSXWD(mx, xy operand.Op)

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

Forms:

VPMOVSXWD xmm  xmm
VPMOVSXWD m64  xmm
VPMOVSXWD xmm  ymm
VPMOVSXWD m128 ymm

Construct and append a VPMOVSXWD instruction to the active function. Operates on the global context.

func VPMOVSXWQ ¶

func VPMOVSXWQ(mx, xy operand.Op)

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

Forms:

VPMOVSXWQ xmm xmm
VPMOVSXWQ m32 xmm
VPMOVSXWQ xmm ymm
VPMOVSXWQ m64 ymm

Construct and append a VPMOVSXWQ instruction to the active function. Operates on the global context.

func VPMOVZXBD ¶

func VPMOVZXBD(mx, xy operand.Op)

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

Forms:

VPMOVZXBD xmm xmm
VPMOVZXBD m32 xmm
VPMOVZXBD xmm ymm
VPMOVZXBD m64 ymm

Construct and append a VPMOVZXBD instruction to the active function. Operates on the global context.

func VPMOVZXBQ ¶

func VPMOVZXBQ(mx, xy operand.Op)

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

Forms:

VPMOVZXBQ xmm xmm
VPMOVZXBQ m16 xmm
VPMOVZXBQ xmm ymm
VPMOVZXBQ m32 ymm

Construct and append a VPMOVZXBQ instruction to the active function. Operates on the global context.

func VPMOVZXBW ¶

func VPMOVZXBW(mx, xy operand.Op)

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

Forms:

VPMOVZXBW xmm  xmm
VPMOVZXBW m64  xmm
VPMOVZXBW xmm  ymm
VPMOVZXBW m128 ymm

Construct and append a VPMOVZXBW instruction to the active function. Operates on the global context.

func VPMOVZXDQ ¶

func VPMOVZXDQ(mx, xy operand.Op)

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

Forms:

VPMOVZXDQ xmm  xmm
VPMOVZXDQ m64  xmm
VPMOVZXDQ xmm  ymm
VPMOVZXDQ m128 ymm

Construct and append a VPMOVZXDQ instruction to the active function. Operates on the global context.

func VPMOVZXWD ¶

func VPMOVZXWD(mx, xy operand.Op)

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

Forms:

VPMOVZXWD xmm  xmm
VPMOVZXWD m64  xmm
VPMOVZXWD xmm  ymm
VPMOVZXWD m128 ymm

Construct and append a VPMOVZXWD instruction to the active function. Operates on the global context.

func VPMOVZXWQ ¶

func VPMOVZXWQ(mx, xy operand.Op)

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

Forms:

VPMOVZXWQ xmm xmm
VPMOVZXWQ m32 xmm
VPMOVZXWQ xmm ymm
VPMOVZXWQ m64 ymm

Construct and append a VPMOVZXWQ instruction to the active function. Operates on the global context.

func VPMULDQ ¶

func VPMULDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULDQ instruction to the active function. Operates on the global context.

func VPMULHRSW ¶

func VPMULHRSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULHRSW instruction to the active function. Operates on the global context.

func VPMULHUW ¶

func VPMULHUW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULHUW instruction to the active function. Operates on the global context.

func VPMULHW ¶

func VPMULHW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULHW instruction to the active function. Operates on the global context.

func VPMULLD ¶

func VPMULLD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULLD instruction to the active function. Operates on the global context.

func VPMULLW ¶

func VPMULLW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULLW instruction to the active function. Operates on the global context.

func VPMULUDQ ¶

func VPMULUDQ(mxy, xy, xy1 operand.Op)

VPMULUDQ: Multiply Packed Unsigned Doubleword Integers.

Forms:

VPMULUDQ xmm  xmm xmm
VPMULUDQ m128 xmm xmm
VPMULUDQ ymm  ymm ymm
VPMULUDQ m256 ymm ymm

Construct and append a VPMULUDQ instruction to the active function. Operates on the global context.

func VPOR ¶

func VPOR(mxy, xy, xy1 operand.Op)

VPOR: Packed Bitwise Logical OR.

Forms:

VPOR xmm  xmm xmm
VPOR m128 xmm xmm
VPOR ymm  ymm ymm
VPOR m256 ymm ymm

Construct and append a VPOR instruction to the active function. Operates on the global context.

func VPSADBW ¶

func VPSADBW(mxy, xy, xy1 operand.Op)

VPSADBW: Compute Sum of Absolute Differences.

Forms:

VPSADBW xmm  xmm xmm
VPSADBW m128 xmm xmm
VPSADBW ymm  ymm ymm
VPSADBW m256 ymm ymm

Construct and append a VPSADBW instruction to the active function. Operates on the global context.

func VPSHUFB ¶

func VPSHUFB(mxy, xy, xy1 operand.Op)

VPSHUFB: Packed Shuffle Bytes.

Forms:

VPSHUFB xmm  xmm xmm
VPSHUFB m128 xmm xmm
VPSHUFB ymm  ymm ymm
VPSHUFB m256 ymm ymm

Construct and append a VPSHUFB instruction to the active function. Operates on the global context.

func VPSHUFD ¶

func VPSHUFD(i, mxy, xy operand.Op)

VPSHUFD: Shuffle Packed Doublewords.

Forms:

VPSHUFD imm8 xmm  xmm
VPSHUFD imm8 m128 xmm
VPSHUFD imm8 ymm  ymm
VPSHUFD imm8 m256 ymm

Construct and append a VPSHUFD instruction to the active function. Operates on the global context.

func VPSHUFHW ¶

func VPSHUFHW(i, mxy, xy operand.Op)

VPSHUFHW: Shuffle Packed High Words.

Forms:

VPSHUFHW imm8 xmm  xmm
VPSHUFHW imm8 m128 xmm
VPSHUFHW imm8 ymm  ymm
VPSHUFHW imm8 m256 ymm

Construct and append a VPSHUFHW instruction to the active function. Operates on the global context.

func VPSHUFLW ¶

func VPSHUFLW(i, mxy, xy operand.Op)

VPSHUFLW: Shuffle Packed Low Words.

Forms:

VPSHUFLW imm8 xmm  xmm
VPSHUFLW imm8 m128 xmm
VPSHUFLW imm8 ymm  ymm
VPSHUFLW imm8 m256 ymm

Construct and append a VPSHUFLW instruction to the active function. Operates on the global context.

func VPSIGNB ¶

func VPSIGNB(mxy, xy, xy1 operand.Op)

VPSIGNB: Packed Sign of Byte Integers.

Forms:

VPSIGNB xmm  xmm xmm
VPSIGNB m128 xmm xmm
VPSIGNB ymm  ymm ymm
VPSIGNB m256 ymm ymm

Construct and append a VPSIGNB instruction to the active function. Operates on the global context.

func VPSIGND ¶

func VPSIGND(mxy, xy, xy1 operand.Op)

VPSIGND: Packed Sign of Doubleword Integers.

Forms:

VPSIGND xmm  xmm xmm
VPSIGND m128 xmm xmm
VPSIGND ymm  ymm ymm
VPSIGND m256 ymm ymm

Construct and append a VPSIGND instruction to the active function. Operates on the global context.

func VPSIGNW ¶

func VPSIGNW(mxy, xy, xy1 operand.Op)

VPSIGNW: Packed Sign of Word Integers.

Forms:

VPSIGNW xmm  xmm xmm
VPSIGNW m128 xmm xmm
VPSIGNW ymm  ymm ymm
VPSIGNW m256 ymm ymm

Construct and append a VPSIGNW instruction to the active function. Operates on the global context.

func VPSLLD ¶

func VPSLLD(imx, xy, xy1 operand.Op)

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

Construct and append a VPSLLD instruction to the active function. Operates on the global context.

func VPSLLDQ ¶

func VPSLLDQ(i, xy, xy1 operand.Op)

VPSLLDQ: Shift Packed Double Quadword Left Logical.

Forms:

VPSLLDQ imm8 xmm xmm
VPSLLDQ imm8 ymm ymm

Construct and append a VPSLLDQ instruction to the active function. Operates on the global context.

func VPSLLQ ¶

func VPSLLQ(imx, xy, xy1 operand.Op)

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

Construct and append a VPSLLQ instruction to the active function. Operates on the global context.

func VPSLLVD ¶

func VPSLLVD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSLLVD instruction to the active function. Operates on the global context.

func VPSLLVQ ¶

func VPSLLVQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSLLVQ instruction to the active function. Operates on the global context.

func VPSLLW ¶

func VPSLLW(imx, xy, xy1 operand.Op)

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

Construct and append a VPSLLW instruction to the active function. Operates on the global context.

func VPSRAD ¶

func VPSRAD(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRAD instruction to the active function. Operates on the global context.

func VPSRAVD ¶

func VPSRAVD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSRAVD instruction to the active function. Operates on the global context.

func VPSRAW ¶

func VPSRAW(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRAW instruction to the active function. Operates on the global context.

func VPSRLD ¶

func VPSRLD(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRLD instruction to the active function. Operates on the global context.

func VPSRLDQ ¶

func VPSRLDQ(i, xy, xy1 operand.Op)

VPSRLDQ: Shift Packed Double Quadword Right Logical.

Forms:

VPSRLDQ imm8 xmm xmm
VPSRLDQ imm8 ymm ymm

Construct and append a VPSRLDQ instruction to the active function. Operates on the global context.

func VPSRLQ ¶

func VPSRLQ(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRLQ instruction to the active function. Operates on the global context.

func VPSRLVD ¶

func VPSRLVD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSRLVD instruction to the active function. Operates on the global context.

func VPSRLVQ ¶

func VPSRLVQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSRLVQ instruction to the active function. Operates on the global context.

func VPSRLW ¶

func VPSRLW(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRLW instruction to the active function. Operates on the global context.

func VPSUBB ¶

func VPSUBB(mxy, xy, xy1 operand.Op)

VPSUBB: Subtract Packed Byte Integers.

Forms:

VPSUBB xmm  xmm xmm
VPSUBB m128 xmm xmm
VPSUBB ymm  ymm ymm
VPSUBB m256 ymm ymm

Construct and append a VPSUBB instruction to the active function. Operates on the global context.

func VPSUBD ¶

func VPSUBD(mxy, xy, xy1 operand.Op)

VPSUBD: Subtract Packed Doubleword Integers.

Forms:

VPSUBD xmm  xmm xmm
VPSUBD m128 xmm xmm
VPSUBD ymm  ymm ymm
VPSUBD m256 ymm ymm

Construct and append a VPSUBD instruction to the active function. Operates on the global context.

func VPSUBQ ¶

func VPSUBQ(mxy, xy, xy1 operand.Op)

VPSUBQ: Subtract Packed Quadword Integers.

Forms:

VPSUBQ xmm  xmm xmm
VPSUBQ m128 xmm xmm
VPSUBQ ymm  ymm ymm
VPSUBQ m256 ymm ymm

Construct and append a VPSUBQ instruction to the active function. Operates on the global context.

func VPSUBSB ¶

func VPSUBSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBSB instruction to the active function. Operates on the global context.

func VPSUBSW ¶

func VPSUBSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBSW instruction to the active function. Operates on the global context.

func VPSUBUSB ¶

func VPSUBUSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBUSB instruction to the active function. Operates on the global context.

func VPSUBUSW ¶

func VPSUBUSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBUSW instruction to the active function. Operates on the global context.

func VPSUBW ¶

func VPSUBW(mxy, xy, xy1 operand.Op)

VPSUBW: Subtract Packed Word Integers.

Forms:

VPSUBW xmm  xmm xmm
VPSUBW m128 xmm xmm
VPSUBW ymm  ymm ymm
VPSUBW m256 ymm ymm

Construct and append a VPSUBW instruction to the active function. Operates on the global context.

func VPTEST ¶

func VPTEST(mxy, xy operand.Op)

VPTEST: Packed Logical Compare.

Forms:

VPTEST xmm  xmm
VPTEST m128 xmm
VPTEST ymm  ymm
VPTEST m256 ymm

Construct and append a VPTEST instruction to the active function. Operates on the global context.

func VPUNPCKHBW ¶

func VPUNPCKHBW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHBW instruction to the active function. Operates on the global context.

func VPUNPCKHDQ ¶

func VPUNPCKHDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHDQ instruction to the active function. Operates on the global context.

func VPUNPCKHQDQ ¶

func VPUNPCKHQDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHQDQ instruction to the active function. Operates on the global context.

func VPUNPCKHWD ¶

func VPUNPCKHWD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHWD instruction to the active function. Operates on the global context.

func VPUNPCKLBW ¶

func VPUNPCKLBW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLBW instruction to the active function. Operates on the global context.

func VPUNPCKLDQ ¶

func VPUNPCKLDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLDQ instruction to the active function. Operates on the global context.

func VPUNPCKLQDQ ¶

func VPUNPCKLQDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLQDQ instruction to the active function. Operates on the global context.

func VPUNPCKLWD ¶

func VPUNPCKLWD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLWD instruction to the active function. Operates on the global context.

func VPXOR ¶

func VPXOR(mxy, xy, xy1 operand.Op)

VPXOR: Packed Bitwise Logical Exclusive OR.

Forms:

VPXOR xmm  xmm xmm
VPXOR m128 xmm xmm
VPXOR ymm  ymm ymm
VPXOR m256 ymm ymm

Construct and append a VPXOR instruction to the active function. Operates on the global context.

func VRCPPS ¶

func VRCPPS(mxy, xy operand.Op)

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

Forms:

VRCPPS xmm  xmm
VRCPPS m128 xmm
VRCPPS ymm  ymm
VRCPPS m256 ymm

Construct and append a VRCPPS instruction to the active function. Operates on the global context.

func VRCPSS ¶

func VRCPSS(mx, x, x1 operand.Op)

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

Forms:

VRCPSS xmm xmm xmm
VRCPSS m32 xmm xmm

Construct and append a VRCPSS instruction to the active function. Operates on the global context.

func VROUNDPD ¶

func VROUNDPD(i, mxy, xy operand.Op)

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

Construct and append a VROUNDPD instruction to the active function. Operates on the global context.

func VROUNDPS ¶

func VROUNDPS(i, mxy, xy operand.Op)

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

Construct and append a VROUNDPS instruction to the active function. Operates on the global context.

func VROUNDSD ¶

func VROUNDSD(i, mx, x, x1 operand.Op)

VROUNDSD: Round Scalar Double Precision Floating-Point Values.

Forms:

VROUNDSD imm8 xmm xmm xmm
VROUNDSD imm8 m64 xmm xmm

Construct and append a VROUNDSD instruction to the active function. Operates on the global context.

func VROUNDSS ¶

func VROUNDSS(i, mx, x, x1 operand.Op)

VROUNDSS: Round Scalar Single Precision Floating-Point Values.

Forms:

VROUNDSS imm8 xmm xmm xmm
VROUNDSS imm8 m32 xmm xmm

Construct and append a VROUNDSS instruction to the active function. Operates on the global context.

func VRSQRTPS ¶

func VRSQRTPS(mxy, xy operand.Op)

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

Construct and append a VRSQRTPS instruction to the active function. Operates on the global context.

func VRSQRTSS ¶

func VRSQRTSS(mx, x, x1 operand.Op)

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

Forms:

VRSQRTSS xmm xmm xmm
VRSQRTSS m32 xmm xmm

Construct and append a VRSQRTSS instruction to the active function. Operates on the global context.

func VSHUFPD ¶

func VSHUFPD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VSHUFPD instruction to the active function. Operates on the global context.

func VSHUFPS ¶

func VSHUFPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VSHUFPS instruction to the active function. Operates on the global context.

func VSQRTPD ¶

func VSQRTPD(mxy, xy operand.Op)

VSQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values.

Forms:

VSQRTPD xmm  xmm
VSQRTPD m128 xmm
VSQRTPD ymm  ymm
VSQRTPD m256 ymm

Construct and append a VSQRTPD instruction to the active function. Operates on the global context.

func VSQRTPS ¶

func VSQRTPS(mxy, xy operand.Op)

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

Forms:

VSQRTPS xmm  xmm
VSQRTPS m128 xmm
VSQRTPS ymm  ymm
VSQRTPS m256 ymm

Construct and append a VSQRTPS instruction to the active function. Operates on the global context.

func VSQRTSD ¶

func VSQRTSD(mx, x, x1 operand.Op)

VSQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value.

Forms:

VSQRTSD xmm xmm xmm
VSQRTSD m64 xmm xmm

Construct and append a VSQRTSD instruction to the active function. Operates on the global context.

func VSQRTSS ¶

func VSQRTSS(mx, x, x1 operand.Op)

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

Forms:

VSQRTSS xmm xmm xmm
VSQRTSS m32 xmm xmm

Construct and append a VSQRTSS instruction to the active function. Operates on the global context.

func VSTMXCSR ¶

func VSTMXCSR(m operand.Op)

VSTMXCSR: Store MXCSR Register State.

Forms:

VSTMXCSR m32

Construct and append a VSTMXCSR instruction to the active function. Operates on the global context.

func VSUBPD ¶

func VSUBPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VSUBPD instruction to the active function. Operates on the global context.

func VSUBPS ¶

func VSUBPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VSUBPS instruction to the active function. Operates on the global context.

func VSUBSD ¶

func VSUBSD(mx, x, x1 operand.Op)

VSUBSD: Subtract Scalar Double-Precision Floating-Point Values.

Forms:

VSUBSD xmm xmm xmm
VSUBSD m64 xmm xmm

Construct and append a VSUBSD instruction to the active function. Operates on the global context.

func VSUBSS ¶

func VSUBSS(mx, x, x1 operand.Op)

VSUBSS: Subtract Scalar Single-Precision Floating-Point Values.

Forms:

VSUBSS xmm xmm xmm
VSUBSS m32 xmm xmm

Construct and append a VSUBSS instruction to the active function. Operates on the global context.

func VTESTPD ¶

func VTESTPD(mxy, xy operand.Op)

VTESTPD: Packed Double-Precision Floating-Point Bit Test.

Forms:

VTESTPD xmm  xmm
VTESTPD m128 xmm
VTESTPD ymm  ymm
VTESTPD m256 ymm

Construct and append a VTESTPD instruction to the active function. Operates on the global context.

func VTESTPS ¶

func VTESTPS(mxy, xy operand.Op)

VTESTPS: Packed Single-Precision Floating-Point Bit Test.

Forms:

VTESTPS xmm  xmm
VTESTPS m128 xmm
VTESTPS ymm  ymm
VTESTPS m256 ymm

Construct and append a VTESTPS instruction to the active function. Operates on the global context.

func VUCOMISD ¶

func VUCOMISD(mx, x operand.Op)

VUCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

VUCOMISD xmm xmm
VUCOMISD m64 xmm

Construct and append a VUCOMISD instruction to the active function. Operates on the global context.

func VUCOMISS ¶

func VUCOMISS(mx, x operand.Op)

VUCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

VUCOMISS xmm xmm
VUCOMISS m32 xmm

Construct and append a VUCOMISS instruction to the active function. Operates on the global context.

func VUNPCKHPD ¶

func VUNPCKHPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKHPD instruction to the active function. Operates on the global context.

func VUNPCKHPS ¶

func VUNPCKHPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKHPS instruction to the active function. Operates on the global context.

func VUNPCKLPD ¶

func VUNPCKLPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKLPD instruction to the active function. Operates on the global context.

func VUNPCKLPS ¶

func VUNPCKLPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKLPS instruction to the active function. Operates on the global context.

func VXORPD ¶

func VXORPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VXORPD instruction to the active function. Operates on the global context.

func VXORPS ¶

func VXORPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VXORPS instruction to the active function. Operates on the global context.

func VZEROALL ¶

func VZEROALL()

VZEROALL: Zero All YMM Registers.

Forms:

VZEROALL

Construct and append a VZEROALL instruction to the active function. Operates on the global context.

func VZEROUPPER ¶

func VZEROUPPER()

VZEROUPPER: Zero Upper Bits of YMM Registers.

Forms:

VZEROUPPER

Construct and append a VZEROUPPER instruction to the active function. Operates on the global context.

func XADDB ¶

func XADDB(r, mr operand.Op)

XADDB: Exchange and Add.

Forms:

XADDB r8 r8
XADDB r8 m8

Construct and append a XADDB instruction to the active function. Operates on the global context.

func XADDL ¶

func XADDL(r, mr operand.Op)

XADDL: Exchange and Add.

Forms:

XADDL r32 r32
XADDL r32 m32

Construct and append a XADDL instruction to the active function. Operates on the global context.

func XADDQ ¶

func XADDQ(r, mr operand.Op)

XADDQ: Exchange and Add.

Forms:

XADDQ r64 r64
XADDQ r64 m64

Construct and append a XADDQ instruction to the active function. Operates on the global context.

func XADDW ¶

func XADDW(r, mr operand.Op)

XADDW: Exchange and Add.

Forms:

XADDW r16 r16
XADDW r16 m16

Construct and append a XADDW instruction to the active function. Operates on the global context.

func XCHGB ¶

func XCHGB(mr, mr1 operand.Op)

XCHGB: Exchange Register/Memory with Register.

Forms:

XCHGB r8 r8
XCHGB m8 r8
XCHGB r8 m8

Construct and append a XCHGB instruction to the active function. Operates on the global context.

func XCHGL ¶

func XCHGL(emr, emr1 operand.Op)

XCHGL: Exchange Register/Memory with Register.

Forms:

XCHGL r32 eax
XCHGL eax r32
XCHGL r32 r32
XCHGL m32 r32
XCHGL r32 m32

Construct and append a XCHGL instruction to the active function. Operates on the global context.

func XCHGQ ¶

func XCHGQ(mr, mr1 operand.Op)

XCHGQ: Exchange Register/Memory with Register.

Forms:

XCHGQ r64 rax
XCHGQ rax r64
XCHGQ r64 r64
XCHGQ m64 r64
XCHGQ r64 m64

Construct and append a XCHGQ instruction to the active function. Operates on the global context.

func XCHGW ¶

func XCHGW(amr, amr1 operand.Op)

XCHGW: Exchange Register/Memory with Register.

Forms:

XCHGW r16 ax
XCHGW ax  r16
XCHGW r16 r16
XCHGW m16 r16
XCHGW r16 m16

Construct and append a XCHGW instruction to the active function. Operates on the global context.

func XGETBV ¶

func XGETBV()

XGETBV: Get Value of Extended Control Register.

Forms:

XGETBV

Construct and append a XGETBV instruction to the active function. Operates on the global context.

func XLAT ¶

func XLAT()

XLAT: Table Look-up Translation.

Forms:

XLAT

Construct and append a XLAT instruction to the active function. Operates on the global context.

func XMM ¶

func XMM() reg.VecVirtual

XMM allocates and returns a 128-bit vector register.

func XORB ¶

func XORB(imr, amr operand.Op)

XORB: Logical Exclusive OR.

Forms:

XORB imm8 al
XORB imm8 r8
XORB r8   r8
XORB m8   r8
XORB imm8 m8
XORB r8   m8

Construct and append a XORB instruction to the active function. Operates on the global context.

func XORL ¶

func XORL(imr, emr operand.Op)

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

Construct and append a XORL instruction to the active function. Operates on the global context.

func XORPD ¶

func XORPD(mx, x operand.Op)

XORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values.

Forms:

XORPD xmm  xmm
XORPD m128 xmm

Construct and append a XORPD instruction to the active function. Operates on the global context.

func XORPS ¶

func XORPS(mx, x operand.Op)

XORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values.

Forms:

XORPS xmm  xmm
XORPS m128 xmm

Construct and append a XORPS instruction to the active function. Operates on the global context.

func XORQ ¶

func XORQ(imr, mr operand.Op)

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

Construct and append a XORQ instruction to the active function. Operates on the global context.

func XORW ¶

func XORW(imr, amr operand.Op)

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

Construct and append a XORW instruction to the active function. Operates on the global context.

func YMM ¶

func YMM() reg.VecVirtual

YMM allocates and returns a 256-bit vector register.

func ZMM ¶

func ZMM() reg.VecVirtual

ZMM allocates and returns a 512-bit vector register.

Types ¶

type Config ¶

type Config struct {
	ErrOut     io.Writer
	MaxErrors  int // max errors to report; 0 means unlimited
	CPUProfile io.WriteCloser
	Passes     []pass.Interface
}

Config contains options for an avo main function.

type Context ¶

type Context struct {
	reg.Collection
	// contains filtered or unexported fields
}

Context maintains state for incrementally building an avo File.

func NewContext ¶

func NewContext() *Context

NewContext initializes an empty build Context.

func (*Context) ADCB ¶

func (c *Context) ADCB(imr, amr operand.Op)

ADCB: Add with Carry.

Forms:

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

Construct and append a ADCB instruction to the active function.

func (*Context) ADCL ¶

func (c *Context) ADCL(imr, emr operand.Op)

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

Construct and append a ADCL instruction to the active function.

func (*Context) ADCQ ¶

func (c *Context) ADCQ(imr, mr operand.Op)

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

Construct and append a ADCQ instruction to the active function.

func (*Context) ADCW ¶

func (c *Context) ADCW(imr, amr operand.Op)

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

Construct and append a ADCW instruction to the active function.

func (*Context) ADCXL ¶

func (c *Context) ADCXL(mr, r operand.Op)

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

Forms:

ADCXL r32 r32
ADCXL m32 r32

Construct and append a ADCXL instruction to the active function.

func (*Context) ADCXQ ¶

func (c *Context) ADCXQ(mr, r operand.Op)

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

Forms:

ADCXQ r64 r64
ADCXQ m64 r64

Construct and append a ADCXQ instruction to the active function.

func (*Context) ADDB ¶

func (c *Context) ADDB(imr, amr operand.Op)

ADDB: Add.

Forms:

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

Construct and append a ADDB instruction to the active function.

func (*Context) ADDL ¶

func (c *Context) ADDL(imr, emr operand.Op)

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

Construct and append a ADDL instruction to the active function.

func (*Context) ADDPD ¶

func (c *Context) ADDPD(mx, x operand.Op)

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

Forms:

ADDPD xmm  xmm
ADDPD m128 xmm

Construct and append a ADDPD instruction to the active function.

func (*Context) ADDPS ¶

func (c *Context) ADDPS(mx, x operand.Op)

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

Forms:

ADDPS xmm  xmm
ADDPS m128 xmm

Construct and append a ADDPS instruction to the active function.

func (*Context) ADDQ ¶

func (c *Context) ADDQ(imr, mr operand.Op)

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

Construct and append a ADDQ instruction to the active function.

func (*Context) ADDSD ¶

func (c *Context) ADDSD(mx, x operand.Op)

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

Forms:

ADDSD xmm xmm
ADDSD m64 xmm

Construct and append a ADDSD instruction to the active function.

func (*Context) ADDSS ¶

func (c *Context) ADDSS(mx, x operand.Op)

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

Forms:

ADDSS xmm xmm
ADDSS m32 xmm

Construct and append a ADDSS instruction to the active function.

func (*Context) ADDSUBPD ¶

func (c *Context) ADDSUBPD(mx, x operand.Op)

ADDSUBPD: Packed Double-FP Add/Subtract.

Forms:

ADDSUBPD xmm  xmm
ADDSUBPD m128 xmm

Construct and append a ADDSUBPD instruction to the active function.

func (*Context) ADDSUBPS ¶

func (c *Context) ADDSUBPS(mx, x operand.Op)

ADDSUBPS: Packed Single-FP Add/Subtract.

Forms:

ADDSUBPS xmm  xmm
ADDSUBPS m128 xmm

Construct and append a ADDSUBPS instruction to the active function.

func (*Context) ADDW ¶

func (c *Context) ADDW(imr, amr operand.Op)

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

Construct and append a ADDW instruction to the active function.

func (*Context) ADOXL ¶

func (c *Context) ADOXL(mr, r operand.Op)

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

Forms:

ADOXL r32 r32
ADOXL m32 r32

Construct and append a ADOXL instruction to the active function.

func (*Context) ADOXQ ¶

func (c *Context) ADOXQ(mr, r operand.Op)

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

Forms:

ADOXQ r64 r64
ADOXQ m64 r64

Construct and append a ADOXQ instruction to the active function.

func (*Context) AESDEC ¶

func (c *Context) AESDEC(mx, x operand.Op)

AESDEC: Perform One Round of an AES Decryption Flow.

Forms:

AESDEC xmm  xmm
AESDEC m128 xmm

Construct and append a AESDEC instruction to the active function.

func (*Context) AESDECLAST ¶

func (c *Context) AESDECLAST(mx, x operand.Op)

AESDECLAST: Perform Last Round of an AES Decryption Flow.

Forms:

AESDECLAST xmm  xmm
AESDECLAST m128 xmm

Construct and append a AESDECLAST instruction to the active function.

func (*Context) AESENC ¶

func (c *Context) AESENC(mx, x operand.Op)

AESENC: Perform One Round of an AES Encryption Flow.

Forms:

AESENC xmm  xmm
AESENC m128 xmm

Construct and append a AESENC instruction to the active function.

func (*Context) AESENCLAST ¶

func (c *Context) AESENCLAST(mx, x operand.Op)

AESENCLAST: Perform Last Round of an AES Encryption Flow.

Forms:

AESENCLAST xmm  xmm
AESENCLAST m128 xmm

Construct and append a AESENCLAST instruction to the active function.

func (*Context) AESIMC ¶

func (c *Context) AESIMC(mx, x operand.Op)

AESIMC: Perform the AES InvMixColumn Transformation.

Forms:

AESIMC xmm  xmm
AESIMC m128 xmm

Construct and append a AESIMC instruction to the active function.

func (*Context) AESKEYGENASSIST ¶

func (c *Context) AESKEYGENASSIST(i, mx, x operand.Op)

AESKEYGENASSIST: AES Round Key Generation Assist.

Forms:

AESKEYGENASSIST imm8 xmm  xmm
AESKEYGENASSIST imm8 m128 xmm

Construct and append a AESKEYGENASSIST instruction to the active function.

func (*Context) ANDB ¶

func (c *Context) ANDB(imr, amr operand.Op)

ANDB: Logical AND.

Forms:

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

Construct and append a ANDB instruction to the active function.

func (*Context) ANDL ¶

func (c *Context) ANDL(imr, emr operand.Op)

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

Construct and append a ANDL instruction to the active function.

func (*Context) ANDNL ¶

func (c *Context) ANDNL(mr, r, r1 operand.Op)

ANDNL: Logical AND NOT.

Forms:

ANDNL r32 r32 r32
ANDNL m32 r32 r32

Construct and append a ANDNL instruction to the active function.

func (*Context) ANDNPD ¶

func (c *Context) ANDNPD(mx, x operand.Op)

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

Forms:

ANDNPD xmm  xmm
ANDNPD m128 xmm

Construct and append a ANDNPD instruction to the active function.

func (*Context) ANDNPS ¶

func (c *Context) ANDNPS(mx, x operand.Op)

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

Forms:

ANDNPS xmm  xmm
ANDNPS m128 xmm

Construct and append a ANDNPS instruction to the active function.

func (*Context) ANDNQ ¶

func (c *Context) ANDNQ(mr, r, r1 operand.Op)

ANDNQ: Logical AND NOT.

Forms:

ANDNQ r64 r64 r64
ANDNQ m64 r64 r64

Construct and append a ANDNQ instruction to the active function.

func (*Context) ANDPD ¶

func (c *Context) ANDPD(mx, x operand.Op)

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

Forms:

ANDPD xmm  xmm
ANDPD m128 xmm

Construct and append a ANDPD instruction to the active function.

func (*Context) ANDPS ¶

func (c *Context) ANDPS(mx, x operand.Op)

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

Forms:

ANDPS xmm  xmm
ANDPS m128 xmm

Construct and append a ANDPS instruction to the active function.

func (*Context) ANDQ ¶

func (c *Context) ANDQ(imr, mr operand.Op)

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

Construct and append a ANDQ instruction to the active function.

func (*Context) ANDW ¶

func (c *Context) ANDW(imr, amr operand.Op)

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

Construct and append a ANDW instruction to the active function.

func (*Context) AddDatum ¶

func (c *Context) AddDatum(offset int, v operand.Constant)

AddDatum adds constant v at offset to the current active global data section.

func (*Context) AllocLocal ¶

func (c *Context) AllocLocal(size int) operand.Mem

AllocLocal allocates size bytes in the stack of the currently active function. Returns a reference to the base pointer for the newly allocated region.

func (*Context) AppendDatum ¶

func (c *Context) AppendDatum(v operand.Constant)

AppendDatum appends a constant to the current active global data section.

func (*Context) Attributes ¶

func (c *Context) Attributes(a attr.Attribute)

Attributes sets function attributes for the currently active function.

func (*Context) BEXTRL ¶

func (c *Context) BEXTRL(r, mr, r1 operand.Op)

BEXTRL: Bit Field Extract.

Forms:

BEXTRL r32 r32 r32
BEXTRL r32 m32 r32

Construct and append a BEXTRL instruction to the active function.

func (*Context) BEXTRQ ¶

func (c *Context) BEXTRQ(r, mr, r1 operand.Op)

BEXTRQ: Bit Field Extract.

Forms:

BEXTRQ r64 r64 r64
BEXTRQ r64 m64 r64

Construct and append a BEXTRQ instruction to the active function.

func (*Context) BLENDPD ¶

func (c *Context) BLENDPD(i, mx, x operand.Op)

BLENDPD: Blend Packed Double Precision Floating-Point Values.

Forms:

BLENDPD imm8 xmm  xmm
BLENDPD imm8 m128 xmm

Construct and append a BLENDPD instruction to the active function.

func (*Context) BLENDPS ¶

func (c *Context) BLENDPS(i, mx, x operand.Op)

BLENDPS: Blend Packed Single Precision Floating-Point Values.

Forms:

BLENDPS imm8 xmm  xmm
BLENDPS imm8 m128 xmm

Construct and append a BLENDPS instruction to the active function.

func (*Context) BLENDVPD ¶

func (c *Context) BLENDVPD(x, mx, x1 operand.Op)

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

Forms:

BLENDVPD xmm0 xmm  xmm
BLENDVPD xmm0 m128 xmm

Construct and append a BLENDVPD instruction to the active function.

func (*Context) BLENDVPS ¶

func (c *Context) BLENDVPS(x, mx, x1 operand.Op)

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

Forms:

BLENDVPS xmm0 xmm  xmm
BLENDVPS xmm0 m128 xmm

Construct and append a BLENDVPS instruction to the active function.

func (*Context) BLSIL ¶

func (c *Context) BLSIL(mr, r operand.Op)

BLSIL: Isolate Lowest Set Bit.

Forms:

BLSIL r32 r32
BLSIL m32 r32

Construct and append a BLSIL instruction to the active function.

func (*Context) BLSIQ ¶

func (c *Context) BLSIQ(mr, r operand.Op)

BLSIQ: Isolate Lowest Set Bit.

Forms:

BLSIQ r64 r64
BLSIQ m64 r64

Construct and append a BLSIQ instruction to the active function.

func (*Context) BLSMSKL ¶

func (c *Context) BLSMSKL(mr, r operand.Op)

BLSMSKL: Mask From Lowest Set Bit.

Forms:

BLSMSKL r32 r32
BLSMSKL m32 r32

Construct and append a BLSMSKL instruction to the active function.

func (*Context) BLSMSKQ ¶

func (c *Context) BLSMSKQ(mr, r operand.Op)

BLSMSKQ: Mask From Lowest Set Bit.

Forms:

BLSMSKQ r64 r64
BLSMSKQ m64 r64

Construct and append a BLSMSKQ instruction to the active function.

func (*Context) BLSRL ¶

func (c *Context) BLSRL(mr, r operand.Op)

BLSRL: Reset Lowest Set Bit.

Forms:

BLSRL r32 r32
BLSRL m32 r32

Construct and append a BLSRL instruction to the active function.

func (*Context) BLSRQ ¶

func (c *Context) BLSRQ(mr, r operand.Op)

BLSRQ: Reset Lowest Set Bit.

Forms:

BLSRQ r64 r64
BLSRQ m64 r64

Construct and append a BLSRQ instruction to the active function.

func (*Context) BSFL ¶

func (c *Context) BSFL(mr, r operand.Op)

BSFL: Bit Scan Forward.

Forms:

BSFL r32 r32
BSFL m32 r32

Construct and append a BSFL instruction to the active function.

func (*Context) BSFQ ¶

func (c *Context) BSFQ(mr, r operand.Op)

BSFQ: Bit Scan Forward.

Forms:

BSFQ r64 r64
BSFQ m64 r64

Construct and append a BSFQ instruction to the active function.

func (*Context) BSFW ¶

func (c *Context) BSFW(mr, r operand.Op)

BSFW: Bit Scan Forward.

Forms:

BSFW r16 r16
BSFW m16 r16

Construct and append a BSFW instruction to the active function.

func (*Context) BSRL ¶

func (c *Context) BSRL(mr, r operand.Op)

BSRL: Bit Scan Reverse.

Forms:

BSRL r32 r32
BSRL m32 r32

Construct and append a BSRL instruction to the active function.

func (*Context) BSRQ ¶

func (c *Context) BSRQ(mr, r operand.Op)

BSRQ: Bit Scan Reverse.

Forms:

BSRQ r64 r64
BSRQ m64 r64

Construct and append a BSRQ instruction to the active function.

func (*Context) BSRW ¶

func (c *Context) BSRW(mr, r operand.Op)

BSRW: Bit Scan Reverse.

Forms:

BSRW r16 r16
BSRW m16 r16

Construct and append a BSRW instruction to the active function.

func (*Context) BSWAPL ¶

func (c *Context) BSWAPL(r operand.Op)

BSWAPL: Byte Swap.

Forms:

BSWAPL r32

Construct and append a BSWAPL instruction to the active function.

func (*Context) BSWAPQ ¶

func (c *Context) BSWAPQ(r operand.Op)

BSWAPQ: Byte Swap.

Forms:

BSWAPQ r64

Construct and append a BSWAPQ instruction to the active function.

func (*Context) BTCL ¶

func (c *Context) BTCL(ir, mr operand.Op)

BTCL: Bit Test and Complement.

Forms:

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

Construct and append a BTCL instruction to the active function.

func (*Context) BTCQ ¶

func (c *Context) BTCQ(ir, mr operand.Op)

BTCQ: Bit Test and Complement.

Forms:

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

Construct and append a BTCQ instruction to the active function.

func (*Context) BTCW ¶

func (c *Context) BTCW(ir, mr operand.Op)

BTCW: Bit Test and Complement.

Forms:

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

Construct and append a BTCW instruction to the active function.

func (*Context) BTL ¶

func (c *Context) BTL(ir, mr operand.Op)

BTL: Bit Test.

Forms:

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

Construct and append a BTL instruction to the active function.

func (*Context) BTQ ¶

func (c *Context) BTQ(ir, mr operand.Op)

BTQ: Bit Test.

Forms:

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

Construct and append a BTQ instruction to the active function.

func (*Context) BTRL ¶

func (c *Context) BTRL(ir, mr operand.Op)

BTRL: Bit Test and Reset.

Forms:

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

Construct and append a BTRL instruction to the active function.

func (*Context) BTRQ ¶

func (c *Context) BTRQ(ir, mr operand.Op)

BTRQ: Bit Test and Reset.

Forms:

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

Construct and append a BTRQ instruction to the active function.

func (*Context) BTRW ¶

func (c *Context) BTRW(ir, mr operand.Op)

BTRW: Bit Test and Reset.

Forms:

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

Construct and append a BTRW instruction to the active function.

func (*Context) BTSL ¶

func (c *Context) BTSL(ir, mr operand.Op)

BTSL: Bit Test and Set.

Forms:

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

Construct and append a BTSL instruction to the active function.

func (*Context) BTSQ ¶

func (c *Context) BTSQ(ir, mr operand.Op)

BTSQ: Bit Test and Set.

Forms:

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

Construct and append a BTSQ instruction to the active function.

func (*Context) BTSW ¶

func (c *Context) BTSW(ir, mr operand.Op)

BTSW: Bit Test and Set.

Forms:

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

Construct and append a BTSW instruction to the active function.

func (*Context) BTW ¶

func (c *Context) BTW(ir, mr operand.Op)

BTW: Bit Test.

Forms:

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

Construct and append a BTW instruction to the active function.

func (*Context) BZHIL ¶

func (c *Context) BZHIL(r, mr, r1 operand.Op)

BZHIL: Zero High Bits Starting with Specified Bit Position.

Forms:

BZHIL r32 r32 r32
BZHIL r32 m32 r32

Construct and append a BZHIL instruction to the active function.

func (*Context) BZHIQ ¶

func (c *Context) BZHIQ(r, mr, r1 operand.Op)

BZHIQ: Zero High Bits Starting with Specified Bit Position.

Forms:

BZHIQ r64 r64 r64
BZHIQ r64 m64 r64

Construct and append a BZHIQ instruction to the active function.

func (*Context) CALL ¶

func (c *Context) CALL(r operand.Op)

CALL: Call Procedure.

Forms:

CALL rel32

Construct and append a CALL instruction to the active function.

func (*Context) CBW ¶

func (c *Context) CBW()

CBW: Convert Byte to Word.

Forms:

CBW

Construct and append a CBW instruction to the active function.

func (*Context) CDQ ¶

func (c *Context) CDQ()

CDQ: Convert Doubleword to Quadword.

Forms:

CDQ

Construct and append a CDQ instruction to the active function.

func (*Context) CDQE ¶

func (c *Context) CDQE()

CDQE: Convert Doubleword to Quadword.

Forms:

CDQE

Construct and append a CDQE instruction to the active function.

func (*Context) CLC ¶

func (c *Context) CLC()

CLC: Clear Carry Flag.

Forms:

CLC

Construct and append a CLC instruction to the active function.

func (*Context) CLD ¶

func (c *Context) CLD()

CLD: Clear Direction Flag.

Forms:

CLD

Construct and append a CLD instruction to the active function.

func (*Context) CLFLUSH ¶

func (c *Context) CLFLUSH(m operand.Op)

CLFLUSH: Flush Cache Line.

Forms:

CLFLUSH m8

Construct and append a CLFLUSH instruction to the active function.

func (*Context) CLFLUSHOPT ¶

func (c *Context) CLFLUSHOPT(m operand.Op)

CLFLUSHOPT: Flush Cache Line Optimized.

Forms:

CLFLUSHOPT m8

Construct and append a CLFLUSHOPT instruction to the active function.

func (*Context) CMC ¶

func (c *Context) CMC()

CMC: Complement Carry Flag.

Forms:

CMC

Construct and append a CMC instruction to the active function.

func (*Context) CMOVLCC ¶

func (c *Context) CMOVLCC(mr, r operand.Op)

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

Forms:

CMOVLCC r32 r32
CMOVLCC m32 r32

Construct and append a CMOVLCC instruction to the active function.

func (*Context) CMOVLCS ¶

func (c *Context) CMOVLCS(mr, r operand.Op)

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

Forms:

CMOVLCS r32 r32
CMOVLCS m32 r32

Construct and append a CMOVLCS instruction to the active function.

func (*Context) CMOVLEQ ¶

func (c *Context) CMOVLEQ(mr, r operand.Op)

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

Forms:

CMOVLEQ r32 r32
CMOVLEQ m32 r32

Construct and append a CMOVLEQ instruction to the active function.

func (*Context) CMOVLGE ¶

func (c *Context) CMOVLGE(mr, r operand.Op)

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

Forms:

CMOVLGE r32 r32
CMOVLGE m32 r32

Construct and append a CMOVLGE instruction to the active function.

func (*Context) CMOVLGT ¶

func (c *Context) CMOVLGT(mr, r operand.Op)

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

Forms:

CMOVLGT r32 r32
CMOVLGT m32 r32

Construct and append a CMOVLGT instruction to the active function.

func (*Context) CMOVLHI ¶

func (c *Context) CMOVLHI(mr, r operand.Op)

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

Forms:

CMOVLHI r32 r32
CMOVLHI m32 r32

Construct and append a CMOVLHI instruction to the active function.

func (*Context) CMOVLLE ¶

func (c *Context) CMOVLLE(mr, r operand.Op)

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

Forms:

CMOVLLE r32 r32
CMOVLLE m32 r32

Construct and append a CMOVLLE instruction to the active function.

func (*Context) CMOVLLS ¶

func (c *Context) CMOVLLS(mr, r operand.Op)

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

Forms:

CMOVLLS r32 r32
CMOVLLS m32 r32

Construct and append a CMOVLLS instruction to the active function.

func (*Context) CMOVLLT ¶

func (c *Context) CMOVLLT(mr, r operand.Op)

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

Forms:

CMOVLLT r32 r32
CMOVLLT m32 r32

Construct and append a CMOVLLT instruction to the active function.

func (*Context) CMOVLMI ¶

func (c *Context) CMOVLMI(mr, r operand.Op)

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

Forms:

CMOVLMI r32 r32
CMOVLMI m32 r32

Construct and append a CMOVLMI instruction to the active function.

func (*Context) CMOVLNE ¶

func (c *Context) CMOVLNE(mr, r operand.Op)

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

Forms:

CMOVLNE r32 r32
CMOVLNE m32 r32

Construct and append a CMOVLNE instruction to the active function.

func (*Context) CMOVLOC ¶

func (c *Context) CMOVLOC(mr, r operand.Op)

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

Forms:

CMOVLOC r32 r32
CMOVLOC m32 r32

Construct and append a CMOVLOC instruction to the active function.

func (*Context) CMOVLOS ¶

func (c *Context) CMOVLOS(mr, r operand.Op)

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

Forms:

CMOVLOS r32 r32
CMOVLOS m32 r32

Construct and append a CMOVLOS instruction to the active function.

func (*Context) CMOVLPC ¶

func (c *Context) CMOVLPC(mr, r operand.Op)

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

Forms:

CMOVLPC r32 r32
CMOVLPC m32 r32

Construct and append a CMOVLPC instruction to the active function.

func (*Context) CMOVLPL ¶

func (c *Context) CMOVLPL(mr, r operand.Op)

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

Forms:

CMOVLPL r32 r32
CMOVLPL m32 r32

Construct and append a CMOVLPL instruction to the active function.

func (*Context) CMOVLPS ¶

func (c *Context) CMOVLPS(mr, r operand.Op)

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

Forms:

CMOVLPS r32 r32
CMOVLPS m32 r32

Construct and append a CMOVLPS instruction to the active function.

func (*Context) CMOVQCC ¶

func (c *Context) CMOVQCC(mr, r operand.Op)

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

Forms:

CMOVQCC r64 r64
CMOVQCC m64 r64

Construct and append a CMOVQCC instruction to the active function.

func (*Context) CMOVQCS ¶

func (c *Context) CMOVQCS(mr, r operand.Op)

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

Forms:

CMOVQCS r64 r64
CMOVQCS m64 r64

Construct and append a CMOVQCS instruction to the active function.

func (*Context) CMOVQEQ ¶

func (c *Context) CMOVQEQ(mr, r operand.Op)

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

Forms:

CMOVQEQ r64 r64
CMOVQEQ m64 r64

Construct and append a CMOVQEQ instruction to the active function.

func (*Context) CMOVQGE ¶

func (c *Context) CMOVQGE(mr, r operand.Op)

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

Forms:

CMOVQGE r64 r64
CMOVQGE m64 r64

Construct and append a CMOVQGE instruction to the active function.

func (*Context) CMOVQGT ¶

func (c *Context) CMOVQGT(mr, r operand.Op)

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

Forms:

CMOVQGT r64 r64
CMOVQGT m64 r64

Construct and append a CMOVQGT instruction to the active function.

func (*Context) CMOVQHI ¶

func (c *Context) CMOVQHI(mr, r operand.Op)

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

Forms:

CMOVQHI r64 r64
CMOVQHI m64 r64

Construct and append a CMOVQHI instruction to the active function.

func (*Context) CMOVQLE ¶

func (c *Context) CMOVQLE(mr, r operand.Op)

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

Forms:

CMOVQLE r64 r64
CMOVQLE m64 r64

Construct and append a CMOVQLE instruction to the active function.

func (*Context) CMOVQLS ¶

func (c *Context) CMOVQLS(mr, r operand.Op)

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

Forms:

CMOVQLS r64 r64
CMOVQLS m64 r64

Construct and append a CMOVQLS instruction to the active function.

func (*Context) CMOVQLT ¶

func (c *Context) CMOVQLT(mr, r operand.Op)

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

Forms:

CMOVQLT r64 r64
CMOVQLT m64 r64

Construct and append a CMOVQLT instruction to the active function.

func (*Context) CMOVQMI ¶

func (c *Context) CMOVQMI(mr, r operand.Op)

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

Forms:

CMOVQMI r64 r64
CMOVQMI m64 r64

Construct and append a CMOVQMI instruction to the active function.

func (*Context) CMOVQNE ¶

func (c *Context) CMOVQNE(mr, r operand.Op)

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

Forms:

CMOVQNE r64 r64
CMOVQNE m64 r64

Construct and append a CMOVQNE instruction to the active function.

func (*Context) CMOVQOC ¶

func (c *Context) CMOVQOC(mr, r operand.Op)

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

Forms:

CMOVQOC r64 r64
CMOVQOC m64 r64

Construct and append a CMOVQOC instruction to the active function.

func (*Context) CMOVQOS ¶

func (c *Context) CMOVQOS(mr, r operand.Op)

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

Forms:

CMOVQOS r64 r64
CMOVQOS m64 r64

Construct and append a CMOVQOS instruction to the active function.

func (*Context) CMOVQPC ¶

func (c *Context) CMOVQPC(mr, r operand.Op)

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

Forms:

CMOVQPC r64 r64
CMOVQPC m64 r64

Construct and append a CMOVQPC instruction to the active function.

func (*Context) CMOVQPL ¶

func (c *Context) CMOVQPL(mr, r operand.Op)

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

Forms:

CMOVQPL r64 r64
CMOVQPL m64 r64

Construct and append a CMOVQPL instruction to the active function.

func (*Context) CMOVQPS ¶

func (c *Context) CMOVQPS(mr, r operand.Op)

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

Forms:

CMOVQPS r64 r64
CMOVQPS m64 r64

Construct and append a CMOVQPS instruction to the active function.

func (*Context) CMOVWCC ¶

func (c *Context) CMOVWCC(mr, r operand.Op)

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

Forms:

CMOVWCC r16 r16
CMOVWCC m16 r16

Construct and append a CMOVWCC instruction to the active function.

func (*Context) CMOVWCS ¶

func (c *Context) CMOVWCS(mr, r operand.Op)

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

Forms:

CMOVWCS r16 r16
CMOVWCS m16 r16

Construct and append a CMOVWCS instruction to the active function.

func (*Context) CMOVWEQ ¶

func (c *Context) CMOVWEQ(mr, r operand.Op)

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

Forms:

CMOVWEQ r16 r16
CMOVWEQ m16 r16

Construct and append a CMOVWEQ instruction to the active function.

func (*Context) CMOVWGE ¶

func (c *Context) CMOVWGE(mr, r operand.Op)

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

Forms:

CMOVWGE r16 r16
CMOVWGE m16 r16

Construct and append a CMOVWGE instruction to the active function.

func (*Context) CMOVWGT ¶

func (c *Context) CMOVWGT(mr, r operand.Op)

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

Forms:

CMOVWGT r16 r16
CMOVWGT m16 r16

Construct and append a CMOVWGT instruction to the active function.

func (*Context) CMOVWHI ¶

func (c *Context) CMOVWHI(mr, r operand.Op)

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

Forms:

CMOVWHI r16 r16
CMOVWHI m16 r16

Construct and append a CMOVWHI instruction to the active function.

func (*Context) CMOVWLE ¶

func (c *Context) CMOVWLE(mr, r operand.Op)

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

Forms:

CMOVWLE r16 r16
CMOVWLE m16 r16

Construct and append a CMOVWLE instruction to the active function.

func (*Context) CMOVWLS ¶

func (c *Context) CMOVWLS(mr, r operand.Op)

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

Forms:

CMOVWLS r16 r16
CMOVWLS m16 r16

Construct and append a CMOVWLS instruction to the active function.

func (*Context) CMOVWLT ¶

func (c *Context) CMOVWLT(mr, r operand.Op)

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

Forms:

CMOVWLT r16 r16
CMOVWLT m16 r16

Construct and append a CMOVWLT instruction to the active function.

func (*Context) CMOVWMI ¶

func (c *Context) CMOVWMI(mr, r operand.Op)

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

Forms:

CMOVWMI r16 r16
CMOVWMI m16 r16

Construct and append a CMOVWMI instruction to the active function.

func (*Context) CMOVWNE ¶

func (c *Context) CMOVWNE(mr, r operand.Op)

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

Forms:

CMOVWNE r16 r16
CMOVWNE m16 r16

Construct and append a CMOVWNE instruction to the active function.

func (*Context) CMOVWOC ¶

func (c *Context) CMOVWOC(mr, r operand.Op)

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

Forms:

CMOVWOC r16 r16
CMOVWOC m16 r16

Construct and append a CMOVWOC instruction to the active function.

func (*Context) CMOVWOS ¶

func (c *Context) CMOVWOS(mr, r operand.Op)

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

Forms:

CMOVWOS r16 r16
CMOVWOS m16 r16

Construct and append a CMOVWOS instruction to the active function.

func (*Context) CMOVWPC ¶

func (c *Context) CMOVWPC(mr, r operand.Op)

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

Forms:

CMOVWPC r16 r16
CMOVWPC m16 r16

Construct and append a CMOVWPC instruction to the active function.

func (*Context) CMOVWPL ¶

func (c *Context) CMOVWPL(mr, r operand.Op)

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

Forms:

CMOVWPL r16 r16
CMOVWPL m16 r16

Construct and append a CMOVWPL instruction to the active function.

func (*Context) CMOVWPS ¶

func (c *Context) CMOVWPS(mr, r operand.Op)

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

Forms:

CMOVWPS r16 r16
CMOVWPS m16 r16

Construct and append a CMOVWPS instruction to the active function.

func (*Context) CMPB ¶

func (c *Context) CMPB(amr, imr operand.Op)

CMPB: Compare Two Operands.

Forms:

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

Construct and append a CMPB instruction to the active function.

func (*Context) CMPL ¶

func (c *Context) CMPL(emr, imr operand.Op)

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

Construct and append a CMPL instruction to the active function.

func (*Context) CMPPD ¶

func (c *Context) CMPPD(mx, x, i operand.Op)

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

Forms:

CMPPD xmm  xmm imm8
CMPPD m128 xmm imm8

Construct and append a CMPPD instruction to the active function.

func (*Context) CMPPS ¶

func (c *Context) CMPPS(mx, x, i operand.Op)

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

Forms:

CMPPS xmm  xmm imm8
CMPPS m128 xmm imm8

Construct and append a CMPPS instruction to the active function.

func (*Context) CMPQ ¶

func (c *Context) CMPQ(mr, imr operand.Op)

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

Construct and append a CMPQ instruction to the active function.

func (*Context) CMPSD ¶

func (c *Context) CMPSD(mx, x, i operand.Op)

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

Forms:

CMPSD xmm xmm imm8
CMPSD m64 xmm imm8

Construct and append a CMPSD instruction to the active function.

func (*Context) CMPSS ¶

func (c *Context) CMPSS(mx, x, i operand.Op)

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

Forms:

CMPSS xmm xmm imm8
CMPSS m32 xmm imm8

Construct and append a CMPSS instruction to the active function.

func (*Context) CMPW ¶

func (c *Context) CMPW(amr, imr operand.Op)

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

Construct and append a CMPW instruction to the active function.

func (*Context) CMPXCHG16B ¶

func (c *Context) CMPXCHG16B(m operand.Op)

CMPXCHG16B: Compare and Exchange 16 Bytes.

Forms:

CMPXCHG16B m128

Construct and append a CMPXCHG16B instruction to the active function.

func (*Context) CMPXCHG8B ¶

func (c *Context) CMPXCHG8B(m operand.Op)

CMPXCHG8B: Compare and Exchange 8 Bytes.

Forms:

CMPXCHG8B m64

Construct and append a CMPXCHG8B instruction to the active function.

func (*Context) CMPXCHGB ¶

func (c *Context) CMPXCHGB(r, mr operand.Op)

CMPXCHGB: Compare and Exchange.

Forms:

CMPXCHGB r8 r8
CMPXCHGB r8 m8

Construct and append a CMPXCHGB instruction to the active function.

func (*Context) CMPXCHGL ¶

func (c *Context) CMPXCHGL(r, mr operand.Op)

CMPXCHGL: Compare and Exchange.

Forms:

CMPXCHGL r32 r32
CMPXCHGL r32 m32

Construct and append a CMPXCHGL instruction to the active function.

func (*Context) CMPXCHGQ ¶

func (c *Context) CMPXCHGQ(r, mr operand.Op)

CMPXCHGQ: Compare and Exchange.

Forms:

CMPXCHGQ r64 r64
CMPXCHGQ r64 m64

Construct and append a CMPXCHGQ instruction to the active function.

func (*Context) CMPXCHGW ¶

func (c *Context) CMPXCHGW(r, mr operand.Op)

CMPXCHGW: Compare and Exchange.

Forms:

CMPXCHGW r16 r16
CMPXCHGW r16 m16

Construct and append a CMPXCHGW instruction to the active function.

func (*Context) COMISD ¶

func (c *Context) COMISD(mx, x operand.Op)

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

Forms:

COMISD xmm xmm
COMISD m64 xmm

Construct and append a COMISD instruction to the active function.

func (*Context) COMISS ¶

func (c *Context) COMISS(mx, x operand.Op)

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

Forms:

COMISS xmm xmm
COMISS m32 xmm

Construct and append a COMISS instruction to the active function.

func (*Context) CPUID ¶

func (c *Context) CPUID()

CPUID: CPU Identification.

Forms:

CPUID

Construct and append a CPUID instruction to the active function.

func (*Context) CQO ¶

func (c *Context) CQO()

CQO: Convert Quadword to Octaword.

Forms:

CQO

Construct and append a CQO instruction to the active function.

func (*Context) CRC32B ¶

func (c *Context) CRC32B(mr, r operand.Op)

CRC32B: Accumulate CRC32 Value.

Forms:

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

Construct and append a CRC32B instruction to the active function.

func (*Context) CRC32L ¶

func (c *Context) CRC32L(mr, r operand.Op)

CRC32L: Accumulate CRC32 Value.

Forms:

CRC32L r32 r32
CRC32L m32 r32

Construct and append a CRC32L instruction to the active function.

func (*Context) CRC32Q ¶

func (c *Context) CRC32Q(mr, r operand.Op)

CRC32Q: Accumulate CRC32 Value.

Forms:

CRC32Q r64 r64
CRC32Q m64 r64

Construct and append a CRC32Q instruction to the active function.

func (*Context) CRC32W ¶

func (c *Context) CRC32W(mr, r operand.Op)

CRC32W: Accumulate CRC32 Value.

Forms:

CRC32W r16 r32
CRC32W m16 r32

Construct and append a CRC32W instruction to the active function.

func (*Context) CVTPD2PL ¶

func (c *Context) CVTPD2PL(mx, x operand.Op)

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

Forms:

CVTPD2PL xmm  xmm
CVTPD2PL m128 xmm

Construct and append a CVTPD2PL instruction to the active function.

func (*Context) CVTPD2PS ¶

func (c *Context) CVTPD2PS(mx, x operand.Op)

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

Forms:

CVTPD2PS xmm  xmm
CVTPD2PS m128 xmm

Construct and append a CVTPD2PS instruction to the active function.

func (*Context) CVTPL2PD ¶

func (c *Context) CVTPL2PD(mx, x operand.Op)

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

Forms:

CVTPL2PD xmm xmm
CVTPL2PD m64 xmm

Construct and append a CVTPL2PD instruction to the active function.

func (*Context) CVTPL2PS ¶

func (c *Context) CVTPL2PS(mx, x operand.Op)

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

Forms:

CVTPL2PS xmm  xmm
CVTPL2PS m128 xmm

Construct and append a CVTPL2PS instruction to the active function.

func (*Context) CVTPS2PD ¶

func (c *Context) CVTPS2PD(mx, x operand.Op)

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

Forms:

CVTPS2PD xmm xmm
CVTPS2PD m64 xmm

Construct and append a CVTPS2PD instruction to the active function.

func (*Context) CVTPS2PL ¶

func (c *Context) CVTPS2PL(mx, x operand.Op)

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

Forms:

CVTPS2PL xmm  xmm
CVTPS2PL m128 xmm

Construct and append a CVTPS2PL instruction to the active function.

func (*Context) CVTSD2SL ¶

func (c *Context) CVTSD2SL(mx, r operand.Op)

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

Forms:

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

Construct and append a CVTSD2SL instruction to the active function.

func (*Context) CVTSD2SS ¶

func (c *Context) CVTSD2SS(mx, x operand.Op)

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

Forms:

CVTSD2SS xmm xmm
CVTSD2SS m64 xmm

Construct and append a CVTSD2SS instruction to the active function.

func (*Context) CVTSL2SD ¶

func (c *Context) CVTSL2SD(mr, x operand.Op)

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

Forms:

CVTSL2SD r32 xmm
CVTSL2SD m32 xmm

Construct and append a CVTSL2SD instruction to the active function.

func (*Context) CVTSL2SS ¶

func (c *Context) CVTSL2SS(mr, x operand.Op)

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

Forms:

CVTSL2SS r32 xmm
CVTSL2SS m32 xmm

Construct and append a CVTSL2SS instruction to the active function.

func (*Context) CVTSQ2SD ¶

func (c *Context) CVTSQ2SD(mr, x operand.Op)

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

Forms:

CVTSQ2SD r64 xmm
CVTSQ2SD m64 xmm

Construct and append a CVTSQ2SD instruction to the active function.

func (*Context) CVTSQ2SS ¶

func (c *Context) CVTSQ2SS(mr, x operand.Op)

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

Forms:

CVTSQ2SS r64 xmm
CVTSQ2SS m64 xmm

Construct and append a CVTSQ2SS instruction to the active function.

func (*Context) CVTSS2SD ¶

func (c *Context) CVTSS2SD(mx, x operand.Op)

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

Forms:

CVTSS2SD xmm xmm
CVTSS2SD m32 xmm

Construct and append a CVTSS2SD instruction to the active function.

func (*Context) CVTSS2SL ¶

func (c *Context) CVTSS2SL(mx, r operand.Op)

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

Forms:

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

Construct and append a CVTSS2SL instruction to the active function.

func (*Context) CVTTPD2PL ¶

func (c *Context) CVTTPD2PL(mx, x operand.Op)

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

Forms:

CVTTPD2PL xmm  xmm
CVTTPD2PL m128 xmm

Construct and append a CVTTPD2PL instruction to the active function.

func (*Context) CVTTPS2PL ¶

func (c *Context) CVTTPS2PL(mx, x operand.Op)

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

Forms:

CVTTPS2PL xmm  xmm
CVTTPS2PL m128 xmm

Construct and append a CVTTPS2PL instruction to the active function.

func (*Context) CVTTSD2SL ¶

func (c *Context) CVTTSD2SL(mx, r operand.Op)

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

Forms:

CVTTSD2SL xmm r32
CVTTSD2SL m64 r32

Construct and append a CVTTSD2SL instruction to the active function.

func (*Context) CVTTSD2SQ ¶

func (c *Context) CVTTSD2SQ(mx, r operand.Op)

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

Forms:

CVTTSD2SQ xmm r64
CVTTSD2SQ m64 r64

Construct and append a CVTTSD2SQ instruction to the active function.

func (*Context) CVTTSS2SL ¶

func (c *Context) CVTTSS2SL(mx, r operand.Op)

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

Construct and append a CVTTSS2SL instruction to the active function.

func (*Context) CWD ¶

func (c *Context) CWD()

CWD: Convert Word to Doubleword.

Forms:

CWD

Construct and append a CWD instruction to the active function.

func (*Context) CWDE ¶

func (c *Context) CWDE()

CWDE: Convert Word to Doubleword.

Forms:

CWDE

Construct and append a CWDE instruction to the active function.

func (*Context) Comment ¶

func (c *Context) Comment(lines ...string)

Comment adds comment lines to the active function.

func (*Context) Commentf ¶

func (c *Context) Commentf(format string, a ...interface{})

Commentf adds a formtted comment line.

func (*Context) ConstData ¶

func (c *Context) ConstData(name string, v operand.Constant) operand.Mem

ConstData builds a static data section containing just the given constant.

func (*Context) Constraint ¶

func (c *Context) Constraint(t buildtags.ConstraintConvertable)

Constraint appends a constraint to the file's build constraints.

func (*Context) ConstraintExpr ¶

func (c *Context) ConstraintExpr(expr string)

func (*Context) Constraints ¶

func (c *Context) Constraints(t buildtags.ConstraintsConvertable)

Constraints sets build constraints for the file.

func (*Context) DECB ¶

func (c *Context) DECB(mr operand.Op)

DECB: Decrement by 1.

Forms:

DECB r8
DECB m8

Construct and append a DECB instruction to the active function.

func (*Context) DECL ¶

func (c *Context) DECL(mr operand.Op)

DECL: Decrement by 1.

Forms:

DECL r32
DECL m32

Construct and append a DECL instruction to the active function.

func (*Context) DECQ ¶

func (c *Context) DECQ(mr operand.Op)

DECQ: Decrement by 1.

Forms:

DECQ r64
DECQ m64

Construct and append a DECQ instruction to the active function.

func (*Context) DECW ¶

func (c *Context) DECW(mr operand.Op)

DECW: Decrement by 1.

Forms:

DECW r16
DECW m16

Construct and append a DECW instruction to the active function.

func (*Context) DIVB ¶

func (c *Context) DIVB(mr operand.Op)

DIVB: Unsigned Divide.

Forms:

DIVB r8
DIVB m8

Construct and append a DIVB instruction to the active function.

func (*Context) DIVL ¶

func (c *Context) DIVL(mr operand.Op)

DIVL: Unsigned Divide.

Forms:

DIVL r32
DIVL m32

Construct and append a DIVL instruction to the active function.

func (*Context) DIVPD ¶

func (c *Context) DIVPD(mx, x operand.Op)

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

Forms:

DIVPD xmm  xmm
DIVPD m128 xmm

Construct and append a DIVPD instruction to the active function.

func (*Context) DIVPS ¶

func (c *Context) DIVPS(mx, x operand.Op)

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

Forms:

DIVPS xmm  xmm
DIVPS m128 xmm

Construct and append a DIVPS instruction to the active function.

func (*Context) DIVQ ¶

func (c *Context) DIVQ(mr operand.Op)

DIVQ: Unsigned Divide.

Forms:

DIVQ r64
DIVQ m64

Construct and append a DIVQ instruction to the active function.

func (*Context) DIVSD ¶

func (c *Context) DIVSD(mx, x operand.Op)

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

Forms:

DIVSD xmm xmm
DIVSD m64 xmm

Construct and append a DIVSD instruction to the active function.

func (*Context) DIVSS ¶

func (c *Context) DIVSS(mx, x operand.Op)

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

Forms:

DIVSS xmm xmm
DIVSS m32 xmm

Construct and append a DIVSS instruction to the active function.

func (*Context) DIVW ¶

func (c *Context) DIVW(mr operand.Op)

DIVW: Unsigned Divide.

Forms:

DIVW r16
DIVW m16

Construct and append a DIVW instruction to the active function.

func (*Context) DPPD ¶

func (c *Context) DPPD(i, mx, x operand.Op)

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

Forms:

DPPD imm8 xmm  xmm
DPPD imm8 m128 xmm

Construct and append a DPPD instruction to the active function.

func (*Context) DPPS ¶

func (c *Context) DPPS(i, mx, x operand.Op)

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

Forms:

DPPS imm8 xmm  xmm
DPPS imm8 m128 xmm

Construct and append a DPPS instruction to the active function.

func (*Context) DataAttributes ¶

func (c *Context) DataAttributes(a attr.Attribute)

DataAttributes sets the attributes on the current active global data section.

func (*Context) Dereference ¶

func (c *Context) Dereference(ptr gotypes.Component) gotypes.Component

Dereference loads a pointer and returns its element type.

func (*Context) Doc ¶

func (c *Context) Doc(lines ...string)

Doc sets documentation comment lines for the currently active function.

func (*Context) EXTRACTPS ¶

func (c *Context) EXTRACTPS(i, x, mr operand.Op)

EXTRACTPS: Extract Packed Single Precision Floating-Point Value.

Forms:

EXTRACTPS imm2u xmm r32
EXTRACTPS imm2u xmm m32

Construct and append a EXTRACTPS instruction to the active function.

func (*Context) Function ¶

func (c *Context) Function(name string)

Function starts building a new function with the given name.

func (*Context) HADDPD ¶

func (c *Context) HADDPD(mx, x operand.Op)

HADDPD: Packed Double-FP Horizontal Add.

Forms:

HADDPD xmm  xmm
HADDPD m128 xmm

Construct and append a HADDPD instruction to the active function.

func (*Context) HADDPS ¶

func (c *Context) HADDPS(mx, x operand.Op)

HADDPS: Packed Single-FP Horizontal Add.

Forms:

HADDPS xmm  xmm
HADDPS m128 xmm

Construct and append a HADDPS instruction to the active function.

func (*Context) HSUBPD ¶

func (c *Context) HSUBPD(mx, x operand.Op)

HSUBPD: Packed Double-FP Horizontal Subtract.

Forms:

HSUBPD xmm  xmm
HSUBPD m128 xmm

Construct and append a HSUBPD instruction to the active function.

func (*Context) HSUBPS ¶

func (c *Context) HSUBPS(mx, x operand.Op)

HSUBPS: Packed Single-FP Horizontal Subtract.

Forms:

HSUBPS xmm  xmm
HSUBPS m128 xmm

Construct and append a HSUBPS instruction to the active function.

func (*Context) IDIVB ¶

func (c *Context) IDIVB(mr operand.Op)

IDIVB: Signed Divide.

Forms:

IDIVB r8
IDIVB m8

Construct and append a IDIVB instruction to the active function.

func (*Context) IDIVL ¶

func (c *Context) IDIVL(mr operand.Op)

IDIVL: Signed Divide.

Forms:

IDIVL r32
IDIVL m32

Construct and append a IDIVL instruction to the active function.

func (*Context) IDIVQ ¶

func (c *Context) IDIVQ(mr operand.Op)

IDIVQ: Signed Divide.

Forms:

IDIVQ r64
IDIVQ m64

Construct and append a IDIVQ instruction to the active function.

func (*Context) IDIVW ¶

func (c *Context) IDIVW(mr operand.Op)

IDIVW: Signed Divide.

Forms:

IDIVW r16
IDIVW m16

Construct and append a IDIVW instruction to the active function.

func (*Context) IMUL3L ¶

func (c *Context) IMUL3L(i, mr, r operand.Op)

IMUL3L: Signed Multiply.

Forms:

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

Construct and append a IMUL3L instruction to the active function.

func (*Context) IMUL3Q ¶

func (c *Context) IMUL3Q(i, mr, r operand.Op)

IMUL3Q: Signed Multiply.

Forms:

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

Construct and append a IMUL3Q instruction to the active function.

func (*Context) IMUL3W ¶

func (c *Context) IMUL3W(i, mr, r operand.Op)

IMUL3W: Signed Multiply.

Forms:

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

Construct and append a IMUL3W instruction to the active function.

func (*Context) IMULB ¶

func (c *Context) IMULB(mr operand.Op)

IMULB: Signed Multiply.

Forms:

IMULB r8
IMULB m8

Construct and append a IMULB instruction to the active function.

func (*Context) IMULL ¶

func (c *Context) IMULL(ops ...operand.Op)

IMULL: Signed Multiply.

Forms:

IMULL r32
IMULL m32
IMULL r32 r32
IMULL m32 r32

Construct and append a IMULL instruction to the active function.

func (*Context) IMULQ ¶

func (c *Context) IMULQ(ops ...operand.Op)

IMULQ: Signed Multiply.

Forms:

IMULQ r64
IMULQ m64
IMULQ r64 r64
IMULQ m64 r64

Construct and append a IMULQ instruction to the active function.

func (*Context) IMULW ¶

func (c *Context) IMULW(ops ...operand.Op)

IMULW: Signed Multiply.

Forms:

IMULW r16
IMULW m16
IMULW r16 r16
IMULW m16 r16

Construct and append a IMULW instruction to the active function.

func (*Context) INCB ¶

func (c *Context) INCB(mr operand.Op)

INCB: Increment by 1.

Forms:

INCB r8
INCB m8

Construct and append a INCB instruction to the active function.

func (*Context) INCL ¶

func (c *Context) INCL(mr operand.Op)

INCL: Increment by 1.

Forms:

INCL r32
INCL m32

Construct and append a INCL instruction to the active function.

func (*Context) INCQ ¶

func (c *Context) INCQ(mr operand.Op)

INCQ: Increment by 1.

Forms:

INCQ r64
INCQ m64

Construct and append a INCQ instruction to the active function.

func (*Context) INCW ¶

func (c *Context) INCW(mr operand.Op)

INCW: Increment by 1.

Forms:

INCW r16
INCW m16

Construct and append a INCW instruction to the active function.

func (*Context) INSERTPS ¶

func (c *Context) INSERTPS(i, mx, x operand.Op)

INSERTPS: Insert Packed Single Precision Floating-Point Value.

Forms:

INSERTPS imm8 xmm xmm
INSERTPS imm8 m32 xmm

Construct and append a INSERTPS instruction to the active function.

func (*Context) INT ¶

func (c *Context) INT(i operand.Op)

INT: Call to Interrupt Procedure.

Forms:

INT 3
INT imm8

Construct and append a INT instruction to the active function.

func (*Context) Implement ¶

func (c *Context) Implement(name string)

Implement starts building a function of the given name, whose type is specified by a stub in the containing package.

func (*Context) Instruction ¶

func (c *Context) Instruction(i *ir.Instruction)

Instruction adds an instruction to the active function.

func (*Context) JA ¶

func (c *Context) JA(r operand.Op)

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

Forms:

JA rel8
JA rel32

Construct and append a JA instruction to the active function.

func (*Context) JAE ¶

func (c *Context) JAE(r operand.Op)

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

Forms:

JAE rel8
JAE rel32

Construct and append a JAE instruction to the active function.

func (*Context) JB ¶

func (c *Context) JB(r operand.Op)

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

Forms:

JB rel8
JB rel32

Construct and append a JB instruction to the active function.

func (*Context) JBE ¶

func (c *Context) JBE(r operand.Op)

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

Forms:

JBE rel8
JBE rel32

Construct and append a JBE instruction to the active function.

func (*Context) JC ¶

func (c *Context) JC(r operand.Op)

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

Forms:

JC rel8
JC rel32

Construct and append a JC instruction to the active function.

func (*Context) JCC ¶

func (c *Context) JCC(r operand.Op)

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

Forms:

JCC rel8
JCC rel32

Construct and append a JCC instruction to the active function.

func (*Context) JCS ¶

func (c *Context) JCS(r operand.Op)

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

Forms:

JCS rel8
JCS rel32

Construct and append a JCS instruction to the active function.

func (*Context) JCXZL ¶

func (c *Context) JCXZL(r operand.Op)

JCXZL: Jump if ECX register is 0.

Forms:

JCXZL rel8

Construct and append a JCXZL instruction to the active function.

func (*Context) JCXZQ ¶

func (c *Context) JCXZQ(r operand.Op)

JCXZQ: Jump if RCX register is 0.

Forms:

JCXZQ rel8

Construct and append a JCXZQ instruction to the active function.

func (*Context) JE ¶

func (c *Context) JE(r operand.Op)

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

Forms:

JE rel8
JE rel32

Construct and append a JE instruction to the active function.

func (*Context) JEQ ¶

func (c *Context) JEQ(r operand.Op)

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

Forms:

JEQ rel8
JEQ rel32

Construct and append a JEQ instruction to the active function.

func (*Context) JG ¶

func (c *Context) JG(r operand.Op)

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

Forms:

JG rel8
JG rel32

Construct and append a JG instruction to the active function.

func (*Context) JGE ¶

func (c *Context) JGE(r operand.Op)

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

Forms:

JGE rel8
JGE rel32

Construct and append a JGE instruction to the active function.

func (*Context) JGT ¶

func (c *Context) JGT(r operand.Op)

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

Forms:

JGT rel8
JGT rel32

Construct and append a JGT instruction to the active function.

func (*Context) JHI ¶

func (c *Context) JHI(r operand.Op)

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

Forms:

JHI rel8
JHI rel32

Construct and append a JHI instruction to the active function.

func (*Context) JHS ¶

func (c *Context) JHS(r operand.Op)

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

Forms:

JHS rel8
JHS rel32

Construct and append a JHS instruction to the active function.

func (*Context) JL ¶

func (c *Context) JL(r operand.Op)

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

Forms:

JL rel8
JL rel32

Construct and append a JL instruction to the active function.

func (*Context) JLE ¶

func (c *Context) JLE(r operand.Op)

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

Forms:

JLE rel8
JLE rel32

Construct and append a JLE instruction to the active function.

func (*Context) JLO ¶

func (c *Context) JLO(r operand.Op)

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

Forms:

JLO rel8
JLO rel32

Construct and append a JLO instruction to the active function.

func (*Context) JLS ¶

func (c *Context) JLS(r operand.Op)

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

Forms:

JLS rel8
JLS rel32

Construct and append a JLS instruction to the active function.

func (*Context) JLT ¶

func (c *Context) JLT(r operand.Op)

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

Forms:

JLT rel8
JLT rel32

Construct and append a JLT instruction to the active function.

func (*Context) JMI ¶

func (c *Context) JMI(r operand.Op)

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

Forms:

JMI rel8
JMI rel32

Construct and append a JMI instruction to the active function.

func (*Context) JMP ¶

func (c *Context) JMP(mr operand.Op)

JMP: Jump Unconditionally.

Forms:

JMP rel8
JMP rel32
JMP r64
JMP m64

Construct and append a JMP instruction to the active function.

func (*Context) JNA ¶

func (c *Context) JNA(r operand.Op)

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

Forms:

JNA rel8
JNA rel32

Construct and append a JNA instruction to the active function.

func (*Context) JNAE ¶

func (c *Context) JNAE(r operand.Op)

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

Forms:

JNAE rel8
JNAE rel32

Construct and append a JNAE instruction to the active function.

func (*Context) JNB ¶

func (c *Context) JNB(r operand.Op)

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

Forms:

JNB rel8
JNB rel32

Construct and append a JNB instruction to the active function.

func (*Context) JNBE ¶

func (c *Context) JNBE(r operand.Op)

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

Forms:

JNBE rel8
JNBE rel32

Construct and append a JNBE instruction to the active function.

func (*Context) JNC ¶

func (c *Context) JNC(r operand.Op)

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

Forms:

JNC rel8
JNC rel32

Construct and append a JNC instruction to the active function.

func (*Context) JNE ¶

func (c *Context) JNE(r operand.Op)

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

Forms:

JNE rel8
JNE rel32

Construct and append a JNE instruction to the active function.

func (*Context) JNG ¶

func (c *Context) JNG(r operand.Op)

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

Forms:

JNG rel8
JNG rel32

Construct and append a JNG instruction to the active function.

func (*Context) JNGE ¶

func (c *Context) JNGE(r operand.Op)

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

Forms:

JNGE rel8
JNGE rel32

Construct and append a JNGE instruction to the active function.

func (*Context) JNL ¶

func (c *Context) JNL(r operand.Op)

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

Forms:

JNL rel8
JNL rel32

Construct and append a JNL instruction to the active function.

func (*Context) JNLE ¶

func (c *Context) JNLE(r operand.Op)

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

Forms:

JNLE rel8
JNLE rel32

Construct and append a JNLE instruction to the active function.

func (*Context) JNO ¶

func (c *Context) JNO(r operand.Op)

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

Forms:

JNO rel8
JNO rel32

Construct and append a JNO instruction to the active function.

func (*Context) JNP ¶

func (c *Context) JNP(r operand.Op)

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

Forms:

JNP rel8
JNP rel32

Construct and append a JNP instruction to the active function.

func (*Context) JNS ¶

func (c *Context) JNS(r operand.Op)

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

Forms:

JNS rel8
JNS rel32

Construct and append a JNS instruction to the active function.

func (*Context) JNZ ¶

func (c *Context) JNZ(r operand.Op)

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

Forms:

JNZ rel8
JNZ rel32

Construct and append a JNZ instruction to the active function.

func (*Context) JO ¶

func (c *Context) JO(r operand.Op)

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

Forms:

JO rel8
JO rel32

Construct and append a JO instruction to the active function.

func (*Context) JOC ¶

func (c *Context) JOC(r operand.Op)

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

Forms:

JOC rel8
JOC rel32

Construct and append a JOC instruction to the active function.

func (*Context) JOS ¶

func (c *Context) JOS(r operand.Op)

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

Forms:

JOS rel8
JOS rel32

Construct and append a JOS instruction to the active function.

func (*Context) JP ¶

func (c *Context) JP(r operand.Op)

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

Forms:

JP rel8
JP rel32

Construct and append a JP instruction to the active function.

func (*Context) JPC ¶

func (c *Context) JPC(r operand.Op)

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

Forms:

JPC rel8
JPC rel32

Construct and append a JPC instruction to the active function.

func (*Context) JPE ¶

func (c *Context) JPE(r operand.Op)

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

Forms:

JPE rel8
JPE rel32

Construct and append a JPE instruction to the active function.

func (*Context) JPL ¶

func (c *Context) JPL(r operand.Op)

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

Forms:

JPL rel8
JPL rel32

Construct and append a JPL instruction to the active function.

func (*Context) JPO ¶

func (c *Context) JPO(r operand.Op)

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

Forms:

JPO rel8
JPO rel32

Construct and append a JPO instruction to the active function.

func (*Context) JPS ¶

func (c *Context) JPS(r operand.Op)

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

Forms:

JPS rel8
JPS rel32

Construct and append a JPS instruction to the active function.

func (*Context) JS ¶

func (c *Context) JS(r operand.Op)

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

Forms:

JS rel8
JS rel32

Construct and append a JS instruction to the active function.

func (*Context) JZ ¶

func (c *Context) JZ(r operand.Op)

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

Forms:

JZ rel8
JZ rel32

Construct and append a JZ instruction to the active function.

func (*Context) LDDQU ¶

func (c *Context) LDDQU(m, x operand.Op)

LDDQU: Load Unaligned Integer 128 Bits.

Forms:

LDDQU m128 xmm

Construct and append a LDDQU instruction to the active function.

func (*Context) LDMXCSR ¶

func (c *Context) LDMXCSR(m operand.Op)

LDMXCSR: Load MXCSR Register.

Forms:

LDMXCSR m32

Construct and append a LDMXCSR instruction to the active function.

func (*Context) LEAL ¶

func (c *Context) LEAL(m, r operand.Op)

LEAL: Load Effective Address.

Forms:

LEAL m r32

Construct and append a LEAL instruction to the active function.

func (*Context) LEAQ ¶

func (c *Context) LEAQ(m, r operand.Op)

LEAQ: Load Effective Address.

Forms:

LEAQ m r64

Construct and append a LEAQ instruction to the active function.

func (*Context) LEAW ¶

func (c *Context) LEAW(m, r operand.Op)

LEAW: Load Effective Address.

Forms:

LEAW m r16

Construct and append a LEAW instruction to the active function.

func (*Context) LFENCE ¶

func (c *Context) LFENCE()

LFENCE: Load Fence.

Forms:

LFENCE

Construct and append a LFENCE instruction to the active function.

func (*Context) LZCNTL ¶

func (c *Context) LZCNTL(mr, r operand.Op)

LZCNTL: Count the Number of Leading Zero Bits.

Forms:

LZCNTL r32 r32
LZCNTL m32 r32

Construct and append a LZCNTL instruction to the active function.

func (*Context) LZCNTQ ¶

func (c *Context) LZCNTQ(mr, r operand.Op)

LZCNTQ: Count the Number of Leading Zero Bits.

Forms:

LZCNTQ r64 r64
LZCNTQ m64 r64

Construct and append a LZCNTQ instruction to the active function.

func (*Context) LZCNTW ¶

func (c *Context) LZCNTW(mr, r operand.Op)

LZCNTW: Count the Number of Leading Zero Bits.

Forms:

LZCNTW r16 r16
LZCNTW m16 r16

Construct and append a LZCNTW instruction to the active function.

func (*Context) Label ¶

func (c *Context) Label(name string)

Label adds a label to the active function.

func (*Context) Load ¶

func (c *Context) Load(src gotypes.Component, dst reg.Register) reg.Register

Load the function argument src into register dst. Returns the destination register. This is syntactic sugar: it will attempt to select the right MOV instruction based on the types involved.

func (*Context) MASKMOVDQU ¶

func (c *Context) MASKMOVDQU(x, x1 operand.Op)

MASKMOVDQU: Store Selected Bytes of Double Quadword.

Forms:

MASKMOVDQU xmm xmm

Construct and append a MASKMOVDQU instruction to the active function.

func (*Context) MASKMOVOU ¶

func (c *Context) MASKMOVOU(x, x1 operand.Op)

MASKMOVOU: Store Selected Bytes of Double Quadword.

Forms:

MASKMOVOU xmm xmm

Construct and append a MASKMOVOU instruction to the active function.

func (*Context) MAXPD ¶

func (c *Context) MAXPD(mx, x operand.Op)

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

Forms:

MAXPD xmm  xmm
MAXPD m128 xmm

Construct and append a MAXPD instruction to the active function.

func (*Context) MAXPS ¶

func (c *Context) MAXPS(mx, x operand.Op)

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

Forms:

MAXPS xmm  xmm
MAXPS m128 xmm

Construct and append a MAXPS instruction to the active function.

func (*Context) MAXSD ¶

func (c *Context) MAXSD(mx, x operand.Op)

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

Forms:

MAXSD xmm xmm
MAXSD m64 xmm

Construct and append a MAXSD instruction to the active function.

func (*Context) MAXSS ¶

func (c *Context) MAXSS(mx, x operand.Op)

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

Forms:

MAXSS xmm xmm
MAXSS m32 xmm

Construct and append a MAXSS instruction to the active function.

func (*Context) MFENCE ¶

func (c *Context) MFENCE()

MFENCE: Memory Fence.

Forms:

MFENCE

Construct and append a MFENCE instruction to the active function.

func (*Context) MINPD ¶

func (c *Context) MINPD(mx, x operand.Op)

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

Forms:

MINPD xmm  xmm
MINPD m128 xmm

Construct and append a MINPD instruction to the active function.

func (*Context) MINPS ¶

func (c *Context) MINPS(mx, x operand.Op)

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

Forms:

MINPS xmm  xmm
MINPS m128 xmm

Construct and append a MINPS instruction to the active function.

func (*Context) MINSD ¶

func (c *Context) MINSD(mx, x operand.Op)

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

Forms:

MINSD xmm xmm
MINSD m64 xmm

Construct and append a MINSD instruction to the active function.

func (*Context) MINSS ¶

func (c *Context) MINSS(mx, x operand.Op)

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

Forms:

MINSS xmm xmm
MINSS m32 xmm

Construct and append a MINSS instruction to the active function.

func (*Context) MONITOR ¶

func (c *Context) MONITOR()

MONITOR: Monitor a Linear Address Range.

Forms:

MONITOR

Construct and append a MONITOR instruction to the active function.

func (*Context) MOVAPD ¶

func (c *Context) MOVAPD(mx, mx1 operand.Op)

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

Forms:

MOVAPD xmm  xmm
MOVAPD m128 xmm
MOVAPD xmm  m128

Construct and append a MOVAPD instruction to the active function.

func (*Context) MOVAPS ¶

func (c *Context) MOVAPS(mx, mx1 operand.Op)

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

Forms:

MOVAPS xmm  xmm
MOVAPS m128 xmm
MOVAPS xmm  m128

Construct and append a MOVAPS instruction to the active function.

func (*Context) MOVB ¶

func (c *Context) MOVB(imr, mr operand.Op)

MOVB: Move.

Forms:

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

Construct and append a MOVB instruction to the active function.

func (*Context) MOVBELL ¶

func (c *Context) MOVBELL(mr, mr1 operand.Op)

MOVBELL: Move Data After Swapping Bytes.

Forms:

MOVBELL m32 r32
MOVBELL r32 m32

Construct and append a MOVBELL instruction to the active function.

func (*Context) MOVBEQQ ¶

func (c *Context) MOVBEQQ(mr, mr1 operand.Op)

MOVBEQQ: Move Data After Swapping Bytes.

Forms:

MOVBEQQ m64 r64
MOVBEQQ r64 m64

Construct and append a MOVBEQQ instruction to the active function.

func (*Context) MOVBEWW ¶

func (c *Context) MOVBEWW(mr, mr1 operand.Op)

MOVBEWW: Move Data After Swapping Bytes.

Forms:

MOVBEWW m16 r16
MOVBEWW r16 m16

Construct and append a MOVBEWW instruction to the active function.

func (*Context) MOVBLSX ¶

func (c *Context) MOVBLSX(mr, r operand.Op)

MOVBLSX: Move with Sign-Extension.

Forms:

MOVBLSX r8 r32
MOVBLSX m8 r32

Construct and append a MOVBLSX instruction to the active function.

func (*Context) MOVBLZX ¶

func (c *Context) MOVBLZX(mr, r operand.Op)

MOVBLZX: Move with Zero-Extend.

Forms:

MOVBLZX r8 r32
MOVBLZX m8 r32

Construct and append a MOVBLZX instruction to the active function.

func (*Context) MOVBQSX ¶

func (c *Context) MOVBQSX(mr, r operand.Op)

MOVBQSX: Move with Sign-Extension.

Forms:

MOVBQSX r8 r64
MOVBQSX m8 r64

Construct and append a MOVBQSX instruction to the active function.

func (*Context) MOVBQZX ¶

func (c *Context) MOVBQZX(mr, r operand.Op)

MOVBQZX: Move with Zero-Extend.

Forms:

MOVBQZX r8 r64
MOVBQZX m8 r64

Construct and append a MOVBQZX instruction to the active function.

func (*Context) MOVBWSX ¶

func (c *Context) MOVBWSX(mr, r operand.Op)

MOVBWSX: Move with Sign-Extension.

Forms:

MOVBWSX r8 r16
MOVBWSX m8 r16

Construct and append a MOVBWSX instruction to the active function.

func (*Context) MOVBWZX ¶

func (c *Context) MOVBWZX(mr, r operand.Op)

MOVBWZX: Move with Zero-Extend.

Forms:

MOVBWZX r8 r16
MOVBWZX m8 r16

Construct and append a MOVBWZX instruction to the active function.

func (*Context) MOVD ¶

func (c *Context) MOVD(imrx, mrx operand.Op)

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

Construct and append a MOVD instruction to the active function.

func (*Context) MOVDDUP ¶

func (c *Context) MOVDDUP(mx, x operand.Op)

MOVDDUP: Move One Double-FP and Duplicate.

Forms:

MOVDDUP xmm xmm
MOVDDUP m64 xmm

Construct and append a MOVDDUP instruction to the active function.

func (*Context) MOVDQ2Q ¶

func (c *Context) MOVDQ2Q(imrx, mrx operand.Op)

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

Construct and append a MOVDQ2Q instruction to the active function.

func (*Context) MOVHLPS ¶

func (c *Context) MOVHLPS(x, x1 operand.Op)

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

Forms:

MOVHLPS xmm xmm

Construct and append a MOVHLPS instruction to the active function.

func (*Context) MOVHPD ¶

func (c *Context) MOVHPD(mx, mx1 operand.Op)

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

Forms:

MOVHPD m64 xmm
MOVHPD xmm m64

Construct and append a MOVHPD instruction to the active function.

func (*Context) MOVHPS ¶

func (c *Context) MOVHPS(mx, mx1 operand.Op)

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

Forms:

MOVHPS m64 xmm
MOVHPS xmm m64

Construct and append a MOVHPS instruction to the active function.

func (*Context) MOVL ¶

func (c *Context) MOVL(imr, mr operand.Op)

MOVL: Move.

Forms:

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

Construct and append a MOVL instruction to the active function.

func (*Context) MOVLHPS ¶

func (c *Context) MOVLHPS(x, x1 operand.Op)

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

Forms:

MOVLHPS xmm xmm

Construct and append a MOVLHPS instruction to the active function.

func (*Context) MOVLPD ¶

func (c *Context) MOVLPD(mx, mx1 operand.Op)

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

Forms:

MOVLPD m64 xmm
MOVLPD xmm m64

Construct and append a MOVLPD instruction to the active function.

func (*Context) MOVLPS ¶

func (c *Context) MOVLPS(mx, mx1 operand.Op)

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

Forms:

MOVLPS m64 xmm
MOVLPS xmm m64

Construct and append a MOVLPS instruction to the active function.

func (*Context) MOVLQSX ¶

func (c *Context) MOVLQSX(mr, r operand.Op)

MOVLQSX: Move Doubleword to Quadword with Sign-Extension.

Forms:

MOVLQSX r32 r64
MOVLQSX m32 r64

Construct and append a MOVLQSX instruction to the active function.

func (*Context) MOVLQZX ¶

func (c *Context) MOVLQZX(m, r operand.Op)

MOVLQZX: Move with Zero-Extend.

Forms:

MOVLQZX m32 r64

Construct and append a MOVLQZX instruction to the active function.

func (*Context) MOVMSKPD ¶

func (c *Context) MOVMSKPD(x, r operand.Op)

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

Forms:

MOVMSKPD xmm r32

Construct and append a MOVMSKPD instruction to the active function.

func (*Context) MOVMSKPS ¶

func (c *Context) MOVMSKPS(x, r operand.Op)

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

Forms:

MOVMSKPS xmm r32

Construct and append a MOVMSKPS instruction to the active function.

func (*Context) MOVNTDQ ¶

func (c *Context) MOVNTDQ(x, m operand.Op)

MOVNTDQ: Store Double Quadword Using Non-Temporal Hint.

Forms:

MOVNTDQ xmm m128

Construct and append a MOVNTDQ instruction to the active function.

func (*Context) MOVNTDQA ¶

func (c *Context) MOVNTDQA(m, x operand.Op)

MOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint.

Forms:

MOVNTDQA m128 xmm

Construct and append a MOVNTDQA instruction to the active function.

func (*Context) MOVNTIL ¶

func (c *Context) MOVNTIL(r, m operand.Op)

MOVNTIL: Store Doubleword Using Non-Temporal Hint.

Forms:

MOVNTIL r32 m32

Construct and append a MOVNTIL instruction to the active function.

func (*Context) MOVNTIQ ¶

func (c *Context) MOVNTIQ(r, m operand.Op)

MOVNTIQ: Store Doubleword Using Non-Temporal Hint.

Forms:

MOVNTIQ r64 m64

Construct and append a MOVNTIQ instruction to the active function.

func (*Context) MOVNTO ¶

func (c *Context) MOVNTO(x, m operand.Op)

MOVNTO: Store Double Quadword Using Non-Temporal Hint.

Forms:

MOVNTO xmm m128

Construct and append a MOVNTO instruction to the active function.

func (*Context) MOVNTPD ¶

func (c *Context) MOVNTPD(x, m operand.Op)

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

Forms:

MOVNTPD xmm m128

Construct and append a MOVNTPD instruction to the active function.

func (*Context) MOVNTPS ¶

func (c *Context) MOVNTPS(x, m operand.Op)

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

Forms:

MOVNTPS xmm m128

Construct and append a MOVNTPS instruction to the active function.

func (*Context) MOVO ¶

func (c *Context) MOVO(mx, mx1 operand.Op)

MOVO: Move Aligned Double Quadword.

Forms:

MOVO xmm  xmm
MOVO m128 xmm
MOVO xmm  m128

Construct and append a MOVO instruction to the active function.

func (*Context) MOVOA ¶

func (c *Context) MOVOA(mx, mx1 operand.Op)

MOVOA: Move Aligned Double Quadword.

Forms:

MOVOA xmm  xmm
MOVOA m128 xmm
MOVOA xmm  m128

Construct and append a MOVOA instruction to the active function.

func (*Context) MOVOU ¶

func (c *Context) MOVOU(mx, mx1 operand.Op)

MOVOU: Move Unaligned Double Quadword.

Forms:

MOVOU xmm  xmm
MOVOU m128 xmm
MOVOU xmm  m128

Construct and append a MOVOU instruction to the active function.

func (*Context) MOVQ ¶

func (c *Context) MOVQ(imrx, mrx operand.Op)

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

Construct and append a MOVQ instruction to the active function.

func (*Context) MOVSD ¶

func (c *Context) MOVSD(mx, mx1 operand.Op)

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

Forms:

MOVSD xmm xmm
MOVSD m64 xmm
MOVSD xmm m64

Construct and append a MOVSD instruction to the active function.

func (*Context) MOVSHDUP ¶

func (c *Context) MOVSHDUP(mx, x operand.Op)

MOVSHDUP: Move Packed Single-FP High and Duplicate.

Forms:

MOVSHDUP xmm  xmm
MOVSHDUP m128 xmm

Construct and append a MOVSHDUP instruction to the active function.

func (*Context) MOVSLDUP ¶

func (c *Context) MOVSLDUP(mx, x operand.Op)

MOVSLDUP: Move Packed Single-FP Low and Duplicate.

Forms:

MOVSLDUP xmm  xmm
MOVSLDUP m128 xmm

Construct and append a MOVSLDUP instruction to the active function.

func (*Context) MOVSS ¶

func (c *Context) MOVSS(mx, mx1 operand.Op)

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

Forms:

MOVSS xmm xmm
MOVSS m32 xmm
MOVSS xmm m32

Construct and append a MOVSS instruction to the active function.

func (*Context) MOVUPD ¶

func (c *Context) MOVUPD(mx, mx1 operand.Op)

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

Forms:

MOVUPD xmm  xmm
MOVUPD m128 xmm
MOVUPD xmm  m128

Construct and append a MOVUPD instruction to the active function.

func (*Context) MOVUPS ¶

func (c *Context) MOVUPS(mx, mx1 operand.Op)

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

Forms:

MOVUPS xmm  xmm
MOVUPS m128 xmm
MOVUPS xmm  m128

Construct and append a MOVUPS instruction to the active function.

func (*Context) MOVW ¶

func (c *Context) MOVW(imr, mr operand.Op)

MOVW: Move.

Forms:

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

Construct and append a MOVW instruction to the active function.

func (*Context) MOVWLSX ¶

func (c *Context) MOVWLSX(mr, r operand.Op)

MOVWLSX: Move with Sign-Extension.

Forms:

MOVWLSX r16 r32
MOVWLSX m16 r32

Construct and append a MOVWLSX instruction to the active function.

func (*Context) MOVWLZX ¶

func (c *Context) MOVWLZX(mr, r operand.Op)

MOVWLZX: Move with Zero-Extend.

Forms:

MOVWLZX r16 r32
MOVWLZX m16 r32

Construct and append a MOVWLZX instruction to the active function.

func (*Context) MOVWQSX ¶

func (c *Context) MOVWQSX(mr, r operand.Op)

MOVWQSX: Move with Sign-Extension.

Forms:

MOVWQSX r16 r64
MOVWQSX m16 r64

Construct and append a MOVWQSX instruction to the active function.

func (*Context) MOVWQZX ¶

func (c *Context) MOVWQZX(mr, r operand.Op)

MOVWQZX: Move with Zero-Extend.

Forms:

MOVWQZX r16 r64
MOVWQZX m16 r64

Construct and append a MOVWQZX instruction to the active function.

func (*Context) MPSADBW ¶

func (c *Context) MPSADBW(i, mx, x operand.Op)

MPSADBW: Compute Multiple Packed Sums of Absolute Difference.

Forms:

MPSADBW imm8 xmm  xmm
MPSADBW imm8 m128 xmm

Construct and append a MPSADBW instruction to the active function.

func (*Context) MULB ¶

func (c *Context) MULB(mr operand.Op)

MULB: Unsigned Multiply.

Forms:

MULB r8
MULB m8

Construct and append a MULB instruction to the active function.

func (*Context) MULL ¶

func (c *Context) MULL(mr operand.Op)

MULL: Unsigned Multiply.

Forms:

MULL r32
MULL m32

Construct and append a MULL instruction to the active function.

func (*Context) MULPD ¶

func (c *Context) MULPD(mx, x operand.Op)

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

Forms:

MULPD xmm  xmm
MULPD m128 xmm

Construct and append a MULPD instruction to the active function.

func (*Context) MULPS ¶

func (c *Context) MULPS(mx, x operand.Op)

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

Forms:

MULPS xmm  xmm
MULPS m128 xmm

Construct and append a MULPS instruction to the active function.

func (*Context) MULQ ¶

func (c *Context) MULQ(mr operand.Op)

MULQ: Unsigned Multiply.

Forms:

MULQ r64
MULQ m64

Construct and append a MULQ instruction to the active function.

func (*Context) MULSD ¶

func (c *Context) MULSD(mx, x operand.Op)

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

Forms:

MULSD xmm xmm
MULSD m64 xmm

Construct and append a MULSD instruction to the active function.

func (*Context) MULSS ¶

func (c *Context) MULSS(mx, x operand.Op)

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

Forms:

MULSS xmm xmm
MULSS m32 xmm

Construct and append a MULSS instruction to the active function.

func (*Context) MULW ¶

func (c *Context) MULW(mr operand.Op)

MULW: Unsigned Multiply.

Forms:

MULW r16
MULW m16

Construct and append a MULW instruction to the active function.

func (*Context) MULXL ¶

func (c *Context) MULXL(mr, r, r1 operand.Op)

MULXL: Unsigned Multiply Without Affecting Flags.

Forms:

MULXL r32 r32 r32
MULXL m32 r32 r32

Construct and append a MULXL instruction to the active function.

func (*Context) MULXQ ¶

func (c *Context) MULXQ(mr, r, r1 operand.Op)

MULXQ: Unsigned Multiply Without Affecting Flags.

Forms:

MULXQ r64 r64 r64
MULXQ m64 r64 r64

Construct and append a MULXQ instruction to the active function.

func (*Context) MWAIT ¶

func (c *Context) MWAIT()

MWAIT: Monitor Wait.

Forms:

MWAIT

Construct and append a MWAIT instruction to the active function.

func (*Context) NEGB ¶

func (c *Context) NEGB(mr operand.Op)

NEGB: Two's Complement Negation.

Forms:

NEGB r8
NEGB m8

Construct and append a NEGB instruction to the active function.

func (*Context) NEGL ¶

func (c *Context) NEGL(mr operand.Op)

NEGL: Two's Complement Negation.

Forms:

NEGL r32
NEGL m32

Construct and append a NEGL instruction to the active function.

func (*Context) NEGQ ¶

func (c *Context) NEGQ(mr operand.Op)

NEGQ: Two's Complement Negation.

Forms:

NEGQ r64
NEGQ m64

Construct and append a NEGQ instruction to the active function.

func (*Context) NEGW ¶

func (c *Context) NEGW(mr operand.Op)

NEGW: Two's Complement Negation.

Forms:

NEGW r16
NEGW m16

Construct and append a NEGW instruction to the active function.

func (*Context) NOP ¶

func (c *Context) NOP()

NOP: No Operation.

Forms:

NOP

Construct and append a NOP instruction to the active function.

func (*Context) NOTB ¶

func (c *Context) NOTB(mr operand.Op)

NOTB: One's Complement Negation.

Forms:

NOTB r8
NOTB m8

Construct and append a NOTB instruction to the active function.

func (*Context) NOTL ¶

func (c *Context) NOTL(mr operand.Op)

NOTL: One's Complement Negation.

Forms:

NOTL r32
NOTL m32

Construct and append a NOTL instruction to the active function.

func (*Context) NOTQ ¶

func (c *Context) NOTQ(mr operand.Op)

NOTQ: One's Complement Negation.

Forms:

NOTQ r64
NOTQ m64

Construct and append a NOTQ instruction to the active function.

func (*Context) NOTW ¶

func (c *Context) NOTW(mr operand.Op)

NOTW: One's Complement Negation.

Forms:

NOTW r16
NOTW m16

Construct and append a NOTW instruction to the active function.

func (*Context) ORB ¶

func (c *Context) ORB(imr, amr operand.Op)

ORB: Logical Inclusive OR.

Forms:

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

Construct and append a ORB instruction to the active function.

func (*Context) ORL ¶

func (c *Context) ORL(imr, emr operand.Op)

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

Construct and append a ORL instruction to the active function.

func (*Context) ORPD ¶

func (c *Context) ORPD(mx, x operand.Op)

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

Forms:

ORPD xmm  xmm
ORPD m128 xmm

Construct and append a ORPD instruction to the active function.

func (*Context) ORPS ¶

func (c *Context) ORPS(mx, x operand.Op)

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

Forms:

ORPS xmm  xmm
ORPS m128 xmm

Construct and append a ORPS instruction to the active function.

func (*Context) ORQ ¶

func (c *Context) ORQ(imr, mr operand.Op)

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

Construct and append a ORQ instruction to the active function.

func (*Context) ORW ¶

func (c *Context) ORW(imr, amr operand.Op)

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

Construct and append a ORW instruction to the active function.

func (*Context) PABSB ¶

func (c *Context) PABSB(mx, x operand.Op)

PABSB: Packed Absolute Value of Byte Integers.

Forms:

PABSB xmm  xmm
PABSB m128 xmm

Construct and append a PABSB instruction to the active function.

func (*Context) PABSD ¶

func (c *Context) PABSD(mx, x operand.Op)

PABSD: Packed Absolute Value of Doubleword Integers.

Forms:

PABSD xmm  xmm
PABSD m128 xmm

Construct and append a PABSD instruction to the active function.

func (*Context) PABSW ¶

func (c *Context) PABSW(mx, x operand.Op)

PABSW: Packed Absolute Value of Word Integers.

Forms:

PABSW xmm  xmm
PABSW m128 xmm

Construct and append a PABSW instruction to the active function.

func (*Context) PACKSSLW ¶

func (c *Context) PACKSSLW(mx, x operand.Op)

PACKSSLW: Pack Doublewords into Words with Signed Saturation.

Forms:

PACKSSLW xmm  xmm
PACKSSLW m128 xmm

Construct and append a PACKSSLW instruction to the active function.

func (*Context) PACKSSWB ¶

func (c *Context) PACKSSWB(mx, x operand.Op)

PACKSSWB: Pack Words into Bytes with Signed Saturation.

Forms:

PACKSSWB xmm  xmm
PACKSSWB m128 xmm

Construct and append a PACKSSWB instruction to the active function.

func (*Context) PACKUSDW ¶

func (c *Context) PACKUSDW(mx, x operand.Op)

PACKUSDW: Pack Doublewords into Words with Unsigned Saturation.

Forms:

PACKUSDW xmm  xmm
PACKUSDW m128 xmm

Construct and append a PACKUSDW instruction to the active function.

func (*Context) PACKUSWB ¶

func (c *Context) PACKUSWB(mx, x operand.Op)

PACKUSWB: Pack Words into Bytes with Unsigned Saturation.

Forms:

PACKUSWB xmm  xmm
PACKUSWB m128 xmm

Construct and append a PACKUSWB instruction to the active function.

func (*Context) PADDB ¶

func (c *Context) PADDB(mx, x operand.Op)

PADDB: Add Packed Byte Integers.

Forms:

PADDB xmm  xmm
PADDB m128 xmm

Construct and append a PADDB instruction to the active function.

func (*Context) PADDD ¶

func (c *Context) PADDD(mx, x operand.Op)

PADDD: Add Packed Doubleword Integers.

Forms:

PADDD xmm  xmm
PADDD m128 xmm

Construct and append a PADDD instruction to the active function.

func (*Context) PADDL ¶

func (c *Context) PADDL(mx, x operand.Op)

PADDL: Add Packed Doubleword Integers.

Forms:

PADDL xmm  xmm
PADDL m128 xmm

Construct and append a PADDL instruction to the active function.

func (*Context) PADDQ ¶

func (c *Context) PADDQ(mx, x operand.Op)

PADDQ: Add Packed Quadword Integers.

Forms:

PADDQ xmm  xmm
PADDQ m128 xmm

Construct and append a PADDQ instruction to the active function.

func (*Context) PADDSB ¶

func (c *Context) PADDSB(mx, x operand.Op)

PADDSB: Add Packed Signed Byte Integers with Signed Saturation.

Forms:

PADDSB xmm  xmm
PADDSB m128 xmm

Construct and append a PADDSB instruction to the active function.

func (*Context) PADDSW ¶

func (c *Context) PADDSW(mx, x operand.Op)

PADDSW: Add Packed Signed Word Integers with Signed Saturation.

Forms:

PADDSW xmm  xmm
PADDSW m128 xmm

Construct and append a PADDSW instruction to the active function.

func (*Context) PADDUSB ¶

func (c *Context) PADDUSB(mx, x operand.Op)

PADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

PADDUSB xmm  xmm
PADDUSB m128 xmm

Construct and append a PADDUSB instruction to the active function.

func (*Context) PADDUSW ¶

func (c *Context) PADDUSW(mx, x operand.Op)

PADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

PADDUSW xmm  xmm
PADDUSW m128 xmm

Construct and append a PADDUSW instruction to the active function.

func (*Context) PADDW ¶

func (c *Context) PADDW(mx, x operand.Op)

PADDW: Add Packed Word Integers.

Forms:

PADDW xmm  xmm
PADDW m128 xmm

Construct and append a PADDW instruction to the active function.

func (*Context) PALIGNR ¶

func (c *Context) PALIGNR(i, mx, x operand.Op)

PALIGNR: Packed Align Right.

Forms:

PALIGNR imm8 xmm  xmm
PALIGNR imm8 m128 xmm

Construct and append a PALIGNR instruction to the active function.

func (*Context) PAND ¶

func (c *Context) PAND(mx, x operand.Op)

PAND: Packed Bitwise Logical AND.

Forms:

PAND xmm  xmm
PAND m128 xmm

Construct and append a PAND instruction to the active function.

func (*Context) PANDN ¶

func (c *Context) PANDN(mx, x operand.Op)

PANDN: Packed Bitwise Logical AND NOT.

Forms:

PANDN xmm  xmm
PANDN m128 xmm

Construct and append a PANDN instruction to the active function.

func (*Context) PAUSE ¶

func (c *Context) PAUSE()

PAUSE: Spin Loop Hint.

Forms:

PAUSE

Construct and append a PAUSE instruction to the active function.

func (*Context) PAVGB ¶

func (c *Context) PAVGB(mx, x operand.Op)

PAVGB: Average Packed Byte Integers.

Forms:

PAVGB xmm  xmm
PAVGB m128 xmm

Construct and append a PAVGB instruction to the active function.

func (*Context) PAVGW ¶

func (c *Context) PAVGW(mx, x operand.Op)

PAVGW: Average Packed Word Integers.

Forms:

PAVGW xmm  xmm
PAVGW m128 xmm

Construct and append a PAVGW instruction to the active function.

func (*Context) PBLENDVB ¶

func (c *Context) PBLENDVB(x, mx, x1 operand.Op)

PBLENDVB: Variable Blend Packed Bytes.

Forms:

PBLENDVB xmm0 xmm  xmm
PBLENDVB xmm0 m128 xmm

Construct and append a PBLENDVB instruction to the active function.

func (*Context) PBLENDW ¶

func (c *Context) PBLENDW(i, mx, x operand.Op)

PBLENDW: Blend Packed Words.

Forms:

PBLENDW imm8 xmm  xmm
PBLENDW imm8 m128 xmm

Construct and append a PBLENDW instruction to the active function.

func (*Context) PCLMULQDQ ¶

func (c *Context) PCLMULQDQ(i, mx, x operand.Op)

PCLMULQDQ: Carry-Less Quadword Multiplication.

Forms:

PCLMULQDQ imm8 xmm  xmm
PCLMULQDQ imm8 m128 xmm

Construct and append a PCLMULQDQ instruction to the active function.

func (*Context) PCMPEQB ¶

func (c *Context) PCMPEQB(mx, x operand.Op)

PCMPEQB: Compare Packed Byte Data for Equality.

Forms:

PCMPEQB xmm  xmm
PCMPEQB m128 xmm

Construct and append a PCMPEQB instruction to the active function.

func (*Context) PCMPEQL ¶

func (c *Context) PCMPEQL(mx, x operand.Op)

PCMPEQL: Compare Packed Doubleword Data for Equality.

Forms:

PCMPEQL xmm  xmm
PCMPEQL m128 xmm

Construct and append a PCMPEQL instruction to the active function.

func (*Context) PCMPEQQ ¶

func (c *Context) PCMPEQQ(mx, x operand.Op)

PCMPEQQ: Compare Packed Quadword Data for Equality.

Forms:

PCMPEQQ xmm  xmm
PCMPEQQ m128 xmm

Construct and append a PCMPEQQ instruction to the active function.

func (*Context) PCMPEQW ¶

func (c *Context) PCMPEQW(mx, x operand.Op)

PCMPEQW: Compare Packed Word Data for Equality.

Forms:

PCMPEQW xmm  xmm
PCMPEQW m128 xmm

Construct and append a PCMPEQW instruction to the active function.

func (*Context) PCMPESTRI ¶

func (c *Context) PCMPESTRI(i, mx, x operand.Op)

PCMPESTRI: Packed Compare Explicit Length Strings, Return Index.

Forms:

PCMPESTRI imm8 xmm  xmm
PCMPESTRI imm8 m128 xmm

Construct and append a PCMPESTRI instruction to the active function.

func (*Context) PCMPESTRM ¶

func (c *Context) PCMPESTRM(i, mx, x operand.Op)

PCMPESTRM: Packed Compare Explicit Length Strings, Return Mask.

Forms:

PCMPESTRM imm8 xmm  xmm
PCMPESTRM imm8 m128 xmm

Construct and append a PCMPESTRM instruction to the active function.

func (*Context) PCMPGTB ¶

func (c *Context) PCMPGTB(mx, x operand.Op)

PCMPGTB: Compare Packed Signed Byte Integers for Greater Than.

Forms:

PCMPGTB xmm  xmm
PCMPGTB m128 xmm

Construct and append a PCMPGTB instruction to the active function.

func (*Context) PCMPGTL ¶

func (c *Context) PCMPGTL(mx, x operand.Op)

PCMPGTL: Compare Packed Signed Doubleword Integers for Greater Than.

Forms:

PCMPGTL xmm  xmm
PCMPGTL m128 xmm

Construct and append a PCMPGTL instruction to the active function.

func (*Context) PCMPGTQ ¶

func (c *Context) PCMPGTQ(mx, x operand.Op)

PCMPGTQ: Compare Packed Data for Greater Than.

Forms:

PCMPGTQ xmm  xmm
PCMPGTQ m128 xmm

Construct and append a PCMPGTQ instruction to the active function.

func (*Context) PCMPGTW ¶

func (c *Context) PCMPGTW(mx, x operand.Op)

PCMPGTW: Compare Packed Signed Word Integers for Greater Than.

Forms:

PCMPGTW xmm  xmm
PCMPGTW m128 xmm

Construct and append a PCMPGTW instruction to the active function.

func (*Context) PCMPISTRI ¶

func (c *Context) PCMPISTRI(i, mx, x operand.Op)

PCMPISTRI: Packed Compare Implicit Length Strings, Return Index.

Forms:

PCMPISTRI imm8 xmm  xmm
PCMPISTRI imm8 m128 xmm

Construct and append a PCMPISTRI instruction to the active function.

func (*Context) PCMPISTRM ¶

func (c *Context) PCMPISTRM(i, mx, x operand.Op)

PCMPISTRM: Packed Compare Implicit Length Strings, Return Mask.

Forms:

PCMPISTRM imm8 xmm  xmm
PCMPISTRM imm8 m128 xmm

Construct and append a PCMPISTRM instruction to the active function.

func (*Context) PDEPL ¶

func (c *Context) PDEPL(mr, r, r1 operand.Op)

PDEPL: Parallel Bits Deposit.

Forms:

PDEPL r32 r32 r32
PDEPL m32 r32 r32

Construct and append a PDEPL instruction to the active function.

func (*Context) PDEPQ ¶

func (c *Context) PDEPQ(mr, r, r1 operand.Op)

PDEPQ: Parallel Bits Deposit.

Forms:

PDEPQ r64 r64 r64
PDEPQ m64 r64 r64

Construct and append a PDEPQ instruction to the active function.

func (*Context) PEXTL ¶

func (c *Context) PEXTL(mr, r, r1 operand.Op)

PEXTL: Parallel Bits Extract.

Forms:

PEXTL r32 r32 r32
PEXTL m32 r32 r32

Construct and append a PEXTL instruction to the active function.

func (*Context) PEXTQ ¶

func (c *Context) PEXTQ(mr, r, r1 operand.Op)

PEXTQ: Parallel Bits Extract.

Forms:

PEXTQ r64 r64 r64
PEXTQ m64 r64 r64

Construct and append a PEXTQ instruction to the active function.

func (*Context) PEXTRB ¶

func (c *Context) PEXTRB(i, x, mr operand.Op)

PEXTRB: Extract Byte.

Forms:

PEXTRB imm8 xmm r32
PEXTRB imm8 xmm m8

Construct and append a PEXTRB instruction to the active function.

func (*Context) PEXTRD ¶

func (c *Context) PEXTRD(i, x, mr operand.Op)

PEXTRD: Extract Doubleword.

Forms:

PEXTRD imm8 xmm r32
PEXTRD imm8 xmm m32

Construct and append a PEXTRD instruction to the active function.

func (*Context) PEXTRQ ¶

func (c *Context) PEXTRQ(i, x, mr operand.Op)

PEXTRQ: Extract Quadword.

Forms:

PEXTRQ imm8 xmm r64
PEXTRQ imm8 xmm m64

Construct and append a PEXTRQ instruction to the active function.

func (*Context) PEXTRW ¶

func (c *Context) PEXTRW(i, x, mr operand.Op)

PEXTRW: Extract Word.

Forms:

PEXTRW imm8 xmm r32
PEXTRW imm8 xmm m16

Construct and append a PEXTRW instruction to the active function.

func (*Context) PHADDD ¶

func (c *Context) PHADDD(mx, x operand.Op)

PHADDD: Packed Horizontal Add Doubleword Integer.

Forms:

PHADDD xmm  xmm
PHADDD m128 xmm

Construct and append a PHADDD instruction to the active function.

func (*Context) PHADDSW ¶

func (c *Context) PHADDSW(mx, x operand.Op)

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

Forms:

PHADDSW xmm  xmm
PHADDSW m128 xmm

Construct and append a PHADDSW instruction to the active function.

func (*Context) PHADDW ¶

func (c *Context) PHADDW(mx, x operand.Op)

PHADDW: Packed Horizontal Add Word Integers.

Forms:

PHADDW xmm  xmm
PHADDW m128 xmm

Construct and append a PHADDW instruction to the active function.

func (*Context) PHMINPOSUW ¶

func (c *Context) PHMINPOSUW(mx, x operand.Op)

PHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers.

Forms:

PHMINPOSUW xmm  xmm
PHMINPOSUW m128 xmm

Construct and append a PHMINPOSUW instruction to the active function.

func (*Context) PHSUBD ¶

func (c *Context) PHSUBD(mx, x operand.Op)

PHSUBD: Packed Horizontal Subtract Doubleword Integers.

Forms:

PHSUBD xmm  xmm
PHSUBD m128 xmm

Construct and append a PHSUBD instruction to the active function.

func (*Context) PHSUBSW ¶

func (c *Context) PHSUBSW(mx, x operand.Op)

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

Forms:

PHSUBSW xmm  xmm
PHSUBSW m128 xmm

Construct and append a PHSUBSW instruction to the active function.

func (*Context) PHSUBW ¶

func (c *Context) PHSUBW(mx, x operand.Op)

PHSUBW: Packed Horizontal Subtract Word Integers.

Forms:

PHSUBW xmm  xmm
PHSUBW m128 xmm

Construct and append a PHSUBW instruction to the active function.

func (*Context) PINSRB ¶

func (c *Context) PINSRB(i, mr, x operand.Op)

PINSRB: Insert Byte.

Forms:

PINSRB imm8 r32 xmm
PINSRB imm8 m8  xmm

Construct and append a PINSRB instruction to the active function.

func (*Context) PINSRD ¶

func (c *Context) PINSRD(i, mr, x operand.Op)

PINSRD: Insert Doubleword.

Forms:

PINSRD imm8 r32 xmm
PINSRD imm8 m32 xmm

Construct and append a PINSRD instruction to the active function.

func (*Context) PINSRQ ¶

func (c *Context) PINSRQ(i, mr, x operand.Op)

PINSRQ: Insert Quadword.

Forms:

PINSRQ imm8 r64 xmm
PINSRQ imm8 m64 xmm

Construct and append a PINSRQ instruction to the active function.

func (*Context) PINSRW ¶

func (c *Context) PINSRW(i, mr, x operand.Op)

PINSRW: Insert Word.

Forms:

PINSRW imm8 r32 xmm
PINSRW imm8 m16 xmm

Construct and append a PINSRW instruction to the active function.

func (*Context) PMADDUBSW ¶

func (c *Context) PMADDUBSW(mx, x operand.Op)

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

Forms:

PMADDUBSW xmm  xmm
PMADDUBSW m128 xmm

Construct and append a PMADDUBSW instruction to the active function.

func (*Context) PMADDWL ¶

func (c *Context) PMADDWL(mx, x operand.Op)

PMADDWL: Multiply and Add Packed Signed Word Integers.

Forms:

PMADDWL xmm  xmm
PMADDWL m128 xmm

Construct and append a PMADDWL instruction to the active function.

func (*Context) PMAXSB ¶

func (c *Context) PMAXSB(mx, x operand.Op)

PMAXSB: Maximum of Packed Signed Byte Integers.

Forms:

PMAXSB xmm  xmm
PMAXSB m128 xmm

Construct and append a PMAXSB instruction to the active function.

func (*Context) PMAXSD ¶

func (c *Context) PMAXSD(mx, x operand.Op)

PMAXSD: Maximum of Packed Signed Doubleword Integers.

Forms:

PMAXSD xmm  xmm
PMAXSD m128 xmm

Construct and append a PMAXSD instruction to the active function.

func (*Context) PMAXSW ¶

func (c *Context) PMAXSW(mx, x operand.Op)

PMAXSW: Maximum of Packed Signed Word Integers.

Forms:

PMAXSW xmm  xmm
PMAXSW m128 xmm

Construct and append a PMAXSW instruction to the active function.

func (*Context) PMAXUB ¶

func (c *Context) PMAXUB(mx, x operand.Op)

PMAXUB: Maximum of Packed Unsigned Byte Integers.

Forms:

PMAXUB xmm  xmm
PMAXUB m128 xmm

Construct and append a PMAXUB instruction to the active function.

func (*Context) PMAXUD ¶

func (c *Context) PMAXUD(mx, x operand.Op)

PMAXUD: Maximum of Packed Unsigned Doubleword Integers.

Forms:

PMAXUD xmm  xmm
PMAXUD m128 xmm

Construct and append a PMAXUD instruction to the active function.

func (*Context) PMAXUW ¶

func (c *Context) PMAXUW(mx, x operand.Op)

PMAXUW: Maximum of Packed Unsigned Word Integers.

Forms:

PMAXUW xmm  xmm
PMAXUW m128 xmm

Construct and append a PMAXUW instruction to the active function.

func (*Context) PMINSB ¶

func (c *Context) PMINSB(mx, x operand.Op)

PMINSB: Minimum of Packed Signed Byte Integers.

Forms:

PMINSB xmm  xmm
PMINSB m128 xmm

Construct and append a PMINSB instruction to the active function.

func (*Context) PMINSD ¶

func (c *Context) PMINSD(mx, x operand.Op)

PMINSD: Minimum of Packed Signed Doubleword Integers.

Forms:

PMINSD xmm  xmm
PMINSD m128 xmm

Construct and append a PMINSD instruction to the active function.

func (*Context) PMINSW ¶

func (c *Context) PMINSW(mx, x operand.Op)

PMINSW: Minimum of Packed Signed Word Integers.

Forms:

PMINSW xmm  xmm
PMINSW m128 xmm

Construct and append a PMINSW instruction to the active function.

func (*Context) PMINUB ¶

func (c *Context) PMINUB(mx, x operand.Op)

PMINUB: Minimum of Packed Unsigned Byte Integers.

Forms:

PMINUB xmm  xmm
PMINUB m128 xmm

Construct and append a PMINUB instruction to the active function.

func (*Context) PMINUD ¶

func (c *Context) PMINUD(mx, x operand.Op)

PMINUD: Minimum of Packed Unsigned Doubleword Integers.

Forms:

PMINUD xmm  xmm
PMINUD m128 xmm

Construct and append a PMINUD instruction to the active function.

func (*Context) PMINUW ¶

func (c *Context) PMINUW(mx, x operand.Op)

PMINUW: Minimum of Packed Unsigned Word Integers.

Forms:

PMINUW xmm  xmm
PMINUW m128 xmm

Construct and append a PMINUW instruction to the active function.

func (*Context) PMOVMSKB ¶

func (c *Context) PMOVMSKB(x, r operand.Op)

PMOVMSKB: Move Byte Mask.

Forms:

PMOVMSKB xmm r32

Construct and append a PMOVMSKB instruction to the active function.

func (*Context) PMOVSXBD ¶

func (c *Context) PMOVSXBD(mx, x operand.Op)

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

Forms:

PMOVSXBD xmm xmm
PMOVSXBD m32 xmm

Construct and append a PMOVSXBD instruction to the active function.

func (*Context) PMOVSXBQ ¶

func (c *Context) PMOVSXBQ(mx, x operand.Op)

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

Forms:

PMOVSXBQ xmm xmm
PMOVSXBQ m16 xmm

Construct and append a PMOVSXBQ instruction to the active function.

func (*Context) PMOVSXBW ¶

func (c *Context) PMOVSXBW(mx, x operand.Op)

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

Forms:

PMOVSXBW xmm xmm
PMOVSXBW m64 xmm

Construct and append a PMOVSXBW instruction to the active function.

func (*Context) PMOVSXDQ ¶

func (c *Context) PMOVSXDQ(mx, x operand.Op)

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

Forms:

PMOVSXDQ xmm xmm
PMOVSXDQ m64 xmm

Construct and append a PMOVSXDQ instruction to the active function.

func (*Context) PMOVSXWD ¶

func (c *Context) PMOVSXWD(mx, x operand.Op)

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

Forms:

PMOVSXWD xmm xmm
PMOVSXWD m64 xmm

Construct and append a PMOVSXWD instruction to the active function.

func (*Context) PMOVSXWQ ¶

func (c *Context) PMOVSXWQ(mx, x operand.Op)

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

Forms:

PMOVSXWQ xmm xmm
PMOVSXWQ m32 xmm

Construct and append a PMOVSXWQ instruction to the active function.

func (*Context) PMOVZXBD ¶

func (c *Context) PMOVZXBD(mx, x operand.Op)

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

Forms:

PMOVZXBD xmm xmm
PMOVZXBD m32 xmm

Construct and append a PMOVZXBD instruction to the active function.

func (*Context) PMOVZXBQ ¶

func (c *Context) PMOVZXBQ(mx, x operand.Op)

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

Forms:

PMOVZXBQ xmm xmm
PMOVZXBQ m16 xmm

Construct and append a PMOVZXBQ instruction to the active function.

func (*Context) PMOVZXBW ¶

func (c *Context) PMOVZXBW(mx, x operand.Op)

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

Forms:

PMOVZXBW xmm xmm
PMOVZXBW m64 xmm

Construct and append a PMOVZXBW instruction to the active function.

func (*Context) PMOVZXDQ ¶

func (c *Context) PMOVZXDQ(mx, x operand.Op)

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

Forms:

PMOVZXDQ xmm xmm
PMOVZXDQ m64 xmm

Construct and append a PMOVZXDQ instruction to the active function.

func (*Context) PMOVZXWD ¶

func (c *Context) PMOVZXWD(mx, x operand.Op)

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

Forms:

PMOVZXWD xmm xmm
PMOVZXWD m64 xmm

Construct and append a PMOVZXWD instruction to the active function.

func (*Context) PMOVZXWQ ¶

func (c *Context) PMOVZXWQ(mx, x operand.Op)

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

Forms:

PMOVZXWQ xmm xmm
PMOVZXWQ m32 xmm

Construct and append a PMOVZXWQ instruction to the active function.

func (*Context) PMULDQ ¶

func (c *Context) PMULDQ(mx, x operand.Op)

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

Forms:

PMULDQ xmm  xmm
PMULDQ m128 xmm

Construct and append a PMULDQ instruction to the active function.

func (*Context) PMULHRSW ¶

func (c *Context) PMULHRSW(mx, x operand.Op)

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

Forms:

PMULHRSW xmm  xmm
PMULHRSW m128 xmm

Construct and append a PMULHRSW instruction to the active function.

func (*Context) PMULHUW ¶

func (c *Context) PMULHUW(mx, x operand.Op)

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

Forms:

PMULHUW xmm  xmm
PMULHUW m128 xmm

Construct and append a PMULHUW instruction to the active function.

func (*Context) PMULHW ¶

func (c *Context) PMULHW(mx, x operand.Op)

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

Forms:

PMULHW xmm  xmm
PMULHW m128 xmm

Construct and append a PMULHW instruction to the active function.

func (*Context) PMULLD ¶

func (c *Context) PMULLD(mx, x operand.Op)

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

Forms:

PMULLD xmm  xmm
PMULLD m128 xmm

Construct and append a PMULLD instruction to the active function.

func (*Context) PMULLW ¶

func (c *Context) PMULLW(mx, x operand.Op)

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

Forms:

PMULLW xmm  xmm
PMULLW m128 xmm

Construct and append a PMULLW instruction to the active function.

func (*Context) PMULULQ ¶

func (c *Context) PMULULQ(mx, x operand.Op)

PMULULQ: Multiply Packed Unsigned Doubleword Integers.

Forms:

PMULULQ xmm  xmm
PMULULQ m128 xmm

Construct and append a PMULULQ instruction to the active function.

func (*Context) POPCNTL ¶

func (c *Context) POPCNTL(mr, r operand.Op)

POPCNTL: Count of Number of Bits Set to 1.

Forms:

POPCNTL r32 r32
POPCNTL m32 r32

Construct and append a POPCNTL instruction to the active function.

func (*Context) POPCNTQ ¶

func (c *Context) POPCNTQ(mr, r operand.Op)

POPCNTQ: Count of Number of Bits Set to 1.

Forms:

POPCNTQ r64 r64
POPCNTQ m64 r64

Construct and append a POPCNTQ instruction to the active function.

func (*Context) POPCNTW ¶

func (c *Context) POPCNTW(mr, r operand.Op)

POPCNTW: Count of Number of Bits Set to 1.

Forms:

POPCNTW r16 r16
POPCNTW m16 r16

Construct and append a POPCNTW instruction to the active function.

func (*Context) POPQ ¶

func (c *Context) POPQ(mr operand.Op)

POPQ: Pop a Value from the Stack.

Forms:

POPQ r64
POPQ m64

Construct and append a POPQ instruction to the active function.

func (*Context) POPW ¶

func (c *Context) POPW(mr operand.Op)

POPW: Pop a Value from the Stack.

Forms:

POPW r16
POPW m16

Construct and append a POPW instruction to the active function.

func (*Context) POR ¶

func (c *Context) POR(mx, x operand.Op)

POR: Packed Bitwise Logical OR.

Forms:

POR xmm  xmm
POR m128 xmm

Construct and append a POR instruction to the active function.

func (*Context) PREFETCHNTA ¶

func (c *Context) PREFETCHNTA(m operand.Op)

PREFETCHNTA: Prefetch Data Into Caches using NTA Hint.

Forms:

PREFETCHNTA m8

Construct and append a PREFETCHNTA instruction to the active function.

func (*Context) PREFETCHT0 ¶

func (c *Context) PREFETCHT0(m operand.Op)

PREFETCHT0: Prefetch Data Into Caches using T0 Hint.

Forms:

PREFETCHT0 m8

Construct and append a PREFETCHT0 instruction to the active function.

func (*Context) PREFETCHT1 ¶

func (c *Context) PREFETCHT1(m operand.Op)

PREFETCHT1: Prefetch Data Into Caches using T1 Hint.

Forms:

PREFETCHT1 m8

Construct and append a PREFETCHT1 instruction to the active function.

func (*Context) PREFETCHT2 ¶

func (c *Context) PREFETCHT2(m operand.Op)

PREFETCHT2: Prefetch Data Into Caches using T2 Hint.

Forms:

PREFETCHT2 m8

Construct and append a PREFETCHT2 instruction to the active function.

func (*Context) PSADBW ¶

func (c *Context) PSADBW(mx, x operand.Op)

PSADBW: Compute Sum of Absolute Differences.

Forms:

PSADBW xmm  xmm
PSADBW m128 xmm

Construct and append a PSADBW instruction to the active function.

func (*Context) PSHUFB ¶

func (c *Context) PSHUFB(mx, x operand.Op)

PSHUFB: Packed Shuffle Bytes.

Forms:

PSHUFB xmm  xmm
PSHUFB m128 xmm

Construct and append a PSHUFB instruction to the active function.

func (*Context) PSHUFD ¶

func (c *Context) PSHUFD(i, mx, x operand.Op)

PSHUFD: Shuffle Packed Doublewords.

Forms:

PSHUFD imm8 xmm  xmm
PSHUFD imm8 m128 xmm

Construct and append a PSHUFD instruction to the active function.

func (*Context) PSHUFHW ¶

func (c *Context) PSHUFHW(i, mx, x operand.Op)

PSHUFHW: Shuffle Packed High Words.

Forms:

PSHUFHW imm8 xmm  xmm
PSHUFHW imm8 m128 xmm

Construct and append a PSHUFHW instruction to the active function.

func (*Context) PSHUFL ¶

func (c *Context) PSHUFL(i, mx, x operand.Op)

PSHUFL: Shuffle Packed Doublewords.

Forms:

PSHUFL imm8 xmm  xmm
PSHUFL imm8 m128 xmm

Construct and append a PSHUFL instruction to the active function.

func (*Context) PSHUFLW ¶

func (c *Context) PSHUFLW(i, mx, x operand.Op)

PSHUFLW: Shuffle Packed Low Words.

Forms:

PSHUFLW imm8 xmm  xmm
PSHUFLW imm8 m128 xmm

Construct and append a PSHUFLW instruction to the active function.

func (*Context) PSIGNB ¶

func (c *Context) PSIGNB(mx, x operand.Op)

PSIGNB: Packed Sign of Byte Integers.

Forms:

PSIGNB xmm  xmm
PSIGNB m128 xmm

Construct and append a PSIGNB instruction to the active function.

func (*Context) PSIGND ¶

func (c *Context) PSIGND(mx, x operand.Op)

PSIGND: Packed Sign of Doubleword Integers.

Forms:

PSIGND xmm  xmm
PSIGND m128 xmm

Construct and append a PSIGND instruction to the active function.

func (*Context) PSIGNW ¶

func (c *Context) PSIGNW(mx, x operand.Op)

PSIGNW: Packed Sign of Word Integers.

Forms:

PSIGNW xmm  xmm
PSIGNW m128 xmm

Construct and append a PSIGNW instruction to the active function.

func (*Context) PSLLDQ ¶

func (c *Context) PSLLDQ(i, x operand.Op)

PSLLDQ: Shift Packed Double Quadword Left Logical.

Forms:

PSLLDQ imm8 xmm

Construct and append a PSLLDQ instruction to the active function.

func (*Context) PSLLL ¶

func (c *Context) PSLLL(imx, x operand.Op)

PSLLL: Shift Packed Doubleword Data Left Logical.

Forms:

PSLLL imm8 xmm
PSLLL xmm  xmm
PSLLL m128 xmm

Construct and append a PSLLL instruction to the active function.

func (*Context) PSLLO ¶

func (c *Context) PSLLO(i, x operand.Op)

PSLLO: Shift Packed Double Quadword Left Logical.

Forms:

PSLLO imm8 xmm

Construct and append a PSLLO instruction to the active function.

func (*Context) PSLLQ ¶

func (c *Context) PSLLQ(imx, x operand.Op)

PSLLQ: Shift Packed Quadword Data Left Logical.

Forms:

PSLLQ imm8 xmm
PSLLQ xmm  xmm
PSLLQ m128 xmm

Construct and append a PSLLQ instruction to the active function.

func (*Context) PSLLW ¶

func (c *Context) PSLLW(imx, x operand.Op)

PSLLW: Shift Packed Word Data Left Logical.

Forms:

PSLLW imm8 xmm
PSLLW xmm  xmm
PSLLW m128 xmm

Construct and append a PSLLW instruction to the active function.

func (*Context) PSRAL ¶

func (c *Context) PSRAL(imx, x operand.Op)

PSRAL: Shift Packed Doubleword Data Right Arithmetic.

Forms:

PSRAL imm8 xmm
PSRAL xmm  xmm
PSRAL m128 xmm

Construct and append a PSRAL instruction to the active function.

func (*Context) PSRAW ¶

func (c *Context) PSRAW(imx, x operand.Op)

PSRAW: Shift Packed Word Data Right Arithmetic.

Forms:

PSRAW imm8 xmm
PSRAW xmm  xmm
PSRAW m128 xmm

Construct and append a PSRAW instruction to the active function.

func (*Context) PSRLDQ ¶

func (c *Context) PSRLDQ(i, x operand.Op)

PSRLDQ: Shift Packed Double Quadword Right Logical.

Forms:

PSRLDQ imm8 xmm

Construct and append a PSRLDQ instruction to the active function.

func (*Context) PSRLL ¶

func (c *Context) PSRLL(imx, x operand.Op)

PSRLL: Shift Packed Doubleword Data Right Logical.

Forms:

PSRLL imm8 xmm
PSRLL xmm  xmm
PSRLL m128 xmm

Construct and append a PSRLL instruction to the active function.

func (*Context) PSRLO ¶

func (c *Context) PSRLO(i, x operand.Op)

PSRLO: Shift Packed Double Quadword Right Logical.

Forms:

PSRLO imm8 xmm

Construct and append a PSRLO instruction to the active function.

func (*Context) PSRLQ ¶

func (c *Context) PSRLQ(imx, x operand.Op)

PSRLQ: Shift Packed Quadword Data Right Logical.

Forms:

PSRLQ imm8 xmm
PSRLQ xmm  xmm
PSRLQ m128 xmm

Construct and append a PSRLQ instruction to the active function.

func (*Context) PSRLW ¶

func (c *Context) PSRLW(imx, x operand.Op)

PSRLW: Shift Packed Word Data Right Logical.

Forms:

PSRLW imm8 xmm
PSRLW xmm  xmm
PSRLW m128 xmm

Construct and append a PSRLW instruction to the active function.

func (*Context) PSUBB ¶

func (c *Context) PSUBB(mx, x operand.Op)

PSUBB: Subtract Packed Byte Integers.

Forms:

PSUBB xmm  xmm
PSUBB m128 xmm

Construct and append a PSUBB instruction to the active function.

func (*Context) PSUBL ¶

func (c *Context) PSUBL(mx, x operand.Op)

PSUBL: Subtract Packed Doubleword Integers.

Forms:

PSUBL xmm  xmm
PSUBL m128 xmm

Construct and append a PSUBL instruction to the active function.

func (*Context) PSUBQ ¶

func (c *Context) PSUBQ(mx, x operand.Op)

PSUBQ: Subtract Packed Quadword Integers.

Forms:

PSUBQ xmm  xmm
PSUBQ m128 xmm

Construct and append a PSUBQ instruction to the active function.

func (*Context) PSUBSB ¶

func (c *Context) PSUBSB(mx, x operand.Op)

PSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation.

Forms:

PSUBSB xmm  xmm
PSUBSB m128 xmm

Construct and append a PSUBSB instruction to the active function.

func (*Context) PSUBSW ¶

func (c *Context) PSUBSW(mx, x operand.Op)

PSUBSW: Subtract Packed Signed Word Integers with Signed Saturation.

Forms:

PSUBSW xmm  xmm
PSUBSW m128 xmm

Construct and append a PSUBSW instruction to the active function.

func (*Context) PSUBUSB ¶

func (c *Context) PSUBUSB(mx, x operand.Op)

PSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation.

Forms:

PSUBUSB xmm  xmm
PSUBUSB m128 xmm

Construct and append a PSUBUSB instruction to the active function.

func (*Context) PSUBUSW ¶

func (c *Context) PSUBUSW(mx, x operand.Op)

PSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation.

Forms:

PSUBUSW xmm  xmm
PSUBUSW m128 xmm

Construct and append a PSUBUSW instruction to the active function.

func (*Context) PSUBW ¶

func (c *Context) PSUBW(mx, x operand.Op)

PSUBW: Subtract Packed Word Integers.

Forms:

PSUBW xmm  xmm
PSUBW m128 xmm

Construct and append a PSUBW instruction to the active function.

func (*Context) PTEST ¶

func (c *Context) PTEST(mx, x operand.Op)

PTEST: Packed Logical Compare.

Forms:

PTEST xmm  xmm
PTEST m128 xmm

Construct and append a PTEST instruction to the active function.

func (*Context) PUNPCKHBW ¶

func (c *Context) PUNPCKHBW(mx, x operand.Op)

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

Forms:

PUNPCKHBW xmm  xmm
PUNPCKHBW m128 xmm

Construct and append a PUNPCKHBW instruction to the active function.

func (*Context) PUNPCKHLQ ¶

func (c *Context) PUNPCKHLQ(mx, x operand.Op)

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

Forms:

PUNPCKHLQ xmm  xmm
PUNPCKHLQ m128 xmm

Construct and append a PUNPCKHLQ instruction to the active function.

func (*Context) PUNPCKHQDQ ¶

func (c *Context) PUNPCKHQDQ(mx, x operand.Op)

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

Forms:

PUNPCKHQDQ xmm  xmm
PUNPCKHQDQ m128 xmm

Construct and append a PUNPCKHQDQ instruction to the active function.

func (*Context) PUNPCKHWL ¶

func (c *Context) PUNPCKHWL(mx, x operand.Op)

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

Forms:

PUNPCKHWL xmm  xmm
PUNPCKHWL m128 xmm

Construct and append a PUNPCKHWL instruction to the active function.

func (*Context) PUNPCKLBW ¶

func (c *Context) PUNPCKLBW(mx, x operand.Op)

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

Forms:

PUNPCKLBW xmm  xmm
PUNPCKLBW m128 xmm

Construct and append a PUNPCKLBW instruction to the active function.

func (*Context) PUNPCKLLQ ¶

func (c *Context) PUNPCKLLQ(mx, x operand.Op)

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

Forms:

PUNPCKLLQ xmm  xmm
PUNPCKLLQ m128 xmm

Construct and append a PUNPCKLLQ instruction to the active function.

func (*Context) PUNPCKLQDQ ¶

func (c *Context) PUNPCKLQDQ(mx, x operand.Op)

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

Forms:

PUNPCKLQDQ xmm  xmm
PUNPCKLQDQ m128 xmm

Construct and append a PUNPCKLQDQ instruction to the active function.

func (*Context) PUNPCKLWL ¶

func (c *Context) PUNPCKLWL(mx, x operand.Op)

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

Forms:

PUNPCKLWL xmm  xmm
PUNPCKLWL m128 xmm

Construct and append a PUNPCKLWL instruction to the active function.

func (*Context) PUSHQ ¶

func (c *Context) PUSHQ(imr operand.Op)

PUSHQ: Push Value Onto the Stack.

Forms:

PUSHQ imm8
PUSHQ imm32
PUSHQ r64
PUSHQ m64

Construct and append a PUSHQ instruction to the active function.

func (*Context) PUSHW ¶

func (c *Context) PUSHW(mr operand.Op)

PUSHW: Push Value Onto the Stack.

Forms:

PUSHW r16
PUSHW m16

Construct and append a PUSHW instruction to the active function.

func (*Context) PXOR ¶

func (c *Context) PXOR(mx, x operand.Op)

PXOR: Packed Bitwise Logical Exclusive OR.

Forms:

PXOR xmm  xmm
PXOR m128 xmm

Construct and append a PXOR instruction to the active function.

func (*Context) Package ¶

func (c *Context) Package(path string)

Package sets the package the generated file will belong to. Required to be able to reference types in the package.

func (*Context) Param ¶

func (c *Context) Param(name string) gotypes.Component

Param returns a the named argument of the active function.

func (*Context) ParamIndex ¶

func (c *Context) ParamIndex(i int) gotypes.Component

ParamIndex returns the ith argument of the active function.

func (*Context) Pragma ¶

func (c *Context) Pragma(directive string, args ...string)

Pragma adds a compiler directive to the currently active function.

func (*Context) RCLB ¶

func (c *Context) RCLB(ci, mr operand.Op)

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

Construct and append a RCLB instruction to the active function.

func (*Context) RCLL ¶

func (c *Context) RCLL(ci, mr operand.Op)

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

Construct and append a RCLL instruction to the active function.

func (*Context) RCLQ ¶

func (c *Context) RCLQ(ci, mr operand.Op)

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

Construct and append a RCLQ instruction to the active function.

func (*Context) RCLW ¶

func (c *Context) RCLW(ci, mr operand.Op)

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

Construct and append a RCLW instruction to the active function.

func (*Context) RCPPS ¶

func (c *Context) RCPPS(mx, x operand.Op)

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

Forms:

RCPPS xmm  xmm
RCPPS m128 xmm

Construct and append a RCPPS instruction to the active function.

func (*Context) RCPSS ¶

func (c *Context) RCPSS(mx, x operand.Op)

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

Forms:

RCPSS xmm xmm
RCPSS m32 xmm

Construct and append a RCPSS instruction to the active function.

func (*Context) RCRB ¶

func (c *Context) RCRB(ci, mr operand.Op)

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

Construct and append a RCRB instruction to the active function.

func (*Context) RCRL ¶

func (c *Context) RCRL(ci, mr operand.Op)

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

Construct and append a RCRL instruction to the active function.

func (*Context) RCRQ ¶

func (c *Context) RCRQ(ci, mr operand.Op)

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

Construct and append a RCRQ instruction to the active function.

func (*Context) RCRW ¶

func (c *Context) RCRW(ci, mr operand.Op)

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

Construct and append a RCRW instruction to the active function.

func (*Context) RDRANDL ¶

func (c *Context) RDRANDL(r operand.Op)

RDRANDL: Read Random Number.

Forms:

RDRANDL r32

Construct and append a RDRANDL instruction to the active function.

func (*Context) RDRANDQ ¶

func (c *Context) RDRANDQ(r operand.Op)

RDRANDQ: Read Random Number.

Forms:

RDRANDQ r64

Construct and append a RDRANDQ instruction to the active function.

func (*Context) RDRANDW ¶

func (c *Context) RDRANDW(r operand.Op)

RDRANDW: Read Random Number.

Forms:

RDRANDW r16

Construct and append a RDRANDW instruction to the active function.

func (*Context) RDSEEDL ¶

func (c *Context) RDSEEDL(r operand.Op)

RDSEEDL: Read Random SEED.

Forms:

RDSEEDL r32

Construct and append a RDSEEDL instruction to the active function.

func (*Context) RDSEEDQ ¶

func (c *Context) RDSEEDQ(r operand.Op)

RDSEEDQ: Read Random SEED.

Forms:

RDSEEDQ r64

Construct and append a RDSEEDQ instruction to the active function.

func (*Context) RDSEEDW ¶

func (c *Context) RDSEEDW(r operand.Op)

RDSEEDW: Read Random SEED.

Forms:

RDSEEDW r16

Construct and append a RDSEEDW instruction to the active function.

func (*Context) RDTSC ¶

func (c *Context) RDTSC()

RDTSC: Read Time-Stamp Counter.

Forms:

RDTSC

Construct and append a RDTSC instruction to the active function.

func (*Context) RDTSCP ¶

func (c *Context) RDTSCP()

RDTSCP: Read Time-Stamp Counter and Processor ID.

Forms:

RDTSCP

Construct and append a RDTSCP instruction to the active function.

func (*Context) RET ¶

func (c *Context) RET()

RET: Return from Procedure.

Forms:

RET

Construct and append a RET instruction to the active function.

func (*Context) RETFL ¶

func (c *Context) RETFL(i operand.Op)

RETFL: Return from Procedure.

Forms:

RETFL imm16

Construct and append a RETFL instruction to the active function.

func (*Context) RETFQ ¶

func (c *Context) RETFQ(i operand.Op)

RETFQ: Return from Procedure.

Forms:

RETFQ imm16

Construct and append a RETFQ instruction to the active function.

func (*Context) RETFW ¶

func (c *Context) RETFW(i operand.Op)

RETFW: Return from Procedure.

Forms:

RETFW imm16

Construct and append a RETFW instruction to the active function.

func (*Context) ROLB ¶

func (c *Context) ROLB(ci, mr operand.Op)

ROLB: Rotate Left.

Forms:

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

Construct and append a ROLB instruction to the active function.

func (*Context) ROLL ¶

func (c *Context) ROLL(ci, mr operand.Op)

ROLL: Rotate Left.

Forms:

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

Construct and append a ROLL instruction to the active function.

func (*Context) ROLQ ¶

func (c *Context) ROLQ(ci, mr operand.Op)

ROLQ: Rotate Left.

Forms:

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

Construct and append a ROLQ instruction to the active function.

func (*Context) ROLW ¶

func (c *Context) ROLW(ci, mr operand.Op)

ROLW: Rotate Left.

Forms:

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

Construct and append a ROLW instruction to the active function.

func (*Context) RORB ¶

func (c *Context) RORB(ci, mr operand.Op)

RORB: Rotate Right.

Forms:

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

Construct and append a RORB instruction to the active function.

func (*Context) RORL ¶

func (c *Context) RORL(ci, mr operand.Op)

RORL: Rotate Right.

Forms:

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

Construct and append a RORL instruction to the active function.

func (*Context) RORQ ¶

func (c *Context) RORQ(ci, mr operand.Op)

RORQ: Rotate Right.

Forms:

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

Construct and append a RORQ instruction to the active function.

func (*Context) RORW ¶

func (c *Context) RORW(ci, mr operand.Op)

RORW: Rotate Right.

Forms:

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

Construct and append a RORW instruction to the active function.

func (*Context) RORXL ¶

func (c *Context) RORXL(i, mr, r operand.Op)

RORXL: Rotate Right Logical Without Affecting Flags.

Forms:

RORXL imm8 r32 r32
RORXL imm8 m32 r32

Construct and append a RORXL instruction to the active function.

func (*Context) RORXQ ¶

func (c *Context) RORXQ(i, mr, r operand.Op)

RORXQ: Rotate Right Logical Without Affecting Flags.

Forms:

RORXQ imm8 r64 r64
RORXQ imm8 m64 r64

Construct and append a RORXQ instruction to the active function.

func (*Context) ROUNDPD ¶

func (c *Context) ROUNDPD(i, mx, x operand.Op)

ROUNDPD: Round Packed Double Precision Floating-Point Values.

Forms:

ROUNDPD imm8 xmm  xmm
ROUNDPD imm8 m128 xmm

Construct and append a ROUNDPD instruction to the active function.

func (*Context) ROUNDPS ¶

func (c *Context) ROUNDPS(i, mx, x operand.Op)

ROUNDPS: Round Packed Single Precision Floating-Point Values.

Forms:

ROUNDPS imm8 xmm  xmm
ROUNDPS imm8 m128 xmm

Construct and append a ROUNDPS instruction to the active function.

func (*Context) ROUNDSD ¶

func (c *Context) ROUNDSD(i, mx, x operand.Op)

ROUNDSD: Round Scalar Double Precision Floating-Point Values.

Forms:

ROUNDSD imm8 xmm xmm
ROUNDSD imm8 m64 xmm

Construct and append a ROUNDSD instruction to the active function.

func (*Context) ROUNDSS ¶

func (c *Context) ROUNDSS(i, mx, x operand.Op)

ROUNDSS: Round Scalar Single Precision Floating-Point Values.

Forms:

ROUNDSS imm8 xmm xmm
ROUNDSS imm8 m32 xmm

Construct and append a ROUNDSS instruction to the active function.

func (*Context) RSQRTPS ¶

func (c *Context) RSQRTPS(mx, x operand.Op)

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

Forms:

RSQRTPS xmm  xmm
RSQRTPS m128 xmm

Construct and append a RSQRTPS instruction to the active function.

func (*Context) RSQRTSS ¶

func (c *Context) RSQRTSS(mx, x operand.Op)

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

Forms:

RSQRTSS xmm xmm
RSQRTSS m32 xmm

Construct and append a RSQRTSS instruction to the active function.

func (*Context) Result ¶

func (c *Context) Result() (*ir.File, error)

Result returns the built file and any accumulated errors.

func (*Context) Return ¶

func (c *Context) Return(name string) gotypes.Component

Return returns a the named return value of the active function.

func (*Context) ReturnIndex ¶

func (c *Context) ReturnIndex(i int) gotypes.Component

ReturnIndex returns the ith argument of the active function.

func (*Context) SALB ¶

func (c *Context) SALB(ci, mr operand.Op)

SALB: Arithmetic Shift Left.

Forms:

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

Construct and append a SALB instruction to the active function.

func (*Context) SALL ¶

func (c *Context) SALL(ci, mr operand.Op)

SALL: Arithmetic Shift Left.

Forms:

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

Construct and append a SALL instruction to the active function.

func (*Context) SALQ ¶

func (c *Context) SALQ(ci, mr operand.Op)

SALQ: Arithmetic Shift Left.

Forms:

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

Construct and append a SALQ instruction to the active function.

func (*Context) SALW ¶

func (c *Context) SALW(ci, mr operand.Op)

SALW: Arithmetic Shift Left.

Forms:

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

Construct and append a SALW instruction to the active function.

func (*Context) SARB ¶

func (c *Context) SARB(ci, mr operand.Op)

SARB: Arithmetic Shift Right.

Forms:

SARB 1    r8
SARB imm8 r8
SARB cl   r8
SARB 1    m8
SARB imm8 m8
SARB cl   m8

Construct and append a SARB instruction to the active function.

func (*Context) SARL ¶

func (c *Context) SARL(ci, mr operand.Op)

SARL: Arithmetic Shift Right.

Forms:

SARL 1    r32
SARL imm8 r32
SARL cl   r32
SARL 1    m32
SARL imm8 m32
SARL cl   m32

Construct and append a SARL instruction to the active function.

func (*Context) SARQ ¶

func (c *Context) SARQ(ci, mr operand.Op)

SARQ: Arithmetic Shift Right.

Forms:

SARQ 1    r64
SARQ imm8 r64
SARQ cl   r64
SARQ 1    m64
SARQ imm8 m64
SARQ cl   m64

Construct and append a SARQ instruction to the active function.

func (*Context) SARW ¶

func (c *Context) SARW(ci, mr operand.Op)

SARW: Arithmetic Shift Right.

Forms:

SARW 1    r16
SARW imm8 r16
SARW cl   r16
SARW 1    m16
SARW imm8 m16
SARW cl   m16

Construct and append a SARW instruction to the active function.

func (*Context) SARXL ¶

func (c *Context) SARXL(r, mr, r1 operand.Op)

SARXL: Arithmetic Shift Right Without Affecting Flags.

Forms:

SARXL r32 r32 r32
SARXL r32 m32 r32

Construct and append a SARXL instruction to the active function.

func (*Context) SARXQ ¶

func (c *Context) SARXQ(r, mr, r1 operand.Op)

SARXQ: Arithmetic Shift Right Without Affecting Flags.

Forms:

SARXQ r64 r64 r64
SARXQ r64 m64 r64

Construct and append a SARXQ instruction to the active function.

func (*Context) SBBB ¶

func (c *Context) SBBB(imr, amr operand.Op)

SBBB: Subtract with Borrow.

Forms:

SBBB imm8 al
SBBB imm8 r8
SBBB r8   r8
SBBB m8   r8
SBBB imm8 m8
SBBB r8   m8

Construct and append a SBBB instruction to the active function.

func (*Context) SBBL ¶

func (c *Context) SBBL(imr, emr operand.Op)

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

Construct and append a SBBL instruction to the active function.

func (*Context) SBBQ ¶

func (c *Context) SBBQ(imr, mr operand.Op)

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

Construct and append a SBBQ instruction to the active function.

func (*Context) SBBW ¶

func (c *Context) SBBW(imr, amr operand.Op)

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

Construct and append a SBBW instruction to the active function.

func (*Context) SETCC ¶

func (c *Context) SETCC(mr operand.Op)

SETCC: Set byte if above or equal (CF == 0).

Forms:

SETCC r8
SETCC m8

Construct and append a SETCC instruction to the active function.

func (*Context) SETCS ¶

func (c *Context) SETCS(mr operand.Op)

SETCS: Set byte if below (CF == 1).

Forms:

SETCS r8
SETCS m8

Construct and append a SETCS instruction to the active function.

func (*Context) SETEQ ¶

func (c *Context) SETEQ(mr operand.Op)

SETEQ: Set byte if equal (ZF == 1).

Forms:

SETEQ r8
SETEQ m8

Construct and append a SETEQ instruction to the active function.

func (*Context) SETGE ¶

func (c *Context) SETGE(mr operand.Op)

SETGE: Set byte if greater or equal (SF == OF).

Forms:

SETGE r8
SETGE m8

Construct and append a SETGE instruction to the active function.

func (*Context) SETGT ¶

func (c *Context) SETGT(mr operand.Op)

SETGT: Set byte if greater (ZF == 0 and SF == OF).

Forms:

SETGT r8
SETGT m8

Construct and append a SETGT instruction to the active function.

func (*Context) SETHI ¶

func (c *Context) SETHI(mr operand.Op)

SETHI: Set byte if above (CF == 0 and ZF == 0).

Forms:

SETHI r8
SETHI m8

Construct and append a SETHI instruction to the active function.

func (*Context) SETLE ¶

func (c *Context) SETLE(mr operand.Op)

SETLE: Set byte if less or equal (ZF == 1 or SF != OF).

Forms:

SETLE r8
SETLE m8

Construct and append a SETLE instruction to the active function.

func (*Context) SETLS ¶

func (c *Context) SETLS(mr operand.Op)

SETLS: Set byte if below or equal (CF == 1 or ZF == 1).

Forms:

SETLS r8
SETLS m8

Construct and append a SETLS instruction to the active function.

func (*Context) SETLT ¶

func (c *Context) SETLT(mr operand.Op)

SETLT: Set byte if less (SF != OF).

Forms:

SETLT r8
SETLT m8

Construct and append a SETLT instruction to the active function.

func (*Context) SETMI ¶

func (c *Context) SETMI(mr operand.Op)

SETMI: Set byte if sign (SF == 1).

Forms:

SETMI r8
SETMI m8

Construct and append a SETMI instruction to the active function.

func (*Context) SETNE ¶

func (c *Context) SETNE(mr operand.Op)

SETNE: Set byte if not equal (ZF == 0).

Forms:

SETNE r8
SETNE m8

Construct and append a SETNE instruction to the active function.

func (*Context) SETOC ¶

func (c *Context) SETOC(mr operand.Op)

SETOC: Set byte if not overflow (OF == 0).

Forms:

SETOC r8
SETOC m8

Construct and append a SETOC instruction to the active function.

func (*Context) SETOS ¶

func (c *Context) SETOS(mr operand.Op)

SETOS: Set byte if overflow (OF == 1).

Forms:

SETOS r8
SETOS m8

Construct and append a SETOS instruction to the active function.

func (*Context) SETPC ¶

func (c *Context) SETPC(mr operand.Op)

SETPC: Set byte if not parity (PF == 0).

Forms:

SETPC r8
SETPC m8

Construct and append a SETPC instruction to the active function.

func (*Context) SETPL ¶

func (c *Context) SETPL(mr operand.Op)

SETPL: Set byte if not sign (SF == 0).

Forms:

SETPL r8
SETPL m8

Construct and append a SETPL instruction to the active function.

func (*Context) SETPS ¶

func (c *Context) SETPS(mr operand.Op)

SETPS: Set byte if parity (PF == 1).

Forms:

SETPS r8
SETPS m8

Construct and append a SETPS instruction to the active function.

func (*Context) SFENCE ¶

func (c *Context) SFENCE()

SFENCE: Store Fence.

Forms:

SFENCE

Construct and append a SFENCE instruction to the active function.

func (*Context) SHA1MSG1 ¶

func (c *Context) SHA1MSG1(mx, x operand.Op)

SHA1MSG1: Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords.

Forms:

SHA1MSG1 xmm  xmm
SHA1MSG1 m128 xmm

Construct and append a SHA1MSG1 instruction to the active function.

func (*Context) SHA1MSG2 ¶

func (c *Context) SHA1MSG2(mx, x operand.Op)

SHA1MSG2: Perform a Final Calculation for the Next Four SHA1 Message Doublewords.

Forms:

SHA1MSG2 xmm  xmm
SHA1MSG2 m128 xmm

Construct and append a SHA1MSG2 instruction to the active function.

func (*Context) SHA1NEXTE ¶

func (c *Context) SHA1NEXTE(mx, x operand.Op)

SHA1NEXTE: Calculate SHA1 State Variable E after Four Rounds.

Forms:

SHA1NEXTE xmm  xmm
SHA1NEXTE m128 xmm

Construct and append a SHA1NEXTE instruction to the active function.

func (*Context) SHA1RNDS4 ¶

func (c *Context) SHA1RNDS4(i, mx, x operand.Op)

SHA1RNDS4: Perform Four Rounds of SHA1 Operation.

Forms:

SHA1RNDS4 imm2u xmm  xmm
SHA1RNDS4 imm2u m128 xmm

Construct and append a SHA1RNDS4 instruction to the active function.

func (*Context) SHA256MSG1 ¶

func (c *Context) SHA256MSG1(mx, x operand.Op)

SHA256MSG1: Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords.

Forms:

SHA256MSG1 xmm  xmm
SHA256MSG1 m128 xmm

Construct and append a SHA256MSG1 instruction to the active function.

func (*Context) SHA256MSG2 ¶

func (c *Context) SHA256MSG2(mx, x operand.Op)

SHA256MSG2: Perform a Final Calculation for the Next Four SHA256 Message Doublewords.

Forms:

SHA256MSG2 xmm  xmm
SHA256MSG2 m128 xmm

Construct and append a SHA256MSG2 instruction to the active function.

func (*Context) SHA256RNDS2 ¶

func (c *Context) SHA256RNDS2(x, mx, x1 operand.Op)

SHA256RNDS2: Perform Two Rounds of SHA256 Operation.

Forms:

SHA256RNDS2 xmm0 xmm  xmm
SHA256RNDS2 xmm0 m128 xmm

Construct and append a SHA256RNDS2 instruction to the active function.

func (*Context) SHLB ¶

func (c *Context) SHLB(ci, mr operand.Op)

SHLB: Logical Shift Left.

Forms:

SHLB 1    r8
SHLB imm8 r8
SHLB cl   r8
SHLB 1    m8
SHLB imm8 m8
SHLB cl   m8

Construct and append a SHLB instruction to the active function.

func (*Context) SHLL ¶

func (c *Context) SHLL(ops ...operand.Op)

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

Construct and append a SHLL instruction to the active function.

func (*Context) SHLQ ¶

func (c *Context) SHLQ(ops ...operand.Op)

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

Construct and append a SHLQ instruction to the active function.

func (*Context) SHLW ¶

func (c *Context) SHLW(ops ...operand.Op)

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

Construct and append a SHLW instruction to the active function.

func (*Context) SHLXL ¶

func (c *Context) SHLXL(r, mr, r1 operand.Op)

SHLXL: Logical Shift Left Without Affecting Flags.

Forms:

SHLXL r32 r32 r32
SHLXL r32 m32 r32

Construct and append a SHLXL instruction to the active function.

func (*Context) SHLXQ ¶

func (c *Context) SHLXQ(r, mr, r1 operand.Op)

SHLXQ: Logical Shift Left Without Affecting Flags.

Forms:

SHLXQ r64 r64 r64
SHLXQ r64 m64 r64

Construct and append a SHLXQ instruction to the active function.

func (*Context) SHRB ¶

func (c *Context) SHRB(ci, mr operand.Op)

SHRB: Logical Shift Right.

Forms:

SHRB 1    r8
SHRB imm8 r8
SHRB cl   r8
SHRB 1    m8
SHRB imm8 m8
SHRB cl   m8

Construct and append a SHRB instruction to the active function.

func (*Context) SHRL ¶

func (c *Context) SHRL(ops ...operand.Op)

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

Construct and append a SHRL instruction to the active function.

func (*Context) SHRQ ¶

func (c *Context) SHRQ(ops ...operand.Op)

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

Construct and append a SHRQ instruction to the active function.

func (*Context) SHRW ¶

func (c *Context) SHRW(ops ...operand.Op)

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

Construct and append a SHRW instruction to the active function.

func (*Context) SHRXL ¶

func (c *Context) SHRXL(r, mr, r1 operand.Op)

SHRXL: Logical Shift Right Without Affecting Flags.

Forms:

SHRXL r32 r32 r32
SHRXL r32 m32 r32

Construct and append a SHRXL instruction to the active function.

func (*Context) SHRXQ ¶

func (c *Context) SHRXQ(r, mr, r1 operand.Op)

SHRXQ: Logical Shift Right Without Affecting Flags.

Forms:

SHRXQ r64 r64 r64
SHRXQ r64 m64 r64

Construct and append a SHRXQ instruction to the active function.

func (*Context) SHUFPD ¶

func (c *Context) SHUFPD(i, mx, x operand.Op)

SHUFPD: Shuffle Packed Double-Precision Floating-Point Values.

Forms:

SHUFPD imm8 xmm  xmm
SHUFPD imm8 m128 xmm

Construct and append a SHUFPD instruction to the active function.

func (*Context) SHUFPS ¶

func (c *Context) SHUFPS(i, mx, x operand.Op)

SHUFPS: Shuffle Packed Single-Precision Floating-Point Values.

Forms:

SHUFPS imm8 xmm  xmm
SHUFPS imm8 m128 xmm

Construct and append a SHUFPS instruction to the active function.

func (*Context) SQRTPD ¶

func (c *Context) SQRTPD(mx, x operand.Op)

SQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values.

Forms:

SQRTPD xmm  xmm
SQRTPD m128 xmm

Construct and append a SQRTPD instruction to the active function.

func (*Context) SQRTPS ¶

func (c *Context) SQRTPS(mx, x operand.Op)

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

Forms:

SQRTPS xmm  xmm
SQRTPS m128 xmm

Construct and append a SQRTPS instruction to the active function.

func (*Context) SQRTSD ¶

func (c *Context) SQRTSD(mx, x operand.Op)

SQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value.

Forms:

SQRTSD xmm xmm
SQRTSD m64 xmm

Construct and append a SQRTSD instruction to the active function.

func (*Context) SQRTSS ¶

func (c *Context) SQRTSS(mx, x operand.Op)

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

Forms:

SQRTSS xmm xmm
SQRTSS m32 xmm

Construct and append a SQRTSS instruction to the active function.

func (*Context) STC ¶

func (c *Context) STC()

STC: Set Carry Flag.

Forms:

STC

Construct and append a STC instruction to the active function.

func (*Context) STD ¶

func (c *Context) STD()

STD: Set Direction Flag.

Forms:

STD

Construct and append a STD instruction to the active function.

func (*Context) STMXCSR ¶

func (c *Context) STMXCSR(m operand.Op)

STMXCSR: Store MXCSR Register State.

Forms:

STMXCSR m32

Construct and append a STMXCSR instruction to the active function.

func (*Context) SUBB ¶

func (c *Context) SUBB(imr, amr operand.Op)

SUBB: Subtract.

Forms:

SUBB imm8 al
SUBB imm8 r8
SUBB r8   r8
SUBB m8   r8
SUBB imm8 m8
SUBB r8   m8

Construct and append a SUBB instruction to the active function.

func (*Context) SUBL ¶

func (c *Context) SUBL(imr, emr operand.Op)

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

Construct and append a SUBL instruction to the active function.

func (*Context) SUBPD ¶

func (c *Context) SUBPD(mx, x operand.Op)

SUBPD: Subtract Packed Double-Precision Floating-Point Values.

Forms:

SUBPD xmm  xmm
SUBPD m128 xmm

Construct and append a SUBPD instruction to the active function.

func (*Context) SUBPS ¶

func (c *Context) SUBPS(mx, x operand.Op)

SUBPS: Subtract Packed Single-Precision Floating-Point Values.

Forms:

SUBPS xmm  xmm
SUBPS m128 xmm

Construct and append a SUBPS instruction to the active function.

func (*Context) SUBQ ¶

func (c *Context) SUBQ(imr, mr operand.Op)

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

Construct and append a SUBQ instruction to the active function.

func (*Context) SUBSD ¶

func (c *Context) SUBSD(mx, x operand.Op)

SUBSD: Subtract Scalar Double-Precision Floating-Point Values.

Forms:

SUBSD xmm xmm
SUBSD m64 xmm

Construct and append a SUBSD instruction to the active function.

func (*Context) SUBSS ¶

func (c *Context) SUBSS(mx, x operand.Op)

SUBSS: Subtract Scalar Single-Precision Floating-Point Values.

Forms:

SUBSS xmm xmm
SUBSS m32 xmm

Construct and append a SUBSS instruction to the active function.

func (*Context) SUBW ¶

func (c *Context) SUBW(imr, amr operand.Op)

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

Construct and append a SUBW instruction to the active function.

func (*Context) SYSCALL ¶

func (c *Context) SYSCALL()

SYSCALL: Fast System Call.

Forms:

SYSCALL

Construct and append a SYSCALL instruction to the active function.

func (*Context) Signature ¶

func (c *Context) Signature(s *gotypes.Signature)

Signature sets the signature for the currently active function.

func (*Context) SignatureExpr ¶

func (c *Context) SignatureExpr(expr string)

SignatureExpr parses the signature expression and sets it as the active function's signature.

func (*Context) StaticGlobal ¶

func (c *Context) StaticGlobal(name string) operand.Mem

StaticGlobal adds a new static data section to the file and returns a pointer to it.

func (*Context) Store ¶

func (c *Context) Store(src reg.Register, dst gotypes.Component)

Store register src into return value dst. This is syntactic sugar: it will attempt to select the right MOV instruction based on the types involved.

func (*Context) TESTB ¶

func (c *Context) TESTB(ir, amr operand.Op)

TESTB: Logical Compare.

Forms:

TESTB imm8 al
TESTB imm8 r8
TESTB r8   r8
TESTB imm8 m8
TESTB r8   m8

Construct and append a TESTB instruction to the active function.

func (*Context) TESTL ¶

func (c *Context) TESTL(ir, emr operand.Op)

TESTL: Logical Compare.

Forms:

TESTL imm32 eax
TESTL imm32 r32
TESTL r32   r32
TESTL imm32 m32
TESTL r32   m32

Construct and append a TESTL instruction to the active function.

func (*Context) TESTQ ¶

func (c *Context) TESTQ(ir, mr operand.Op)

TESTQ: Logical Compare.

Forms:

TESTQ imm32 rax
TESTQ imm32 r64
TESTQ r64   r64
TESTQ imm32 m64
TESTQ r64   m64

Construct and append a TESTQ instruction to the active function.

func (*Context) TESTW ¶

func (c *Context) TESTW(ir, amr operand.Op)

TESTW: Logical Compare.

Forms:

TESTW imm16 ax
TESTW imm16 r16
TESTW r16   r16
TESTW imm16 m16
TESTW r16   m16

Construct and append a TESTW instruction to the active function.

func (*Context) TZCNTL ¶

func (c *Context) TZCNTL(mr, r operand.Op)

TZCNTL: Count the Number of Trailing Zero Bits.

Forms:

TZCNTL r32 r32
TZCNTL m32 r32

Construct and append a TZCNTL instruction to the active function.

func (*Context) TZCNTQ ¶

func (c *Context) TZCNTQ(mr, r operand.Op)

TZCNTQ: Count the Number of Trailing Zero Bits.

Forms:

TZCNTQ r64 r64
TZCNTQ m64 r64

Construct and append a TZCNTQ instruction to the active function.

func (*Context) TZCNTW ¶

func (c *Context) TZCNTW(mr, r operand.Op)

TZCNTW: Count the Number of Trailing Zero Bits.

Forms:

TZCNTW r16 r16
TZCNTW m16 r16

Construct and append a TZCNTW instruction to the active function.

func (*Context) UCOMISD ¶

func (c *Context) UCOMISD(mx, x operand.Op)

UCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

UCOMISD xmm xmm
UCOMISD m64 xmm

Construct and append a UCOMISD instruction to the active function.

func (*Context) UCOMISS ¶

func (c *Context) UCOMISS(mx, x operand.Op)

UCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

UCOMISS xmm xmm
UCOMISS m32 xmm

Construct and append a UCOMISS instruction to the active function.

func (*Context) UD2 ¶

func (c *Context) UD2()

UD2: Undefined Instruction.

Forms:

UD2

Construct and append a UD2 instruction to the active function.

func (*Context) UNPCKHPD ¶

func (c *Context) UNPCKHPD(mx, x operand.Op)

UNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values.

Forms:

UNPCKHPD xmm  xmm
UNPCKHPD m128 xmm

Construct and append a UNPCKHPD instruction to the active function.

func (*Context) UNPCKHPS ¶

func (c *Context) UNPCKHPS(mx, x operand.Op)

UNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values.

Forms:

UNPCKHPS xmm  xmm
UNPCKHPS m128 xmm

Construct and append a UNPCKHPS instruction to the active function.

func (*Context) UNPCKLPD ¶

func (c *Context) UNPCKLPD(mx, x operand.Op)

UNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values.

Forms:

UNPCKLPD xmm  xmm
UNPCKLPD m128 xmm

Construct and append a UNPCKLPD instruction to the active function.

func (*Context) UNPCKLPS ¶

func (c *Context) UNPCKLPS(mx, x operand.Op)

UNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values.

Forms:

UNPCKLPS xmm  xmm
UNPCKLPS m128 xmm

Construct and append a UNPCKLPS instruction to the active function.

func (*Context) VADDPD ¶

func (c *Context) VADDPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VADDPD instruction to the active function.

func (*Context) VADDPS ¶

func (c *Context) VADDPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VADDPS instruction to the active function.

func (*Context) VADDSD ¶

func (c *Context) VADDSD(mx, x, x1 operand.Op)

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

Forms:

VADDSD xmm xmm xmm
VADDSD m64 xmm xmm

Construct and append a VADDSD instruction to the active function.

func (*Context) VADDSS ¶

func (c *Context) VADDSS(mx, x, x1 operand.Op)

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

Forms:

VADDSS xmm xmm xmm
VADDSS m32 xmm xmm

Construct and append a VADDSS instruction to the active function.

func (*Context) VADDSUBPD ¶

func (c *Context) VADDSUBPD(mxy, xy, xy1 operand.Op)

VADDSUBPD: Packed Double-FP Add/Subtract.

Forms:

VADDSUBPD xmm  xmm xmm
VADDSUBPD m128 xmm xmm
VADDSUBPD ymm  ymm ymm
VADDSUBPD m256 ymm ymm

Construct and append a VADDSUBPD instruction to the active function.

func (*Context) VADDSUBPS ¶

func (c *Context) VADDSUBPS(mxy, xy, xy1 operand.Op)

VADDSUBPS: Packed Single-FP Add/Subtract.

Forms:

VADDSUBPS xmm  xmm xmm
VADDSUBPS m128 xmm xmm
VADDSUBPS ymm  ymm ymm
VADDSUBPS m256 ymm ymm

Construct and append a VADDSUBPS instruction to the active function.

func (*Context) VAESDEC ¶

func (c *Context) VAESDEC(mx, x, x1 operand.Op)

VAESDEC: Perform One Round of an AES Decryption Flow.

Forms:

VAESDEC xmm  xmm xmm
VAESDEC m128 xmm xmm

Construct and append a VAESDEC instruction to the active function.

func (*Context) VAESDECLAST ¶

func (c *Context) VAESDECLAST(mx, x, x1 operand.Op)

VAESDECLAST: Perform Last Round of an AES Decryption Flow.

Forms:

VAESDECLAST xmm  xmm xmm
VAESDECLAST m128 xmm xmm

Construct and append a VAESDECLAST instruction to the active function.

func (*Context) VAESENC ¶

func (c *Context) VAESENC(mx, x, x1 operand.Op)

VAESENC: Perform One Round of an AES Encryption Flow.

Forms:

VAESENC xmm  xmm xmm
VAESENC m128 xmm xmm

Construct and append a VAESENC instruction to the active function.

func (*Context) VAESENCLAST ¶

func (c *Context) VAESENCLAST(mx, x, x1 operand.Op)

VAESENCLAST: Perform Last Round of an AES Encryption Flow.

Forms:

VAESENCLAST xmm  xmm xmm
VAESENCLAST m128 xmm xmm

Construct and append a VAESENCLAST instruction to the active function.

func (*Context) VAESIMC ¶

func (c *Context) VAESIMC(mx, x operand.Op)

VAESIMC: Perform the AES InvMixColumn Transformation.

Forms:

VAESIMC xmm  xmm
VAESIMC m128 xmm

Construct and append a VAESIMC instruction to the active function.

func (*Context) VAESKEYGENASSIST ¶

func (c *Context) VAESKEYGENASSIST(i, mx, x operand.Op)

VAESKEYGENASSIST: AES Round Key Generation Assist.

Forms:

VAESKEYGENASSIST imm8 xmm  xmm
VAESKEYGENASSIST imm8 m128 xmm

Construct and append a VAESKEYGENASSIST instruction to the active function.

func (*Context) VANDNPD ¶

func (c *Context) VANDNPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDNPD instruction to the active function.

func (*Context) VANDNPS ¶

func (c *Context) VANDNPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDNPS instruction to the active function.

func (*Context) VANDPD ¶

func (c *Context) VANDPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDPD instruction to the active function.

func (*Context) VANDPS ¶

func (c *Context) VANDPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VANDPS instruction to the active function.

func (*Context) VBLENDPD ¶

func (c *Context) VBLENDPD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VBLENDPD instruction to the active function.

func (*Context) VBLENDPS ¶

func (c *Context) VBLENDPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VBLENDPS instruction to the active function.

func (*Context) VBLENDVPD ¶

func (c *Context) VBLENDVPD(xy, mxy, xy1, xy2 operand.Op)

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

Construct and append a VBLENDVPD instruction to the active function.

func (*Context) VBLENDVPS ¶

func (c *Context) VBLENDVPS(xy, mxy, xy1, xy2 operand.Op)

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

Construct and append a VBLENDVPS instruction to the active function.

func (*Context) VBROADCASTF128 ¶

func (c *Context) VBROADCASTF128(m, y operand.Op)

VBROADCASTF128: Broadcast 128 Bit of Floating-Point Data.

Forms:

VBROADCASTF128 m128 ymm

Construct and append a VBROADCASTF128 instruction to the active function.

func (*Context) VBROADCASTI128 ¶

func (c *Context) VBROADCASTI128(m, y operand.Op)

VBROADCASTI128: Broadcast 128 Bits of Integer Data.

Forms:

VBROADCASTI128 m128 ymm

Construct and append a VBROADCASTI128 instruction to the active function.

func (*Context) VBROADCASTSD ¶

func (c *Context) VBROADCASTSD(mx, y operand.Op)

VBROADCASTSD: Broadcast Double-Precision Floating-Point Element.

Forms:

VBROADCASTSD xmm ymm
VBROADCASTSD m64 ymm

Construct and append a VBROADCASTSD instruction to the active function.

func (*Context) VBROADCASTSS ¶

func (c *Context) VBROADCASTSS(mx, xy operand.Op)

VBROADCASTSS: Broadcast Single-Precision Floating-Point Element.

Forms:

VBROADCASTSS xmm xmm
VBROADCASTSS m32 xmm
VBROADCASTSS xmm ymm
VBROADCASTSS m32 ymm

Construct and append a VBROADCASTSS instruction to the active function.

func (*Context) VCMPPD ¶

func (c *Context) VCMPPD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VCMPPD instruction to the active function.

func (*Context) VCMPPS ¶

func (c *Context) VCMPPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VCMPPS instruction to the active function.

func (*Context) VCMPSD ¶

func (c *Context) VCMPSD(i, mx, x, x1 operand.Op)

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

Forms:

VCMPSD imm8 xmm xmm xmm
VCMPSD imm8 m64 xmm xmm

Construct and append a VCMPSD instruction to the active function.

func (*Context) VCMPSS ¶

func (c *Context) VCMPSS(i, mx, x, x1 operand.Op)

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

Forms:

VCMPSS imm8 xmm xmm xmm
VCMPSS imm8 m32 xmm xmm

Construct and append a VCMPSS instruction to the active function.

func (*Context) VCOMISD ¶

func (c *Context) VCOMISD(mx, x operand.Op)

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

Forms:

VCOMISD xmm xmm
VCOMISD m64 xmm

Construct and append a VCOMISD instruction to the active function.

func (*Context) VCOMISS ¶

func (c *Context) VCOMISS(mx, x operand.Op)

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

Forms:

VCOMISS xmm xmm
VCOMISS m32 xmm

Construct and append a VCOMISS instruction to the active function.

func (*Context) VCVTDQ2PD ¶

func (c *Context) VCVTDQ2PD(mx, xy operand.Op)

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

Forms:

VCVTDQ2PD xmm  xmm
VCVTDQ2PD m64  xmm
VCVTDQ2PD xmm  ymm
VCVTDQ2PD m128 ymm

Construct and append a VCVTDQ2PD instruction to the active function.

func (*Context) VCVTDQ2PS ¶

func (c *Context) VCVTDQ2PS(mxy, xy operand.Op)

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

Forms:

VCVTDQ2PS xmm  xmm
VCVTDQ2PS m128 xmm
VCVTDQ2PS ymm  ymm
VCVTDQ2PS m256 ymm

Construct and append a VCVTDQ2PS instruction to the active function.

func (*Context) VCVTPD2DQX ¶

func (c *Context) VCVTPD2DQX(mx, x operand.Op)

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

Forms:

VCVTPD2DQX xmm  xmm
VCVTPD2DQX m128 xmm

Construct and append a VCVTPD2DQX instruction to the active function.

func (*Context) VCVTPD2DQY ¶

func (c *Context) VCVTPD2DQY(my, x operand.Op)

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

Forms:

VCVTPD2DQY ymm  xmm
VCVTPD2DQY m256 xmm

Construct and append a VCVTPD2DQY instruction to the active function.

func (*Context) VCVTPD2PSX ¶

func (c *Context) VCVTPD2PSX(mx, x operand.Op)

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

Forms:

VCVTPD2PSX xmm  xmm
VCVTPD2PSX m128 xmm

Construct and append a VCVTPD2PSX instruction to the active function.

func (*Context) VCVTPD2PSY ¶

func (c *Context) VCVTPD2PSY(my, x operand.Op)

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

Forms:

VCVTPD2PSY ymm  xmm
VCVTPD2PSY m256 xmm

Construct and append a VCVTPD2PSY instruction to the active function.

func (*Context) VCVTPH2PS ¶

func (c *Context) VCVTPH2PS(mx, xy operand.Op)

VCVTPH2PS: Convert Half-Precision FP Values to Single-Precision FP Values.

Forms:

VCVTPH2PS xmm  xmm
VCVTPH2PS m64  xmm
VCVTPH2PS xmm  ymm
VCVTPH2PS m128 ymm

Construct and append a VCVTPH2PS instruction to the active function.

func (*Context) VCVTPS2DQ ¶

func (c *Context) VCVTPS2DQ(mxy, xy operand.Op)

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

Forms:

VCVTPS2DQ xmm  xmm
VCVTPS2DQ m128 xmm
VCVTPS2DQ ymm  ymm
VCVTPS2DQ m256 ymm

Construct and append a VCVTPS2DQ instruction to the active function.

func (*Context) VCVTPS2PD ¶

func (c *Context) VCVTPS2PD(mx, xy operand.Op)

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

Construct and append a VCVTPS2PD instruction to the active function.

func (*Context) VCVTPS2PH ¶

func (c *Context) VCVTPS2PH(i, xy, mx operand.Op)

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

Construct and append a VCVTPS2PH instruction to the active function.

func (*Context) VCVTSD2SI ¶

func (c *Context) VCVTSD2SI(mx, r operand.Op)

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

Forms:

VCVTSD2SI xmm r32
VCVTSD2SI m64 r32

Construct and append a VCVTSD2SI instruction to the active function.

func (*Context) VCVTSD2SIQ ¶

func (c *Context) VCVTSD2SIQ(mx, r operand.Op)

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

Forms:

VCVTSD2SIQ xmm r64
VCVTSD2SIQ m64 r64

Construct and append a VCVTSD2SIQ instruction to the active function.

func (*Context) VCVTSD2SS ¶

func (c *Context) VCVTSD2SS(mx, x, x1 operand.Op)

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

Forms:

VCVTSD2SS xmm xmm xmm
VCVTSD2SS m64 xmm xmm

Construct and append a VCVTSD2SS instruction to the active function.

func (*Context) VCVTSI2SDL ¶

func (c *Context) VCVTSI2SDL(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SDL r32 xmm xmm
VCVTSI2SDL m32 xmm xmm

Construct and append a VCVTSI2SDL instruction to the active function.

func (*Context) VCVTSI2SDQ ¶

func (c *Context) VCVTSI2SDQ(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SDQ r64 xmm xmm
VCVTSI2SDQ m64 xmm xmm

Construct and append a VCVTSI2SDQ instruction to the active function.

func (*Context) VCVTSI2SSL ¶

func (c *Context) VCVTSI2SSL(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SSL r32 xmm xmm
VCVTSI2SSL m32 xmm xmm

Construct and append a VCVTSI2SSL instruction to the active function.

func (*Context) VCVTSI2SSQ ¶

func (c *Context) VCVTSI2SSQ(mr, x, x1 operand.Op)

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

Forms:

VCVTSI2SSQ r64 xmm xmm
VCVTSI2SSQ m64 xmm xmm

Construct and append a VCVTSI2SSQ instruction to the active function.

func (*Context) VCVTSS2SD ¶

func (c *Context) VCVTSS2SD(mx, x, x1 operand.Op)

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

Forms:

VCVTSS2SD xmm xmm xmm
VCVTSS2SD m32 xmm xmm

Construct and append a VCVTSS2SD instruction to the active function.

func (*Context) VCVTSS2SI ¶

func (c *Context) VCVTSS2SI(mx, r operand.Op)

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

Forms:

VCVTSS2SI xmm r32
VCVTSS2SI m32 r32

Construct and append a VCVTSS2SI instruction to the active function.

func (*Context) VCVTSS2SIQ ¶

func (c *Context) VCVTSS2SIQ(mx, r operand.Op)

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

Forms:

VCVTSS2SIQ xmm r64
VCVTSS2SIQ m32 r64

Construct and append a VCVTSS2SIQ instruction to the active function.

func (*Context) VCVTTPD2DQX ¶

func (c *Context) VCVTTPD2DQX(mx, x operand.Op)

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

Forms:

VCVTTPD2DQX xmm  xmm
VCVTTPD2DQX m128 xmm

Construct and append a VCVTTPD2DQX instruction to the active function.

func (*Context) VCVTTPD2DQY ¶

func (c *Context) VCVTTPD2DQY(my, x operand.Op)

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

Forms:

VCVTTPD2DQY ymm  xmm
VCVTTPD2DQY m256 xmm

Construct and append a VCVTTPD2DQY instruction to the active function.

func (*Context) VCVTTPS2DQ ¶

func (c *Context) VCVTTPS2DQ(mxy, xy operand.Op)

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

Construct and append a VCVTTPS2DQ instruction to the active function.

func (*Context) VCVTTSD2SI ¶

func (c *Context) VCVTTSD2SI(mx, r operand.Op)

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

Forms:

VCVTTSD2SI xmm r32
VCVTTSD2SI m64 r32

Construct and append a VCVTTSD2SI instruction to the active function.

func (*Context) VCVTTSD2SIQ ¶

func (c *Context) VCVTTSD2SIQ(mx, r operand.Op)

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

Forms:

VCVTTSD2SIQ xmm r64
VCVTTSD2SIQ m64 r64

Construct and append a VCVTTSD2SIQ instruction to the active function.

func (*Context) VCVTTSS2SI ¶

func (c *Context) VCVTTSS2SI(mx, r operand.Op)

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

Forms:

VCVTTSS2SI xmm r32
VCVTTSS2SI m32 r32

Construct and append a VCVTTSS2SI instruction to the active function.

func (*Context) VCVTTSS2SIQ ¶

func (c *Context) VCVTTSS2SIQ(mx, r operand.Op)

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

Forms:

VCVTTSS2SIQ xmm r64
VCVTTSS2SIQ m32 r64

Construct and append a VCVTTSS2SIQ instruction to the active function.

func (*Context) VDIVPD ¶

func (c *Context) VDIVPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VDIVPD instruction to the active function.

func (*Context) VDIVPS ¶

func (c *Context) VDIVPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VDIVPS instruction to the active function.

func (*Context) VDIVSD ¶

func (c *Context) VDIVSD(mx, x, x1 operand.Op)

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

Forms:

VDIVSD xmm xmm xmm
VDIVSD m64 xmm xmm

Construct and append a VDIVSD instruction to the active function.

func (*Context) VDIVSS ¶

func (c *Context) VDIVSS(mx, x, x1 operand.Op)

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

Forms:

VDIVSS xmm xmm xmm
VDIVSS m32 xmm xmm

Construct and append a VDIVSS instruction to the active function.

func (*Context) VDPPD ¶

func (c *Context) VDPPD(i, mx, x, x1 operand.Op)

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

Forms:

VDPPD imm8 xmm  xmm xmm
VDPPD imm8 m128 xmm xmm

Construct and append a VDPPD instruction to the active function.

func (*Context) VDPPS ¶

func (c *Context) VDPPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VDPPS instruction to the active function.

func (*Context) VEXTRACTF128 ¶

func (c *Context) VEXTRACTF128(i, y, mx operand.Op)

VEXTRACTF128: Extract Packed Floating-Point Values.

Forms:

VEXTRACTF128 imm8 ymm xmm
VEXTRACTF128 imm8 ymm m128

Construct and append a VEXTRACTF128 instruction to the active function.

func (*Context) VEXTRACTI128 ¶

func (c *Context) VEXTRACTI128(i, y, mx operand.Op)

VEXTRACTI128: Extract Packed Integer Values.

Forms:

VEXTRACTI128 imm8 ymm xmm
VEXTRACTI128 imm8 ymm m128

Construct and append a VEXTRACTI128 instruction to the active function.

func (*Context) VEXTRACTPS ¶

func (c *Context) VEXTRACTPS(i, x, mr operand.Op)

VEXTRACTPS: Extract Packed Single Precision Floating-Point Value.

Forms:

VEXTRACTPS imm8 xmm r32
VEXTRACTPS imm8 xmm m32

Construct and append a VEXTRACTPS instruction to the active function.

func (*Context) VFMADD132PD ¶

func (c *Context) VFMADD132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD132PD instruction to the active function.

func (*Context) VFMADD132PS ¶

func (c *Context) VFMADD132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD132PS instruction to the active function.

func (*Context) VFMADD132SD ¶

func (c *Context) VFMADD132SD(mx, x, x1 operand.Op)

VFMADD132SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD132SD xmm xmm xmm
VFMADD132SD m64 xmm xmm

Construct and append a VFMADD132SD instruction to the active function.

func (*Context) VFMADD132SS ¶

func (c *Context) VFMADD132SS(mx, x, x1 operand.Op)

VFMADD132SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD132SS xmm xmm xmm
VFMADD132SS m32 xmm xmm

Construct and append a VFMADD132SS instruction to the active function.

func (*Context) VFMADD213PD ¶

func (c *Context) VFMADD213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD213PD instruction to the active function.

func (*Context) VFMADD213PS ¶

func (c *Context) VFMADD213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD213PS instruction to the active function.

func (*Context) VFMADD213SD ¶

func (c *Context) VFMADD213SD(mx, x, x1 operand.Op)

VFMADD213SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD213SD xmm xmm xmm
VFMADD213SD m64 xmm xmm

Construct and append a VFMADD213SD instruction to the active function.

func (*Context) VFMADD213SS ¶

func (c *Context) VFMADD213SS(mx, x, x1 operand.Op)

VFMADD213SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD213SS xmm xmm xmm
VFMADD213SS m32 xmm xmm

Construct and append a VFMADD213SS instruction to the active function.

func (*Context) VFMADD231PD ¶

func (c *Context) VFMADD231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD231PD instruction to the active function.

func (*Context) VFMADD231PS ¶

func (c *Context) VFMADD231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADD231PS instruction to the active function.

func (*Context) VFMADD231SD ¶

func (c *Context) VFMADD231SD(mx, x, x1 operand.Op)

VFMADD231SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFMADD231SD xmm xmm xmm
VFMADD231SD m64 xmm xmm

Construct and append a VFMADD231SD instruction to the active function.

func (*Context) VFMADD231SS ¶

func (c *Context) VFMADD231SS(mx, x, x1 operand.Op)

VFMADD231SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFMADD231SS xmm xmm xmm
VFMADD231SS m32 xmm xmm

Construct and append a VFMADD231SS instruction to the active function.

func (*Context) VFMADDSUB132PD ¶

func (c *Context) VFMADDSUB132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB132PD instruction to the active function.

func (*Context) VFMADDSUB132PS ¶

func (c *Context) VFMADDSUB132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB132PS instruction to the active function.

func (*Context) VFMADDSUB213PD ¶

func (c *Context) VFMADDSUB213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB213PD instruction to the active function.

func (*Context) VFMADDSUB213PS ¶

func (c *Context) VFMADDSUB213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB213PS instruction to the active function.

func (*Context) VFMADDSUB231PD ¶

func (c *Context) VFMADDSUB231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB231PD instruction to the active function.

func (*Context) VFMADDSUB231PS ¶

func (c *Context) VFMADDSUB231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMADDSUB231PS instruction to the active function.

func (*Context) VFMSUB132PD ¶

func (c *Context) VFMSUB132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB132PD instruction to the active function.

func (*Context) VFMSUB132PS ¶

func (c *Context) VFMSUB132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB132PS instruction to the active function.

func (*Context) VFMSUB132SD ¶

func (c *Context) VFMSUB132SD(mx, x, x1 operand.Op)

VFMSUB132SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB132SD xmm xmm xmm
VFMSUB132SD m64 xmm xmm

Construct and append a VFMSUB132SD instruction to the active function.

func (*Context) VFMSUB132SS ¶

func (c *Context) VFMSUB132SS(mx, x, x1 operand.Op)

VFMSUB132SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB132SS xmm xmm xmm
VFMSUB132SS m32 xmm xmm

Construct and append a VFMSUB132SS instruction to the active function.

func (*Context) VFMSUB213PD ¶

func (c *Context) VFMSUB213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB213PD instruction to the active function.

func (*Context) VFMSUB213PS ¶

func (c *Context) VFMSUB213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB213PS instruction to the active function.

func (*Context) VFMSUB213SD ¶

func (c *Context) VFMSUB213SD(mx, x, x1 operand.Op)

VFMSUB213SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB213SD xmm xmm xmm
VFMSUB213SD m64 xmm xmm

Construct and append a VFMSUB213SD instruction to the active function.

func (*Context) VFMSUB213SS ¶

func (c *Context) VFMSUB213SS(mx, x, x1 operand.Op)

VFMSUB213SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB213SS xmm xmm xmm
VFMSUB213SS m32 xmm xmm

Construct and append a VFMSUB213SS instruction to the active function.

func (*Context) VFMSUB231PD ¶

func (c *Context) VFMSUB231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB231PD instruction to the active function.

func (*Context) VFMSUB231PS ¶

func (c *Context) VFMSUB231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUB231PS instruction to the active function.

func (*Context) VFMSUB231SD ¶

func (c *Context) VFMSUB231SD(mx, x, x1 operand.Op)

VFMSUB231SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFMSUB231SD xmm xmm xmm
VFMSUB231SD m64 xmm xmm

Construct and append a VFMSUB231SD instruction to the active function.

func (*Context) VFMSUB231SS ¶

func (c *Context) VFMSUB231SS(mx, x, x1 operand.Op)

VFMSUB231SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFMSUB231SS xmm xmm xmm
VFMSUB231SS m32 xmm xmm

Construct and append a VFMSUB231SS instruction to the active function.

func (*Context) VFMSUBADD132PD ¶

func (c *Context) VFMSUBADD132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD132PD instruction to the active function.

func (*Context) VFMSUBADD132PS ¶

func (c *Context) VFMSUBADD132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD132PS instruction to the active function.

func (*Context) VFMSUBADD213PD ¶

func (c *Context) VFMSUBADD213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD213PD instruction to the active function.

func (*Context) VFMSUBADD213PS ¶

func (c *Context) VFMSUBADD213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD213PS instruction to the active function.

func (*Context) VFMSUBADD231PD ¶

func (c *Context) VFMSUBADD231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD231PD instruction to the active function.

func (*Context) VFMSUBADD231PS ¶

func (c *Context) VFMSUBADD231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFMSUBADD231PS instruction to the active function.

func (*Context) VFNMADD132PD ¶

func (c *Context) VFNMADD132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD132PD instruction to the active function.

func (*Context) VFNMADD132PS ¶

func (c *Context) VFNMADD132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD132PS instruction to the active function.

func (*Context) VFNMADD132SD ¶

func (c *Context) VFNMADD132SD(mx, x, x1 operand.Op)

VFNMADD132SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD132SD xmm xmm xmm
VFNMADD132SD m64 xmm xmm

Construct and append a VFNMADD132SD instruction to the active function.

func (*Context) VFNMADD132SS ¶

func (c *Context) VFNMADD132SS(mx, x, x1 operand.Op)

VFNMADD132SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD132SS xmm xmm xmm
VFNMADD132SS m32 xmm xmm

Construct and append a VFNMADD132SS instruction to the active function.

func (*Context) VFNMADD213PD ¶

func (c *Context) VFNMADD213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD213PD instruction to the active function.

func (*Context) VFNMADD213PS ¶

func (c *Context) VFNMADD213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD213PS instruction to the active function.

func (*Context) VFNMADD213SD ¶

func (c *Context) VFNMADD213SD(mx, x, x1 operand.Op)

VFNMADD213SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD213SD xmm xmm xmm
VFNMADD213SD m64 xmm xmm

Construct and append a VFNMADD213SD instruction to the active function.

func (*Context) VFNMADD213SS ¶

func (c *Context) VFNMADD213SS(mx, x, x1 operand.Op)

VFNMADD213SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD213SS xmm xmm xmm
VFNMADD213SS m32 xmm xmm

Construct and append a VFNMADD213SS instruction to the active function.

func (*Context) VFNMADD231PD ¶

func (c *Context) VFNMADD231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD231PD instruction to the active function.

func (*Context) VFNMADD231PS ¶

func (c *Context) VFNMADD231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMADD231PS instruction to the active function.

func (*Context) VFNMADD231SD ¶

func (c *Context) VFNMADD231SD(mx, x, x1 operand.Op)

VFNMADD231SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMADD231SD xmm xmm xmm
VFNMADD231SD m64 xmm xmm

Construct and append a VFNMADD231SD instruction to the active function.

func (*Context) VFNMADD231SS ¶

func (c *Context) VFNMADD231SS(mx, x, x1 operand.Op)

VFNMADD231SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMADD231SS xmm xmm xmm
VFNMADD231SS m32 xmm xmm

Construct and append a VFNMADD231SS instruction to the active function.

func (*Context) VFNMSUB132PD ¶

func (c *Context) VFNMSUB132PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB132PD instruction to the active function.

func (*Context) VFNMSUB132PS ¶

func (c *Context) VFNMSUB132PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB132PS instruction to the active function.

func (*Context) VFNMSUB132SD ¶

func (c *Context) VFNMSUB132SD(mx, x, x1 operand.Op)

VFNMSUB132SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB132SD xmm xmm xmm
VFNMSUB132SD m64 xmm xmm

Construct and append a VFNMSUB132SD instruction to the active function.

func (*Context) VFNMSUB132SS ¶

func (c *Context) VFNMSUB132SS(mx, x, x1 operand.Op)

VFNMSUB132SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB132SS xmm xmm xmm
VFNMSUB132SS m32 xmm xmm

Construct and append a VFNMSUB132SS instruction to the active function.

func (*Context) VFNMSUB213PD ¶

func (c *Context) VFNMSUB213PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB213PD instruction to the active function.

func (*Context) VFNMSUB213PS ¶

func (c *Context) VFNMSUB213PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB213PS instruction to the active function.

func (*Context) VFNMSUB213SD ¶

func (c *Context) VFNMSUB213SD(mx, x, x1 operand.Op)

VFNMSUB213SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB213SD xmm xmm xmm
VFNMSUB213SD m64 xmm xmm

Construct and append a VFNMSUB213SD instruction to the active function.

func (*Context) VFNMSUB213SS ¶

func (c *Context) VFNMSUB213SS(mx, x, x1 operand.Op)

VFNMSUB213SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB213SS xmm xmm xmm
VFNMSUB213SS m32 xmm xmm

Construct and append a VFNMSUB213SS instruction to the active function.

func (*Context) VFNMSUB231PD ¶

func (c *Context) VFNMSUB231PD(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB231PD instruction to the active function.

func (*Context) VFNMSUB231PS ¶

func (c *Context) VFNMSUB231PS(mxy, xy, xy1 operand.Op)

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

Construct and append a VFNMSUB231PS instruction to the active function.

func (*Context) VFNMSUB231SD ¶

func (c *Context) VFNMSUB231SD(mx, x, x1 operand.Op)

VFNMSUB231SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values.

Forms:

VFNMSUB231SD xmm xmm xmm
VFNMSUB231SD m64 xmm xmm

Construct and append a VFNMSUB231SD instruction to the active function.

func (*Context) VFNMSUB231SS ¶

func (c *Context) VFNMSUB231SS(mx, x, x1 operand.Op)

VFNMSUB231SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values.

Forms:

VFNMSUB231SS xmm xmm xmm
VFNMSUB231SS m32 xmm xmm

Construct and append a VFNMSUB231SS instruction to the active function.

func (*Context) VGATHERDPD ¶

func (c *Context) VGATHERDPD(xy, v, xy1 operand.Op)

VGATHERDPD: Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices.

Forms:

VGATHERDPD xmm vm32x xmm
VGATHERDPD ymm vm32x ymm

Construct and append a VGATHERDPD instruction to the active function.

func (*Context) VGATHERDPS ¶

func (c *Context) VGATHERDPS(xy, v, xy1 operand.Op)

VGATHERDPS: Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices.

Forms:

VGATHERDPS xmm vm32x xmm
VGATHERDPS ymm vm32y ymm

Construct and append a VGATHERDPS instruction to the active function.

func (*Context) VGATHERQPD ¶

func (c *Context) VGATHERQPD(xy, v, xy1 operand.Op)

VGATHERQPD: Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices.

Forms:

VGATHERQPD xmm vm64x xmm
VGATHERQPD ymm vm64y ymm

Construct and append a VGATHERQPD instruction to the active function.

func (*Context) VGATHERQPS ¶

func (c *Context) VGATHERQPS(x, v, x1 operand.Op)

VGATHERQPS: Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices.

Forms:

VGATHERQPS xmm vm64x xmm
VGATHERQPS xmm vm64y xmm

Construct and append a VGATHERQPS instruction to the active function.

func (*Context) VHADDPD ¶

func (c *Context) VHADDPD(mxy, xy, xy1 operand.Op)

VHADDPD: Packed Double-FP Horizontal Add.

Forms:

VHADDPD xmm  xmm xmm
VHADDPD m128 xmm xmm
VHADDPD ymm  ymm ymm
VHADDPD m256 ymm ymm

Construct and append a VHADDPD instruction to the active function.

func (*Context) VHADDPS ¶

func (c *Context) VHADDPS(mxy, xy, xy1 operand.Op)

VHADDPS: Packed Single-FP Horizontal Add.

Forms:

VHADDPS xmm  xmm xmm
VHADDPS m128 xmm xmm
VHADDPS ymm  ymm ymm
VHADDPS m256 ymm ymm

Construct and append a VHADDPS instruction to the active function.

func (*Context) VHSUBPD ¶

func (c *Context) VHSUBPD(mxy, xy, xy1 operand.Op)

VHSUBPD: Packed Double-FP Horizontal Subtract.

Forms:

VHSUBPD xmm  xmm xmm
VHSUBPD m128 xmm xmm
VHSUBPD ymm  ymm ymm
VHSUBPD m256 ymm ymm

Construct and append a VHSUBPD instruction to the active function.

func (*Context) VHSUBPS ¶

func (c *Context) VHSUBPS(mxy, xy, xy1 operand.Op)

VHSUBPS: Packed Single-FP Horizontal Subtract.

Forms:

VHSUBPS xmm  xmm xmm
VHSUBPS m128 xmm xmm
VHSUBPS ymm  ymm ymm
VHSUBPS m256 ymm ymm

Construct and append a VHSUBPS instruction to the active function.

func (*Context) VINSERTF128 ¶

func (c *Context) VINSERTF128(i, mx, y, y1 operand.Op)

VINSERTF128: Insert Packed Floating-Point Values.

Forms:

VINSERTF128 imm8 xmm  ymm ymm
VINSERTF128 imm8 m128 ymm ymm

Construct and append a VINSERTF128 instruction to the active function.

func (*Context) VINSERTI128 ¶

func (c *Context) VINSERTI128(i, mx, y, y1 operand.Op)

VINSERTI128: Insert Packed Integer Values.

Forms:

VINSERTI128 imm8 xmm  ymm ymm
VINSERTI128 imm8 m128 ymm ymm

Construct and append a VINSERTI128 instruction to the active function.

func (*Context) VINSERTPS ¶

func (c *Context) VINSERTPS(i, mx, x, x1 operand.Op)

VINSERTPS: Insert Packed Single Precision Floating-Point Value.

Forms:

VINSERTPS imm8 xmm xmm xmm
VINSERTPS imm8 m32 xmm xmm

Construct and append a VINSERTPS instruction to the active function.

func (*Context) VLDDQU ¶

func (c *Context) VLDDQU(m, xy operand.Op)

VLDDQU: Load Unaligned Integer 128 Bits.

Forms:

VLDDQU m128 xmm
VLDDQU m256 ymm

Construct and append a VLDDQU instruction to the active function.

func (*Context) VLDMXCSR ¶

func (c *Context) VLDMXCSR(m operand.Op)

VLDMXCSR: Load MXCSR Register.

Forms:

VLDMXCSR m32

Construct and append a VLDMXCSR instruction to the active function.

func (*Context) VMASKMOVDQU ¶

func (c *Context) VMASKMOVDQU(x, x1 operand.Op)

VMASKMOVDQU: Store Selected Bytes of Double Quadword.

Forms:

VMASKMOVDQU xmm xmm

Construct and append a VMASKMOVDQU instruction to the active function.

func (*Context) VMASKMOVPD ¶

func (c *Context) VMASKMOVPD(mxy, xy, mxy1 operand.Op)

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

Construct and append a VMASKMOVPD instruction to the active function.

func (*Context) VMASKMOVPS ¶

func (c *Context) VMASKMOVPS(mxy, xy, mxy1 operand.Op)

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

Construct and append a VMASKMOVPS instruction to the active function.

func (*Context) VMAXPD ¶

func (c *Context) VMAXPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VMAXPD instruction to the active function.

func (*Context) VMAXPS ¶

func (c *Context) VMAXPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VMAXPS instruction to the active function.

func (*Context) VMAXSD ¶

func (c *Context) VMAXSD(mx, x, x1 operand.Op)

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

Forms:

VMAXSD xmm xmm xmm
VMAXSD m64 xmm xmm

Construct and append a VMAXSD instruction to the active function.

func (*Context) VMAXSS ¶

func (c *Context) VMAXSS(mx, x, x1 operand.Op)

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

Forms:

VMAXSS xmm xmm xmm
VMAXSS m32 xmm xmm

Construct and append a VMAXSS instruction to the active function.

func (*Context) VMINPD ¶

func (c *Context) VMINPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VMINPD instruction to the active function.

func (*Context) VMINPS ¶

func (c *Context) VMINPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VMINPS instruction to the active function.

func (*Context) VMINSD ¶

func (c *Context) VMINSD(mx, x, x1 operand.Op)

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

Forms:

VMINSD xmm xmm xmm
VMINSD m64 xmm xmm

Construct and append a VMINSD instruction to the active function.

func (*Context) VMINSS ¶

func (c *Context) VMINSS(mx, x, x1 operand.Op)

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

Forms:

VMINSS xmm xmm xmm
VMINSS m32 xmm xmm

Construct and append a VMINSS instruction to the active function.

func (*Context) VMOVAPD ¶

func (c *Context) VMOVAPD(mxy, mxy1 operand.Op)

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

Construct and append a VMOVAPD instruction to the active function.

func (*Context) VMOVAPS ¶

func (c *Context) VMOVAPS(mxy, mxy1 operand.Op)

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

Construct and append a VMOVAPS instruction to the active function.

func (*Context) VMOVD ¶

func (c *Context) VMOVD(mrx, mrx1 operand.Op)

VMOVD: Move Doubleword.

Forms:

VMOVD xmm r32
VMOVD r32 xmm
VMOVD m32 xmm
VMOVD xmm m32

Construct and append a VMOVD instruction to the active function.

func (*Context) VMOVDDUP ¶

func (c *Context) VMOVDDUP(mxy, xy operand.Op)

VMOVDDUP: Move One Double-FP and Duplicate.

Forms:

VMOVDDUP xmm  xmm
VMOVDDUP m64  xmm
VMOVDDUP ymm  ymm
VMOVDDUP m256 ymm

Construct and append a VMOVDDUP instruction to the active function.

func (*Context) VMOVDQA ¶

func (c *Context) VMOVDQA(mxy, mxy1 operand.Op)

VMOVDQA: Move Aligned Double Quadword.

Forms:

VMOVDQA xmm  xmm
VMOVDQA m128 xmm
VMOVDQA ymm  ymm
VMOVDQA m256 ymm
VMOVDQA xmm  m128
VMOVDQA ymm  m256

Construct and append a VMOVDQA instruction to the active function.

func (*Context) VMOVDQU ¶

func (c *Context) VMOVDQU(mxy, mxy1 operand.Op)

VMOVDQU: Move Unaligned Double Quadword.

Forms:

VMOVDQU xmm  xmm
VMOVDQU m128 xmm
VMOVDQU ymm  ymm
VMOVDQU m256 ymm
VMOVDQU xmm  m128
VMOVDQU ymm  m256

Construct and append a VMOVDQU instruction to the active function.

func (*Context) VMOVHLPS ¶

func (c *Context) VMOVHLPS(x, x1, x2 operand.Op)

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

Forms:

VMOVHLPS xmm xmm xmm

Construct and append a VMOVHLPS instruction to the active function.

func (*Context) VMOVHPD ¶

func (c *Context) VMOVHPD(ops ...operand.Op)

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

Forms:

VMOVHPD xmm m64
VMOVHPD m64 xmm xmm

Construct and append a VMOVHPD instruction to the active function.

func (*Context) VMOVHPS ¶

func (c *Context) VMOVHPS(ops ...operand.Op)

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

Forms:

VMOVHPS xmm m64
VMOVHPS m64 xmm xmm

Construct and append a VMOVHPS instruction to the active function.

func (*Context) VMOVLHPS ¶

func (c *Context) VMOVLHPS(x, x1, x2 operand.Op)

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

Forms:

VMOVLHPS xmm xmm xmm

Construct and append a VMOVLHPS instruction to the active function.

func (*Context) VMOVLPD ¶

func (c *Context) VMOVLPD(ops ...operand.Op)

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

Forms:

VMOVLPD xmm m64
VMOVLPD m64 xmm xmm

Construct and append a VMOVLPD instruction to the active function.

func (*Context) VMOVLPS ¶

func (c *Context) VMOVLPS(ops ...operand.Op)

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

Forms:

VMOVLPS xmm m64
VMOVLPS m64 xmm xmm

Construct and append a VMOVLPS instruction to the active function.

func (*Context) VMOVMSKPD ¶

func (c *Context) VMOVMSKPD(xy, r operand.Op)

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

Forms:

VMOVMSKPD xmm r32
VMOVMSKPD ymm r32

Construct and append a VMOVMSKPD instruction to the active function.

func (*Context) VMOVMSKPS ¶

func (c *Context) VMOVMSKPS(xy, r operand.Op)

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

Forms:

VMOVMSKPS xmm r32
VMOVMSKPS ymm r32

Construct and append a VMOVMSKPS instruction to the active function.

func (*Context) VMOVNTDQ ¶

func (c *Context) VMOVNTDQ(xy, m operand.Op)

VMOVNTDQ: Store Double Quadword Using Non-Temporal Hint.

Forms:

VMOVNTDQ xmm m128
VMOVNTDQ ymm m256

Construct and append a VMOVNTDQ instruction to the active function.

func (*Context) VMOVNTDQA ¶

func (c *Context) VMOVNTDQA(m, xy operand.Op)

VMOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint.

Forms:

VMOVNTDQA m128 xmm
VMOVNTDQA m256 ymm

Construct and append a VMOVNTDQA instruction to the active function.

func (*Context) VMOVNTPD ¶

func (c *Context) VMOVNTPD(xy, m operand.Op)

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

Forms:

VMOVNTPD xmm m128
VMOVNTPD ymm m256

Construct and append a VMOVNTPD instruction to the active function.

func (*Context) VMOVNTPS ¶

func (c *Context) VMOVNTPS(xy, m operand.Op)

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

Forms:

VMOVNTPS xmm m128
VMOVNTPS ymm m256

Construct and append a VMOVNTPS instruction to the active function.

func (*Context) VMOVQ ¶

func (c *Context) VMOVQ(mrx, mrx1 operand.Op)

VMOVQ: Move Quadword.

Forms:

VMOVQ xmm r64
VMOVQ r64 xmm
VMOVQ xmm xmm
VMOVQ m64 xmm
VMOVQ xmm m64

Construct and append a VMOVQ instruction to the active function.

func (*Context) VMOVSD ¶

func (c *Context) VMOVSD(ops ...operand.Op)

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

Forms:

VMOVSD m64 xmm
VMOVSD xmm m64
VMOVSD xmm xmm xmm

Construct and append a VMOVSD instruction to the active function.

func (*Context) VMOVSHDUP ¶

func (c *Context) VMOVSHDUP(mxy, xy operand.Op)

VMOVSHDUP: Move Packed Single-FP High and Duplicate.

Forms:

VMOVSHDUP xmm  xmm
VMOVSHDUP m128 xmm
VMOVSHDUP ymm  ymm
VMOVSHDUP m256 ymm

Construct and append a VMOVSHDUP instruction to the active function.

func (*Context) VMOVSLDUP ¶

func (c *Context) VMOVSLDUP(mxy, xy operand.Op)

VMOVSLDUP: Move Packed Single-FP Low and Duplicate.

Forms:

VMOVSLDUP xmm  xmm
VMOVSLDUP m128 xmm
VMOVSLDUP ymm  ymm
VMOVSLDUP m256 ymm

Construct and append a VMOVSLDUP instruction to the active function.

func (*Context) VMOVSS ¶

func (c *Context) VMOVSS(ops ...operand.Op)

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

Forms:

VMOVSS m32 xmm
VMOVSS xmm m32
VMOVSS xmm xmm xmm

Construct and append a VMOVSS instruction to the active function.

func (*Context) VMOVUPD ¶

func (c *Context) VMOVUPD(mxy, mxy1 operand.Op)

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

Construct and append a VMOVUPD instruction to the active function.

func (*Context) VMOVUPS ¶

func (c *Context) VMOVUPS(mxy, mxy1 operand.Op)

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

Construct and append a VMOVUPS instruction to the active function.

func (*Context) VMPSADBW ¶

func (c *Context) VMPSADBW(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VMPSADBW instruction to the active function.

func (*Context) VMULPD ¶

func (c *Context) VMULPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VMULPD instruction to the active function.

func (*Context) VMULPS ¶

func (c *Context) VMULPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VMULPS instruction to the active function.

func (*Context) VMULSD ¶

func (c *Context) VMULSD(mx, x, x1 operand.Op)

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

Forms:

VMULSD xmm xmm xmm
VMULSD m64 xmm xmm

Construct and append a VMULSD instruction to the active function.

func (*Context) VMULSS ¶

func (c *Context) VMULSS(mx, x, x1 operand.Op)

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

Forms:

VMULSS xmm xmm xmm
VMULSS m32 xmm xmm

Construct and append a VMULSS instruction to the active function.

func (*Context) VORPD ¶

func (c *Context) VORPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VORPD instruction to the active function.

func (*Context) VORPS ¶

func (c *Context) VORPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VORPS instruction to the active function.

func (*Context) VPABSB ¶

func (c *Context) VPABSB(mxy, xy operand.Op)

VPABSB: Packed Absolute Value of Byte Integers.

Forms:

VPABSB xmm  xmm
VPABSB m128 xmm
VPABSB ymm  ymm
VPABSB m256 ymm

Construct and append a VPABSB instruction to the active function.

func (*Context) VPABSD ¶

func (c *Context) VPABSD(mxy, xy operand.Op)

VPABSD: Packed Absolute Value of Doubleword Integers.

Forms:

VPABSD xmm  xmm
VPABSD m128 xmm
VPABSD ymm  ymm
VPABSD m256 ymm

Construct and append a VPABSD instruction to the active function.

func (*Context) VPABSW ¶

func (c *Context) VPABSW(mxy, xy operand.Op)

VPABSW: Packed Absolute Value of Word Integers.

Forms:

VPABSW xmm  xmm
VPABSW m128 xmm
VPABSW ymm  ymm
VPABSW m256 ymm

Construct and append a VPABSW instruction to the active function.

func (*Context) VPACKSSDW ¶

func (c *Context) VPACKSSDW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKSSDW instruction to the active function.

func (*Context) VPACKSSWB ¶

func (c *Context) VPACKSSWB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKSSWB instruction to the active function.

func (*Context) VPACKUSDW ¶

func (c *Context) VPACKUSDW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKUSDW instruction to the active function.

func (*Context) VPACKUSWB ¶

func (c *Context) VPACKUSWB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPACKUSWB instruction to the active function.

func (*Context) VPADDB ¶

func (c *Context) VPADDB(mxy, xy, xy1 operand.Op)

VPADDB: Add Packed Byte Integers.

Forms:

VPADDB xmm  xmm xmm
VPADDB m128 xmm xmm
VPADDB ymm  ymm ymm
VPADDB m256 ymm ymm

Construct and append a VPADDB instruction to the active function.

func (*Context) VPADDD ¶

func (c *Context) VPADDD(mxy, xy, xy1 operand.Op)

VPADDD: Add Packed Doubleword Integers.

Forms:

VPADDD xmm  xmm xmm
VPADDD m128 xmm xmm
VPADDD ymm  ymm ymm
VPADDD m256 ymm ymm

Construct and append a VPADDD instruction to the active function.

func (*Context) VPADDQ ¶

func (c *Context) VPADDQ(mxy, xy, xy1 operand.Op)

VPADDQ: Add Packed Quadword Integers.

Forms:

VPADDQ xmm  xmm xmm
VPADDQ m128 xmm xmm
VPADDQ ymm  ymm ymm
VPADDQ m256 ymm ymm

Construct and append a VPADDQ instruction to the active function.

func (*Context) VPADDSB ¶

func (c *Context) VPADDSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDSB instruction to the active function.

func (*Context) VPADDSW ¶

func (c *Context) VPADDSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDSW instruction to the active function.

func (*Context) VPADDUSB ¶

func (c *Context) VPADDUSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDUSB instruction to the active function.

func (*Context) VPADDUSW ¶

func (c *Context) VPADDUSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPADDUSW instruction to the active function.

func (*Context) VPADDW ¶

func (c *Context) VPADDW(mxy, xy, xy1 operand.Op)

VPADDW: Add Packed Word Integers.

Forms:

VPADDW xmm  xmm xmm
VPADDW m128 xmm xmm
VPADDW ymm  ymm ymm
VPADDW m256 ymm ymm

Construct and append a VPADDW instruction to the active function.

func (*Context) VPALIGNR ¶

func (c *Context) VPALIGNR(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VPALIGNR instruction to the active function.

func (*Context) VPAND ¶

func (c *Context) VPAND(mxy, xy, xy1 operand.Op)

VPAND: Packed Bitwise Logical AND.

Forms:

VPAND xmm  xmm xmm
VPAND m128 xmm xmm
VPAND ymm  ymm ymm
VPAND m256 ymm ymm

Construct and append a VPAND instruction to the active function.

func (*Context) VPANDN ¶

func (c *Context) VPANDN(mxy, xy, xy1 operand.Op)

VPANDN: Packed Bitwise Logical AND NOT.

Forms:

VPANDN xmm  xmm xmm
VPANDN m128 xmm xmm
VPANDN ymm  ymm ymm
VPANDN m256 ymm ymm

Construct and append a VPANDN instruction to the active function.

func (*Context) VPAVGB ¶

func (c *Context) VPAVGB(mxy, xy, xy1 operand.Op)

VPAVGB: Average Packed Byte Integers.

Forms:

VPAVGB xmm  xmm xmm
VPAVGB m128 xmm xmm
VPAVGB ymm  ymm ymm
VPAVGB m256 ymm ymm

Construct and append a VPAVGB instruction to the active function.

func (*Context) VPAVGW ¶

func (c *Context) VPAVGW(mxy, xy, xy1 operand.Op)

VPAVGW: Average Packed Word Integers.

Forms:

VPAVGW xmm  xmm xmm
VPAVGW m128 xmm xmm
VPAVGW ymm  ymm ymm
VPAVGW m256 ymm ymm

Construct and append a VPAVGW instruction to the active function.

func (*Context) VPBLENDD ¶

func (c *Context) VPBLENDD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VPBLENDD instruction to the active function.

func (*Context) VPBLENDVB ¶

func (c *Context) VPBLENDVB(xy, mxy, xy1, xy2 operand.Op)

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

Construct and append a VPBLENDVB instruction to the active function.

func (*Context) VPBLENDW ¶

func (c *Context) VPBLENDW(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VPBLENDW instruction to the active function.

func (*Context) VPBROADCASTB ¶

func (c *Context) VPBROADCASTB(mx, xy operand.Op)

VPBROADCASTB: Broadcast Byte Integer.

Forms:

VPBROADCASTB xmm xmm
VPBROADCASTB m8  xmm
VPBROADCASTB xmm ymm
VPBROADCASTB m8  ymm

Construct and append a VPBROADCASTB instruction to the active function.

func (*Context) VPBROADCASTD ¶

func (c *Context) VPBROADCASTD(mx, xy operand.Op)

VPBROADCASTD: Broadcast Doubleword Integer.

Forms:

VPBROADCASTD xmm xmm
VPBROADCASTD m32 xmm
VPBROADCASTD xmm ymm
VPBROADCASTD m32 ymm

Construct and append a VPBROADCASTD instruction to the active function.

func (*Context) VPBROADCASTQ ¶

func (c *Context) VPBROADCASTQ(mx, xy operand.Op)

VPBROADCASTQ: Broadcast Quadword Integer.

Forms:

VPBROADCASTQ xmm xmm
VPBROADCASTQ m64 xmm
VPBROADCASTQ xmm ymm
VPBROADCASTQ m64 ymm

Construct and append a VPBROADCASTQ instruction to the active function.

func (*Context) VPBROADCASTW ¶

func (c *Context) VPBROADCASTW(mx, xy operand.Op)

VPBROADCASTW: Broadcast Word Integer.

Forms:

VPBROADCASTW xmm xmm
VPBROADCASTW m16 xmm
VPBROADCASTW xmm ymm
VPBROADCASTW m16 ymm

Construct and append a VPBROADCASTW instruction to the active function.

func (*Context) VPCLMULQDQ ¶

func (c *Context) VPCLMULQDQ(i, mx, x, x1 operand.Op)

VPCLMULQDQ: Carry-Less Quadword Multiplication.

Forms:

VPCLMULQDQ imm8 xmm  xmm xmm
VPCLMULQDQ imm8 m128 xmm xmm

Construct and append a VPCLMULQDQ instruction to the active function.

func (*Context) VPCMPEQB ¶

func (c *Context) VPCMPEQB(mxy, xy, xy1 operand.Op)

VPCMPEQB: Compare Packed Byte Data for Equality.

Forms:

VPCMPEQB xmm  xmm xmm
VPCMPEQB m128 xmm xmm
VPCMPEQB ymm  ymm ymm
VPCMPEQB m256 ymm ymm

Construct and append a VPCMPEQB instruction to the active function.

func (*Context) VPCMPEQD ¶

func (c *Context) VPCMPEQD(mxy, xy, xy1 operand.Op)

VPCMPEQD: Compare Packed Doubleword Data for Equality.

Forms:

VPCMPEQD xmm  xmm xmm
VPCMPEQD m128 xmm xmm
VPCMPEQD ymm  ymm ymm
VPCMPEQD m256 ymm ymm

Construct and append a VPCMPEQD instruction to the active function.

func (*Context) VPCMPEQQ ¶

func (c *Context) VPCMPEQQ(mxy, xy, xy1 operand.Op)

VPCMPEQQ: Compare Packed Quadword Data for Equality.

Forms:

VPCMPEQQ xmm  xmm xmm
VPCMPEQQ m128 xmm xmm
VPCMPEQQ ymm  ymm ymm
VPCMPEQQ m256 ymm ymm

Construct and append a VPCMPEQQ instruction to the active function.

func (*Context) VPCMPEQW ¶

func (c *Context) VPCMPEQW(mxy, xy, xy1 operand.Op)

VPCMPEQW: Compare Packed Word Data for Equality.

Forms:

VPCMPEQW xmm  xmm xmm
VPCMPEQW m128 xmm xmm
VPCMPEQW ymm  ymm ymm
VPCMPEQW m256 ymm ymm

Construct and append a VPCMPEQW instruction to the active function.

func (*Context) VPCMPESTRI ¶

func (c *Context) VPCMPESTRI(i, mx, x operand.Op)

VPCMPESTRI: Packed Compare Explicit Length Strings, Return Index.

Forms:

VPCMPESTRI imm8 xmm  xmm
VPCMPESTRI imm8 m128 xmm

Construct and append a VPCMPESTRI instruction to the active function.

func (*Context) VPCMPESTRM ¶

func (c *Context) VPCMPESTRM(i, mx, x operand.Op)

VPCMPESTRM: Packed Compare Explicit Length Strings, Return Mask.

Forms:

VPCMPESTRM imm8 xmm  xmm
VPCMPESTRM imm8 m128 xmm

Construct and append a VPCMPESTRM instruction to the active function.

func (*Context) VPCMPGTB ¶

func (c *Context) VPCMPGTB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPCMPGTB instruction to the active function.

func (*Context) VPCMPGTD ¶

func (c *Context) VPCMPGTD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPCMPGTD instruction to the active function.

func (*Context) VPCMPGTQ ¶

func (c *Context) VPCMPGTQ(mxy, xy, xy1 operand.Op)

VPCMPGTQ: Compare Packed Data for Greater Than.

Forms:

VPCMPGTQ xmm  xmm xmm
VPCMPGTQ m128 xmm xmm
VPCMPGTQ ymm  ymm ymm
VPCMPGTQ m256 ymm ymm

Construct and append a VPCMPGTQ instruction to the active function.

func (*Context) VPCMPGTW ¶

func (c *Context) VPCMPGTW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPCMPGTW instruction to the active function.

func (*Context) VPCMPISTRI ¶

func (c *Context) VPCMPISTRI(i, mx, x operand.Op)

VPCMPISTRI: Packed Compare Implicit Length Strings, Return Index.

Forms:

VPCMPISTRI imm8 xmm  xmm
VPCMPISTRI imm8 m128 xmm

Construct and append a VPCMPISTRI instruction to the active function.

func (*Context) VPCMPISTRM ¶

func (c *Context) VPCMPISTRM(i, mx, x operand.Op)

VPCMPISTRM: Packed Compare Implicit Length Strings, Return Mask.

Forms:

VPCMPISTRM imm8 xmm  xmm
VPCMPISTRM imm8 m128 xmm

Construct and append a VPCMPISTRM instruction to the active function.

func (*Context) VPERM2F128 ¶

func (c *Context) VPERM2F128(i, my, y, y1 operand.Op)

VPERM2F128: Permute Floating-Point Values.

Forms:

VPERM2F128 imm8 ymm  ymm ymm
VPERM2F128 imm8 m256 ymm ymm

Construct and append a VPERM2F128 instruction to the active function.

func (*Context) VPERM2I128 ¶

func (c *Context) VPERM2I128(i, my, y, y1 operand.Op)

VPERM2I128: Permute 128-Bit Integer Values.

Forms:

VPERM2I128 imm8 ymm  ymm ymm
VPERM2I128 imm8 m256 ymm ymm

Construct and append a VPERM2I128 instruction to the active function.

func (*Context) VPERMD ¶

func (c *Context) VPERMD(my, y, y1 operand.Op)

VPERMD: Permute Doubleword Integers.

Forms:

VPERMD ymm  ymm ymm
VPERMD m256 ymm ymm

Construct and append a VPERMD instruction to the active function.

func (*Context) VPERMILPD ¶

func (c *Context) VPERMILPD(imxy, mxy, xy operand.Op)

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

Construct and append a VPERMILPD instruction to the active function.

func (*Context) VPERMILPS ¶

func (c *Context) VPERMILPS(imxy, mxy, xy operand.Op)

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

Construct and append a VPERMILPS instruction to the active function.

func (*Context) VPERMPD ¶

func (c *Context) VPERMPD(i, my, y operand.Op)

VPERMPD: Permute Double-Precision Floating-Point Elements.

Forms:

VPERMPD imm8 ymm  ymm
VPERMPD imm8 m256 ymm

Construct and append a VPERMPD instruction to the active function.

func (*Context) VPERMPS ¶

func (c *Context) VPERMPS(my, y, y1 operand.Op)

VPERMPS: Permute Single-Precision Floating-Point Elements.

Forms:

VPERMPS ymm  ymm ymm
VPERMPS m256 ymm ymm

Construct and append a VPERMPS instruction to the active function.

func (*Context) VPERMQ ¶

func (c *Context) VPERMQ(i, my, y operand.Op)

VPERMQ: Permute Quadword Integers.

Forms:

VPERMQ imm8 ymm  ymm
VPERMQ imm8 m256 ymm

Construct and append a VPERMQ instruction to the active function.

func (*Context) VPEXTRB ¶

func (c *Context) VPEXTRB(i, x, mr operand.Op)

VPEXTRB: Extract Byte.

Forms:

VPEXTRB imm8 xmm r32
VPEXTRB imm8 xmm m8

Construct and append a VPEXTRB instruction to the active function.

func (*Context) VPEXTRD ¶

func (c *Context) VPEXTRD(i, x, mr operand.Op)

VPEXTRD: Extract Doubleword.

Forms:

VPEXTRD imm8 xmm r32
VPEXTRD imm8 xmm m32

Construct and append a VPEXTRD instruction to the active function.

func (*Context) VPEXTRQ ¶

func (c *Context) VPEXTRQ(i, x, mr operand.Op)

VPEXTRQ: Extract Quadword.

Forms:

VPEXTRQ imm8 xmm r64
VPEXTRQ imm8 xmm m64

Construct and append a VPEXTRQ instruction to the active function.

func (*Context) VPEXTRW ¶

func (c *Context) VPEXTRW(i, x, mr operand.Op)

VPEXTRW: Extract Word.

Forms:

VPEXTRW imm8 xmm r32
VPEXTRW imm8 xmm m16

Construct and append a VPEXTRW instruction to the active function.

func (*Context) VPGATHERDD ¶

func (c *Context) VPGATHERDD(xy, v, xy1 operand.Op)

VPGATHERDD: Gather Packed Doubleword Values Using Signed Doubleword Indices.

Forms:

VPGATHERDD xmm vm32x xmm
VPGATHERDD ymm vm32y ymm

Construct and append a VPGATHERDD instruction to the active function.

func (*Context) VPGATHERDQ ¶

func (c *Context) VPGATHERDQ(xy, v, xy1 operand.Op)

VPGATHERDQ: Gather Packed Quadword Values Using Signed Doubleword Indices.

Forms:

VPGATHERDQ xmm vm32x xmm
VPGATHERDQ ymm vm32x ymm

Construct and append a VPGATHERDQ instruction to the active function.

func (*Context) VPGATHERQD ¶

func (c *Context) VPGATHERQD(x, v, x1 operand.Op)

VPGATHERQD: Gather Packed Doubleword Values Using Signed Quadword Indices.

Forms:

VPGATHERQD xmm vm64x xmm
VPGATHERQD xmm vm64y xmm

Construct and append a VPGATHERQD instruction to the active function.

func (*Context) VPGATHERQQ ¶

func (c *Context) VPGATHERQQ(xy, v, xy1 operand.Op)

VPGATHERQQ: Gather Packed Quadword Values Using Signed Quadword Indices.

Forms:

VPGATHERQQ xmm vm64x xmm
VPGATHERQQ ymm vm64y ymm

Construct and append a VPGATHERQQ instruction to the active function.

func (*Context) VPHADDD ¶

func (c *Context) VPHADDD(mxy, xy, xy1 operand.Op)

VPHADDD: Packed Horizontal Add Doubleword Integer.

Forms:

VPHADDD xmm  xmm xmm
VPHADDD m128 xmm xmm
VPHADDD ymm  ymm ymm
VPHADDD m256 ymm ymm

Construct and append a VPHADDD instruction to the active function.

func (*Context) VPHADDSW ¶

func (c *Context) VPHADDSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPHADDSW instruction to the active function.

func (*Context) VPHADDW ¶

func (c *Context) VPHADDW(mxy, xy, xy1 operand.Op)

VPHADDW: Packed Horizontal Add Word Integers.

Forms:

VPHADDW xmm  xmm xmm
VPHADDW m128 xmm xmm
VPHADDW ymm  ymm ymm
VPHADDW m256 ymm ymm

Construct and append a VPHADDW instruction to the active function.

func (*Context) VPHMINPOSUW ¶

func (c *Context) VPHMINPOSUW(mx, x operand.Op)

VPHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers.

Forms:

VPHMINPOSUW xmm  xmm
VPHMINPOSUW m128 xmm

Construct and append a VPHMINPOSUW instruction to the active function.

func (*Context) VPHSUBD ¶

func (c *Context) VPHSUBD(mxy, xy, xy1 operand.Op)

VPHSUBD: Packed Horizontal Subtract Doubleword Integers.

Forms:

VPHSUBD xmm  xmm xmm
VPHSUBD m128 xmm xmm
VPHSUBD ymm  ymm ymm
VPHSUBD m256 ymm ymm

Construct and append a VPHSUBD instruction to the active function.

func (*Context) VPHSUBSW ¶

func (c *Context) VPHSUBSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPHSUBSW instruction to the active function.

func (*Context) VPHSUBW ¶

func (c *Context) VPHSUBW(mxy, xy, xy1 operand.Op)

VPHSUBW: Packed Horizontal Subtract Word Integers.

Forms:

VPHSUBW xmm  xmm xmm
VPHSUBW m128 xmm xmm
VPHSUBW ymm  ymm ymm
VPHSUBW m256 ymm ymm

Construct and append a VPHSUBW instruction to the active function.

func (*Context) VPINSRB ¶

func (c *Context) VPINSRB(i, mr, x, x1 operand.Op)

VPINSRB: Insert Byte.

Forms:

VPINSRB imm8 r32 xmm xmm
VPINSRB imm8 m8  xmm xmm

Construct and append a VPINSRB instruction to the active function.

func (*Context) VPINSRD ¶

func (c *Context) VPINSRD(i, mr, x, x1 operand.Op)

VPINSRD: Insert Doubleword.

Forms:

VPINSRD imm8 r32 xmm xmm
VPINSRD imm8 m32 xmm xmm

Construct and append a VPINSRD instruction to the active function.

func (*Context) VPINSRQ ¶

func (c *Context) VPINSRQ(i, mr, x, x1 operand.Op)

VPINSRQ: Insert Quadword.

Forms:

VPINSRQ imm8 r64 xmm xmm
VPINSRQ imm8 m64 xmm xmm

Construct and append a VPINSRQ instruction to the active function.

func (*Context) VPINSRW ¶

func (c *Context) VPINSRW(i, mr, x, x1 operand.Op)

VPINSRW: Insert Word.

Forms:

VPINSRW imm8 r32 xmm xmm
VPINSRW imm8 m16 xmm xmm

Construct and append a VPINSRW instruction to the active function.

func (*Context) VPMADDUBSW ¶

func (c *Context) VPMADDUBSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMADDUBSW instruction to the active function.

func (*Context) VPMADDWD ¶

func (c *Context) VPMADDWD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMADDWD instruction to the active function.

func (*Context) VPMASKMOVD ¶

func (c *Context) VPMASKMOVD(mxy, xy, mxy1 operand.Op)

VPMASKMOVD: Conditional Move Packed Doubleword Integers.

Forms:

VPMASKMOVD m128 xmm xmm
VPMASKMOVD m256 ymm ymm
VPMASKMOVD xmm  xmm m128
VPMASKMOVD ymm  ymm m256

Construct and append a VPMASKMOVD instruction to the active function.

func (*Context) VPMASKMOVQ ¶

func (c *Context) VPMASKMOVQ(mxy, xy, mxy1 operand.Op)

VPMASKMOVQ: Conditional Move Packed Quadword Integers.

Forms:

VPMASKMOVQ m128 xmm xmm
VPMASKMOVQ m256 ymm ymm
VPMASKMOVQ xmm  xmm m128
VPMASKMOVQ ymm  ymm m256

Construct and append a VPMASKMOVQ instruction to the active function.

func (*Context) VPMAXSB ¶

func (c *Context) VPMAXSB(mxy, xy, xy1 operand.Op)

VPMAXSB: Maximum of Packed Signed Byte Integers.

Forms:

VPMAXSB xmm  xmm xmm
VPMAXSB m128 xmm xmm
VPMAXSB ymm  ymm ymm
VPMAXSB m256 ymm ymm

Construct and append a VPMAXSB instruction to the active function.

func (*Context) VPMAXSD ¶

func (c *Context) VPMAXSD(mxy, xy, xy1 operand.Op)

VPMAXSD: Maximum of Packed Signed Doubleword Integers.

Forms:

VPMAXSD xmm  xmm xmm
VPMAXSD m128 xmm xmm
VPMAXSD ymm  ymm ymm
VPMAXSD m256 ymm ymm

Construct and append a VPMAXSD instruction to the active function.

func (*Context) VPMAXSW ¶

func (c *Context) VPMAXSW(mxy, xy, xy1 operand.Op)

VPMAXSW: Maximum of Packed Signed Word Integers.

Forms:

VPMAXSW xmm  xmm xmm
VPMAXSW m128 xmm xmm
VPMAXSW ymm  ymm ymm
VPMAXSW m256 ymm ymm

Construct and append a VPMAXSW instruction to the active function.

func (*Context) VPMAXUB ¶

func (c *Context) VPMAXUB(mxy, xy, xy1 operand.Op)

VPMAXUB: Maximum of Packed Unsigned Byte Integers.

Forms:

VPMAXUB xmm  xmm xmm
VPMAXUB m128 xmm xmm
VPMAXUB ymm  ymm ymm
VPMAXUB m256 ymm ymm

Construct and append a VPMAXUB instruction to the active function.

func (*Context) VPMAXUD ¶

func (c *Context) VPMAXUD(mxy, xy, xy1 operand.Op)

VPMAXUD: Maximum of Packed Unsigned Doubleword Integers.

Forms:

VPMAXUD xmm  xmm xmm
VPMAXUD m128 xmm xmm
VPMAXUD ymm  ymm ymm
VPMAXUD m256 ymm ymm

Construct and append a VPMAXUD instruction to the active function.

func (*Context) VPMAXUW ¶

func (c *Context) VPMAXUW(mxy, xy, xy1 operand.Op)

VPMAXUW: Maximum of Packed Unsigned Word Integers.

Forms:

VPMAXUW xmm  xmm xmm
VPMAXUW m128 xmm xmm
VPMAXUW ymm  ymm ymm
VPMAXUW m256 ymm ymm

Construct and append a VPMAXUW instruction to the active function.

func (*Context) VPMINSB ¶

func (c *Context) VPMINSB(mxy, xy, xy1 operand.Op)

VPMINSB: Minimum of Packed Signed Byte Integers.

Forms:

VPMINSB xmm  xmm xmm
VPMINSB m128 xmm xmm
VPMINSB ymm  ymm ymm
VPMINSB m256 ymm ymm

Construct and append a VPMINSB instruction to the active function.

func (*Context) VPMINSD ¶

func (c *Context) VPMINSD(mxy, xy, xy1 operand.Op)

VPMINSD: Minimum of Packed Signed Doubleword Integers.

Forms:

VPMINSD xmm  xmm xmm
VPMINSD m128 xmm xmm
VPMINSD ymm  ymm ymm
VPMINSD m256 ymm ymm

Construct and append a VPMINSD instruction to the active function.

func (*Context) VPMINSW ¶

func (c *Context) VPMINSW(mxy, xy, xy1 operand.Op)

VPMINSW: Minimum of Packed Signed Word Integers.

Forms:

VPMINSW xmm  xmm xmm
VPMINSW m128 xmm xmm
VPMINSW ymm  ymm ymm
VPMINSW m256 ymm ymm

Construct and append a VPMINSW instruction to the active function.

func (*Context) VPMINUB ¶

func (c *Context) VPMINUB(mxy, xy, xy1 operand.Op)

VPMINUB: Minimum of Packed Unsigned Byte Integers.

Forms:

VPMINUB xmm  xmm xmm
VPMINUB m128 xmm xmm
VPMINUB ymm  ymm ymm
VPMINUB m256 ymm ymm

Construct and append a VPMINUB instruction to the active function.

func (*Context) VPMINUD ¶

func (c *Context) VPMINUD(mxy, xy, xy1 operand.Op)

VPMINUD: Minimum of Packed Unsigned Doubleword Integers.

Forms:

VPMINUD xmm  xmm xmm
VPMINUD m128 xmm xmm
VPMINUD ymm  ymm ymm
VPMINUD m256 ymm ymm

Construct and append a VPMINUD instruction to the active function.

func (*Context) VPMINUW ¶

func (c *Context) VPMINUW(mxy, xy, xy1 operand.Op)

VPMINUW: Minimum of Packed Unsigned Word Integers.

Forms:

VPMINUW xmm  xmm xmm
VPMINUW m128 xmm xmm
VPMINUW ymm  ymm ymm
VPMINUW m256 ymm ymm

Construct and append a VPMINUW instruction to the active function.

func (*Context) VPMOVMSKB ¶

func (c *Context) VPMOVMSKB(xy, r operand.Op)

VPMOVMSKB: Move Byte Mask.

Forms:

VPMOVMSKB xmm r32
VPMOVMSKB ymm r32

Construct and append a VPMOVMSKB instruction to the active function.

func (*Context) VPMOVSXBD ¶

func (c *Context) VPMOVSXBD(mx, xy operand.Op)

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

Forms:

VPMOVSXBD xmm xmm
VPMOVSXBD m32 xmm
VPMOVSXBD xmm ymm
VPMOVSXBD m64 ymm

Construct and append a VPMOVSXBD instruction to the active function.

func (*Context) VPMOVSXBQ ¶

func (c *Context) VPMOVSXBQ(mx, xy operand.Op)

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

Forms:

VPMOVSXBQ xmm xmm
VPMOVSXBQ m16 xmm
VPMOVSXBQ xmm ymm
VPMOVSXBQ m32 ymm

Construct and append a VPMOVSXBQ instruction to the active function.

func (*Context) VPMOVSXBW ¶

func (c *Context) VPMOVSXBW(mx, xy operand.Op)

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

Forms:

VPMOVSXBW xmm  xmm
VPMOVSXBW m64  xmm
VPMOVSXBW xmm  ymm
VPMOVSXBW m128 ymm

Construct and append a VPMOVSXBW instruction to the active function.

func (*Context) VPMOVSXDQ ¶

func (c *Context) VPMOVSXDQ(mx, xy operand.Op)

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

Forms:

VPMOVSXDQ xmm  xmm
VPMOVSXDQ m64  xmm
VPMOVSXDQ xmm  ymm
VPMOVSXDQ m128 ymm

Construct and append a VPMOVSXDQ instruction to the active function.

func (*Context) VPMOVSXWD ¶

func (c *Context) VPMOVSXWD(mx, xy operand.Op)

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

Forms:

VPMOVSXWD xmm  xmm
VPMOVSXWD m64  xmm
VPMOVSXWD xmm  ymm
VPMOVSXWD m128 ymm

Construct and append a VPMOVSXWD instruction to the active function.

func (*Context) VPMOVSXWQ ¶

func (c *Context) VPMOVSXWQ(mx, xy operand.Op)

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

Forms:

VPMOVSXWQ xmm xmm
VPMOVSXWQ m32 xmm
VPMOVSXWQ xmm ymm
VPMOVSXWQ m64 ymm

Construct and append a VPMOVSXWQ instruction to the active function.

func (*Context) VPMOVZXBD ¶

func (c *Context) VPMOVZXBD(mx, xy operand.Op)

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

Forms:

VPMOVZXBD xmm xmm
VPMOVZXBD m32 xmm
VPMOVZXBD xmm ymm
VPMOVZXBD m64 ymm

Construct and append a VPMOVZXBD instruction to the active function.

func (*Context) VPMOVZXBQ ¶

func (c *Context) VPMOVZXBQ(mx, xy operand.Op)

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

Forms:

VPMOVZXBQ xmm xmm
VPMOVZXBQ m16 xmm
VPMOVZXBQ xmm ymm
VPMOVZXBQ m32 ymm

Construct and append a VPMOVZXBQ instruction to the active function.

func (*Context) VPMOVZXBW ¶

func (c *Context) VPMOVZXBW(mx, xy operand.Op)

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

Forms:

VPMOVZXBW xmm  xmm
VPMOVZXBW m64  xmm
VPMOVZXBW xmm  ymm
VPMOVZXBW m128 ymm

Construct and append a VPMOVZXBW instruction to the active function.

func (*Context) VPMOVZXDQ ¶

func (c *Context) VPMOVZXDQ(mx, xy operand.Op)

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

Forms:

VPMOVZXDQ xmm  xmm
VPMOVZXDQ m64  xmm
VPMOVZXDQ xmm  ymm
VPMOVZXDQ m128 ymm

Construct and append a VPMOVZXDQ instruction to the active function.

func (*Context) VPMOVZXWD ¶

func (c *Context) VPMOVZXWD(mx, xy operand.Op)

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

Forms:

VPMOVZXWD xmm  xmm
VPMOVZXWD m64  xmm
VPMOVZXWD xmm  ymm
VPMOVZXWD m128 ymm

Construct and append a VPMOVZXWD instruction to the active function.

func (*Context) VPMOVZXWQ ¶

func (c *Context) VPMOVZXWQ(mx, xy operand.Op)

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

Forms:

VPMOVZXWQ xmm xmm
VPMOVZXWQ m32 xmm
VPMOVZXWQ xmm ymm
VPMOVZXWQ m64 ymm

Construct and append a VPMOVZXWQ instruction to the active function.

func (*Context) VPMULDQ ¶

func (c *Context) VPMULDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULDQ instruction to the active function.

func (*Context) VPMULHRSW ¶

func (c *Context) VPMULHRSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULHRSW instruction to the active function.

func (*Context) VPMULHUW ¶

func (c *Context) VPMULHUW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULHUW instruction to the active function.

func (*Context) VPMULHW ¶

func (c *Context) VPMULHW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULHW instruction to the active function.

func (*Context) VPMULLD ¶

func (c *Context) VPMULLD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULLD instruction to the active function.

func (*Context) VPMULLW ¶

func (c *Context) VPMULLW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPMULLW instruction to the active function.

func (*Context) VPMULUDQ ¶

func (c *Context) VPMULUDQ(mxy, xy, xy1 operand.Op)

VPMULUDQ: Multiply Packed Unsigned Doubleword Integers.

Forms:

VPMULUDQ xmm  xmm xmm
VPMULUDQ m128 xmm xmm
VPMULUDQ ymm  ymm ymm
VPMULUDQ m256 ymm ymm

Construct and append a VPMULUDQ instruction to the active function.

func (*Context) VPOR ¶

func (c *Context) VPOR(mxy, xy, xy1 operand.Op)

VPOR: Packed Bitwise Logical OR.

Forms:

VPOR xmm  xmm xmm
VPOR m128 xmm xmm
VPOR ymm  ymm ymm
VPOR m256 ymm ymm

Construct and append a VPOR instruction to the active function.

func (*Context) VPSADBW ¶

func (c *Context) VPSADBW(mxy, xy, xy1 operand.Op)

VPSADBW: Compute Sum of Absolute Differences.

Forms:

VPSADBW xmm  xmm xmm
VPSADBW m128 xmm xmm
VPSADBW ymm  ymm ymm
VPSADBW m256 ymm ymm

Construct and append a VPSADBW instruction to the active function.

func (*Context) VPSHUFB ¶

func (c *Context) VPSHUFB(mxy, xy, xy1 operand.Op)

VPSHUFB: Packed Shuffle Bytes.

Forms:

VPSHUFB xmm  xmm xmm
VPSHUFB m128 xmm xmm
VPSHUFB ymm  ymm ymm
VPSHUFB m256 ymm ymm

Construct and append a VPSHUFB instruction to the active function.

func (*Context) VPSHUFD ¶

func (c *Context) VPSHUFD(i, mxy, xy operand.Op)

VPSHUFD: Shuffle Packed Doublewords.

Forms:

VPSHUFD imm8 xmm  xmm
VPSHUFD imm8 m128 xmm
VPSHUFD imm8 ymm  ymm
VPSHUFD imm8 m256 ymm

Construct and append a VPSHUFD instruction to the active function.

func (*Context) VPSHUFHW ¶

func (c *Context) VPSHUFHW(i, mxy, xy operand.Op)

VPSHUFHW: Shuffle Packed High Words.

Forms:

VPSHUFHW imm8 xmm  xmm
VPSHUFHW imm8 m128 xmm
VPSHUFHW imm8 ymm  ymm
VPSHUFHW imm8 m256 ymm

Construct and append a VPSHUFHW instruction to the active function.

func (*Context) VPSHUFLW ¶

func (c *Context) VPSHUFLW(i, mxy, xy operand.Op)

VPSHUFLW: Shuffle Packed Low Words.

Forms:

VPSHUFLW imm8 xmm  xmm
VPSHUFLW imm8 m128 xmm
VPSHUFLW imm8 ymm  ymm
VPSHUFLW imm8 m256 ymm

Construct and append a VPSHUFLW instruction to the active function.

func (*Context) VPSIGNB ¶

func (c *Context) VPSIGNB(mxy, xy, xy1 operand.Op)

VPSIGNB: Packed Sign of Byte Integers.

Forms:

VPSIGNB xmm  xmm xmm
VPSIGNB m128 xmm xmm
VPSIGNB ymm  ymm ymm
VPSIGNB m256 ymm ymm

Construct and append a VPSIGNB instruction to the active function.

func (*Context) VPSIGND ¶

func (c *Context) VPSIGND(mxy, xy, xy1 operand.Op)

VPSIGND: Packed Sign of Doubleword Integers.

Forms:

VPSIGND xmm  xmm xmm
VPSIGND m128 xmm xmm
VPSIGND ymm  ymm ymm
VPSIGND m256 ymm ymm

Construct and append a VPSIGND instruction to the active function.

func (*Context) VPSIGNW ¶

func (c *Context) VPSIGNW(mxy, xy, xy1 operand.Op)

VPSIGNW: Packed Sign of Word Integers.

Forms:

VPSIGNW xmm  xmm xmm
VPSIGNW m128 xmm xmm
VPSIGNW ymm  ymm ymm
VPSIGNW m256 ymm ymm

Construct and append a VPSIGNW instruction to the active function.

func (*Context) VPSLLD ¶

func (c *Context) VPSLLD(imx, xy, xy1 operand.Op)

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

Construct and append a VPSLLD instruction to the active function.

func (*Context) VPSLLDQ ¶

func (c *Context) VPSLLDQ(i, xy, xy1 operand.Op)

VPSLLDQ: Shift Packed Double Quadword Left Logical.

Forms:

VPSLLDQ imm8 xmm xmm
VPSLLDQ imm8 ymm ymm

Construct and append a VPSLLDQ instruction to the active function.

func (*Context) VPSLLQ ¶

func (c *Context) VPSLLQ(imx, xy, xy1 operand.Op)

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

Construct and append a VPSLLQ instruction to the active function.

func (*Context) VPSLLVD ¶

func (c *Context) VPSLLVD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSLLVD instruction to the active function.

func (*Context) VPSLLVQ ¶

func (c *Context) VPSLLVQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSLLVQ instruction to the active function.

func (*Context) VPSLLW ¶

func (c *Context) VPSLLW(imx, xy, xy1 operand.Op)

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

Construct and append a VPSLLW instruction to the active function.

func (*Context) VPSRAD ¶

func (c *Context) VPSRAD(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRAD instruction to the active function.

func (*Context) VPSRAVD ¶

func (c *Context) VPSRAVD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSRAVD instruction to the active function.

func (*Context) VPSRAW ¶

func (c *Context) VPSRAW(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRAW instruction to the active function.

func (*Context) VPSRLD ¶

func (c *Context) VPSRLD(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRLD instruction to the active function.

func (*Context) VPSRLDQ ¶

func (c *Context) VPSRLDQ(i, xy, xy1 operand.Op)

VPSRLDQ: Shift Packed Double Quadword Right Logical.

Forms:

VPSRLDQ imm8 xmm xmm
VPSRLDQ imm8 ymm ymm

Construct and append a VPSRLDQ instruction to the active function.

func (*Context) VPSRLQ ¶

func (c *Context) VPSRLQ(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRLQ instruction to the active function.

func (*Context) VPSRLVD ¶

func (c *Context) VPSRLVD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSRLVD instruction to the active function.

func (*Context) VPSRLVQ ¶

func (c *Context) VPSRLVQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSRLVQ instruction to the active function.

func (*Context) VPSRLW ¶

func (c *Context) VPSRLW(imx, xy, xy1 operand.Op)

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

Construct and append a VPSRLW instruction to the active function.

func (*Context) VPSUBB ¶

func (c *Context) VPSUBB(mxy, xy, xy1 operand.Op)

VPSUBB: Subtract Packed Byte Integers.

Forms:

VPSUBB xmm  xmm xmm
VPSUBB m128 xmm xmm
VPSUBB ymm  ymm ymm
VPSUBB m256 ymm ymm

Construct and append a VPSUBB instruction to the active function.

func (*Context) VPSUBD ¶

func (c *Context) VPSUBD(mxy, xy, xy1 operand.Op)

VPSUBD: Subtract Packed Doubleword Integers.

Forms:

VPSUBD xmm  xmm xmm
VPSUBD m128 xmm xmm
VPSUBD ymm  ymm ymm
VPSUBD m256 ymm ymm

Construct and append a VPSUBD instruction to the active function.

func (*Context) VPSUBQ ¶

func (c *Context) VPSUBQ(mxy, xy, xy1 operand.Op)

VPSUBQ: Subtract Packed Quadword Integers.

Forms:

VPSUBQ xmm  xmm xmm
VPSUBQ m128 xmm xmm
VPSUBQ ymm  ymm ymm
VPSUBQ m256 ymm ymm

Construct and append a VPSUBQ instruction to the active function.

func (*Context) VPSUBSB ¶

func (c *Context) VPSUBSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBSB instruction to the active function.

func (*Context) VPSUBSW ¶

func (c *Context) VPSUBSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBSW instruction to the active function.

func (*Context) VPSUBUSB ¶

func (c *Context) VPSUBUSB(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBUSB instruction to the active function.

func (*Context) VPSUBUSW ¶

func (c *Context) VPSUBUSW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPSUBUSW instruction to the active function.

func (*Context) VPSUBW ¶

func (c *Context) VPSUBW(mxy, xy, xy1 operand.Op)

VPSUBW: Subtract Packed Word Integers.

Forms:

VPSUBW xmm  xmm xmm
VPSUBW m128 xmm xmm
VPSUBW ymm  ymm ymm
VPSUBW m256 ymm ymm

Construct and append a VPSUBW instruction to the active function.

func (*Context) VPTEST ¶

func (c *Context) VPTEST(mxy, xy operand.Op)

VPTEST: Packed Logical Compare.

Forms:

VPTEST xmm  xmm
VPTEST m128 xmm
VPTEST ymm  ymm
VPTEST m256 ymm

Construct and append a VPTEST instruction to the active function.

func (*Context) VPUNPCKHBW ¶

func (c *Context) VPUNPCKHBW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHBW instruction to the active function.

func (*Context) VPUNPCKHDQ ¶

func (c *Context) VPUNPCKHDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHDQ instruction to the active function.

func (*Context) VPUNPCKHQDQ ¶

func (c *Context) VPUNPCKHQDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHQDQ instruction to the active function.

func (*Context) VPUNPCKHWD ¶

func (c *Context) VPUNPCKHWD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKHWD instruction to the active function.

func (*Context) VPUNPCKLBW ¶

func (c *Context) VPUNPCKLBW(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLBW instruction to the active function.

func (*Context) VPUNPCKLDQ ¶

func (c *Context) VPUNPCKLDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLDQ instruction to the active function.

func (*Context) VPUNPCKLQDQ ¶

func (c *Context) VPUNPCKLQDQ(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLQDQ instruction to the active function.

func (*Context) VPUNPCKLWD ¶

func (c *Context) VPUNPCKLWD(mxy, xy, xy1 operand.Op)

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

Construct and append a VPUNPCKLWD instruction to the active function.

func (*Context) VPXOR ¶

func (c *Context) VPXOR(mxy, xy, xy1 operand.Op)

VPXOR: Packed Bitwise Logical Exclusive OR.

Forms:

VPXOR xmm  xmm xmm
VPXOR m128 xmm xmm
VPXOR ymm  ymm ymm
VPXOR m256 ymm ymm

Construct and append a VPXOR instruction to the active function.

func (*Context) VRCPPS ¶

func (c *Context) VRCPPS(mxy, xy operand.Op)

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

Forms:

VRCPPS xmm  xmm
VRCPPS m128 xmm
VRCPPS ymm  ymm
VRCPPS m256 ymm

Construct and append a VRCPPS instruction to the active function.

func (*Context) VRCPSS ¶

func (c *Context) VRCPSS(mx, x, x1 operand.Op)

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

Forms:

VRCPSS xmm xmm xmm
VRCPSS m32 xmm xmm

Construct and append a VRCPSS instruction to the active function.

func (*Context) VROUNDPD ¶

func (c *Context) VROUNDPD(i, mxy, xy operand.Op)

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

Construct and append a VROUNDPD instruction to the active function.

func (*Context) VROUNDPS ¶

func (c *Context) VROUNDPS(i, mxy, xy operand.Op)

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

Construct and append a VROUNDPS instruction to the active function.

func (*Context) VROUNDSD ¶

func (c *Context) VROUNDSD(i, mx, x, x1 operand.Op)

VROUNDSD: Round Scalar Double Precision Floating-Point Values.

Forms:

VROUNDSD imm8 xmm xmm xmm
VROUNDSD imm8 m64 xmm xmm

Construct and append a VROUNDSD instruction to the active function.

func (*Context) VROUNDSS ¶

func (c *Context) VROUNDSS(i, mx, x, x1 operand.Op)

VROUNDSS: Round Scalar Single Precision Floating-Point Values.

Forms:

VROUNDSS imm8 xmm xmm xmm
VROUNDSS imm8 m32 xmm xmm

Construct and append a VROUNDSS instruction to the active function.

func (*Context) VRSQRTPS ¶

func (c *Context) VRSQRTPS(mxy, xy operand.Op)

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

Construct and append a VRSQRTPS instruction to the active function.

func (*Context) VRSQRTSS ¶

func (c *Context) VRSQRTSS(mx, x, x1 operand.Op)

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

Forms:

VRSQRTSS xmm xmm xmm
VRSQRTSS m32 xmm xmm

Construct and append a VRSQRTSS instruction to the active function.

func (*Context) VSHUFPD ¶

func (c *Context) VSHUFPD(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VSHUFPD instruction to the active function.

func (*Context) VSHUFPS ¶

func (c *Context) VSHUFPS(i, mxy, xy, xy1 operand.Op)

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

Construct and append a VSHUFPS instruction to the active function.

func (*Context) VSQRTPD ¶

func (c *Context) VSQRTPD(mxy, xy operand.Op)

VSQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values.

Forms:

VSQRTPD xmm  xmm
VSQRTPD m128 xmm
VSQRTPD ymm  ymm
VSQRTPD m256 ymm

Construct and append a VSQRTPD instruction to the active function.

func (*Context) VSQRTPS ¶

func (c *Context) VSQRTPS(mxy, xy operand.Op)

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

Forms:

VSQRTPS xmm  xmm
VSQRTPS m128 xmm
VSQRTPS ymm  ymm
VSQRTPS m256 ymm

Construct and append a VSQRTPS instruction to the active function.

func (*Context) VSQRTSD ¶

func (c *Context) VSQRTSD(mx, x, x1 operand.Op)

VSQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value.

Forms:

VSQRTSD xmm xmm xmm
VSQRTSD m64 xmm xmm

Construct and append a VSQRTSD instruction to the active function.

func (*Context) VSQRTSS ¶

func (c *Context) VSQRTSS(mx, x, x1 operand.Op)

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

Forms:

VSQRTSS xmm xmm xmm
VSQRTSS m32 xmm xmm

Construct and append a VSQRTSS instruction to the active function.

func (*Context) VSTMXCSR ¶

func (c *Context) VSTMXCSR(m operand.Op)

VSTMXCSR: Store MXCSR Register State.

Forms:

VSTMXCSR m32

Construct and append a VSTMXCSR instruction to the active function.

func (*Context) VSUBPD ¶

func (c *Context) VSUBPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VSUBPD instruction to the active function.

func (*Context) VSUBPS ¶

func (c *Context) VSUBPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VSUBPS instruction to the active function.

func (*Context) VSUBSD ¶

func (c *Context) VSUBSD(mx, x, x1 operand.Op)

VSUBSD: Subtract Scalar Double-Precision Floating-Point Values.

Forms:

VSUBSD xmm xmm xmm
VSUBSD m64 xmm xmm

Construct and append a VSUBSD instruction to the active function.

func (*Context) VSUBSS ¶

func (c *Context) VSUBSS(mx, x, x1 operand.Op)

VSUBSS: Subtract Scalar Single-Precision Floating-Point Values.

Forms:

VSUBSS xmm xmm xmm
VSUBSS m32 xmm xmm

Construct and append a VSUBSS instruction to the active function.

func (*Context) VTESTPD ¶

func (c *Context) VTESTPD(mxy, xy operand.Op)

VTESTPD: Packed Double-Precision Floating-Point Bit Test.

Forms:

VTESTPD xmm  xmm
VTESTPD m128 xmm
VTESTPD ymm  ymm
VTESTPD m256 ymm

Construct and append a VTESTPD instruction to the active function.

func (*Context) VTESTPS ¶

func (c *Context) VTESTPS(mxy, xy operand.Op)

VTESTPS: Packed Single-Precision Floating-Point Bit Test.

Forms:

VTESTPS xmm  xmm
VTESTPS m128 xmm
VTESTPS ymm  ymm
VTESTPS m256 ymm

Construct and append a VTESTPS instruction to the active function.

func (*Context) VUCOMISD ¶

func (c *Context) VUCOMISD(mx, x operand.Op)

VUCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS.

Forms:

VUCOMISD xmm xmm
VUCOMISD m64 xmm

Construct and append a VUCOMISD instruction to the active function.

func (*Context) VUCOMISS ¶

func (c *Context) VUCOMISS(mx, x operand.Op)

VUCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS.

Forms:

VUCOMISS xmm xmm
VUCOMISS m32 xmm

Construct and append a VUCOMISS instruction to the active function.

func (*Context) VUNPCKHPD ¶

func (c *Context) VUNPCKHPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKHPD instruction to the active function.

func (*Context) VUNPCKHPS ¶

func (c *Context) VUNPCKHPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKHPS instruction to the active function.

func (*Context) VUNPCKLPD ¶

func (c *Context) VUNPCKLPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKLPD instruction to the active function.

func (*Context) VUNPCKLPS ¶

func (c *Context) VUNPCKLPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VUNPCKLPS instruction to the active function.

func (*Context) VXORPD ¶

func (c *Context) VXORPD(mxy, xy, xy1 operand.Op)

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

Construct and append a VXORPD instruction to the active function.

func (*Context) VXORPS ¶

func (c *Context) VXORPS(mxy, xy, xy1 operand.Op)

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

Construct and append a VXORPS instruction to the active function.

func (*Context) VZEROALL ¶

func (c *Context) VZEROALL()

VZEROALL: Zero All YMM Registers.

Forms:

VZEROALL

Construct and append a VZEROALL instruction to the active function.

func (*Context) VZEROUPPER ¶

func (c *Context) VZEROUPPER()

VZEROUPPER: Zero Upper Bits of YMM Registers.

Forms:

VZEROUPPER

Construct and append a VZEROUPPER instruction to the active function.

func (*Context) XADDB ¶

func (c *Context) XADDB(r, mr operand.Op)

XADDB: Exchange and Add.

Forms:

XADDB r8 r8
XADDB r8 m8

Construct and append a XADDB instruction to the active function.

func (*Context) XADDL ¶

func (c *Context) XADDL(r, mr operand.Op)

XADDL: Exchange and Add.

Forms:

XADDL r32 r32
XADDL r32 m32

Construct and append a XADDL instruction to the active function.

func (*Context) XADDQ ¶

func (c *Context) XADDQ(r, mr operand.Op)

XADDQ: Exchange and Add.

Forms:

XADDQ r64 r64
XADDQ r64 m64

Construct and append a XADDQ instruction to the active function.

func (*Context) XADDW ¶

func (c *Context) XADDW(r, mr operand.Op)

XADDW: Exchange and Add.

Forms:

XADDW r16 r16
XADDW r16 m16

Construct and append a XADDW instruction to the active function.

func (*Context) XCHGB ¶

func (c *Context) XCHGB(mr, mr1 operand.Op)

XCHGB: Exchange Register/Memory with Register.

Forms:

XCHGB r8 r8
XCHGB m8 r8
XCHGB r8 m8

Construct and append a XCHGB instruction to the active function.

func (*Context) XCHGL ¶

func (c *Context) XCHGL(emr, emr1 operand.Op)

XCHGL: Exchange Register/Memory with Register.

Forms:

XCHGL r32 eax
XCHGL eax r32
XCHGL r32 r32
XCHGL m32 r32
XCHGL r32 m32

Construct and append a XCHGL instruction to the active function.

func (*Context) XCHGQ ¶

func (c *Context) XCHGQ(mr, mr1 operand.Op)

XCHGQ: Exchange Register/Memory with Register.

Forms:

XCHGQ r64 rax
XCHGQ rax r64
XCHGQ r64 r64
XCHGQ m64 r64
XCHGQ r64 m64

Construct and append a XCHGQ instruction to the active function.

func (*Context) XCHGW ¶

func (c *Context) XCHGW(amr, amr1 operand.Op)

XCHGW: Exchange Register/Memory with Register.

Forms:

XCHGW r16 ax
XCHGW ax  r16
XCHGW r16 r16
XCHGW m16 r16
XCHGW r16 m16

Construct and append a XCHGW instruction to the active function.

func (*Context) XGETBV ¶

func (c *Context) XGETBV()

XGETBV: Get Value of Extended Control Register.

Forms:

XGETBV

Construct and append a XGETBV instruction to the active function.

func (*Context) XLAT ¶

func (c *Context) XLAT()

XLAT: Table Look-up Translation.

Forms:

XLAT

Construct and append a XLAT instruction to the active function.

func (*Context) XORB ¶

func (c *Context) XORB(imr, amr operand.Op)

XORB: Logical Exclusive OR.

Forms:

XORB imm8 al
XORB imm8 r8
XORB r8   r8
XORB m8   r8
XORB imm8 m8
XORB r8   m8

Construct and append a XORB instruction to the active function.

func (*Context) XORL ¶

func (c *Context) XORL(imr, emr operand.Op)

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

Construct and append a XORL instruction to the active function.

func (*Context) XORPD ¶

func (c *Context) XORPD(mx, x operand.Op)

XORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values.

Forms:

XORPD xmm  xmm
XORPD m128 xmm

Construct and append a XORPD instruction to the active function.

func (*Context) XORPS ¶

func (c *Context) XORPS(mx, x operand.Op)

XORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values.

Forms:

XORPS xmm  xmm
XORPS m128 xmm

Construct and append a XORPS instruction to the active function.

func (*Context) XORQ ¶

func (c *Context) XORQ(imr, mr operand.Op)

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

Construct and append a XORQ instruction to the active function.

func (*Context) XORW ¶

func (c *Context) XORW(imr, amr operand.Op)

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

Construct and append a XORW instruction to the active function.

type Error ¶

type Error struct {
	Position src.Position
	Err      error
}

Error represents an error during building, optionally tagged with the position at which it happened.

func (Error) Error ¶

func (e Error) Error() string

type ErrorList ¶

type ErrorList []Error

ErrorList is a collection of errors for a source file.

func (*ErrorList) Add ¶

func (e *ErrorList) Add(err Error)

Add appends an error to the list.

func (*ErrorList) AddAt ¶

func (e *ErrorList) AddAt(p src.Position, err error)

AddAt appends an error at position p.

func (ErrorList) Err ¶

func (e ErrorList) Err() error

Err returns an error equivalent to this error list. If the list is empty, Err returns nil.

func (ErrorList) Error ¶

func (e ErrorList) Error() string

An ErrorList implements the error interface.

type Flags ¶

type Flags struct {
	// contains filtered or unexported fields
}

Flags represents CLI flags for an avo program.

func NewFlags ¶

func NewFlags(fs *flag.FlagSet) *Flags

NewFlags initializes avo flags for the given FlagSet.

func (*Flags) Config ¶

func (f *Flags) Config() *Config

Config builds a configuration object based on flag values.

Source Files ¶

attr.go cli.go context.go doc.go error.go global.go pseudo.go zinstructions.go zmov.go

Version: v0.2.0
Published: Apr 19, 2021
Platform: darwin/amd64
Imports: 20 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