x86_64

package
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: Apr 17, 2024 License: Apache-2.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	AH = SPL | 0x80
	CH = BPL | 0x80
	DH = SIL | 0x80
	BH = DIL | 0x80
)

Variables

View Source 
var DefaultArch = CreateArch()

DefaultArch is the default architecture with all ISA enabled.

View Source 
var Instructions = map[string]_InstructionEncoder{}/* 1364 elements not displayed */

Instructions maps all the instruction name to it's encoder function.

View Source 
var Registers = map[string]Register{}/* 180 elements not displayed */

Registers maps register name into Register instances.

Functions

This section is empty.

Types

type AddressType 

type AddressType uint

AddressType indicates which kind of value that an Addressable object contains. 

const (
	// None indicates the Addressable does not contain any addressable value.
	None AddressType = iota

	// Memory indicates the Addressable contains a memory address.
	Memory

	// Offset indicates the Addressable contains an RIP-relative offset.
	Offset

	// Reference indicates the Addressable contains a label reference.
	Reference
)

type Addressable 

type Addressable struct {
	Type      AddressType
	Memory    MemoryAddress
	Offset    RelativeOffset
	Reference *Label
}

Addressable is a union to represent an addressable operand.

func (*Addressable) String 

func (self *Addressable) String() string

String implements the fmt.Stringer interface.

type Arch 

type Arch struct {
	// contains filtered or unexported fields
}

Arch represents the x86_64 architecture.

func CreateArch 

func CreateArch() *Arch

CreateArch creates a new Arch with all ISA enabled.

func (*Arch) CreateProgram 

func (self *Arch) CreateProgram() *Program

CreateProgram creates a new empty program.

func (*Arch) DisableISA 

func (self *Arch) DisableISA(isa ISA) *Arch

DisableISA disables a particular ISA.

func (*Arch) EnableISA 

func (self *Arch) EnableISA(isa ISA) *Arch

EnableISA enables a particular ISA.

func (*Arch) HasISA 

func (self *Arch) HasISA(isa ISA) bool

HasISA checks if a particular ISA was enabled.

type Assembler 

type Assembler struct {
	// contains filtered or unexported fields
}

Assembler assembles the entire assembly program and generates the corresponding machine code representations.

func (*Assembler) Assemble 

func (self *Assembler) Assemble(src string) error

Assemble assembles the assembly source and save the machine code to internal buffer.

func (*Assembler) Base 

func (self *Assembler) Base() uintptr

Base returns the origin.

func (*Assembler) Code 

func (self *Assembler) Code() []byte

Code returns the assembled machine code.

func (*Assembler) Entry 

func (self *Assembler) Entry() uintptr

Entry returns the address of the specified entry point, or the origin if not specified.

func (*Assembler) Options 

func (self *Assembler) Options() *Options

Options returns the internal options reference, changing it WILL affect this Assembler instance.

func (*Assembler) WithBase 

func (self *Assembler) WithBase(pc uintptr) *Assembler

WithBase resets the origin to pc.

type Disposable 

type Disposable interface {
	Free()
}

Disposable is a type of object that can be Free'd manually.

type ExceptionControl 

type ExceptionControl uint8

ExceptionControl represents the "Suppress All Exceptions" flag. 

const (
	// SAE represents the flag "Suppress All Exceptions" for floating point operations.
	SAE ExceptionControl = iota
)

func (ExceptionControl) String 

func (ExceptionControl) String() string

type ISA 

type ISA uint64

ISA represents an extension to x86-64 instruction set. 

const (
	ISA_CPUID ISA = 1 << iota
	ISA_RDTSC
	ISA_RDTSCP
	ISA_CMOV
	ISA_MOVBE
	ISA_POPCNT
	ISA_LZCNT
	ISA_TBM
	ISA_BMI
	ISA_BMI2
	ISA_ADX
	ISA_MMX
	ISA_MMX_PLUS
	ISA_FEMMS
	ISA_3DNOW
	ISA_3DNOW_PLUS
	ISA_SSE
	ISA_SSE2
	ISA_SSE3
	ISA_SSSE3
	ISA_SSE4A
	ISA_SSE4_1
	ISA_SSE4_2
	ISA_FMA3
	ISA_FMA4
	ISA_XOP
	ISA_F16C
	ISA_AVX
	ISA_AVX2
	ISA_AVX512F
	ISA_AVX512BW
	ISA_AVX512DQ
	ISA_AVX512VL
	ISA_AVX512PF
	ISA_AVX512ER
	ISA_AVX512CD
	ISA_AVX512VBMI
	ISA_AVX512IFMA
	ISA_AVX512VPOPCNTDQ
	ISA_AVX512_4VNNIW
	ISA_AVX512_4FMAPS
	ISA_PREFETCH
	ISA_PREFETCHW
	ISA_PREFETCHWT1
	ISA_CLFLUSH
	ISA_CLFLUSHOPT
	ISA_CLWB
	ISA_CLZERO
	ISA_RDRAND
	ISA_RDSEED
	ISA_PCLMULQDQ
	ISA_AES
	ISA_SHA
	ISA_MONITOR
	ISA_MONITORX
	ISA_ALL = ^ISA(0)
)

func ParseISA 

func ParseISA(name string) ISA

ParseISA parses name into ISA, it will panic if the name is invalid.

func (ISA) String 

func (self ISA) String() string

type Instruction 

type Instruction struct {
	// contains filtered or unexported fields
}

Instruction represents an unencoded instruction.

func (*Instruction) CS 

func (self *Instruction) CS() *Instruction

CS overrides the memory operation of this instruction to CS.

func (*Instruction) DS 

func (self *Instruction) DS() *Instruction

DS overrides the memory operation of this instruction to DS, this is the default section for most instructions if not specified.

func (*Instruction) Domain 

func (self *Instruction) Domain() InstructionDomain

Domain returns the domain of this instruction.

func (*Instruction) ES 

func (self *Instruction) ES() *Instruction

ES overrides the memory operation of this instruction to ES.

func (*Instruction) FS 

func (self *Instruction) FS() *Instruction

FS overrides the memory operation of this instruction to FS.

func (*Instruction) GS 

func (self *Instruction) GS() *Instruction

GS overrides the memory operation of this instruction to GS.

func (*Instruction) LOCK 

func (self *Instruction) LOCK() *Instruction

LOCK causes the processor's LOCK# signal to be asserted during execution of the accompanying instruction (turns the instruction into an atomic instruction). In a multiprocessor environment, the LOCK# signal insures that the processor has exclusive use of any shared memory while the signal is asserted.

func (*Instruction) Name 

func (self *Instruction) Name() string

Name returns the instruction name.

func (*Instruction) Operands 

func (self *Instruction) Operands() []interface{}

Operands returns the operands of this instruction.

func (*Instruction) SS 

func (self *Instruction) SS() *Instruction

SS overrides the memory operation of this instruction to SS.

type InstructionDomain 

type InstructionDomain uint8

InstructionDomain represents the domain of an instruction. 

const (
	DomainGeneric InstructionDomain = iota
	DomainMMXSSE
	DomainAVX
	DomainFMA
	DomainCrypto
	DomainMask
	DomainAMDSpecific
	DomainMisc
	DomainPseudo
)

type InstructionPrefix 

type InstructionPrefix byte

InstructionPrefix indicates the prefix bytes prepended to the instruction. 

const (
	// PrefixLock causes the processor's LOCK# signal to be asserted during execution of
	// the accompanying instruction (turns the instruction into an atomic instruction).
	// In a multiprocessor environment, the LOCK# signal insures that the processor
	// has exclusive use of any shared memory while the signal is asserted.
	PrefixLock InstructionPrefix = iota

	// PrefixSegmentCS overrides the memory operation of this instruction to CS (Code Segment).
	PrefixSegmentCS

	// PrefixSegmentDS overrides the memory operation of this instruction to DS (Data Segment),
	// this is the default section for most instructions if not specified.
	PrefixSegmentDS

	// PrefixSegmentES overrides the memory operation of this instruction to ES (Extra Segment).
	PrefixSegmentES

	// PrefixSegmentFS overrides the memory operation of this instruction to FS.
	PrefixSegmentFS

	// PrefixSegmentGS overrides the memory operation of this instruction to GS.
	PrefixSegmentGS

	// PrefixSegmentSS overrides the memory operation of this instruction to SS (Stack Segment).
	PrefixSegmentSS
)

type KRegister 

type KRegister byte
const (
	K0 KRegister = iota
	K1
	K2
	K3
	K4
	K5
	K6
	K7
)

func (KRegister) String 

func (self KRegister) String() string

type Label 

type Label struct {
	Name string
	Dest *Instruction
	// contains filtered or unexported fields
}

Label represents a location within the program.

func CreateLabel 

func CreateLabel(name string) *Label

CreateLabel creates a new Label, it may allocate a new one or grab one from a pool.

func (*Label) Evaluate 

func (self *Label) Evaluate() (int64, error)

Evaluate implements the interface expr.Term.

func (*Label) Free 

func (self *Label) Free()

Free decreases the reference count of a Label, if the refcount drops to 0, the Label will be recycled.

func (*Label) Retain 

func (self *Label) Retain() *Label

Retain increases the reference count of a Label.

func (*Label) String 

func (self *Label) String() string

String implements the fmt.Stringer interface.

type LabelKind 

type LabelKind int

LabelKind indicates the type of label reference. 

const (
	// Declaration means the label is a declaration.
	Declaration LabelKind = iota + 1

	// BranchTarget means the label should be treated as a branch target.
	BranchTarget

	// RelativeAddress means the label should be treated as a reference to
	// the code section (e.g. RIP-relative addressing).
	RelativeAddress
)

type LineKind 

type LineKind int

LineKind indicates the type of ParsedLine. 

const (
	// LineLabel means the ParsedLine is a label.
	LineLabel LineKind = iota + 1

	// LineInstr means the ParsedLine is an instruction.
	LineInstr

	// LineCommand means the ParsedLine is a ParsedCommand.
	LineCommand
)

type MMRegister 

type MMRegister byte
const (
	MM0 MMRegister = iota
	MM1
	MM2
	MM3
	MM4
	MM5
	MM6
	MM7
)

func (MMRegister) String 

func (self MMRegister) String() string

type MaskedRegister 

type MaskedRegister struct {
	Reg  Register
	Mask RegisterMask
}

MaskedRegister is a Register masked by a RegisterMask.

func (MaskedRegister) String 

func (self MaskedRegister) String() string

String implements the fmt.Stringer interface.

type MemoryAddress 

type MemoryAddress struct {
	Base         Register
	Index        Register
	Scale        uint8
	Displacement int32
}

MemoryAddress represents a memory address.

func (*MemoryAddress) EnsureValid 

func (self *MemoryAddress) EnsureValid()

EnsureValid checks if the memory address is valid, if not, it panics.

func (*MemoryAddress) String 

func (self *MemoryAddress) String() string

String implements the fmt.Stringer interface.

type MemoryOperand 

type MemoryOperand struct {
	Size      int
	Addr      Addressable
	Mask      RegisterMask
	Masked    bool
	Broadcast uint8
	// contains filtered or unexported fields
}

MemoryOperand represents a memory operand for an instruction.

func Abs 

func Abs(disp int32) *MemoryOperand

Abs construct a simple memory address that represents absolute addressing.

func CreateMemoryOperand 

func CreateMemoryOperand() *MemoryOperand

CreateMemoryOperand creates a new MemoryOperand, it may allocate a new one or grab one from a pool.

func Ptr 

func Ptr(base Register, disp int32) *MemoryOperand

Ptr constructs a simple memory operand with base and displacement.

func Ref 

func Ref(ref *Label) (v *MemoryOperand)

Ref constructs a memory reference to a label.

func Sib 

func Sib(base Register, index Register, scale uint8, disp int32) (v *MemoryOperand)

Sib constructs a simple memory operand that represents a complete memory address.

func (*MemoryOperand) EnsureValid 

func (self *MemoryOperand) EnsureValid()

EnsureValid checks if the memory operand is valid, if not, it panics.

func (*MemoryOperand) Free 

func (self *MemoryOperand) Free()

Free decreases the reference count of a MemoryOperand, if the refcount drops to 0, the Label will be recycled.

func (*MemoryOperand) Retain 

func (self *MemoryOperand) Retain() *MemoryOperand

Retain increases the reference count of a MemoryOperand.

func (*MemoryOperand) String 

func (self *MemoryOperand) String() string

String implements the fmt.Stringer interface.

type OperandKind 

type OperandKind int

OperandKind indicates the type of the operand. 

const (
	// OpImm means the operand is an immediate value.
	OpImm OperandKind = 1 << iota

	// OpReg means the operand is a register.
	OpReg

	// OpMem means the operand is a memory address.
	OpMem

	// OpLabel means the operand is a label, specifically for
	// branch instructions.
	OpLabel
)

type Operands 

type Operands [_N_args]interface{}

Operands represents a sequence of operand required by an instruction.

type Options 

type Options struct {
	// InstructionAliasing specifies whether to enable instruction aliasing.
	// Set to true enables instruction aliasing, and the Assembler will try harder to find instructions.
	InstructionAliasing bool

	// IgnoreUnknownDirectives specifies whether to report errors when encountered unknown directives.
	// Set to true ignores all unknwon directives silently, useful for parsing generated assembly.
	IgnoreUnknownDirectives bool
}

Options controls the behavior of Assembler.

type ParsedCommand 

type ParsedCommand struct {
	Cmd  string
	Args []ParsedCommandArg
}

ParsedCommand represents a parsed assembly directive command.

type ParsedCommandArg 

type ParsedCommandArg struct {
	Value    string
	IsString bool
}

ParsedCommandArg represents an argument of a ParsedCommand.

type ParsedInstruction 

type ParsedInstruction struct {
	Mnemonic string
	Operands []ParsedOperand
	Prefixes []InstructionPrefix
}

ParsedInstruction represents an instruction in the source.

type ParsedLabel 

type ParsedLabel struct {
	Name string
	Kind LabelKind
}

ParsedLabel represents a label in the source, either a jump target or an RIP-relative addressing.

type ParsedLine 

type ParsedLine struct {
	Row         int
	Src         []rune
	Kind        LineKind
	Label       ParsedLabel
	Command     ParsedCommand
	Instruction ParsedInstruction
}

ParsedLine represents a parsed source line.

type ParsedOperand 

type ParsedOperand struct {
	Op     OperandKind
	Imm    int64
	Reg    Register
	Label  ParsedLabel
	Memory MemoryAddress
}

ParsedOperand represents an operand of an instruction in the source.

type Parser 

type Parser struct {
	// contains filtered or unexported fields
}

Parser parses the source, and generates a sequence of ParsedInstruction's.

func (*Parser) Directive 

func (self *Parser) Directive(line string) (err error)

Directive handles the directive.

func (*Parser) Feed 

func (self *Parser) Feed(src string) (ret *ParsedLine, err error)

Feed feeds the parser with one more line, and the parser parses it into a ParsedLine.

NOTE: Feed does not handle empty lines or multiple lines, 

it panics when this happens. Use Parse to parse multiple
lines of assembly source.

func (*Parser) Parse 

func (self *Parser) Parse(src string) (ret []*ParsedLine, err error)

Parse parses the entire assembly source (possibly multiple lines) into a sequence of *ParsedLine.

type Program 

type Program struct {
	// contains filtered or unexported fields
}

Program represents a sequence of instructions.

func (*Program) ADCB 

func (self *Program) ADCB(v0 interface{}, v1 interface{}) *Instruction

ADCB performs "Add with Carry".

Mnemonic : ADC Supported forms : (6 forms)

  • ADCB imm8, al
  • ADCB imm8, r8
  • ADCB r8, r8
  • ADCB m8, r8
  • ADCB imm8, m8
  • ADCB r8, m8

func (*Program) ADCL 

func (self *Program) ADCL(v0 interface{}, v1 interface{}) *Instruction

ADCL performs "Add with Carry".

Mnemonic : ADC Supported forms : (8 forms)

  • ADCL imm32, eax
  • ADCL imm8, r32
  • ADCL imm32, r32
  • ADCL r32, r32
  • ADCL m32, r32
  • ADCL imm8, m32
  • ADCL imm32, m32
  • ADCL r32, m32

func (*Program) ADCQ 

func (self *Program) ADCQ(v0 interface{}, v1 interface{}) *Instruction

ADCQ performs "Add with Carry".

Mnemonic : ADC Supported forms : (8 forms)

  • ADCQ imm32, rax
  • ADCQ imm8, r64
  • ADCQ imm32, r64
  • ADCQ r64, r64
  • ADCQ m64, r64
  • ADCQ imm8, m64
  • ADCQ imm32, m64
  • ADCQ r64, m64

func (*Program) ADCW 

func (self *Program) ADCW(v0 interface{}, v1 interface{}) *Instruction

ADCW performs "Add with Carry".

Mnemonic : ADC Supported forms : (8 forms)

  • ADCW imm16, ax
  • ADCW imm8, r16
  • ADCW imm16, r16
  • ADCW r16, r16
  • ADCW m16, r16
  • ADCW imm8, m16
  • ADCW imm16, m16
  • ADCW r16, m16

func (*Program) ADCXL 

func (self *Program) ADCXL(v0 interface{}, v1 interface{}) *Instruction

ADCXL performs "Unsigned Integer Addition of Two Operands with Carry Flag".

Mnemonic : ADCX Supported forms : (2 forms)

  • ADCXL r32, r32 [ADX]
  • ADCXL m32, r32 [ADX]

func (*Program) ADCXQ 

func (self *Program) ADCXQ(v0 interface{}, v1 interface{}) *Instruction

ADCXQ performs "Unsigned Integer Addition of Two Operands with Carry Flag".

Mnemonic : ADCX Supported forms : (2 forms)

  • ADCXQ r64, r64 [ADX]
  • ADCXQ m64, r64 [ADX]

func (*Program) ADDB 

func (self *Program) ADDB(v0 interface{}, v1 interface{}) *Instruction

ADDB performs "Add".

Mnemonic : ADD Supported forms : (6 forms)

  • ADDB imm8, al
  • ADDB imm8, r8
  • ADDB r8, r8
  • ADDB m8, r8
  • ADDB imm8, m8
  • ADDB r8, m8

func (*Program) ADDL 

func (self *Program) ADDL(v0 interface{}, v1 interface{}) *Instruction

ADDL performs "Add".

Mnemonic : ADD Supported forms : (8 forms)

  • ADDL imm32, eax
  • ADDL imm8, r32
  • ADDL imm32, r32
  • ADDL r32, r32
  • ADDL m32, r32
  • ADDL imm8, m32
  • ADDL imm32, m32
  • ADDL r32, m32

func (*Program) ADDPD 

func (self *Program) ADDPD(v0 interface{}, v1 interface{}) *Instruction

ADDPD performs "Add Packed Double-Precision Floating-Point Values".

Mnemonic : ADDPD Supported forms : (2 forms)

  • ADDPD xmm, xmm [SSE2]
  • ADDPD m128, xmm [SSE2]

func (*Program) ADDPS 

func (self *Program) ADDPS(v0 interface{}, v1 interface{}) *Instruction

ADDPS performs "Add Packed Single-Precision Floating-Point Values".

Mnemonic : ADDPS Supported forms : (2 forms)

  • ADDPS xmm, xmm [SSE]
  • ADDPS m128, xmm [SSE]

func (*Program) ADDQ 

func (self *Program) ADDQ(v0 interface{}, v1 interface{}) *Instruction

ADDQ performs "Add".

Mnemonic : ADD Supported forms : (8 forms)

  • ADDQ imm32, rax
  • ADDQ imm8, r64
  • ADDQ imm32, r64
  • ADDQ r64, r64
  • ADDQ m64, r64
  • ADDQ imm8, m64
  • ADDQ imm32, m64
  • ADDQ r64, m64

func (*Program) ADDSD 

func (self *Program) ADDSD(v0 interface{}, v1 interface{}) *Instruction

ADDSD performs "Add Scalar Double-Precision Floating-Point Values".

Mnemonic : ADDSD Supported forms : (2 forms)

  • ADDSD xmm, xmm [SSE2]
  • ADDSD m64, xmm [SSE2]

func (*Program) ADDSS 

func (self *Program) ADDSS(v0 interface{}, v1 interface{}) *Instruction

ADDSS performs "Add Scalar Single-Precision Floating-Point Values".

Mnemonic : ADDSS Supported forms : (2 forms)

  • ADDSS xmm, xmm [SSE]
  • ADDSS m32, xmm [SSE]

func (*Program) ADDSUBPD 

func (self *Program) ADDSUBPD(v0 interface{}, v1 interface{}) *Instruction

ADDSUBPD performs "Packed Double-FP Add/Subtract".

Mnemonic : ADDSUBPD Supported forms : (2 forms)

  • ADDSUBPD xmm, xmm [SSE3]
  • ADDSUBPD m128, xmm [SSE3]

func (*Program) ADDSUBPS 

func (self *Program) ADDSUBPS(v0 interface{}, v1 interface{}) *Instruction

ADDSUBPS performs "Packed Single-FP Add/Subtract".

Mnemonic : ADDSUBPS Supported forms : (2 forms)

  • ADDSUBPS xmm, xmm [SSE3]
  • ADDSUBPS m128, xmm [SSE3]

func (*Program) ADDW 

func (self *Program) ADDW(v0 interface{}, v1 interface{}) *Instruction

ADDW performs "Add".

Mnemonic : ADD Supported forms : (8 forms)

  • ADDW imm16, ax
  • ADDW imm8, r16
  • ADDW imm16, r16
  • ADDW r16, r16
  • ADDW m16, r16
  • ADDW imm8, m16
  • ADDW imm16, m16
  • ADDW r16, m16

func (*Program) ADOXL 

func (self *Program) ADOXL(v0 interface{}, v1 interface{}) *Instruction

ADOXL performs "Unsigned Integer Addition of Two Operands with Overflow Flag".

Mnemonic : ADOX Supported forms : (2 forms)

  • ADOXL r32, r32 [ADX]
  • ADOXL m32, r32 [ADX]

func (*Program) ADOXQ 

func (self *Program) ADOXQ(v0 interface{}, v1 interface{}) *Instruction

ADOXQ performs "Unsigned Integer Addition of Two Operands with Overflow Flag".

Mnemonic : ADOX Supported forms : (2 forms)

  • ADOXQ r64, r64 [ADX]
  • ADOXQ m64, r64 [ADX]

func (*Program) AESDEC 

func (self *Program) AESDEC(v0 interface{}, v1 interface{}) *Instruction

AESDEC performs "Perform One Round of an AES Decryption Flow".

Mnemonic : AESDEC Supported forms : (2 forms)

  • AESDEC xmm, xmm [AES]
  • AESDEC m128, xmm [AES]

func (*Program) AESDECLAST 

func (self *Program) AESDECLAST(v0 interface{}, v1 interface{}) *Instruction

AESDECLAST performs "Perform Last Round of an AES Decryption Flow".

Mnemonic : AESDECLAST Supported forms : (2 forms)

  • AESDECLAST xmm, xmm [AES]
  • AESDECLAST m128, xmm [AES]

func (*Program) AESENC 

func (self *Program) AESENC(v0 interface{}, v1 interface{}) *Instruction

AESENC performs "Perform One Round of an AES Encryption Flow".

Mnemonic : AESENC Supported forms : (2 forms)

  • AESENC xmm, xmm [AES]
  • AESENC m128, xmm [AES]

func (*Program) AESENCLAST 

func (self *Program) AESENCLAST(v0 interface{}, v1 interface{}) *Instruction

AESENCLAST performs "Perform Last Round of an AES Encryption Flow".

Mnemonic : AESENCLAST Supported forms : (2 forms)

  • AESENCLAST xmm, xmm [AES]
  • AESENCLAST m128, xmm [AES]

func (*Program) AESIMC 

func (self *Program) AESIMC(v0 interface{}, v1 interface{}) *Instruction

AESIMC performs "Perform the AES InvMixColumn Transformation".

Mnemonic : AESIMC Supported forms : (2 forms)

  • AESIMC xmm, xmm [AES]
  • AESIMC m128, xmm [AES]

func (*Program) AESKEYGENASSIST 

func (self *Program) AESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

AESKEYGENASSIST performs "AES Round Key Generation Assist".

Mnemonic : AESKEYGENASSIST Supported forms : (2 forms)

  • AESKEYGENASSIST imm8, xmm, xmm [AES]
  • AESKEYGENASSIST imm8, m128, xmm [AES]

func (*Program) ANDB 

func (self *Program) ANDB(v0 interface{}, v1 interface{}) *Instruction

ANDB performs "Logical AND".

Mnemonic : AND Supported forms : (6 forms)

  • ANDB imm8, al
  • ANDB imm8, r8
  • ANDB r8, r8
  • ANDB m8, r8
  • ANDB imm8, m8
  • ANDB r8, m8

func (*Program) ANDL 

func (self *Program) ANDL(v0 interface{}, v1 interface{}) *Instruction

ANDL performs "Logical AND".

Mnemonic : AND Supported forms : (8 forms)

  • ANDL imm32, eax
  • ANDL imm8, r32
  • ANDL imm32, r32
  • ANDL r32, r32
  • ANDL m32, r32
  • ANDL imm8, m32
  • ANDL imm32, m32
  • ANDL r32, m32

func (*Program) ANDNL 

func (self *Program) ANDNL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ANDNL performs "Logical AND NOT".

Mnemonic : ANDN Supported forms : (2 forms)

  • ANDNL r32, r32, r32 [BMI]
  • ANDNL m32, r32, r32 [BMI]

func (*Program) ANDNPD 

func (self *Program) ANDNPD(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : ANDNPD Supported forms : (2 forms)

  • ANDNPD xmm, xmm [SSE2]
  • ANDNPD m128, xmm [SSE2]

func (*Program) ANDNPS 

func (self *Program) ANDNPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : ANDNPS Supported forms : (2 forms)

  • ANDNPS xmm, xmm [SSE]
  • ANDNPS m128, xmm [SSE]

func (*Program) ANDNQ 

func (self *Program) ANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ANDNQ performs "Logical AND NOT".

Mnemonic : ANDN Supported forms : (2 forms)

  • ANDNQ r64, r64, r64 [BMI]
  • ANDNQ m64, r64, r64 [BMI]

func (*Program) ANDPD 

func (self *Program) ANDPD(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : ANDPD Supported forms : (2 forms)

  • ANDPD xmm, xmm [SSE2]
  • ANDPD m128, xmm [SSE2]

func (*Program) ANDPS 

func (self *Program) ANDPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : ANDPS Supported forms : (2 forms)

  • ANDPS xmm, xmm [SSE]
  • ANDPS m128, xmm [SSE]

func (*Program) ANDQ 

func (self *Program) ANDQ(v0 interface{}, v1 interface{}) *Instruction

ANDQ performs "Logical AND".

Mnemonic : AND Supported forms : (8 forms)

  • ANDQ imm32, rax
  • ANDQ imm8, r64
  • ANDQ imm32, r64
  • ANDQ r64, r64
  • ANDQ m64, r64
  • ANDQ imm8, m64
  • ANDQ imm32, m64
  • ANDQ r64, m64

func (*Program) ANDW 

func (self *Program) ANDW(v0 interface{}, v1 interface{}) *Instruction

ANDW performs "Logical AND".

Mnemonic : AND Supported forms : (8 forms)

  • ANDW imm16, ax
  • ANDW imm8, r16
  • ANDW imm16, r16
  • ANDW r16, r16
  • ANDW m16, r16
  • ANDW imm8, m16
  • ANDW imm16, m16
  • ANDW r16, m16

func (*Program) Align 

func (self *Program) Align(align uint64, padding *expr.Expr) (p *Instruction)

Align is a pseudo-instruction to ensure the PC is aligned to a certain value.

func (*Program) Assemble 

func (self *Program) Assemble(pc uintptr) (ret []byte)

Assemble assembles and links the entire program into machine code.

func (*Program) AssembleAndFree 

func (self *Program) AssembleAndFree(pc uintptr) (ret []byte)

AssembleAndFree is like Assemble, but it frees the Program after assembling.

func (*Program) BEXTR 

func (self *Program) BEXTR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BEXTR performs "Bit Field Extract".

Mnemonic : BEXTR Supported forms : (8 forms)

  • BEXTR imm32, r32, r32 [TBM]
  • BEXTR imm32, m32, r32 [TBM]
  • BEXTR imm32, r64, r64 [TBM]
  • BEXTR imm32, m64, r64 [TBM]
  • BEXTR r32, r32, r32 [BMI]
  • BEXTR r32, m32, r32 [BMI]
  • BEXTR r64, r64, r64 [BMI]
  • BEXTR r64, m64, r64 [BMI]

func (*Program) BLCFILL 

func (self *Program) BLCFILL(v0 interface{}, v1 interface{}) *Instruction

BLCFILL performs "Fill From Lowest Clear Bit".

Mnemonic : BLCFILL Supported forms : (4 forms)

  • BLCFILL r32, r32 [TBM]
  • BLCFILL m32, r32 [TBM]
  • BLCFILL r64, r64 [TBM]
  • BLCFILL m64, r64 [TBM]

func (*Program) BLCI 

func (self *Program) BLCI(v0 interface{}, v1 interface{}) *Instruction

BLCI performs "Isolate Lowest Clear Bit".

Mnemonic : BLCI Supported forms : (4 forms)

  • BLCI r32, r32 [TBM]
  • BLCI m32, r32 [TBM]
  • BLCI r64, r64 [TBM]
  • BLCI m64, r64 [TBM]

func (*Program) BLCIC 

func (self *Program) BLCIC(v0 interface{}, v1 interface{}) *Instruction

BLCIC performs "Isolate Lowest Set Bit and Complement".

Mnemonic : BLCIC Supported forms : (4 forms)

  • BLCIC r32, r32 [TBM]
  • BLCIC m32, r32 [TBM]
  • BLCIC r64, r64 [TBM]
  • BLCIC m64, r64 [TBM]

func (*Program) BLCMSK 

func (self *Program) BLCMSK(v0 interface{}, v1 interface{}) *Instruction

BLCMSK performs "Mask From Lowest Clear Bit".

Mnemonic : BLCMSK Supported forms : (4 forms)

  • BLCMSK r32, r32 [TBM]
  • BLCMSK m32, r32 [TBM]
  • BLCMSK r64, r64 [TBM]
  • BLCMSK m64, r64 [TBM]

func (*Program) BLCS 

func (self *Program) BLCS(v0 interface{}, v1 interface{}) *Instruction

BLCS performs "Set Lowest Clear Bit".

Mnemonic : BLCS Supported forms : (4 forms)

  • BLCS r32, r32 [TBM]
  • BLCS m32, r32 [TBM]
  • BLCS r64, r64 [TBM]
  • BLCS m64, r64 [TBM]

func (*Program) BLENDPD 

func (self *Program) BLENDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDPD performs "Blend Packed Double Precision Floating-Point Values".

Mnemonic : BLENDPD Supported forms : (2 forms)

  • BLENDPD imm8, xmm, xmm [SSE4.1]
  • BLENDPD imm8, m128, xmm [SSE4.1]

func (*Program) BLENDPS 

func (self *Program) BLENDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDPS performs " Blend Packed Single Precision Floating-Point Values".

Mnemonic : BLENDPS Supported forms : (2 forms)

  • BLENDPS imm8, xmm, xmm [SSE4.1]
  • BLENDPS imm8, m128, xmm [SSE4.1]

func (*Program) BLENDVPD 

func (self *Program) BLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDVPD performs " Variable Blend Packed Double Precision Floating-Point Values".

Mnemonic : BLENDVPD Supported forms : (2 forms)

  • BLENDVPD xmm0, xmm, xmm [SSE4.1]
  • BLENDVPD xmm0, m128, xmm [SSE4.1]

func (*Program) BLENDVPS 

func (self *Program) BLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BLENDVPS performs " Variable Blend Packed Single Precision Floating-Point Values".

Mnemonic : BLENDVPS Supported forms : (2 forms)

  • BLENDVPS xmm0, xmm, xmm [SSE4.1]
  • BLENDVPS xmm0, m128, xmm [SSE4.1]

func (*Program) BLSFILL 

func (self *Program) BLSFILL(v0 interface{}, v1 interface{}) *Instruction

BLSFILL performs "Fill From Lowest Set Bit".

Mnemonic : BLSFILL Supported forms : (4 forms)

  • BLSFILL r32, r32 [TBM]
  • BLSFILL m32, r32 [TBM]
  • BLSFILL r64, r64 [TBM]
  • BLSFILL m64, r64 [TBM]

func (*Program) BLSI 

func (self *Program) BLSI(v0 interface{}, v1 interface{}) *Instruction

BLSI performs "Isolate Lowest Set Bit".

Mnemonic : BLSI Supported forms : (4 forms)

  • BLSI r32, r32 [BMI]
  • BLSI m32, r32 [BMI]
  • BLSI r64, r64 [BMI]
  • BLSI m64, r64 [BMI]

func (*Program) BLSIC 

func (self *Program) BLSIC(v0 interface{}, v1 interface{}) *Instruction

BLSIC performs "Isolate Lowest Set Bit and Complement".

Mnemonic : BLSIC Supported forms : (4 forms)

  • BLSIC r32, r32 [TBM]
  • BLSIC m32, r32 [TBM]
  • BLSIC r64, r64 [TBM]
  • BLSIC m64, r64 [TBM]

func (*Program) BLSMSK 

func (self *Program) BLSMSK(v0 interface{}, v1 interface{}) *Instruction

BLSMSK performs "Mask From Lowest Set Bit".

Mnemonic : BLSMSK Supported forms : (4 forms)

  • BLSMSK r32, r32 [BMI]
  • BLSMSK m32, r32 [BMI]
  • BLSMSK r64, r64 [BMI]
  • BLSMSK m64, r64 [BMI]

func (*Program) BLSR 

func (self *Program) BLSR(v0 interface{}, v1 interface{}) *Instruction

BLSR performs "Reset Lowest Set Bit".

Mnemonic : BLSR Supported forms : (4 forms)

  • BLSR r32, r32 [BMI]
  • BLSR m32, r32 [BMI]
  • BLSR r64, r64 [BMI]
  • BLSR m64, r64 [BMI]

func (*Program) BSFL 

func (self *Program) BSFL(v0 interface{}, v1 interface{}) *Instruction

BSFL performs "Bit Scan Forward".

Mnemonic : BSF Supported forms : (2 forms)

  • BSFL r32, r32
  • BSFL m32, r32

func (*Program) BSFQ 

func (self *Program) BSFQ(v0 interface{}, v1 interface{}) *Instruction

BSFQ performs "Bit Scan Forward".

Mnemonic : BSF Supported forms : (2 forms)

  • BSFQ r64, r64
  • BSFQ m64, r64

func (*Program) BSFW 

func (self *Program) BSFW(v0 interface{}, v1 interface{}) *Instruction

BSFW performs "Bit Scan Forward".

Mnemonic : BSF Supported forms : (2 forms)

  • BSFW r16, r16
  • BSFW m16, r16

func (*Program) BSRL 

func (self *Program) BSRL(v0 interface{}, v1 interface{}) *Instruction

BSRL performs "Bit Scan Reverse".

Mnemonic : BSR Supported forms : (2 forms)

  • BSRL r32, r32
  • BSRL m32, r32

func (*Program) BSRQ 

func (self *Program) BSRQ(v0 interface{}, v1 interface{}) *Instruction

BSRQ performs "Bit Scan Reverse".

Mnemonic : BSR Supported forms : (2 forms)

  • BSRQ r64, r64
  • BSRQ m64, r64

func (*Program) BSRW 

func (self *Program) BSRW(v0 interface{}, v1 interface{}) *Instruction

BSRW performs "Bit Scan Reverse".

Mnemonic : BSR Supported forms : (2 forms)

  • BSRW r16, r16
  • BSRW m16, r16

func (*Program) BSWAPL 

func (self *Program) BSWAPL(v0 interface{}) *Instruction

BSWAPL performs "Byte Swap".

Mnemonic : BSWAP Supported forms : (1 form)

  • BSWAPL r32

func (*Program) BSWAPQ 

func (self *Program) BSWAPQ(v0 interface{}) *Instruction

BSWAPQ performs "Byte Swap".

Mnemonic : BSWAP Supported forms : (1 form)

  • BSWAPQ r64

func (*Program) BTCL 

func (self *Program) BTCL(v0 interface{}, v1 interface{}) *Instruction

BTCL performs "Bit Test and Complement".

Mnemonic : BTC Supported forms : (4 forms)

  • BTCL imm8, r32
  • BTCL r32, r32
  • BTCL imm8, m32
  • BTCL r32, m32

func (*Program) BTCQ 

func (self *Program) BTCQ(v0 interface{}, v1 interface{}) *Instruction

BTCQ performs "Bit Test and Complement".

Mnemonic : BTC Supported forms : (4 forms)

  • BTCQ imm8, r64
  • BTCQ r64, r64
  • BTCQ imm8, m64
  • BTCQ r64, m64

func (*Program) BTCW 

func (self *Program) BTCW(v0 interface{}, v1 interface{}) *Instruction

BTCW performs "Bit Test and Complement".

Mnemonic : BTC Supported forms : (4 forms)

  • BTCW imm8, r16
  • BTCW r16, r16
  • BTCW imm8, m16
  • BTCW r16, m16

func (*Program) BTL 

func (self *Program) BTL(v0 interface{}, v1 interface{}) *Instruction

BTL performs "Bit Test".

Mnemonic : BT Supported forms : (4 forms)

  • BTL imm8, r32
  • BTL r32, r32
  • BTL imm8, m32
  • BTL r32, m32

func (*Program) BTQ 

func (self *Program) BTQ(v0 interface{}, v1 interface{}) *Instruction

BTQ performs "Bit Test".

Mnemonic : BT Supported forms : (4 forms)

  • BTQ imm8, r64
  • BTQ r64, r64
  • BTQ imm8, m64
  • BTQ r64, m64

func (*Program) BTRL 

func (self *Program) BTRL(v0 interface{}, v1 interface{}) *Instruction

BTRL performs "Bit Test and Reset".

Mnemonic : BTR Supported forms : (4 forms)

  • BTRL imm8, r32
  • BTRL r32, r32
  • BTRL imm8, m32
  • BTRL r32, m32

func (*Program) BTRQ 

func (self *Program) BTRQ(v0 interface{}, v1 interface{}) *Instruction

BTRQ performs "Bit Test and Reset".

Mnemonic : BTR Supported forms : (4 forms)

  • BTRQ imm8, r64
  • BTRQ r64, r64
  • BTRQ imm8, m64
  • BTRQ r64, m64

func (*Program) BTRW 

func (self *Program) BTRW(v0 interface{}, v1 interface{}) *Instruction

BTRW performs "Bit Test and Reset".

Mnemonic : BTR Supported forms : (4 forms)

  • BTRW imm8, r16
  • BTRW r16, r16
  • BTRW imm8, m16
  • BTRW r16, m16

func (*Program) BTSL 

func (self *Program) BTSL(v0 interface{}, v1 interface{}) *Instruction

BTSL performs "Bit Test and Set".

Mnemonic : BTS Supported forms : (4 forms)

  • BTSL imm8, r32
  • BTSL r32, r32
  • BTSL imm8, m32
  • BTSL r32, m32

func (*Program) BTSQ 

func (self *Program) BTSQ(v0 interface{}, v1 interface{}) *Instruction

BTSQ performs "Bit Test and Set".

Mnemonic : BTS Supported forms : (4 forms)

  • BTSQ imm8, r64
  • BTSQ r64, r64
  • BTSQ imm8, m64
  • BTSQ r64, m64

func (*Program) BTSW 

func (self *Program) BTSW(v0 interface{}, v1 interface{}) *Instruction

BTSW performs "Bit Test and Set".

Mnemonic : BTS Supported forms : (4 forms)

  • BTSW imm8, r16
  • BTSW r16, r16
  • BTSW imm8, m16
  • BTSW r16, m16

func (*Program) BTW 

func (self *Program) BTW(v0 interface{}, v1 interface{}) *Instruction

BTW performs "Bit Test".

Mnemonic : BT Supported forms : (4 forms)

  • BTW imm8, r16
  • BTW r16, r16
  • BTW imm8, m16
  • BTW r16, m16

func (*Program) BZHI 

func (self *Program) BZHI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

BZHI performs "Zero High Bits Starting with Specified Bit Position".

Mnemonic : BZHI Supported forms : (4 forms)

  • BZHI r32, r32, r32 [BMI2]
  • BZHI r32, m32, r32 [BMI2]
  • BZHI r64, r64, r64 [BMI2]
  • BZHI r64, m64, r64 [BMI2]

func (*Program) Byte 

func (self *Program) Byte(v *expr.Expr) (p *Instruction)

Byte is a pseudo-instruction to add raw byte to the assembled code.

func (*Program) CALL 

func (self *Program) CALL(v0 interface{}) *Instruction

CALL performs "Call Procedure".

Mnemonic : CALL Supported forms : (1 form)

  • CALL rel32

func (*Program) CALLQ 

func (self *Program) CALLQ(v0 interface{}) *Instruction

CALLQ performs "Call Procedure".

Mnemonic : CALL Supported forms : (2 forms)

  • CALLQ r64
  • CALLQ m64

func (*Program) CBTW 

func (self *Program) CBTW() *Instruction

CBTW performs "Convert Byte to Word".

Mnemonic : CBW Supported forms : (1 form)

  • CBTW

func (*Program) CLC 

func (self *Program) CLC() *Instruction

CLC performs "Clear Carry Flag".

Mnemonic : CLC Supported forms : (1 form)

  • CLC

func (*Program) CLD 

func (self *Program) CLD() *Instruction

CLD performs "Clear Direction Flag".

Mnemonic : CLD Supported forms : (1 form)

  • CLD

func (*Program) CLFLUSH 

func (self *Program) CLFLUSH(v0 interface{}) *Instruction

CLFLUSH performs "Flush Cache Line".

Mnemonic : CLFLUSH Supported forms : (1 form)

  • CLFLUSH m8 [CLFLUSH]

func (*Program) CLFLUSHOPT 

func (self *Program) CLFLUSHOPT(v0 interface{}) *Instruction

CLFLUSHOPT performs "Flush Cache Line Optimized".

Mnemonic : CLFLUSHOPT Supported forms : (1 form)

  • CLFLUSHOPT m8 [CLFLUSHOPT]

func (*Program) CLTD 

func (self *Program) CLTD() *Instruction

CLTD performs "Convert Doubleword to Quadword".

Mnemonic : CDQ Supported forms : (1 form)

  • CLTD

func (*Program) CLTQ 

func (self *Program) CLTQ() *Instruction

CLTQ performs "Convert Doubleword to Quadword".

Mnemonic : CDQE Supported forms : (1 form)

  • CLTQ

func (*Program) CLWB 

func (self *Program) CLWB(v0 interface{}) *Instruction

CLWB performs "Cache Line Write Back".

Mnemonic : CLWB Supported forms : (1 form)

  • CLWB m8 [CLWB]

func (*Program) CLZERO 

func (self *Program) CLZERO() *Instruction

CLZERO performs "Zero-out 64-bit Cache Line".

Mnemonic : CLZERO Supported forms : (1 form)

  • CLZERO [CLZERO]

func (*Program) CMC 

func (self *Program) CMC() *Instruction

CMC performs "Complement Carry Flag".

Mnemonic : CMC Supported forms : (1 form)

  • CMC

func (*Program) CMOVA 

func (self *Program) CMOVA(v0 interface{}, v1 interface{}) *Instruction

CMOVA performs "Move if above (CF == 0 and ZF == 0)".

Mnemonic : CMOVA Supported forms : (6 forms)

  • CMOVA r16, r16 [CMOV]
  • CMOVA m16, r16 [CMOV]
  • CMOVA r32, r32 [CMOV]
  • CMOVA m32, r32 [CMOV]
  • CMOVA r64, r64 [CMOV]
  • CMOVA m64, r64 [CMOV]

func (*Program) CMOVAE 

func (self *Program) CMOVAE(v0 interface{}, v1 interface{}) *Instruction

CMOVAE performs "Move if above or equal (CF == 0)".

Mnemonic : CMOVAE Supported forms : (6 forms)

  • CMOVAE r16, r16 [CMOV]
  • CMOVAE m16, r16 [CMOV]
  • CMOVAE r32, r32 [CMOV]
  • CMOVAE m32, r32 [CMOV]
  • CMOVAE r64, r64 [CMOV]
  • CMOVAE m64, r64 [CMOV]

func (*Program) CMOVB 

func (self *Program) CMOVB(v0 interface{}, v1 interface{}) *Instruction

CMOVB performs "Move if below (CF == 1)".

Mnemonic : CMOVB Supported forms : (6 forms)

  • CMOVB r16, r16 [CMOV]
  • CMOVB m16, r16 [CMOV]
  • CMOVB r32, r32 [CMOV]
  • CMOVB m32, r32 [CMOV]
  • CMOVB r64, r64 [CMOV]
  • CMOVB m64, r64 [CMOV]

func (*Program) CMOVBE 

func (self *Program) CMOVBE(v0 interface{}, v1 interface{}) *Instruction

CMOVBE performs "Move if below or equal (CF == 1 or ZF == 1)".

Mnemonic : CMOVBE Supported forms : (6 forms)

  • CMOVBE r16, r16 [CMOV]
  • CMOVBE m16, r16 [CMOV]
  • CMOVBE r32, r32 [CMOV]
  • CMOVBE m32, r32 [CMOV]
  • CMOVBE r64, r64 [CMOV]
  • CMOVBE m64, r64 [CMOV]

func (*Program) CMOVC 

func (self *Program) CMOVC(v0 interface{}, v1 interface{}) *Instruction

CMOVC performs "Move if carry (CF == 1)".

Mnemonic : CMOVC Supported forms : (6 forms)

  • CMOVC r16, r16 [CMOV]
  • CMOVC m16, r16 [CMOV]
  • CMOVC r32, r32 [CMOV]
  • CMOVC m32, r32 [CMOV]
  • CMOVC r64, r64 [CMOV]
  • CMOVC m64, r64 [CMOV]

func (*Program) CMOVE 

func (self *Program) CMOVE(v0 interface{}, v1 interface{}) *Instruction

CMOVE performs "Move if equal (ZF == 1)".

Mnemonic : CMOVE Supported forms : (6 forms)

  • CMOVE r16, r16 [CMOV]
  • CMOVE m16, r16 [CMOV]
  • CMOVE r32, r32 [CMOV]
  • CMOVE m32, r32 [CMOV]
  • CMOVE r64, r64 [CMOV]
  • CMOVE m64, r64 [CMOV]

func (*Program) CMOVG 

func (self *Program) CMOVG(v0 interface{}, v1 interface{}) *Instruction

CMOVG performs "Move if greater (ZF == 0 and SF == OF)".

Mnemonic : CMOVG Supported forms : (6 forms)

  • CMOVG r16, r16 [CMOV]
  • CMOVG m16, r16 [CMOV]
  • CMOVG r32, r32 [CMOV]
  • CMOVG m32, r32 [CMOV]
  • CMOVG r64, r64 [CMOV]
  • CMOVG m64, r64 [CMOV]

func (*Program) CMOVGE 

func (self *Program) CMOVGE(v0 interface{}, v1 interface{}) *Instruction

CMOVGE performs "Move if greater or equal (SF == OF)".

Mnemonic : CMOVGE Supported forms : (6 forms)

  • CMOVGE r16, r16 [CMOV]
  • CMOVGE m16, r16 [CMOV]
  • CMOVGE r32, r32 [CMOV]
  • CMOVGE m32, r32 [CMOV]
  • CMOVGE r64, r64 [CMOV]
  • CMOVGE m64, r64 [CMOV]

func (*Program) CMOVL 

func (self *Program) CMOVL(v0 interface{}, v1 interface{}) *Instruction

CMOVL performs "Move if less (SF != OF)".

Mnemonic : CMOVL Supported forms : (6 forms)

  • CMOVL r16, r16 [CMOV]
  • CMOVL m16, r16 [CMOV]
  • CMOVL r32, r32 [CMOV]
  • CMOVL m32, r32 [CMOV]
  • CMOVL r64, r64 [CMOV]
  • CMOVL m64, r64 [CMOV]

func (*Program) CMOVLE 

func (self *Program) CMOVLE(v0 interface{}, v1 interface{}) *Instruction

CMOVLE performs "Move if less or equal (ZF == 1 or SF != OF)".

Mnemonic : CMOVLE Supported forms : (6 forms)

  • CMOVLE r16, r16 [CMOV]
  • CMOVLE m16, r16 [CMOV]
  • CMOVLE r32, r32 [CMOV]
  • CMOVLE m32, r32 [CMOV]
  • CMOVLE r64, r64 [CMOV]
  • CMOVLE m64, r64 [CMOV]

func (*Program) CMOVNA 

func (self *Program) CMOVNA(v0 interface{}, v1 interface{}) *Instruction

CMOVNA performs "Move if not above (CF == 1 or ZF == 1)".

Mnemonic : CMOVNA Supported forms : (6 forms)

  • CMOVNA r16, r16 [CMOV]
  • CMOVNA m16, r16 [CMOV]
  • CMOVNA r32, r32 [CMOV]
  • CMOVNA m32, r32 [CMOV]
  • CMOVNA r64, r64 [CMOV]
  • CMOVNA m64, r64 [CMOV]

func (*Program) CMOVNAE 

func (self *Program) CMOVNAE(v0 interface{}, v1 interface{}) *Instruction

CMOVNAE performs "Move if not above or equal (CF == 1)".

Mnemonic : CMOVNAE Supported forms : (6 forms)

  • CMOVNAE r16, r16 [CMOV]
  • CMOVNAE m16, r16 [CMOV]
  • CMOVNAE r32, r32 [CMOV]
  • CMOVNAE m32, r32 [CMOV]
  • CMOVNAE r64, r64 [CMOV]
  • CMOVNAE m64, r64 [CMOV]

func (*Program) CMOVNB 

func (self *Program) CMOVNB(v0 interface{}, v1 interface{}) *Instruction

CMOVNB performs "Move if not below (CF == 0)".

Mnemonic : CMOVNB Supported forms : (6 forms)

  • CMOVNB r16, r16 [CMOV]
  • CMOVNB m16, r16 [CMOV]
  • CMOVNB r32, r32 [CMOV]
  • CMOVNB m32, r32 [CMOV]
  • CMOVNB r64, r64 [CMOV]
  • CMOVNB m64, r64 [CMOV]

func (*Program) CMOVNBE 

func (self *Program) CMOVNBE(v0 interface{}, v1 interface{}) *Instruction

CMOVNBE performs "Move if not below or equal (CF == 0 and ZF == 0)".

Mnemonic : CMOVNBE Supported forms : (6 forms)

  • CMOVNBE r16, r16 [CMOV]
  • CMOVNBE m16, r16 [CMOV]
  • CMOVNBE r32, r32 [CMOV]
  • CMOVNBE m32, r32 [CMOV]
  • CMOVNBE r64, r64 [CMOV]
  • CMOVNBE m64, r64 [CMOV]

func (*Program) CMOVNC 

func (self *Program) CMOVNC(v0 interface{}, v1 interface{}) *Instruction

CMOVNC performs "Move if not carry (CF == 0)".

Mnemonic : CMOVNC Supported forms : (6 forms)

  • CMOVNC r16, r16 [CMOV]
  • CMOVNC m16, r16 [CMOV]
  • CMOVNC r32, r32 [CMOV]
  • CMOVNC m32, r32 [CMOV]
  • CMOVNC r64, r64 [CMOV]
  • CMOVNC m64, r64 [CMOV]

func (*Program) CMOVNE 

func (self *Program) CMOVNE(v0 interface{}, v1 interface{}) *Instruction

CMOVNE performs "Move if not equal (ZF == 0)".

Mnemonic : CMOVNE Supported forms : (6 forms)

  • CMOVNE r16, r16 [CMOV]
  • CMOVNE m16, r16 [CMOV]
  • CMOVNE r32, r32 [CMOV]
  • CMOVNE m32, r32 [CMOV]
  • CMOVNE r64, r64 [CMOV]
  • CMOVNE m64, r64 [CMOV]

func (*Program) CMOVNG 

func (self *Program) CMOVNG(v0 interface{}, v1 interface{}) *Instruction

CMOVNG performs "Move if not greater (ZF == 1 or SF != OF)".

Mnemonic : CMOVNG Supported forms : (6 forms)

  • CMOVNG r16, r16 [CMOV]
  • CMOVNG m16, r16 [CMOV]
  • CMOVNG r32, r32 [CMOV]
  • CMOVNG m32, r32 [CMOV]
  • CMOVNG r64, r64 [CMOV]
  • CMOVNG m64, r64 [CMOV]

func (*Program) CMOVNGE 

func (self *Program) CMOVNGE(v0 interface{}, v1 interface{}) *Instruction

CMOVNGE performs "Move if not greater or equal (SF != OF)".

Mnemonic : CMOVNGE Supported forms : (6 forms)

  • CMOVNGE r16, r16 [CMOV]
  • CMOVNGE m16, r16 [CMOV]
  • CMOVNGE r32, r32 [CMOV]
  • CMOVNGE m32, r32 [CMOV]
  • CMOVNGE r64, r64 [CMOV]
  • CMOVNGE m64, r64 [CMOV]

func (*Program) CMOVNL 

func (self *Program) CMOVNL(v0 interface{}, v1 interface{}) *Instruction

CMOVNL performs "Move if not less (SF == OF)".

Mnemonic : CMOVNL Supported forms : (6 forms)

  • CMOVNL r16, r16 [CMOV]
  • CMOVNL m16, r16 [CMOV]
  • CMOVNL r32, r32 [CMOV]
  • CMOVNL m32, r32 [CMOV]
  • CMOVNL r64, r64 [CMOV]
  • CMOVNL m64, r64 [CMOV]

func (*Program) CMOVNLE 

func (self *Program) CMOVNLE(v0 interface{}, v1 interface{}) *Instruction

CMOVNLE performs "Move if not less or equal (ZF == 0 and SF == OF)".

Mnemonic : CMOVNLE Supported forms : (6 forms)

  • CMOVNLE r16, r16 [CMOV]
  • CMOVNLE m16, r16 [CMOV]
  • CMOVNLE r32, r32 [CMOV]
  • CMOVNLE m32, r32 [CMOV]
  • CMOVNLE r64, r64 [CMOV]
  • CMOVNLE m64, r64 [CMOV]

func (*Program) CMOVNO 

func (self *Program) CMOVNO(v0 interface{}, v1 interface{}) *Instruction

CMOVNO performs "Move if not overflow (OF == 0)".

Mnemonic : CMOVNO Supported forms : (6 forms)

  • CMOVNO r16, r16 [CMOV]
  • CMOVNO m16, r16 [CMOV]
  • CMOVNO r32, r32 [CMOV]
  • CMOVNO m32, r32 [CMOV]
  • CMOVNO r64, r64 [CMOV]
  • CMOVNO m64, r64 [CMOV]

func (*Program) CMOVNP 

func (self *Program) CMOVNP(v0 interface{}, v1 interface{}) *Instruction

CMOVNP performs "Move if not parity (PF == 0)".

Mnemonic : CMOVNP Supported forms : (6 forms)

  • CMOVNP r16, r16 [CMOV]
  • CMOVNP m16, r16 [CMOV]
  • CMOVNP r32, r32 [CMOV]
  • CMOVNP m32, r32 [CMOV]
  • CMOVNP r64, r64 [CMOV]
  • CMOVNP m64, r64 [CMOV]

func (*Program) CMOVNS 

func (self *Program) CMOVNS(v0 interface{}, v1 interface{}) *Instruction

CMOVNS performs "Move if not sign (SF == 0)".

Mnemonic : CMOVNS Supported forms : (6 forms)

  • CMOVNS r16, r16 [CMOV]
  • CMOVNS m16, r16 [CMOV]
  • CMOVNS r32, r32 [CMOV]
  • CMOVNS m32, r32 [CMOV]
  • CMOVNS r64, r64 [CMOV]
  • CMOVNS m64, r64 [CMOV]

func (*Program) CMOVNZ 

func (self *Program) CMOVNZ(v0 interface{}, v1 interface{}) *Instruction

CMOVNZ performs "Move if not zero (ZF == 0)".

Mnemonic : CMOVNZ Supported forms : (6 forms)

  • CMOVNZ r16, r16 [CMOV]
  • CMOVNZ m16, r16 [CMOV]
  • CMOVNZ r32, r32 [CMOV]
  • CMOVNZ m32, r32 [CMOV]
  • CMOVNZ r64, r64 [CMOV]
  • CMOVNZ m64, r64 [CMOV]

func (*Program) CMOVO 

func (self *Program) CMOVO(v0 interface{}, v1 interface{}) *Instruction

CMOVO performs "Move if overflow (OF == 1)".

Mnemonic : CMOVO Supported forms : (6 forms)

  • CMOVO r16, r16 [CMOV]
  • CMOVO m16, r16 [CMOV]
  • CMOVO r32, r32 [CMOV]
  • CMOVO m32, r32 [CMOV]
  • CMOVO r64, r64 [CMOV]
  • CMOVO m64, r64 [CMOV]

func (*Program) CMOVP 

func (self *Program) CMOVP(v0 interface{}, v1 interface{}) *Instruction

CMOVP performs "Move if parity (PF == 1)".

Mnemonic : CMOVP Supported forms : (6 forms)

  • CMOVP r16, r16 [CMOV]
  • CMOVP m16, r16 [CMOV]
  • CMOVP r32, r32 [CMOV]
  • CMOVP m32, r32 [CMOV]
  • CMOVP r64, r64 [CMOV]
  • CMOVP m64, r64 [CMOV]

func (*Program) CMOVPE 

func (self *Program) CMOVPE(v0 interface{}, v1 interface{}) *Instruction

CMOVPE performs "Move if parity even (PF == 1)".

Mnemonic : CMOVPE Supported forms : (6 forms)

  • CMOVPE r16, r16 [CMOV]
  • CMOVPE m16, r16 [CMOV]
  • CMOVPE r32, r32 [CMOV]
  • CMOVPE m32, r32 [CMOV]
  • CMOVPE r64, r64 [CMOV]
  • CMOVPE m64, r64 [CMOV]

func (*Program) CMOVPO 

func (self *Program) CMOVPO(v0 interface{}, v1 interface{}) *Instruction

CMOVPO performs "Move if parity odd (PF == 0)".

Mnemonic : CMOVPO Supported forms : (6 forms)

  • CMOVPO r16, r16 [CMOV]
  • CMOVPO m16, r16 [CMOV]
  • CMOVPO r32, r32 [CMOV]
  • CMOVPO m32, r32 [CMOV]
  • CMOVPO r64, r64 [CMOV]
  • CMOVPO m64, r64 [CMOV]

func (*Program) CMOVS 

func (self *Program) CMOVS(v0 interface{}, v1 interface{}) *Instruction

CMOVS performs "Move if sign (SF == 1)".

Mnemonic : CMOVS Supported forms : (6 forms)

  • CMOVS r16, r16 [CMOV]
  • CMOVS m16, r16 [CMOV]
  • CMOVS r32, r32 [CMOV]
  • CMOVS m32, r32 [CMOV]
  • CMOVS r64, r64 [CMOV]
  • CMOVS m64, r64 [CMOV]

func (*Program) CMOVZ 

func (self *Program) CMOVZ(v0 interface{}, v1 interface{}) *Instruction

CMOVZ performs "Move if zero (ZF == 1)".

Mnemonic : CMOVZ Supported forms : (6 forms)

  • CMOVZ r16, r16 [CMOV]
  • CMOVZ m16, r16 [CMOV]
  • CMOVZ r32, r32 [CMOV]
  • CMOVZ m32, r32 [CMOV]
  • CMOVZ r64, r64 [CMOV]
  • CMOVZ m64, r64 [CMOV]

func (*Program) CMPB 

func (self *Program) CMPB(v0 interface{}, v1 interface{}) *Instruction

CMPB performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (6 forms)

  • CMPB imm8, al
  • CMPB imm8, r8
  • CMPB r8, r8
  • CMPB m8, r8
  • CMPB imm8, m8
  • CMPB r8, m8

func (*Program) CMPL 

func (self *Program) CMPL(v0 interface{}, v1 interface{}) *Instruction

CMPL performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (8 forms)

  • CMPL imm32, eax
  • CMPL imm8, r32
  • CMPL imm32, r32
  • CMPL r32, r32
  • CMPL m32, r32
  • CMPL imm8, m32
  • CMPL imm32, m32
  • CMPL r32, m32

func (*Program) CMPPD 

func (self *Program) CMPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPPD performs "Compare Packed Double-Precision Floating-Point Values".

Mnemonic : CMPPD Supported forms : (2 forms)

  • CMPPD imm8, xmm, xmm [SSE2]
  • CMPPD imm8, m128, xmm [SSE2]

func (*Program) CMPPS 

func (self *Program) CMPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPPS performs "Compare Packed Single-Precision Floating-Point Values".

Mnemonic : CMPPS Supported forms : (2 forms)

  • CMPPS imm8, xmm, xmm [SSE]
  • CMPPS imm8, m128, xmm [SSE]

func (*Program) CMPQ 

func (self *Program) CMPQ(v0 interface{}, v1 interface{}) *Instruction

CMPQ performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (8 forms)

  • CMPQ imm32, rax
  • CMPQ imm8, r64
  • CMPQ imm32, r64
  • CMPQ r64, r64
  • CMPQ m64, r64
  • CMPQ imm8, m64
  • CMPQ imm32, m64
  • CMPQ r64, m64

func (*Program) CMPSD 

func (self *Program) CMPSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPSD performs "Compare Scalar Double-Precision Floating-Point Values".

Mnemonic : CMPSD Supported forms : (2 forms)

  • CMPSD imm8, xmm, xmm [SSE2]
  • CMPSD imm8, m64, xmm [SSE2]

func (*Program) CMPSS 

func (self *Program) CMPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

CMPSS performs "Compare Scalar Single-Precision Floating-Point Values".

Mnemonic : CMPSS Supported forms : (2 forms)

  • CMPSS imm8, xmm, xmm [SSE]
  • CMPSS imm8, m32, xmm [SSE]

func (*Program) CMPW 

func (self *Program) CMPW(v0 interface{}, v1 interface{}) *Instruction

CMPW performs "Compare Two Operands".

Mnemonic : CMP Supported forms : (8 forms)

  • CMPW imm16, ax
  • CMPW imm8, r16
  • CMPW imm16, r16
  • CMPW r16, r16
  • CMPW m16, r16
  • CMPW imm8, m16
  • CMPW imm16, m16
  • CMPW r16, m16

func (*Program) CMPXCHG16B 

func (self *Program) CMPXCHG16B(v0 interface{}) *Instruction

CMPXCHG16B performs "Compare and Exchange 16 Bytes".

Mnemonic : CMPXCHG16B Supported forms : (1 form)

  • CMPXCHG16B m128

func (*Program) CMPXCHG8B 

func (self *Program) CMPXCHG8B(v0 interface{}) *Instruction

CMPXCHG8B performs "Compare and Exchange 8 Bytes".

Mnemonic : CMPXCHG8B Supported forms : (1 form)

  • CMPXCHG8B m64

func (*Program) CMPXCHGB 

func (self *Program) CMPXCHGB(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGB performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

  • CMPXCHGB r8, r8
  • CMPXCHGB r8, m8

func (*Program) CMPXCHGL 

func (self *Program) CMPXCHGL(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGL performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

  • CMPXCHGL r32, r32
  • CMPXCHGL r32, m32

func (*Program) CMPXCHGQ 

func (self *Program) CMPXCHGQ(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGQ performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

  • CMPXCHGQ r64, r64
  • CMPXCHGQ r64, m64

func (*Program) CMPXCHGW 

func (self *Program) CMPXCHGW(v0 interface{}, v1 interface{}) *Instruction

CMPXCHGW performs "Compare and Exchange".

Mnemonic : CMPXCHG Supported forms : (2 forms)

  • CMPXCHGW r16, r16
  • CMPXCHGW r16, m16

func (*Program) COMISD 

func (self *Program) COMISD(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : COMISD Supported forms : (2 forms)

  • COMISD xmm, xmm [SSE2]
  • COMISD m64, xmm [SSE2]

func (*Program) COMISS 

func (self *Program) COMISS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : COMISS Supported forms : (2 forms)

  • COMISS xmm, xmm [SSE]
  • COMISS m32, xmm [SSE]

func (*Program) CPUID 

func (self *Program) CPUID() *Instruction

CPUID performs "CPU Identification".

Mnemonic : CPUID Supported forms : (1 form)

  • CPUID [CPUID]

func (*Program) CQTO 

func (self *Program) CQTO() *Instruction

CQTO performs "Convert Quadword to Octaword".

Mnemonic : CQO Supported forms : (1 form)

  • CQTO

func (*Program) CRC32B 

func (self *Program) CRC32B(v0 interface{}, v1 interface{}) *Instruction

CRC32B performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (4 forms)

  • CRC32B r8, r32 [SSE4.2]
  • CRC32B m8, r32 [SSE4.2]
  • CRC32B r8, r64 [SSE4.2]
  • CRC32B m8, r64 [SSE4.2]

func (*Program) CRC32L 

func (self *Program) CRC32L(v0 interface{}, v1 interface{}) *Instruction

CRC32L performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (2 forms)

  • CRC32L r32, r32 [SSE4.2]
  • CRC32L m32, r32 [SSE4.2]

func (*Program) CRC32Q 

func (self *Program) CRC32Q(v0 interface{}, v1 interface{}) *Instruction

CRC32Q performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (2 forms)

  • CRC32Q r64, r64 [SSE4.2]
  • CRC32Q m64, r64 [SSE4.2]

func (*Program) CRC32W 

func (self *Program) CRC32W(v0 interface{}, v1 interface{}) *Instruction

CRC32W performs "Accumulate CRC32 Value".

Mnemonic : CRC32 Supported forms : (2 forms)

  • CRC32W r16, r32 [SSE4.2]
  • CRC32W m16, r32 [SSE4.2]

func (*Program) CVTDQ2PD 

func (self *Program) CVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction

CVTDQ2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".

Mnemonic : CVTDQ2PD Supported forms : (2 forms)

  • CVTDQ2PD xmm, xmm [SSE2]
  • CVTDQ2PD m64, xmm [SSE2]

func (*Program) CVTDQ2PS 

func (self *Program) CVTDQ2PS(v0 interface{}, v1 interface{}) *Instruction

CVTDQ2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".

Mnemonic : CVTDQ2PS Supported forms : (2 forms)

  • CVTDQ2PS xmm, xmm [SSE2]
  • CVTDQ2PS m128, xmm [SSE2]

func (*Program) CVTPD2DQ 

func (self *Program) CVTPD2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTPD2DQ performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPD2DQ Supported forms : (2 forms)

  • CVTPD2DQ xmm, xmm [SSE2]
  • CVTPD2DQ m128, xmm [SSE2]

func (*Program) CVTPD2PI 

func (self *Program) CVTPD2PI(v0 interface{}, v1 interface{}) *Instruction

CVTPD2PI performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPD2PI Supported forms : (2 forms)

  • CVTPD2PI xmm, mm [SSE]
  • CVTPD2PI m128, mm [SSE]

func (*Program) CVTPD2PS 

func (self *Program) CVTPD2PS(v0 interface{}, v1 interface{}) *Instruction

CVTPD2PS performs "Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values".

Mnemonic : CVTPD2PS Supported forms : (2 forms)

  • CVTPD2PS xmm, xmm [SSE2]
  • CVTPD2PS m128, xmm [SSE2]

func (*Program) CVTPI2PD 

func (self *Program) CVTPI2PD(v0 interface{}, v1 interface{}) *Instruction

CVTPI2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".

Mnemonic : CVTPI2PD Supported forms : (2 forms)

  • CVTPI2PD mm, xmm [SSE2]
  • CVTPI2PD m64, xmm [SSE2]

func (*Program) CVTPI2PS 

func (self *Program) CVTPI2PS(v0 interface{}, v1 interface{}) *Instruction

CVTPI2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".

Mnemonic : CVTPI2PS Supported forms : (2 forms)

  • CVTPI2PS mm, xmm [SSE]
  • CVTPI2PS m64, xmm [SSE]

func (*Program) CVTPS2DQ 

func (self *Program) CVTPS2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTPS2DQ performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPS2DQ Supported forms : (2 forms)

  • CVTPS2DQ xmm, xmm [SSE2]
  • CVTPS2DQ m128, xmm [SSE2]

func (*Program) CVTPS2PD 

func (self *Program) CVTPS2PD(v0 interface{}, v1 interface{}) *Instruction

CVTPS2PD performs "Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values".

Mnemonic : CVTPS2PD Supported forms : (2 forms)

  • CVTPS2PD xmm, xmm [SSE2]
  • CVTPS2PD m64, xmm [SSE2]

func (*Program) CVTPS2PI 

func (self *Program) CVTPS2PI(v0 interface{}, v1 interface{}) *Instruction

CVTPS2PI performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTPS2PI Supported forms : (2 forms)

  • CVTPS2PI xmm, mm [SSE]
  • CVTPS2PI m64, mm [SSE]

func (*Program) CVTSD2SI 

func (self *Program) CVTSD2SI(v0 interface{}, v1 interface{}) *Instruction

CVTSD2SI performs "Convert Scalar Double-Precision FP Value to Integer".

Mnemonic : CVTSD2SI Supported forms : (4 forms)

  • CVTSD2SI xmm, r32 [SSE2]
  • CVTSD2SI m64, r32 [SSE2]
  • CVTSD2SI xmm, r64 [SSE2]
  • CVTSD2SI m64, r64 [SSE2]

func (*Program) CVTSD2SS 

func (self *Program) CVTSD2SS(v0 interface{}, v1 interface{}) *Instruction

CVTSD2SS performs "Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value".

Mnemonic : CVTSD2SS Supported forms : (2 forms)

  • CVTSD2SS xmm, xmm [SSE2]
  • CVTSD2SS m64, xmm [SSE2]

func (*Program) CVTSI2SD 

func (self *Program) CVTSI2SD(v0 interface{}, v1 interface{}) *Instruction

CVTSI2SD performs "Convert Dword Integer to Scalar Double-Precision FP Value".

Mnemonic : CVTSI2SD Supported forms : (4 forms)

  • CVTSI2SD r32, xmm [SSE2]
  • CVTSI2SD r64, xmm [SSE2]
  • CVTSI2SD m32, xmm [SSE2]
  • CVTSI2SD m64, xmm [SSE2]

func (*Program) CVTSI2SS 

func (self *Program) CVTSI2SS(v0 interface{}, v1 interface{}) *Instruction

CVTSI2SS performs "Convert Dword Integer to Scalar Single-Precision FP Value".

Mnemonic : CVTSI2SS Supported forms : (4 forms)

  • CVTSI2SS r32, xmm [SSE]
  • CVTSI2SS r64, xmm [SSE]
  • CVTSI2SS m32, xmm [SSE]
  • CVTSI2SS m64, xmm [SSE]

func (*Program) CVTSS2SD 

func (self *Program) CVTSS2SD(v0 interface{}, v1 interface{}) *Instruction

CVTSS2SD performs "Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value".

Mnemonic : CVTSS2SD Supported forms : (2 forms)

  • CVTSS2SD xmm, xmm [SSE2]
  • CVTSS2SD m32, xmm [SSE2]

func (*Program) CVTSS2SI 

func (self *Program) CVTSS2SI(v0 interface{}, v1 interface{}) *Instruction

CVTSS2SI performs "Convert Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : CVTSS2SI Supported forms : (4 forms)

  • CVTSS2SI xmm, r32 [SSE]
  • CVTSS2SI m32, r32 [SSE]
  • CVTSS2SI xmm, r64 [SSE]
  • CVTSS2SI m32, r64 [SSE]

func (*Program) CVTTPD2DQ 

func (self *Program) CVTTPD2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTTPD2DQ performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPD2DQ Supported forms : (2 forms)

  • CVTTPD2DQ xmm, xmm [SSE2]
  • CVTTPD2DQ m128, xmm [SSE2]

func (*Program) CVTTPD2PI 

func (self *Program) CVTTPD2PI(v0 interface{}, v1 interface{}) *Instruction

CVTTPD2PI performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPD2PI Supported forms : (2 forms)

  • CVTTPD2PI xmm, mm [SSE2]
  • CVTTPD2PI m128, mm [SSE2]

func (*Program) CVTTPS2DQ 

func (self *Program) CVTTPS2DQ(v0 interface{}, v1 interface{}) *Instruction

CVTTPS2DQ performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPS2DQ Supported forms : (2 forms)

  • CVTTPS2DQ xmm, xmm [SSE2]
  • CVTTPS2DQ m128, xmm [SSE2]

func (*Program) CVTTPS2PI 

func (self *Program) CVTTPS2PI(v0 interface{}, v1 interface{}) *Instruction

CVTTPS2PI performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : CVTTPS2PI Supported forms : (2 forms)

  • CVTTPS2PI xmm, mm [SSE]
  • CVTTPS2PI m64, mm [SSE]

func (*Program) CVTTSD2SI 

func (self *Program) CVTTSD2SI(v0 interface{}, v1 interface{}) *Instruction

CVTTSD2SI performs "Convert with Truncation Scalar Double-Precision FP Value to Signed Integer".

Mnemonic : CVTTSD2SI Supported forms : (4 forms)

  • CVTTSD2SI xmm, r32 [SSE2]
  • CVTTSD2SI m64, r32 [SSE2]
  • CVTTSD2SI xmm, r64 [SSE2]
  • CVTTSD2SI m64, r64 [SSE2]

func (*Program) CVTTSS2SI 

func (self *Program) CVTTSS2SI(v0 interface{}, v1 interface{}) *Instruction

CVTTSS2SI performs "Convert with Truncation Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : CVTTSS2SI Supported forms : (4 forms)

  • CVTTSS2SI xmm, r32 [SSE]
  • CVTTSS2SI m32, r32 [SSE]
  • CVTTSS2SI xmm, r64 [SSE]
  • CVTTSS2SI m32, r64 [SSE]

func (*Program) CWTD 

func (self *Program) CWTD() *Instruction

CWTD performs "Convert Word to Doubleword".

Mnemonic : CWD Supported forms : (1 form)

  • CWTD

func (*Program) CWTL 

func (self *Program) CWTL() *Instruction

CWTL performs "Convert Word to Doubleword".

Mnemonic : CWDE Supported forms : (1 form)

  • CWTL

func (*Program) DECB 

func (self *Program) DECB(v0 interface{}) *Instruction

DECB performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

  • DECB r8
  • DECB m8

func (*Program) DECL 

func (self *Program) DECL(v0 interface{}) *Instruction

DECL performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

  • DECL r32
  • DECL m32

func (*Program) DECQ 

func (self *Program) DECQ(v0 interface{}) *Instruction

DECQ performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

  • DECQ r64
  • DECQ m64

func (*Program) DECW 

func (self *Program) DECW(v0 interface{}) *Instruction

DECW performs "Decrement by 1".

Mnemonic : DEC Supported forms : (2 forms)

  • DECW r16
  • DECW m16

func (*Program) DIVB 

func (self *Program) DIVB(v0 interface{}) *Instruction

DIVB performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

  • DIVB r8
  • DIVB m8

func (*Program) DIVL 

func (self *Program) DIVL(v0 interface{}) *Instruction

DIVL performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

  • DIVL r32
  • DIVL m32

func (*Program) DIVPD 

func (self *Program) DIVPD(v0 interface{}, v1 interface{}) *Instruction

DIVPD performs "Divide Packed Double-Precision Floating-Point Values".

Mnemonic : DIVPD Supported forms : (2 forms)

  • DIVPD xmm, xmm [SSE2]
  • DIVPD m128, xmm [SSE2]

func (*Program) DIVPS 

func (self *Program) DIVPS(v0 interface{}, v1 interface{}) *Instruction

DIVPS performs "Divide Packed Single-Precision Floating-Point Values".

Mnemonic : DIVPS Supported forms : (2 forms)

  • DIVPS xmm, xmm [SSE]
  • DIVPS m128, xmm [SSE]

func (*Program) DIVQ 

func (self *Program) DIVQ(v0 interface{}) *Instruction

DIVQ performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

  • DIVQ r64
  • DIVQ m64

func (*Program) DIVSD 

func (self *Program) DIVSD(v0 interface{}, v1 interface{}) *Instruction

DIVSD performs "Divide Scalar Double-Precision Floating-Point Values".

Mnemonic : DIVSD Supported forms : (2 forms)

  • DIVSD xmm, xmm [SSE2]
  • DIVSD m64, xmm [SSE2]

func (*Program) DIVSS 

func (self *Program) DIVSS(v0 interface{}, v1 interface{}) *Instruction

DIVSS performs "Divide Scalar Single-Precision Floating-Point Values".

Mnemonic : DIVSS Supported forms : (2 forms)

  • DIVSS xmm, xmm [SSE]
  • DIVSS m32, xmm [SSE]

func (*Program) DIVW 

func (self *Program) DIVW(v0 interface{}) *Instruction

DIVW performs "Unsigned Divide".

Mnemonic : DIV Supported forms : (2 forms)

  • DIVW r16
  • DIVW m16

func (*Program) DPPD 

func (self *Program) DPPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

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

Mnemonic : DPPD Supported forms : (2 forms)

  • DPPD imm8, xmm, xmm [SSE4.1]
  • DPPD imm8, m128, xmm [SSE4.1]

func (*Program) DPPS 

func (self *Program) DPPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

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

Mnemonic : DPPS Supported forms : (2 forms)

  • DPPS imm8, xmm, xmm [SSE4.1]
  • DPPS imm8, m128, xmm [SSE4.1]

func (*Program) Data 

func (self *Program) Data(v []byte) (p *Instruction)

Data is a pseudo-instruction to add raw bytes to the assembled code.

func (*Program) EMMS 

func (self *Program) EMMS() *Instruction

EMMS performs "Exit MMX State".

Mnemonic : EMMS Supported forms : (1 form)

  • EMMS [MMX]

func (*Program) EXTRACTPS 

func (self *Program) EXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

EXTRACTPS performs "Extract Packed Single Precision Floating-Point Value".

Mnemonic : EXTRACTPS Supported forms : (2 forms)

  • EXTRACTPS imm8, xmm, r32 [SSE4.1]
  • EXTRACTPS imm8, xmm, m32 [SSE4.1]

func (*Program) EXTRQ 

func (self *Program) EXTRQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

EXTRQ performs "Extract Field".

Mnemonic : EXTRQ Supported forms : (2 forms)

  • EXTRQ xmm, xmm [SSE4A]
  • EXTRQ imm8, imm8, xmm [SSE4A]

func (*Program) FEMMS 

func (self *Program) FEMMS() *Instruction

FEMMS performs "Fast Exit Multimedia State".

Mnemonic : FEMMS Supported forms : (1 form)

  • FEMMS [FEMMS]

func (*Program) Free 

func (self *Program) Free()

Free returns the Program object into pool. Any operation performed after Free is undefined behavior.

NOTE: This also frees all the instructions, labels, memory 

operands and expressions associated with this program.

func (*Program) HADDPD 

func (self *Program) HADDPD(v0 interface{}, v1 interface{}) *Instruction

HADDPD performs "Packed Double-FP Horizontal Add".

Mnemonic : HADDPD Supported forms : (2 forms)

  • HADDPD xmm, xmm [SSE3]
  • HADDPD m128, xmm [SSE3]

func (*Program) HADDPS 

func (self *Program) HADDPS(v0 interface{}, v1 interface{}) *Instruction

HADDPS performs "Packed Single-FP Horizontal Add".

Mnemonic : HADDPS Supported forms : (2 forms)

  • HADDPS xmm, xmm [SSE3]
  • HADDPS m128, xmm [SSE3]

func (*Program) HSUBPD 

func (self *Program) HSUBPD(v0 interface{}, v1 interface{}) *Instruction

HSUBPD performs "Packed Double-FP Horizontal Subtract".

Mnemonic : HSUBPD Supported forms : (2 forms)

  • HSUBPD xmm, xmm [SSE3]
  • HSUBPD m128, xmm [SSE3]

func (*Program) HSUBPS 

func (self *Program) HSUBPS(v0 interface{}, v1 interface{}) *Instruction

HSUBPS performs "Packed Single-FP Horizontal Subtract".

Mnemonic : HSUBPS Supported forms : (2 forms)

  • HSUBPS xmm, xmm [SSE3]
  • HSUBPS m128, xmm [SSE3]

func (*Program) IDIVB 

func (self *Program) IDIVB(v0 interface{}) *Instruction

IDIVB performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

  • IDIVB r8
  • IDIVB m8

func (*Program) IDIVL 

func (self *Program) IDIVL(v0 interface{}) *Instruction

IDIVL performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

  • IDIVL r32
  • IDIVL m32

func (*Program) IDIVQ 

func (self *Program) IDIVQ(v0 interface{}) *Instruction

IDIVQ performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

  • IDIVQ r64
  • IDIVQ m64

func (*Program) IDIVW 

func (self *Program) IDIVW(v0 interface{}) *Instruction

IDIVW performs "Signed Divide".

Mnemonic : IDIV Supported forms : (2 forms)

  • IDIVW r16
  • IDIVW m16

func (*Program) IMULB 

func (self *Program) IMULB(v0 interface{}) *Instruction

IMULB performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (2 forms)

  • IMULB r8
  • IMULB m8

func (*Program) IMULL 

func (self *Program) IMULL(v0 interface{}, vv ...interface{}) *Instruction

IMULL performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (8 forms)

  • IMULL r32
  • IMULL m32
  • IMULL r32, r32
  • IMULL m32, r32
  • IMULL imm8, r32, r32
  • IMULL imm32, r32, r32
  • IMULL imm8, m32, r32
  • IMULL imm32, m32, r32

func (*Program) IMULQ 

func (self *Program) IMULQ(v0 interface{}, vv ...interface{}) *Instruction

IMULQ performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (8 forms)

  • IMULQ r64
  • IMULQ m64
  • IMULQ r64, r64
  • IMULQ m64, r64
  • IMULQ imm8, r64, r64
  • IMULQ imm32, r64, r64
  • IMULQ imm8, m64, r64
  • IMULQ imm32, m64, r64

func (*Program) IMULW 

func (self *Program) IMULW(v0 interface{}, vv ...interface{}) *Instruction

IMULW performs "Signed Multiply".

Mnemonic : IMUL Supported forms : (8 forms)

  • IMULW r16
  • IMULW m16
  • IMULW r16, r16
  • IMULW m16, r16
  • IMULW imm8, r16, r16
  • IMULW imm16, r16, r16
  • IMULW imm8, m16, r16
  • IMULW imm16, m16, r16

func (*Program) INCB 

func (self *Program) INCB(v0 interface{}) *Instruction

INCB performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

  • INCB r8
  • INCB m8

func (*Program) INCL 

func (self *Program) INCL(v0 interface{}) *Instruction

INCL performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

  • INCL r32
  • INCL m32

func (*Program) INCQ 

func (self *Program) INCQ(v0 interface{}) *Instruction

INCQ performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

  • INCQ r64
  • INCQ m64

func (*Program) INCW 

func (self *Program) INCW(v0 interface{}) *Instruction

INCW performs "Increment by 1".

Mnemonic : INC Supported forms : (2 forms)

  • INCW r16
  • INCW m16

func (*Program) INSERTPS 

func (self *Program) INSERTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

INSERTPS performs "Insert Packed Single Precision Floating-Point Value".

Mnemonic : INSERTPS Supported forms : (2 forms)

  • INSERTPS imm8, xmm, xmm [SSE4.1]
  • INSERTPS imm8, m32, xmm [SSE4.1]

func (*Program) INSERTQ 

func (self *Program) INSERTQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

INSERTQ performs "Insert Field".

Mnemonic : INSERTQ Supported forms : (2 forms)

  • INSERTQ xmm, xmm [SSE4A]
  • INSERTQ imm8, imm8, xmm, xmm [SSE4A]

func (*Program) INT 

func (self *Program) INT(v0 interface{}) *Instruction

INT performs "Call to Interrupt Procedure".

Mnemonic : INT Supported forms : (2 forms)

  • INT 3
  • INT imm8

func (*Program) JA 

func (self *Program) JA(v0 interface{}) *Instruction

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

Mnemonic : JA Supported forms : (2 forms)

  • JA rel8
  • JA rel32

func (*Program) JAE 

func (self *Program) JAE(v0 interface{}) *Instruction

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

Mnemonic : JAE Supported forms : (2 forms)

  • JAE rel8
  • JAE rel32

func (*Program) JB 

func (self *Program) JB(v0 interface{}) *Instruction

JB performs "Jump if below (CF == 1)".

Mnemonic : JB Supported forms : (2 forms)

  • JB rel8
  • JB rel32

func (*Program) JBE 

func (self *Program) JBE(v0 interface{}) *Instruction

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

Mnemonic : JBE Supported forms : (2 forms)

  • JBE rel8
  • JBE rel32

func (*Program) JC 

func (self *Program) JC(v0 interface{}) *Instruction

JC performs "Jump if carry (CF == 1)".

Mnemonic : JC Supported forms : (2 forms)

  • JC rel8
  • JC rel32

func (*Program) JE 

func (self *Program) JE(v0 interface{}) *Instruction

JE performs "Jump if equal (ZF == 1)".

Mnemonic : JE Supported forms : (2 forms)

  • JE rel8
  • JE rel32

func (*Program) JECXZ 

func (self *Program) JECXZ(v0 interface{}) *Instruction

JECXZ performs "Jump if ECX register is 0".

Mnemonic : JECXZ Supported forms : (1 form)

  • JECXZ rel8

func (*Program) JG 

func (self *Program) JG(v0 interface{}) *Instruction

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

Mnemonic : JG Supported forms : (2 forms)

  • JG rel8
  • JG rel32

func (*Program) JGE 

func (self *Program) JGE(v0 interface{}) *Instruction

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

Mnemonic : JGE Supported forms : (2 forms)

  • JGE rel8
  • JGE rel32

func (*Program) JL 

func (self *Program) JL(v0 interface{}) *Instruction

JL performs "Jump if less (SF != OF)".

Mnemonic : JL Supported forms : (2 forms)

  • JL rel8
  • JL rel32

func (*Program) JLE 

func (self *Program) JLE(v0 interface{}) *Instruction

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

Mnemonic : JLE Supported forms : (2 forms)

  • JLE rel8
  • JLE rel32

func (*Program) JMP 

func (self *Program) JMP(v0 interface{}) *Instruction

JMP performs "Jump Unconditionally".

Mnemonic : JMP Supported forms : (2 forms)

  • JMP rel8
  • JMP rel32

func (*Program) JMPQ 

func (self *Program) JMPQ(v0 interface{}) *Instruction

JMPQ performs "Jump Unconditionally".

Mnemonic : JMP Supported forms : (2 forms)

  • JMPQ r64
  • JMPQ m64

func (*Program) JNA 

func (self *Program) JNA(v0 interface{}) *Instruction

JNA performs "Jump if not above (CF == 1 or ZF == 1)".

Mnemonic : JNA Supported forms : (2 forms)

  • JNA rel8
  • JNA rel32

func (*Program) JNAE 

func (self *Program) JNAE(v0 interface{}) *Instruction

JNAE performs "Jump if not above or equal (CF == 1)".

Mnemonic : JNAE Supported forms : (2 forms)

  • JNAE rel8
  • JNAE rel32

func (*Program) JNB 

func (self *Program) JNB(v0 interface{}) *Instruction

JNB performs "Jump if not below (CF == 0)".

Mnemonic : JNB Supported forms : (2 forms)

  • JNB rel8
  • JNB rel32

func (*Program) JNBE 

func (self *Program) JNBE(v0 interface{}) *Instruction

JNBE performs "Jump if not below or equal (CF == 0 and ZF == 0)".

Mnemonic : JNBE Supported forms : (2 forms)

  • JNBE rel8
  • JNBE rel32

func (*Program) JNC 

func (self *Program) JNC(v0 interface{}) *Instruction

JNC performs "Jump if not carry (CF == 0)".

Mnemonic : JNC Supported forms : (2 forms)

  • JNC rel8
  • JNC rel32

func (*Program) JNE 

func (self *Program) JNE(v0 interface{}) *Instruction

JNE performs "Jump if not equal (ZF == 0)".

Mnemonic : JNE Supported forms : (2 forms)

  • JNE rel8
  • JNE rel32

func (*Program) JNG 

func (self *Program) JNG(v0 interface{}) *Instruction

JNG performs "Jump if not greater (ZF == 1 or SF != OF)".

Mnemonic : JNG Supported forms : (2 forms)

  • JNG rel8
  • JNG rel32

func (*Program) JNGE 

func (self *Program) JNGE(v0 interface{}) *Instruction

JNGE performs "Jump if not greater or equal (SF != OF)".

Mnemonic : JNGE Supported forms : (2 forms)

  • JNGE rel8
  • JNGE rel32

func (*Program) JNL 

func (self *Program) JNL(v0 interface{}) *Instruction

JNL performs "Jump if not less (SF == OF)".

Mnemonic : JNL Supported forms : (2 forms)

  • JNL rel8
  • JNL rel32

func (*Program) JNLE 

func (self *Program) JNLE(v0 interface{}) *Instruction

JNLE performs "Jump if not less or equal (ZF == 0 and SF == OF)".

Mnemonic : JNLE Supported forms : (2 forms)

  • JNLE rel8
  • JNLE rel32

func (*Program) JNO 

func (self *Program) JNO(v0 interface{}) *Instruction

JNO performs "Jump if not overflow (OF == 0)".

Mnemonic : JNO Supported forms : (2 forms)

  • JNO rel8
  • JNO rel32

func (*Program) JNP 

func (self *Program) JNP(v0 interface{}) *Instruction

JNP performs "Jump if not parity (PF == 0)".

Mnemonic : JNP Supported forms : (2 forms)

  • JNP rel8
  • JNP rel32

func (*Program) JNS 

func (self *Program) JNS(v0 interface{}) *Instruction

JNS performs "Jump if not sign (SF == 0)".

Mnemonic : JNS Supported forms : (2 forms)

  • JNS rel8
  • JNS rel32

func (*Program) JNZ 

func (self *Program) JNZ(v0 interface{}) *Instruction

JNZ performs "Jump if not zero (ZF == 0)".

Mnemonic : JNZ Supported forms : (2 forms)

  • JNZ rel8
  • JNZ rel32

func (*Program) JO 

func (self *Program) JO(v0 interface{}) *Instruction

JO performs "Jump if overflow (OF == 1)".

Mnemonic : JO Supported forms : (2 forms)

  • JO rel8
  • JO rel32

func (*Program) JP 

func (self *Program) JP(v0 interface{}) *Instruction

JP performs "Jump if parity (PF == 1)".

Mnemonic : JP Supported forms : (2 forms)

  • JP rel8
  • JP rel32

func (*Program) JPE 

func (self *Program) JPE(v0 interface{}) *Instruction

JPE performs "Jump if parity even (PF == 1)".

Mnemonic : JPE Supported forms : (2 forms)

  • JPE rel8
  • JPE rel32

func (*Program) JPO 

func (self *Program) JPO(v0 interface{}) *Instruction

JPO performs "Jump if parity odd (PF == 0)".

Mnemonic : JPO Supported forms : (2 forms)

  • JPO rel8
  • JPO rel32

func (*Program) JRCXZ 

func (self *Program) JRCXZ(v0 interface{}) *Instruction

JRCXZ performs "Jump if RCX register is 0".

Mnemonic : JRCXZ Supported forms : (1 form)

  • JRCXZ rel8

func (*Program) JS 

func (self *Program) JS(v0 interface{}) *Instruction

JS performs "Jump if sign (SF == 1)".

Mnemonic : JS Supported forms : (2 forms)

  • JS rel8
  • JS rel32

func (*Program) JZ 

func (self *Program) JZ(v0 interface{}) *Instruction

JZ performs "Jump if zero (ZF == 1)".

Mnemonic : JZ Supported forms : (2 forms)

  • JZ rel8
  • JZ rel32

func (*Program) KADDB 

func (self *Program) KADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDB performs "ADD Two 8-bit Masks".

Mnemonic : KADDB Supported forms : (1 form)

  • KADDB k, k, k [AVX512DQ]

func (*Program) KADDD 

func (self *Program) KADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDD performs "ADD Two 32-bit Masks".

Mnemonic : KADDD Supported forms : (1 form)

  • KADDD k, k, k [AVX512BW]

func (*Program) KADDQ 

func (self *Program) KADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDQ performs "ADD Two 64-bit Masks".

Mnemonic : KADDQ Supported forms : (1 form)

  • KADDQ k, k, k [AVX512BW]

func (*Program) KADDW 

func (self *Program) KADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KADDW performs "ADD Two 16-bit Masks".

Mnemonic : KADDW Supported forms : (1 form)

  • KADDW k, k, k [AVX512DQ]

func (*Program) KANDB 

func (self *Program) KANDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDB performs "Bitwise Logical AND 8-bit Masks".

Mnemonic : KANDB Supported forms : (1 form)

  • KANDB k, k, k [AVX512DQ]

func (*Program) KANDD 

func (self *Program) KANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDD performs "Bitwise Logical AND 32-bit Masks".

Mnemonic : KANDD Supported forms : (1 form)

  • KANDD k, k, k [AVX512BW]

func (*Program) KANDNB 

func (self *Program) KANDNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDNB performs "Bitwise Logical AND NOT 8-bit Masks".

Mnemonic : KANDNB Supported forms : (1 form)

  • KANDNB k, k, k [AVX512DQ]

func (*Program) KANDND 

func (self *Program) KANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDND performs "Bitwise Logical AND NOT 32-bit Masks".

Mnemonic : KANDND Supported forms : (1 form)

  • KANDND k, k, k [AVX512BW]

func (*Program) KANDNQ 

func (self *Program) KANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDNQ performs "Bitwise Logical AND NOT 64-bit Masks".

Mnemonic : KANDNQ Supported forms : (1 form)

  • KANDNQ k, k, k [AVX512BW]

func (*Program) KANDNW 

func (self *Program) KANDNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDNW performs "Bitwise Logical AND NOT 16-bit Masks".

Mnemonic : KANDNW Supported forms : (1 form)

  • KANDNW k, k, k [AVX512F]

func (*Program) KANDQ 

func (self *Program) KANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDQ performs "Bitwise Logical AND 64-bit Masks".

Mnemonic : KANDQ Supported forms : (1 form)

  • KANDQ k, k, k [AVX512BW]

func (*Program) KANDW 

func (self *Program) KANDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KANDW performs "Bitwise Logical AND 16-bit Masks".

Mnemonic : KANDW Supported forms : (1 form)

  • KANDW k, k, k [AVX512F]

func (*Program) KMOVB 

func (self *Program) KMOVB(v0 interface{}, v1 interface{}) *Instruction

KMOVB performs "Move 8-bit Mask".

Mnemonic : KMOVB Supported forms : (5 forms)

  • KMOVB k, k [AVX512DQ]
  • KMOVB r32, k [AVX512DQ]
  • KMOVB m8, k [AVX512DQ]
  • KMOVB k, r32 [AVX512DQ]
  • KMOVB k, m8 [AVX512DQ]

func (*Program) KMOVD 

func (self *Program) KMOVD(v0 interface{}, v1 interface{}) *Instruction

KMOVD performs "Move 32-bit Mask".

Mnemonic : KMOVD Supported forms : (5 forms)

  • KMOVD k, k [AVX512BW]
  • KMOVD r32, k [AVX512BW]
  • KMOVD m32, k [AVX512BW]
  • KMOVD k, r32 [AVX512BW]
  • KMOVD k, m32 [AVX512BW]

func (*Program) KMOVQ 

func (self *Program) KMOVQ(v0 interface{}, v1 interface{}) *Instruction

KMOVQ performs "Move 64-bit Mask".

Mnemonic : KMOVQ Supported forms : (5 forms)

  • KMOVQ k, k [AVX512BW]
  • KMOVQ r64, k [AVX512BW]
  • KMOVQ m64, k [AVX512BW]
  • KMOVQ k, r64 [AVX512BW]
  • KMOVQ k, m64 [AVX512BW]

func (*Program) KMOVW 

func (self *Program) KMOVW(v0 interface{}, v1 interface{}) *Instruction

KMOVW performs "Move 16-bit Mask".

Mnemonic : KMOVW Supported forms : (5 forms)

  • KMOVW k, k [AVX512F]
  • KMOVW r32, k [AVX512F]
  • KMOVW m16, k [AVX512F]
  • KMOVW k, r32 [AVX512F]
  • KMOVW k, m16 [AVX512F]

func (*Program) KNOTB 

func (self *Program) KNOTB(v0 interface{}, v1 interface{}) *Instruction

KNOTB performs "NOT 8-bit Mask Register".

Mnemonic : KNOTB Supported forms : (1 form)

  • KNOTB k, k [AVX512DQ]

func (*Program) KNOTD 

func (self *Program) KNOTD(v0 interface{}, v1 interface{}) *Instruction

KNOTD performs "NOT 32-bit Mask Register".

Mnemonic : KNOTD Supported forms : (1 form)

  • KNOTD k, k [AVX512BW]

func (*Program) KNOTQ 

func (self *Program) KNOTQ(v0 interface{}, v1 interface{}) *Instruction

KNOTQ performs "NOT 64-bit Mask Register".

Mnemonic : KNOTQ Supported forms : (1 form)

  • KNOTQ k, k [AVX512BW]

func (*Program) KNOTW 

func (self *Program) KNOTW(v0 interface{}, v1 interface{}) *Instruction

KNOTW performs "NOT 16-bit Mask Register".

Mnemonic : KNOTW Supported forms : (1 form)

  • KNOTW k, k [AVX512F]

func (*Program) KORB 

func (self *Program) KORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORB performs "Bitwise Logical OR 8-bit Masks".

Mnemonic : KORB Supported forms : (1 form)

  • KORB k, k, k [AVX512DQ]

func (*Program) KORD 

func (self *Program) KORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORD performs "Bitwise Logical OR 32-bit Masks".

Mnemonic : KORD Supported forms : (1 form)

  • KORD k, k, k [AVX512BW]

func (*Program) KORQ 

func (self *Program) KORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORQ performs "Bitwise Logical OR 64-bit Masks".

Mnemonic : KORQ Supported forms : (1 form)

  • KORQ k, k, k [AVX512BW]

func (*Program) KORTESTB 

func (self *Program) KORTESTB(v0 interface{}, v1 interface{}) *Instruction

KORTESTB performs "OR 8-bit Masks and Set Flags".

Mnemonic : KORTESTB Supported forms : (1 form)

  • KORTESTB k, k [AVX512DQ]

func (*Program) KORTESTD 

func (self *Program) KORTESTD(v0 interface{}, v1 interface{}) *Instruction

KORTESTD performs "OR 32-bit Masks and Set Flags".

Mnemonic : KORTESTD Supported forms : (1 form)

  • KORTESTD k, k [AVX512BW]

func (*Program) KORTESTQ 

func (self *Program) KORTESTQ(v0 interface{}, v1 interface{}) *Instruction

KORTESTQ performs "OR 64-bit Masks and Set Flags".

Mnemonic : KORTESTQ Supported forms : (1 form)

  • KORTESTQ k, k [AVX512BW]

func (*Program) KORTESTW 

func (self *Program) KORTESTW(v0 interface{}, v1 interface{}) *Instruction

KORTESTW performs "OR 16-bit Masks and Set Flags".

Mnemonic : KORTESTW Supported forms : (1 form)

  • KORTESTW k, k [AVX512F]

func (*Program) KORW 

func (self *Program) KORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KORW performs "Bitwise Logical OR 16-bit Masks".

Mnemonic : KORW Supported forms : (1 form)

  • KORW k, k, k [AVX512F]

func (*Program) KSHIFTLB 

func (self *Program) KSHIFTLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLB performs "Shift Left 8-bit Masks".

Mnemonic : KSHIFTLB Supported forms : (1 form)

  • KSHIFTLB imm8, k, k [AVX512DQ]

func (*Program) KSHIFTLD 

func (self *Program) KSHIFTLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLD performs "Shift Left 32-bit Masks".

Mnemonic : KSHIFTLD Supported forms : (1 form)

  • KSHIFTLD imm8, k, k [AVX512BW]

func (*Program) KSHIFTLQ 

func (self *Program) KSHIFTLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLQ performs "Shift Left 64-bit Masks".

Mnemonic : KSHIFTLQ Supported forms : (1 form)

  • KSHIFTLQ imm8, k, k [AVX512BW]

func (*Program) KSHIFTLW 

func (self *Program) KSHIFTLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTLW performs "Shift Left 16-bit Masks".

Mnemonic : KSHIFTLW Supported forms : (1 form)

  • KSHIFTLW imm8, k, k [AVX512F]

func (*Program) KSHIFTRB 

func (self *Program) KSHIFTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRB performs "Shift Right 8-bit Masks".

Mnemonic : KSHIFTRB Supported forms : (1 form)

  • KSHIFTRB imm8, k, k [AVX512DQ]

func (*Program) KSHIFTRD 

func (self *Program) KSHIFTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRD performs "Shift Right 32-bit Masks".

Mnemonic : KSHIFTRD Supported forms : (1 form)

  • KSHIFTRD imm8, k, k [AVX512BW]

func (*Program) KSHIFTRQ 

func (self *Program) KSHIFTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRQ performs "Shift Right 64-bit Masks".

Mnemonic : KSHIFTRQ Supported forms : (1 form)

  • KSHIFTRQ imm8, k, k [AVX512BW]

func (*Program) KSHIFTRW 

func (self *Program) KSHIFTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KSHIFTRW performs "Shift Right 16-bit Masks".

Mnemonic : KSHIFTRW Supported forms : (1 form)

  • KSHIFTRW imm8, k, k [AVX512F]

func (*Program) KTESTB 

func (self *Program) KTESTB(v0 interface{}, v1 interface{}) *Instruction

KTESTB performs "Bit Test 8-bit Masks and Set Flags".

Mnemonic : KTESTB Supported forms : (1 form)

  • KTESTB k, k [AVX512DQ]

func (*Program) KTESTD 

func (self *Program) KTESTD(v0 interface{}, v1 interface{}) *Instruction

KTESTD performs "Bit Test 32-bit Masks and Set Flags".

Mnemonic : KTESTD Supported forms : (1 form)

  • KTESTD k, k [AVX512BW]

func (*Program) KTESTQ 

func (self *Program) KTESTQ(v0 interface{}, v1 interface{}) *Instruction

KTESTQ performs "Bit Test 64-bit Masks and Set Flags".

Mnemonic : KTESTQ Supported forms : (1 form)

  • KTESTQ k, k [AVX512BW]

func (*Program) KTESTW 

func (self *Program) KTESTW(v0 interface{}, v1 interface{}) *Instruction

KTESTW performs "Bit Test 16-bit Masks and Set Flags".

Mnemonic : KTESTW Supported forms : (1 form)

  • KTESTW k, k [AVX512DQ]

func (*Program) KUNPCKBW 

func (self *Program) KUNPCKBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KUNPCKBW performs "Unpack and Interleave 8-bit Masks".

Mnemonic : KUNPCKBW Supported forms : (1 form)

  • KUNPCKBW k, k, k [AVX512F]

func (*Program) KUNPCKDQ 

func (self *Program) KUNPCKDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KUNPCKDQ performs "Unpack and Interleave 32-bit Masks".

Mnemonic : KUNPCKDQ Supported forms : (1 form)

  • KUNPCKDQ k, k, k [AVX512BW]

func (*Program) KUNPCKWD 

func (self *Program) KUNPCKWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KUNPCKWD performs "Unpack and Interleave 16-bit Masks".

Mnemonic : KUNPCKWD Supported forms : (1 form)

  • KUNPCKWD k, k, k [AVX512BW]

func (*Program) KXNORB 

func (self *Program) KXNORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORB performs "Bitwise Logical XNOR 8-bit Masks".

Mnemonic : KXNORB Supported forms : (1 form)

  • KXNORB k, k, k [AVX512DQ]

func (*Program) KXNORD 

func (self *Program) KXNORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORD performs "Bitwise Logical XNOR 32-bit Masks".

Mnemonic : KXNORD Supported forms : (1 form)

  • KXNORD k, k, k [AVX512BW]

func (*Program) KXNORQ 

func (self *Program) KXNORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORQ performs "Bitwise Logical XNOR 64-bit Masks".

Mnemonic : KXNORQ Supported forms : (1 form)

  • KXNORQ k, k, k [AVX512BW]

func (*Program) KXNORW 

func (self *Program) KXNORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXNORW performs "Bitwise Logical XNOR 16-bit Masks".

Mnemonic : KXNORW Supported forms : (1 form)

  • KXNORW k, k, k [AVX512F]

func (*Program) KXORB 

func (self *Program) KXORB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORB performs "Bitwise Logical XOR 8-bit Masks".

Mnemonic : KXORB Supported forms : (1 form)

  • KXORB k, k, k [AVX512DQ]

func (*Program) KXORD 

func (self *Program) KXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORD performs "Bitwise Logical XOR 32-bit Masks".

Mnemonic : KXORD Supported forms : (1 form)

  • KXORD k, k, k [AVX512BW]

func (*Program) KXORQ 

func (self *Program) KXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORQ performs "Bitwise Logical XOR 64-bit Masks".

Mnemonic : KXORQ Supported forms : (1 form)

  • KXORQ k, k, k [AVX512BW]

func (*Program) KXORW 

func (self *Program) KXORW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

KXORW performs "Bitwise Logical XOR 16-bit Masks".

Mnemonic : KXORW Supported forms : (1 form)

  • KXORW k, k, k [AVX512F]

func (*Program) LDDQU 

func (self *Program) LDDQU(v0 interface{}, v1 interface{}) *Instruction

LDDQU performs "Load Unaligned Integer 128 Bits".

Mnemonic : LDDQU Supported forms : (1 form)

  • LDDQU m128, xmm [SSE3]

func (*Program) LDMXCSR 

func (self *Program) LDMXCSR(v0 interface{}) *Instruction

LDMXCSR performs "Load MXCSR Register".

Mnemonic : LDMXCSR Supported forms : (1 form)

  • LDMXCSR m32 [SSE]

func (*Program) LEAL 

func (self *Program) LEAL(v0 interface{}, v1 interface{}) *Instruction

LEAL performs "Load Effective Address".

Mnemonic : LEA Supported forms : (1 form)

  • LEAL m, r32

func (*Program) LEAQ 

func (self *Program) LEAQ(v0 interface{}, v1 interface{}) *Instruction

LEAQ performs "Load Effective Address".

Mnemonic : LEA Supported forms : (1 form)

  • LEAQ m, r64

func (*Program) LEAW 

func (self *Program) LEAW(v0 interface{}, v1 interface{}) *Instruction

LEAW performs "Load Effective Address".

Mnemonic : LEA Supported forms : (1 form)

  • LEAW m, r16

func (*Program) LFENCE 

func (self *Program) LFENCE() *Instruction

LFENCE performs "Load Fence".

Mnemonic : LFENCE Supported forms : (1 form)

  • LFENCE [SSE2]

func (*Program) LZCNTL 

func (self *Program) LZCNTL(v0 interface{}, v1 interface{}) *Instruction

LZCNTL performs "Count the Number of Leading Zero Bits".

Mnemonic : LZCNT Supported forms : (2 forms)

  • LZCNTL r32, r32 [LZCNT]
  • LZCNTL m32, r32 [LZCNT]

func (*Program) LZCNTQ 

func (self *Program) LZCNTQ(v0 interface{}, v1 interface{}) *Instruction

LZCNTQ performs "Count the Number of Leading Zero Bits".

Mnemonic : LZCNT Supported forms : (2 forms)

  • LZCNTQ r64, r64 [LZCNT]
  • LZCNTQ m64, r64 [LZCNT]

func (*Program) LZCNTW 

func (self *Program) LZCNTW(v0 interface{}, v1 interface{}) *Instruction

LZCNTW performs "Count the Number of Leading Zero Bits".

Mnemonic : LZCNT Supported forms : (2 forms)

  • LZCNTW r16, r16 [LZCNT]
  • LZCNTW m16, r16 [LZCNT]
func (self *Program) Link(p *Label)

Link pins a label at the current position.

func (*Program) Long 

func (self *Program) Long(v *expr.Expr) (p *Instruction)

Long is a pseudo-instruction to add raw uint32 as little-endian to the assembled code.

func (*Program) MASKMOVDQU 

func (self *Program) MASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction

MASKMOVDQU performs "Store Selected Bytes of Double Quadword".

Mnemonic : MASKMOVDQU Supported forms : (1 form)

  • MASKMOVDQU xmm, xmm [SSE2]

func (*Program) MASKMOVQ 

func (self *Program) MASKMOVQ(v0 interface{}, v1 interface{}) *Instruction

MASKMOVQ performs "Store Selected Bytes of Quadword".

Mnemonic : MASKMOVQ Supported forms : (1 form)

  • MASKMOVQ mm, mm [MMX+]

func (*Program) MAXPD 

func (self *Program) MAXPD(v0 interface{}, v1 interface{}) *Instruction

MAXPD performs "Return Maximum Packed Double-Precision Floating-Point Values".

Mnemonic : MAXPD Supported forms : (2 forms)

  • MAXPD xmm, xmm [SSE2]
  • MAXPD m128, xmm [SSE2]

func (*Program) MAXPS 

func (self *Program) MAXPS(v0 interface{}, v1 interface{}) *Instruction

MAXPS performs "Return Maximum Packed Single-Precision Floating-Point Values".

Mnemonic : MAXPS Supported forms : (2 forms)

  • MAXPS xmm, xmm [SSE]
  • MAXPS m128, xmm [SSE]

func (*Program) MAXSD 

func (self *Program) MAXSD(v0 interface{}, v1 interface{}) *Instruction

MAXSD performs "Return Maximum Scalar Double-Precision Floating-Point Value".

Mnemonic : MAXSD Supported forms : (2 forms)

  • MAXSD xmm, xmm [SSE2]
  • MAXSD m64, xmm [SSE2]

func (*Program) MAXSS 

func (self *Program) MAXSS(v0 interface{}, v1 interface{}) *Instruction

MAXSS performs "Return Maximum Scalar Single-Precision Floating-Point Value".

Mnemonic : MAXSS Supported forms : (2 forms)

  • MAXSS xmm, xmm [SSE]
  • MAXSS m32, xmm [SSE]

func (*Program) MFENCE 

func (self *Program) MFENCE() *Instruction

MFENCE performs "Memory Fence".

Mnemonic : MFENCE Supported forms : (1 form)

  • MFENCE [SSE2]

func (*Program) MINPD 

func (self *Program) MINPD(v0 interface{}, v1 interface{}) *Instruction

MINPD performs "Return Minimum Packed Double-Precision Floating-Point Values".

Mnemonic : MINPD Supported forms : (2 forms)

  • MINPD xmm, xmm [SSE2]
  • MINPD m128, xmm [SSE2]

func (*Program) MINPS 

func (self *Program) MINPS(v0 interface{}, v1 interface{}) *Instruction

MINPS performs "Return Minimum Packed Single-Precision Floating-Point Values".

Mnemonic : MINPS Supported forms : (2 forms)

  • MINPS xmm, xmm [SSE]
  • MINPS m128, xmm [SSE]

func (*Program) MINSD 

func (self *Program) MINSD(v0 interface{}, v1 interface{}) *Instruction

MINSD performs "Return Minimum Scalar Double-Precision Floating-Point Value".

Mnemonic : MINSD Supported forms : (2 forms)

  • MINSD xmm, xmm [SSE2]
  • MINSD m64, xmm [SSE2]

func (*Program) MINSS 

func (self *Program) MINSS(v0 interface{}, v1 interface{}) *Instruction

MINSS performs "Return Minimum Scalar Single-Precision Floating-Point Value".

Mnemonic : MINSS Supported forms : (2 forms)

  • MINSS xmm, xmm [SSE]
  • MINSS m32, xmm [SSE]

func (*Program) MONITOR 

func (self *Program) MONITOR() *Instruction

MONITOR performs "Monitor a Linear Address Range".

Mnemonic : MONITOR Supported forms : (1 form)

  • MONITOR [MONITOR]

func (*Program) MONITORX 

func (self *Program) MONITORX() *Instruction

MONITORX performs "Monitor a Linear Address Range with Timeout".

Mnemonic : MONITORX Supported forms : (1 form)

  • MONITORX [MONITORX]

func (*Program) MOVAPD 

func (self *Program) MOVAPD(v0 interface{}, v1 interface{}) *Instruction

MOVAPD performs "Move Aligned Packed Double-Precision Floating-Point Values".

Mnemonic : MOVAPD Supported forms : (3 forms)

  • MOVAPD xmm, xmm [SSE2]
  • MOVAPD m128, xmm [SSE2]
  • MOVAPD xmm, m128 [SSE2]

func (*Program) MOVAPS 

func (self *Program) MOVAPS(v0 interface{}, v1 interface{}) *Instruction

MOVAPS performs "Move Aligned Packed Single-Precision Floating-Point Values".

Mnemonic : MOVAPS Supported forms : (3 forms)

  • MOVAPS xmm, xmm [SSE]
  • MOVAPS m128, xmm [SSE]
  • MOVAPS xmm, m128 [SSE]

func (*Program) MOVB 

func (self *Program) MOVB(v0 interface{}, v1 interface{}) *Instruction

MOVB performs "Move".

Mnemonic : MOV Supported forms : (5 forms)

  • MOVB imm8, r8
  • MOVB r8, r8
  • MOVB m8, r8
  • MOVB imm8, m8
  • MOVB r8, m8

func (*Program) MOVBEL 

func (self *Program) MOVBEL(v0 interface{}, v1 interface{}) *Instruction

MOVBEL performs "Move Data After Swapping Bytes".

Mnemonic : MOVBE Supported forms : (2 forms)

  • MOVBEL m32, r32 [MOVBE]
  • MOVBEL r32, m32 [MOVBE]

func (*Program) MOVBEQ 

func (self *Program) MOVBEQ(v0 interface{}, v1 interface{}) *Instruction

MOVBEQ performs "Move Data After Swapping Bytes".

Mnemonic : MOVBE Supported forms : (2 forms)

  • MOVBEQ m64, r64 [MOVBE]
  • MOVBEQ r64, m64 [MOVBE]

func (*Program) MOVBEW 

func (self *Program) MOVBEW(v0 interface{}, v1 interface{}) *Instruction

MOVBEW performs "Move Data After Swapping Bytes".

Mnemonic : MOVBE Supported forms : (2 forms)

  • MOVBEW m16, r16 [MOVBE]
  • MOVBEW r16, m16 [MOVBE]

func (*Program) MOVD 

func (self *Program) MOVD(v0 interface{}, v1 interface{}) *Instruction

MOVD performs "Move Doubleword".

Mnemonic : MOVD Supported forms : (8 forms)

  • MOVD mm, r32 [MMX]
  • MOVD r32, mm [MMX]
  • MOVD m32, mm [MMX]
  • MOVD mm, m32 [MMX]
  • MOVD xmm, r32 [SSE2]
  • MOVD r32, xmm [SSE2]
  • MOVD m32, xmm [SSE2]
  • MOVD xmm, m32 [SSE2]

func (*Program) MOVDDUP 

func (self *Program) MOVDDUP(v0 interface{}, v1 interface{}) *Instruction

MOVDDUP performs "Move One Double-FP and Duplicate".

Mnemonic : MOVDDUP Supported forms : (2 forms)

  • MOVDDUP xmm, xmm [SSE3]
  • MOVDDUP m64, xmm [SSE3]

func (*Program) MOVDQ2Q 

func (self *Program) MOVDQ2Q(v0 interface{}, v1 interface{}) *Instruction

MOVDQ2Q performs "Move Quadword from XMM to MMX Technology Register".

Mnemonic : MOVDQ2Q Supported forms : (1 form)

  • MOVDQ2Q xmm, mm [SSE2]

func (*Program) MOVDQA 

func (self *Program) MOVDQA(v0 interface{}, v1 interface{}) *Instruction

MOVDQA performs "Move Aligned Double Quadword".

Mnemonic : MOVDQA Supported forms : (3 forms)

  • MOVDQA xmm, xmm [SSE2]
  • MOVDQA m128, xmm [SSE2]
  • MOVDQA xmm, m128 [SSE2]

func (*Program) MOVDQU 

func (self *Program) MOVDQU(v0 interface{}, v1 interface{}) *Instruction

MOVDQU performs "Move Unaligned Double Quadword".

Mnemonic : MOVDQU Supported forms : (3 forms)

  • MOVDQU xmm, xmm [SSE2]
  • MOVDQU m128, xmm [SSE2]
  • MOVDQU xmm, m128 [SSE2]

func (*Program) MOVHLPS 

func (self *Program) MOVHLPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : MOVHLPS Supported forms : (1 form)

  • MOVHLPS xmm, xmm [SSE]

func (*Program) MOVHPD 

func (self *Program) MOVHPD(v0 interface{}, v1 interface{}) *Instruction

MOVHPD performs "Move High Packed Double-Precision Floating-Point Value".

Mnemonic : MOVHPD Supported forms : (2 forms)

  • MOVHPD m64, xmm [SSE2]
  • MOVHPD xmm, m64 [SSE2]

func (*Program) MOVHPS 

func (self *Program) MOVHPS(v0 interface{}, v1 interface{}) *Instruction

MOVHPS performs "Move High Packed Single-Precision Floating-Point Values".

Mnemonic : MOVHPS Supported forms : (2 forms)

  • MOVHPS m64, xmm [SSE]
  • MOVHPS xmm, m64 [SSE]

func (*Program) MOVL 

func (self *Program) MOVL(v0 interface{}, v1 interface{}) *Instruction

MOVL performs "Move".

Mnemonic : MOV Supported forms : (5 forms)

  • MOVL imm32, r32
  • MOVL r32, r32
  • MOVL m32, r32
  • MOVL imm32, m32
  • MOVL r32, m32

func (*Program) MOVLHPS 

func (self *Program) MOVLHPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : MOVLHPS Supported forms : (1 form)

  • MOVLHPS xmm, xmm [SSE]

func (*Program) MOVLPD 

func (self *Program) MOVLPD(v0 interface{}, v1 interface{}) *Instruction

MOVLPD performs "Move Low Packed Double-Precision Floating-Point Value".

Mnemonic : MOVLPD Supported forms : (2 forms)

  • MOVLPD m64, xmm [SSE2]
  • MOVLPD xmm, m64 [SSE2]

func (*Program) MOVLPS 

func (self *Program) MOVLPS(v0 interface{}, v1 interface{}) *Instruction

MOVLPS performs "Move Low Packed Single-Precision Floating-Point Values".

Mnemonic : MOVLPS Supported forms : (2 forms)

  • MOVLPS m64, xmm [SSE]
  • MOVLPS xmm, m64 [SSE]

func (*Program) MOVMSKPD 

func (self *Program) MOVMSKPD(v0 interface{}, v1 interface{}) *Instruction

MOVMSKPD performs "Extract Packed Double-Precision Floating-Point Sign Mask".

Mnemonic : MOVMSKPD Supported forms : (1 form)

  • MOVMSKPD xmm, r32 [SSE2]

func (*Program) MOVMSKPS 

func (self *Program) MOVMSKPS(v0 interface{}, v1 interface{}) *Instruction

MOVMSKPS performs "Extract Packed Single-Precision Floating-Point Sign Mask".

Mnemonic : MOVMSKPS Supported forms : (1 form)

  • MOVMSKPS xmm, r32 [SSE]

func (*Program) MOVNTDQ 

func (self *Program) MOVNTDQ(v0 interface{}, v1 interface{}) *Instruction

MOVNTDQ performs "Store Double Quadword Using Non-Temporal Hint".

Mnemonic : MOVNTDQ Supported forms : (1 form)

  • MOVNTDQ xmm, m128 [SSE2]

func (*Program) MOVNTDQA 

func (self *Program) MOVNTDQA(v0 interface{}, v1 interface{}) *Instruction

MOVNTDQA performs "Load Double Quadword Non-Temporal Aligned Hint".

Mnemonic : MOVNTDQA Supported forms : (1 form)

  • MOVNTDQA m128, xmm [SSE4.1]

func (*Program) MOVNTIL 

func (self *Program) MOVNTIL(v0 interface{}, v1 interface{}) *Instruction

MOVNTIL performs "Store Doubleword Using Non-Temporal Hint".

Mnemonic : MOVNTI Supported forms : (1 form)

  • MOVNTIL r32, m32 [SSE2]

func (*Program) MOVNTIQ 

func (self *Program) MOVNTIQ(v0 interface{}, v1 interface{}) *Instruction

MOVNTIQ performs "Store Doubleword Using Non-Temporal Hint".

Mnemonic : MOVNTI Supported forms : (1 form)

  • MOVNTIQ r64, m64 [SSE2]

func (*Program) MOVNTPD 

func (self *Program) MOVNTPD(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : MOVNTPD Supported forms : (1 form)

  • MOVNTPD xmm, m128 [SSE2]

func (*Program) MOVNTPS 

func (self *Program) MOVNTPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : MOVNTPS Supported forms : (1 form)

  • MOVNTPS xmm, m128 [SSE]

func (*Program) MOVNTQ 

func (self *Program) MOVNTQ(v0 interface{}, v1 interface{}) *Instruction

MOVNTQ performs "Store of Quadword Using Non-Temporal Hint".

Mnemonic : MOVNTQ Supported forms : (1 form)

  • MOVNTQ mm, m64 [MMX+]

func (*Program) MOVNTSD 

func (self *Program) MOVNTSD(v0 interface{}, v1 interface{}) *Instruction

MOVNTSD performs "Store Scalar Double-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : MOVNTSD Supported forms : (1 form)

  • MOVNTSD xmm, m64 [SSE4A]

func (*Program) MOVNTSS 

func (self *Program) MOVNTSS(v0 interface{}, v1 interface{}) *Instruction

MOVNTSS performs "Store Scalar Single-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : MOVNTSS Supported forms : (1 form)

  • MOVNTSS xmm, m32 [SSE4A]

func (*Program) MOVQ 

func (self *Program) MOVQ(v0 interface{}, v1 interface{}) *Instruction

MOVQ performs "Move".

Mnemonic : MOV Supported forms : (16 forms)

  • MOVQ imm32, r64
  • MOVQ imm64, r64
  • MOVQ r64, r64
  • MOVQ m64, r64
  • MOVQ imm32, m64
  • MOVQ r64, m64
  • MOVQ mm, r64 [MMX]
  • MOVQ r64, mm [MMX]
  • MOVQ mm, mm [MMX]
  • MOVQ m64, mm [MMX]
  • MOVQ mm, m64 [MMX]
  • MOVQ xmm, r64 [SSE2]
  • MOVQ r64, xmm [SSE2]
  • MOVQ xmm, xmm [SSE2]
  • MOVQ m64, xmm [SSE2]
  • MOVQ xmm, m64 [SSE2]

func (*Program) MOVQ2DQ 

func (self *Program) MOVQ2DQ(v0 interface{}, v1 interface{}) *Instruction

MOVQ2DQ performs "Move Quadword from MMX Technology to XMM Register".

Mnemonic : MOVQ2DQ Supported forms : (1 form)

  • MOVQ2DQ mm, xmm [SSE2]

func (*Program) MOVSBL 

func (self *Program) MOVSBL(v0 interface{}, v1 interface{}) *Instruction

MOVSBL performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

  • MOVSBL r8, r32
  • MOVSBL m8, r32

func (*Program) MOVSBQ 

func (self *Program) MOVSBQ(v0 interface{}, v1 interface{}) *Instruction

MOVSBQ performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

  • MOVSBQ r8, r64
  • MOVSBQ m8, r64

func (*Program) MOVSBW 

func (self *Program) MOVSBW(v0 interface{}, v1 interface{}) *Instruction

MOVSBW performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

  • MOVSBW r8, r16
  • MOVSBW m8, r16

func (*Program) MOVSD 

func (self *Program) MOVSD(v0 interface{}, v1 interface{}) *Instruction

MOVSD performs "Move Scalar Double-Precision Floating-Point Value".

Mnemonic : MOVSD Supported forms : (3 forms)

  • MOVSD xmm, xmm [SSE2]
  • MOVSD m64, xmm [SSE2]
  • MOVSD xmm, m64 [SSE2]

func (*Program) MOVSHDUP 

func (self *Program) MOVSHDUP(v0 interface{}, v1 interface{}) *Instruction

MOVSHDUP performs "Move Packed Single-FP High and Duplicate".

Mnemonic : MOVSHDUP Supported forms : (2 forms)

  • MOVSHDUP xmm, xmm [SSE3]
  • MOVSHDUP m128, xmm [SSE3]

func (*Program) MOVSLDUP 

func (self *Program) MOVSLDUP(v0 interface{}, v1 interface{}) *Instruction

MOVSLDUP performs "Move Packed Single-FP Low and Duplicate".

Mnemonic : MOVSLDUP Supported forms : (2 forms)

  • MOVSLDUP xmm, xmm [SSE3]
  • MOVSLDUP m128, xmm [SSE3]

func (*Program) MOVSLQ 

func (self *Program) MOVSLQ(v0 interface{}, v1 interface{}) *Instruction

MOVSLQ performs "Move Doubleword to Quadword with Sign-Extension".

Mnemonic : MOVSXD Supported forms : (2 forms)

  • MOVSLQ r32, r64
  • MOVSLQ m32, r64

func (*Program) MOVSS 

func (self *Program) MOVSS(v0 interface{}, v1 interface{}) *Instruction

MOVSS performs "Move Scalar Single-Precision Floating-Point Values".

Mnemonic : MOVSS Supported forms : (3 forms)

  • MOVSS xmm, xmm [SSE]
  • MOVSS m32, xmm [SSE]
  • MOVSS xmm, m32 [SSE]

func (*Program) MOVSWL 

func (self *Program) MOVSWL(v0 interface{}, v1 interface{}) *Instruction

MOVSWL performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

  • MOVSWL r16, r32
  • MOVSWL m16, r32

func (*Program) MOVSWQ 

func (self *Program) MOVSWQ(v0 interface{}, v1 interface{}) *Instruction

MOVSWQ performs "Move with Sign-Extension".

Mnemonic : MOVSX Supported forms : (2 forms)

  • MOVSWQ r16, r64
  • MOVSWQ m16, r64

func (*Program) MOVUPD 

func (self *Program) MOVUPD(v0 interface{}, v1 interface{}) *Instruction

MOVUPD performs "Move Unaligned Packed Double-Precision Floating-Point Values".

Mnemonic : MOVUPD Supported forms : (3 forms)

  • MOVUPD xmm, xmm [SSE2]
  • MOVUPD m128, xmm [SSE2]
  • MOVUPD xmm, m128 [SSE2]

func (*Program) MOVUPS 

func (self *Program) MOVUPS(v0 interface{}, v1 interface{}) *Instruction

MOVUPS performs "Move Unaligned Packed Single-Precision Floating-Point Values".

Mnemonic : MOVUPS Supported forms : (3 forms)

  • MOVUPS xmm, xmm [SSE]
  • MOVUPS m128, xmm [SSE]
  • MOVUPS xmm, m128 [SSE]

func (*Program) MOVW 

func (self *Program) MOVW(v0 interface{}, v1 interface{}) *Instruction

MOVW performs "Move".

Mnemonic : MOV Supported forms : (5 forms)

  • MOVW imm16, r16
  • MOVW r16, r16
  • MOVW m16, r16
  • MOVW imm16, m16
  • MOVW r16, m16

func (*Program) MOVZBL 

func (self *Program) MOVZBL(v0 interface{}, v1 interface{}) *Instruction

MOVZBL performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

  • MOVZBL r8, r32
  • MOVZBL m8, r32

func (*Program) MOVZBQ 

func (self *Program) MOVZBQ(v0 interface{}, v1 interface{}) *Instruction

MOVZBQ performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

  • MOVZBQ r8, r64
  • MOVZBQ m8, r64

func (*Program) MOVZBW 

func (self *Program) MOVZBW(v0 interface{}, v1 interface{}) *Instruction

MOVZBW performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

  • MOVZBW r8, r16
  • MOVZBW m8, r16

func (*Program) MOVZWL 

func (self *Program) MOVZWL(v0 interface{}, v1 interface{}) *Instruction

MOVZWL performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

  • MOVZWL r16, r32
  • MOVZWL m16, r32

func (*Program) MOVZWQ 

func (self *Program) MOVZWQ(v0 interface{}, v1 interface{}) *Instruction

MOVZWQ performs "Move with Zero-Extend".

Mnemonic : MOVZX Supported forms : (2 forms)

  • MOVZWQ r16, r64
  • MOVZWQ m16, r64

func (*Program) MPSADBW 

func (self *Program) MPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

MPSADBW performs "Compute Multiple Packed Sums of Absolute Difference".

Mnemonic : MPSADBW Supported forms : (2 forms)

  • MPSADBW imm8, xmm, xmm [SSE4.1]
  • MPSADBW imm8, m128, xmm [SSE4.1]

func (*Program) MULB 

func (self *Program) MULB(v0 interface{}) *Instruction

MULB performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

  • MULB r8
  • MULB m8

func (*Program) MULL 

func (self *Program) MULL(v0 interface{}) *Instruction

MULL performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

  • MULL r32
  • MULL m32

func (*Program) MULPD 

func (self *Program) MULPD(v0 interface{}, v1 interface{}) *Instruction

MULPD performs "Multiply Packed Double-Precision Floating-Point Values".

Mnemonic : MULPD Supported forms : (2 forms)

  • MULPD xmm, xmm [SSE2]
  • MULPD m128, xmm [SSE2]

func (*Program) MULPS 

func (self *Program) MULPS(v0 interface{}, v1 interface{}) *Instruction

MULPS performs "Multiply Packed Single-Precision Floating-Point Values".

Mnemonic : MULPS Supported forms : (2 forms)

  • MULPS xmm, xmm [SSE]
  • MULPS m128, xmm [SSE]

func (*Program) MULQ 

func (self *Program) MULQ(v0 interface{}) *Instruction

MULQ performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

  • MULQ r64
  • MULQ m64

func (*Program) MULSD 

func (self *Program) MULSD(v0 interface{}, v1 interface{}) *Instruction

MULSD performs "Multiply Scalar Double-Precision Floating-Point Values".

Mnemonic : MULSD Supported forms : (2 forms)

  • MULSD xmm, xmm [SSE2]
  • MULSD m64, xmm [SSE2]

func (*Program) MULSS 

func (self *Program) MULSS(v0 interface{}, v1 interface{}) *Instruction

MULSS performs "Multiply Scalar Single-Precision Floating-Point Values".

Mnemonic : MULSS Supported forms : (2 forms)

  • MULSS xmm, xmm [SSE]
  • MULSS m32, xmm [SSE]

func (*Program) MULW 

func (self *Program) MULW(v0 interface{}) *Instruction

MULW performs "Unsigned Multiply".

Mnemonic : MUL Supported forms : (2 forms)

  • MULW r16
  • MULW m16

func (*Program) MULXL 

func (self *Program) MULXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

MULXL performs "Unsigned Multiply Without Affecting Flags".

Mnemonic : MULX Supported forms : (2 forms)

  • MULXL r32, r32, r32 [BMI2]
  • MULXL m32, r32, r32 [BMI2]

func (*Program) MULXQ 

func (self *Program) MULXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

MULXQ performs "Unsigned Multiply Without Affecting Flags".

Mnemonic : MULX Supported forms : (2 forms)

  • MULXQ r64, r64, r64 [BMI2]
  • MULXQ m64, r64, r64 [BMI2]

func (*Program) MWAIT 

func (self *Program) MWAIT() *Instruction

MWAIT performs "Monitor Wait".

Mnemonic : MWAIT Supported forms : (1 form)

  • MWAIT [MONITOR]

func (*Program) MWAITX 

func (self *Program) MWAITX() *Instruction

MWAITX performs "Monitor Wait with Timeout".

Mnemonic : MWAITX Supported forms : (1 form)

  • MWAITX [MONITORX]

func (*Program) NEGB 

func (self *Program) NEGB(v0 interface{}) *Instruction

NEGB performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

  • NEGB r8
  • NEGB m8

func (*Program) NEGL 

func (self *Program) NEGL(v0 interface{}) *Instruction

NEGL performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

  • NEGL r32
  • NEGL m32

func (*Program) NEGQ 

func (self *Program) NEGQ(v0 interface{}) *Instruction

NEGQ performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

  • NEGQ r64
  • NEGQ m64

func (*Program) NEGW 

func (self *Program) NEGW(v0 interface{}) *Instruction

NEGW performs "Two's Complement Negation".

Mnemonic : NEG Supported forms : (2 forms)

  • NEGW r16
  • NEGW m16

func (*Program) NOP 

func (self *Program) NOP() *Instruction

NOP performs "No Operation".

Mnemonic : NOP Supported forms : (1 form)

  • NOP

func (*Program) NOTB 

func (self *Program) NOTB(v0 interface{}) *Instruction

NOTB performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

  • NOTB r8
  • NOTB m8

func (*Program) NOTL 

func (self *Program) NOTL(v0 interface{}) *Instruction

NOTL performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

  • NOTL r32
  • NOTL m32

func (*Program) NOTQ 

func (self *Program) NOTQ(v0 interface{}) *Instruction

NOTQ performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

  • NOTQ r64
  • NOTQ m64

func (*Program) NOTW 

func (self *Program) NOTW(v0 interface{}) *Instruction

NOTW performs "One's Complement Negation".

Mnemonic : NOT Supported forms : (2 forms)

  • NOTW r16
  • NOTW m16

func (*Program) ORB 

func (self *Program) ORB(v0 interface{}, v1 interface{}) *Instruction

ORB performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (6 forms)

  • ORB imm8, al
  • ORB imm8, r8
  • ORB r8, r8
  • ORB m8, r8
  • ORB imm8, m8
  • ORB r8, m8

func (*Program) ORL 

func (self *Program) ORL(v0 interface{}, v1 interface{}) *Instruction

ORL performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (8 forms)

  • ORL imm32, eax
  • ORL imm8, r32
  • ORL imm32, r32
  • ORL r32, r32
  • ORL m32, r32
  • ORL imm8, m32
  • ORL imm32, m32
  • ORL r32, m32

func (*Program) ORPD 

func (self *Program) ORPD(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : ORPD Supported forms : (2 forms)

  • ORPD xmm, xmm [SSE2]
  • ORPD m128, xmm [SSE2]

func (*Program) ORPS 

func (self *Program) ORPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : ORPS Supported forms : (2 forms)

  • ORPS xmm, xmm [SSE]
  • ORPS m128, xmm [SSE]

func (*Program) ORQ 

func (self *Program) ORQ(v0 interface{}, v1 interface{}) *Instruction

ORQ performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (8 forms)

  • ORQ imm32, rax
  • ORQ imm8, r64
  • ORQ imm32, r64
  • ORQ r64, r64
  • ORQ m64, r64
  • ORQ imm8, m64
  • ORQ imm32, m64
  • ORQ r64, m64

func (*Program) ORW 

func (self *Program) ORW(v0 interface{}, v1 interface{}) *Instruction

ORW performs "Logical Inclusive OR".

Mnemonic : OR Supported forms : (8 forms)

  • ORW imm16, ax
  • ORW imm8, r16
  • ORW imm16, r16
  • ORW r16, r16
  • ORW m16, r16
  • ORW imm8, m16
  • ORW imm16, m16
  • ORW r16, m16

func (*Program) PABSB 

func (self *Program) PABSB(v0 interface{}, v1 interface{}) *Instruction

PABSB performs "Packed Absolute Value of Byte Integers".

Mnemonic : PABSB Supported forms : (4 forms)

  • PABSB mm, mm [SSSE3]
  • PABSB m64, mm [SSSE3]
  • PABSB xmm, xmm [SSSE3]
  • PABSB m128, xmm [SSSE3]

func (*Program) PABSD 

func (self *Program) PABSD(v0 interface{}, v1 interface{}) *Instruction

PABSD performs "Packed Absolute Value of Doubleword Integers".

Mnemonic : PABSD Supported forms : (4 forms)

  • PABSD mm, mm [SSSE3]
  • PABSD m64, mm [SSSE3]
  • PABSD xmm, xmm [SSSE3]
  • PABSD m128, xmm [SSSE3]

func (*Program) PABSW 

func (self *Program) PABSW(v0 interface{}, v1 interface{}) *Instruction

PABSW performs "Packed Absolute Value of Word Integers".

Mnemonic : PABSW Supported forms : (4 forms)

  • PABSW mm, mm [SSSE3]
  • PABSW m64, mm [SSSE3]
  • PABSW xmm, xmm [SSSE3]
  • PABSW m128, xmm [SSSE3]

func (*Program) PACKSSDW 

func (self *Program) PACKSSDW(v0 interface{}, v1 interface{}) *Instruction

PACKSSDW performs "Pack Doublewords into Words with Signed Saturation".

Mnemonic : PACKSSDW Supported forms : (4 forms)

  • PACKSSDW mm, mm [MMX]
  • PACKSSDW m64, mm [MMX]
  • PACKSSDW xmm, xmm [SSE2]
  • PACKSSDW m128, xmm [SSE2]

func (*Program) PACKSSWB 

func (self *Program) PACKSSWB(v0 interface{}, v1 interface{}) *Instruction

PACKSSWB performs "Pack Words into Bytes with Signed Saturation".

Mnemonic : PACKSSWB Supported forms : (4 forms)

  • PACKSSWB mm, mm [MMX]
  • PACKSSWB m64, mm [MMX]
  • PACKSSWB xmm, xmm [SSE2]
  • PACKSSWB m128, xmm [SSE2]

func (*Program) PACKUSDW 

func (self *Program) PACKUSDW(v0 interface{}, v1 interface{}) *Instruction

PACKUSDW performs "Pack Doublewords into Words with Unsigned Saturation".

Mnemonic : PACKUSDW Supported forms : (2 forms)

  • PACKUSDW xmm, xmm [SSE4.1]
  • PACKUSDW m128, xmm [SSE4.1]

func (*Program) PACKUSWB 

func (self *Program) PACKUSWB(v0 interface{}, v1 interface{}) *Instruction

PACKUSWB performs "Pack Words into Bytes with Unsigned Saturation".

Mnemonic : PACKUSWB Supported forms : (4 forms)

  • PACKUSWB mm, mm [MMX]
  • PACKUSWB m64, mm [MMX]
  • PACKUSWB xmm, xmm [SSE2]
  • PACKUSWB m128, xmm [SSE2]

func (*Program) PADDB 

func (self *Program) PADDB(v0 interface{}, v1 interface{}) *Instruction

PADDB performs "Add Packed Byte Integers".

Mnemonic : PADDB Supported forms : (4 forms)

  • PADDB mm, mm [MMX]
  • PADDB m64, mm [MMX]
  • PADDB xmm, xmm [SSE2]
  • PADDB m128, xmm [SSE2]

func (*Program) PADDD 

func (self *Program) PADDD(v0 interface{}, v1 interface{}) *Instruction

PADDD performs "Add Packed Doubleword Integers".

Mnemonic : PADDD Supported forms : (4 forms)

  • PADDD mm, mm [MMX]
  • PADDD m64, mm [MMX]
  • PADDD xmm, xmm [SSE2]
  • PADDD m128, xmm [SSE2]

func (*Program) PADDQ 

func (self *Program) PADDQ(v0 interface{}, v1 interface{}) *Instruction

PADDQ performs "Add Packed Quadword Integers".

Mnemonic : PADDQ Supported forms : (4 forms)

  • PADDQ mm, mm [SSE2]
  • PADDQ m64, mm [SSE2]
  • PADDQ xmm, xmm [SSE2]
  • PADDQ m128, xmm [SSE2]

func (*Program) PADDSB 

func (self *Program) PADDSB(v0 interface{}, v1 interface{}) *Instruction

PADDSB performs "Add Packed Signed Byte Integers with Signed Saturation".

Mnemonic : PADDSB Supported forms : (4 forms)

  • PADDSB mm, mm [MMX]
  • PADDSB m64, mm [MMX]
  • PADDSB xmm, xmm [SSE2]
  • PADDSB m128, xmm [SSE2]

func (*Program) PADDSW 

func (self *Program) PADDSW(v0 interface{}, v1 interface{}) *Instruction

PADDSW performs "Add Packed Signed Word Integers with Signed Saturation".

Mnemonic : PADDSW Supported forms : (4 forms)

  • PADDSW mm, mm [MMX]
  • PADDSW m64, mm [MMX]
  • PADDSW xmm, xmm [SSE2]
  • PADDSW m128, xmm [SSE2]

func (*Program) PADDUSB 

func (self *Program) PADDUSB(v0 interface{}, v1 interface{}) *Instruction

PADDUSB performs "Add Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : PADDUSB Supported forms : (4 forms)

  • PADDUSB mm, mm [MMX]
  • PADDUSB m64, mm [MMX]
  • PADDUSB xmm, xmm [SSE2]
  • PADDUSB m128, xmm [SSE2]

func (*Program) PADDUSW 

func (self *Program) PADDUSW(v0 interface{}, v1 interface{}) *Instruction

PADDUSW performs "Add Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : PADDUSW Supported forms : (4 forms)

  • PADDUSW mm, mm [MMX]
  • PADDUSW m64, mm [MMX]
  • PADDUSW xmm, xmm [SSE2]
  • PADDUSW m128, xmm [SSE2]

func (*Program) PADDW 

func (self *Program) PADDW(v0 interface{}, v1 interface{}) *Instruction

PADDW performs "Add Packed Word Integers".

Mnemonic : PADDW Supported forms : (4 forms)

  • PADDW mm, mm [MMX]
  • PADDW m64, mm [MMX]
  • PADDW xmm, xmm [SSE2]
  • PADDW m128, xmm [SSE2]

func (*Program) PALIGNR 

func (self *Program) PALIGNR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PALIGNR performs "Packed Align Right".

Mnemonic : PALIGNR Supported forms : (4 forms)

  • PALIGNR imm8, mm, mm [SSSE3]
  • PALIGNR imm8, m64, mm [SSSE3]
  • PALIGNR imm8, xmm, xmm [SSSE3]
  • PALIGNR imm8, m128, xmm [SSSE3]

func (*Program) PAND 

func (self *Program) PAND(v0 interface{}, v1 interface{}) *Instruction

PAND performs "Packed Bitwise Logical AND".

Mnemonic : PAND Supported forms : (4 forms)

  • PAND mm, mm [MMX]
  • PAND m64, mm [MMX]
  • PAND xmm, xmm [SSE2]
  • PAND m128, xmm [SSE2]

func (*Program) PANDN 

func (self *Program) PANDN(v0 interface{}, v1 interface{}) *Instruction

PANDN performs "Packed Bitwise Logical AND NOT".

Mnemonic : PANDN Supported forms : (4 forms)

  • PANDN mm, mm [MMX]
  • PANDN m64, mm [MMX]
  • PANDN xmm, xmm [SSE2]
  • PANDN m128, xmm [SSE2]

func (*Program) PAUSE 

func (self *Program) PAUSE() *Instruction

PAUSE performs "Spin Loop Hint".

Mnemonic : PAUSE Supported forms : (1 form)

  • PAUSE

func (*Program) PAVGB 

func (self *Program) PAVGB(v0 interface{}, v1 interface{}) *Instruction

PAVGB performs "Average Packed Byte Integers".

Mnemonic : PAVGB Supported forms : (4 forms)

  • PAVGB mm, mm [MMX+]
  • PAVGB m64, mm [MMX+]
  • PAVGB xmm, xmm [SSE2]
  • PAVGB m128, xmm [SSE2]

func (*Program) PAVGUSB 

func (self *Program) PAVGUSB(v0 interface{}, v1 interface{}) *Instruction

PAVGUSB performs "Average Packed Byte Integers".

Mnemonic : PAVGUSB Supported forms : (2 forms)

  • PAVGUSB mm, mm [3dnow!]
  • PAVGUSB m64, mm [3dnow!]

func (*Program) PAVGW 

func (self *Program) PAVGW(v0 interface{}, v1 interface{}) *Instruction

PAVGW performs "Average Packed Word Integers".

Mnemonic : PAVGW Supported forms : (4 forms)

  • PAVGW mm, mm [MMX+]
  • PAVGW m64, mm [MMX+]
  • PAVGW xmm, xmm [SSE2]
  • PAVGW m128, xmm [SSE2]

func (*Program) PBLENDVB 

func (self *Program) PBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PBLENDVB performs "Variable Blend Packed Bytes".

Mnemonic : PBLENDVB Supported forms : (2 forms)

  • PBLENDVB xmm0, xmm, xmm [SSE4.1]
  • PBLENDVB xmm0, m128, xmm [SSE4.1]

func (*Program) PBLENDW 

func (self *Program) PBLENDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PBLENDW performs "Blend Packed Words".

Mnemonic : PBLENDW Supported forms : (2 forms)

  • PBLENDW imm8, xmm, xmm [SSE4.1]
  • PBLENDW imm8, m128, xmm [SSE4.1]

func (*Program) PCLMULQDQ 

func (self *Program) PCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCLMULQDQ performs "Carry-Less Quadword Multiplication".

Mnemonic : PCLMULQDQ Supported forms : (2 forms)

  • PCLMULQDQ imm8, xmm, xmm [PCLMULQDQ]
  • PCLMULQDQ imm8, m128, xmm [PCLMULQDQ]

func (*Program) PCMPEQB 

func (self *Program) PCMPEQB(v0 interface{}, v1 interface{}) *Instruction

PCMPEQB performs "Compare Packed Byte Data for Equality".

Mnemonic : PCMPEQB Supported forms : (4 forms)

  • PCMPEQB mm, mm [MMX]
  • PCMPEQB m64, mm [MMX]
  • PCMPEQB xmm, xmm [SSE2]
  • PCMPEQB m128, xmm [SSE2]

func (*Program) PCMPEQD 

func (self *Program) PCMPEQD(v0 interface{}, v1 interface{}) *Instruction

PCMPEQD performs "Compare Packed Doubleword Data for Equality".

Mnemonic : PCMPEQD Supported forms : (4 forms)

  • PCMPEQD mm, mm [MMX]
  • PCMPEQD m64, mm [MMX]
  • PCMPEQD xmm, xmm [SSE2]
  • PCMPEQD m128, xmm [SSE2]

func (*Program) PCMPEQQ 

func (self *Program) PCMPEQQ(v0 interface{}, v1 interface{}) *Instruction

PCMPEQQ performs "Compare Packed Quadword Data for Equality".

Mnemonic : PCMPEQQ Supported forms : (2 forms)

  • PCMPEQQ xmm, xmm [SSE4.1]
  • PCMPEQQ m128, xmm [SSE4.1]

func (*Program) PCMPEQW 

func (self *Program) PCMPEQW(v0 interface{}, v1 interface{}) *Instruction

PCMPEQW performs "Compare Packed Word Data for Equality".

Mnemonic : PCMPEQW Supported forms : (4 forms)

  • PCMPEQW mm, mm [MMX]
  • PCMPEQW m64, mm [MMX]
  • PCMPEQW xmm, xmm [SSE2]
  • PCMPEQW m128, xmm [SSE2]

func (*Program) PCMPESTRI 

func (self *Program) PCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPESTRI performs "Packed Compare Explicit Length Strings, Return Index".

Mnemonic : PCMPESTRI Supported forms : (2 forms)

  • PCMPESTRI imm8, xmm, xmm [SSE4.2]
  • PCMPESTRI imm8, m128, xmm [SSE4.2]

func (*Program) PCMPESTRM 

func (self *Program) PCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPESTRM performs "Packed Compare Explicit Length Strings, Return Mask".

Mnemonic : PCMPESTRM Supported forms : (2 forms)

  • PCMPESTRM imm8, xmm, xmm [SSE4.2]
  • PCMPESTRM imm8, m128, xmm [SSE4.2]

func (*Program) PCMPGTB 

func (self *Program) PCMPGTB(v0 interface{}, v1 interface{}) *Instruction

PCMPGTB performs "Compare Packed Signed Byte Integers for Greater Than".

Mnemonic : PCMPGTB Supported forms : (4 forms)

  • PCMPGTB mm, mm [MMX]
  • PCMPGTB m64, mm [MMX]
  • PCMPGTB xmm, xmm [SSE2]
  • PCMPGTB m128, xmm [SSE2]

func (*Program) PCMPGTD 

func (self *Program) PCMPGTD(v0 interface{}, v1 interface{}) *Instruction

PCMPGTD performs "Compare Packed Signed Doubleword Integers for Greater Than".

Mnemonic : PCMPGTD Supported forms : (4 forms)

  • PCMPGTD mm, mm [MMX]
  • PCMPGTD m64, mm [MMX]
  • PCMPGTD xmm, xmm [SSE2]
  • PCMPGTD m128, xmm [SSE2]

func (*Program) PCMPGTQ 

func (self *Program) PCMPGTQ(v0 interface{}, v1 interface{}) *Instruction

PCMPGTQ performs "Compare Packed Data for Greater Than".

Mnemonic : PCMPGTQ Supported forms : (2 forms)

  • PCMPGTQ xmm, xmm [SSE4.2]
  • PCMPGTQ m128, xmm [SSE4.2]

func (*Program) PCMPGTW 

func (self *Program) PCMPGTW(v0 interface{}, v1 interface{}) *Instruction

PCMPGTW performs "Compare Packed Signed Word Integers for Greater Than".

Mnemonic : PCMPGTW Supported forms : (4 forms)

  • PCMPGTW mm, mm [MMX]
  • PCMPGTW m64, mm [MMX]
  • PCMPGTW xmm, xmm [SSE2]
  • PCMPGTW m128, xmm [SSE2]

func (*Program) PCMPISTRI 

func (self *Program) PCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPISTRI performs "Packed Compare Implicit Length Strings, Return Index".

Mnemonic : PCMPISTRI Supported forms : (2 forms)

  • PCMPISTRI imm8, xmm, xmm [SSE4.2]
  • PCMPISTRI imm8, m128, xmm [SSE4.2]

func (*Program) PCMPISTRM 

func (self *Program) PCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PCMPISTRM performs "Packed Compare Implicit Length Strings, Return Mask".

Mnemonic : PCMPISTRM Supported forms : (2 forms)

  • PCMPISTRM imm8, xmm, xmm [SSE4.2]
  • PCMPISTRM imm8, m128, xmm [SSE4.2]

func (*Program) PDEP 

func (self *Program) PDEP(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PDEP performs "Parallel Bits Deposit".

Mnemonic : PDEP Supported forms : (4 forms)

  • PDEP r32, r32, r32 [BMI2]
  • PDEP m32, r32, r32 [BMI2]
  • PDEP r64, r64, r64 [BMI2]
  • PDEP m64, r64, r64 [BMI2]

func (*Program) PEXT 

func (self *Program) PEXT(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXT performs "Parallel Bits Extract".

Mnemonic : PEXT Supported forms : (4 forms)

  • PEXT r32, r32, r32 [BMI2]
  • PEXT m32, r32, r32 [BMI2]
  • PEXT r64, r64, r64 [BMI2]
  • PEXT m64, r64, r64 [BMI2]

func (*Program) PEXTRB 

func (self *Program) PEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRB performs "Extract Byte".

Mnemonic : PEXTRB Supported forms : (2 forms)

  • PEXTRB imm8, xmm, r32 [SSE4.1]
  • PEXTRB imm8, xmm, m8 [SSE4.1]

func (*Program) PEXTRD 

func (self *Program) PEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRD performs "Extract Doubleword".

Mnemonic : PEXTRD Supported forms : (2 forms)

  • PEXTRD imm8, xmm, r32 [SSE4.1]
  • PEXTRD imm8, xmm, m32 [SSE4.1]

func (*Program) PEXTRQ 

func (self *Program) PEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRQ performs "Extract Quadword".

Mnemonic : PEXTRQ Supported forms : (2 forms)

  • PEXTRQ imm8, xmm, r64 [SSE4.1]
  • PEXTRQ imm8, xmm, m64 [SSE4.1]

func (*Program) PEXTRW 

func (self *Program) PEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PEXTRW performs "Extract Word".

Mnemonic : PEXTRW Supported forms : (3 forms)

  • PEXTRW imm8, mm, r32 [MMX+]
  • PEXTRW imm8, xmm, r32 [SSE4.1]
  • PEXTRW imm8, xmm, m16 [SSE4.1]

func (*Program) PF2ID 

func (self *Program) PF2ID(v0 interface{}, v1 interface{}) *Instruction

PF2ID performs "Packed Floating-Point to Integer Doubleword Converson".

Mnemonic : PF2ID Supported forms : (2 forms)

  • PF2ID mm, mm [3dnow!]
  • PF2ID m64, mm [3dnow!]

func (*Program) PF2IW 

func (self *Program) PF2IW(v0 interface{}, v1 interface{}) *Instruction

PF2IW performs "Packed Floating-Point to Integer Word Conversion".

Mnemonic : PF2IW Supported forms : (2 forms)

  • PF2IW mm, mm [3dnow!+]
  • PF2IW m64, mm [3dnow!+]

func (*Program) PFACC 

func (self *Program) PFACC(v0 interface{}, v1 interface{}) *Instruction

PFACC performs "Packed Floating-Point Accumulate".

Mnemonic : PFACC Supported forms : (2 forms)

  • PFACC mm, mm [3dnow!]
  • PFACC m64, mm [3dnow!]

func (*Program) PFADD 

func (self *Program) PFADD(v0 interface{}, v1 interface{}) *Instruction

PFADD performs "Packed Floating-Point Add".

Mnemonic : PFADD Supported forms : (2 forms)

  • PFADD mm, mm [3dnow!]
  • PFADD m64, mm [3dnow!]

func (*Program) PFCMPEQ 

func (self *Program) PFCMPEQ(v0 interface{}, v1 interface{}) *Instruction

PFCMPEQ performs "Packed Floating-Point Compare for Equal".

Mnemonic : PFCMPEQ Supported forms : (2 forms)

  • PFCMPEQ mm, mm [3dnow!]
  • PFCMPEQ m64, mm [3dnow!]

func (*Program) PFCMPGE 

func (self *Program) PFCMPGE(v0 interface{}, v1 interface{}) *Instruction

PFCMPGE performs "Packed Floating-Point Compare for Greater or Equal".

Mnemonic : PFCMPGE Supported forms : (2 forms)

  • PFCMPGE mm, mm [3dnow!]
  • PFCMPGE m64, mm [3dnow!]

func (*Program) PFCMPGT 

func (self *Program) PFCMPGT(v0 interface{}, v1 interface{}) *Instruction

PFCMPGT performs "Packed Floating-Point Compare for Greater Than".

Mnemonic : PFCMPGT Supported forms : (2 forms)

  • PFCMPGT mm, mm [3dnow!]
  • PFCMPGT m64, mm [3dnow!]

func (*Program) PFMAX 

func (self *Program) PFMAX(v0 interface{}, v1 interface{}) *Instruction

PFMAX performs "Packed Floating-Point Maximum".

Mnemonic : PFMAX Supported forms : (2 forms)

  • PFMAX mm, mm [3dnow!]
  • PFMAX m64, mm [3dnow!]

func (*Program) PFMIN 

func (self *Program) PFMIN(v0 interface{}, v1 interface{}) *Instruction

PFMIN performs "Packed Floating-Point Minimum".

Mnemonic : PFMIN Supported forms : (2 forms)

  • PFMIN mm, mm [3dnow!]
  • PFMIN m64, mm [3dnow!]

func (*Program) PFMUL 

func (self *Program) PFMUL(v0 interface{}, v1 interface{}) *Instruction

PFMUL performs "Packed Floating-Point Multiply".

Mnemonic : PFMUL Supported forms : (2 forms)

  • PFMUL mm, mm [3dnow!]
  • PFMUL m64, mm [3dnow!]

func (*Program) PFNACC 

func (self *Program) PFNACC(v0 interface{}, v1 interface{}) *Instruction

PFNACC performs "Packed Floating-Point Negative Accumulate".

Mnemonic : PFNACC Supported forms : (2 forms)

  • PFNACC mm, mm [3dnow!+]
  • PFNACC m64, mm [3dnow!+]

func (*Program) PFPNACC 

func (self *Program) PFPNACC(v0 interface{}, v1 interface{}) *Instruction

PFPNACC performs "Packed Floating-Point Positive-Negative Accumulate".

Mnemonic : PFPNACC Supported forms : (2 forms)

  • PFPNACC mm, mm [3dnow!+]
  • PFPNACC m64, mm [3dnow!+]

func (*Program) PFRCP 

func (self *Program) PFRCP(v0 interface{}, v1 interface{}) *Instruction

PFRCP performs "Packed Floating-Point Reciprocal Approximation".

Mnemonic : PFRCP Supported forms : (2 forms)

  • PFRCP mm, mm [3dnow!]
  • PFRCP m64, mm [3dnow!]

func (*Program) PFRCPIT1 

func (self *Program) PFRCPIT1(v0 interface{}, v1 interface{}) *Instruction

PFRCPIT1 performs "Packed Floating-Point Reciprocal Iteration 1".

Mnemonic : PFRCPIT1 Supported forms : (2 forms)

  • PFRCPIT1 mm, mm [3dnow!]
  • PFRCPIT1 m64, mm [3dnow!]

func (*Program) PFRCPIT2 

func (self *Program) PFRCPIT2(v0 interface{}, v1 interface{}) *Instruction

PFRCPIT2 performs "Packed Floating-Point Reciprocal Iteration 2".

Mnemonic : PFRCPIT2 Supported forms : (2 forms)

  • PFRCPIT2 mm, mm [3dnow!]
  • PFRCPIT2 m64, mm [3dnow!]

func (*Program) PFRSQIT1 

func (self *Program) PFRSQIT1(v0 interface{}, v1 interface{}) *Instruction

PFRSQIT1 performs "Packed Floating-Point Reciprocal Square Root Iteration 1".

Mnemonic : PFRSQIT1 Supported forms : (2 forms)

  • PFRSQIT1 mm, mm [3dnow!]
  • PFRSQIT1 m64, mm [3dnow!]

func (*Program) PFRSQRT 

func (self *Program) PFRSQRT(v0 interface{}, v1 interface{}) *Instruction

PFRSQRT performs "Packed Floating-Point Reciprocal Square Root Approximation".

Mnemonic : PFRSQRT Supported forms : (2 forms)

  • PFRSQRT mm, mm [3dnow!]
  • PFRSQRT m64, mm [3dnow!]

func (*Program) PFSUB 

func (self *Program) PFSUB(v0 interface{}, v1 interface{}) *Instruction

PFSUB performs "Packed Floating-Point Subtract".

Mnemonic : PFSUB Supported forms : (2 forms)

  • PFSUB mm, mm [3dnow!]
  • PFSUB m64, mm [3dnow!]

func (*Program) PFSUBR 

func (self *Program) PFSUBR(v0 interface{}, v1 interface{}) *Instruction

PFSUBR performs "Packed Floating-Point Subtract Reverse".

Mnemonic : PFSUBR Supported forms : (2 forms)

  • PFSUBR mm, mm [3dnow!]
  • PFSUBR m64, mm [3dnow!]

func (*Program) PHADDD 

func (self *Program) PHADDD(v0 interface{}, v1 interface{}) *Instruction

PHADDD performs "Packed Horizontal Add Doubleword Integer".

Mnemonic : PHADDD Supported forms : (4 forms)

  • PHADDD mm, mm [SSSE3]
  • PHADDD m64, mm [SSSE3]
  • PHADDD xmm, xmm [SSSE3]
  • PHADDD m128, xmm [SSSE3]

func (*Program) PHADDSW 

func (self *Program) PHADDSW(v0 interface{}, v1 interface{}) *Instruction

PHADDSW performs "Packed Horizontal Add Signed Word Integers with Signed Saturation".

Mnemonic : PHADDSW Supported forms : (4 forms)

  • PHADDSW mm, mm [SSSE3]
  • PHADDSW m64, mm [SSSE3]
  • PHADDSW xmm, xmm [SSSE3]
  • PHADDSW m128, xmm [SSSE3]

func (*Program) PHADDW 

func (self *Program) PHADDW(v0 interface{}, v1 interface{}) *Instruction

PHADDW performs "Packed Horizontal Add Word Integers".

Mnemonic : PHADDW Supported forms : (4 forms)

  • PHADDW mm, mm [SSSE3]
  • PHADDW m64, mm [SSSE3]
  • PHADDW xmm, xmm [SSSE3]
  • PHADDW m128, xmm [SSSE3]

func (*Program) PHMINPOSUW 

func (self *Program) PHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction

PHMINPOSUW performs "Packed Horizontal Minimum of Unsigned Word Integers".

Mnemonic : PHMINPOSUW Supported forms : (2 forms)

  • PHMINPOSUW xmm, xmm [SSE4.1]
  • PHMINPOSUW m128, xmm [SSE4.1]

func (*Program) PHSUBD 

func (self *Program) PHSUBD(v0 interface{}, v1 interface{}) *Instruction

PHSUBD performs "Packed Horizontal Subtract Doubleword Integers".

Mnemonic : PHSUBD Supported forms : (4 forms)

  • PHSUBD mm, mm [SSSE3]
  • PHSUBD m64, mm [SSSE3]
  • PHSUBD xmm, xmm [SSSE3]
  • PHSUBD m128, xmm [SSSE3]

func (*Program) PHSUBSW 

func (self *Program) PHSUBSW(v0 interface{}, v1 interface{}) *Instruction

PHSUBSW performs "Packed Horizontal Subtract Signed Word Integers with Signed Saturation".

Mnemonic : PHSUBSW Supported forms : (4 forms)

  • PHSUBSW mm, mm [SSSE3]
  • PHSUBSW m64, mm [SSSE3]
  • PHSUBSW xmm, xmm [SSSE3]
  • PHSUBSW m128, xmm [SSSE3]

func (*Program) PHSUBW 

func (self *Program) PHSUBW(v0 interface{}, v1 interface{}) *Instruction

PHSUBW performs "Packed Horizontal Subtract Word Integers".

Mnemonic : PHSUBW Supported forms : (4 forms)

  • PHSUBW mm, mm [SSSE3]
  • PHSUBW m64, mm [SSSE3]
  • PHSUBW xmm, xmm [SSSE3]
  • PHSUBW m128, xmm [SSSE3]

func (*Program) PI2FD 

func (self *Program) PI2FD(v0 interface{}, v1 interface{}) *Instruction

PI2FD performs "Packed Integer to Floating-Point Doubleword Conversion".

Mnemonic : PI2FD Supported forms : (2 forms)

  • PI2FD mm, mm [3dnow!]
  • PI2FD m64, mm [3dnow!]

func (*Program) PI2FW 

func (self *Program) PI2FW(v0 interface{}, v1 interface{}) *Instruction

PI2FW performs "Packed Integer to Floating-Point Word Conversion".

Mnemonic : PI2FW Supported forms : (2 forms)

  • PI2FW mm, mm [3dnow!+]
  • PI2FW m64, mm [3dnow!+]

func (*Program) PINSRB 

func (self *Program) PINSRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRB performs "Insert Byte".

Mnemonic : PINSRB Supported forms : (2 forms)

  • PINSRB imm8, r32, xmm [SSE4.1]
  • PINSRB imm8, m8, xmm [SSE4.1]

func (*Program) PINSRD 

func (self *Program) PINSRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRD performs "Insert Doubleword".

Mnemonic : PINSRD Supported forms : (2 forms)

  • PINSRD imm8, r32, xmm [SSE4.1]
  • PINSRD imm8, m32, xmm [SSE4.1]

func (*Program) PINSRQ 

func (self *Program) PINSRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRQ performs "Insert Quadword".

Mnemonic : PINSRQ Supported forms : (2 forms)

  • PINSRQ imm8, r64, xmm [SSE4.1]
  • PINSRQ imm8, m64, xmm [SSE4.1]

func (*Program) PINSRW 

func (self *Program) PINSRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PINSRW performs "Insert Word".

Mnemonic : PINSRW Supported forms : (4 forms)

  • PINSRW imm8, r32, mm [MMX+]
  • PINSRW imm8, m16, mm [MMX+]
  • PINSRW imm8, r32, xmm [SSE2]
  • PINSRW imm8, m16, xmm [SSE2]

func (*Program) PMADDUBSW 

func (self *Program) PMADDUBSW(v0 interface{}, v1 interface{}) *Instruction

PMADDUBSW performs "Multiply and Add Packed Signed and Unsigned Byte Integers".

Mnemonic : PMADDUBSW Supported forms : (4 forms)

  • PMADDUBSW mm, mm [SSSE3]
  • PMADDUBSW m64, mm [SSSE3]
  • PMADDUBSW xmm, xmm [SSSE3]
  • PMADDUBSW m128, xmm [SSSE3]

func (*Program) PMADDWD 

func (self *Program) PMADDWD(v0 interface{}, v1 interface{}) *Instruction

PMADDWD performs "Multiply and Add Packed Signed Word Integers".

Mnemonic : PMADDWD Supported forms : (4 forms)

  • PMADDWD mm, mm [MMX]
  • PMADDWD m64, mm [MMX]
  • PMADDWD xmm, xmm [SSE2]
  • PMADDWD m128, xmm [SSE2]

func (*Program) PMAXSB 

func (self *Program) PMAXSB(v0 interface{}, v1 interface{}) *Instruction

PMAXSB performs "Maximum of Packed Signed Byte Integers".

Mnemonic : PMAXSB Supported forms : (2 forms)

  • PMAXSB xmm, xmm [SSE4.1]
  • PMAXSB m128, xmm [SSE4.1]

func (*Program) PMAXSD 

func (self *Program) PMAXSD(v0 interface{}, v1 interface{}) *Instruction

PMAXSD performs "Maximum of Packed Signed Doubleword Integers".

Mnemonic : PMAXSD Supported forms : (2 forms)

  • PMAXSD xmm, xmm [SSE4.1]
  • PMAXSD m128, xmm [SSE4.1]

func (*Program) PMAXSW 

func (self *Program) PMAXSW(v0 interface{}, v1 interface{}) *Instruction

PMAXSW performs "Maximum of Packed Signed Word Integers".

Mnemonic : PMAXSW Supported forms : (4 forms)

  • PMAXSW mm, mm [MMX+]
  • PMAXSW m64, mm [MMX+]
  • PMAXSW xmm, xmm [SSE2]
  • PMAXSW m128, xmm [SSE2]

func (*Program) PMAXUB 

func (self *Program) PMAXUB(v0 interface{}, v1 interface{}) *Instruction

PMAXUB performs "Maximum of Packed Unsigned Byte Integers".

Mnemonic : PMAXUB Supported forms : (4 forms)

  • PMAXUB mm, mm [MMX+]
  • PMAXUB m64, mm [MMX+]
  • PMAXUB xmm, xmm [SSE2]
  • PMAXUB m128, xmm [SSE2]

func (*Program) PMAXUD 

func (self *Program) PMAXUD(v0 interface{}, v1 interface{}) *Instruction

PMAXUD performs "Maximum of Packed Unsigned Doubleword Integers".

Mnemonic : PMAXUD Supported forms : (2 forms)

  • PMAXUD xmm, xmm [SSE4.1]
  • PMAXUD m128, xmm [SSE4.1]

func (*Program) PMAXUW 

func (self *Program) PMAXUW(v0 interface{}, v1 interface{}) *Instruction

PMAXUW performs "Maximum of Packed Unsigned Word Integers".

Mnemonic : PMAXUW Supported forms : (2 forms)

  • PMAXUW xmm, xmm [SSE4.1]
  • PMAXUW m128, xmm [SSE4.1]

func (*Program) PMINSB 

func (self *Program) PMINSB(v0 interface{}, v1 interface{}) *Instruction

PMINSB performs "Minimum of Packed Signed Byte Integers".

Mnemonic : PMINSB Supported forms : (2 forms)

  • PMINSB xmm, xmm [SSE4.1]
  • PMINSB m128, xmm [SSE4.1]

func (*Program) PMINSD 

func (self *Program) PMINSD(v0 interface{}, v1 interface{}) *Instruction

PMINSD performs "Minimum of Packed Signed Doubleword Integers".

Mnemonic : PMINSD Supported forms : (2 forms)

  • PMINSD xmm, xmm [SSE4.1]
  • PMINSD m128, xmm [SSE4.1]

func (*Program) PMINSW 

func (self *Program) PMINSW(v0 interface{}, v1 interface{}) *Instruction

PMINSW performs "Minimum of Packed Signed Word Integers".

Mnemonic : PMINSW Supported forms : (4 forms)

  • PMINSW mm, mm [MMX+]
  • PMINSW m64, mm [MMX+]
  • PMINSW xmm, xmm [SSE2]
  • PMINSW m128, xmm [SSE2]

func (*Program) PMINUB 

func (self *Program) PMINUB(v0 interface{}, v1 interface{}) *Instruction

PMINUB performs "Minimum of Packed Unsigned Byte Integers".

Mnemonic : PMINUB Supported forms : (4 forms)

  • PMINUB mm, mm [MMX+]
  • PMINUB m64, mm [MMX+]
  • PMINUB xmm, xmm [SSE2]
  • PMINUB m128, xmm [SSE2]

func (*Program) PMINUD 

func (self *Program) PMINUD(v0 interface{}, v1 interface{}) *Instruction

PMINUD performs "Minimum of Packed Unsigned Doubleword Integers".

Mnemonic : PMINUD Supported forms : (2 forms)

  • PMINUD xmm, xmm [SSE4.1]
  • PMINUD m128, xmm [SSE4.1]

func (*Program) PMINUW 

func (self *Program) PMINUW(v0 interface{}, v1 interface{}) *Instruction

PMINUW performs "Minimum of Packed Unsigned Word Integers".

Mnemonic : PMINUW Supported forms : (2 forms)

  • PMINUW xmm, xmm [SSE4.1]
  • PMINUW m128, xmm [SSE4.1]

func (*Program) PMOVMSKB 

func (self *Program) PMOVMSKB(v0 interface{}, v1 interface{}) *Instruction

PMOVMSKB performs "Move Byte Mask".

Mnemonic : PMOVMSKB Supported forms : (2 forms)

  • PMOVMSKB mm, r32 [MMX+]
  • PMOVMSKB xmm, r32 [SSE2]

func (*Program) PMOVSXBD 

func (self *Program) PMOVSXBD(v0 interface{}, v1 interface{}) *Instruction

PMOVSXBD performs "Move Packed Byte Integers to Doubleword Integers with Sign Extension".

Mnemonic : PMOVSXBD Supported forms : (2 forms)

  • PMOVSXBD xmm, xmm [SSE4.1]
  • PMOVSXBD m32, xmm [SSE4.1]

func (*Program) PMOVSXBQ 

func (self *Program) PMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction

PMOVSXBQ performs "Move Packed Byte Integers to Quadword Integers with Sign Extension".

Mnemonic : PMOVSXBQ Supported forms : (2 forms)

  • PMOVSXBQ xmm, xmm [SSE4.1]
  • PMOVSXBQ m16, xmm [SSE4.1]

func (*Program) PMOVSXBW 

func (self *Program) PMOVSXBW(v0 interface{}, v1 interface{}) *Instruction

PMOVSXBW performs "Move Packed Byte Integers to Word Integers with Sign Extension".

Mnemonic : PMOVSXBW Supported forms : (2 forms)

  • PMOVSXBW xmm, xmm [SSE4.1]
  • PMOVSXBW m64, xmm [SSE4.1]

func (*Program) PMOVSXDQ 

func (self *Program) PMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction

PMOVSXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Sign Extension".

Mnemonic : PMOVSXDQ Supported forms : (2 forms)

  • PMOVSXDQ xmm, xmm [SSE4.1]
  • PMOVSXDQ m64, xmm [SSE4.1]

func (*Program) PMOVSXWD 

func (self *Program) PMOVSXWD(v0 interface{}, v1 interface{}) *Instruction

PMOVSXWD performs "Move Packed Word Integers to Doubleword Integers with Sign Extension".

Mnemonic : PMOVSXWD Supported forms : (2 forms)

  • PMOVSXWD xmm, xmm [SSE4.1]
  • PMOVSXWD m64, xmm [SSE4.1]

func (*Program) PMOVSXWQ 

func (self *Program) PMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction

PMOVSXWQ performs "Move Packed Word Integers to Quadword Integers with Sign Extension".

Mnemonic : PMOVSXWQ Supported forms : (2 forms)

  • PMOVSXWQ xmm, xmm [SSE4.1]
  • PMOVSXWQ m32, xmm [SSE4.1]

func (*Program) PMOVZXBD 

func (self *Program) PMOVZXBD(v0 interface{}, v1 interface{}) *Instruction

PMOVZXBD performs "Move Packed Byte Integers to Doubleword Integers with Zero Extension".

Mnemonic : PMOVZXBD Supported forms : (2 forms)

  • PMOVZXBD xmm, xmm [SSE4.1]
  • PMOVZXBD m32, xmm [SSE4.1]

func (*Program) PMOVZXBQ 

func (self *Program) PMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction

PMOVZXBQ performs "Move Packed Byte Integers to Quadword Integers with Zero Extension".

Mnemonic : PMOVZXBQ Supported forms : (2 forms)

  • PMOVZXBQ xmm, xmm [SSE4.1]
  • PMOVZXBQ m16, xmm [SSE4.1]

func (*Program) PMOVZXBW 

func (self *Program) PMOVZXBW(v0 interface{}, v1 interface{}) *Instruction

PMOVZXBW performs "Move Packed Byte Integers to Word Integers with Zero Extension".

Mnemonic : PMOVZXBW Supported forms : (2 forms)

  • PMOVZXBW xmm, xmm [SSE4.1]
  • PMOVZXBW m64, xmm [SSE4.1]

func (*Program) PMOVZXDQ 

func (self *Program) PMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction

PMOVZXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Zero Extension".

Mnemonic : PMOVZXDQ Supported forms : (2 forms)

  • PMOVZXDQ xmm, xmm [SSE4.1]
  • PMOVZXDQ m64, xmm [SSE4.1]

func (*Program) PMOVZXWD 

func (self *Program) PMOVZXWD(v0 interface{}, v1 interface{}) *Instruction

PMOVZXWD performs "Move Packed Word Integers to Doubleword Integers with Zero Extension".

Mnemonic : PMOVZXWD Supported forms : (2 forms)

  • PMOVZXWD xmm, xmm [SSE4.1]
  • PMOVZXWD m64, xmm [SSE4.1]

func (*Program) PMOVZXWQ 

func (self *Program) PMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction

PMOVZXWQ performs "Move Packed Word Integers to Quadword Integers with Zero Extension".

Mnemonic : PMOVZXWQ Supported forms : (2 forms)

  • PMOVZXWQ xmm, xmm [SSE4.1]
  • PMOVZXWQ m32, xmm [SSE4.1]

func (*Program) PMULDQ 

func (self *Program) PMULDQ(v0 interface{}, v1 interface{}) *Instruction

PMULDQ performs "Multiply Packed Signed Doubleword Integers and Store Quadword Result".

Mnemonic : PMULDQ Supported forms : (2 forms)

  • PMULDQ xmm, xmm [SSE4.1]
  • PMULDQ m128, xmm [SSE4.1]

func (*Program) PMULHRSW 

func (self *Program) PMULHRSW(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : PMULHRSW Supported forms : (4 forms)

  • PMULHRSW mm, mm [SSSE3]
  • PMULHRSW m64, mm [SSSE3]
  • PMULHRSW xmm, xmm [SSSE3]
  • PMULHRSW m128, xmm [SSSE3]

func (*Program) PMULHRW 

func (self *Program) PMULHRW(v0 interface{}, v1 interface{}) *Instruction

PMULHRW performs "Packed Multiply High Rounded Word".

Mnemonic : PMULHRW Supported forms : (2 forms)

  • PMULHRW mm, mm [3dnow!]
  • PMULHRW m64, mm [3dnow!]

func (*Program) PMULHUW 

func (self *Program) PMULHUW(v0 interface{}, v1 interface{}) *Instruction

PMULHUW performs "Multiply Packed Unsigned Word Integers and Store High Result".

Mnemonic : PMULHUW Supported forms : (4 forms)

  • PMULHUW mm, mm [MMX+]
  • PMULHUW m64, mm [MMX+]
  • PMULHUW xmm, xmm [SSE2]
  • PMULHUW m128, xmm [SSE2]

func (*Program) PMULHW 

func (self *Program) PMULHW(v0 interface{}, v1 interface{}) *Instruction

PMULHW performs "Multiply Packed Signed Word Integers and Store High Result".

Mnemonic : PMULHW Supported forms : (4 forms)

  • PMULHW mm, mm [MMX]
  • PMULHW m64, mm [MMX]
  • PMULHW xmm, xmm [SSE2]
  • PMULHW m128, xmm [SSE2]

func (*Program) PMULLD 

func (self *Program) PMULLD(v0 interface{}, v1 interface{}) *Instruction

PMULLD performs "Multiply Packed Signed Doubleword Integers and Store Low Result".

Mnemonic : PMULLD Supported forms : (2 forms)

  • PMULLD xmm, xmm [SSE4.1]
  • PMULLD m128, xmm [SSE4.1]

func (*Program) PMULLW 

func (self *Program) PMULLW(v0 interface{}, v1 interface{}) *Instruction

PMULLW performs "Multiply Packed Signed Word Integers and Store Low Result".

Mnemonic : PMULLW Supported forms : (4 forms)

  • PMULLW mm, mm [MMX]
  • PMULLW m64, mm [MMX]
  • PMULLW xmm, xmm [SSE2]
  • PMULLW m128, xmm [SSE2]

func (*Program) PMULUDQ 

func (self *Program) PMULUDQ(v0 interface{}, v1 interface{}) *Instruction

PMULUDQ performs "Multiply Packed Unsigned Doubleword Integers".

Mnemonic : PMULUDQ Supported forms : (4 forms)

  • PMULUDQ mm, mm [SSE2]
  • PMULUDQ m64, mm [SSE2]
  • PMULUDQ xmm, xmm [SSE2]
  • PMULUDQ m128, xmm [SSE2]

func (*Program) POPCNTL 

func (self *Program) POPCNTL(v0 interface{}, v1 interface{}) *Instruction

POPCNTL performs "Count of Number of Bits Set to 1".

Mnemonic : POPCNT Supported forms : (2 forms)

  • POPCNTL r32, r32 [POPCNT]
  • POPCNTL m32, r32 [POPCNT]

func (*Program) POPCNTQ 

func (self *Program) POPCNTQ(v0 interface{}, v1 interface{}) *Instruction

POPCNTQ performs "Count of Number of Bits Set to 1".

Mnemonic : POPCNT Supported forms : (2 forms)

  • POPCNTQ r64, r64 [POPCNT]
  • POPCNTQ m64, r64 [POPCNT]

func (*Program) POPCNTW 

func (self *Program) POPCNTW(v0 interface{}, v1 interface{}) *Instruction

POPCNTW performs "Count of Number of Bits Set to 1".

Mnemonic : POPCNT Supported forms : (2 forms)

  • POPCNTW r16, r16 [POPCNT]
  • POPCNTW m16, r16 [POPCNT]

func (*Program) POPQ 

func (self *Program) POPQ(v0 interface{}) *Instruction

POPQ performs "Pop a Value from the Stack".

Mnemonic : POP Supported forms : (2 forms)

  • POPQ r64
  • POPQ m64

func (*Program) POPW 

func (self *Program) POPW(v0 interface{}) *Instruction

POPW performs "Pop a Value from the Stack".

Mnemonic : POP Supported forms : (2 forms)

  • POPW r16
  • POPW m16

func (*Program) POR 

func (self *Program) POR(v0 interface{}, v1 interface{}) *Instruction

POR performs "Packed Bitwise Logical OR".

Mnemonic : POR Supported forms : (4 forms)

  • POR mm, mm [MMX]
  • POR m64, mm [MMX]
  • POR xmm, xmm [SSE2]
  • POR m128, xmm [SSE2]

func (*Program) PREFETCH 

func (self *Program) PREFETCH(v0 interface{}) *Instruction

PREFETCH performs "Prefetch Data into Caches".

Mnemonic : PREFETCH Supported forms : (1 form)

  • PREFETCH m8 [PREFETCH]

func (*Program) PREFETCHNTA 

func (self *Program) PREFETCHNTA(v0 interface{}) *Instruction

PREFETCHNTA performs "Prefetch Data Into Caches using NTA Hint".

Mnemonic : PREFETCHNTA Supported forms : (1 form)

  • PREFETCHNTA m8 [MMX+]

func (*Program) PREFETCHT0 

func (self *Program) PREFETCHT0(v0 interface{}) *Instruction

PREFETCHT0 performs "Prefetch Data Into Caches using T0 Hint".

Mnemonic : PREFETCHT0 Supported forms : (1 form)

  • PREFETCHT0 m8 [MMX+]

func (*Program) PREFETCHT1 

func (self *Program) PREFETCHT1(v0 interface{}) *Instruction

PREFETCHT1 performs "Prefetch Data Into Caches using T1 Hint".

Mnemonic : PREFETCHT1 Supported forms : (1 form)

  • PREFETCHT1 m8 [MMX+]

func (*Program) PREFETCHT2 

func (self *Program) PREFETCHT2(v0 interface{}) *Instruction

PREFETCHT2 performs "Prefetch Data Into Caches using T2 Hint".

Mnemonic : PREFETCHT2 Supported forms : (1 form)

  • PREFETCHT2 m8 [MMX+]

func (*Program) PREFETCHW 

func (self *Program) PREFETCHW(v0 interface{}) *Instruction

PREFETCHW performs "Prefetch Data into Caches in Anticipation of a Write".

Mnemonic : PREFETCHW Supported forms : (1 form)

  • PREFETCHW m8 [PREFETCHW]

func (*Program) PREFETCHWT1 

func (self *Program) PREFETCHWT1(v0 interface{}) *Instruction

PREFETCHWT1 performs "Prefetch Vector Data Into Caches with Intent to Write and T1 Hint".

Mnemonic : PREFETCHWT1 Supported forms : (1 form)

  • PREFETCHWT1 m8 [PREFETCHWT1]

func (*Program) PSADBW 

func (self *Program) PSADBW(v0 interface{}, v1 interface{}) *Instruction

PSADBW performs "Compute Sum of Absolute Differences".

Mnemonic : PSADBW Supported forms : (4 forms)

  • PSADBW mm, mm [MMX+]
  • PSADBW m64, mm [MMX+]
  • PSADBW xmm, xmm [SSE2]
  • PSADBW m128, xmm [SSE2]

func (*Program) PSHUFB 

func (self *Program) PSHUFB(v0 interface{}, v1 interface{}) *Instruction

PSHUFB performs "Packed Shuffle Bytes".

Mnemonic : PSHUFB Supported forms : (4 forms)

  • PSHUFB mm, mm [SSSE3]
  • PSHUFB m64, mm [SSSE3]
  • PSHUFB xmm, xmm [SSSE3]
  • PSHUFB m128, xmm [SSSE3]

func (*Program) PSHUFD 

func (self *Program) PSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFD performs "Shuffle Packed Doublewords".

Mnemonic : PSHUFD Supported forms : (2 forms)

  • PSHUFD imm8, xmm, xmm [SSE2]
  • PSHUFD imm8, m128, xmm [SSE2]

func (*Program) PSHUFHW 

func (self *Program) PSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFHW performs "Shuffle Packed High Words".

Mnemonic : PSHUFHW Supported forms : (2 forms)

  • PSHUFHW imm8, xmm, xmm [SSE2]
  • PSHUFHW imm8, m128, xmm [SSE2]

func (*Program) PSHUFLW 

func (self *Program) PSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFLW performs "Shuffle Packed Low Words".

Mnemonic : PSHUFLW Supported forms : (2 forms)

  • PSHUFLW imm8, xmm, xmm [SSE2]
  • PSHUFLW imm8, m128, xmm [SSE2]

func (*Program) PSHUFW 

func (self *Program) PSHUFW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

PSHUFW performs "Shuffle Packed Words".

Mnemonic : PSHUFW Supported forms : (2 forms)

  • PSHUFW imm8, mm, mm [MMX+]
  • PSHUFW imm8, m64, mm [MMX+]

func (*Program) PSIGNB 

func (self *Program) PSIGNB(v0 interface{}, v1 interface{}) *Instruction

PSIGNB performs "Packed Sign of Byte Integers".

Mnemonic : PSIGNB Supported forms : (4 forms)

  • PSIGNB mm, mm [SSSE3]
  • PSIGNB m64, mm [SSSE3]
  • PSIGNB xmm, xmm [SSSE3]
  • PSIGNB m128, xmm [SSSE3]

func (*Program) PSIGND 

func (self *Program) PSIGND(v0 interface{}, v1 interface{}) *Instruction

PSIGND performs "Packed Sign of Doubleword Integers".

Mnemonic : PSIGND Supported forms : (4 forms)

  • PSIGND mm, mm [SSSE3]
  • PSIGND m64, mm [SSSE3]
  • PSIGND xmm, xmm [SSSE3]
  • PSIGND m128, xmm [SSSE3]

func (*Program) PSIGNW 

func (self *Program) PSIGNW(v0 interface{}, v1 interface{}) *Instruction

PSIGNW performs "Packed Sign of Word Integers".

Mnemonic : PSIGNW Supported forms : (4 forms)

  • PSIGNW mm, mm [SSSE3]
  • PSIGNW m64, mm [SSSE3]
  • PSIGNW xmm, xmm [SSSE3]
  • PSIGNW m128, xmm [SSSE3]

func (*Program) PSLLD 

func (self *Program) PSLLD(v0 interface{}, v1 interface{}) *Instruction

PSLLD performs "Shift Packed Doubleword Data Left Logical".

Mnemonic : PSLLD Supported forms : (6 forms)

  • PSLLD imm8, mm [MMX]
  • PSLLD mm, mm [MMX]
  • PSLLD m64, mm [MMX]
  • PSLLD imm8, xmm [SSE2]
  • PSLLD xmm, xmm [SSE2]
  • PSLLD m128, xmm [SSE2]

func (*Program) PSLLDQ 

func (self *Program) PSLLDQ(v0 interface{}, v1 interface{}) *Instruction

PSLLDQ performs "Shift Packed Double Quadword Left Logical".

Mnemonic : PSLLDQ Supported forms : (1 form)

  • PSLLDQ imm8, xmm [SSE2]

func (*Program) PSLLQ 

func (self *Program) PSLLQ(v0 interface{}, v1 interface{}) *Instruction

PSLLQ performs "Shift Packed Quadword Data Left Logical".

Mnemonic : PSLLQ Supported forms : (6 forms)

  • PSLLQ imm8, mm [MMX]
  • PSLLQ mm, mm [MMX]
  • PSLLQ m64, mm [MMX]
  • PSLLQ imm8, xmm [SSE2]
  • PSLLQ xmm, xmm [SSE2]
  • PSLLQ m128, xmm [SSE2]

func (*Program) PSLLW 

func (self *Program) PSLLW(v0 interface{}, v1 interface{}) *Instruction

PSLLW performs "Shift Packed Word Data Left Logical".

Mnemonic : PSLLW Supported forms : (6 forms)

  • PSLLW imm8, mm [MMX]
  • PSLLW mm, mm [MMX]
  • PSLLW m64, mm [MMX]
  • PSLLW imm8, xmm [SSE2]
  • PSLLW xmm, xmm [SSE2]
  • PSLLW m128, xmm [SSE2]

func (*Program) PSRAD 

func (self *Program) PSRAD(v0 interface{}, v1 interface{}) *Instruction

PSRAD performs "Shift Packed Doubleword Data Right Arithmetic".

Mnemonic : PSRAD Supported forms : (6 forms)

  • PSRAD imm8, mm [MMX]
  • PSRAD mm, mm [MMX]
  • PSRAD m64, mm [MMX]
  • PSRAD imm8, xmm [SSE2]
  • PSRAD xmm, xmm [SSE2]
  • PSRAD m128, xmm [SSE2]

func (*Program) PSRAW 

func (self *Program) PSRAW(v0 interface{}, v1 interface{}) *Instruction

PSRAW performs "Shift Packed Word Data Right Arithmetic".

Mnemonic : PSRAW Supported forms : (6 forms)

  • PSRAW imm8, mm [MMX]
  • PSRAW mm, mm [MMX]
  • PSRAW m64, mm [MMX]
  • PSRAW imm8, xmm [SSE2]
  • PSRAW xmm, xmm [SSE2]
  • PSRAW m128, xmm [SSE2]

func (*Program) PSRLD 

func (self *Program) PSRLD(v0 interface{}, v1 interface{}) *Instruction

PSRLD performs "Shift Packed Doubleword Data Right Logical".

Mnemonic : PSRLD Supported forms : (6 forms)

  • PSRLD imm8, mm [MMX]
  • PSRLD mm, mm [MMX]
  • PSRLD m64, mm [MMX]
  • PSRLD imm8, xmm [SSE2]
  • PSRLD xmm, xmm [SSE2]
  • PSRLD m128, xmm [SSE2]

func (*Program) PSRLDQ 

func (self *Program) PSRLDQ(v0 interface{}, v1 interface{}) *Instruction

PSRLDQ performs "Shift Packed Double Quadword Right Logical".

Mnemonic : PSRLDQ Supported forms : (1 form)

  • PSRLDQ imm8, xmm [SSE2]

func (*Program) PSRLQ 

func (self *Program) PSRLQ(v0 interface{}, v1 interface{}) *Instruction

PSRLQ performs "Shift Packed Quadword Data Right Logical".

Mnemonic : PSRLQ Supported forms : (6 forms)

  • PSRLQ imm8, mm [MMX]
  • PSRLQ mm, mm [MMX]
  • PSRLQ m64, mm [MMX]
  • PSRLQ imm8, xmm [SSE2]
  • PSRLQ xmm, xmm [SSE2]
  • PSRLQ m128, xmm [SSE2]

func (*Program) PSRLW 

func (self *Program) PSRLW(v0 interface{}, v1 interface{}) *Instruction

PSRLW performs "Shift Packed Word Data Right Logical".

Mnemonic : PSRLW Supported forms : (6 forms)

  • PSRLW imm8, mm [MMX]
  • PSRLW mm, mm [MMX]
  • PSRLW m64, mm [MMX]
  • PSRLW imm8, xmm [SSE2]
  • PSRLW xmm, xmm [SSE2]
  • PSRLW m128, xmm [SSE2]

func (*Program) PSUBB 

func (self *Program) PSUBB(v0 interface{}, v1 interface{}) *Instruction

PSUBB performs "Subtract Packed Byte Integers".

Mnemonic : PSUBB Supported forms : (4 forms)

  • PSUBB mm, mm [MMX]
  • PSUBB m64, mm [MMX]
  • PSUBB xmm, xmm [SSE2]
  • PSUBB m128, xmm [SSE2]

func (*Program) PSUBD 

func (self *Program) PSUBD(v0 interface{}, v1 interface{}) *Instruction

PSUBD performs "Subtract Packed Doubleword Integers".

Mnemonic : PSUBD Supported forms : (4 forms)

  • PSUBD mm, mm [MMX]
  • PSUBD m64, mm [MMX]
  • PSUBD xmm, xmm [SSE2]
  • PSUBD m128, xmm [SSE2]

func (*Program) PSUBQ 

func (self *Program) PSUBQ(v0 interface{}, v1 interface{}) *Instruction

PSUBQ performs "Subtract Packed Quadword Integers".

Mnemonic : PSUBQ Supported forms : (4 forms)

  • PSUBQ mm, mm [SSE2]
  • PSUBQ m64, mm [SSE2]
  • PSUBQ xmm, xmm [SSE2]
  • PSUBQ m128, xmm [SSE2]

func (*Program) PSUBSB 

func (self *Program) PSUBSB(v0 interface{}, v1 interface{}) *Instruction

PSUBSB performs "Subtract Packed Signed Byte Integers with Signed Saturation".

Mnemonic : PSUBSB Supported forms : (4 forms)

  • PSUBSB mm, mm [MMX]
  • PSUBSB m64, mm [MMX]
  • PSUBSB xmm, xmm [SSE2]
  • PSUBSB m128, xmm [SSE2]

func (*Program) PSUBSW 

func (self *Program) PSUBSW(v0 interface{}, v1 interface{}) *Instruction

PSUBSW performs "Subtract Packed Signed Word Integers with Signed Saturation".

Mnemonic : PSUBSW Supported forms : (4 forms)

  • PSUBSW mm, mm [MMX]
  • PSUBSW m64, mm [MMX]
  • PSUBSW xmm, xmm [SSE2]
  • PSUBSW m128, xmm [SSE2]

func (*Program) PSUBUSB 

func (self *Program) PSUBUSB(v0 interface{}, v1 interface{}) *Instruction

PSUBUSB performs "Subtract Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : PSUBUSB Supported forms : (4 forms)

  • PSUBUSB mm, mm [MMX]
  • PSUBUSB m64, mm [MMX]
  • PSUBUSB xmm, xmm [SSE2]
  • PSUBUSB m128, xmm [SSE2]

func (*Program) PSUBUSW 

func (self *Program) PSUBUSW(v0 interface{}, v1 interface{}) *Instruction

PSUBUSW performs "Subtract Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : PSUBUSW Supported forms : (4 forms)

  • PSUBUSW mm, mm [MMX]
  • PSUBUSW m64, mm [MMX]
  • PSUBUSW xmm, xmm [SSE2]
  • PSUBUSW m128, xmm [SSE2]

func (*Program) PSUBW 

func (self *Program) PSUBW(v0 interface{}, v1 interface{}) *Instruction

PSUBW performs "Subtract Packed Word Integers".

Mnemonic : PSUBW Supported forms : (4 forms)

  • PSUBW mm, mm [MMX]
  • PSUBW m64, mm [MMX]
  • PSUBW xmm, xmm [SSE2]
  • PSUBW m128, xmm [SSE2]

func (*Program) PSWAPD 

func (self *Program) PSWAPD(v0 interface{}, v1 interface{}) *Instruction

PSWAPD performs "Packed Swap Doubleword".

Mnemonic : PSWAPD Supported forms : (2 forms)

  • PSWAPD mm, mm [3dnow!+]
  • PSWAPD m64, mm [3dnow!+]

func (*Program) PTEST 

func (self *Program) PTEST(v0 interface{}, v1 interface{}) *Instruction

PTEST performs "Packed Logical Compare".

Mnemonic : PTEST Supported forms : (2 forms)

  • PTEST xmm, xmm [SSE4.1]
  • PTEST m128, xmm [SSE4.1]

func (*Program) PUNPCKHBW 

func (self *Program) PUNPCKHBW(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHBW performs "Unpack and Interleave High-Order Bytes into Words".

Mnemonic : PUNPCKHBW Supported forms : (4 forms)

  • PUNPCKHBW mm, mm [MMX]
  • PUNPCKHBW m64, mm [MMX]
  • PUNPCKHBW xmm, xmm [SSE2]
  • PUNPCKHBW m128, xmm [SSE2]

func (*Program) PUNPCKHDQ 

func (self *Program) PUNPCKHDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHDQ performs "Unpack and Interleave High-Order Doublewords into Quadwords".

Mnemonic : PUNPCKHDQ Supported forms : (4 forms)

  • PUNPCKHDQ mm, mm [MMX]
  • PUNPCKHDQ m64, mm [MMX]
  • PUNPCKHDQ xmm, xmm [SSE2]
  • PUNPCKHDQ m128, xmm [SSE2]

func (*Program) PUNPCKHQDQ 

func (self *Program) PUNPCKHQDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHQDQ performs "Unpack and Interleave High-Order Quadwords into Double Quadwords".

Mnemonic : PUNPCKHQDQ Supported forms : (2 forms)

  • PUNPCKHQDQ xmm, xmm [SSE2]
  • PUNPCKHQDQ m128, xmm [SSE2]

func (*Program) PUNPCKHWD 

func (self *Program) PUNPCKHWD(v0 interface{}, v1 interface{}) *Instruction

PUNPCKHWD performs "Unpack and Interleave High-Order Words into Doublewords".

Mnemonic : PUNPCKHWD Supported forms : (4 forms)

  • PUNPCKHWD mm, mm [MMX]
  • PUNPCKHWD m64, mm [MMX]
  • PUNPCKHWD xmm, xmm [SSE2]
  • PUNPCKHWD m128, xmm [SSE2]

func (*Program) PUNPCKLBW 

func (self *Program) PUNPCKLBW(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLBW performs "Unpack and Interleave Low-Order Bytes into Words".

Mnemonic : PUNPCKLBW Supported forms : (4 forms)

  • PUNPCKLBW mm, mm [MMX]
  • PUNPCKLBW m32, mm [MMX]
  • PUNPCKLBW xmm, xmm [SSE2]
  • PUNPCKLBW m128, xmm [SSE2]

func (*Program) PUNPCKLDQ 

func (self *Program) PUNPCKLDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLDQ performs "Unpack and Interleave Low-Order Doublewords into Quadwords".

Mnemonic : PUNPCKLDQ Supported forms : (4 forms)

  • PUNPCKLDQ mm, mm [MMX]
  • PUNPCKLDQ m32, mm [MMX]
  • PUNPCKLDQ xmm, xmm [SSE2]
  • PUNPCKLDQ m128, xmm [SSE2]

func (*Program) PUNPCKLQDQ 

func (self *Program) PUNPCKLQDQ(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLQDQ performs "Unpack and Interleave Low-Order Quadwords into Double Quadwords".

Mnemonic : PUNPCKLQDQ Supported forms : (2 forms)

  • PUNPCKLQDQ xmm, xmm [SSE2]
  • PUNPCKLQDQ m128, xmm [SSE2]

func (*Program) PUNPCKLWD 

func (self *Program) PUNPCKLWD(v0 interface{}, v1 interface{}) *Instruction

PUNPCKLWD performs "Unpack and Interleave Low-Order Words into Doublewords".

Mnemonic : PUNPCKLWD Supported forms : (4 forms)

  • PUNPCKLWD mm, mm [MMX]
  • PUNPCKLWD m32, mm [MMX]
  • PUNPCKLWD xmm, xmm [SSE2]
  • PUNPCKLWD m128, xmm [SSE2]

func (*Program) PUSHQ 

func (self *Program) PUSHQ(v0 interface{}) *Instruction

PUSHQ performs "Push Value Onto the Stack".

Mnemonic : PUSH Supported forms : (4 forms)

  • PUSHQ imm8
  • PUSHQ imm32
  • PUSHQ r64
  • PUSHQ m64

func (*Program) PUSHW 

func (self *Program) PUSHW(v0 interface{}) *Instruction

PUSHW performs "Push Value Onto the Stack".

Mnemonic : PUSH Supported forms : (2 forms)

  • PUSHW r16
  • PUSHW m16

func (*Program) PXOR 

func (self *Program) PXOR(v0 interface{}, v1 interface{}) *Instruction

PXOR performs "Packed Bitwise Logical Exclusive OR".

Mnemonic : PXOR Supported forms : (4 forms)

  • PXOR mm, mm [MMX]
  • PXOR m64, mm [MMX]
  • PXOR xmm, xmm [SSE2]
  • PXOR m128, xmm [SSE2]

func (*Program) Quad 

func (self *Program) Quad(v *expr.Expr) (p *Instruction)

Quad is a pseudo-instruction to add raw uint64 as little-endian to the assembled code.

func (*Program) RCLB 

func (self *Program) RCLB(v0 interface{}, v1 interface{}) *Instruction

RCLB performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

  • RCLB 1, r8
  • RCLB imm8, r8
  • RCLB cl, r8
  • RCLB 1, m8
  • RCLB imm8, m8
  • RCLB cl, m8

func (*Program) RCLL 

func (self *Program) RCLL(v0 interface{}, v1 interface{}) *Instruction

RCLL performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

  • RCLL 1, r32
  • RCLL imm8, r32
  • RCLL cl, r32
  • RCLL 1, m32
  • RCLL imm8, m32
  • RCLL cl, m32

func (*Program) RCLQ 

func (self *Program) RCLQ(v0 interface{}, v1 interface{}) *Instruction

RCLQ performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

  • RCLQ 1, r64
  • RCLQ imm8, r64
  • RCLQ cl, r64
  • RCLQ 1, m64
  • RCLQ imm8, m64
  • RCLQ cl, m64

func (*Program) RCLW 

func (self *Program) RCLW(v0 interface{}, v1 interface{}) *Instruction

RCLW performs "Rotate Left through Carry Flag".

Mnemonic : RCL Supported forms : (6 forms)

  • RCLW 1, r16
  • RCLW imm8, r16
  • RCLW cl, r16
  • RCLW 1, m16
  • RCLW imm8, m16
  • RCLW cl, m16

func (*Program) RCPPS 

func (self *Program) RCPPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : RCPPS Supported forms : (2 forms)

  • RCPPS xmm, xmm [SSE]
  • RCPPS m128, xmm [SSE]

func (*Program) RCPSS 

func (self *Program) RCPSS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : RCPSS Supported forms : (2 forms)

  • RCPSS xmm, xmm [SSE]
  • RCPSS m32, xmm [SSE]

func (*Program) RCRB 

func (self *Program) RCRB(v0 interface{}, v1 interface{}) *Instruction

RCRB performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

  • RCRB 1, r8
  • RCRB imm8, r8
  • RCRB cl, r8
  • RCRB 1, m8
  • RCRB imm8, m8
  • RCRB cl, m8

func (*Program) RCRL 

func (self *Program) RCRL(v0 interface{}, v1 interface{}) *Instruction

RCRL performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

  • RCRL 1, r32
  • RCRL imm8, r32
  • RCRL cl, r32
  • RCRL 1, m32
  • RCRL imm8, m32
  • RCRL cl, m32

func (*Program) RCRQ 

func (self *Program) RCRQ(v0 interface{}, v1 interface{}) *Instruction

RCRQ performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

  • RCRQ 1, r64
  • RCRQ imm8, r64
  • RCRQ cl, r64
  • RCRQ 1, m64
  • RCRQ imm8, m64
  • RCRQ cl, m64

func (*Program) RCRW 

func (self *Program) RCRW(v0 interface{}, v1 interface{}) *Instruction

RCRW performs "Rotate Right through Carry Flag".

Mnemonic : RCR Supported forms : (6 forms)

  • RCRW 1, r16
  • RCRW imm8, r16
  • RCRW cl, r16
  • RCRW 1, m16
  • RCRW imm8, m16
  • RCRW cl, m16

func (*Program) RDRAND 

func (self *Program) RDRAND(v0 interface{}) *Instruction

RDRAND performs "Read Random Number".

Mnemonic : RDRAND Supported forms : (3 forms)

  • RDRAND r16 [RDRAND]
  • RDRAND r32 [RDRAND]
  • RDRAND r64 [RDRAND]

func (*Program) RDSEED 

func (self *Program) RDSEED(v0 interface{}) *Instruction

RDSEED performs "Read Random SEED".

Mnemonic : RDSEED Supported forms : (3 forms)

  • RDSEED r16 [RDSEED]
  • RDSEED r32 [RDSEED]
  • RDSEED r64 [RDSEED]

func (*Program) RDTSC 

func (self *Program) RDTSC() *Instruction

RDTSC performs "Read Time-Stamp Counter".

Mnemonic : RDTSC Supported forms : (1 form)

  • RDTSC [RDTSC]

func (*Program) RDTSCP 

func (self *Program) RDTSCP() *Instruction

RDTSCP performs "Read Time-Stamp Counter and Processor ID".

Mnemonic : RDTSCP Supported forms : (1 form)

  • RDTSCP [RDTSCP]

func (*Program) RET 

func (self *Program) RET(vv ...interface{}) *Instruction

RET performs "Return from Procedure".

Mnemonic : RET Supported forms : (2 forms)

  • RET
  • RET imm16

func (*Program) ROLB 

func (self *Program) ROLB(v0 interface{}, v1 interface{}) *Instruction

ROLB performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

  • ROLB 1, r8
  • ROLB imm8, r8
  • ROLB cl, r8
  • ROLB 1, m8
  • ROLB imm8, m8
  • ROLB cl, m8

func (*Program) ROLL 

func (self *Program) ROLL(v0 interface{}, v1 interface{}) *Instruction

ROLL performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

  • ROLL 1, r32
  • ROLL imm8, r32
  • ROLL cl, r32
  • ROLL 1, m32
  • ROLL imm8, m32
  • ROLL cl, m32

func (*Program) ROLQ 

func (self *Program) ROLQ(v0 interface{}, v1 interface{}) *Instruction

ROLQ performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

  • ROLQ 1, r64
  • ROLQ imm8, r64
  • ROLQ cl, r64
  • ROLQ 1, m64
  • ROLQ imm8, m64
  • ROLQ cl, m64

func (*Program) ROLW 

func (self *Program) ROLW(v0 interface{}, v1 interface{}) *Instruction

ROLW performs "Rotate Left".

Mnemonic : ROL Supported forms : (6 forms)

  • ROLW 1, r16
  • ROLW imm8, r16
  • ROLW cl, r16
  • ROLW 1, m16
  • ROLW imm8, m16
  • ROLW cl, m16

func (*Program) RORB 

func (self *Program) RORB(v0 interface{}, v1 interface{}) *Instruction

RORB performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

  • RORB 1, r8
  • RORB imm8, r8
  • RORB cl, r8
  • RORB 1, m8
  • RORB imm8, m8
  • RORB cl, m8

func (*Program) RORL 

func (self *Program) RORL(v0 interface{}, v1 interface{}) *Instruction

RORL performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

  • RORL 1, r32
  • RORL imm8, r32
  • RORL cl, r32
  • RORL 1, m32
  • RORL imm8, m32
  • RORL cl, m32

func (*Program) RORQ 

func (self *Program) RORQ(v0 interface{}, v1 interface{}) *Instruction

RORQ performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

  • RORQ 1, r64
  • RORQ imm8, r64
  • RORQ cl, r64
  • RORQ 1, m64
  • RORQ imm8, m64
  • RORQ cl, m64

func (*Program) RORW 

func (self *Program) RORW(v0 interface{}, v1 interface{}) *Instruction

RORW performs "Rotate Right".

Mnemonic : ROR Supported forms : (6 forms)

  • RORW 1, r16
  • RORW imm8, r16
  • RORW cl, r16
  • RORW 1, m16
  • RORW imm8, m16
  • RORW cl, m16

func (*Program) RORXL 

func (self *Program) RORXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

RORXL performs "Rotate Right Logical Without Affecting Flags".

Mnemonic : RORX Supported forms : (2 forms)

  • RORXL imm8, r32, r32 [BMI2]
  • RORXL imm8, m32, r32 [BMI2]

func (*Program) RORXQ 

func (self *Program) RORXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

RORXQ performs "Rotate Right Logical Without Affecting Flags".

Mnemonic : RORX Supported forms : (2 forms)

  • RORXQ imm8, r64, r64 [BMI2]
  • RORXQ imm8, m64, r64 [BMI2]

func (*Program) ROUNDPD 

func (self *Program) ROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDPD performs "Round Packed Double Precision Floating-Point Values".

Mnemonic : ROUNDPD Supported forms : (2 forms)

  • ROUNDPD imm8, xmm, xmm [SSE4.1]
  • ROUNDPD imm8, m128, xmm [SSE4.1]

func (*Program) ROUNDPS 

func (self *Program) ROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDPS performs "Round Packed Single Precision Floating-Point Values".

Mnemonic : ROUNDPS Supported forms : (2 forms)

  • ROUNDPS imm8, xmm, xmm [SSE4.1]
  • ROUNDPS imm8, m128, xmm [SSE4.1]

func (*Program) ROUNDSD 

func (self *Program) ROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDSD performs "Round Scalar Double Precision Floating-Point Values".

Mnemonic : ROUNDSD Supported forms : (2 forms)

  • ROUNDSD imm8, xmm, xmm [SSE4.1]
  • ROUNDSD imm8, m64, xmm [SSE4.1]

func (*Program) ROUNDSS 

func (self *Program) ROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

ROUNDSS performs "Round Scalar Single Precision Floating-Point Values".

Mnemonic : ROUNDSS Supported forms : (2 forms)

  • ROUNDSS imm8, xmm, xmm [SSE4.1]
  • ROUNDSS imm8, m32, xmm [SSE4.1]

func (*Program) RSQRTPS 

func (self *Program) RSQRTPS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : RSQRTPS Supported forms : (2 forms)

  • RSQRTPS xmm, xmm [SSE]
  • RSQRTPS m128, xmm [SSE]

func (*Program) RSQRTSS 

func (self *Program) RSQRTSS(v0 interface{}, v1 interface{}) *Instruction

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

Mnemonic : RSQRTSS Supported forms : (2 forms)

  • RSQRTSS xmm, xmm [SSE]
  • RSQRTSS m32, xmm [SSE]

func (*Program) SALB 

func (self *Program) SALB(v0 interface{}, v1 interface{}) *Instruction

SALB performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

  • SALB 1, r8
  • SALB imm8, r8
  • SALB cl, r8
  • SALB 1, m8
  • SALB imm8, m8
  • SALB cl, m8

func (*Program) SALL 

func (self *Program) SALL(v0 interface{}, v1 interface{}) *Instruction

SALL performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

  • SALL 1, r32
  • SALL imm8, r32
  • SALL cl, r32
  • SALL 1, m32
  • SALL imm8, m32
  • SALL cl, m32

func (*Program) SALQ 

func (self *Program) SALQ(v0 interface{}, v1 interface{}) *Instruction

SALQ performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

  • SALQ 1, r64
  • SALQ imm8, r64
  • SALQ cl, r64
  • SALQ 1, m64
  • SALQ imm8, m64
  • SALQ cl, m64

func (*Program) SALW 

func (self *Program) SALW(v0 interface{}, v1 interface{}) *Instruction

SALW performs "Arithmetic Shift Left".

Mnemonic : SAL Supported forms : (6 forms)

  • SALW 1, r16
  • SALW imm8, r16
  • SALW cl, r16
  • SALW 1, m16
  • SALW imm8, m16
  • SALW cl, m16

func (*Program) SARB 

func (self *Program) SARB(v0 interface{}, v1 interface{}) *Instruction

SARB performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

  • SARB 1, r8
  • SARB imm8, r8
  • SARB cl, r8
  • SARB 1, m8
  • SARB imm8, m8
  • SARB cl, m8

func (*Program) SARL 

func (self *Program) SARL(v0 interface{}, v1 interface{}) *Instruction

SARL performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

  • SARL 1, r32
  • SARL imm8, r32
  • SARL cl, r32
  • SARL 1, m32
  • SARL imm8, m32
  • SARL cl, m32

func (*Program) SARQ 

func (self *Program) SARQ(v0 interface{}, v1 interface{}) *Instruction

SARQ performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

  • SARQ 1, r64
  • SARQ imm8, r64
  • SARQ cl, r64
  • SARQ 1, m64
  • SARQ imm8, m64
  • SARQ cl, m64

func (*Program) SARW 

func (self *Program) SARW(v0 interface{}, v1 interface{}) *Instruction

SARW performs "Arithmetic Shift Right".

Mnemonic : SAR Supported forms : (6 forms)

  • SARW 1, r16
  • SARW imm8, r16
  • SARW cl, r16
  • SARW 1, m16
  • SARW imm8, m16
  • SARW cl, m16

func (*Program) SARXL 

func (self *Program) SARXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SARXL performs "Arithmetic Shift Right Without Affecting Flags".

Mnemonic : SARX Supported forms : (2 forms)

  • SARXL r32, r32, r32 [BMI2]
  • SARXL r32, m32, r32 [BMI2]

func (*Program) SARXQ 

func (self *Program) SARXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SARXQ performs "Arithmetic Shift Right Without Affecting Flags".

Mnemonic : SARX Supported forms : (2 forms)

  • SARXQ r64, r64, r64 [BMI2]
  • SARXQ r64, m64, r64 [BMI2]

func (*Program) SBBB 

func (self *Program) SBBB(v0 interface{}, v1 interface{}) *Instruction

SBBB performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (6 forms)

  • SBBB imm8, al
  • SBBB imm8, r8
  • SBBB r8, r8
  • SBBB m8, r8
  • SBBB imm8, m8
  • SBBB r8, m8

func (*Program) SBBL 

func (self *Program) SBBL(v0 interface{}, v1 interface{}) *Instruction

SBBL performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (8 forms)

  • SBBL imm32, eax
  • SBBL imm8, r32
  • SBBL imm32, r32
  • SBBL r32, r32
  • SBBL m32, r32
  • SBBL imm8, m32
  • SBBL imm32, m32
  • SBBL r32, m32

func (*Program) SBBQ 

func (self *Program) SBBQ(v0 interface{}, v1 interface{}) *Instruction

SBBQ performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (8 forms)

  • SBBQ imm32, rax
  • SBBQ imm8, r64
  • SBBQ imm32, r64
  • SBBQ r64, r64
  • SBBQ m64, r64
  • SBBQ imm8, m64
  • SBBQ imm32, m64
  • SBBQ r64, m64

func (*Program) SBBW 

func (self *Program) SBBW(v0 interface{}, v1 interface{}) *Instruction

SBBW performs "Subtract with Borrow".

Mnemonic : SBB Supported forms : (8 forms)

  • SBBW imm16, ax
  • SBBW imm8, r16
  • SBBW imm16, r16
  • SBBW r16, r16
  • SBBW m16, r16
  • SBBW imm8, m16
  • SBBW imm16, m16
  • SBBW r16, m16

func (*Program) SETA 

func (self *Program) SETA(v0 interface{}) *Instruction

SETA performs "Set byte if above (CF == 0 and ZF == 0)".

Mnemonic : SETA Supported forms : (2 forms)

  • SETA r8
  • SETA m8

func (*Program) SETAE 

func (self *Program) SETAE(v0 interface{}) *Instruction

SETAE performs "Set byte if above or equal (CF == 0)".

Mnemonic : SETAE Supported forms : (2 forms)

  • SETAE r8
  • SETAE m8

func (*Program) SETB 

func (self *Program) SETB(v0 interface{}) *Instruction

SETB performs "Set byte if below (CF == 1)".

Mnemonic : SETB Supported forms : (2 forms)

  • SETB r8
  • SETB m8

func (*Program) SETBE 

func (self *Program) SETBE(v0 interface{}) *Instruction

SETBE performs "Set byte if below or equal (CF == 1 or ZF == 1)".

Mnemonic : SETBE Supported forms : (2 forms)

  • SETBE r8
  • SETBE m8

func (*Program) SETC 

func (self *Program) SETC(v0 interface{}) *Instruction

SETC performs "Set byte if carry (CF == 1)".

Mnemonic : SETC Supported forms : (2 forms)

  • SETC r8
  • SETC m8

func (*Program) SETE 

func (self *Program) SETE(v0 interface{}) *Instruction

SETE performs "Set byte if equal (ZF == 1)".

Mnemonic : SETE Supported forms : (2 forms)

  • SETE r8
  • SETE m8

func (*Program) SETG 

func (self *Program) SETG(v0 interface{}) *Instruction

SETG performs "Set byte if greater (ZF == 0 and SF == OF)".

Mnemonic : SETG Supported forms : (2 forms)

  • SETG r8
  • SETG m8

func (*Program) SETGE 

func (self *Program) SETGE(v0 interface{}) *Instruction

SETGE performs "Set byte if greater or equal (SF == OF)".

Mnemonic : SETGE Supported forms : (2 forms)

  • SETGE r8
  • SETGE m8

func (*Program) SETL 

func (self *Program) SETL(v0 interface{}) *Instruction

SETL performs "Set byte if less (SF != OF)".

Mnemonic : SETL Supported forms : (2 forms)

  • SETL r8
  • SETL m8

func (*Program) SETLE 

func (self *Program) SETLE(v0 interface{}) *Instruction

SETLE performs "Set byte if less or equal (ZF == 1 or SF != OF)".

Mnemonic : SETLE Supported forms : (2 forms)

  • SETLE r8
  • SETLE m8

func (*Program) SETNA 

func (self *Program) SETNA(v0 interface{}) *Instruction

SETNA performs "Set byte if not above (CF == 1 or ZF == 1)".

Mnemonic : SETNA Supported forms : (2 forms)

  • SETNA r8
  • SETNA m8

func (*Program) SETNAE 

func (self *Program) SETNAE(v0 interface{}) *Instruction

SETNAE performs "Set byte if not above or equal (CF == 1)".

Mnemonic : SETNAE Supported forms : (2 forms)

  • SETNAE r8
  • SETNAE m8

func (*Program) SETNB 

func (self *Program) SETNB(v0 interface{}) *Instruction

SETNB performs "Set byte if not below (CF == 0)".

Mnemonic : SETNB Supported forms : (2 forms)

  • SETNB r8
  • SETNB m8

func (*Program) SETNBE 

func (self *Program) SETNBE(v0 interface{}) *Instruction

SETNBE performs "Set byte if not below or equal (CF == 0 and ZF == 0)".

Mnemonic : SETNBE Supported forms : (2 forms)

  • SETNBE r8
  • SETNBE m8

func (*Program) SETNC 

func (self *Program) SETNC(v0 interface{}) *Instruction

SETNC performs "Set byte if not carry (CF == 0)".

Mnemonic : SETNC Supported forms : (2 forms)

  • SETNC r8
  • SETNC m8

func (*Program) SETNE 

func (self *Program) SETNE(v0 interface{}) *Instruction

SETNE performs "Set byte if not equal (ZF == 0)".

Mnemonic : SETNE Supported forms : (2 forms)

  • SETNE r8
  • SETNE m8

func (*Program) SETNG 

func (self *Program) SETNG(v0 interface{}) *Instruction

SETNG performs "Set byte if not greater (ZF == 1 or SF != OF)".

Mnemonic : SETNG Supported forms : (2 forms)

  • SETNG r8
  • SETNG m8

func (*Program) SETNGE 

func (self *Program) SETNGE(v0 interface{}) *Instruction

SETNGE performs "Set byte if not greater or equal (SF != OF)".

Mnemonic : SETNGE Supported forms : (2 forms)

  • SETNGE r8
  • SETNGE m8

func (*Program) SETNL 

func (self *Program) SETNL(v0 interface{}) *Instruction

SETNL performs "Set byte if not less (SF == OF)".

Mnemonic : SETNL Supported forms : (2 forms)

  • SETNL r8
  • SETNL m8

func (*Program) SETNLE 

func (self *Program) SETNLE(v0 interface{}) *Instruction

SETNLE performs "Set byte if not less or equal (ZF == 0 and SF == OF)".

Mnemonic : SETNLE Supported forms : (2 forms)

  • SETNLE r8
  • SETNLE m8

func (*Program) SETNO 

func (self *Program) SETNO(v0 interface{}) *Instruction

SETNO performs "Set byte if not overflow (OF == 0)".

Mnemonic : SETNO Supported forms : (2 forms)

  • SETNO r8
  • SETNO m8

func (*Program) SETNP 

func (self *Program) SETNP(v0 interface{}) *Instruction

SETNP performs "Set byte if not parity (PF == 0)".

Mnemonic : SETNP Supported forms : (2 forms)

  • SETNP r8
  • SETNP m8

func (*Program) SETNS 

func (self *Program) SETNS(v0 interface{}) *Instruction

SETNS performs "Set byte if not sign (SF == 0)".

Mnemonic : SETNS Supported forms : (2 forms)

  • SETNS r8
  • SETNS m8

func (*Program) SETNZ 

func (self *Program) SETNZ(v0 interface{}) *Instruction

SETNZ performs "Set byte if not zero (ZF == 0)".

Mnemonic : SETNZ Supported forms : (2 forms)

  • SETNZ r8
  • SETNZ m8

func (*Program) SETO 

func (self *Program) SETO(v0 interface{}) *Instruction

SETO performs "Set byte if overflow (OF == 1)".

Mnemonic : SETO Supported forms : (2 forms)

  • SETO r8
  • SETO m8

func (*Program) SETP 

func (self *Program) SETP(v0 interface{}) *Instruction

SETP performs "Set byte if parity (PF == 1)".

Mnemonic : SETP Supported forms : (2 forms)

  • SETP r8
  • SETP m8

func (*Program) SETPE 

func (self *Program) SETPE(v0 interface{}) *Instruction

SETPE performs "Set byte if parity even (PF == 1)".

Mnemonic : SETPE Supported forms : (2 forms)

  • SETPE r8
  • SETPE m8

func (*Program) SETPO 

func (self *Program) SETPO(v0 interface{}) *Instruction

SETPO performs "Set byte if parity odd (PF == 0)".

Mnemonic : SETPO Supported forms : (2 forms)

  • SETPO r8
  • SETPO m8

func (*Program) SETS 

func (self *Program) SETS(v0 interface{}) *Instruction

SETS performs "Set byte if sign (SF == 1)".

Mnemonic : SETS Supported forms : (2 forms)

  • SETS r8
  • SETS m8

func (*Program) SETZ 

func (self *Program) SETZ(v0 interface{}) *Instruction

SETZ performs "Set byte if zero (ZF == 1)".

Mnemonic : SETZ Supported forms : (2 forms)

  • SETZ r8
  • SETZ m8

func (*Program) SFENCE 

func (self *Program) SFENCE() *Instruction

SFENCE performs "Store Fence".

Mnemonic : SFENCE Supported forms : (1 form)

  • SFENCE [MMX+]

func (*Program) SHA1MSG1 

func (self *Program) SHA1MSG1(v0 interface{}, v1 interface{}) *Instruction

SHA1MSG1 performs "Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords".

Mnemonic : SHA1MSG1 Supported forms : (2 forms)

  • SHA1MSG1 xmm, xmm [SHA]
  • SHA1MSG1 m128, xmm [SHA]

func (*Program) SHA1MSG2 

func (self *Program) SHA1MSG2(v0 interface{}, v1 interface{}) *Instruction

SHA1MSG2 performs "Perform a Final Calculation for the Next Four SHA1 Message Doublewords".

Mnemonic : SHA1MSG2 Supported forms : (2 forms)

  • SHA1MSG2 xmm, xmm [SHA]
  • SHA1MSG2 m128, xmm [SHA]

func (*Program) SHA1NEXTE 

func (self *Program) SHA1NEXTE(v0 interface{}, v1 interface{}) *Instruction

SHA1NEXTE performs "Calculate SHA1 State Variable E after Four Rounds".

Mnemonic : SHA1NEXTE Supported forms : (2 forms)

  • SHA1NEXTE xmm, xmm [SHA]
  • SHA1NEXTE m128, xmm [SHA]

func (*Program) SHA1RNDS4 

func (self *Program) SHA1RNDS4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHA1RNDS4 performs "Perform Four Rounds of SHA1 Operation".

Mnemonic : SHA1RNDS4 Supported forms : (2 forms)

  • SHA1RNDS4 imm8, xmm, xmm [SHA]
  • SHA1RNDS4 imm8, m128, xmm [SHA]

func (*Program) SHA256MSG1 

func (self *Program) SHA256MSG1(v0 interface{}, v1 interface{}) *Instruction

SHA256MSG1 performs "Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords".

Mnemonic : SHA256MSG1 Supported forms : (2 forms)

  • SHA256MSG1 xmm, xmm [SHA]
  • SHA256MSG1 m128, xmm [SHA]

func (*Program) SHA256MSG2 

func (self *Program) SHA256MSG2(v0 interface{}, v1 interface{}) *Instruction

SHA256MSG2 performs "Perform a Final Calculation for the Next Four SHA256 Message Doublewords".

Mnemonic : SHA256MSG2 Supported forms : (2 forms)

  • SHA256MSG2 xmm, xmm [SHA]
  • SHA256MSG2 m128, xmm [SHA]

func (*Program) SHA256RNDS2 

func (self *Program) SHA256RNDS2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHA256RNDS2 performs "Perform Two Rounds of SHA256 Operation".

Mnemonic : SHA256RNDS2 Supported forms : (2 forms)

  • SHA256RNDS2 xmm0, xmm, xmm [SHA]
  • SHA256RNDS2 xmm0, m128, xmm [SHA]

func (*Program) SHLB 

func (self *Program) SHLB(v0 interface{}, v1 interface{}) *Instruction

SHLB performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

  • SHLB 1, r8
  • SHLB imm8, r8
  • SHLB cl, r8
  • SHLB 1, m8
  • SHLB imm8, m8
  • SHLB cl, m8

func (*Program) SHLDL 

func (self *Program) SHLDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLDL performs "Integer Double Precision Shift Left".

Mnemonic : SHLD Supported forms : (4 forms)

  • SHLDL imm8, r32, r32
  • SHLDL cl, r32, r32
  • SHLDL imm8, r32, m32
  • SHLDL cl, r32, m32

func (*Program) SHLDQ 

func (self *Program) SHLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLDQ performs "Integer Double Precision Shift Left".

Mnemonic : SHLD Supported forms : (4 forms)

  • SHLDQ imm8, r64, r64
  • SHLDQ cl, r64, r64
  • SHLDQ imm8, r64, m64
  • SHLDQ cl, r64, m64

func (*Program) SHLDW 

func (self *Program) SHLDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLDW performs "Integer Double Precision Shift Left".

Mnemonic : SHLD Supported forms : (4 forms)

  • SHLDW imm8, r16, r16
  • SHLDW cl, r16, r16
  • SHLDW imm8, r16, m16
  • SHLDW cl, r16, m16

func (*Program) SHLL 

func (self *Program) SHLL(v0 interface{}, v1 interface{}) *Instruction

SHLL performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

  • SHLL 1, r32
  • SHLL imm8, r32
  • SHLL cl, r32
  • SHLL 1, m32
  • SHLL imm8, m32
  • SHLL cl, m32

func (*Program) SHLQ 

func (self *Program) SHLQ(v0 interface{}, v1 interface{}) *Instruction

SHLQ performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

  • SHLQ 1, r64
  • SHLQ imm8, r64
  • SHLQ cl, r64
  • SHLQ 1, m64
  • SHLQ imm8, m64
  • SHLQ cl, m64

func (*Program) SHLW 

func (self *Program) SHLW(v0 interface{}, v1 interface{}) *Instruction

SHLW performs "Logical Shift Left".

Mnemonic : SHL Supported forms : (6 forms)

  • SHLW 1, r16
  • SHLW imm8, r16
  • SHLW cl, r16
  • SHLW 1, m16
  • SHLW imm8, m16
  • SHLW cl, m16

func (*Program) SHLXL 

func (self *Program) SHLXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLXL performs "Logical Shift Left Without Affecting Flags".

Mnemonic : SHLX Supported forms : (2 forms)

  • SHLXL r32, r32, r32 [BMI2]
  • SHLXL r32, m32, r32 [BMI2]

func (*Program) SHLXQ 

func (self *Program) SHLXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHLXQ performs "Logical Shift Left Without Affecting Flags".

Mnemonic : SHLX Supported forms : (2 forms)

  • SHLXQ r64, r64, r64 [BMI2]
  • SHLXQ r64, m64, r64 [BMI2]

func (*Program) SHRB 

func (self *Program) SHRB(v0 interface{}, v1 interface{}) *Instruction

SHRB performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

  • SHRB 1, r8
  • SHRB imm8, r8
  • SHRB cl, r8
  • SHRB 1, m8
  • SHRB imm8, m8
  • SHRB cl, m8

func (*Program) SHRDL 

func (self *Program) SHRDL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRDL performs "Integer Double Precision Shift Right".

Mnemonic : SHRD Supported forms : (4 forms)

  • SHRDL imm8, r32, r32
  • SHRDL cl, r32, r32
  • SHRDL imm8, r32, m32
  • SHRDL cl, r32, m32

func (*Program) SHRDQ 

func (self *Program) SHRDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRDQ performs "Integer Double Precision Shift Right".

Mnemonic : SHRD Supported forms : (4 forms)

  • SHRDQ imm8, r64, r64
  • SHRDQ cl, r64, r64
  • SHRDQ imm8, r64, m64
  • SHRDQ cl, r64, m64

func (*Program) SHRDW 

func (self *Program) SHRDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRDW performs "Integer Double Precision Shift Right".

Mnemonic : SHRD Supported forms : (4 forms)

  • SHRDW imm8, r16, r16
  • SHRDW cl, r16, r16
  • SHRDW imm8, r16, m16
  • SHRDW cl, r16, m16

func (*Program) SHRL 

func (self *Program) SHRL(v0 interface{}, v1 interface{}) *Instruction

SHRL performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

  • SHRL 1, r32
  • SHRL imm8, r32
  • SHRL cl, r32
  • SHRL 1, m32
  • SHRL imm8, m32
  • SHRL cl, m32

func (*Program) SHRQ 

func (self *Program) SHRQ(v0 interface{}, v1 interface{}) *Instruction

SHRQ performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

  • SHRQ 1, r64
  • SHRQ imm8, r64
  • SHRQ cl, r64
  • SHRQ 1, m64
  • SHRQ imm8, m64
  • SHRQ cl, m64

func (*Program) SHRW 

func (self *Program) SHRW(v0 interface{}, v1 interface{}) *Instruction

SHRW performs "Logical Shift Right".

Mnemonic : SHR Supported forms : (6 forms)

  • SHRW 1, r16
  • SHRW imm8, r16
  • SHRW cl, r16
  • SHRW 1, m16
  • SHRW imm8, m16
  • SHRW cl, m16

func (*Program) SHRXL 

func (self *Program) SHRXL(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRXL performs "Logical Shift Right Without Affecting Flags".

Mnemonic : SHRX Supported forms : (2 forms)

  • SHRXL r32, r32, r32 [BMI2]
  • SHRXL r32, m32, r32 [BMI2]

func (*Program) SHRXQ 

func (self *Program) SHRXQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHRXQ performs "Logical Shift Right Without Affecting Flags".

Mnemonic : SHRX Supported forms : (2 forms)

  • SHRXQ r64, r64, r64 [BMI2]
  • SHRXQ r64, m64, r64 [BMI2]

func (*Program) SHUFPD 

func (self *Program) SHUFPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHUFPD performs "Shuffle Packed Double-Precision Floating-Point Values".

Mnemonic : SHUFPD Supported forms : (2 forms)

  • SHUFPD imm8, xmm, xmm [SSE2]
  • SHUFPD imm8, m128, xmm [SSE2]

func (*Program) SHUFPS 

func (self *Program) SHUFPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

SHUFPS performs "Shuffle Packed Single-Precision Floating-Point Values".

Mnemonic : SHUFPS Supported forms : (2 forms)

  • SHUFPS imm8, xmm, xmm [SSE]
  • SHUFPS imm8, m128, xmm [SSE]

func (*Program) SQRTPD 

func (self *Program) SQRTPD(v0 interface{}, v1 interface{}) *Instruction

SQRTPD performs "Compute Square Roots of Packed Double-Precision Floating-Point Values".

Mnemonic : SQRTPD Supported forms : (2 forms)

  • SQRTPD xmm, xmm [SSE2]
  • SQRTPD m128, xmm [SSE2]

func (*Program) SQRTPS 

func (self *Program) SQRTPS(v0 interface{}, v1 interface{}) *Instruction

SQRTPS performs "Compute Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : SQRTPS Supported forms : (2 forms)

  • SQRTPS xmm, xmm [SSE]
  • SQRTPS m128, xmm [SSE]

func (*Program) SQRTSD 

func (self *Program) SQRTSD(v0 interface{}, v1 interface{}) *Instruction

SQRTSD performs "Compute Square Root of Scalar Double-Precision Floating-Point Value".

Mnemonic : SQRTSD Supported forms : (2 forms)

  • SQRTSD xmm, xmm [SSE2]
  • SQRTSD m64, xmm [SSE2]

func (*Program) SQRTSS 

func (self *Program) SQRTSS(v0 interface{}, v1 interface{}) *Instruction

SQRTSS performs "Compute Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : SQRTSS Supported forms : (2 forms)

  • SQRTSS xmm, xmm [SSE]
  • SQRTSS m32, xmm [SSE]

func (*Program) STC 

func (self *Program) STC() *Instruction

STC performs "Set Carry Flag".

Mnemonic : STC Supported forms : (1 form)

  • STC

func (*Program) STD 

func (self *Program) STD() *Instruction

STD performs "Set Direction Flag".

Mnemonic : STD Supported forms : (1 form)

  • STD

func (*Program) STMXCSR 

func (self *Program) STMXCSR(v0 interface{}) *Instruction

STMXCSR performs "Store MXCSR Register State".

Mnemonic : STMXCSR Supported forms : (1 form)

  • STMXCSR m32 [SSE]

func (*Program) SUBB 

func (self *Program) SUBB(v0 interface{}, v1 interface{}) *Instruction

SUBB performs "Subtract".

Mnemonic : SUB Supported forms : (6 forms)

  • SUBB imm8, al
  • SUBB imm8, r8
  • SUBB r8, r8
  • SUBB m8, r8
  • SUBB imm8, m8
  • SUBB r8, m8

func (*Program) SUBL 

func (self *Program) SUBL(v0 interface{}, v1 interface{}) *Instruction

SUBL performs "Subtract".

Mnemonic : SUB Supported forms : (8 forms)

  • SUBL imm32, eax
  • SUBL imm8, r32
  • SUBL imm32, r32
  • SUBL r32, r32
  • SUBL m32, r32
  • SUBL imm8, m32
  • SUBL imm32, m32
  • SUBL r32, m32

func (*Program) SUBPD 

func (self *Program) SUBPD(v0 interface{}, v1 interface{}) *Instruction

SUBPD performs "Subtract Packed Double-Precision Floating-Point Values".

Mnemonic : SUBPD Supported forms : (2 forms)

  • SUBPD xmm, xmm [SSE2]
  • SUBPD m128, xmm [SSE2]

func (*Program) SUBPS 

func (self *Program) SUBPS(v0 interface{}, v1 interface{}) *Instruction

SUBPS performs "Subtract Packed Single-Precision Floating-Point Values".

Mnemonic : SUBPS Supported forms : (2 forms)

  • SUBPS xmm, xmm [SSE]
  • SUBPS m128, xmm [SSE]

func (*Program) SUBQ 

func (self *Program) SUBQ(v0 interface{}, v1 interface{}) *Instruction

SUBQ performs "Subtract".

Mnemonic : SUB Supported forms : (8 forms)

  • SUBQ imm32, rax
  • SUBQ imm8, r64
  • SUBQ imm32, r64
  • SUBQ r64, r64
  • SUBQ m64, r64
  • SUBQ imm8, m64
  • SUBQ imm32, m64
  • SUBQ r64, m64

func (*Program) SUBSD 

func (self *Program) SUBSD(v0 interface{}, v1 interface{}) *Instruction

SUBSD performs "Subtract Scalar Double-Precision Floating-Point Values".

Mnemonic : SUBSD Supported forms : (2 forms)

  • SUBSD xmm, xmm [SSE2]
  • SUBSD m64, xmm [SSE2]

func (*Program) SUBSS 

func (self *Program) SUBSS(v0 interface{}, v1 interface{}) *Instruction

SUBSS performs "Subtract Scalar Single-Precision Floating-Point Values".

Mnemonic : SUBSS Supported forms : (2 forms)

  • SUBSS xmm, xmm [SSE]
  • SUBSS m32, xmm [SSE]

func (*Program) SUBW 

func (self *Program) SUBW(v0 interface{}, v1 interface{}) *Instruction

SUBW performs "Subtract".

Mnemonic : SUB Supported forms : (8 forms)

  • SUBW imm16, ax
  • SUBW imm8, r16
  • SUBW imm16, r16
  • SUBW r16, r16
  • SUBW m16, r16
  • SUBW imm8, m16
  • SUBW imm16, m16
  • SUBW r16, m16

func (*Program) SYSCALL 

func (self *Program) SYSCALL() *Instruction

SYSCALL performs "Fast System Call".

Mnemonic : SYSCALL Supported forms : (1 form)

  • SYSCALL

func (*Program) T1MSKC 

func (self *Program) T1MSKC(v0 interface{}, v1 interface{}) *Instruction

T1MSKC performs "Inverse Mask From Trailing Ones".

Mnemonic : T1MSKC Supported forms : (4 forms)

  • T1MSKC r32, r32 [TBM]
  • T1MSKC m32, r32 [TBM]
  • T1MSKC r64, r64 [TBM]
  • T1MSKC m64, r64 [TBM]

func (*Program) TESTB 

func (self *Program) TESTB(v0 interface{}, v1 interface{}) *Instruction

TESTB performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

  • TESTB imm8, al
  • TESTB imm8, r8
  • TESTB r8, r8
  • TESTB imm8, m8
  • TESTB r8, m8

func (*Program) TESTL 

func (self *Program) TESTL(v0 interface{}, v1 interface{}) *Instruction

TESTL performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

  • TESTL imm32, eax
  • TESTL imm32, r32
  • TESTL r32, r32
  • TESTL imm32, m32
  • TESTL r32, m32

func (*Program) TESTQ 

func (self *Program) TESTQ(v0 interface{}, v1 interface{}) *Instruction

TESTQ performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

  • TESTQ imm32, rax
  • TESTQ imm32, r64
  • TESTQ r64, r64
  • TESTQ imm32, m64
  • TESTQ r64, m64

func (*Program) TESTW 

func (self *Program) TESTW(v0 interface{}, v1 interface{}) *Instruction

TESTW performs "Logical Compare".

Mnemonic : TEST Supported forms : (5 forms)

  • TESTW imm16, ax
  • TESTW imm16, r16
  • TESTW r16, r16
  • TESTW imm16, m16
  • TESTW r16, m16

func (*Program) TZCNTL 

func (self *Program) TZCNTL(v0 interface{}, v1 interface{}) *Instruction

TZCNTL performs "Count the Number of Trailing Zero Bits".

Mnemonic : TZCNT Supported forms : (2 forms)

  • TZCNTL r32, r32 [BMI]
  • TZCNTL m32, r32 [BMI]

func (*Program) TZCNTQ 

func (self *Program) TZCNTQ(v0 interface{}, v1 interface{}) *Instruction

TZCNTQ performs "Count the Number of Trailing Zero Bits".

Mnemonic : TZCNT Supported forms : (2 forms)

  • TZCNTQ r64, r64 [BMI]
  • TZCNTQ m64, r64 [BMI]

func (*Program) TZCNTW 

func (self *Program) TZCNTW(v0 interface{}, v1 interface{}) *Instruction

TZCNTW performs "Count the Number of Trailing Zero Bits".

Mnemonic : TZCNT Supported forms : (2 forms)

  • TZCNTW r16, r16 [BMI]
  • TZCNTW m16, r16 [BMI]

func (*Program) TZMSK 

func (self *Program) TZMSK(v0 interface{}, v1 interface{}) *Instruction

TZMSK performs "Mask From Trailing Zeros".

Mnemonic : TZMSK Supported forms : (4 forms)

  • TZMSK r32, r32 [TBM]
  • TZMSK m32, r32 [TBM]
  • TZMSK r64, r64 [TBM]
  • TZMSK m64, r64 [TBM]

func (*Program) UCOMISD 

func (self *Program) UCOMISD(v0 interface{}, v1 interface{}) *Instruction

UCOMISD performs "Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : UCOMISD Supported forms : (2 forms)

  • UCOMISD xmm, xmm [SSE2]
  • UCOMISD m64, xmm [SSE2]

func (*Program) UCOMISS 

func (self *Program) UCOMISS(v0 interface{}, v1 interface{}) *Instruction

UCOMISS performs "Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : UCOMISS Supported forms : (2 forms)

  • UCOMISS xmm, xmm [SSE]
  • UCOMISS m32, xmm [SSE]

func (*Program) UD2 

func (self *Program) UD2() *Instruction

UD2 performs "Undefined Instruction".

Mnemonic : UD2 Supported forms : (1 form)

  • UD2

func (*Program) UNPCKHPD 

func (self *Program) UNPCKHPD(v0 interface{}, v1 interface{}) *Instruction

UNPCKHPD performs "Unpack and Interleave High Packed Double-Precision Floating-Point Values".

Mnemonic : UNPCKHPD Supported forms : (2 forms)

  • UNPCKHPD xmm, xmm [SSE2]
  • UNPCKHPD m128, xmm [SSE2]

func (*Program) UNPCKHPS 

func (self *Program) UNPCKHPS(v0 interface{}, v1 interface{}) *Instruction

UNPCKHPS performs "Unpack and Interleave High Packed Single-Precision Floating-Point Values".

Mnemonic : UNPCKHPS Supported forms : (2 forms)

  • UNPCKHPS xmm, xmm [SSE]
  • UNPCKHPS m128, xmm [SSE]

func (*Program) UNPCKLPD 

func (self *Program) UNPCKLPD(v0 interface{}, v1 interface{}) *Instruction

UNPCKLPD performs "Unpack and Interleave Low Packed Double-Precision Floating-Point Values".

Mnemonic : UNPCKLPD Supported forms : (2 forms)

  • UNPCKLPD xmm, xmm [SSE2]
  • UNPCKLPD m128, xmm [SSE2]

func (*Program) UNPCKLPS 

func (self *Program) UNPCKLPS(v0 interface{}, v1 interface{}) *Instruction

UNPCKLPS performs "Unpack and Interleave Low Packed Single-Precision Floating-Point Values".

Mnemonic : UNPCKLPS Supported forms : (2 forms)

  • UNPCKLPS xmm, xmm [SSE]
  • UNPCKLPS m128, xmm [SSE]

func (*Program) VADDPD 

func (self *Program) VADDPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDPD performs "Add Packed Double-Precision Floating-Point Values".

Mnemonic : VADDPD Supported forms : (11 forms)

  • VADDPD xmm, xmm, xmm [AVX]
  • VADDPD m128, xmm, xmm [AVX]
  • VADDPD ymm, ymm, ymm [AVX]
  • VADDPD m256, ymm, ymm [AVX]
  • VADDPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VADDPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VADDPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VADDPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VADDPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VADDPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VADDPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VADDPS 

func (self *Program) VADDPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDPS performs "Add Packed Single-Precision Floating-Point Values".

Mnemonic : VADDPS Supported forms : (11 forms)

  • VADDPS xmm, xmm, xmm [AVX]
  • VADDPS m128, xmm, xmm [AVX]
  • VADDPS ymm, ymm, ymm [AVX]
  • VADDPS m256, ymm, ymm [AVX]
  • VADDPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VADDPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VADDPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VADDPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VADDPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VADDPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VADDPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VADDSD 

func (self *Program) VADDSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDSD performs "Add Scalar Double-Precision Floating-Point Values".

Mnemonic : VADDSD Supported forms : (5 forms)

  • VADDSD xmm, xmm, xmm [AVX]
  • VADDSD m64, xmm, xmm [AVX]
  • VADDSD m64, xmm, xmm{k}{z} [AVX512F]
  • VADDSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VADDSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VADDSS 

func (self *Program) VADDSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VADDSS performs "Add Scalar Single-Precision Floating-Point Values".

Mnemonic : VADDSS Supported forms : (5 forms)

  • VADDSS xmm, xmm, xmm [AVX]
  • VADDSS m32, xmm, xmm [AVX]
  • VADDSS m32, xmm, xmm{k}{z} [AVX512F]
  • VADDSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VADDSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VADDSUBPD 

func (self *Program) VADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VADDSUBPD performs "Packed Double-FP Add/Subtract".

Mnemonic : VADDSUBPD Supported forms : (4 forms)

  • VADDSUBPD xmm, xmm, xmm [AVX]
  • VADDSUBPD m128, xmm, xmm [AVX]
  • VADDSUBPD ymm, ymm, ymm [AVX]
  • VADDSUBPD m256, ymm, ymm [AVX]

func (*Program) VADDSUBPS 

func (self *Program) VADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VADDSUBPS performs "Packed Single-FP Add/Subtract".

Mnemonic : VADDSUBPS Supported forms : (4 forms)

  • VADDSUBPS xmm, xmm, xmm [AVX]
  • VADDSUBPS m128, xmm, xmm [AVX]
  • VADDSUBPS ymm, ymm, ymm [AVX]
  • VADDSUBPS m256, ymm, ymm [AVX]

func (*Program) VAESDEC 

func (self *Program) VAESDEC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESDEC performs "Perform One Round of an AES Decryption Flow".

Mnemonic : VAESDEC Supported forms : (2 forms)

  • VAESDEC xmm, xmm, xmm [AES,AVX]
  • VAESDEC m128, xmm, xmm [AES,AVX]

func (*Program) VAESDECLAST 

func (self *Program) VAESDECLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESDECLAST performs "Perform Last Round of an AES Decryption Flow".

Mnemonic : VAESDECLAST Supported forms : (2 forms)

  • VAESDECLAST xmm, xmm, xmm [AES,AVX]
  • VAESDECLAST m128, xmm, xmm [AES,AVX]

func (*Program) VAESENC 

func (self *Program) VAESENC(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESENC performs "Perform One Round of an AES Encryption Flow".

Mnemonic : VAESENC Supported forms : (2 forms)

  • VAESENC xmm, xmm, xmm [AES,AVX]
  • VAESENC m128, xmm, xmm [AES,AVX]

func (*Program) VAESENCLAST 

func (self *Program) VAESENCLAST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESENCLAST performs "Perform Last Round of an AES Encryption Flow".

Mnemonic : VAESENCLAST Supported forms : (2 forms)

  • VAESENCLAST xmm, xmm, xmm [AES,AVX]
  • VAESENCLAST m128, xmm, xmm [AES,AVX]

func (*Program) VAESIMC 

func (self *Program) VAESIMC(v0 interface{}, v1 interface{}) *Instruction

VAESIMC performs "Perform the AES InvMixColumn Transformation".

Mnemonic : VAESIMC Supported forms : (2 forms)

  • VAESIMC xmm, xmm [AES,AVX]
  • VAESIMC m128, xmm [AES,AVX]

func (*Program) VAESKEYGENASSIST 

func (self *Program) VAESKEYGENASSIST(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VAESKEYGENASSIST performs "AES Round Key Generation Assist".

Mnemonic : VAESKEYGENASSIST Supported forms : (2 forms)

  • VAESKEYGENASSIST imm8, xmm, xmm [AES,AVX]
  • VAESKEYGENASSIST imm8, m128, xmm [AES,AVX]

func (*Program) VALIGND 

func (self *Program) VALIGND(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VALIGND performs "Align Doubleword Vectors".

Mnemonic : VALIGND Supported forms : (6 forms)

  • VALIGND imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VALIGND imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VALIGND imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VALIGND imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VALIGND imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VALIGND imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VALIGNQ 

func (self *Program) VALIGNQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VALIGNQ performs "Align Quadword Vectors".

Mnemonic : VALIGNQ Supported forms : (6 forms)

  • VALIGNQ imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VALIGNQ imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VALIGNQ imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VALIGNQ imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VALIGNQ imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VALIGNQ imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VANDNPD 

func (self *Program) VANDNPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDNPD performs "Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values".

Mnemonic : VANDNPD Supported forms : (10 forms)

  • VANDNPD xmm, xmm, xmm [AVX]
  • VANDNPD m128, xmm, xmm [AVX]
  • VANDNPD ymm, ymm, ymm [AVX]
  • VANDNPD m256, ymm, ymm [AVX]
  • VANDNPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VANDNPD zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VANDNPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDNPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDNPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VANDNPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VANDNPS 

func (self *Program) VANDNPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDNPS performs "Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values".

Mnemonic : VANDNPS Supported forms : (10 forms)

  • VANDNPS xmm, xmm, xmm [AVX]
  • VANDNPS m128, xmm, xmm [AVX]
  • VANDNPS ymm, ymm, ymm [AVX]
  • VANDNPS m256, ymm, ymm [AVX]
  • VANDNPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VANDNPS zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VANDNPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDNPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDNPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VANDNPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VANDPD 

func (self *Program) VANDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDPD performs "Bitwise Logical AND of Packed Double-Precision Floating-Point Values".

Mnemonic : VANDPD Supported forms : (10 forms)

  • VANDPD xmm, xmm, xmm [AVX]
  • VANDPD m128, xmm, xmm [AVX]
  • VANDPD ymm, ymm, ymm [AVX]
  • VANDPD m256, ymm, ymm [AVX]
  • VANDPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VANDPD zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VANDPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VANDPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VANDPS 

func (self *Program) VANDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VANDPS performs "Bitwise Logical AND of Packed Single-Precision Floating-Point Values".

Mnemonic : VANDPS Supported forms : (10 forms)

  • VANDPS xmm, xmm, xmm [AVX]
  • VANDPS m128, xmm, xmm [AVX]
  • VANDPS ymm, ymm, ymm [AVX]
  • VANDPS m256, ymm, ymm [AVX]
  • VANDPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VANDPS zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VANDPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VANDPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VANDPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VBLENDMPD 

func (self *Program) VBLENDMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VBLENDMPD performs "Blend Packed Double-Precision Floating-Point Vectors Using an OpMask Control".

Mnemonic : VBLENDMPD Supported forms : (6 forms)

  • VBLENDMPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VBLENDMPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VBLENDMPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VBLENDMPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VBLENDMPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VBLENDMPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VBLENDMPS 

func (self *Program) VBLENDMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VBLENDMPS performs "Blend Packed Single-Precision Floating-Point Vectors Using an OpMask Control".

Mnemonic : VBLENDMPS Supported forms : (6 forms)

  • VBLENDMPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VBLENDMPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VBLENDMPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VBLENDMPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VBLENDMPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VBLENDMPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VBLENDPD 

func (self *Program) VBLENDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDPD performs "Blend Packed Double Precision Floating-Point Values".

Mnemonic : VBLENDPD Supported forms : (4 forms)

  • VBLENDPD imm8, xmm, xmm, xmm [AVX]
  • VBLENDPD imm8, m128, xmm, xmm [AVX]
  • VBLENDPD imm8, ymm, ymm, ymm [AVX]
  • VBLENDPD imm8, m256, ymm, ymm [AVX]

func (*Program) VBLENDPS 

func (self *Program) VBLENDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDPS performs " Blend Packed Single Precision Floating-Point Values".

Mnemonic : VBLENDPS Supported forms : (4 forms)

  • VBLENDPS imm8, xmm, xmm, xmm [AVX]
  • VBLENDPS imm8, m128, xmm, xmm [AVX]
  • VBLENDPS imm8, ymm, ymm, ymm [AVX]
  • VBLENDPS imm8, m256, ymm, ymm [AVX]

func (*Program) VBLENDVPD 

func (self *Program) VBLENDVPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDVPD performs " Variable Blend Packed Double Precision Floating-Point Values".

Mnemonic : VBLENDVPD Supported forms : (4 forms)

  • VBLENDVPD xmm, xmm, xmm, xmm [AVX]
  • VBLENDVPD xmm, m128, xmm, xmm [AVX]
  • VBLENDVPD ymm, ymm, ymm, ymm [AVX]
  • VBLENDVPD ymm, m256, ymm, ymm [AVX]

func (*Program) VBLENDVPS 

func (self *Program) VBLENDVPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VBLENDVPS performs " Variable Blend Packed Single Precision Floating-Point Values".

Mnemonic : VBLENDVPS Supported forms : (4 forms)

  • VBLENDVPS xmm, xmm, xmm, xmm [AVX]
  • VBLENDVPS xmm, m128, xmm, xmm [AVX]
  • VBLENDVPS ymm, ymm, ymm, ymm [AVX]
  • VBLENDVPS ymm, m256, ymm, ymm [AVX]

func (*Program) VBROADCASTF128 

func (self *Program) VBROADCASTF128(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF128 performs "Broadcast 128 Bit of Floating-Point Data".

Mnemonic : VBROADCASTF128 Supported forms : (1 form)

  • VBROADCASTF128 m128, ymm [AVX]

func (*Program) VBROADCASTF32X2 

func (self *Program) VBROADCASTF32X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF32X2 performs "Broadcast Two Single-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF32X2 Supported forms : (4 forms)

  • VBROADCASTF32X2 xmm, zmm{k}{z} [AVX512DQ]
  • VBROADCASTF32X2 m64, zmm{k}{z} [AVX512DQ]
  • VBROADCASTF32X2 xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VBROADCASTF32X2 m64, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VBROADCASTF32X4 

func (self *Program) VBROADCASTF32X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF32X4 performs "Broadcast Four Single-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF32X4 Supported forms : (2 forms)

  • VBROADCASTF32X4 m128, zmm{k}{z} [AVX512F]
  • VBROADCASTF32X4 m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VBROADCASTF32X8 

func (self *Program) VBROADCASTF32X8(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF32X8 performs "Broadcast Eight Single-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF32X8 Supported forms : (1 form)

  • VBROADCASTF32X8 m256, zmm{k}{z} [AVX512DQ]

func (*Program) VBROADCASTF64X2 

func (self *Program) VBROADCASTF64X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF64X2 performs "Broadcast Two Double-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF64X2 Supported forms : (2 forms)

  • VBROADCASTF64X2 m128, zmm{k}{z} [AVX512DQ]
  • VBROADCASTF64X2 m128, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VBROADCASTF64X4 

func (self *Program) VBROADCASTF64X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTF64X4 performs "Broadcast Four Double-Precision Floating-Point Elements".

Mnemonic : VBROADCASTF64X4 Supported forms : (1 form)

  • VBROADCASTF64X4 m256, zmm{k}{z} [AVX512F]

func (*Program) VBROADCASTI128 

func (self *Program) VBROADCASTI128(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI128 performs "Broadcast 128 Bits of Integer Data".

Mnemonic : VBROADCASTI128 Supported forms : (1 form)

  • VBROADCASTI128 m128, ymm [AVX2]

func (*Program) VBROADCASTI32X2 

func (self *Program) VBROADCASTI32X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI32X2 performs "Broadcast Two Doubleword Elements".

Mnemonic : VBROADCASTI32X2 Supported forms : (6 forms)

  • VBROADCASTI32X2 xmm, zmm{k}{z} [AVX512DQ]
  • VBROADCASTI32X2 m64, zmm{k}{z} [AVX512DQ]
  • VBROADCASTI32X2 xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VBROADCASTI32X2 xmm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VBROADCASTI32X2 m64, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VBROADCASTI32X2 m64, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VBROADCASTI32X4 

func (self *Program) VBROADCASTI32X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI32X4 performs "Broadcast Four Doubleword Elements".

Mnemonic : VBROADCASTI32X4 Supported forms : (2 forms)

  • VBROADCASTI32X4 m128, zmm{k}{z} [AVX512F]
  • VBROADCASTI32X4 m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VBROADCASTI32X8 

func (self *Program) VBROADCASTI32X8(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI32X8 performs "Broadcast Eight Doubleword Elements".

Mnemonic : VBROADCASTI32X8 Supported forms : (1 form)

  • VBROADCASTI32X8 m256, zmm{k}{z} [AVX512DQ]

func (*Program) VBROADCASTI64X2 

func (self *Program) VBROADCASTI64X2(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI64X2 performs "Broadcast Two Quadword Elements".

Mnemonic : VBROADCASTI64X2 Supported forms : (2 forms)

  • VBROADCASTI64X2 m128, zmm{k}{z} [AVX512DQ]
  • VBROADCASTI64X2 m128, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VBROADCASTI64X4 

func (self *Program) VBROADCASTI64X4(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTI64X4 performs "Broadcast Four Quadword Elements".

Mnemonic : VBROADCASTI64X4 Supported forms : (1 form)

  • VBROADCASTI64X4 m256, zmm{k}{z} [AVX512F]

func (*Program) VBROADCASTSD 

func (self *Program) VBROADCASTSD(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTSD performs "Broadcast Double-Precision Floating-Point Element".

Mnemonic : VBROADCASTSD Supported forms : (6 forms)

  • VBROADCASTSD m64, ymm [AVX]
  • VBROADCASTSD xmm, ymm [AVX2]
  • VBROADCASTSD xmm, zmm{k}{z} [AVX512F]
  • VBROADCASTSD m64, zmm{k}{z} [AVX512F]
  • VBROADCASTSD xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VBROADCASTSD m64, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VBROADCASTSS 

func (self *Program) VBROADCASTSS(v0 interface{}, v1 interface{}) *Instruction

VBROADCASTSS performs "Broadcast Single-Precision Floating-Point Element".

Mnemonic : VBROADCASTSS Supported forms : (8 forms)

  • VBROADCASTSS m32, xmm [AVX]
  • VBROADCASTSS m32, ymm [AVX]
  • VBROADCASTSS xmm, xmm [AVX2]
  • VBROADCASTSS xmm, ymm [AVX2]
  • VBROADCASTSS xmm, zmm{k}{z} [AVX512F]
  • VBROADCASTSS m32, zmm{k}{z} [AVX512F]
  • VBROADCASTSS xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VBROADCASTSS m32, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCMPPD 

func (self *Program) VCMPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPPD performs "Compare Packed Double-Precision Floating-Point Values".

Mnemonic : VCMPPD Supported forms : (11 forms)

  • VCMPPD imm8, xmm, xmm, xmm [AVX]
  • VCMPPD imm8, m128, xmm, xmm [AVX]
  • VCMPPD imm8, ymm, ymm, ymm [AVX]
  • VCMPPD imm8, m256, ymm, ymm [AVX]
  • VCMPPD imm8, m512/m64bcst, zmm, k{k} [AVX512F]
  • VCMPPD imm8, {sae}, zmm, zmm, k{k} [AVX512F]
  • VCMPPD imm8, zmm, zmm, k{k} [AVX512F]
  • VCMPPD imm8, m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VCMPPD imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VCMPPD imm8, m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VCMPPD imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VCMPPS 

func (self *Program) VCMPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPPS performs "Compare Packed Single-Precision Floating-Point Values".

Mnemonic : VCMPPS Supported forms : (11 forms)

  • VCMPPS imm8, xmm, xmm, xmm [AVX]
  • VCMPPS imm8, m128, xmm, xmm [AVX]
  • VCMPPS imm8, ymm, ymm, ymm [AVX]
  • VCMPPS imm8, m256, ymm, ymm [AVX]
  • VCMPPS imm8, m512/m32bcst, zmm, k{k} [AVX512F]
  • VCMPPS imm8, {sae}, zmm, zmm, k{k} [AVX512F]
  • VCMPPS imm8, zmm, zmm, k{k} [AVX512F]
  • VCMPPS imm8, m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VCMPPS imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VCMPPS imm8, m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VCMPPS imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VCMPSD 

func (self *Program) VCMPSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPSD performs "Compare Scalar Double-Precision Floating-Point Values".

Mnemonic : VCMPSD Supported forms : (5 forms)

  • VCMPSD imm8, xmm, xmm, xmm [AVX]
  • VCMPSD imm8, m64, xmm, xmm [AVX]
  • VCMPSD imm8, m64, xmm, k{k} [AVX512F]
  • VCMPSD imm8, {sae}, xmm, xmm, k{k} [AVX512F]
  • VCMPSD imm8, xmm, xmm, k{k} [AVX512F]

func (*Program) VCMPSS 

func (self *Program) VCMPSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VCMPSS performs "Compare Scalar Single-Precision Floating-Point Values".

Mnemonic : VCMPSS Supported forms : (5 forms)

  • VCMPSS imm8, xmm, xmm, xmm [AVX]
  • VCMPSS imm8, m32, xmm, xmm [AVX]
  • VCMPSS imm8, m32, xmm, k{k} [AVX512F]
  • VCMPSS imm8, {sae}, xmm, xmm, k{k} [AVX512F]
  • VCMPSS imm8, xmm, xmm, k{k} [AVX512F]

func (*Program) VCOMISD 

func (self *Program) VCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCOMISD performs "Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VCOMISD Supported forms : (5 forms)

  • VCOMISD xmm, xmm [AVX]
  • VCOMISD m64, xmm [AVX]
  • VCOMISD m64, xmm [AVX512F]
  • VCOMISD {sae}, xmm, xmm [AVX512F]
  • VCOMISD xmm, xmm [AVX512F]

func (*Program) VCOMISS 

func (self *Program) VCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCOMISS performs "Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VCOMISS Supported forms : (5 forms)

  • VCOMISS xmm, xmm [AVX]
  • VCOMISS m32, xmm [AVX]
  • VCOMISS m32, xmm [AVX512F]
  • VCOMISS {sae}, xmm, xmm [AVX512F]
  • VCOMISS xmm, xmm [AVX512F]

func (*Program) VCOMPRESSPD 

func (self *Program) VCOMPRESSPD(v0 interface{}, v1 interface{}) *Instruction

VCOMPRESSPD performs "Store Sparse Packed Double-Precision Floating-Point Values into Dense Memory/Register".

Mnemonic : VCOMPRESSPD Supported forms : (6 forms)

  • VCOMPRESSPD zmm, zmm{k}{z} [AVX512F]
  • VCOMPRESSPD zmm, m512{k}{z} [AVX512F]
  • VCOMPRESSPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCOMPRESSPD xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VCOMPRESSPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VCOMPRESSPD ymm, m256{k}{z} [AVX512F,AVX512VL]

func (*Program) VCOMPRESSPS 

func (self *Program) VCOMPRESSPS(v0 interface{}, v1 interface{}) *Instruction

VCOMPRESSPS performs "Store Sparse Packed Single-Precision Floating-Point Values into Dense Memory/Register".

Mnemonic : VCOMPRESSPS Supported forms : (6 forms)

  • VCOMPRESSPS zmm, zmm{k}{z} [AVX512F]
  • VCOMPRESSPS zmm, m512{k}{z} [AVX512F]
  • VCOMPRESSPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCOMPRESSPS xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VCOMPRESSPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VCOMPRESSPS ymm, m256{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTDQ2PD 

func (self *Program) VCVTDQ2PD(v0 interface{}, v1 interface{}) *Instruction

VCVTDQ2PD performs "Convert Packed Dword Integers to Packed Double-Precision FP Values".

Mnemonic : VCVTDQ2PD Supported forms : (10 forms)

  • VCVTDQ2PD xmm, xmm [AVX]
  • VCVTDQ2PD m64, xmm [AVX]
  • VCVTDQ2PD xmm, ymm [AVX]
  • VCVTDQ2PD m128, ymm [AVX]
  • VCVTDQ2PD m256/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTDQ2PD ymm, zmm{k}{z} [AVX512F]
  • VCVTDQ2PD m64/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTDQ2PD m128/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTDQ2PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTDQ2PD xmm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTDQ2PS 

func (self *Program) VCVTDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTDQ2PS performs "Convert Packed Dword Integers to Packed Single-Precision FP Values".

Mnemonic : VCVTDQ2PS Supported forms : (11 forms)

  • VCVTDQ2PS xmm, xmm [AVX]
  • VCVTDQ2PS m128, xmm [AVX]
  • VCVTDQ2PS ymm, ymm [AVX]
  • VCVTDQ2PS m256, ymm [AVX]
  • VCVTDQ2PS m512/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTDQ2PS {er}, zmm, zmm{k}{z} [AVX512F]
  • VCVTDQ2PS zmm, zmm{k}{z} [AVX512F]
  • VCVTDQ2PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTDQ2PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTDQ2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTDQ2PS ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPD2DQ 

func (self *Program) VCVTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2DQ performs "Convert Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTPD2DQ Supported forms : (11 forms)

  • VCVTPD2DQ xmm, xmm [AVX]
  • VCVTPD2DQ ymm, xmm [AVX]
  • VCVTPD2DQ m128, xmm [AVX]
  • VCVTPD2DQ m256, xmm [AVX]
  • VCVTPD2DQ m512/m64bcst, ymm{k}{z} [AVX512F]
  • VCVTPD2DQ {er}, zmm, ymm{k}{z} [AVX512F]
  • VCVTPD2DQ zmm, ymm{k}{z} [AVX512F]
  • VCVTPD2DQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2DQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2DQ ymm, xmm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPD2PS 

func (self *Program) VCVTPD2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2PS performs "Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values".

Mnemonic : VCVTPD2PS Supported forms : (11 forms)

  • VCVTPD2PS xmm, xmm [AVX]
  • VCVTPD2PS ymm, xmm [AVX]
  • VCVTPD2PS m128, xmm [AVX]
  • VCVTPD2PS m256, xmm [AVX]
  • VCVTPD2PS m512/m64bcst, ymm{k}{z} [AVX512F]
  • VCVTPD2PS {er}, zmm, ymm{k}{z} [AVX512F]
  • VCVTPD2PS zmm, ymm{k}{z} [AVX512F]
  • VCVTPD2PS m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2PS m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2PS ymm, xmm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPD2QQ 

func (self *Program) VCVTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2QQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Quadword Integers".

Mnemonic : VCVTPD2QQ Supported forms : (7 forms)

  • VCVTPD2QQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VCVTPD2QQ {er}, zmm, zmm{k}{z} [AVX512DQ]
  • VCVTPD2QQ zmm, zmm{k}{z} [AVX512DQ]
  • VCVTPD2QQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPD2QQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPD2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPD2QQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTPD2UDQ 

func (self *Program) VCVTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2UDQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers".

Mnemonic : VCVTPD2UDQ Supported forms : (7 forms)

  • VCVTPD2UDQ m512/m64bcst, ymm{k}{z} [AVX512F]
  • VCVTPD2UDQ {er}, zmm, ymm{k}{z} [AVX512F]
  • VCVTPD2UDQ zmm, ymm{k}{z} [AVX512F]
  • VCVTPD2UDQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2UDQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPD2UDQ ymm, xmm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPD2UQQ 

func (self *Program) VCVTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPD2UQQ performs "Convert Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers".

Mnemonic : VCVTPD2UQQ Supported forms : (7 forms)

  • VCVTPD2UQQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VCVTPD2UQQ {er}, zmm, zmm{k}{z} [AVX512DQ]
  • VCVTPD2UQQ zmm, zmm{k}{z} [AVX512DQ]
  • VCVTPD2UQQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPD2UQQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPD2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPD2UQQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTPH2PS 

func (self *Program) VCVTPH2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPH2PS performs "Convert Half-Precision FP Values to Single-Precision FP Values".

Mnemonic : VCVTPH2PS Supported forms : (11 forms)

  • VCVTPH2PS xmm, xmm [F16C]
  • VCVTPH2PS m64, xmm [F16C]
  • VCVTPH2PS xmm, ymm [F16C]
  • VCVTPH2PS m128, ymm [F16C]
  • VCVTPH2PS m256, zmm{k}{z} [AVX512F]
  • VCVTPH2PS {sae}, ymm, zmm{k}{z} [AVX512F]
  • VCVTPH2PS ymm, zmm{k}{z} [AVX512F]
  • VCVTPH2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPH2PS xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTPH2PS m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPH2PS m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPS2DQ 

func (self *Program) VCVTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2DQ performs "Convert Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTPS2DQ Supported forms : (11 forms)

  • VCVTPS2DQ xmm, xmm [AVX]
  • VCVTPS2DQ m128, xmm [AVX]
  • VCVTPS2DQ ymm, ymm [AVX]
  • VCVTPS2DQ m256, ymm [AVX]
  • VCVTPS2DQ m512/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTPS2DQ {er}, zmm, zmm{k}{z} [AVX512F]
  • VCVTPS2DQ zmm, zmm{k}{z} [AVX512F]
  • VCVTPS2DQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2DQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2DQ ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPS2PD 

func (self *Program) VCVTPS2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2PD performs "Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values".

Mnemonic : VCVTPS2PD Supported forms : (11 forms)

  • VCVTPS2PD xmm, xmm [AVX]
  • VCVTPS2PD m64, xmm [AVX]
  • VCVTPS2PD xmm, ymm [AVX]
  • VCVTPS2PD m128, ymm [AVX]
  • VCVTPS2PD m256/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTPS2PD {sae}, ymm, zmm{k}{z} [AVX512F]
  • VCVTPS2PD ymm, zmm{k}{z} [AVX512F]
  • VCVTPS2PD m64/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2PD m128/m32bcst, ymm{k}{z} [AVX512VL]
  • VCVTPS2PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2PD xmm, ymm{k}{z} [AVX512VL]

func (*Program) VCVTPS2PH 

func (self *Program) VCVTPS2PH(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTPS2PH performs "Convert Single-Precision FP value to Half-Precision FP value".

Mnemonic : VCVTPS2PH Supported forms : (11 forms)

  • VCVTPS2PH imm8, xmm, xmm [F16C]
  • VCVTPS2PH imm8, ymm, xmm [F16C]
  • VCVTPS2PH imm8, xmm, m64 [F16C]
  • VCVTPS2PH imm8, ymm, m128 [F16C]
  • VCVTPS2PH imm8, zmm, m256{k}{z} [AVX512F]
  • VCVTPS2PH imm8, {sae}, zmm, ymm{k}{z} [AVX512F]
  • VCVTPS2PH imm8, zmm, ymm{k}{z} [AVX512F]
  • VCVTPS2PH imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2PH imm8, xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2PH imm8, ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2PH imm8, ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPS2QQ 

func (self *Program) VCVTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2QQ performs "Convert Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values".

Mnemonic : VCVTPS2QQ Supported forms : (7 forms)

  • VCVTPS2QQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
  • VCVTPS2QQ {er}, ymm, zmm{k}{z} [AVX512DQ]
  • VCVTPS2QQ ymm, zmm{k}{z} [AVX512DQ]
  • VCVTPS2QQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPS2QQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPS2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPS2QQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTPS2UDQ 

func (self *Program) VCVTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2UDQ performs "Convert Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values".

Mnemonic : VCVTPS2UDQ Supported forms : (7 forms)

  • VCVTPS2UDQ m512/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTPS2UDQ {er}, zmm, zmm{k}{z} [AVX512F]
  • VCVTPS2UDQ zmm, zmm{k}{z} [AVX512F]
  • VCVTPS2UDQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2UDQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTPS2UDQ ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTPS2UQQ 

func (self *Program) VCVTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTPS2UQQ performs "Convert Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values".

Mnemonic : VCVTPS2UQQ Supported forms : (7 forms)

  • VCVTPS2UQQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
  • VCVTPS2UQQ {er}, ymm, zmm{k}{z} [AVX512DQ]
  • VCVTPS2UQQ ymm, zmm{k}{z} [AVX512DQ]
  • VCVTPS2UQQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPS2UQQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPS2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTPS2UQQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTQQ2PD 

func (self *Program) VCVTQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTQQ2PD performs "Convert Packed Quadword Integers to Packed Double-Precision Floating-Point Values".

Mnemonic : VCVTQQ2PD Supported forms : (7 forms)

  • VCVTQQ2PD m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VCVTQQ2PD {er}, zmm, zmm{k}{z} [AVX512DQ]
  • VCVTQQ2PD zmm, zmm{k}{z} [AVX512DQ]
  • VCVTQQ2PD m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTQQ2PD m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTQQ2PD xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTQQ2PD ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTQQ2PS 

func (self *Program) VCVTQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTQQ2PS performs "Convert Packed Quadword Integers to Packed Single-Precision Floating-Point Values".

Mnemonic : VCVTQQ2PS Supported forms : (7 forms)

  • VCVTQQ2PS m512/m64bcst, ymm{k}{z} [AVX512DQ]
  • VCVTQQ2PS {er}, zmm, ymm{k}{z} [AVX512DQ]
  • VCVTQQ2PS zmm, ymm{k}{z} [AVX512DQ]
  • VCVTQQ2PS m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTQQ2PS m256/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTQQ2PS xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTQQ2PS ymm, xmm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTSD2SI 

func (self *Program) VCVTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSD2SI performs "Convert Scalar Double-Precision FP Value to Integer".

Mnemonic : VCVTSD2SI Supported forms : (10 forms)

  • VCVTSD2SI xmm, r32 [AVX]
  • VCVTSD2SI m64, r32 [AVX]
  • VCVTSD2SI xmm, r64 [AVX]
  • VCVTSD2SI m64, r64 [AVX]
  • VCVTSD2SI m64, r32 [AVX512F]
  • VCVTSD2SI m64, r64 [AVX512F]
  • VCVTSD2SI {er}, xmm, r32 [AVX512F]
  • VCVTSD2SI {er}, xmm, r64 [AVX512F]
  • VCVTSD2SI xmm, r32 [AVX512F]
  • VCVTSD2SI xmm, r64 [AVX512F]

func (*Program) VCVTSD2SS 

func (self *Program) VCVTSD2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSD2SS performs "Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value".

Mnemonic : VCVTSD2SS Supported forms : (5 forms)

  • VCVTSD2SS xmm, xmm, xmm [AVX]
  • VCVTSD2SS m64, xmm, xmm [AVX]
  • VCVTSD2SS m64, xmm, xmm{k}{z} [AVX512F]
  • VCVTSD2SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VCVTSD2SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VCVTSD2USI 

func (self *Program) VCVTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSD2USI performs "Convert Scalar Double-Precision Floating-Point Value to Unsigned Doubleword Integer".

Mnemonic : VCVTSD2USI Supported forms : (6 forms)

  • VCVTSD2USI m64, r32 [AVX512F]
  • VCVTSD2USI m64, r64 [AVX512F]
  • VCVTSD2USI {er}, xmm, r32 [AVX512F]
  • VCVTSD2USI {er}, xmm, r64 [AVX512F]
  • VCVTSD2USI xmm, r32 [AVX512F]
  • VCVTSD2USI xmm, r64 [AVX512F]

func (*Program) VCVTSI2SD 

func (self *Program) VCVTSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSI2SD performs "Convert Dword Integer to Scalar Double-Precision FP Value".

Mnemonic : VCVTSI2SD Supported forms : (9 forms)

  • VCVTSI2SD r32, xmm, xmm [AVX]
  • VCVTSI2SD r64, xmm, xmm [AVX]
  • VCVTSI2SD m32, xmm, xmm [AVX]
  • VCVTSI2SD m64, xmm, xmm [AVX]
  • VCVTSI2SD r32, xmm, xmm [AVX512F]
  • VCVTSI2SD m32, xmm, xmm [AVX512F]
  • VCVTSI2SD m64, xmm, xmm [AVX512F]
  • VCVTSI2SD {er}, r64, xmm, xmm [AVX512F]
  • VCVTSI2SD r64, xmm, xmm [AVX512F]

func (*Program) VCVTSI2SS 

func (self *Program) VCVTSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSI2SS performs "Convert Dword Integer to Scalar Single-Precision FP Value".

Mnemonic : VCVTSI2SS Supported forms : (10 forms)

  • VCVTSI2SS r32, xmm, xmm [AVX]
  • VCVTSI2SS r64, xmm, xmm [AVX]
  • VCVTSI2SS m32, xmm, xmm [AVX]
  • VCVTSI2SS m64, xmm, xmm [AVX]
  • VCVTSI2SS m32, xmm, xmm [AVX512F]
  • VCVTSI2SS m64, xmm, xmm [AVX512F]
  • VCVTSI2SS {er}, r32, xmm, xmm [AVX512F]
  • VCVTSI2SS {er}, r64, xmm, xmm [AVX512F]
  • VCVTSI2SS r32, xmm, xmm [AVX512F]
  • VCVTSI2SS r64, xmm, xmm [AVX512F]

func (*Program) VCVTSS2SD 

func (self *Program) VCVTSS2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTSS2SD performs "Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value".

Mnemonic : VCVTSS2SD Supported forms : (5 forms)

  • VCVTSS2SD xmm, xmm, xmm [AVX]
  • VCVTSS2SD m32, xmm, xmm [AVX]
  • VCVTSS2SD m32, xmm, xmm{k}{z} [AVX512F]
  • VCVTSS2SD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VCVTSS2SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VCVTSS2SI 

func (self *Program) VCVTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSS2SI performs "Convert Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : VCVTSS2SI Supported forms : (10 forms)

  • VCVTSS2SI xmm, r32 [AVX]
  • VCVTSS2SI m32, r32 [AVX]
  • VCVTSS2SI xmm, r64 [AVX]
  • VCVTSS2SI m32, r64 [AVX]
  • VCVTSS2SI m32, r32 [AVX512F]
  • VCVTSS2SI m32, r64 [AVX512F]
  • VCVTSS2SI {er}, xmm, r32 [AVX512F]
  • VCVTSS2SI {er}, xmm, r64 [AVX512F]
  • VCVTSS2SI xmm, r32 [AVX512F]
  • VCVTSS2SI xmm, r64 [AVX512F]

func (*Program) VCVTSS2USI 

func (self *Program) VCVTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTSS2USI performs "Convert Scalar Single-Precision Floating-Point Value to Unsigned Doubleword Integer".

Mnemonic : VCVTSS2USI Supported forms : (6 forms)

  • VCVTSS2USI m32, r32 [AVX512F]
  • VCVTSS2USI m32, r64 [AVX512F]
  • VCVTSS2USI {er}, xmm, r32 [AVX512F]
  • VCVTSS2USI {er}, xmm, r64 [AVX512F]
  • VCVTSS2USI xmm, r32 [AVX512F]
  • VCVTSS2USI xmm, r64 [AVX512F]

func (*Program) VCVTTPD2DQ 

func (self *Program) VCVTTPD2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2DQ performs "Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTTPD2DQ Supported forms : (11 forms)

  • VCVTTPD2DQ xmm, xmm [AVX]
  • VCVTTPD2DQ ymm, xmm [AVX]
  • VCVTTPD2DQ m128, xmm [AVX]
  • VCVTTPD2DQ m256, xmm [AVX]
  • VCVTTPD2DQ m512/m64bcst, ymm{k}{z} [AVX512F]
  • VCVTTPD2DQ {sae}, zmm, ymm{k}{z} [AVX512F]
  • VCVTTPD2DQ zmm, ymm{k}{z} [AVX512F]
  • VCVTTPD2DQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPD2DQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPD2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPD2DQ ymm, xmm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTTPD2QQ 

func (self *Program) VCVTTPD2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2QQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Quadword Integers".

Mnemonic : VCVTTPD2QQ Supported forms : (7 forms)

  • VCVTTPD2QQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VCVTTPD2QQ {sae}, zmm, zmm{k}{z} [AVX512DQ]
  • VCVTTPD2QQ zmm, zmm{k}{z} [AVX512DQ]
  • VCVTTPD2QQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPD2QQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPD2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPD2QQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTTPD2UDQ 

func (self *Program) VCVTTPD2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2UDQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Doubleword Integers".

Mnemonic : VCVTTPD2UDQ Supported forms : (7 forms)

  • VCVTTPD2UDQ m512/m64bcst, ymm{k}{z} [AVX512F]
  • VCVTTPD2UDQ {sae}, zmm, ymm{k}{z} [AVX512F]
  • VCVTTPD2UDQ zmm, ymm{k}{z} [AVX512F]
  • VCVTTPD2UDQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPD2UDQ m256/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPD2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPD2UDQ ymm, xmm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTTPD2UQQ 

func (self *Program) VCVTTPD2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPD2UQQ performs "Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Unsigned Quadword Integers".

Mnemonic : VCVTTPD2UQQ Supported forms : (7 forms)

  • VCVTTPD2UQQ m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VCVTTPD2UQQ {sae}, zmm, zmm{k}{z} [AVX512DQ]
  • VCVTTPD2UQQ zmm, zmm{k}{z} [AVX512DQ]
  • VCVTTPD2UQQ m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPD2UQQ m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPD2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPD2UQQ ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTTPS2DQ 

func (self *Program) VCVTTPS2DQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2DQ performs "Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers".

Mnemonic : VCVTTPS2DQ Supported forms : (11 forms)

  • VCVTTPS2DQ xmm, xmm [AVX]
  • VCVTTPS2DQ m128, xmm [AVX]
  • VCVTTPS2DQ ymm, ymm [AVX]
  • VCVTTPS2DQ m256, ymm [AVX]
  • VCVTTPS2DQ m512/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTTPS2DQ {sae}, zmm, zmm{k}{z} [AVX512F]
  • VCVTTPS2DQ zmm, zmm{k}{z} [AVX512F]
  • VCVTTPS2DQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPS2DQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPS2DQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPS2DQ ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTTPS2QQ 

func (self *Program) VCVTTPS2QQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2QQ performs "Convert with Truncation Packed Single Precision Floating-Point Values to Packed Singed Quadword Integer Values".

Mnemonic : VCVTTPS2QQ Supported forms : (7 forms)

  • VCVTTPS2QQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
  • VCVTTPS2QQ {sae}, ymm, zmm{k}{z} [AVX512DQ]
  • VCVTTPS2QQ ymm, zmm{k}{z} [AVX512DQ]
  • VCVTTPS2QQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPS2QQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPS2QQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPS2QQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTTPS2UDQ 

func (self *Program) VCVTTPS2UDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2UDQ performs "Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Unsigned Doubleword Integer Values".

Mnemonic : VCVTTPS2UDQ Supported forms : (7 forms)

  • VCVTTPS2UDQ m512/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTTPS2UDQ {sae}, zmm, zmm{k}{z} [AVX512F]
  • VCVTTPS2UDQ zmm, zmm{k}{z} [AVX512F]
  • VCVTTPS2UDQ m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPS2UDQ m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPS2UDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTTPS2UDQ ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTTPS2UQQ 

func (self *Program) VCVTTPS2UQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTPS2UQQ performs "Convert with Truncation Packed Single Precision Floating-Point Values to Packed Unsigned Quadword Integer Values".

Mnemonic : VCVTTPS2UQQ Supported forms : (7 forms)

  • VCVTTPS2UQQ m256/m32bcst, zmm{k}{z} [AVX512DQ]
  • VCVTTPS2UQQ {sae}, ymm, zmm{k}{z} [AVX512DQ]
  • VCVTTPS2UQQ ymm, zmm{k}{z} [AVX512DQ]
  • VCVTTPS2UQQ m64/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPS2UQQ m128/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPS2UQQ xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTTPS2UQQ xmm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTTSD2SI 

func (self *Program) VCVTTSD2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSD2SI performs "Convert with Truncation Scalar Double-Precision FP Value to Signed Integer".

Mnemonic : VCVTTSD2SI Supported forms : (10 forms)

  • VCVTTSD2SI xmm, r32 [AVX]
  • VCVTTSD2SI m64, r32 [AVX]
  • VCVTTSD2SI xmm, r64 [AVX]
  • VCVTTSD2SI m64, r64 [AVX]
  • VCVTTSD2SI m64, r32 [AVX512F]
  • VCVTTSD2SI m64, r64 [AVX512F]
  • VCVTTSD2SI {sae}, xmm, r32 [AVX512F]
  • VCVTTSD2SI {sae}, xmm, r64 [AVX512F]
  • VCVTTSD2SI xmm, r32 [AVX512F]
  • VCVTTSD2SI xmm, r64 [AVX512F]

func (*Program) VCVTTSD2USI 

func (self *Program) VCVTTSD2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSD2USI performs "Convert with Truncation Scalar Double-Precision Floating-Point Value to Unsigned Integer".

Mnemonic : VCVTTSD2USI Supported forms : (6 forms)

  • VCVTTSD2USI m64, r32 [AVX512F]
  • VCVTTSD2USI m64, r64 [AVX512F]
  • VCVTTSD2USI {sae}, xmm, r32 [AVX512F]
  • VCVTTSD2USI {sae}, xmm, r64 [AVX512F]
  • VCVTTSD2USI xmm, r32 [AVX512F]
  • VCVTTSD2USI xmm, r64 [AVX512F]

func (*Program) VCVTTSS2SI 

func (self *Program) VCVTTSS2SI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSS2SI performs "Convert with Truncation Scalar Single-Precision FP Value to Dword Integer".

Mnemonic : VCVTTSS2SI Supported forms : (10 forms)

  • VCVTTSS2SI xmm, r32 [AVX]
  • VCVTTSS2SI m32, r32 [AVX]
  • VCVTTSS2SI xmm, r64 [AVX]
  • VCVTTSS2SI m32, r64 [AVX]
  • VCVTTSS2SI m32, r32 [AVX512F]
  • VCVTTSS2SI m32, r64 [AVX512F]
  • VCVTTSS2SI {sae}, xmm, r32 [AVX512F]
  • VCVTTSS2SI {sae}, xmm, r64 [AVX512F]
  • VCVTTSS2SI xmm, r32 [AVX512F]
  • VCVTTSS2SI xmm, r64 [AVX512F]

func (*Program) VCVTTSS2USI 

func (self *Program) VCVTTSS2USI(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTTSS2USI performs "Convert with Truncation Scalar Single-Precision Floating-Point Value to Unsigned Integer".

Mnemonic : VCVTTSS2USI Supported forms : (6 forms)

  • VCVTTSS2USI m32, r32 [AVX512F]
  • VCVTTSS2USI m32, r64 [AVX512F]
  • VCVTTSS2USI {sae}, xmm, r32 [AVX512F]
  • VCVTTSS2USI {sae}, xmm, r64 [AVX512F]
  • VCVTTSS2USI xmm, r32 [AVX512F]
  • VCVTTSS2USI xmm, r64 [AVX512F]

func (*Program) VCVTUDQ2PD 

func (self *Program) VCVTUDQ2PD(v0 interface{}, v1 interface{}) *Instruction

VCVTUDQ2PD performs "Convert Packed Unsigned Doubleword Integers to Packed Double-Precision Floating-Point Values".

Mnemonic : VCVTUDQ2PD Supported forms : (6 forms)

  • VCVTUDQ2PD m256/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTUDQ2PD ymm, zmm{k}{z} [AVX512F]
  • VCVTUDQ2PD m64/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTUDQ2PD m128/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTUDQ2PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTUDQ2PD xmm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTUDQ2PS 

func (self *Program) VCVTUDQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTUDQ2PS performs "Convert Packed Unsigned Doubleword Integers to Packed Single-Precision Floating-Point Values".

Mnemonic : VCVTUDQ2PS Supported forms : (7 forms)

  • VCVTUDQ2PS m512/m32bcst, zmm{k}{z} [AVX512F]
  • VCVTUDQ2PS {er}, zmm, zmm{k}{z} [AVX512F]
  • VCVTUDQ2PS zmm, zmm{k}{z} [AVX512F]
  • VCVTUDQ2PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTUDQ2PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VCVTUDQ2PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VCVTUDQ2PS ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VCVTUQQ2PD 

func (self *Program) VCVTUQQ2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTUQQ2PD performs "Convert Packed Unsigned Quadword Integers to Packed Double-Precision Floating-Point Values".

Mnemonic : VCVTUQQ2PD Supported forms : (7 forms)

  • VCVTUQQ2PD m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VCVTUQQ2PD {er}, zmm, zmm{k}{z} [AVX512DQ]
  • VCVTUQQ2PD zmm, zmm{k}{z} [AVX512DQ]
  • VCVTUQQ2PD m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTUQQ2PD m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTUQQ2PD xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTUQQ2PD ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTUQQ2PS 

func (self *Program) VCVTUQQ2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VCVTUQQ2PS performs "Convert Packed Unsigned Quadword Integers to Packed Single-Precision Floating-Point Values".

Mnemonic : VCVTUQQ2PS Supported forms : (7 forms)

  • VCVTUQQ2PS m512/m64bcst, ymm{k}{z} [AVX512DQ]
  • VCVTUQQ2PS {er}, zmm, ymm{k}{z} [AVX512DQ]
  • VCVTUQQ2PS zmm, ymm{k}{z} [AVX512DQ]
  • VCVTUQQ2PS m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTUQQ2PS m256/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTUQQ2PS xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VCVTUQQ2PS ymm, xmm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VCVTUSI2SD 

func (self *Program) VCVTUSI2SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTUSI2SD performs "Convert Unsigned Integer to Scalar Double-Precision Floating-Point Value".

Mnemonic : VCVTUSI2SD Supported forms : (5 forms)

  • VCVTUSI2SD r32, xmm, xmm [AVX512F]
  • VCVTUSI2SD m32, xmm, xmm [AVX512F]
  • VCVTUSI2SD m64, xmm, xmm [AVX512F]
  • VCVTUSI2SD {er}, r64, xmm, xmm [AVX512F]
  • VCVTUSI2SD r64, xmm, xmm [AVX512F]

func (*Program) VCVTUSI2SS 

func (self *Program) VCVTUSI2SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VCVTUSI2SS performs "Convert Unsigned Integer to Scalar Single-Precision Floating-Point Value".

Mnemonic : VCVTUSI2SS Supported forms : (6 forms)

  • VCVTUSI2SS m32, xmm, xmm [AVX512F]
  • VCVTUSI2SS m64, xmm, xmm [AVX512F]
  • VCVTUSI2SS {er}, r32, xmm, xmm [AVX512F]
  • VCVTUSI2SS {er}, r64, xmm, xmm [AVX512F]
  • VCVTUSI2SS r32, xmm, xmm [AVX512F]
  • VCVTUSI2SS r64, xmm, xmm [AVX512F]

func (*Program) VDBPSADBW 

func (self *Program) VDBPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VDBPSADBW performs "Double Block Packed Sum-Absolute-Differences on Unsigned Bytes".

Mnemonic : VDBPSADBW Supported forms : (6 forms)

  • VDBPSADBW imm8, zmm, zmm, zmm{k}{z} [AVX512BW]
  • VDBPSADBW imm8, m512, zmm, zmm{k}{z} [AVX512BW]
  • VDBPSADBW imm8, xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VDBPSADBW imm8, m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VDBPSADBW imm8, ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VDBPSADBW imm8, m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VDIVPD 

func (self *Program) VDIVPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVPD performs "Divide Packed Double-Precision Floating-Point Values".

Mnemonic : VDIVPD Supported forms : (11 forms)

  • VDIVPD xmm, xmm, xmm [AVX]
  • VDIVPD m128, xmm, xmm [AVX]
  • VDIVPD ymm, ymm, ymm [AVX]
  • VDIVPD m256, ymm, ymm [AVX]
  • VDIVPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VDIVPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VDIVPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VDIVPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VDIVPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VDIVPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VDIVPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VDIVPS 

func (self *Program) VDIVPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVPS performs "Divide Packed Single-Precision Floating-Point Values".

Mnemonic : VDIVPS Supported forms : (11 forms)

  • VDIVPS xmm, xmm, xmm [AVX]
  • VDIVPS m128, xmm, xmm [AVX]
  • VDIVPS ymm, ymm, ymm [AVX]
  • VDIVPS m256, ymm, ymm [AVX]
  • VDIVPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VDIVPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VDIVPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VDIVPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VDIVPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VDIVPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VDIVPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VDIVSD 

func (self *Program) VDIVSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVSD performs "Divide Scalar Double-Precision Floating-Point Values".

Mnemonic : VDIVSD Supported forms : (5 forms)

  • VDIVSD xmm, xmm, xmm [AVX]
  • VDIVSD m64, xmm, xmm [AVX]
  • VDIVSD m64, xmm, xmm{k}{z} [AVX512F]
  • VDIVSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VDIVSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VDIVSS 

func (self *Program) VDIVSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VDIVSS performs "Divide Scalar Single-Precision Floating-Point Values".

Mnemonic : VDIVSS Supported forms : (5 forms)

  • VDIVSS xmm, xmm, xmm [AVX]
  • VDIVSS m32, xmm, xmm [AVX]
  • VDIVSS m32, xmm, xmm{k}{z} [AVX512F]
  • VDIVSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VDIVSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VDPPD 

func (self *Program) VDPPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VDPPD performs "Dot Product of Packed Double Precision Floating-Point Values".

Mnemonic : VDPPD Supported forms : (2 forms)

  • VDPPD imm8, xmm, xmm, xmm [AVX]
  • VDPPD imm8, m128, xmm, xmm [AVX]

func (*Program) VDPPS 

func (self *Program) VDPPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VDPPS performs "Dot Product of Packed Single Precision Floating-Point Values".

Mnemonic : VDPPS Supported forms : (4 forms)

  • VDPPS imm8, xmm, xmm, xmm [AVX]
  • VDPPS imm8, m128, xmm, xmm [AVX]
  • VDPPS imm8, ymm, ymm, ymm [AVX]
  • VDPPS imm8, m256, ymm, ymm [AVX]

func (*Program) VEXP2PD 

func (self *Program) VEXP2PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VEXP2PD performs "Approximation to the Exponential 2^x of Packed Double-Precision Floating-Point Values with Less Than 2^-23 Relative Error".

Mnemonic : VEXP2PD Supported forms : (3 forms)

  • VEXP2PD m512/m64bcst, zmm{k}{z} [AVX512ER]
  • VEXP2PD {sae}, zmm, zmm{k}{z} [AVX512ER]
  • VEXP2PD zmm, zmm{k}{z} [AVX512ER]

func (*Program) VEXP2PS 

func (self *Program) VEXP2PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VEXP2PS performs "Approximation to the Exponential 2^x of Packed Single-Precision Floating-Point Values with Less Than 2^-23 Relative Error".

Mnemonic : VEXP2PS Supported forms : (3 forms)

  • VEXP2PS m512/m32bcst, zmm{k}{z} [AVX512ER]
  • VEXP2PS {sae}, zmm, zmm{k}{z} [AVX512ER]
  • VEXP2PS zmm, zmm{k}{z} [AVX512ER]

func (*Program) VEXPANDPD 

func (self *Program) VEXPANDPD(v0 interface{}, v1 interface{}) *Instruction

VEXPANDPD performs "Load Sparse Packed Double-Precision Floating-Point Values from Dense Memory".

Mnemonic : VEXPANDPD Supported forms : (6 forms)

  • VEXPANDPD zmm, zmm{k}{z} [AVX512F]
  • VEXPANDPD m512, zmm{k}{z} [AVX512F]
  • VEXPANDPD xmm, xmm{k}{z} [AVX512VL]
  • VEXPANDPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VEXPANDPD m128, xmm{k}{z} [AVX512VL]
  • VEXPANDPD m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VEXPANDPS 

func (self *Program) VEXPANDPS(v0 interface{}, v1 interface{}) *Instruction

VEXPANDPS performs "Load Sparse Packed Single-Precision Floating-Point Values from Dense Memory".

Mnemonic : VEXPANDPS Supported forms : (6 forms)

  • VEXPANDPS zmm, zmm{k}{z} [AVX512F]
  • VEXPANDPS m512, zmm{k}{z} [AVX512F]
  • VEXPANDPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VEXPANDPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VEXPANDPS m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VEXPANDPS m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VEXTRACTF128 

func (self *Program) VEXTRACTF128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF128 performs "Extract Packed Floating-Point Values".

Mnemonic : VEXTRACTF128 Supported forms : (2 forms)

  • VEXTRACTF128 imm8, ymm, xmm [AVX]
  • VEXTRACTF128 imm8, ymm, m128 [AVX]

func (*Program) VEXTRACTF32X4 

func (self *Program) VEXTRACTF32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF32X4 performs "Extract 128 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VEXTRACTF32X4 Supported forms : (4 forms)

  • VEXTRACTF32X4 imm8, zmm, xmm{k}{z} [AVX512F]
  • VEXTRACTF32X4 imm8, zmm, m128{k}{z} [AVX512F]
  • VEXTRACTF32X4 imm8, ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VEXTRACTF32X4 imm8, ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VEXTRACTF32X8 

func (self *Program) VEXTRACTF32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF32X8 performs "Extract 256 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VEXTRACTF32X8 Supported forms : (2 forms)

  • VEXTRACTF32X8 imm8, zmm, ymm{k}{z} [AVX512DQ]
  • VEXTRACTF32X8 imm8, zmm, m256{k}{z} [AVX512DQ]

func (*Program) VEXTRACTF64X2 

func (self *Program) VEXTRACTF64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF64X2 performs "Extract 128 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VEXTRACTF64X2 Supported forms : (4 forms)

  • VEXTRACTF64X2 imm8, zmm, xmm{k}{z} [AVX512DQ]
  • VEXTRACTF64X2 imm8, zmm, m128{k}{z} [AVX512DQ]
  • VEXTRACTF64X2 imm8, ymm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VEXTRACTF64X2 imm8, ymm, m128{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VEXTRACTF64X4 

func (self *Program) VEXTRACTF64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTF64X4 performs "Extract 256 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VEXTRACTF64X4 Supported forms : (2 forms)

  • VEXTRACTF64X4 imm8, zmm, ymm{k}{z} [AVX512F]
  • VEXTRACTF64X4 imm8, zmm, m256{k}{z} [AVX512F]

func (*Program) VEXTRACTI128 

func (self *Program) VEXTRACTI128(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI128 performs "Extract Packed Integer Values".

Mnemonic : VEXTRACTI128 Supported forms : (2 forms)

  • VEXTRACTI128 imm8, ymm, xmm [AVX2]
  • VEXTRACTI128 imm8, ymm, m128 [AVX2]

func (*Program) VEXTRACTI32X4 

func (self *Program) VEXTRACTI32X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI32X4 performs "Extract 128 Bits of Packed Doubleword Integer Values".

Mnemonic : VEXTRACTI32X4 Supported forms : (4 forms)

  • VEXTRACTI32X4 imm8, zmm, xmm{k}{z} [AVX512F]
  • VEXTRACTI32X4 imm8, zmm, m128{k}{z} [AVX512F]
  • VEXTRACTI32X4 imm8, ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VEXTRACTI32X4 imm8, ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VEXTRACTI32X8 

func (self *Program) VEXTRACTI32X8(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI32X8 performs "Extract 256 Bits of Packed Doubleword Integer Values".

Mnemonic : VEXTRACTI32X8 Supported forms : (2 forms)

  • VEXTRACTI32X8 imm8, zmm, ymm{k}{z} [AVX512DQ]
  • VEXTRACTI32X8 imm8, zmm, m256{k}{z} [AVX512DQ]

func (*Program) VEXTRACTI64X2 

func (self *Program) VEXTRACTI64X2(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI64X2 performs "Extract 128 Bits of Packed Quadword Integer Values".

Mnemonic : VEXTRACTI64X2 Supported forms : (4 forms)

  • VEXTRACTI64X2 imm8, zmm, xmm{k}{z} [AVX512DQ]
  • VEXTRACTI64X2 imm8, zmm, m128{k}{z} [AVX512DQ]
  • VEXTRACTI64X2 imm8, ymm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VEXTRACTI64X2 imm8, ymm, m128{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VEXTRACTI64X4 

func (self *Program) VEXTRACTI64X4(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTI64X4 performs "Extract 256 Bits of Packed Quadword Integer Values".

Mnemonic : VEXTRACTI64X4 Supported forms : (2 forms)

  • VEXTRACTI64X4 imm8, zmm, ymm{k}{z} [AVX512F]
  • VEXTRACTI64X4 imm8, zmm, m256{k}{z} [AVX512F]

func (*Program) VEXTRACTPS 

func (self *Program) VEXTRACTPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VEXTRACTPS performs "Extract Packed Single Precision Floating-Point Value".

Mnemonic : VEXTRACTPS Supported forms : (4 forms)

  • VEXTRACTPS imm8, xmm, r32 [AVX]
  • VEXTRACTPS imm8, xmm, m32 [AVX]
  • VEXTRACTPS imm8, xmm, r32 [AVX512F]
  • VEXTRACTPS imm8, xmm, m32 [AVX512F]

func (*Program) VFIXUPIMMPD 

func (self *Program) VFIXUPIMMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMPD performs "Fix Up Special Packed Double-Precision Floating-Point Values".

Mnemonic : VFIXUPIMMPD Supported forms : (7 forms)

  • VFIXUPIMMPD imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFIXUPIMMPD imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFIXUPIMMPD imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFIXUPIMMPD imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFIXUPIMMPD imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFIXUPIMMPD imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFIXUPIMMPD imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFIXUPIMMPS 

func (self *Program) VFIXUPIMMPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMPS performs "Fix Up Special Packed Single-Precision Floating-Point Values".

Mnemonic : VFIXUPIMMPS Supported forms : (7 forms)

  • VFIXUPIMMPS imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFIXUPIMMPS imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFIXUPIMMPS imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFIXUPIMMPS imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512VL]
  • VFIXUPIMMPS imm8, xmm, xmm, xmm{k}{z} [AVX512VL]
  • VFIXUPIMMPS imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFIXUPIMMPS imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFIXUPIMMSD 

func (self *Program) VFIXUPIMMSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMSD performs "Fix Up Special Scalar Double-Precision Floating-Point Value".

Mnemonic : VFIXUPIMMSD Supported forms : (3 forms)

  • VFIXUPIMMSD imm8, m64, xmm, xmm{k}{z} [AVX512F]
  • VFIXUPIMMSD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFIXUPIMMSD imm8, xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFIXUPIMMSS 

func (self *Program) VFIXUPIMMSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VFIXUPIMMSS performs "Fix Up Special Scalar Single-Precision Floating-Point Value".

Mnemonic : VFIXUPIMMSS Supported forms : (3 forms)

  • VFIXUPIMMSS imm8, m32, xmm, xmm{k}{z} [AVX512F]
  • VFIXUPIMMSS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFIXUPIMMSS imm8, xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADD132PD 

func (self *Program) VFMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADD132PD Supported forms : (11 forms)

  • VFMADD132PD xmm, xmm, xmm [FMA3]
  • VFMADD132PD m128, xmm, xmm [FMA3]
  • VFMADD132PD ymm, ymm, ymm [FMA3]
  • VFMADD132PD m256, ymm, ymm [FMA3]
  • VFMADD132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADD132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD132PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADD132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADD132PS 

func (self *Program) VFMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADD132PS Supported forms : (11 forms)

  • VFMADD132PS xmm, xmm, xmm [FMA3]
  • VFMADD132PS m128, xmm, xmm [FMA3]
  • VFMADD132PS ymm, ymm, ymm [FMA3]
  • VFMADD132PS m256, ymm, ymm [FMA3]
  • VFMADD132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADD132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD132PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADD132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADD132SD 

func (self *Program) VFMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADD132SD Supported forms : (5 forms)

  • VFMADD132SD xmm, xmm, xmm [FMA3]
  • VFMADD132SD m64, xmm, xmm [FMA3]
  • VFMADD132SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFMADD132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMADD132SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADD132SS 

func (self *Program) VFMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD132SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADD132SS Supported forms : (5 forms)

  • VFMADD132SS xmm, xmm, xmm [FMA3]
  • VFMADD132SS m32, xmm, xmm [FMA3]
  • VFMADD132SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFMADD132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMADD132SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADD213PD 

func (self *Program) VFMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADD213PD Supported forms : (11 forms)

  • VFMADD213PD xmm, xmm, xmm [FMA3]
  • VFMADD213PD m128, xmm, xmm [FMA3]
  • VFMADD213PD ymm, ymm, ymm [FMA3]
  • VFMADD213PD m256, ymm, ymm [FMA3]
  • VFMADD213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADD213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD213PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADD213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADD213PS 

func (self *Program) VFMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADD213PS Supported forms : (11 forms)

  • VFMADD213PS xmm, xmm, xmm [FMA3]
  • VFMADD213PS m128, xmm, xmm [FMA3]
  • VFMADD213PS ymm, ymm, ymm [FMA3]
  • VFMADD213PS m256, ymm, ymm [FMA3]
  • VFMADD213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADD213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD213PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADD213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADD213SD 

func (self *Program) VFMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADD213SD Supported forms : (5 forms)

  • VFMADD213SD xmm, xmm, xmm [FMA3]
  • VFMADD213SD m64, xmm, xmm [FMA3]
  • VFMADD213SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFMADD213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMADD213SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADD213SS 

func (self *Program) VFMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD213SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADD213SS Supported forms : (5 forms)

  • VFMADD213SS xmm, xmm, xmm [FMA3]
  • VFMADD213SS m32, xmm, xmm [FMA3]
  • VFMADD213SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFMADD213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMADD213SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADD231PD 

func (self *Program) VFMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231PD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADD231PD Supported forms : (11 forms)

  • VFMADD231PD xmm, xmm, xmm [FMA3]
  • VFMADD231PD m128, xmm, xmm [FMA3]
  • VFMADD231PD ymm, ymm, ymm [FMA3]
  • VFMADD231PD m256, ymm, ymm [FMA3]
  • VFMADD231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADD231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD231PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADD231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADD231PS 

func (self *Program) VFMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231PS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADD231PS Supported forms : (11 forms)

  • VFMADD231PS xmm, xmm, xmm [FMA3]
  • VFMADD231PS m128, xmm, xmm [FMA3]
  • VFMADD231PS ymm, ymm, ymm [FMA3]
  • VFMADD231PS m256, ymm, ymm [FMA3]
  • VFMADD231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADD231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD231PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADD231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADD231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADD231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADD231SD 

func (self *Program) VFMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231SD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADD231SD Supported forms : (5 forms)

  • VFMADD231SD xmm, xmm, xmm [FMA3]
  • VFMADD231SD m64, xmm, xmm [FMA3]
  • VFMADD231SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFMADD231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMADD231SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADD231SS 

func (self *Program) VFMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADD231SS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADD231SS Supported forms : (5 forms)

  • VFMADD231SS xmm, xmm, xmm [FMA3]
  • VFMADD231SS m32, xmm, xmm [FMA3]
  • VFMADD231SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFMADD231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMADD231SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMADDPD 

func (self *Program) VFMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDPD performs "Fused Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDPD Supported forms : (6 forms)

  • VFMADDPD xmm, xmm, xmm, xmm [FMA4]
  • VFMADDPD m128, xmm, xmm, xmm [FMA4]
  • VFMADDPD xmm, m128, xmm, xmm [FMA4]
  • VFMADDPD ymm, ymm, ymm, ymm [FMA4]
  • VFMADDPD m256, ymm, ymm, ymm [FMA4]
  • VFMADDPD ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMADDPS 

func (self *Program) VFMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDPS performs "Fused Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDPS Supported forms : (6 forms)

  • VFMADDPS xmm, xmm, xmm, xmm [FMA4]
  • VFMADDPS m128, xmm, xmm, xmm [FMA4]
  • VFMADDPS xmm, m128, xmm, xmm [FMA4]
  • VFMADDPS ymm, ymm, ymm, ymm [FMA4]
  • VFMADDPS m256, ymm, ymm, ymm [FMA4]
  • VFMADDPS ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMADDSD 

func (self *Program) VFMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSD performs "Fused Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMADDSD Supported forms : (3 forms)

  • VFMADDSD xmm, xmm, xmm, xmm [FMA4]
  • VFMADDSD m64, xmm, xmm, xmm [FMA4]
  • VFMADDSD xmm, m64, xmm, xmm [FMA4]

func (*Program) VFMADDSS 

func (self *Program) VFMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSS performs "Fused Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMADDSS Supported forms : (3 forms)

  • VFMADDSS xmm, xmm, xmm, xmm [FMA4]
  • VFMADDSS m32, xmm, xmm, xmm [FMA4]
  • VFMADDSS xmm, m32, xmm, xmm [FMA4]

func (*Program) VFMADDSUB132PD 

func (self *Program) VFMADDSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB132PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUB132PD Supported forms : (11 forms)

  • VFMADDSUB132PD xmm, xmm, xmm [FMA3]
  • VFMADDSUB132PD m128, xmm, xmm [FMA3]
  • VFMADDSUB132PD ymm, ymm, ymm [FMA3]
  • VFMADDSUB132PD m256, ymm, ymm [FMA3]
  • VFMADDSUB132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB132PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADDSUB132PS 

func (self *Program) VFMADDSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB132PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUB132PS Supported forms : (11 forms)

  • VFMADDSUB132PS xmm, xmm, xmm [FMA3]
  • VFMADDSUB132PS m128, xmm, xmm [FMA3]
  • VFMADDSUB132PS ymm, ymm, ymm [FMA3]
  • VFMADDSUB132PS m256, ymm, ymm [FMA3]
  • VFMADDSUB132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB132PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADDSUB213PD 

func (self *Program) VFMADDSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB213PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUB213PD Supported forms : (11 forms)

  • VFMADDSUB213PD xmm, xmm, xmm [FMA3]
  • VFMADDSUB213PD m128, xmm, xmm [FMA3]
  • VFMADDSUB213PD ymm, ymm, ymm [FMA3]
  • VFMADDSUB213PD m256, ymm, ymm [FMA3]
  • VFMADDSUB213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB213PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADDSUB213PS 

func (self *Program) VFMADDSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB213PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUB213PS Supported forms : (11 forms)

  • VFMADDSUB213PS xmm, xmm, xmm [FMA3]
  • VFMADDSUB213PS m128, xmm, xmm [FMA3]
  • VFMADDSUB213PS ymm, ymm, ymm [FMA3]
  • VFMADDSUB213PS m256, ymm, ymm [FMA3]
  • VFMADDSUB213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB213PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADDSUB231PD 

func (self *Program) VFMADDSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB231PD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUB231PD Supported forms : (11 forms)

  • VFMADDSUB231PD xmm, xmm, xmm [FMA3]
  • VFMADDSUB231PD m128, xmm, xmm [FMA3]
  • VFMADDSUB231PD ymm, ymm, ymm [FMA3]
  • VFMADDSUB231PD m256, ymm, ymm [FMA3]
  • VFMADDSUB231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB231PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADDSUB231PS 

func (self *Program) VFMADDSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMADDSUB231PS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUB231PS Supported forms : (11 forms)

  • VFMADDSUB231PS xmm, xmm, xmm [FMA3]
  • VFMADDSUB231PS m128, xmm, xmm [FMA3]
  • VFMADDSUB231PS ymm, ymm, ymm [FMA3]
  • VFMADDSUB231PS m256, ymm, ymm [FMA3]
  • VFMADDSUB231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB231PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMADDSUB231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMADDSUB231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMADDSUBPD 

func (self *Program) VFMADDSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSUBPD performs "Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMADDSUBPD Supported forms : (6 forms)

  • VFMADDSUBPD xmm, xmm, xmm, xmm [FMA4]
  • VFMADDSUBPD m128, xmm, xmm, xmm [FMA4]
  • VFMADDSUBPD xmm, m128, xmm, xmm [FMA4]
  • VFMADDSUBPD ymm, ymm, ymm, ymm [FMA4]
  • VFMADDSUBPD m256, ymm, ymm, ymm [FMA4]
  • VFMADDSUBPD ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMADDSUBPS 

func (self *Program) VFMADDSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMADDSUBPS performs "Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMADDSUBPS Supported forms : (6 forms)

  • VFMADDSUBPS xmm, xmm, xmm, xmm [FMA4]
  • VFMADDSUBPS m128, xmm, xmm, xmm [FMA4]
  • VFMADDSUBPS xmm, m128, xmm, xmm [FMA4]
  • VFMADDSUBPS ymm, ymm, ymm, ymm [FMA4]
  • VFMADDSUBPS m256, ymm, ymm, ymm [FMA4]
  • VFMADDSUBPS ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMSUB132PD 

func (self *Program) VFMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUB132PD Supported forms : (11 forms)

  • VFMSUB132PD xmm, xmm, xmm [FMA3]
  • VFMSUB132PD m128, xmm, xmm [FMA3]
  • VFMSUB132PD ymm, ymm, ymm [FMA3]
  • VFMSUB132PD m256, ymm, ymm [FMA3]
  • VFMSUB132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB132PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUB132PS 

func (self *Program) VFMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUB132PS Supported forms : (11 forms)

  • VFMSUB132PS xmm, xmm, xmm [FMA3]
  • VFMSUB132PS m128, xmm, xmm [FMA3]
  • VFMSUB132PS ymm, ymm, ymm [FMA3]
  • VFMSUB132PS m256, ymm, ymm [FMA3]
  • VFMSUB132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB132PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUB132SD 

func (self *Program) VFMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUB132SD Supported forms : (5 forms)

  • VFMSUB132SD xmm, xmm, xmm [FMA3]
  • VFMSUB132SD m64, xmm, xmm [FMA3]
  • VFMSUB132SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB132SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMSUB132SS 

func (self *Program) VFMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB132SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUB132SS Supported forms : (5 forms)

  • VFMSUB132SS xmm, xmm, xmm [FMA3]
  • VFMSUB132SS m32, xmm, xmm [FMA3]
  • VFMSUB132SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB132SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMSUB213PD 

func (self *Program) VFMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUB213PD Supported forms : (11 forms)

  • VFMSUB213PD xmm, xmm, xmm [FMA3]
  • VFMSUB213PD m128, xmm, xmm [FMA3]
  • VFMSUB213PD ymm, ymm, ymm [FMA3]
  • VFMSUB213PD m256, ymm, ymm [FMA3]
  • VFMSUB213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB213PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUB213PS 

func (self *Program) VFMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUB213PS Supported forms : (11 forms)

  • VFMSUB213PS xmm, xmm, xmm [FMA3]
  • VFMSUB213PS m128, xmm, xmm [FMA3]
  • VFMSUB213PS ymm, ymm, ymm [FMA3]
  • VFMSUB213PS m256, ymm, ymm [FMA3]
  • VFMSUB213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB213PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUB213SD 

func (self *Program) VFMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUB213SD Supported forms : (5 forms)

  • VFMSUB213SD xmm, xmm, xmm [FMA3]
  • VFMSUB213SD m64, xmm, xmm [FMA3]
  • VFMSUB213SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB213SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMSUB213SS 

func (self *Program) VFMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB213SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUB213SS Supported forms : (5 forms)

  • VFMSUB213SS xmm, xmm, xmm [FMA3]
  • VFMSUB213SS m32, xmm, xmm [FMA3]
  • VFMSUB213SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB213SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMSUB231PD 

func (self *Program) VFMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231PD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUB231PD Supported forms : (11 forms)

  • VFMSUB231PD xmm, xmm, xmm [FMA3]
  • VFMSUB231PD m128, xmm, xmm [FMA3]
  • VFMSUB231PD ymm, ymm, ymm [FMA3]
  • VFMSUB231PD m256, ymm, ymm [FMA3]
  • VFMSUB231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB231PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUB231PS 

func (self *Program) VFMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231PS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUB231PS Supported forms : (11 forms)

  • VFMSUB231PS xmm, xmm, xmm [FMA3]
  • VFMSUB231PS m128, xmm, xmm [FMA3]
  • VFMSUB231PS ymm, ymm, ymm [FMA3]
  • VFMSUB231PS m256, ymm, ymm [FMA3]
  • VFMSUB231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB231PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUB231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUB231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUB231SD 

func (self *Program) VFMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231SD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUB231SD Supported forms : (5 forms)

  • VFMSUB231SD xmm, xmm, xmm [FMA3]
  • VFMSUB231SD m64, xmm, xmm [FMA3]
  • VFMSUB231SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB231SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMSUB231SS 

func (self *Program) VFMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUB231SS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUB231SS Supported forms : (5 forms)

  • VFMSUB231SS xmm, xmm, xmm [FMA3]
  • VFMSUB231SS m32, xmm, xmm [FMA3]
  • VFMSUB231SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFMSUB231SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFMSUBADD132PD 

func (self *Program) VFMSUBADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD132PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADD132PD Supported forms : (11 forms)

  • VFMSUBADD132PD xmm, xmm, xmm [FMA3]
  • VFMSUBADD132PD m128, xmm, xmm [FMA3]
  • VFMSUBADD132PD ymm, ymm, ymm [FMA3]
  • VFMSUBADD132PD m256, ymm, ymm [FMA3]
  • VFMSUBADD132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD132PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUBADD132PS 

func (self *Program) VFMSUBADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD132PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADD132PS Supported forms : (11 forms)

  • VFMSUBADD132PS xmm, xmm, xmm [FMA3]
  • VFMSUBADD132PS m128, xmm, xmm [FMA3]
  • VFMSUBADD132PS ymm, ymm, ymm [FMA3]
  • VFMSUBADD132PS m256, ymm, ymm [FMA3]
  • VFMSUBADD132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD132PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUBADD213PD 

func (self *Program) VFMSUBADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD213PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADD213PD Supported forms : (11 forms)

  • VFMSUBADD213PD xmm, xmm, xmm [FMA3]
  • VFMSUBADD213PD m128, xmm, xmm [FMA3]
  • VFMSUBADD213PD ymm, ymm, ymm [FMA3]
  • VFMSUBADD213PD m256, ymm, ymm [FMA3]
  • VFMSUBADD213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD213PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUBADD213PS 

func (self *Program) VFMSUBADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD213PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADD213PS Supported forms : (11 forms)

  • VFMSUBADD213PS xmm, xmm, xmm [FMA3]
  • VFMSUBADD213PS m128, xmm, xmm [FMA3]
  • VFMSUBADD213PS ymm, ymm, ymm [FMA3]
  • VFMSUBADD213PS m256, ymm, ymm [FMA3]
  • VFMSUBADD213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD213PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUBADD231PD 

func (self *Program) VFMSUBADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD231PD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADD231PD Supported forms : (11 forms)

  • VFMSUBADD231PD xmm, xmm, xmm [FMA3]
  • VFMSUBADD231PD m128, xmm, xmm [FMA3]
  • VFMSUBADD231PD ymm, ymm, ymm [FMA3]
  • VFMSUBADD231PD m256, ymm, ymm [FMA3]
  • VFMSUBADD231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD231PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUBADD231PS 

func (self *Program) VFMSUBADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFMSUBADD231PS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADD231PS Supported forms : (11 forms)

  • VFMSUBADD231PS xmm, xmm, xmm [FMA3]
  • VFMSUBADD231PS m128, xmm, xmm [FMA3]
  • VFMSUBADD231PS ymm, ymm, ymm [FMA3]
  • VFMSUBADD231PS m256, ymm, ymm [FMA3]
  • VFMSUBADD231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD231PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFMSUBADD231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFMSUBADD231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFMSUBADDPD 

func (self *Program) VFMSUBADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBADDPD performs "Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBADDPD Supported forms : (6 forms)

  • VFMSUBADDPD xmm, xmm, xmm, xmm [FMA4]
  • VFMSUBADDPD m128, xmm, xmm, xmm [FMA4]
  • VFMSUBADDPD xmm, m128, xmm, xmm [FMA4]
  • VFMSUBADDPD ymm, ymm, ymm, ymm [FMA4]
  • VFMSUBADDPD m256, ymm, ymm, ymm [FMA4]
  • VFMSUBADDPD ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMSUBADDPS 

func (self *Program) VFMSUBADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBADDPS performs "Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBADDPS Supported forms : (6 forms)

  • VFMSUBADDPS xmm, xmm, xmm, xmm [FMA4]
  • VFMSUBADDPS m128, xmm, xmm, xmm [FMA4]
  • VFMSUBADDPS xmm, m128, xmm, xmm [FMA4]
  • VFMSUBADDPS ymm, ymm, ymm, ymm [FMA4]
  • VFMSUBADDPS m256, ymm, ymm, ymm [FMA4]
  • VFMSUBADDPS ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMSUBPD 

func (self *Program) VFMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBPD performs "Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFMSUBPD Supported forms : (6 forms)

  • VFMSUBPD xmm, xmm, xmm, xmm [FMA4]
  • VFMSUBPD m128, xmm, xmm, xmm [FMA4]
  • VFMSUBPD xmm, m128, xmm, xmm [FMA4]
  • VFMSUBPD ymm, ymm, ymm, ymm [FMA4]
  • VFMSUBPD m256, ymm, ymm, ymm [FMA4]
  • VFMSUBPD ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMSUBPS 

func (self *Program) VFMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBPS performs "Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFMSUBPS Supported forms : (6 forms)

  • VFMSUBPS xmm, xmm, xmm, xmm [FMA4]
  • VFMSUBPS m128, xmm, xmm, xmm [FMA4]
  • VFMSUBPS xmm, m128, xmm, xmm [FMA4]
  • VFMSUBPS ymm, ymm, ymm, ymm [FMA4]
  • VFMSUBPS m256, ymm, ymm, ymm [FMA4]
  • VFMSUBPS ymm, m256, ymm, ymm [FMA4]

func (*Program) VFMSUBSD 

func (self *Program) VFMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBSD performs "Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFMSUBSD Supported forms : (3 forms)

  • VFMSUBSD xmm, xmm, xmm, xmm [FMA4]
  • VFMSUBSD m64, xmm, xmm, xmm [FMA4]
  • VFMSUBSD xmm, m64, xmm, xmm [FMA4]

func (*Program) VFMSUBSS 

func (self *Program) VFMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFMSUBSS performs "Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFMSUBSS Supported forms : (3 forms)

  • VFMSUBSS xmm, xmm, xmm, xmm [FMA4]
  • VFMSUBSS m32, xmm, xmm, xmm [FMA4]
  • VFMSUBSS xmm, m32, xmm, xmm [FMA4]

func (*Program) VFNMADD132PD 

func (self *Program) VFNMADD132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADD132PD Supported forms : (11 forms)

  • VFNMADD132PD xmm, xmm, xmm [FMA3]
  • VFNMADD132PD m128, xmm, xmm [FMA3]
  • VFNMADD132PD ymm, ymm, ymm [FMA3]
  • VFNMADD132PD m256, ymm, ymm [FMA3]
  • VFNMADD132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD132PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMADD132PS 

func (self *Program) VFNMADD132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADD132PS Supported forms : (11 forms)

  • VFNMADD132PS xmm, xmm, xmm [FMA3]
  • VFNMADD132PS m128, xmm, xmm [FMA3]
  • VFNMADD132PS ymm, ymm, ymm [FMA3]
  • VFNMADD132PS m256, ymm, ymm [FMA3]
  • VFNMADD132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD132PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMADD132SD 

func (self *Program) VFNMADD132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADD132SD Supported forms : (5 forms)

  • VFNMADD132SD xmm, xmm, xmm [FMA3]
  • VFNMADD132SD m64, xmm, xmm [FMA3]
  • VFNMADD132SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD132SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMADD132SS 

func (self *Program) VFNMADD132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD132SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADD132SS Supported forms : (5 forms)

  • VFNMADD132SS xmm, xmm, xmm [FMA3]
  • VFNMADD132SS m32, xmm, xmm [FMA3]
  • VFNMADD132SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD132SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMADD213PD 

func (self *Program) VFNMADD213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADD213PD Supported forms : (11 forms)

  • VFNMADD213PD xmm, xmm, xmm [FMA3]
  • VFNMADD213PD m128, xmm, xmm [FMA3]
  • VFNMADD213PD ymm, ymm, ymm [FMA3]
  • VFNMADD213PD m256, ymm, ymm [FMA3]
  • VFNMADD213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD213PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMADD213PS 

func (self *Program) VFNMADD213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADD213PS Supported forms : (11 forms)

  • VFNMADD213PS xmm, xmm, xmm [FMA3]
  • VFNMADD213PS m128, xmm, xmm [FMA3]
  • VFNMADD213PS ymm, ymm, ymm [FMA3]
  • VFNMADD213PS m256, ymm, ymm [FMA3]
  • VFNMADD213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD213PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMADD213SD 

func (self *Program) VFNMADD213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADD213SD Supported forms : (5 forms)

  • VFNMADD213SD xmm, xmm, xmm [FMA3]
  • VFNMADD213SD m64, xmm, xmm [FMA3]
  • VFNMADD213SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD213SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMADD213SS 

func (self *Program) VFNMADD213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD213SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADD213SS Supported forms : (5 forms)

  • VFNMADD213SS xmm, xmm, xmm [FMA3]
  • VFNMADD213SS m32, xmm, xmm [FMA3]
  • VFNMADD213SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD213SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMADD231PD 

func (self *Program) VFNMADD231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231PD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADD231PD Supported forms : (11 forms)

  • VFNMADD231PD xmm, xmm, xmm [FMA3]
  • VFNMADD231PD m128, xmm, xmm [FMA3]
  • VFNMADD231PD ymm, ymm, ymm [FMA3]
  • VFNMADD231PD m256, ymm, ymm [FMA3]
  • VFNMADD231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD231PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMADD231PS 

func (self *Program) VFNMADD231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231PS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADD231PS Supported forms : (11 forms)

  • VFNMADD231PS xmm, xmm, xmm [FMA3]
  • VFNMADD231PS m128, xmm, xmm [FMA3]
  • VFNMADD231PS ymm, ymm, ymm [FMA3]
  • VFNMADD231PS m256, ymm, ymm [FMA3]
  • VFNMADD231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD231PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMADD231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMADD231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMADD231SD 

func (self *Program) VFNMADD231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231SD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADD231SD Supported forms : (5 forms)

  • VFNMADD231SD xmm, xmm, xmm [FMA3]
  • VFNMADD231SD m64, xmm, xmm [FMA3]
  • VFNMADD231SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD231SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMADD231SS 

func (self *Program) VFNMADD231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMADD231SS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADD231SS Supported forms : (5 forms)

  • VFNMADD231SS xmm, xmm, xmm [FMA3]
  • VFNMADD231SS m32, xmm, xmm [FMA3]
  • VFNMADD231SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMADD231SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMADDPD 

func (self *Program) VFNMADDPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDPD performs "Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMADDPD Supported forms : (6 forms)

  • VFNMADDPD xmm, xmm, xmm, xmm [FMA4]
  • VFNMADDPD m128, xmm, xmm, xmm [FMA4]
  • VFNMADDPD xmm, m128, xmm, xmm [FMA4]
  • VFNMADDPD ymm, ymm, ymm, ymm [FMA4]
  • VFNMADDPD m256, ymm, ymm, ymm [FMA4]
  • VFNMADDPD ymm, m256, ymm, ymm [FMA4]

func (*Program) VFNMADDPS 

func (self *Program) VFNMADDPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDPS performs "Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMADDPS Supported forms : (6 forms)

  • VFNMADDPS xmm, xmm, xmm, xmm [FMA4]
  • VFNMADDPS m128, xmm, xmm, xmm [FMA4]
  • VFNMADDPS xmm, m128, xmm, xmm [FMA4]
  • VFNMADDPS ymm, ymm, ymm, ymm [FMA4]
  • VFNMADDPS m256, ymm, ymm, ymm [FMA4]
  • VFNMADDPS ymm, m256, ymm, ymm [FMA4]

func (*Program) VFNMADDSD 

func (self *Program) VFNMADDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDSD performs "Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMADDSD Supported forms : (3 forms)

  • VFNMADDSD xmm, xmm, xmm, xmm [FMA4]
  • VFNMADDSD m64, xmm, xmm, xmm [FMA4]
  • VFNMADDSD xmm, m64, xmm, xmm [FMA4]

func (*Program) VFNMADDSS 

func (self *Program) VFNMADDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMADDSS performs "Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMADDSS Supported forms : (3 forms)

  • VFNMADDSS xmm, xmm, xmm, xmm [FMA4]
  • VFNMADDSS m32, xmm, xmm, xmm [FMA4]
  • VFNMADDSS xmm, m32, xmm, xmm [FMA4]

func (*Program) VFNMSUB132PD 

func (self *Program) VFNMSUB132PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB132PD Supported forms : (11 forms)

  • VFNMSUB132PD xmm, xmm, xmm [FMA3]
  • VFNMSUB132PD m128, xmm, xmm [FMA3]
  • VFNMSUB132PD ymm, ymm, ymm [FMA3]
  • VFNMSUB132PD m256, ymm, ymm [FMA3]
  • VFNMSUB132PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB132PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB132PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB132PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB132PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB132PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB132PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMSUB132PS 

func (self *Program) VFNMSUB132PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB132PS Supported forms : (11 forms)

  • VFNMSUB132PS xmm, xmm, xmm [FMA3]
  • VFNMSUB132PS m128, xmm, xmm [FMA3]
  • VFNMSUB132PS ymm, ymm, ymm [FMA3]
  • VFNMSUB132PS m256, ymm, ymm [FMA3]
  • VFNMSUB132PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB132PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB132PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB132PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB132PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB132PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB132PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMSUB132SD 

func (self *Program) VFNMSUB132SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB132SD Supported forms : (5 forms)

  • VFNMSUB132SD xmm, xmm, xmm [FMA3]
  • VFNMSUB132SD m64, xmm, xmm [FMA3]
  • VFNMSUB132SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB132SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB132SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMSUB132SS 

func (self *Program) VFNMSUB132SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB132SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB132SS Supported forms : (5 forms)

  • VFNMSUB132SS xmm, xmm, xmm [FMA3]
  • VFNMSUB132SS m32, xmm, xmm [FMA3]
  • VFNMSUB132SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB132SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB132SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMSUB213PD 

func (self *Program) VFNMSUB213PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB213PD Supported forms : (11 forms)

  • VFNMSUB213PD xmm, xmm, xmm [FMA3]
  • VFNMSUB213PD m128, xmm, xmm [FMA3]
  • VFNMSUB213PD ymm, ymm, ymm [FMA3]
  • VFNMSUB213PD m256, ymm, ymm [FMA3]
  • VFNMSUB213PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB213PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB213PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB213PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB213PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB213PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB213PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMSUB213PS 

func (self *Program) VFNMSUB213PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB213PS Supported forms : (11 forms)

  • VFNMSUB213PS xmm, xmm, xmm [FMA3]
  • VFNMSUB213PS m128, xmm, xmm [FMA3]
  • VFNMSUB213PS ymm, ymm, ymm [FMA3]
  • VFNMSUB213PS m256, ymm, ymm [FMA3]
  • VFNMSUB213PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB213PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB213PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB213PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB213PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB213PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB213PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMSUB213SD 

func (self *Program) VFNMSUB213SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB213SD Supported forms : (5 forms)

  • VFNMSUB213SD xmm, xmm, xmm [FMA3]
  • VFNMSUB213SD m64, xmm, xmm [FMA3]
  • VFNMSUB213SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB213SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB213SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMSUB213SS 

func (self *Program) VFNMSUB213SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB213SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB213SS Supported forms : (5 forms)

  • VFNMSUB213SS xmm, xmm, xmm [FMA3]
  • VFNMSUB213SS m32, xmm, xmm [FMA3]
  • VFNMSUB213SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB213SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB213SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMSUB231PD 

func (self *Program) VFNMSUB231PD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231PD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB231PD Supported forms : (11 forms)

  • VFNMSUB231PD xmm, xmm, xmm [FMA3]
  • VFNMSUB231PD m128, xmm, xmm [FMA3]
  • VFNMSUB231PD ymm, ymm, ymm [FMA3]
  • VFNMSUB231PD m256, ymm, ymm [FMA3]
  • VFNMSUB231PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB231PD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB231PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB231PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB231PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB231PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB231PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMSUB231PS 

func (self *Program) VFNMSUB231PS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231PS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB231PS Supported forms : (11 forms)

  • VFNMSUB231PS xmm, xmm, xmm [FMA3]
  • VFNMSUB231PS m128, xmm, xmm [FMA3]
  • VFNMSUB231PS ymm, ymm, ymm [FMA3]
  • VFNMSUB231PS m256, ymm, ymm [FMA3]
  • VFNMSUB231PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB231PS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB231PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VFNMSUB231PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB231PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB231PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VFNMSUB231PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VFNMSUB231SD 

func (self *Program) VFNMSUB231SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231SD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUB231SD Supported forms : (5 forms)

  • VFNMSUB231SD xmm, xmm, xmm [FMA3]
  • VFNMSUB231SD m64, xmm, xmm [FMA3]
  • VFNMSUB231SD m64, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB231SD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB231SD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMSUB231SS 

func (self *Program) VFNMSUB231SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VFNMSUB231SS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUB231SS Supported forms : (5 forms)

  • VFNMSUB231SS xmm, xmm, xmm [FMA3]
  • VFNMSUB231SS m32, xmm, xmm [FMA3]
  • VFNMSUB231SS m32, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB231SS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VFNMSUB231SS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VFNMSUBPD 

func (self *Program) VFNMSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBPD performs "Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values".

Mnemonic : VFNMSUBPD Supported forms : (6 forms)

  • VFNMSUBPD xmm, xmm, xmm, xmm [FMA4]
  • VFNMSUBPD m128, xmm, xmm, xmm [FMA4]
  • VFNMSUBPD xmm, m128, xmm, xmm [FMA4]
  • VFNMSUBPD ymm, ymm, ymm, ymm [FMA4]
  • VFNMSUBPD m256, ymm, ymm, ymm [FMA4]
  • VFNMSUBPD ymm, m256, ymm, ymm [FMA4]

func (*Program) VFNMSUBPS 

func (self *Program) VFNMSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBPS performs "Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values".

Mnemonic : VFNMSUBPS Supported forms : (6 forms)

  • VFNMSUBPS xmm, xmm, xmm, xmm [FMA4]
  • VFNMSUBPS m128, xmm, xmm, xmm [FMA4]
  • VFNMSUBPS xmm, m128, xmm, xmm [FMA4]
  • VFNMSUBPS ymm, ymm, ymm, ymm [FMA4]
  • VFNMSUBPS m256, ymm, ymm, ymm [FMA4]
  • VFNMSUBPS ymm, m256, ymm, ymm [FMA4]

func (*Program) VFNMSUBSD 

func (self *Program) VFNMSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBSD performs "Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values".

Mnemonic : VFNMSUBSD Supported forms : (3 forms)

  • VFNMSUBSD xmm, xmm, xmm, xmm [FMA4]
  • VFNMSUBSD m64, xmm, xmm, xmm [FMA4]
  • VFNMSUBSD xmm, m64, xmm, xmm [FMA4]

func (*Program) VFNMSUBSS 

func (self *Program) VFNMSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VFNMSUBSS performs "Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values".

Mnemonic : VFNMSUBSS Supported forms : (3 forms)

  • VFNMSUBSS xmm, xmm, xmm, xmm [FMA4]
  • VFNMSUBSS m32, xmm, xmm, xmm [FMA4]
  • VFNMSUBSS xmm, m32, xmm, xmm [FMA4]

func (*Program) VFPCLASSPD 

func (self *Program) VFPCLASSPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSPD performs "Test Class of Packed Double-Precision Floating-Point Values".

Mnemonic : VFPCLASSPD Supported forms : (6 forms)

  • VFPCLASSPD imm8, m512/m64bcst, k{k} [AVX512DQ]
  • VFPCLASSPD imm8, zmm, k{k} [AVX512DQ]
  • VFPCLASSPD imm8, m128/m64bcst, k{k} [AVX512DQ,AVX512VL]
  • VFPCLASSPD imm8, m256/m64bcst, k{k} [AVX512DQ,AVX512VL]
  • VFPCLASSPD imm8, xmm, k{k} [AVX512DQ,AVX512VL]
  • VFPCLASSPD imm8, ymm, k{k} [AVX512DQ,AVX512VL]

func (*Program) VFPCLASSPS 

func (self *Program) VFPCLASSPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSPS performs "Test Class of Packed Single-Precision Floating-Point Values".

Mnemonic : VFPCLASSPS Supported forms : (6 forms)

  • VFPCLASSPS imm8, m512/m32bcst, k{k} [AVX512DQ]
  • VFPCLASSPS imm8, zmm, k{k} [AVX512DQ]
  • VFPCLASSPS imm8, m128/m32bcst, k{k} [AVX512DQ,AVX512VL]
  • VFPCLASSPS imm8, m256/m32bcst, k{k} [AVX512DQ,AVX512VL]
  • VFPCLASSPS imm8, xmm, k{k} [AVX512DQ,AVX512VL]
  • VFPCLASSPS imm8, ymm, k{k} [AVX512DQ,AVX512VL]

func (*Program) VFPCLASSSD 

func (self *Program) VFPCLASSSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSSD performs "Test Class of Scalar Double-Precision Floating-Point Value".

Mnemonic : VFPCLASSSD Supported forms : (2 forms)

  • VFPCLASSSD imm8, xmm, k{k} [AVX512DQ]
  • VFPCLASSSD imm8, m64, k{k} [AVX512DQ]

func (*Program) VFPCLASSSS 

func (self *Program) VFPCLASSSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VFPCLASSSS performs "Test Class of Scalar Single-Precision Floating-Point Value".

Mnemonic : VFPCLASSSS Supported forms : (2 forms)

  • VFPCLASSSS imm8, xmm, k{k} [AVX512DQ]
  • VFPCLASSSS imm8, m32, k{k} [AVX512DQ]

func (*Program) VFRCZPD 

func (self *Program) VFRCZPD(v0 interface{}, v1 interface{}) *Instruction

VFRCZPD performs "Extract Fraction Packed Double-Precision Floating-Point".

Mnemonic : VFRCZPD Supported forms : (4 forms)

  • VFRCZPD xmm, xmm [XOP]
  • VFRCZPD m128, xmm [XOP]
  • VFRCZPD ymm, ymm [XOP]
  • VFRCZPD m256, ymm [XOP]

func (*Program) VFRCZPS 

func (self *Program) VFRCZPS(v0 interface{}, v1 interface{}) *Instruction

VFRCZPS performs "Extract Fraction Packed Single-Precision Floating-Point".

Mnemonic : VFRCZPS Supported forms : (4 forms)

  • VFRCZPS xmm, xmm [XOP]
  • VFRCZPS m128, xmm [XOP]
  • VFRCZPS ymm, ymm [XOP]
  • VFRCZPS m256, ymm [XOP]

func (*Program) VFRCZSD 

func (self *Program) VFRCZSD(v0 interface{}, v1 interface{}) *Instruction

VFRCZSD performs "Extract Fraction Scalar Double-Precision Floating-Point".

Mnemonic : VFRCZSD Supported forms : (2 forms)

  • VFRCZSD xmm, xmm [XOP]
  • VFRCZSD m64, xmm [XOP]

func (*Program) VFRCZSS 

func (self *Program) VFRCZSS(v0 interface{}, v1 interface{}) *Instruction

VFRCZSS performs "Extract Fraction Scalar Single-Precision Floating Point".

Mnemonic : VFRCZSS Supported forms : (2 forms)

  • VFRCZSS xmm, xmm [XOP]
  • VFRCZSS m32, xmm [XOP]

func (*Program) VGATHERDPD 

func (self *Program) VGATHERDPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERDPD performs "Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices".

Mnemonic : VGATHERDPD Supported forms : (5 forms)

  • VGATHERDPD xmm, vm32x, xmm [AVX2]
  • VGATHERDPD ymm, vm32x, ymm [AVX2]
  • VGATHERDPD vm32y, zmm{k} [AVX512F]
  • VGATHERDPD vm32x, xmm{k} [AVX512F,AVX512VL]
  • VGATHERDPD vm32x, ymm{k} [AVX512F,AVX512VL]

func (*Program) VGATHERDPS 

func (self *Program) VGATHERDPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERDPS performs "Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices".

Mnemonic : VGATHERDPS Supported forms : (5 forms)

  • VGATHERDPS xmm, vm32x, xmm [AVX2]
  • VGATHERDPS ymm, vm32y, ymm [AVX2]
  • VGATHERDPS vm32z, zmm{k} [AVX512F]
  • VGATHERDPS vm32x, xmm{k} [AVX512F,AVX512VL]
  • VGATHERDPS vm32y, ymm{k} [AVX512F,AVX512VL]

func (*Program) VGATHERPF0DPD 

func (self *Program) VGATHERPF0DPD(v0 interface{}) *Instruction

VGATHERPF0DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint".

Mnemonic : VGATHERPF0DPD Supported forms : (1 form)

  • VGATHERPF0DPD vm32y{k} [AVX512PF]

func (*Program) VGATHERPF0DPS 

func (self *Program) VGATHERPF0DPS(v0 interface{}) *Instruction

VGATHERPF0DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint".

Mnemonic : VGATHERPF0DPS Supported forms : (1 form)

  • VGATHERPF0DPS vm32z{k} [AVX512PF]

func (*Program) VGATHERPF0QPD 

func (self *Program) VGATHERPF0QPD(v0 interface{}) *Instruction

VGATHERPF0QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint".

Mnemonic : VGATHERPF0QPD Supported forms : (1 form)

  • VGATHERPF0QPD vm64z{k} [AVX512PF]

func (*Program) VGATHERPF0QPS 

func (self *Program) VGATHERPF0QPS(v0 interface{}) *Instruction

VGATHERPF0QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint".

Mnemonic : VGATHERPF0QPS Supported forms : (1 form)

  • VGATHERPF0QPS vm64z{k} [AVX512PF]

func (*Program) VGATHERPF1DPD 

func (self *Program) VGATHERPF1DPD(v0 interface{}) *Instruction

VGATHERPF1DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint".

Mnemonic : VGATHERPF1DPD Supported forms : (1 form)

  • VGATHERPF1DPD vm32y{k} [AVX512PF]

func (*Program) VGATHERPF1DPS 

func (self *Program) VGATHERPF1DPS(v0 interface{}) *Instruction

VGATHERPF1DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint".

Mnemonic : VGATHERPF1DPS Supported forms : (1 form)

  • VGATHERPF1DPS vm32z{k} [AVX512PF]

func (*Program) VGATHERPF1QPD 

func (self *Program) VGATHERPF1QPD(v0 interface{}) *Instruction

VGATHERPF1QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint".

Mnemonic : VGATHERPF1QPD Supported forms : (1 form)

  • VGATHERPF1QPD vm64z{k} [AVX512PF]

func (*Program) VGATHERPF1QPS 

func (self *Program) VGATHERPF1QPS(v0 interface{}) *Instruction

VGATHERPF1QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint".

Mnemonic : VGATHERPF1QPS Supported forms : (1 form)

  • VGATHERPF1QPS vm64z{k} [AVX512PF]

func (*Program) VGATHERQPD 

func (self *Program) VGATHERQPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERQPD performs "Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices".

Mnemonic : VGATHERQPD Supported forms : (5 forms)

  • VGATHERQPD xmm, vm64x, xmm [AVX2]
  • VGATHERQPD ymm, vm64y, ymm [AVX2]
  • VGATHERQPD vm64z, zmm{k} [AVX512F]
  • VGATHERQPD vm64x, xmm{k} [AVX512F,AVX512VL]
  • VGATHERQPD vm64y, ymm{k} [AVX512F,AVX512VL]

func (*Program) VGATHERQPS 

func (self *Program) VGATHERQPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGATHERQPS performs "Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices".

Mnemonic : VGATHERQPS Supported forms : (5 forms)

  • VGATHERQPS xmm, vm64x, xmm [AVX2]
  • VGATHERQPS xmm, vm64y, xmm [AVX2]
  • VGATHERQPS vm64z, ymm{k} [AVX512F]
  • VGATHERQPS vm64x, xmm{k} [AVX512F,AVX512VL]
  • VGATHERQPS vm64y, xmm{k} [AVX512F,AVX512VL]

func (*Program) VGETEXPPD 

func (self *Program) VGETEXPPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGETEXPPD performs "Extract Exponents of Packed Double-Precision Floating-Point Values as Double-Precision Floating-Point Values".

Mnemonic : VGETEXPPD Supported forms : (7 forms)

  • VGETEXPPD m512/m64bcst, zmm{k}{z} [AVX512F]
  • VGETEXPPD {sae}, zmm, zmm{k}{z} [AVX512F]
  • VGETEXPPD zmm, zmm{k}{z} [AVX512F]
  • VGETEXPPD m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETEXPPD m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VGETEXPPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETEXPPD ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VGETEXPPS 

func (self *Program) VGETEXPPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VGETEXPPS performs "Extract Exponents of Packed Single-Precision Floating-Point Values as Single-Precision Floating-Point Values".

Mnemonic : VGETEXPPS Supported forms : (7 forms)

  • VGETEXPPS m512/m32bcst, zmm{k}{z} [AVX512F]
  • VGETEXPPS {sae}, zmm, zmm{k}{z} [AVX512F]
  • VGETEXPPS zmm, zmm{k}{z} [AVX512F]
  • VGETEXPPS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETEXPPS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VGETEXPPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETEXPPS ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VGETEXPSD 

func (self *Program) VGETEXPSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETEXPSD performs "Extract Exponent of Scalar Double-Precision Floating-Point Value as Double-Precision Floating-Point Value".

Mnemonic : VGETEXPSD Supported forms : (3 forms)

  • VGETEXPSD m64, xmm, xmm{k}{z} [AVX512F]
  • VGETEXPSD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VGETEXPSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VGETEXPSS 

func (self *Program) VGETEXPSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETEXPSS performs "Extract Exponent of Scalar Single-Precision Floating-Point Value as Single-Precision Floating-Point Value".

Mnemonic : VGETEXPSS Supported forms : (3 forms)

  • VGETEXPSS m32, xmm, xmm{k}{z} [AVX512F]
  • VGETEXPSS {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VGETEXPSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VGETMANTPD 

func (self *Program) VGETMANTPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETMANTPD performs "Extract Normalized Mantissas from Packed Double-Precision Floating-Point Values".

Mnemonic : VGETMANTPD Supported forms : (7 forms)

  • VGETMANTPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VGETMANTPD imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
  • VGETMANTPD imm8, zmm, zmm{k}{z} [AVX512F]
  • VGETMANTPD imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETMANTPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VGETMANTPD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETMANTPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VGETMANTPS 

func (self *Program) VGETMANTPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VGETMANTPS performs "Extract Normalized Mantissas from Packed Single-Precision Floating-Point Values".

Mnemonic : VGETMANTPS Supported forms : (7 forms)

  • VGETMANTPS imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VGETMANTPS imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
  • VGETMANTPS imm8, zmm, zmm{k}{z} [AVX512F]
  • VGETMANTPS imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETMANTPS imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VGETMANTPS imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VGETMANTPS imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VGETMANTSD 

func (self *Program) VGETMANTSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VGETMANTSD performs "Extract Normalized Mantissa from Scalar Double-Precision Floating-Point Value".

Mnemonic : VGETMANTSD Supported forms : (3 forms)

  • VGETMANTSD imm8, m64, xmm, xmm{k}{z} [AVX512F]
  • VGETMANTSD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VGETMANTSD imm8, xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VGETMANTSS 

func (self *Program) VGETMANTSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VGETMANTSS performs "Extract Normalized Mantissa from Scalar Single-Precision Floating-Point Value".

Mnemonic : VGETMANTSS Supported forms : (3 forms)

  • VGETMANTSS imm8, m32, xmm, xmm{k}{z} [AVX512F]
  • VGETMANTSS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VGETMANTSS imm8, xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VHADDPD 

func (self *Program) VHADDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHADDPD performs "Packed Double-FP Horizontal Add".

Mnemonic : VHADDPD Supported forms : (4 forms)

  • VHADDPD xmm, xmm, xmm [AVX]
  • VHADDPD m128, xmm, xmm [AVX]
  • VHADDPD ymm, ymm, ymm [AVX]
  • VHADDPD m256, ymm, ymm [AVX]

func (*Program) VHADDPS 

func (self *Program) VHADDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHADDPS performs "Packed Single-FP Horizontal Add".

Mnemonic : VHADDPS Supported forms : (4 forms)

  • VHADDPS xmm, xmm, xmm [AVX]
  • VHADDPS m128, xmm, xmm [AVX]
  • VHADDPS ymm, ymm, ymm [AVX]
  • VHADDPS m256, ymm, ymm [AVX]

func (*Program) VHSUBPD 

func (self *Program) VHSUBPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHSUBPD performs "Packed Double-FP Horizontal Subtract".

Mnemonic : VHSUBPD Supported forms : (4 forms)

  • VHSUBPD xmm, xmm, xmm [AVX]
  • VHSUBPD m128, xmm, xmm [AVX]
  • VHSUBPD ymm, ymm, ymm [AVX]
  • VHSUBPD m256, ymm, ymm [AVX]

func (*Program) VHSUBPS 

func (self *Program) VHSUBPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VHSUBPS performs "Packed Single-FP Horizontal Subtract".

Mnemonic : VHSUBPS Supported forms : (4 forms)

  • VHSUBPS xmm, xmm, xmm [AVX]
  • VHSUBPS m128, xmm, xmm [AVX]
  • VHSUBPS ymm, ymm, ymm [AVX]
  • VHSUBPS m256, ymm, ymm [AVX]

func (*Program) VINSERTF128 

func (self *Program) VINSERTF128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF128 performs "Insert Packed Floating-Point Values".

Mnemonic : VINSERTF128 Supported forms : (2 forms)

  • VINSERTF128 imm8, xmm, ymm, ymm [AVX]
  • VINSERTF128 imm8, m128, ymm, ymm [AVX]

func (*Program) VINSERTF32X4 

func (self *Program) VINSERTF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF32X4 performs "Insert 128 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VINSERTF32X4 Supported forms : (4 forms)

  • VINSERTF32X4 imm8, xmm, zmm, zmm{k}{z} [AVX512F]
  • VINSERTF32X4 imm8, m128, zmm, zmm{k}{z} [AVX512F]
  • VINSERTF32X4 imm8, xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VINSERTF32X4 imm8, m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VINSERTF32X8 

func (self *Program) VINSERTF32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF32X8 performs "Insert 256 Bits of Packed Single-Precision Floating-Point Values".

Mnemonic : VINSERTF32X8 Supported forms : (2 forms)

  • VINSERTF32X8 imm8, ymm, zmm, zmm{k}{z} [AVX512DQ]
  • VINSERTF32X8 imm8, m256, zmm, zmm{k}{z} [AVX512DQ]

func (*Program) VINSERTF64X2 

func (self *Program) VINSERTF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF64X2 performs "Insert 128 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VINSERTF64X2 Supported forms : (4 forms)

  • VINSERTF64X2 imm8, xmm, zmm, zmm{k}{z} [AVX512DQ]
  • VINSERTF64X2 imm8, m128, zmm, zmm{k}{z} [AVX512DQ]
  • VINSERTF64X2 imm8, xmm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VINSERTF64X2 imm8, m128, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VINSERTF64X4 

func (self *Program) VINSERTF64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTF64X4 performs "Insert 256 Bits of Packed Double-Precision Floating-Point Values".

Mnemonic : VINSERTF64X4 Supported forms : (2 forms)

  • VINSERTF64X4 imm8, ymm, zmm, zmm{k}{z} [AVX512F]
  • VINSERTF64X4 imm8, m256, zmm, zmm{k}{z} [AVX512F]

func (*Program) VINSERTI128 

func (self *Program) VINSERTI128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI128 performs "Insert Packed Integer Values".

Mnemonic : VINSERTI128 Supported forms : (2 forms)

  • VINSERTI128 imm8, xmm, ymm, ymm [AVX2]
  • VINSERTI128 imm8, m128, ymm, ymm [AVX2]

func (*Program) VINSERTI32X4 

func (self *Program) VINSERTI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI32X4 performs "Insert 128 Bits of Packed Doubleword Integer Values".

Mnemonic : VINSERTI32X4 Supported forms : (4 forms)

  • VINSERTI32X4 imm8, xmm, zmm, zmm{k}{z} [AVX512F]
  • VINSERTI32X4 imm8, m128, zmm, zmm{k}{z} [AVX512F]
  • VINSERTI32X4 imm8, xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VINSERTI32X4 imm8, m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VINSERTI32X8 

func (self *Program) VINSERTI32X8(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI32X8 performs "Insert 256 Bits of Packed Doubleword Integer Values".

Mnemonic : VINSERTI32X8 Supported forms : (2 forms)

  • VINSERTI32X8 imm8, ymm, zmm, zmm{k}{z} [AVX512DQ]
  • VINSERTI32X8 imm8, m256, zmm, zmm{k}{z} [AVX512DQ]

func (*Program) VINSERTI64X2 

func (self *Program) VINSERTI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI64X2 performs "Insert 128 Bits of Packed Quadword Integer Values".

Mnemonic : VINSERTI64X2 Supported forms : (4 forms)

  • VINSERTI64X2 imm8, xmm, zmm, zmm{k}{z} [AVX512DQ]
  • VINSERTI64X2 imm8, m128, zmm, zmm{k}{z} [AVX512DQ]
  • VINSERTI64X2 imm8, xmm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VINSERTI64X2 imm8, m128, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VINSERTI64X4 

func (self *Program) VINSERTI64X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTI64X4 performs "Insert 256 Bits of Packed Quadword Integer Values".

Mnemonic : VINSERTI64X4 Supported forms : (2 forms)

  • VINSERTI64X4 imm8, ymm, zmm, zmm{k}{z} [AVX512F]
  • VINSERTI64X4 imm8, m256, zmm, zmm{k}{z} [AVX512F]

func (*Program) VINSERTPS 

func (self *Program) VINSERTPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VINSERTPS performs "Insert Packed Single Precision Floating-Point Value".

Mnemonic : VINSERTPS Supported forms : (4 forms)

  • VINSERTPS imm8, xmm, xmm, xmm [AVX]
  • VINSERTPS imm8, m32, xmm, xmm [AVX]
  • VINSERTPS imm8, xmm, xmm, xmm [AVX512F]
  • VINSERTPS imm8, m32, xmm, xmm [AVX512F]

func (*Program) VLDDQU 

func (self *Program) VLDDQU(v0 interface{}, v1 interface{}) *Instruction

VLDDQU performs "Load Unaligned Integer 128 Bits".

Mnemonic : VLDDQU Supported forms : (2 forms)

  • VLDDQU m128, xmm [AVX]
  • VLDDQU m256, ymm [AVX]

func (*Program) VLDMXCSR 

func (self *Program) VLDMXCSR(v0 interface{}) *Instruction

VLDMXCSR performs "Load MXCSR Register".

Mnemonic : VLDMXCSR Supported forms : (1 form)

  • VLDMXCSR m32 [AVX]

func (*Program) VMASKMOVDQU 

func (self *Program) VMASKMOVDQU(v0 interface{}, v1 interface{}) *Instruction

VMASKMOVDQU performs "Store Selected Bytes of Double Quadword".

Mnemonic : VMASKMOVDQU Supported forms : (1 form)

  • VMASKMOVDQU xmm, xmm [AVX]

func (*Program) VMASKMOVPD 

func (self *Program) VMASKMOVPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMASKMOVPD performs "Conditional Move Packed Double-Precision Floating-Point Values".

Mnemonic : VMASKMOVPD Supported forms : (4 forms)

  • VMASKMOVPD m128, xmm, xmm [AVX]
  • VMASKMOVPD m256, ymm, ymm [AVX]
  • VMASKMOVPD xmm, xmm, m128 [AVX]
  • VMASKMOVPD ymm, ymm, m256 [AVX]

func (*Program) VMASKMOVPS 

func (self *Program) VMASKMOVPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMASKMOVPS performs "Conditional Move Packed Single-Precision Floating-Point Values".

Mnemonic : VMASKMOVPS Supported forms : (4 forms)

  • VMASKMOVPS m128, xmm, xmm [AVX]
  • VMASKMOVPS m256, ymm, ymm [AVX]
  • VMASKMOVPS xmm, xmm, m128 [AVX]
  • VMASKMOVPS ymm, ymm, m256 [AVX]

func (*Program) VMAXPD 

func (self *Program) VMAXPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXPD performs "Return Maximum Packed Double-Precision Floating-Point Values".

Mnemonic : VMAXPD Supported forms : (11 forms)

  • VMAXPD xmm, xmm, xmm [AVX]
  • VMAXPD m128, xmm, xmm [AVX]
  • VMAXPD ymm, ymm, ymm [AVX]
  • VMAXPD m256, ymm, ymm [AVX]
  • VMAXPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VMAXPD {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VMAXPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VMAXPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMAXPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMAXPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMAXPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMAXPS 

func (self *Program) VMAXPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXPS performs "Return Maximum Packed Single-Precision Floating-Point Values".

Mnemonic : VMAXPS Supported forms : (11 forms)

  • VMAXPS xmm, xmm, xmm [AVX]
  • VMAXPS m128, xmm, xmm [AVX]
  • VMAXPS ymm, ymm, ymm [AVX]
  • VMAXPS m256, ymm, ymm [AVX]
  • VMAXPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VMAXPS {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VMAXPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VMAXPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMAXPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMAXPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMAXPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMAXSD 

func (self *Program) VMAXSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXSD performs "Return Maximum Scalar Double-Precision Floating-Point Value".

Mnemonic : VMAXSD Supported forms : (5 forms)

  • VMAXSD xmm, xmm, xmm [AVX]
  • VMAXSD m64, xmm, xmm [AVX]
  • VMAXSD m64, xmm, xmm{k}{z} [AVX512F]
  • VMAXSD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VMAXSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMAXSS 

func (self *Program) VMAXSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMAXSS performs "Return Maximum Scalar Single-Precision Floating-Point Value".

Mnemonic : VMAXSS Supported forms : (5 forms)

  • VMAXSS xmm, xmm, xmm [AVX]
  • VMAXSS m32, xmm, xmm [AVX]
  • VMAXSS m32, xmm, xmm{k}{z} [AVX512F]
  • VMAXSS {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VMAXSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMINPD 

func (self *Program) VMINPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINPD performs "Return Minimum Packed Double-Precision Floating-Point Values".

Mnemonic : VMINPD Supported forms : (11 forms)

  • VMINPD xmm, xmm, xmm [AVX]
  • VMINPD m128, xmm, xmm [AVX]
  • VMINPD ymm, ymm, ymm [AVX]
  • VMINPD m256, ymm, ymm [AVX]
  • VMINPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VMINPD {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VMINPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VMINPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMINPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMINPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMINPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMINPS 

func (self *Program) VMINPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINPS performs "Return Minimum Packed Single-Precision Floating-Point Values".

Mnemonic : VMINPS Supported forms : (11 forms)

  • VMINPS xmm, xmm, xmm [AVX]
  • VMINPS m128, xmm, xmm [AVX]
  • VMINPS ymm, ymm, ymm [AVX]
  • VMINPS m256, ymm, ymm [AVX]
  • VMINPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VMINPS {sae}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VMINPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VMINPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMINPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMINPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMINPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMINSD 

func (self *Program) VMINSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINSD performs "Return Minimum Scalar Double-Precision Floating-Point Value".

Mnemonic : VMINSD Supported forms : (5 forms)

  • VMINSD xmm, xmm, xmm [AVX]
  • VMINSD m64, xmm, xmm [AVX]
  • VMINSD m64, xmm, xmm{k}{z} [AVX512F]
  • VMINSD {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VMINSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMINSS 

func (self *Program) VMINSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMINSS performs "Return Minimum Scalar Single-Precision Floating-Point Value".

Mnemonic : VMINSS Supported forms : (5 forms)

  • VMINSS xmm, xmm, xmm [AVX]
  • VMINSS m32, xmm, xmm [AVX]
  • VMINSS m32, xmm, xmm{k}{z} [AVX512F]
  • VMINSS {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VMINSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMOVAPD 

func (self *Program) VMOVAPD(v0 interface{}, v1 interface{}) *Instruction

VMOVAPD performs "Move Aligned Packed Double-Precision Floating-Point Values".

Mnemonic : VMOVAPD Supported forms : (15 forms)

  • VMOVAPD xmm, xmm [AVX]
  • VMOVAPD m128, xmm [AVX]
  • VMOVAPD ymm, ymm [AVX]
  • VMOVAPD m256, ymm [AVX]
  • VMOVAPD xmm, m128 [AVX]
  • VMOVAPD ymm, m256 [AVX]
  • VMOVAPD zmm, m512{k}{z} [AVX512F]
  • VMOVAPD zmm, zmm{k}{z} [AVX512F]
  • VMOVAPD m512, zmm{k}{z} [AVX512F]
  • VMOVAPD xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVAPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVAPD ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVAPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVAPD m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVAPD m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVAPS 

func (self *Program) VMOVAPS(v0 interface{}, v1 interface{}) *Instruction

VMOVAPS performs "Move Aligned Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVAPS Supported forms : (15 forms)

  • VMOVAPS xmm, xmm [AVX]
  • VMOVAPS m128, xmm [AVX]
  • VMOVAPS ymm, ymm [AVX]
  • VMOVAPS m256, ymm [AVX]
  • VMOVAPS xmm, m128 [AVX]
  • VMOVAPS ymm, m256 [AVX]
  • VMOVAPS zmm, m512{k}{z} [AVX512F]
  • VMOVAPS zmm, zmm{k}{z} [AVX512F]
  • VMOVAPS m512, zmm{k}{z} [AVX512F]
  • VMOVAPS xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVAPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVAPS ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVAPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVAPS m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVAPS m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVD 

func (self *Program) VMOVD(v0 interface{}, v1 interface{}) *Instruction

VMOVD performs "Move Doubleword".

Mnemonic : VMOVD Supported forms : (8 forms)

  • VMOVD xmm, r32 [AVX]
  • VMOVD r32, xmm [AVX]
  • VMOVD m32, xmm [AVX]
  • VMOVD xmm, m32 [AVX]
  • VMOVD xmm, r32 [AVX512F]
  • VMOVD r32, xmm [AVX512F]
  • VMOVD m32, xmm [AVX512F]
  • VMOVD xmm, m32 [AVX512F]

func (*Program) VMOVDDUP 

func (self *Program) VMOVDDUP(v0 interface{}, v1 interface{}) *Instruction

VMOVDDUP performs "Move One Double-FP and Duplicate".

Mnemonic : VMOVDDUP Supported forms : (10 forms)

  • VMOVDDUP xmm, xmm [AVX]
  • VMOVDDUP m64, xmm [AVX]
  • VMOVDDUP ymm, ymm [AVX]
  • VMOVDDUP m256, ymm [AVX]
  • VMOVDDUP zmm, zmm{k}{z} [AVX512F]
  • VMOVDDUP m512, zmm{k}{z} [AVX512F]
  • VMOVDDUP xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDDUP ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVDDUP m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDDUP m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVDQA 

func (self *Program) VMOVDQA(v0 interface{}, v1 interface{}) *Instruction

VMOVDQA performs "Move Aligned Double Quadword".

Mnemonic : VMOVDQA Supported forms : (6 forms)

  • VMOVDQA xmm, xmm [AVX]
  • VMOVDQA m128, xmm [AVX]
  • VMOVDQA ymm, ymm [AVX]
  • VMOVDQA m256, ymm [AVX]
  • VMOVDQA xmm, m128 [AVX]
  • VMOVDQA ymm, m256 [AVX]

func (*Program) VMOVDQA32 

func (self *Program) VMOVDQA32(v0 interface{}, v1 interface{}) *Instruction

VMOVDQA32 performs "Move Aligned Doubleword Values".

Mnemonic : VMOVDQA32 Supported forms : (9 forms)

  • VMOVDQA32 zmm, m512{k}{z} [AVX512F]
  • VMOVDQA32 zmm, zmm{k}{z} [AVX512F]
  • VMOVDQA32 m512, zmm{k}{z} [AVX512F]
  • VMOVDQA32 xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA32 xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA32 ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA32 ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA32 m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA32 m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVDQA64 

func (self *Program) VMOVDQA64(v0 interface{}, v1 interface{}) *Instruction

VMOVDQA64 performs "Move Aligned Quadword Values".

Mnemonic : VMOVDQA64 Supported forms : (9 forms)

  • VMOVDQA64 zmm, m512{k}{z} [AVX512F]
  • VMOVDQA64 zmm, zmm{k}{z} [AVX512F]
  • VMOVDQA64 m512, zmm{k}{z} [AVX512F]
  • VMOVDQA64 xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA64 xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA64 ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA64 ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA64 m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQA64 m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVDQU 

func (self *Program) VMOVDQU(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU performs "Move Unaligned Double Quadword".

Mnemonic : VMOVDQU Supported forms : (6 forms)

  • VMOVDQU xmm, xmm [AVX]
  • VMOVDQU m128, xmm [AVX]
  • VMOVDQU ymm, ymm [AVX]
  • VMOVDQU m256, ymm [AVX]
  • VMOVDQU xmm, m128 [AVX]
  • VMOVDQU ymm, m256 [AVX]

func (*Program) VMOVDQU16 

func (self *Program) VMOVDQU16(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU16 performs "Move Unaligned Word Values".

Mnemonic : VMOVDQU16 Supported forms : (9 forms)

  • VMOVDQU16 zmm, m512{k}{z} [AVX512BW]
  • VMOVDQU16 zmm, zmm{k}{z} [AVX512BW]
  • VMOVDQU16 m512, zmm{k}{z} [AVX512BW]
  • VMOVDQU16 xmm, m128{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU16 xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU16 ymm, m256{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU16 ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU16 m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU16 m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VMOVDQU32 

func (self *Program) VMOVDQU32(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU32 performs "Move Unaligned Doubleword Values".

Mnemonic : VMOVDQU32 Supported forms : (9 forms)

  • VMOVDQU32 zmm, m512{k}{z} [AVX512F]
  • VMOVDQU32 zmm, zmm{k}{z} [AVX512F]
  • VMOVDQU32 m512, zmm{k}{z} [AVX512F]
  • VMOVDQU32 xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU32 xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU32 ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU32 ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU32 m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU32 m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVDQU64 

func (self *Program) VMOVDQU64(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU64 performs "Move Unaligned Quadword Values".

Mnemonic : VMOVDQU64 Supported forms : (9 forms)

  • VMOVDQU64 zmm, m512{k}{z} [AVX512F]
  • VMOVDQU64 zmm, zmm{k}{z} [AVX512F]
  • VMOVDQU64 m512, zmm{k}{z} [AVX512F]
  • VMOVDQU64 xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU64 xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU64 ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU64 ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU64 m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVDQU64 m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVDQU8 

func (self *Program) VMOVDQU8(v0 interface{}, v1 interface{}) *Instruction

VMOVDQU8 performs "Move Unaligned Byte Values".

Mnemonic : VMOVDQU8 Supported forms : (9 forms)

  • VMOVDQU8 zmm, m512{k}{z} [AVX512BW]
  • VMOVDQU8 zmm, zmm{k}{z} [AVX512BW]
  • VMOVDQU8 m512, zmm{k}{z} [AVX512BW]
  • VMOVDQU8 xmm, m128{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU8 xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU8 ymm, m256{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU8 ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU8 m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VMOVDQU8 m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VMOVHLPS 

func (self *Program) VMOVHLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMOVHLPS performs "Move Packed Single-Precision Floating-Point Values High to Low".

Mnemonic : VMOVHLPS Supported forms : (2 forms)

  • VMOVHLPS xmm, xmm, xmm [AVX]
  • VMOVHLPS xmm, xmm, xmm [AVX512F]

func (*Program) VMOVHPD 

func (self *Program) VMOVHPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVHPD performs "Move High Packed Double-Precision Floating-Point Value".

Mnemonic : VMOVHPD Supported forms : (4 forms)

  • VMOVHPD xmm, m64 [AVX]
  • VMOVHPD m64, xmm, xmm [AVX]
  • VMOVHPD xmm, m64 [AVX512F]
  • VMOVHPD m64, xmm, xmm [AVX512F]

func (*Program) VMOVHPS 

func (self *Program) VMOVHPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVHPS performs "Move High Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVHPS Supported forms : (4 forms)

  • VMOVHPS xmm, m64 [AVX]
  • VMOVHPS m64, xmm, xmm [AVX]
  • VMOVHPS xmm, m64 [AVX512F]
  • VMOVHPS m64, xmm, xmm [AVX512F]

func (*Program) VMOVLHPS 

func (self *Program) VMOVLHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VMOVLHPS performs "Move Packed Single-Precision Floating-Point Values Low to High".

Mnemonic : VMOVLHPS Supported forms : (2 forms)

  • VMOVLHPS xmm, xmm, xmm [AVX]
  • VMOVLHPS xmm, xmm, xmm [AVX512F]

func (*Program) VMOVLPD 

func (self *Program) VMOVLPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVLPD performs "Move Low Packed Double-Precision Floating-Point Value".

Mnemonic : VMOVLPD Supported forms : (4 forms)

  • VMOVLPD xmm, m64 [AVX]
  • VMOVLPD m64, xmm, xmm [AVX]
  • VMOVLPD xmm, m64 [AVX512F]
  • VMOVLPD m64, xmm, xmm [AVX512F]

func (*Program) VMOVLPS 

func (self *Program) VMOVLPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVLPS performs "Move Low Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVLPS Supported forms : (4 forms)

  • VMOVLPS xmm, m64 [AVX]
  • VMOVLPS m64, xmm, xmm [AVX]
  • VMOVLPS xmm, m64 [AVX512F]
  • VMOVLPS m64, xmm, xmm [AVX512F]

func (*Program) VMOVMSKPD 

func (self *Program) VMOVMSKPD(v0 interface{}, v1 interface{}) *Instruction

VMOVMSKPD performs "Extract Packed Double-Precision Floating-Point Sign Mask".

Mnemonic : VMOVMSKPD Supported forms : (2 forms)

  • VMOVMSKPD xmm, r32 [AVX]
  • VMOVMSKPD ymm, r32 [AVX]

func (*Program) VMOVMSKPS 

func (self *Program) VMOVMSKPS(v0 interface{}, v1 interface{}) *Instruction

VMOVMSKPS performs "Extract Packed Single-Precision Floating-Point Sign Mask".

Mnemonic : VMOVMSKPS Supported forms : (2 forms)

  • VMOVMSKPS xmm, r32 [AVX]
  • VMOVMSKPS ymm, r32 [AVX]

func (*Program) VMOVNTDQ 

func (self *Program) VMOVNTDQ(v0 interface{}, v1 interface{}) *Instruction

VMOVNTDQ performs "Store Double Quadword Using Non-Temporal Hint".

Mnemonic : VMOVNTDQ Supported forms : (5 forms)

  • VMOVNTDQ xmm, m128 [AVX]
  • VMOVNTDQ ymm, m256 [AVX]
  • VMOVNTDQ zmm, m512 [AVX512F]
  • VMOVNTDQ xmm, m128 [AVX512F,AVX512VL]
  • VMOVNTDQ ymm, m256 [AVX512F,AVX512VL]

func (*Program) VMOVNTDQA 

func (self *Program) VMOVNTDQA(v0 interface{}, v1 interface{}) *Instruction

VMOVNTDQA performs "Load Double Quadword Non-Temporal Aligned Hint".

Mnemonic : VMOVNTDQA Supported forms : (5 forms)

  • VMOVNTDQA m128, xmm [AVX]
  • VMOVNTDQA m256, ymm [AVX2]
  • VMOVNTDQA m512, zmm [AVX512F]
  • VMOVNTDQA m128, xmm [AVX512F,AVX512VL]
  • VMOVNTDQA m256, ymm [AVX512F,AVX512VL]

func (*Program) VMOVNTPD 

func (self *Program) VMOVNTPD(v0 interface{}, v1 interface{}) *Instruction

VMOVNTPD performs "Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : VMOVNTPD Supported forms : (5 forms)

  • VMOVNTPD xmm, m128 [AVX]
  • VMOVNTPD ymm, m256 [AVX]
  • VMOVNTPD zmm, m512 [AVX512F]
  • VMOVNTPD xmm, m128 [AVX512F,AVX512VL]
  • VMOVNTPD ymm, m256 [AVX512F,AVX512VL]

func (*Program) VMOVNTPS 

func (self *Program) VMOVNTPS(v0 interface{}, v1 interface{}) *Instruction

VMOVNTPS performs "Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint".

Mnemonic : VMOVNTPS Supported forms : (5 forms)

  • VMOVNTPS xmm, m128 [AVX]
  • VMOVNTPS ymm, m256 [AVX]
  • VMOVNTPS zmm, m512 [AVX512F]
  • VMOVNTPS xmm, m128 [AVX512F,AVX512VL]
  • VMOVNTPS ymm, m256 [AVX512F,AVX512VL]

func (*Program) VMOVQ 

func (self *Program) VMOVQ(v0 interface{}, v1 interface{}) *Instruction

VMOVQ performs "Move Quadword".

Mnemonic : VMOVQ Supported forms : (10 forms)

  • VMOVQ xmm, r64 [AVX]
  • VMOVQ r64, xmm [AVX]
  • VMOVQ xmm, xmm [AVX]
  • VMOVQ m64, xmm [AVX]
  • VMOVQ xmm, m64 [AVX]
  • VMOVQ xmm, r64 [AVX512F]
  • VMOVQ r64, xmm [AVX512F]
  • VMOVQ xmm, xmm [AVX512F]
  • VMOVQ m64, xmm [AVX512F]
  • VMOVQ xmm, m64 [AVX512F]

func (*Program) VMOVSD 

func (self *Program) VMOVSD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVSD performs "Move Scalar Double-Precision Floating-Point Value".

Mnemonic : VMOVSD Supported forms : (6 forms)

  • VMOVSD m64, xmm [AVX]
  • VMOVSD xmm, m64 [AVX]
  • VMOVSD xmm, xmm, xmm [AVX]
  • VMOVSD xmm, m64{k} [AVX512F]
  • VMOVSD m64, xmm{k}{z} [AVX512F]
  • VMOVSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMOVSHDUP 

func (self *Program) VMOVSHDUP(v0 interface{}, v1 interface{}) *Instruction

VMOVSHDUP performs "Move Packed Single-FP High and Duplicate".

Mnemonic : VMOVSHDUP Supported forms : (10 forms)

  • VMOVSHDUP xmm, xmm [AVX]
  • VMOVSHDUP m128, xmm [AVX]
  • VMOVSHDUP ymm, ymm [AVX]
  • VMOVSHDUP m256, ymm [AVX]
  • VMOVSHDUP zmm, zmm{k}{z} [AVX512F]
  • VMOVSHDUP m512, zmm{k}{z} [AVX512F]
  • VMOVSHDUP xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVSHDUP ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVSHDUP m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVSHDUP m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVSLDUP 

func (self *Program) VMOVSLDUP(v0 interface{}, v1 interface{}) *Instruction

VMOVSLDUP performs "Move Packed Single-FP Low and Duplicate".

Mnemonic : VMOVSLDUP Supported forms : (10 forms)

  • VMOVSLDUP xmm, xmm [AVX]
  • VMOVSLDUP m128, xmm [AVX]
  • VMOVSLDUP ymm, ymm [AVX]
  • VMOVSLDUP m256, ymm [AVX]
  • VMOVSLDUP zmm, zmm{k}{z} [AVX512F]
  • VMOVSLDUP m512, zmm{k}{z} [AVX512F]
  • VMOVSLDUP xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVSLDUP ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVSLDUP m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVSLDUP m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVSS 

func (self *Program) VMOVSS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VMOVSS performs "Move Scalar Single-Precision Floating-Point Values".

Mnemonic : VMOVSS Supported forms : (6 forms)

  • VMOVSS m32, xmm [AVX]
  • VMOVSS xmm, m32 [AVX]
  • VMOVSS xmm, xmm, xmm [AVX]
  • VMOVSS xmm, m32{k} [AVX512F]
  • VMOVSS m32, xmm{k}{z} [AVX512F]
  • VMOVSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMOVUPD 

func (self *Program) VMOVUPD(v0 interface{}, v1 interface{}) *Instruction

VMOVUPD performs "Move Unaligned Packed Double-Precision Floating-Point Values".

Mnemonic : VMOVUPD Supported forms : (15 forms)

  • VMOVUPD xmm, xmm [AVX]
  • VMOVUPD m128, xmm [AVX]
  • VMOVUPD ymm, ymm [AVX]
  • VMOVUPD m256, ymm [AVX]
  • VMOVUPD xmm, m128 [AVX]
  • VMOVUPD ymm, m256 [AVX]
  • VMOVUPD zmm, m512{k}{z} [AVX512F]
  • VMOVUPD zmm, zmm{k}{z} [AVX512F]
  • VMOVUPD m512, zmm{k}{z} [AVX512F]
  • VMOVUPD xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVUPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVUPD ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVUPD ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVUPD m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVUPD m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMOVUPS 

func (self *Program) VMOVUPS(v0 interface{}, v1 interface{}) *Instruction

VMOVUPS performs "Move Unaligned Packed Single-Precision Floating-Point Values".

Mnemonic : VMOVUPS Supported forms : (15 forms)

  • VMOVUPS xmm, xmm [AVX]
  • VMOVUPS m128, xmm [AVX]
  • VMOVUPS ymm, ymm [AVX]
  • VMOVUPS m256, ymm [AVX]
  • VMOVUPS xmm, m128 [AVX]
  • VMOVUPS ymm, m256 [AVX]
  • VMOVUPS zmm, m512{k}{z} [AVX512F]
  • VMOVUPS zmm, zmm{k}{z} [AVX512F]
  • VMOVUPS m512, zmm{k}{z} [AVX512F]
  • VMOVUPS xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VMOVUPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVUPS ymm, m256{k}{z} [AVX512F,AVX512VL]
  • VMOVUPS ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMOVUPS m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VMOVUPS m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMPSADBW 

func (self *Program) VMPSADBW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VMPSADBW performs "Compute Multiple Packed Sums of Absolute Difference".

Mnemonic : VMPSADBW Supported forms : (4 forms)

  • VMPSADBW imm8, xmm, xmm, xmm [AVX]
  • VMPSADBW imm8, m128, xmm, xmm [AVX]
  • VMPSADBW imm8, ymm, ymm, ymm [AVX2]
  • VMPSADBW imm8, m256, ymm, ymm [AVX2]

func (*Program) VMULPD 

func (self *Program) VMULPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULPD performs "Multiply Packed Double-Precision Floating-Point Values".

Mnemonic : VMULPD Supported forms : (11 forms)

  • VMULPD xmm, xmm, xmm [AVX]
  • VMULPD m128, xmm, xmm [AVX]
  • VMULPD ymm, ymm, ymm [AVX]
  • VMULPD m256, ymm, ymm [AVX]
  • VMULPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VMULPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VMULPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VMULPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMULPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMULPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMULPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMULPS 

func (self *Program) VMULPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULPS performs "Multiply Packed Single-Precision Floating-Point Values".

Mnemonic : VMULPS Supported forms : (11 forms)

  • VMULPS xmm, xmm, xmm [AVX]
  • VMULPS m128, xmm, xmm [AVX]
  • VMULPS ymm, ymm, ymm [AVX]
  • VMULPS m256, ymm, ymm [AVX]
  • VMULPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VMULPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VMULPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VMULPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMULPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VMULPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VMULPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VMULSD 

func (self *Program) VMULSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULSD performs "Multiply Scalar Double-Precision Floating-Point Values".

Mnemonic : VMULSD Supported forms : (5 forms)

  • VMULSD xmm, xmm, xmm [AVX]
  • VMULSD m64, xmm, xmm [AVX]
  • VMULSD m64, xmm, xmm{k}{z} [AVX512F]
  • VMULSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VMULSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VMULSS 

func (self *Program) VMULSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VMULSS performs "Multiply Scalar Single-Precision Floating-Point Values".

Mnemonic : VMULSS Supported forms : (5 forms)

  • VMULSS xmm, xmm, xmm [AVX]
  • VMULSS m32, xmm, xmm [AVX]
  • VMULSS m32, xmm, xmm{k}{z} [AVX512F]
  • VMULSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VMULSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VORPD 

func (self *Program) VORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VORPD performs "Bitwise Logical OR of Double-Precision Floating-Point Values".

Mnemonic : VORPD Supported forms : (10 forms)

  • VORPD xmm, xmm, xmm [AVX]
  • VORPD m128, xmm, xmm [AVX]
  • VORPD ymm, ymm, ymm [AVX]
  • VORPD m256, ymm, ymm [AVX]
  • VORPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VORPD zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VORPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VORPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VORPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VORPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VORPS 

func (self *Program) VORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VORPS performs "Bitwise Logical OR of Single-Precision Floating-Point Values".

Mnemonic : VORPS Supported forms : (10 forms)

  • VORPS xmm, xmm, xmm [AVX]
  • VORPS m128, xmm, xmm [AVX]
  • VORPS ymm, ymm, ymm [AVX]
  • VORPS m256, ymm, ymm [AVX]
  • VORPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VORPS zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VORPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VORPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VORPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VORPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VPABSB 

func (self *Program) VPABSB(v0 interface{}, v1 interface{}) *Instruction

VPABSB performs "Packed Absolute Value of Byte Integers".

Mnemonic : VPABSB Supported forms : (10 forms)

  • VPABSB xmm, xmm [AVX]
  • VPABSB m128, xmm [AVX]
  • VPABSB ymm, ymm [AVX2]
  • VPABSB m256, ymm [AVX2]
  • VPABSB zmm, zmm{k}{z} [AVX512BW]
  • VPABSB m512, zmm{k}{z} [AVX512BW]
  • VPABSB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPABSB ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPABSB m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPABSB m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPABSD 

func (self *Program) VPABSD(v0 interface{}, v1 interface{}) *Instruction

VPABSD performs "Packed Absolute Value of Doubleword Integers".

Mnemonic : VPABSD Supported forms : (10 forms)

  • VPABSD xmm, xmm [AVX]
  • VPABSD m128, xmm [AVX]
  • VPABSD ymm, ymm [AVX2]
  • VPABSD m256, ymm [AVX2]
  • VPABSD m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPABSD zmm, zmm{k}{z} [AVX512F]
  • VPABSD m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPABSD m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPABSD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPABSD ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPABSQ 

func (self *Program) VPABSQ(v0 interface{}, v1 interface{}) *Instruction

VPABSQ performs "Packed Absolute Value of Quadword Integers".

Mnemonic : VPABSQ Supported forms : (6 forms)

  • VPABSQ m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPABSQ zmm, zmm{k}{z} [AVX512F]
  • VPABSQ m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPABSQ m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPABSQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPABSQ ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPABSW 

func (self *Program) VPABSW(v0 interface{}, v1 interface{}) *Instruction

VPABSW performs "Packed Absolute Value of Word Integers".

Mnemonic : VPABSW Supported forms : (10 forms)

  • VPABSW xmm, xmm [AVX]
  • VPABSW m128, xmm [AVX]
  • VPABSW ymm, ymm [AVX2]
  • VPABSW m256, ymm [AVX2]
  • VPABSW zmm, zmm{k}{z} [AVX512BW]
  • VPABSW m512, zmm{k}{z} [AVX512BW]
  • VPABSW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPABSW ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPABSW m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPABSW m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPACKSSDW 

func (self *Program) VPACKSSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKSSDW performs "Pack Doublewords into Words with Signed Saturation".

Mnemonic : VPACKSSDW Supported forms : (10 forms)

  • VPACKSSDW xmm, xmm, xmm [AVX]
  • VPACKSSDW m128, xmm, xmm [AVX]
  • VPACKSSDW ymm, ymm, ymm [AVX2]
  • VPACKSSDW m256, ymm, ymm [AVX2]
  • VPACKSSDW m512/m32bcst, zmm, zmm{k}{z} [AVX512BW]
  • VPACKSSDW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPACKSSDW m128/m32bcst, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKSSDW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKSSDW m256/m32bcst, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPACKSSDW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPACKSSWB 

func (self *Program) VPACKSSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKSSWB performs "Pack Words into Bytes with Signed Saturation".

Mnemonic : VPACKSSWB Supported forms : (10 forms)

  • VPACKSSWB xmm, xmm, xmm [AVX]
  • VPACKSSWB m128, xmm, xmm [AVX]
  • VPACKSSWB ymm, ymm, ymm [AVX2]
  • VPACKSSWB m256, ymm, ymm [AVX2]
  • VPACKSSWB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPACKSSWB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPACKSSWB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKSSWB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKSSWB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPACKSSWB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPACKUSDW 

func (self *Program) VPACKUSDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKUSDW performs "Pack Doublewords into Words with Unsigned Saturation".

Mnemonic : VPACKUSDW Supported forms : (10 forms)

  • VPACKUSDW xmm, xmm, xmm [AVX]
  • VPACKUSDW m128, xmm, xmm [AVX]
  • VPACKUSDW ymm, ymm, ymm [AVX2]
  • VPACKUSDW m256, ymm, ymm [AVX2]
  • VPACKUSDW m512/m32bcst, zmm, zmm{k}{z} [AVX512BW]
  • VPACKUSDW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPACKUSDW m128/m32bcst, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKUSDW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKUSDW m256/m32bcst, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPACKUSDW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPACKUSWB 

func (self *Program) VPACKUSWB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPACKUSWB performs "Pack Words into Bytes with Unsigned Saturation".

Mnemonic : VPACKUSWB Supported forms : (10 forms)

  • VPACKUSWB xmm, xmm, xmm [AVX]
  • VPACKUSWB m128, xmm, xmm [AVX]
  • VPACKUSWB ymm, ymm, ymm [AVX2]
  • VPACKUSWB m256, ymm, ymm [AVX2]
  • VPACKUSWB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPACKUSWB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPACKUSWB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKUSWB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPACKUSWB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPACKUSWB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPADDB 

func (self *Program) VPADDB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDB performs "Add Packed Byte Integers".

Mnemonic : VPADDB Supported forms : (10 forms)

  • VPADDB xmm, xmm, xmm [AVX]
  • VPADDB m128, xmm, xmm [AVX]
  • VPADDB ymm, ymm, ymm [AVX2]
  • VPADDB m256, ymm, ymm [AVX2]
  • VPADDB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPADDB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPADDB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPADDB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPADDD 

func (self *Program) VPADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDD performs "Add Packed Doubleword Integers".

Mnemonic : VPADDD Supported forms : (10 forms)

  • VPADDD xmm, xmm, xmm [AVX]
  • VPADDD m128, xmm, xmm [AVX]
  • VPADDD ymm, ymm, ymm [AVX2]
  • VPADDD m256, ymm, ymm [AVX2]
  • VPADDD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPADDD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPADDD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPADDD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPADDD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPADDD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPADDQ 

func (self *Program) VPADDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDQ performs "Add Packed Quadword Integers".

Mnemonic : VPADDQ Supported forms : (10 forms)

  • VPADDQ xmm, xmm, xmm [AVX]
  • VPADDQ m128, xmm, xmm [AVX]
  • VPADDQ ymm, ymm, ymm [AVX2]
  • VPADDQ m256, ymm, ymm [AVX2]
  • VPADDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPADDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPADDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPADDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPADDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPADDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPADDSB 

func (self *Program) VPADDSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDSB performs "Add Packed Signed Byte Integers with Signed Saturation".

Mnemonic : VPADDSB Supported forms : (10 forms)

  • VPADDSB xmm, xmm, xmm [AVX]
  • VPADDSB m128, xmm, xmm [AVX]
  • VPADDSB ymm, ymm, ymm [AVX2]
  • VPADDSB m256, ymm, ymm [AVX2]
  • VPADDSB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPADDSB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPADDSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPADDSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPADDSW 

func (self *Program) VPADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDSW performs "Add Packed Signed Word Integers with Signed Saturation".

Mnemonic : VPADDSW Supported forms : (10 forms)

  • VPADDSW xmm, xmm, xmm [AVX]
  • VPADDSW m128, xmm, xmm [AVX]
  • VPADDSW ymm, ymm, ymm [AVX2]
  • VPADDSW m256, ymm, ymm [AVX2]
  • VPADDSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPADDSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPADDSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPADDSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPADDUSB 

func (self *Program) VPADDUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDUSB performs "Add Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : VPADDUSB Supported forms : (10 forms)

  • VPADDUSB xmm, xmm, xmm [AVX]
  • VPADDUSB m128, xmm, xmm [AVX]
  • VPADDUSB ymm, ymm, ymm [AVX2]
  • VPADDUSB m256, ymm, ymm [AVX2]
  • VPADDUSB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPADDUSB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPADDUSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDUSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDUSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPADDUSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPADDUSW 

func (self *Program) VPADDUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDUSW performs "Add Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : VPADDUSW Supported forms : (10 forms)

  • VPADDUSW xmm, xmm, xmm [AVX]
  • VPADDUSW m128, xmm, xmm [AVX]
  • VPADDUSW ymm, ymm, ymm [AVX2]
  • VPADDUSW m256, ymm, ymm [AVX2]
  • VPADDUSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPADDUSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPADDUSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDUSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDUSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPADDUSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPADDW 

func (self *Program) VPADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPADDW performs "Add Packed Word Integers".

Mnemonic : VPADDW Supported forms : (10 forms)

  • VPADDW xmm, xmm, xmm [AVX]
  • VPADDW m128, xmm, xmm [AVX]
  • VPADDW ymm, ymm, ymm [AVX2]
  • VPADDW m256, ymm, ymm [AVX2]
  • VPADDW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPADDW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPADDW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPADDW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPADDW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPALIGNR 

func (self *Program) VPALIGNR(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPALIGNR performs "Packed Align Right".

Mnemonic : VPALIGNR Supported forms : (10 forms)

  • VPALIGNR imm8, xmm, xmm, xmm [AVX]
  • VPALIGNR imm8, m128, xmm, xmm [AVX]
  • VPALIGNR imm8, ymm, ymm, ymm [AVX2]
  • VPALIGNR imm8, m256, ymm, ymm [AVX2]
  • VPALIGNR imm8, zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPALIGNR imm8, m512, zmm, zmm{k}{z} [AVX512BW]
  • VPALIGNR imm8, xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPALIGNR imm8, m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPALIGNR imm8, ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPALIGNR imm8, m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPAND 

func (self *Program) VPAND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPAND performs "Packed Bitwise Logical AND".

Mnemonic : VPAND Supported forms : (4 forms)

  • VPAND xmm, xmm, xmm [AVX]
  • VPAND m128, xmm, xmm [AVX]
  • VPAND ymm, ymm, ymm [AVX2]
  • VPAND m256, ymm, ymm [AVX2]

func (*Program) VPANDD 

func (self *Program) VPANDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDD performs "Bitwise Logical AND of Packed Doubleword Integers".

Mnemonic : VPANDD Supported forms : (6 forms)

  • VPANDD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPANDD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPANDD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPANDD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPANDN 

func (self *Program) VPANDN(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDN performs "Packed Bitwise Logical AND NOT".

Mnemonic : VPANDN Supported forms : (4 forms)

  • VPANDN xmm, xmm, xmm [AVX]
  • VPANDN m128, xmm, xmm [AVX]
  • VPANDN ymm, ymm, ymm [AVX2]
  • VPANDN m256, ymm, ymm [AVX2]

func (*Program) VPANDND 

func (self *Program) VPANDND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDND performs "Bitwise Logical AND NOT of Packed Doubleword Integers".

Mnemonic : VPANDND Supported forms : (6 forms)

  • VPANDND m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPANDND zmm, zmm, zmm{k}{z} [AVX512F]
  • VPANDND m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDND xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDND m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPANDND ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPANDNQ 

func (self *Program) VPANDNQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDNQ performs "Bitwise Logical AND NOT of Packed Quadword Integers".

Mnemonic : VPANDNQ Supported forms : (6 forms)

  • VPANDNQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPANDNQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPANDNQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDNQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDNQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPANDNQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPANDQ 

func (self *Program) VPANDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPANDQ performs "Bitwise Logical AND of Packed Quadword Integers".

Mnemonic : VPANDQ Supported forms : (6 forms)

  • VPANDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPANDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPANDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPANDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPANDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPAVGB 

func (self *Program) VPAVGB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPAVGB performs "Average Packed Byte Integers".

Mnemonic : VPAVGB Supported forms : (10 forms)

  • VPAVGB xmm, xmm, xmm [AVX]
  • VPAVGB m128, xmm, xmm [AVX]
  • VPAVGB ymm, ymm, ymm [AVX2]
  • VPAVGB m256, ymm, ymm [AVX2]
  • VPAVGB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPAVGB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPAVGB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPAVGB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPAVGB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPAVGB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPAVGW 

func (self *Program) VPAVGW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPAVGW performs "Average Packed Word Integers".

Mnemonic : VPAVGW Supported forms : (10 forms)

  • VPAVGW xmm, xmm, xmm [AVX]
  • VPAVGW m128, xmm, xmm [AVX]
  • VPAVGW ymm, ymm, ymm [AVX2]
  • VPAVGW m256, ymm, ymm [AVX2]
  • VPAVGW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPAVGW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPAVGW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPAVGW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPAVGW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPAVGW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPBLENDD 

func (self *Program) VPBLENDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPBLENDD performs "Blend Packed Doublewords".

Mnemonic : VPBLENDD Supported forms : (4 forms)

  • VPBLENDD imm8, xmm, xmm, xmm [AVX2]
  • VPBLENDD imm8, m128, xmm, xmm [AVX2]
  • VPBLENDD imm8, ymm, ymm, ymm [AVX2]
  • VPBLENDD imm8, m256, ymm, ymm [AVX2]

func (*Program) VPBLENDMB 

func (self *Program) VPBLENDMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMB performs "Blend Byte Vectors Using an OpMask Control".

Mnemonic : VPBLENDMB Supported forms : (6 forms)

  • VPBLENDMB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPBLENDMB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPBLENDMB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBLENDMB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBLENDMB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPBLENDMB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPBLENDMD 

func (self *Program) VPBLENDMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMD performs "Blend Doubleword Vectors Using an OpMask Control".

Mnemonic : VPBLENDMD Supported forms : (6 forms)

  • VPBLENDMD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPBLENDMD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPBLENDMD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBLENDMD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBLENDMD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPBLENDMD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPBLENDMQ 

func (self *Program) VPBLENDMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMQ performs "Blend Quadword Vectors Using an OpMask Control".

Mnemonic : VPBLENDMQ Supported forms : (6 forms)

  • VPBLENDMQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPBLENDMQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPBLENDMQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBLENDMQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBLENDMQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPBLENDMQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPBLENDMW 

func (self *Program) VPBLENDMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPBLENDMW performs "Blend Word Vectors Using an OpMask Control".

Mnemonic : VPBLENDMW Supported forms : (6 forms)

  • VPBLENDMW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPBLENDMW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPBLENDMW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBLENDMW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBLENDMW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPBLENDMW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPBLENDVB 

func (self *Program) VPBLENDVB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPBLENDVB performs "Variable Blend Packed Bytes".

Mnemonic : VPBLENDVB Supported forms : (4 forms)

  • VPBLENDVB xmm, xmm, xmm, xmm [AVX]
  • VPBLENDVB xmm, m128, xmm, xmm [AVX]
  • VPBLENDVB ymm, ymm, ymm, ymm [AVX2]
  • VPBLENDVB ymm, m256, ymm, ymm [AVX2]

func (*Program) VPBLENDW 

func (self *Program) VPBLENDW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPBLENDW performs "Blend Packed Words".

Mnemonic : VPBLENDW Supported forms : (4 forms)

  • VPBLENDW imm8, xmm, xmm, xmm [AVX]
  • VPBLENDW imm8, m128, xmm, xmm [AVX]
  • VPBLENDW imm8, ymm, ymm, ymm [AVX2]
  • VPBLENDW imm8, m256, ymm, ymm [AVX2]

func (*Program) VPBROADCASTB 

func (self *Program) VPBROADCASTB(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTB performs "Broadcast Byte Integer".

Mnemonic : VPBROADCASTB Supported forms : (13 forms)

  • VPBROADCASTB xmm, xmm [AVX2]
  • VPBROADCASTB m8, xmm [AVX2]
  • VPBROADCASTB xmm, ymm [AVX2]
  • VPBROADCASTB m8, ymm [AVX2]
  • VPBROADCASTB r32, zmm{k}{z} [AVX512BW]
  • VPBROADCASTB xmm, zmm{k}{z} [AVX512BW]
  • VPBROADCASTB m8, zmm{k}{z} [AVX512BW]
  • VPBROADCASTB r32, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTB r32, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTB xmm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTB m8, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTB m8, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPBROADCASTD 

func (self *Program) VPBROADCASTD(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTD performs "Broadcast Doubleword Integer".

Mnemonic : VPBROADCASTD Supported forms : (13 forms)

  • VPBROADCASTD xmm, xmm [AVX2]
  • VPBROADCASTD m32, xmm [AVX2]
  • VPBROADCASTD xmm, ymm [AVX2]
  • VPBROADCASTD m32, ymm [AVX2]
  • VPBROADCASTD r32, zmm{k}{z} [AVX512F]
  • VPBROADCASTD xmm, zmm{k}{z} [AVX512F]
  • VPBROADCASTD m32, zmm{k}{z} [AVX512F]
  • VPBROADCASTD r32, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTD r32, ymm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTD xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTD m32, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTD m32, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPBROADCASTMB2Q 

func (self *Program) VPBROADCASTMB2Q(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTMB2Q performs "Broadcast Low Byte of Mask Register to Packed Quadword Values".

Mnemonic : VPBROADCASTMB2Q Supported forms : (3 forms)

  • VPBROADCASTMB2Q k, xmm [AVX512CD,AVX512VL]
  • VPBROADCASTMB2Q k, ymm [AVX512CD,AVX512VL]
  • VPBROADCASTMB2Q k, zmm [AVX512CD]

func (*Program) VPBROADCASTMW2D 

func (self *Program) VPBROADCASTMW2D(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTMW2D performs "Broadcast Low Word of Mask Register to Packed Doubleword Values".

Mnemonic : VPBROADCASTMW2D Supported forms : (3 forms)

  • VPBROADCASTMW2D k, xmm [AVX512CD,AVX512VL]
  • VPBROADCASTMW2D k, ymm [AVX512CD,AVX512VL]
  • VPBROADCASTMW2D k, zmm [AVX512CD]

func (*Program) VPBROADCASTQ 

func (self *Program) VPBROADCASTQ(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTQ performs "Broadcast Quadword Integer".

Mnemonic : VPBROADCASTQ Supported forms : (13 forms)

  • VPBROADCASTQ xmm, xmm [AVX2]
  • VPBROADCASTQ m64, xmm [AVX2]
  • VPBROADCASTQ xmm, ymm [AVX2]
  • VPBROADCASTQ m64, ymm [AVX2]
  • VPBROADCASTQ r64, zmm{k}{z} [AVX512F]
  • VPBROADCASTQ xmm, zmm{k}{z} [AVX512F]
  • VPBROADCASTQ m64, zmm{k}{z} [AVX512F]
  • VPBROADCASTQ r64, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTQ r64, ymm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTQ m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VPBROADCASTQ m64, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPBROADCASTW 

func (self *Program) VPBROADCASTW(v0 interface{}, v1 interface{}) *Instruction

VPBROADCASTW performs "Broadcast Word Integer".

Mnemonic : VPBROADCASTW Supported forms : (13 forms)

  • VPBROADCASTW xmm, xmm [AVX2]
  • VPBROADCASTW m16, xmm [AVX2]
  • VPBROADCASTW xmm, ymm [AVX2]
  • VPBROADCASTW m16, ymm [AVX2]
  • VPBROADCASTW r32, zmm{k}{z} [AVX512BW]
  • VPBROADCASTW xmm, zmm{k}{z} [AVX512BW]
  • VPBROADCASTW m16, zmm{k}{z} [AVX512BW]
  • VPBROADCASTW r32, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTW r32, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTW xmm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTW m16, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPBROADCASTW m16, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPCLMULQDQ 

func (self *Program) VPCLMULQDQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCLMULQDQ performs "Carry-Less Quadword Multiplication".

Mnemonic : VPCLMULQDQ Supported forms : (2 forms)

  • VPCLMULQDQ imm8, xmm, xmm, xmm [AVX,PCLMULQDQ]
  • VPCLMULQDQ imm8, m128, xmm, xmm [AVX,PCLMULQDQ]

func (*Program) VPCMOV 

func (self *Program) VPCMOV(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMOV performs "Packed Conditional Move".

Mnemonic : VPCMOV Supported forms : (6 forms)

  • VPCMOV xmm, xmm, xmm, xmm [XOP]
  • VPCMOV m128, xmm, xmm, xmm [XOP]
  • VPCMOV xmm, m128, xmm, xmm [XOP]
  • VPCMOV ymm, ymm, ymm, ymm [XOP]
  • VPCMOV m256, ymm, ymm, ymm [XOP]
  • VPCMOV ymm, m256, ymm, ymm [XOP]

func (*Program) VPCMPB 

func (self *Program) VPCMPB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPB performs "Compare Packed Signed Byte Values".

Mnemonic : VPCMPB Supported forms : (6 forms)

  • VPCMPB imm8, zmm, zmm, k{k} [AVX512BW]
  • VPCMPB imm8, m512, zmm, k{k} [AVX512BW]
  • VPCMPB imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPB imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPB imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPB imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPD 

func (self *Program) VPCMPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPD performs "Compare Packed Signed Doubleword Values".

Mnemonic : VPCMPD Supported forms : (6 forms)

  • VPCMPD imm8, m512/m32bcst, zmm, k{k} [AVX512F]
  • VPCMPD imm8, zmm, zmm, k{k} [AVX512F]
  • VPCMPD imm8, m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPD imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPD imm8, m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPD imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPEQB 

func (self *Program) VPCMPEQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQB performs "Compare Packed Byte Data for Equality".

Mnemonic : VPCMPEQB Supported forms : (10 forms)

  • VPCMPEQB xmm, xmm, xmm [AVX]
  • VPCMPEQB m128, xmm, xmm [AVX]
  • VPCMPEQB ymm, ymm, ymm [AVX2]
  • VPCMPEQB m256, ymm, ymm [AVX2]
  • VPCMPEQB zmm, zmm, k{k} [AVX512BW]
  • VPCMPEQB m512, zmm, k{k} [AVX512BW]
  • VPCMPEQB xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPEQB m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPEQB ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPEQB m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPEQD 

func (self *Program) VPCMPEQD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQD performs "Compare Packed Doubleword Data for Equality".

Mnemonic : VPCMPEQD Supported forms : (10 forms)

  • VPCMPEQD xmm, xmm, xmm [AVX]
  • VPCMPEQD m128, xmm, xmm [AVX]
  • VPCMPEQD ymm, ymm, ymm [AVX2]
  • VPCMPEQD m256, ymm, ymm [AVX2]
  • VPCMPEQD m512/m32bcst, zmm, k{k} [AVX512F]
  • VPCMPEQD zmm, zmm, k{k} [AVX512F]
  • VPCMPEQD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPEQD xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPEQD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPEQD ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPEQQ 

func (self *Program) VPCMPEQQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQQ performs "Compare Packed Quadword Data for Equality".

Mnemonic : VPCMPEQQ Supported forms : (10 forms)

  • VPCMPEQQ xmm, xmm, xmm [AVX]
  • VPCMPEQQ m128, xmm, xmm [AVX]
  • VPCMPEQQ ymm, ymm, ymm [AVX2]
  • VPCMPEQQ m256, ymm, ymm [AVX2]
  • VPCMPEQQ m512/m64bcst, zmm, k{k} [AVX512F]
  • VPCMPEQQ zmm, zmm, k{k} [AVX512F]
  • VPCMPEQQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPEQQ xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPEQQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPEQQ ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPEQW 

func (self *Program) VPCMPEQW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPEQW performs "Compare Packed Word Data for Equality".

Mnemonic : VPCMPEQW Supported forms : (10 forms)

  • VPCMPEQW xmm, xmm, xmm [AVX]
  • VPCMPEQW m128, xmm, xmm [AVX]
  • VPCMPEQW ymm, ymm, ymm [AVX2]
  • VPCMPEQW m256, ymm, ymm [AVX2]
  • VPCMPEQW zmm, zmm, k{k} [AVX512BW]
  • VPCMPEQW m512, zmm, k{k} [AVX512BW]
  • VPCMPEQW xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPEQW m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPEQW ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPEQW m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPESTRI 

func (self *Program) VPCMPESTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPESTRI performs "Packed Compare Explicit Length Strings, Return Index".

Mnemonic : VPCMPESTRI Supported forms : (2 forms)

  • VPCMPESTRI imm8, xmm, xmm [AVX]
  • VPCMPESTRI imm8, m128, xmm [AVX]

func (*Program) VPCMPESTRM 

func (self *Program) VPCMPESTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPESTRM performs "Packed Compare Explicit Length Strings, Return Mask".

Mnemonic : VPCMPESTRM Supported forms : (2 forms)

  • VPCMPESTRM imm8, xmm, xmm [AVX]
  • VPCMPESTRM imm8, m128, xmm [AVX]

func (*Program) VPCMPGTB 

func (self *Program) VPCMPGTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTB performs "Compare Packed Signed Byte Integers for Greater Than".

Mnemonic : VPCMPGTB Supported forms : (10 forms)

  • VPCMPGTB xmm, xmm, xmm [AVX]
  • VPCMPGTB m128, xmm, xmm [AVX]
  • VPCMPGTB ymm, ymm, ymm [AVX2]
  • VPCMPGTB m256, ymm, ymm [AVX2]
  • VPCMPGTB zmm, zmm, k{k} [AVX512BW]
  • VPCMPGTB m512, zmm, k{k} [AVX512BW]
  • VPCMPGTB xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPGTB m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPGTB ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPGTB m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPGTD 

func (self *Program) VPCMPGTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTD performs "Compare Packed Signed Doubleword Integers for Greater Than".

Mnemonic : VPCMPGTD Supported forms : (10 forms)

  • VPCMPGTD xmm, xmm, xmm [AVX]
  • VPCMPGTD m128, xmm, xmm [AVX]
  • VPCMPGTD ymm, ymm, ymm [AVX2]
  • VPCMPGTD m256, ymm, ymm [AVX2]
  • VPCMPGTD m512/m32bcst, zmm, k{k} [AVX512F]
  • VPCMPGTD zmm, zmm, k{k} [AVX512F]
  • VPCMPGTD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPGTD xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPGTD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPGTD ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPGTQ 

func (self *Program) VPCMPGTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTQ performs "Compare Packed Data for Greater Than".

Mnemonic : VPCMPGTQ Supported forms : (10 forms)

  • VPCMPGTQ xmm, xmm, xmm [AVX]
  • VPCMPGTQ m128, xmm, xmm [AVX]
  • VPCMPGTQ ymm, ymm, ymm [AVX2]
  • VPCMPGTQ m256, ymm, ymm [AVX2]
  • VPCMPGTQ m512/m64bcst, zmm, k{k} [AVX512F]
  • VPCMPGTQ zmm, zmm, k{k} [AVX512F]
  • VPCMPGTQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPGTQ xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPGTQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPGTQ ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPGTW 

func (self *Program) VPCMPGTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPGTW performs "Compare Packed Signed Word Integers for Greater Than".

Mnemonic : VPCMPGTW Supported forms : (10 forms)

  • VPCMPGTW xmm, xmm, xmm [AVX]
  • VPCMPGTW m128, xmm, xmm [AVX]
  • VPCMPGTW ymm, ymm, ymm [AVX2]
  • VPCMPGTW m256, ymm, ymm [AVX2]
  • VPCMPGTW zmm, zmm, k{k} [AVX512BW]
  • VPCMPGTW m512, zmm, k{k} [AVX512BW]
  • VPCMPGTW xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPGTW m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPGTW ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPGTW m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPISTRI 

func (self *Program) VPCMPISTRI(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPISTRI performs "Packed Compare Implicit Length Strings, Return Index".

Mnemonic : VPCMPISTRI Supported forms : (2 forms)

  • VPCMPISTRI imm8, xmm, xmm [AVX]
  • VPCMPISTRI imm8, m128, xmm [AVX]

func (*Program) VPCMPISTRM 

func (self *Program) VPCMPISTRM(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPCMPISTRM performs "Packed Compare Implicit Length Strings, Return Mask".

Mnemonic : VPCMPISTRM Supported forms : (2 forms)

  • VPCMPISTRM imm8, xmm, xmm [AVX]
  • VPCMPISTRM imm8, m128, xmm [AVX]

func (*Program) VPCMPQ 

func (self *Program) VPCMPQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPQ performs "Compare Packed Signed Quadword Values".

Mnemonic : VPCMPQ Supported forms : (6 forms)

  • VPCMPQ imm8, m512/m64bcst, zmm, k{k} [AVX512F]
  • VPCMPQ imm8, zmm, zmm, k{k} [AVX512F]
  • VPCMPQ imm8, m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPQ imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPQ imm8, m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPQ imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPUB 

func (self *Program) VPCMPUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUB performs "Compare Packed Unsigned Byte Values".

Mnemonic : VPCMPUB Supported forms : (6 forms)

  • VPCMPUB imm8, zmm, zmm, k{k} [AVX512BW]
  • VPCMPUB imm8, m512, zmm, k{k} [AVX512BW]
  • VPCMPUB imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPUB imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPUB imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPUB imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPUD 

func (self *Program) VPCMPUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUD performs "Compare Packed Unsigned Doubleword Values".

Mnemonic : VPCMPUD Supported forms : (6 forms)

  • VPCMPUD imm8, m512/m32bcst, zmm, k{k} [AVX512F]
  • VPCMPUD imm8, zmm, zmm, k{k} [AVX512F]
  • VPCMPUD imm8, m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPUD imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPUD imm8, m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPUD imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPUQ 

func (self *Program) VPCMPUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUQ performs "Compare Packed Unsigned Quadword Values".

Mnemonic : VPCMPUQ Supported forms : (6 forms)

  • VPCMPUQ imm8, m512/m64bcst, zmm, k{k} [AVX512F]
  • VPCMPUQ imm8, zmm, zmm, k{k} [AVX512F]
  • VPCMPUQ imm8, m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPUQ imm8, xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPCMPUQ imm8, m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPCMPUQ imm8, ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPCMPUW 

func (self *Program) VPCMPUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPUW performs "Compare Packed Unsigned Word Values".

Mnemonic : VPCMPUW Supported forms : (6 forms)

  • VPCMPUW imm8, zmm, zmm, k{k} [AVX512BW]
  • VPCMPUW imm8, m512, zmm, k{k} [AVX512BW]
  • VPCMPUW imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPUW imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPUW imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPUW imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCMPW 

func (self *Program) VPCMPW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCMPW performs "Compare Packed Signed Word Values".

Mnemonic : VPCMPW Supported forms : (6 forms)

  • VPCMPW imm8, zmm, zmm, k{k} [AVX512BW]
  • VPCMPW imm8, m512, zmm, k{k} [AVX512BW]
  • VPCMPW imm8, xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPW imm8, m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPCMPW imm8, ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPCMPW imm8, m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPCOMB 

func (self *Program) VPCOMB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMB performs "Compare Packed Signed Byte Integers".

Mnemonic : VPCOMB Supported forms : (2 forms)

  • VPCOMB imm8, xmm, xmm, xmm [XOP]
  • VPCOMB imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMD 

func (self *Program) VPCOMD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMD performs "Compare Packed Signed Doubleword Integers".

Mnemonic : VPCOMD Supported forms : (2 forms)

  • VPCOMD imm8, xmm, xmm, xmm [XOP]
  • VPCOMD imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMPRESSD 

func (self *Program) VPCOMPRESSD(v0 interface{}, v1 interface{}) *Instruction

VPCOMPRESSD performs "Store Sparse Packed Doubleword Integer Values into Dense Memory/Register".

Mnemonic : VPCOMPRESSD Supported forms : (6 forms)

  • VPCOMPRESSD zmm, zmm{k}{z} [AVX512F]
  • VPCOMPRESSD zmm, m512{k}{z} [AVX512F]
  • VPCOMPRESSD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPCOMPRESSD xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VPCOMPRESSD ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPCOMPRESSD ymm, m256{k}{z} [AVX512F,AVX512VL]

func (*Program) VPCOMPRESSQ 

func (self *Program) VPCOMPRESSQ(v0 interface{}, v1 interface{}) *Instruction

VPCOMPRESSQ performs "Store Sparse Packed Quadword Integer Values into Dense Memory/Register".

Mnemonic : VPCOMPRESSQ Supported forms : (6 forms)

  • VPCOMPRESSQ zmm, zmm{k}{z} [AVX512F]
  • VPCOMPRESSQ zmm, m512{k}{z} [AVX512F]
  • VPCOMPRESSQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPCOMPRESSQ xmm, m128{k}{z} [AVX512F,AVX512VL]
  • VPCOMPRESSQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPCOMPRESSQ ymm, m256{k}{z} [AVX512F,AVX512VL]

func (*Program) VPCOMQ 

func (self *Program) VPCOMQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMQ performs "Compare Packed Signed Quadword Integers".

Mnemonic : VPCOMQ Supported forms : (2 forms)

  • VPCOMQ imm8, xmm, xmm, xmm [XOP]
  • VPCOMQ imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMUB 

func (self *Program) VPCOMUB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUB performs "Compare Packed Unsigned Byte Integers".

Mnemonic : VPCOMUB Supported forms : (2 forms)

  • VPCOMUB imm8, xmm, xmm, xmm [XOP]
  • VPCOMUB imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMUD 

func (self *Program) VPCOMUD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUD performs "Compare Packed Unsigned Doubleword Integers".

Mnemonic : VPCOMUD Supported forms : (2 forms)

  • VPCOMUD imm8, xmm, xmm, xmm [XOP]
  • VPCOMUD imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMUQ 

func (self *Program) VPCOMUQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUQ performs "Compare Packed Unsigned Quadword Integers".

Mnemonic : VPCOMUQ Supported forms : (2 forms)

  • VPCOMUQ imm8, xmm, xmm, xmm [XOP]
  • VPCOMUQ imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMUW 

func (self *Program) VPCOMUW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMUW performs "Compare Packed Unsigned Word Integers".

Mnemonic : VPCOMUW Supported forms : (2 forms)

  • VPCOMUW imm8, xmm, xmm, xmm [XOP]
  • VPCOMUW imm8, m128, xmm, xmm [XOP]

func (*Program) VPCOMW 

func (self *Program) VPCOMW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPCOMW performs "Compare Packed Signed Word Integers".

Mnemonic : VPCOMW Supported forms : (2 forms)

  • VPCOMW imm8, xmm, xmm, xmm [XOP]
  • VPCOMW imm8, m128, xmm, xmm [XOP]

func (*Program) VPCONFLICTD 

func (self *Program) VPCONFLICTD(v0 interface{}, v1 interface{}) *Instruction

VPCONFLICTD performs "Detect Conflicts Within a Vector of Packed Doubleword Values into Dense Memory/Register".

Mnemonic : VPCONFLICTD Supported forms : (6 forms)

  • VPCONFLICTD m128/m32bcst, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTD m256/m32bcst, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTD m512/m32bcst, zmm{k}{z} [AVX512CD]
  • VPCONFLICTD xmm, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTD ymm, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTD zmm, zmm{k}{z} [AVX512CD]

func (*Program) VPCONFLICTQ 

func (self *Program) VPCONFLICTQ(v0 interface{}, v1 interface{}) *Instruction

VPCONFLICTQ performs "Detect Conflicts Within a Vector of Packed Quadword Values into Dense Memory/Register".

Mnemonic : VPCONFLICTQ Supported forms : (6 forms)

  • VPCONFLICTQ m128/m64bcst, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTQ m256/m64bcst, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTQ m512/m64bcst, zmm{k}{z} [AVX512CD]
  • VPCONFLICTQ xmm, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTQ ymm, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPCONFLICTQ zmm, zmm{k}{z} [AVX512CD]

func (*Program) VPERM2F128 

func (self *Program) VPERM2F128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPERM2F128 performs "Permute Floating-Point Values".

Mnemonic : VPERM2F128 Supported forms : (2 forms)

  • VPERM2F128 imm8, ymm, ymm, ymm [AVX]
  • VPERM2F128 imm8, m256, ymm, ymm [AVX]

func (*Program) VPERM2I128 

func (self *Program) VPERM2I128(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPERM2I128 performs "Permute 128-Bit Integer Values".

Mnemonic : VPERM2I128 Supported forms : (2 forms)

  • VPERM2I128 imm8, ymm, ymm, ymm [AVX2]
  • VPERM2I128 imm8, m256, ymm, ymm [AVX2]

func (*Program) VPERMB 

func (self *Program) VPERMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMB performs "Permute Byte Integers".

Mnemonic : VPERMB Supported forms : (6 forms)

  • VPERMB xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMB m128, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMB ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMB m256, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMB zmm, zmm, zmm{k}{z} [AVX512VBMI]
  • VPERMB m512, zmm, zmm{k}{z} [AVX512VBMI]

func (*Program) VPERMD 

func (self *Program) VPERMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMD performs "Permute Doubleword Integers".

Mnemonic : VPERMD Supported forms : (6 forms)

  • VPERMD ymm, ymm, ymm [AVX2]
  • VPERMD m256, ymm, ymm [AVX2]
  • VPERMD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMI2B 

func (self *Program) VPERMI2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2B performs "Full Permute of Bytes From Two Tables Overwriting the Index".

Mnemonic : VPERMI2B Supported forms : (6 forms)

  • VPERMI2B xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMI2B m128, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMI2B ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMI2B m256, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMI2B zmm, zmm, zmm{k}{z} [AVX512VBMI]
  • VPERMI2B m512, zmm, zmm{k}{z} [AVX512VBMI]

func (*Program) VPERMI2D 

func (self *Program) VPERMI2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2D performs "Full Permute of Doublewords From Two Tables Overwriting the Index".

Mnemonic : VPERMI2D Supported forms : (6 forms)

  • VPERMI2D m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2D zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2D m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2D xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2D m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2D ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMI2PD 

func (self *Program) VPERMI2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2PD performs "Full Permute of Double-Precision Floating-Point Values From Two Tables Overwriting the Index".

Mnemonic : VPERMI2PD Supported forms : (6 forms)

  • VPERMI2PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMI2PS 

func (self *Program) VPERMI2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2PS performs "Full Permute of Single-Precision Floating-Point Values From Two Tables Overwriting the Index".

Mnemonic : VPERMI2PS Supported forms : (6 forms)

  • VPERMI2PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMI2Q 

func (self *Program) VPERMI2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2Q performs "Full Permute of Quadwords From Two Tables Overwriting the Index".

Mnemonic : VPERMI2Q Supported forms : (6 forms)

  • VPERMI2Q m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2Q zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMI2Q m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2Q xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2Q m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMI2Q ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMI2W 

func (self *Program) VPERMI2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMI2W performs "Full Permute of Words From Two Tables Overwriting the Index".

Mnemonic : VPERMI2W Supported forms : (6 forms)

  • VPERMI2W zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPERMI2W m512, zmm, zmm{k}{z} [AVX512BW]
  • VPERMI2W xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPERMI2W m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPERMI2W ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPERMI2W m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPERMIL2PD 

func (self *Program) VPERMIL2PD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction

VPERMIL2PD performs "Permute Two-Source Double-Precision Floating-Point Vectors".

Mnemonic : VPERMIL2PD Supported forms : (6 forms)

  • VPERMIL2PD imm4, xmm, xmm, xmm, xmm [XOP]
  • VPERMIL2PD imm4, m128, xmm, xmm, xmm [XOP]
  • VPERMIL2PD imm4, xmm, m128, xmm, xmm [XOP]
  • VPERMIL2PD imm4, ymm, ymm, ymm, ymm [XOP]
  • VPERMIL2PD imm4, m256, ymm, ymm, ymm [XOP]
  • VPERMIL2PD imm4, ymm, m256, ymm, ymm [XOP]

func (*Program) VPERMIL2PS 

func (self *Program) VPERMIL2PS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, v4 interface{}) *Instruction

VPERMIL2PS performs "Permute Two-Source Single-Precision Floating-Point Vectors".

Mnemonic : VPERMIL2PS Supported forms : (6 forms)

  • VPERMIL2PS imm4, xmm, xmm, xmm, xmm [XOP]
  • VPERMIL2PS imm4, m128, xmm, xmm, xmm [XOP]
  • VPERMIL2PS imm4, xmm, m128, xmm, xmm [XOP]
  • VPERMIL2PS imm4, ymm, ymm, ymm, ymm [XOP]
  • VPERMIL2PS imm4, m256, ymm, ymm, ymm [XOP]
  • VPERMIL2PS imm4, ymm, m256, ymm, ymm [XOP]

func (*Program) VPERMILPD 

func (self *Program) VPERMILPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMILPD performs "Permute Double-Precision Floating-Point Values".

Mnemonic : VPERMILPD Supported forms : (20 forms)

  • VPERMILPD imm8, xmm, xmm [AVX]
  • VPERMILPD xmm, xmm, xmm [AVX]
  • VPERMILPD m128, xmm, xmm [AVX]
  • VPERMILPD imm8, m128, xmm [AVX]
  • VPERMILPD imm8, ymm, ymm [AVX]
  • VPERMILPD ymm, ymm, ymm [AVX]
  • VPERMILPD m256, ymm, ymm [AVX]
  • VPERMILPD imm8, m256, ymm [AVX]
  • VPERMILPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPERMILPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMILPD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPERMILPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMILPD imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMILPS 

func (self *Program) VPERMILPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMILPS performs "Permute Single-Precision Floating-Point Values".

Mnemonic : VPERMILPS Supported forms : (20 forms)

  • VPERMILPS imm8, xmm, xmm [AVX]
  • VPERMILPS xmm, xmm, xmm [AVX]
  • VPERMILPS m128, xmm, xmm [AVX]
  • VPERMILPS imm8, m128, xmm [AVX]
  • VPERMILPS imm8, ymm, ymm [AVX]
  • VPERMILPS ymm, ymm, ymm [AVX]
  • VPERMILPS m256, ymm, ymm [AVX]
  • VPERMILPS imm8, m256, ymm [AVX]
  • VPERMILPS imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPERMILPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMILPS imm8, zmm, zmm{k}{z} [AVX512F]
  • VPERMILPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMILPS imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMILPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMPD 

func (self *Program) VPERMPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMPD performs "Permute Double-Precision Floating-Point Elements".

Mnemonic : VPERMPD Supported forms : (10 forms)

  • VPERMPD imm8, ymm, ymm [AVX2]
  • VPERMPD imm8, m256, ymm [AVX2]
  • VPERMPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPERMPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMPD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPERMPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMPS 

func (self *Program) VPERMPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMPS performs "Permute Single-Precision Floating-Point Elements".

Mnemonic : VPERMPS Supported forms : (6 forms)

  • VPERMPS ymm, ymm, ymm [AVX2]
  • VPERMPS m256, ymm, ymm [AVX2]
  • VPERMPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMQ 

func (self *Program) VPERMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMQ performs "Permute Quadword Integers".

Mnemonic : VPERMQ Supported forms : (10 forms)

  • VPERMQ imm8, ymm, ymm [AVX2]
  • VPERMQ imm8, m256, ymm [AVX2]
  • VPERMQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPERMQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMQ imm8, zmm, zmm{k}{z} [AVX512F]
  • VPERMQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMT2B 

func (self *Program) VPERMT2B(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2B performs "Full Permute of Bytes From Two Tables Overwriting a Table".

Mnemonic : VPERMT2B Supported forms : (6 forms)

  • VPERMT2B xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMT2B m128, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMT2B ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMT2B m256, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPERMT2B zmm, zmm, zmm{k}{z} [AVX512VBMI]
  • VPERMT2B m512, zmm, zmm{k}{z} [AVX512VBMI]

func (*Program) VPERMT2D 

func (self *Program) VPERMT2D(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2D performs "Full Permute of Doublewords From Two Tables Overwriting a Table".

Mnemonic : VPERMT2D Supported forms : (6 forms)

  • VPERMT2D m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2D zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2D m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2D xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2D m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2D ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMT2PD 

func (self *Program) VPERMT2PD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2PD performs "Full Permute of Double-Precision Floating-Point Values From Two Tables Overwriting a Table".

Mnemonic : VPERMT2PD Supported forms : (6 forms)

  • VPERMT2PD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2PD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2PD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2PD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2PD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2PD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMT2PS 

func (self *Program) VPERMT2PS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2PS performs "Full Permute of Single-Precision Floating-Point Values From Two Tables Overwriting a Table".

Mnemonic : VPERMT2PS Supported forms : (6 forms)

  • VPERMT2PS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2PS zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2PS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2PS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2PS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2PS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMT2Q 

func (self *Program) VPERMT2Q(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2Q performs "Full Permute of Quadwords From Two Tables Overwriting a Table".

Mnemonic : VPERMT2Q Supported forms : (6 forms)

  • VPERMT2Q m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2Q zmm, zmm, zmm{k}{z} [AVX512F]
  • VPERMT2Q m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2Q xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2Q m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPERMT2Q ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPERMT2W 

func (self *Program) VPERMT2W(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMT2W performs "Full Permute of Words From Two Tables Overwriting a Table".

Mnemonic : VPERMT2W Supported forms : (6 forms)

  • VPERMT2W zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPERMT2W m512, zmm, zmm{k}{z} [AVX512BW]
  • VPERMT2W xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPERMT2W m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPERMT2W ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPERMT2W m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPERMW 

func (self *Program) VPERMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPERMW performs "Permute Word Integers".

Mnemonic : VPERMW Supported forms : (6 forms)

  • VPERMW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPERMW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPERMW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPERMW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPERMW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPERMW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPEXPANDD 

func (self *Program) VPEXPANDD(v0 interface{}, v1 interface{}) *Instruction

VPEXPANDD performs "Load Sparse Packed Doubleword Integer Values from Dense Memory/Register".

Mnemonic : VPEXPANDD Supported forms : (6 forms)

  • VPEXPANDD zmm, zmm{k}{z} [AVX512F]
  • VPEXPANDD m512, zmm{k}{z} [AVX512F]
  • VPEXPANDD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPEXPANDD ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPEXPANDD m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VPEXPANDD m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPEXPANDQ 

func (self *Program) VPEXPANDQ(v0 interface{}, v1 interface{}) *Instruction

VPEXPANDQ performs "Load Sparse Packed Quadword Integer Values from Dense Memory/Register".

Mnemonic : VPEXPANDQ Supported forms : (6 forms)

  • VPEXPANDQ zmm, zmm{k}{z} [AVX512F]
  • VPEXPANDQ m512, zmm{k}{z} [AVX512F]
  • VPEXPANDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPEXPANDQ ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPEXPANDQ m128, xmm{k}{z} [AVX512F,AVX512VL]
  • VPEXPANDQ m256, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPEXTRB 

func (self *Program) VPEXTRB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRB performs "Extract Byte".

Mnemonic : VPEXTRB Supported forms : (4 forms)

  • VPEXTRB imm8, xmm, r32 [AVX]
  • VPEXTRB imm8, xmm, m8 [AVX]
  • VPEXTRB imm8, xmm, r32 [AVX512BW]
  • VPEXTRB imm8, xmm, m8 [AVX512BW]

func (*Program) VPEXTRD 

func (self *Program) VPEXTRD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRD performs "Extract Doubleword".

Mnemonic : VPEXTRD Supported forms : (4 forms)

  • VPEXTRD imm8, xmm, r32 [AVX]
  • VPEXTRD imm8, xmm, m32 [AVX]
  • VPEXTRD imm8, xmm, r32 [AVX512DQ]
  • VPEXTRD imm8, xmm, m32 [AVX512DQ]

func (*Program) VPEXTRQ 

func (self *Program) VPEXTRQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRQ performs "Extract Quadword".

Mnemonic : VPEXTRQ Supported forms : (4 forms)

  • VPEXTRQ imm8, xmm, r64 [AVX]
  • VPEXTRQ imm8, xmm, m64 [AVX]
  • VPEXTRQ imm8, xmm, r64 [AVX512DQ]
  • VPEXTRQ imm8, xmm, m64 [AVX512DQ]

func (*Program) VPEXTRW 

func (self *Program) VPEXTRW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPEXTRW performs "Extract Word".

Mnemonic : VPEXTRW Supported forms : (4 forms)

  • VPEXTRW imm8, xmm, r32 [AVX]
  • VPEXTRW imm8, xmm, m16 [AVX]
  • VPEXTRW imm8, xmm, r32 [AVX512BW]
  • VPEXTRW imm8, xmm, m16 [AVX512BW]

func (*Program) VPGATHERDD 

func (self *Program) VPGATHERDD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERDD performs "Gather Packed Doubleword Values Using Signed Doubleword Indices".

Mnemonic : VPGATHERDD Supported forms : (5 forms)

  • VPGATHERDD xmm, vm32x, xmm [AVX2]
  • VPGATHERDD ymm, vm32y, ymm [AVX2]
  • VPGATHERDD vm32z, zmm{k} [AVX512F]
  • VPGATHERDD vm32x, xmm{k} [AVX512F,AVX512VL]
  • VPGATHERDD vm32y, ymm{k} [AVX512F,AVX512VL]

func (*Program) VPGATHERDQ 

func (self *Program) VPGATHERDQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERDQ performs "Gather Packed Quadword Values Using Signed Doubleword Indices".

Mnemonic : VPGATHERDQ Supported forms : (5 forms)

  • VPGATHERDQ xmm, vm32x, xmm [AVX2]
  • VPGATHERDQ ymm, vm32x, ymm [AVX2]
  • VPGATHERDQ vm32y, zmm{k} [AVX512F]
  • VPGATHERDQ vm32x, xmm{k} [AVX512F,AVX512VL]
  • VPGATHERDQ vm32x, ymm{k} [AVX512F,AVX512VL]

func (*Program) VPGATHERQD 

func (self *Program) VPGATHERQD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERQD performs "Gather Packed Doubleword Values Using Signed Quadword Indices".

Mnemonic : VPGATHERQD Supported forms : (5 forms)

  • VPGATHERQD xmm, vm64x, xmm [AVX2]
  • VPGATHERQD xmm, vm64y, xmm [AVX2]
  • VPGATHERQD vm64z, ymm{k} [AVX512F]
  • VPGATHERQD vm64x, xmm{k} [AVX512F,AVX512VL]
  • VPGATHERQD vm64y, xmm{k} [AVX512F,AVX512VL]

func (*Program) VPGATHERQQ 

func (self *Program) VPGATHERQQ(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VPGATHERQQ performs "Gather Packed Quadword Values Using Signed Quadword Indices".

Mnemonic : VPGATHERQQ Supported forms : (5 forms)

  • VPGATHERQQ xmm, vm64x, xmm [AVX2]
  • VPGATHERQQ ymm, vm64y, ymm [AVX2]
  • VPGATHERQQ vm64z, zmm{k} [AVX512F]
  • VPGATHERQQ vm64x, xmm{k} [AVX512F,AVX512VL]
  • VPGATHERQQ vm64y, ymm{k} [AVX512F,AVX512VL]

func (*Program) VPHADDBD 

func (self *Program) VPHADDBD(v0 interface{}, v1 interface{}) *Instruction

VPHADDBD performs "Packed Horizontal Add Signed Byte to Signed Doubleword".

Mnemonic : VPHADDBD Supported forms : (2 forms)

  • VPHADDBD xmm, xmm [XOP]
  • VPHADDBD m128, xmm [XOP]

func (*Program) VPHADDBQ 

func (self *Program) VPHADDBQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDBQ performs "Packed Horizontal Add Signed Byte to Signed Quadword".

Mnemonic : VPHADDBQ Supported forms : (2 forms)

  • VPHADDBQ xmm, xmm [XOP]
  • VPHADDBQ m128, xmm [XOP]

func (*Program) VPHADDBW 

func (self *Program) VPHADDBW(v0 interface{}, v1 interface{}) *Instruction

VPHADDBW performs "Packed Horizontal Add Signed Byte to Signed Word".

Mnemonic : VPHADDBW Supported forms : (2 forms)

  • VPHADDBW xmm, xmm [XOP]
  • VPHADDBW m128, xmm [XOP]

func (*Program) VPHADDD 

func (self *Program) VPHADDD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHADDD performs "Packed Horizontal Add Doubleword Integer".

Mnemonic : VPHADDD Supported forms : (4 forms)

  • VPHADDD xmm, xmm, xmm [AVX]
  • VPHADDD m128, xmm, xmm [AVX]
  • VPHADDD ymm, ymm, ymm [AVX2]
  • VPHADDD m256, ymm, ymm [AVX2]

func (*Program) VPHADDDQ 

func (self *Program) VPHADDDQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDDQ performs "Packed Horizontal Add Signed Doubleword to Signed Quadword".

Mnemonic : VPHADDDQ Supported forms : (2 forms)

  • VPHADDDQ xmm, xmm [XOP]
  • VPHADDDQ m128, xmm [XOP]

func (*Program) VPHADDSW 

func (self *Program) VPHADDSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHADDSW performs "Packed Horizontal Add Signed Word Integers with Signed Saturation".

Mnemonic : VPHADDSW Supported forms : (4 forms)

  • VPHADDSW xmm, xmm, xmm [AVX]
  • VPHADDSW m128, xmm, xmm [AVX]
  • VPHADDSW ymm, ymm, ymm [AVX2]
  • VPHADDSW m256, ymm, ymm [AVX2]

func (*Program) VPHADDUBD 

func (self *Program) VPHADDUBD(v0 interface{}, v1 interface{}) *Instruction

VPHADDUBD performs "Packed Horizontal Add Unsigned Byte to Doubleword".

Mnemonic : VPHADDUBD Supported forms : (2 forms)

  • VPHADDUBD xmm, xmm [XOP]
  • VPHADDUBD m128, xmm [XOP]

func (*Program) VPHADDUBQ 

func (self *Program) VPHADDUBQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDUBQ performs "Packed Horizontal Add Unsigned Byte to Quadword".

Mnemonic : VPHADDUBQ Supported forms : (2 forms)

  • VPHADDUBQ xmm, xmm [XOP]
  • VPHADDUBQ m128, xmm [XOP]

func (*Program) VPHADDUBW 

func (self *Program) VPHADDUBW(v0 interface{}, v1 interface{}) *Instruction

VPHADDUBW performs "Packed Horizontal Add Unsigned Byte to Word".

Mnemonic : VPHADDUBW Supported forms : (2 forms)

  • VPHADDUBW xmm, xmm [XOP]
  • VPHADDUBW m128, xmm [XOP]

func (*Program) VPHADDUDQ 

func (self *Program) VPHADDUDQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDUDQ performs "Packed Horizontal Add Unsigned Doubleword to Quadword".

Mnemonic : VPHADDUDQ Supported forms : (2 forms)

  • VPHADDUDQ xmm, xmm [XOP]
  • VPHADDUDQ m128, xmm [XOP]

func (*Program) VPHADDUWD 

func (self *Program) VPHADDUWD(v0 interface{}, v1 interface{}) *Instruction

VPHADDUWD performs "Packed Horizontal Add Unsigned Word to Doubleword".

Mnemonic : VPHADDUWD Supported forms : (2 forms)

  • VPHADDUWD xmm, xmm [XOP]
  • VPHADDUWD m128, xmm [XOP]

func (*Program) VPHADDUWQ 

func (self *Program) VPHADDUWQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDUWQ performs "Packed Horizontal Add Unsigned Word to Quadword".

Mnemonic : VPHADDUWQ Supported forms : (2 forms)

  • VPHADDUWQ xmm, xmm [XOP]
  • VPHADDUWQ m128, xmm [XOP]

func (*Program) VPHADDW 

func (self *Program) VPHADDW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHADDW performs "Packed Horizontal Add Word Integers".

Mnemonic : VPHADDW Supported forms : (4 forms)

  • VPHADDW xmm, xmm, xmm [AVX]
  • VPHADDW m128, xmm, xmm [AVX]
  • VPHADDW ymm, ymm, ymm [AVX2]
  • VPHADDW m256, ymm, ymm [AVX2]

func (*Program) VPHADDWD 

func (self *Program) VPHADDWD(v0 interface{}, v1 interface{}) *Instruction

VPHADDWD performs "Packed Horizontal Add Signed Word to Signed Doubleword".

Mnemonic : VPHADDWD Supported forms : (2 forms)

  • VPHADDWD xmm, xmm [XOP]
  • VPHADDWD m128, xmm [XOP]

func (*Program) VPHADDWQ 

func (self *Program) VPHADDWQ(v0 interface{}, v1 interface{}) *Instruction

VPHADDWQ performs "Packed Horizontal Add Signed Word to Signed Quadword".

Mnemonic : VPHADDWQ Supported forms : (2 forms)

  • VPHADDWQ xmm, xmm [XOP]
  • VPHADDWQ m128, xmm [XOP]

func (*Program) VPHMINPOSUW 

func (self *Program) VPHMINPOSUW(v0 interface{}, v1 interface{}) *Instruction

VPHMINPOSUW performs "Packed Horizontal Minimum of Unsigned Word Integers".

Mnemonic : VPHMINPOSUW Supported forms : (2 forms)

  • VPHMINPOSUW xmm, xmm [AVX]
  • VPHMINPOSUW m128, xmm [AVX]

func (*Program) VPHSUBBW 

func (self *Program) VPHSUBBW(v0 interface{}, v1 interface{}) *Instruction

VPHSUBBW performs "Packed Horizontal Subtract Signed Byte to Signed Word".

Mnemonic : VPHSUBBW Supported forms : (2 forms)

  • VPHSUBBW xmm, xmm [XOP]
  • VPHSUBBW m128, xmm [XOP]

func (*Program) VPHSUBD 

func (self *Program) VPHSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHSUBD performs "Packed Horizontal Subtract Doubleword Integers".

Mnemonic : VPHSUBD Supported forms : (4 forms)

  • VPHSUBD xmm, xmm, xmm [AVX]
  • VPHSUBD m128, xmm, xmm [AVX]
  • VPHSUBD ymm, ymm, ymm [AVX2]
  • VPHSUBD m256, ymm, ymm [AVX2]

func (*Program) VPHSUBDQ 

func (self *Program) VPHSUBDQ(v0 interface{}, v1 interface{}) *Instruction

VPHSUBDQ performs "Packed Horizontal Subtract Signed Doubleword to Signed Quadword".

Mnemonic : VPHSUBDQ Supported forms : (2 forms)

  • VPHSUBDQ xmm, xmm [XOP]
  • VPHSUBDQ m128, xmm [XOP]

func (*Program) VPHSUBSW 

func (self *Program) VPHSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHSUBSW performs "Packed Horizontal Subtract Signed Word Integers with Signed Saturation".

Mnemonic : VPHSUBSW Supported forms : (4 forms)

  • VPHSUBSW xmm, xmm, xmm [AVX]
  • VPHSUBSW m128, xmm, xmm [AVX]
  • VPHSUBSW ymm, ymm, ymm [AVX2]
  • VPHSUBSW m256, ymm, ymm [AVX2]

func (*Program) VPHSUBW 

func (self *Program) VPHSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPHSUBW performs "Packed Horizontal Subtract Word Integers".

Mnemonic : VPHSUBW Supported forms : (4 forms)

  • VPHSUBW xmm, xmm, xmm [AVX]
  • VPHSUBW m128, xmm, xmm [AVX]
  • VPHSUBW ymm, ymm, ymm [AVX2]
  • VPHSUBW m256, ymm, ymm [AVX2]

func (*Program) VPHSUBWD 

func (self *Program) VPHSUBWD(v0 interface{}, v1 interface{}) *Instruction

VPHSUBWD performs "Packed Horizontal Subtract Signed Word to Signed Doubleword".

Mnemonic : VPHSUBWD Supported forms : (2 forms)

  • VPHSUBWD xmm, xmm [XOP]
  • VPHSUBWD m128, xmm [XOP]

func (*Program) VPINSRB 

func (self *Program) VPINSRB(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRB performs "Insert Byte".

Mnemonic : VPINSRB Supported forms : (4 forms)

  • VPINSRB imm8, r32, xmm, xmm [AVX]
  • VPINSRB imm8, m8, xmm, xmm [AVX]
  • VPINSRB imm8, r32, xmm, xmm [AVX512BW]
  • VPINSRB imm8, m8, xmm, xmm [AVX512BW]

func (*Program) VPINSRD 

func (self *Program) VPINSRD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRD performs "Insert Doubleword".

Mnemonic : VPINSRD Supported forms : (4 forms)

  • VPINSRD imm8, r32, xmm, xmm [AVX]
  • VPINSRD imm8, m32, xmm, xmm [AVX]
  • VPINSRD imm8, r32, xmm, xmm [AVX512DQ]
  • VPINSRD imm8, m32, xmm, xmm [AVX512DQ]

func (*Program) VPINSRQ 

func (self *Program) VPINSRQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRQ performs "Insert Quadword".

Mnemonic : VPINSRQ Supported forms : (4 forms)

  • VPINSRQ imm8, r64, xmm, xmm [AVX]
  • VPINSRQ imm8, m64, xmm, xmm [AVX]
  • VPINSRQ imm8, r64, xmm, xmm [AVX512DQ]
  • VPINSRQ imm8, m64, xmm, xmm [AVX512DQ]

func (*Program) VPINSRW 

func (self *Program) VPINSRW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPINSRW performs "Insert Word".

Mnemonic : VPINSRW Supported forms : (4 forms)

  • VPINSRW imm8, r32, xmm, xmm [AVX]
  • VPINSRW imm8, m16, xmm, xmm [AVX]
  • VPINSRW imm8, r32, xmm, xmm [AVX512BW]
  • VPINSRW imm8, m16, xmm, xmm [AVX512BW]

func (*Program) VPLZCNTD 

func (self *Program) VPLZCNTD(v0 interface{}, v1 interface{}) *Instruction

VPLZCNTD performs "Count the Number of Leading Zero Bits for Packed Doubleword Values".

Mnemonic : VPLZCNTD Supported forms : (6 forms)

  • VPLZCNTD m128/m32bcst, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTD m256/m32bcst, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTD m512/m32bcst, zmm{k}{z} [AVX512CD]
  • VPLZCNTD xmm, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTD ymm, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTD zmm, zmm{k}{z} [AVX512CD]

func (*Program) VPLZCNTQ 

func (self *Program) VPLZCNTQ(v0 interface{}, v1 interface{}) *Instruction

VPLZCNTQ performs "Count the Number of Leading Zero Bits for Packed Quadword Values".

Mnemonic : VPLZCNTQ Supported forms : (6 forms)

  • VPLZCNTQ m128/m64bcst, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTQ m256/m64bcst, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTQ m512/m64bcst, zmm{k}{z} [AVX512CD]
  • VPLZCNTQ xmm, xmm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTQ ymm, ymm{k}{z} [AVX512CD,AVX512VL]
  • VPLZCNTQ zmm, zmm{k}{z} [AVX512CD]

func (*Program) VPMACSDD 

func (self *Program) VPMACSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSDD performs "Packed Multiply Accumulate Signed Doubleword to Signed Doubleword".

Mnemonic : VPMACSDD Supported forms : (2 forms)

  • VPMACSDD xmm, xmm, xmm, xmm [XOP]
  • VPMACSDD xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSDQH 

func (self *Program) VPMACSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSDQH performs "Packed Multiply Accumulate Signed High Doubleword to Signed Quadword".

Mnemonic : VPMACSDQH Supported forms : (2 forms)

  • VPMACSDQH xmm, xmm, xmm, xmm [XOP]
  • VPMACSDQH xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSDQL 

func (self *Program) VPMACSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSDQL performs "Packed Multiply Accumulate Signed Low Doubleword to Signed Quadword".

Mnemonic : VPMACSDQL Supported forms : (2 forms)

  • VPMACSDQL xmm, xmm, xmm, xmm [XOP]
  • VPMACSDQL xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSSDD 

func (self *Program) VPMACSSDD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSDD performs "Packed Multiply Accumulate with Saturation Signed Doubleword to Signed Doubleword".

Mnemonic : VPMACSSDD Supported forms : (2 forms)

  • VPMACSSDD xmm, xmm, xmm, xmm [XOP]
  • VPMACSSDD xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSSDQH 

func (self *Program) VPMACSSDQH(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSDQH performs "Packed Multiply Accumulate with Saturation Signed High Doubleword to Signed Quadword".

Mnemonic : VPMACSSDQH Supported forms : (2 forms)

  • VPMACSSDQH xmm, xmm, xmm, xmm [XOP]
  • VPMACSSDQH xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSSDQL 

func (self *Program) VPMACSSDQL(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSDQL performs "Packed Multiply Accumulate with Saturation Signed Low Doubleword to Signed Quadword".

Mnemonic : VPMACSSDQL Supported forms : (2 forms)

  • VPMACSSDQL xmm, xmm, xmm, xmm [XOP]
  • VPMACSSDQL xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSSWD 

func (self *Program) VPMACSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSWD performs "Packed Multiply Accumulate with Saturation Signed Word to Signed Doubleword".

Mnemonic : VPMACSSWD Supported forms : (2 forms)

  • VPMACSSWD xmm, xmm, xmm, xmm [XOP]
  • VPMACSSWD xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSSWW 

func (self *Program) VPMACSSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSSWW performs "Packed Multiply Accumulate with Saturation Signed Word to Signed Word".

Mnemonic : VPMACSSWW Supported forms : (2 forms)

  • VPMACSSWW xmm, xmm, xmm, xmm [XOP]
  • VPMACSSWW xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSWD 

func (self *Program) VPMACSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSWD performs "Packed Multiply Accumulate Signed Word to Signed Doubleword".

Mnemonic : VPMACSWD Supported forms : (2 forms)

  • VPMACSWD xmm, xmm, xmm, xmm [XOP]
  • VPMACSWD xmm, m128, xmm, xmm [XOP]

func (*Program) VPMACSWW 

func (self *Program) VPMACSWW(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMACSWW performs "Packed Multiply Accumulate Signed Word to Signed Word".

Mnemonic : VPMACSWW Supported forms : (2 forms)

  • VPMACSWW xmm, xmm, xmm, xmm [XOP]
  • VPMACSWW xmm, m128, xmm, xmm [XOP]

func (*Program) VPMADCSSWD 

func (self *Program) VPMADCSSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMADCSSWD performs "Packed Multiply Add Accumulate with Saturation Signed Word to Signed Doubleword".

Mnemonic : VPMADCSSWD Supported forms : (2 forms)

  • VPMADCSSWD xmm, xmm, xmm, xmm [XOP]
  • VPMADCSSWD xmm, m128, xmm, xmm [XOP]

func (*Program) VPMADCSWD 

func (self *Program) VPMADCSWD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPMADCSWD performs "Packed Multiply Add Accumulate Signed Word to Signed Doubleword".

Mnemonic : VPMADCSWD Supported forms : (2 forms)

  • VPMADCSWD xmm, xmm, xmm, xmm [XOP]
  • VPMADCSWD xmm, m128, xmm, xmm [XOP]

func (*Program) VPMADD52HUQ 

func (self *Program) VPMADD52HUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADD52HUQ performs "Packed Multiply of Unsigned 52-bit Unsigned Integers and Add High 52-bit Products to Quadword Accumulators".

Mnemonic : VPMADD52HUQ Supported forms : (6 forms)

  • VPMADD52HUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52HUQ xmm, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52HUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52HUQ ymm, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52HUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512IFMA]
  • VPMADD52HUQ zmm, zmm, zmm{k}{z} [AVX512IFMA]

func (*Program) VPMADD52LUQ 

func (self *Program) VPMADD52LUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADD52LUQ performs "Packed Multiply of Unsigned 52-bit Integers and Add the Low 52-bit Products to Quadword Accumulators".

Mnemonic : VPMADD52LUQ Supported forms : (6 forms)

  • VPMADD52LUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52LUQ xmm, xmm, xmm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52LUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52LUQ ymm, ymm, ymm{k}{z} [AVX512IFMA,AVX512VL]
  • VPMADD52LUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512IFMA]
  • VPMADD52LUQ zmm, zmm, zmm{k}{z} [AVX512IFMA]

func (*Program) VPMADDUBSW 

func (self *Program) VPMADDUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADDUBSW performs "Multiply and Add Packed Signed and Unsigned Byte Integers".

Mnemonic : VPMADDUBSW Supported forms : (10 forms)

  • VPMADDUBSW xmm, xmm, xmm [AVX]
  • VPMADDUBSW m128, xmm, xmm [AVX]
  • VPMADDUBSW ymm, ymm, ymm [AVX2]
  • VPMADDUBSW m256, ymm, ymm [AVX2]
  • VPMADDUBSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMADDUBSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMADDUBSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMADDUBSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMADDUBSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMADDUBSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMADDWD 

func (self *Program) VPMADDWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMADDWD performs "Multiply and Add Packed Signed Word Integers".

Mnemonic : VPMADDWD Supported forms : (10 forms)

  • VPMADDWD xmm, xmm, xmm [AVX]
  • VPMADDWD m128, xmm, xmm [AVX]
  • VPMADDWD ymm, ymm, ymm [AVX2]
  • VPMADDWD m256, ymm, ymm [AVX2]
  • VPMADDWD zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMADDWD m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMADDWD xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMADDWD m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMADDWD ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMADDWD m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMASKMOVD 

func (self *Program) VPMASKMOVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMASKMOVD performs "Conditional Move Packed Doubleword Integers".

Mnemonic : VPMASKMOVD Supported forms : (4 forms)

  • VPMASKMOVD m128, xmm, xmm [AVX2]
  • VPMASKMOVD m256, ymm, ymm [AVX2]
  • VPMASKMOVD xmm, xmm, m128 [AVX2]
  • VPMASKMOVD ymm, ymm, m256 [AVX2]

func (*Program) VPMASKMOVQ 

func (self *Program) VPMASKMOVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMASKMOVQ performs "Conditional Move Packed Quadword Integers".

Mnemonic : VPMASKMOVQ Supported forms : (4 forms)

  • VPMASKMOVQ m128, xmm, xmm [AVX2]
  • VPMASKMOVQ m256, ymm, ymm [AVX2]
  • VPMASKMOVQ xmm, xmm, m128 [AVX2]
  • VPMASKMOVQ ymm, ymm, m256 [AVX2]

func (*Program) VPMAXSB 

func (self *Program) VPMAXSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSB performs "Maximum of Packed Signed Byte Integers".

Mnemonic : VPMAXSB Supported forms : (10 forms)

  • VPMAXSB xmm, xmm, xmm [AVX]
  • VPMAXSB m128, xmm, xmm [AVX]
  • VPMAXSB ymm, ymm, ymm [AVX2]
  • VPMAXSB m256, ymm, ymm [AVX2]
  • VPMAXSB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXSB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMAXSD 

func (self *Program) VPMAXSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSD performs "Maximum of Packed Signed Doubleword Integers".

Mnemonic : VPMAXSD Supported forms : (10 forms)

  • VPMAXSD xmm, xmm, xmm [AVX]
  • VPMAXSD m128, xmm, xmm [AVX]
  • VPMAXSD ymm, ymm, ymm [AVX2]
  • VPMAXSD m256, ymm, ymm [AVX2]
  • VPMAXSD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMAXSD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMAXSD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXSD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXSD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMAXSD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMAXSQ 

func (self *Program) VPMAXSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSQ performs "Maximum of Packed Signed Quadword Integers".

Mnemonic : VPMAXSQ Supported forms : (6 forms)

  • VPMAXSQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMAXSQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMAXSQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXSQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXSQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMAXSQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMAXSW 

func (self *Program) VPMAXSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXSW performs "Maximum of Packed Signed Word Integers".

Mnemonic : VPMAXSW Supported forms : (10 forms)

  • VPMAXSW xmm, xmm, xmm [AVX]
  • VPMAXSW m128, xmm, xmm [AVX]
  • VPMAXSW ymm, ymm, ymm [AVX2]
  • VPMAXSW m256, ymm, ymm [AVX2]
  • VPMAXSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMAXUB 

func (self *Program) VPMAXUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUB performs "Maximum of Packed Unsigned Byte Integers".

Mnemonic : VPMAXUB Supported forms : (10 forms)

  • VPMAXUB xmm, xmm, xmm [AVX]
  • VPMAXUB m128, xmm, xmm [AVX]
  • VPMAXUB ymm, ymm, ymm [AVX2]
  • VPMAXUB m256, ymm, ymm [AVX2]
  • VPMAXUB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXUB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXUB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXUB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXUB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXUB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMAXUD 

func (self *Program) VPMAXUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUD performs "Maximum of Packed Unsigned Doubleword Integers".

Mnemonic : VPMAXUD Supported forms : (10 forms)

  • VPMAXUD xmm, xmm, xmm [AVX]
  • VPMAXUD m128, xmm, xmm [AVX]
  • VPMAXUD ymm, ymm, ymm [AVX2]
  • VPMAXUD m256, ymm, ymm [AVX2]
  • VPMAXUD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMAXUD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMAXUD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXUD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXUD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMAXUD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMAXUQ 

func (self *Program) VPMAXUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUQ performs "Maximum of Packed Unsigned Quadword Integers".

Mnemonic : VPMAXUQ Supported forms : (6 forms)

  • VPMAXUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMAXUQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMAXUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXUQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMAXUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMAXUQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMAXUW 

func (self *Program) VPMAXUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMAXUW performs "Maximum of Packed Unsigned Word Integers".

Mnemonic : VPMAXUW Supported forms : (10 forms)

  • VPMAXUW xmm, xmm, xmm [AVX]
  • VPMAXUW m128, xmm, xmm [AVX]
  • VPMAXUW ymm, ymm, ymm [AVX2]
  • VPMAXUW m256, ymm, ymm [AVX2]
  • VPMAXUW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXUW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMAXUW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXUW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXUW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMAXUW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMINSB 

func (self *Program) VPMINSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSB performs "Minimum of Packed Signed Byte Integers".

Mnemonic : VPMINSB Supported forms : (10 forms)

  • VPMINSB xmm, xmm, xmm [AVX]
  • VPMINSB m128, xmm, xmm [AVX]
  • VPMINSB ymm, ymm, ymm [AVX2]
  • VPMINSB m256, ymm, ymm [AVX2]
  • VPMINSB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMINSB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMINSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMINSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMINSD 

func (self *Program) VPMINSD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSD performs "Minimum of Packed Signed Doubleword Integers".

Mnemonic : VPMINSD Supported forms : (10 forms)

  • VPMINSD xmm, xmm, xmm [AVX]
  • VPMINSD m128, xmm, xmm [AVX]
  • VPMINSD ymm, ymm, ymm [AVX2]
  • VPMINSD m256, ymm, ymm [AVX2]
  • VPMINSD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMINSD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMINSD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINSD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINSD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMINSD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMINSQ 

func (self *Program) VPMINSQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSQ performs "Minimum of Packed Signed Quadword Integers".

Mnemonic : VPMINSQ Supported forms : (6 forms)

  • VPMINSQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMINSQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMINSQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINSQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINSQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMINSQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMINSW 

func (self *Program) VPMINSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINSW performs "Minimum of Packed Signed Word Integers".

Mnemonic : VPMINSW Supported forms : (10 forms)

  • VPMINSW xmm, xmm, xmm [AVX]
  • VPMINSW m128, xmm, xmm [AVX]
  • VPMINSW ymm, ymm, ymm [AVX2]
  • VPMINSW m256, ymm, ymm [AVX2]
  • VPMINSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMINSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMINSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMINSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMINUB 

func (self *Program) VPMINUB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUB performs "Minimum of Packed Unsigned Byte Integers".

Mnemonic : VPMINUB Supported forms : (10 forms)

  • VPMINUB xmm, xmm, xmm [AVX]
  • VPMINUB m128, xmm, xmm [AVX]
  • VPMINUB ymm, ymm, ymm [AVX2]
  • VPMINUB m256, ymm, ymm [AVX2]
  • VPMINUB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMINUB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMINUB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINUB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINUB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMINUB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMINUD 

func (self *Program) VPMINUD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUD performs "Minimum of Packed Unsigned Doubleword Integers".

Mnemonic : VPMINUD Supported forms : (10 forms)

  • VPMINUD xmm, xmm, xmm [AVX]
  • VPMINUD m128, xmm, xmm [AVX]
  • VPMINUD ymm, ymm, ymm [AVX2]
  • VPMINUD m256, ymm, ymm [AVX2]
  • VPMINUD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMINUD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMINUD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINUD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINUD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMINUD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMINUQ 

func (self *Program) VPMINUQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUQ performs "Minimum of Packed Unsigned Quadword Integers".

Mnemonic : VPMINUQ Supported forms : (6 forms)

  • VPMINUQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMINUQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMINUQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINUQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMINUQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMINUQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMINUW 

func (self *Program) VPMINUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMINUW performs "Minimum of Packed Unsigned Word Integers".

Mnemonic : VPMINUW Supported forms : (10 forms)

  • VPMINUW xmm, xmm, xmm [AVX]
  • VPMINUW m128, xmm, xmm [AVX]
  • VPMINUW ymm, ymm, ymm [AVX2]
  • VPMINUW m256, ymm, ymm [AVX2]
  • VPMINUW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMINUW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMINUW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINUW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMINUW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMINUW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMOVB2M 

func (self *Program) VPMOVB2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVB2M performs "Move Signs of Packed Byte Integers to Mask Register".

Mnemonic : VPMOVB2M Supported forms : (3 forms)

  • VPMOVB2M zmm, k [AVX512BW]
  • VPMOVB2M xmm, k [AVX512BW,AVX512VL]
  • VPMOVB2M ymm, k [AVX512BW,AVX512VL]

func (*Program) VPMOVD2M 

func (self *Program) VPMOVD2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVD2M performs "Move Signs of Packed Doubleword Integers to Mask Register".

Mnemonic : VPMOVD2M Supported forms : (3 forms)

  • VPMOVD2M zmm, k [AVX512DQ]
  • VPMOVD2M xmm, k [AVX512DQ,AVX512VL]
  • VPMOVD2M ymm, k [AVX512DQ,AVX512VL]

func (*Program) VPMOVDB 

func (self *Program) VPMOVDB(v0 interface{}, v1 interface{}) *Instruction

VPMOVDB performs "Down Convert Packed Doubleword Values to Byte Values with Truncation".

Mnemonic : VPMOVDB Supported forms : (6 forms)

  • VPMOVDB zmm, xmm{k}{z} [AVX512F]
  • VPMOVDB zmm, m128{k}{z} [AVX512F]
  • VPMOVDB xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVDB xmm, m32{k}{z} [AVX512F,AVX512VL]
  • VPMOVDB ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVDB ymm, m64{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVDW 

func (self *Program) VPMOVDW(v0 interface{}, v1 interface{}) *Instruction

VPMOVDW performs "Down Convert Packed Doubleword Values to Word Values with Truncation".

Mnemonic : VPMOVDW Supported forms : (6 forms)

  • VPMOVDW zmm, ymm{k}{z} [AVX512F]
  • VPMOVDW zmm, m256{k}{z} [AVX512F]
  • VPMOVDW xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVDW xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VPMOVDW ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVDW ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVM2B 

func (self *Program) VPMOVM2B(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2B performs "Expand Bits of Mask Register to Packed Byte Integers".

Mnemonic : VPMOVM2B Supported forms : (3 forms)

  • VPMOVM2B k, zmm [AVX512BW]
  • VPMOVM2B k, xmm [AVX512BW,AVX512VL]
  • VPMOVM2B k, ymm [AVX512BW,AVX512VL]

func (*Program) VPMOVM2D 

func (self *Program) VPMOVM2D(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2D performs "Expand Bits of Mask Register to Packed Doubleword Integers".

Mnemonic : VPMOVM2D Supported forms : (3 forms)

  • VPMOVM2D k, zmm [AVX512DQ]
  • VPMOVM2D k, xmm [AVX512DQ,AVX512VL]
  • VPMOVM2D k, ymm [AVX512DQ,AVX512VL]

func (*Program) VPMOVM2Q 

func (self *Program) VPMOVM2Q(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2Q performs "Expand Bits of Mask Register to Packed Quadword Integers".

Mnemonic : VPMOVM2Q Supported forms : (3 forms)

  • VPMOVM2Q k, zmm [AVX512DQ]
  • VPMOVM2Q k, xmm [AVX512DQ,AVX512VL]
  • VPMOVM2Q k, ymm [AVX512DQ,AVX512VL]

func (*Program) VPMOVM2W 

func (self *Program) VPMOVM2W(v0 interface{}, v1 interface{}) *Instruction

VPMOVM2W performs "Expand Bits of Mask Register to Packed Word Integers".

Mnemonic : VPMOVM2W Supported forms : (3 forms)

  • VPMOVM2W k, zmm [AVX512BW]
  • VPMOVM2W k, xmm [AVX512BW,AVX512VL]
  • VPMOVM2W k, ymm [AVX512BW,AVX512VL]

func (*Program) VPMOVMSKB 

func (self *Program) VPMOVMSKB(v0 interface{}, v1 interface{}) *Instruction

VPMOVMSKB performs "Move Byte Mask".

Mnemonic : VPMOVMSKB Supported forms : (2 forms)

  • VPMOVMSKB xmm, r32 [AVX]
  • VPMOVMSKB ymm, r32 [AVX2]

func (*Program) VPMOVQ2M 

func (self *Program) VPMOVQ2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVQ2M performs "Move Signs of Packed Quadword Integers to Mask Register".

Mnemonic : VPMOVQ2M Supported forms : (3 forms)

  • VPMOVQ2M zmm, k [AVX512DQ]
  • VPMOVQ2M xmm, k [AVX512DQ,AVX512VL]
  • VPMOVQ2M ymm, k [AVX512DQ,AVX512VL]

func (*Program) VPMOVQB 

func (self *Program) VPMOVQB(v0 interface{}, v1 interface{}) *Instruction

VPMOVQB performs "Down Convert Packed Quadword Values to Byte Values with Truncation".

Mnemonic : VPMOVQB Supported forms : (6 forms)

  • VPMOVQB zmm, xmm{k}{z} [AVX512F]
  • VPMOVQB zmm, m64{k}{z} [AVX512F]
  • VPMOVQB xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVQB xmm, m16{k}{z} [AVX512F,AVX512VL]
  • VPMOVQB ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVQB ymm, m32{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVQD 

func (self *Program) VPMOVQD(v0 interface{}, v1 interface{}) *Instruction

VPMOVQD performs "Down Convert Packed Quadword Values to Doubleword Values with Truncation".

Mnemonic : VPMOVQD Supported forms : (6 forms)

  • VPMOVQD zmm, ymm{k}{z} [AVX512F]
  • VPMOVQD zmm, m256{k}{z} [AVX512F]
  • VPMOVQD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVQD xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VPMOVQD ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVQD ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVQW 

func (self *Program) VPMOVQW(v0 interface{}, v1 interface{}) *Instruction

VPMOVQW performs "Down Convert Packed Quadword Values to Word Values with Truncation".

Mnemonic : VPMOVQW Supported forms : (6 forms)

  • VPMOVQW zmm, xmm{k}{z} [AVX512F]
  • VPMOVQW zmm, m128{k}{z} [AVX512F]
  • VPMOVQW xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVQW xmm, m32{k}{z} [AVX512F,AVX512VL]
  • VPMOVQW ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVQW ymm, m64{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSDB 

func (self *Program) VPMOVSDB(v0 interface{}, v1 interface{}) *Instruction

VPMOVSDB performs "Down Convert Packed Doubleword Values to Byte Values with Signed Saturation".

Mnemonic : VPMOVSDB Supported forms : (6 forms)

  • VPMOVSDB zmm, xmm{k}{z} [AVX512F]
  • VPMOVSDB zmm, m128{k}{z} [AVX512F]
  • VPMOVSDB xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSDB xmm, m32{k}{z} [AVX512F,AVX512VL]
  • VPMOVSDB ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSDB ymm, m64{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSDW 

func (self *Program) VPMOVSDW(v0 interface{}, v1 interface{}) *Instruction

VPMOVSDW performs "Down Convert Packed Doubleword Values to Word Values with Signed Saturation".

Mnemonic : VPMOVSDW Supported forms : (6 forms)

  • VPMOVSDW zmm, ymm{k}{z} [AVX512F]
  • VPMOVSDW zmm, m256{k}{z} [AVX512F]
  • VPMOVSDW xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSDW xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VPMOVSDW ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSDW ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSQB 

func (self *Program) VPMOVSQB(v0 interface{}, v1 interface{}) *Instruction

VPMOVSQB performs "Down Convert Packed Quadword Values to Byte Values with Signed Saturation".

Mnemonic : VPMOVSQB Supported forms : (6 forms)

  • VPMOVSQB zmm, xmm{k}{z} [AVX512F]
  • VPMOVSQB zmm, m64{k}{z} [AVX512F]
  • VPMOVSQB xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQB xmm, m16{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQB ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQB ymm, m32{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSQD 

func (self *Program) VPMOVSQD(v0 interface{}, v1 interface{}) *Instruction

VPMOVSQD performs "Down Convert Packed Quadword Values to Doubleword Values with Signed Saturation".

Mnemonic : VPMOVSQD Supported forms : (6 forms)

  • VPMOVSQD zmm, ymm{k}{z} [AVX512F]
  • VPMOVSQD zmm, m256{k}{z} [AVX512F]
  • VPMOVSQD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQD xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQD ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQD ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSQW 

func (self *Program) VPMOVSQW(v0 interface{}, v1 interface{}) *Instruction

VPMOVSQW performs "Down Convert Packed Quadword Values to Word Values with Signed Saturation".

Mnemonic : VPMOVSQW Supported forms : (6 forms)

  • VPMOVSQW zmm, xmm{k}{z} [AVX512F]
  • VPMOVSQW zmm, m128{k}{z} [AVX512F]
  • VPMOVSQW xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQW xmm, m32{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQW ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSQW ymm, m64{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSWB 

func (self *Program) VPMOVSWB(v0 interface{}, v1 interface{}) *Instruction

VPMOVSWB performs "Down Convert Packed Word Values to Byte Values with Signed Saturation".

Mnemonic : VPMOVSWB Supported forms : (6 forms)

  • VPMOVSWB zmm, ymm{k}{z} [AVX512BW]
  • VPMOVSWB zmm, m256{k}{z} [AVX512BW]
  • VPMOVSWB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVSWB xmm, m64{k}{z} [AVX512BW,AVX512VL]
  • VPMOVSWB ymm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVSWB ymm, m128{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMOVSXBD 

func (self *Program) VPMOVSXBD(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXBD performs "Move Packed Byte Integers to Doubleword Integers with Sign Extension".

Mnemonic : VPMOVSXBD Supported forms : (10 forms)

  • VPMOVSXBD xmm, xmm [AVX]
  • VPMOVSXBD m32, xmm [AVX]
  • VPMOVSXBD xmm, ymm [AVX2]
  • VPMOVSXBD m64, ymm [AVX2]
  • VPMOVSXBD xmm, zmm{k}{z} [AVX512F]
  • VPMOVSXBD m128, zmm{k}{z} [AVX512F]
  • VPMOVSXBD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXBD xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXBD m32, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXBD m64, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSXBQ 

func (self *Program) VPMOVSXBQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXBQ performs "Move Packed Byte Integers to Quadword Integers with Sign Extension".

Mnemonic : VPMOVSXBQ Supported forms : (10 forms)

  • VPMOVSXBQ xmm, xmm [AVX]
  • VPMOVSXBQ m16, xmm [AVX]
  • VPMOVSXBQ xmm, ymm [AVX2]
  • VPMOVSXBQ m32, ymm [AVX2]
  • VPMOVSXBQ xmm, zmm{k}{z} [AVX512F]
  • VPMOVSXBQ m64, zmm{k}{z} [AVX512F]
  • VPMOVSXBQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXBQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXBQ m16, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXBQ m32, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSXBW 

func (self *Program) VPMOVSXBW(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXBW performs "Move Packed Byte Integers to Word Integers with Sign Extension".

Mnemonic : VPMOVSXBW Supported forms : (10 forms)

  • VPMOVSXBW xmm, xmm [AVX]
  • VPMOVSXBW m64, xmm [AVX]
  • VPMOVSXBW xmm, ymm [AVX2]
  • VPMOVSXBW m128, ymm [AVX2]
  • VPMOVSXBW ymm, zmm{k}{z} [AVX512BW]
  • VPMOVSXBW m256, zmm{k}{z} [AVX512BW]
  • VPMOVSXBW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVSXBW xmm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVSXBW m64, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVSXBW m128, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMOVSXDQ 

func (self *Program) VPMOVSXDQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Sign Extension".

Mnemonic : VPMOVSXDQ Supported forms : (10 forms)

  • VPMOVSXDQ xmm, xmm [AVX]
  • VPMOVSXDQ m64, xmm [AVX]
  • VPMOVSXDQ xmm, ymm [AVX2]
  • VPMOVSXDQ m128, ymm [AVX2]
  • VPMOVSXDQ ymm, zmm{k}{z} [AVX512F]
  • VPMOVSXDQ m256, zmm{k}{z} [AVX512F]
  • VPMOVSXDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXDQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXDQ m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXDQ m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSXWD 

func (self *Program) VPMOVSXWD(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXWD performs "Move Packed Word Integers to Doubleword Integers with Sign Extension".

Mnemonic : VPMOVSXWD Supported forms : (10 forms)

  • VPMOVSXWD xmm, xmm [AVX]
  • VPMOVSXWD m64, xmm [AVX]
  • VPMOVSXWD xmm, ymm [AVX2]
  • VPMOVSXWD m128, ymm [AVX2]
  • VPMOVSXWD ymm, zmm{k}{z} [AVX512F]
  • VPMOVSXWD m256, zmm{k}{z} [AVX512F]
  • VPMOVSXWD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXWD xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXWD m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXWD m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVSXWQ 

func (self *Program) VPMOVSXWQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVSXWQ performs "Move Packed Word Integers to Quadword Integers with Sign Extension".

Mnemonic : VPMOVSXWQ Supported forms : (10 forms)

  • VPMOVSXWQ xmm, xmm [AVX]
  • VPMOVSXWQ m32, xmm [AVX]
  • VPMOVSXWQ xmm, ymm [AVX2]
  • VPMOVSXWQ m64, ymm [AVX2]
  • VPMOVSXWQ xmm, zmm{k}{z} [AVX512F]
  • VPMOVSXWQ m128, zmm{k}{z} [AVX512F]
  • VPMOVSXWQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXWQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXWQ m32, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVSXWQ m64, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVUSDB 

func (self *Program) VPMOVUSDB(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSDB performs "Down Convert Packed Doubleword Values to Byte Values with Unsigned Saturation".

Mnemonic : VPMOVUSDB Supported forms : (6 forms)

  • VPMOVUSDB zmm, xmm{k}{z} [AVX512F]
  • VPMOVUSDB zmm, m128{k}{z} [AVX512F]
  • VPMOVUSDB xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSDB xmm, m32{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSDB ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSDB ymm, m64{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVUSDW 

func (self *Program) VPMOVUSDW(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSDW performs "Down Convert Packed Doubleword Values to Word Values with Unsigned Saturation".

Mnemonic : VPMOVUSDW Supported forms : (6 forms)

  • VPMOVUSDW zmm, ymm{k}{z} [AVX512F]
  • VPMOVUSDW zmm, m256{k}{z} [AVX512F]
  • VPMOVUSDW xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSDW xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSDW ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSDW ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVUSQB 

func (self *Program) VPMOVUSQB(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSQB performs "Down Convert Packed Quadword Values to Byte Values with Unsigned Saturation".

Mnemonic : VPMOVUSQB Supported forms : (6 forms)

  • VPMOVUSQB zmm, xmm{k}{z} [AVX512F]
  • VPMOVUSQB zmm, m64{k}{z} [AVX512F]
  • VPMOVUSQB xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQB xmm, m16{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQB ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQB ymm, m32{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVUSQD 

func (self *Program) VPMOVUSQD(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSQD performs "Down Convert Packed Quadword Values to Doubleword Values with Unsigned Saturation".

Mnemonic : VPMOVUSQD Supported forms : (6 forms)

  • VPMOVUSQD zmm, ymm{k}{z} [AVX512F]
  • VPMOVUSQD zmm, m256{k}{z} [AVX512F]
  • VPMOVUSQD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQD xmm, m64{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQD ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQD ymm, m128{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVUSQW 

func (self *Program) VPMOVUSQW(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSQW performs "Down Convert Packed Quadword Values to Word Values with Unsigned Saturation".

Mnemonic : VPMOVUSQW Supported forms : (6 forms)

  • VPMOVUSQW zmm, xmm{k}{z} [AVX512F]
  • VPMOVUSQW zmm, m128{k}{z} [AVX512F]
  • VPMOVUSQW xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQW xmm, m32{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQW ymm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVUSQW ymm, m64{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVUSWB 

func (self *Program) VPMOVUSWB(v0 interface{}, v1 interface{}) *Instruction

VPMOVUSWB performs "Down Convert Packed Word Values to Byte Values with Unsigned Saturation".

Mnemonic : VPMOVUSWB Supported forms : (6 forms)

  • VPMOVUSWB zmm, ymm{k}{z} [AVX512BW]
  • VPMOVUSWB zmm, m256{k}{z} [AVX512BW]
  • VPMOVUSWB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVUSWB xmm, m64{k}{z} [AVX512BW,AVX512VL]
  • VPMOVUSWB ymm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVUSWB ymm, m128{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMOVW2M 

func (self *Program) VPMOVW2M(v0 interface{}, v1 interface{}) *Instruction

VPMOVW2M performs "Move Signs of Packed Word Integers to Mask Register".

Mnemonic : VPMOVW2M Supported forms : (3 forms)

  • VPMOVW2M zmm, k [AVX512BW]
  • VPMOVW2M xmm, k [AVX512BW,AVX512VL]
  • VPMOVW2M ymm, k [AVX512BW,AVX512VL]

func (*Program) VPMOVWB 

func (self *Program) VPMOVWB(v0 interface{}, v1 interface{}) *Instruction

VPMOVWB performs "Down Convert Packed Word Values to Byte Values with Truncation".

Mnemonic : VPMOVWB Supported forms : (6 forms)

  • VPMOVWB zmm, ymm{k}{z} [AVX512BW]
  • VPMOVWB zmm, m256{k}{z} [AVX512BW]
  • VPMOVWB xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVWB xmm, m64{k}{z} [AVX512BW,AVX512VL]
  • VPMOVWB ymm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVWB ymm, m128{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMOVZXBD 

func (self *Program) VPMOVZXBD(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXBD performs "Move Packed Byte Integers to Doubleword Integers with Zero Extension".

Mnemonic : VPMOVZXBD Supported forms : (10 forms)

  • VPMOVZXBD xmm, xmm [AVX]
  • VPMOVZXBD m32, xmm [AVX]
  • VPMOVZXBD xmm, ymm [AVX2]
  • VPMOVZXBD m64, ymm [AVX2]
  • VPMOVZXBD xmm, zmm{k}{z} [AVX512F]
  • VPMOVZXBD m128, zmm{k}{z} [AVX512F]
  • VPMOVZXBD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXBD xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXBD m32, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXBD m64, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVZXBQ 

func (self *Program) VPMOVZXBQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXBQ performs "Move Packed Byte Integers to Quadword Integers with Zero Extension".

Mnemonic : VPMOVZXBQ Supported forms : (10 forms)

  • VPMOVZXBQ xmm, xmm [AVX]
  • VPMOVZXBQ m16, xmm [AVX]
  • VPMOVZXBQ xmm, ymm [AVX2]
  • VPMOVZXBQ m32, ymm [AVX2]
  • VPMOVZXBQ xmm, zmm{k}{z} [AVX512F]
  • VPMOVZXBQ m64, zmm{k}{z} [AVX512F]
  • VPMOVZXBQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXBQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXBQ m16, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXBQ m32, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVZXBW 

func (self *Program) VPMOVZXBW(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXBW performs "Move Packed Byte Integers to Word Integers with Zero Extension".

Mnemonic : VPMOVZXBW Supported forms : (10 forms)

  • VPMOVZXBW xmm, xmm [AVX]
  • VPMOVZXBW m64, xmm [AVX]
  • VPMOVZXBW xmm, ymm [AVX2]
  • VPMOVZXBW m128, ymm [AVX2]
  • VPMOVZXBW ymm, zmm{k}{z} [AVX512BW]
  • VPMOVZXBW m256, zmm{k}{z} [AVX512BW]
  • VPMOVZXBW xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVZXBW xmm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVZXBW m64, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMOVZXBW m128, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMOVZXDQ 

func (self *Program) VPMOVZXDQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXDQ performs "Move Packed Doubleword Integers to Quadword Integers with Zero Extension".

Mnemonic : VPMOVZXDQ Supported forms : (10 forms)

  • VPMOVZXDQ xmm, xmm [AVX]
  • VPMOVZXDQ m64, xmm [AVX]
  • VPMOVZXDQ xmm, ymm [AVX2]
  • VPMOVZXDQ m128, ymm [AVX2]
  • VPMOVZXDQ ymm, zmm{k}{z} [AVX512F]
  • VPMOVZXDQ m256, zmm{k}{z} [AVX512F]
  • VPMOVZXDQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXDQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXDQ m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXDQ m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVZXWD 

func (self *Program) VPMOVZXWD(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXWD performs "Move Packed Word Integers to Doubleword Integers with Zero Extension".

Mnemonic : VPMOVZXWD Supported forms : (10 forms)

  • VPMOVZXWD xmm, xmm [AVX]
  • VPMOVZXWD m64, xmm [AVX]
  • VPMOVZXWD xmm, ymm [AVX2]
  • VPMOVZXWD m128, ymm [AVX2]
  • VPMOVZXWD ymm, zmm{k}{z} [AVX512F]
  • VPMOVZXWD m256, zmm{k}{z} [AVX512F]
  • VPMOVZXWD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXWD xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXWD m64, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXWD m128, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMOVZXWQ 

func (self *Program) VPMOVZXWQ(v0 interface{}, v1 interface{}) *Instruction

VPMOVZXWQ performs "Move Packed Word Integers to Quadword Integers with Zero Extension".

Mnemonic : VPMOVZXWQ Supported forms : (10 forms)

  • VPMOVZXWQ xmm, xmm [AVX]
  • VPMOVZXWQ m32, xmm [AVX]
  • VPMOVZXWQ xmm, ymm [AVX2]
  • VPMOVZXWQ m64, ymm [AVX2]
  • VPMOVZXWQ xmm, zmm{k}{z} [AVX512F]
  • VPMOVZXWQ m128, zmm{k}{z} [AVX512F]
  • VPMOVZXWQ xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXWQ xmm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXWQ m32, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMOVZXWQ m64, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMULDQ 

func (self *Program) VPMULDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULDQ performs "Multiply Packed Signed Doubleword Integers and Store Quadword Result".

Mnemonic : VPMULDQ Supported forms : (10 forms)

  • VPMULDQ xmm, xmm, xmm [AVX]
  • VPMULDQ m128, xmm, xmm [AVX]
  • VPMULDQ ymm, ymm, ymm [AVX2]
  • VPMULDQ m256, ymm, ymm [AVX2]
  • VPMULDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMULDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMULDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMULDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMULDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMULDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMULHRSW 

func (self *Program) VPMULHRSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULHRSW performs "Packed Multiply Signed Word Integers and Store High Result with Round and Scale".

Mnemonic : VPMULHRSW Supported forms : (10 forms)

  • VPMULHRSW xmm, xmm, xmm [AVX]
  • VPMULHRSW m128, xmm, xmm [AVX]
  • VPMULHRSW ymm, ymm, ymm [AVX2]
  • VPMULHRSW m256, ymm, ymm [AVX2]
  • VPMULHRSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMULHRSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMULHRSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHRSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHRSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHRSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMULHUW 

func (self *Program) VPMULHUW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULHUW performs "Multiply Packed Unsigned Word Integers and Store High Result".

Mnemonic : VPMULHUW Supported forms : (10 forms)

  • VPMULHUW xmm, xmm, xmm [AVX]
  • VPMULHUW m128, xmm, xmm [AVX]
  • VPMULHUW ymm, ymm, ymm [AVX2]
  • VPMULHUW m256, ymm, ymm [AVX2]
  • VPMULHUW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMULHUW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMULHUW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHUW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHUW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHUW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMULHW 

func (self *Program) VPMULHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULHW performs "Multiply Packed Signed Word Integers and Store High Result".

Mnemonic : VPMULHW Supported forms : (10 forms)

  • VPMULHW xmm, xmm, xmm [AVX]
  • VPMULHW m128, xmm, xmm [AVX]
  • VPMULHW ymm, ymm, ymm [AVX2]
  • VPMULHW m256, ymm, ymm [AVX2]
  • VPMULHW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMULHW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMULHW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMULHW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMULLD 

func (self *Program) VPMULLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULLD performs "Multiply Packed Signed Doubleword Integers and Store Low Result".

Mnemonic : VPMULLD Supported forms : (10 forms)

  • VPMULLD xmm, xmm, xmm [AVX]
  • VPMULLD m128, xmm, xmm [AVX]
  • VPMULLD ymm, ymm, ymm [AVX2]
  • VPMULLD m256, ymm, ymm [AVX2]
  • VPMULLD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMULLD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMULLD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMULLD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMULLD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMULLD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPMULLQ 

func (self *Program) VPMULLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULLQ performs "Multiply Packed Signed Quadword Integers and Store Low Result".

Mnemonic : VPMULLQ Supported forms : (6 forms)

  • VPMULLQ m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VPMULLQ zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VPMULLQ m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VPMULLQ xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VPMULLQ m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VPMULLQ ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VPMULLW 

func (self *Program) VPMULLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULLW performs "Multiply Packed Signed Word Integers and Store Low Result".

Mnemonic : VPMULLW Supported forms : (10 forms)

  • VPMULLW xmm, xmm, xmm [AVX]
  • VPMULLW m128, xmm, xmm [AVX]
  • VPMULLW ymm, ymm, ymm [AVX2]
  • VPMULLW m256, ymm, ymm [AVX2]
  • VPMULLW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPMULLW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPMULLW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULLW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPMULLW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPMULLW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPMULTISHIFTQB 

func (self *Program) VPMULTISHIFTQB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULTISHIFTQB performs "Select Packed Unaligned Bytes from Quadword Sources".

Mnemonic : VPMULTISHIFTQB Supported forms : (6 forms)

  • VPMULTISHIFTQB m128/m64bcst, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPMULTISHIFTQB xmm, xmm, xmm{k}{z} [AVX512VBMI,AVX512VL]
  • VPMULTISHIFTQB m256/m64bcst, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPMULTISHIFTQB ymm, ymm, ymm{k}{z} [AVX512VBMI,AVX512VL]
  • VPMULTISHIFTQB m512/m64bcst, zmm, zmm{k}{z} [AVX512VBMI]
  • VPMULTISHIFTQB zmm, zmm, zmm{k}{z} [AVX512VBMI]

func (*Program) VPMULUDQ 

func (self *Program) VPMULUDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPMULUDQ performs "Multiply Packed Unsigned Doubleword Integers".

Mnemonic : VPMULUDQ Supported forms : (10 forms)

  • VPMULUDQ xmm, xmm, xmm [AVX]
  • VPMULUDQ m128, xmm, xmm [AVX]
  • VPMULUDQ ymm, ymm, ymm [AVX2]
  • VPMULUDQ m256, ymm, ymm [AVX2]
  • VPMULUDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPMULUDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPMULUDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMULUDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPMULUDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPMULUDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPOPCNTD 

func (self *Program) VPOPCNTD(v0 interface{}, v1 interface{}) *Instruction

VPOPCNTD performs "Packed Population Count for Doubleword Integers".

Mnemonic : VPOPCNTD Supported forms : (2 forms)

  • VPOPCNTD m512/m32bcst, zmm{k}{z} [AVX512VPOPCNTDQ]
  • VPOPCNTD zmm, zmm{k}{z} [AVX512VPOPCNTDQ]

func (*Program) VPOPCNTQ 

func (self *Program) VPOPCNTQ(v0 interface{}, v1 interface{}) *Instruction

VPOPCNTQ performs "Packed Population Count for Quadword Integers".

Mnemonic : VPOPCNTQ Supported forms : (2 forms)

  • VPOPCNTQ m512/m64bcst, zmm{k}{z} [AVX512VPOPCNTDQ]
  • VPOPCNTQ zmm, zmm{k}{z} [AVX512VPOPCNTDQ]

func (*Program) VPOR 

func (self *Program) VPOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPOR performs "Packed Bitwise Logical OR".

Mnemonic : VPOR Supported forms : (4 forms)

  • VPOR xmm, xmm, xmm [AVX]
  • VPOR m128, xmm, xmm [AVX]
  • VPOR ymm, ymm, ymm [AVX2]
  • VPOR m256, ymm, ymm [AVX2]

func (*Program) VPORD 

func (self *Program) VPORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPORD performs "Bitwise Logical OR of Packed Doubleword Integers".

Mnemonic : VPORD Supported forms : (6 forms)

  • VPORD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPORD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPORD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPORD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPORD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPORD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPORQ 

func (self *Program) VPORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPORQ performs "Bitwise Logical OR of Packed Quadword Integers".

Mnemonic : VPORQ Supported forms : (6 forms)

  • VPORQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPORQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPORQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPORQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPORQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPORQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPPERM 

func (self *Program) VPPERM(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPPERM performs "Packed Permute Bytes".

Mnemonic : VPPERM Supported forms : (3 forms)

  • VPPERM xmm, xmm, xmm, xmm [XOP]
  • VPPERM m128, xmm, xmm, xmm [XOP]
  • VPPERM xmm, m128, xmm, xmm [XOP]

func (*Program) VPROLD 

func (self *Program) VPROLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLD performs "Rotate Packed Doubleword Left".

Mnemonic : VPROLD Supported forms : (6 forms)

  • VPROLD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPROLD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPROLD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPROLD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPROLQ 

func (self *Program) VPROLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLQ performs "Rotate Packed Quadword Left".

Mnemonic : VPROLQ Supported forms : (6 forms)

  • VPROLQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPROLQ imm8, zmm, zmm{k}{z} [AVX512F]
  • VPROLQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPROLQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPROLVD 

func (self *Program) VPROLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLVD performs "Variable Rotate Packed Doubleword Left".

Mnemonic : VPROLVD Supported forms : (6 forms)

  • VPROLVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPROLVD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPROLVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPROLVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPROLVQ 

func (self *Program) VPROLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROLVQ performs "Variable Rotate Packed Quadword Left".

Mnemonic : VPROLVQ Supported forms : (6 forms)

  • VPROLVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPROLVQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPROLVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPROLVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPROLVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPRORD 

func (self *Program) VPRORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORD performs "Rotate Packed Doubleword Right".

Mnemonic : VPRORD Supported forms : (6 forms)

  • VPRORD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPRORD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPRORD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPRORD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPRORQ 

func (self *Program) VPRORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORQ performs "Rotate Packed Quadword Right".

Mnemonic : VPRORQ Supported forms : (6 forms)

  • VPRORQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPRORQ imm8, zmm, zmm{k}{z} [AVX512F]
  • VPRORQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPRORQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPRORVD 

func (self *Program) VPRORVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORVD performs "Variable Rotate Packed Doubleword Right".

Mnemonic : VPRORVD Supported forms : (6 forms)

  • VPRORVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPRORVD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPRORVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPRORVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPRORVQ 

func (self *Program) VPRORVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPRORVQ performs "Variable Rotate Packed Quadword Right".

Mnemonic : VPRORVQ Supported forms : (6 forms)

  • VPRORVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPRORVQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPRORVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPRORVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPRORVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPROTB 

func (self *Program) VPROTB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTB performs "Packed Rotate Bytes".

Mnemonic : VPROTB Supported forms : (5 forms)

  • VPROTB imm8, xmm, xmm [XOP]
  • VPROTB xmm, xmm, xmm [XOP]
  • VPROTB m128, xmm, xmm [XOP]
  • VPROTB imm8, m128, xmm [XOP]
  • VPROTB xmm, m128, xmm [XOP]

func (*Program) VPROTD 

func (self *Program) VPROTD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTD performs "Packed Rotate Doublewords".

Mnemonic : VPROTD Supported forms : (5 forms)

  • VPROTD imm8, xmm, xmm [XOP]
  • VPROTD xmm, xmm, xmm [XOP]
  • VPROTD m128, xmm, xmm [XOP]
  • VPROTD imm8, m128, xmm [XOP]
  • VPROTD xmm, m128, xmm [XOP]

func (*Program) VPROTQ 

func (self *Program) VPROTQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTQ performs "Packed Rotate Quadwords".

Mnemonic : VPROTQ Supported forms : (5 forms)

  • VPROTQ imm8, xmm, xmm [XOP]
  • VPROTQ xmm, xmm, xmm [XOP]
  • VPROTQ m128, xmm, xmm [XOP]
  • VPROTQ imm8, m128, xmm [XOP]
  • VPROTQ xmm, m128, xmm [XOP]

func (*Program) VPROTW 

func (self *Program) VPROTW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPROTW performs "Packed Rotate Words".

Mnemonic : VPROTW Supported forms : (5 forms)

  • VPROTW imm8, xmm, xmm [XOP]
  • VPROTW xmm, xmm, xmm [XOP]
  • VPROTW m128, xmm, xmm [XOP]
  • VPROTW imm8, m128, xmm [XOP]
  • VPROTW xmm, m128, xmm [XOP]

func (*Program) VPSADBW 

func (self *Program) VPSADBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSADBW performs "Compute Sum of Absolute Differences".

Mnemonic : VPSADBW Supported forms : (10 forms)

  • VPSADBW xmm, xmm, xmm [AVX]
  • VPSADBW m128, xmm, xmm [AVX]
  • VPSADBW ymm, ymm, ymm [AVX2]
  • VPSADBW m256, ymm, ymm [AVX2]
  • VPSADBW zmm, zmm, zmm [AVX512BW]
  • VPSADBW m512, zmm, zmm [AVX512BW]
  • VPSADBW xmm, xmm, xmm [AVX512BW,AVX512VL]
  • VPSADBW m128, xmm, xmm [AVX512BW,AVX512VL]
  • VPSADBW ymm, ymm, ymm [AVX512BW,AVX512VL]
  • VPSADBW m256, ymm, ymm [AVX512BW,AVX512VL]

func (*Program) VPSCATTERDD 

func (self *Program) VPSCATTERDD(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERDD performs "Scatter Packed Doubleword Values with Signed Doubleword Indices".

Mnemonic : VPSCATTERDD Supported forms : (3 forms)

  • VPSCATTERDD zmm, vm32z{k} [AVX512F]
  • VPSCATTERDD xmm, vm32x{k} [AVX512F,AVX512VL]
  • VPSCATTERDD ymm, vm32y{k} [AVX512F,AVX512VL]

func (*Program) VPSCATTERDQ 

func (self *Program) VPSCATTERDQ(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERDQ performs "Scatter Packed Quadword Values with Signed Doubleword Indices".

Mnemonic : VPSCATTERDQ Supported forms : (3 forms)

  • VPSCATTERDQ zmm, vm32y{k} [AVX512F]
  • VPSCATTERDQ xmm, vm32x{k} [AVX512F,AVX512VL]
  • VPSCATTERDQ ymm, vm32x{k} [AVX512F,AVX512VL]

func (*Program) VPSCATTERQD 

func (self *Program) VPSCATTERQD(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERQD performs "Scatter Packed Doubleword Values with Signed Quadword Indices".

Mnemonic : VPSCATTERQD Supported forms : (3 forms)

  • VPSCATTERQD ymm, vm64z{k} [AVX512F]
  • VPSCATTERQD xmm, vm64x{k} [AVX512F,AVX512VL]
  • VPSCATTERQD xmm, vm64y{k} [AVX512F,AVX512VL]

func (*Program) VPSCATTERQQ 

func (self *Program) VPSCATTERQQ(v0 interface{}, v1 interface{}) *Instruction

VPSCATTERQQ performs "Scatter Packed Quadword Values with Signed Quadword Indices".

Mnemonic : VPSCATTERQQ Supported forms : (3 forms)

  • VPSCATTERQQ zmm, vm64z{k} [AVX512F]
  • VPSCATTERQQ xmm, vm64x{k} [AVX512F,AVX512VL]
  • VPSCATTERQQ ymm, vm64y{k} [AVX512F,AVX512VL]

func (*Program) VPSHAB 

func (self *Program) VPSHAB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAB performs "Packed Shift Arithmetic Bytes".

Mnemonic : VPSHAB Supported forms : (3 forms)

  • VPSHAB xmm, xmm, xmm [XOP]
  • VPSHAB m128, xmm, xmm [XOP]
  • VPSHAB xmm, m128, xmm [XOP]

func (*Program) VPSHAD 

func (self *Program) VPSHAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAD performs "Packed Shift Arithmetic Doublewords".

Mnemonic : VPSHAD Supported forms : (3 forms)

  • VPSHAD xmm, xmm, xmm [XOP]
  • VPSHAD m128, xmm, xmm [XOP]
  • VPSHAD xmm, m128, xmm [XOP]

func (*Program) VPSHAQ 

func (self *Program) VPSHAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAQ performs "Packed Shift Arithmetic Quadwords".

Mnemonic : VPSHAQ Supported forms : (3 forms)

  • VPSHAQ xmm, xmm, xmm [XOP]
  • VPSHAQ m128, xmm, xmm [XOP]
  • VPSHAQ xmm, m128, xmm [XOP]

func (*Program) VPSHAW 

func (self *Program) VPSHAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHAW performs "Packed Shift Arithmetic Words".

Mnemonic : VPSHAW Supported forms : (3 forms)

  • VPSHAW xmm, xmm, xmm [XOP]
  • VPSHAW m128, xmm, xmm [XOP]
  • VPSHAW xmm, m128, xmm [XOP]

func (*Program) VPSHLB 

func (self *Program) VPSHLB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLB performs "Packed Shift Logical Bytes".

Mnemonic : VPSHLB Supported forms : (3 forms)

  • VPSHLB xmm, xmm, xmm [XOP]
  • VPSHLB m128, xmm, xmm [XOP]
  • VPSHLB xmm, m128, xmm [XOP]

func (*Program) VPSHLD 

func (self *Program) VPSHLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLD performs "Packed Shift Logical Doublewords".

Mnemonic : VPSHLD Supported forms : (3 forms)

  • VPSHLD xmm, xmm, xmm [XOP]
  • VPSHLD m128, xmm, xmm [XOP]
  • VPSHLD xmm, m128, xmm [XOP]

func (*Program) VPSHLQ 

func (self *Program) VPSHLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLQ performs "Packed Shift Logical Quadwords".

Mnemonic : VPSHLQ Supported forms : (3 forms)

  • VPSHLQ xmm, xmm, xmm [XOP]
  • VPSHLQ m128, xmm, xmm [XOP]
  • VPSHLQ xmm, m128, xmm [XOP]

func (*Program) VPSHLW 

func (self *Program) VPSHLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHLW performs "Packed Shift Logical Words".

Mnemonic : VPSHLW Supported forms : (3 forms)

  • VPSHLW xmm, xmm, xmm [XOP]
  • VPSHLW m128, xmm, xmm [XOP]
  • VPSHLW xmm, m128, xmm [XOP]

func (*Program) VPSHUFB 

func (self *Program) VPSHUFB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFB performs "Packed Shuffle Bytes".

Mnemonic : VPSHUFB Supported forms : (10 forms)

  • VPSHUFB xmm, xmm, xmm [AVX]
  • VPSHUFB m128, xmm, xmm [AVX]
  • VPSHUFB ymm, ymm, ymm [AVX2]
  • VPSHUFB m256, ymm, ymm [AVX2]
  • VPSHUFB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSHUFB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSHUFB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSHUFD 

func (self *Program) VPSHUFD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFD performs "Shuffle Packed Doublewords".

Mnemonic : VPSHUFD Supported forms : (10 forms)

  • VPSHUFD imm8, xmm, xmm [AVX]
  • VPSHUFD imm8, m128, xmm [AVX]
  • VPSHUFD imm8, ymm, ymm [AVX2]
  • VPSHUFD imm8, m256, ymm [AVX2]
  • VPSHUFD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPSHUFD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSHUFD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSHUFD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSHUFD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSHUFD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSHUFHW 

func (self *Program) VPSHUFHW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFHW performs "Shuffle Packed High Words".

Mnemonic : VPSHUFHW Supported forms : (10 forms)

  • VPSHUFHW imm8, xmm, xmm [AVX]
  • VPSHUFHW imm8, m128, xmm [AVX]
  • VPSHUFHW imm8, ymm, ymm [AVX2]
  • VPSHUFHW imm8, m256, ymm [AVX2]
  • VPSHUFHW imm8, zmm, zmm{k}{z} [AVX512BW]
  • VPSHUFHW imm8, m512, zmm{k}{z} [AVX512BW]
  • VPSHUFHW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFHW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFHW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFHW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSHUFLW 

func (self *Program) VPSHUFLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSHUFLW performs "Shuffle Packed Low Words".

Mnemonic : VPSHUFLW Supported forms : (10 forms)

  • VPSHUFLW imm8, xmm, xmm [AVX]
  • VPSHUFLW imm8, m128, xmm [AVX]
  • VPSHUFLW imm8, ymm, ymm [AVX2]
  • VPSHUFLW imm8, m256, ymm [AVX2]
  • VPSHUFLW imm8, zmm, zmm{k}{z} [AVX512BW]
  • VPSHUFLW imm8, m512, zmm{k}{z} [AVX512BW]
  • VPSHUFLW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFLW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFLW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSHUFLW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSIGNB 

func (self *Program) VPSIGNB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSIGNB performs "Packed Sign of Byte Integers".

Mnemonic : VPSIGNB Supported forms : (4 forms)

  • VPSIGNB xmm, xmm, xmm [AVX]
  • VPSIGNB m128, xmm, xmm [AVX]
  • VPSIGNB ymm, ymm, ymm [AVX2]
  • VPSIGNB m256, ymm, ymm [AVX2]

func (*Program) VPSIGND 

func (self *Program) VPSIGND(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSIGND performs "Packed Sign of Doubleword Integers".

Mnemonic : VPSIGND Supported forms : (4 forms)

  • VPSIGND xmm, xmm, xmm [AVX]
  • VPSIGND m128, xmm, xmm [AVX]
  • VPSIGND ymm, ymm, ymm [AVX2]
  • VPSIGND m256, ymm, ymm [AVX2]

func (*Program) VPSIGNW 

func (self *Program) VPSIGNW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSIGNW performs "Packed Sign of Word Integers".

Mnemonic : VPSIGNW Supported forms : (4 forms)

  • VPSIGNW xmm, xmm, xmm [AVX]
  • VPSIGNW m128, xmm, xmm [AVX]
  • VPSIGNW ymm, ymm, ymm [AVX2]
  • VPSIGNW m256, ymm, ymm [AVX2]

func (*Program) VPSLLD 

func (self *Program) VPSLLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLD performs "Shift Packed Doubleword Data Left Logical".

Mnemonic : VPSLLD Supported forms : (18 forms)

  • VPSLLD imm8, xmm, xmm [AVX]
  • VPSLLD xmm, xmm, xmm [AVX]
  • VPSLLD m128, xmm, xmm [AVX]
  • VPSLLD imm8, ymm, ymm [AVX2]
  • VPSLLD xmm, ymm, ymm [AVX2]
  • VPSLLD m128, ymm, ymm [AVX2]
  • VPSLLD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPSLLD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSLLD xmm, zmm, zmm{k}{z} [AVX512F]
  • VPSLLD m128, zmm, zmm{k}{z} [AVX512F]
  • VPSLLD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLD m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSLLDQ 

func (self *Program) VPSLLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLDQ performs "Shift Packed Double Quadword Left Logical".

Mnemonic : VPSLLDQ Supported forms : (8 forms)

  • VPSLLDQ imm8, xmm, xmm [AVX]
  • VPSLLDQ imm8, ymm, ymm [AVX2]
  • VPSLLDQ imm8, zmm, zmm [AVX512BW]
  • VPSLLDQ imm8, m512, zmm [AVX512BW]
  • VPSLLDQ imm8, xmm, xmm [AVX512BW,AVX512VL]
  • VPSLLDQ imm8, m128, xmm [AVX512BW,AVX512VL]
  • VPSLLDQ imm8, ymm, ymm [AVX512BW,AVX512VL]
  • VPSLLDQ imm8, m256, ymm [AVX512BW,AVX512VL]

func (*Program) VPSLLQ 

func (self *Program) VPSLLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLQ performs "Shift Packed Quadword Data Left Logical".

Mnemonic : VPSLLQ Supported forms : (18 forms)

  • VPSLLQ imm8, xmm, xmm [AVX]
  • VPSLLQ xmm, xmm, xmm [AVX]
  • VPSLLQ m128, xmm, xmm [AVX]
  • VPSLLQ imm8, ymm, ymm [AVX2]
  • VPSLLQ xmm, ymm, ymm [AVX2]
  • VPSLLQ m128, ymm, ymm [AVX2]
  • VPSLLQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPSLLQ imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSLLQ xmm, zmm, zmm{k}{z} [AVX512F]
  • VPSLLQ m128, zmm, zmm{k}{z} [AVX512F]
  • VPSLLQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLQ m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSLLVD 

func (self *Program) VPSLLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLVD performs "Variable Shift Packed Doubleword Data Left Logical".

Mnemonic : VPSLLVD Supported forms : (10 forms)

  • VPSLLVD xmm, xmm, xmm [AVX2]
  • VPSLLVD m128, xmm, xmm [AVX2]
  • VPSLLVD ymm, ymm, ymm [AVX2]
  • VPSLLVD m256, ymm, ymm [AVX2]
  • VPSLLVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSLLVD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSLLVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSLLVQ 

func (self *Program) VPSLLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLVQ performs "Variable Shift Packed Quadword Data Left Logical".

Mnemonic : VPSLLVQ Supported forms : (10 forms)

  • VPSLLVQ xmm, xmm, xmm [AVX2]
  • VPSLLVQ m128, xmm, xmm [AVX2]
  • VPSLLVQ ymm, ymm, ymm [AVX2]
  • VPSLLVQ m256, ymm, ymm [AVX2]
  • VPSLLVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSLLVQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSLLVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSLLVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSLLVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSLLVW 

func (self *Program) VPSLLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLVW performs "Variable Shift Packed Word Data Left Logical".

Mnemonic : VPSLLVW Supported forms : (6 forms)

  • VPSLLVW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSLLVW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSLLVW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLVW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLVW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLVW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSLLW 

func (self *Program) VPSLLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSLLW performs "Shift Packed Word Data Left Logical".

Mnemonic : VPSLLW Supported forms : (18 forms)

  • VPSLLW imm8, xmm, xmm [AVX]
  • VPSLLW xmm, xmm, xmm [AVX]
  • VPSLLW m128, xmm, xmm [AVX]
  • VPSLLW imm8, ymm, ymm [AVX2]
  • VPSLLW xmm, ymm, ymm [AVX2]
  • VPSLLW m128, ymm, ymm [AVX2]
  • VPSLLW imm8, zmm, zmm{k}{z} [AVX512BW]
  • VPSLLW xmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSLLW m128, zmm, zmm{k}{z} [AVX512BW]
  • VPSLLW imm8, m512, zmm{k}{z} [AVX512BW]
  • VPSLLW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW xmm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW m128, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSLLW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSRAD 

func (self *Program) VPSRAD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAD performs "Shift Packed Doubleword Data Right Arithmetic".

Mnemonic : VPSRAD Supported forms : (18 forms)

  • VPSRAD imm8, xmm, xmm [AVX]
  • VPSRAD xmm, xmm, xmm [AVX]
  • VPSRAD m128, xmm, xmm [AVX]
  • VPSRAD imm8, ymm, ymm [AVX2]
  • VPSRAD xmm, ymm, ymm [AVX2]
  • VPSRAD m128, ymm, ymm [AVX2]
  • VPSRAD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPSRAD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSRAD xmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRAD m128, zmm, zmm{k}{z} [AVX512F]
  • VPSRAD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAD m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRAQ 

func (self *Program) VPSRAQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAQ performs "Shift Packed Quadword Data Right Arithmetic".

Mnemonic : VPSRAQ Supported forms : (12 forms)

  • VPSRAQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPSRAQ imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSRAQ xmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRAQ m128, zmm, zmm{k}{z} [AVX512F]
  • VPSRAQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAQ m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRAVD 

func (self *Program) VPSRAVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAVD performs "Variable Shift Packed Doubleword Data Right Arithmetic".

Mnemonic : VPSRAVD Supported forms : (10 forms)

  • VPSRAVD xmm, xmm, xmm [AVX2]
  • VPSRAVD m128, xmm, xmm [AVX2]
  • VPSRAVD ymm, ymm, ymm [AVX2]
  • VPSRAVD m256, ymm, ymm [AVX2]
  • VPSRAVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSRAVD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRAVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRAVQ 

func (self *Program) VPSRAVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAVQ performs "Variable Shift Packed Quadword Data Right Arithmetic".

Mnemonic : VPSRAVQ Supported forms : (6 forms)

  • VPSRAVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSRAVQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRAVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRAVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRAVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRAVW 

func (self *Program) VPSRAVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAVW performs "Variable Shift Packed Word Data Right Arithmetic".

Mnemonic : VPSRAVW Supported forms : (6 forms)

  • VPSRAVW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSRAVW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSRAVW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAVW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAVW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAVW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSRAW 

func (self *Program) VPSRAW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRAW performs "Shift Packed Word Data Right Arithmetic".

Mnemonic : VPSRAW Supported forms : (18 forms)

  • VPSRAW imm8, xmm, xmm [AVX]
  • VPSRAW xmm, xmm, xmm [AVX]
  • VPSRAW m128, xmm, xmm [AVX]
  • VPSRAW imm8, ymm, ymm [AVX2]
  • VPSRAW xmm, ymm, ymm [AVX2]
  • VPSRAW m128, ymm, ymm [AVX2]
  • VPSRAW imm8, zmm, zmm{k}{z} [AVX512BW]
  • VPSRAW xmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSRAW m128, zmm, zmm{k}{z} [AVX512BW]
  • VPSRAW imm8, m512, zmm{k}{z} [AVX512BW]
  • VPSRAW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW xmm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW m128, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRAW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSRLD 

func (self *Program) VPSRLD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLD performs "Shift Packed Doubleword Data Right Logical".

Mnemonic : VPSRLD Supported forms : (18 forms)

  • VPSRLD imm8, xmm, xmm [AVX]
  • VPSRLD xmm, xmm, xmm [AVX]
  • VPSRLD m128, xmm, xmm [AVX]
  • VPSRLD imm8, ymm, ymm [AVX2]
  • VPSRLD xmm, ymm, ymm [AVX2]
  • VPSRLD m128, ymm, ymm [AVX2]
  • VPSRLD imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VPSRLD imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSRLD xmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRLD m128, zmm, zmm{k}{z} [AVX512F]
  • VPSRLD imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLD m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRLDQ 

func (self *Program) VPSRLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLDQ performs "Shift Packed Double Quadword Right Logical".

Mnemonic : VPSRLDQ Supported forms : (8 forms)

  • VPSRLDQ imm8, xmm, xmm [AVX]
  • VPSRLDQ imm8, ymm, ymm [AVX2]
  • VPSRLDQ imm8, zmm, zmm [AVX512BW]
  • VPSRLDQ imm8, m512, zmm [AVX512BW]
  • VPSRLDQ imm8, xmm, xmm [AVX512BW,AVX512VL]
  • VPSRLDQ imm8, m128, xmm [AVX512BW,AVX512VL]
  • VPSRLDQ imm8, ymm, ymm [AVX512BW,AVX512VL]
  • VPSRLDQ imm8, m256, ymm [AVX512BW,AVX512VL]

func (*Program) VPSRLQ 

func (self *Program) VPSRLQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLQ performs "Shift Packed Quadword Data Right Logical".

Mnemonic : VPSRLQ Supported forms : (18 forms)

  • VPSRLQ imm8, xmm, xmm [AVX]
  • VPSRLQ xmm, xmm, xmm [AVX]
  • VPSRLQ m128, xmm, xmm [AVX]
  • VPSRLQ imm8, ymm, ymm [AVX2]
  • VPSRLQ xmm, ymm, ymm [AVX2]
  • VPSRLQ m128, ymm, ymm [AVX2]
  • VPSRLQ imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VPSRLQ imm8, zmm, zmm{k}{z} [AVX512F]
  • VPSRLQ xmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRLQ m128, zmm, zmm{k}{z} [AVX512F]
  • VPSRLQ imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ m128, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ xmm, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLQ m128, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRLVD 

func (self *Program) VPSRLVD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLVD performs "Variable Shift Packed Doubleword Data Right Logical".

Mnemonic : VPSRLVD Supported forms : (10 forms)

  • VPSRLVD xmm, xmm, xmm [AVX2]
  • VPSRLVD m128, xmm, xmm [AVX2]
  • VPSRLVD ymm, ymm, ymm [AVX2]
  • VPSRLVD m256, ymm, ymm [AVX2]
  • VPSRLVD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSRLVD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRLVD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLVD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLVD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLVD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRLVQ 

func (self *Program) VPSRLVQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLVQ performs "Variable Shift Packed Quadword Data Right Logical".

Mnemonic : VPSRLVQ Supported forms : (10 forms)

  • VPSRLVQ xmm, xmm, xmm [AVX2]
  • VPSRLVQ m128, xmm, xmm [AVX2]
  • VPSRLVQ ymm, ymm, ymm [AVX2]
  • VPSRLVQ m256, ymm, ymm [AVX2]
  • VPSRLVQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSRLVQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSRLVQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLVQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSRLVQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSRLVQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSRLVW 

func (self *Program) VPSRLVW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLVW performs "Variable Shift Packed Word Data Right Logical".

Mnemonic : VPSRLVW Supported forms : (6 forms)

  • VPSRLVW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSRLVW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSRLVW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLVW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLVW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLVW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSRLW 

func (self *Program) VPSRLW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSRLW performs "Shift Packed Word Data Right Logical".

Mnemonic : VPSRLW Supported forms : (18 forms)

  • VPSRLW imm8, xmm, xmm [AVX]
  • VPSRLW xmm, xmm, xmm [AVX]
  • VPSRLW m128, xmm, xmm [AVX]
  • VPSRLW imm8, ymm, ymm [AVX2]
  • VPSRLW xmm, ymm, ymm [AVX2]
  • VPSRLW m128, ymm, ymm [AVX2]
  • VPSRLW imm8, zmm, zmm{k}{z} [AVX512BW]
  • VPSRLW xmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSRLW m128, zmm, zmm{k}{z} [AVX512BW]
  • VPSRLW imm8, m512, zmm{k}{z} [AVX512BW]
  • VPSRLW imm8, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW imm8, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW xmm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW m128, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW imm8, m128, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSRLW imm8, m256, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSUBB 

func (self *Program) VPSUBB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBB performs "Subtract Packed Byte Integers".

Mnemonic : VPSUBB Supported forms : (10 forms)

  • VPSUBB xmm, xmm, xmm [AVX]
  • VPSUBB m128, xmm, xmm [AVX]
  • VPSUBB ymm, ymm, ymm [AVX2]
  • VPSUBB m256, ymm, ymm [AVX2]
  • VPSUBB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSUBD 

func (self *Program) VPSUBD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBD performs "Subtract Packed Doubleword Integers".

Mnemonic : VPSUBD Supported forms : (10 forms)

  • VPSUBD xmm, xmm, xmm [AVX]
  • VPSUBD m128, xmm, xmm [AVX]
  • VPSUBD ymm, ymm, ymm [AVX2]
  • VPSUBD m256, ymm, ymm [AVX2]
  • VPSUBD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSUBD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSUBD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSUBD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSUBD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSUBD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSUBQ 

func (self *Program) VPSUBQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBQ performs "Subtract Packed Quadword Integers".

Mnemonic : VPSUBQ Supported forms : (10 forms)

  • VPSUBQ xmm, xmm, xmm [AVX]
  • VPSUBQ m128, xmm, xmm [AVX]
  • VPSUBQ ymm, ymm, ymm [AVX2]
  • VPSUBQ m256, ymm, ymm [AVX2]
  • VPSUBQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPSUBQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPSUBQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSUBQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPSUBQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPSUBQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPSUBSB 

func (self *Program) VPSUBSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBSB performs "Subtract Packed Signed Byte Integers with Signed Saturation".

Mnemonic : VPSUBSB Supported forms : (10 forms)

  • VPSUBSB xmm, xmm, xmm [AVX]
  • VPSUBSB m128, xmm, xmm [AVX]
  • VPSUBSB ymm, ymm, ymm [AVX2]
  • VPSUBSB m256, ymm, ymm [AVX2]
  • VPSUBSB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBSB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSUBSW 

func (self *Program) VPSUBSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBSW performs "Subtract Packed Signed Word Integers with Signed Saturation".

Mnemonic : VPSUBSW Supported forms : (10 forms)

  • VPSUBSW xmm, xmm, xmm [AVX]
  • VPSUBSW m128, xmm, xmm [AVX]
  • VPSUBSW ymm, ymm, ymm [AVX2]
  • VPSUBSW m256, ymm, ymm [AVX2]
  • VPSUBSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSUBUSB 

func (self *Program) VPSUBUSB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBUSB performs "Subtract Packed Unsigned Byte Integers with Unsigned Saturation".

Mnemonic : VPSUBUSB Supported forms : (10 forms)

  • VPSUBUSB xmm, xmm, xmm [AVX]
  • VPSUBUSB m128, xmm, xmm [AVX]
  • VPSUBUSB ymm, ymm, ymm [AVX2]
  • VPSUBUSB m256, ymm, ymm [AVX2]
  • VPSUBUSB zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBUSB m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBUSB xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBUSB m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBUSB ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBUSB m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSUBUSW 

func (self *Program) VPSUBUSW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBUSW performs "Subtract Packed Unsigned Word Integers with Unsigned Saturation".

Mnemonic : VPSUBUSW Supported forms : (10 forms)

  • VPSUBUSW xmm, xmm, xmm [AVX]
  • VPSUBUSW m128, xmm, xmm [AVX]
  • VPSUBUSW ymm, ymm, ymm [AVX2]
  • VPSUBUSW m256, ymm, ymm [AVX2]
  • VPSUBUSW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBUSW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBUSW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBUSW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBUSW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBUSW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPSUBW 

func (self *Program) VPSUBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPSUBW performs "Subtract Packed Word Integers".

Mnemonic : VPSUBW Supported forms : (10 forms)

  • VPSUBW xmm, xmm, xmm [AVX]
  • VPSUBW m128, xmm, xmm [AVX]
  • VPSUBW ymm, ymm, ymm [AVX2]
  • VPSUBW m256, ymm, ymm [AVX2]
  • VPSUBW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPSUBW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPSUBW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPTERNLOGD 

func (self *Program) VPTERNLOGD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPTERNLOGD performs "Bitwise Ternary Logical Operation on Doubleword Values".

Mnemonic : VPTERNLOGD Supported forms : (6 forms)

  • VPTERNLOGD imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPTERNLOGD imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VPTERNLOGD imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPTERNLOGD imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPTERNLOGD imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPTERNLOGD imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPTERNLOGQ 

func (self *Program) VPTERNLOGQ(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VPTERNLOGQ performs "Bitwise Ternary Logical Operation on Quadword Values".

Mnemonic : VPTERNLOGQ Supported forms : (6 forms)

  • VPTERNLOGQ imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPTERNLOGQ imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VPTERNLOGQ imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPTERNLOGQ imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPTERNLOGQ imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPTERNLOGQ imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPTEST 

func (self *Program) VPTEST(v0 interface{}, v1 interface{}) *Instruction

VPTEST performs "Packed Logical Compare".

Mnemonic : VPTEST Supported forms : (4 forms)

  • VPTEST xmm, xmm [AVX]
  • VPTEST m128, xmm [AVX]
  • VPTEST ymm, ymm [AVX]
  • VPTEST m256, ymm [AVX]

func (*Program) VPTESTMB 

func (self *Program) VPTESTMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMB performs "Logical AND of Packed Byte Integer Values and Set Mask".

Mnemonic : VPTESTMB Supported forms : (6 forms)

  • VPTESTMB zmm, zmm, k{k} [AVX512BW]
  • VPTESTMB m512, zmm, k{k} [AVX512BW]
  • VPTESTMB xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTMB m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTMB ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPTESTMB m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPTESTMD 

func (self *Program) VPTESTMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMD performs "Logical AND of Packed Doubleword Integer Values and Set Mask".

Mnemonic : VPTESTMD Supported forms : (6 forms)

  • VPTESTMD m512/m32bcst, zmm, k{k} [AVX512F]
  • VPTESTMD zmm, zmm, k{k} [AVX512F]
  • VPTESTMD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTMD xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTMD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPTESTMD ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPTESTMQ 

func (self *Program) VPTESTMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMQ performs "Logical AND of Packed Quadword Integer Values and Set Mask".

Mnemonic : VPTESTMQ Supported forms : (6 forms)

  • VPTESTMQ m512/m64bcst, zmm, k{k} [AVX512F]
  • VPTESTMQ zmm, zmm, k{k} [AVX512F]
  • VPTESTMQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTMQ xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTMQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPTESTMQ ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPTESTMW 

func (self *Program) VPTESTMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTMW performs "Logical AND of Packed Word Integer Values and Set Mask".

Mnemonic : VPTESTMW Supported forms : (6 forms)

  • VPTESTMW zmm, zmm, k{k} [AVX512BW]
  • VPTESTMW m512, zmm, k{k} [AVX512BW]
  • VPTESTMW xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTMW m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTMW ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPTESTMW m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPTESTNMB 

func (self *Program) VPTESTNMB(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMB performs "Logical NAND of Packed Byte Integer Values and Set Mask".

Mnemonic : VPTESTNMB Supported forms : (6 forms)

  • VPTESTNMB zmm, zmm, k{k} [AVX512BW,AVX512F]
  • VPTESTNMB m512, zmm, k{k} [AVX512BW,AVX512F]
  • VPTESTNMB xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTNMB m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTNMB ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPTESTNMB m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPTESTNMD 

func (self *Program) VPTESTNMD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMD performs "Logical NAND of Packed Doubleword Integer Values and Set Mask".

Mnemonic : VPTESTNMD Supported forms : (6 forms)

  • VPTESTNMD m512/m32bcst, zmm, k{k} [AVX512F]
  • VPTESTNMD zmm, zmm, k{k} [AVX512F]
  • VPTESTNMD m128/m32bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTNMD xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTNMD m256/m32bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPTESTNMD ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPTESTNMQ 

func (self *Program) VPTESTNMQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMQ performs "Logical NAND of Packed Quadword Integer Values and Set Mask".

Mnemonic : VPTESTNMQ Supported forms : (6 forms)

  • VPTESTNMQ m512/m64bcst, zmm, k{k} [AVX512F]
  • VPTESTNMQ zmm, zmm, k{k} [AVX512F]
  • VPTESTNMQ m128/m64bcst, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTNMQ xmm, xmm, k{k} [AVX512F,AVX512VL]
  • VPTESTNMQ m256/m64bcst, ymm, k{k} [AVX512F,AVX512VL]
  • VPTESTNMQ ymm, ymm, k{k} [AVX512F,AVX512VL]

func (*Program) VPTESTNMW 

func (self *Program) VPTESTNMW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPTESTNMW performs "Logical NAND of Packed Word Integer Values and Set Mask".

Mnemonic : VPTESTNMW Supported forms : (6 forms)

  • VPTESTNMW zmm, zmm, k{k} [AVX512BW,AVX512F]
  • VPTESTNMW m512, zmm, k{k} [AVX512BW,AVX512F]
  • VPTESTNMW xmm, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTNMW m128, xmm, k{k} [AVX512BW,AVX512VL]
  • VPTESTNMW ymm, ymm, k{k} [AVX512BW,AVX512VL]
  • VPTESTNMW m256, ymm, k{k} [AVX512BW,AVX512VL]

func (*Program) VPUNPCKHBW 

func (self *Program) VPUNPCKHBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHBW performs "Unpack and Interleave High-Order Bytes into Words".

Mnemonic : VPUNPCKHBW Supported forms : (10 forms)

  • VPUNPCKHBW xmm, xmm, xmm [AVX]
  • VPUNPCKHBW m128, xmm, xmm [AVX]
  • VPUNPCKHBW ymm, ymm, ymm [AVX2]
  • VPUNPCKHBW m256, ymm, ymm [AVX2]
  • VPUNPCKHBW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKHBW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKHBW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKHBW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKHBW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKHBW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPUNPCKHDQ 

func (self *Program) VPUNPCKHDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHDQ performs "Unpack and Interleave High-Order Doublewords into Quadwords".

Mnemonic : VPUNPCKHDQ Supported forms : (10 forms)

  • VPUNPCKHDQ xmm, xmm, xmm [AVX]
  • VPUNPCKHDQ m128, xmm, xmm [AVX]
  • VPUNPCKHDQ ymm, ymm, ymm [AVX2]
  • VPUNPCKHDQ m256, ymm, ymm [AVX2]
  • VPUNPCKHDQ m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKHDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKHDQ m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKHDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKHDQ m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKHDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPUNPCKHQDQ 

func (self *Program) VPUNPCKHQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHQDQ performs "Unpack and Interleave High-Order Quadwords into Double Quadwords".

Mnemonic : VPUNPCKHQDQ Supported forms : (10 forms)

  • VPUNPCKHQDQ xmm, xmm, xmm [AVX]
  • VPUNPCKHQDQ m128, xmm, xmm [AVX]
  • VPUNPCKHQDQ ymm, ymm, ymm [AVX2]
  • VPUNPCKHQDQ m256, ymm, ymm [AVX2]
  • VPUNPCKHQDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKHQDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKHQDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKHQDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKHQDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKHQDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPUNPCKHWD 

func (self *Program) VPUNPCKHWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKHWD performs "Unpack and Interleave High-Order Words into Doublewords".

Mnemonic : VPUNPCKHWD Supported forms : (10 forms)

  • VPUNPCKHWD xmm, xmm, xmm [AVX]
  • VPUNPCKHWD m128, xmm, xmm [AVX]
  • VPUNPCKHWD ymm, ymm, ymm [AVX2]
  • VPUNPCKHWD m256, ymm, ymm [AVX2]
  • VPUNPCKHWD zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKHWD m512, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKHWD xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKHWD m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKHWD ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKHWD m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPUNPCKLBW 

func (self *Program) VPUNPCKLBW(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLBW performs "Unpack and Interleave Low-Order Bytes into Words".

Mnemonic : VPUNPCKLBW Supported forms : (10 forms)

  • VPUNPCKLBW xmm, xmm, xmm [AVX]
  • VPUNPCKLBW m128, xmm, xmm [AVX]
  • VPUNPCKLBW ymm, ymm, ymm [AVX2]
  • VPUNPCKLBW m256, ymm, ymm [AVX2]
  • VPUNPCKLBW zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKLBW m512, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKLBW xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKLBW m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKLBW ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKLBW m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPUNPCKLDQ 

func (self *Program) VPUNPCKLDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLDQ performs "Unpack and Interleave Low-Order Doublewords into Quadwords".

Mnemonic : VPUNPCKLDQ Supported forms : (10 forms)

  • VPUNPCKLDQ xmm, xmm, xmm [AVX]
  • VPUNPCKLDQ m128, xmm, xmm [AVX]
  • VPUNPCKLDQ ymm, ymm, ymm [AVX2]
  • VPUNPCKLDQ m256, ymm, ymm [AVX2]
  • VPUNPCKLDQ m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKLDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKLDQ m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKLDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKLDQ m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKLDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPUNPCKLQDQ 

func (self *Program) VPUNPCKLQDQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLQDQ performs "Unpack and Interleave Low-Order Quadwords into Double Quadwords".

Mnemonic : VPUNPCKLQDQ Supported forms : (10 forms)

  • VPUNPCKLQDQ xmm, xmm, xmm [AVX]
  • VPUNPCKLQDQ m128, xmm, xmm [AVX]
  • VPUNPCKLQDQ ymm, ymm, ymm [AVX2]
  • VPUNPCKLQDQ m256, ymm, ymm [AVX2]
  • VPUNPCKLQDQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKLQDQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPUNPCKLQDQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKLQDQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKLQDQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPUNPCKLQDQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPUNPCKLWD 

func (self *Program) VPUNPCKLWD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPUNPCKLWD performs "Unpack and Interleave Low-Order Words into Doublewords".

Mnemonic : VPUNPCKLWD Supported forms : (10 forms)

  • VPUNPCKLWD xmm, xmm, xmm [AVX]
  • VPUNPCKLWD m128, xmm, xmm [AVX]
  • VPUNPCKLWD ymm, ymm, ymm [AVX2]
  • VPUNPCKLWD m256, ymm, ymm [AVX2]
  • VPUNPCKLWD zmm, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKLWD m512, zmm, zmm{k}{z} [AVX512BW]
  • VPUNPCKLWD xmm, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKLWD m128, xmm, xmm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKLWD ymm, ymm, ymm{k}{z} [AVX512BW,AVX512VL]
  • VPUNPCKLWD m256, ymm, ymm{k}{z} [AVX512BW,AVX512VL]

func (*Program) VPXOR 

func (self *Program) VPXOR(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPXOR performs "Packed Bitwise Logical Exclusive OR".

Mnemonic : VPXOR Supported forms : (4 forms)

  • VPXOR xmm, xmm, xmm [AVX]
  • VPXOR m128, xmm, xmm [AVX]
  • VPXOR ymm, ymm, ymm [AVX2]
  • VPXOR m256, ymm, ymm [AVX2]

func (*Program) VPXORD 

func (self *Program) VPXORD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPXORD performs "Bitwise Logical Exclusive OR of Packed Doubleword Integers".

Mnemonic : VPXORD Supported forms : (6 forms)

  • VPXORD m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VPXORD zmm, zmm, zmm{k}{z} [AVX512F]
  • VPXORD m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPXORD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPXORD m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPXORD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VPXORQ 

func (self *Program) VPXORQ(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VPXORQ performs "Bitwise Logical Exclusive OR of Packed Quadword Integers".

Mnemonic : VPXORQ Supported forms : (6 forms)

  • VPXORQ m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VPXORQ zmm, zmm, zmm{k}{z} [AVX512F]
  • VPXORQ m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPXORQ xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VPXORQ m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VPXORQ ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRANGEPD 

func (self *Program) VRANGEPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGEPD performs "Range Restriction Calculation For Packed Pairs of Double-Precision Floating-Point Values".

Mnemonic : VRANGEPD Supported forms : (7 forms)

  • VRANGEPD imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VRANGEPD imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VRANGEPD imm8, zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VRANGEPD imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VRANGEPD imm8, xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VRANGEPD imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VRANGEPD imm8, ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VRANGEPS 

func (self *Program) VRANGEPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGEPS performs "Range Restriction Calculation For Packed Pairs of Single-Precision Floating-Point Values".

Mnemonic : VRANGEPS Supported forms : (7 forms)

  • VRANGEPS imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VRANGEPS imm8, {sae}, zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VRANGEPS imm8, zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VRANGEPS imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VRANGEPS imm8, xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VRANGEPS imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VRANGEPS imm8, ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VRANGESD 

func (self *Program) VRANGESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGESD performs "Range Restriction Calculation For a pair of Scalar Double-Precision Floating-Point Values".

Mnemonic : VRANGESD Supported forms : (3 forms)

  • VRANGESD imm8, m64, xmm, xmm{k}{z} [AVX512DQ]
  • VRANGESD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512DQ]
  • VRANGESD imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]

func (*Program) VRANGESS 

func (self *Program) VRANGESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRANGESS performs "Range Restriction Calculation For a pair of Scalar Single-Precision Floating-Point Values".

Mnemonic : VRANGESS Supported forms : (3 forms)

  • VRANGESS imm8, m32, xmm, xmm{k}{z} [AVX512DQ]
  • VRANGESS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512DQ]
  • VRANGESS imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]

func (*Program) VRCP14PD 

func (self *Program) VRCP14PD(v0 interface{}, v1 interface{}) *Instruction

VRCP14PD performs "Compute Approximate Reciprocals of Packed Double-Precision Floating-Point Values".

Mnemonic : VRCP14PD Supported forms : (6 forms)

  • VRCP14PD m512/m64bcst, zmm{k}{z} [AVX512F]
  • VRCP14PD zmm, zmm{k}{z} [AVX512F]
  • VRCP14PD m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VRCP14PD m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VRCP14PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VRCP14PD ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRCP14PS 

func (self *Program) VRCP14PS(v0 interface{}, v1 interface{}) *Instruction

VRCP14PS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".

Mnemonic : VRCP14PS Supported forms : (6 forms)

  • VRCP14PS m512/m32bcst, zmm{k}{z} [AVX512F]
  • VRCP14PS zmm, zmm{k}{z} [AVX512F]
  • VRCP14PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VRCP14PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VRCP14PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VRCP14PS ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRCP14SD 

func (self *Program) VRCP14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRCP14SD performs "Compute Approximate Reciprocal of a Scalar Double-Precision Floating-Point Value".

Mnemonic : VRCP14SD Supported forms : (2 forms)

  • VRCP14SD xmm, xmm, xmm{k}{z} [AVX512F]
  • VRCP14SD m64, xmm, xmm{k}{z} [AVX512F]

func (*Program) VRCP14SS 

func (self *Program) VRCP14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRCP14SS performs "Compute Approximate Reciprocal of a Scalar Single-Precision Floating-Point Value".

Mnemonic : VRCP14SS Supported forms : (2 forms)

  • VRCP14SS xmm, xmm, xmm{k}{z} [AVX512F]
  • VRCP14SS m32, xmm, xmm{k}{z} [AVX512F]

func (*Program) VRCP28PD 

func (self *Program) VRCP28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRCP28PD performs "Approximation to the Reciprocal of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28PD Supported forms : (3 forms)

  • VRCP28PD m512/m64bcst, zmm{k}{z} [AVX512ER]
  • VRCP28PD {sae}, zmm, zmm{k}{z} [AVX512ER]
  • VRCP28PD zmm, zmm{k}{z} [AVX512ER]

func (*Program) VRCP28PS 

func (self *Program) VRCP28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRCP28PS performs "Approximation to the Reciprocal of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28PS Supported forms : (3 forms)

  • VRCP28PS m512/m32bcst, zmm{k}{z} [AVX512ER]
  • VRCP28PS {sae}, zmm, zmm{k}{z} [AVX512ER]
  • VRCP28PS zmm, zmm{k}{z} [AVX512ER]

func (*Program) VRCP28SD 

func (self *Program) VRCP28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRCP28SD performs "Approximation to the Reciprocal of a Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28SD Supported forms : (3 forms)

  • VRCP28SD m64, xmm, xmm{k}{z} [AVX512ER]
  • VRCP28SD {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
  • VRCP28SD xmm, xmm, xmm{k}{z} [AVX512ER]

func (*Program) VRCP28SS 

func (self *Program) VRCP28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRCP28SS performs "Approximation to the Reciprocal of a Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRCP28SS Supported forms : (3 forms)

  • VRCP28SS m32, xmm, xmm{k}{z} [AVX512ER]
  • VRCP28SS {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
  • VRCP28SS xmm, xmm, xmm{k}{z} [AVX512ER]

func (*Program) VRCPPS 

func (self *Program) VRCPPS(v0 interface{}, v1 interface{}) *Instruction

VRCPPS performs "Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values".

Mnemonic : VRCPPS Supported forms : (4 forms)

  • VRCPPS xmm, xmm [AVX]
  • VRCPPS m128, xmm [AVX]
  • VRCPPS ymm, ymm [AVX]
  • VRCPPS m256, ymm [AVX]

func (*Program) VRCPSS 

func (self *Program) VRCPSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRCPSS performs "Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values".

Mnemonic : VRCPSS Supported forms : (2 forms)

  • VRCPSS xmm, xmm, xmm [AVX]
  • VRCPSS m32, xmm, xmm [AVX]

func (*Program) VREDUCEPD 

func (self *Program) VREDUCEPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VREDUCEPD performs "Perform Reduction Transformation on Packed Double-Precision Floating-Point Values".

Mnemonic : VREDUCEPD Supported forms : (6 forms)

  • VREDUCEPD imm8, m512/m64bcst, zmm{k}{z} [AVX512DQ]
  • VREDUCEPD imm8, zmm, zmm{k}{z} [AVX512DQ]
  • VREDUCEPD imm8, m128/m64bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VREDUCEPD imm8, m256/m64bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VREDUCEPD imm8, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VREDUCEPD imm8, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VREDUCEPS 

func (self *Program) VREDUCEPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VREDUCEPS performs "Perform Reduction Transformation on Packed Single-Precision Floating-Point Values".

Mnemonic : VREDUCEPS Supported forms : (6 forms)

  • VREDUCEPS imm8, m512/m32bcst, zmm{k}{z} [AVX512DQ]
  • VREDUCEPS imm8, zmm, zmm{k}{z} [AVX512DQ]
  • VREDUCEPS imm8, m128/m32bcst, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VREDUCEPS imm8, m256/m32bcst, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VREDUCEPS imm8, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VREDUCEPS imm8, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VREDUCESD 

func (self *Program) VREDUCESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VREDUCESD performs "Perform Reduction Transformation on a Scalar Double-Precision Floating-Point Value".

Mnemonic : VREDUCESD Supported forms : (2 forms)

  • VREDUCESD imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]
  • VREDUCESD imm8, m64, xmm, xmm{k}{z} [AVX512DQ]

func (*Program) VREDUCESS 

func (self *Program) VREDUCESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VREDUCESS performs "Perform Reduction Transformation on a Scalar Single-Precision Floating-Point Value".

Mnemonic : VREDUCESS Supported forms : (2 forms)

  • VREDUCESS imm8, xmm, xmm, xmm{k}{z} [AVX512DQ]
  • VREDUCESS imm8, m32, xmm, xmm{k}{z} [AVX512DQ]

func (*Program) VRNDSCALEPD 

func (self *Program) VRNDSCALEPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRNDSCALEPD performs "Round Packed Double-Precision Floating-Point Values To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALEPD Supported forms : (7 forms)

  • VRNDSCALEPD imm8, m512/m64bcst, zmm{k}{z} [AVX512F]
  • VRNDSCALEPD imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
  • VRNDSCALEPD imm8, zmm, zmm{k}{z} [AVX512F]
  • VRNDSCALEPD imm8, m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VRNDSCALEPD imm8, m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VRNDSCALEPD imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VRNDSCALEPD imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRNDSCALEPS 

func (self *Program) VRNDSCALEPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRNDSCALEPS performs "Round Packed Single-Precision Floating-Point Values To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALEPS Supported forms : (7 forms)

  • VRNDSCALEPS imm8, m512/m32bcst, zmm{k}{z} [AVX512F]
  • VRNDSCALEPS imm8, {sae}, zmm, zmm{k}{z} [AVX512F]
  • VRNDSCALEPS imm8, zmm, zmm{k}{z} [AVX512F]
  • VRNDSCALEPS imm8, m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VRNDSCALEPS imm8, m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VRNDSCALEPS imm8, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VRNDSCALEPS imm8, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRNDSCALESD 

func (self *Program) VRNDSCALESD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRNDSCALESD performs "Round Scalar Double-Precision Floating-Point Value To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALESD Supported forms : (3 forms)

  • VRNDSCALESD imm8, m64, xmm, xmm{k}{z} [AVX512F]
  • VRNDSCALESD imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VRNDSCALESD imm8, xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VRNDSCALESS 

func (self *Program) VRNDSCALESS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}, vv ...interface{}) *Instruction

VRNDSCALESS performs "Round Scalar Single-Precision Floating-Point Value To Include A Given Number Of Fraction Bits".

Mnemonic : VRNDSCALESS Supported forms : (3 forms)

  • VRNDSCALESS imm8, m32, xmm, xmm{k}{z} [AVX512F]
  • VRNDSCALESS imm8, {sae}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VRNDSCALESS imm8, xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VROUNDPD 

func (self *Program) VROUNDPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VROUNDPD performs "Round Packed Double Precision Floating-Point Values".

Mnemonic : VROUNDPD Supported forms : (4 forms)

  • VROUNDPD imm8, xmm, xmm [AVX]
  • VROUNDPD imm8, m128, xmm [AVX]
  • VROUNDPD imm8, ymm, ymm [AVX]
  • VROUNDPD imm8, m256, ymm [AVX]

func (*Program) VROUNDPS 

func (self *Program) VROUNDPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VROUNDPS performs "Round Packed Single Precision Floating-Point Values".

Mnemonic : VROUNDPS Supported forms : (4 forms)

  • VROUNDPS imm8, xmm, xmm [AVX]
  • VROUNDPS imm8, m128, xmm [AVX]
  • VROUNDPS imm8, ymm, ymm [AVX]
  • VROUNDPS imm8, m256, ymm [AVX]

func (*Program) VROUNDSD 

func (self *Program) VROUNDSD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VROUNDSD performs "Round Scalar Double Precision Floating-Point Values".

Mnemonic : VROUNDSD Supported forms : (2 forms)

  • VROUNDSD imm8, xmm, xmm, xmm [AVX]
  • VROUNDSD imm8, m64, xmm, xmm [AVX]

func (*Program) VROUNDSS 

func (self *Program) VROUNDSS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VROUNDSS performs "Round Scalar Single Precision Floating-Point Values".

Mnemonic : VROUNDSS Supported forms : (2 forms)

  • VROUNDSS imm8, xmm, xmm, xmm [AVX]
  • VROUNDSS imm8, m32, xmm, xmm [AVX]

func (*Program) VRSQRT14PD 

func (self *Program) VRSQRT14PD(v0 interface{}, v1 interface{}) *Instruction

VRSQRT14PD performs "Compute Approximate Reciprocals of Square Roots of Packed Double-Precision Floating-Point Values".

Mnemonic : VRSQRT14PD Supported forms : (6 forms)

  • VRSQRT14PD m512/m64bcst, zmm{k}{z} [AVX512F]
  • VRSQRT14PD zmm, zmm{k}{z} [AVX512F]
  • VRSQRT14PD m128/m64bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VRSQRT14PD m256/m64bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VRSQRT14PD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VRSQRT14PD ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRSQRT14PS 

func (self *Program) VRSQRT14PS(v0 interface{}, v1 interface{}) *Instruction

VRSQRT14PS performs "Compute Approximate Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : VRSQRT14PS Supported forms : (6 forms)

  • VRSQRT14PS m512/m32bcst, zmm{k}{z} [AVX512F]
  • VRSQRT14PS zmm, zmm{k}{z} [AVX512F]
  • VRSQRT14PS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VRSQRT14PS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VRSQRT14PS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VRSQRT14PS ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VRSQRT14SD 

func (self *Program) VRSQRT14SD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRSQRT14SD performs "Compute Approximate Reciprocal of a Square Root of a Scalar Double-Precision Floating-Point Value".

Mnemonic : VRSQRT14SD Supported forms : (2 forms)

  • VRSQRT14SD xmm, xmm, xmm{k}{z} [AVX512F]
  • VRSQRT14SD m64, xmm, xmm{k}{z} [AVX512F]

func (*Program) VRSQRT14SS 

func (self *Program) VRSQRT14SS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRSQRT14SS performs "Compute Approximate Reciprocal of a Square Root of a Scalar Single-Precision Floating-Point Value".

Mnemonic : VRSQRT14SS Supported forms : (2 forms)

  • VRSQRT14SS xmm, xmm, xmm{k}{z} [AVX512F]
  • VRSQRT14SS m32, xmm, xmm{k}{z} [AVX512F]

func (*Program) VRSQRT28PD 

func (self *Program) VRSQRT28PD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRSQRT28PD performs "Approximation to the Reciprocal Square Root of Packed Double-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28PD Supported forms : (3 forms)

  • VRSQRT28PD m512/m64bcst, zmm{k}{z} [AVX512ER]
  • VRSQRT28PD {sae}, zmm, zmm{k}{z} [AVX512ER]
  • VRSQRT28PD zmm, zmm{k}{z} [AVX512ER]

func (*Program) VRSQRT28PS 

func (self *Program) VRSQRT28PS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VRSQRT28PS performs "Approximation to the Reciprocal Square Root of Packed Single-Precision Floating-Point Values with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28PS Supported forms : (3 forms)

  • VRSQRT28PS m512/m32bcst, zmm{k}{z} [AVX512ER]
  • VRSQRT28PS {sae}, zmm, zmm{k}{z} [AVX512ER]
  • VRSQRT28PS zmm, zmm{k}{z} [AVX512ER]

func (*Program) VRSQRT28SD 

func (self *Program) VRSQRT28SD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRSQRT28SD performs "Approximation to the Reciprocal Square Root of a Scalar Double-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28SD Supported forms : (3 forms)

  • VRSQRT28SD m64, xmm, xmm{k}{z} [AVX512ER]
  • VRSQRT28SD {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
  • VRSQRT28SD xmm, xmm, xmm{k}{z} [AVX512ER]

func (*Program) VRSQRT28SS 

func (self *Program) VRSQRT28SS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VRSQRT28SS performs "Approximation to the Reciprocal Square Root of a Scalar Single-Precision Floating-Point Value with Less Than 2^-28 Relative Error".

Mnemonic : VRSQRT28SS Supported forms : (3 forms)

  • VRSQRT28SS m32, xmm, xmm{k}{z} [AVX512ER]
  • VRSQRT28SS {sae}, xmm, xmm, xmm{k}{z} [AVX512ER]
  • VRSQRT28SS xmm, xmm, xmm{k}{z} [AVX512ER]

func (*Program) VRSQRTPS 

func (self *Program) VRSQRTPS(v0 interface{}, v1 interface{}) *Instruction

VRSQRTPS performs "Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : VRSQRTPS Supported forms : (4 forms)

  • VRSQRTPS xmm, xmm [AVX]
  • VRSQRTPS m128, xmm [AVX]
  • VRSQRTPS ymm, ymm [AVX]
  • VRSQRTPS m256, ymm [AVX]

func (*Program) VRSQRTSS 

func (self *Program) VRSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VRSQRTSS performs "Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : VRSQRTSS Supported forms : (2 forms)

  • VRSQRTSS xmm, xmm, xmm [AVX]
  • VRSQRTSS m32, xmm, xmm [AVX]

func (*Program) VSCALEFPD 

func (self *Program) VSCALEFPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFPD performs "Scale Packed Double-Precision Floating-Point Values With Double-Precision Floating-Point Values".

Mnemonic : VSCALEFPD Supported forms : (7 forms)

  • VSCALEFPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VSCALEFPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSCALEFPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VSCALEFPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSCALEFPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSCALEFPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSCALEFPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSCALEFPS 

func (self *Program) VSCALEFPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFPS performs "Scale Packed Single-Precision Floating-Point Values With Single-Precision Floating-Point Values".

Mnemonic : VSCALEFPS Supported forms : (7 forms)

  • VSCALEFPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VSCALEFPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSCALEFPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VSCALEFPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSCALEFPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSCALEFPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSCALEFPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSCALEFSD 

func (self *Program) VSCALEFSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFSD performs "Scale Scalar Double-Precision Floating-Point Value With a Double-Precision Floating-Point Value".

Mnemonic : VSCALEFSD Supported forms : (3 forms)

  • VSCALEFSD m64, xmm, xmm{k}{z} [AVX512F]
  • VSCALEFSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VSCALEFSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VSCALEFSS 

func (self *Program) VSCALEFSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSCALEFSS performs "Scale Scalar Single-Precision Floating-Point Value With a Single-Precision Floating-Point Value".

Mnemonic : VSCALEFSS Supported forms : (3 forms)

  • VSCALEFSS m32, xmm, xmm{k}{z} [AVX512F]
  • VSCALEFSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VSCALEFSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VSCATTERDPD 

func (self *Program) VSCATTERDPD(v0 interface{}, v1 interface{}) *Instruction

VSCATTERDPD performs "Scatter Packed Double-Precision Floating-Point Values with Signed Doubleword Indices".

Mnemonic : VSCATTERDPD Supported forms : (3 forms)

  • VSCATTERDPD zmm, vm32y{k} [AVX512F]
  • VSCATTERDPD xmm, vm32x{k} [AVX512F,AVX512VL]
  • VSCATTERDPD ymm, vm32x{k} [AVX512F,AVX512VL]

func (*Program) VSCATTERDPS 

func (self *Program) VSCATTERDPS(v0 interface{}, v1 interface{}) *Instruction

VSCATTERDPS performs "Scatter Packed Single-Precision Floating-Point Values with Signed Doubleword Indices".

Mnemonic : VSCATTERDPS Supported forms : (3 forms)

  • VSCATTERDPS zmm, vm32z{k} [AVX512F]
  • VSCATTERDPS xmm, vm32x{k} [AVX512F,AVX512VL]
  • VSCATTERDPS ymm, vm32y{k} [AVX512F,AVX512VL]

func (*Program) VSCATTERPF0DPD 

func (self *Program) VSCATTERPF0DPD(v0 interface{}) *Instruction

VSCATTERPF0DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0DPD Supported forms : (1 form)

  • VSCATTERPF0DPD vm32y{k} [AVX512PF]

func (*Program) VSCATTERPF0DPS 

func (self *Program) VSCATTERPF0DPS(v0 interface{}) *Instruction

VSCATTERPF0DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0DPS Supported forms : (1 form)

  • VSCATTERPF0DPS vm32z{k} [AVX512PF]

func (*Program) VSCATTERPF0QPD 

func (self *Program) VSCATTERPF0QPD(v0 interface{}) *Instruction

VSCATTERPF0QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0QPD Supported forms : (1 form)

  • VSCATTERPF0QPD vm64z{k} [AVX512PF]

func (*Program) VSCATTERPF0QPS 

func (self *Program) VSCATTERPF0QPS(v0 interface{}) *Instruction

VSCATTERPF0QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T0 Hint with Intent to Write".

Mnemonic : VSCATTERPF0QPS Supported forms : (1 form)

  • VSCATTERPF0QPS vm64z{k} [AVX512PF]

func (*Program) VSCATTERPF1DPD 

func (self *Program) VSCATTERPF1DPD(v0 interface{}) *Instruction

VSCATTERPF1DPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1DPD Supported forms : (1 form)

  • VSCATTERPF1DPD vm32y{k} [AVX512PF]

func (*Program) VSCATTERPF1DPS 

func (self *Program) VSCATTERPF1DPS(v0 interface{}) *Instruction

VSCATTERPF1DPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Doubleword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1DPS Supported forms : (1 form)

  • VSCATTERPF1DPS vm32z{k} [AVX512PF]

func (*Program) VSCATTERPF1QPD 

func (self *Program) VSCATTERPF1QPD(v0 interface{}) *Instruction

VSCATTERPF1QPD performs "Sparse Prefetch Packed Double-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1QPD Supported forms : (1 form)

  • VSCATTERPF1QPD vm64z{k} [AVX512PF]

func (*Program) VSCATTERPF1QPS 

func (self *Program) VSCATTERPF1QPS(v0 interface{}) *Instruction

VSCATTERPF1QPS performs "Sparse Prefetch Packed Single-Precision Floating-Point Data Values with Signed Quadword Indices Using T1 Hint with Intent to Write".

Mnemonic : VSCATTERPF1QPS Supported forms : (1 form)

  • VSCATTERPF1QPS vm64z{k} [AVX512PF]

func (*Program) VSCATTERQPD 

func (self *Program) VSCATTERQPD(v0 interface{}, v1 interface{}) *Instruction

VSCATTERQPD performs "Scatter Packed Double-Precision Floating-Point Values with Signed Quadword Indices".

Mnemonic : VSCATTERQPD Supported forms : (3 forms)

  • VSCATTERQPD zmm, vm64z{k} [AVX512F]
  • VSCATTERQPD xmm, vm64x{k} [AVX512F,AVX512VL]
  • VSCATTERQPD ymm, vm64y{k} [AVX512F,AVX512VL]

func (*Program) VSCATTERQPS 

func (self *Program) VSCATTERQPS(v0 interface{}, v1 interface{}) *Instruction

VSCATTERQPS performs "Scatter Packed Single-Precision Floating-Point Values with Signed Quadword Indices".

Mnemonic : VSCATTERQPS Supported forms : (3 forms)

  • VSCATTERQPS ymm, vm64z{k} [AVX512F]
  • VSCATTERQPS xmm, vm64x{k} [AVX512F,AVX512VL]
  • VSCATTERQPS xmm, vm64y{k} [AVX512F,AVX512VL]

func (*Program) VSHUFF32X4 

func (self *Program) VSHUFF32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFF32X4 performs "Shuffle 128-Bit Packed Single-Precision Floating-Point Values".

Mnemonic : VSHUFF32X4 Supported forms : (4 forms)

  • VSHUFF32X4 imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VSHUFF32X4 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSHUFF32X4 imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSHUFF32X4 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSHUFF64X2 

func (self *Program) VSHUFF64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFF64X2 performs "Shuffle 128-Bit Packed Double-Precision Floating-Point Values".

Mnemonic : VSHUFF64X2 Supported forms : (4 forms)

  • VSHUFF64X2 imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VSHUFF64X2 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSHUFF64X2 imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSHUFF64X2 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSHUFI32X4 

func (self *Program) VSHUFI32X4(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFI32X4 performs "Shuffle 128-Bit Packed Doubleword Integer Values".

Mnemonic : VSHUFI32X4 Supported forms : (4 forms)

  • VSHUFI32X4 imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VSHUFI32X4 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSHUFI32X4 imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSHUFI32X4 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSHUFI64X2 

func (self *Program) VSHUFI64X2(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFI64X2 performs "Shuffle 128-Bit Packed Quadword Integer Values".

Mnemonic : VSHUFI64X2 Supported forms : (4 forms)

  • VSHUFI64X2 imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VSHUFI64X2 imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSHUFI64X2 imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSHUFI64X2 imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSHUFPD 

func (self *Program) VSHUFPD(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFPD performs "Shuffle Packed Double-Precision Floating-Point Values".

Mnemonic : VSHUFPD Supported forms : (10 forms)

  • VSHUFPD imm8, xmm, xmm, xmm [AVX]
  • VSHUFPD imm8, m128, xmm, xmm [AVX]
  • VSHUFPD imm8, ymm, ymm, ymm [AVX]
  • VSHUFPD imm8, m256, ymm, ymm [AVX]
  • VSHUFPD imm8, m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VSHUFPD imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSHUFPD imm8, m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSHUFPD imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSHUFPD imm8, m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSHUFPD imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSHUFPS 

func (self *Program) VSHUFPS(v0 interface{}, v1 interface{}, v2 interface{}, v3 interface{}) *Instruction

VSHUFPS performs "Shuffle Packed Single-Precision Floating-Point Values".

Mnemonic : VSHUFPS Supported forms : (10 forms)

  • VSHUFPS imm8, xmm, xmm, xmm [AVX]
  • VSHUFPS imm8, m128, xmm, xmm [AVX]
  • VSHUFPS imm8, ymm, ymm, ymm [AVX]
  • VSHUFPS imm8, m256, ymm, ymm [AVX]
  • VSHUFPS imm8, m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VSHUFPS imm8, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSHUFPS imm8, m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSHUFPS imm8, xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSHUFPS imm8, m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSHUFPS imm8, ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSQRTPD 

func (self *Program) VSQRTPD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VSQRTPD performs "Compute Square Roots of Packed Double-Precision Floating-Point Values".

Mnemonic : VSQRTPD Supported forms : (11 forms)

  • VSQRTPD xmm, xmm [AVX]
  • VSQRTPD m128, xmm [AVX]
  • VSQRTPD ymm, ymm [AVX]
  • VSQRTPD m256, ymm [AVX]
  • VSQRTPD m512/m64bcst, zmm{k}{z} [AVX512F]
  • VSQRTPD {er}, zmm, zmm{k}{z} [AVX512F]
  • VSQRTPD zmm, zmm{k}{z} [AVX512F]
  • VSQRTPD m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VSQRTPD m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VSQRTPD xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSQRTPD ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSQRTPS 

func (self *Program) VSQRTPS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VSQRTPS performs "Compute Square Roots of Packed Single-Precision Floating-Point Values".

Mnemonic : VSQRTPS Supported forms : (11 forms)

  • VSQRTPS xmm, xmm [AVX]
  • VSQRTPS m128, xmm [AVX]
  • VSQRTPS ymm, ymm [AVX]
  • VSQRTPS m256, ymm [AVX]
  • VSQRTPS m512/m32bcst, zmm{k}{z} [AVX512F]
  • VSQRTPS {er}, zmm, zmm{k}{z} [AVX512F]
  • VSQRTPS zmm, zmm{k}{z} [AVX512F]
  • VSQRTPS m128/m32bcst, xmm{k}{z} [AVX512F,AVX512VL]
  • VSQRTPS m256/m32bcst, ymm{k}{z} [AVX512F,AVX512VL]
  • VSQRTPS xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSQRTPS ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSQRTSD 

func (self *Program) VSQRTSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSQRTSD performs "Compute Square Root of Scalar Double-Precision Floating-Point Value".

Mnemonic : VSQRTSD Supported forms : (5 forms)

  • VSQRTSD xmm, xmm, xmm [AVX]
  • VSQRTSD m64, xmm, xmm [AVX]
  • VSQRTSD m64, xmm, xmm{k}{z} [AVX512F]
  • VSQRTSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VSQRTSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VSQRTSS 

func (self *Program) VSQRTSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSQRTSS performs "Compute Square Root of Scalar Single-Precision Floating-Point Value".

Mnemonic : VSQRTSS Supported forms : (5 forms)

  • VSQRTSS xmm, xmm, xmm [AVX]
  • VSQRTSS m32, xmm, xmm [AVX]
  • VSQRTSS m32, xmm, xmm{k}{z} [AVX512F]
  • VSQRTSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VSQRTSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VSTMXCSR 

func (self *Program) VSTMXCSR(v0 interface{}) *Instruction

VSTMXCSR performs "Store MXCSR Register State".

Mnemonic : VSTMXCSR Supported forms : (1 form)

  • VSTMXCSR m32 [AVX]

func (*Program) VSUBPD 

func (self *Program) VSUBPD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBPD performs "Subtract Packed Double-Precision Floating-Point Values".

Mnemonic : VSUBPD Supported forms : (11 forms)

  • VSUBPD xmm, xmm, xmm [AVX]
  • VSUBPD m128, xmm, xmm [AVX]
  • VSUBPD ymm, ymm, ymm [AVX]
  • VSUBPD m256, ymm, ymm [AVX]
  • VSUBPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VSUBPD {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSUBPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VSUBPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSUBPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSUBPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSUBPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSUBPS 

func (self *Program) VSUBPS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBPS performs "Subtract Packed Single-Precision Floating-Point Values".

Mnemonic : VSUBPS Supported forms : (11 forms)

  • VSUBPS xmm, xmm, xmm [AVX]
  • VSUBPS m128, xmm, xmm [AVX]
  • VSUBPS ymm, ymm, ymm [AVX]
  • VSUBPS m256, ymm, ymm [AVX]
  • VSUBPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VSUBPS {er}, zmm, zmm, zmm{k}{z} [AVX512F]
  • VSUBPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VSUBPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSUBPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VSUBPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VSUBPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VSUBSD 

func (self *Program) VSUBSD(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBSD performs "Subtract Scalar Double-Precision Floating-Point Values".

Mnemonic : VSUBSD Supported forms : (5 forms)

  • VSUBSD xmm, xmm, xmm [AVX]
  • VSUBSD m64, xmm, xmm [AVX]
  • VSUBSD m64, xmm, xmm{k}{z} [AVX512F]
  • VSUBSD {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VSUBSD xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VSUBSS 

func (self *Program) VSUBSS(v0 interface{}, v1 interface{}, v2 interface{}, vv ...interface{}) *Instruction

VSUBSS performs "Subtract Scalar Single-Precision Floating-Point Values".

Mnemonic : VSUBSS Supported forms : (5 forms)

  • VSUBSS xmm, xmm, xmm [AVX]
  • VSUBSS m32, xmm, xmm [AVX]
  • VSUBSS m32, xmm, xmm{k}{z} [AVX512F]
  • VSUBSS {er}, xmm, xmm, xmm{k}{z} [AVX512F]
  • VSUBSS xmm, xmm, xmm{k}{z} [AVX512F]

func (*Program) VTESTPD 

func (self *Program) VTESTPD(v0 interface{}, v1 interface{}) *Instruction

VTESTPD performs "Packed Double-Precision Floating-Point Bit Test".

Mnemonic : VTESTPD Supported forms : (4 forms)

  • VTESTPD xmm, xmm [AVX]
  • VTESTPD m128, xmm [AVX]
  • VTESTPD ymm, ymm [AVX]
  • VTESTPD m256, ymm [AVX]

func (*Program) VTESTPS 

func (self *Program) VTESTPS(v0 interface{}, v1 interface{}) *Instruction

VTESTPS performs "Packed Single-Precision Floating-Point Bit Test".

Mnemonic : VTESTPS Supported forms : (4 forms)

  • VTESTPS xmm, xmm [AVX]
  • VTESTPS m128, xmm [AVX]
  • VTESTPS ymm, ymm [AVX]
  • VTESTPS m256, ymm [AVX]

func (*Program) VUCOMISD 

func (self *Program) VUCOMISD(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VUCOMISD performs "Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VUCOMISD Supported forms : (5 forms)

  • VUCOMISD xmm, xmm [AVX]
  • VUCOMISD m64, xmm [AVX]
  • VUCOMISD m64, xmm [AVX512F]
  • VUCOMISD {sae}, xmm, xmm [AVX512F]
  • VUCOMISD xmm, xmm [AVX512F]

func (*Program) VUCOMISS 

func (self *Program) VUCOMISS(v0 interface{}, v1 interface{}, vv ...interface{}) *Instruction

VUCOMISS performs "Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS".

Mnemonic : VUCOMISS Supported forms : (5 forms)

  • VUCOMISS xmm, xmm [AVX]
  • VUCOMISS m32, xmm [AVX]
  • VUCOMISS m32, xmm [AVX512F]
  • VUCOMISS {sae}, xmm, xmm [AVX512F]
  • VUCOMISS xmm, xmm [AVX512F]

func (*Program) VUNPCKHPD 

func (self *Program) VUNPCKHPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKHPD performs "Unpack and Interleave High Packed Double-Precision Floating-Point Values".

Mnemonic : VUNPCKHPD Supported forms : (10 forms)

  • VUNPCKHPD xmm, xmm, xmm [AVX]
  • VUNPCKHPD m128, xmm, xmm [AVX]
  • VUNPCKHPD ymm, ymm, ymm [AVX]
  • VUNPCKHPD m256, ymm, ymm [AVX]
  • VUNPCKHPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKHPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKHPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKHPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKHPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKHPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VUNPCKHPS 

func (self *Program) VUNPCKHPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKHPS performs "Unpack and Interleave High Packed Single-Precision Floating-Point Values".

Mnemonic : VUNPCKHPS Supported forms : (10 forms)

  • VUNPCKHPS xmm, xmm, xmm [AVX]
  • VUNPCKHPS m128, xmm, xmm [AVX]
  • VUNPCKHPS ymm, ymm, ymm [AVX]
  • VUNPCKHPS m256, ymm, ymm [AVX]
  • VUNPCKHPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKHPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKHPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKHPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKHPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKHPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VUNPCKLPD 

func (self *Program) VUNPCKLPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKLPD performs "Unpack and Interleave Low Packed Double-Precision Floating-Point Values".

Mnemonic : VUNPCKLPD Supported forms : (10 forms)

  • VUNPCKLPD xmm, xmm, xmm [AVX]
  • VUNPCKLPD m128, xmm, xmm [AVX]
  • VUNPCKLPD ymm, ymm, ymm [AVX]
  • VUNPCKLPD m256, ymm, ymm [AVX]
  • VUNPCKLPD m512/m64bcst, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKLPD zmm, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKLPD m128/m64bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKLPD xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKLPD m256/m64bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKLPD ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VUNPCKLPS 

func (self *Program) VUNPCKLPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VUNPCKLPS performs "Unpack and Interleave Low Packed Single-Precision Floating-Point Values".

Mnemonic : VUNPCKLPS Supported forms : (10 forms)

  • VUNPCKLPS xmm, xmm, xmm [AVX]
  • VUNPCKLPS m128, xmm, xmm [AVX]
  • VUNPCKLPS ymm, ymm, ymm [AVX]
  • VUNPCKLPS m256, ymm, ymm [AVX]
  • VUNPCKLPS m512/m32bcst, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKLPS zmm, zmm, zmm{k}{z} [AVX512F]
  • VUNPCKLPS m128/m32bcst, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKLPS xmm, xmm, xmm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKLPS m256/m32bcst, ymm, ymm{k}{z} [AVX512F,AVX512VL]
  • VUNPCKLPS ymm, ymm, ymm{k}{z} [AVX512F,AVX512VL]

func (*Program) VXORPD 

func (self *Program) VXORPD(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VXORPD performs "Bitwise Logical XOR for Double-Precision Floating-Point Values".

Mnemonic : VXORPD Supported forms : (10 forms)

  • VXORPD xmm, xmm, xmm [AVX]
  • VXORPD m128, xmm, xmm [AVX]
  • VXORPD ymm, ymm, ymm [AVX]
  • VXORPD m256, ymm, ymm [AVX]
  • VXORPD m512/m64bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VXORPD zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VXORPD m128/m64bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VXORPD xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VXORPD m256/m64bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VXORPD ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VXORPS 

func (self *Program) VXORPS(v0 interface{}, v1 interface{}, v2 interface{}) *Instruction

VXORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".

Mnemonic : VXORPS Supported forms : (10 forms)

  • VXORPS xmm, xmm, xmm [AVX]
  • VXORPS m128, xmm, xmm [AVX]
  • VXORPS ymm, ymm, ymm [AVX]
  • VXORPS m256, ymm, ymm [AVX]
  • VXORPS m512/m32bcst, zmm, zmm{k}{z} [AVX512DQ]
  • VXORPS zmm, zmm, zmm{k}{z} [AVX512DQ]
  • VXORPS m128/m32bcst, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VXORPS xmm, xmm, xmm{k}{z} [AVX512DQ,AVX512VL]
  • VXORPS m256/m32bcst, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]
  • VXORPS ymm, ymm, ymm{k}{z} [AVX512DQ,AVX512VL]

func (*Program) VZEROALL 

func (self *Program) VZEROALL() *Instruction

VZEROALL performs "Zero All YMM Registers".

Mnemonic : VZEROALL Supported forms : (1 form)

  • VZEROALL [AVX]

func (*Program) VZEROUPPER 

func (self *Program) VZEROUPPER() *Instruction

VZEROUPPER performs "Zero Upper Bits of YMM Registers".

Mnemonic : VZEROUPPER Supported forms : (1 form)

  • VZEROUPPER [AVX]

func (*Program) Word 

func (self *Program) Word(v *expr.Expr) (p *Instruction)

Word is a pseudo-instruction to add raw uint16 as little-endian to the assembled code.

func (*Program) XADDB 

func (self *Program) XADDB(v0 interface{}, v1 interface{}) *Instruction

XADDB performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

  • XADDB r8, r8
  • XADDB r8, m8

func (*Program) XADDL 

func (self *Program) XADDL(v0 interface{}, v1 interface{}) *Instruction

XADDL performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

  • XADDL r32, r32
  • XADDL r32, m32

func (*Program) XADDQ 

func (self *Program) XADDQ(v0 interface{}, v1 interface{}) *Instruction

XADDQ performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

  • XADDQ r64, r64
  • XADDQ r64, m64

func (*Program) XADDW 

func (self *Program) XADDW(v0 interface{}, v1 interface{}) *Instruction

XADDW performs "Exchange and Add".

Mnemonic : XADD Supported forms : (2 forms)

  • XADDW r16, r16
  • XADDW r16, m16

func (*Program) XCHGB 

func (self *Program) XCHGB(v0 interface{}, v1 interface{}) *Instruction

XCHGB performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (3 forms)

  • XCHGB r8, r8
  • XCHGB m8, r8
  • XCHGB r8, m8

func (*Program) XCHGL 

func (self *Program) XCHGL(v0 interface{}, v1 interface{}) *Instruction

XCHGL performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (5 forms)

  • XCHGL r32, eax
  • XCHGL eax, r32
  • XCHGL r32, r32
  • XCHGL m32, r32
  • XCHGL r32, m32

func (*Program) XCHGQ 

func (self *Program) XCHGQ(v0 interface{}, v1 interface{}) *Instruction

XCHGQ performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (5 forms)

  • XCHGQ r64, rax
  • XCHGQ rax, r64
  • XCHGQ r64, r64
  • XCHGQ m64, r64
  • XCHGQ r64, m64

func (*Program) XCHGW 

func (self *Program) XCHGW(v0 interface{}, v1 interface{}) *Instruction

XCHGW performs "Exchange Register/Memory with Register".

Mnemonic : XCHG Supported forms : (5 forms)

  • XCHGW r16, ax
  • XCHGW ax, r16
  • XCHGW r16, r16
  • XCHGW m16, r16
  • XCHGW r16, m16

func (*Program) XGETBV 

func (self *Program) XGETBV() *Instruction

XGETBV performs "Get Value of Extended Control Register".

Mnemonic : XGETBV Supported forms : (1 form)

  • XGETBV

func (*Program) XLATB 

func (self *Program) XLATB() *Instruction

XLATB performs "Table Look-up Translation".

Mnemonic : XLATB Supported forms : (2 forms)

  • XLATB
  • XLATB

func (*Program) XORB 

func (self *Program) XORB(v0 interface{}, v1 interface{}) *Instruction

XORB performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (6 forms)

  • XORB imm8, al
  • XORB imm8, r8
  • XORB r8, r8
  • XORB m8, r8
  • XORB imm8, m8
  • XORB r8, m8

func (*Program) XORL 

func (self *Program) XORL(v0 interface{}, v1 interface{}) *Instruction

XORL performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (8 forms)

  • XORL imm32, eax
  • XORL imm8, r32
  • XORL imm32, r32
  • XORL r32, r32
  • XORL m32, r32
  • XORL imm8, m32
  • XORL imm32, m32
  • XORL r32, m32

func (*Program) XORPD 

func (self *Program) XORPD(v0 interface{}, v1 interface{}) *Instruction

XORPD performs "Bitwise Logical XOR for Double-Precision Floating-Point Values".

Mnemonic : XORPD Supported forms : (2 forms)

  • XORPD xmm, xmm [SSE2]
  • XORPD m128, xmm [SSE2]

func (*Program) XORPS 

func (self *Program) XORPS(v0 interface{}, v1 interface{}) *Instruction

XORPS performs "Bitwise Logical XOR for Single-Precision Floating-Point Values".

Mnemonic : XORPS Supported forms : (2 forms)

  • XORPS xmm, xmm [SSE]
  • XORPS m128, xmm [SSE]

func (*Program) XORQ 

func (self *Program) XORQ(v0 interface{}, v1 interface{}) *Instruction

XORQ performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (8 forms)

  • XORQ imm32, rax
  • XORQ imm8, r64
  • XORQ imm32, r64
  • XORQ r64, r64
  • XORQ m64, r64
  • XORQ imm8, m64
  • XORQ imm32, m64
  • XORQ r64, m64

func (*Program) XORW 

func (self *Program) XORW(v0 interface{}, v1 interface{}) *Instruction

XORW performs "Logical Exclusive OR".

Mnemonic : XOR Supported forms : (8 forms)

  • XORW imm16, ax
  • XORW imm8, r16
  • XORW imm16, r16
  • XORW r16, r16
  • XORW m16, r16
  • XORW imm8, m16
  • XORW imm16, m16
  • XORW r16, m16

type Register 

type Register interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

Register represents a hardware register.

type Register16 

type Register16 byte
const (
	AX Register16 = iota
	CX
	DX
	BX
	SP
	BP
	SI
	DI
	R8w
	R9w
	R10w
	R11w
	R12w
	R13w
	R14w
	R15w
)

func (Register16) String 

func (self Register16) String() string

type Register32 

type Register32 byte
const (
	EAX Register32 = iota
	ECX
	EDX
	EBX
	ESP
	EBP
	ESI
	EDI
	R8d
	R9d
	R10d
	R11d
	R12d
	R13d
	R14d
	R15d
)

func (Register32) String 

func (self Register32) String() string

type Register64 

type Register64 byte
const (
	RAX Register64 = iota
	RCX
	RDX
	RBX
	RSP
	RBP
	RSI
	RDI
	R8
	R9
	R10
	R11
	R12
	R13
	R14
	R15
)

func (Register64) String 

func (self Register64) String() string

type Register8 

type Register8 byte
const (
	AL Register8 = iota
	CL
	DL
	BL
	SPL
	BPL
	SIL
	DIL
	R8b
	R9b
	R10b
	R11b
	R12b
	R13b
	R14b
	R15b
)

func (Register8) String 

func (self Register8) String() string

type RegisterMask 

type RegisterMask struct {
	Z bool
	K KRegister
}

RegisterMask is a KRegister used to mask another register.

func (RegisterMask) String 

func (self RegisterMask) String() string

String implements the fmt.Stringer interface.

type RelativeOffset 

type RelativeOffset int32

RelativeOffset represents an RIP-relative offset.

func (RelativeOffset) String 

func (self RelativeOffset) String() string

String implements the fmt.Stringer interface.

type RoundingControl 

type RoundingControl uint8

RoundingControl represents a floating-point rounding option. 

const (
	// RN_SAE represents "Round Nearest", which is the default rounding option.
	RN_SAE RoundingControl = iota

	// RD_SAE represents "Round Down".
	RD_SAE

	// RU_SAE represents "Round Up".
	RU_SAE

	// RZ_SAE represents "Round towards Zero".
	RZ_SAE
)

func (RoundingControl) String 

func (self RoundingControl) String() string

type SyntaxError 

type SyntaxError struct {
	Pos    int
	Row    int
	Src    []rune
	Reason string
}

SyntaxError represents an error in the assembly syntax.

func (*SyntaxError) Error 

func (self *SyntaxError) Error() string

Error implements the error interface.

type XMMRegister 

type XMMRegister byte
const (
	XMM0 XMMRegister = iota
	XMM1
	XMM2
	XMM3
	XMM4
	XMM5
	XMM6
	XMM7
	XMM8
	XMM9
	XMM10
	XMM11
	XMM12
	XMM13
	XMM14
	XMM15
	XMM16
	XMM17
	XMM18
	XMM19
	XMM20
	XMM21
	XMM22
	XMM23
	XMM24
	XMM25
	XMM26
	XMM27
	XMM28
	XMM29
	XMM30
	XMM31
)

func (XMMRegister) String 

func (self XMMRegister) String() string

type YMMRegister 

type YMMRegister byte
const (
	YMM0 YMMRegister = iota
	YMM1
	YMM2
	YMM3
	YMM4
	YMM5
	YMM6
	YMM7
	YMM8
	YMM9
	YMM10
	YMM11
	YMM12
	YMM13
	YMM14
	YMM15
	YMM16
	YMM17
	YMM18
	YMM19
	YMM20
	YMM21
	YMM22
	YMM23
	YMM24
	YMM25
	YMM26
	YMM27
	YMM28
	YMM29
	YMM30
	YMM31
)

func (YMMRegister) String 

func (self YMMRegister) String() string

type ZMMRegister 

type ZMMRegister byte
const (
	ZMM0 ZMMRegister = iota
	ZMM1
	ZMM2
	ZMM3
	ZMM4
	ZMM5
	ZMM6
	ZMM7
	ZMM8
	ZMM9
	ZMM10
	ZMM11
	ZMM12
	ZMM13
	ZMM14
	ZMM15
	ZMM16
	ZMM17
	ZMM18
	ZMM19
	ZMM20
	ZMM21
	ZMM22
	ZMM23
	ZMM24
	ZMM25
	ZMM26
	ZMM27
	ZMM28
	ZMM29
	ZMM30
	ZMM31
)

func (ZMMRegister) String 

func (self ZMMRegister) String() string

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.