Module core::arch::wasm32

This is supported on WebAssembly only.

wasm32 平台的平台特定的内联函数。

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

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

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

有关 arch 模块和平台内联函数的一般信息，请参见 module documentation。

Atomics

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

请注意，在 atomics 提案中添加的指令可以在具有共享 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::*;
    // ...
}

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

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

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

• 首先，您可以使用 #[target_feature(enable = "simd128")] 注解函数。这将导致仅一个函数可以使用 SIMD 支持，并且在这种情况下，内联函数将像往常一样被内联。

• 其次，您可以使用 -Ctarget-feature=+simd128 编译程序。 该编译标志毯可为您的整个编译提供 SIMD 支持。请注意，除非您使用 recompile the standard library，否则这不包括标准库。

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

Structs

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

Functions

memory_atomic_notify⚠	Experimentalatomics 对应 wasm 的 memory.atomic.notify 指令
memory_atomic_wait32⚠	Experimentalatomics 对应 wasm 的 memory.atomic.wait32 指令
memory_atomic_wait64⚠	Experimentalatomics 对应 wasm 的 memory.atomic.wait64 指令
f32x4	simd128 从提供的操作数实现 SIMD 值。
f32x4_abs	simd128 计算一个 128 位 vector 的每个通道的绝对值，该绝对值解释为四个 32 位浮点数。
f32x4_add	simd128 将两个 128 位 vectors 的成对通道相加，将其解释为四个 32 位浮点数。
f32x4_ceil	simd128 按通道舍入到不小于输入的最近整数值。
f32x4_convert_i32x4	simd128 将解释为四个 32 位有符号整数的 128 位 vector 转换为 四个 32 位浮点数的 128 位 vector。
f32x4_convert_u32x4	simd128 将解释为四个 32 位无符号整数的 128 位 vector 转换为 四个 32 位浮点数的 128 位 vector。
f32x4_demote_f64x2_zero	simd128 将结果的两个双精度浮点通道转换为两个较低的单精度通道。 结果的两个较高通道被初始化为零。 如果转换结果不能表示为单精度浮点数，则将其四舍五入为最接近的偶数可表示数。
f32x4_div	simd128 将两个 128 位 vectors 的成对通道划分为四个 32 位浮点数。
f32x4_eq	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_extract_lane	simd128 从解释为 4 个包装的 f32 数字的 128 位 vector 中提取通道。
f32x4_floor	simd128 按通道舍入到不大于输入的最近整数值。
f32x4_ge	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_gt	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_le	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_lt	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_max	simd128 计算两个解释为四个 32 位浮点数的 128 位 vectors 的成对通道的最大值。
f32x4_min	simd128 计算两个解释为四个 32 位浮点数的 128 位 vectors 的成对通道的最小值。
f32x4_mul	simd128 将两个 128 位 vectors 的成对通道相乘，将其解释为四个 32 位浮点数。
f32x4_ne	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位浮点数的两个 vectors 一样。
f32x4_nearest	simd128 按通道舍入到最接近的整数值; 如果两个值相等，则舍入到偶数。
f32x4_neg	simd128 对解释为四个 32 位浮点数的 128 位向量的每个通道求反。
f32x4_pmax	simd128 通道最大值，定义为 a < b ? b : a
f32x4_pmin	simd128 通道最小值，定义为 b < a ? b : a
f32x4_replace_lane	simd128 从解释为 4 个包装的 f32 编号的 128 位 vector 替换一个通道。
f32x4_splat	simd128 创建具有相同通道的 vector。
f32x4_sqrt	simd128 计算一个 128 位 vector 的每个通道的平方根，该 vector 解释为四个 32 位浮点数。
f32x4_sub	simd128 减去两个 128 位 vectors 的成对通道，它们被解释为四个 32 位浮点数。
f32x4_trunc	simd128 按通道舍入到最接近的整数值，幅度不大于输入。
f64x2	simd128 从提供的操作数实现 SIMD 值。
f64x2_abs	simd128 计算被解释为两个 64 位浮点数的 128 位 vector 的每个通道的绝对值。
f64x2_add	simd128 将两个 128 位 vectors 的成对通道相加，将其解释为两个 64 位浮点数。
f64x2_ceil	simd128 按通道舍入到不小于输入的最近整数值。
f64x2_convert_low_i32x4	simd128 从整数到浮点的逐行转换。
f64x2_convert_low_u32x4	simd128 从整数到浮点的逐行转换。
f64x2_div	simd128 将两个 128 位 vectors 的成对通道划分为两个 64 位浮点数。
f64x2_eq	simd128 比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_extract_lane	simd128 从解释为 2 个包装的 f64 编号的 128 位 vector 中提取通道。
f64x2_floor	simd128 按通道舍入到不大于输入的最近整数值。
f64x2_ge	simd128 比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_gt	simd128 比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_le	simd128 比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_lt	simd128 比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_max	simd128 计算两个解释为两个 64 位浮点数的 128 位 vectors 的成对通道的最大值。
f64x2_min	simd128 计算两个解释为两个 64 位浮点数的 128 位 vectors 的成对通道的最小值。
f64x2_mul	simd128 将两个解释为两个 64 位浮点数的 128 位 vectors 的成对通道相乘。
f64x2_ne	simd128 比较两个 128 位 vectors，就好像它们是 2 个 64 位浮点数的两个 vectors 一样。
f64x2_nearest	simd128 按通道舍入到最接近的整数值; 如果两个值相等，则舍入到偶数。
f64x2_neg	simd128 取反解释为两个 64 位浮点数的 128 位 vector 的每个通道。
f64x2_pmax	simd128 通道最大值，定义为 a < b ? b : a
f64x2_pmin	simd128 通道最小值，定义为 b < a ? b : a
f64x2_promote_low_f32x4	simd128 将两个较低的单精度浮点通道转换为结果的两个双精度通道。
f64x2_replace_lane	simd128 从一个解释为 2 包装的 f64 编号的 128 位 vector 替换一个通道。
f64x2_splat	simd128 创建具有相同通道的 vector。
f64x2_sqrt	simd128 计算一个 128 位 vector 的每个通道的平方根，该 vector 解释为两个 64 位浮点数。
f64x2_sub	simd128 减去两个 128 位 vectors 的成对通道，它们被解释为两个 64 位浮点数。
f64x2_trunc	simd128 按通道舍入到最接近的整数值，幅度不大于输入。
i8x16	simd128 从提供的操作数实现 SIMD 值。
i8x16_abs	simd128 逐行包装绝对值。
i8x16_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位整数一样。
i8x16_add_sat	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位有符号整数一样，在溢出到 i8::MAX 时会饱和。
i8x16_all_true	simd128 如果所有通道都不为零，则返回 true，如果任何通道不为零，则返回 false。
i8x16_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
i8x16_eq	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
i8x16_extract_lane	simd128 从解释为 16 个包装的 i8 数字的 128 位 vector 中提取通道。
i8x16_ge	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_gt	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_le	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_lt	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位有符号整数的两个 vectors 一样。
i8x16_max	simd128 比较通道有符号整数，并返回每对的最大值。
i8x16_min	simd128 比较通道有符号整数，并返回每对中的最小值。
i8x16_narrow_i16x8	simd128 通过使每个通道变窄，将两个输入 vectors 转换为较小的通道 vector。
i8x16_ne	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
i8x16_neg	simd128 取反一个 16 位 8 位带符号整数的 128 位 vectors
i8x16_popcnt	simd128 计算每个通道内设置为 1 的位数。
i8x16_replace_lane	simd128 替换 128 位 vector 中的通道，该通道被解释为 16 个包装的 i8 数字。
i8x16_shl	simd128 将每个通道向左移动指定的位数。
i8x16_shr	simd128 将每个通道向右移动指定的位数，并扩展符号。
i8x16_shuffle	simd128 返回一个新的 vector，其通道从 16 个 immediate 操作数中指定的两个输入 vectors $a 和 $b 的通道中选择。
i8x16_splat	simd128 创建具有相同通道的 vector。
i8x16_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位整数一样。
i8x16_sub_sat	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位有符号整数一样，在溢出到 i8::MIN 时会饱和。
i8x16_swizzle	simd128 返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的通道中选择的通道的新 vector。
i16x8	simd128 从提供的操作数实现 SIMD 值。
i16x8_abs	simd128 逐行包装绝对值。
i16x8_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位整数一样。
i16x8_add_sat	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位有符号整数一样，在溢出到 i16::MAX 时会饱和。
i16x8_all_true	simd128 如果所有通道都不为零，则返回 1; 如果任何通道都不为零，则返回 0。
i16x8_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
i16x8_eq	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
i16x8_extadd_pairwise_i8x16	simd128 逐行整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。
i16x8_extadd_pairwise_u8x16	simd128 逐行整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。
i16x8_extend_high_i8x16	simd128 将较小通道 vector 的高一半转换为较大通道 vector，并对其进行符号扩展。
i16x8_extend_high_u8x16	simd128 将较小通道 vector 的高一半转换为较大通道 vector，扩展为零。
i16x8_extend_low_i8x16	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，并扩展符号。
i16x8_extend_low_u8x16	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，扩展为零。
i16x8_extmul_high_i8x16	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i16x8_extmul_high_u8x16	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i16x8_extmul_low_i8x16	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i16x8_extmul_low_u8x16	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i16x8_extract_lane	simd128 从解释为 8 个包装的 i16 数字的 128 位 vector 中提取通道。
i16x8_ge	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_gt	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_le	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_load_extend_i8x8⚠	simd128 加载 8 个 8 位整数，并将每个符号扩展到 16 位通道
i16x8_load_extend_u8x8⚠	simd128 加载 8 个 8 位整数，零加载每个整数至 16 位通道
i16x8_lt	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。
i16x8_max	simd128 比较通道有符号整数，并返回每对的最大值。
i16x8_min	simd128 比较通道有符号整数，并返回每对中的最小值。
i16x8_mul	simd128 将两个 128 位 vectors 相乘，就好像它们是两个包装的八个 16 位有符号整数一样。
i16x8_narrow_i32x4	simd128 通过使每个通道变窄，将两个输入 vectors 转换为较小的通道 vector。
i16x8_ne	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
i16x8_neg	simd128 取反一个 8 位 16 位带符号整数的 128 位 vectors
i16x8_q15mulr_sat	simd128 Q15 格式的通道饱和舍入乘法。
i16x8_replace_lane	simd128 从解释为 8 个包装的 i16 编号的 128 位 vector 替换一个通道。
i16x8_shl	simd128 将每个通道向左移动指定的位数。
i16x8_shr	simd128 将每个通道向右移动指定的位数，并扩展符号。
i16x8_shuffle	simd128 与 i8x16_shuffle 相同，只是操作起来好像输入是八个 16 位整数，仅需 8 个索引即可重排。
i16x8_splat	simd128 创建具有相同通道的 vector。
i16x8_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位整数一样。
i16x8_sub_sat	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位有符号整数一样，在溢出到 i16::MIN 时会饱和。
i32x4	simd128 从提供的操作数实现 SIMD 值。
i32x4_abs	simd128 逐行包装绝对值。
i32x4_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的四个 32 位整数一样。
i32x4_all_true	simd128 如果所有通道都不为零，则返回 1; 如果任何通道都不为零，则返回 0。
i32x4_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
i32x4_dot_i16x8	simd128 在两个输入 vectors 中逐行乘以带符号的 16 位整数，并将完整的 32 位结果的相邻对相加。
i32x4_eq	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
i32x4_extadd_pairwise_i16x8	simd128 逐行整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。
i32x4_extadd_pairwise_u16x8	simd128 逐行整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。
i32x4_extend_high_i16x8	simd128 将较小通道 vector 的高一半转换为较大通道 vector，并对其进行符号扩展。
i32x4_extend_high_u16x8	simd128 将较小通道 vector 的高一半转换为较大通道 vector，扩展为零。
i32x4_extend_low_i16x8	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，并扩展符号。
i32x4_extend_low_u16x8	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，扩展为零。
i32x4_extmul_high_i16x8	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i32x4_extmul_high_u16x8	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i32x4_extmul_low_i16x8	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i32x4_extmul_low_u16x8	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i32x4_extract_lane	simd128 从解释为 4 个包装的 i32 数字的 128 位 vector 中提取通道。
i32x4_ge	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_gt	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_le	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_load_extend_i16x4⚠	simd128 加载四个 16 位整数，并将每个符号扩展到 32 位通道
i32x4_load_extend_u16x4⚠	simd128 加载四个 16 位整数，零加载一个整数到 32 位通道
i32x4_lt	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位有符号整数的两个 vectors 一样。
i32x4_max	simd128 比较通道有符号整数，并返回每对的最大值。
i32x4_min	simd128 比较通道有符号整数，并返回每对中的最小值。
i32x4_mul	simd128 将两个 128 位 vectors 相乘，就好像它们是两个包装的四个 32 位有符号整数一样。
i32x4_ne	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
i32x4_neg	simd128 取反一个 128 位 vectors，该 vectors 解释为四个 32 位带符号整数
i32x4_replace_lane	simd128 从解释为 4 个包装的 i32 编号的 128 位 vector 替换一个通道。
i32x4_shl	simd128 将每个通道向左移动指定的位数。
i32x4_shr	simd128 将每个通道向右移动指定的位数，并扩展符号。
i32x4_shuffle	simd128 与 i8x16_shuffle 相同，但操作时如同输入为 4 32 位整数，仅需 4 个索引即可重排。
i32x4_splat	simd128 创建具有相同通道的 vector。
i32x4_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的四个 32 位整数一样。
i32x4_trunc_sat_f32x4	simd128 将解释为四个 32 位浮点数的 128 位 vector 转换为包含四个 32 位带符号整数的 128 位 vector。
i32x4_trunc_sat_f64x2_zero	simd128 使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点通道饱和转换为两个较低的整数通道。
i64x2	simd128 从提供的操作数实现 SIMD 值。
i64x2_abs	simd128 逐行包装绝对值。
i64x2_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的两个 64 位整数一样。
i64x2_all_true	simd128 如果所有通道都不为零，则返回 1; 如果任何通道都不为零，则返回 0。
i64x2_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
i64x2_eq	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
i64x2_extend_high_i32x4	simd128 将较小通道 vector 的高一半转换为较大通道 vector，并对其进行符号扩展。
i64x2_extend_high_u32x4	simd128 将较小通道 vector 的高一半转换为较大通道 vector，扩展为零。
i64x2_extend_low_i32x4	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，并扩展符号。
i64x2_extend_low_u32x4	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，扩展为零。
i64x2_extmul_high_i32x4	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i64x2_extmul_high_u32x4	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i64x2_extmul_low_i32x4	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i64x2_extmul_low_u32x4	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
i64x2_extract_lane	simd128 从解释为 2 个包装的 i64 编号的 128 位 vector 中提取通道。
i64x2_ge	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_gt	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_le	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_load_extend_i32x2⚠	simd128 加载两个 32 位整数并将每个符号扩展到 64 位通道
i64x2_load_extend_u32x2⚠	simd128 加载两个 32 位整数，零加载每个整数到 64 位通道
i64x2_lt	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位有符号整数的两个 vectors。
i64x2_mul	simd128 将两个 128 位 vectors 相乘，就好像它们是两个包装的两个 64 位整数一样。
i64x2_ne	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
i64x2_neg	simd128 取反被解释为两个 64 位有符号整数的 128 位 vectors
i64x2_replace_lane	simd128 从一个解释为 2 个包装的 i64 编号的 128 位 vector 替换一个通道。
i64x2_shl	simd128 将每个通道向左移动指定的位数。
i64x2_shr	simd128 将每个通道向右移动指定的位数，并扩展符号。
i64x2_shuffle	simd128 与 i8x16_shuffle 相同，但操作时就像输入是两个 64 位整数，仅需 2 个索引即可重排。
i64x2_splat	simd128 创建具有相同通道的 vector。
i64x2_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的两个 64 位整数一样。
memory_grow	对应 wasm 的 memory.grow 指令
memory_size	对应 wasm 的 memory.size 指令
u8x16	simd128 从提供的操作数实现 SIMD 值。
u8x16_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位整数一样。
u8x16_add_sat	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的 16 个 8 位无符号整数一样，在溢出到 u8::MAX 时会饱和。
u8x16_all_true	simd128 如果所有通道都不为零，则返回 true，如果任何通道不为零，则返回 false。
u8x16_avgr	simd128 逐行舍入平均值。
u8x16_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
u8x16_eq	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
u8x16_extract_lane	simd128 从解释为 16 个包装的 u8 数字的 128 位 vector 中提取一个通道。
u8x16_ge	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_gt	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_le	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_lt	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位无符号整数的两个 vectors 一样。
u8x16_max	simd128 比较通道无符号整数，并返回每对的最大值。
u8x16_min	simd128 比较通道无符号整数，并返回每对中的最小值。
u8x16_narrow_i16x8	simd128 通过使每个通道变窄，将两个输入 vectors 转换为较小的通道 vector。
u8x16_ne	simd128 比较两个 128 位 vectors，就好像它们是 16 个 8 位整数的两个 vectors 一样。
u8x16_popcnt	simd128 计算每个通道内设置为 1 的位数。
u8x16_replace_lane	simd128 从解释为 16 个包装的 u8 数字的 128 位 vector 替换一个通道。
u8x16_shl	simd128 将每个通道向左移动指定的位数。
u8x16_shr	simd128 将每个通道向右移动指定的位数，以零为单位。
u8x16_shuffle	simd128 返回一个新的 vector，其通道从 16 个 immediate 操作数中指定的两个输入 vectors $a 和 $b 的通道中选择。
u8x16_splat	simd128 创建具有相同通道的 vector。
u8x16_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位整数一样。
u8x16_sub_sat	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的 16 个 8 位无符号整数一样，溢出时饱和为 0。
u8x16_swizzle	simd128 返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的通道中选择的通道的新 vector。
u16x8	simd128 从提供的操作数实现 SIMD 值。
u16x8_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位整数一样。
u16x8_add_sat	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的八个 16 位无符号整数一样，在溢出到 u16::MAX 时会饱和。
u16x8_all_true	simd128 如果所有通道都不为零，则返回 1; 如果任何通道都不为零，则返回 0。
u16x8_avgr	simd128 逐行舍入平均值。
u16x8_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
u16x8_eq	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
u16x8_extadd_pairwise_u8x16	simd128 逐行整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。
u16x8_extend_high_u8x16	simd128 将较小通道 vector 的高一半转换为较大通道 vector，扩展为零。
u16x8_extend_low_u8x16	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，扩展为零。
u16x8_extmul_high_u8x16	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
u16x8_extmul_low_u8x16	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
u16x8_extract_lane	simd128 从解释为 8 个包装的 u16 数字的 128 位 vector 中提取一个通道。
u16x8_ge	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_gt	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_le	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_load_extend_u8x8⚠	simd128 加载 8 个 8 位整数，零加载每个整数至 16 位通道
u16x8_lt	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。
u16x8_max	simd128 比较通道无符号整数，并返回每对的最大值。
u16x8_min	simd128 比较通道无符号整数，并返回每对中的最小值。
u16x8_mul	simd128 将两个 128 位 vectors 相乘，就好像它们是两个包装的八个 16 位有符号整数一样。
u16x8_narrow_i32x4	simd128 通过使每个通道变窄，将两个输入 vectors 转换为较小的通道 vector。
u16x8_ne	simd128 比较两个 128 位 vectors，就好像它们是 8 个 16 位整数的两个 vectors 一样。
u16x8_replace_lane	simd128 从解释为 8 个包装的 u16 数字的 128 位 vector 替换一个通道。
u16x8_shl	simd128 将每个通道向左移动指定的位数。
u16x8_shr	simd128 将每个通道向右移动指定的位数，以零为单位。
u16x8_shuffle	simd128 与 i8x16_shuffle 相同，只是操作起来好像输入是八个 16 位整数，仅需 8 个索引即可重排。
u16x8_splat	simd128 创建具有相同通道的 vector。
u16x8_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位整数一样。
u16x8_sub_sat	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的八个 16 位无符号整数一样，溢出时饱和为 0。
u32x4	simd128 从提供的操作数实现 SIMD 值。
u32x4_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的四个 32 位整数一样。
u32x4_all_true	simd128 如果所有通道都不为零，则返回 1; 如果任何通道都不为零，则返回 0。
u32x4_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
u32x4_eq	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
u32x4_extadd_pairwise_u16x8	simd128 逐行整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。
u32x4_extend_high_u16x8	simd128 将较小通道 vector 的高一半转换为较大通道 vector，扩展为零。
u32x4_extend_low_u16x8	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，扩展为零。
u32x4_extmul_high_u16x8	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
u32x4_extmul_low_u16x8	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
u32x4_extract_lane	simd128 从解释为 4 个包装的 u32 数字的 128 位 vector 中提取一个通道。
u32x4_ge	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_gt	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_le	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_load_extend_u16x4⚠	simd128 加载四个 16 位整数，零加载一个整数到 32 位通道
u32x4_lt	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位无符号整数的两个 vectors 一样。
u32x4_max	simd128 比较通道无符号整数，并返回每对的最大值。
u32x4_min	simd128 比较通道无符号整数，并返回每对中的最小值。
u32x4_mul	simd128 将两个 128 位 vectors 相乘，就好像它们是两个包装的四个 32 位有符号整数一样。
u32x4_ne	simd128 比较两个 128 位 vectors，就好像它们是 4 个 32 位整数的两个 vectors 一样。
u32x4_replace_lane	simd128 从解释为 4 个包装的 u32 数字的 128 位 vector 替换一个通道。
u32x4_shl	simd128 将每个通道向左移动指定的位数。
u32x4_shr	simd128 将每个通道向右移动指定的位数，以零为单位。
u32x4_shuffle	simd128 与 i8x16_shuffle 相同，但操作时如同输入为 4 32 位整数，仅需 4 个索引即可重排。
u32x4_splat	simd128 创建具有相同通道的 vector。
u32x4_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的四个 32 位整数一样。
u32x4_trunc_sat_f32x4	simd128 将解释为四个 32 位浮点数的 128 位 vector 转换为四个 32 位无符号整数的 128 位 vector。
u32x4_trunc_sat_f64x2_zero	simd128 使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点通道饱和转换为两个较低的整数通道。
u64x2	simd128 从提供的操作数实现 SIMD 值。
u64x2_add	simd128 将两个 128 位 vectors 相加，就好像它们是两个包装的两个 64 位整数一样。
u64x2_all_true	simd128 如果所有通道都不为零，则返回 1; 如果任何通道都不为零，则返回 0。
u64x2_bitmask	simd128 提取 a 中每个通道的高位并生成一个所有位连接的标量掩码。
u64x2_eq	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
u64x2_extend_high_u32x4	simd128 将较小通道 vector 的高一半转换为较大通道 vector，扩展为零。
u64x2_extend_low_u32x4	simd128 将较小通道 vector 的下半部分转换为较大通道 vector，扩展为零。
u64x2_extmul_high_u32x4	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
u64x2_extmul_low_u32x4	simd128 逐行整数扩展乘法产生比输入宽两倍的结果。
u64x2_extract_lane	simd128 从解释为 2 个包装的 u64 数字的 128 位 vector 中提取一个通道。
u64x2_load_extend_u32x2⚠	simd128 加载两个 32 位整数，零加载每个整数到 64 位通道
u64x2_mul	simd128 将两个 128 位 vectors 相乘，就好像它们是两个包装的两个 64 位整数一样。
u64x2_ne	simd128 比较两个 128 位 vectors，就好像它们是两个 64 位整数的两个 vectors。
u64x2_replace_lane	simd128 从解释为 2 个包装的 u64 数字的 128 位 vector 替换一个通道。
u64x2_shl	simd128 将每个通道向左移动指定的位数。
u64x2_shr	simd128 将每个通道向右移动指定的位数，以零为单位。
u64x2_shuffle	simd128 与 i8x16_shuffle 相同，但操作时就像输入是两个 64 位整数，仅需 2 个索引即可重排。
u64x2_splat	simd128 创建具有相同通道的 vector。
u64x2_sub	simd128 将两个 128 位 vectors 相减，就好像它们是两个包装的两个 64 位整数一样。
unreachable⚠	生成陷阱指令 UNREACHABLE
v128_and	simd128 对两个输入的 128 位 vectors 进行按位和运算，返回结果 vector。
v128_andnot	simd128 a 的位按位与与 b 的位进行逻辑逆。
v128_any_true	simd128 如果设置了 a 中的任何一位，则返回 true，否则返回 false。
v128_bitselect	simd128 使用 c 中的位掩码在 1 时从 v1 中选择位，在 0 时从 v2 中选择位。
v128_load⚠	simd128 从给定的堆地址加载 v128 vector。
v128_load8_lane⚠	simd128 从 m 加载一个 8 位值并将 v 的通道 L 设置为该值。
v128_load8_splat⚠	simd128 加载单个元素，然后将其放置到 v128 vector 的所有通道中。
v128_load16_lane⚠	simd128 从 m 加载 16 位值并将 v 的通道 L 设置为该值。
v128_load16_splat⚠	simd128 加载单个元素，然后将其放置到 v128 vector 的所有通道中。
v128_load32_lane⚠	simd128 从 m 加载 32 位值并将 v 的通道 L 设置为该值。
v128_load32_splat⚠	simd128 加载单个元素，然后将其放置到 v128 vector 的所有通道中。
v128_load32_zero⚠	simd128 将 32 位元素加载到 vector 的低位并将所有其他位设置为零。
v128_load64_lane⚠	simd128 从 m 加载 64 位值并将 v 的通道 L 设置为该值。
v128_load64_splat⚠	simd128 加载单个元素，然后将其放置到 v128 vector 的所有通道中。
v128_load64_zero⚠	simd128 将 64 位元素加载到 vector 的低位并将所有其他位设置为零。
v128_not	simd128 翻转 128 位输入 vector 的每个位。
v128_or	simd128 对两个输入的 128 位 vectors 进行按位或逻辑运算，返回结果 vector。
v128_store⚠	simd128 将 v128 vector 存储到给定的堆地址。
v128_store8_lane⚠	simd128 将来自 v 的 L 通道的 8 位值存储到 m
v128_store16_lane⚠	simd128 将 v 的通道 L 的 16 位值存储到 m
v128_store32_lane⚠	simd128 将来自 v 的 L 通道的 32 位值存储到 m
v128_store64_lane⚠	simd128 将来自 v 的 L 通道的 64 位值存储到 m
v128_xor	simd128 对两个输入的 128 位 vectors 进行按位异或，返回结果 vector。