Module core::arch::wasm

🔬This is a nightly-only experimental API. (simd_wasm64 #90599)

Available on target_family="wasm" only.

特定于平台的用于 wasm 目标家庭的内部函数。

有关更多详细信息，请参见 模块级文档。

Structs

• v128
  特定于 WASM 的 128 位宽 SIMD vector 类型。

Functions

• f32x4_relaxed_maddExperimentalrelaxed-simd
  使用一次舍入或两次舍入计算 a * b + c。
• f32x4_relaxed_maxExperimentalrelaxed-simd
  f32x4_max 的宽松版本，即 f32x4_max 或 f32x4_pmax。
• f32x4_relaxed_minExperimentalrelaxed-simd
  f32x4_min 的宽松版本，即 f32x4_min 或 f32x4_pmin。
• f32x4_relaxed_nmaddExperimentalrelaxed-simd
  使用一次舍入或两次舍入计算 -a * b + c。
• f64x2_relaxed_maddExperimentalrelaxed-simd
  使用一次舍入或两次舍入计算 a * b + c。
• f64x2_relaxed_maxExperimentalrelaxed-simd
  f64x2_max 的宽松版本，即 f64x2_max 或 f64x2_pmax。
• f64x2_relaxed_minExperimentalrelaxed-simd
  f64x2_min 的宽松版本，即 f64x2_min 或 f64x2_pmin。
• f64x2_relaxed_nmaddExperimentalrelaxed-simd
  使用一次舍入或两次舍入计算 -a * b + c。
• i8x16_relaxed_laneselectExperimentalrelaxed-simd
  v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
• i8x16_relaxed_swizzleExperimentalrelaxed-simd
  i8x16_swizzle(a, s) 的轻松版本，它使用 s 中的索引从 a 中选择 lanes。
• i16x8_relaxed_dot_i8x16_i7x16Experimentalrelaxed-simd
  轻松的点积指令。
• i16x8_relaxed_laneselectExperimentalrelaxed-simd
  v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
• i16x8_relaxed_q15mulrExperimentalrelaxed-simd
  i16x8_relaxed_q15mulr 的宽松版本，如果两个 lanes 都是 i16::MIN，则结果是 i16::MIN 或 i16::MAX。
• i32x4_relaxed_dot_i8x16_i7x16_addExperimentalrelaxed-simd
  与 i16x8_relaxed_dot_i8x16_i7x16 类似，不同之处在于中间 i16x8 结果被馈送到 i32x4_extadd_pairwise_i16x8，然后 i32x4_add 将值 c 添加到结果中。
• i32x4_relaxed_laneselectExperimentalrelaxed-simd
  v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
• i32x4_relaxed_trunc_f32x4Experimentalrelaxed-simd
  i32x4_trunc_sat_f32x4(a) 的宽松版本将 a 的 f32 lanes 转换为带符号的 32 位整数。
• i32x4_relaxed_trunc_f64x2_zeroExperimentalrelaxed-simd
  i32x4_trunc_sat_f64x2_zero(a) 的宽松版本将 a 的 f64 lanes 转换为带符号的 32 位整数，并且高两个 lanes 为零。
• i64x2_relaxed_laneselectExperimentalrelaxed-simd
  v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
• memory_atomic_notify^⚠Experimentalatomics
  对应 wasm 的 memory.atomic.notify 指令
• memory_atomic_wait32^⚠Experimentalatomics
  对应 wasm 的 memory.atomic.wait32 指令
• memory_atomic_wait64^⚠Experimentalatomics
  对应 wasm 的 memory.atomic.wait64 指令
• u32x4_relaxed_trunc_f32x4Experimentalrelaxed-simd
  u32x4_trunc_sat_f32x4(a) 的宽松版本将 a 的 f32 lanes 转换为无符号 32 位整数。
• u32x4_relaxed_trunc_f64x2_zeroExperimentalrelaxed-simd
  u32x4_trunc_sat_f64x2_zero(a) 的宽松版本将 a 的 f64 lanes 转换为无符号 32 位整数，并且高两个 lanes 为零。
• f32x4simd128
  从提供的操作数实现 SIMD 值。
• f32x4_abssimd128
  计算一个 128 位 vector 的每个 lane 的绝对值，该绝对值解释为四个 32 位浮点数。
• f32x4_addsimd128
  Lane 两个 128 位 vectors 的加法被解释为四个 32 位浮点数。
• f32x4_ceilsimd128
  按 lane-wise 舍入到不小于输入的最近整数值。
• f32x4_convert_i32x4simd128
  将解释为四个 32 位有符号整数的 128 位 vector 转换为 四个 32 位浮点数的 128 位 vector。
• f32x4_convert_u32x4simd128
  将解释为四个 32 位无符号整数的 128 位 vector 转换为 四个 32 位浮点数的 128 位 vector。
• f32x4_demote_f64x2_zerosimd128
  将结果的两个双精度浮点 lanes 转换为两个较低的单精度 lanes。 结果的两个较高 lane 被初始化为零。 如果转换结果不能表示为单精度浮点数，则将其四舍五入为最接近的偶数可表示数。
• f32x4_divsimd128
  两个 128 位 vectors 的 Lane 除法解释为四个 32 位浮点数。
• f32x4_eqsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
• f32x4_extract_lanesimd128
  从解释为 4 个包装的 f32 数字的 128 位 vector 中提取 lane。
• f32x4_floorsimd128
  按 lane-wise 舍入到不大于输入的最近整数值。
• f32x4_gesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
• f32x4_gtsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
• f32x4_lesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
• f32x4_ltsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
• f32x4_maxsimd128
  计算两个 128 位 vectors 的 lane 最小值，解释为四个 32 位浮点数。
• f32x4_minsimd128
  计算两个 128 位 vectors 的 lane 最小值，解释为四个 32 位浮点数。
• f32x4_mulsimd128
  两个 128 位 vectors 的 Lane 乘法被解释为四个 32 位浮点数。
• f32x4_nesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
• f32x4_nearestsimd128
  按 lane-wise 舍入到最接近的整数值； 如果两个值相等，则舍入到偶数。
• f32x4_negsimd128
  对解释为四个 32 位浮点数的 128 位向量的每个 lane 求反。
• f32x4_pmaxsimd128
  lane-wise 最大值，定义为 a < b ? b : a
• f32x4_pminsimd128
  lane-wise 最小值，定义为 b < a ? b : a
• f32x4_replace_lanesimd128
  从解释为 4 个包装的 f32 编号的 128 位 vector 替换一个 lane。
• f32x4_splatsimd128
  创建具有相同 lanes 的 vector。
• f32x4_sqrtsimd128
  计算一个 128 位 vector 的每个 lane 的平方根，该 vector 解释为四个 32 位浮点数。
• f32x4_subsimd128
  两个 128 位 vectors 的 Lane 减法被解释为四个 32 位浮点数。
• f32x4_truncsimd128
  按 lane-wise 舍入到最接近的整数值，幅度不大于输入。
• f64x2simd128
  从提供的操作数实现 SIMD 值。
• f64x2_abssimd128
  计算被解释为两个 64 位浮点数的 128 位 vector 的每个 lane 的绝对值。
• f64x2_addsimd128
  两个 128 位 vectors 的 Lane 方式相加被解释为两个 64 位浮点数。
• f64x2_ceilsimd128
  按 lane-wise 舍入到不小于输入的最近整数值。
• f64x2_convert_low_i32x4simd128
  从整数到浮点的按 lane-wise 转换。
• f64x2_convert_low_u32x4simd128
  从整数到浮点的按 lane-wise 转换。
• f64x2_divsimd128
  两个 128 位 vectors 的 Lane 方式除法被解释为两个 64 位浮点数。
• f64x2_eqsimd128
  比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
• f64x2_extract_lanesimd128
  从解释为 2 个包装的 f64 编号的 128 位 vector 中提取 lane。
• f64x2_floorsimd128
  按 lane-wise 舍入到不大于输入的最近整数值。
• f64x2_gesimd128
  比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
• f64x2_gtsimd128
  比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
• f64x2_lesimd128
  比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
• f64x2_ltsimd128
  比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
• f64x2_maxsimd128
  计算两个 128 位 vectors 的 lane 最大值，解释为两个 64 位浮点数。
• f64x2_minsimd128
  计算两个 128 位 vectors 的 lane 最小值，解释为两个 64 位浮点数。
• f64x2_mulsimd128
  两个 128 位 vectors 的 Lane 乘法被解释为两个 64 位浮点数。
• f64x2_nesimd128
  比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
• f64x2_nearestsimd128
  按 lane-wise 舍入到最接近的整数值； 如果两个值相等，则舍入到偶数。
• f64x2_negsimd128
  取反解释为两个 64 位浮点数的 128 位 vector 的每个 lane。
• f64x2_pmaxsimd128
  lane-wise 最大值，定义为 a < b ? b : a
• f64x2_pminsimd128
  lane-wise 最小值，定义为 b < a ? b : a
• f64x2_promote_low_f32x4simd128
  将两个较低的单精度浮点 lanes 转换为结果的两个双精度 lanes。
• f64x2_replace_lanesimd128
  从一个解释为 2 包装的 f64 编号的 128 位 vector 替换一个 lane。
• f64x2_splatsimd128
  创建具有相同 lanes 的 vector。
• f64x2_sqrtsimd128
  计算一个 128 位 vector 的每个 lane 的平方根，该 vector 解释为两个 64 位浮点数。
• f64x2_subsimd128
  两个 128 位 vectors 的 Lane 减法被解释为两个 64 位浮点数。
• f64x2_truncsimd128
  按 lane-wise 舍入到最接近的整数值，幅度不大于输入。
• i8x16simd128
  从提供的操作数实现 SIMD 值。
• i8x16_abssimd128
  按 lane-wise 包装绝对值。
• i8x16_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位整数一样。
• i8x16_add_satsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位有符号整数一样，在溢出到 i8::MAX 时会饱和。
• i8x16_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• i8x16_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• i8x16_eqsimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
• i8x16_extract_lanesimd128
  从解释为 16 个包装的 i8 数字的 128 位 vector 中提取 lane。
• i8x16_gesimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
• i8x16_gtsimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
• i8x16_lesimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
• i8x16_ltsimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
• i8x16_maxsimd128
  比较 lane-wise 有符号整数，并返回每对的最大值。
• i8x16_minsimd128
  比较 lane-wise 有符号整数，并返回每对中的最小值。
• i8x16_narrow_i16x8simd128
  通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
• i8x16_nesimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
• i8x16_negsimd128
  对解释为 16 个 8 位有符号整数的 128 位 vectors 求反
• i8x16_popcntsimd128
  计算每个 lane 内设置为 1 的位数。
• i8x16_replace_lanesimd128
  替换 128 位 vector 中的 lane，该 lane 被解释为 16 个包装的 i8 数字。
• i8x16_shlsimd128
  将每个 lane 向左移动指定的位数。
• i8x16_shrsimd128
  将每个 lane 向右移动指定的位数，并扩展符号。
• i8x16_shufflesimd128
  返回一个新的 vector，其 lanes 从 16 个 immediate 操作数中指定的两个输入 vectors $a 和 $b 的 lanes 中选择。
• i8x16_splatsimd128
  创建具有相同 lanes 的 vector。
• i8x16_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位整数一样。
• i8x16_sub_satsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位有符号整数一样，在溢出到 i8::MIN 时会饱和。
• i8x16_swizzlesimd128
  返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的 lanes 中选择的 lanes 的新 vector。
• i16x8simd128
  从提供的操作数实现 SIMD 值。
• i16x8_abssimd128
  按 lane-wise 包装绝对值。
• i16x8_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位整数一样。
• i16x8_add_satsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位有符号整数一样，在溢出到 i16::MAX 时会饱和。
• i16x8_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• i16x8_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• i16x8_eqsimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
• i16x8_extadd_pairwise_i8x16simd128
  整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
• i16x8_extadd_pairwise_u8x16simd128
  整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
• i16x8_extend_high_i8x16simd128
  将较小 lane vector 的高一半转换为较大 lane vector，并对其进行符号扩展。
• i16x8_extend_high_u8x16simd128
  将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
• i16x8_extend_low_i8x16simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，并扩展符号。
• i16x8_extend_low_u8x16simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
• i16x8_extmul_high_i8x16simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i16x8_extmul_high_u8x16simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i16x8_extmul_low_i8x16simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i16x8_extmul_low_u8x16simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i16x8_extract_lanesimd128
  从解释为 8 个包装的 i16 数字的 128 位 vector 中提取 lane。
• i16x8_gesimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
• i16x8_gtsimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
• i16x8_lesimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
• i16x8_load_extend_i8x8^⚠simd128
  加载 8 个 8 位整数，并将每个符号扩展到 16 位 lane
• i16x8_load_extend_u8x8^⚠simd128
  加载 8 个 8 位整数，零加载每个整数至 16 位 lane
• i16x8_ltsimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
• i16x8_maxsimd128
  比较 lane-wise 有符号整数，并返回每对的最大值。
• i16x8_minsimd128
  比较 lane-wise 有符号整数，并返回每对中的最小值。
• i16x8_mulsimd128
  将两个 128 位 vectors 相乘，就好像它们是两个包装的八个 16 位有符号整数一样。
• i16x8_narrow_i32x4simd128
  通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
• i16x8_nesimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
• i16x8_negsimd128
  对解释为八个 16 位有符号整数的 128 位 vectors 求反
• i16x8_q15mulr_satsimd128
  Q15 格式的 lane-wise 饱和舍入乘法。
• i16x8_replace_lanesimd128
  从解释为 8 个包装的 i16 编号的 128 位 vector 替换一个 lane。
• i16x8_shlsimd128
  将每个 lane 向左移动指定的位数。
• i16x8_shrsimd128
  将每个 lane 向右移动指定的位数，并扩展符号。
• i16x8_shufflesimd128
  与 i8x16_shuffle 相同，只是操作起来好像输入是八个 16 位整数，仅需 8 个索引即可重排。
• i16x8_splatsimd128
  创建具有相同 lanes 的 vector。
• i16x8_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位整数一样。
• i16x8_sub_satsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位有符号整数一样，在溢出到 i16::MIN 时会饱和。
• i32x4simd128
  从提供的操作数实现 SIMD 值。
• i32x4_abssimd128
  按 lane-wise 包装绝对值。
• i32x4_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的四个 32 位整数一样。
• i32x4_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• i32x4_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• i32x4_dot_i16x8simd128
  在两个输入 vectors 中按 lane-wise 乘以带符号的 16 位整数，并将完整的 32 位结果的相邻对相加。
• i32x4_eqsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
• i32x4_extadd_pairwise_i16x8simd128
  整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
• i32x4_extadd_pairwise_u16x8simd128
  整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
• i32x4_extend_high_i16x8simd128
  将较小 lane vector 的高一半转换为较大 lane vector，并对其进行符号扩展。
• i32x4_extend_high_u16x8simd128
  将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
• i32x4_extend_low_i16x8simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，并扩展符号。
• i32x4_extend_low_u16x8simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
• i32x4_extmul_high_i16x8simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i32x4_extmul_high_u16x8simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i32x4_extmul_low_i16x8simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i32x4_extmul_low_u16x8simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i32x4_extract_lanesimd128
  从解释为 4 个包装的 i32 数字的 128 位 vector 中提取 lane。
• i32x4_gesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
• i32x4_gtsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
• i32x4_lesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
• i32x4_load_extend_i16x4^⚠simd128
  加载四个 16 位整数，并将每个符号扩展到 32 位 lane
• i32x4_load_extend_u16x4^⚠simd128
  加载四个 16 位整数，零加载一个整数到 32 位 lane
• i32x4_ltsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
• i32x4_maxsimd128
  比较 lane-wise 有符号整数，并返回每对的最大值。
• i32x4_minsimd128
  比较 lane-wise 有符号整数，并返回每对中的最小值。
• i32x4_mulsimd128
  将两个 128 位 vectors 相乘，就好像它们是两个包装的四个 32 位有符号整数一样。
• i32x4_nesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
• i32x4_negsimd128
  对解释为四个 32 位有符号整数的 128 位 vectors 求反
• i32x4_replace_lanesimd128
  从解释为 4 个包装的 i32 编号的 128 位 vector 替换一个 lane。
• i32x4_shlsimd128
  将每个 lane 向左移动指定的位数。
• i32x4_shrsimd128
  将每个 lane 向右移动指定的位数，并扩展符号。
• i32x4_shufflesimd128
  与 i8x16_shuffle 相同，但操作时如同输入为 4 32 位整数，仅需 4 个索引即可重排。
• i32x4_splatsimd128
  创建具有相同 lanes 的 vector。
• i32x4_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的四个 32 位整数一样。
• i32x4_trunc_sat_f32x4simd128
  将解释为四个 32 位浮点数的 128 位 vector 转换为包含四个 32 位带符号整数的 128 位 vector。
• i32x4_trunc_sat_f64x2_zerosimd128
  使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点 lanes 饱和转换为两个较低的整数 lanes。
• i64x2simd128
  从提供的操作数实现 SIMD 值。
• i64x2_abssimd128
  按 lane-wise 包装绝对值。
• i64x2_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的两个 64 位整数一样。
• i64x2_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• i64x2_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• i64x2_eqsimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
• i64x2_extend_high_i32x4simd128
  将较小 lane vector 的高一半转换为较大 lane vector，并对其进行符号扩展。
• i64x2_extend_high_u32x4simd128
  将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
• i64x2_extend_low_i32x4simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，并扩展符号。
• i64x2_extend_low_u32x4simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
• i64x2_extmul_high_i32x4simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i64x2_extmul_high_u32x4simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i64x2_extmul_low_i32x4simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i64x2_extmul_low_u32x4simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• i64x2_extract_lanesimd128
  从解释为 2 个包装的 i64 编号的 128 位 vector 中提取 lane。
• i64x2_gesimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
• i64x2_gtsimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
• i64x2_lesimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
• i64x2_load_extend_i32x2^⚠simd128
  加载两个 32 位整数并将每个符号扩展到 64 位 lane
• i64x2_load_extend_u32x2^⚠simd128
  加载两个 32 位整数，零加载每个整数到 64 位 lane
• i64x2_ltsimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
• i64x2_mulsimd128
  将两个 128 位 vectors 相乘，就好像它们是两个包装的两个 64 位整数一样。
• i64x2_nesimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
• i64x2_negsimd128
  对解释为两个 64 位有符号整数的 128 位 vectors 求反
• i64x2_replace_lanesimd128
  从一个解释为 2 个包装的 i64 编号的 128 位 vector 替换一个 lane。
• i64x2_shlsimd128
  将每个 lane 向左移动指定的位数。
• i64x2_shrsimd128
  将每个 lane 向右移动指定的位数，并扩展符号。
• i64x2_shufflesimd128
  与 i8x16_shuffle 相同，但操作时就像输入是两个 64 位整数，仅需 2 个索引即可重排。
• i64x2_splatsimd128
  创建具有相同 lanes 的 vector。
• i64x2_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的两个 64 位整数一样。
• memory_grow
  对应 wasm 的 memory.grow 指令
• memory_size
  对应 wasm 的 memory.size 指令
• u8x16simd128
  从提供的操作数实现 SIMD 值。
• u8x16_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位整数一样。
• u8x16_add_satsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位无符号整数一样，在溢出到 u8::MAX 时会饱和。
• u8x16_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• u8x16_avgrsimd128
  lane-wise 舍入平均值。
• u8x16_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• u8x16_eqsimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
• u8x16_extract_lanesimd128
  从解释为 16 个包装的 u8 数字的 128 位 vector 中提取一个 lane。
• u8x16_gesimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
• u8x16_gtsimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
• u8x16_lesimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
• u8x16_ltsimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
• u8x16_maxsimd128
  比较 lane-wise 无符号整数，并返回每对的最大值。
• u8x16_minsimd128
  比较 lane-wise 无符号整数，并返回每对中的最小值。
• u8x16_narrow_i16x8simd128
  通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
• u8x16_nesimd128
  比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
• u8x16_popcntsimd128
  计算每个 lane 内设置为 1 的位数。
• u8x16_replace_lanesimd128
  从解释为 16 个包装的 u8 数字的 128 位 vector 替换一个 lane。
• u8x16_shlsimd128
  将每个 lane 向左移动指定的位数。
• u8x16_shrsimd128
  将每个 lane 向右移动指定的位数，以零为单位。
• u8x16_shufflesimd128
  返回一个新的 vector，其 lanes 从 16 个 immediate 操作数中指定的两个输入 vectors $a 和 $b 的 lanes 中选择。
• u8x16_splatsimd128
  创建具有相同 lanes 的 vector。
• u8x16_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位整数一样。
• u8x16_sub_satsimd128
  减去两个 128 位 vectors，就好像它们是两个包装的 16 个 8 位无符号整数，溢出时饱和到 0.
• u8x16_swizzlesimd128
  返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的 lanes 中选择的 lanes 的新 vector。
• u16x8simd128
  从提供的操作数实现 SIMD 值。
• u16x8_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位整数一样。
• u16x8_add_satsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位无符号整数一样，在溢出到 u16::MAX 时会饱和。
• u16x8_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• u16x8_avgrsimd128
  lane-wise 舍入平均值。
• u16x8_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• u16x8_eqsimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
• u16x8_extadd_pairwise_u8x16simd128
  整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
• u16x8_extend_high_u8x16simd128
  将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
• u16x8_extend_low_u8x16simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
• u16x8_extmul_high_u8x16simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• u16x8_extmul_low_u8x16simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• u16x8_extract_lanesimd128
  从解释为 8 个包装的 u16 数字的 128 位 vector 中提取一个 lane。
• u16x8_gesimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
• u16x8_gtsimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
• u16x8_lesimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
• u16x8_load_extend_u8x8^⚠simd128
  加载 8 个 8 位整数，零加载每个整数至 16 位 lane
• u16x8_ltsimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
• u16x8_maxsimd128
  比较 lane-wise 无符号整数，并返回每对的最大值。
• u16x8_minsimd128
  比较 lane-wise 无符号整数，并返回每对中的最小值。
• u16x8_mulsimd128
  将两个 128 位 vectors 相乘，就好像它们是两个包装的八个 16 位有符号整数一样。
• u16x8_narrow_i32x4simd128
  通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
• u16x8_nesimd128
  比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
• u16x8_replace_lanesimd128
  从解释为 8 个包装的 u16 数字的 128 位 vector 替换一个 lane。
• u16x8_shlsimd128
  将每个 lane 向左移动指定的位数。
• u16x8_shrsimd128
  将每个 lane 向右移动指定的位数，以零为单位。
• u16x8_shufflesimd128
  与 i8x16_shuffle 相同，只是操作起来好像输入是八个 16 位整数，仅需 8 个索引即可重排。
• u16x8_splatsimd128
  创建具有相同 lanes 的 vector。
• u16x8_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位整数一样。
• u16x8_sub_satsimd128
  减去两个 128 位 vectors，就好像它们是两个包装的八个 16 位无符号整数，溢出时饱和到 0.
• u32x4simd128
  从提供的操作数实现 SIMD 值。
• u32x4_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的四个 32 位整数一样。
• u32x4_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• u32x4_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• u32x4_eqsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
• u32x4_extadd_pairwise_u16x8simd128
  整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
• u32x4_extend_high_u16x8simd128
  将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
• u32x4_extend_low_u16x8simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
• u32x4_extmul_high_u16x8simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• u32x4_extmul_low_u16x8simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• u32x4_extract_lanesimd128
  从解释为 4 个包装的 u32 数字的 128 位 vector 中提取一个 lane。
• u32x4_gesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
• u32x4_gtsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
• u32x4_lesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
• u32x4_load_extend_u16x4^⚠simd128
  加载四个 16 位整数，零加载一个整数到 32 位 lane
• u32x4_ltsimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
• u32x4_maxsimd128
  比较 lane-wise 无符号整数，并返回每对的最大值。
• u32x4_minsimd128
  比较 lane-wise 无符号整数，并返回每对中的最小值。
• u32x4_mulsimd128
  将两个 128 位 vectors 相乘，就好像它们是两个包装的四个 32 位有符号整数一样。
• u32x4_nesimd128
  比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
• u32x4_replace_lanesimd128
  从解释为 4 个包装的 u32 数字的 128 位 vector 替换一个 lane。
• u32x4_shlsimd128
  将每个 lane 向左移动指定的位数。
• u32x4_shrsimd128
  将每个 lane 向右移动指定的位数，以零为单位。
• u32x4_shufflesimd128
  与 i8x16_shuffle 相同，但操作时如同输入为 4 32 位整数，仅需 4 个索引即可重排。
• u32x4_splatsimd128
  创建具有相同 lanes 的 vector。
• u32x4_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的四个 32 位整数一样。
• u32x4_trunc_sat_f32x4simd128
  将解释为四个 32 位浮点数的 128 位 vector 转换为四个 32 位无符号整数的 128 位 vector。
• u32x4_trunc_sat_f64x2_zerosimd128
  使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点 lanes 饱和转换为两个较低的整数 lanes。
• u64x2simd128
  从提供的操作数实现 SIMD 值。
• u64x2_addsimd128
  将两个 128 位 vectors 相加，就好像它们是两个包装的两个 64 位整数一样。
• u64x2_all_truesimd128
  如果所有 lanes 都不为零，则返回 true，否则返回 false。
• u64x2_bitmasksimd128
  提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
• u64x2_eqsimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
• u64x2_extend_high_u32x4simd128
  将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
• u64x2_extend_low_u32x4simd128
  将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
• u64x2_extmul_high_u32x4simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• u64x2_extmul_low_u32x4simd128
  lane-wise 整数扩展乘法产生两倍于输入的结果。
• u64x2_extract_lanesimd128
  从解释为 2 个包装的 u64 数字的 128 位 vector 中提取一个 lane。
• u64x2_load_extend_u32x2^⚠simd128
  加载两个 32 位整数，零加载每个整数到 64 位 lane
• u64x2_mulsimd128
  将两个 128 位 vectors 相乘，就好像它们是两个包装的两个 64 位整数一样。
• u64x2_nesimd128
  比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
• u64x2_replace_lanesimd128
  从解释为 2 个包装的 u64 数字的 128 位 vector 替换一个 lane。
• u64x2_shlsimd128
  将每个 lane 向左移动指定的位数。
• u64x2_shrsimd128
  将每个 lane 向右移动指定的位数，以零为单位。
• u64x2_shufflesimd128
  与 i8x16_shuffle 相同，但操作时就像输入是两个 64 位整数，仅需 2 个索引即可重排。
• u64x2_splatsimd128
  创建具有相同 lanes 的 vector。
• u64x2_subsimd128
  将两个 128 位 vectors 相减，就好像它们是两个包装的两个 64 位整数一样。
• unreachable
  生成 unreachable 指令，这会导致无条件的 trap。
• v128_andsimd128
  对两个输入的 128 位 vectors 进行按位和运算，返回结果 vector。
• v128_andnotsimd128
  a 的位按位与与 b 的位进行逻辑逆。
• v128_any_truesimd128
  如果设置了 a 中的任何一位，则返回 true，否则返回 false。
• v128_bitselectsimd128
  使用 c 中的位掩码选择 v1 为 1 和 v2 的位 0.
• v128_load^⚠simd128
  从给定的堆地址加载 v128 vector。
• v128_load8_lane^⚠simd128
  从 m 加载一个 8 位值并将 v 的 lane L 设置为该值。
• v128_load8_splat^⚠simd128
  加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
• v128_load16_lane^⚠simd128
  从 m 加载 16 位值并将 v 的 lane L 设置为该值。
• v128_load16_splat^⚠simd128
  加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
• v128_load32_lane^⚠simd128
  从 m 加载 32 位值并将 v 的 lane L 设置为该值。
• v128_load32_splat^⚠simd128
  加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
• v128_load32_zero^⚠simd128
  将 32 位元素加载到 vector 的低位并将所有其他位设置为零。
• v128_load64_lane^⚠simd128
  从 m 加载 64 位值并将 v 的 lane L 设置为该值。
• v128_load64_splat^⚠simd128
  加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
• v128_load64_zero^⚠simd128
  将 64 位元素加载到 vector 的低位并将所有其他位设置为零。
• v128_notsimd128
  翻转 128 位输入 vector 的每个位。
• v128_orsimd128
  对两个输入的 128 位 vectors 进行按位或逻辑运算，返回结果 vector。
• v128_store^⚠simd128
  将 v128 vector 存储到给定的堆地址。
• v128_store8_lane^⚠simd128
  将来自 v 的 L lane 的 8 位值存储到 m
• v128_store16_lane^⚠simd128
  将 v 的 lane L 的 16 位值存储到 m
• v128_store32_lane^⚠simd128
  将来自 v 的 L lane 的 32 位值存储到 m
• v128_store64_lane^⚠simd128
  将来自 v 的 L lane 的 64 位值存储到 m
• v128_xorsimd128
  对两个输入的 128 位 vectors 进行按位异或，返回结果 vector。