# Builtins

The following builtins provide direct access to WebAssembly and compiler features. They form the low-level foundation of the standard library, for example, while also being available for everyone to utilize where directly tapping into WebAssembly or the compiler is desired.

# Static type checks

By making use of the following special type checks, especially in generic contexts, untaken branches can be eliminated statically, leading to concrete WebAssembly functions that handle one type specificially.

  • function isInteger<T>(value?: T): bool
    

    Tests if the specified type or expression is of an integer type and not a reference. Compiles to a constant.

  • function isFloat<T>(value?: T): bool
    

    Tests if the specified type or expression is of a float type. Compiles to a constant.

  • function isSigned<T>(value?: T): bool
    

    Tests if the specified type or expression can represent negative numbers. Compiles to a constant.

  • function isReference<T>(value?: T): bool
    

    Tests if the specified type or expression is of a reference type. Compiles to a constant.

  • function isString<T>(value?: T): bool
    

    Tests if the specified type or expression can be used as a string. Compiles to a constant.

  • function isArray<T>(value?: T): bool
    

    Tests if the specified type or expression can be used as an array. Compiles to a constant.

  • function isFunction<T>(value?: T): bool
    

    Tests if the specified type or expression is of a function type. Compiles to a constant.

  • function isNullable<T>(value?: T): bool
    

    Tests if the specified type or expression is of a nullable reference type. Compiles to a constant.

  • function isDefined(expression: auto): bool
    

    Tests if the specified expression resolves to a defined element. Compiles to a constant.

  • function isConstant(expression: auto): bool
    

    Tests if the specified expression evaluates to a constant value. Compiles to a constant.

  • function isManaged<T>(expression: auto): bool
    

    Tests if the specified type or expression is of a managed type. Compiles to a constant. Usually only relevant when implementing custom collection-like classes.

# Example

function add<T>(a: T, b: T): T {
  return a + b // addition if numeric, string concatenation if a string
}

function add<T>(a: T, b: T): T {
  if (isString<T>()) { // eliminated if T is not a string
    return parseInt(a) + parseInt(b)
  } else { // eliminated if T is a string
    return a + b
  }
}

TIP

If you are not going to use low-level WebAssembly in the foreseeable future, feel free to come back to the following paragraphs at a later time and continue at the next pageright away.

# Utility

  • function sizeof<T>(): usize
    

    Determines the byte size of the respective basic type. Means: If T is a class type, the size of usize is returned. To obtain the size of a class in memory, use offsetof<T>() instead. Compiles to a constant.

  • function offsetof<T>(fieldName?: string): usize
    

    Determines the offset of the specified field within the given class type. Returns the class type's end offset (means: where the next field would be located, before alignment) if field name has been omitted. Compiles to a constant. The fieldName argument must be a compile-time constant string because there is no information about field names anymore in the final binary. Hence, the field's name must be known at the time the returned constant is computed.

  • function alignof<T>(): usize
    

    Determines the alignment (log2) of the specified underlying basic type. Means: If T is a class type, the alignment of usize is returned. Compiles to a constant.

  • function assert<T>(isTrueish: T, message?: string): T
    

    Traps if the specified value is not true-ish, otherwise returns the non-nullable value. Like assertions in C, aborting the entire program if the expectation fails, with the --noAssert option to disable all assertions in production.

  • function instantiate<T>(...args: auto[]): T
    

    Instantiates a new instance of T using the specified constructor arguments.

  • function changetype<T>(value: auto): T
    

    Changes the type of a value to another one. Useful for casting class instances to their pointer values and vice-versa.

  • function idof<T>(): u32
    

    Obtains the computed unique id of a class type. Usually only relevant when allocating objects or dealing with RTTI externally.

  • function nameof<T>(value?: T): string
    

    Determines the name of a given type.

  • function bswap<T>(value: T): T
    

    Reverses the byte order of the specified integer.

  • function bswap16<T>(value: T): T
    

    Reverses only the last 2 bytes regardless of the type argument.

# WebAssembly

# Math

The following generic built-ins compile to WebAssembly instructions directly.

  • function clz<T>(value: T): T
    
    Performs the sign-agnostic count leading zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered leading if the value is zero.
    T Instruction
    i8, u8, i16, u16, i32, u32, bool i32.clz
    i64, u64 i64.clz
  • function ctz<T>(value: T): T
    
    Performs the sign-agnostic count tailing zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered trailing if the value is zero.
    T Instruction
    i8, u8, i16, u16, i32, u32, bool i32.ctz
    i64, u64 i64.ctz
  • function popcnt<T>(value: T): T
    
    Performs the sign-agnostic count number of one bits operation on a 32-bit or 64-bit integer.
    T Instruction
    i8, u8, i16, u16, i32, u32 i32.popcnt
    i64, u64 i64.popcnt
    bool none
  • function rotl<T>(value: T, shift: T): T
    
    Performs the sign-agnostic rotate left operation on a 32-bit or 64-bit integer.
    T Instruction
    i32, u32 i32.rotl
    i64, u64 i64.rotl
    i8, u8, i16, u16 emulated
    bool none
  • function rotr<T>(value: T, shift: T): T
    
    Performs the sign-agnostic rotate right operation on a 32-bit or 64-bit integer.
    T Instruction
    i32, u32 i32.rotr
    i64, u64 i64.rotr
    i8, u8, i16, u16 emulated
    bool none
  • function abs<T>(value: T): T
    
    Computes the absolute value of an integer or float.
    T Instruction
    f32 f32.abs
    f64 f64.abs
    i8, i16, i32, i64 emulated
    u8, u16, u32, u64, bool none
  • function max<T>(left: T, right: T): T
    
    Determines the maximum of two integers or floats. If either operand is NaN, returns NaN.
    T Instruction
    f32 f32.max
    f64 f64.max
    i8, u8, i16, u16, i32, u32, i64, u64, bool emulated
  • function min<T>(left: T, right: T): T
    
    Determines the minimum of two integers or floats. If either operand is NaN, returns NaN.
    T Instruction
    f32 f32.min
    f64 f64.min
    i8, u8, i16, u16, i32, u32, i64, u64, bool emulated
  • function ceil<T>(value: T): T
    
    Performs the ceiling operation on a 32-bit or 64-bit float.
    T Instruction
    f32 f32.ceil
    f64 f64.ceil
    i8, u8, i16, u16, i32, u32, i64, u64, bool none
  • function floor<T>(value: T): T
    
    Performs the floor operation on a 32-bit or 64-bit float.
    T Instruction
    f32 f32.floor
    f64 f64.floor
    i8, u8, i16, u16, i32, u32, i64, u64, bool none
  • function copysign<T>(x: T , y: T): T
    
    Composes a 32-bit or 64-bit float from the magnitude of x and the sign of y.
    T Instruction
    f32 f32.copysign
    f64 f64.copysign
  • function nearest<T>(value: T): T
    
    Rounds to the nearest integer tied to even of a 32-bit or 64-bit float.
    T Instruction
    f32 f32.nearest
    f64 f64.nearest
    i8, u8, i16, u16, i32, u32, i64, u64, bool none
  • function reinterpret<TTo>(value: auto): T
    
    Reinterprets the bits of the specified value as type T.
    TTo Instruction
    i32, u32 i32.reinterpret_f32
    i64, u64 i64.reinterpret_f64
    f32 f32.reinterpret_i32
    f64 f64.reinterpret_i64
  • function sqrt<T>(value: T): T
    
    Calculates the square root of a 32-bit or 64-bit float.
    T Instruction
    f32 f32.sqrt
    f64 f64.sqrt
  • function trunc<T>(value: T): T
    
    Rounds to the nearest integer towards zero of a 32-bit or 64-bit float.
    T Instruction
    f32 f32.trunc
    f64 f64.trunc
    i8, u8, i16, u16, i32, u32, i64, u64, bool none

# Memory

Similarly, the following built-ins emit WebAssembly instructions accessing or otherwise modifying memory.

  • function load<T>(ptr: usize, immOffset?: usize): T
    
    Loads a value of the specified type from memory. Equivalent to dereferencing a pointer in other languages.
    T Instruction If context is i64
    i8 i32.load8_s i64.load8_s
    u8 i32.load8_u i64.load8_u
    i16 i32.load16_s i64.load16_s
    u16 i32.load16_u i64.load16_u
    i32 i32.load i64.load32_s
    u32 i32.load i64.load32_u
    i64, u64 i64.load n/a
    f32 f32.load n/a
    f64 f64.load n/a
    <ref> i32/i64.load n/a
  • function store<T>(ptr: usize, value: auto, immOffset?: usize): void
    
    Stores a value of the specified type to memory. Equivalent to dereferencing a pointer in other languages and assigning a value.
    T Instruction If value is i64
    i8, u8 i32.store8 i64.store8
    i16, u16 i32.store16 i64.store16
    i32, u32 i32.store i64.store32
    i64, u64 i64.store n/a
    f32 f32.store n/a
    f64 f64.store n/a
    <ref> i32/i64.store n/a

    WARNING

    immOffset argument in load and store should be a non-negative constant value. See more details in rationale (opens new window)

  • function memory.size(): i32
    

    Returns the current size of the memory in units of pages. One page is 64kb.

  • function memory.grow(value: i32): i32
    

    Grows linear memory by a given unsigned delta of pages. One page is 64kb. Returns the previous size of the memory in units of pages or -1 on failure.

    WARNING

    Calling memory.grow where a memory manager is present might break it.

  • function memory.copy(dst: usize, src: usize, n: usize): void
    

    Copies n bytes from src to dst . Regions may overlap. Emits the respective instruction if bulk-memory is enabled, otherwise ships a polyfill.

  • function memory.fill(dst: usize, value: u8, n: usize): void
    

    Fills n bytes at dst with the given byte value. Emits the respective instruction if bulk-memory is enabled, otherwise ships a polyfill.

  • function memory.repeat(dst: usize, src: usize, srcLength: usize, count: usize): void
    

    Repeats a sequence of bytes given as src with srcLength count times into destination dst.

  • function memory.compare(lhs: usize, rhs: usize, n: usize): i32
    

    Compares the first n bytes of left and rigth and returns a value that indicates their relationship:

    • Negative value if the first differing byte in lhs is less than the corresponding byte in rhs.
    • Positive value if the first differing byte in lhs is greater than the corresponding byte in rhs.
    • Zero​ if all n bytes of lhs and rhs are equal.
  • function memory.data(size: i32, align?: i32): usize
    

    Gets a pointer to a zeroed static chunk of memory of the given size. Alignment defaults to 16. Arguments must be compile-time constants.

  • function memory.data<T>(values: T[], align?: i32): usize
    

    Gets a pointer to a pre-initialized static chunk of memory. Alignment defaults to the size of T. Arguments must be compile-time constants.

The immOffset argument is a bit special here, because it becomes an actual immediate of the respective WebAssembly instruction instead of a normal operand. Thus it must be provided as a compile time constant value. This can be a literal or the value of a const variable that the compiler can precompute.

# Control flow

  • function select<T>(ifTrue: T, ifFalse: T, condition: bool): T
    

    Selects one of two pre-evaluated values depending on the condition. Differs from an if/else in that both arms are always executed and the final value is picked based on the condition afterwards. Performs better than an if/else only if the condition is random (means: branch prediction is not going to perform well) and both alternatives are cheap. It is also worth to note that Binaryen will do relevant optimizations like switching to a select automatically, so using a ternary ? : for example is just fine.

  • function unreachable(): auto
    

    Emits an unreachable instruction that results in a runtime error (trap) when executed. Both a statement and an expression of any type. Beware that trapping in managed code will most likely lead to memory leaks or even break the program because it ends execution prematurely.

# Atomics πŸ¦„

The following instructions represent the WebAssembly threads and atomics (opens new window) specification. Must be enabled with --enable threads.

  • function atomic.load<T>(ptr: usize, immOffset?: usize): T
    

    Atomically loads an integer value from memory and returns it.

  • function atomic.store<T>(ptr: usize, value: auto, immOffset?: usize): void
    

    Atomically stores an integer value to memory.

  • function atomic.add<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically adds an integer value in memory.

  • function atomic.sub<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically subtracts an integer value in memory.

  • function atomic.and<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically performs a bitwise AND operation on an integer value in memory.

  • function atomic.or<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically performs a bitwise OR operation on an integer value in memory.

  • function atomic.xor<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically performs a bitwise XOR operation on an integer value in memory.

  • function atomic.xchg<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically exchanges an integer value in memory.

  • function atomic.cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T
    

    Atomically compares and exchanges an integer value in memory if the condition is met.

  • function atomic.wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult
    

    Performs a wait operation on an address in memory suspending this agent if the integer condition is met. Return values are

    Value Description
    0 OK - Woken by another agent.
    1 NOT_EQUAL - Loaded value did not match the expected value.
    2 TIMED_OUT - Not woken before the timeout expired.
  • function atomic.notify(ptr: usize, count: i32): i32
    

    Performs a notify operation on an address in memory waking up suspended agents.

  • function atomic.fence(): void
    

    Performs a fence operation, preserving synchronization guarantees of higher level languages.

Again, the immOffset argument must be a compile time constant value.

# SIMD πŸ¦„

Likewise, these represent the WebAssembly SIMD (opens new window) specification. Must be enabled with --enable simd.

  • function v128(a: i8, ... , p: i8): v128
    

    Initializes a 128-bit vector from sixteen 8-bit integer values. Arguments must be compile-time constants.

    See Constructing constant vectors for additional type-specific options.

  • function v128.splat<T>(x: T): v128
    
    Creates a vector with identical lanes.
    T Instruction
    i8, u8 i8x16.splat
    i16, u16 i16x8.splat
    i32, u32 i32x4.splat
    i64, u64 i64x2.splat
    f32 f32x4.splat
    f64 f64x2.splat
  • function v128.extract_lane<T>(x: v128, idx: u8): T
    
    Extracts one lane as a scalar.
    T Instruction
    i8 i8x16.extract_lane_s
    u8 i8x16.extract_lane_u
    i16 i16x8.extract_lane_s
    u16 i16x8.extract_lane_u
    i32, u32 i32x4.extract_lane
    i64, u64 i64x2.extract_lane
    f32 f32x4.extract_lane
    f64 f64x2.extract_lane
  • function v128.replace_lane<T>(x: v128, idx: u8, value: T): v128
    
    Replaces one lane.
    T Instruction
    i8, u8 i8x16.replace_lane
    i16, u16 i16x8.replace_lane
    i32, u32 i32x4.replace_lane
    i64, u64 i64x2.replace_lane
    f32 f32x4.replace_lane
    f64 f64x2.replace_lane
  • function v128.shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128
    
    Selects lanes from either vector according to the specified lane indexes.
    T Instruction
    i8, u8, i16, u16, i32, u32, i64, u64, f32, f64 i8x16.shuffle
  • function v128.swizzle(a: v128, s: v128): v128
    

    Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector.

  • function v128.load(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    

    Loads a vector from memory.

  • function v128.load_ext<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    
    Creates a vector by loading the lanes of the specified integer type and extending each to the next larger type.
    TFrom Instruction
    i8 v128.load8x8_s
    u8 v128.load8x8_u
    i16 v128.load16x4_s
    u16 v128.load16x4_u
    i32 v128.load32x2_s
    u32 v128.load32x2_u
  • function v128.load_zero<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    
    Creates a vector by loading a value of the specified type into the lowest bits and initializing all other bits of the vector to zero.
    TFrom Instruction
    i32, u32, f32 v128.load32_zero
    i64, u64, f64 v128.load64_zero
  • function v128.load_lane<T>(
      ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize
    ): v128
    
    Loads a single lane from memory into the specified lane of the given vector. Other lanes are bypassed as is.
    T Instruction
    i8, u8 v128.load8_lane
    i16, u16 v128.load16_lane
    i32, u32, f32 v128.load32_lane
    i64, u64, f64 v128.load64_lane
  • function v128.store_lane<T>(
      ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize
    ): v128
    
    Stores the single lane at the specified index of the given vector to memory.
    T Instruction
    i8, u8 v128.store8_lane
    i16, u16 v128.store16_lane
    i32, u32, f32 v128.store32_lane
    i64, u64, f64 v128.store64_lane
  • function v128.load_splat<T>(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    
    Creates a vector with identical lanes by loading the splatted value.
    T Instruction
    i8, u8 v128.load8_splat
    i16, u16 v128.load16_splat
    i32, u32, f32 v128.load32_splat
    i64, u64, f64 v128.load64_splat
  • function v128.store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void
    

    Stores a vector to memory.

  • function v128.add<T>(a: v128, b: v128): v128
    
    Adds each lane.
    T Instruction
    i8, u8 i8x16.add
    i16, u16 i16x8.add
    i32, u32 i32x4.add
    i64, u64 i64x2.add
    f32 f32x4.add
    f64 f64x2.add
  • function v128.sub<T>(a: v128, b: v128): v128
    
    Subtracts each lane.
    T Instruction
    i8, u8 i8x16.sub
    i16, u16 i16x8.sub
    i32, u32 i32x4.sub
    i64, u64 i64x2.sub
    f32 f32x4.sub
    f64 f64x2.sub
  • function v128.mul<T>(a: v128, b: v128): v128
    
    Multiplies each lane.
    T Instruction
    i16, u16 i16x8.mul
    i32, u32 i32x4.mul
    i64, u64 i64x2.mul
    f32 f32x4.mul
    f64 f64x2.mul
  • function v128.div<T>(a: v128, b: v128): v128
    
    Divides each floating point lane.
    T Instruction
    f32 f32x4.div
    f64 f64x2.div
  • function v128.neg<T>(a: v128): v128
    
    Negates each lane.
    T Instruction
    i8, u8 i8x16.neg
    i16, u16 i16x8.neg
    i32, u32 i32x4.neg
    i64, u64 i64x2.neg
    f32 f32x4.neg
    f64 f64x2.neg
  • function v128.add_sat<T>(a: v128, b: v128): v128
    
    Adds each signed small integer lane using saturation.
    T Instruction
    i8 i8x16.add_sat_s
    u8 i8x16.add_sat_u
    i16 i16x8.add_sat_s
    u16 i16x8.add_sat_u
  • function v128.sub_sat<T>(a: v128, b: v128): v128
    
    Subtracts each signed small integer lane using saturation.
    T Instruction
    i8 i8x16.sub_sat_s
    u8 i8x16.sub_sat_u
    i16 i16x8.sub_sat_s
    u16 i16x8.sub_sat_u
  • function v128.shl<T>(a: v128, b: i32): v128
    
    Performs a bitwise left shift by a scalar on each integer lane.
    T Instruction
    i8, u8 i8x16.shl
    i16, u16 i16x8.shl
    i32, u32 i32x4.shl
    i64, u64 i64x2.shl
  • function v128.shr<T>(a: v128, b: i32): v128
    
    Performs a bitwise right shift by a scalar on each integer lane.
    T Instruction
    i8 i8x16.shr_s
    u8 i8x16.shr_u
    i16 i16x8.shr_s
    u16 i16x8.shr_u
    i32 i32x4.shr_s
    u32 i32x4.shr_u
    i64 i64x2.shr_s
    u64 i64x2.shr_u
  • function v128.and(a: v128, b: v128): v128
    

    Performs the bitwise a & b operation on each lane.

  • function v128.or(a: v128, b: v128): v128
    

    Performs the bitwise a | b operation on each lane.

  • function v128.xor(a: v128, b: v128): v128
    

    Performs the bitwise a ^ b operation on each lane.

  • function v128.andnot(a: v128, b: v128): v128
    

    Performs the bitwise !a & b operation on each lane.

  • function v128.not(a: v128): v128
    

    Performs the bitwise !a operation on each lane.

  • function v128.bitselect(a: v128, b: v128, mask: v128): v128
    

    Selects bits of either vector according to the specified mask.

  • function v128.any_true(a: v128): bool
    

    Reduces a vector to a scalar indicating whether any lane is considered true.

  • function v128.all_true<T>(a: v128): bool
    
    Reduces a vector to a scalar indicating whether all lanes are considered true.
    T Instruction
    i8, u8 i8x16.all_true
    i16, u16 i16x8.all_true
    i32, u32 i32x4.all_true
    i64, u64 i64x2.all_true
  • function v128.bitmask<T>(a: v128): bool
    
    Extracts the high bit of each integer lane (except 64-bit) and produces a scalar mask with all bits concatenated.
    T Instruction
    i8, u8 i8x16.bitmask
    i16, u16 i16x8.bitmask
    i32, u32 i32x4.bitmask
    i64, u64 i64x2.bitmask
  • function v128.popcnt<T>(a: v128): v128
    
    Counts the number of bits set to one within each lane.
    T Instruction
    i8, u8 i8x16.popcnt
  • function v128.min<T>(a: v128, b: v128): v128
    
    Computes the minimum of each lane.
    T Instruction
    i8 i8x16.min_s
    u8 i8x16.min_u
    i16 i16x8.min_s
    u16 i16x8.min_u
    i32 i32x4.min_s
    u32 i32x4.min_u
    f32 f32x4.min
    f64 f64x2.min
  • function v128.max<T>(a: v128, b: v128): v128
    
    Computes the maximum of each lane.
    T Instruction
    i8 i8x16.max_s
    u8 i8x16.max_u
    i16 i16x8.max_s
    u16 i16x8.max_u
    i32 i32x4.max_s
    u32 i32x4.max_u
    f32 f32x4.max
    f64 f64x2.max
  • function v128.pmin<T>(a: v128, b: v128): v128
    
    Computes the psuedo-minimum of each lane.
    T Instruction
    f32 f32x4.pmin
    f64 f64x2.pmin
  • function v128.pmax<T>(a: v128, b: v128): v128
    
    Computes the pseudo-maximum of each lane.
    T Instruction
    f32 f32x4.pmax
    f64 f64x2.pmax
  • function v128.dot<T>(a: v128, b: v128): v128
    
    Computes the dot product of two 16-bit integer lanes each, yielding lanes one size wider than the input.
    T Instruction
    i16 i32x4.dot_i16x8_s
  • function v128.avgr<T>(a: v128, b: v128): v128)
    
    Computes the rounding average of each unsigned small integer lane.
    T Instruction
    u8 i8x16.avgr_u
    u16 i16x8.avgr_u
  • function v128.abs<T>(a: v128): v128
    
    Computes the absolute value of each lane (except 64-bit integers).
    T Instruction
    i8, u8 i8x16.abs
    i16, u16 i16x8.abs
    i32, u32 i32x4.abs
    i64, u64 i64x2.abs
    f32 f32x4.abs
    f64 f64x2.abs
  • function v128.sqrt<T>(a: v128): v128
    
    Computes the square root of each floating point lane.
    T Instruction
    f32 f32x4.sqrt
    f64 f64x2.sqrt
  • function v128.ceil<T>(a: v128): v128
    
    Performs the ceiling operation on each lane.
    T Instruction
    f32 f32x4.ceil
    f64 f64x2.ceil
  • function v128.floor<T>(a: v128): v128
    
    Performs the floor operation on each lane.
    T Instruction
    f32 f32x4.floor
    f64 f64x2.floor
  • function v128.trunc<T>(a: v128): v128
    
    Rounds to the nearest integer towards zero of each lane.
    T Instruction
    f32 f32x4.trunc
    f64 f64x2.trunc
  • function v128.nearest<T>(a: v128): v128
    
    Rounds to the nearest integer tied to even of each lane.
    T Instruction
    f32 f32x4.nearest
    f64 f64x2.nearest
  • function v128.eq<T>(a: v128, b: v128): v128
    
    Computes which lanes are equal.
    T Instruction
    i8, u8 i8x16.eq
    i16, u16 i16x8.eq
    i32, u32 i32x4.eq
    i64, u64 i64x2.eq
    f32 f32x4.eq
    f64 f64x2.eq
  • function v128.ne<T>(a: v128, b: v128): v128
    
    Computes which lanes are not equal.
    T Instruction
    i8, u8 i8x16.ne
    i16, u16 i16x8.ne
    i32, u32 i32x4.ne
    i64, u64 i64x2.ne
    f32 f32x4.ne
    f64 f64x2.ne
  • function v128.lt<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are less than those of the second.
    T Instruction
    i8 i8x16.lt_s
    u8 i8x16.lt_u
    i16 i16x8.lt_s
    u16 i16x8.lt_u
    i32 i32x4.lt_s
    u32 i32x4.lt_u
    i64 i64x2.lt_s
    f32 f32x4.lt
    f64 f64x2.lt
  • function v128.le<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are less than or equal those of the second.
    T Instruction
    i8 i8x16.le_s
    u8 i8x16.le_u
    i16 i16x8.le_s
    u16 i16x8.le_u
    i32 i32x4.le_s
    u32 i32x4.le_u
    i64 i64x2.le_s
    f32 f32x4.le
    f64 f64x2.le
  • function v128.gt<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are greater than those of the second.
    T Instruction
    i8 i8x16.gt_s
    u8 i8x16.gt_u
    i16 i16x8.gt_s
    u16 i16x8.gt_u
    i32 i32x4.gt_s
    u32 i32x4.gt_u
    i64 i64x2.gt_s
    f32 f32x4.gt
    f64 f64x2.gt
  • function v128.ge<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are greater than or equal those of the second.
    T Instruction
    i8 i8x16.ge_s
    u8 i8x16.ge_u
    i16 i16x8.ge_s
    u16 i16x8.ge_u
    i32 i32x4.ge_s
    u32 i32x4.ge_u
    i64 i64x2.ge_s
    f32 f32x4.ge
    f64 f64x2.ge
  • function v128.convert<TFrom>(a: v128): v128
    
    Converts each lane of a vector from integer to single-precision floating point.
    TFrom Instruction
    i32 f32x4.convert_i32x4_s
    u32 f32x4.convert_i32x4_u
  • function v128.convert_low<TFrom>(a: v128): v128
    
    Converts the low lanes of a vector from integer to double-precision floating point.
    TFrom Instruction
    i32 f64x2.convert_low_i32x4_s
    u32 f64x2.convert_low_i32x4_u
  • function v128.trunc_sat<TTo>(a: v128): v128
    
    Truncates each lane of a vector from single-precision floating point to integer with saturation. Takes the target type.
    TTo Instruction
    i32 i32x4.trunc_sat_f32x4_s
    u32 i32x4.trunc_sat_f32x4_u
  • function v128.trunc_sat_zero<TTo>(a: v128): v128
    
    Truncates each lane of a vector from double-precision floating point to integer with saturation. Takes the target type.
    TTo Instruction
    i32 i32x4.trunc_sat_f64x2_s_zero
    u32 i32x4.trunc_sat_f64x2_u_zero
  • function v128.narrow<TFrom>(a: v128, b: v128): v128
    
    Narrows wider integer lanes to their respective narrower lanes.
    TFrom Instruction
    i16 i8x16.narrow_i16x8_s
    u16 i8x16.narrow_i16x8_u
    i32 i16x8.narrow_i32x4_s
    u32 i16x8.narrow_i32x4_u
  • function v128.extend_low<TFrom>(a: v128): v128
    
    Extends the low half of narrower integer lanes to their respective wider lanes.
    TFrom Instruction
    i8 i16x8.extend_low_i8x16_s
    u8 i16x8.extend_low_i8x16_u
    i16 i32x4.extend_low_i16x8_s
    u16 i32x4.extend_low_i16x8_u
    i32 i64x2.extend_low_i32x4_s
    u32 i64x2.extend_low_i32x4_u
  • function v128.extend_high<TFrom>(a: v128): v128
    
    Extends the high half of narrower integer lanes to their respective wider lanes.
    TFrom Instruction
    i8 i16x8.extend_high_i8x16_s
    u8 i16x8.extend_high_i8x16_u
    i16 i32x4.extend_high_i16x8_s
    u16 i32x4.extend_high_i16x8_u
    i32 i64x2.extend_high_i32x4_s
    u32 i64x2.extend_high_i32x4_u
  • function v128.extadd_pairwise<TFrom>(a: v128): v128
    
    Adds lanes pairwise producing twice wider extended results.
    TFrom Instruction
    i16 i16x8.extadd_pairwise_i8x16_s
    u16 i16x8.extadd_pairwise_i8x16_u
    i32 i32x4.extadd_pairwise_i16x8_s
    u32 i32x4.extadd_pairwise_i16x8_u
  • function v128.demote_zero<T>(a: v128): v128
    
    Demotes each float lane to lower precision. The higher lanes of the result are initialized to zero.
    T Instruction
    f64 f32x4.demote_f64x2_zero
  • function v128.promote_low<T>(a: v128): v128
    
    Promotes the lower float lanes to higher precision.
    T Instruction
    f32 f64x2.promote_low_f32x4
  • function v128.q15mulr_sat<T>(a: v128, b: v128): v128
    
    Performs the line-wise saturating rounding multiplication in Q15 format.
    T Instruction
    i16 i16x8.q15mulr_sat_s
  • function v128.extmul_low<T>(a: v128, b: v128): v128
    
    Performs the lane-wise integer extended multiplication of the lower lanes producing a twice wider result than the inputs.
    T Instruction
    i8 i16x8.extmul_low_i8x16_s
    u8 i16x8.extmul_low_i8x16_u
    i16 i32x4.extmul_low_i16x8_s
    u16 i32x4.extmul_low_i16x8_u
    i32 i64x2.extmul_low_i32x4_s
    u32 i64x2.extmul_low_i32x4_u
  • function v128.extmul_high<T>(a: v128, b: v128): v128
    
    Performs the lane-wise integer extended multiplication of the higher lanes producing a twice wider result than the inputs.
    T Instruction
    i8 i16x8.extmul_high_i8x16_s
    u8 i16x8.extmul_high_i8x16_u
    i16 i32x4.extmul_high_i16x8_s
    u16 i32x4.extmul_high_i16x8_u
    i32 i64x2.extmul_high_i32x4_s
    u32 i64x2.extmul_high_i32x4_u

# Constructing constant vectors

  • function i8x16(a: i8, ... , p: i8): v128
    

    Initializes a 128-bit vector from sixteen 8-bit integer values. Arguments must be compile-time constants.

  • function i16x8(a: i16, ..., h: i16): v128
    

    Initializes a 128-bit vector from eight 16-bit integer values. Arguments must be compile-time constants.

  • function i32x4(a: i32, b: i32, c: i32, d: i32): v128
    

    Initializes a 128-bit vector from four 32-bit integer values. Arguments must be compile-time constants.

  • function i64x2(a: i64, b: i64): v128
    

    Initializes a 128-bit vector from two 64-bit integer values. Arguments must be compile-time constants.

  • function f32x4(a: f32, b: f32, c: f32, d: f32): v128
    

    Initializes a 128-bit vector from four 32-bit float values. Arguments must be compile-time constants.

  • function f64x2(a: f64, b: f64): v128
    

    Initializes a 128-bit vector from two 64-bit float values. Arguments must be compile-time constants.

# Inline instructions

In addition to using the generic builtins above, most WebAssembly instructions can be written directly in AssemblyScript code. For example, the following is equivalent:

// generic builtin
v128.splat<i32>(42);

// inline instruction
i32x4.splat(42);