Module core::arch::wasm32

1.33.0 · source ·

Available on WebAssembly only.

Expand description

特定于平台的用于 wasm32 平台的内部函数。

该模块提供特定于 WebAssembly 体系结构的内部函数。在这里，您会发现特定于 WebAssembly 的内部函数，它们不会在 std 的跨平台抽象中以其他方式出现，您还会发现利用 WebAssembly 提案 (如原子性和 simd) 的函数。

wasm32 模块中的内部函数是根据它们所代表的 WebAssembly 指令建模的。大多数函数都以它们想要对应的指令命名，arguments/results 对应指令本身的类型签名。稳定的 WebAssembly 指令是在线文档。

如果一个提案在 WebAssembly 本身中还不稳定，那么这个函数中的函数可能是不稳定的，需要使用 Rust 的夜间通道。由于提案本身具有稳定性，该模块中的内部函数也应该是稳定的。

有关 arch 模块和平台内部函数的一般信息，请参见模块级文档。

Atomics

线程提案 for WebAssembly 添加了许多有关处理多线程程序的指令。atomics 提案中添加的大多数指令都通过 std::sync::atomic 模块在 Rust 中公开。但是，某些指令在 Rust 中没有直接等效项，因此它们在此处公开。

请注意，在原子性提案中添加的指令可以在具有共享 wasm 内存和不具有共享 wasm 内存的上下文中工作。这些内部函数始终在标准库中可用，但除非您使用 -Ctarget-feature=+atomics 重新编译标准库 (和所有代码)，否则您可能无法高效地使用它们。

还值得指出的是，截至撰写本文时，多线程 WebAssembly 及其在 Rust 中的描述仍处于 “早期” 阶段。件基本上可以工作，但它通常需要大量的手动设置。这个时候它不像 “只需调用 std::thread::spawn” 那么简单，但希望有一天它能被实现!

SIMD

WebAssembly 的 simd 提案添加了一个新的 v128 类型，用于 128 位 SIMD 寄存器。它还添加了大量指令以对 v128 类型进行操作以执行数据处理。例如，在 wasm 上使用 SIMD 与在 x86_64 上使用类似。您将编写一个函数，例如：

#[cfg(target_arch = "wasm32")]
#[target_feature(enable = "simd128")]
unsafe fn uses_simd() {
    use std::arch::wasm32::*;
    // ...
}

Run

然而，与 x86_64 不同的是，WebAssembly 目前没有在运行时动态检测是否支持 SIMD (这是条件部分和特性检测提案的动机之一，但这还处于早期阶段)。

这意味着您的二进制文件将具有 SIMD，并且只能在支持 SIMD 的引擎上运行，或者根本不具有 SIMD。为了兼容，标准库本身内部未使用任何 SIMD。确定如何最好地使用 SIMD 发送 WebAssembly 二进制文件在很大程度上取决于您，因为根据您的情况，它可能非常细微。

要在编译时启用 SIMD 支持，您需要执行以下两项操作之一：

首先，您可以使用 #[target_feature(enable = "simd128")] 注解函数。这将导致仅一个函数可以使用 SIMD 支持，并且在这种情况下，内部函数将像往常一样被内联。
其次，您可以使用 -Ctarget-feature=+simd128 编译程序。该编译标志毯可为您的整个编译提供 SIMD 支持。请注意，除非您使用重新编译标准库，否则这不包括标准库。

如果通过这两种途径之一启用 SIMD，那么您将拥有一个使用 SIMD 指令的 WebAssembly 二进制文件，并且需要相应地进行运送。还要注意，如果您调用 SIMD 内部函数但未通过这两种机制之一启用 SIMD，则程序中仍将生成 SIMD。这意味着要生成没有 SIMD 的二进制文件，您将需要避免上述两个选项以及调用此模块中的任何内部函数。

Structs

v128target_family="wasm"
特定于 WASM 的 128 位宽 SIMD vector 类型。

Functions

f32x4_relaxed_maddExperimentaltarget_family="wasm" and relaxed-simd
使用一次舍入或两次舍入计算 a * b + c。
f32x4_relaxed_maxExperimentaltarget_family="wasm" and relaxed-simd
f32x4_max 的宽松版本，即 f32x4_max 或 f32x4_pmax。
f32x4_relaxed_minExperimentaltarget_family="wasm" and relaxed-simd
f32x4_min 的宽松版本，即 f32x4_min 或 f32x4_pmin。
f32x4_relaxed_nmaddExperimentaltarget_family="wasm" and relaxed-simd
使用一次舍入或两次舍入计算 -a * b + c。
f64x2_relaxed_maddExperimentaltarget_family="wasm" and relaxed-simd
使用一次舍入或两次舍入计算 a * b + c。
f64x2_relaxed_maxExperimentaltarget_family="wasm" and relaxed-simd
f64x2_max 的宽松版本，即 f64x2_max 或 f64x2_pmax。
f64x2_relaxed_minExperimentaltarget_family="wasm" and relaxed-simd
f64x2_min 的宽松版本，即 f64x2_min 或 f64x2_pmin。
f64x2_relaxed_nmaddExperimentaltarget_family="wasm" and relaxed-simd
使用一次舍入或两次舍入计算 -a * b + c。
i8x16_relaxed_laneselectExperimentaltarget_family="wasm" and relaxed-simd
v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
i8x16_relaxed_swizzleExperimentaltarget_family="wasm" and relaxed-simd
i8x16_swizzle(a, s) 的轻松版本，它使用 s 中的索引从 a 中选择 lanes。
i16x8_relaxed_dot_i8x16_i7x16Experimentaltarget_family="wasm" and relaxed-simd
轻松的点积指令。
i16x8_relaxed_laneselectExperimentaltarget_family="wasm" and relaxed-simd
v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
i16x8_relaxed_q15mulrExperimentaltarget_family="wasm" and relaxed-simd
i16x8_relaxed_q15mulr 的宽松版本，如果两个 lanes 都是 i16::MIN，则结果是 i16::MIN 或 i16::MAX。
i32x4_relaxed_dot_i8x16_i7x16_addExperimentaltarget_family="wasm" and relaxed-simd
与 i16x8_relaxed_dot_i8x16_i7x16 类似，不同之处在于中间 i16x8 结果被馈送到 i32x4_extadd_pairwise_i16x8，然后 i32x4_add 将值 c 添加到结果中。
i32x4_relaxed_laneselectExperimentaltarget_family="wasm" and relaxed-simd
v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
i32x4_relaxed_trunc_f32x4Experimentaltarget_family="wasm" and relaxed-simd
i32x4_trunc_sat_f32x4(a) 的宽松版本将 a 的 f32 lanes 转换为带符号的 32 位整数。
i32x4_relaxed_trunc_f64x2_zeroExperimentaltarget_family="wasm" and relaxed-simd
i32x4_trunc_sat_f64x2_zero(a) 的宽松版本将 a 的 f64 lanes 转换为带符号的 32 位整数，并且高两个 lanes 为零。
i64x2_relaxed_laneselectExperimentaltarget_family="wasm" and relaxed-simd
v128_bitselect 的宽松版本，其中它的行为与 v128_bitselect 相同或检查每个 lane m 的高位，如果该位为 1，则选择 a 的相应 lane，如果为零，则选择 b 的 lane。
memory_atomic_notify^⚠Experimentaltarget_family="wasm" and atomics
对应 wasm 的 memory.atomic.notify 指令
memory_atomic_wait32^⚠Experimentaltarget_family="wasm" and atomics
对应 wasm 的 memory.atomic.wait32 指令
memory_atomic_wait64^⚠Experimentaltarget_family="wasm" and atomics
对应 wasm 的 memory.atomic.wait64 指令
u32x4_relaxed_trunc_f32x4Experimentaltarget_family="wasm" and relaxed-simd
u32x4_trunc_sat_f32x4(a) 的宽松版本将 a 的 f32 lanes 转换为无符号 32 位整数。
u32x4_relaxed_trunc_f64x2_zeroExperimentaltarget_family="wasm" and relaxed-simd
u32x4_trunc_sat_f64x2_zero(a) 的宽松版本将 a 的 f64 lanes 转换为无符号 32 位整数，并且高两个 lanes 为零。
f32x4target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
f32x4_abstarget_family="wasm" and simd128
计算一个 128 位 vector 的每个 lane 的绝对值，该绝对值解释为四个 32 位浮点数。
f32x4_addtarget_family="wasm" and simd128
Lane 两个 128 位 vectors 的加法被解释为四个 32 位浮点数。
f32x4_ceiltarget_family="wasm" and simd128
按 lane-wise 舍入到不小于输入的最近整数值。
f32x4_convert_i32x4target_family="wasm" and simd128
将解释为四个 32 位有符号整数的 128 位 vector 转换为四个 32 位浮点数的 128 位 vector。
f32x4_convert_u32x4target_family="wasm" and simd128
将解释为四个 32 位无符号整数的 128 位 vector 转换为四个 32 位浮点数的 128 位 vector。
f32x4_demote_f64x2_zerotarget_family="wasm" and simd128
将结果的两个双精度浮点 lanes 转换为两个较低的单精度 lanes。结果的两个较高 lane 被初始化为零。如果转换结果不能表示为单精度浮点数，则将其四舍五入为最接近的偶数可表示数。
f32x4_divtarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 除法解释为四个 32 位浮点数。
f32x4_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_extract_lanetarget_family="wasm" and simd128
从解释为 4 个包装的 f32 数字的 128 位 vector 中提取 lane。
f32x4_floortarget_family="wasm" and simd128
按 lane-wise 舍入到不大于输入的最近整数值。
f32x4_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_maxtarget_family="wasm" and simd128
计算两个 128 位 vectors 的 lane 最小值，解释为四个 32 位浮点数。
f32x4_mintarget_family="wasm" and simd128
计算两个 128 位 vectors 的 lane 最小值，解释为四个 32 位浮点数。
f32x4_multarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 乘法被解释为四个 32 位浮点数。
f32x4_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_nearesttarget_family="wasm" and simd128
按 lane-wise 舍入到最接近的整数值；如果两个值相等，则舍入到偶数。
f32x4_negtarget_family="wasm" and simd128
对解释为四个 32 位浮点数的 128 位向量的每个 lane 求反。
f32x4_pmaxtarget_family="wasm" and simd128
lane-wise 最大值，定义为 a < b ? b : a
f32x4_pmintarget_family="wasm" and simd128
lane-wise 最小值，定义为 b < a ? b : a
f32x4_replace_lanetarget_family="wasm" and simd128
从解释为 4 个包装的 f32 编号的 128 位 vector 替换一个 lane。
f32x4_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
f32x4_sqrttarget_family="wasm" and simd128
计算一个 128 位 vector 的每个 lane 的平方根，该 vector 解释为四个 32 位浮点数。
f32x4_subtarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 减法被解释为四个 32 位浮点数。
f32x4_trunctarget_family="wasm" and simd128
按 lane-wise 舍入到最接近的整数值，幅度不大于输入。
f64x2target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
f64x2_abstarget_family="wasm" and simd128
计算被解释为两个 64 位浮点数的 128 位 vector 的每个 lane 的绝对值。
f64x2_addtarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 方式相加被解释为两个 64 位浮点数。
f64x2_ceiltarget_family="wasm" and simd128
按 lane-wise 舍入到不小于输入的最近整数值。
f64x2_convert_low_i32x4target_family="wasm" and simd128
从整数到浮点的按 lane-wise 转换。
f64x2_convert_low_u32x4target_family="wasm" and simd128
从整数到浮点的按 lane-wise 转换。
f64x2_divtarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 方式除法被解释为两个 64 位浮点数。
f64x2_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_extract_lanetarget_family="wasm" and simd128
从解释为 2 个包装的 f64 编号的 128 位 vector 中提取 lane。
f64x2_floortarget_family="wasm" and simd128
按 lane-wise 舍入到不大于输入的最近整数值。
f64x2_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_maxtarget_family="wasm" and simd128
计算两个 128 位 vectors 的 lane 最大值，解释为两个 64 位浮点数。
f64x2_mintarget_family="wasm" and simd128
计算两个 128 位 vectors 的 lane 最小值，解释为两个 64 位浮点数。
f64x2_multarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 乘法被解释为两个 64 位浮点数。
f64x2_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_nearesttarget_family="wasm" and simd128
按 lane-wise 舍入到最接近的整数值；如果两个值相等，则舍入到偶数。
f64x2_negtarget_family="wasm" and simd128
取反解释为两个 64 位浮点数的 128 位 vector 的每个 lane。
f64x2_pmaxtarget_family="wasm" and simd128
lane-wise 最大值，定义为 a < b ? b : a
f64x2_pmintarget_family="wasm" and simd128
lane-wise 最小值，定义为 b < a ? b : a
f64x2_promote_low_f32x4target_family="wasm" and simd128
将两个较低的单精度浮点 lanes 转换为结果的两个双精度 lanes。
f64x2_replace_lanetarget_family="wasm" and simd128
从一个解释为 2 包装的 f64 编号的 128 位 vector 替换一个 lane。
f64x2_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
f64x2_sqrttarget_family="wasm" and simd128
计算一个 128 位 vector 的每个 lane 的平方根，该 vector 解释为两个 64 位浮点数。
f64x2_subtarget_family="wasm" and simd128
两个 128 位 vectors 的 Lane 减法被解释为两个 64 位浮点数。
f64x2_trunctarget_family="wasm" and simd128
按 lane-wise 舍入到最接近的整数值，幅度不大于输入。
i8x16target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
i8x16_abstarget_family="wasm" and simd128
按 lane-wise 包装绝对值。
i8x16_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位整数一样。
i8x16_add_sattarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位有符号整数一样，在溢出到 i8::MAX 时会饱和。
i8x16_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
i8x16_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
i8x16_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
i8x16_extract_lanetarget_family="wasm" and simd128
从解释为 16 个包装的 i8 数字的 128 位 vector 中提取 lane。
i8x16_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_maxtarget_family="wasm" and simd128
比较 lane-wise 有符号整数，并返回每对的最大值。
i8x16_mintarget_family="wasm" and simd128
比较 lane-wise 有符号整数，并返回每对中的最小值。
i8x16_narrow_i16x8target_family="wasm" and simd128
通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
i8x16_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
i8x16_negtarget_family="wasm" and simd128
对解释为 16 个 8 位有符号整数的 128 位 vectors 求反
i8x16_popcnttarget_family="wasm" and simd128
计算每个 lane 内设置为 1 的位数。
i8x16_replace_lanetarget_family="wasm" and simd128
替换 128 位 vector 中的 lane，该 lane 被解释为 16 个包装的 i8 数字。
i8x16_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
i8x16_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，并扩展符号。
i8x16_shuffletarget_family="wasm" and simd128
返回一个新的 vector，其 lanes 从 16 个 immediate 操作数中指定的两个输入 vectors $a 和 $b 的 lanes 中选择。
i8x16_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
i8x16_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位整数一样。
i8x16_sub_sattarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位有符号整数一样，在溢出到 i8::MIN 时会饱和。
i8x16_swizzletarget_family="wasm" and simd128
返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的 lanes 中选择的 lanes 的新 vector。
i16x8target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
i16x8_abstarget_family="wasm" and simd128
按 lane-wise 包装绝对值。
i16x8_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位整数一样。
i16x8_add_sattarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位有符号整数一样，在溢出到 i16::MAX 时会饱和。
i16x8_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
i16x8_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
i16x8_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
i16x8_extadd_pairwise_i8x16target_family="wasm" and simd128
整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
i16x8_extadd_pairwise_u8x16target_family="wasm" and simd128
整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
i16x8_extend_high_i8x16target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，并对其进行符号扩展。
i16x8_extend_high_u8x16target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
i16x8_extend_low_i8x16target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，并扩展符号。
i16x8_extend_low_u8x16target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
i16x8_extmul_high_i8x16target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i16x8_extmul_high_u8x16target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i16x8_extmul_low_i8x16target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i16x8_extmul_low_u8x16target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i16x8_extract_lanetarget_family="wasm" and simd128
从解释为 8 个包装的 i16 数字的 128 位 vector 中提取 lane。
i16x8_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_load_extend_i8x8^⚠target_family="wasm" and simd128
加载 8 个 8 位整数，并将每个符号扩展到 16 位 lane
i16x8_load_extend_u8x8^⚠target_family="wasm" and simd128
加载 8 个 8 位整数，零加载每个整数至 16 位 lane
i16x8_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_maxtarget_family="wasm" and simd128
比较 lane-wise 有符号整数，并返回每对的最大值。
i16x8_mintarget_family="wasm" and simd128
比较 lane-wise 有符号整数，并返回每对中的最小值。
i16x8_multarget_family="wasm" and simd128
将两个 128 位 vectors 相乘，就好像它们是两个包装的八个 16 位有符号整数一样。
i16x8_narrow_i32x4target_family="wasm" and simd128
通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
i16x8_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
i16x8_negtarget_family="wasm" and simd128
对解释为八个 16 位有符号整数的 128 位 vectors 求反
i16x8_q15mulr_sattarget_family="wasm" and simd128
Q15 格式的 lane-wise 饱和舍入乘法。
i16x8_replace_lanetarget_family="wasm" and simd128
从解释为 8 个包装的 i16 编号的 128 位 vector 替换一个 lane。
i16x8_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
i16x8_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，并扩展符号。
i16x8_shuffletarget_family="wasm" and simd128
与 i8x16_shuffle 相同，只是操作起来好像输入是八个 16 位整数，仅需 8 个索引即可重排。
i16x8_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
i16x8_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位整数一样。
i16x8_sub_sattarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位有符号整数一样，在溢出到 i16::MIN 时会饱和。
i32x4target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
i32x4_abstarget_family="wasm" and simd128
按 lane-wise 包装绝对值。
i32x4_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的四个 32 位整数一样。
i32x4_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
i32x4_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
i32x4_dot_i16x8target_family="wasm" and simd128
在两个输入 vectors 中按 lane-wise 乘以带符号的 16 位整数，并将完整的 32 位结果的相邻对相加。
i32x4_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
i32x4_extadd_pairwise_i16x8target_family="wasm" and simd128
整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
i32x4_extadd_pairwise_u16x8target_family="wasm" and simd128
整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
i32x4_extend_high_i16x8target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，并对其进行符号扩展。
i32x4_extend_high_u16x8target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
i32x4_extend_low_i16x8target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，并扩展符号。
i32x4_extend_low_u16x8target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
i32x4_extmul_high_i16x8target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i32x4_extmul_high_u16x8target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i32x4_extmul_low_i16x8target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i32x4_extmul_low_u16x8target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i32x4_extract_lanetarget_family="wasm" and simd128
从解释为 4 个包装的 i32 数字的 128 位 vector 中提取 lane。
i32x4_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_load_extend_i16x4^⚠target_family="wasm" and simd128
加载四个 16 位整数，并将每个符号扩展到 32 位 lane
i32x4_load_extend_u16x4^⚠target_family="wasm" and simd128
加载四个 16 位整数，零加载一个整数到 32 位 lane
i32x4_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_maxtarget_family="wasm" and simd128
比较 lane-wise 有符号整数，并返回每对的最大值。
i32x4_mintarget_family="wasm" and simd128
比较 lane-wise 有符号整数，并返回每对中的最小值。
i32x4_multarget_family="wasm" and simd128
将两个 128 位 vectors 相乘，就好像它们是两个包装的四个 32 位有符号整数一样。
i32x4_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
i32x4_negtarget_family="wasm" and simd128
对解释为四个 32 位有符号整数的 128 位 vectors 求反
i32x4_replace_lanetarget_family="wasm" and simd128
从解释为 4 个包装的 i32 编号的 128 位 vector 替换一个 lane。
i32x4_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
i32x4_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，并扩展符号。
i32x4_shuffletarget_family="wasm" and simd128
与 i8x16_shuffle 相同，但操作时如同输入为 4 32 位整数，仅需 4 个索引即可重排。
i32x4_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
i32x4_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的四个 32 位整数一样。
i32x4_trunc_sat_f32x4target_family="wasm" and simd128
将解释为四个 32 位浮点数的 128 位 vector 转换为包含四个 32 位带符号整数的 128 位 vector。
i32x4_trunc_sat_f64x2_zerotarget_family="wasm" and simd128
使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点 lanes 饱和转换为两个较低的整数 lanes。
i64x2target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
i64x2_abstarget_family="wasm" and simd128
按 lane-wise 包装绝对值。
i64x2_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的两个 64 位整数一样。
i64x2_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
i64x2_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
i64x2_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
i64x2_extend_high_i32x4target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，并对其进行符号扩展。
i64x2_extend_high_u32x4target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
i64x2_extend_low_i32x4target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，并扩展符号。
i64x2_extend_low_u32x4target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
i64x2_extmul_high_i32x4target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i64x2_extmul_high_u32x4target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i64x2_extmul_low_i32x4target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i64x2_extmul_low_u32x4target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
i64x2_extract_lanetarget_family="wasm" and simd128
从解释为 2 个包装的 i64 编号的 128 位 vector 中提取 lane。
i64x2_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_load_extend_i32x2^⚠target_family="wasm" and simd128
加载两个 32 位整数并将每个符号扩展到 64 位 lane
i64x2_load_extend_u32x2^⚠target_family="wasm" and simd128
加载两个 32 位整数，零加载每个整数到 64 位 lane
i64x2_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_multarget_family="wasm" and simd128
将两个 128 位 vectors 相乘，就好像它们是两个包装的两个 64 位整数一样。
i64x2_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
i64x2_negtarget_family="wasm" and simd128
对解释为两个 64 位有符号整数的 128 位 vectors 求反
i64x2_replace_lanetarget_family="wasm" and simd128
从一个解释为 2 个包装的 i64 编号的 128 位 vector 替换一个 lane。
i64x2_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
i64x2_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，并扩展符号。
i64x2_shuffletarget_family="wasm" and simd128
与 i8x16_shuffle 相同，但操作时就像输入是两个 64 位整数，仅需 2 个索引即可重排。
i64x2_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
i64x2_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的两个 64 位整数一样。
memory_growtarget_family="wasm"
对应 wasm 的 memory.grow 指令
memory_sizetarget_family="wasm"
对应 wasm 的 memory.size 指令
u8x16target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
u8x16_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位整数一样。
u8x16_add_sattarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位无符号整数一样，在溢出到 u8::MAX 时会饱和。
u8x16_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
u8x16_avgrtarget_family="wasm" and simd128
lane-wise 舍入平均值。
u8x16_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
u8x16_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
u8x16_extract_lanetarget_family="wasm" and simd128
从解释为 16 个包装的 u8 数字的 128 位 vector 中提取一个 lane。
u8x16_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_maxtarget_family="wasm" and simd128
比较 lane-wise 无符号整数，并返回每对的最大值。
u8x16_mintarget_family="wasm" and simd128
比较 lane-wise 无符号整数，并返回每对中的最小值。
u8x16_narrow_i16x8target_family="wasm" and simd128
通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
u8x16_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
u8x16_popcnttarget_family="wasm" and simd128
计算每个 lane 内设置为 1 的位数。
u8x16_replace_lanetarget_family="wasm" and simd128
从解释为 16 个包装的 u8 数字的 128 位 vector 替换一个 lane。
u8x16_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
u8x16_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，以零为单位。
u8x16_shuffletarget_family="wasm" and simd128
返回一个新的 vector，其 lanes 从 16 个 immediate 操作数中指定的两个输入 vectors $a 和 $b 的 lanes 中选择。
u8x16_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
u8x16_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位整数一样。
u8x16_sub_sattarget_family="wasm" and simd128
减去两个 128 位 vectors，就好像它们是两个包装的 16 个 8 位无符号整数，溢出时饱和到 0.
u8x16_swizzletarget_family="wasm" and simd128
返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的 lanes 中选择的 lanes 的新 vector。
u16x8target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
u16x8_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位整数一样。
u16x8_add_sattarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位无符号整数一样，在溢出到 u16::MAX 时会饱和。
u16x8_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
u16x8_avgrtarget_family="wasm" and simd128
lane-wise 舍入平均值。
u16x8_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
u16x8_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
u16x8_extadd_pairwise_u8x16target_family="wasm" and simd128
整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
u16x8_extend_high_u8x16target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
u16x8_extend_low_u8x16target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
u16x8_extmul_high_u8x16target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
u16x8_extmul_low_u8x16target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
u16x8_extract_lanetarget_family="wasm" and simd128
从解释为 8 个包装的 u16 数字的 128 位 vector 中提取一个 lane。
u16x8_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_load_extend_u8x8^⚠target_family="wasm" and simd128
加载 8 个 8 位整数，零加载每个整数至 16 位 lane
u16x8_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_maxtarget_family="wasm" and simd128
比较 lane-wise 无符号整数，并返回每对的最大值。
u16x8_mintarget_family="wasm" and simd128
比较 lane-wise 无符号整数，并返回每对中的最小值。
u16x8_multarget_family="wasm" and simd128
将两个 128 位 vectors 相乘，就好像它们是两个包装的八个 16 位有符号整数一样。
u16x8_narrow_i32x4target_family="wasm" and simd128
通过使每个 lane 变窄，将两个输入 vectors 转换为较小的 lane vector。
u16x8_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
u16x8_replace_lanetarget_family="wasm" and simd128
从解释为 8 个包装的 u16 数字的 128 位 vector 替换一个 lane。
u16x8_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
u16x8_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，以零为单位。
u16x8_shuffletarget_family="wasm" and simd128
与 i8x16_shuffle 相同，只是操作起来好像输入是八个 16 位整数，仅需 8 个索引即可重排。
u16x8_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
u16x8_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位整数一样。
u16x8_sub_sattarget_family="wasm" and simd128
减去两个 128 位 vectors，就好像它们是两个包装的八个 16 位无符号整数，溢出时饱和到 0.
u32x4target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
u32x4_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的四个 32 位整数一样。
u32x4_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
u32x4_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
u32x4_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
u32x4_extadd_pairwise_u16x8target_family="wasm" and simd128
整数扩展成对加法产生扩展结果 (比输入宽两倍的结果)。
u32x4_extend_high_u16x8target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
u32x4_extend_low_u16x8target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
u32x4_extmul_high_u16x8target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
u32x4_extmul_low_u16x8target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
u32x4_extract_lanetarget_family="wasm" and simd128
从解释为 4 个包装的 u32 数字的 128 位 vector 中提取一个 lane。
u32x4_getarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_gttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_letarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_load_extend_u16x4^⚠target_family="wasm" and simd128
加载四个 16 位整数，零加载一个整数到 32 位 lane
u32x4_lttarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_maxtarget_family="wasm" and simd128
比较 lane-wise 无符号整数，并返回每对的最大值。
u32x4_mintarget_family="wasm" and simd128
比较 lane-wise 无符号整数，并返回每对中的最小值。
u32x4_multarget_family="wasm" and simd128
将两个 128 位 vectors 相乘，就好像它们是两个包装的四个 32 位有符号整数一样。
u32x4_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
u32x4_replace_lanetarget_family="wasm" and simd128
从解释为 4 个包装的 u32 数字的 128 位 vector 替换一个 lane。
u32x4_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
u32x4_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，以零为单位。
u32x4_shuffletarget_family="wasm" and simd128
与 i8x16_shuffle 相同，但操作时如同输入为 4 32 位整数，仅需 4 个索引即可重排。
u32x4_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
u32x4_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的四个 32 位整数一样。
u32x4_trunc_sat_f32x4target_family="wasm" and simd128
将解释为四个 32 位浮点数的 128 位 vector 转换为四个 32 位无符号整数的 128 位 vector。
u32x4_trunc_sat_f64x2_zerotarget_family="wasm" and simd128
使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点 lanes 饱和转换为两个较低的整数 lanes。
u64x2target_family="wasm" and simd128
从提供的操作数实现 SIMD 值。
u64x2_addtarget_family="wasm" and simd128
将两个 128 位 vectors 相加，就好像它们是两个包装的两个 64 位整数一样。
u64x2_all_truetarget_family="wasm" and simd128
如果所有 lanes 都不为零，则返回 true，否则返回 false。
u64x2_bitmasktarget_family="wasm" and simd128
提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。
u64x2_eqtarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
u64x2_extend_high_u32x4target_family="wasm" and simd128
将较小 lane vector 的高一半转换为较大 lane vector，扩展为零。
u64x2_extend_low_u32x4target_family="wasm" and simd128
将较小 lane vector 的下半部分转换为较大 lane vector，扩展为零。
u64x2_extmul_high_u32x4target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
u64x2_extmul_low_u32x4target_family="wasm" and simd128
lane-wise 整数扩展乘法产生两倍于输入的结果。
u64x2_extract_lanetarget_family="wasm" and simd128
从解释为 2 个包装的 u64 数字的 128 位 vector 中提取一个 lane。
u64x2_load_extend_u32x2^⚠target_family="wasm" and simd128
加载两个 32 位整数，零加载每个整数到 64 位 lane
u64x2_multarget_family="wasm" and simd128
将两个 128 位 vectors 相乘，就好像它们是两个包装的两个 64 位整数一样。
u64x2_netarget_family="wasm" and simd128
比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
u64x2_replace_lanetarget_family="wasm" and simd128
从解释为 2 个包装的 u64 数字的 128 位 vector 替换一个 lane。
u64x2_shltarget_family="wasm" and simd128
将每个 lane 向左移动指定的位数。
u64x2_shrtarget_family="wasm" and simd128
将每个 lane 向右移动指定的位数，以零为单位。
u64x2_shuffletarget_family="wasm" and simd128
与 i8x16_shuffle 相同，但操作时就像输入是两个 64 位整数，仅需 2 个索引即可重排。
u64x2_splattarget_family="wasm" and simd128
创建具有相同 lanes 的 vector。
u64x2_subtarget_family="wasm" and simd128
将两个 128 位 vectors 相减，就好像它们是两个包装的两个 64 位整数一样。
unreachabletarget_family="wasm"
生成 unreachable 指令，这会导致无条件的 trap。
v128_andtarget_family="wasm" and simd128
对两个输入的 128 位 vectors 进行按位和运算，返回结果 vector。
v128_andnottarget_family="wasm" and simd128
a 的位按位与与 b 的位进行逻辑逆。
v128_any_truetarget_family="wasm" and simd128
如果设置了 a 中的任何一位，则返回 true，否则返回 false。
v128_bitselecttarget_family="wasm" and simd128
使用 c 中的位掩码选择 v1 为 1 和 v2 的位 0.
v128_load^⚠target_family="wasm" and simd128
从给定的堆地址加载 v128 vector。
v128_load8_lane^⚠target_family="wasm" and simd128
从 m 加载一个 8 位值并将 v 的 lane L 设置为该值。
v128_load8_splat^⚠target_family="wasm" and simd128
加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
v128_load16_lane^⚠target_family="wasm" and simd128
从 m 加载 16 位值并将 v 的 lane L 设置为该值。
v128_load16_splat^⚠target_family="wasm" and simd128
加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
v128_load32_lane^⚠target_family="wasm" and simd128
从 m 加载 32 位值并将 v 的 lane L 设置为该值。
v128_load32_splat^⚠target_family="wasm" and simd128
加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
v128_load32_zero^⚠target_family="wasm" and simd128
将 32 位元素加载到 vector 的低位并将所有其他位设置为零。
v128_load64_lane^⚠target_family="wasm" and simd128
从 m 加载 64 位值并将 v 的 lane L 设置为该值。
v128_load64_splat^⚠target_family="wasm" and simd128
加载单个元素，然后将其放置到 v128 vector 的所有 lane 中。
v128_load64_zero^⚠target_family="wasm" and simd128
将 64 位元素加载到 vector 的低位并将所有其他位设置为零。
v128_nottarget_family="wasm" and simd128
翻转 128 位输入 vector 的每个位。
v128_ortarget_family="wasm" and simd128
对两个输入的 128 位 vectors 进行按位或逻辑运算，返回结果 vector。
v128_store^⚠target_family="wasm" and simd128
将 v128 vector 存储到给定的堆地址。
v128_store8_lane^⚠target_family="wasm" and simd128
将来自 v 的 L lane 的 8 位值存储到 m
v128_store16_lane^⚠target_family="wasm" and simd128
将 v 的 lane L 的 16 位值存储到 m
v128_store32_lane^⚠target_family="wasm" and simd128
将来自 v 的 L lane 的 32 位值存储到 m
v128_store64_lane^⚠target_family="wasm" and simd128
将来自 v 的 L lane 的 64 位值存储到 m
v128_xortarget_family="wasm" and simd128
对两个输入的 128 位 vectors 进行按位异或，返回结果 vector。