build

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 19, 2021 License: BSD-3-Clause Imports: 20 Imported by: 51

Documentation

Overview

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

Index

Constants

View Source 
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.

Variables

This section is empty.

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 Commentf 

func Commentf(format string, a ...interface{})

Commentf adds a formtted comment line.

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)

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 (*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

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.