🔬This is a nightly-only experimental API. (
simd_wasm64 #90599)Available on 
target_family="wasm" only.Expand description
Platform-specific intrinsics for the wasm target family.
See the module documentation for more details.
Structs§
- WASM-specific 128-bit wide SIMD vector type.
Functions§
- Materializes a SIMD value from the provided operands.
- f32x4_abssimd128Calculates the absolute value of each lane of a 128-bit vector interpreted as four 32-bit floating point numbers.
- f32x4_addsimd128Lane-wise addition of two 128-bit vectors interpreted as four 32-bit floating point numbers.
- f32x4_ceilsimd128Lane-wise rounding to the nearest integral value not smaller than the input.
- f32x4_convert_i32x4simd128Converts a 128-bit vector interpreted as four 32-bit signed integers into a 128-bit vector of four 32-bit floating point numbers.
- f32x4_convert_u32x4simd128Converts a 128-bit vector interpreted as four 32-bit unsigned integers into a 128-bit vector of four 32-bit floating point numbers.
- f32x4_demote_f64x2_zerosimd128Conversion of the two double-precision floating point lanes to two lower single-precision lanes of the result. The two higher lanes of the result are initialized to zero. If the conversion result is not representable as a single-precision floating point number, it is rounded to the nearest-even representable number.
- f32x4_divsimd128Lane-wise division of two 128-bit vectors interpreted as four 32-bit floating point numbers.
- f32x4_eqsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit floating point numbers.
- f32x4_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 4 packed f32 numbers.
- f32x4_floorsimd128Lane-wise rounding to the nearest integral value not greater than the input.
- f32x4_gesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit floating point numbers.
- f32x4_gtsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit floating point numbers.
- f32x4_lesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit floating point numbers.
- f32x4_ltsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit floating point numbers.
- f32x4_maxsimd128Calculates the lane-wise minimum of two 128-bit vectors interpreted as four 32-bit floating point numbers.
- f32x4_minsimd128Calculates the lane-wise minimum of two 128-bit vectors interpreted as four 32-bit floating point numbers.
- f32x4_mulsimd128Lane-wise multiplication of two 128-bit vectors interpreted as four 32-bit floating point numbers.
- f32x4_nesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit floating point numbers.
- f32x4_nearestsimd128Lane-wise rounding to the nearest integral value; if two values are equally near, rounds to the even one.
- f32x4_negsimd128Negates each lane of a 128-bit vector interpreted as four 32-bit floating point numbers.
- f32x4_pmaxsimd128Lane-wise maximum value, defined asa < b ? b : a
- f32x4_pminsimd128Lane-wise minimum value, defined asb < a ? b : a
- f32x4_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 4 packed f32 numbers.
- f32x4_splatsimd128Creates a vector with identical lanes.
- f32x4_sqrtsimd128Calculates the square root of each lane of a 128-bit vector interpreted as four 32-bit floating point numbers.
- f32x4_subsimd128Lane-wise subtraction of two 128-bit vectors interpreted as four 32-bit floating point numbers.
- f32x4_truncsimd128Lane-wise rounding to the nearest integral value with the magnitude not larger than the input.
- Materializes a SIMD value from the provided operands.
- f64x2_abssimd128Calculates the absolute value of each lane of a 128-bit vector interpreted as two 64-bit floating point numbers.
- f64x2_addsimd128Lane-wise add of two 128-bit vectors interpreted as two 64-bit floating point numbers.
- f64x2_ceilsimd128Lane-wise rounding to the nearest integral value not smaller than the input.
- f64x2_convert_low_i32x4simd128Lane-wise conversion from integer to floating point.
- f64x2_convert_low_u32x4simd128Lane-wise conversion from integer to floating point.
- f64x2_divsimd128Lane-wise divide of two 128-bit vectors interpreted as two 64-bit floating point numbers.
- f64x2_eqsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit floating point numbers.
- f64x2_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 2 packed f64 numbers.
- f64x2_floorsimd128Lane-wise rounding to the nearest integral value not greater than the input.
- f64x2_gesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit floating point numbers.
- f64x2_gtsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit floating point numbers.
- f64x2_lesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit floating point numbers.
- f64x2_ltsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit floating point numbers.
- f64x2_maxsimd128Calculates the lane-wise maximum of two 128-bit vectors interpreted as two 64-bit floating point numbers.
- f64x2_minsimd128Calculates the lane-wise minimum of two 128-bit vectors interpreted as two 64-bit floating point numbers.
- f64x2_mulsimd128Lane-wise multiply of two 128-bit vectors interpreted as two 64-bit floating point numbers.
- f64x2_nesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit floating point numbers.
- f64x2_nearestsimd128Lane-wise rounding to the nearest integral value; if two values are equally near, rounds to the even one.
- f64x2_negsimd128Negates each lane of a 128-bit vector interpreted as two 64-bit floating point numbers.
- f64x2_pmaxsimd128Lane-wise maximum value, defined asa < b ? b : a
- f64x2_pminsimd128Lane-wise minimum value, defined asb < a ? b : a
- f64x2_promote_low_f32x4simd128Conversion of the two lower single-precision floating point lanes to the two double-precision lanes of the result.
- f64x2_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 2 packed f64 numbers.
- f64x2_splatsimd128Creates a vector with identical lanes.
- f64x2_sqrtsimd128Calculates the square root of each lane of a 128-bit vector interpreted as two 64-bit floating point numbers.
- f64x2_subsimd128Lane-wise subtract of two 128-bit vectors interpreted as two 64-bit floating point numbers.
- f64x2_truncsimd128Lane-wise rounding to the nearest integral value with the magnitude not larger than the input.
- Materializes a SIMD value from the provided operands.
- i8x16_abssimd128Lane-wise wrapping absolute value.
- i8x16_addsimd128Adds two 128-bit vectors as if they were two packed sixteen 8-bit integers.
- i8x16_add_satsimd128Adds two 128-bit vectors as if they were two packed sixteen 8-bit signed integers, saturating on overflow toi8::MAX.
- i8x16_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- i8x16_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- i8x16_eqsimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit integers.
- i8x16_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 16 packed i8 numbers.
- i8x16_gesimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit signed integers.
- i8x16_gtsimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit signed integers.
- i8x16_lesimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit signed integers.
- i8x16_ltsimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit signed integers.
- i8x16_maxsimd128Compares lane-wise signed integers, and returns the maximum of each pair.
- i8x16_minsimd128Compares lane-wise signed integers, and returns the minimum of each pair.
- i8x16_narrow_i16x8simd128Converts two input vectors into a smaller lane vector by narrowing each lane.
- i8x16_nesimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit integers.
- i8x16_negsimd128Negates a 128-bit vectors interpreted as sixteen 8-bit signed integers
- i8x16_popcntsimd128Count the number of bits set to one within each lane.
- i8x16_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 16 packed i8 numbers.
- i8x16_shlsimd128Shifts each lane to the left by the specified number of bits.
- i8x16_shrsimd128Shifts each lane to the right by the specified number of bits, sign extending.
- i8x16_shufflesimd128Returns a new vector with lanes selected from the lanes of the two input vectors$aand$bspecified in the 16 immediate operands.
- i8x16_splatsimd128Creates a vector with identical lanes.
- i8x16_subsimd128Subtracts two 128-bit vectors as if they were two packed sixteen 8-bit integers.
- i8x16_sub_satsimd128Subtracts two 128-bit vectors as if they were two packed sixteen 8-bit signed integers, saturating on overflow toi8::MIN.
- i8x16_swizzlesimd128Returns a new vector with lanes selected from the lanes of the first input vectoraspecified in the second input vectors.
- Materializes a SIMD value from the provided operands.
- i16x8_abssimd128Lane-wise wrapping absolute value.
- i16x8_addsimd128Adds two 128-bit vectors as if they were two packed eight 16-bit integers.
- i16x8_add_satsimd128Adds two 128-bit vectors as if they were two packed eight 16-bit signed integers, saturating on overflow toi16::MAX.
- i16x8_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- i16x8_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- i16x8_eqsimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit integers.
- i16x8_extadd_pairwise_i8x16simd128Integer extended pairwise addition producing extended results (twice wider results than the inputs).
- i16x8_extadd_pairwise_u8x16simd128Integer extended pairwise addition producing extended results (twice wider results than the inputs).
- i16x8_extend_high_i8x16simd128Converts high half of the smaller lane vector to a larger lane vector, sign extended.
- i16x8_extend_high_u8x16simd128Converts high half of the smaller lane vector to a larger lane vector, zero extended.
- i16x8_extend_low_i8x16simd128Converts low half of the smaller lane vector to a larger lane vector, sign extended.
- i16x8_extend_low_u8x16simd128Converts low half of the smaller lane vector to a larger lane vector, zero extended.
- i16x8_extmul_high_i8x16simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i16x8_extmul_high_u8x16simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i16x8_extmul_low_i8x16simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i16x8_extmul_low_u8x16simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i16x8_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 8 packed i16 numbers.
- i16x8_gesimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit signed integers.
- i16x8_gtsimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit signed integers.
- i16x8_lesimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit signed integers.
- i16x8_load_extend_i8x8⚠simd128Load eight 8-bit integers and sign extend each one to a 16-bit lane
- i16x8_load_extend_u8x8⚠simd128Load eight 8-bit integers and zero extend each one to a 16-bit lane
- i16x8_ltsimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit signed integers.
- i16x8_maxsimd128Compares lane-wise signed integers, and returns the maximum of each pair.
- i16x8_minsimd128Compares lane-wise signed integers, and returns the minimum of each pair.
- i16x8_mulsimd128Multiplies two 128-bit vectors as if they were two packed eight 16-bit signed integers.
- i16x8_narrow_i32x4simd128Converts two input vectors into a smaller lane vector by narrowing each lane.
- i16x8_nesimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit integers.
- i16x8_negsimd128Negates a 128-bit vectors interpreted as eight 16-bit signed integers
- i16x8_q15mulr_satsimd128Lane-wise saturating rounding multiplication in Q15 format.
- i16x8_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 8 packed i16 numbers.
- i16x8_shlsimd128Shifts each lane to the left by the specified number of bits.
- i16x8_shrsimd128Shifts each lane to the right by the specified number of bits, sign extending.
- i16x8_shufflesimd128Same asi8x16_shuffle, except operates as if the inputs were eight 16-bit integers, only taking 8 indices to shuffle.
- i16x8_splatsimd128Creates a vector with identical lanes.
- i16x8_subsimd128Subtracts two 128-bit vectors as if they were two packed eight 16-bit integers.
- i16x8_sub_satsimd128Subtracts two 128-bit vectors as if they were two packed eight 16-bit signed integers, saturating on overflow toi16::MIN.
- Materializes a SIMD value from the provided operands.
- i32x4_abssimd128Lane-wise wrapping absolute value.
- i32x4_addsimd128Adds two 128-bit vectors as if they were two packed four 32-bit integers.
- i32x4_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- i32x4_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- i32x4_dot_i16x8simd128Lane-wise multiply signed 16-bit integers in the two input vectors and add adjacent pairs of the full 32-bit results.
- i32x4_eqsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit integers.
- i32x4_extadd_pairwise_i16x8simd128Integer extended pairwise addition producing extended results (twice wider results than the inputs).
- i32x4_extadd_pairwise_u16x8simd128Integer extended pairwise addition producing extended results (twice wider results than the inputs).
- i32x4_extend_high_i16x8simd128Converts high half of the smaller lane vector to a larger lane vector, sign extended.
- i32x4_extend_high_u16x8simd128Converts high half of the smaller lane vector to a larger lane vector, zero extended.
- i32x4_extend_low_i16x8simd128Converts low half of the smaller lane vector to a larger lane vector, sign extended.
- i32x4_extend_low_u16x8simd128Converts low half of the smaller lane vector to a larger lane vector, zero extended.
- i32x4_extmul_high_i16x8simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i32x4_extmul_high_u16x8simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i32x4_extmul_low_i16x8simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i32x4_extmul_low_u16x8simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i32x4_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 4 packed i32 numbers.
- i32x4_gesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit signed integers.
- i32x4_gtsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit signed integers.
- i32x4_lesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit signed integers.
- i32x4_load_extend_i16x4⚠simd128Load four 16-bit integers and sign extend each one to a 32-bit lane
- i32x4_load_extend_u16x4⚠simd128Load four 16-bit integers and zero extend each one to a 32-bit lane
- i32x4_ltsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit signed integers.
- i32x4_maxsimd128Compares lane-wise signed integers, and returns the maximum of each pair.
- i32x4_minsimd128Compares lane-wise signed integers, and returns the minimum of each pair.
- i32x4_mulsimd128Multiplies two 128-bit vectors as if they were two packed four 32-bit signed integers.
- i32x4_nesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit integers.
- i32x4_negsimd128Negates a 128-bit vectors interpreted as four 32-bit signed integers
- i32x4_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 4 packed i32 numbers.
- i32x4_shlsimd128Shifts each lane to the left by the specified number of bits.
- i32x4_shrsimd128Shifts each lane to the right by the specified number of bits, sign extending.
- i32x4_shufflesimd128Same asi8x16_shuffle, except operates as if the inputs were four 32-bit integers, only taking 4 indices to shuffle.
- i32x4_splatsimd128Creates a vector with identical lanes.
- i32x4_subsimd128Subtracts two 128-bit vectors as if they were two packed four 32-bit integers.
- i32x4_trunc_sat_f32x4simd128Converts a 128-bit vector interpreted as four 32-bit floating point numbers into a 128-bit vector of four 32-bit signed integers.
- i32x4_trunc_sat_f64x2_zerosimd128Saturating conversion of the two double-precision floating point lanes to two lower integer lanes using the IEEEconvertToIntegerTowardZerofunction.
- Materializes a SIMD value from the provided operands.
- i64x2_abssimd128Lane-wise wrapping absolute value.
- i64x2_addsimd128Adds two 128-bit vectors as if they were two packed two 64-bit integers.
- i64x2_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- i64x2_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- i64x2_eqsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit integers.
- i64x2_extend_high_i32x4simd128Converts high half of the smaller lane vector to a larger lane vector, sign extended.
- i64x2_extend_high_u32x4simd128Converts high half of the smaller lane vector to a larger lane vector, zero extended.
- i64x2_extend_low_i32x4simd128Converts low half of the smaller lane vector to a larger lane vector, sign extended.
- i64x2_extend_low_u32x4simd128Converts low half of the smaller lane vector to a larger lane vector, zero extended.
- i64x2_extmul_high_i32x4simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i64x2_extmul_high_u32x4simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i64x2_extmul_low_i32x4simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i64x2_extmul_low_u32x4simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- i64x2_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 2 packed i64 numbers.
- i64x2_gesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit signed integers.
- i64x2_gtsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit signed integers.
- i64x2_lesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit signed integers.
- i64x2_load_extend_i32x2⚠simd128Load two 32-bit integers and sign extend each one to a 64-bit lane
- i64x2_load_extend_u32x2⚠simd128Load two 32-bit integers and zero extend each one to a 64-bit lane
- i64x2_ltsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit signed integers.
- i64x2_mulsimd128Multiplies two 128-bit vectors as if they were two packed two 64-bit integers.
- i64x2_nesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit integers.
- i64x2_negsimd128Negates a 128-bit vectors interpreted as two 64-bit signed integers
- i64x2_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 2 packed i64 numbers.
- i64x2_shlsimd128Shifts each lane to the left by the specified number of bits.
- i64x2_shrsimd128Shifts each lane to the right by the specified number of bits, sign extending.
- i64x2_shufflesimd128Same asi8x16_shuffle, except operates as if the inputs were two 64-bit integers, only taking 2 indices to shuffle.
- i64x2_splatsimd128Creates a vector with identical lanes.
- i64x2_subsimd128Subtracts two 128-bit vectors as if they were two packed two 64-bit integers.
- Corresponding intrinsic to wasm’smemory.growinstruction
- Corresponding intrinsic to wasm’smemory.sizeinstruction
- Materializes a SIMD value from the provided operands.
- u8x16_addsimd128Adds two 128-bit vectors as if they were two packed sixteen 8-bit integers.
- u8x16_add_satsimd128Adds two 128-bit vectors as if they were two packed sixteen 8-bit unsigned integers, saturating on overflow tou8::MAX.
- u8x16_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- u8x16_avgrsimd128Lane-wise rounding average.
- u8x16_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- u8x16_eqsimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit integers.
- u8x16_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 16 packed u8 numbers.
- u8x16_gesimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit unsigned integers.
- u8x16_gtsimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit unsigned integers.
- u8x16_lesimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit unsigned integers.
- u8x16_ltsimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit unsigned integers.
- u8x16_maxsimd128Compares lane-wise unsigned integers, and returns the maximum of each pair.
- u8x16_minsimd128Compares lane-wise unsigned integers, and returns the minimum of each pair.
- u8x16_narrow_i16x8simd128Converts two input vectors into a smaller lane vector by narrowing each lane.
- u8x16_nesimd128Compares two 128-bit vectors as if they were two vectors of 16 eight-bit integers.
- u8x16_popcntsimd128Count the number of bits set to one within each lane.
- u8x16_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 16 packed u8 numbers.
- u8x16_shlsimd128Shifts each lane to the left by the specified number of bits.
- u8x16_shrsimd128Shifts each lane to the right by the specified number of bits, shifting in zeros.
- u8x16_shufflesimd128Returns a new vector with lanes selected from the lanes of the two input vectors$aand$bspecified in the 16 immediate operands.
- u8x16_splatsimd128Creates a vector with identical lanes.
- u8x16_subsimd128Subtracts two 128-bit vectors as if they were two packed sixteen 8-bit integers.
- u8x16_sub_satsimd128Subtracts two 128-bit vectors as if they were two packed sixteen 8-bit unsigned integers, saturating on overflow to 0.
- u8x16_swizzlesimd128Returns a new vector with lanes selected from the lanes of the first input vectoraspecified in the second input vectors.
- Materializes a SIMD value from the provided operands.
- u16x8_addsimd128Adds two 128-bit vectors as if they were two packed eight 16-bit integers.
- u16x8_add_satsimd128Adds two 128-bit vectors as if they were two packed eight 16-bit unsigned integers, saturating on overflow tou16::MAX.
- u16x8_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- u16x8_avgrsimd128Lane-wise rounding average.
- u16x8_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- u16x8_eqsimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit integers.
- u16x8_extadd_pairwise_u8x16simd128Integer extended pairwise addition producing extended results (twice wider results than the inputs).
- u16x8_extend_high_u8x16simd128Converts high half of the smaller lane vector to a larger lane vector, zero extended.
- u16x8_extend_low_u8x16simd128Converts low half of the smaller lane vector to a larger lane vector, zero extended.
- u16x8_extmul_high_u8x16simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- u16x8_extmul_low_u8x16simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- u16x8_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 8 packed u16 numbers.
- u16x8_gesimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit unsigned integers.
- u16x8_gtsimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit unsigned integers.
- u16x8_lesimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit unsigned integers.
- u16x8_load_extend_u8x8⚠simd128Load eight 8-bit integers and zero extend each one to a 16-bit lane
- u16x8_ltsimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit unsigned integers.
- u16x8_maxsimd128Compares lane-wise unsigned integers, and returns the maximum of each pair.
- u16x8_minsimd128Compares lane-wise unsigned integers, and returns the minimum of each pair.
- u16x8_mulsimd128Multiplies two 128-bit vectors as if they were two packed eight 16-bit signed integers.
- u16x8_narrow_i32x4simd128Converts two input vectors into a smaller lane vector by narrowing each lane.
- u16x8_nesimd128Compares two 128-bit vectors as if they were two vectors of 8 sixteen-bit integers.
- u16x8_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 8 packed u16 numbers.
- u16x8_shlsimd128Shifts each lane to the left by the specified number of bits.
- u16x8_shrsimd128Shifts each lane to the right by the specified number of bits, shifting in zeros.
- u16x8_shufflesimd128Same asi8x16_shuffle, except operates as if the inputs were eight 16-bit integers, only taking 8 indices to shuffle.
- u16x8_splatsimd128Creates a vector with identical lanes.
- u16x8_subsimd128Subtracts two 128-bit vectors as if they were two packed eight 16-bit integers.
- u16x8_sub_satsimd128Subtracts two 128-bit vectors as if they were two packed eight 16-bit unsigned integers, saturating on overflow to 0.
- Materializes a SIMD value from the provided operands.
- u32x4_addsimd128Adds two 128-bit vectors as if they were two packed four 32-bit integers.
- u32x4_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- u32x4_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- u32x4_eqsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit integers.
- u32x4_extadd_pairwise_u16x8simd128Integer extended pairwise addition producing extended results (twice wider results than the inputs).
- u32x4_extend_high_u16x8simd128Converts high half of the smaller lane vector to a larger lane vector, zero extended.
- u32x4_extend_low_u16x8simd128Converts low half of the smaller lane vector to a larger lane vector, zero extended.
- u32x4_extmul_high_u16x8simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- u32x4_extmul_low_u16x8simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- u32x4_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 4 packed u32 numbers.
- u32x4_gesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit unsigned integers.
- u32x4_gtsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit unsigned integers.
- u32x4_lesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit unsigned integers.
- u32x4_load_extend_u16x4⚠simd128Load four 16-bit integers and zero extend each one to a 32-bit lane
- u32x4_ltsimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit unsigned integers.
- u32x4_maxsimd128Compares lane-wise unsigned integers, and returns the maximum of each pair.
- u32x4_minsimd128Compares lane-wise unsigned integers, and returns the minimum of each pair.
- u32x4_mulsimd128Multiplies two 128-bit vectors as if they were two packed four 32-bit signed integers.
- u32x4_nesimd128Compares two 128-bit vectors as if they were two vectors of 4 thirty-two-bit integers.
- u32x4_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 4 packed u32 numbers.
- u32x4_shlsimd128Shifts each lane to the left by the specified number of bits.
- u32x4_shrsimd128Shifts each lane to the right by the specified number of bits, shifting in zeros.
- u32x4_shufflesimd128Same asi8x16_shuffle, except operates as if the inputs were four 32-bit integers, only taking 4 indices to shuffle.
- u32x4_splatsimd128Creates a vector with identical lanes.
- u32x4_subsimd128Subtracts two 128-bit vectors as if they were two packed four 32-bit integers.
- u32x4_trunc_sat_f32x4simd128Converts a 128-bit vector interpreted as four 32-bit floating point numbers into a 128-bit vector of four 32-bit unsigned integers.
- u32x4_trunc_sat_f64x2_zerosimd128Saturating conversion of the two double-precision floating point lanes to two lower integer lanes using the IEEEconvertToIntegerTowardZerofunction.
- Materializes a SIMD value from the provided operands.
- u64x2_addsimd128Adds two 128-bit vectors as if they were two packed two 64-bit integers.
- u64x2_all_truesimd128Returns true if all lanes are non-zero, false otherwise.
- u64x2_bitmasksimd128Extracts the high bit for each lane inaand produce a scalar mask with all bits concatenated.
- u64x2_eqsimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit integers.
- u64x2_extend_high_u32x4simd128Converts high half of the smaller lane vector to a larger lane vector, zero extended.
- u64x2_extend_low_u32x4simd128Converts low half of the smaller lane vector to a larger lane vector, zero extended.
- u64x2_extmul_high_u32x4simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- u64x2_extmul_low_u32x4simd128Lane-wise integer extended multiplication producing twice wider result than the inputs.
- u64x2_extract_lanesimd128Extracts a lane from a 128-bit vector interpreted as 2 packed u64 numbers.
- u64x2_load_extend_u32x2⚠simd128Load two 32-bit integers and zero extend each one to a 64-bit lane
- u64x2_mulsimd128Multiplies two 128-bit vectors as if they were two packed two 64-bit integers.
- u64x2_nesimd128Compares two 128-bit vectors as if they were two vectors of 2 sixty-four-bit integers.
- u64x2_replace_lanesimd128Replaces a lane from a 128-bit vector interpreted as 2 packed u64 numbers.
- u64x2_shlsimd128Shifts each lane to the left by the specified number of bits.
- u64x2_shrsimd128Shifts each lane to the right by the specified number of bits, shifting in zeros.
- u64x2_shufflesimd128Same asi8x16_shuffle, except operates as if the inputs were two 64-bit integers, only taking 2 indices to shuffle.
- u64x2_splatsimd128Creates a vector with identical lanes.
- u64x2_subsimd128Subtracts two 128-bit vectors as if they were two packed two 64-bit integers.
- Generates theunreachableinstruction, which causes an unconditional trap.
- v128_andsimd128Performs a bitwise and of the two input 128-bit vectors, returning the resulting vector.
- v128_andnotsimd128Bitwise AND of bits ofaand the logical inverse of bits ofb.
- v128_any_truesimd128Returnstrueif any bit inais set, orfalseotherwise.
- v128_bitselectsimd128Use the bitmask incto select bits fromv1when 1 andv2when 0.
- v128_load⚠simd128Loads av128vector from the given heap address.
- v128_load8_lane⚠simd128Loads an 8-bit value frommand sets laneLofvto that value.
- v128_load8_splat⚠simd128Load a single element and splat to all lanes of a v128 vector.
- v128_load16_lane⚠simd128Loads a 16-bit value frommand sets laneLofvto that value.
- v128_load16_splat⚠simd128Load a single element and splat to all lanes of a v128 vector.
- v128_load32_lane⚠simd128Loads a 32-bit value frommand sets laneLofvto that value.
- v128_load32_splat⚠simd128Load a single element and splat to all lanes of a v128 vector.
- v128_load32_zero⚠simd128Load a 32-bit element into the low bits of the vector and sets all other bits to zero.
- v128_load64_lane⚠simd128Loads a 64-bit value frommand sets laneLofvto that value.
- v128_load64_splat⚠simd128Load a single element and splat to all lanes of a v128 vector.
- v128_load64_zero⚠simd128Load a 64-bit element into the low bits of the vector and sets all other bits to zero.
- v128_notsimd128Flips each bit of the 128-bit input vector.
- v128_orsimd128Performs a bitwise or of the two input 128-bit vectors, returning the resulting vector.
- v128_store⚠simd128Stores av128vector to the given heap address.
- v128_store8_lane⚠simd128Stores the 8-bit value from laneLofvintom
- v128_store16_lane⚠simd128Stores the 16-bit value from laneLofvintom
- v128_store32_lane⚠simd128Stores the 32-bit value from laneLofvintom
- v128_store64_lane⚠simd128Stores the 64-bit value from laneLofvintom
- v128_xorsimd128Performs a bitwise xor of the two input 128-bit vectors, returning the resulting vector.
- Computesa * b + cwith either one rounding or two roundings.
- A relaxed version off32x4_maxwhich is eitherf32x4_maxorf32x4_pmax.
- A relaxed version off32x4_minwhich is eitherf32x4_minorf32x4_pmin.
- Computes-a * b + cwith either one rounding or two roundings.
- Computesa * b + cwith either one rounding or two roundings.
- A relaxed version off64x2_maxwhich is eitherf64x2_maxorf64x2_pmax.
- A relaxed version off64x2_minwhich is eitherf64x2_minorf64x2_pmin.
- Computes-a * b + cwith either one rounding or two roundings.
- A relaxed version ofv128_bitselectwhere this either behaves the same asv128_bitselector the high bit of each lanemis inspected and the corresponding lane ofais chosen if the bit is 1 or the lane ofbis chosen if it’s zero.
- A relaxed version ofi8x16_swizzle(a, s)which selects lanes fromausing indices ins.
- A relaxed dot-product instruction.
- A relaxed version ofv128_bitselectwhere this either behaves the same asv128_bitselector the high bit of each lanemis inspected and the corresponding lane ofais chosen if the bit is 1 or the lane ofbis chosen if it’s zero.
- A relaxed version ofi16x8_relaxed_q15mulrwhere if both lanes arei16::MINthen the result is eitheri16::MINori16::MAX.
- Similar toi16x8_relaxed_dot_i8x16_i7x16except that the intermediatei16x8result is fed intoi32x4_extadd_pairwise_i16x8followed byi32x4_addto add the valuecto the result.
- A relaxed version ofv128_bitselectwhere this either behaves the same asv128_bitselector the high bit of each lanemis inspected and the corresponding lane ofais chosen if the bit is 1 or the lane ofbis chosen if it’s zero.
- A relaxed version ofi32x4_trunc_sat_f32x4(a)converts thef32lanes ofato signed 32-bit integers.
- A relaxed version ofi32x4_trunc_sat_f64x2_zero(a)converts thef64lanes ofato signed 32-bit integers and the upper two lanes are zero.
- A relaxed version ofv128_bitselectwhere this either behaves the same asv128_bitselector the high bit of each lanemis inspected and the corresponding lane ofais chosen if the bit is 1 or the lane ofbis chosen if it’s zero.
- Corresponding intrinsic to wasm’smemory.atomic.notifyinstruction
- Corresponding intrinsic to wasm’smemory.atomic.wait32instruction
- Corresponding intrinsic to wasm’smemory.atomic.wait64instruction
- throw⚠ExperimentalGenerates thethrowinstruction from the exception-handling proposal for WASM.
- A relaxed version ofu32x4_trunc_sat_f32x4(a)converts thef32lanes ofato unsigned 32-bit integers.
- A relaxed version ofu32x4_trunc_sat_f64x2_zero(a)converts thef64lanes ofato unsigned 32-bit integers and the upper two lanes are zero.