zio-wasm
API
Generated with
zio-wasm/zio.wasm

zio.wasm

package zio.wasm

Members list

Packages

package zio.wasm.componentmodel
package zio.wasm.internal
package zio.wasm.metadata
package zio.wasm.syntax
package zio.wasm.tools

Type members

Classlikes

enum BlockType

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait ControlInstr

Instructions in this group affect the flow of control.

Instructions in this group affect the flow of control.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case Block
case Loop
case If
case Br
case BrIf
case BrTable
case Call
Show all
sealed trait CoreIndexSpace extends IndexSpace

Attributes

Companion
object
Supertypes
trait IndexSpace
class Object
trait Matchable
class Any
Known subtypes
object Code.type
object Custom.type
object Data.type
object Elem.type
object Export.type
object Func.type
object Global.type
object Label.type
object Local.type
object Mem.type
object Start.type
object Table.type
object Type.type
Show all
object CoreIndexSpace

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
final case class Custom(name: Name, data: Chunk[Byte]) extends Section[CoreIndexSpace]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object CustomIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
CustomIdx.type
sealed trait CvtOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case ITruncF
case IExtend8S
case IExtend16S
case FConvertI
case ITruncSatF
Show all
final case class Data(init: Chunk[Byte], mode: DataMode) extends Section[CoreIndexSpace]

The initial contents of a memory are zero bytes. Data segments can be used to initialize a range of memory from a static vector of bytes.

The initial contents of a memory are zero bytes. Data segments can be used to initialize a range of memory from a static vector of bytes.

The datas component of a module defines a vector of data segments.

Like element segments, data segments have a mode that identifies them as either passive or active. A passive data segment’s contents can be copied into a memory using the memory.init instruction. An active data segment copies its contents into a memory during instantiation, as specified by a memory index and a constant expression defining an offset into that memory.

Data segments are referenced through data indices.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class DataCount(count: Int) extends Section[CoreIndexSpace]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object DataIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
DataIdx.type
enum DataMode

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class Elem(refType: RefType, init: Chunk[Expr], mode: ElemMode) extends Section[CoreIndexSpace]

The initial contents of a table is uninitialized. Element segments can be used to initialize a subrange of a table from a static vector of elements.

The initial contents of a table is uninitialized. Element segments can be used to initialize a subrange of a table from a static vector of elements.

The elems component of a module defines a vector of element segments. Each element segment defines a reference type and a corresponding list of constant element expressions.

Element segments have a mode that identifies them as either passive, active, or declarative. A passive element segment’s elements can be copied to a table using the table.init instruction. An active element segment copies its elements into a table during instantiation, as specified by a table index and a constant expression defining an offset into that table. A declarative element segment is not available at runtime but merely serves to forward-declare references that are formed in code with instructions like ref.func.

Element segments are referenced through element indices.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object ElemIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
ElemIdx.type
enum ElemMode

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Example extends ZIOAppDefault

Attributes

Supertypes
trait ZIOApp
class Object
trait Matchable
class Any
Show all
Self type
Example.type
final case class Export(name: Name, desc: ExportDesc) extends Section[CoreIndexSpace]

The exports component of a module defines a set of exports that become accessible to the host environment once the module has been instantiated.

The exports component of a module defines a set of exports that become accessible to the host environment once the module has been instantiated.

Each export is labeled by a unique name. Exportable definitions are functions, tables, memories, and globals, which are referenced through a respective descriptor.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
enum ExportDesc

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object ExportIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
ExportIdx.type
final case class Expr(instructions: Chunk[Instr])

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
enum ExternType

External types classify imports and external values with their respective types.

External types classify imports and external values with their respective types.

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait FBinOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case FSqrt
case FAdd
case FSub
case FMul
case FDiv
case FMin
case FMax
case FCopySign
Show all
sealed trait FRelOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case FEq
case FNe
case FLt
case FGt
case FLe
case FGe
Show all
enum FShape

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait FUnOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case FAbs
case FNeg
case FCeil
case FFloor
case FTrunc
case FNearest
Show all
enum FloatWidth

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class Func(typ: TypeIdx, locals: Chunk[ValType], body: Expr)

The funcs component of a module defines a vector of functions with the following structure.

The funcs component of a module defines a vector of functions with the following structure.

Functions are referenced through function indices, starting with the smallest index not referencing a function import.

Value parameters

body

The body is an instruction sequence that upon termination must produce a stack matching the function type’s result type.

locals

The locals declare a vector of mutable local variables and their types. These variables are referenced through local indices in the function’s body. The index of the first local is the smallest index not referencing a parameter.

typ

The type of a function declares its signature by reference to a type defined in the module. The parameters of the function are referenced through 0-based local indices in the function’s body; they are mutable.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class FuncCode(locals: Chunk[ValType], body: Expr) extends Section[CoreIndexSpace]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object FuncIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
FuncIdx.type
final case class FuncType(input: ResultType, output: ResultType) extends Section[CoreIndexSpace]

Function types classify the signature of functions, mapping a vector of parameters to a vector of results. They are also used to classify the inputs and outputs of instructions.

Function types classify the signature of functions, mapping a vector of parameters to a vector of results. They are also used to classify the inputs and outputs of instructions.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class FuncTypeRef(typeIdx: TypeIdx) extends Section[CoreIndexSpace]

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class Global(globalType: GlobalType, init: Expr) extends Section[CoreIndexSpace]

The globals component of a module defines a vector of global variables (or globals for short):

The globals component of a module defines a vector of global variables (or globals for short):

Each global stores a single value of the given global type. Its type also specifies whether a global is immutable or mutable. Moreover, each global is initialized with an value given by a constant initializer expression.

Globals are referenced through global indices, starting with the smallest index not referencing a global import.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object GlobalIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
GlobalIdx.type
final case class GlobalType(mut: Mut, valType: ValType)

Global types classify global variables, which hold a value and can either be mutable or immutable.

Global types classify global variables, which hold a value and can either be mutable or immutable.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
enum Half

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait IBinOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case IAdd
case ISub
case IMul
case IDiv
case IRem
case IAnd
case IOr
case IXor
case IShl
case IShr
case IRotL
case IRotR
Show all
sealed trait IRelOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case IEq
case INe
case ILt
case IGt
case ILe
case IGe
Show all
enum IShape

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait ITestOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case IEqz
sealed trait IUnOp extends NumericInstr

Attributes

Supertypes
trait NumericInstr
class Object
trait Matchable
class Any
Known subtypes
case IClz
case ICtz
case IPopCnt
final case class Import(module: Name, name: Name, desc: ImportDesc) extends Section[CoreIndexSpace]

The imports component of a module defines a set of imports that are required for instantiation.

The imports component of a module defines a set of imports that are required for instantiation.

Each import is labeled by a two-level name space, consisting of a module name and a name for an entity within that module. Importable definitions are functions, tables, memories, and globals. Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match.

Every import defines an index in the respective index space. In each index space, the indices of imports go before the first index of any definition contained in the module itself.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
enum ImportDesc

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
trait IndexSpace

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Component.type
object CoreFunc.type
object CoreGlobal.type
object CoreInstance.type
object CoreMem.type
object CoreTable.type
object CoreType.type
object Custom.type
object Func.type
object Instance.type
object Module.type
object Start.type
object Type.type
object Value.type
object Code.type
object Custom.type
object Data.type
object Elem.type
object Export.type
object Func.type
object Global.type
object Label.type
object Local.type
object Mem.type
object Start.type
object Table.type
object Type.type
Show all
enum Instr

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
Known subtypes
case I32Const
case I64Const
case F32Const
case F64Const
case IEqz
case IEq
case INe
case ILt
case IGt
case ILe
case IGe
case FEq
case FNe
case FLt
case FGt
case FLe
case FGe
case IClz
case ICtz
case IPopCnt
case IAdd
case ISub
case IMul
case IDiv
case IRem
case IAnd
case IOr
case IXor
case IShl
case IShr
case IRotL
case IRotR
case FAbs
case FNeg
case FCeil
case FFloor
case FTrunc
case FNearest
case FSqrt
case FAdd
case FSub
case FMul
case FDiv
case FMin
case FMax
case FCopySign
case ITruncF
case IExtend8S
case IExtend16S
case FConvertI
case ITruncSatF
case VSplat
case VIEq
case VINe
case VILt
case VIGt
case VILe
case VIGe
case VFEq
case VFNe
case VFLt
case VFGt
case VFLe
case VFGe
case VIAbs
case VINeg
case VFAbs
case VFNeg
case VFSqrt
case VFCeil
case VFFloor
case VFTrunc
case VFNearest
case VIAllTrue
case VIBitMask
case VIShl
case VIShr
case VIAdd
case VISub
case VIMin
case VIMax
case VIAddSat
case VISubSat
case VIMul
case VIAvgr
case VIExtMul
case VFAdd
case VFSub
case VFMul
case VFDiv
case VFMin
case VFMax
case VFPMin
case VFPMax
case RefNull
case RefFunc
case Select
case LocalGet
case LocalSet
case LocalTee
case GlobalGet
case GlobalSet
case TableGet
case TableSet
case TableSize
case TableGrow
case TableFill
case TableCopy
case TableInit
case ElemDrop
case Load
case Store
case Load8
case Load16
case Load32
case Store8
case Store16
case Store32
case MemoryInit
case DataDrop
case Block
case Loop
case If
case Br
case BrIf
case BrTable
case Call
Show all
final case class Int128(high: Long, low: Long)

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Int128

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Int128.type
enum IntWidth

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object LabelIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
LabelIdx.type
opaque object LaneIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
LaneIdx.type
final case class Limits(min: Int, max: Option[Int])

Limits classify the size range of resizeable storage associated with memory types and table types.

Limits classify the size range of resizeable storage associated with memory types and table types.

If no maximum is given, the respective storage can grow to any size.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object LocalIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
LocalIdx.type
final case class Mem(memType: MemType) extends Section[CoreIndexSpace]

The mems component of a module defines a vector of linear memories (or memories for short) as described by their memory type:

The mems component of a module defines a vector of linear memories (or memories for short) as described by their memory type:

A memory is a vector of raw uninterpreted bytes. The size in the limits of the memory type specifies the initial size of that memory, while its max, if present, restricts the size to which it can grow later. Both are in units of page size.

Memories can be initialized through data segments.

Memories are referenced through memory indices, starting with the smallest index not referencing a memory import. Most constructs implicitly reference memory index 0.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class MemArg(align: Int, offset: Int)

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object MemIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
MemIdx.type
final case class MemType(limits: Limits)

Memory types classify linear memories and their size range.

Memory types classify linear memories and their size range.

The limits constrain the minimum and optionally the maximum size of a memory. The limits are given in units of page size.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait MemoryInstr

Instructions in this group are concerned with linear memory.

Instructions in this group are concerned with linear memory.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case Load
case Store
case Load8
case Load16
case Load32
case Store8
case Store16
case Store32
case MemoryInit
case DataDrop
Show all
final case class Module(sections: Sections[CoreIndexSpace]) extends Section[ComponentIndexSpace]

WebAssembly programs are organized into modules, which are the unit of deployment, loading, and compilation. A module collects definitions for types, functions, tables, memories, and globals. In addition, it can declare imports and exports and provide initialization in the form of data and element segments, or a start function.

WebAssembly programs are organized into modules, which are the unit of deployment, loading, and compilation. A module collects definitions for types, functions, tables, memories, and globals. In addition, it can declare imports and exports and provide initialization in the form of data and element segments, or a start function.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
enum Mut

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Name

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Name.type
enum NumType

Number types classify numeric values.

Number types classify numeric values.

The types i32 and i64 classify 32 and 64 bit integers, respectively. Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.

The types f32 and f64 classify 32 and 64 bit floating-point data, respectively. They correspond to the respective binary floating-point representations, also known as single and double precision, as defined by the IEEE 754 standard (Section 3.3).

Number types are transparent, meaning that their bit patterns can be observed. Values of number type can be stored in memories.

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait NumericInstr

Numeric instructions provide basic operations over numeric values of specific type. These operations closely match respective operations available in hardware.

Numeric instructions provide basic operations over numeric values of specific type. These operations closely match respective operations available in hardware.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait CvtOp
case ITruncF
case IExtend8S
case IExtend16S
case FConvertI
case ITruncSatF
trait FBinOp
case FSqrt
case FAdd
case FSub
case FMul
case FDiv
case FMin
case FMax
case FCopySign
trait FRelOp
case FEq
case FNe
case FLt
case FGt
case FLe
case FGe
trait FUnOp
case FAbs
case FNeg
case FCeil
case FFloor
case FTrunc
case FNearest
trait IBinOp
case IAdd
case ISub
case IMul
case IDiv
case IRem
case IAnd
case IOr
case IXor
case IShl
case IShr
case IRotL
case IRotR
trait IRelOp
case IEq
case INe
case ILt
case IGt
case ILe
case IGe
trait ITestOp
case IEqz
trait IUnOp
case IClz
case ICtz
case IPopCnt
case I32Const
case I64Const
case F32Const
case F64Const
Show all
sealed trait ParametricInstr

Instructions in this group can operate on operands of any value type.

Instructions in this group can operate on operands of any value type.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case Select
enum RefType

Reference types classify first-class references to objects in the runtime store.

Reference types classify first-class references to objects in the runtime store.

The type funcref denotes the infinite union of all references to functions, regardless of their function types.

The type externref denotes the infinite union of all references to objects owned by the embedder and that can be passed into WebAssembly under this type.

Reference types are opaque, meaning that neither their size nor their bit pattern can be observed. Values of reference type can be stored in tables.

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait ReferenceInstr

Instructions in this group are concerned with accessing references.

Instructions in this group are concerned with accessing references.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case RefNull
case RefFunc
final case class ResultType(values: Chunk[ValType])

Result types classify the result of executing instructions or functions, which is a sequence of values, written with brackets.

Result types classify the result of executing instructions or functions, which is a sequence of values, written with brackets.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
trait Section[IS <: IndexSpace]

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
enum Alias
enum Canon
class Component
enum CoreType
class Custom
enum Instance
class Custom
class Data
class DataCount
class Elem
class Export
class FuncCode
class FuncType
class FuncTypeRef
class Global
class Import
class Mem
class Module
class Start
class Table
Show all
trait SectionType[IS <: IndexSpace]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object ComponentAliasSection.type
object ComponentCanonSection.type
object ComponentSection.type
object ComponentStartSection.type
object ComponentTypeSection.type
object CoreCodeSection.type
object CoreDataCountSection.type
object CoreDataSection.type
object CoreElemSection.type
object CoreExportSection.type
object CoreFuncSection.type
object CoreGlobalSection.type
object CoreImportSection.type
object CoreMemSection.type
object CoreStartSection.type
object CoreTableSection.type
object CoreTypeSection.type
object CustomSection.type
Show all
object SectionType

Attributes

Companion
trait
Supertypes
class Object
trait Matchable
class Any
Self type
final case class Sections[IS <: IndexSpace](sections: Chunk[Section[IS]])

Attributes

Companion
object
Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Sections

Attributes

Companion
class
Supertypes
trait Product
trait Mirror
class Object
trait Matchable
class Any
Self type
Sections.type
enum Signedness

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class Start(func: FuncIdx) extends Section[CoreIndexSpace]

The start component of a module declares the function index of a start function that is automatically invoked when the module is instantiated, after tables and memories have been initialized.

The start component of a module declares the function index of a start function that is automatically invoked when the module is instantiated, after tables and memories have been initialized.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
final case class Table(tableType: TableType) extends Section[CoreIndexSpace]

The tables component of a module defines a vector of tables described by their table type:

The tables component of a module defines a vector of tables described by their table type:

A table is a vector of opaque values of a particular reference type. The size in the limits of the table type specifies the initial size of that table, while its max, if present, restricts the size to which it can grow later.

Tables can be initialized through element segments.

Tables are referenced through table indices, starting with the smallest index not referencing a table import. Most constructs implicitly reference table index 0.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object TableIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
TableIdx.type
sealed trait TableInstr

Instructions in this group are concerned with tables table.

Instructions in this group are concerned with tables table.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case TableGet
case TableSet
case TableSize
case TableGrow
case TableFill
case TableCopy
case TableInit
case ElemDrop
Show all
final case class TableType(limits: Limits, elements: RefType)

Table types classify tables over elements of reference type within a size range.

Table types classify tables over elements of reference type within a size range.

Like memories, tables are constrained by limits for their minimum and optionally maximum size. The limits are given in numbers of entries.

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
enum Type

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
opaque object TypeIdx

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
TypeIdx.type
object Url

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type
Url.type
sealed trait VCvtOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
Show all
sealed trait VFBinOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VFAdd
case VFSub
case VFMul
case VFDiv
case VFMin
case VFMax
case VFPMin
case VFPMax
Show all
sealed trait VFRelOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VFEq
case VFNe
case VFLt
case VFGt
case VFLe
case VFGe
Show all
sealed trait VFUnOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VFAbs
case VFNeg
case VFSqrt
case VFCeil
case VFFloor
case VFTrunc
case VFNearest
Show all
sealed trait VIBinOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIAdd
case VISub
sealed trait VIMinMaxOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIMin
case VIMax
sealed trait VIRelOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIEq
case VINe
case VILt
case VIGt
case VILe
case VIGe
Show all
sealed trait VISatBinOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIAddSat
case VISubSat
sealed trait VIShiftOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIShl
case VIShr
sealed trait VITestOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIAllTrue
sealed trait VIUnOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
Known subtypes
case VIAbs
case VINeg
sealed trait VVBinOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
sealed trait VVTernOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
sealed trait VVTestOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
sealed trait VVUnOp extends VectorInstr

Attributes

Supertypes
trait VectorInstr
class Object
trait Matchable
class Any
sealed trait VariableInstr

Variable instructions are concerned with access to local or global variables.

Variable instructions are concerned with access to local or global variables.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case LocalGet
case LocalSet
case LocalTee
case GlobalGet
case GlobalSet
enum VecType

Vector types classify vectors of numeric values processed by vector instructions (also known as SIMD instructions, single instruction multiple data).

Vector types classify vectors of numeric values processed by vector instructions (also known as SIMD instructions, single instruction multiple data).

The type v128 corresponds to a 128 bit vector of packed integer or floating-point data. The packed data can be interpreted as signed or unsigned integers, single or double precision floating-point values, or a single 128 bit type. The interpretation is determined by individual operations.

Vector types, like number types are transparent, meaning that their bit patterns can be observed. Values of vector type can be stored in memories.

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
sealed trait VectorInstr

Vector instructions (also known as SIMD instructions, single instruction multiple data) provide basic operations over values of vector type.

Vector instructions (also known as SIMD instructions, single instruction multiple data) provide basic operations over values of vector type.

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
case VSplat
case VIEq
case VINe
case VILt
case VIGt
case VILe
case VIGe
case VFEq
case VFNe
case VFLt
case VFGt
case VFLe
case VFGe
case VIAbs
case VINeg
case VFAbs
case VFNeg
case VFSqrt
case VFCeil
case VFFloor
case VFTrunc
case VFNearest
case VIAllTrue
case VIBitMask
case VIShl
case VIShr
case VIAdd
case VISub
case VIMin
case VIMax
case VIAddSat
case VISubSat
case VIMul
case VIAvgr
case VIExtMul
case VFAdd
case VFSub
case VFMul
case VFDiv
case VFMin
case VFMax
case VFPMin
case VFPMax
trait VCvtOp
trait VFBinOp
trait VFRelOp
trait VFUnOp
trait VIBinOp
trait VIMinMaxOp
trait VIRelOp
trait VISatBinOp
trait VIShiftOp
trait VITestOp
trait VIUnOp
trait VVBinOp
trait VVTernOp
trait VVTestOp
trait VVUnOp
Show all
enum VectorLoadShape

Attributes

Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all

Types

type BinOp = IBinOp | FBinOp
opaque type CustomIdx
type DataIdx = DataIdx
type ElemIdx = ElemIdx
opaque type ExportIdx
type FuncIdx = FuncIdx
opaque type LabelIdx
type LaneIdx = LaneIdx
type MemIdx = MemIdx
opaque type Name
type RelOp = IRelOp | FRelOp
type Shape = IShape | FShape
type TestOp = ITestOp
type TypeIdx = TypeIdx
type UnOp = IUnOp | FUnOp
opaque type Url
type VBinOp = VIBinOp | VFBinOp | VIMinMaxOp | VISatBinOp | VIMul.type | VFMul.type | VIAvgr.type | Instr & VectorInstr
type VTestOp = VITestOp
type ValType = NumType | VecType | RefType

Value types classify the individual values that WebAssembly code can compute with and the values that a variable accepts. They are either number types, vector types, or reference types.

Value types classify the individual values that WebAssembly code can compute with and the values that a variable accepts. They are either number types, vector types, or reference types.

Attributes

Generated with