ssa

package
v1.7.2 Latest Latest
Warning

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

 Go to latest Published: May 7, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Overview

Package ssa is used to construct SSA function. By nature this is free of Wasm specific thing and ISA.

We use the "block argument" variant of SSA: https://en.wikipedia.org/wiki/Static_single-assignment_form#Block_arguments which is equivalent to the traditional PHI function based one, but more convenient during optimizations. However, in this package's source code comment, we might use PHI whenever it seems necessary in order to be aligned with existing literatures, e.g. SSA level optimization algorithms are often described using PHI nodes.

The rationale doc for the choice of "block argument" by MLIR of LLVM is worth a read: https://mlir.llvm.org/docs/Rationale/Rationale/#block-arguments-vs-phi-nodes

The algorithm to resolve variable definitions used here is based on the paper "Simple and Efficient Construction of Static Single Assignment Form": https://link.springer.com/content/pdf/10.1007/978-3-642-37051-9_6.pdf.

Index

Constants

This section is empty.

Variables

View Source 
var ValuesNil = wazevoapi.NewNilVarLength[Value]()

ValuesNil is a nil Values.

Functions

This section is empty.

Types

type AtomicRmwOp added in v1.7.0 

type AtomicRmwOp byte

AtomicRmwOp represents the atomic read-modify-write operation. 

const (
	// AtomicRmwOpAdd is an atomic add operation.
	AtomicRmwOpAdd AtomicRmwOp = iota
	// AtomicRmwOpSub is an atomic sub operation.
	AtomicRmwOpSub
	// AtomicRmwOpAnd is an atomic and operation.
	AtomicRmwOpAnd
	// AtomicRmwOpOr is an atomic or operation.
	AtomicRmwOpOr
	// AtomicRmwOpXor is an atomic xor operation.
	AtomicRmwOpXor
	// AtomicRmwOpXchg is an atomic swap operation.
	AtomicRmwOpXchg
)

func (AtomicRmwOp) String added in v1.7.0 

func (op AtomicRmwOp) String() string

String implements the fmt.Stringer.

type BasicBlock 

type BasicBlock interface {
	// ID returns the unique ID of this block.
	ID() BasicBlockID

	// Name returns the unique string ID of this block. e.g. blk0, blk1, ...
	Name() string

	// AddParam adds the parameter to the block whose type specified by `t`.
	AddParam(b Builder, t Type) Value

	// Params returns the number of parameters to this block.
	Params() int

	// Param returns (Variable, Value) which corresponds to the i-th parameter of this block.
	// The returned Value is the definition of the param in this block.
	Param(i int) Value

	// InsertInstruction inserts an instruction that implements Value into the tail of this block.
	InsertInstruction(raw *Instruction)

	// Root returns the root instruction of this block.
	Root() *Instruction

	// Tail returns the tail instruction of this block.
	Tail() *Instruction

	// EntryBlock returns true if this block represents the function entry.
	EntryBlock() bool

	// ReturnBlock returns ture if this block represents the function return.
	ReturnBlock() bool

	// FormatHeader returns the debug string of this block, not including instruction.
	FormatHeader(b Builder) string

	// Valid is true if this block is still valid even after optimizations.
	Valid() bool

	// Sealed is true if this block has been sealed.
	Sealed() bool

	// BeginPredIterator returns the first predecessor of this block.
	BeginPredIterator() BasicBlock

	// NextPredIterator returns the next predecessor of this block.
	NextPredIterator() BasicBlock

	// Preds returns the number of predecessors of this block.
	Preds() int

	// Pred returns the i-th predecessor of this block.
	Pred(i int) BasicBlock

	// Succs returns the number of successors of this block.
	Succs() int

	// Succ returns the i-th successor of this block.
	Succ(i int) BasicBlock

	// LoopHeader returns true if this block is a loop header.
	LoopHeader() bool

	// LoopNestingForestChildren returns the children of this block in the loop nesting forest.
	LoopNestingForestChildren() []BasicBlock
}

BasicBlock represents the Basic Block of an SSA function. Each BasicBlock always ends with branching instructions (e.g. Branch, Return, etc.), and at most two branches are allowed. If there's two branches, these two are placed together at the end of the block. In other words, there's no branching instruction in the middle of the block.

Note: we use the "block argument" variant of SSA, instead of PHI functions. See the package level doc comments.

Note: we use "parameter/param" as a placeholder which represents a variant of PHI, and "argument/arg" as an actual Value passed to that "parameter/param".

type BasicBlockID 

type BasicBlockID uint32

BasicBlockID is the unique ID of a basicBlock.

func (BasicBlockID) String 

func (bid BasicBlockID) String() string

String implements fmt.Stringer for debugging.

type Builder 

type Builder interface {
	// Init must be called to reuse this builder for the next function.
	Init(typ *Signature)

	// Signature returns the Signature of the currently-compiled function.
	Signature() *Signature

	// BlockIDMax returns the maximum value of BasicBlocksID existing in the currently-compiled function.
	BlockIDMax() BasicBlockID

	// AllocateBasicBlock creates a basic block in SSA function.
	AllocateBasicBlock() BasicBlock

	// CurrentBlock returns the currently handled BasicBlock which is set by the latest call to SetCurrentBlock.
	CurrentBlock() BasicBlock

	// EntryBlock returns the entry BasicBlock of the currently-compiled function.
	EntryBlock() BasicBlock

	// SetCurrentBlock sets the instruction insertion target to the BasicBlock `b`.
	SetCurrentBlock(b BasicBlock)

	// DeclareVariable declares a Variable of the given Type.
	DeclareVariable(Type) Variable

	// DefineVariable defines a variable in the `block` with value.
	// The defining instruction will be inserted into the `block`.
	DefineVariable(variable Variable, value Value, block BasicBlock)

	// DefineVariableInCurrentBB is the same as DefineVariable except the definition is
	// inserted into the current BasicBlock. Alias to DefineVariable(x, y, CurrentBlock()).
	DefineVariableInCurrentBB(variable Variable, value Value)

	// AllocateInstruction returns a new Instruction.
	AllocateInstruction() *Instruction

	// InsertInstruction executes BasicBlock.InsertInstruction for the currently handled basic block.
	InsertInstruction(raw *Instruction)

	// MustFindValue searches the latest definition of the given Variable and returns the result.
	MustFindValue(variable Variable) Value

	// MustFindValueInBlk is the same as MustFindValue except it searches the latest definition from the given BasicBlock.
	MustFindValueInBlk(variable Variable, blk BasicBlock) Value

	// FindValueInLinearPath tries to find the latest definition of the given Variable in the linear path to the current BasicBlock.
	// If it cannot find the definition, or it's not sealed yet, it returns ValueInvalid.
	FindValueInLinearPath(variable Variable) Value

	// Seal declares that we've known all the predecessors to this block and were added via AddPred.
	// After calling this, AddPred will be forbidden.
	Seal(blk BasicBlock)

	// AnnotateValue is for debugging purpose.
	AnnotateValue(value Value, annotation string)

	// DeclareSignature appends the *Signature to be referenced by various instructions (e.g. OpcodeCall).
	DeclareSignature(signature *Signature)

	// Signatures returns the slice of declared Signatures.
	Signatures() []*Signature

	// ResolveSignature returns the Signature which corresponds to SignatureID.
	ResolveSignature(id SignatureID) *Signature

	// RunPasses runs various passes on the constructed SSA function.
	RunPasses()

	// Format returns the debugging string of the SSA function.
	Format() string

	// BlockIteratorBegin initializes the state to iterate over all the valid BasicBlock(s) compiled.
	// Combined with BlockIteratorNext, we can use this like:
	//
	// 	for blk := builder.BlockIteratorBegin(); blk != nil; blk = builder.BlockIteratorNext() {
	// 		// ...
	//	}
	//
	// The returned blocks are ordered in the order of AllocateBasicBlock being called.
	BlockIteratorBegin() BasicBlock

	// BlockIteratorNext advances the state for iteration initialized by BlockIteratorBegin.
	// Returns nil if there's no unseen BasicBlock.
	BlockIteratorNext() BasicBlock

	// ValueRefCounts returns the map of ValueID to its reference count.
	// The returned slice must not be modified.
	ValueRefCounts() []int

	// BlockIteratorReversePostOrderBegin is almost the same as BlockIteratorBegin except it returns the BasicBlock in the reverse post-order.
	// This is available after RunPasses is run.
	BlockIteratorReversePostOrderBegin() BasicBlock

	// BlockIteratorReversePostOrderNext is almost the same as BlockIteratorPostOrderNext except it returns the BasicBlock in the reverse post-order.
	// This is available after RunPasses is run.
	BlockIteratorReversePostOrderNext() BasicBlock

	// ReturnBlock returns the BasicBlock which is used to return from the function.
	ReturnBlock() BasicBlock

	// InsertUndefined inserts an undefined instruction at the current position.
	InsertUndefined()

	// SetCurrentSourceOffset sets the current source offset. The incoming instruction will be annotated with this offset.
	SetCurrentSourceOffset(line SourceOffset)

	// LoopNestingForestRoots returns the roots of the loop nesting forest.
	LoopNestingForestRoots() []BasicBlock

	// LowestCommonAncestor returns the lowest common ancestor in the dominator tree of the given BasicBlock(s).
	LowestCommonAncestor(blk1, blk2 BasicBlock) BasicBlock

	// Idom returns the immediate dominator of the given BasicBlock.
	Idom(blk BasicBlock) BasicBlock

	VarLengthPool() *wazevoapi.VarLengthPool[Value]
	// contains filtered or unexported methods
}

Builder is used to builds SSA consisting of Basic Blocks per function.

func NewBuilder 

func NewBuilder() Builder

NewBuilder returns a new Builder implementation.

type FloatCmpCond 

type FloatCmpCond byte
const (
	// FloatCmpCondInvalid represents an invalid condition.
	FloatCmpCondInvalid FloatCmpCond = iota
	// FloatCmpCondEqual represents "==".
	FloatCmpCondEqual
	// FloatCmpCondNotEqual represents "!=".
	FloatCmpCondNotEqual
	// FloatCmpCondLessThan represents "<".
	FloatCmpCondLessThan
	// FloatCmpCondLessThanOrEqual represents "<=".
	FloatCmpCondLessThanOrEqual
	// FloatCmpCondGreaterThan represents ">".
	FloatCmpCondGreaterThan
	// FloatCmpCondGreaterThanOrEqual represents ">=".
	FloatCmpCondGreaterThanOrEqual
)

func (FloatCmpCond) String 

func (f FloatCmpCond) String() string

String implements fmt.Stringer.

type FuncRef 

type FuncRef uint32

FuncRef is a unique identifier for a function of the frontend, and is used to reference the function in function call.

func (FuncRef) String 

func (r FuncRef) String() string

String implements fmt.Stringer.

type Instruction 

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

Instruction represents an instruction whose opcode is specified by Opcode. Since Go doesn't have union type, we use this flattened type for all instructions, and therefore each field has different meaning depending on Opcode.

func (*Instruction) Arg 

func (i *Instruction) Arg() Value

Arg returns the first argument to this instruction.

func (*Instruction) Arg2 

func (i *Instruction) Arg2() (Value, Value)

Arg2 returns the first two arguments to this instruction.

func (*Instruction) Arg2WithLane added in v1.6.0 

func (i *Instruction) Arg2WithLane() (Value, Value, VecLane)

Arg2WithLane returns the first two arguments to this instruction, and the lane type.

func (*Instruction) Arg3 added in v1.6.0 

func (i *Instruction) Arg3() (Value, Value, Value)

Arg3 returns the first three arguments to this instruction.

func (*Instruction) ArgWithLane added in v1.6.0 

func (i *Instruction) ArgWithLane() (Value, VecLane)

ArgWithLane returns the first argument to this instruction, and the lane type.

func (*Instruction) Args 

func (i *Instruction) Args() (v1, v2, v3 Value, vs []Value)

Args returns the arguments to this instruction.

func (*Instruction) AsAtomicCas added in v1.7.0 

func (i *Instruction) AsAtomicCas(addr, exp, repl Value, size uint64) *Instruction

AsAtomicCas initializes this instruction as an atomic compare-and-swap. The size is in bytes and must be 1, 2, 4, or 8.

func (*Instruction) AsAtomicLoad added in v1.7.0 

func (i *Instruction) AsAtomicLoad(addr Value, size uint64, typ Type) *Instruction

AsAtomicLoad initializes this instruction as an atomic load. The size is in bytes and must be 1, 2, 4, or 8.

func (*Instruction) AsAtomicRmw added in v1.7.0 

func (i *Instruction) AsAtomicRmw(op AtomicRmwOp, addr, val Value, size uint64) *Instruction

AsAtomicRmw initializes this instruction as an atomic read-modify-write. The size is in bytes and must be 1, 2, 4, or 8.

func (*Instruction) AsAtomicStore added in v1.7.0 

func (i *Instruction) AsAtomicStore(addr, val Value, size uint64) *Instruction

AsAtomicLoad initializes this instruction as an atomic store. The size is in bytes and must be 1, 2, 4, or 8.

func (*Instruction) AsBand added in v1.6.0 

func (i *Instruction) AsBand(x, amount Value) *Instruction

AsBand initializes this instruction as an integer bitwise and instruction with OpcodeBand.

func (*Instruction) AsBitcast added in v1.6.0 

func (i *Instruction) AsBitcast(x Value, dstType Type) *Instruction

AsBitcast initializes this instruction as an instruction with OpcodeBitcast.

func (*Instruction) AsBor added in v1.6.0 

func (i *Instruction) AsBor(x, amount Value)

AsBor initializes this instruction as an integer bitwise or instruction with OpcodeBor.

func (*Instruction) AsBrTable 

func (i *Instruction) AsBrTable(index Value, targets []BasicBlock)

AsBrTable initializes this instruction as a branch-table instruction with OpcodeBrTable.

func (*Instruction) AsBrnz 

func (i *Instruction) AsBrnz(v Value, args Values, target BasicBlock) *Instruction

AsBrnz initializes this instruction as a branch-if-not-zero instruction with OpcodeBrnz.

func (*Instruction) AsBrz 

func (i *Instruction) AsBrz(v Value, args Values, target BasicBlock)

AsBrz initializes this instruction as a branch-if-zero instruction with OpcodeBrz.

func (*Instruction) AsBxor added in v1.6.0 

func (i *Instruction) AsBxor(x, amount Value)

AsBxor initializes this instruction as an integer bitwise xor instruction with OpcodeBxor.

func (*Instruction) AsCall 

func (i *Instruction) AsCall(ref FuncRef, sig *Signature, args Values)

AsCall initializes this instruction as a call instruction with OpcodeCall.

func (*Instruction) AsCallGoRuntimeMemmove added in v1.7.2 

func (i *Instruction) AsCallGoRuntimeMemmove(funcPtr Value, sig *Signature, args Values) *Instruction

AsCallGoRuntimeMemmove is the same as AsCallIndirect, but with a special flag set to indicate that it is a call to the Go runtime memmove function.

func (*Instruction) AsCallIndirect 

func (i *Instruction) AsCallIndirect(funcPtr Value, sig *Signature, args Values) *Instruction

AsCallIndirect initializes this instruction as a call-indirect instruction with OpcodeCallIndirect.

func (*Instruction) AsCeil added in v1.6.0 

func (i *Instruction) AsCeil(x Value) *Instruction

AsCeil initializes this instruction as an instruction with OpcodeCeil.

func (*Instruction) AsClz 

func (i *Instruction) AsClz(x Value)

AsClz initializes this instruction as a Count Leading Zeroes instruction with OpcodeClz.

func (*Instruction) AsCtz 

func (i *Instruction) AsCtz(x Value)

AsCtz initializes this instruction as a Count Trailing Zeroes instruction with OpcodeCtz.

func (*Instruction) AsExitIfTrueWithCode 

func (i *Instruction) AsExitIfTrueWithCode(ctx, c Value, code wazevoapi.ExitCode) *Instruction

AsExitIfTrueWithCode initializes this instruction as a trap instruction with OpcodeExitIfTrueWithCode.

func (*Instruction) AsExitWithCode 

func (i *Instruction) AsExitWithCode(ctx Value, code wazevoapi.ExitCode)

AsExitWithCode initializes this instruction as a trap instruction with OpcodeExitWithCode.

func (*Instruction) AsExtIaddPairwise added in v1.7.0 

func (i *Instruction) AsExtIaddPairwise(x Value, srcLane VecLane, signed bool) *Instruction

AsExtIaddPairwise initializes this instruction as a lane-wise integer extended pairwise addition instruction with OpcodeIaddPairwise on a vector.

func (*Instruction) AsExtLoad 

func (i *Instruction) AsExtLoad(op Opcode, ptr Value, offset uint32, dst64bit bool) *Instruction

AsExtLoad initializes this instruction as a store instruction with OpcodeLoad.

func (*Instruction) AsExtractlane added in v1.6.0 

func (i *Instruction) AsExtractlane(x Value, index byte, lane VecLane, signed bool) *Instruction

AsExtractlane initializes this instruction as an extract lane instruction with OpcodeExtractlane on vector.

func (*Instruction) AsF32const 

func (i *Instruction) AsF32const(f float32) *Instruction

AsF32const initializes this instruction as a 32-bit floating-point constant instruction with OpcodeF32const.

func (*Instruction) AsF64const 

func (i *Instruction) AsF64const(f float64) *Instruction

AsF64const initializes this instruction as a 64-bit floating-point constant instruction with OpcodeF64const.

func (*Instruction) AsFabs added in v1.6.0 

func (i *Instruction) AsFabs(x Value) *Instruction

AsFabs initializes this instruction as an instruction with OpcodeFabs.

func (*Instruction) AsFadd 

func (i *Instruction) AsFadd(x, y Value)

AsFadd initializes this instruction as a floating-point addition instruction with OpcodeFadd.

func (*Instruction) AsFallthroughJump 

func (i *Instruction) AsFallthroughJump()

AsFallthroughJump marks this instruction as a fallthrough jump.

func (*Instruction) AsFcmp 

func (i *Instruction) AsFcmp(x, y Value, c FloatCmpCond)

AsFcmp initializes this instruction as an integer comparison instruction with OpcodeFcmp.

func (*Instruction) AsFcopysign added in v1.6.0 

func (i *Instruction) AsFcopysign(x, y Value) *Instruction

AsFcopysign initializes this instruction as an instruction with OpcodeFcopysign.

func (*Instruction) AsFcvtFromInt 

func (i *Instruction) AsFcvtFromInt(x Value, signed bool, dst64bit bool) *Instruction

AsFcvtFromInt initializes this instruction as an instruction with either OpcodeFcvtFromUint or OpcodeFcvtFromSint

func (*Instruction) AsFcvtToInt added in v1.6.0 

func (i *Instruction) AsFcvtToInt(x, ctx Value, signed bool, dst64bit bool, sat bool) *Instruction

AsFcvtToInt initializes this instruction as an instruction with either OpcodeFcvtToUint or OpcodeFcvtToSint

func (*Instruction) AsFdemote added in v1.6.0 

func (i *Instruction) AsFdemote(x Value)

AsFdemote initializes this instruction as an instruction with OpcodeFdemote.

func (*Instruction) AsFdiv 

func (i *Instruction) AsFdiv(x, y Value)

AsFdiv initializes this instruction as a floating-point division instruction with OpcodeFdiv.

func (*Instruction) AsFence added in v1.7.0 

func (i *Instruction) AsFence(order byte) *Instruction

AsFence initializes this instruction as a memory fence. A single byte immediate may be used to indicate fence ordering in the future but is currently always 0 and ignored.

func (*Instruction) AsFloor added in v1.6.0 

func (i *Instruction) AsFloor(x Value) *Instruction

AsFloor initializes this instruction as an instruction with OpcodeFloor.

func (*Instruction) AsFmax 

func (i *Instruction) AsFmax(x, y Value)

AsFmax initializes this instruction to take the maximum of two floating-points with OpcodeFmax.

func (*Instruction) AsFmin 

func (i *Instruction) AsFmin(x, y Value)

AsFmin initializes this instruction to take the minimum of two floating-points with OpcodeFmin.

func (*Instruction) AsFmul 

func (i *Instruction) AsFmul(x, y Value)

AsFmul initializes this instruction as a floating-point multiplication instruction with OpcodeFmul.

func (*Instruction) AsFneg 

func (i *Instruction) AsFneg(x Value) *Instruction

AsFneg initializes this instruction as an instruction with OpcodeFneg.

func (*Instruction) AsFpromote 

func (i *Instruction) AsFpromote(x Value)

AsFpromote initializes this instruction as an instruction with OpcodeFpromote.

func (*Instruction) AsFsub 

func (i *Instruction) AsFsub(x, y Value)

AsFsub initializes this instruction as a floating-point subtraction instruction with OpcodeFsub.

func (*Instruction) AsFvdemote added in v1.6.0 

func (i *Instruction) AsFvdemote(x Value, lane VecLane) *Instruction

AsFvdemote initializes this instruction as an instruction with OpcodeFvdemote

func (*Instruction) AsFvpromoteLow added in v1.6.0 

func (i *Instruction) AsFvpromoteLow(x Value, lane VecLane) *Instruction

AsFvpromoteLow initializes this instruction as an instruction with OpcodeFvpromoteLow

func (*Instruction) AsIadd 

func (i *Instruction) AsIadd(x, y Value) *Instruction

AsIadd initializes this instruction as an integer addition instruction with OpcodeIadd.

func (*Instruction) AsIcmp 

func (i *Instruction) AsIcmp(x, y Value, c IntegerCmpCond) *Instruction

AsIcmp initializes this instruction as an integer comparison instruction with OpcodeIcmp.

func (*Instruction) AsIconst32 

func (i *Instruction) AsIconst32(v uint32) *Instruction

AsIconst32 initializes this instruction as a 32-bit integer constant instruction with OpcodeIconst.

func (*Instruction) AsIconst64 

func (i *Instruction) AsIconst64(v uint64) *Instruction

AsIconst64 initializes this instruction as a 64-bit integer constant instruction with OpcodeIconst.

func (*Instruction) AsImul 

func (i *Instruction) AsImul(x, y Value) *Instruction

AsImul initializes this instruction as an integer addition instruction with OpcodeImul.

func (*Instruction) AsInsertlane added in v1.6.0 

func (i *Instruction) AsInsertlane(x, y Value, index byte, lane VecLane) *Instruction

AsInsertlane initializes this instruction as an insert lane instruction with OpcodeInsertlane on vector.

func (*Instruction) AsIreduce 

func (i *Instruction) AsIreduce(v Value, dstType Type) *Instruction

AsIreduce initializes this instruction as a reduction instruction with OpcodeIreduce.

func (*Instruction) AsIshl 

func (i *Instruction) AsIshl(x, amount Value) *Instruction

AsIshl initializes this instruction as an integer shift left instruction with OpcodeIshl.

func (*Instruction) AsIsub 

func (i *Instruction) AsIsub(x, y Value) *Instruction

AsIsub initializes this instruction as an integer subtraction instruction with OpcodeIsub.

func (*Instruction) AsJump 

func (i *Instruction) AsJump(vs Values, target BasicBlock) *Instruction

AsJump initializes this instruction as a jump instruction with OpcodeJump.

func (*Instruction) AsLoad 

func (i *Instruction) AsLoad(ptr Value, offset uint32, typ Type) *Instruction

AsLoad initializes this instruction as a store instruction with OpcodeLoad.

func (*Instruction) AsLoadSplat added in v1.6.0 

func (i *Instruction) AsLoadSplat(ptr Value, offset uint32, lane VecLane) *Instruction

AsLoadSplat initializes this instruction as a store instruction with OpcodeLoadSplat.

func (*Instruction) AsNarrow added in v1.6.0 

func (i *Instruction) AsNarrow(x, y Value, lane VecLane, signed bool) *Instruction

AsNarrow initializes this instruction as an instruction with either OpcodeSnarrow or OpcodeUnarrow

func (*Instruction) AsNearest added in v1.6.0 

func (i *Instruction) AsNearest(x Value) *Instruction

AsNearest initializes this instruction as an instruction with OpcodeNearest.

func (*Instruction) AsPopcnt 

func (i *Instruction) AsPopcnt(x Value)

AsPopcnt initializes this instruction as a Population Count instruction with OpcodePopcnt.

func (*Instruction) AsReturn 

func (i *Instruction) AsReturn(vs wazevoapi.VarLength[Value]) *Instruction

AsReturn initializes this instruction as a return instruction with OpcodeReturn.

func (*Instruction) AsRotl added in v1.6.0 

func (i *Instruction) AsRotl(x, amount Value)

AsRotl initializes this instruction as a word rotate left instruction with OpcodeRotl.

func (*Instruction) AsRotr added in v1.6.0 

func (i *Instruction) AsRotr(x, amount Value)

AsRotr initializes this instruction as a word rotate right instruction with OpcodeRotr.

func (*Instruction) AsSDiv added in v1.6.0 

func (i *Instruction) AsSDiv(x, y, ctx Value) *Instruction

AsSDiv initializes this instruction as an integer bitwise and instruction with OpcodeSdiv.

func (*Instruction) AsSExtend 

func (i *Instruction) AsSExtend(v Value, from, to byte) *Instruction

AsSExtend initializes this instruction as a sign extension instruction with OpcodeSExtend.

func (*Instruction) AsSRem added in v1.6.0 

func (i *Instruction) AsSRem(x, y, ctx Value) *Instruction

AsSRem initializes this instruction as an integer bitwise and instruction with OpcodeSrem.

func (*Instruction) AsSelect 

func (i *Instruction) AsSelect(c, x, y Value) *Instruction

AsSelect initializes this instruction as an unsigned extension instruction with OpcodeSelect.

func (*Instruction) AsShuffle added in v1.6.0 

func (i *Instruction) AsShuffle(x, y Value, lane []byte) *Instruction

AsShuffle initializes this instruction as a shuffle instruction with OpcodeShuffle on vector.

func (*Instruction) AsSplat added in v1.6.0 

func (i *Instruction) AsSplat(x Value, lane VecLane) *Instruction

AsSplat initializes this instruction as an insert lane instruction with OpcodeSplat on vector.

func (*Instruction) AsSqmulRoundSat added in v1.6.0 

func (i *Instruction) AsSqmulRoundSat(x, y Value, lane VecLane) *Instruction

AsSqmulRoundSat initializes this instruction as a lane-wise saturating rounding multiplication in Q15 format with OpcodeSqmulRoundSat on a vector.

func (*Instruction) AsSqrt added in v1.6.0 

func (i *Instruction) AsSqrt(x Value) *Instruction

AsSqrt initializes this instruction as an instruction with OpcodeSqrt.

func (*Instruction) AsSshr 

func (i *Instruction) AsSshr(x, amount Value) *Instruction

AsSshr initializes this instruction as an integer signed shift right (arithmetic shift right) instruction with OpcodeSshr.

func (*Instruction) AsStore 

func (i *Instruction) AsStore(storeOp Opcode, value, ptr Value, offset uint32) *Instruction

AsStore initializes this instruction as a store instruction with OpcodeStore.

func (*Instruction) AsSwizzle added in v1.6.0 

func (i *Instruction) AsSwizzle(x, y Value, lane VecLane) *Instruction

AsSwizzle initializes this instruction as an insert lane instruction with OpcodeSwizzle on vector.

func (*Instruction) AsTrunc added in v1.6.0 

func (i *Instruction) AsTrunc(x Value) *Instruction

AsTrunc initializes this instruction as an instruction with OpcodeTrunc.

func (*Instruction) AsUDiv added in v1.6.0 

func (i *Instruction) AsUDiv(x, y, ctx Value) *Instruction

AsUDiv initializes this instruction as an integer bitwise and instruction with OpcodeUdiv.

func (*Instruction) AsUExtend 

func (i *Instruction) AsUExtend(v Value, from, to byte) *Instruction

AsUExtend initializes this instruction as an unsigned extension instruction with OpcodeUExtend.

func (*Instruction) AsURem added in v1.6.0 

func (i *Instruction) AsURem(x, y, ctx Value) *Instruction

AsURem initializes this instruction as an integer bitwise and instruction with OpcodeUrem.

func (*Instruction) AsUshr 

func (i *Instruction) AsUshr(x, amount Value) *Instruction

AsUshr initializes this instruction as an integer unsigned shift right (logical shift right) instruction with OpcodeUshr.

func (*Instruction) AsVAvgRound added in v1.6.0 

func (i *Instruction) AsVAvgRound(x, y Value, lane VecLane) *Instruction

AsVAvgRound initializes this instruction as an unsigned integer avg instruction, truncating to zero with OpcodeVAvgRound on a vector.

func (*Instruction) AsVCeil added in v1.6.0 

func (i *Instruction) AsVCeil(x Value, lane VecLane) *Instruction

AsVCeil initializes this instruction as an instruction with OpcodeCeil.

func (*Instruction) AsVFabs added in v1.6.0 

func (i *Instruction) AsVFabs(x Value, lane VecLane) *Instruction

AsVFabs initializes this instruction as a float abs instruction with OpcodeVFabs on a vector.

func (*Instruction) AsVFadd added in v1.6.0 

func (i *Instruction) AsVFadd(x, y Value, lane VecLane) *Instruction

AsVFadd initializes this instruction as a floating point add instruction with OpcodeVFadd on a vector.

func (*Instruction) AsVFcmp added in v1.6.0 

func (i *Instruction) AsVFcmp(x, y Value, c FloatCmpCond, lane VecLane) *Instruction

AsVFcmp initializes this instruction as a float comparison instruction with OpcodeVFcmp on Vector.

func (*Instruction) AsVFcvtFromInt added in v1.6.0 

func (i *Instruction) AsVFcvtFromInt(x Value, lane VecLane, signed bool) *Instruction

AsVFcvtFromInt initializes this instruction as an instruction with either OpcodeVFcvtToSintSat or OpcodeVFcvtToUintSat

func (*Instruction) AsVFcvtToIntSat added in v1.6.0 

func (i *Instruction) AsVFcvtToIntSat(x Value, lane VecLane, signed bool) *Instruction

AsVFcvtToIntSat initializes this instruction as an instruction with either OpcodeVFcvtToSintSat or OpcodeVFcvtToUintSat

func (*Instruction) AsVFdiv added in v1.6.0 

func (i *Instruction) AsVFdiv(x, y Value, lane VecLane) *Instruction

AsVFdiv initializes this instruction as a floating point division instruction with OpcodeVFdiv on a vector.

func (*Instruction) AsVFloor added in v1.6.0 

func (i *Instruction) AsVFloor(x Value, lane VecLane) *Instruction

AsVFloor initializes this instruction as an instruction with OpcodeFloor.

func (*Instruction) AsVFmax added in v1.6.0 

func (i *Instruction) AsVFmax(x, y Value, lane VecLane) *Instruction

AsVFmax initializes this instruction as a float max instruction with OpcodeVFmax on a vector.

func (*Instruction) AsVFmin added in v1.6.0 

func (i *Instruction) AsVFmin(x, y Value, lane VecLane) *Instruction

AsVFmin initializes this instruction as a float min instruction with OpcodeVFmin on a vector.

func (*Instruction) AsVFmul added in v1.6.0 

func (i *Instruction) AsVFmul(x, y Value, lane VecLane) *Instruction

AsVFmul initializes this instruction as a floating point multiplication instruction with OpcodeVFmul on a vector.

func (*Instruction) AsVFneg added in v1.6.0 

func (i *Instruction) AsVFneg(x Value, lane VecLane) *Instruction

AsVFneg initializes this instruction as a float neg instruction with OpcodeVFneg on a vector.

func (*Instruction) AsVFsub added in v1.6.0 

func (i *Instruction) AsVFsub(x, y Value, lane VecLane) *Instruction

AsVFsub initializes this instruction as a floating point subtraction instruction with OpcodeVFsub on a vector.

func (*Instruction) AsVIabs added in v1.6.0 

func (i *Instruction) AsVIabs(x Value, lane VecLane) *Instruction

AsVIabs initializes this instruction as a vector absolute value with OpcodeVIabs.

func (*Instruction) AsVIadd added in v1.6.0 

func (i *Instruction) AsVIadd(x, y Value, lane VecLane) *Instruction

AsVIadd initializes this instruction as an integer addition instruction with OpcodeVIadd on a vector.

func (*Instruction) AsVIcmp added in v1.6.0 

func (i *Instruction) AsVIcmp(x, y Value, c IntegerCmpCond, lane VecLane) *Instruction

AsVIcmp initializes this instruction as an integer vector comparison instruction with OpcodeVIcmp.

func (*Instruction) AsVImax added in v1.6.0 

func (i *Instruction) AsVImax(x, y Value, lane VecLane) *Instruction

AsVImax initializes this instruction as a signed integer max instruction with OpcodeVImax on a vector.

func (*Instruction) AsVImin added in v1.6.0 

func (i *Instruction) AsVImin(x, y Value, lane VecLane) *Instruction

AsVImin initializes this instruction as a signed integer min instruction with OpcodeVImin on a vector.

func (*Instruction) AsVImul added in v1.6.0 

func (i *Instruction) AsVImul(x, y Value, lane VecLane) *Instruction

AsVImul initializes this instruction as an integer multiplication with OpcodeVImul on a vector.

func (*Instruction) AsVIneg added in v1.6.0 

func (i *Instruction) AsVIneg(x Value, lane VecLane) *Instruction

AsVIneg initializes this instruction as a vector negation with OpcodeVIneg.

func (*Instruction) AsVIpopcnt added in v1.6.0 

func (i *Instruction) AsVIpopcnt(x Value, lane VecLane) *Instruction

AsVIpopcnt initializes this instruction as a Population Count instruction with OpcodeVIpopcnt on a vector.

func (*Instruction) AsVIshl added in v1.6.0 

func (i *Instruction) AsVIshl(x, amount Value, lane VecLane) *Instruction

AsVIshl initializes this instruction as an integer shift left instruction with OpcodeVIshl on vector.

func (*Instruction) AsVIsub added in v1.6.0 

func (i *Instruction) AsVIsub(x, y Value, lane VecLane) *Instruction

AsVIsub initializes this instruction as an integer subtraction instruction with OpcodeVIsub on a vector.

func (*Instruction) AsVMaxPseudo added in v1.6.0 

func (i *Instruction) AsVMaxPseudo(x, y Value, lane VecLane) *Instruction

AsVMaxPseudo initializes this instruction as an instruction with OpcodeVMaxPseudo.

func (*Instruction) AsVMinPseudo added in v1.6.0 

func (i *Instruction) AsVMinPseudo(x, y Value, lane VecLane) *Instruction

AsVMinPseudo initializes this instruction as an instruction with OpcodeVMinPseudo.

func (*Instruction) AsVNearest added in v1.6.0 

func (i *Instruction) AsVNearest(x Value, lane VecLane) *Instruction

AsVNearest initializes this instruction as an instruction with OpcodeNearest.

func (*Instruction) AsVSaddSat added in v1.6.0 

func (i *Instruction) AsVSaddSat(x, y Value, lane VecLane) *Instruction

AsVSaddSat initializes this instruction as a vector addition with saturation instruction with OpcodeVSaddSat on a vector.

func (*Instruction) AsVSqrt added in v1.6.0 

func (i *Instruction) AsVSqrt(x Value, lane VecLane) *Instruction

AsVSqrt initializes this instruction as a sqrt instruction with OpcodeVSqrt on a vector.

func (*Instruction) AsVSshr added in v1.6.0 

func (i *Instruction) AsVSshr(x, amount Value, lane VecLane) *Instruction

AsVSshr initializes this instruction as an integer signed shift right (arithmetic shift right) instruction with OpcodeVSshr on vector.

func (*Instruction) AsVSsubSat added in v1.6.0 

func (i *Instruction) AsVSsubSat(x, y Value, lane VecLane) *Instruction

AsVSsubSat initializes this instruction as a vector addition with saturation instruction with OpcodeVSsubSat on a vector.

func (*Instruction) AsVTrunc added in v1.6.0 

func (i *Instruction) AsVTrunc(x Value, lane VecLane) *Instruction

AsVTrunc initializes this instruction as an instruction with OpcodeTrunc.

func (*Instruction) AsVUaddSat added in v1.6.0 

func (i *Instruction) AsVUaddSat(x, y Value, lane VecLane) *Instruction

AsVUaddSat initializes this instruction as a vector addition with saturation instruction with OpcodeVUaddSat on a vector.

func (*Instruction) AsVUmax added in v1.6.0 

func (i *Instruction) AsVUmax(x, y Value, lane VecLane) *Instruction

AsVUmax initializes this instruction as an unsigned integer max instruction with OpcodeVUmax on a vector.

func (*Instruction) AsVUmin added in v1.6.0 

func (i *Instruction) AsVUmin(x, y Value, lane VecLane) *Instruction

AsVUmin initializes this instruction as an unsigned integer min instruction with OpcodeVUmin on a vector.

func (*Instruction) AsVUshr added in v1.6.0 

func (i *Instruction) AsVUshr(x, amount Value, lane VecLane) *Instruction

AsVUshr initializes this instruction as an integer unsigned shift right (logical shift right) instruction with OpcodeVUshr on vector.

func (*Instruction) AsVUsubSat added in v1.6.0 

func (i *Instruction) AsVUsubSat(x, y Value, lane VecLane) *Instruction

AsVUsubSat initializes this instruction as a vector addition with saturation instruction with OpcodeVUsubSat on a vector.

func (*Instruction) AsVZeroExtLoad added in v1.6.0 

func (i *Instruction) AsVZeroExtLoad(ptr Value, offset uint32, scalarType Type) *Instruction

AsVZeroExtLoad initializes this instruction as a store instruction with OpcodeVExtLoad.

func (*Instruction) AsVallTrue added in v1.6.0 

func (i *Instruction) AsVallTrue(x Value, lane VecLane) *Instruction

AsVallTrue initializes this instruction as an allTrue vector instruction with OpcodeVallTrue.

func (*Instruction) AsVanyTrue added in v1.6.0 

func (i *Instruction) AsVanyTrue(x Value) *Instruction

AsVanyTrue initializes this instruction as an anyTrue vector instruction with OpcodeVanyTrue.

func (*Instruction) AsVband added in v1.6.0 

func (i *Instruction) AsVband(x, y Value) *Instruction

AsVband initializes this instruction as an and vector instruction with OpcodeVband.

func (*Instruction) AsVbandnot added in v1.6.0 

func (i *Instruction) AsVbandnot(x, y Value) *Instruction

AsVbandnot initializes this instruction as an and-not vector instruction with OpcodeVbandnot.

func (*Instruction) AsVbitselect added in v1.6.0 

func (i *Instruction) AsVbitselect(c, x, y Value) *Instruction

AsVbitselect initializes this instruction as a bit select vector instruction with OpcodeVbitselect.

func (*Instruction) AsVbnot added in v1.6.0 

func (i *Instruction) AsVbnot(v Value) *Instruction

AsVbnot initializes this instruction as a vector negation instruction with OpcodeVbnot.

func (*Instruction) AsVbor added in v1.6.0 

func (i *Instruction) AsVbor(x, y Value) *Instruction

AsVbor initializes this instruction as an or vector instruction with OpcodeVbor.

func (*Instruction) AsVbxor added in v1.6.0 

func (i *Instruction) AsVbxor(x, y Value) *Instruction

AsVbxor initializes this instruction as a xor vector instruction with OpcodeVbxor.

func (*Instruction) AsVconst added in v1.6.0 

func (i *Instruction) AsVconst(lo, hi uint64) *Instruction

AsVconst initializes this instruction as a vector constant instruction with OpcodeVconst.

func (*Instruction) AsVhighBits added in v1.6.0 

func (i *Instruction) AsVhighBits(x Value, lane VecLane) *Instruction

AsVhighBits initializes this instruction as a highBits vector instruction with OpcodeVhighBits.

func (*Instruction) AsWiden added in v1.6.0 

func (i *Instruction) AsWiden(v Value, lane VecLane, signed, low bool) *Instruction

AsWiden initializes this instruction as a signed or unsigned widen instruction on low half or high half of the given vector with OpcodeSwidenLow, OpcodeUwidenLow, OpcodeSwidenHigh, OpcodeUwidenHigh.

func (*Instruction) AsWideningPairwiseDotProductS added in v1.7.0 

func (i *Instruction) AsWideningPairwiseDotProductS(x, y Value) *Instruction

AsWideningPairwiseDotProductS initializes this instruction as a lane-wise integer extended pairwise addition instruction with OpcodeIaddPairwise on a vector.

func (*Instruction) AtomicRmwData added in v1.7.0 

func (i *Instruction) AtomicRmwData() (op AtomicRmwOp, size uint64)

AtomicRmwData returns the data for this atomic read-modify-write instruction.

func (*Instruction) AtomicTargetSize added in v1.7.0 

func (i *Instruction) AtomicTargetSize() (size uint64)

AtomicTargetSize returns the target memory size of the atomic instruction.

func (*Instruction) BitcastData added in v1.6.0 

func (i *Instruction) BitcastData() (x Value, dstType Type)

BitcastData returns the operands for a bitcast instruction.

func (*Instruction) BrTableData 

func (i *Instruction) BrTableData() (index Value, targets []BasicBlock)

BrTableData returns the branch table data for this instruction necessary for backends.

func (*Instruction) BranchData 

func (i *Instruction) BranchData() (condVal Value, blockArgs []Value, target BasicBlock)

BranchData returns the branch data for this instruction necessary for backends.

func (*Instruction) CallData 

func (i *Instruction) CallData() (ref FuncRef, sigID SignatureID, args []Value)

CallData returns the call data for this instruction necessary for backends.

func (*Instruction) CallIndirectData 

func (i *Instruction) CallIndirectData() (funcPtr Value, sigID SignatureID, args []Value, isGoMemmove bool)

CallIndirectData returns the call indirect data for this instruction necessary for backends.

func (*Instruction) Constant 

func (i *Instruction) Constant() bool

Constant returns true if this instruction is a constant instruction.

func (*Instruction) ConstantVal 

func (i *Instruction) ConstantVal() (ret uint64)

ConstantVal returns the constant value of this instruction. How to interpret the return value depends on the opcode.

func (*Instruction) ExitIfTrueWithCodeData 

func (i *Instruction) ExitIfTrueWithCodeData() (ctx, c Value, code wazevoapi.ExitCode)

ExitIfTrueWithCodeData returns the context and exit code of OpcodeExitWithCode.

func (*Instruction) ExitWithCodeData 

func (i *Instruction) ExitWithCodeData() (ctx Value, code wazevoapi.ExitCode)

ExitWithCodeData returns the context and exit code of OpcodeExitWithCode.

func (*Instruction) ExtIaddPairwiseData added in v1.7.0 

func (i *Instruction) ExtIaddPairwiseData() (x Value, srcLane VecLane, signed bool)

ExtIaddPairwiseData returns the operands for a lane-wise integer extended pairwise addition instruction.

func (*Instruction) ExtendData 

func (i *Instruction) ExtendData() (from, to byte, signed bool)

func (*Instruction) ExtendFromToBits 

func (i *Instruction) ExtendFromToBits() (from, to byte)

ExtendFromToBits returns the from and to bit size for the extension instruction.

func (*Instruction) ExtractlaneData added in v1.6.0 

func (i *Instruction) ExtractlaneData() (x Value, index byte, signed bool, l VecLane)

ExtractlaneData returns the operands and sign flag of Extractlane on vector.

func (*Instruction) FcmpData 

func (i *Instruction) FcmpData() (x, y Value, c FloatCmpCond)

FcmpData returns the operands and comparison condition of this floating-point comparison instruction.

func (*Instruction) Format 

func (i *Instruction) Format(b Builder) string

Format returns a string representation of this instruction with the given builder. For debugging purposes only.

func (*Instruction) GroupID 

func (i *Instruction) GroupID() InstructionGroupID

GroupID returns the InstructionGroupID of this instruction.

func (*Instruction) IcmpData 

func (i *Instruction) IcmpData() (x, y Value, c IntegerCmpCond)

IcmpData returns the operands and comparison condition of this integer comparison instruction.

func (*Instruction) Insert 

func (i *Instruction) Insert(b Builder) *Instruction

func (*Instruction) InsertlaneData added in v1.6.0 

func (i *Instruction) InsertlaneData() (x, y Value, index byte, l VecLane)

InsertlaneData returns the operands and sign flag of Insertlane on vector.

func (*Instruction) InvertBrx 

func (i *Instruction) InvertBrx()

InvertBrx inverts either OpcodeBrz or OpcodeBrnz to the other.

func (*Instruction) IsBranching 

func (i *Instruction) IsBranching() bool

IsBranching returns true if this instruction is a branching instruction.

func (*Instruction) IsFallthroughJump 

func (i *Instruction) IsFallthroughJump() bool

IsFallthroughJump returns true if this instruction is a fallthrough jump.

func (*Instruction) LoadData 

func (i *Instruction) LoadData() (ptr Value, offset uint32, typ Type)

LoadData returns the operands for a load instruction.

func (*Instruction) LoadSplatData added in v1.6.0 

func (i *Instruction) LoadSplatData() (ptr Value, offset uint32, lane VecLane)

LoadSplatData returns the operands for a load splat instruction.

func (*Instruction) Lowered added in v1.6.0 

func (i *Instruction) Lowered() bool

Lowered returns true if this instruction is already lowered.

func (*Instruction) MarkLowered added in v1.6.0 

func (i *Instruction) MarkLowered()

MarkLowered marks this instruction as already lowered.

func (*Instruction) Next 

func (i *Instruction) Next() *Instruction

Next returns the next instruction laid out next to itself.

func (*Instruction) Opcode 

func (i *Instruction) Opcode() Opcode

Opcode returns the opcode of this instruction.

func (*Instruction) Prev 

func (i *Instruction) Prev() *Instruction

Prev returns the previous instruction laid out prior to itself.

func (*Instruction) Return 

func (i *Instruction) Return() (first Value)

Return returns a Value(s) produced by this instruction if any. If there's multiple return values, only the first one is returned.

func (*Instruction) ReturnVals 

func (i *Instruction) ReturnVals() []Value

ReturnVals returns the return values of OpcodeReturn.

func (*Instruction) Returns 

func (i *Instruction) Returns() (first Value, rest []Value)

Returns Value(s) produced by this instruction if any. The `first` is the first return value, and `rest` is the rest of the values.

func (*Instruction) SelectData 

func (i *Instruction) SelectData() (c, x, y Value)

SelectData returns the select data for this instruction necessary for backends.

func (*Instruction) ShuffleData added in v1.6.0 

func (i *Instruction) ShuffleData() (v Value, v2 Value, lo uint64, hi uint64)

ShuffleData returns the first two arguments to this instruction and 2 uint64s `lo`, `hi`.

Note: Each uint64 encodes a sequence of 8 bytes where each byte encodes a VecLane, so that the 128bit integer `hi<<64|lo` packs a slice `[16]VecLane`, where `lane[0]` is the least significant byte, and `lane[n]` is shifted to offset `n*8`.

func (*Instruction) SourceOffset added in v1.6.0 

func (i *Instruction) SourceOffset() SourceOffset

SourceOffset returns the source offset of this instruction.

func (*Instruction) StoreData 

func (i *Instruction) StoreData() (value, ptr Value, offset uint32, storeSizeInBits byte)

StoreData returns the operands for a store instruction.

func (*Instruction) VFcmpData added in v1.6.0 

func (i *Instruction) VFcmpData() (x, y Value, c FloatCmpCond, l VecLane)

VFcmpData returns the operands and comparison condition of this float comparison instruction on vector.

func (*Instruction) VIcmpData added in v1.6.0 

func (i *Instruction) VIcmpData() (x, y Value, c IntegerCmpCond, l VecLane)

VIcmpData returns the operands and comparison condition of this integer comparison instruction on vector.

func (*Instruction) VZeroExtLoadData added in v1.6.0 

func (i *Instruction) VZeroExtLoadData() (ptr Value, offset uint32, typ Type)

VZeroExtLoadData returns the operands for a load instruction. The returned `typ` is the scalar type of the load target.

func (*Instruction) VconstData added in v1.6.0 

func (i *Instruction) VconstData() (lo, hi uint64)

VconstData returns the operands of this vector constant instruction.

type InstructionGroupID 

type InstructionGroupID uint32

InstructionGroupID is assigned to each instruction and represents a group of instructions where each instruction is interchangeable with others except for the last instruction in the group which has side effects. In short, InstructionGroupID is determined by the side effects of instructions. That means, if there's an instruction with side effect between two instructions, then these two instructions will have different instructionGroupID. Note that each block always ends with branching, which is with side effects, therefore, instructions in different blocks always have different InstructionGroupID(s).

The notable application of this is used in lowering SSA-level instruction to a ISA specific instruction, where we eagerly try to merge multiple instructions into single operation etc. Such merging cannot be done if these instruction have different InstructionGroupID since it will change the semantics of a program.

See passDeadCodeElimination.

type IntegerCmpCond 

type IntegerCmpCond byte

IntegerCmpCond represents a condition for integer comparison. 

const (
	// IntegerCmpCondInvalid represents an invalid condition.
	IntegerCmpCondInvalid IntegerCmpCond = iota
	// IntegerCmpCondEqual represents "==".
	IntegerCmpCondEqual
	// IntegerCmpCondNotEqual represents "!=".
	IntegerCmpCondNotEqual
	// IntegerCmpCondSignedLessThan represents Signed "<".
	IntegerCmpCondSignedLessThan
	// IntegerCmpCondSignedGreaterThanOrEqual represents Signed ">=".
	IntegerCmpCondSignedGreaterThanOrEqual
	// IntegerCmpCondSignedGreaterThan represents Signed ">".
	IntegerCmpCondSignedGreaterThan
	// IntegerCmpCondSignedLessThanOrEqual represents Signed "<=".
	IntegerCmpCondSignedLessThanOrEqual
	// IntegerCmpCondUnsignedLessThan represents Unsigned "<".
	IntegerCmpCondUnsignedLessThan
	// IntegerCmpCondUnsignedGreaterThanOrEqual represents Unsigned ">=".
	IntegerCmpCondUnsignedGreaterThanOrEqual
	// IntegerCmpCondUnsignedGreaterThan represents Unsigned ">".
	IntegerCmpCondUnsignedGreaterThan
	// IntegerCmpCondUnsignedLessThanOrEqual represents Unsigned "<=".
	IntegerCmpCondUnsignedLessThanOrEqual
)

func (IntegerCmpCond) Signed 

func (i IntegerCmpCond) Signed() bool

Signed returns true if the condition is signed integer comparison.

func (IntegerCmpCond) String 

func (i IntegerCmpCond) String() string

String implements fmt.Stringer.

type Opcode 

type Opcode uint32

Opcode represents a SSA instruction. 

const (
	OpcodeInvalid Opcode = iota

	// OpcodeUndefined is a placeholder for undefined opcode. This can be used for debugging to intentionally
	// cause a crash at certain point.
	OpcodeUndefined

	// OpcodeJump takes the list of args to the `block` and unconditionally jumps to it.
	OpcodeJump

	// OpcodeBrz branches into `blk` with `args`  if the value `c` equals zero: `Brz c, blk, args`.
	OpcodeBrz

	// OpcodeBrnz branches into `blk` with `args`  if the value `c` is not zero: `Brnz c, blk, args`.
	OpcodeBrnz

	// OpcodeBrTable takes the index value `index`, and branches into `labelX`. If the `index` is out of range,
	// it branches into the last labelN: `BrTable index, [label1, label2, ... labelN]`.
	OpcodeBrTable

	// OpcodeExitWithCode exit the execution immediately.
	OpcodeExitWithCode

	// OpcodeExitIfTrueWithCode exits the execution immediately if the value `c` is not zero.
	OpcodeExitIfTrueWithCode

	// OpcodeReturn returns from the function: `return rvalues`.
	OpcodeReturn

	// OpcodeCall calls a function specified by the symbol FN with arguments `args`: `returnvals = Call FN, args...`
	// This is a "near" call, which means the call target is known at compile time, and the target is relatively close
	// to this function. If the target cannot be reached by near call, the backend fails to compile.
	OpcodeCall

	// OpcodeCallIndirect calls a function specified by `callee` which is a function address: `returnvals = call_indirect SIG, callee, args`.
	// Note that this is different from call_indirect in Wasm, which also does type checking, etc.
	OpcodeCallIndirect

	// OpcodeSplat performs a vector splat operation: `v = Splat.lane x`.
	OpcodeSplat

	// OpcodeSwizzle performs a vector swizzle operation: `v = Swizzle.lane x, y`.
	OpcodeSwizzle

	// OpcodeInsertlane inserts a lane value into a vector: `v = InsertLane x, y, Idx`.
	OpcodeInsertlane

	// OpcodeExtractlane extracts a lane value from a vector: `v = ExtractLane x, Idx`.
	OpcodeExtractlane

	// OpcodeLoad loads a Type value from the [base + offset] address: `v = Load base, offset`.
	OpcodeLoad

	// OpcodeStore stores a Type value to the [base + offset] address: `Store v, base, offset`.
	OpcodeStore

	// OpcodeUload8 loads the 8-bit value from the [base + offset] address, zero-extended to 64 bits: `v = Uload8 base, offset`.
	OpcodeUload8

	// OpcodeSload8 loads the 8-bit value from the [base + offset] address, sign-extended to 64 bits: `v = Sload8 base, offset`.
	OpcodeSload8

	// OpcodeIstore8 stores the 8-bit value to the [base + offset] address, sign-extended to 64 bits: `Istore8 v, base, offset`.
	OpcodeIstore8

	// OpcodeUload16 loads the 16-bit value from the [base + offset] address, zero-extended to 64 bits: `v = Uload16 base, offset`.
	OpcodeUload16

	// OpcodeSload16 loads the 16-bit value from the [base + offset] address, sign-extended to 64 bits: `v = Sload16 base, offset`.
	OpcodeSload16

	// OpcodeIstore16 stores the 16-bit value to the [base + offset] address, zero-extended to 64 bits: `Istore16 v, base, offset`.
	OpcodeIstore16

	// OpcodeUload32 loads the 32-bit value from the [base + offset] address, zero-extended to 64 bits: `v = Uload32 base, offset`.
	OpcodeUload32

	// OpcodeSload32 loads the 32-bit value from the [base + offset] address, sign-extended to 64 bits: `v = Sload32 base, offset`.
	OpcodeSload32

	// OpcodeIstore32 stores the 32-bit value to the [base + offset] address, zero-extended to 64 bits: `Istore16 v, base, offset`.
	OpcodeIstore32

	// OpcodeLoadSplat represents a load that replicates the loaded value to all lanes `v = LoadSplat.lane p, Offset`.
	OpcodeLoadSplat

	// OpcodeVZeroExtLoad loads a scalar single/double precision floating point value from the [p + Offset] address,
	// and zero-extend it to the V128 value: `v = VExtLoad  p, Offset`.
	OpcodeVZeroExtLoad

	// OpcodeIconst represents the integer const.
	OpcodeIconst

	// OpcodeF32const represents the single-precision const.
	OpcodeF32const

	// OpcodeF64const represents the double-precision const.
	OpcodeF64const

	// OpcodeVconst represents the 128bit vector const.
	OpcodeVconst

	// OpcodeVbor computes binary or between two 128bit vectors: `v = bor x, y`.
	OpcodeVbor

	// OpcodeVbxor computes binary xor between two 128bit vectors: `v = bxor x, y`.
	OpcodeVbxor

	// OpcodeVband computes binary and between two 128bit vectors: `v = band x, y`.
	OpcodeVband

	// OpcodeVbandnot computes binary and-not between two 128bit vectors: `v = bandnot x, y`.
	OpcodeVbandnot

	// OpcodeVbnot negates a 128bit vector: `v = bnot x`.
	OpcodeVbnot

	// OpcodeVbitselect uses the bits in the control mask c to select the corresponding bit from x when 1
	// and y when 0: `v = bitselect c, x, y`.
	OpcodeVbitselect

	// OpcodeShuffle shuffles two vectors using the given 128-bit immediate: `v = shuffle imm, x, y`.
	// For each byte in the immediate, a value i in [0, 15] selects the i-th byte in vector x;
	// i in [16, 31] selects the (i-16)-th byte in vector y.
	OpcodeShuffle

	// OpcodeSelect chooses between two values based on a condition `c`: `v = Select c, x, y`.
	OpcodeSelect

	// OpcodeVanyTrue performs a any true operation: `s = VanyTrue a`.
	OpcodeVanyTrue

	// OpcodeVallTrue performs a lane-wise all true operation: `s = VallTrue.lane a`.
	OpcodeVallTrue

	// OpcodeVhighBits performs a lane-wise extract of the high bits: `v = VhighBits.lane a`.
	OpcodeVhighBits

	// OpcodeIcmp compares two integer values with the given condition: `v = icmp Cond, x, y`.
	OpcodeIcmp

	// OpcodeVIcmp compares two integer values with the given condition: `v = vicmp Cond, x, y` on vector.
	OpcodeVIcmp

	// OpcodeIcmpImm compares an integer value with the immediate value on the given condition: `v = icmp_imm Cond, x, Y`.
	OpcodeIcmpImm

	// OpcodeIadd performs an integer addition: `v = Iadd x, y`.
	OpcodeIadd

	// OpcodeVIadd performs an integer addition: `v = VIadd.lane x, y` on vector.
	OpcodeVIadd

	// OpcodeVSaddSat performs a signed saturating vector addition: `v = VSaddSat.lane x, y` on vector.
	OpcodeVSaddSat

	// OpcodeVUaddSat performs an unsigned saturating vector addition: `v = VUaddSat.lane x, y` on vector.
	OpcodeVUaddSat

	// OpcodeIsub performs an integer subtraction: `v = Isub x, y`.
	OpcodeIsub

	// OpcodeVIsub performs an integer subtraction: `v = VIsub.lane x, y` on vector.
	OpcodeVIsub

	// OpcodeVSsubSat performs a signed saturating vector subtraction: `v = VSsubSat.lane x, y` on vector.
	OpcodeVSsubSat

	// OpcodeVUsubSat performs an unsigned saturating vector subtraction: `v = VUsubSat.lane x, y` on vector.
	OpcodeVUsubSat

	// OpcodeVImin performs a signed integer min: `v = VImin.lane x, y` on vector.
	OpcodeVImin

	// OpcodeVUmin performs an unsigned integer min: `v = VUmin.lane x, y` on vector.
	OpcodeVUmin

	// OpcodeVImax performs a signed integer max: `v = VImax.lane x, y` on vector.
	OpcodeVImax

	// OpcodeVUmax performs an unsigned integer max: `v = VUmax.lane x, y` on vector.
	OpcodeVUmax

	// OpcodeVAvgRound performs an unsigned integer avg, truncating to zero: `v = VAvgRound.lane x, y` on vector.
	OpcodeVAvgRound

	// OpcodeVImul performs an integer multiplication: `v = VImul.lane x, y` on vector.
	OpcodeVImul

	// OpcodeVIneg negates the given integer vector value: `v = VIneg x`.
	OpcodeVIneg

	// OpcodeVIpopcnt counts the number of 1-bits in the given vector: `v = VIpopcnt x`.
	OpcodeVIpopcnt

	// OpcodeVIabs returns the absolute value for the given vector value: `v = VIabs.lane x`.
	OpcodeVIabs

	// OpcodeVIshl shifts x left by (y mod lane-width): `v = VIshl.lane x, y` on vector.
	OpcodeVIshl

	// OpcodeVUshr shifts x right by (y mod lane-width), unsigned: `v = VUshr.lane x, y` on vector.
	OpcodeVUshr

	// OpcodeVSshr shifts x right by (y mod lane-width), signed: `v = VSshr.lane x, y` on vector.
	OpcodeVSshr

	// OpcodeVFabs takes the absolute value of a floating point value: `v = VFabs.lane x on vector.
	OpcodeVFabs

	// OpcodeVFmax takes the maximum of two floating point values: `v = VFmax.lane x, y on vector.
	OpcodeVFmax

	// OpcodeVFmin takes the minimum of two floating point values: `v = VFmin.lane x, y on vector.
	OpcodeVFmin

	// OpcodeVFneg negates the given floating point vector value: `v = VFneg x`.
	OpcodeVFneg

	// OpcodeVFadd performs a floating point addition: `v = VFadd.lane x, y` on vector.
	OpcodeVFadd

	// OpcodeVFsub performs a floating point subtraction: `v = VFsub.lane x, y` on vector.
	OpcodeVFsub

	// OpcodeVFmul performs a floating point multiplication: `v = VFmul.lane x, y` on vector.
	OpcodeVFmul

	// OpcodeVFdiv performs a floating point division: `v = VFdiv.lane x, y` on vector.
	OpcodeVFdiv

	// OpcodeVFcmp compares two float values with the given condition: `v = VFcmp.lane Cond, x, y` on float.
	OpcodeVFcmp

	// OpcodeVCeil takes the ceiling of the given floating point value: `v = ceil.lane x` on vector.
	OpcodeVCeil

	// OpcodeVFloor takes the floor of the given floating point value: `v = floor.lane x` on vector.
	OpcodeVFloor

	// OpcodeVTrunc takes the truncation of the given floating point value: `v = trunc.lane x` on vector.
	OpcodeVTrunc

	// OpcodeVNearest takes the nearest integer of the given floating point value: `v = nearest.lane x` on vector.
	OpcodeVNearest

	// OpcodeVMaxPseudo computes the lane-wise maximum value `v = VMaxPseudo.lane x, y` on vector defined as `x < y ? x : y`.
	OpcodeVMaxPseudo

	// OpcodeVMinPseudo computes the lane-wise minimum value `v = VMinPseudo.lane x, y` on vector defined as `y < x ? x : y`.
	OpcodeVMinPseudo

	// OpcodeVSqrt takes the minimum of two floating point values: `v = VFmin.lane x, y` on vector.
	OpcodeVSqrt

	// OpcodeVFcvtToUintSat converts a floating point value to an unsigned integer: `v = FcvtToUintSat.lane x` on vector.
	OpcodeVFcvtToUintSat

	// OpcodeVFcvtToSintSat converts a floating point value to a signed integer: `v = VFcvtToSintSat.lane x` on vector.
	OpcodeVFcvtToSintSat

	// OpcodeVFcvtFromUint converts a floating point value from an unsigned integer: `v = FcvtFromUint.lane x` on vector.
	// x is always a 32-bit integer lane, and the result is either a 32-bit or 64-bit floating point-sized vector.
	OpcodeVFcvtFromUint

	// OpcodeVFcvtFromSint converts a floating point value from a signed integer: `v = VFcvtFromSint.lane x` on vector.
	// x is always a 32-bit integer lane, and the result is either a 32-bit or 64-bit floating point-sized vector.
	OpcodeVFcvtFromSint

	// OpcodeImul performs an integer multiplication: `v = Imul x, y`.
	OpcodeImul

	// OpcodeUdiv performs the unsigned integer division `v = Udiv x, y`.
	OpcodeUdiv

	// OpcodeSdiv performs the signed integer division `v = Sdiv x, y`.
	OpcodeSdiv

	// OpcodeUrem computes the remainder of the unsigned integer division `v = Urem x, y`.
	OpcodeUrem

	// OpcodeSrem computes the remainder of the signed integer division `v = Srem x, y`.
	OpcodeSrem

	// OpcodeBand performs a binary and: `v = Band x, y`.
	OpcodeBand

	// OpcodeBor performs a binary or: `v = Bor x, y`.
	OpcodeBor

	// OpcodeBxor performs a binary xor: `v = Bxor x, y`.
	OpcodeBxor

	// OpcodeBnot performs a binary not: `v = Bnot x`.
	OpcodeBnot

	// OpcodeRotl rotates the given integer value to the left: `v = Rotl x, y`.
	OpcodeRotl

	// OpcodeRotr rotates the given integer value to the right: `v = Rotr x, y`.
	OpcodeRotr

	// OpcodeIshl does logical shift left: `v = Ishl x, y`.
	OpcodeIshl

	// OpcodeUshr does logical shift right: `v = Ushr x, y`.
	OpcodeUshr

	// OpcodeSshr does arithmetic shift right: `v = Sshr x, y`.
	OpcodeSshr

	// OpcodeClz counts the number of leading zeros: `v = clz x`.
	OpcodeClz

	// OpcodeCtz counts the number of trailing zeros: `v = ctz x`.
	OpcodeCtz

	// OpcodePopcnt counts the number of 1-bits: `v = popcnt x`.
	OpcodePopcnt

	// OpcodeFcmp compares two floating point values: `v = fcmp Cond, x, y`.
	OpcodeFcmp

	// OpcodeFadd performs a floating point addition: / `v = Fadd x, y`.
	OpcodeFadd

	// OpcodeFsub performs a floating point subtraction: `v = Fsub x, y`.
	OpcodeFsub

	// OpcodeFmul performs a floating point multiplication: `v = Fmul x, y`.
	OpcodeFmul

	// OpcodeSqmulRoundSat performs a lane-wise saturating rounding multiplication
	// in Q15 format: `v = SqmulRoundSat.lane x,y` on vector.
	OpcodeSqmulRoundSat

	// OpcodeFdiv performs a floating point division: `v = Fdiv x, y`.
	OpcodeFdiv

	// OpcodeSqrt takes the square root of the given floating point value: `v = sqrt x`.
	OpcodeSqrt

	// OpcodeFneg negates the given floating point value: `v = Fneg x`.
	OpcodeFneg

	// OpcodeFabs takes the absolute value of the given floating point value: `v = fabs x`.
	OpcodeFabs

	// OpcodeFcopysign copies the sign of the second floating point value to the first floating point value:
	// `v = Fcopysign x, y`.
	OpcodeFcopysign

	// OpcodeFmin takes the minimum of two floating point values: `v = fmin x, y`.
	OpcodeFmin

	// OpcodeFmax takes the maximum of two floating point values: `v = fmax x, y`.
	OpcodeFmax

	// OpcodeCeil takes the ceiling of the given floating point value: `v = ceil x`.
	OpcodeCeil

	// OpcodeFloor takes the floor of the given floating point value: `v = floor x`.
	OpcodeFloor

	// OpcodeTrunc takes the truncation of the given floating point value: `v = trunc x`.
	OpcodeTrunc

	// OpcodeNearest takes the nearest integer of the given floating point value: `v = nearest x`.
	OpcodeNearest

	// OpcodeBitcast is a bitcast operation: `v = bitcast x`.
	OpcodeBitcast

	// OpcodeIreduce narrow the given integer: `v = Ireduce x`.
	OpcodeIreduce

	// OpcodeSnarrow converts two input vectors x, y into a smaller lane vector by narrowing each lane, signed `v = Snarrow.lane x, y`.
	OpcodeSnarrow

	// OpcodeUnarrow converts two input vectors x, y into a smaller lane vector by narrowing each lane, unsigned `v = Unarrow.lane x, y`.
	OpcodeUnarrow

	// OpcodeSwidenLow converts low half of the smaller lane vector to a larger lane vector, sign extended: `v = SwidenLow.lane x`.
	OpcodeSwidenLow

	// OpcodeSwidenHigh converts high half of the smaller lane vector to a larger lane vector, sign extended: `v = SwidenHigh.lane x`.
	OpcodeSwidenHigh

	// OpcodeUwidenLow converts low half of the smaller lane vector to a larger lane vector, zero (unsigned) extended: `v = UwidenLow.lane x`.
	OpcodeUwidenLow

	// OpcodeUwidenHigh converts high half of the smaller lane vector to a larger lane vector, zero (unsigned) extended: `v = UwidenHigh.lane x`.
	OpcodeUwidenHigh

	// OpcodeExtIaddPairwise is a lane-wise integer extended pairwise addition producing extended results (twice wider results than the inputs): `v = extiadd_pairwise x, y` on vector.
	OpcodeExtIaddPairwise

	// OpcodeWideningPairwiseDotProductS is a lane-wise widening pairwise dot product with signed saturation: `v = WideningPairwiseDotProductS x, y` on vector.
	// Currently, the only lane is i16, and the result is i32.
	OpcodeWideningPairwiseDotProductS

	// OpcodeUExtend zero-extends the given integer: `v = UExtend x, from->to`.
	OpcodeUExtend

	// OpcodeSExtend sign-extends the given integer: `v = SExtend x, from->to`.
	OpcodeSExtend

	// OpcodeFpromote promotes the given floating point value: `v = Fpromote x`.
	OpcodeFpromote

	// OpcodeFvpromoteLow converts the two lower single-precision floating point lanes
	// to the two double-precision lanes of the result: `v = FvpromoteLow.lane x` on vector.
	OpcodeFvpromoteLow

	// OpcodeFdemote demotes the given float point value: `v = Fdemote x`.
	OpcodeFdemote

	// OpcodeFvdemote converts the two double-precision floating point lanes
	// to two lower single-precision lanes of the result `v = Fvdemote.lane x`.
	OpcodeFvdemote

	// OpcodeFcvtToUint converts a floating point value to an unsigned integer: `v = FcvtToUint x`.
	OpcodeFcvtToUint

	// OpcodeFcvtToSint converts a floating point value to a signed integer: `v = FcvtToSint x`.
	OpcodeFcvtToSint

	// OpcodeFcvtToUintSat converts a floating point value to an unsigned integer: `v = FcvtToUintSat x` which saturates on overflow.
	OpcodeFcvtToUintSat

	// OpcodeFcvtToSintSat converts a floating point value to a signed integer: `v = FcvtToSintSat x` which saturates on overflow.
	OpcodeFcvtToSintSat

	// OpcodeFcvtFromUint converts an unsigned integer to a floating point value: `v = FcvtFromUint x`.
	OpcodeFcvtFromUint

	// OpcodeFcvtFromSint converts a signed integer to a floating point value: `v = FcvtFromSint x`.
	OpcodeFcvtFromSint

	// OpcodeAtomicRmw is atomic read-modify-write operation: `v = atomic_rmw op, p, offset, value`.
	OpcodeAtomicRmw

	// OpcodeAtomicCas is atomic compare-and-swap operation.
	OpcodeAtomicCas

	// OpcodeAtomicLoad is atomic load operation.
	OpcodeAtomicLoad

	// OpcodeAtomicStore is atomic store operation.
	OpcodeAtomicStore

	// OpcodeFence is a memory fence operation.
	OpcodeFence
)

TODO: complete opcode comments.

func (Opcode) String 

func (o Opcode) String() (ret string)

String implements fmt.Stringer.

type Signature 

type Signature struct {
	// ID is a unique identifier for this signature used to lookup.
	ID SignatureID
	// Params and Results are the types of the parameters and results of the function.
	Params, Results []Type
	// contains filtered or unexported fields
}

Signature is a function prototype.

func (*Signature) String 

func (s *Signature) String() string

String implements fmt.Stringer.

type SignatureID 

type SignatureID int

SignatureID is an unique identifier used to lookup.

func (SignatureID) String 

func (s SignatureID) String() string

String implements fmt.Stringer.

type SourceOffset added in v1.6.0 

type SourceOffset int64

SourceOffset represents the offset of the source of an instruction.

func (SourceOffset) Valid added in v1.6.0 

func (l SourceOffset) Valid() bool

Valid returns true if this source offset is valid.

type Type 

type Type byte
const (

	// TypeI32 represents an integer type with 32 bits.
	TypeI32 Type

	// TypeI64 represents an integer type with 64 bits.
	TypeI64

	// TypeF32 represents 32-bit floats in the IEEE 754.
	TypeF32

	// TypeF64 represents 64-bit floats in the IEEE 754.
	TypeF64

	// TypeV128 represents 128-bit SIMD vectors.
	TypeV128
)

func (Type) Bits 

func (t Type) Bits() byte

Bits returns the number of bits required to represent the type.

func (Type) IsFloat added in v1.7.0 

func (t Type) IsFloat() bool

IsFloat returns true if the type is a floating point type.

func (Type) IsInt 

func (t Type) IsInt() bool

IsInt returns true if the type is an integer type.

func (Type) Size 

func (t Type) Size() byte

Size returns the number of bytes required to represent the type.

func (Type) String 

func (t Type) String() (ret string)

String implements fmt.Stringer.

type Value 

type Value uint64

Value represents an SSA value with a type information. The relationship with Variable is 1: N (including 0), that means there might be multiple Variable(s) for a Value.

Higher 32-bit is used to store Type for this value. 

const (
	ValueInvalid Value = Value(valueIDInvalid)
)

func (Value) Format 

func (v Value) Format(b Builder) string

Format creates a debug string for this Value using the data stored in Builder.

func (Value) ID 

func (v Value) ID() ValueID

ID returns the valueID of this value.

func (Value) Type 

func (v Value) Type() Type

Type returns the Type of this value.

func (Value) Valid 

func (v Value) Valid() bool

Valid returns true if this value is valid.

type ValueID 

type ValueID uint32

ValueID is the lower 32bit of Value, which is the pure identifier of Value without type info.

type Values added in v1.7.0 

type Values = wazevoapi.VarLength[Value]

Values is a slice of Value. Use this instead of []Value to reuse the underlying memory.

type Variable 

type Variable uint32

Variable is a unique identifier for a source program's variable and will correspond to multiple ssa Value(s).

For example, `Local 1` is a Variable in WebAssembly, and Value(s) will be created for it whenever it executes `local.set 1`.

Variable is useful to track the SSA Values of a variable in the source program, and can be used to find the corresponding latest SSA Value via Builder.FindValue.

func (Variable) String 

func (v Variable) String() string

String implements fmt.Stringer.

type VecLane added in v1.6.0 

type VecLane byte

VecLane represents a lane in a SIMD vector. 

const (
	VecLaneInvalid VecLane = 1 + iota
	VecLaneI8x16
	VecLaneI16x8
	VecLaneI32x4
	VecLaneI64x2
	VecLaneF32x4
	VecLaneF64x2
)

func (VecLane) String added in v1.6.0 

func (vl VecLane) String() (ret string)

String implements fmt.Stringer.

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.