Module core::arch::wasm[][src]

🔬 This is a nightly-only experimental API. (simd_wasm64 #90599)
This is supported on target_family="wasm" only.
Expand description

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

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

Structs

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

Functions

memory_atomic_notifyExperimentalatomics
memory_atomic_wait32Experimentalatomics
memory_atomic_wait64Experimentalatomics
f32x4simd128

从提供的操作数实现 SIMD 值。

f32x4_abssimd128

计算一个 128 位 vector 的每个 lane 的绝对值,该绝对值解释为四个 32 位浮点数。

f32x4_addsimd128

将两个 128 位 vectors 的成对 lanes 相加,将其解释为四个 32 位浮点数。

f32x4_ceilsimd128

按 lane-wise 舍入到不小于输入的最近整数值。

将解释为四个 32 位有符号整数的 128 位 vector 转换为 四个 32 位浮点数的 128 位 vector。

将解释为四个 32 位无符号整数的 128 位 vector 转换为 四个 32 位浮点数的 128 位 vector。

将结果的两个双精度浮点 lanes 转换为两个较低的单精度 lanes。 结果的两个较高 lane 被初始化为零。 如果转换结果不能表示为单精度浮点数,则将其四舍五入为最接近的偶数可表示数。

f32x4_divsimd128

将两个 128 位 vectors 的成对 lanes 划分为四个 32 位浮点数。

f32x4_eqsimd128

比较两个 128 位 vectors,就好像它们是 4 个 32 位浮点数的两个 vectors 一样。

从解释为 4 个包装的 f32 数字的 128 位 vector 中提取 lane。

按 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

计算两个解释为四个 32 位浮点数的 128 位 vectors 的成对 lanes 的最大值。

f32x4_minsimd128

计算两个解释为四个 32 位浮点数的 128 位 vectors 的成对 lanes 的最小值。

f32x4_mulsimd128

将两个 128 位 vectors 的成对 lanes 相乘,将其解释为四个 32 位浮点数。

f32x4_nesimd128

比较两个 128 位 vectors,就好像它们是 4 个 32 位浮点数的两个 vectors 一样。

按 lane-wise 舍入到最接近的整数值; 如果两个值相等,则舍入到偶数。

f32x4_negsimd128

对解释为四个 32 位浮点数的 128 位向量的每个 lane 求反。

f32x4_pmaxsimd128

lane-wise 最大值,定义为 a < b ? b : a

f32x4_pminsimd128

lane-wise 最小值,定义为 b < a ? b : a

从解释为 4 个包装的 f32 编号的 128 位 vector 替换一个 lane。

创建具有相同 lanes 的 vector。

f32x4_sqrtsimd128

计算一个 128 位 vector 的每个 lane 的平方根,该 vector 解释为四个 32 位浮点数。

f32x4_subsimd128

减去两个 128 位 vectors 的成对 lanes,它们被解释为四个 32 位浮点数。

按 lane-wise 舍入到最接近的整数值,幅度不大于输入。

f64x2simd128

从提供的操作数实现 SIMD 值。

f64x2_abssimd128

计算被解释为两个 64 位浮点数的 128 位 vector 的每个 lane 的绝对值。

f64x2_addsimd128

将两个 128 位 vectors 的成对 lanes 相加,将其解释为两个 64 位浮点数。

f64x2_ceilsimd128

按 lane-wise 舍入到不小于输入的最近整数值。

从整数到浮点的按 lane-wise 转换。

从整数到浮点的按 lane-wise 转换。

f64x2_divsimd128

将两个 128 位 vectors 的成对 lanes 划分为两个 64 位浮点数。

f64x2_eqsimd128

比较两个 128 位 vectors,就好像它们是 2 个 64 位浮点数的两个 vectors 一样。

从解释为 2 个包装的 f64 编号的 128 位 vector 中提取 lane。

按 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

计算两个解释为两个 64 位浮点数的 128 位 vectors 的成 lanes 的最大值。

f64x2_minsimd128

计算两个解释为两个 64 位浮点数的 128 位 vectors 的成对 lanes 的最小值。

f64x2_mulsimd128

将两个解释为两个 64 位浮点数的 128 位 vectors 的成对 lanes 相乘。

f64x2_nesimd128

比较两个 128 位 vectors,就好像它们是 2 个 64 位浮点数的两个 vectors 一样。

按 lane-wise 舍入到最接近的整数值; 如果两个值相等,则舍入到偶数。

f64x2_negsimd128

取反解释为两个 64 位浮点数的 128 位 vector 的每个 lane。

f64x2_pmaxsimd128

lane-wise 最大值,定义为 a < b ? b : a

f64x2_pminsimd128

lane-wise 最小值,定义为 b < a ? b : a

将两个较低的单精度浮点 lanes 转换为结果的两个双精度 lanes。

从一个解释为 2 包装的 f64 编号的 128 位 vector 替换一个 lane。

创建具有相同 lanes 的 vector。

f64x2_sqrtsimd128

计算一个 128 位 vector 的每个 lane 的平方根,该 vector 解释为两个 64 位浮点数。

f64x2_subsimd128

减去两个 128 位 vectors 的成对 lanes,它们被解释为两个 64 位浮点数。

按 lane-wise 舍入到最接近的整数值,幅度不大于输入。

i8x16simd128

从提供的操作数实现 SIMD 值。

i8x16_abssimd128

按 lane-wise 包装绝对值。

i8x16_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的 16 个 8 位整数一样。

将两个 128 位 vectors 相加,就好像它们是两个包装的 16 个 8 位有符号整数一样,在溢出到 i8::MAX 时会饱和。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

i8x16_eqsimd128

比较两个 128 位 vectors,就好像它们是 16 个 8 位整数的两个 vectors 一样。

从解释为 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 有符号整数,并返回每对中的最小值。

通过使每个 lane 变窄,将两个输入 vectors 转换为较小的 lane vector。

i8x16_nesimd128

比较两个 128 位 vectors,就好像它们是 16 个 8 位整数的两个 vectors 一样。

i8x16_negsimd128

对 128 位 vectors 取反,解释为 16 个 8 位有符号整数

计算每个 lane 内设置为 1 的位数。

替换 128 位 vector 中的 lane,该 lane 被解释为 16 个包装的 i8 数字。

i8x16_shlsimd128

将每个 lane 向左移动指定的位数。

i8x16_shrsimd128

将每个 lane 向右移动指定的位数,并扩展符号。

返回一个新的 vector,其 lanes 从 16 个 immediate 操作数中指定的两个输入 vectors $a$b 的 lanes 中选择。

创建具有相同 lanes 的 vector。

i8x16_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的 16 个 8 位整数一样。

将两个 128 位 vectors 相减,就好像它们是两个包装的 16 个 8 位有符号整数一样,在溢出到 i8::MIN 时会饱和。

返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的 lanes 中选择的 lanes 的新 vector。

i16x8simd128

从提供的操作数实现 SIMD 值。

i16x8_abssimd128

按 lane-wise 包装绝对值。

i16x8_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的八个 16 位整数一样。

将两个 128 位 vectors 相加,就好像它们是两个包装的八个 16 位有符号整数一样,在溢出到 i16::MAX 时会饱和。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

i16x8_eqsimd128

比较两个 128 位 vectors,就好像它们是 8 个 16 位整数的两个 vectors 一样。

lane-wise 整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。

lane-wise 整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。

将较小 lane vector 的高一半转换为较大 lane vector,并对其进行符号扩展。

将较小 lane vector 的高一半转换为较大 lane vector,扩展为零。

将较小 lane vector 的下半部分转换为较大 lane vector,并扩展符号。

将较小 lane vector 的下半部分转换为较大 lane vector,扩展为零。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

从解释为 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 一样。

加载 8 个 8 位整数,并将每个符号扩展到 16 位 lane

加载 8 个 8 位整数,零加载每个整数至 16 位 lane

i16x8_ltsimd128

比较两个 128 位 vectors,就好像它们是 8 个 16 位带符号整数的两个 vectors 一样。

i16x8_maxsimd128

比较 lane-wise 有符号整数,并返回每对的最大值。

i16x8_minsimd128

比较 lane-wise 有符号整数,并返回每对中的最小值。

i16x8_mulsimd128

将两个 128 位 vectors 相乘,就好像它们是两个包装的八个 16 位有符号整数一样。

通过使每个 lane 变窄,将两个输入 vectors 转换为较小的 lane vector。

i16x8_nesimd128

比较两个 128 位 vectors,就好像它们是 8 个 16 位整数的两个 vectors 一样。

i16x8_negsimd128

对 128 位 vectors 取反,解释为 8 个 16 位有符号整数

Q15 格式的 lane-wise 饱和舍入乘法。

从解释为 8 个包装的 i16 编号的 128 位 vector 替换一个 lane。

i16x8_shlsimd128

将每个 lane 向左移动指定的位数。

i16x8_shrsimd128

将每个 lane 向右移动指定的位数,并扩展符号。

i8x16_shuffle 相同,只是操作起来好像输入是八个 16 位整数,仅需 8 个索引即可重排。

创建具有相同 lanes 的 vector。

i16x8_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的八个 16 位整数一样。

将两个 128 位 vectors 相减,就好像它们是两个包装的八个 16 位有符号整数一样,在溢出到 i16::MIN 时会饱和。

i32x4simd128

从提供的操作数实现 SIMD 值。

i32x4_abssimd128

按 lane-wise 包装绝对值。

i32x4_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的四个 32 位整数一样。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

在两个输入 vectors 中按 lane-wise 乘以带符号的 16 位整数,并将完整的 32 位结果的相邻对相加。

i32x4_eqsimd128

比较两个 128 位 vectors,就好像它们是 4 个 32 位整数的两个 vectors 一样。

lane-wise 整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。

lane-wise 整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。

将较小 lane vector 的高一半转换为较大 lane vector,并对其进行符号扩展。

将较小 lane vector 的高一半转换为较大 lane vector,扩展为零。

将较小 lane vector 的下半部分转换为较大 lane vector,并扩展符号。

将较小 lane vector 的下半部分转换为较大 lane vector,扩展为零。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

从解释为 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 一样。

加载四个 16 位整数,并将每个符号扩展到 32 位 lane

加载四个 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

对 128 位 vectors 取反,解释为 4 个 32 位有符号整数

从解释为 4 个包装的 i32 编号的 128 位 vector 替换一个 lane。

i32x4_shlsimd128

将每个 lane 向左移动指定的位数。

i32x4_shrsimd128

将每个 lane 向右移动指定的位数,并扩展符号。

i8x16_shuffle 相同,但操作时如同输入为 4 32 位整数,仅需 4 个索引即可重排。

创建具有相同 lanes 的 vector。

i32x4_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的四个 32 位整数一样。

将解释为四个 32 位浮点数的 128 位 vector 转换为包含四个 32 位带符号整数的 128 位 vector。

使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点 lanes 饱和转换为两个较低的整数 lanes。

i64x2simd128

从提供的操作数实现 SIMD 值。

i64x2_abssimd128

按 lane-wise 包装绝对值。

i64x2_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的两个 64 位整数一样。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

i64x2_eqsimd128

比较两个 128 位 vectors,就好像它们是两个 64 位整数的两个 vectors。

将较小 lane vector 的高一半转换为较大 lane vector,并对其进行符号扩展。

将较小 lane vector 的高一半转换为较大 lane vector,扩展为零。

将较小 lane vector 的下半部分转换为较大 lane vector,并扩展符号。

将较小 lane vector 的下半部分转换为较大 lane vector,扩展为零。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

从解释为 2 个包装的 i64 编号的 128 位 vector 中提取 lane。

i64x2_gesimd128

比较两个 128 位 vectors,就好像它们是两个 64 位有符号整数的两个 vectors。

i64x2_gtsimd128

比较两个 128 位 vectors,就好像它们是两个 64 位有符号整数的两个 vectors。

i64x2_lesimd128

比较两个 128 位 vectors,就好像它们是两个 64 位有符号整数的两个 vectors。

加载两个 32 位整数并将每个符号扩展到 64 位 lane

加载两个 32 位整数,零加载每个整数到 64 位 lane

i64x2_ltsimd128

比较两个 128 位 vectors,就好像它们是两个 64 位有符号整数的两个 vectors。

i64x2_mulsimd128

将两个 128 位 vectors 相乘,就好像它们是两个包装的两个 64 位整数一样。

i64x2_nesimd128

比较两个 128 位 vectors,就好像它们是两个 64 位整数的两个 vectors。

i64x2_negsimd128

对 128 位 vectors 取反,解释为 2 个 64 位有符号整数

从一个解释为 2 个包装的 i64 编号的 128 位 vector 替换一个 lane。

i64x2_shlsimd128

将每个 lane 向左移动指定的位数。

i64x2_shrsimd128

将每个 lane 向右移动指定的位数,并扩展符号。

i8x16_shuffle 相同,但操作时就像输入是两个 64 位整数,仅需 2 个索引即可重排。

创建具有相同 lanes 的 vector。

i64x2_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的两个 64 位整数一样。

u8x16simd128

从提供的操作数实现 SIMD 值。

u8x16_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的 16 个 8 位整数一样。

将两个 128 位 vectors 相加,就好像它们是两个包装的 16 个 8 位无符号整数一样,在溢出到 u8::MAX 时会饱和。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

u8x16_avgrsimd128

lane-wise 舍入平均值。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

u8x16_eqsimd128

比较两个 128 位 vectors,就好像它们是 16 个 8 位整数的两个 vectors 一样。

从解释为 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 无符号整数,并返回每对中的最小值。

通过使每个 lane 变窄,将两个输入 vectors 转换为较小的 lane vector。

u8x16_nesimd128

比较两个 128 位 vectors,就好像它们是 16 个 8 位整数的两个 vectors 一样。

计算每个 lane 内设置为 1 的位数。

从解释为 16 个包装的 u8 数字的 128 位 vector 替换一个 lane。

u8x16_shlsimd128

将每个 lane 向左移动指定的位数。

u8x16_shrsimd128

将每个 lane 向右移动指定的位数,以零为单位。

返回一个新的 vector,其 lanes 从 16 个 immediate 操作数中指定的两个输入 vectors $a$b 的 lanes 中选择。

创建具有相同 lanes 的 vector。

u8x16_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的 16 个 8 位整数一样。

将两个 128 位 vectors 相减,就好像它们是两个包装的 16 个 8 位无符号整数一样,溢出时饱和为 0。

返回带有从第二个输入 vector s 中指定的第一个输入 vector a 的 lanes 中选择的 lanes 的新 vector。

u16x8simd128

从提供的操作数实现 SIMD 值。

u16x8_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的八个 16 位整数一样。

将两个 128 位 vectors 相加,就好像它们是两个包装的八个 16 位无符号整数一样,在溢出到 u16::MAX 时会饱和。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

u16x8_avgrsimd128

lane-wise 舍入平均值。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

u16x8_eqsimd128

比较两个 128 位 vectors,就好像它们是 8 个 16 位整数的两个 vectors 一样。

lane-wise 整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。

将较小 lane vector 的高一半转换为较大 lane vector,扩展为零。

将较小 lane vector 的下半部分转换为较大 lane vector,扩展为零。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

从解释为 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 一样。

加载 8 个 8 位整数,零加载每个整数至 16 位 lane

u16x8_ltsimd128

比较两个 128 位 vectors,就好像它们是 8 个 16 位无符号整数的两个 vectors 一样。

u16x8_maxsimd128

比较 lane-wise 无符号整数,并返回每对的最大值。

u16x8_minsimd128

比较 lane-wise 无符号整数,并返回每对中的最小值。

u16x8_mulsimd128

将两个 128 位 vectors 相乘,就好像它们是两个包装的八个 16 位有符号整数一样。

通过使每个 lane 变窄,将两个输入 vectors 转换为较小的 lane vector。

u16x8_nesimd128

比较两个 128 位 vectors,就好像它们是 8 个 16 位整数的两个 vectors 一样。

从解释为 8 个包装的 u16 数字的 128 位 vector 替换一个 lane。

u16x8_shlsimd128

将每个 lane 向左移动指定的位数。

u16x8_shrsimd128

将每个 lane 向右移动指定的位数,以零为单位。

i8x16_shuffle 相同,只是操作起来好像输入是八个 16 位整数,仅需 8 个索引即可重排。

创建具有相同 lanes 的 vector。

u16x8_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的八个 16 位整数一样。

将两个 128 位 vectors 相减,就好像它们是两个包装的八个 16 位无符号整数一样,溢出时饱和为 0。

u32x4simd128

从提供的操作数实现 SIMD 值。

u32x4_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的四个 32 位整数一样。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

u32x4_eqsimd128

比较两个 128 位 vectors,就好像它们是 4 个 32 位整数的两个 vectors 一样。

lane-wise 整数扩展成对加法产生扩展结果 (结果比输入宽两倍)。

将较小 lane vector 的高一半转换为较大 lane vector,扩展为零。

将较小 lane vector 的下半部分转换为较大 lane vector,扩展为零。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

从解释为 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 一样。

加载四个 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 一样。

从解释为 4 个包装的 u32 数字的 128 位 vector 替换一个 lane。

u32x4_shlsimd128

将每个 lane 向左移动指定的位数。

u32x4_shrsimd128

将每个 lane 向右移动指定的位数,以零为单位。

i8x16_shuffle 相同,但操作时如同输入为 4 32 位整数,仅需 4 个索引即可重排。

创建具有相同 lanes 的 vector。

u32x4_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的四个 32 位整数一样。

将解释为四个 32 位浮点数的 128 位 vector 转换为四个 32 位无符号整数的 128 位 vector。

使用 IEEE convertToIntegerTowardZero 函数将两个双精度浮点 lanes 饱和转换为两个较低的整数 lanes。

u64x2simd128

从提供的操作数实现 SIMD 值。

u64x2_addsimd128

将两个 128 位 vectors 相加,就好像它们是两个包装的两个 64 位整数一样。

如果所有 lanes 都不为零,则返回 true,否则返回 false。

提取 a 中每个 lane 的高位并生成一个所有位连接的标量掩码。

u64x2_eqsimd128

比较两个 128 位 vectors,就好像它们是两个 64 位整数的两个 vectors。

将较小 lane vector 的高一半转换为较大 lane vector,扩展为零。

将较小 lane vector 的下半部分转换为较大 lane vector,扩展为零。

lane-wise 整数扩展乘法产生两倍于输入的结果。

lane-wise 整数扩展乘法产生两倍于输入的结果。

从解释为 2 个包装的 u64 数字的 128 位 vector 中提取一个 lane。

加载两个 32 位整数,零加载每个整数到 64 位 lane

u64x2_mulsimd128

将两个 128 位 vectors 相乘,就好像它们是两个包装的两个 64 位整数一样。

u64x2_nesimd128

比较两个 128 位 vectors,就好像它们是两个 64 位整数的两个 vectors。

从解释为 2 个包装的 u64 数字的 128 位 vector 替换一个 lane。

u64x2_shlsimd128

将每个 lane 向左移动指定的位数。

u64x2_shrsimd128

将每个 lane 向右移动指定的位数,以零为单位。

i8x16_shuffle 相同,但操作时就像输入是两个 64 位整数,仅需 2 个索引即可重排。

创建具有相同 lanes 的 vector。

u64x2_subsimd128

将两个 128 位 vectors 相减,就好像它们是两个包装的两个 64 位整数一样。

生成 unreachable 指令,这会导致无条件的 trap

v128_andsimd128

对两个输入的 128 位 vectors 进行按位和运算,返回结果 vector。

a 的位按位与与 b 的位进行逻辑逆。

如果设置了 a 中的任何一位,则返回 true,否则返回 false

使用 c 中的位掩码在 1 时从 v1 中选择位,在 0 时从 v2 中选择位。

从给定的堆地址加载 v128 vector。

m 加载一个 8 位值并将 v 的 lane L 设置为该值。

加载单个元素,然后将其放置到 v128 vector 的所有 lane 中。

m 加载 16 位值并将 v 的 lane L 设置为该值。

加载单个元素,然后将其放置到 v128 vector 的所有 lane 中。

m 加载 32 位值并将 v 的 lane L 设置为该值。

加载单个元素,然后将其放置到 v128 vector 的所有 lane 中。

将 32 位元素加载到 vector 的低位并将所有其他位设置为零。

m 加载 64 位值并将 v 的 lane L 设置为该值。

加载单个元素,然后将其放置到 v128 vector 的所有 lane 中。

将 64 位元素加载到 vector 的低位并将所有其他位设置为零。

v128_notsimd128

翻转 128 位输入 vector 的每个位。

v128_orsimd128

对两个输入的 128 位 vectors 进行按位或逻辑运算,返回结果 vector。

v128 vector 存储到给定的堆地址。

将来自 vL lane 的 8 位值存储到 m

v 的 lane L 的 16 位值存储到 m

将来自 vL lane 的 32 位值存储到 m

将来自 vL lane 的 64 位值存储到 m

v128_xorsimd128

对两个输入的 128 位 vectors 进行按位异或,返回结果 vector。