Module core::arch::x86 1.27.0[−][src]
Expand description
x86 平台的平台特定的内联函数。
有关更多详细信息，请参见 module documentation。
Structs
| __m128bh | Experimental 128 位宽的一组 8 个 |
| __m256bh | Experimental 256 位宽的 16 种 |
| __m512 | Experimental 512 位宽的十六种 |
| __m512bh | Experimental 512 位宽的 32 种 |
| __m512d | Experimental 八种 |
| __m512i | Experimental 512 位宽的整数 vector 类型，特定于 x86 |
| CpuidResult |
|
| __m128 | 四种 |
| __m128d | 两种 |
| __m128i | 128 位宽的整数 vector 类型，特定于 x86 |
| __m256 | 256 位宽的八种 |
| __m256d | 256 位宽的四种 |
| __m256i | 256 位宽的整数 vector 类型，特定于 x86 |
Constants
Functions
| _MM_SHUFFLE | Experimental 一个实用程序函数，用于创建与 Intel 重排和置换内联函数一起使用的掩码。 |
| _kadd_mask32⚠ | Experimentalavx512bw在 a 和 b 中添加 32 位掩码，并将结果存储在 k 中。 |
| _kadd_mask64⚠ | Experimentalavx512bw在 a 和 b 中添加 64 位掩码，并将结果存储在 k 中。 |
| _kand_mask16⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位与，并将结果存储在 k 中。 |
| _kand_mask32⚠ | Experimentalavx512bw计算 32 位掩码 a 和 b 的按位与，并将结果存储在 k 中。 |
| _kand_mask64⚠ | Experimentalavx512bw计算 64 位掩码 a 和 b 的按位与，并将结果存储在 k 中。 |
| _kandn_mask16⚠ | Experimentalavx512f计算 16 位掩码 a 的按位非，然后与 b 计算 AND，并将结果存储在 k 中。 |
| _kandn_mask32⚠ | Experimentalavx512bw计算 32 位掩码 a 的按位非，然后与 b 计算 AND，并将结果存储在 k 中。 |
| _kandn_mask64⚠ | Experimentalavx512bw计算 64 位掩码 a 的按位非，然后与 b 进行与运算，并将结果存储在 k 中。 |
| _knot_mask16⚠ | Experimentalavx512f计算 16 位掩码 a 的按位非，并将结果存储在 k 中。 |
| _knot_mask32⚠ | Experimentalavx512bw计算 32 位掩码 a 的按位非，并将结果存储在 k 中。 |
| _knot_mask64⚠ | Experimentalavx512bw计算 64 位掩码 a 的按位非，并将结果存储在 k 中。 |
| _kor_mask16⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位或，并将结果存储在 k 中。 |
| _kor_mask32⚠ | Experimentalavx512bw计算 32 位掩码 a 和 b 的按位或，并将结果存储在 k 中。 |
| _kor_mask64⚠ | Experimentalavx512bw计算 64 位掩码 a 和 b 的按位或，并将结果存储在 k 中。 |
| _kxnor_mask16⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位 XNOR，并将结果存储在 k 中。 |
| _kxnor_mask32⚠ | Experimentalavx512bw计算 32 位掩码 a 和 b 的按位 XNOR，并将结果存储在 k 中。 |
| _kxnor_mask64⚠ | Experimentalavx512bw计算 64 位掩码 a 和 b 的按位 XNOR，并将结果存储在 k 中。 |
| _kxor_mask16⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位 XOR，并将结果存储在 k 中。 |
| _kxor_mask32⚠ | Experimentalavx512bw计算 32 位掩码 a 和 b 的按位 XOR，并将结果存储在 k 中。 |
| _kxor_mask64⚠ | Experimentalavx512bw计算 64 位掩码 a 和 b 的按位 XOR，并将结果存储在 k 中。 |
| _load_mask32⚠ | Experimentalavx512bw将内存中的 32 位掩码加载到 k 中。 |
| _load_mask64⚠ | Experimentalavx512bw将内存中的 64 位掩码加载到 k 中。 |
| _mm256_abs_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的带符号的 64 位整数的绝对值，并将无符号的结果存储在 dst 中。 |
| _mm256_aesdec_epi128⚠ | Experimentalavx512vaes,avx512vl使用 |
| _mm256_aesdeclast_epi128⚠ | Experimentalavx512vaes,avx512vl使用 |
| _mm256_aesenc_epi128⚠ | Experimentalavx512vaes,avx512vl使用 |
| _mm256_aesenclast_epi128⚠ | Experimentalavx512vaes,avx512vl使用 |
| _mm256_alignr_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成一个 64 字节的 immediate 结果，将结果右移 imm8 个 32 位元素，并将低 32 字节 (8 个元素) 存储在 dst 中。 |
| _mm256_alignr_epi64⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 64 字节的 immediate 结果，将结果右移 imm8 个 64 位元素，并将低 32 字节 (4 个元素) 存储在 dst 中。 |
| _mm256_bitshuffle_epi64_mask⚠ | Experimentalavx512bitalg,avx512vl将输入 |
| _mm256_broadcast_f32x4⚠ | Experimentalavx512f,avx512vl从 a 广播 4 个包装的单精度 (32-bit) 浮点元素到 dst 的所有元素。 |
| _mm256_broadcast_i32x4⚠ | Experimentalavx512f,avx512vl将 4 个包装的 32 位整数从 a 广播到 dst 的所有元素。 |
| _mm256_broadcastmb_epi64⚠ | Experimentalavx512cd,avx512vl将输入掩码 k 的低 8 位广播到 dst 的所有 64 位元素。 |
| _mm256_broadcastmw_epi32⚠ | Experimentalavx512cd,avx512vl将输入掩码 k 的低 16 位广播到 dst 的所有 32 位元素。 |
| _mm256_clmulepi64_epi128⚠ | Experimentalavx512vpclmulqdq,avx512vl在 2 个 128 位通道中的每个通道中，在有限域 GF(2^k) 上执行两个 64 位多项式的无进位乘法。 |
| _mm256_cmp_epi8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装带符号 8 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epi16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epi32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装有符号 32 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epi64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epu8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epu16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 16 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epu32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_epu64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 64 位整数，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_pd_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm256_cmp_ps_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 64 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpeq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号 32 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpge_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpgt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数以得出小于或等于的结果，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmple_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数小于零，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数小于零，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数以得到小于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装后的无符号 16 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmplt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_cmpneq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm256_conflict_epi32⚠ | Experimentalavx512cd,avx512vl测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm256_conflict_epi64⚠ | Experimentalavx512cd,avx512vl测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm256_cvtepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtepi32_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtepi32_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtepi64_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtepi64_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带有截断的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtepi64_epi32⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带有截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtepu32_pd⚠ | Experimentalavx512f,avx512vl将 A 中的包装的无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm256_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512vl将两个 256 位 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并将结果存入 a |
| _mm256_cvtneps_pbh⚠ | Experimentalavx512bf16,avx512vl将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并将结果存储在 dst 中。 Intel’s documentation |
| _mm256_cvtpd_epu32⚠ | Experimentalavx512f,avx512vl将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtph_ps⚠ | Experimentalf16c将 128 位 vector |
| _mm256_cvtps_epu32⚠ | Experimentalavx512f,avx512vl将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtps_ph⚠ | Experimentalf16c将 256 位 vector |
| _mm256_cvtsepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 A 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtsepi32_epi8⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtsepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtsepi64_epi8⚠ | Experimentalavx512f,avx512vl将包装的带符号的 64 位整数转换为带符号饱和的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtsepi64_epi16⚠ | Experimentalavx512f,avx512vl将包装的带符号的 64 位整数转换为带符号饱和的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtsepi64_epi32⚠ | Experimentalavx512f,avx512vl将包装的带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm256_cvttpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm256_cvttps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtusepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtusepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtusepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装无符号 32 位整数转换为具有无符号饱和度的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtusepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtusepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm256_cvtusepi64_epi32⚠ | Experimentalavx512f,avx512vl将 A 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm256_dbsad_epu8⚠ | Experimentalavx512bw,avx512vl计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs)，并将 16 位结果存储在 dst 中。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm256_dpbf16_ps⚠ | Experimentalavx512bf16,avx512vl计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间单精度 (32-bit) 浮点元素与 src 中的元素相加，并将结果存储在 dst 中。 |
| _mm256_dpbusd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果存入 dst。 |
| _mm256_dpbusds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。使用有符号饱和将这 4 个结果与 src 中相应的 32 位整数相加，并将包装的 32 位结果存储在 dst 中。 |
| _mm256_dpwssd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果存入 dst。 |
| _mm256_dpwssds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并将包装的 32 位结果存储在 dst 中。 |
| _mm256_extractf32x4_ps⚠ | Experimentalavx512f,avx512vl从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并用 imm8 进行选择，并将结果存储在 dst 中。 |
| _mm256_extracti32x4_epi32⚠ | Experimentalavx512f,avx512vl从 a 中提取 128 位 (由 4 个包装的 32 位整数组成)，用 IMM1 选中，结果存入 dst。 |
| _mm256_fixupimm_pd⚠ | Experimentalavx512f,avx512vl使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm256_fixupimm_ps⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm256_getexp_pd⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm256_getexp_ps⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm256_getmant_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化，并将结果存储在 dst 中。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm256_getmant_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素的尾数标准化，并将结果存储在 dst 中。 此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 尾数被标准化为由 interv 指定的间隔，该间隔可以采用以下值: _MM_MANT_NORM_1_2 // interval [1, 2) _MM_MANT_NORM_p5_2 // interval [0.5, 2) _MM_MANT_NORM_p5_1 // interval [0.5, 1) _MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5) The sign is determined by sc which can take the following values: |
| _mm256_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm256_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm256_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm256_insertf32x4⚠ | Experimentalavx512f,avx512vl将 a 复制到 dst，然后在 x00X 指定的位置将 d 的 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入 dst。 |
| _mm256_inserti32x4⚠ | Experimentalavx512f,avx512vl将 a 复制到 dst，然后在 x00X 指定的位置将 d 的 128 位 (由 4 个包装的 32 位整数组成) 插入 dst。 |
| _mm256_load_epi32⚠ | Experimentalavx512f,avx512vl将 256 位 (由 8 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 32 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm256_load_epi64⚠ | Experimentalavx512f,avx512vl将 256 位 (由 4 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 32 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm256_loadu_epi8⚠ | Experimentalavx512bw,avx512vl将 256 位 (由 32 个包装的 8 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_loadu_epi16⚠ | Experimentalavx512bw,avx512vl将 256 位 (由 16 个包装的 16 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_loadu_epi32⚠ | Experimentalavx512f,avx512vl将 256 位 (由 8 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_loadu_epi64⚠ | Experimentalavx512f,avx512vl将 256 位 (由 4 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_lzcnt_epi32⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 32 位整数中前导零位的数目，并将结果存储在 dst 中。 |
| _mm256_lzcnt_epi64⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 64 位整数中前导零位的数目，并将结果存储在 dst 中。 |
| _mm256_madd52hi_epu64⚠ | Experimentalavx512ifma,avx512vl将 |
| _mm256_madd52lo_epu64⚠ | Experimentalavx512ifma,avx512vl将 |
| _mm256_mask2_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm256_mask2_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm256_mask2_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm256_mask2_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm256_mask2_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 idx 复制元素) |
| _mm256_mask2_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的对应选择器和索引在 a 和 b 中的通道中对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm256_mask3_fmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 c 复制元素)。 |
| _mm256_mask3_fmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm256_mask3_fmaddsub_pd⚠ | Experimentalavx512f,avx512vl在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm256_mask3_fmaddsub_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm256_mask3_fmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm256_mask3_fmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm256_mask3_fmsubadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm256_mask3_fmsubadd_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素，或者在中间结果中减去并在 c from/to 中包装的元素相乘，然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm256_mask3_fnmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm256_mask3_fnmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 c 复制)。 |
| _mm256_mask3_fnmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 c 复制元素)。 |
| _mm256_mask3_fnmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm256_mask_abs_epi8⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 8 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_abs_epi16⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 16 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_abs_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的有符号 32 位整数的绝对值，并使用 writemask k 将无符号结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_abs_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的带符号的 64 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_add_epi8⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中添加包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_add_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中添加包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_add_epi32⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_add_epi64⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_add_pd⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_add_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_adds_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_adds_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_adds_epu8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_adds_epu16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_alignr_epi8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果，将结果右移 imm8 字节，并使用写掩码 k 将低 16 个字节存储在 dst 中 (当相应的掩码位为 1 时，元素从 src 复制没有设置)。 |
| _mm256_mask_alignr_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 64 字节的 immediate 结果，将结果右移 imm8 个 32 位元素，并使用 writemask k 将低 32 字节 (8 个元素) 存储在 dst 中 (当相应的掩码位为没有设置)。 |
| _mm256_mask_alignr_epi64⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 64 字节的 immediate 结果，将结果右移 imm8 个 64 位元素，并使用 writemask k 将低 32 字节 (4 个元素) 存储在 dst 中 (当相应的掩码位为没有设置)。 |
| _mm256_mask_and_epi32⚠ | Experimentalavx512f,avx512vl在包装的 a 和 b 的 32 位整数元素之间执行逐个元素的按位 AND，使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_and_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 src 复制元素)。 |
| _mm256_mask_andnot_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 32 位整数的按位 NOT，然后与 b 计算 AND，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_andnot_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 64 位整数的按位 NOT，然后与 b 计算 AND，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_avg_epu8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 8 位整数平均，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_avg_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数进行平均，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_bitshuffle_epi64_mask⚠ | Experimentalavx512bitalg,avx512vl将输入 |
| _mm256_mask_blend_epi8⚠ | Experimentalavx512bw,avx512vl使用控制掩码 k 混合 a 和 b 中的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm256_mask_blend_epi16⚠ | Experimentalavx512bw,avx512vl使用控制掩码 k 混合来自 a 和 b 的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm256_mask_blend_epi32⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合 a 和 b 中的包装 32 位整数，并将结果存储在 dst 中。 |
| _mm256_mask_blend_epi64⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合 a 和 b 中的包装 64 位整数，并将结果存储在 dst 中。 |
| _mm256_mask_blend_pd⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合来自 a 和 b 的包装后的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm256_mask_blend_ps⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合来自 a 和 b 的包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm256_mask_broadcast_f32x4⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_broadcast_i32x4⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将 a 的 4 个包装的 32 位整数广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_broadcastb_epi8⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将 d 的低包装的 8 位整数广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_broadcastd_epi32⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_broadcastq_epi64⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_broadcastsd_pd⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低双精度 (64-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_broadcastss_ps⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低单精度 (32-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，将元素从 src 复制)。 |
| _mm256_mask_broadcastw_epi16⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_cmp_epi8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmp_epi16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmp_epi32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 32 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmp_epi64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmp_epu8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmp_epu16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmp_epu32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmp_epu64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmp_pd_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmp_ps_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmpeq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpeq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否相等，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpeq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmpeq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 64 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpeq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpeq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpeq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpeq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数是否等于或大于等于，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于等于，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpge_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数是否大于，并将结果使用零掩码 k1 存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpgt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmple_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmple_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数 (小于或等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmple_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmple_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数 (小于等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmple_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmple_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmple_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmple_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数 (小于或等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_mask_cmplt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数以得到小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmplt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpneq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_mask_cmpneq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpneq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpneq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_mask_cmpneq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpneq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpneq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_cmpneq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_mask_compress_epi8⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 8 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst，并通过 src 中的其余元素。 |
| _mm256_mask_compress_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 16 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst，并通过 src 中的其余元素。 |
| _mm256_mask_compress_epi32⚠ | Experimentalavx512f,avx512vl将活动的 32 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst，并通过 src 中的其余元素。 |
| _mm256_mask_compress_epi64⚠ | Experimentalavx512f,avx512vl将活动的 64 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst，并通过 src 中的其余元素。 |
| _mm256_mask_compress_pd⚠ | Experimentalavx512f,avx512vl将活动的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位在写掩码 k 中设置) 到 dst，并通过 src 中的其余元素。 |
| _mm256_mask_compress_ps⚠ | Experimentalavx512f,avx512vl将活动的单精度 (32-bit) 浮点元素连续存储在 dst 中 (将其各自的位设置在写掩码 k 中的那些元素中) 存储到 dst，并通过 src 中的其余元素。 |
| _mm256_mask_conflict_epi32⚠ | Experimentalavx512cd,avx512vl使用写掩码 k (在未设置相应的掩码位时从 src 复制元素)，测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm256_mask_conflict_epi64⚠ | Experimentalavx512cd,avx512vl使用写掩码 k 测试 a 的每个 64 位元素是否与所有其他元素相等 (更接近最低有效位) (当未设置相应的掩码位时，从 src 复制元素)。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm256_mask_cvt_roundps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi8_epi16⚠ | Experimentalavx512bw,avx512vl使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi8_epi32⚠ | Experimentalavx512f,avx512vl符号将包装的 8 位整数从 a 扩展为包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi8_epi64⚠ | Experimentalavx512f,avx512vl将 a 的低 4 字节中的 8 位整数符号扩展为包装的 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_cvtepi16_epi8⚠ | Experimentalavx512bw,avx512vl将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi16_epi32⚠ | Experimentalavx512f,avx512vl符号将包装后的 16 位整数从 a 扩展为包装后的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi16_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi16_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtepi32_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi32_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi32_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi32_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi32_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数在 a 中转换为带有截断的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtepi32_storeu_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 32 位整数转换为带截断的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带有截断的包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的 16 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepi64_storeu_epi8⚠ | Experimentalavx512f,avx512vl将 a 中包装的 64 位整数转换为包装的 8 位整数并截断，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。 |
| _mm256_mask_cvtepi64_storeu_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtepi64_storeu_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtepu8_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepu8_epi32⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数在 a 的低 8 字节到包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm256_mask_cvtepu8_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数在 a 的低 4 字节到包装的 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm256_mask_cvtepu16_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepu16_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 16 位整数 a 的低 8 字节到包装的 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_cvtepu32_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtepu32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512vl将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 writemask k 将结果存储在单个 vector dst 中 (当相应的掩码位为没有设置)。 |
| _mm256_mask_cvtneps_pbh⚠ | Experimentalavx512bf16,avx512vl将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm256_mask_cvtpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtpd_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtph_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtps_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装带符号的 16 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi16_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将包装在 a 中的有符号 16 位整数转换为有符号饱和的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtsepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi32_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtsepi32_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 16 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtsepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtsepi64_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtsepi64_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtsepi64_storeu_epi32⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvttpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvttpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvttps_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvttps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtusepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtusepi16_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将包装在 a 中的无符号 16 位整数转换为具有无符号饱和的包装的无符号 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtusepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_cvtusepi32_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtusepi32_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtusepi32_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的无符号 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtusepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_cvtusepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_cvtusepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_cvtusepi64_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。 |
| _mm256_mask_cvtusepi64_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的无符号 64 位整数转换为具有无符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_cvtusepi64_storeu_epi32⚠ | Experimentalavx512f,avx512vl将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm256_mask_dbsad_epu8⚠ | Experimentalavx512bw,avx512vl计算 a 中的无符号 8 位整数与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs)，并使用写掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm256_mask_div_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_div_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_dpbf16_ps⚠ | Experimentalavx512bf16,avx512vl计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间的单精度 (32-bit) 浮点元素与 src 中的元素相加，并使用 writemask k 将结果存储在 dst 中 (当对应的元素从 src 复制时掩码位未设置)。 |
| _mm256_mask_dpbusd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (未设置相应掩码位时从 src 复制元素)。 |
| _mm256_mask_dpbusds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。使用符号饱和将这 4 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_dpwssd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm256_mask_dpwssds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm256_mask_expand_epi8⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_expand_epi16⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_expand_epi32⚠ | Experimentalavx512f,avx512vl从 a 加载连续的有效 32 位整数 (它们各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_expand_epi64⚠ | Experimentalavx512f,avx512vl从 a 加载连续的有效 64 位整数 (它们各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_expand_pd⚠ | Experimentalavx512f,avx512vl从 a 加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_expand_ps⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_extractf32x4_ps⚠ | Experimentalavx512f,avx512vl从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并用 imm8 进行选择，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 src 复制元素)。 |
| _mm256_mask_extracti32x4_epi32⚠ | Experimentalavx512f,avx512vl从 a 中提取 128 位 (由 4 个包装的 32 位整数组成)，用 IMM1 选中，用 writemask k 将结果存入 dst 中 (未设置相应掩码位时从 src 复制元素)。 |
| _mm256_mask_fixupimm_pd⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm256_mask_fixupimm_ps⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm256_mask_fmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm256_mask_fmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。 |
| _mm256_mask_fmaddsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 中复制元素放)。 |
| _mm256_mask_fmaddsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。 |
| _mm256_mask_fmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 a 复制元素)。 |
| _mm256_mask_fmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm256_mask_fmsubadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时，元素将从 a 复制放)。 |
| _mm256_mask_fmsubadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 复制元素放)。 |
| _mm256_mask_fnmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm256_mask_fnmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm256_mask_fnmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm256_mask_fnmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm256_mask_getexp_pd⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm256_mask_getexp_ps⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm256_mask_getmant_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm256_mask_getmant_ps⚠ | Experimentalavx512f,avx512vl标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm256_mask_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm256_mask_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm256_mask_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm256_mask_insertf32x4⚠ | Experimentalavx512f,avx512vl将 a 复制到 tmp，然后在 x00X 指定的位置将 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_inserti32x4⚠ | Experimentalavx512f,avx512vl将 a 复制到 tmp，然后在 imm8 指定的位置，将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_lzcnt_epi32⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 32 位整数中前导零位的数目，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_lzcnt_epi64⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 64 位整数中前导零位的数目，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_madd_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对，并使用 writemask k 将结果打包到 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_maddubs_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘，生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对，并使用写掩码 k 将饱和结果包装到 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_max_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_min_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_mov_epi8⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将包装的 8 位整数从 a 移到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_mov_epi16⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将包装的 16 位整数从 a 移到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_mov_epi32⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的 32 位整数从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_mov_epi64⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的 64 位整数从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_mov_pd⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_mov_ps⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm256_mask_movedup_pd⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_movehdup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_moveldup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_mul_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘，并使用写掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_mul_epu32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并使用写掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_mul_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_mul_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_mulhi_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的带符号的 16 位整数相乘，生成 32 位中间整数，并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_mulhi_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数相乘，生成 32 位中间整数，并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_mulhrs_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，通过加 1 舍入，并使用 writemask k 将位 [16:1] 存储到 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_mullo_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并使用写掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_mullo_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并使用写掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_multishift_epi64_epi8⚠ | Experimentalavx512vbmi,avx512vl对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并使用 writemask k (元素当相应的屏蔽位未设置时，从 src 复制)。 |
| _mm256_mask_or_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位或，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_or_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位或，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_packs_epi16⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_packs_epi32⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_packus_epi16⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_packus_epi32⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_permute_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_permute_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_permutevar_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 的双精度 (64-bit) 浮点元素进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_permutevar_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 的单精度 (32-bit) 浮点元素打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm256_mask_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm256_mask_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm256_mask_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm256_mask_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm256_mask_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在 a 和 b 中的通道上对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm256_mask_permutex_epi64⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 256 位通道内将 64 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_permutex_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 256 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_permutexvar_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应索引在跨通道的 a 中打乱 8 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_permutexvar_epi16⚠ | Experimentalavx512bw,avx512vl使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_permutexvar_epi32⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中对 32 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_permutexvar_epi64⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中随机排列 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_permutexvar_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引对跨通道中的双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_permutexvar_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引对跨通道中的单精度 (32-bit) 浮点元素进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_popcnt_epi8⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_mask_popcnt_epi16⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_mask_popcnt_epi32⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_mask_popcnt_epi64⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm256_mask_rcp14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_mask_rcp14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_mask_rol_epi32⚠ | Experimentalavx512f,avx512vl将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_rol_epi64⚠ | Experimentalavx512f,avx512vl将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_rolv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向左旋转 b 对应元素 b 中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm256_mask_rolv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向左旋转 b 的对应元素中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm256_mask_ror_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_ror_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_rorv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向右旋转 b 的对应元素中指定的位数，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm256_mask_rorv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm256_mask_roundscale_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_roundscale_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_rsqrt14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_mask_rsqrt14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_mask_scalef_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_scalef_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_set1_epi8⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_set1_epi16⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 向 dst 的所有元素广播 16 位整数 a (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_set1_epi32⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_set1_epi64⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_shldi_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_shldi_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_shldi_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_shldv_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm256_mask_shldv_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm256_mask_shldv_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 复制)。 |
| _mm256_mask_shrdi_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_shrdi_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm256_mask_shrdi_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素从 src` 复制)。 |
| _mm256_mask_shrdv_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm256_mask_shrdv_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm256_mask_shrdv_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm256_mask_shuffle_epi8⚠ | Experimentalavx512bw,avx512vl使用 b 中相应的 8 位元素中的控件在 128 位通道内对 a 中的 8 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_shuffle_epi32⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件将 128 位通道中的 32 位整数随机排列，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_shuffle_f32x4⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_shuffle_f64x2⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_shuffle_i32x4⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 重排，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_shuffle_i64x2⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 进行混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_shuffle_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件对 128 位通道中的双精度 (64-bit) 浮点元素进行混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_shuffle_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_shufflehi_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，将 128 位通道的低 64 位从 a 复制到 dst，使用写掩码 k (当相应的掩码位不存在时，元素从 src 复制放)。 |
| _mm256_mask_shufflelo_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，并使用写掩码 k 将 128 位通道的高 64 位从 a 复制到 dst (当未使用相应的掩码位时，元素从 src 复制) 放)。 |
| _mm256_mask_sll_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数左移，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sll_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移计数，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sll_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数左移计数，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_slli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数左移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_slli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_slli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数向左移动 imm8，同时向零移动，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sllv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按 count 中相应元素指定的数量向左移位，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sllv_epi32⚠ | Experimentalavx512f,avx512vl将填充的 32 位整数向左移动计数中相应元素指定的数量，同时将其移位为零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sllv_epi64⚠ | Experimentalavx512f,avx512vl将填充的 64 位整数向左移动 count 中相应元素指定的数量，同时将其移位为零，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm256_mask_sqrt_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sqrt_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sra_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数右移，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sra_epi32⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sra_epi64⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srai_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srai_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srai_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srav_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 count 中相应元素指定的数量，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srav_epi32⚠ | Experimentalavx512f,avx512vl在将符号位移位的同时，将已包装的 32 位整数向右移动计数中相应元素指定的数量，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srav_epi64⚠ | Experimentalavx512f,avx512vl在移入符号位的同时，将包装的 64 位整数向右移动计数中相应元素指定的数量，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srl_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srl_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移，同时移零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srl_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移，同时移零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srlv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srlv_epi32⚠ | Experimentalavx512f,avx512vl向右移动包装的 32 位整数整数 (由 count 中相应元素指定的数量)，同时向零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_srlv_epi64⚠ | Experimentalavx512f,avx512vl向右移位包装的 64 位整数，其数量为计数中相应元素指定的数量，同时向零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sub_epi8⚠ | Experimentalavx512bw,avx512vl从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sub_epi16⚠ | Experimentalavx512bw,avx512vl从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sub_epi32⚠ | Experimentalavx512f,avx512vl从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sub_epi64⚠ | Experimentalavx512f,avx512vl从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sub_pd⚠ | Experimentalavx512f,avx512vl从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_sub_ps⚠ | Experimentalavx512f,avx512vl将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_subs_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度将 b 中的包装 8 位整数减去 b 中的包装 8 位有符号整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_subs_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_subs_epu8⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_subs_epu16⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度从 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm256_mask_ternarylogic_epi32⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 32 位整数中的每一位，使用 src、a 和 b 中的相应位形成 imm8 的 3 位索引，并使用 writemask 将 imm8 中该位的值写入 dst 中的相应位 k 在 32 位粒度 (当相应的掩码位未设置时，从 src 复制 32 位元素)。 |
| _mm256_mask_ternarylogic_epi64⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，src、a 和 b 中的相应位用于形成 imm8 的 3 位索引，并使用 writemask 将 imm8 中该位的值写入 dst 中的相应位 k 在 64 位粒度 (当相应的掩码位未设置时，从 src 复制 64 位元素)。 |
| _mm256_mask_test_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位与，生成中间 8 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm256_mask_test_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位与，生成中间的 16 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm256_mask_test_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位与，生成中间的 32 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm256_mask_test_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，生成中间 64 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm256_mask_testn_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位 NAND，生成中间的 8 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm256_mask_testn_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位 NAND，生成中间的 16 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm256_mask_testn_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 NAND，生成中间的 32 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm256_mask_testn_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 NAND，生成中间 64 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm256_mask_unpackhi_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_unpackhi_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_unpackhi_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_unpackhi_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_unpackhi_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm256_mask_unpackhi_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm256_mask_unpacklo_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_unpacklo_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_unpacklo_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm256_mask_unpacklo_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_unpacklo_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包并交织双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm256_mask_unpacklo_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包并交织单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm256_mask_xor_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 XOR，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_mask_xor_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 XOR，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm256_maskz_abs_epi8⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 8 位整数的绝对值，并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_abs_epi16⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 16 位整数的绝对值，并使用零掩码 k (将未设置相应掩码位的元素清零) 将无符号结果存储在 dst 中。 |
| _mm256_maskz_abs_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的有符号 32 位整数的绝对值，并使用 zeromask k 将无符号结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_abs_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的带符号的 64 位整数的绝对值，并使用零掩码 k (将未设置相应掩码位的元素清零) 将无符号结果存储在 dst 中。 |
| _mm256_maskz_add_epi8⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中添加包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_add_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数添加到 a 和 b 中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_add_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数添加到 a 和 b 中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_add_epi64⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_add_pd⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_add_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_adds_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_adds_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_adds_epu8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_adds_epu16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_alignr_epi8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的 16 字节块对连接成一个 32 字节的临时结果，将结果右移 imm8 字节，并使用零掩码 k 将低 16 字节存储在 dst 中 (当未使用相应的掩码位时元素清零) 放)。 |
| _mm256_maskz_alignr_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成一个 64 字节的 immediate 结果，将结果右移 imm8 个 32 位元素，并使用 zeromask k 将低 32 字节 (8 个元素) 存储在 dst 中 (当相应的掩码位不存在时，元素被清零放)。 |
| _mm256_maskz_alignr_epi64⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 64 字节的 immediate 结果，将结果右移 imm8 个 64 位元素，并使用 zeromask k 将低 32 字节 (4 个元素) 存储在 dst 中 (当相应的掩码位不存在时，元素被清零放)。 |
| _mm256_maskz_and_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位与，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_and_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_andnot_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 32 位整数的按位 NOT，然后计算 b 中的 AND，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_andnot_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 64 位整数的按位 NOT，然后与 b 计算 AND，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_avg_epu8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 8 位整数进行平均，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_avg_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数进行平均，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_broadcast_f32x4⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_broadcast_i32x4⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将 4 的包装的 32 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_broadcastb_epi8⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将低包装的 8 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_broadcastd_epi32⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_broadcastq_epi64⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_broadcastsd_pd⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_broadcastss_ps⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_broadcastw_epi16⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_compress_epi8⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 8 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst，并将其余元素设置为零。 |
| _mm256_maskz_compress_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 16 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst，并将其余元素设置为零。 |
| _mm256_maskz_compress_epi32⚠ | Experimentalavx512f,avx512vl将活动的 32 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst，并将其余元素设置为零。 |
| _mm256_maskz_compress_epi64⚠ | Experimentalavx512f,avx512vl将活动的 64 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst，并将其余元素设置为零。 |
| _mm256_maskz_compress_pd⚠ | Experimentalavx512f,avx512vl将活动的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst，并将其余元素设置为零。 |
| _mm256_maskz_compress_ps⚠ | Experimentalavx512f,avx512vl将活动的单精度 (32-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst，并将其余元素设置为零。 |
| _mm256_maskz_conflict_epi32⚠ | Experimentalavx512cd,avx512vl使用零掩码 k (在未设置相应的掩码位时将元素清零)，测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm256_maskz_conflict_epi64⚠ | Experimentalavx512cd,avx512vl使用零掩码 k (在未设置相应的掩码位时将元素清零)，测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm256_maskz_cvt_roundps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtepi8_epi16⚠ | Experimentalavx512bw,avx512vl使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtepi8_epi32⚠ | Experimentalavx512f,avx512vl使用符号将包装的 8 位整数从 a 扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi8_epi64⚠ | Experimentalavx512f,avx512vl将 a 的低 4 字节中的 8 位整数符号扩展为包装的 64 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_cvtepi16_epi8⚠ | Experimentalavx512bw,avx512vl将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi16_epi32⚠ | Experimentalavx512f,avx512vl符号将包装的 16 位整数从 a 扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtepi16_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi32_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi32_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi32_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtepi32_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用零掩码 k (未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm256_maskz_cvtepi64_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带截断的 8 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi64_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带截断的 16 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtepu8_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_cvtepu8_epi32⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数 a 的低 8 字节到包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_cvtepu8_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数在 a 的低 4 字节到包装的 64 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_cvtepu16_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_cvtepu16_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 16 位整数 a 的低 8 字节到包装的 64 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_cvtepu32_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_cvtepu32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512vl将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在单个 vector dst 中 (当对应的掩码位不存在时，元素归零放)。 |
| _mm256_maskz_cvtneps_pbh⚠ | Experimentalavx512bf16,avx512vl将包装的单精度 (32-bit) 浮点元素在 a 中转换为包装的 BF16 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_cvtpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtpd_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtph_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvtps_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvtsepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_cvtsepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_cvtsepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并将结果存储在 dst 中。 |
| _mm256_maskz_cvtsepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 64 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtsepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtsepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvttpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm256_maskz_cvttpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_cvttps_epi32⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_cvttps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_cvtusepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtusepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtusepi32_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtusepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_cvtusepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_cvtusepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_dbsad_epu8⚠ | Experimentalavx512bw,avx512vl计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs) 的总和，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将 16 位结果存储在 dst 中。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm256_maskz_div_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_div_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_dpbf16_ps⚠ | Experimentalavx512bf16,avx512vl计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间单精度 (32-bit) 浮点元素与 src 中的元素进行累加，并将结果存储在 dst 中使用 zeromask k (当对应的掩码为位未设置)。 |
| _mm256_maskz_dpbusd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果使用 zeromask k 存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_dpbusds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数用带符号饱和求和，并将包装的 32 位结果用 zeromask k 存储在 dst 中 (当对应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_dpwssd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加，并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_dpwssds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_expand_epi8⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_expand_epi16⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_expand_epi32⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的有效 32 位整数 (它们各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_expand_epi64⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的有效 64 位整数 (它们各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_expand_pd⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_expand_ps⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_extractf32x4_ps⚠ | Experimentalavx512f,avx512vl从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并用 imm8 进行选择，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_extracti32x4_epi32⚠ | Experimentalavx512f,avx512vl从 a 中提取 128 位 (由 4 个包装的 32 位整数组成)，用 IMM1 选择，结果用 zeromask k 存储在 dst 中 (当相应的掩码位未设置时，元素归零)。 |
| _mm256_maskz_fixupimm_pd⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm256_maskz_fixupimm_ps⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm256_maskz_fmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_fmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_fmaddsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_fmaddsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_fmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_fmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_fmsubadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_fmsubadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，或者将 C from/to 中的包装元素相减并相加，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_fnmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_fnmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_fnmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_fnmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_getexp_pd⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm256_maskz_getexp_ps⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm256_maskz_getmant_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm256_maskz_getmant_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm256_maskz_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm256_maskz_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm256_maskz_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm256_maskz_insertf32x4⚠ | Experimentalavx512f,avx512vl将 a 复制到 tmp，然后在 x00X 指定的位置将 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时，元素会被清零)。 |
| _mm256_maskz_inserti32x4⚠ | Experimentalavx512f,avx512vl将 a 复制到 tmp，然后在 imm8 指定的位置，将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时，元素会被清零)。 |
| _mm256_maskz_lzcnt_epi32⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 32 位整数中前导零位的数目，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_lzcnt_epi64⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 64 位整数中前导零位的数目，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_madd_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对，并使用 zeromask k 将结果打包到 dst (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_maddubs_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘，生成中间有符号的 16 位整数。水平添加相邻的中间有符号 16 位整数对，并使用 zeromask k 将饱和结果打包到 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_max_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_max_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_max_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm256_maskz_min_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_min_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm256_maskz_mov_epi8⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_mov_epi16⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_mov_epi32⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的 32 位整数从 a 移至 dst (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_mov_epi64⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的 64 位整数从 a 移到 dst (未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_mov_pd⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移到 dst (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_mov_ps⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移到 dst (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_movedup_pd⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_movehdup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_moveldup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_mul_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低位有符号 32 位整数相乘，并使用零掩码 k 将有符号的 64 位结果存储在 dst 中 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_mul_epu32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并使用零掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_mul_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_mul_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_mulhi_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的带符号的 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_mulhi_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_mulhrs_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，通过加 1 舍入，并使用 zeromask k 将位 [16:1] 存储到 dst (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_mullo_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_mullo_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将中间整数的低 32 位存储在 dst 中。 |
| _mm256_maskz_multishift_epi64_epi8⚠ | Experimentalavx512vbmi,avx512vl对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并使用 zeromask k (元素当相应的屏蔽位未设置时被清零)。 |
| _mm256_maskz_or_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位或，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_or_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位或，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_packs_epi16⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_packs_epi32⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_packus_epi16⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_packus_epi32⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_permute_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permute_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutevar_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 中的双精度 (64-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutevar_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 的单精度 (32-bit) 浮点元素打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 64 位整数进行混洗，并使用 zeromask k (未设置相应的 mask 位时将元素清零) 将结果存储在 dst 中。 |
| _mm256_maskz_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的通道 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_permutex_epi64⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 256 位通道内将 64 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutex_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 256 位通道内将双精度 (64-bit) 浮点元素打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_permutexvar_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应索引在跨通道的 a 中打乱 8 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_permutexvar_epi16⚠ | Experimentalavx512bw,avx512vl使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutexvar_epi32⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中对 32 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutexvar_epi64⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中对 64 位整数进行打乱，并使用零掩码 k (未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm256_maskz_permutexvar_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中对双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_permutexvar_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中对单精度 (32-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_popcnt_epi8⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_maskz_popcnt_epi16⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_maskz_popcnt_epi32⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_maskz_popcnt_epi64⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm256_maskz_rcp14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_maskz_rcp14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_maskz_rol_epi32⚠ | Experimentalavx512f,avx512vl将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_rol_epi64⚠ | Experimentalavx512f,avx512vl将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_rolv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_rolv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_ror_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_ror_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm256_maskz_rorv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_rorv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm256_maskz_roundscale_pd⚠ | Experimentalavx512f,avx512vl将 x 中的包装双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_roundscale_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_rsqrt14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中的包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_maskz_rsqrt14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm256_maskz_scalef_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_scalef_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_set1_epi8⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_set1_epi16⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_set1_epi32⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_set1_epi64⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm256_maskz_shldi_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shldi_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shldi_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shldv_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shldv_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shldv_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shrdi_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shrdi_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shrdi_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shrdv_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shrdv_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shrdv_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shuffle_epi8⚠ | Experimentalavx512bw,avx512vl根据 b 的相应 8 位元素中的打乱控制掩码对 a 中的包装 8 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_shuffle_epi32⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道中的 32 位整数中混洗 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_shuffle_f32x4⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_shuffle_f64x2⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_shuffle_i32x4⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_shuffle_i64x2⚠ | Experimentalavx512f,avx512vl将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_shuffle_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件对 128 位通道内的双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_shuffle_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_shufflehi_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，将 128 位通道的低 64 位从 a 复制到 dst，使用 zeromask k (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_shufflelo_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，并使用写掩码 k 将 128 位通道的高 64 位从 a 复制到 dst (当未使用相应的掩码位时，元素从 src 复制) 放)。 |
| _mm256_maskz_sll_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数左移，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sll_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移计数，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sll_epi64⚠ | Experimentalavx512f,avx512vl将填充的 64 位整数左移计数，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_slli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_slli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_slli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sllv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数左移由 count 中的相应元素指定的数量，同时移入零，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sllv_epi32⚠ | Experimentalavx512f,avx512vl在将移位的 32 位整数左移零时，将其对应计数指定的数量左移，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sllv_epi64⚠ | Experimentalavx512f,avx512vl在将移位的 64 位整数左移零时，将其对应计数指定的数量左移，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sqrt_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用零掩码 k (将结果置零，当未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm256_maskz_sqrt_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sra_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数右移，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sra_epi32⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sra_epi64⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srai_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srai_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_srai_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srav_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移由 count 中的相应元素指定的数量，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srav_epi32⚠ | Experimentalavx512f,avx512vl在将符号位移位的同时，将已包装的 32 位整数向右移动计数中相应元素指定的数量，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srav_epi64⚠ | Experimentalavx512f,avx512vl在移入符号位的同时，将包装的 64 位整数右移由 count 中相应元素指定的数量，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srl_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srl_epi32⚠ | Experimentalavx512f,avx512vl将移位的 32 位整数右移，同时移零，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srl_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移计数，同时移入零，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm256_maskz_srli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srlv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srlv_epi32⚠ | Experimentalavx512f,avx512vl向右移动已包装的 32 位整数，偏移量为相应元素在计数中指定的数量，同时向零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_srlv_epi64⚠ | Experimentalavx512f,avx512vl向右移位包装的 64 位整数，其数量为计数中相应元素指定的数量，同时移位为零，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_sub_epi8⚠ | Experimentalavx512bw,avx512vl从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_sub_epi16⚠ | Experimentalavx512bw,avx512vl从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_sub_epi32⚠ | Experimentalavx512f,avx512vl从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_sub_epi64⚠ | Experimentalavx512f,avx512vl从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sub_pd⚠ | Experimentalavx512f,avx512vl从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_sub_ps⚠ | Experimentalavx512f,avx512vl将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_subs_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度从包装的 8 位整数中减去 b 中的包装有符号的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_subs_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_subs_epu8⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度从 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_subs_epu16⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_ternarylogic_epi32⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 32 位整数中的每一位，来自 a、b 和 c 的相应位用于形成 imm8 的 3 位索引，并使用零掩码将 imm8 中该位的值写入 dst 中的相应位 k 在 32 位粒度 (当未设置相应的掩码位时，32 位元素被清零)。 |
| _mm256_maskz_ternarylogic_epi64⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，来自 a、b 和 c 的相应位用于在 imm8 中形成 3 位索引，并使用零掩码将 imm8 中该位的值写入 dst 中的相应位 k 在 64 位粒度 (当未设置相应的掩码位时，64 位元素将被清零)。 |
| _mm256_maskz_unpackhi_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpackhi_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpackhi_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpackhi_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpackhi_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_unpackhi_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_unpacklo_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpacklo_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_unpacklo_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpacklo_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm256_maskz_unpacklo_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_unpacklo_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm256_maskz_xor_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 XOR，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_maskz_xor_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 XOR，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm256_max_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并将包装的最大值存储在 dst 中。 |
| _mm256_max_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并将包装的最大值存储在 dst 中。 |
| _mm256_min_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并将包装的最小值存储在 dst 中。 |
| _mm256_min_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并将包装的最小值存储在 dst 中。 |
| _mm256_movepi8_mask⚠ | Experimentalavx512bw,avx512vl根据 a 中相应包装的 8 位整数的最高有效位设置掩码寄存器 k 的每个位。 |
| _mm256_movepi16_mask⚠ | Experimentalavx512bw,avx512vl根据 a 中相应的包装的 16 位整数的最高有效位设置掩码寄存器 k 的每一位。 |
| _mm256_movm_epi8⚠ | Experimentalavx512bw,avx512vl根据 k 中相应位的值，将 dst 中每个包装的 8 位整数设置为全 1 或全 0。 |
| _mm256_movm_epi16⚠ | Experimentalavx512bw,avx512vl根据 k 中相应位的值，将 dst 中每个包装的 16 位整数设置为全 1 或全 0。 |
| _mm256_multishift_epi64_epi8⚠ | Experimentalavx512vbmi,avx512vl对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并将 8 个组装字节存储到 dst 的相应 64 位元素。 |
| _mm256_or_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位或，并将结果存储在 dst 中。 |
| _mm256_or_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位或，并将结果存储在 dst 中。 |
| _mm256_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨通道打乱，并将结果存储在 dst 中。 |
| _mm256_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm256_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 32 位整数，并将结果存储在 dst 中。 |
| _mm256_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm256_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm256_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm256_permutex_epi64⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 256 位通道中的 a 内随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm256_permutex_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 256 位通道内对双精度 (64-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm256_permutexvar_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应索引将 a 中的 8 位整数打乱到通道中，并将结果存储在 dst 中。 |
| _mm256_permutexvar_epi16⚠ | Experimentalavx512bw,avx512vl使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm256_permutexvar_epi32⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中随机排列 32 位整数，并将结果存储在 dst 中。 |
| _mm256_permutexvar_epi64⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm256_permutexvar_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引在跨通道中对双精度 (64-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm256_permutexvar_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应索引对跨通道中的单精度 (32-bit) 浮点元素进行打乱。 |
| _mm256_popcnt_epi8⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_popcnt_epi16⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_popcnt_epi32⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm256_popcnt_epi64⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm256_rcp14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm256_rcp14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm256_rol_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_rol_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_rolv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_rolv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_ror_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并将结果存储在 dst 中。 |
| _mm256_ror_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_rorv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_rorv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm256_roundscale_pd⚠ | Experimentalavx512f,avx512vl将 x 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并将结果存储在 dst 中。 |
| _mm256_roundscale_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，然后将结果存储在 dst 中。 |
| _mm256_scalef_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm256_scalef_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm256_shldi_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并将高 16 位存储在 dst 中)。 |
| _mm256_shldi_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并将高 32 位存储在 dst 中。 |
| _mm256_shldi_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并将高 64 位存储在 dst 中)。 |
| _mm256_shldv_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的对应元素中指定的量，并将高 16 位存储在 dst 中。 |
| _mm256_shldv_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的对应元素中指定的量，并将高 32 位存储在 dst 中。 |
| _mm256_shldv_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的对应元素中指定的量，并将高 64 位存储在 dst 中。 |
| _mm256_shrdi_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并将低 16 位存储在 dst 中。 |
| _mm256_shrdi_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并将低 32 位存储在 dst 中。 |
| _mm256_shrdi_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并将低 64 位存储在 dst 中。 |
| _mm256_shrdv_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的对应元素中指定的量，并将低 16 位存储在 dst 中。 |
| _mm256_shrdv_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的对应元素中指定的量，并将低 32 位存储在 dst 中。 |
| _mm256_shrdv_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的对应元素中指定的量，并将低 64 位存储在 dst 中。 |
| _mm256_shuffle_f32x4⚠ | Experimentalavx512f,avx512vlimm8 从 a 和 b 中随机选择 128 位 (由 4 个单精度 (32-bit) 浮点元素组成)，并将结果存储在 dst 中。 |
| _mm256_shuffle_f64x2⚠ | Experimentalavx512f,avx512vl随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成)，并将结果存储在 dst 中。 |
| _mm256_shuffle_i32x4⚠ | Experimentalavx512f,avx512vl随机排列 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成)，并将结果存储在 dst 中。 |
| _mm256_shuffle_i64x2⚠ | Experimentalavx512f,avx512vl随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成)，并将结果存储在 dst 中。 |
| _mm256_sllv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按 count 中相应元素指定的数量向左移位，同时将零移位，并将结果存储在 dst 中。 |
| _mm256_sra_epi64⚠ | Experimentalavx512f,avx512vl在移动符号位的同时按计数右移包装的 64 位整数，并将结果存储在 dst 中。 |
| _mm256_srai_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将符号位移位，并将结果存储在 dst 中。 |
| _mm256_srav_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 count 中相应元素指定的数量，同时移入符号位，然后将结果存储在 dst 中。 |
| _mm256_srav_epi64⚠ | Experimentalavx512f,avx512vl将移位的 64 位整数向右移动计数中相应元素指定的数量，同时移入符号位，并将结果存储在 dst 中。 |
| _mm256_srlv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并将结果存储在 dst 中。 |
| _mm256_store_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的 256 位 (由 8 个包装的 32 位整数组成) 存储到内存中。mem_addr 必须在 32 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm256_store_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的 256 位 (由 4 个包装的 64 位整数组成) 存储到内存中。mem_addr 必须在 32 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm256_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的 256 位 (由 32 个包装的 8 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_storeu_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的 256 位 (由 16 个包装的 16 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_storeu_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的 256 位 (由 8 个包装的 32 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_storeu_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的 256 位 (由 4 个包装的 64 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm256_ternarylogic_epi32⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每个位，来自 a，b 和 c 的相应位用于形成到 imm8 的 3 位索引，并且将 imm8 中该位的值写入 dst 中的相应位。 |
| _mm256_ternarylogic_epi64⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，a、b 和 c 中的相应位用于形成 imm8 中的 3 位索引，并将 imm8 中该位的值写入 dst 中的相应位。 |
| _mm256_test_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位与，生成中间 8 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_test_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位与，生成中间的 16 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_test_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位与，生成中间的 32 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_test_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，生成中间 64 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_testn_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位 NAND，生成中间的 8 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_testn_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位 NAND，生成中间的 16 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_testn_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 NAND，生成中间的 32 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_testn_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 NAND，生成中间的 64 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm256_xor_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 XOR，并将结果存储在 dst 中。 |
| _mm256_xor_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 XOR，并将结果存储在 dst 中。 |
| _mm512_abs_epi8⚠ | Experimentalavx512bw计算 a 中包装的带符号的 8 位整数的绝对值，并将无符号的结果存储在 dst 中。 |
| _mm512_abs_epi16⚠ | Experimentalavx512bw计算 a 中包装的带符号的 16 位整数的绝对值，并将无符号的结果存储在 dst 中。 |
| _mm512_abs_epi32⚠ | Experimentalavx512f计算 |
| _mm512_abs_epi64⚠ | Experimentalavx512f计算 a 中包装的带符号的 64 位整数的绝对值，并将无符号的结果存储在 dst 中。 |
| _mm512_abs_pd⚠ | Experimentalavx512f查找 v2 中每个包装的双精度 (64-bit) 浮点元素的绝对值，并将结果存储在 dst 中。 |
| _mm512_abs_ps⚠ | Experimentalavx512f查找 v2 中每个包装的单精度 (32-bit) 浮点元素的绝对值，并将结果存储在 dst 中。 |
| _mm512_add_epi8⚠ | Experimentalavx512bw将包装的 8 位整数添加到 a 和 b 中，并将结果存储在 dst 中。 |
| _mm512_add_epi16⚠ | Experimentalavx512bw将包装的 16 位整数添加到 a 和 b 中，并将结果存储在 dst 中。 |
| _mm512_add_epi32⚠ | Experimentalavx512f在 a 和 b 中添加包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_add_epi64⚠ | Experimentalavx512f在 a 和 b 中添加包装的 64 位整数，并将结果存储在 dst 中。 |
| _mm512_add_pd⚠ | Experimentalavx512f在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_add_ps⚠ | Experimentalavx512f在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_add_round_pd⚠ | Experimentalavx512f在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_add_round_ps⚠ | Experimentalavx512f在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_adds_epi8⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_adds_epi16⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_adds_epu8⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm512_adds_epu16⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm512_aesdec_epi128⚠ | Experimentalavx512vaes,avx512f使用 |
| _mm512_aesdeclast_epi128⚠ | Experimentalavx512vaes,avx512f使用 |
| _mm512_aesenc_epi128⚠ | Experimentalavx512vaes,avx512f使用 |
| _mm512_aesenclast_epi128⚠ | Experimentalavx512vaes,avx512f使用 |
| _mm512_alignr_epi8⚠ | Experimentalavx512bw将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果，将结果右移 imm8 字节，并将低 16 字节存储在 dst 中。 |
| _mm512_alignr_epi32⚠ | Experimentalavx512f将 a 和 b 连接成一个 128 字节的立即结果，将结果右移 imm8 32 位元素，并将低 64 字节 (16 个元素) 存储在 dst 中。 |
| _mm512_alignr_epi64⚠ | Experimentalavx512f将 a 和 b 连接成一个 128 字节的立即结果，将结果右移 imm8 64 位元素，并将低 64 字节 (8 个元素) 存储在 dst 中。 |
| _mm512_and_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位与，并将结果存储在 dst 中。 |
| _mm512_and_epi64⚠ | Experimentalavx512f计算 a 和 b 中 512 位 (由包装的 64 位整数组成) 的按位与，并将结果存储在 dst 中。 |
| _mm512_and_si512⚠ | Experimentalavx512f计算 a 和 b 中 512 位 (代表整数数据) 的按位与，并将结果存储在 dst 中。 |
| _mm512_andnot_epi32⚠ | Experimentalavx512f计算 a 中包装的 32 位整数的按位 NOT，然后与 b 计算 AND，并将结果存储在 dst 中。 |
| _mm512_andnot_epi64⚠ | Experimentalavx512f计算 a 中的 512 位 (由包装的 64 位整数组成) 的按位非，然后与 b 计算 AND，并将结果存储在 dst 中。 |
| _mm512_andnot_si512⚠ | Experimentalavx512f计算 a 中的 512 位 (代表整数数据) 的按位非，然后与 b 计算 AND，并将结果存储在 dst 中。 |
| _mm512_avg_epu8⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 8 位整数平均，然后将结果存储在 dst 中。 |
| _mm512_avg_epu16⚠ | Experimentalavx512bw将 a 和 b 中的包装无符号 16 位整数进行平均，然后将结果存储在 dst 中。 |
| _mm512_bitshuffle_epi64_mask⚠ | Experimentalavx512bitalg将输入 |
| _mm512_broadcast_f32x4⚠ | Experimentalavx512f从 a 广播 4 个包装的单精度 (32-bit) 浮点元素到 dst 的所有元素。 |
| _mm512_broadcast_f64x4⚠ | Experimentalavx512f从 a 广播 4 个包装的双精度 (64-bit) 浮点元素到 dst 的所有元素。 |
| _mm512_broadcast_i32x4⚠ | Experimentalavx512f将 4 个包装的 32 位整数从 a 广播到 dst 的所有元素。 |
| _mm512_broadcast_i64x4⚠ | Experimentalavx512f将 4 个包装的 64 位整数从 a 广播到 dst 的所有元素。 |
| _mm512_broadcastb_epi8⚠ | Experimentalavx512bw将低包装的 8 位整数从 a 广播到 dst 的所有元素。 |
| _mm512_broadcastd_epi32⚠ | Experimentalavx512f将低包装的 32 位整数从 a 广播到 dst 的所有元素。 |
| _mm512_broadcastmb_epi64⚠ | Experimentalavx512cd将输入掩码 k 的低 8 位广播到 dst 的所有 64 位元素。 |
| _mm512_broadcastmw_epi32⚠ | Experimentalavx512cd将输入掩码 k 的低 16 位广播到 dst 的所有 32 位元素。 |
| _mm512_broadcastq_epi64⚠ | Experimentalavx512f将低包装的 64 位整数从 a 广播到 dst 的所有元素。 |
| _mm512_broadcastsd_pd⚠ | Experimentalavx512f从 a 广播低双精度 (64-bit) 浮点元素到 dst 的所有元素。 |
| _mm512_broadcastss_ps⚠ | Experimentalavx512f将低单精度 (32-bit) 浮点元素从 A 广播到 dst 的所有元素。 |
| _mm512_broadcastw_epi16⚠ | Experimentalavx512bw将低包装的 16 位整数从 a 广播到 dst 的所有元素。 |
| _mm512_bslli_epi128⚠ | Experimentalavx512bw向左移动 128 位通道 imm8 字节，同时向零移动，并将结果存储在 dst 中。 |
| _mm512_bsrli_epi128⚠ | Experimentalavx512bw向右移动 128 位通道 imm8 字节，同时向零移动，并将结果存储在 dst 中。 |
| _mm512_castpd128_pd512⚠ | Experimentalavx512f将类型 __m128d 的 vector 强制转换为 __m512d 类型; 结果的高 384 位未定义。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castpd256_pd512⚠ | Experimentalavx512f将类型 __m256d 的 vector 强制转换为 __m512d 类型; 结果的高 256 位未定义。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castpd512_pd128⚠ | Experimentalavx512f将类型为 __m512d 的 vector 强制转换为类型为 __m128d 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castpd512_pd256⚠ | Experimentalavx512f将类型为 __m512d 的 vector 强制转换为类型为 __m256d 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castpd_ps⚠ | Experimentalavx512f将类型为 __m512d 的 vector 强制转换为类型 __m512。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castpd_si512⚠ | Experimentalavx512f将类型为 __m512d 的 vector 强制转换为类型为 __m512i 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castps128_ps512⚠ | Experimentalavx512f将类型 __m128 的 vector 转换为 __m512 类型; 结果的高 384 位未定义。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castps256_ps512⚠ | Experimentalavx512f将类型为 __m256 的 vector 强制转换为类型 __m512; 结果的高 256 位未定义。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castps512_ps128⚠ | Experimentalavx512f将类型为 __m512 的 vector 强制转换为类型为 __m128 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castps512_ps256⚠ | Experimentalavx512f将类型为 __m512 的 vector 强制转换为类型 __m256。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castps_pd⚠ | Experimentalavx512f将类型为 __m512 的 vector 强制转换为类型为 __m512d 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castps_si512⚠ | Experimentalavx512f将类型为 __m512 的 vector 强制转换为类型 __m512i。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castsi128_si512⚠ | Experimentalavx512f将类型为 __m128i 的 vector 强制转换为类型 __m512i; 结果的高 384 位未定义。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castsi256_si512⚠ | Experimentalavx512f将类型为 __m256i 的 vector 强制转换为类型 __m512i; 结果的高 256 位未定义。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castsi512_pd⚠ | Experimentalavx512f将类型为 __m512i 的 vector 强制转换为类型为 __m512d 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castsi512_ps⚠ | Experimentalavx512f将类型为 __m512i 的 vector 强制转换为类型 __m512。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castsi512_si128⚠ | Experimentalavx512f将类型为 __m512i 的 vector 强制转换为类型为 __m128i 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_castsi512_si256⚠ | Experimentalavx512f将类型为 __m512i 的 vector 强制转换为类型为 __m256i 的 vector。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_clmulepi64_epi128⚠ | Experimentalavx512vpclmulqdq,avx512f在 4 个 128 位通道中的每一个中，在有限域 GF(2^k) 上执行两个 64 位多项式的无进位乘法。 |
| _mm512_cmp_epi8_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中的包装带符号 8 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_epi16_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_epi32_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装有符号 32 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_epi64_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_epu8_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_epu16_mask⚠ | Experimentalavx512bw根据 |
| _mm512_cmp_epu32_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_epu64_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 64 位整数，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_pd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_ps_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_round_pd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm512_cmp_round_ps_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的 32 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的 64 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpeq_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号 16 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号 32 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpge_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号 16 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpgt_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数以得出小于或等于的结果，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmple_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数小于零，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数小于零，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数以得到小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装后的无符号 16 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装后的双精度 (64-bit) 浮点元素的小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmplt_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素的小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号 16 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的 32 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpneq_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpnle_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否等于或小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpnle_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否等于或小于等于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpnlt_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素不小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpnlt_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素不小于，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpord_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，看是否都不是 NaN，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpord_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，看是否都不是 NaN，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpunord_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，以查看其中一个是否为 NaN，并将结果存储在掩码 vector k 中。 |
| _mm512_cmpunord_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，以查看是否为 NaN，并将结果存储在掩码 vector k 中。 |
| _mm512_conflict_epi32⚠ | Experimentalavx512cd测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm512_conflict_epi64⚠ | Experimentalavx512cd测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm512_cvt_roundepi32_ps⚠ | Experimentalavx512f将包装后的带符号的 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvt_roundepu32_ps⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvt_roundpd_epi32⚠ | Experimentalavx512f将包装的双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvt_roundpd_epu32⚠ | Experimentalavx512f将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvt_roundpd_ps⚠ | Experimentalavx512f将包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvt_roundph_ps⚠ | Experimentalavx512f将包装的半精度 (16-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvt_roundps_epi32⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvt_roundps_epu32⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvt_roundps_pd⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvt_roundps_ph⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtepi8_epi16⚠ | Experimentalavx512bw使用符号将包装的 8 位整数从 a 扩展到包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi8_epi32⚠ | Experimentalavx512f使用符号将包装的 8 位整数从 a 扩展到包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi8_epi64⚠ | Experimentalavx512f符号将 a 的低 8 个字节中的包装 8 位整数扩展为包装 64 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi16_epi8⚠ | Experimentalavx512bw将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi16_epi32⚠ | Experimentalavx512f符号将包装的 16 位整数从 a 扩展为包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi16_epi64⚠ | Experimentalavx512f使用符号将包装的 16 位整数从 a 扩展到包装的 64 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi32_epi8⚠ | Experimentalavx512f将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi32_epi16⚠ | Experimentalavx512f将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi32_epi64⚠ | Experimentalavx512f使用符号将包装的 32 位整数从 a 扩展到包装的 64 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi32_pd⚠ | Experimentalavx512f将包装后的带符号的 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtepi32_ps⚠ | Experimentalavx512f将包装后的带符号的 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtepi32lo_pd⚠ | Experimentalavx512f将 v2 中包装的 32 位整数整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素，将元素进行逐元素转换，并将结果存储在 dst 中。 |
| _mm512_cvtepi64_epi8⚠ | Experimentalavx512f将带有 a 的包装的 64 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi64_epi16⚠ | Experimentalavx512f将带有 a 的包装的 64 位整数转换为带有截断的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepi64_epi32⚠ | Experimentalavx512f将带有 a 的包装的 64 位整数转换为带有截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu8_epi16⚠ | Experimentalavx512bw将 a 中的包装无符号 8 位整数零扩展为包装 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu8_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 8 位整数零扩展为包装 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu8_epi64⚠ | Experimentalavx512f将低 8 字节 sof 中的包装无符号 8 位整数零扩展到包装 64 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu16_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu16_epi64⚠ | Experimentalavx512f将 a 中的包装无符号 16 位整数零扩展为包装 64 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu32_epi64⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtepu32_pd⚠ | Experimentalavx512f将 A 中的包装的无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtepu32_ps⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtepu32lo_pd⚠ | Experimentalavx512f将 v2 中包装的 32 位无符号整数整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素，将每个元素进行逐元素转换，并将结果存储在 dst 中。 |
| _mm512_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512f将两个 512 位 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并将结果存入 a |
| _mm512_cvtneps_pbh⚠ | Experimentalavx512bf16,avx512f将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并将结果存储在 dst 中。 Intel’s documentation |
| _mm512_cvtpd_epi32⚠ | Experimentalavx512f将包装的双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtpd_epu32⚠ | Experimentalavx512f将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtpd_ps⚠ | Experimentalavx512f将包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtpd_pslo⚠ | Experimentalavx512f将 v2 中的包装的双精度 (64-bit) 浮点元素执行逐元素转换为单精度 (32-bit) 浮点元素并将其存储在 dst 中。元素存储在结果 vector 的下半部分中，而其余的上半部分位置设置为 0。 |
| _mm512_cvtph_ps⚠ | Experimentalavx512f将包装的半精度 (16-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtps_epi32⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtps_epu32⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtps_pd⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtps_ph⚠ | Experimentalavx512f将包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_cvtpslo_pd⚠ | Experimentalavx512f对 v2 中包装的单精度 (32-bit) 浮点元素的下半部分到包装的双精度 (64-bit) 浮点元素的下半部分进行逐元素转换，并将结果存储在 dst 中。 |
| _mm512_cvtsepi16_epi8⚠ | Experimentalavx512bw将 A 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtsepi32_epi8⚠ | Experimentalavx512f将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtsepi32_epi16⚠ | Experimentalavx512f将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtsepi64_epi8⚠ | Experimentalavx512f将包装的带符号的 64 位整数转换为带符号饱和的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtsepi64_epi16⚠ | Experimentalavx512f将包装的带符号的 64 位整数转换为带符号饱和的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtsepi64_epi32⚠ | Experimentalavx512f将包装的带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtsi512_si32⚠ | Experimentalavx512f将 a 中的低 32 位整数复制到 dst。 |
| _mm512_cvtt_roundpd_epi32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtt_roundpd_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtt_roundps_epi32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtt_roundps_epu32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvttpd_epi32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvttpd_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvttps_epi32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvttps_epu32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtusepi16_epi8⚠ | Experimentalavx512bw将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtusepi32_epi8⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtusepi32_epi16⚠ | Experimentalavx512f将 A 中的包装无符号 32 位整数转换为具有无符号饱和度的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtusepi64_epi8⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtusepi64_epi16⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm512_cvtusepi64_epi32⚠ | Experimentalavx512f将 A 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm512_dbsad_epu8⚠ | Experimentalavx512bw计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs)，并将 16 位结果存储在 dst 中。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm512_div_pd⚠ | Experimentalavx512f将 b 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后将结果存储在 dst 中。 |
| _mm512_div_ps⚠ | Experimentalavx512f将 b 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素，然后将结果存储在 dst 中。 |
| _mm512_div_round_pd⚠ | Experimentalavx512f将 b 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，并将结果存储在 dst 中。 |
| _mm512_div_round_ps⚠ | Experimentalavx512f将 b 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素，然后将结果存储在 dst 中。 |
| _mm512_dpbf16_ps⚠ | Experimentalavx512bf16,avx512f计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间单精度 (32-bit) 浮点元素与 src 中的元素累加，结果存储在 BF16 (16-bit) 浮点对的 dst.Compute 点积中 b、将中间的单精度 (32-bit) 浮点元素与 src 中的元素进行累加，并将结果存入 dst。 |
| _mm512_dpbusd_epi32⚠ | Experimentalavx512vnni将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果存入 dst。 |
| _mm512_dpbusds_epi32⚠ | Experimentalavx512vnni将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。使用有符号饱和将这 4 个结果与 src 中相应的 32 位整数相加，并将包装的 32 位结果存储在 dst 中。 |
| _mm512_dpwssd_epi32⚠ | Experimentalavx512vnni将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果存入 dst。 |
| _mm512_dpwssds_epi32⚠ | Experimentalavx512vnni将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并将包装的 32 位结果存储在 dst 中。 |
| _mm512_extractf32x4_ps⚠ | Experimentalavx512f从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并用 imm8 进行选择，并将结果存储在 dst 中。 |
| _mm512_extractf64x4_pd⚠ | Experimentalavx512f从 a 提取 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成)，并用 imm8 进行选择，并将结果存储在 dst 中。 |
| _mm512_extracti32x4_epi32⚠ | Experimentalavx512f从 a 中提取 128 位 (由 4 个包装的 32 位整数组成)，用 IMM2 选中，结果存入 dst。 |
| _mm512_extracti64x4_epi64⚠ | Experimentalavx512f从 a 中提取 256 位 (由 4 个包装的 64 位整数组成)，用 IMM1 选择，并将结果存储在 dst 中。 |
| _mm512_fixupimm_pd⚠ | Experimentalavx512f使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm512_fixupimm_ps⚠ | Experimentalavx512f使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm512_fixupimm_round_pd⚠ | Experimentalavx512f使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm512_fixupimm_round_ps⚠ | Experimentalavx512f使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm512_fmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并将结果存储在 dst 中。 |
| _mm512_fmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并将结果存储在 dst 中。 |
| _mm512_fmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并将结果存储在 dst 中。 |
| _mm512_fmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并将结果存储在 dst 中。 |
| _mm512_fmaddsub_pd⚠ | Experimentalavx512f在 a 和 b 中乘以包装的双精度 (64-bit) 浮点元素，或者在中间结果中乘以 c to/from 的包装的元素，然后将结果存储在 dst 中。 |
| _mm512_fmaddsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，或者将 c to/from 中的包装的元素相加或相减，得到中间结果，并将结果存储在 dst 中。 |
| _mm512_fmaddsub_round_pd⚠ | Experimentalavx512f在 a 和 b 中乘以包装的双精度 (64-bit) 浮点元素，或者在中间结果中乘以 c to/from 的包装的元素，然后将结果存储在 dst 中。 |
| _mm512_fmaddsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，或者将 c to/from 中的包装的元素相加或相减，得到中间结果，并将结果存储在 dst 中。 |
| _mm512_fmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并将结果存储在 dst 中。 |
| _mm512_fmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并将结果存储在 dst 中。 |
| _mm512_fmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并将结果存储在 dst 中。 |
| _mm512_fmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并将结果存储在 dst 中。 |
| _mm512_fmsubadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 c from/to 中的包装后的元素相减并相加，然后将结果存储在 dst 中。 |
| _mm512_fmsubadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，或者将 c from/to 中的包装的元素相减并相加，得到中间结果，并将结果存储在 dst 中。 |
| _mm512_fmsubadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 c from/to 中的包装后的元素相减并相加，然后将结果存储在 dst 中。 |
| _mm512_fmsubadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，或者将 c from/to 中的包装的元素相减并相加，得到中间结果，并将结果存储在 dst 中。 |
| _mm512_fnmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，然后将结果存储在 dst 中。 |
| _mm512_fnmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，然后将结果存储在 dst 中。 |
| _mm512_fnmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，然后将结果存储在 dst 中。 |
| _mm512_fnmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，然后将结果存储在 dst 中。 |
| _mm512_fnmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装的元素，并将结果存储在 dst 中。 |
| _mm512_fnmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，然后将结果存储在 dst 中。 |
| _mm512_fnmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装的元素，并将结果存储在 dst 中。 |
| _mm512_fnmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，然后将结果存储在 dst 中。 |
| _mm512_getexp_pd⚠ | Experimentalavx512f将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_getexp_ps⚠ | Experimentalavx512f将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_getexp_round_pd⚠ | Experimentalavx512f将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_getexp_round_ps⚠ | Experimentalavx512f将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_getmant_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化，并将结果存储在 dst 中。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_getmant_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素的尾数标准化，并将结果存储在 dst 中。 此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 尾数被标准化为由 interv 指定的间隔，该间隔可以采用以下值: _MM_MANT_NORM_1_2 // interval [1, 2) _MM_MANT_NORM_p5_2 // interval [0.5, 2) _MM_MANT_NORM_p5_1 // interval [0.5, 1) _MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5) The sign is determined by sc which can take the following values: |
| _mm512_getmant_round_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化，并将结果存储在 dst 中。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_getmant_round_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素的尾数标准化，并将结果存储在 dst 中。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm512_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm512_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm512_i32gather_epi32⚠ | Experimentalavx512f使用 32 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i32gather_epi64⚠ | Experimentalavx512f使用 32 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i32gather_pd⚠ | Experimentalavx512f使用 32 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i32gather_ps⚠ | Experimentalavx512f使用 32 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i32scatter_epi32⚠ | Experimentalavx512f使用 32 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i32scatter_epi64⚠ | Experimentalavx512f使用 32 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i32scatter_pd⚠ | Experimentalavx512f使用 32 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i32scatter_ps⚠ | Experimentalavx512f使用 32 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i64gather_epi32⚠ | Experimentalavx512f使用 64 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i64gather_epi64⚠ | Experimentalavx512f使用 64 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i64gather_pd⚠ | Experimentalavx512f使用 64 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i64gather_ps⚠ | Experimentalavx512f使用 64 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。收集的元素将合并到 dst 中。小数位数应为 1、2、4 或 8。 |
| _mm512_i64scatter_epi32⚠ | Experimentalavx512f使用 64 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i64scatter_epi64⚠ | Experimentalavx512f使用 64 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i64scatter_pd⚠ | Experimentalavx512f使用 64 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。小数位数应为 1、2、4 或 8。 |
| _mm512_i64scatter_ps⚠ | Experimentalavx512f使用 64 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)，且受掩码 k 限制 (未设置相应的掩码位时不存储元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_insertf32x4⚠ | Experimentalavx512f将 a 复制到 dst，然后在 x00X 指定的位置将 d 的 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入 dst。 |
| _mm512_insertf64x4⚠ | Experimentalavx512f将 a 复制到 dst，然后在 x00X 指定的位置将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 插入 dst。 |
| _mm512_inserti32x4⚠ | Experimentalavx512f将 a 复制到 dst，然后在 x00X 指定的位置将 d 的 128 位 (由 4 个包装的 32 位整数组成) 插入 dst。 |
| _mm512_inserti64x4⚠ | Experimentalavx512f将 a 复制到 dst，然后在 imm8 指定的位置将 256 位 (由 4 个包装的 64 位整数组成) 插入 dst。 |
| _mm512_int2mask⚠ | Experimentalavx512f将整数掩码转换为位掩码，并将结果存储在 dst 中。 |
| _mm512_kand⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位与，并将结果存储在 k 中。 |
| _mm512_kandn⚠ | Experimentalavx512f计算 16 位掩码 a 的按位非，然后与 b 计算 AND，并将结果存储在 k 中。 |
| _mm512_kmov⚠ | Experimentalavx512f将 16 位掩码 a 复制到 k。 |
| _mm512_knot⚠ | Experimentalavx512f计算 16 位掩码 a 的按位非，并将结果存储在 k 中。 |
| _mm512_kor⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位或，并将结果存储在 k 中。 |
| _mm512_kortestc⚠ | Experimentalavx512f在 k1 和 k2 之间执行按位或运算，将结果存储在 dst 中。如果 dst 全为 1，则设置 CF 标志。 |
| _mm512_kunpackb⚠ | Experimentalavx512f从掩码 a 和 b 解包并交织 8 位，并将 16 位结果存储在 k 中。 |
| _mm512_kxnor⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位 XNOR，并将结果存储在 k 中。 |
| _mm512_kxor⚠ | Experimentalavx512f计算 16 位掩码 a 和 b 的按位 XOR，并将结果存储在 k 中。 |
| _mm512_load_epi32⚠ | Experimentalavx512f将 512 位 (由 16 个包装的 32 位整数组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_load_epi64⚠ | Experimentalavx512f将 512 位 (由 8 个包装的 64 位整数组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_load_pd⚠ | Experimentalavx512f将 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_load_ps⚠ | Experimentalavx512f将 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_load_si512⚠ | Experimentalavx512f将 512 位整数数据从内存加载到 dst 中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_loadu_epi8⚠ | Experimentalavx512bw将 512 位 (由 64 个包装的 8 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_loadu_epi16⚠ | Experimentalavx512bw将 512 位 (由 32 个包装的 16 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_loadu_epi32⚠ | Experimentalavx512f将 512 位 (由 16 个包装的 32 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_loadu_epi64⚠ | Experimentalavx512f将 512 位 (由 8 个包装的 64 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_loadu_pd⚠ | Experimentalavx512f从内存中加载 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 到结果中。 |
| _mm512_loadu_ps⚠ | Experimentalavx512f从内存中将 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 加载到结果中。 |
| _mm512_loadu_si512⚠ | Experimentalavx512f将 512 位整数数据从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_lzcnt_epi32⚠ | Experimentalavx512cd计算 a 中每个包装的 32 位整数中前导零位的数目，并将结果存储在 dst 中。 |
| _mm512_lzcnt_epi64⚠ | Experimentalavx512cd计算 a 中每个包装的 64 位整数中前导零位的数目，并将结果存储在 dst 中。 |
| _mm512_madd52hi_epu64⚠ | Experimentalavx512ifma将 |
| _mm512_madd52lo_epu64⚠ | Experimentalavx512ifma将 |
| _mm512_madd_epi16⚠ | Experimentalavx512bw在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将相邻的 32 位中间整数对水平相加，并将结果打包到 dst 中。 |
| _mm512_maddubs_epi16⚠ | Experimentalavx512bw将 a 中的每个无符号 8 位整数与 b 中对应的有符号 8 位整数垂直相乘，生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对，并将饱和结果包装到 dst 中。 |
| _mm512_mask2_permutex2var_epi8⚠ | Experimentalavx512vbmi使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm512_mask2_permutex2var_epi16⚠ | Experimentalavx512bw使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm512_mask2_permutex2var_epi32⚠ | Experimentalavx512f使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm512_mask2_permutex2var_epi64⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm512_mask2_permutex2var_pd⚠ | Experimentalavx512f使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 idx 复制元素) |
| _mm512_mask2_permutex2var_ps⚠ | Experimentalavx512f使用 idx 中的对应选择器和索引在 a 和 b 中的通道中对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm512_mask2int⚠ | Experimentalavx512f将位掩码 k1 转换为整数值，并将结果存储在 dst 中。 |
| _mm512_mask3_fmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 c 复制元素)。 |
| _mm512_mask3_fmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm512_mask3_fmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 c 复制元素)。 |
| _mm512_mask3_fmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm512_mask3_fmaddsub_pd⚠ | Experimentalavx512f在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm512_mask3_fmaddsub_ps⚠ | Experimentalavx512f在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm512_mask3_fmaddsub_round_pd⚠ | Experimentalavx512f在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm512_mask3_fmaddsub_round_ps⚠ | Experimentalavx512f在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm512_mask3_fmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm512_mask3_fmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm512_mask3_fmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm512_mask3_fmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm512_mask3_fmsubadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm512_mask3_fmsubadd_ps⚠ | Experimentalavx512f在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素，或者在中间结果中减去并在 c from/to 中包装的元素相乘，然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm512_mask3_fmsubadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm512_mask3_fmsubadd_round_ps⚠ | Experimentalavx512f在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素，或者在中间结果中减去并在 c from/to 中包装的元素相乘，然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm512_mask3_fnmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm512_mask3_fnmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 c 复制)。 |
| _mm512_mask3_fnmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm512_mask3_fnmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 c 复制)。 |
| _mm512_mask3_fnmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 c 复制元素)。 |
| _mm512_mask3_fnmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm512_mask3_fnmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 c 复制元素)。 |
| _mm512_mask3_fnmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm512_mask_abs_epi8⚠ | Experimentalavx512bw计算 a 中包装的带符号的 8 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_abs_epi16⚠ | Experimentalavx512bw计算 a 中包装的带符号的 16 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_abs_epi32⚠ | Experimentalavx512f计算 |
| _mm512_mask_abs_epi64⚠ | Experimentalavx512f计算 a 中包装的带符号的 64 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_abs_pd⚠ | Experimentalavx512f查找 v2 中每个包装的双精度 (64-bit) 浮点元素的绝对值，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_abs_ps⚠ | Experimentalavx512f查找 v2 中每个包装的单精度 (32-bit) 浮点元素的绝对值，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_add_epi8⚠ | Experimentalavx512bw在 a 和 b 中添加包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_epi16⚠ | Experimentalavx512bw在 a 和 b 中添加包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_epi32⚠ | Experimentalavx512f在 a 和 b 中添加包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_epi64⚠ | Experimentalavx512f在 a 和 b 中添加包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_pd⚠ | Experimentalavx512f在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_ps⚠ | Experimentalavx512f在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_round_pd⚠ | Experimentalavx512f在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_add_round_ps⚠ | Experimentalavx512f在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_adds_epi8⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_adds_epi16⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_adds_epu8⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_adds_epu16⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_alignr_epi8⚠ | Experimentalavx512bw将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果，将结果右移 imm8 字节，并使用写掩码 k 将低 16 个字节存储在 dst 中 (当相应的掩码位为 1 时，元素从 src 复制没有设置)。 |
| _mm512_mask_alignr_epi32⚠ | Experimentalavx512f将 a 和 b 连接成一个 128 字节的立即结果，将结果右移 imm8 32 位元素，并使用写掩码 k 将低 64 字节 (16 个元素) 存储在 dst 中 (当相应的掩码位为 1 时，元素从 src 复制) 没有设置)。 |
| _mm512_mask_alignr_epi64⚠ | Experimentalavx512f将 a 和 b 连接成一个 128 字节的立即结果，将结果右移 imm8 64 位元素，并使用写掩码 k 将低 64 字节 (8 个元素) 存储在 dst 中 (当相应的掩码位为 1 时，元素从 src 复制) 没有设置)。 |
| _mm512_mask_and_epi32⚠ | Experimentalavx512f在包装的 a 和 b 的 32 位整数元素之间执行逐个元素的按位 AND，使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_and_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位与，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 src 复制元素)。 |
| _mm512_mask_andnot_epi32⚠ | Experimentalavx512f计算 a 中包装的 32 位整数的按位 NOT，然后与 b 计算 AND，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_andnot_epi64⚠ | Experimentalavx512f计算 a 中包装的 64 位整数的按位 NOT，然后与 b 计算 AND，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_avg_epu8⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 8 位整数平均，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_avg_epu16⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 16 位整数进行平均，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_bitshuffle_epi64_mask⚠ | Experimentalavx512bitalg将输入 |
| _mm512_mask_blend_epi8⚠ | Experimentalavx512bw使用控制掩码 k 混合 a 和 b 中的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm512_mask_blend_epi16⚠ | Experimentalavx512bw使用控制掩码 k 混合来自 a 和 b 的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_mask_blend_epi32⚠ | Experimentalavx512f使用控制掩码 k 混合 a 和 b 中的包装 32 位整数，并将结果存储在 dst 中。 |
| _mm512_mask_blend_epi64⚠ | Experimentalavx512f使用控制掩码 k 混合 a 和 b 中的包装 64 位整数，并将结果存储在 dst 中。 |
| _mm512_mask_blend_pd⚠ | Experimentalavx512f使用控制掩码 k 混合来自 a 和 b 的包装后的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_mask_blend_ps⚠ | Experimentalavx512f使用控制掩码 k 混合来自 a 和 b 的包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_mask_broadcast_f32x4⚠ | Experimentalavx512f使用写掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_broadcast_f64x4⚠ | Experimentalavx512f使用写掩码 k 将 4 个包装的双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_broadcast_i32x4⚠ | Experimentalavx512f使用写掩码 k 将 a 的 4 个包装的 32 位整数广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_broadcast_i64x4⚠ | Experimentalavx512f使用写掩码 k 将 a 的 4 个包装的 64 位整数广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_broadcastb_epi8⚠ | Experimentalavx512bw使用写掩码 k 将 d 的低包装的 8 位整数广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_broadcastd_epi32⚠ | Experimentalavx512f使用写掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_broadcastq_epi64⚠ | Experimentalavx512f使用写掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_broadcastsd_pd⚠ | Experimentalavx512f使用写掩码 k 将低双精度 (64-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_broadcastss_ps⚠ | Experimentalavx512f使用写掩码 k 将低单精度 (32-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，将元素从 src 复制)。 |
| _mm512_mask_broadcastw_epi16⚠ | Experimentalavx512bw使用写掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_cmp_epi8_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmp_epi16_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmp_epi32_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 32 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmp_epi64_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmp_epu8_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmp_epu16_mask⚠ | Experimentalavx512bw根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmp_epu32_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmp_epu64_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmp_pd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmp_ps_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmp_round_pd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmp_round_ps_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpeq_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数是否相等，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的 32 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpeq_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的 64 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpeq_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数是否等于或大于等于，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否大于等于，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpge_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数是否大于，并将结果使用零掩码 k1 存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpgt_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数 (小于或等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmple_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数 (小于等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmple_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmple_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数 (小于或等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmplt_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数以得到小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmplt_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素的小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmplt_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpneq_epi8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_mask_cmpneq_epi16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpneq_epi32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的 32 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpneq_epi64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_mask_cmpneq_epu8_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpneq_epu16_mask⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpneq_epu32_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpneq_epu64_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpneq_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpneq_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否相等，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpnle_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否等于或小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpnle_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否等于或小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpnlt_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpnlt_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpord_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，看是否都不是 NaN，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpord_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，看是否都不是 NaN，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_cmpunord_pd_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素以查看是否为 NaN，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_mask_cmpunord_ps_mask⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，看是否为 NaN，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_mask_compress_epi8⚠ | Experimentalavx512vbmi2将 a 中的活动 8 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst，并通过 src 中的其余元素。 |
| _mm512_mask_compress_epi16⚠ | Experimentalavx512vbmi2将 a 中的活动 16 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst，并通过 src 中的其余元素。 |
| _mm512_mask_compress_epi32⚠ | Experimentalavx512f将活动的 32 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst，并通过 src 中的其余元素。 |
| _mm512_mask_compress_epi64⚠ | Experimentalavx512f将活动的 64 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst，并通过 src 中的其余元素。 |
| _mm512_mask_compress_pd⚠ | Experimentalavx512f将活动的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位在写掩码 k 中设置) 到 dst，并通过 src 中的其余元素。 |
| _mm512_mask_compress_ps⚠ | Experimentalavx512f将活动的单精度 (32-bit) 浮点元素连续存储在 dst 中 (将其各自的位设置在写掩码 k 中的那些元素中) 存储到 dst，并通过 src 中的其余元素。 |
| _mm512_mask_conflict_epi32⚠ | Experimentalavx512cd使用写掩码 k (在未设置相应的掩码位时从 src 复制元素)，测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm512_mask_conflict_epi64⚠ | Experimentalavx512cd使用写掩码 k 测试 a 的每个 64 位元素是否与所有其他元素相等 (更接近最低有效位) (当未设置相应的掩码位时，从 src 复制元素)。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm512_mask_cvt_roundepi32_ps⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundepu32_ps⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundpd_epi32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundpd_epu32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundpd_ps⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundph_ps⚠ | Experimentalavx512f将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundps_epi32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundps_epu32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundps_pd⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvt_roundps_ph⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi8_epi16⚠ | Experimentalavx512bw使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi8_epi32⚠ | Experimentalavx512f符号将包装的 8 位整数从 a 扩展为包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi8_epi64⚠ | Experimentalavx512f符号将 a 的低 8 个字节中的包装 8 位整数扩展为包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi16_epi8⚠ | Experimentalavx512bw将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi16_epi32⚠ | Experimentalavx512f符号将包装后的 16 位整数从 a 扩展为包装后的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi16_epi64⚠ | Experimentalavx512f使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi16_storeu_epi8⚠ | Experimentalavx512bw将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtepi32_epi8⚠ | Experimentalavx512f将带有 a 的包装的 32 位整数转换为带截断的包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi32_epi16⚠ | Experimentalavx512f将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi32_epi64⚠ | Experimentalavx512f使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi32_pd⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi32_ps⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi32_storeu_epi8⚠ | Experimentalavx512f将包装的 32 位整数在 a 中转换为带有截断的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtepi32_storeu_epi16⚠ | Experimentalavx512f将 a 中的包装的 32 位整数转换为带截断的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtepi32lo_pd⚠ | Experimentalavx512f将 v2 中包装的 32 位整数整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素，进行逐元素转换，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 位为 src 时，会复制这些元素未设置)。 |
| _mm512_mask_cvtepi64_epi8⚠ | Experimentalavx512f将 a 中的包装的 64 位整数转换为带有截断的包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi64_epi16⚠ | Experimentalavx512f将 a 中的包装的 64 位整数转换为带截断的 16 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi64_epi32⚠ | Experimentalavx512f将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepi64_storeu_epi8⚠ | Experimentalavx512f将 a 中包装的 64 位整数转换为包装的 8 位整数并截断，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。 |
| _mm512_mask_cvtepi64_storeu_epi16⚠ | Experimentalavx512f将 a 中的包装的 64 位整数转换为带截断的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtepi64_storeu_epi32⚠ | Experimentalavx512f将 a 中的包装的 64 位整数转换为带截断的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtepu8_epi16⚠ | Experimentalavx512bw将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu8_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 8 位整数零扩展为包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu8_epi64⚠ | Experimentalavx512f将 a 的低 8 个字节中的包装无符号 8 位整数零扩展为包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu16_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu16_epi64⚠ | Experimentalavx512f将 a 中的包装无符号 16 位整数零扩展为包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu32_epi64⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu32_pd⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu32_ps⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtepu32lo_pd⚠ | Experimentalavx512f将 v2 中 32 位无符号整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中，使用 writemask k (当相应的 mask 位为 src 时，复制这些元素) 未设置)。 |
| _mm512_mask_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512f将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 writemask k 将结果存储在单个 vector dst 中 (当对应的掩码位为没有设置)。 |
| _mm512_mask_cvtneps_pbh⚠ | Experimentalavx512bf16,avx512f将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm512_mask_cvtpd_epi32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtpd_epu32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtpd_ps⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtpd_pslo⚠ | Experimentalavx512f将 v2 中的包装的双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素，将其逐个元素转换，并使用 writemask k 将它们存储在 dst 中 (如果没有相应的 mask 位，则从 src 复制元素放)。元素存储在结果 vector 的下半部分中，而其余的上半部分位置设置为 0。 |
| _mm512_mask_cvtph_ps⚠ | Experimentalavx512f将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtps_epi32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtps_epu32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtps_pd⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtps_ph⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtpslo_pd⚠ | Experimentalavx512f将 v2 中包装的单精度 (32-bit) 浮点元素的下半部分转换为包装的双精度 (64-bit) 浮点元素的下半部分进行逐元素转换，并使用写掩码 k 将结果存储在 dst 中 (当相应的屏蔽位未设置)。 |
| _mm512_mask_cvtsepi16_epi8⚠ | Experimentalavx512bw将 a 中的包装带符号的 16 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtsepi16_storeu_epi8⚠ | Experimentalavx512bw将包装在 a 中的有符号 16 位整数转换为有符号饱和的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtsepi32_epi8⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtsepi32_epi16⚠ | Experimentalavx512f将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtsepi32_storeu_epi8⚠ | Experimentalavx512f将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtsepi32_storeu_epi16⚠ | Experimentalavx512f将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 16 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtsepi64_epi8⚠ | Experimentalavx512f将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtsepi64_epi16⚠ | Experimentalavx512f将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtsepi64_epi32⚠ | Experimentalavx512f将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtsepi64_storeu_epi8⚠ | Experimentalavx512f将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtsepi64_storeu_epi16⚠ | Experimentalavx512f将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtsepi64_storeu_epi32⚠ | Experimentalavx512f将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtt_roundpd_epi32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtt_roundpd_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtt_roundps_epi32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtt_roundps_epu32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvttpd_epi32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvttpd_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvttps_epi32⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvttps_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtusepi16_epi8⚠ | Experimentalavx512bw将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtusepi16_storeu_epi8⚠ | Experimentalavx512bw将包装在 a 中的无符号 16 位整数转换为具有无符号饱和的包装的无符号 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtusepi32_epi8⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_cvtusepi32_epi16⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtusepi32_storeu_epi8⚠ | Experimentalavx512f将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtusepi32_storeu_epi16⚠ | Experimentalavx512f将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtusepi64_epi8⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_cvtusepi64_epi16⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_cvtusepi64_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_cvtusepi64_storeu_epi8⚠ | Experimentalavx512f将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。 |
| _mm512_mask_cvtusepi64_storeu_epi16⚠ | Experimentalavx512f将包装在 a 中的无符号 64 位整数转换为具有无符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_cvtusepi64_storeu_epi32⚠ | Experimentalavx512f将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm512_mask_dbsad_epu8⚠ | Experimentalavx512bw计算 a 中的无符号 8 位整数与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs)，并使用写掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm512_mask_div_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_div_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_div_round_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_div_round_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_dpbf16_ps⚠ | Experimentalavx512bf16,avx512f计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间的单精度 (32-bit) 浮点元素与 src 中的元素相加，并使用 writemask k 将结果存储在 dst 中 (当对应的元素从 src 复制时掩码位未设置)。 |
| _mm512_mask_dpbusd_epi32⚠ | Experimentalavx512vnni将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (未设置相应掩码位时从 src 复制元素)。 |
| _mm512_mask_dpbusds_epi32⚠ | Experimentalavx512vnni将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。使用符号饱和将这 4 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_dpwssd_epi32⚠ | Experimentalavx512vnni将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm512_mask_dpwssds_epi32⚠ | Experimentalavx512vnni将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm512_mask_expand_epi8⚠ | Experimentalavx512vbmi2从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_expand_epi16⚠ | Experimentalavx512vbmi2从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_expand_epi32⚠ | Experimentalavx512f从 a 加载连续的有效 32 位整数 (它们各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_expand_epi64⚠ | Experimentalavx512f从 a 加载连续的有效 64 位整数 (它们各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_expand_pd⚠ | Experimentalavx512f从 a 加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_expand_ps⚠ | Experimentalavx512f从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_extractf32x4_ps⚠ | Experimentalavx512f从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并用 imm8 进行选择，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 src 复制元素)。 |
| _mm512_mask_extractf64x4_pd⚠ | Experimentalavx512f从 a 提取 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成)，并用 imm8 进行选择，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_extracti32x4_epi32⚠ | Experimentalavx512f从 a 中提取 128 位 (由 4 个包装的 32 位整数组成)，用 IMM2 选中，用 writemask k 将结果存入 dst 中 (未设置相应掩码位时从 src 复制元素)。 |
| _mm512_mask_extracti64x4_epi64⚠ | Experimentalavx512f从 a 中提取 256 位 (由 4 个包装的 64 位整数组成)，用 IMM1 选中，用 writemask k 将结果存入 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_fixupimm_pd⚠ | Experimentalavx512f使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm512_mask_fixupimm_ps⚠ | Experimentalavx512f使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm512_mask_fixupimm_round_pd⚠ | Experimentalavx512f使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm512_mask_fixupimm_round_ps⚠ | Experimentalavx512f使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm512_mask_fmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm512_mask_fmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。 |
| _mm512_mask_fmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm512_mask_fmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。 |
| _mm512_mask_fmaddsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 中复制元素放)。 |
| _mm512_mask_fmaddsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。 |
| _mm512_mask_fmaddsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 中复制元素放)。 |
| _mm512_mask_fmaddsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。 |
| _mm512_mask_fmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 a 复制元素)。 |
| _mm512_mask_fmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm512_mask_fmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 a 复制元素)。 |
| _mm512_mask_fmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm512_mask_fmsubadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时，元素将从 a 复制放)。 |
| _mm512_mask_fmsubadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 复制元素放)。 |
| _mm512_mask_fmsubadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时，元素将从 a 复制放)。 |
| _mm512_mask_fmsubadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 复制元素放)。 |
| _mm512_mask_fnmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_fnmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm512_mask_getexp_pd⚠ | Experimentalavx512f将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_mask_getexp_ps⚠ | Experimentalavx512f将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_mask_getexp_round_pd⚠ | Experimentalavx512f将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_mask_getexp_round_ps⚠ | Experimentalavx512f将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_mask_getmant_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_mask_getmant_ps⚠ | Experimentalavx512f标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_mask_getmant_round_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_mask_getmant_round_ps⚠ | Experimentalavx512f标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_mask_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm512_mask_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm512_mask_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm512_mask_i32gather_epi32⚠ | Experimentalavx512f使用 32 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32gather_epi64⚠ | Experimentalavx512f使用 32 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32gather_pd⚠ | Experimentalavx512f使用 32 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32gather_ps⚠ | Experimentalavx512f使用 32 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 32 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32scatter_epi32⚠ | Experimentalavx512f使用 32 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 32 位元素偏移 (每个索引按比例因子缩放) 受掩码 k (当相应掩码位未设置时不存储元素) . 小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32scatter_epi64⚠ | Experimentalavx512f使用 32 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址中，并由 vindex 中的每个 32 位元素偏移 (每个索引按比例因子缩放) 受掩码 k (未设置相应掩码位时不存储元素) . 小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32scatter_pd⚠ | Experimentalavx512f使用 32 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址中，并由 vindex 中的每个 32 位元素偏移 (每个索引按比例因子缩放) 受掩码 k (未设置相应掩码位时不存储元素) . 小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i32scatter_ps⚠ | Experimentalavx512f使用 32 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 32 位元素偏移 (每个索引按比例因子缩放) 受掩码 k (当相应掩码位未设置时不存储元素) . 小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64gather_epi32⚠ | Experimentalavx512f使用 64 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64gather_epi64⚠ | Experimentalavx512f使用 64 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64gather_pd⚠ | Experimentalavx512f使用 64 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64gather_ps⚠ | Experimentalavx512f使用 64 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)。使用 writemask k 将收集到的元素合并到 dst (当相应的掩码位未设置时，从 src 复制元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64scatter_epi32⚠ | Experimentalavx512f使用 64 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)，且受掩码 k 限制 (未设置相应的掩码位时不存储元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64scatter_epi64⚠ | Experimentalavx512f使用 64 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引按比例因子缩放) 受掩码 k (当相应掩码位未设置时不存储元素) . 小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64scatter_pd⚠ | Experimentalavx512f使用 64 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引按比例因子缩放) 受掩码 k (当相应掩码位未设置时不存储元素) . 小数位数应为 1、2、4 或 8。 |
| _mm512_mask_i64scatter_ps⚠ | Experimentalavx512f使用 64 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处，并由 vindex 中的每个 64 位元素偏移 (每个索引均按比例因子进行缩放)，且受掩码 k 限制 (未设置相应的掩码位时不存储元素)。小数位数应为 1、2、4 或 8。 |
| _mm512_mask_insertf32x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 x00X 指定的位置将 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_insertf64x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 x00X 指定的位置将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_inserti32x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 imm8 指定的位置，将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_inserti64x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 imm8 指定的位置将 b 的 256 位 (由 4 个包装的 64 位整数组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_lzcnt_epi32⚠ | Experimentalavx512cd计算 a 中每个包装的 32 位整数中前导零位的数目，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_lzcnt_epi64⚠ | Experimentalavx512cd计算 a 中每个包装的 64 位整数中前导零位的数目，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_madd_epi16⚠ | Experimentalavx512bw在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对，并使用 writemask k 将结果打包到 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_maddubs_epi16⚠ | Experimentalavx512bw将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘，生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对，并使用写掩码 k 将饱和结果包装到 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epi8⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epi16⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epi32⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epi64⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epu8⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epu16⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epu32⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_epu64⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_round_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_max_round_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epi8⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epi16⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号 16 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epi32⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epi64⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epu8⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epu16⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epu32⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_epu64⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_round_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_min_round_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_mov_epi8⚠ | Experimentalavx512bw使用写掩码 k 将包装的 8 位整数从 a 移到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_mov_epi16⚠ | Experimentalavx512bw使用写掩码 k 将包装的 16 位整数从 a 移到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_mov_epi32⚠ | Experimentalavx512f使用写掩码 k 将包装的 32 位整数从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_mov_epi64⚠ | Experimentalavx512f使用写掩码 k 将包装的 64 位整数从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_mov_pd⚠ | Experimentalavx512f使用写掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_mov_ps⚠ | Experimentalavx512f使用写掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm512_mask_movedup_pd⚠ | Experimentalavx512f从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_movehdup_ps⚠ | Experimentalavx512f从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_moveldup_ps⚠ | Experimentalavx512f从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mul_epi32⚠ | Experimentalavx512f将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘，并使用写掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mul_epu32⚠ | Experimentalavx512f将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并使用写掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mul_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_mul_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_mul_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_mul_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_mulhi_epi16⚠ | Experimentalavx512bw将 a 和 b 中包装的带符号的 16 位整数相乘，生成 32 位中间整数，并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mulhi_epu16⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 16 位整数相乘，生成 32 位中间整数，并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mulhrs_epi16⚠ | Experimentalavx512bw在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，通过加 1 舍入，并使用 writemask k 将位 [16:1] 存储到 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_mullo_epi16⚠ | Experimentalavx512bw将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并使用写掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mullo_epi32⚠ | Experimentalavx512f将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并使用写掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_mullox_epi64⚠ | Experimentalavx512f将包装的 64 位整数 vectors a 和 b 中的元素相乘，使用写掩码 k 将结果的低 64 位存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_multishift_epi64_epi8⚠ | Experimentalavx512vbmi对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并使用 writemask k (元素当相应的屏蔽位未设置时，从 src 复制)。 |
| _mm512_mask_or_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位或，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_or_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位或，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_packs_epi16⚠ | Experimentalavx512bw使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_packs_epi32⚠ | Experimentalavx512bw使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_packus_epi16⚠ | Experimentalavx512bw使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_packus_epi32⚠ | Experimentalavx512bw使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_permute_pd⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_permute_ps⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_permutevar_epi32⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对 32 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。请注意，与使用 permutevar 名称的过去内联函数不同，该内联函数在 128 位通道上进行了重排。此内联函数与 _mm512_mask_permutexvar_epi32 相同，建议您使用该内联函数名称。 |
| _mm512_mask_permutevar_pd⚠ | Experimentalavx512f使用 b 中的控件在 128 位通道内将 a 的双精度 (64-bit) 浮点元素进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_permutevar_ps⚠ | Experimentalavx512f使用 b 中的控件在 128 位通道内将 a 的单精度 (32-bit) 浮点元素打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_permutex2var_epi8⚠ | Experimentalavx512vbmi使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm512_mask_permutex2var_epi16⚠ | Experimentalavx512bw使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm512_mask_permutex2var_epi32⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm512_mask_permutex2var_epi64⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm512_mask_permutex2var_pd⚠ | Experimentalavx512f使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm512_mask_permutex2var_ps⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在 a 和 b 中的通道上对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm512_mask_permutex_epi64⚠ | Experimentalavx512f使用 imm8 中的控件在 256 位通道内将 64 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_permutex_pd⚠ | Experimentalavx512f使用 imm8 中的控件在 256 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_permutexvar_epi8⚠ | Experimentalavx512vbmi使用 idx 中的相应索引在跨通道的 a 中打乱 8 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_permutexvar_epi16⚠ | Experimentalavx512bw使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_permutexvar_epi32⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对 32 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_permutexvar_epi64⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中随机排列 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_permutexvar_pd⚠ | Experimentalavx512f使用 idx 中的相应索引对跨通道中的双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_permutexvar_ps⚠ | Experimentalavx512f使用 idx 中的相应索引对跨通道中的单精度 (32-bit) 浮点元素进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_popcnt_epi8⚠ | Experimentalavx512bitalg对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_mask_popcnt_epi16⚠ | Experimentalavx512bitalg对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_mask_popcnt_epi32⚠ | Experimentalavx512vpopcntdq对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_mask_popcnt_epi64⚠ | Experimentalavx512vpopcntdq对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm512_mask_rcp14_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_mask_rcp14_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_mask_reduce_add_epi32⚠ | Experimentalavx512f使用掩码 k 通过加法来减少 a 中包装的 32 位整数。返回 a 中所有活动元素的总和。 |
| _mm512_mask_reduce_add_epi64⚠ | Experimentalavx512f使用掩码 k 通过加法来减少 a 中包装的 64 位整数。返回 a 中所有活动元素的总和。 |
| _mm512_mask_reduce_add_pd⚠ | Experimentalavx512f通过使用掩膜 k 加法来减少包装的双精度 (64-bit) 浮点元素。返回 a 中所有活动元素的总和。 |
| _mm512_mask_reduce_add_ps⚠ | Experimentalavx512f通过使用掩码 k 加法来减少包装的单精度 (32-bit) 浮点元素。返回 a 中所有活动元素的总和。 |
| _mm512_mask_reduce_and_epi32⚠ | Experimentalavx512f使用掩码 k 按位与减少包装的 32 位整数。返回 a 中所有活动元素的按位与。 |
| _mm512_mask_reduce_and_epi64⚠ | Experimentalavx512f使用掩码 k 通过加法来减少 a 中包装的 64 位整数。返回 a 中所有活动元素的总和。 |
| _mm512_mask_reduce_max_epi32⚠ | Experimentalavx512f使用掩码 k 最多减少 a 中的包装有符号 32 位整数。返回 a 中所有活动元素的最大值。 |
| _mm512_mask_reduce_max_epi64⚠ | Experimentalavx512f使用掩码 k 最大减少包装的带符号的 64 位整数。返回 a 中所有活动元素的最大值。 |
| _mm512_mask_reduce_max_epu32⚠ | Experimentalavx512f使用掩码 k 最大减少包装的无符号 32 位整数。返回 a 中所有活动元素的最大值。 |
| _mm512_mask_reduce_max_epu64⚠ | Experimentalavx512f使用掩码 k 最大减少包装的无符号 64 位整数。返回 a 中所有活动元素的最大值。 |
| _mm512_mask_reduce_max_pd⚠ | Experimentalavx512f使用掩码 k 最多减少 a 中包装的双精度 (64-bit) 浮点元素。返回 a 中所有活动元素的最大值。 |
| _mm512_mask_reduce_max_ps⚠ | Experimentalavx512f最多使用掩码 k 减少包装后的单精度 (32-bit) 浮点元素。返回 a 中所有活动元素的最大值。 |
| _mm512_mask_reduce_min_epi32⚠ | Experimentalavx512f使用掩码 k 最多减少 a 中的包装有符号 32 位整数。返回 a 中所有活动元素的最小值。 |
| _mm512_mask_reduce_min_epi64⚠ | Experimentalavx512f使用掩码 k 最大减少包装的带符号的 64 位整数。返回 a 中所有活动元素的最小值。 |
| _mm512_mask_reduce_min_epu32⚠ | Experimentalavx512f使用掩码 k 最大减少包装的无符号 32 位整数。返回 a 中所有活动元素的最小值。 |
| _mm512_mask_reduce_min_epu64⚠ | Experimentalavx512f使用掩码 k 最大减少包装的带符号的 64 位整数。返回 a 中所有活动元素的最小值。 |
| _mm512_mask_reduce_min_pd⚠ | Experimentalavx512f使用掩码 k 最多减少 a 中包装的双精度 (64-bit) 浮点元素。返回 a 中所有活动元素的最小值。 |
| _mm512_mask_reduce_min_ps⚠ | Experimentalavx512f最多使用掩码 k 减少包装后的单精度 (32-bit) 浮点元素。返回 a 中所有活动元素的最小值。 |
| _mm512_mask_reduce_mul_epi32⚠ | Experimentalavx512f使用掩码 k 通过乘以减少 a 中包装的 32 位整数。返回 a 中所有活动元素的乘积。 |
| _mm512_mask_reduce_mul_epi64⚠ | Experimentalavx512f使用掩码 k 通过乘以减少 a 中包装的 64 位整数。返回 a 中所有活动元素的乘积。 |
| _mm512_mask_reduce_mul_pd⚠ | Experimentalavx512f使用掩码 k 通过乘以减少 a 中包装的双精度 (64-bit) 浮点元素。返回 a 中所有活动元素的乘积。 |
| _mm512_mask_reduce_mul_ps⚠ | Experimentalavx512f使用掩码 k 通过乘以减少 a 中包装的单精度 (32-bit) 浮点元素。返回 a 中所有活动元素的乘积。 |
| _mm512_mask_reduce_or_epi32⚠ | Experimentalavx512f使用掩码 k 按位或减少包装的 32 位整数。返回 a 中所有活动元素的按位或。 |
| _mm512_mask_reduce_or_epi64⚠ | Experimentalavx512f使用掩码 k 按位或减少包装的 64 位整数。返回 a 中所有活动元素的按位或。 |
| _mm512_mask_rol_epi32⚠ | Experimentalavx512f将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_rol_epi64⚠ | Experimentalavx512f将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_rolv_epi32⚠ | Experimentalavx512f将 a 中每个包装的 32 位整数中的位向左旋转 b 对应元素 b 中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm512_mask_rolv_epi64⚠ | Experimentalavx512f将 a 中每个包装的 64 位整数中的位向左旋转 b 的对应元素中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm512_mask_ror_epi32⚠ | Experimentalavx512f将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_ror_epi64⚠ | Experimentalavx512f将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_rorv_epi32⚠ | Experimentalavx512f将 a 中每个包装的 32 位整数中的位向右旋转 b 的对应元素中指定的位数，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm512_mask_rorv_epi64⚠ | Experimentalavx512f将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm512_mask_roundscale_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_roundscale_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_roundscale_round_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_roundscale_round_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_rsqrt14_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_mask_rsqrt14_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_mask_scalef_pd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_scalef_ps⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_scalef_round_pd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_scalef_round_ps⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_set1_epi8⚠ | Experimentalavx512bw使用写掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_set1_epi16⚠ | Experimentalavx512bw使用写掩码 k 向 dst 的所有元素广播 16 位整数 a (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_set1_epi32⚠ | Experimentalavx512f使用写掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_set1_epi64⚠ | Experimentalavx512f使用写掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_shldi_epi16⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_shldi_epi32⚠ | Experimentalavx512vbmi2将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_shldi_epi64⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_shldv_epi16⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm512_mask_shldv_epi32⚠ | Experimentalavx512vbmi2将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm512_mask_shldv_epi64⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 复制)。 |
| _mm512_mask_shrdi_epi16⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_shrdi_epi32⚠ | Experimentalavx512vbmi2连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm512_mask_shrdi_epi64⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素从 src` 复制)。 |
| _mm512_mask_shrdv_epi16⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm512_mask_shrdv_epi32⚠ | Experimentalavx512vbmi2连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm512_mask_shrdv_epi64⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm512_mask_shuffle_epi8⚠ | Experimentalavx512bw使用 b 中相应的 8 位元素中的控件在 128 位通道内对 a 中的 8 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_shuffle_epi32⚠ | Experimentalavx512f使用 imm8 中的控件将 128 位通道中的 32 位整数随机排列，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_shuffle_f32x4⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_shuffle_f64x2⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_shuffle_i32x4⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 重排，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_shuffle_i64x2⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 进行混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_shuffle_pd⚠ | Experimentalavx512f使用 imm8 中的控件对 128 位通道中的双精度 (64-bit) 浮点元素进行混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_shuffle_ps⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_shufflehi_epi16⚠ | Experimentalavx512bw使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，将 128 位通道的低 64 位从 a 复制到 dst，使用写掩码 k (当相应的掩码位不存在时，元素从 src 复制放)。 |
| _mm512_mask_shufflelo_epi16⚠ | Experimentalavx512bw使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，并使用写掩码 k 将 128 位通道的高 64 位从 a 复制到 dst (当未使用相应的掩码位时，元素从 src 复制) 放)。 |
| _mm512_mask_sll_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数左移，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sll_epi32⚠ | Experimentalavx512f将包装的 32 位整数左移计数，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sll_epi64⚠ | Experimentalavx512f将包装的 64 位整数左移计数，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_slli_epi16⚠ | Experimentalavx512bw将包装的 16 位整数左移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_slli_epi32⚠ | Experimentalavx512f将包装的 32 位整数左移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_slli_epi64⚠ | Experimentalavx512f将包装的 64 位整数向左移动 imm8，同时向零移动，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sllv_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按 count 中相应元素指定的数量向左移位，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sllv_epi32⚠ | Experimentalavx512f将填充的 32 位整数向左移动计数中相应元素指定的数量，同时将其移位为零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sllv_epi64⚠ | Experimentalavx512f将填充的 64 位整数向左移动 count 中相应元素指定的数量，同时将其移位为零，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm512_mask_sqrt_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sqrt_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sqrt_round_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sqrt_round_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sra_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数右移，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sra_epi32⚠ | Experimentalavx512f在移动符号位的同时右移计数包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sra_epi64⚠ | Experimentalavx512f在移动符号位的同时右移计数包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srai_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srai_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srai_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srav_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 count 中相应元素指定的数量，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srav_epi32⚠ | Experimentalavx512f在将符号位移位的同时，将已包装的 32 位整数向右移动计数中相应元素指定的数量，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srav_epi64⚠ | Experimentalavx512f在移入符号位的同时，将包装的 64 位整数向右移动计数中相应元素指定的数量，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srl_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srl_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移，同时移零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srl_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移，同时移零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srli_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srli_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srli_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srlv_epi16⚠ | Experimentalavx512bw将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srlv_epi32⚠ | Experimentalavx512f向右移动包装的 32 位整数整数 (由 count 中相应元素指定的数量)，同时向零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_srlv_epi64⚠ | Experimentalavx512f向右移位包装的 64 位整数，其数量为计数中相应元素指定的数量，同时向零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_epi8⚠ | Experimentalavx512bw从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_epi16⚠ | Experimentalavx512bw从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_epi32⚠ | Experimentalavx512f从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_epi64⚠ | Experimentalavx512f从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_pd⚠ | Experimentalavx512f从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_ps⚠ | Experimentalavx512f将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_round_pd⚠ | Experimentalavx512f从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_sub_round_ps⚠ | Experimentalavx512f将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_subs_epi8⚠ | Experimentalavx512bw使用饱和度将 b 中的包装 8 位整数减去 b 中的包装 8 位有符号整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_subs_epi16⚠ | Experimentalavx512bw使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_subs_epu8⚠ | Experimentalavx512bw使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_subs_epu16⚠ | Experimentalavx512bw使用 a 饱和度从 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm512_mask_ternarylogic_epi32⚠ | Experimentalavx512f提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 32 位整数中的每一位，使用 src、a 和 b 中的相应位形成 imm8 的 3 位索引，并使用 writemask 将 imm8 中该位的值写入 dst 中的相应位 k 在 32 位粒度 (当相应的掩码位未设置时，从 src 复制 32 位元素)。 |
| _mm512_mask_ternarylogic_epi64⚠ | Experimentalavx512f提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，src、a 和 b 中的相应位用于形成 imm8 的 3 位索引，并使用 writemask 将 imm8 中该位的值写入 dst 中的相应位 k 在 64 位粒度 (当相应的掩码位未设置时，从 src 复制 64 位元素)。 |
| _mm512_mask_test_epi8_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 8 位整数的按位与，生成中间 8 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm512_mask_test_epi16_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 16 位整数的按位与，生成中间的 16 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm512_mask_test_epi32_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位与，生成中间的 32 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm512_mask_test_epi64_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位与，生成中间 64 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm512_mask_testn_epi8_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 8 位整数的按位 NAND，生成中间的 8 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm512_mask_testn_epi16_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 16 位整数的按位 NAND，生成中间的 16 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm512_mask_testn_epi32_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位 NAND，生成中间的 32 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm512_mask_testn_epi64_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位 NAND，生成中间 64 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm512_mask_unpackhi_epi8⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_unpackhi_epi16⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_unpackhi_epi32⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_unpackhi_epi64⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_unpackhi_pd⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm512_mask_unpackhi_ps⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm512_mask_unpacklo_epi8⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的下半部分拆包和交织 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_unpacklo_epi16⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的下半部分拆包和交织 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_unpacklo_epi32⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm512_mask_unpacklo_epi64⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_unpacklo_pd⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包并交织双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm512_mask_unpacklo_ps⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包并交织单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm512_mask_xor_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位 XOR，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_mask_xor_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位 XOR，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm512_maskz_abs_epi8⚠ | Experimentalavx512bw计算 a 中包装的带符号的 8 位整数的绝对值，并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_abs_epi16⚠ | Experimentalavx512bw计算 a 中包装的带符号的 16 位整数的绝对值，并使用零掩码 k (将未设置相应掩码位的元素清零) 将无符号结果存储在 dst 中。 |
| _mm512_maskz_abs_epi32⚠ | Experimentalavx512f计算 |
| _mm512_maskz_abs_epi64⚠ | Experimentalavx512f计算 a 中包装的带符号的 64 位整数的绝对值，并使用零掩码 k (将未设置相应掩码位的元素清零) 将无符号结果存储在 dst 中。 |
| _mm512_maskz_add_epi8⚠ | Experimentalavx512bw在 a 和 b 中添加包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_epi16⚠ | Experimentalavx512bw将包装的 16 位整数添加到 a 和 b 中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_epi32⚠ | Experimentalavx512f将包装的 32 位整数添加到 a 和 b 中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_epi64⚠ | Experimentalavx512f在 a 和 b 中添加包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_pd⚠ | Experimentalavx512f在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_ps⚠ | Experimentalavx512f在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_round_pd⚠ | Experimentalavx512f在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_add_round_ps⚠ | Experimentalavx512f在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_adds_epi8⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_adds_epi16⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_adds_epu8⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_adds_epu16⚠ | Experimentalavx512bw使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_alignr_epi8⚠ | Experimentalavx512bw将 a 和 b 中的 16 字节块对连接成一个 32 字节的临时结果，将结果右移 imm8 字节，并使用零掩码 k 将低 16 字节存储在 dst 中 (当未使用相应的掩码位时元素清零) 放)。 |
| _mm512_maskz_alignr_epi32⚠ | Experimentalavx512f将 a 和 b 连接成一个 128 字节的立即结果，将结果右移 imm8 32 位元素，并使用零掩码 k 将低 64 字节 (16 个元素) 存储在 dst 中 (当未使用相应的掩码位时元素清零) 放)。 |
| _mm512_maskz_alignr_epi64⚠ | Experimentalavx512f将 a 和 b 连接成一个 128 字节的立即结果，将结果右移 imm8 64 位元素，并使用零掩码 k 将低 64 字节 (8 个元素) 存储在 dst 中 (当未使用相应的掩码位时元素清零) 放)。 |
| _mm512_maskz_and_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位与，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_and_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位与，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_andnot_epi32⚠ | Experimentalavx512f计算 a 中包装的 32 位整数的按位 NOT，然后计算 b 中的 AND，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_andnot_epi64⚠ | Experimentalavx512f计算 a 中包装的 64 位整数的按位 NOT，然后与 b 计算 AND，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_avg_epu8⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 8 位整数进行平均，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_avg_epu16⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 16 位整数进行平均，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_broadcast_f32x4⚠ | Experimentalavx512f使用零掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_broadcast_f64x4⚠ | Experimentalavx512f使用零掩码 k 将 4 个包装的双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcast_i32x4⚠ | Experimentalavx512f使用零掩码 k 将 4 的包装的 32 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcast_i64x4⚠ | Experimentalavx512f使用零掩码 k 将 4 个包装的 64 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcastb_epi8⚠ | Experimentalavx512bw使用零掩码 k 将低包装的 8 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcastd_epi32⚠ | Experimentalavx512f使用零掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcastq_epi64⚠ | Experimentalavx512f使用零掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcastsd_pd⚠ | Experimentalavx512f使用零掩码 k 将低双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_broadcastss_ps⚠ | Experimentalavx512f使用零掩码 k 将低单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_broadcastw_epi16⚠ | Experimentalavx512bw使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_compress_epi8⚠ | Experimentalavx512vbmi2将 a 中的活动 8 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst，并将其余元素设置为零。 |
| _mm512_maskz_compress_epi16⚠ | Experimentalavx512vbmi2将 a 中的活动 16 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst，并将其余元素设置为零。 |
| _mm512_maskz_compress_epi32⚠ | Experimentalavx512f将活动的 32 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst，并将其余元素设置为零。 |
| _mm512_maskz_compress_epi64⚠ | Experimentalavx512f将活动的 64 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst，并将其余元素设置为零。 |
| _mm512_maskz_compress_pd⚠ | Experimentalavx512f将活动的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst，并将其余元素设置为零。 |
| _mm512_maskz_compress_ps⚠ | Experimentalavx512f将活动的单精度 (32-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst，并将其余元素设置为零。 |
| _mm512_maskz_conflict_epi32⚠ | Experimentalavx512cd使用零掩码 k (在未设置相应的掩码位时将元素清零)，测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm512_maskz_conflict_epi64⚠ | Experimentalavx512cd使用零掩码 k (在未设置相应的掩码位时将元素清零)，测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm512_maskz_cvt_roundepi32_ps⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用零掩码 k (未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm512_maskz_cvt_roundepu32_ps⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvt_roundpd_epi32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvt_roundpd_epu32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvt_roundpd_ps⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvt_roundph_ps⚠ | Experimentalavx512f将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvt_roundps_epi32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvt_roundps_epu32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvt_roundps_pd⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvt_roundps_ph⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtepi8_epi16⚠ | Experimentalavx512bw使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtepi8_epi32⚠ | Experimentalavx512f使用符号将包装的 8 位整数从 a 扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi8_epi64⚠ | Experimentalavx512f符号将 a 的低 8 个字节中的包装 8 位整数扩展为包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi16_epi8⚠ | Experimentalavx512bw将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi16_epi32⚠ | Experimentalavx512f符号将包装的 16 位整数从 a 扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtepi16_epi64⚠ | Experimentalavx512f使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi32_epi8⚠ | Experimentalavx512f将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi32_epi16⚠ | Experimentalavx512f将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi32_epi64⚠ | Experimentalavx512f使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi32_pd⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtepi32_ps⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用零掩码 k (未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm512_maskz_cvtepi64_epi8⚠ | Experimentalavx512f将带有 a 的包装的 64 位整数转换为带截断的 8 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi64_epi16⚠ | Experimentalavx512f将带有 a 的包装的 64 位整数转换为带截断的 16 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepi64_epi32⚠ | Experimentalavx512f将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepu8_epi16⚠ | Experimentalavx512bw将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_cvtepu8_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 8 位整数零扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_cvtepu8_epi64⚠ | Experimentalavx512f将 a 的低 8 个字节中的包装无符号 8 位整数零扩展为包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtepu16_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtepu16_epi64⚠ | Experimentalavx512f将 a 中的包装无符号 16 位整数零扩展为包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtepu32_epi64⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_cvtepu32_pd⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtepu32_ps⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512f将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在单个 vector dst 中 (当对应的掩码位不存在时，元素归零放)。 |
| _mm512_maskz_cvtneps_pbh⚠ | Experimentalavx512bf16,avx512f将包装的单精度 (32-bit) 浮点元素在 a 中转换为包装的 BF16 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_cvtpd_epi32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtpd_epu32⚠ | Experimentalavx512f将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtpd_ps⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtph_ps⚠ | Experimentalavx512f将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtps_epi32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtps_epu32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtps_pd⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtps_ph⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvtsepi16_epi8⚠ | Experimentalavx512bw将 a 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtsepi32_epi8⚠ | Experimentalavx512f将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtsepi32_epi16⚠ | Experimentalavx512f将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并将结果存储在 dst 中。 |
| _mm512_maskz_cvtsepi64_epi8⚠ | Experimentalavx512f将 a 中的包装有符号 64 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtsepi64_epi16⚠ | Experimentalavx512f将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtsepi64_epi32⚠ | Experimentalavx512f将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtt_roundpd_epi32⚠ | Experimentalavx512f将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtt_roundpd_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtt_roundps_epi32⚠ | Experimentalavx512f将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvtt_roundps_epu32⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素转换为带有截断的包装无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvttpd_epi32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm512_maskz_cvttpd_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvttps_epi32⚠ | Experimentalavx512f将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_cvttps_epu32⚠ | Experimentalavx512f将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtusepi16_epi8⚠ | Experimentalavx512bw将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtusepi32_epi8⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtusepi32_epi16⚠ | Experimentalavx512f将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtusepi64_epi8⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_cvtusepi64_epi16⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_cvtusepi64_epi32⚠ | Experimentalavx512f将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_dbsad_epu8⚠ | Experimentalavx512bw计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs) 的总和，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将 16 位结果存储在 dst 中。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm512_maskz_div_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_div_ps⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_div_round_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_div_round_ps⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_dpbf16_ps⚠ | Experimentalavx512bf16,avx512f计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间单精度 (32-bit) 浮点元素与 src 中的元素进行累加，并将结果存储在 dst 中使用 zeromask k (当对应的掩码为位未设置)。 |
| _mm512_maskz_dpbusd_epi32⚠ | Experimentalavx512vnni将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果使用 zeromask k 存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_dpbusds_epi32⚠ | Experimentalavx512vnni将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数用带符号饱和求和，并将包装的 32 位结果用 zeromask k 存储在 dst 中 (当对应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_dpwssd_epi32⚠ | Experimentalavx512vnni将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加，并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_dpwssds_epi32⚠ | Experimentalavx512vnni将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_expand_epi8⚠ | Experimentalavx512vbmi2从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_expand_epi16⚠ | Experimentalavx512vbmi2从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_expand_epi32⚠ | Experimentalavx512f从 a 中加载连续的有效 32 位整数 (它们各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_expand_epi64⚠ | Experimentalavx512f从 a 中加载连续的有效 64 位整数 (它们各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_expand_pd⚠ | Experimentalavx512f从 a 中加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_expand_ps⚠ | Experimentalavx512f从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_extractf32x4_ps⚠ | Experimentalavx512f从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并用 imm8 进行选择，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_extractf64x4_pd⚠ | Experimentalavx512f从 a 提取 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成)，并用 imm8 进行选择，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_extracti32x4_epi32⚠ | Experimentalavx512f从 a 中提取 128 位 (由 4 个包装的 32 位整数组成)，用 IMM2 选择，结果用 zeromask k 存储在 dst 中 (当相应的掩码位未设置时，元素归零)。 |
| _mm512_maskz_extracti64x4_epi64⚠ | Experimentalavx512f从 a 中提取 256 位 (由 4 个包装的 64 位整数组成)，用 IMM1 选择，结果用 zeromask k 存储在 dst 中 (当相应的掩码位未设置时，元素归零)。 |
| _mm512_maskz_fixupimm_pd⚠ | Experimentalavx512f使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm512_maskz_fixupimm_ps⚠ | Experimentalavx512f使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm512_maskz_fixupimm_round_pd⚠ | Experimentalavx512f使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm512_maskz_fixupimm_round_ps⚠ | Experimentalavx512f使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm512_maskz_fmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_fmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_fmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_fmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并将结果存储在使用零掩码 k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_fmaddsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmaddsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmaddsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmaddsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fmsubadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmsubadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，或者将 C from/to 中的包装元素相减并相加，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmsubadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fmsubadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，或者将 C from/to 中的包装元素相减并相加，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_fnmadd_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fnmadd_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_fnmadd_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fnmadd_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_fnmsub_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fnmsub_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fnmsub_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_fnmsub_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_getexp_pd⚠ | Experimentalavx512f将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_maskz_getexp_ps⚠ | Experimentalavx512f将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_maskz_getexp_round_pd⚠ | Experimentalavx512f将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_maskz_getexp_round_ps⚠ | Experimentalavx512f将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm512_maskz_getmant_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_maskz_getmant_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_maskz_getmant_round_pd⚠ | Experimentalavx512f将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_maskz_getmant_round_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm512_maskz_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm512_maskz_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm512_maskz_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512f在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm512_maskz_insertf32x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 x00X 指定的位置将 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时，元素会被清零)。 |
| _mm512_maskz_insertf64x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 x00X 指定的位置将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时，元素会被清零)。 |
| _mm512_maskz_inserti32x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 imm8 指定的位置，将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时，元素会被清零)。 |
| _mm512_maskz_inserti64x4⚠ | Experimentalavx512f将 a 复制到 tmp，然后在 imm8 指定的位置将 b 的 256 位 (由 4 个包装的 64 位整数组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时，元素会被清零)。 |
| _mm512_maskz_lzcnt_epi32⚠ | Experimentalavx512cd计算 a 中每个包装的 32 位整数中前导零位的数目，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_lzcnt_epi64⚠ | Experimentalavx512cd计算 a 中每个包装的 64 位整数中前导零位的数目，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_madd_epi16⚠ | Experimentalavx512bw在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对，并使用 zeromask k 将结果打包到 dst (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_maddubs_epi16⚠ | Experimentalavx512bw将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘，生成中间有符号的 16 位整数。水平添加相邻的中间有符号 16 位整数对，并使用 zeromask k 将饱和结果打包到 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_max_epi8⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_epi16⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_epi32⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_epi64⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_max_epu8⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_epu16⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_epu32⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_epu64⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_ps⚠ | Experimentalavx512f比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_round_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_max_round_ps⚠ | Experimentalavx512f比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm512_maskz_min_epi8⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epi16⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epi32⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epi64⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epu8⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epu16⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epu32⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_epu64⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_ps⚠ | Experimentalavx512f比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_round_pd⚠ | Experimentalavx512f比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_min_round_ps⚠ | Experimentalavx512f比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm512_maskz_mov_epi8⚠ | Experimentalavx512bw使用零掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_mov_epi16⚠ | Experimentalavx512bw使用零掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_mov_epi32⚠ | Experimentalavx512f使用零掩码 k 将包装的 32 位整数从 a 移至 dst (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_mov_epi64⚠ | Experimentalavx512f使用零掩码 k 将包装的 64 位整数从 a 移到 dst (未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_mov_pd⚠ | Experimentalavx512f使用零掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移到 dst (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_mov_ps⚠ | Experimentalavx512f使用零掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移到 dst (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_movedup_pd⚠ | Experimentalavx512f从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_movehdup_ps⚠ | Experimentalavx512f从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_moveldup_ps⚠ | Experimentalavx512f从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_mul_epi32⚠ | Experimentalavx512f将 a 和 b 中每个包装的 64 位元素的低位有符号 32 位整数相乘，并使用零掩码 k 将有符号的 64 位结果存储在 dst 中 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_mul_epu32⚠ | Experimentalavx512f将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并使用零掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_mul_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_mul_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_mul_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_mul_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_mulhi_epi16⚠ | Experimentalavx512bw将 a 和 b 中包装的带符号的 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_mulhi_epu16⚠ | Experimentalavx512bw将 a 和 b 中包装的无符号 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_mulhrs_epi16⚠ | Experimentalavx512bw在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，通过加 1 舍入，并使用 zeromask k 将位 [16:1] 存储到 dst (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_mullo_epi16⚠ | Experimentalavx512bw将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_mullo_epi32⚠ | Experimentalavx512f将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将中间整数的低 32 位存储在 dst 中。 |
| _mm512_maskz_multishift_epi64_epi8⚠ | Experimentalavx512vbmi对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并使用 zeromask k (元素当相应的屏蔽位未设置时被清零)。 |
| _mm512_maskz_or_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位或，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_or_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位或，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_packs_epi16⚠ | Experimentalavx512bw使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_packs_epi32⚠ | Experimentalavx512bw使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_packus_epi16⚠ | Experimentalavx512bw使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_packus_epi32⚠ | Experimentalavx512bw使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_permute_pd⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permute_ps⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutevar_pd⚠ | Experimentalavx512f使用 b 中的控件在 128 位通道内将 a 中的双精度 (64-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutevar_ps⚠ | Experimentalavx512f使用 b 中的控件在 128 位通道内将 a 的单精度 (32-bit) 浮点元素打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_permutex2var_epi8⚠ | Experimentalavx512vbmi使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_permutex2var_epi16⚠ | Experimentalavx512bw使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutex2var_epi32⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutex2var_epi64⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 64 位整数进行混洗，并使用 zeromask k (未设置相应的 mask 位时将元素清零) 将结果存储在 dst 中。 |
| _mm512_maskz_permutex2var_pd⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的通道 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutex2var_ps⚠ | Experimentalavx512f使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_permutex_epi64⚠ | Experimentalavx512f使用 imm8 中的控件在 256 位通道内将 64 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutex_pd⚠ | Experimentalavx512f使用 imm8 中的控件在 256 位通道内将双精度 (64-bit) 浮点元素打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_permutexvar_epi8⚠ | Experimentalavx512vbmi使用 idx 中的相应索引在跨通道的 a 中打乱 8 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_permutexvar_epi16⚠ | Experimentalavx512bw使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutexvar_epi32⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对 32 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutexvar_epi64⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对 64 位整数进行打乱，并使用零掩码 k (未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm512_maskz_permutexvar_pd⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_permutexvar_ps⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对单精度 (32-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_popcnt_epi8⚠ | Experimentalavx512bitalg对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_maskz_popcnt_epi16⚠ | Experimentalavx512bitalg对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_maskz_popcnt_epi32⚠ | Experimentalavx512vpopcntdq对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_maskz_popcnt_epi64⚠ | Experimentalavx512vpopcntdq对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm512_maskz_rcp14_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_maskz_rcp14_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_maskz_rol_epi32⚠ | Experimentalavx512f将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_rol_epi64⚠ | Experimentalavx512f将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_rolv_epi32⚠ | Experimentalavx512f将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_rolv_epi64⚠ | Experimentalavx512f将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_ror_epi32⚠ | Experimentalavx512f将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_ror_epi64⚠ | Experimentalavx512f将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm512_maskz_rorv_epi32⚠ | Experimentalavx512f将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_rorv_epi64⚠ | Experimentalavx512f将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm512_maskz_roundscale_pd⚠ | Experimentalavx512f将 x 中的包装双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_roundscale_ps⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_roundscale_round_pd⚠ | Experimentalavx512f将 x 中的包装双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_roundscale_round_ps⚠ | Experimentalavx512f将 a 中的包装单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_rsqrt14_pd⚠ | Experimentalavx512f计算 a 中的包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_maskz_rsqrt14_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm512_maskz_scalef_pd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_scalef_ps⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_scalef_round_pd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_scalef_round_ps⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_set1_epi8⚠ | Experimentalavx512bw使用零掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_set1_epi16⚠ | Experimentalavx512bw使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_set1_epi32⚠ | Experimentalavx512f使用零掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_set1_epi64⚠ | Experimentalavx512f使用零掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm512_maskz_shldi_epi16⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shldi_epi32⚠ | Experimentalavx512vbmi2将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shldi_epi64⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shldv_epi16⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shldv_epi32⚠ | Experimentalavx512vbmi2将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shldv_epi64⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shrdi_epi16⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shrdi_epi32⚠ | Experimentalavx512vbmi2连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shrdi_epi64⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shrdv_epi16⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shrdv_epi32⚠ | Experimentalavx512vbmi2连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shrdv_epi64⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shuffle_epi8⚠ | Experimentalavx512bw根据 b 的相应 8 位元素中的打乱控制掩码对 a 中的包装 8 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_shuffle_epi32⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道中的 32 位整数中混洗 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_shuffle_f32x4⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_shuffle_f64x2⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_shuffle_i32x4⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_shuffle_i64x2⚠ | Experimentalavx512f将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_shuffle_pd⚠ | Experimentalavx512f使用 imm8 中的控件对 128 位通道内的双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_shuffle_ps⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_shufflehi_epi16⚠ | Experimentalavx512bw使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，将 128 位通道的低 64 位从 a 复制到 dst，使用 zeromask k (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_shufflelo_epi16⚠ | Experimentalavx512bw使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，128 位通道的高 64 位从 a 复制到 dst，使用 zeromask k (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_sll_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数左移，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sll_epi32⚠ | Experimentalavx512f将包装的 32 位整数左移计数，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sll_epi64⚠ | Experimentalavx512f将填充的 64 位整数左移计数，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_slli_epi16⚠ | Experimentalavx512bw将包装的 16 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_slli_epi32⚠ | Experimentalavx512f将包装的 32 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_slli_epi64⚠ | Experimentalavx512f将包装的 64 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sllv_epi16⚠ | Experimentalavx512bw将包装的 16 位整数左移由 count 中的相应元素指定的数量，同时移入零，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sllv_epi32⚠ | Experimentalavx512f在将移位的 32 位整数左移零时，将其对应计数指定的数量左移，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sllv_epi64⚠ | Experimentalavx512f在将移位的 64 位整数左移零时，将其对应计数指定的数量左移，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sqrt_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用零掩码 k (将结果置零，当未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm512_maskz_sqrt_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sqrt_round_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用零掩码 k (将结果置零，当未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm512_maskz_sqrt_round_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sra_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数右移，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sra_epi32⚠ | Experimentalavx512f在移动符号位的同时右移计数包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sra_epi64⚠ | Experimentalavx512f在移动符号位的同时右移计数包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srai_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srai_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_srai_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srav_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移由 count 中的相应元素指定的数量，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srav_epi32⚠ | Experimentalavx512f在将符号位移位的同时，将已包装的 32 位整数向右移动计数中相应元素指定的数量，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srav_epi64⚠ | Experimentalavx512f在移入符号位的同时，将包装的 64 位整数右移由 count 中相应元素指定的数量，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srl_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srl_epi32⚠ | Experimentalavx512f将移位的 32 位整数右移，同时移零，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srl_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移计数，同时移入零，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm512_maskz_srli_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srli_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srli_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srlv_epi16⚠ | Experimentalavx512bw将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srlv_epi32⚠ | Experimentalavx512f向右移动已包装的 32 位整数，偏移量为相应元素在计数中指定的数量，同时向零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_srlv_epi64⚠ | Experimentalavx512f向右移位包装的 64 位整数，其数量为计数中相应元素指定的数量，同时移位为零，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_sub_epi8⚠ | Experimentalavx512bw从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_sub_epi16⚠ | Experimentalavx512bw从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_sub_epi32⚠ | Experimentalavx512f从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_sub_epi64⚠ | Experimentalavx512f从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sub_pd⚠ | Experimentalavx512f从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sub_ps⚠ | Experimentalavx512f将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sub_round_pd⚠ | Experimentalavx512f从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_sub_round_ps⚠ | Experimentalavx512f将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_subs_epi8⚠ | Experimentalavx512bw使用饱和度从包装的 8 位整数中减去 b 中的包装有符号的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_subs_epi16⚠ | Experimentalavx512bw使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_subs_epu8⚠ | Experimentalavx512bw使用 a 饱和度从 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_subs_epu16⚠ | Experimentalavx512bw使用 a 饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_ternarylogic_epi32⚠ | Experimentalavx512f提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 32 位整数中的每一位，来自 a、b 和 c 的相应位用于形成 imm8 的 3 位索引，并使用零掩码将 imm8 中该位的值写入 dst 中的相应位 k 在 32 位粒度 (当未设置相应的掩码位时，32 位元素被清零)。 |
| _mm512_maskz_ternarylogic_epi64⚠ | Experimentalavx512f提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，来自 a、b 和 c 的相应位用于在 imm8 中形成 3 位索引，并使用零掩码将 imm8 中该位的值写入 dst 中的相应位 k 在 64 位粒度 (当未设置相应的掩码位时，64 位元素将被清零)。 |
| _mm512_maskz_unpackhi_epi8⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpackhi_epi16⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpackhi_epi32⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpackhi_epi64⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpackhi_pd⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_unpackhi_ps⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_unpacklo_epi8⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的下半部分拆包和交织 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpacklo_epi16⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的下半部分拆包和交织 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_unpacklo_epi32⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpacklo_epi64⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm512_maskz_unpacklo_pd⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_unpacklo_ps⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm512_maskz_xor_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位 XOR，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_maskz_xor_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位 XOR，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm512_max_epi8⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epi16⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epi32⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号 32 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epi64⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epu8⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epu16⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epu32⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_epu64⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数，并将包装的最大值存储在 dst 中。 |
| _mm512_max_pd⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，并将包装的最大值存储在 dst 中。 |
| _mm512_max_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将包装的最大值存储在 dst 中。 |
| _mm512_max_round_pd⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，并将包装的最大值存储在 dst 中。 |
| _mm512_max_round_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将包装的最大值存储在 dst 中。 |
| _mm512_min_epi8⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 8 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epi16⚠ | Experimentalavx512bw比较 a 和 b 中包装的带符号的 16 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epi32⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号 32 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epi64⚠ | Experimentalavx512f比较 a 和 b 中包装的带符号的 64 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epu8⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 8 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epu16⚠ | Experimentalavx512bw比较 a 和 b 中包装的无符号 16 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epu32⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 32 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_epu64⚠ | Experimentalavx512f比较 a 和 b 中包装的无符号 64 位整数，并将包装的最小值存储在 dst 中。 |
| _mm512_min_pd⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，并将包装的最小值存储在 dst 中。 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，并将包装的最小值存储在 dst 中。 |
| _mm512_min_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将包装的最小值存储在 dst 中。 |
| _mm512_min_round_pd⚠ | Experimentalavx512f比较 a 和 b 中包装的双精度 (64-bit) 浮点元素，并将包装的最小值存储在 dst 中。 |
| _mm512_min_round_ps⚠ | Experimentalavx512f比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将包装的最小值存储在 dst 中。 |
| _mm512_movedup_pd⚠ | Experimentalavx512f从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_movehdup_ps⚠ | Experimentalavx512f从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_moveldup_ps⚠ | Experimentalavx512f从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_movepi8_mask⚠ | Experimentalavx512bw根据 a 中相应包装的 8 位整数的最高有效位设置掩码寄存器 k 的每个位。 |
| _mm512_movepi16_mask⚠ | Experimentalavx512bw根据 a 中相应的包装的 16 位整数的最高有效位设置掩码寄存器 k 的每一位。 |
| _mm512_movm_epi8⚠ | Experimentalavx512bw根据 k 中相应位的值，将 dst 中每个包装的 8 位整数设置为全 1 或全 0。 |
| _mm512_movm_epi16⚠ | Experimentalavx512bw根据 k 中相应位的值，将 dst 中每个包装的 16 位整数设置为全 1 或全 0。 |
| _mm512_mul_epi32⚠ | Experimentalavx512f将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘，并将带符号的 64 位结果存储在 dst 中。 |
| _mm512_mul_epu32⚠ | Experimentalavx512f将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并将无符号 64 位结果存储在 dst 中。 |
| _mm512_mul_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并将结果存储在 dst 中。 |
| _mm512_mul_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并将结果存储在 dst 中。 |
| _mm512_mul_round_pd⚠ | Experimentalavx512f将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并将结果存储在 dst 中。 |
| _mm512_mul_round_ps⚠ | Experimentalavx512f将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并将结果存储在 dst 中。 |
| _mm512_mulhi_epi16⚠ | Experimentalavx512bw将包装的带符号的 16 位整数与 a 和 b 相乘，生成中间的 32 位整数，并将中间整数的高 16 位存储在 dst 中。 |
| _mm512_mulhi_epu16⚠ | Experimentalavx512bw将包装的无符号 16 位整数与 a 和 b 相乘，生成中间的 32 位整数，并将中间整数的高 16 位存储在 dst 中。 |
| _mm512_mulhrs_epi16⚠ | Experimentalavx512bw在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，加 1 舍入，然后将 [16: 1] 位存储到 dst。 |
| _mm512_mullo_epi16⚠ | Experimentalavx512bw将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并将中间整数的低 16 位存储在 dst 中。 |
| _mm512_mullo_epi32⚠ | Experimentalavx512f将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并将中间整数的低 32 位存储在 dst 中。 |
| _mm512_mullox_epi64⚠ | Experimentalavx512f将包装的 64 位整数 vectors a 和 b 中的元素相乘，将结果的低 64 位存储在 dst 中。 |
| _mm512_multishift_epi64_epi8⚠ | Experimentalavx512vbmi对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并将 8 个组装字节存储到 dst 的相应 64 位元素。 |
| _mm512_or_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位或，并将结果存储在 dst 中。 |
| _mm512_or_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位或，并将结果存储在 dst 中。 |
| _mm512_or_si512⚠ | Experimentalavx512f计算 a 和 b 中 512 位 (代表整数数据) 的按位或，并将结果存储在 dst 中。 |
| _mm512_packs_epi16⚠ | Experimentalavx512bw使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_packs_epi32⚠ | Experimentalavx512bw使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_packus_epi16⚠ | Experimentalavx512bw使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm512_packus_epi32⚠ | Experimentalavx512bw使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_permute_pd⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_permute_ps⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_permutevar_epi32⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中随机排列 32 位整数，并将结果存储在 dst 中。请注意，与使用 permutevar 名称的过去内联函数不同，该内联函数在 128 位通道上进行了重排。此内部函数与 _mm512_permutexvar_epi32 相同，建议您使用该内部函数名称。 |
| _mm512_permutevar_pd⚠ | Experimentalavx512f使用 b 中的控件在 128 位通道内将 a 双精度 (64-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_permutevar_ps⚠ | Experimentalavx512f使用 b 中的控件在 128 位通道内将 a 单精度 (32-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_permutex2var_epi8⚠ | Experimentalavx512vbmi使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨通道打乱，并将结果存储在 dst 中。 |
| _mm512_permutex2var_epi16⚠ | Experimentalavx512bw使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm512_permutex2var_epi32⚠ | Experimentalavx512f使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 32 位整数，并将结果存储在 dst 中。 |
| _mm512_permutex2var_epi64⚠ | Experimentalavx512f使用 idx 中的相应选择器和索引在通道中的 a 和 b 中随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm512_permutex2var_pd⚠ | Experimentalavx512f使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm512_permutex2var_ps⚠ | Experimentalavx512f使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm512_permutex_epi64⚠ | Experimentalavx512f使用 imm8 中的控件在 256 位通道中的 a 内随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm512_permutex_pd⚠ | Experimentalavx512f使用 imm8 中的控件在 256 位通道内对双精度 (64-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_permutexvar_epi8⚠ | Experimentalavx512vbmi使用 idx 中的相应索引将 a 中的 8 位整数打乱到通道中，并将结果存储在 dst 中。 |
| _mm512_permutexvar_epi16⚠ | Experimentalavx512bw使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm512_permutexvar_epi32⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中随机排列 32 位整数，并将结果存储在 dst 中。 |
| _mm512_permutexvar_epi64⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm512_permutexvar_pd⚠ | Experimentalavx512f使用 idx 中的相应索引在跨通道中对双精度 (64-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm512_permutexvar_ps⚠ | Experimentalavx512f使用 idx 中的相应索引对跨通道中的单精度 (32-bit) 浮点元素进行打乱。 |
| _mm512_popcnt_epi8⚠ | Experimentalavx512bitalg对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_popcnt_epi16⚠ | Experimentalavx512bitalg对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_popcnt_epi32⚠ | Experimentalavx512vpopcntdq对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm512_popcnt_epi64⚠ | Experimentalavx512vpopcntdq对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm512_rcp14_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm512_rcp14_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm512_reduce_add_epi32⚠ | Experimentalavx512f通过加法减少包装的 32 位整数。返回 a 中所有元素的总和。 |
| _mm512_reduce_add_epi64⚠ | Experimentalavx512f通过加法减少包装的 64 位整数。返回 a 中所有元素的总和。 |
| _mm512_reduce_add_pd⚠ | Experimentalavx512f另外，还减少了包装的双精度 (64-bit) 浮点元素。返回 a 中所有元素的总和。 |
| _mm512_reduce_add_ps⚠ | Experimentalavx512f此外，还减少了包装的单精度 (32-bit) 浮点元素。返回 a 中所有元素的总和。 |
| _mm512_reduce_and_epi32⚠ | Experimentalavx512f通过按位 AND 减少包装的 32 位整数。返回 a 中所有元素的按位与。 |
| _mm512_reduce_and_epi64⚠ | Experimentalavx512f通过按位 AND 减少包装的 64 位整数。返回 a 中所有元素的按位与。 |
| _mm512_reduce_max_epi32⚠ | Experimentalavx512f最多减少包装的带符号 32 位整数。返回 a 中所有元素的最大值。 |
| _mm512_reduce_max_epi64⚠ | Experimentalavx512f最大减少包装的带符号的 64 位整数。返回 a 中所有元素的最大值。 |
| _mm512_reduce_max_epu32⚠ | Experimentalavx512f最多减少包装的无符号 32 位整数。返回 a 中所有元素的最大值。 |
| _mm512_reduce_max_epu64⚠ | Experimentalavx512f最多减少包装的无符号 64 位整数。返回 a 中所有元素的最大值。 |
| _mm512_reduce_max_pd⚠ | Experimentalavx512f最大减少包装的双精度 (64-bit) 浮点元素。返回 a 中所有元素的最大值。 |
| _mm512_reduce_max_ps⚠ | Experimentalavx512f最大减少包装的单精度 (32-bit) 浮点元素。返回 a 中所有元素的最大值。 |
| _mm512_reduce_min_epi32⚠ | Experimentalavx512f将包装的有符号的 32 位整数减少到最小值。返回 a 中所有元素的最小值。 |
| _mm512_reduce_min_epi64⚠ | Experimentalavx512f将一个包装的有符号 64 位整数减少到最小值。返回 a 中所有元素的最小值。 |
| _mm512_reduce_min_epu32⚠ | Experimentalavx512f将一个包装的无符号 32 位整数减少到最小值。返回 a 中所有元素的最小值。 |
| _mm512_reduce_min_epu64⚠ | Experimentalavx512f将一个包装的无符号 64 位整数减少到最小。返回 a 中所有元素的最小值。 |
| _mm512_reduce_min_pd⚠ | Experimentalavx512f将一个包装的双精度（64位）浮点元素减少到最小。返回 a 中所有元素的最小值。 |
| _mm512_reduce_min_ps⚠ | Experimentalavx512f将一个包装的单精度（32位）浮点元素减少到最小。返回 a 中所有元素的最小值。 |
| _mm512_reduce_mul_epi32⚠ | Experimentalavx512f通过乘法减少包装的 32 位整数。返回 a 中所有元素的乘积。 |
| _mm512_reduce_mul_epi64⚠ | Experimentalavx512f通过乘法减少包装的 64 位整数。返回 a 中所有元素的乘积。 |
| _mm512_reduce_mul_pd⚠ | Experimentalavx512f通过乘法减少包装的双精度 (64-bit) 浮点元素。返回 a 中所有元素的乘积。 |
| _mm512_reduce_mul_ps⚠ | Experimentalavx512f通过乘法减少包装的单精度 (32-bit) 浮点元素。返回 a 中所有元素的乘积。 |
| _mm512_reduce_or_epi32⚠ | Experimentalavx512f通过按位 OR 减少包装的 32 位整数。返回 a 中所有元素的按位或。 |
| _mm512_reduce_or_epi64⚠ | Experimentalavx512f通过按位 OR 减少包装的 64 位整数。返回 a 中所有元素的按位或。 |
| _mm512_rol_epi32⚠ | Experimentalavx512f将 X 中每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_rol_epi64⚠ | Experimentalavx512f将 X 中每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_rolv_epi32⚠ | Experimentalavx512f将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_rolv_epi64⚠ | Experimentalavx512f将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_ror_epi32⚠ | Experimentalavx512f将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并将结果存储在 dst 中。 |
| _mm512_ror_epi64⚠ | Experimentalavx512f将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_rorv_epi32⚠ | Experimentalavx512f将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_rorv_epi64⚠ | Experimentalavx512f将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm512_roundscale_pd⚠ | Experimentalavx512f将 x 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并将结果存储在 dst 中。 |
| _mm512_roundscale_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，然后将结果存储在 dst 中。 |
| _mm512_roundscale_round_pd⚠ | Experimentalavx512f将 x 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并将结果存储在 dst 中。 |
| _mm512_roundscale_round_ps⚠ | Experimentalavx512f将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，然后将结果存储在 dst 中。 |
| _mm512_rsqrt14_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm512_rsqrt14_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm512_sad_epu8⚠ | Experimentalavx512bw计算 a 和 b 中包装的无符号 8 位整数的绝对差，然后将每个连续的 8 个差水平地求和以生成八个无符号的 16 位整数，并将这些无符号的 16 位整数包装在 64 位元素的低 16 位中在 dst。 |
| _mm512_scalef_pd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_scalef_ps⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_scalef_round_pd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_scalef_round_ps⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_set1_epi8⚠ | Experimentalavx512f向 dst 的所有元素广播 8 位整数 a。 |
| _mm512_set1_epi16⚠ | Experimentalavx512f将低包装的 16 位整数从 a 广播到 dst 的所有所有元素。 |
| _mm512_set1_epi32⚠ | Experimentalavx512f向 |
| _mm512_set1_epi64⚠ | Experimentalavx512f向 |
| _mm512_set1_pd⚠ | Experimentalavx512f向 |
| _mm512_set1_ps⚠ | Experimentalavx512f向 |
| _mm512_set4_epi32⚠ | Experimentalavx512f使用重复的 4 个元素序列在 dst 中设置包装的 32 位整数。 |
| _mm512_set4_epi64⚠ | Experimentalavx512f使用重复的 4 个元素序列在 dst 中设置包装的 64 位整数。 |
| _mm512_set4_pd⚠ | Experimentalavx512f使用重复的 4 个元素序列在 dst 中设置包装的双精度 (64-bit) 浮点元素。 |
| _mm512_set4_ps⚠ | Experimentalavx512f使用重复的 4 个元素序列在 dst 中设置包装的单精度 (32-bit) 浮点元素。 |
| _mm512_set_epi8⚠ | Experimentalavx512f使用提供的值在 dst 中设置包装的 8 位整数。 |
| _mm512_set_epi16⚠ | Experimentalavx512f使用提供的值在 dst 中设置包装的 16 位整数。 |
| _mm512_set_epi32⚠ | Experimentalavx512f使用提供的值在 |
| _mm512_set_epi64⚠ | Experimentalavx512f使用提供的值在 dst 中设置包装的 64 位整数。 |
| _mm512_set_pd⚠ | Experimentalavx512f使用提供的值在 dst 中设置包装的双精度 (64-bit) 浮点元素。 |
| _mm512_set_ps⚠ | Experimentalavx512f使用提供的值在 |
| _mm512_setr4_epi32⚠ | Experimentalavx512f在 dst 中设置包装的 32 位整数，并以相反的顺序重复 4 个元素序列。 |
| _mm512_setr4_epi64⚠ | Experimentalavx512f在 dst 中设置包装的 64 位整数，并以相反的顺序重复 4 个元素序列。 |
| _mm512_setr4_pd⚠ | Experimentalavx512f在 dst 中设置包装的双精度 (64-bit) 浮点元素，并以相反的顺序重复 4 个元素序列。 |
| _mm512_setr4_ps⚠ | Experimentalavx512f在 dst 中设置包装的单精度 (32-bit) 浮点元素，并以相反的顺序重复 4 个元素。 |
| _mm512_setr_epi32⚠ | Experimentalavx512f在 |
| _mm512_setr_epi64⚠ | Experimentalavx512f在 dst 中设置包装的 64 位整数，并以相反的顺序提供所提供的值。 |
| _mm512_setr_pd⚠ | Experimentalavx512f在 dst 中设置包装的双精度 (64-bit) 浮点元素，并以相反的顺序提供所提供的值。 |
| _mm512_setr_ps⚠ | Experimentalavx512f在 |
| _mm512_setzero⚠ | Experimentalavx512f返回 __m512 类型的 vector，所有元素均设置为零。 |
| _mm512_setzero_epi32⚠ | Experimentalavx512f返回类型为 __m512i 的 vector，所有元素均设置为零。 |
| _mm512_setzero_pd⚠ | Experimentalavx512f返回 |
| _mm512_setzero_ps⚠ | Experimentalavx512f返回 |
| _mm512_setzero_si512⚠ | Experimentalavx512f返回 |
| _mm512_shldi_epi16⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并将高 16 位存储在 dst 中)。 |
| _mm512_shldi_epi32⚠ | Experimentalavx512vbmi2将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并将高 32 位存储在 dst 中。 |
| _mm512_shldi_epi64⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并将高 64 位存储在 dst 中)。 |
| _mm512_shldv_epi16⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的对应元素中指定的量，并将高 16 位存储在 dst 中。 |
| _mm512_shldv_epi32⚠ | Experimentalavx512vbmi2将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的对应元素中指定的量，并将高 32 位存储在 dst 中。 |
| _mm512_shldv_epi64⚠ | Experimentalavx512vbmi2在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的对应元素中指定的量，并将高 64 位存储在 dst 中。 |
| _mm512_shrdi_epi16⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并将低 16 位存储在 dst 中。 |
| _mm512_shrdi_epi32⚠ | Experimentalavx512vbmi2连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并将低 32 位存储在 dst 中。 |
| _mm512_shrdi_epi64⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并将低 64 位存储在 dst 中。 |
| _mm512_shrdv_epi16⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的对应元素中指定的量，并将低 16 位存储在 dst 中。 |
| _mm512_shrdv_epi32⚠ | Experimentalavx512vbmi2连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的对应元素中指定的量，并将低 32 位存储在 dst 中。 |
| _mm512_shrdv_epi64⚠ | Experimentalavx512vbmi2将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的对应元素中指定的量，并将低 64 位存储在 dst 中。 |
| _mm512_shuffle_epi8⚠ | Experimentalavx512bw根据 b 的对应 8 位元素中的打乱控制掩码，将 a 中的包装 8 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm512_shuffle_epi32⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_shuffle_f32x4⚠ | Experimentalavx512fimm8 从 a 和 b 中随机选择 128 位 (由 4 个单精度 (32-bit) 浮点元素组成)，并将结果存储在 dst 中。 |
| _mm512_shuffle_f64x2⚠ | Experimentalavx512f随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成)，并将结果存储在 dst 中。 |
| _mm512_shuffle_i32x4⚠ | Experimentalavx512f随机排列 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成)，并将结果存储在 dst 中。 |
| _mm512_shuffle_i64x2⚠ | Experimentalavx512f随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成)，并将结果存储在 dst 中。 |
| _mm512_shuffle_pd⚠ | Experimentalavx512f使用 imm8 中的控件对 128 位通道中的双精度 (64-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm512_shuffle_ps⚠ | Experimentalavx512f使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并将结果存储在 dst 中。 |
| _mm512_shufflehi_epi16⚠ | Experimentalavx512bw使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，并从 a 到 dst 复制 128 位的通道的低 64 位。 |
| _mm512_shufflelo_epi16⚠ | Experimentalavx512bw使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，并从 a 到 dst 复制 128 位的通道的高 64 位。 |
| _mm512_sll_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数左移，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_sll_epi32⚠ | Experimentalavx512f将包装的 32 位整数左移计数，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_sll_epi64⚠ | Experimentalavx512f将填充的 64 位整数左移计数，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_slli_epi16⚠ | Experimentalavx512bw将包装的 16 位整数左移 imm8，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_slli_epi32⚠ | Experimentalavx512f将包装的 32 位整数左移 imm8，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_slli_epi64⚠ | Experimentalavx512f将包装的 64 位整数左移 imm8，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_sllv_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按 count 中相应元素指定的数量向左移位，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_sllv_epi32⚠ | Experimentalavx512f将填充的 32 位整数向左移动 count 中相应元素指定的数量，同时向零移动，并将结果存储在 dst 中。 |
| _mm512_sllv_epi64⚠ | Experimentalavx512f将填充的 64 位整数向左移动由 count 中相应元素指定的数量，同时向零移动，并将结果存储在 dst 中。 |
| _mm512_sqrt_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并将结果存储在 dst 中。 |
| _mm512_sqrt_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并将结果存储在 dst 中。 |
| _mm512_sqrt_round_pd⚠ | Experimentalavx512f计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并将结果存储在 dst 中。 |
| _mm512_sqrt_round_ps⚠ | Experimentalavx512f计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并将结果存储在 dst 中。 |
| _mm512_sra_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数右移，同时将符号位移位，并将结果存储在 dst 中。 |
| _mm512_sra_epi32⚠ | Experimentalavx512f在移入符号位的同时按计数右移包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm512_sra_epi64⚠ | Experimentalavx512f在移动符号位的同时按计数右移包装的 64 位整数，并将结果存储在 dst 中。 |
| _mm512_srai_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 imm8，同时将符号位移位，并将结果存储在 dst 中。 |
| _mm512_srai_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移 imm8，同时将符号位移位，并将结果存储在 dst 中。 |
| _mm512_srai_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移 imm8，同时将符号位移位，并将结果存储在 dst 中。 |
| _mm512_srav_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 count 中相应元素指定的数量，同时移入符号位，然后将结果存储在 dst 中。 |
| _mm512_srav_epi32⚠ | Experimentalavx512f在将符号位移位的同时，将已包装的 32 位整数右移由 count 中相应元素指定的数量，然后将结果存储在 dst 中。 |
| _mm512_srav_epi64⚠ | Experimentalavx512f将移位的 64 位整数向右移动计数中相应元素指定的数量，同时移入符号位，并将结果存储在 dst 中。 |
| _mm512_srl_epi16⚠ | Experimentalavx512bw将包装的 16 位整数按计数右移，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srl_epi32⚠ | Experimentalavx512f将计数包装的 32 位整数右移，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srl_epi64⚠ | Experimentalavx512f按计数右移包装的 64 位整数，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srli_epi16⚠ | Experimentalavx512bw将包装的 16 位整数右移 imm8，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srli_epi32⚠ | Experimentalavx512f将包装的 32 位整数右移 imm8，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srli_epi64⚠ | Experimentalavx512f将包装的 64 位整数右移 imm8，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srlv_epi16⚠ | Experimentalavx512bw将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并将结果存储在 dst 中。 |
| _mm512_srlv_epi32⚠ | Experimentalavx512f向右移动已包装的 32 位整数，偏移量为计数中相应元素指定的数量，同时向零移动，并将结果存储在 dst 中。 |
| _mm512_srlv_epi64⚠ | Experimentalavx512f向右移位包装的 64 位整数 (由 count 中相应元素指定的数量)，同时向零移位，并将结果存储在 dst 中。 |
| _mm512_store_epi32⚠ | Experimentalavx512f将 a 中的 512 位 (由 16 个包装的 32 位整数组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_store_epi64⚠ | Experimentalavx512f将 a 中的 512 位 (由 8 个包装的 64 位整数组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_store_pd⚠ | Experimentalavx512f将 a 中的 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_store_ps⚠ | Experimentalavx512f将 a 中的 512 位整数数据存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_store_si512⚠ | Experimentalavx512f将 a 中的 512 位整数数据存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_storeu_epi8⚠ | Experimentalavx512bw将 a 中的 512 位 (由 64 个包装的 8 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_storeu_epi16⚠ | Experimentalavx512bw将 a 中的 512 位 (由 32 个包装的 16 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_storeu_epi32⚠ | Experimentalavx512f将 a 中的 512 位 (由 16 个包装的 32 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_storeu_epi64⚠ | Experimentalavx512f将 a 中的 512 位 (由 8 个包装的 64 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_storeu_pd⚠ | Experimentalavx512f将来自 |
| _mm512_storeu_si512⚠ | Experimentalavx512f将 a 中的 512 位整数数据存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm512_stream_pd⚠ | Experimentalavx512f使用非临时内存提示将 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_stream_ps⚠ | Experimentalavx512f使用非临时内存提示将 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_stream_si512⚠ | Experimentalavx512f使用非临时内存提示将 512 位整数数据从 a 存储到内存中。mem_addr 必须在 64 字节边界上对齐，否则可能会生成常规保护异常。 |
| _mm512_sub_epi8⚠ | Experimentalavx512bw从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm512_sub_epi16⚠ | Experimentalavx512bw从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm512_sub_epi32⚠ | Experimentalavx512f从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并将结果存储在 dst 中。 |
| _mm512_sub_epi64⚠ | Experimentalavx512f从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并将结果存储在 dst 中。 |
| _mm512_sub_pd⚠ | Experimentalavx512f从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_sub_ps⚠ | Experimentalavx512f从 a 中的包装的单精度 (32-bit) 浮点元素中减去 b 中的包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_sub_round_pd⚠ | Experimentalavx512f从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_sub_round_ps⚠ | Experimentalavx512f从 a 中的包装的单精度 (32-bit) 浮点元素中减去 b 中的包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_subs_epi8⚠ | Experimentalavx512bw使用饱和度从包装的 8 位整数中减去 b 中的包装有符号 8 位整数，并将结果存储在 dst 中。 |
| _mm512_subs_epi16⚠ | Experimentalavx512bw使用饱和度从 a 中的包装的 16 位整数减去 b 中的包装的有符号 16 位整数，并将结果存储在 dst 中。 |
| _mm512_subs_epu8⚠ | Experimentalavx512bw使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm512_subs_epu16⚠ | Experimentalavx512bw使用饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm512_ternarylogic_epi32⚠ | Experimentalavx512f提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每个位，来自 a，b 和 c 的相应位用于形成到 imm8 的 3 位索引，并且将 imm8 中该位的值写入 dst 中的相应位。 |
| _mm512_ternarylogic_epi64⚠ | Experimentalavx512f提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，a、b 和 c 中的相应位用于形成 imm8 中的 3 位索引，并将 imm8 中该位的值写入 dst 中的相应位。 |
| _mm512_test_epi8_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 8 位整数的按位与，生成中间 8 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_test_epi16_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 16 位整数的按位与，生成中间的 16 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_test_epi32_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位与，生成中间的 32 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_test_epi64_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位与，生成中间 64 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_testn_epi8_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 8 位整数的按位 NAND，生成中间的 8 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_testn_epi16_mask⚠ | Experimentalavx512bw计算 a 和 b 中包装的 16 位整数的按位 NAND，生成中间的 16 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_testn_epi32_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位 NAND，生成中间的 32 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_testn_epi64_mask⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位 NAND，生成中间的 64 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm512_undefined⚠ | Experimentalavx512f返回类型为 __m512 的 vector，其中包含未定义的元素。 |
| _mm512_undefined_epi32⚠ | Experimentalavx512f返回类型为 __m512i 的 vector，其中包含未定义的元素。 |
| _mm512_undefined_pd⚠ | Experimentalavx512f返回带有未定义元素的 |
| _mm512_undefined_ps⚠ | Experimentalavx512f返回带有未定义元素的 |
| _mm512_unpackhi_epi8⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并将结果存储在 dst 中。 |
| _mm512_unpackhi_epi16⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并将结果存储在 dst 中。 |
| _mm512_unpackhi_epi32⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并将结果存储在 dst 中。 |
| _mm512_unpackhi_epi64⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并将结果存储在 dst 中。 |
| _mm512_unpackhi_pd⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包并交织双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_unpackhi_ps⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_unpacklo_epi8⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的下半部分拆包并交织 8 位整数，并将结果存储在 dst 中。 |
| _mm512_unpacklo_epi16⚠ | Experimentalavx512bw从 a 和 b 中每个 128 位通道的下半部分拆包并交织 16 位整数，并将结果存储在 dst 中。 |
| _mm512_unpacklo_epi32⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并将结果存储在 dst 中。 |
| _mm512_unpacklo_epi64⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解包并交织 64 位整数，并将结果存储在 dst 中。 |
| _mm512_unpacklo_pd⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解解包并交织双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_unpacklo_ps⚠ | Experimentalavx512f从 a 和 b 中每个 128 位通道的下半部分解压包并交织单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm512_xor_epi32⚠ | Experimentalavx512f计算 a 和 b 中包装的 32 位整数的按位 XOR，并将结果存储在 dst 中。 |
| _mm512_xor_epi64⚠ | Experimentalavx512f计算 a 和 b 中包装的 64 位整数的按位 XOR，并将结果存储在 dst 中。 |
| _mm512_xor_si512⚠ | Experimentalavx512f计算 a 和 b 中 512 位 (代表整数数据) 的按位 XOR，并将结果存储在 dst 中。 |
| _mm512_zextpd128_pd512⚠ | Experimentalavx512f将类型 __m128d 的 vector 强制转换为 __m512d 类型; 结果的高 384 位被清零。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_zextpd256_pd512⚠ | Experimentalavx512f将类型 __m256d 的 vector 强制转换为 __m512d 类型; 结果的高 256 位被清零。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_zextps128_ps512⚠ | Experimentalavx512f将类型 __m128 的 vector 转换为 __m512 类型; 结果的高 384 位被清零。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_zextps256_ps512⚠ | Experimentalavx512f将类型为 __m256 的 vector 强制转换为类型 __m512; 结果的高 256 位被清零。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_zextsi128_si512⚠ | Experimentalavx512f将类型为 __m128i 的 vector 强制转换为类型 __m512i; 结果的高 384 位被清零。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm512_zextsi256_si512⚠ | Experimentalavx512f将类型为 __m256i 的 vector 强制转换为类型 __m512i; 结果的高 256 位被清零。此内联函数仅用于编译，不会生成任何指令，因此延迟为零。 |
| _mm_add_round_sd⚠ | Experimentalavx512f在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素，将结果存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_add_round_ss⚠ | Experimentalavx512f在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素，将结果存储在 dst 的较低元素中，并将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。 |
| _mm_alignr_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成一个 32 字节的 immediate 结果，将结果右移 imm8 个 32 位元素，并将低 16 字节 (4 个元素) 存储在 dst 中。 |
| _mm_alignr_epi64⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成一个 32 字节的 immediate 结果，将结果右移 imm8 个 64 位元素，并将低 16 字节 (2 个元素) 存储在 dst 中。 |
| _mm_bitshuffle_epi64_mask⚠ | Experimentalavx512bitalg,avx512vl将输入 |
| _mm_broadcastmb_epi64⚠ | Experimentalavx512cd,avx512vl将输入掩码 k 的低 8 位广播到 dst 的所有 64 位元素。 |
| _mm_broadcastmw_epi32⚠ | Experimentalavx512cd,avx512vl将输入掩码 k 的低 16 位广播到 dst 的所有 32 位元素。 |
| _mm_cmp_epi8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装带符号 8 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epi16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epi32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装有符号 32 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epi64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epu8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epu16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 16 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epu32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_epu64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 64 位整数，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_pd_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_ps_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_round_sd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_round_ss_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_sd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm_cmp_ss_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 64 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpeq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号 32 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpge_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpgt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数 (小于等于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数以得出小于或等于的结果，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmple_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于等于，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数小于零，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数小于零，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数以得到小于，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装后的无符号 16 位整数 (小于)，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于，并将结果存储在掩码 vector k 中。 |
| _mm_cmplt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_cmpneq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否不相等，并将结果存储在掩码 vector k 中。 |
| _mm_comi_round_sd⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，并返回布尔结果 (0 或 1)。 |
| _mm_comi_round_ss⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，并返回布尔结果 (0 或 1)。 |
| _mm_conflict_epi32⚠ | Experimentalavx512cd,avx512vl测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm_conflict_epi64⚠ | Experimentalavx512cd,avx512vl测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm_cvt_roundi32_ss⚠ | Experimentalavx512f将带符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 dst 的高位元素。 |
| _mm_cvt_roundsd_i32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvt_roundsd_si32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvt_roundsd_ss⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_cvt_roundsd_u32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位无符号整数，并将结果存储在 dst 中。 |
| _mm_cvt_roundsi32_ss⚠ | Experimentalavx512f将带符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 dst 的高位元素。 |
| _mm_cvt_roundss_i32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvt_roundss_sd⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素，将结果存储在 dst 的下部元素中，然后将上部的元素从 a 复制到 dst 的上部元素。 |
| _mm_cvt_roundss_si32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvt_roundss_u32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位无符号整数，并将结果存储在 dst 中。 |
| _mm_cvt_roundu32_ss⚠ | Experimentalavx512f将无符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 dst 的高位元素。 |
| _mm_cvtepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtepi32_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtepi32_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm_cvtepi64_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带有截断的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtepi64_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带有截断的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm_cvtepi64_epi32⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带有截断的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtepu32_pd⚠ | Experimentalavx512f,avx512vl将 A 中的包装的无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm_cvti32_sd⚠ | Experimentalavx512f将带符号的 32 位整数 b 转换为双精度 (64-bit) 浮点元素，将结果存储在 dst 的下部元素中，然后将 a 的上部元素复制到 dst 的上部元素。 |
| _mm_cvti32_ss⚠ | Experimentalavx512f将带符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 dst 的高位元素。 |
| _mm_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512vl将两个 128 位 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并将结果存入 a |
| _mm_cvtpd_epu32⚠ | Experimentalavx512f,avx512vl将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtph_ps⚠ | Experimentalf16c将 128 位 vector |
| _mm_cvtps_epu32⚠ | Experimentalavx512f,avx512vl将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtps_ph⚠ | Experimentalf16c将 128 位 vector |
| _mm_cvtsd_i32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtsd_u32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位无符号整数，并将结果存储在 dst 中。 |
| _mm_cvtsepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 A 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtsepi32_epi8⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtsepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并将结果存储在 dst 中。 |
| _mm_cvtsepi64_epi8⚠ | Experimentalavx512f,avx512vl将包装的带符号的 64 位整数转换为带符号饱和的包装的 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtsepi64_epi16⚠ | Experimentalavx512f,avx512vl将包装的带符号的 64 位整数转换为带符号饱和的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm_cvtsepi64_epi32⚠ | Experimentalavx512f,avx512vl将包装的带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtss_i32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtss_u32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位无符号整数，并将结果存储在 dst 中。 |
| _mm_cvtt_roundsd_i32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtt_roundsd_si32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtt_roundsd_u32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtt_roundss_i32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtt_roundss_si32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtt_roundss_u32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvttpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvttps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvttsd_i32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvttsd_u32⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvttss_i32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvttss_u32⚠ | Experimentalavx512f将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_cvtu32_sd⚠ | Experimentalavx512f将无符号的 32 位整数 b 转换为双精度 (64-bit) 浮点元素，将结果存储在 dst 的低位元素中，然后将 a 的高位元素复制到 dst 的高位元素。 |
| _mm_cvtu32_ss⚠ | Experimentalavx512f将无符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 dst 的高位元素。 |
| _mm_cvtusepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtusepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtusepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装无符号 32 位整数转换为具有无符号饱和度的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm_cvtusepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并将结果存储在 dst 中。 |
| _mm_cvtusepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并将结果存储在 dst 中。 |
| _mm_cvtusepi64_epi32⚠ | Experimentalavx512f,avx512vl将 A 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并将结果存储在 dst 中。 |
| _mm_dbsad_epu8⚠ | Experimentalavx512bw,avx512vl计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs)，并将 16 位结果存储在 dst 中。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm_div_round_sd⚠ | Experimentalavx512f将 a 中的下部双精度 (64-bit) 浮点元素除以 b 中的下部双精度 (64-bit) 浮点元素，将结果存储在 dst 的下部元素中，并将上部的元素从 a 复制到 dst 的上部元素。 |
| _mm_div_round_ss⚠ | Experimentalavx512f将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素，将结果存储在 dst 的下部元素中，并将上部 3 个包装的元素从 a 复制到上部元素 dst。 |
| _mm_dpbf16_ps⚠ | Experimentalavx512bf16,avx512vl计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间单精度 (32-bit) 浮点元素与 src 中的元素相加，并将结果存储在 dst 中。 |
| _mm_dpbusd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果存入 dst。 |
| _mm_dpbusds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。使用有符号饱和将这 4 个结果与 src 中相应的 32 位整数相加，并将包装的 32 位结果存储在 dst 中。 |
| _mm_dpwssd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果存入 dst。 |
| _mm_dpwssds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并将包装的 32 位结果存储在 dst 中。 |
| _mm_fixupimm_pd⚠ | Experimentalavx512f,avx512vl使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm_fixupimm_ps⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。imm8 用于设置所需的标志报告。 |
| _mm_fixupimm_round_sd⚠ | Experimentalavx512f使用 c 中的较低 64 位整数修复 a 和 b 中较低的双精度 (64-bit) 浮点元素，将结果存储在 dst 的较低元素中，并将较高的元素从 a 复制到 dst 的较高元素。imm8 用于设置所需的标志报告。 |
| _mm_fixupimm_round_ss⚠ | Experimentalavx512f使用 c 中的低 32 位整数修复 a 和 b 中的低位单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 a 的高位元素 dst。imm8 用于设置所需的标志报告。 |
| _mm_fixupimm_sd⚠ | Experimentalavx512f使用 c 中的较低 64 位整数修复 a 和 b 中较低的双精度 (64-bit) 浮点元素，将结果存储在 dst 的较低元素中，并将较高的元素从 a 复制到 dst 的较高元素。imm8 用于设置所需的标志报告。 |
| _mm_fixupimm_ss⚠ | Experimentalavx512f使用 c 中的低 32 位整数修复 a 和 b 中的低位单精度 (32-bit) 浮点元素，将结果存储在 dst 的低位元素中，并将高 3 个包装的元素从 a 复制到 a 的高位元素 dst。imm8 用于设置所需的标志报告。 |
| _mm_fmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，并将中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中，并将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_fmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，并将中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中，然后将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。 |
| _mm_fmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。将结果存储在 dst 的下部元素中，然后将 a 的上部元素复制到 dst 的上部元素中。 |
| _mm_fmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。将结果存储在 dst 的下部元素中，并将上部 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_fnmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后将求和的中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素中。 |
| _mm_fnmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后将取反的中间结果与较低元素 in c. Store 相加，将结果与 dst 的较低元素相乘，然后将较高的 3 个包装的元素从 a 复制到 dst。 |
| _mm_fnmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。将结果存储在 dst 的下部元素中，然后将 a 的上部元素复制到 dst 的上部元素中。 |
| _mm_fnmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的下部元素，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到上部 dst 的元素。 |
| _mm_getexp_pd⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm_getexp_ps⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并将结果存储在 dst 中。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm_getexp_round_sd⚠ | Experimentalavx512f将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，将结果存储在 dst 的低位元素中，并将高位元素从 a 复制到 dst 的上层元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_getexp_round_ss⚠ | Experimentalavx512f将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，将结果存储在 dst 的较低元素中，并从 a 中复制较高的 3 个包装的元素到 dst 的上层元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_getexp_sd⚠ | Experimentalavx512f将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，将结果存储在 dst 的低位元素中，并将高位元素从 a 复制到 dst 的上层元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_getexp_ss⚠ | Experimentalavx512f将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，将结果存储在 dst 的较低元素中，并从 a 中复制较高的 3 个包装的元素到 dst 的上层元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_getmant_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化，并将结果存储在 dst 中。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_getmant_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素的尾数标准化，并将结果存储在 dst 中。 此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 尾数被标准化为由 interv 指定的间隔，该间隔可以采用以下值: _MM_MANT_NORM_1_2 // interval [1, 2) _MM_MANT_NORM_p5_2 // interval [0.5, 2) _MM_MANT_NORM_p5_1 // interval [0.5, 1) _MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5) The sign is determined by sc which can take the following values: |
| _mm_getmant_round_sd⚠ | Experimentalavx512f标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数，将结果存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_getmant_round_ss⚠ | Experimentalavx512f标准化 b 中较低单精度 (32-bit) 浮点元素的尾数，将结果存储在 dst 的较低元素中，并将高 3 个包装的元素从 a 复制到 dst 的较高元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_getmant_sd⚠ | Experimentalavx512f标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数，将结果存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_getmant_ss⚠ | Experimentalavx512f标准化 b 中较低单精度 (32-bit) 浮点元素的尾数，将结果存储在 dst 的较低元素中，并将高 3 个包装的元素从 a 复制到 dst 的较高元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm_load_epi32⚠ | Experimentalavx512f,avx512vl将 128 位 (由 4 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 16 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm_load_epi64⚠ | Experimentalavx512f,avx512vl将 128 位 (由 2 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 16 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm_loadu_epi8⚠ | Experimentalavx512bw,avx512vl将 128 位 (由 16 个包装的 8 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_loadu_epi16⚠ | Experimentalavx512bw,avx512vl将 128 位 (由 8 个包装的 16 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_loadu_epi32⚠ | Experimentalavx512f,avx512vl将 128 位 (由 4 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_loadu_epi64⚠ | Experimentalavx512f,avx512vl将 128 位 (由 2 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_lzcnt_epi32⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 32 位整数中前导零位的数目，并将结果存储在 dst 中。 |
| _mm_lzcnt_epi64⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 64 位整数中前导零位的数目，并将结果存储在 dst 中。 |
| _mm_madd52hi_epu64⚠ | Experimentalavx512ifma,avx512vl将 |
| _mm_madd52lo_epu64⚠ | Experimentalavx512ifma,avx512vl将 |
| _mm_mask2_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm_mask2_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm_mask2_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm_mask2_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm_mask2_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 idx 复制元素) |
| _mm_mask2_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的对应选择器和索引在 a 和 b 中的通道中对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 idx 复制元素)。 |
| _mm_mask3_fmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 c 复制元素)。 |
| _mm_mask3_fmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm_mask3_fmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，并将中间结果与较低的元素 in c. Store 的结果相加，使用 writemask k 在 dst 的较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置)，然后将 c 的上部元素复制到 dst 的上部元素。 |
| _mm_mask3_fmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，并将中间结果加到较低元素 in c. Store 中，并使用 writemask k 将结果存储到 dst 较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置)，然后将 c 的高 3 个包装的元素复制到 dst 的高元素。 |
| _mm_mask3_fmadd_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，并将中间结果与较低的元素 in c. Store 的结果相加，使用 writemask k 在 dst 的较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置)，然后将 c 的上部元素复制到 dst 的上部元素。 |
| _mm_mask3_fmadd_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，并将中间结果加到较低元素 in c. Store 中，并使用 writemask k 将结果存储到 dst 较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置)，然后将 c 的高 3 个包装的元素复制到 dst 的高元素。 |
| _mm_mask3_fmaddsub_pd⚠ | Experimentalavx512f,avx512vl在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm_mask3_fmaddsub_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素，或者在 to/from 中将中间结果乘以包装的元素加减乘以 x，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 c 复制元素) 放)。 |
| _mm_mask3_fmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm_mask3_fmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。 |
| _mm_mask3_fmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时，从 c 复制元素)，并将 c 上的上层元素复制到 dst 的上层元素。 |
| _mm_mask3_fmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高 3 个包装的元素从 c 复制到 dst 的上部元素。 |
| _mm_mask3_fmsub_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时，从 c 复制元素)，并将 c 上的上层元素复制到 dst 的上层元素。 |
| _mm_mask3_fmsub_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高 3 个包装的元素从 c 复制到 dst 的上部元素。 |
| _mm_mask3_fmsubadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm_mask3_fmsubadd_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素，或者在中间结果中减去并在 c from/to 中包装的元素相乘，然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。 |
| _mm_mask3_fnmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm_mask3_fnmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 c 复制)。 |
| _mm_mask3_fnmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置)，然后将 c 的上部元素复制到 dst 的上部元素。 |
| _mm_mask3_fnmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用写掩码 k 将取反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置)，然后将 c 的高 3 个包装的元素复制到 dst 的高元素。 |
| _mm_mask3_fnmadd_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置)，然后将 c 的上部元素复制到 dst 的上部元素。 |
| _mm_mask3_fnmadd_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用写掩码 k 将取反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置)，然后将 c 的高 3 个包装的元素复制到 dst 的高元素。 |
| _mm_mask3_fnmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 c 复制元素)。 |
| _mm_mask3_fnmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 c 复制元素)。 |
| _mm_mask3_fnmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时，从 c 复制元素)，并将 c 上的上层元素复制到 dst 的上层元素。 |
| _mm_mask3_fnmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高 3 个包装的元素从 c 复制到 dst 的上部元素。 |
| _mm_mask3_fnmsub_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时，从 c 复制元素)，并将 c 上的上层元素复制到 dst 的上层元素。 |
| _mm_mask3_fnmsub_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高 3 个包装的元素从 c 复制到 dst 的上部元素。 |
| _mm_mask_abs_epi8⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 8 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制) |
| _mm_mask_abs_epi16⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 16 位整数的绝对值，并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_abs_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的有符号 32 位整数的绝对值，并使用 writemask k 将无符号结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_add_epi8⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中添加包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_add_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中添加包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_add_epi32⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_add_epi64⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_add_pd⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_add_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_add_round_sd⚠ | Experimentalavx512f在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并从中复制较高的元素。a 到 dst 的高位元素。 |
| _mm_mask_add_round_ss⚠ | Experimentalavx512f在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时，该元素是从 src 复制的)，并复制高位 3 从 a 到 dst 的高位元素。 |
| _mm_mask_add_sd⚠ | Experimentalavx512f在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并从中复制较高的元素。a 到 dst 的高位元素。 |
| _mm_mask_add_ss⚠ | Experimentalavx512f在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时，该元素是从 src 复制的)，并复制高位 3 从 a 到 dst 的高位元素。 |
| _mm_mask_adds_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_adds_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_adds_epu8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_adds_epu16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_alignr_epi8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果，将结果右移 imm8 字节，并使用写掩码 k 将低 16 个字节存储在 dst 中 (当相应的掩码位为 1 时，元素从 src 复制没有设置)。 |
| _mm_mask_alignr_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成一个 32 字节的 immediate 结果，将结果右移 imm8 个 32 位元素，并使用 writemask k 将低 16 字节 (4 个元素) 存储在 dst 中 (当对应的掩码位为没有设置)。 |
| _mm_mask_alignr_epi64⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 32 字节的 immediate 结果，将结果右移 imm8 个 64 位元素，并使用 writemask k 将低 16 字节 (2 个元素) 存储在 dst 中 (当相应的掩码位为没有设置)。 |
| _mm_mask_and_epi32⚠ | Experimentalavx512f,avx512vl在包装的 a 和 b 的 32 位整数元素之间执行逐个元素的按位 AND，使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_and_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 src 复制元素)。 |
| _mm_mask_andnot_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 32 位整数的按位 NOT，然后与 b 计算 AND，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_andnot_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 64 位整数的按位 NOT，然后与 b 计算 AND，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_avg_epu8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 8 位整数平均，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_avg_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数进行平均，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_bitshuffle_epi64_mask⚠ | Experimentalavx512bitalg,avx512vl将输入 |
| _mm_mask_blend_epi8⚠ | Experimentalavx512bw,avx512vl使用控制掩码 k 混合 a 和 b 中的包装 8 位整数，并将结果存储在 dst 中。 |
| _mm_mask_blend_epi16⚠ | Experimentalavx512bw,avx512vl使用控制掩码 k 混合来自 a 和 b 的包装的 16 位整数，并将结果存储在 dst 中。 |
| _mm_mask_blend_epi32⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合 a 和 b 中的包装 32 位整数，并将结果存储在 dst 中。 |
| _mm_mask_blend_epi64⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合 a 和 b 中的包装 64 位整数，并将结果存储在 dst 中。 |
| _mm_mask_blend_pd⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合来自 a 和 b 的包装后的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm_mask_blend_ps⚠ | Experimentalavx512f,avx512vl使用控制掩码 k 混合来自 a 和 b 的包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm_mask_broadcastb_epi8⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将 d 的低包装的 8 位整数广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_broadcastd_epi32⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_broadcastq_epi64⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_broadcastss_ps⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将低单精度 (32-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，将元素从 src 复制)。 |
| _mm_mask_broadcastw_epi16⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_cmp_epi8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmp_epi16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmp_epi32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 32 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmp_epi64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmp_epu8_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmp_epu16_mask⚠ | Experimentalavx512bw,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmp_epu32_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmp_epu64_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmp_pd_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmp_ps_mask⚠ | Experimentalavx512f,avx512vl根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmp_round_sd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。 |
| _mm_mask_cmp_round_ss_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。 |
| _mm_mask_cmp_sd_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。 |
| _mm_mask_cmp_ss_mask⚠ | Experimentalavx512f根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。 |
| _mm_mask_cmpeq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpeq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否相等，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpeq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmpeq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 64 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpeq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpeq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpeq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpeq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数是否等于或大于等于，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于等于，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpge_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数是否大于，并将结果使用零掩码 k1 存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpgt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否大于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmple_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmple_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数 (小于或等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmple_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmple_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数 (小于等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmple_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmple_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmple_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmple_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数 (小于或等于)，然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_mask_cmplt_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数小于零，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数以得到小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否小于等于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmplt_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否小于，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpneq_epi8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_mask_cmpneq_epi16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpneq_epi32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的 32 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpneq_epi64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_mask_cmpneq_epu8_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpneq_epu16_mask⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpneq_epu32_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_cmpneq_epu64_mask⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数是否不相等，并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_mask_compress_epi8⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 8 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst，并通过 src 中的其余元素。 |
| _mm_mask_compress_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 16 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst，并通过 src 中的其余元素。 |
| _mm_mask_compress_epi32⚠ | Experimentalavx512f,avx512vl将活动的 32 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst，并通过 src 中的其余元素。 |
| _mm_mask_compress_epi64⚠ | Experimentalavx512f,avx512vl将活动的 64 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst，并通过 src 中的其余元素。 |
| _mm_mask_compress_pd⚠ | Experimentalavx512f,avx512vl将活动的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位在写掩码 k 中设置) 到 dst，并通过 src 中的其余元素。 |
| _mm_mask_compress_ps⚠ | Experimentalavx512f,avx512vl将活动的单精度 (32-bit) 浮点元素连续存储在 dst 中 (将其各自的位设置在写掩码 k 中的那些元素中) 存储到 dst，并通过 src 中的其余元素。 |
| _mm_mask_conflict_epi32⚠ | Experimentalavx512cd,avx512vl使用写掩码 k (在未设置相应的掩码位时从 src 复制元素)，测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm_mask_conflict_epi64⚠ | Experimentalavx512cd,avx512vl使用写掩码 k 测试 a 的每个 64 位元素是否与所有其他元素相等 (更接近最低有效位) (当未设置相应的掩码位时，从 src 复制元素)。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm_mask_cvt_roundps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvt_roundsd_ss⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_cvt_roundss_sd⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_cvtepi8_epi16⚠ | Experimentalavx512bw,avx512vl使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi8_epi32⚠ | Experimentalavx512f,avx512vl符号将包装的 8 位整数从 a 扩展为包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi8_epi64⚠ | Experimentalavx512f,avx512vl将 a 的低 2 字节中的 8 位整数符号扩展为包装的 64 位整数，并使用 writemask k 将结果存入 dst 中 (未设置相应掩码位时从 src 复制元素)。 |
| _mm_mask_cvtepi16_epi8⚠ | Experimentalavx512bw,avx512vl将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi16_epi32⚠ | Experimentalavx512f,avx512vl符号将包装后的 16 位整数从 a 扩展为包装后的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi16_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi16_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtepi32_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi32_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi32_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi32_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi32_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数在 a 中转换为带有截断的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtepi32_storeu_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 32 位整数转换为带截断的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带有截断的包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的 16 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepi64_storeu_epi8⚠ | Experimentalavx512f,avx512vl将 a 中包装的 64 位整数转换为包装的 8 位整数并截断，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。 |
| _mm_mask_cvtepi64_storeu_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtepi64_storeu_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtepu8_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepu8_epi32⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数在 a 的低 4 字节到包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm_mask_cvtepu8_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数在 a 的低 2 字节到包装的 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm_mask_cvtepu16_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepu16_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 16 位整数 a 的低 4 字节到包装的 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm_mask_cvtepu32_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtepu32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512vl将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 writemask k 将结果存储在单个 vector dst 中 (当对应的掩码位为没有设置)。 |
| _mm_mask_cvtpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtpd_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtph_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtps_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtsd_ss⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_cvtsepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装带符号的 16 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtsepi16_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将包装在 a 中的有符号 16 位整数转换为有符号饱和的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtsepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtsepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtsepi32_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 8 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtsepi32_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 16 位整数，并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtsepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtsepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtsepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtsepi64_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtsepi64_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtsepi64_storeu_epi32⚠ | Experimentalavx512f,avx512vl将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtss_sd⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_cvttpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvttpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvttps_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvttps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtusepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtusepi16_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将包装在 a 中的无符号 16 位整数转换为具有无符号饱和的包装的无符号 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtusepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_cvtusepi32_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtusepi32_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtusepi32_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的无符号 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtusepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_cvtusepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_cvtusepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_cvtusepi64_storeu_epi8⚠ | Experimentalavx512f,avx512vl将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 8 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。 |
| _mm_mask_cvtusepi64_storeu_epi16⚠ | Experimentalavx512f,avx512vl将包装在 a 中的无符号 64 位整数转换为具有无符号饱和的包装的 16 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_cvtusepi64_storeu_epi32⚠ | Experimentalavx512f,avx512vl将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 32 位整数，并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。 |
| _mm_mask_dbsad_epu8⚠ | Experimentalavx512bw,avx512vl计算 a 中的无符号 8 位整数与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs)，并使用写掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm_mask_div_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_div_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_div_round_sd⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_div_round_ss⚠ | Experimentalavx512f将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 时，该元素从 src 复制 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_div_sd⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_div_ss⚠ | Experimentalavx512f将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 时，该元素从 src 复制 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_dpbf16_ps⚠ | Experimentalavx512bf16,avx512vl计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间的单精度 (32-bit) 浮点元素与 src 中的元素相加，并使用 writemask k 将结果存储在 dst 中 (当对应的元素从 src 复制时掩码位未设置)。 |
| _mm_mask_dpbusd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (未设置相应掩码位时从 src 复制元素)。 |
| _mm_mask_dpbusds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。使用符号饱和将这 4 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_dpwssd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm_mask_dpwssds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm_mask_expand_epi8⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_expand_epi16⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_expand_epi32⚠ | Experimentalavx512f,avx512vl从 a 加载连续的有效 32 位整数 (它们各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_expand_epi64⚠ | Experimentalavx512f,avx512vl从 a 加载连续的有效 64 位整数 (它们各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_expand_pd⚠ | Experimentalavx512f,avx512vl从 a 加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_expand_ps⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_fixupimm_pd⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (未设置相应的 mask 位时从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm_mask_fixupimm_ps⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，从 a 复制元素)。imm8 用于设置所需的标志报告。 |
| _mm_mask_fixupimm_round_sd⚠ | Experimentalavx512f使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。 |
| _mm_mask_fixupimm_round_ss⚠ | Experimentalavx512f使用 c 中的较低 32 位整数修复 a 和 b 中的较低单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。 |
| _mm_mask_fixupimm_sd⚠ | Experimentalavx512f使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。 |
| _mm_mask_fixupimm_ss⚠ | Experimentalavx512f使用 c 中的较低 32 位整数修复 a 和 b 中的较低单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。 |
| _mm_mask_fmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm_mask_fmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。 |
| _mm_mask_fmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，并使用 writemask k 将中间结果添加到 dst 较低元素中的较低元素 in c. Store 的结果 (当未使用掩码位 0 时从 a 复制该元素) set)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_fmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，并将中间结果加到较低元素 in c. Store 中，并使用 writemask k 将结果添加到 dst 较低元素中 (当未使用 mask bit 0 时从 a 复制该元素设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_fmadd_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，并使用 writemask k 将中间结果添加到 dst 较低元素中的较低元素 in c. Store 的结果 (当未使用掩码位 0 时从 a 复制该元素) set)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_fmadd_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，并将中间结果加到较低元素 in c. Store 中，并使用 writemask k 将结果添加到 dst 较低元素中 (当未使用 mask bit 0 时从 a 复制该元素设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_fmaddsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 中复制元素放)。 |
| _mm_mask_fmaddsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。 |
| _mm_mask_fmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位，则从 a 复制元素)。 |
| _mm_mask_fmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 a 复制元素)。 |
| _mm_mask_fmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 a 复制该元素)，然后将 a 的上部元素复制到 dst 的上部元素。 |
| _mm_mask_fmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时从 a 复制该元素)，并将高 3 个压缩元素从 a 复制到 dst 的高位元素。 |
| _mm_mask_fmsub_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 a 复制该元素)，然后将 a 的上部元素复制到 dst 的上部元素。 |
| _mm_mask_fmsub_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。将结果存储在 dst 的下部元素中，并将上部 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_mask_fmsubadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时，元素将从 a 复制放)。 |
| _mm_mask_fmsubadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将中间结果中的包装后的元素 from/to 减去并相加，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 a 复制元素放)。 |
| _mm_mask_fnmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm_mask_fnmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm_mask_fnmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 a 复制 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_fnmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用写掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时，该元素是从 a 复制的 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_fnmadd_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 a 复制 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_fnmadd_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用写掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时，该元素是从 a 复制的 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_fnmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm_mask_fnmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 a 复制元素)。 |
| _mm_mask_fnmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高位元素从 a 复制到 dst 的高位元素。 |
| _mm_mask_fnmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_mask_fnmsub_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高位元素从 a 复制到 dst 的高位元素。 |
| _mm_mask_fnmsub_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素)，并将高 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_mask_getexp_pd⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm_mask_getexp_ps⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，并使用 writemask k 将结果存储在 dst 中 (当相应的 mask 时，元素从 src 复制位未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm_mask_getexp_round_sd⚠ | Experimentalavx512f将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数，使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置屏蔽位 0 时)，然后将 a 的高位元素复制到 dst 的高位元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_mask_getexp_round_ss⚠ | Experimentalavx512f将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置掩码位 0 时)，并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_mask_getexp_sd⚠ | Experimentalavx512f将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数，使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置屏蔽位 0 时)，然后将 a 的高位元素复制到 dst 的高位元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_mask_getexp_ss⚠ | Experimentalavx512f将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置掩码位 0 时)，并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_mask_getmant_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_mask_getmant_ps⚠ | Experimentalavx512f,avx512vl标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_mask_getmant_round_sd⚠ | Experimentalavx512f标准化 b 中下部双精度 (64-bit) 浮点元素的尾数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部元素从 a 到 dst 的高位元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_mask_getmant_round_ss⚠ | Experimentalavx512f标准化 b 中较低单精度 (32-bit) 浮点元素的尾数，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制高 3 从 a 到 dst 的上层元素的包装的元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_mask_getmant_sd⚠ | Experimentalavx512f标准化 b 中下部双精度 (64-bit) 浮点元素的尾数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部元素从 a 到 dst 的高位元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_mask_getmant_ss⚠ | Experimentalavx512f标准化 b 中较低单精度 (32-bit) 浮点元素的尾数，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制高 3 从 a 到 dst 的上层元素的包装的元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_mask_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm_mask_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm_mask_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm_mask_lzcnt_epi32⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 32 位整数中前导零位的数目，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_lzcnt_epi64⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 64 位整数中前导零位的数目，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_madd_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对，并使用 writemask k 将结果打包到 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_maddubs_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘，生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对，并使用写掩码 k 将饱和结果包装到 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 16 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_max_round_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的元素从 a 到 dst 的高位元素。 |
| _mm_mask_max_round_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_mask_max_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的元素从 a 到 dst 的高位元素。 |
| _mm_mask_max_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_mask_min_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的单精度 (32-bit) 浮点元素，并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_min_round_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，然后复制较高的元素从 a 到 dst 的高位元素。 |
| _mm_mask_min_round_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_mask_min_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，然后复制较高的元素从 a 到 dst 的高位元素。 |
| _mm_mask_min_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_mask_mov_epi8⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将包装的 8 位整数从 a 移到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_mov_epi16⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将包装的 16 位整数从 a 移到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_mov_epi32⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的 32 位整数从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_mov_epi64⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的 64 位整数从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_mov_pd⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_mov_ps⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移动到 dst (未设置相应的掩码位时，将从 src 复制元素)。 |
| _mm_mask_move_sd⚠ | Experimentalavx512f使用写掩码 k 将低位双精度 (64-bit) 浮点元素从 b 移到 dst 的低位元素 (当未设置掩码位 0 时从 src 复制该元素)，并将高位元素从 a 复制到 a 的高位元素 dst。 |
| _mm_mask_move_ss⚠ | Experimentalavx512f使用写掩码 k 将低位单精度 (32-bit) 浮点元素从 b 移到 dst 的低位元素 (当未设置掩码位 0 时从 src 复制该元素)，并将高 3 个包装的元素从 a 复制到高位 dst 的元素。 |
| _mm_mask_movedup_pd⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_movehdup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_moveldup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_mul_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘，并使用写掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_mul_epu32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并使用写掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_mul_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_mul_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_mul_round_sd⚠ | Experimentalavx512f将 a 和 b 中的下部双精度 (64-bit) 浮点元素相乘，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并从中复制上部元素。a 到 dst 的高位元素。 |
| _mm_mask_mul_round_ss⚠ | Experimentalavx512f将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制包装后的高 3 位元素从 a 到 dst 的高位元素。 |
| _mm_mask_mul_sd⚠ | Experimentalavx512f将 a 和 b 中的下部双精度 (64-bit) 浮点元素相乘，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并从中复制上部元素。a 到 dst 的高位元素。 |
| _mm_mask_mul_ss⚠ | Experimentalavx512f将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制包装后的高 3 位元素从 a 到 dst 的高位元素。 |
| _mm_mask_mulhi_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的带符号的 16 位整数相乘，生成 32 位中间整数，并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_mulhi_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数相乘，生成 32 位中间整数，并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_mulhrs_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，通过加 1 舍入，并使用 writemask k 将位 [16:1] 存储到 dst (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_mullo_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并使用写掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_mullo_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并使用写掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_multishift_epi64_epi8⚠ | Experimentalavx512vbmi,avx512vl对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并使用 writemask k (元素当相应的屏蔽位未设置时，从 src 复制)。 |
| _mm_mask_or_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位或，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_or_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位或，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_packs_epi16⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_packs_epi32⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_packus_epi16⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_packus_epi32⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_permute_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_permute_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_permutevar_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 的双精度 (64-bit) 浮点元素进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_permutevar_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 的单精度 (32-bit) 浮点元素打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm_mask_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm_mask_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm_mask_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 64 位整数，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm_mask_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm_mask_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在 a 和 b 中的通道上对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 a 复制)。 |
| _mm_mask_permutexvar_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应索引在跨通道的 a 中打乱 8 位整数，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_permutexvar_epi16⚠ | Experimentalavx512bw,avx512vl使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_popcnt_epi8⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_mask_popcnt_epi16⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_mask_popcnt_epi32⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_mask_popcnt_epi64⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm_mask_rcp14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rcp14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rcp14_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，并复制较高的 x 元素从 a 到 dst 的高位元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rcp14_ss⚠ | Experimentalavx512f计算 b 中下部单精度 (32-bit) 浮点元素的近似倒数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rol_epi32⚠ | Experimentalavx512f,avx512vl将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_rol_epi64⚠ | Experimentalavx512f,avx512vl将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_rolv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向左旋转 b 对应元素 b 中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm_mask_rolv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向左旋转 b 的对应元素中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm_mask_ror_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_ror_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_rorv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向右旋转 b 的对应元素中指定的位数，然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm_mask_rorv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位，则从 src 复制元素放)。 |
| _mm_mask_roundscale_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_roundscale_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_roundscale_round_sd⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素四舍五入为 imm8 指定的分数位数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时，该元素从 src 复制)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_roundscale_round_ss⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时，该元素从 src 复制)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_roundscale_sd⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素四舍五入为 imm8 指定的分数位数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时，该元素从 src 复制)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_roundscale_ss⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时，该元素从 src 复制)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_rsqrt14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rsqrt14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rsqrt14_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的近似平方根，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，然后复制从 a 到 dst 的上元素的上元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_rsqrt14_ss⚠ | Experimentalavx512f计算 b 中较低单精度 (32-bit) 浮点元素的近似倒数平方根，使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素)，然后复制从 a 到 dst 的高位元素的前 3 个包装的元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_mask_scalef_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_scalef_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_scalef_round_sd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部元素从 a 到 dst 的高位元素。 |
| _mm_mask_scalef_round_ss⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的下部元素 (未设置 mask bit 0 时从 src 复制该元素)，并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。 |
| _mm_mask_scalef_sd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部元素从 a 到 dst 的高位元素。 |
| _mm_mask_scalef_ss⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 的下部元素 (未设置 mask bit 0 时从 src 复制该元素)，并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。 |
| _mm_mask_set1_epi8⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_set1_epi16⚠ | Experimentalavx512bw,avx512vl使用写掩码 k 向 dst 的所有元素广播 16 位整数 a (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_set1_epi32⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_set1_epi64⚠ | Experimentalavx512f,avx512vl使用写掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_shldi_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_shldi_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_shldi_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_shldv_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm_mask_shldv_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm_mask_shldv_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量，并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 复制)。 |
| _mm_mask_shrdi_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_shrdi_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，从 src 复制元素)。 |
| _mm_mask_shrdi_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素从 src` 复制)。 |
| _mm_mask_shrdv_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm_mask_shrdv_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素从 a 中复制)。 |
| _mm_mask_shrdv_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量，并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，从 a 复制元素)。 |
| _mm_mask_shuffle_epi8⚠ | Experimentalavx512bw,avx512vl使用 b 中相应的 8 位元素中的控件在 128 位通道内对 a 中的 8 位整数进行打乱，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_shuffle_epi32⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件将 128 位通道中的 32 位整数随机排列，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_shuffle_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件对 128 位通道中的双精度 (64-bit) 浮点元素进行混洗，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_shuffle_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件 shuffle a 中的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素从 src 复制)。 |
| _mm_mask_shufflehi_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，将 128 位通道的低 64 位从 a 复制到 dst，使用写掩码 k (当相应的掩码位不存在时，元素从 src 复制放)。 |
| _mm_mask_shufflelo_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，并使用写掩码 k 将 128 位通道的高 64 位从 a 复制到 dst (当未使用相应的掩码位时，元素从 src 复制) 放)。 |
| _mm_mask_sll_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数左移，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sll_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移计数，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sll_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数左移计数，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_slli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数左移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_slli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_slli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数向左移动 imm8，同时向零移动，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sllv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按 count 中相应元素指定的数量向左移位，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sllv_epi32⚠ | Experimentalavx512f,avx512vl将填充的 32 位整数向左移动计数中相应元素指定的数量，同时将其移位为零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sllv_epi64⚠ | Experimentalavx512f,avx512vl将填充的 64 位整数向左移动 count 中相应元素指定的数量，同时将其移位为零，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素将从 src 复制)。 |
| _mm_mask_sqrt_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sqrt_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sqrt_round_sd⚠ | Experimentalavx512f计算 b 中下部双精度 (64-bit) 浮点元素的平方根，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部元素从 a 到 dst 的高位元素。 |
| _mm_mask_sqrt_round_ss⚠ | Experimentalavx512f计算 b 中下部单精度 (32-bit) 浮点元素的平方根，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。 |
| _mm_mask_sqrt_sd⚠ | Experimentalavx512f计算 b 中下部双精度 (64-bit) 浮点元素的平方根，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部元素从 a 到 dst 的高位元素。 |
| _mm_mask_sqrt_ss⚠ | Experimentalavx512f计算 b 中下部单精度 (32-bit) 浮点元素的平方根，使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素)，并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。 |
| _mm_mask_sra_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数右移，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sra_epi32⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sra_epi64⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srai_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srai_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srai_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srav_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 count 中相应元素指定的数量，同时将符号位移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srav_epi32⚠ | Experimentalavx512f,avx512vl在将符号位移位的同时，将已包装的 32 位整数向右移动计数中相应元素指定的数量，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srav_epi64⚠ | Experimentalavx512f,avx512vl在移入符号位的同时，将包装的 64 位整数向右移动计数中相应元素指定的数量，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srl_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srl_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移，同时移零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srl_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移，同时移零，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srlv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srlv_epi32⚠ | Experimentalavx512f,avx512vl向右移动包装的 32 位整数整数 (由 count 中相应元素指定的数量)，同时向零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_srlv_epi64⚠ | Experimentalavx512f,avx512vl向右移位包装的 64 位整数，其数量为计数中相应元素指定的数量，同时向零移位，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_epi8⚠ | Experimentalavx512bw,avx512vl从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_epi16⚠ | Experimentalavx512bw,avx512vl从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_epi32⚠ | Experimentalavx512f,avx512vl从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_epi64⚠ | Experimentalavx512f,avx512vl从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_pd⚠ | Experimentalavx512f,avx512vl从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_ps⚠ | Experimentalavx512f,avx512vl将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_sub_round_sd⚠ | Experimentalavx512f从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时，该元素是从 src 复制的 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_sub_round_ss⚠ | Experimentalavx512f从 a 中的较低单精度 (32-bit) 浮点元素减去 b 中的较低单精度 (32-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_sub_sd⚠ | Experimentalavx512f从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中较低的双精度 (64-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时，该元素是从 src 复制的 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_mask_sub_ss⚠ | Experimentalavx512f从 a 中的较低单精度 (32-bit) 浮点元素减去 b 中的较低单精度 (32-bit) 浮点元素，使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_mask_subs_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度将 b 中的包装 8 位整数减去 b 中的包装 8 位有符号整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_subs_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_subs_epu8⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_subs_epu16⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度从 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 src 复制元素)。 |
| _mm_mask_ternarylogic_epi32⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 32 位整数中的每一位，使用 src、a 和 b 中的相应位形成 imm8 的 3 位索引，并使用 writemask 将 imm8 中该位的值写入 dst 中的相应位 k 在 32 位粒度 (当相应的掩码位未设置时，从 src 复制 32 位元素)。 |
| _mm_mask_ternarylogic_epi64⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，src、a 和 b 中的相应位用于形成 imm8 的 3 位索引，并使用 writemask 将 imm8 中该位的值写入 dst 中的相应位 k 在 64 位粒度 (当相应的掩码位未设置时，从 src 复制 64 位元素)。 |
| _mm_mask_test_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位与，生成中间 8 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm_mask_test_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位与，生成中间的 16 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm_mask_test_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位与，生成中间的 32 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm_mask_test_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，生成中间 64 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm_mask_testn_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位 NAND，生成中间的 8 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm_mask_testn_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位 NAND，生成中间的 16 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm_mask_testn_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 NAND，生成中间的 32 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (服从写掩码 k)。 |
| _mm_mask_testn_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 NAND，生成中间 64 位值，如果中间值为零，则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。 |
| _mm_mask_unpackhi_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_unpackhi_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_unpackhi_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_unpackhi_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_unpackhi_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm_mask_unpackhi_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm_mask_unpacklo_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 8 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_unpacklo_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 16 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_unpacklo_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，从 src 复制元素)。 |
| _mm_mask_unpacklo_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 64 位整数，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_unpacklo_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包并交织双精度 (64-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm_mask_unpacklo_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包并交织单精度 (32-bit) 浮点元素，并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时从 src 复制元素)。 |
| _mm_mask_xor_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 XOR，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_mask_xor_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 XOR，并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将从 src 复制)。 |
| _mm_maskz_abs_epi8⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 8 位整数的绝对值，并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_abs_epi16⚠ | Experimentalavx512bw,avx512vl计算 a 中包装的带符号的 16 位整数的绝对值，并使用零掩码 k (将未设置相应掩码位的元素清零) 将无符号结果存储在 dst 中。 |
| _mm_maskz_abs_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的有符号 32 位整数的绝对值，并使用 zeromask k 将无符号结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_add_epi8⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中添加包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_add_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数添加到 a 和 b 中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_add_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数添加到 a 和 b 中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_add_epi64⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_add_pd⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_add_ps⚠ | Experimentalavx512f,avx512vl在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_add_round_sd⚠ | Experimentalavx512f在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零)，然后从 a 中复制较高的元素到 dst 的上层元素。 |
| _mm_maskz_add_round_ss⚠ | Experimentalavx512f在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素归零)，并复制较高的 3 个包装的元素从 a 到 dst 的上层元素。 |
| _mm_maskz_add_sd⚠ | Experimentalavx512f在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零)，然后从 a 中复制较高的元素到 dst 的上层元素。 |
| _mm_maskz_add_ss⚠ | Experimentalavx512f在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素归零)，并复制较高的 3 个包装的元素从 a 到 dst 的上层元素。 |
| _mm_maskz_adds_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_adds_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_adds_epu8⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_adds_epu16⚠ | Experimentalavx512bw,avx512vl使用饱和度在 a 和 b 中添加包装的无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_alignr_epi8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的 16 字节块对连接成一个 32 字节的临时结果，将结果右移 imm8 字节，并使用零掩码 k 将低 16 字节存储在 dst 中 (当未使用相应的掩码位时元素清零) 放)。 |
| _mm_maskz_alignr_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 32 字节的 immediate 结果，将结果右移 imm8 个 32 位元素，并使用 zeromask k 将低 16 字节 (4 个元素) 存储在 dst 中 (当相应的掩码位不存在时，元素被清零放)。 |
| _mm_maskz_alignr_epi64⚠ | Experimentalavx512f,avx512vl将 a 和 b 连接成 32 字节的 immediate 结果，将结果右移 imm8 个 64 位元素，并使用 zeromask k 将低 16 字节 (2 个元素) 存储在 dst 中 (当相应的掩码位不存在时，元素被清零放)。 |
| _mm_maskz_and_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位与，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_and_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_andnot_epi32⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 32 位整数的按位 NOT，然后计算 b 中的 AND，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_andnot_epi64⚠ | Experimentalavx512f,avx512vl计算 a 中包装的 64 位整数的按位 NOT，然后与 b 计算 AND，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_avg_epu8⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 8 位整数进行平均，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_avg_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数进行平均，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_broadcastb_epi8⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将低包装的 8 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_broadcastd_epi32⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_broadcastq_epi64⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_broadcastss_ps⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将低单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_broadcastw_epi16⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_compress_epi8⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 8 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst，并将其余元素设置为零。 |
| _mm_maskz_compress_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 a 中的活动 16 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst，并将其余元素设置为零。 |
| _mm_maskz_compress_epi32⚠ | Experimentalavx512f,avx512vl将活动的 32 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst，并将其余元素设置为零。 |
| _mm_maskz_compress_epi64⚠ | Experimentalavx512f,avx512vl将活动的 64 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst，并将其余元素设置为零。 |
| _mm_maskz_compress_pd⚠ | Experimentalavx512f,avx512vl将活动的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst，并将其余元素设置为零。 |
| _mm_maskz_compress_ps⚠ | Experimentalavx512f,avx512vl将活动的单精度 (32-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst，并将其余元素设置为零。 |
| _mm_maskz_conflict_epi32⚠ | Experimentalavx512cd,avx512vl使用零掩码 k (在未设置相应的掩码位时将元素清零)，测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm_maskz_conflict_epi64⚠ | Experimentalavx512cd,avx512vl使用零掩码 k (在未设置相应的掩码位时将元素清零)，测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。 |
| _mm_maskz_cvt_roundps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvt_roundsd_ss⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_cvt_roundss_sd⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_cvtepi8_epi16⚠ | Experimentalavx512bw,avx512vl使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtepi8_epi32⚠ | Experimentalavx512f,avx512vl使用符号将包装的 8 位整数从 a 扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi8_epi64⚠ | Experimentalavx512f,avx512vl将 a 的低 2 字节中的 8 位整数符号扩展为包装的 64 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_cvtepi16_epi8⚠ | Experimentalavx512bw,avx512vl将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi16_epi32⚠ | Experimentalavx512f,avx512vl符号将包装的 16 位整数从 a 扩展为包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtepi16_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi32_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi32_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi32_epi64⚠ | Experimentalavx512f,avx512vl使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtepi32_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素，并使用零掩码 k (未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm_maskz_cvtepi64_epi8⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带截断的 8 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi64_epi16⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的 64 位整数转换为带截断的 16 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtepu8_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_cvtepu8_epi32⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数 a 的后 4 个字节到包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_cvtepu8_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 8 位整数在 a 的低 2 字节到包装的 64 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_cvtepu16_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_cvtepu16_epi64⚠ | Experimentalavx512f,avx512vl零扩展包装的无符号 16 位整数在 a 的低 4 字节到包装的 64 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_cvtepu32_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_cvtepu32_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtne2ps_pbh⚠ | Experimentalavx512bf16,avx512vl将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在单个 vector dst 中 (当对应的掩码位不存在时，元素归零放)。 |
| _mm_maskz_cvtpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvtpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvtpd_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvtph_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvtps_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvtps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvtps_ph⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvtsd_ss⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_cvtsepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_cvtsepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_cvtsepi32_epi16⚠ | Experimentalavx512f,avx512vl将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数，并将结果存储在 dst 中。 |
| _mm_maskz_cvtsepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装有符号 64 位整数转换为带符号饱和的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtsepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtsepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtss_sd⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_cvttpd_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。 |
| _mm_maskz_cvttpd_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_cvttps_epi32⚠ | Experimentalavx512f,avx512vl将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_cvttps_epu32⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_cvtusepi16_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtusepi32_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtusepi32_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtusepi64_epi8⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_cvtusepi64_epi16⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_cvtusepi64_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_dbsad_epu8⚠ | Experimentalavx512bw,avx512vl计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs) 的总和，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将 16 位结果存储在 dst 中。对于每个 64 位通道，在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中通道的低 8 位四元组，而后两个 SAD 使用 a 中通道的较高 8 位四元组。根据 imm8 中的控件，从 128 位通道中选择 b 中的四元组，并且每个 64 位通道中的每个 SAD 使用 8 位偏移量的选定四元组。 |
| _mm_maskz_div_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_div_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_div_round_sd⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 为 0 时，该元素归零 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_div_round_ss⚠ | Experimentalavx512f将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 为 0 时，该元素清零) (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_div_sd⚠ | Experimentalavx512f将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 为 0 时，该元素归零 (未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_div_ss⚠ | Experimentalavx512f将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 为 0 时，该元素清零) (未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_dpbf16_ps⚠ | Experimentalavx512bf16,avx512vl计算 a 和 b 中 BF16 (16-bit) 浮点对的点积，将中间单精度 (32-bit) 浮点元素与 src 中的元素进行累加，并将结果存储在 dst 中使用 zeromask k (当对应的掩码为位未设置)。 |
| _mm_maskz_dpbusd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加，并将包装的 32 位结果使用 zeromask k 存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_dpbusds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘，产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数用带符号饱和求和，并将包装的 32 位结果用 zeromask k 存储在 dst 中 (当对应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_dpwssd_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加，并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_dpwssds_epi32⚠ | Experimentalavx512vnni,avx512vl将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘，产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加，并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_expand_epi8⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_expand_epi16⚠ | Experimentalavx512vbmi2,avx512vl从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数)，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_expand_epi32⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的有效 32 位整数 (它们各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_expand_epi64⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的有效 64 位整数 (它们各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_expand_pd⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_expand_ps⚠ | Experimentalavx512f,avx512vl从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置)，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_fixupimm_pd⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的 mask 位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm_maskz_fixupimm_ps⚠ | Experimentalavx512f,avx512vl使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。imm8 用于设置所需的标志报告。 |
| _mm_maskz_fixupimm_round_sd⚠ | Experimentalavx512f使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 的较低元素中 (当不使用掩码位 0 时该元素清零) set)，然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。 |
| _mm_maskz_fixupimm_round_ss⚠ | Experimentalavx512f使用 c 中的较低 32 位整数固定 a 和 b 中的较低单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 的较低元素中 (当未使用掩码 bit 0 时该元素被清零) 设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。 |
| _mm_maskz_fixupimm_sd⚠ | Experimentalavx512f使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 的较低元素中 (当不使用掩码位 0 时该元素清零) set)，然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。 |
| _mm_maskz_fixupimm_ss⚠ | Experimentalavx512f使用 c 中的较低 32 位整数固定 a 和 b 中的较低单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 的较低元素中 (当未使用掩码 bit 0 时该元素被清零) 设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。 |
| _mm_maskz_fmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_fmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_fmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后使用零掩码 k 将中间结果与较低元素 in c. Store 的结果加到 dst 较低元素中 (当未设置掩码位 0 时该元素归零) )，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_fmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用零掩码 k 将中间结果与较低元素 in c. Store 的中间结果相加到 dst 较低元素中 (未设置掩码位 0 时该元素归零) )，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_fmadd_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后使用零掩码 k 将中间结果与较低元素 in c. Store 的结果加到 dst 较低元素中 (当未设置掩码位 0 时该元素归零) )，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_fmadd_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用零掩码 k 将中间结果与较低元素 in c. Store 的中间结果相加到 dst 较低元素中 (未设置掩码位 0 时该元素归零) )，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_fmaddsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_fmaddsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或相减，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_fmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，从中间结果中减去 c 中的包装的元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_fmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_fmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当掩码位 0 未设置时元素被清零)，并将上元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当未设置掩码位 0 时，元素被清零)，并将上 3 个打包元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fmsub_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当掩码位 0 未设置时元素被清零)，并将上元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fmsub_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当未设置掩码位 0 时，元素被清零)，并将上 3 个打包元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fmsubadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘，或者将 C to/from 中的包装后的元素相加或减去，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_fmsubadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，或者将 C from/to 中的包装元素相减并相加，得到中间结果，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_fnmadd_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_fnmadd_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，将取反的中间结果添加到 c 中的包装元素中，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_fnmadd_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，然后使用零掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) set)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_fnmadd_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用零掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) 设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_fnmadd_sd⚠ | Experimentalavx512f将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘，然后使用零掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) set)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_fnmadd_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后使用零掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) 设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_fnmsub_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_fnmsub_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘，从取反的中间结果中减去 c 中的包装元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_fnmsub_round_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 中 (当未设置掩码位 0 时元素被清零)，并将上元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fnmsub_round_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当未设置掩码位 0 时，元素被清零)，并将上 3 个打包元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fnmsub_sd⚠ | Experimentalavx512f将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 中 (当未设置掩码位 0 时元素被清零)，并将上元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_fnmsub_ss⚠ | Experimentalavx512f将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘，然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当未设置掩码位 0 时，元素被清零)，并将上 3 个打包元素从 a 复制到 dst 的上元素。 |
| _mm_maskz_getexp_pd⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm_maskz_getexp_ps⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数，并使用 zeromask k 将结果存储在 dst 中 (当相应的 mask 位为零时，元素被清零未设置)。本质上，此内联函数为每个元素计算 floor(log2(x))。 |
| _mm_maskz_getexp_round_sd⚠ | Experimentalavx512f将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置)，然后将较高的元素从 a 复制到 dst 的较高的元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_maskz_getexp_round_ss⚠ | Experimentalavx512f将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置)，并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_maskz_getexp_sd⚠ | Experimentalavx512f将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置)，然后将较高的元素从 a 复制到 dst 的较高的元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_maskz_getexp_ss⚠ | Experimentalavx512f将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置)，并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上，此内联函数计算下部元素的 floor(log2(x))。 |
| _mm_maskz_getmant_pd⚠ | Experimentalavx512f,avx512vl将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_maskz_getmant_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_maskz_getmant_round_sd⚠ | Experimentalavx512f标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数，使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零)，然后从中复制较高元素。a 到 dst 的高位元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_maskz_getmant_round_ss⚠ | Experimentalavx512f标准化 b 中较低单精度 (32-bit) 浮点元素的尾数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零)，然后复制高位 3 从 a 到 dst 的高位元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_maskz_getmant_sd⚠ | Experimentalavx512f标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数，使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零)，然后从中复制较高元素。a 到 dst 的高位元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_maskz_getmant_ss⚠ | Experimentalavx512f标准化 b 中较低单精度 (32-bit) 浮点元素的尾数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零)，然后复制高位 3 从 a 到 dst 的高位元素。此内联函数本质上计算 ± (2 ^ k) * | x.significand |，其中 k 取决于由 interv 定义的间隔范围，而符号取决于 sc 和源符号。 |
| _mm_maskz_gf2p8affine_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的包装字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2^8 上计算 a * x + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm_maskz_gf2p8affineinv_epi64_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl对 x 中的反向包装的字节执行仿射变换。 也就是说，对于每个包装的字节，在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b，其中 a 是 8x8 位矩阵，b 是恒定 8 位 immediate 数。 |
| _mm_maskz_gf2p8mul_epi8⚠ | Experimentalavx512gfni,avx512bw,avx512vl在包装的字节上执行 GF(2^8) 乘法。 该字段以多项式表示，具有约数多项式 x^8 + x^4 + x^3 + x + 1。 |
| _mm_maskz_lzcnt_epi32⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 32 位整数中前导零位的数目，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_lzcnt_epi64⚠ | Experimentalavx512cd,avx512vl计算 a 中每个包装的 64 位整数中前导零位的数目，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_madd_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对，并使用 zeromask k 将结果打包到 dst (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_maddubs_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘，生成中间有符号的 16 位整数。水平添加相邻的中间有符号 16 位整数对，并使用 zeromask k 将饱和结果打包到 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_max_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_max_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最大值存储在 dst 中。 |
| _mm_maskz_max_round_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后从中复制较高元素。a 到 dst 的高位元素。 |
| _mm_maskz_max_round_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后复制包装后的高 3 位从 a 到 dst 的高位元素。 |
| _mm_maskz_max_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后从中复制较高元素。a 到 dst 的高位元素。 |
| _mm_maskz_max_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后复制包装后的高 3 位从 a 到 dst 的高位元素。 |
| _mm_maskz_min_epi8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号的 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_epi16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的带符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_epi32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_epu8⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 8 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_epu16⚠ | Experimentalavx512bw,avx512vl比较 a 和 b 中包装的无符号 16 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_epu32⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 32 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_pd⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_ps⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中的包装单精度 (32-bit) 浮点元素，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将包装的最小值存储在 dst 中。 |
| _mm_maskz_min_round_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零)，然后从中复制较高元素。a 到 dst 的高位元素。 |
| _mm_maskz_min_round_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后复制包装后的高 3 位从 a 到 dst 的高位元素。 |
| _mm_maskz_min_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零)，然后从中复制较高元素。a 到 dst 的高位元素。 |
| _mm_maskz_min_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后复制包装后的高 3 位从 a 到 dst 的高位元素。 |
| _mm_maskz_mov_epi8⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_mov_epi16⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_mov_epi32⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的 32 位整数从 a 移至 dst (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_mov_epi64⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的 64 位整数从 a 移到 dst (未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_mov_pd⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移到 dst (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_mov_ps⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移到 dst (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_move_sd⚠ | Experimentalavx512f使用零掩码 k 将较低的双精度 (64-bit) 浮点元素从 b 移动到 dst 的较低元素 (未设置掩码位 0 时将该元素清零)，然后将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_maskz_move_ss⚠ | Experimentalavx512f使用零掩码 k 将较低的单精度 (32-bit) 浮点元素从 b 移动到 dst 的较低元素 (未设置掩码位 0 时将该元素清零)，然后将较高的 3 个包装的元素从 a 复制到较高的元素 dst。 |
| _mm_maskz_movedup_pd⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_movehdup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制奇数索引的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_moveldup_ps⚠ | Experimentalavx512f,avx512vl从 a 复制偶数索引的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_mul_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低位有符号 32 位整数相乘，并使用零掩码 k 将有符号的 64 位结果存储在 dst 中 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_mul_epu32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘，并使用零掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_mul_pd⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_mul_ps⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_mul_round_sd⚠ | Experimentalavx512f将 a 和 b 中的低位双精度 (64-bit) 浮点元素相乘，使用零掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时该元素归零)，然后从 a 中复制高位元素到 dst 的上层元素。 |
| _mm_maskz_mul_round_ss⚠ | Experimentalavx512f将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，并复制上部 3 个包装的元素从 a 到 dst 的上层元素。 |
| _mm_maskz_mul_sd⚠ | Experimentalavx512f将 a 和 b 中的低位双精度 (64-bit) 浮点元素相乘，使用零掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时该元素归零)，然后从 a 中复制高位元素到 dst 的上层元素。 |
| _mm_maskz_mul_ss⚠ | Experimentalavx512f将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，并复制上部 3 个包装的元素从 a 到 dst 的上层元素。 |
| _mm_maskz_mulhi_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的带符号的 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_mulhi_epu16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中包装的无符号 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_mulhrs_epi16⚠ | Experimentalavx512bw,avx512vl在 a 和 b 中乘以包装的带符号的 16 位整数，产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位，通过加 1 舍入，并使用 zeromask k 将位 [16:1] 存储到 dst (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_mullo_epi16⚠ | Experimentalavx512bw,avx512vl将 a 和 b 中的包装的 16 位整数相乘，生成中间的 32 位整数，并使用零掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_mullo_epi32⚠ | Experimentalavx512f,avx512vl将 a 和 b 中的包装的 32 位整数相乘，生成中间 64 位整数，并使用零掩码 k (在未设置相应的掩码位时将元素清零) 将中间整数的低 32 位存储在 dst 中。 |
| _mm_maskz_multishift_epi64_epi8⚠ | Experimentalavx512vbmi,avx512vl对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并使用 zeromask k (元素当相应的屏蔽位未设置时被清零)。 |
| _mm_maskz_or_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位或，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_or_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位或，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_packs_epi16⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_packs_epi32⚠ | Experimentalavx512bw,avx512vl使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_packus_epi16⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_packus_epi32⚠ | Experimentalavx512bw,avx512vl使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_permute_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对双精度 (64-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_permute_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道内对单精度 (32-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_permutevar_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 中的双精度 (64-bit) 浮点元素进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_permutevar_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的控件在 128 位通道内将 a 的单精度 (32-bit) 浮点元素打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨通道打乱，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用相应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 32 位整数进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 64 位整数进行混洗，并使用 zeromask k (未设置相应的 mask 位时将元素清零) 将结果存储在 dst 中。 |
| _mm_maskz_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的通道 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_permutexvar_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应索引在跨通道的 a 中打乱 8 位整数，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_permutexvar_epi16⚠ | Experimentalavx512bw,avx512vl使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_popcnt_epi8⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_maskz_popcnt_epi16⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_maskz_popcnt_epi32⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_maskz_popcnt_epi64⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm_maskz_rcp14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rcp14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rcp14_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数，使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零)，然后复制较高元素从 a 到 dst 的高位元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rcp14_ss⚠ | Experimentalavx512f计算 b 中较低的单精度 (32-bit) 浮点元素的近似倒数，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素归零)，并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rol_epi32⚠ | Experimentalavx512f,avx512vl将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_rol_epi64⚠ | Experimentalavx512f,avx512vl将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_rolv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_rolv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_ror_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_ror_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将清零)。 |
| _mm_maskz_rorv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_rorv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零) )。 |
| _mm_maskz_roundscale_pd⚠ | Experimentalavx512f,avx512vl将 x 中的包装双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_roundscale_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_roundscale_round_sd⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零)，并将上一个元素从 a 复制到 dst 的上一个元素。 |
| _mm_maskz_roundscale_round_ss⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素四舍五入为 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零)，并将上面的 3 个包装的元素从 a 复制到 dst 的上面的元素。 |
| _mm_maskz_roundscale_sd⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零)，并将上一个元素从 a 复制到 dst 的上一个元素。 |
| _mm_maskz_roundscale_ss⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素四舍五入为 imm8 指定的分数位数，并使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零)，并将上面的 3 个包装的元素从 a 复制到 dst 的上面的元素。 |
| _mm_maskz_rsqrt14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中的包装的双精度 (64-bit) 浮点元素的近似倒数平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rsqrt14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rsqrt14_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数平方根，使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零)，然后复制从 a 到 dst 的上元素的上元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_rsqrt14_ss⚠ | Experimentalavx512f计算 b 中较低单精度 (32-bit) 浮点元素的近似倒数平方根，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素归零)，然后复制从 a 到 dst 的上层元素的上 3 个包装的元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_maskz_scalef_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_scalef_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_scalef_round_sd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后复制上部元素从 a 到 dst 的高位元素。 |
| _mm_maskz_scalef_round_ss⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，并复制上部 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_maskz_scalef_sd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后复制上部元素从 a 到 dst 的高位元素。 |
| _mm_maskz_scalef_ss⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，并复制上部 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_maskz_set1_epi8⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_set1_epi16⚠ | Experimentalavx512bw,avx512vl使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_set1_epi32⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_set1_epi64⚠ | Experimentalavx512f,avx512vl使用零掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (未设置相应的掩码位时将元素清零)。 |
| _mm_maskz_shldi_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shldi_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shldi_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并使用 zeromask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shldv_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shldv_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shldv_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量，并使用 zeromask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shrdi_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shrdi_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shrdi_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并使用 zeromask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shrdv_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shrdv_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shrdv_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量，并使用 zeromask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shuffle_epi8⚠ | Experimentalavx512bw,avx512vl根据 b 的相应 8 位元素中的打乱控制掩码对 a 中的包装 8 位整数进行打乱，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_shuffle_epi32⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件在 128 位通道中的 32 位整数中混洗 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_shuffle_pd⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件对 128 位通道内的双精度 (64-bit) 浮点元素进行混洗，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_shuffle_ps⚠ | Experimentalavx512f,avx512vl使用 imm8 中的控件对 a 中的单精度 (32-bit) 浮点元素进行打乱，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素会被清零)。 |
| _mm_maskz_shufflehi_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的高 64 位中，将 128 位通道的低 64 位从 a 复制到 dst，使用 zeromask k (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_shufflelo_epi16⚠ | Experimentalavx512bw,avx512vl使用 imm8 中的控件在 a 的 128 位通道的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位通道的低 64 位中，并使用写掩码 k 将 128 位通道的高 64 位从 a 复制到 dst (当未使用相应的掩码位时，元素从 src 复制) 放)。 |
| _mm_maskz_sll_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数左移，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sll_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移计数，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sll_epi64⚠ | Experimentalavx512f,avx512vl将填充的 64 位整数左移计数，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_slli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_slli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_slli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数左移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sllv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数左移由 count 中的相应元素指定的数量，同时移入零，并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sllv_epi32⚠ | Experimentalavx512f,avx512vl在将移位的 32 位整数左移零时，将其对应计数指定的数量左移，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sllv_epi64⚠ | Experimentalavx512f,avx512vl在将移位的 64 位整数左移零时，将其对应计数指定的数量左移，然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sqrt_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的平方根，并使用零掩码 k (将结果置零，当未设置相应的掩码位时将元素清零) 将结果存储在 dst 中。 |
| _mm_maskz_sqrt_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的平方根，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sqrt_round_sd⚠ | Experimentalavx512f计算 b 中下部双精度 (64-bit) 浮点元素的平方根，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后复制上部元素从 a 到 dst 的高位元素。 |
| _mm_maskz_sqrt_round_ss⚠ | Experimentalavx512f计算 b 中较低的单精度 (32-bit) 浮点元素的平方根，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后复制高 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_maskz_sqrt_sd⚠ | Experimentalavx512f计算 b 中下部双精度 (64-bit) 浮点元素的平方根，使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零)，然后复制上部元素从 a 到 dst 的高位元素。 |
| _mm_maskz_sqrt_ss⚠ | Experimentalavx512f计算 b 中较低的单精度 (32-bit) 浮点元素的平方根，使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零)，然后复制高 3 从 a 到 dst 的上层元素的包装的元素。 |
| _mm_maskz_sra_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按计数右移，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sra_epi32⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sra_epi64⚠ | Experimentalavx512f,avx512vl在移动符号位的同时右移计数包装的 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srai_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srai_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_srai_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srav_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移由 count 中的相应元素指定的数量，同时将符号位移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srav_epi32⚠ | Experimentalavx512f,avx512vl在将符号位移位的同时，将已包装的 32 位整数向右移动计数中相应元素指定的数量，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srav_epi64⚠ | Experimentalavx512f,avx512vl在移入符号位的同时，将包装的 64 位整数右移由 count 中相应元素指定的数量，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srl_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srl_epi32⚠ | Experimentalavx512f,avx512vl将移位的 32 位整数右移，同时移零，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srl_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移计数，同时移入零，并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时，元素被清零)。 |
| _mm_maskz_srli_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srli_epi32⚠ | Experimentalavx512f,avx512vl将包装的 32 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srli_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srlv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srlv_epi32⚠ | Experimentalavx512f,avx512vl向右移动已包装的 32 位整数，偏移量为相应元素在计数中指定的数量，同时向零移位，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_srlv_epi64⚠ | Experimentalavx512f,avx512vl向右移位包装的 64 位整数，其数量为计数中相应元素指定的数量，同时移位为零，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_sub_epi8⚠ | Experimentalavx512bw,avx512vl从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_sub_epi16⚠ | Experimentalavx512bw,avx512vl从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_sub_epi32⚠ | Experimentalavx512f,avx512vl从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_sub_epi64⚠ | Experimentalavx512f,avx512vl从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sub_pd⚠ | Experimentalavx512f,avx512vl从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sub_ps⚠ | Experimentalavx512f,avx512vl将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_sub_round_sd⚠ | Experimentalavx512f从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中的较低双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时，该元素将被清零。(未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_sub_round_ss⚠ | Experimentalavx512f从 a 中的较低单精度 (32-bit) 浮点元素中减去 b 中的较低单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时，该元素将被清零。(未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_sub_sd⚠ | Experimentalavx512f从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中的较低双精度 (64-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时，该元素将被清零。(未设置)，然后将上层元素从 a 复制到 dst 的上层元素。 |
| _mm_maskz_sub_ss⚠ | Experimentalavx512f从 a 中的较低单精度 (32-bit) 浮点元素中减去 b 中的较低单精度 (32-bit) 浮点元素，使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时，该元素将被清零。(未设置)，然后将前 3 个包装的元素从 a 复制到 dst 的高元素。 |
| _mm_maskz_subs_epi8⚠ | Experimentalavx512bw,avx512vl使用饱和度从包装的 8 位整数中减去 b 中的包装有符号的 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_subs_epi16⚠ | Experimentalavx512bw,avx512vl使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_subs_epu8⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度从 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_subs_epu16⚠ | Experimentalavx512bw,avx512vl使用 a 饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_ternarylogic_epi32⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 32 位整数中的每一位，来自 a、b 和 c 的相应位用于形成 imm8 的 3 位索引，并使用零掩码将 imm8 中该位的值写入 dst 中的相应位 k 在 32 位粒度 (当未设置相应的掩码位时，32 位元素被清零)。 |
| _mm_maskz_ternarylogic_epi64⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，来自 a、b 和 c 的相应位用于在 imm8 中形成 3 位索引，并使用零掩码将 imm8 中该位的值写入 dst 中的相应位 k 在 64 位粒度 (当未设置相应的掩码位时，64 位元素将被清零)。 |
| _mm_maskz_unpackhi_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpackhi_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的高半部分拆包和交织 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpackhi_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpackhi_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpackhi_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_unpackhi_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的高半部分解包和交织单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_unpacklo_epi8⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 8 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpacklo_epi16⚠ | Experimentalavx512bw,avx512vl从 a 和 b 中每个 128 位通道的下半部分拆包和交织 16 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_unpacklo_epi32⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 32 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpacklo_epi64⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织 64 位整数，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时元素清零)。 |
| _mm_maskz_unpacklo_pd⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织双精度 (64-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_unpacklo_ps⚠ | Experimentalavx512f,avx512vl从 a 和 b 中每个 128 位通道的下半部分解包和交织单精度 (32-bit) 浮点元素，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素清零)。 |
| _mm_maskz_xor_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 XOR，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_maskz_xor_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 XOR，并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时，元素将被清零)。 |
| _mm_max_epi64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的带符号的 64 位整数，并将包装的最大值存储在 dst 中。 |
| _mm_max_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并将包装的最大值存储在 dst 中。 |
| _mm_max_round_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，将最大值存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_max_round_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，将最大值存储在 dst 的较低元素中，并将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。 |
| _mm_min_epu64⚠ | Experimentalavx512f,avx512vl比较 a 和 b 中包装的无符号 64 位整数，并将包装的最小值存储在 dst 中。 |
| _mm_min_round_sd⚠ | Experimentalavx512f比较 a 和 b 中较低的双精度 (64-bit) 浮点元素，将最小值存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_min_round_ss⚠ | Experimentalavx512f比较 a 和 b 中较低的单精度 (32-bit) 浮点元素，将最小值存储在 dst 的较低元素中，并将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。 |
| _mm_movepi8_mask⚠ | Experimentalavx512bw,avx512vl根据 a 中相应包装的 8 位整数的最高有效位设置掩码寄存器 k 的每个位。 |
| _mm_movepi16_mask⚠ | Experimentalavx512bw,avx512vl根据 a 中相应的包装的 16 位整数的最高有效位设置掩码寄存器 k 的每一位。 |
| _mm_movm_epi8⚠ | Experimentalavx512bw,avx512vl根据 k 中相应位的值，将 dst 中每个包装的 8 位整数设置为全 1 或全 0。 |
| _mm_movm_epi16⚠ | Experimentalavx512bw,avx512vl根据 k 中相应位的值，将 dst 中每个包装的 16 位整数设置为全 1 或全 0。 |
| _mm_mul_round_sd⚠ | Experimentalavx512f将 a 和 b 中的下部双精度 (64-bit) 浮点元素相乘，将结果存储在 dst 的下部元素中，然后将 a 的上部元素复制到 dst 的上部元素。 |
| _mm_mul_round_ss⚠ | Experimentalavx512f将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_multishift_epi64_epi8⚠ | Experimentalavx512vbmi,avx512vl对于 b 中的每个 64 位元素，使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节，并将 8 个组装字节存储到 dst 的相应 64 位元素。 |
| _mm_or_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位或，并将结果存储在 dst 中。 |
| _mm_or_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位或，并将结果存储在 dst 中。 |
| _mm_permutex2var_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨通道打乱，并将结果存储在 dst 中。 |
| _mm_permutex2var_epi16⚠ | Experimentalavx512bw,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中对 16 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm_permutex2var_epi32⚠ | Experimentalavx512f,avx512vl使用对应的选择器和 idx 中的索引在通道中的 a 和 b 中随机排列 32 位整数，并将结果存储在 dst 中。 |
| _mm_permutex2var_epi64⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中随机排列 64 位整数，并将结果存储在 dst 中。 |
| _mm_permutex2var_pd⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm_permutex2var_ps⚠ | Experimentalavx512f,avx512vl使用 idx 中的相应选择器和索引在通道中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗，并将结果存储在 dst 中。 |
| _mm_permutexvar_epi8⚠ | Experimentalavx512vbmi,avx512vl使用 idx 中的相应索引将 a 中的 8 位整数打乱到通道中，并将结果存储在 dst 中。 |
| _mm_permutexvar_epi16⚠ | Experimentalavx512bw,avx512vl使用 idx 中的相应索引在跨通道中对 16 位整数进行打乱，并将结果存储在 dst 中。 |
| _mm_popcnt_epi8⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 8 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_popcnt_epi16⚠ | Experimentalavx512bitalg,avx512vl对于每个包装的 16 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_popcnt_epi32⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 32 位整数 maps，该值等于逻辑 1 位的数量。 |
| _mm_popcnt_epi64⚠ | Experimentalavx512vpopcntdq,avx512vl对于每个包装的 64 位整数 maps，该值均等于逻辑 1 位的数量。 |
| _mm_rcp14_pd⚠ | Experimentalavx512f,avx512vl计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm_rcp14_ps⚠ | Experimentalavx512f,avx512vl计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数，并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。 |
| _mm_rcp14_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数，将结果存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_rcp14_ss⚠ | Experimentalavx512f计算 b 中较低的单精度 (32-bit) 浮点元素的近似倒数，将结果存储在 dst 的较低元素中，并将高 3 个包装的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_rol_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm_rol_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm_rolv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm_rolv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm_ror_epi32⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数，并将结果存储在 dst 中。 |
| _mm_ror_epi64⚠ | Experimentalavx512f,avx512vl将 X 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数，然后将结果存储在 dst 中。 |
| _mm_rorv_epi32⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm_rorv_epi64⚠ | Experimentalavx512f,avx512vl将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数，然后将结果存储在 dst 中。 |
| _mm_roundscale_pd⚠ | Experimentalavx512f,avx512vl将 x 中的包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，并将结果存储在 dst 中。 |
| _mm_roundscale_ps⚠ | Experimentalavx512f,avx512vl将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数，然后将结果存储在 dst 中。 |
| _mm_roundscale_round_sd⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，将结果存储在 dst 的下部元素中，并将上部的元素从 a 复制到 dst 的上部元素。 |
| _mm_roundscale_round_ss⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_roundscale_sd⚠ | Experimentalavx512f将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数，将结果存储在 dst 的下部元素中，并将上部的元素从 a 复制到 dst 的上部元素。 |
| _mm_roundscale_ss⚠ | Experimentalavx512f将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_rsqrt14_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数平方根，将结果存储在 dst 的较低元素中，并将较高的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_rsqrt14_ss⚠ | Experimentalavx512f计算 b 中较低单精度 (32-bit) 浮点元素的近似倒数平方根，将结果存储在 dst 的较低元素中，并将高 3 个包装的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。 |
| _mm_scalef_pd⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm_scalef_ps⚠ | Experimentalavx512f,avx512vl使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素，并将结果存储在 dst 中。 |
| _mm_scalef_round_sd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，将结果存储在 dst 的下部元素中，然后将 a 的上部元素复制到 dst 的上部元素。 |
| _mm_scalef_round_ss⚠ | Experimentalavx512f使用 b 中的值缩放 a 中的包装的单精度 (32-bit) 浮点元素，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_scalef_sd⚠ | Experimentalavx512f使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素，将结果存储在 dst 的下部元素中，然后将 a 的上部元素复制到 dst 的上部元素。 |
| _mm_scalef_ss⚠ | Experimentalavx512f使用 b 中的值缩放 a 中的包装的单精度 (32-bit) 浮点元素，将结果存储在 dst 的下部元素中，并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。 |
| _mm_shldi_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 imm8 位，并将高 16 位存储在 dst 中)。 |
| _mm_shldi_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位，并将高 32 位存储在 dst 中。 |
| _mm_shldi_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 imm8 位，并将高 64 位存储在 dst 中)。 |
| _mm_shldv_epi16⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 16 位整数，产生一个中间 32 位结果。将结果左移 c 的对应元素中指定的量，并将高 16 位存储在 dst 中。 |
| _mm_shldv_epi32⚠ | Experimentalavx512vbmi2,avx512vl将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的对应元素中指定的量，并将高 32 位存储在 dst 中。 |
| _mm_shldv_epi64⚠ | Experimentalavx512vbmi2,avx512vl在 a 和 b 中连接包装的 64 位整数，产生一个中间的 128 位结果。将结果左移 c 的对应元素中指定的量，并将高 64 位存储在 dst 中。 |
| _mm_shrdi_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 imm8 位，并将低 16 位存储在 dst 中。 |
| _mm_shrdi_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 imm8 位，并将低 32 位存储在 dst 中。 |
| _mm_shrdi_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 imm8 位，并将低 64 位存储在 dst 中。 |
| _mm_shrdv_epi16⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 16 位整数连接起来，产生一个中间 32 位结果。将结果右移 c 的对应元素中指定的量，并将低 16 位存储在 dst 中。 |
| _mm_shrdv_epi32⚠ | Experimentalavx512vbmi2,avx512vl连接包装在 b 和 a 中的 32 位整数，产生中间 64 位结果。将结果右移 c 的对应元素中指定的量，并将低 32 位存储在 dst 中。 |
| _mm_shrdv_epi64⚠ | Experimentalavx512vbmi2,avx512vl将 b 和 a 中的包装的 64 位整数连接起来，产生一个中间的 128 位结果。将结果右移 c 的对应元素中指定的量，并将低 64 位存储在 dst 中。 |
| _mm_sllv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数按 count 中相应元素指定的数量向左移位，同时将零移位，并将结果存储在 dst 中。 |
| _mm_sqrt_round_sd⚠ | Experimentalavx512f计算 b 中较低的双精度 (64-bit) 浮点元素的平方根，将结果存储在 dst 的较低元素中，然后将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_sqrt_round_ss⚠ | Experimentalavx512f计算 b 中较低的单精度 (32-bit) 浮点元素的平方根，将结果存储在 dst 的较低元素中，并将高 3 个包装的元素从 a 复制到 dst 的较高元素。 |
| _mm_sra_epi64⚠ | Experimentalavx512f,avx512vl在移动符号位的同时按计数右移包装的 64 位整数，并将结果存储在 dst 中。 |
| _mm_srai_epi64⚠ | Experimentalavx512f,avx512vl将包装的 64 位整数右移 imm8，同时将符号位移位，并将结果存储在 dst 中。 |
| _mm_srav_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数右移 count 中相应元素指定的数量，同时移入符号位，然后将结果存储在 dst 中。 |
| _mm_srav_epi64⚠ | Experimentalavx512f,avx512vl将移位的 64 位整数向右移动计数中相应元素指定的数量，同时移入符号位，并将结果存储在 dst 中。 |
| _mm_srlv_epi16⚠ | Experimentalavx512bw,avx512vl将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量)，同时将零移位，并将结果存储在 dst 中。 |
| _mm_store_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的 128 位 (由 4 个包装的 32 位整数组成) 存储到内存中。mem_addr 必须在 16 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm_store_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的 128 位 (由 2 个包装的 64 位整数组成) 存储到内存中。mem_addr 必须在 16 字节边界上对齐，否则可能会生成一般保护异常。 |
| _mm_storeu_epi8⚠ | Experimentalavx512bw,avx512vl将 a 中的 128 位 (由 16 个包装的 8 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_storeu_epi16⚠ | Experimentalavx512bw,avx512vl将 a 中的 128 位 (由 8 个包装的 16 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_storeu_epi32⚠ | Experimentalavx512f,avx512vl将 a 中的 128 位 (由 4 个包装的 32 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_storeu_epi64⚠ | Experimentalavx512f,avx512vl将 a 中的 128 位 (由 2 个包装的 64 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。 |
| _mm_sub_round_sd⚠ | Experimentalavx512f从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中较低的双精度 (64-bit) 浮点元素，将结果存储在 dst 的较低元素中，并将较高的元素从 a 复制到 dst 的较高元素。 |
| _mm_sub_round_ss⚠ | Experimentalavx512f从 a 中的下部单精度 (32-bit) 浮点元素中减去 b 中的下部单精度 (32-bit) 浮点元素，将结果存储在 dst 的下部元素中，并将上部 3 个包装的元素从 a 复制到上部元素 dst。 |
| _mm_ternarylogic_epi32⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每个位，来自 a，b 和 c 的相应位用于形成到 imm8 的 3 位索引，并且将 imm8 中该位的值写入 dst 中的相应位。 |
| _mm_ternarylogic_epi64⚠ | Experimentalavx512f,avx512vl提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个打包的 64 位整数中的每一位，a、b 和 c 中的相应位用于形成 imm8 中的 3 位索引，并将 imm8 中该位的值写入 dst 中的相应位。 |
| _mm_test_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位与，生成中间 8 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm_test_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位与，生成中间的 16 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm_test_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位与，生成中间的 32 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm_test_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位与，生成中间 64 位值，如果中间值不为零，则在结果掩码 k 中设置相应的位。 |
| _mm_testn_epi8_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 8 位整数的按位 NAND，生成中间的 8 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm_testn_epi16_mask⚠ | Experimentalavx512bw,avx512vl计算 a 和 b 中包装的 16 位整数的按位 NAND，生成中间的 16 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm_testn_epi32_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 NAND，生成中间的 32 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm_testn_epi64_mask⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 NAND，生成中间的 64 位值，如果中间值为零，则在结果掩码 k 中设置相应的位。 |
| _mm_xor_epi32⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 32 位整数的按位 XOR，并将结果存储在 dst 中。 |
| _mm_xor_epi64⚠ | Experimentalavx512f,avx512vl计算 a 和 b 中包装的 64 位整数的按位 XOR，并将结果存储在 dst 中。 |
| _store_mask32⚠ | Experimentalavx512bw将 32 位掩码从 a 存储到内存中。 |
| _store_mask64⚠ | Experimentalavx512bw将 64 位掩码从 a 存储到内存中。 |
| _xabort⚠ | Experimentalrtm强制将受限制的事务内存 (RTM) 区域终止。 Intel’s documentation. |
| _xabort_code | Experimental |
| _xbegin⚠ | Experimentalrtm指定受限制的事务性存储器 (RTM) 代码区域的开始，并返回一个指示状态的值。 |
| _xend⚠ | Experimentalrtm指定受限制的事务性存储器 (RTM) 代码区域的结尾。 Intel’s documentation. |
| _xtest⚠ | Experimentalrtm查询处理器是在由受限事务存储器 (RTM) 还是硬件锁定扩展 (HLE) 标识的事务区域中执行。 |
| has_cpuid | Experimental 主机是否支持 |
| ud2⚠ | Experimental 生成陷阱指令 |
| _MM_GET_EXCEPTION_MASK⚠ | sse请参见 |
| _MM_GET_EXCEPTION_STATE⚠ | sse请参见 |
| _MM_GET_FLUSH_ZERO_MODE⚠ | sse请参见 |
| _MM_GET_ROUNDING_MODE⚠ | sse请参见 |
| _MM_SET_EXCEPTION_MASK⚠ | sse请参见 |
| _MM_SET_EXCEPTION_STATE⚠ | sse请参见 |
| _MM_SET_FLUSH_ZERO_MODE⚠ | sse请参见 |
| _MM_SET_ROUNDING_MODE⚠ | sse请参见 |
| _MM_TRANSPOSE4_PS⚠ | sse将由 4 行 __m128 组成的 4x4 矩阵转置到位。 |
| __cpuid⚠ | 请参见 |
| __cpuid_count⚠ | 返回给定 |
| __get_cpuid_max⚠ | 返回最高支持的 |
| __rdtscp⚠ | 读取处理器时间戳计数器和 |
| _addcarry_u32⚠ | 将无符号的 32 位整数 |
| _addcarryx_u32⚠ | adx将无符号的 32 位整数 |
| _andn_u32⚠ | bmi1
|
| _bextr2_u32⚠ | bmi1将 |
| _bextr_u32⚠ | bmi1从 |
| _bittest⚠ | 返回由 |
| _bittestandcomplement⚠ | 返回由 |
| _bittestandreset⚠ | 返回由 |
| _bittestandset⚠ | 返回由 |
| _blcfill_u32⚠ | tbm清除 |
| _blcfill_u64⚠ | tbm清除 |
| _blci_u32⚠ | tbm将 |
| _blci_u64⚠ | tbm将 |
| _blcic_u32⚠ | tbm设置 |
| _blcic_u64⚠ | tbm设置 |
| _blcmsk_u32⚠ | tbm设置 |
| _blcmsk_u64⚠ | tbm设置 |
| _blcs_u32⚠ | tbm设置 |
| _blcs_u64⚠ | tbm设置 |
| _blsfill_u32⚠ | tbm将 |
| _blsfill_u64⚠ | tbm将 |
| _blsi_u32⚠ | bmi1提取最低位隔离位。 |
| _blsic_u32⚠ | tbm清除最低有效位并设置所有其他位。 |
| _blsic_u64⚠ | tbm清除最低有效位并设置所有其他位。 |
| _blsmsk_u32⚠ | bmi1将掩码提高到最低设置位。 |
| _blsr_u32⚠ | bmi1复位 |
| _bswap⚠ | 返回整数，其字节顺序为 x |
| _bzhi_u32⚠ | bmi2将 |
| _fxrstor⚠ | fxsr从以下位置恢复 |
| _fxsave⚠ | fxsr将 |
| _lzcnt_u32⚠ | lzcnt计算前导最高有效零位。 |
| _mm256_abs_epi8⚠ | avx2计算 |
| _mm256_abs_epi16⚠ | avx2计算 |
| _mm256_abs_epi32⚠ | avx2计算 |
| _mm256_add_epi8⚠ | avx2在 |
| _mm256_add_epi16⚠ | avx2在 |
| _mm256_add_epi32⚠ | avx2在 |
| _mm256_add_epi64⚠ | avx2在 |
| _mm256_add_pd⚠ | avx在 |
| _mm256_add_ps⚠ | avx在 |
| _mm256_adds_epi8⚠ | avx2使用饱和度在 |
| _mm256_adds_epi16⚠ | avx2使用饱和度在 |
| _mm256_adds_epu8⚠ | avx2使用饱和度在 |
| _mm256_adds_epu16⚠ | avx2使用饱和度在 |
| _mm256_addsub_pd⚠ | avx或者，将 |
| _mm256_addsub_ps⚠ | avx或者，将 |
| _mm256_alignr_epi8⚠ | avx2将 |
| _mm256_and_pd⚠ | avx计算 |
| _mm256_and_ps⚠ | avx计算 |
| _mm256_and_si256⚠ | avx2计算 |
| _mm256_andnot_pd⚠ | avx计算 |
| _mm256_andnot_ps⚠ | avx计算 |
| _mm256_andnot_si256⚠ | avx2计算 |
| _mm256_avg_epu8⚠ | avx2
|
| _mm256_avg_epu16⚠ | avx2
|
| _mm256_blend_epi16⚠ | avx2使用控制掩码 |
| _mm256_blend_epi32⚠ | avx2使用控制掩码 |
| _mm256_blend_pd⚠ | avx使用控制掩码 |
| _mm256_blend_ps⚠ | avx使用控制掩码 |
| _mm256_blendv_epi8⚠ | avx2使用 |
| _mm256_blendv_pd⚠ | avx使用 |
| _mm256_blendv_ps⚠ | avx使用 |
| _mm256_broadcast_pd⚠ | avx将内存中的 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 广播到返回的 vector 的所有元素。 |
| _mm256_broadcast_ps⚠ | avx从内存 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 向广播的 vector 的所有元素广播 128 位。 |
| _mm256_broadcast_sd⚠ | avx从内存向返回的 vector 的所有元素广播双精度 (64-bit) 浮点元素。 |
| _mm256_broadcast_ss⚠ | avx从内存向返回的 vector 的所有元素广播单精度 (32-bit) 浮点元素。 |
| _mm256_broadcastb_epi8⚠ | avx2将 |
| _mm256_broadcastd_epi32⚠ | avx2将 |
| _mm256_broadcastq_epi64⚠ | avx2将 |
| _mm256_broadcastsd_pd⚠ | avx2将低双精度 (64-bit) 浮点元素从 |
| _mm256_broadcastsi128_si256⚠ | avx2从 a 广播 128 位整数数据到 256 位返回值中的所有 128 位通道。 |
| _mm256_broadcastss_ps⚠ | avx2将低单精度 (32-bit) 浮点元素从 |
| _mm256_broadcastw_epi16⚠ | avx2将低位包装的 16 位整数从 a 广播到 256 位返回值的所有元素 |
| _mm256_bslli_epi128⚠ | avx2将 |
| _mm256_bsrli_epi128⚠ | avx2将 |
| _mm256_castpd128_pd256⚠ | avx将类型 __m128d 的 vector 转换为 __m256d 类型; 结果的高 128 位未定义。 |
| _mm256_castpd256_pd128⚠ | avx将类型为 __m256d 的 vector 强制转换为类型为 __m128d 的 vector。 |
| _mm256_castpd_ps⚠ | avx将类型为 __m256d 的 vector 强制转换为类型为 __m256 的 vector。 |
| _mm256_castpd_si256⚠ | avx将类型为 __m256d 的 vector 强制转换为类型为 __m256i 的 vector。 |
| _mm256_castps128_ps256⚠ | avx将类型 __m128 的 vector 转换为 __m256 类型; 结果的高 128 位未定义。 |
| _mm256_castps256_ps128⚠ | avx将类型为 __m256 的 vector 强制转换为类型为 __m128 的 vector。 |
| _mm256_castps_pd⚠ | avx将类型为 __m256 的 vector 强制转换为类型为 __m256d 的 vector。 |
| _mm256_castps_si256⚠ | avx将类型为 __m256 的 vector 强制转换为类型为 __m256i 的 vector。 |
| _mm256_castsi128_si256⚠ | avx将类型为 __m128i 的 vector 强制转换为类型 __m256i; 结果的高 128 位未定义。 |
| _mm256_castsi256_pd⚠ | avx将类型为 __m256i 的 vector 强制转换为类型为 __m256d 的 vector。 |
| _mm256_castsi256_ps⚠ | avx将类型为 __m256i 的 vector 强制转换为类型为 __m256 的 vector。 |
| _mm256_castsi256_si128⚠ | avx将类型为 __m256i 的 vector 强制转换为类型为 __m128i 的 vector。 |
| _mm256_ceil_pd⚠ | avx将 |
| _mm256_ceil_ps⚠ | avx将 |
| _mm256_cmp_pd⚠ | avx根据 |
| _mm256_cmp_ps⚠ | avx根据 |
| _mm256_cmpeq_epi8⚠ | avx2比较 |
| _mm256_cmpeq_epi16⚠ | avx2比较 |
| _mm256_cmpeq_epi32⚠ | avx2比较 |
| _mm256_cmpeq_epi64⚠ | avx2比较 |
| _mm256_cmpgt_epi8⚠ | avx2比较 |
| _mm256_cmpgt_epi16⚠ | avx2比较 |
| _mm256_cmpgt_epi32⚠ | avx2比较 |
| _mm256_cmpgt_epi64⚠ | avx2比较 |
| _mm256_cvtepi8_epi16⚠ | avx2将 8 位整数符号扩展为 16 位整数。 |
| _mm256_cvtepi8_epi32⚠ | avx2将 8 位整数符号扩展为 32 位整数。 |
| _mm256_cvtepi8_epi64⚠ | avx2将 8 位整数符号扩展为 64 位整数。 |
| _mm256_cvtepi16_epi32⚠ | avx2将 16 位整数符号扩展为 32 位整数。 |
| _mm256_cvtepi16_epi64⚠ | avx2将 16 位整数符号扩展为 64 位整数。 |
| _mm256_cvtepi32_epi64⚠ | avx2将 32 位整数符号扩展为 64 位整数。 |
| _mm256_cvtepi32_pd⚠ | avx将 |
| _mm256_cvtepi32_ps⚠ | avx将 |
| _mm256_cvtepu8_epi16⚠ | avx2将 |
| _mm256_cvtepu8_epi32⚠ | avx2将 |
| _mm256_cvtepu8_epi64⚠ | avx2将 |
| _mm256_cvtepu16_epi32⚠ | avx2零将 |
| _mm256_cvtepu16_epi64⚠ | avx2将 |
| _mm256_cvtepu32_epi64⚠ | avx2将 |
| _mm256_cvtpd_epi32⚠ | avx将 |
| _mm256_cvtpd_ps⚠ | avx将 |
| _mm256_cvtps_epi32⚠ | avx将 |
| _mm256_cvtps_pd⚠ | avx将 |
| _mm256_cvtsd_f64⚠ | avx2返回 |
| _mm256_cvtsi256_si32⚠ | avx2返回 |
| _mm256_cvtss_f32⚠ | avx返回 |
| _mm256_cvttpd_epi32⚠ | avx将 |
| _mm256_cvttps_epi32⚠ | avx将 |
| _mm256_div_pd⚠ | avx计算 |
| _mm256_div_ps⚠ | avx计算 |
| _mm256_dp_ps⚠ | avx使用 |
| _mm256_extract_epi8⚠ | avx2从 |
| _mm256_extract_epi16⚠ | avx2从 |
| _mm256_extract_epi32⚠ | avx2从 |
| _mm256_extractf128_pd⚠ | avx从 |
| _mm256_extractf128_ps⚠ | avx从 |
| _mm256_extractf128_si256⚠ | avx从 |
| _mm256_extracti128_si256⚠ | avx2从 |
| _mm256_floor_pd⚠ | avx将 |
| _mm256_floor_ps⚠ | avx将 |
| _mm256_fmadd_pd⚠ | fma将 |
| _mm256_fmadd_ps⚠ | fma将 |
| _mm256_fmaddsub_pd⚠ | fma将 |
| _mm256_fmaddsub_ps⚠ | fma将 |
| _mm256_fmsub_pd⚠ | fma将 |
| _mm256_fmsub_ps⚠ | fma将 |
| _mm256_fmsubadd_pd⚠ | fma将 |
| _mm256_fmsubadd_ps⚠ | fma将 |
| _mm256_fnmadd_pd⚠ | fma将 |
| _mm256_fnmadd_ps⚠ | fma将 |
| _mm256_fnmsub_pd⚠ | fma将 |
| _mm256_fnmsub_ps⚠ | fma将 |
| _mm256_hadd_epi16⚠ | avx2在 |
| _mm256_hadd_epi32⚠ | avx2在 |
| _mm256_hadd_pd⚠ | avx在 4 个 64 位浮点 |
| _mm256_hadd_ps⚠ | avx在 8 个 32 位浮点 |
| _mm256_hadds_epi16⚠ | avx2使用饱和度在 |
| _mm256_hsub_epi16⚠ | avx2水平减去 |
| _mm256_hsub_epi32⚠ | avx2水平减去 |
| _mm256_hsub_pd⚠ | avx在 4 个 64 位浮点 |
| _mm256_hsub_ps⚠ | avx将 8 个 32 位浮点 |
| _mm256_hsubs_epi16⚠ | avx2使用饱和度水平减去 |
| _mm256_i32gather_epi32⚠ | avx2从 |
| _mm256_i32gather_epi64⚠ | avx2从 |
| _mm256_i32gather_pd⚠ | avx2从 |
| _mm256_i32gather_ps⚠ | avx2从 |
| _mm256_i64gather_epi32⚠ | avx2从 |
| _mm256_i64gather_epi64⚠ | avx2从 |
| _mm256_i64gather_pd⚠ | avx2从 |
| _mm256_i64gather_ps⚠ | avx2从 |
| _mm256_insert_epi8⚠ | avx复制 |
| _mm256_insert_epi16⚠ | avx复制 |
| _mm256_insert_epi32⚠ | avx复制 |
| _mm256_insertf128_pd⚠ | avx将 |
| _mm256_insertf128_ps⚠ | avx将 |
| _mm256_insertf128_si256⚠ | avx复制 |
| _mm256_inserti128_si256⚠ | avx2将 |
| _mm256_lddqu_si256⚠ | avx从未对齐的内存中将 256 位整数数据加载到结果中。
当数据越过缓存行边界时，此内联函数可能比 |
| _mm256_load_pd⚠ | avx从内存中将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 加载到结果中。 |
| _mm256_load_ps⚠ | avx从内存中将 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成) 加载到结果中。 |
| _mm256_load_si256⚠ | avx从内存中将 256 位整数数据加载到结果中。
|
| _mm256_loadu2_m128⚠ | avx,sse从内存中加载两个 128 位值 (由 4 个包装的单精度 (32-bit) 浮点元素组成)，并将它们组合为 256 位值。 |
| _mm256_loadu2_m128d⚠ | avx,sse2从内存中加载两个 128 位值 (由 2 个包装的双精度 (64-bit) 浮点元素组成)，并将它们组合为 256 位值。 |
| _mm256_loadu2_m128i⚠ | avx,sse2从内存中加载两个 128 位值 (由整数数据组成)，并将它们组合为 256 位值。
|
| _mm256_loadu_pd⚠ | avx从内存中将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 加载到结果中。 |
| _mm256_loadu_ps⚠ | avx从内存中将 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成) 加载到结果中。 |
| _mm256_loadu_si256⚠ | avx从内存中将 256 位整数数据加载到结果中。
|
| _mm256_madd_epi16⚠ | avx2将 |
| _mm256_maddubs_epi16⚠ | avx2将 |
| _mm256_mask_i32gather_epi32⚠ | avx2从 |
| _mm256_mask_i32gather_epi64⚠ | avx2从 |
| _mm256_mask_i32gather_pd⚠ | avx2从 |
| _mm256_mask_i32gather_ps⚠ | avx2从 |
| _mm256_mask_i64gather_epi32⚠ | avx2从 |
| _mm256_mask_i64gather_epi64⚠ | avx2从 |
| _mm256_mask_i64gather_pd⚠ | avx2从 |
| _mm256_mask_i64gather_ps⚠ | avx2从 |
| _mm256_maskload_epi32⚠ | avx2使用 |
| _mm256_maskload_epi64⚠ | avx2使用 |
| _mm256_maskload_pd⚠ | avx使用 |
| _mm256_maskload_ps⚠ | avx使用 |
| _mm256_maskstore_epi32⚠ | avx2使用 |
| _mm256_maskstore_epi64⚠ | avx2使用 |
| _mm256_maskstore_pd⚠ | avx使用 |
| _mm256_maskstore_ps⚠ | avx使用 |
| _mm256_max_epi8⚠ | avx2比较 |
| _mm256_max_epi16⚠ | avx2比较 |
| _mm256_max_epi32⚠ | avx2比较 |
| _mm256_max_epu8⚠ | avx2比较 |
| _mm256_max_epu16⚠ | avx2比较 |
| _mm256_max_epu32⚠ | avx2比较 |
| _mm256_max_pd⚠ | avx比较 |
| _mm256_max_ps⚠ | avx比较 |
| _mm256_min_epi8⚠ | avx2比较 |
| _mm256_min_epi16⚠ | avx2比较 |
| _mm256_min_epi32⚠ | avx2比较 |
| _mm256_min_epu8⚠ | avx2比较 |
| _mm256_min_epu16⚠ | avx2比较 |
| _mm256_min_epu32⚠ | avx2比较 |
| _mm256_min_pd⚠ | avx比较 |
| _mm256_min_ps⚠ | avx比较 |
| _mm256_movedup_pd⚠ | avx从 |
| _mm256_movehdup_ps⚠ | avx从 |
| _mm256_moveldup_ps⚠ | avx从 |
| _mm256_movemask_epi8⚠ | avx2从 |
| _mm256_movemask_pd⚠ | avx根据 |
| _mm256_movemask_ps⚠ | avx基于 |
| _mm256_mpsadbw_epu8⚠ | avx2计算无符号四元组的绝对差之和 (SADs)
|
| _mm256_mul_epi32⚠ | avx2将 |
| _mm256_mul_epu32⚠ | avx2将 |
| _mm256_mul_pd⚠ | avx将 |
| _mm256_mul_ps⚠ | avx将 |
| _mm256_mulhi_epi16⚠ | avx2将 |
| _mm256_mulhi_epu16⚠ | avx2将 |
| _mm256_mulhrs_epi16⚠ | avx2将 |
| _mm256_mullo_epi16⚠ | avx2将 |
| _mm256_mullo_epi32⚠ | avx2将 |
| _mm256_or_pd⚠ | avx计算 |
| _mm256_or_ps⚠ | avx计算 |
| _mm256_or_si256⚠ | avx2计算 |
| _mm256_packs_epi16⚠ | avx2使用带符号的饱和度将包装的 16 位整数从 |
| _mm256_packs_epi32⚠ | avx2使用带符号的饱和度将包装的 32 位整数从 |
| _mm256_packus_epi16⚠ | avx2使用无符号饱和度将包装的 16 位整数从 |
| _mm256_packus_epi32⚠ | avx2使用无符号饱和度将包装的 32 位整数从 |
| _mm256_permute2f128_pd⚠ | avx混洗 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成)，由 |
| _mm256_permute2f128_ps⚠ | avx混洗 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成)，由 |
| _mm256_permute2f128_si256⚠ | avx重排 |
| _mm256_permute2x128_si256⚠ | avx2打乱由 |
| _mm256_permute4x64_epi64⚠ | avx2使用控制掩码 |
| _mm256_permute4x64_pd⚠ | avx2使用 |
| _mm256_permute_pd⚠ | avx使用 |
| _mm256_permute_ps⚠ | avx使用 |
| _mm256_permutevar8x32_epi32⚠ | avx2根据 |
| _mm256_permutevar8x32_ps⚠ | avx2使用 |
| _mm256_permutevar_pd⚠ | avx使用 |
| _mm256_permutevar_ps⚠ | avx使用 |
| _mm256_rcp_ps⚠ | avx计算 |
| _mm256_round_pd⚠ | avx根据 |
| _mm256_round_ps⚠ | avx根据标志 |
| _mm256_rsqrt_ps⚠ | avx计算 |
| _mm256_sad_epu8⚠ | avx2计算 |
| _mm256_set1_epi8⚠ | avx向返回的 vector 的所有元素广播 8 位整数 |
| _mm256_set1_epi16⚠ | avx向返回的 vector 的所有所有元素广播 16 位整数 |
| _mm256_set1_epi32⚠ | avx向返回的 vector 的所有元素广播 32 位整数 |
| _mm256_set1_epi64x⚠ | avx向返回的 vector 的所有元素广播 64 位整数 |
| _mm256_set1_pd⚠ | avx向返回的 vector 的所有元素广播双精度 (64-bit) 浮点值 |
| _mm256_set1_ps⚠ | avx向返回的 vector 的所有元素广播单精度 (32-bit) 浮点值 |
| _mm256_set_epi8⚠ | avx在返回的 vector 中设置包装的 8 位整数，并以相反的顺序提供所提供的值。 |
| _mm256_set_epi16⚠ | avx使用提供的值在返回的 vector 中设置包装的 16 位整数。 |
| _mm256_set_epi32⚠ | avx使用提供的值在返回的 vector 中设置包装的 32 位整数。 |
| _mm256_set_epi64x⚠ | avx使用提供的值在返回的 vector 中设置包装的 64 位整数。 |
| _mm256_set_m128⚠ | avx设置包装的 __m256 返回的 vector 与提供的值。 |
| _mm256_set_m128d⚠ | avx设置包装的 __m256d 返回的 vector 具有提供的值。 |
| _mm256_set_m128i⚠ | avx包装的 __m256i 集合使用提供的值返回 vector。 |
| _mm256_set_pd⚠ | avx使用提供的值在返回的 vector 中设置包装的双精度 (64-bit) 浮点元素。 |
| _mm256_set_ps⚠ | avx使用提供的值在返回的 vector 中设置包装的单精度 (32-bit) 浮点元素。 |
| _mm256_setr_epi8⚠ | avx在返回的 vector 中设置包装的 8 位整数，并以相反的顺序提供所提供的值。 |
| _mm256_setr_epi16⚠ | avx在返回的 vector 中设置包装的 16 位整数，其提供的值的顺序相反。 |
| _mm256_setr_epi32⚠ | avx在返回的 vector 中设置包装的 32 位整数，并以相反的顺序提供所提供的值。 |
| _mm256_setr_epi64x⚠ | avx在返回的 vector 中设置包装的 64 位整数，其提供的值的顺序相反。 |
| _mm256_setr_m128⚠ | avx设置包装的 __m256 返回的 vector 与提供的值。 |
| _mm256_setr_m128d⚠ | avx设置包装的 __m256d 返回的 vector 具有提供的值。 |
| _mm256_setr_m128i⚠ | avx包装的 __m256i 集合使用提供的值返回 vector。 |
| _mm256_setr_pd⚠ | avx在返回的 vector 中使用反向提供的值设置包装的双精度 (64-bit) 浮点元素。 |
| _mm256_setr_ps⚠ | avx在返回的 vector 中使用反向提供的值设置包装的单精度 (32-bit) 浮点元素。 |
| _mm256_setzero_pd⚠ | avx返回 __m256d 类型的 vector，所有元素均设置为零。 |
| _mm256_setzero_ps⚠ | avx返回 __m256 类型的 vector，所有元素都设置为零。 |
| _mm256_setzero_si256⚠ | avx返回类型为 __m256i 的 vector，所有元素均设置为零。 |
| _mm256_shuffle_epi8⚠ | avx2根据 |
| _mm256_shuffle_epi32⚠ | avx2使用 |
| _mm256_shuffle_pd⚠ | avx使用 |
| _mm256_shuffle_ps⚠ | avx将 |
| _mm256_shufflehi_epi16⚠ | avx2使用 |
| _mm256_shufflelo_epi16⚠ | avx2使用 |
| _mm256_sign_epi8⚠ | avx2当相应的带符号时，将 |
| _mm256_sign_epi16⚠ | avx2当相应的带符号时，将 |
| _mm256_sign_epi32⚠ | avx2当相应的带符号时，将 |
| _mm256_sll_epi16⚠ | avx2将 |
| _mm256_sll_epi32⚠ | avx2将 |
| _mm256_sll_epi64⚠ | avx2将 |
| _mm256_slli_epi16⚠ | avx2将 |
| _mm256_slli_epi32⚠ | avx2将 |
| _mm256_slli_epi64⚠ | avx2将 |
| _mm256_slli_si256⚠ | avx2将 |
| _mm256_sllv_epi32⚠ | avx2将 |
| _mm256_sllv_epi64⚠ | avx2将 |
| _mm256_sqrt_pd⚠ | avx返回 |
| _mm256_sqrt_ps⚠ | avx返回 |
| _mm256_sra_epi16⚠ | avx2将符号位移入时，将 |
| _mm256_sra_epi32⚠ | avx2将符号位移位时，将 |
| _mm256_srai_epi16⚠ | avx2将 |
| _mm256_srai_epi32⚠ | avx2将 |
| _mm256_srav_epi32⚠ | avx2将 |
| _mm256_srl_epi16⚠ | avx2将 |
| _mm256_srl_epi32⚠ | avx2将 |
| _mm256_srl_epi64⚠ | avx2将 |
| _mm256_srli_epi16⚠ | avx2将 |
| _mm256_srli_epi32⚠ | avx2将 |
| _mm256_srli_epi64⚠ | avx2将 |
| _mm256_srli_si256⚠ | avx2将 |
| _mm256_srlv_epi32⚠ | avx2将 |
| _mm256_srlv_epi64⚠ | avx2将 |
| _mm256_store_pd⚠ | avx将来自 |
| _mm256_store_ps⚠ | avx将来自 |
| _mm256_store_si256⚠ | avx将来自 |
| _mm256_storeu2_m128⚠ | avx,sse将来自 |
| _mm256_storeu2_m128d⚠ | avx,sse2将来自 |
| _mm256_storeu2_m128i⚠ | avx,sse2将来自 |
| _mm256_storeu_pd⚠ | avx将来自 |
| _mm256_storeu_ps⚠ | avx将来自 |
| _mm256_storeu_si256⚠ | avx将来自 |
| _mm256_stream_pd⚠ | avx将双精度值从 |
| _mm256_stream_ps⚠ | avx将单精度浮点值从 |
| _mm256_stream_si256⚠ | avx将整数数据从 256 位整数 vector 移动到 32 字节对齐的内存位置。 为了最大程度地减少缓存，数据被标记为非时间性的 (不太可能很快再次使用) |
| _mm256_sub_epi8⚠ | avx2从 |
| _mm256_sub_epi16⚠ | avx2从 |
| _mm256_sub_epi32⚠ | avx2从 |
| _mm256_sub_epi64⚠ | avx2从 |
| _mm256_sub_pd⚠ | avx从 |
| _mm256_sub_ps⚠ | avx从 |
| _mm256_subs_epi8⚠ | avx2使用饱和度从 |
| _mm256_subs_epi16⚠ | avx2使用饱和度从 |
| _mm256_subs_epu8⚠ | avx2使用饱和度从 |
| _mm256_subs_epu16⚠ | avx2使用饱和度从 |
| _mm256_testc_pd⚠ | avx计算 |
| _mm256_testc_ps⚠ | avx计算 |
| _mm256_testc_si256⚠ | avx计算 |
| _mm256_testnzc_pd⚠ | avx计算 |
| _mm256_testnzc_ps⚠ | avx计算 |
| _mm256_testnzc_si256⚠ | avx计算 |
| _mm256_testz_pd⚠ | avx计算 |
| _mm256_testz_ps⚠ | avx计算 |
| _mm256_testz_si256⚠ | avx计算 |
| _mm256_undefined_pd⚠ | avx返回带有未定义元素的 |
| _mm256_undefined_ps⚠ | avx返回带有未定义元素的 |
| _mm256_undefined_si256⚠ | avx返回带有未定义元素的 __m256i 类型的 vector。 |
| _mm256_unpackhi_epi8⚠ | avx2从每个高位的一半拆包并交织 8 位整数
|
| _mm256_unpackhi_epi16⚠ | avx2从每个高位的一半拆包并交织 16 位整数
|
| _mm256_unpackhi_epi32⚠ | avx2从每个高位的一半拆包并交织 32 位整数
|
| _mm256_unpackhi_epi64⚠ | avx2从每个高位的一半拆包并交织 64 位整数
|
| _mm256_unpackhi_pd⚠ | avx从 |
| _mm256_unpackhi_ps⚠ | avx从 |
| _mm256_unpacklo_epi8⚠ | avx2从每个低位拆包并交织 8 位整数
|
| _mm256_unpacklo_epi16⚠ | avx2从每个低位拆包并交织 16 位整数
|
| _mm256_unpacklo_epi32⚠ | avx2从每个低位拆包并交织 32 位整数
|
| _mm256_unpacklo_epi64⚠ | avx2从每个字节的下半部分拆包并交织 64 位整数
|
| _mm256_unpacklo_pd⚠ | avx从 |
| _mm256_unpacklo_ps⚠ | avx从 |
| _mm256_xor_pd⚠ | avx计算 |
| _mm256_xor_ps⚠ | avx计算 |
| _mm256_xor_si256⚠ | avx2计算 |
| _mm256_zeroall⚠ | avx将所有 XMM 或 YMM 寄存器的内容清零。 |
| _mm256_zeroupper⚠ | avx将所有 YMM 寄存器的高 128 位清零; 寄存器的低 128 位保持不变。 |
| _mm256_zextpd128_pd256⚠ | avx,sse2从 a 创建一个 |
| _mm256_zextps128_ps256⚠ | avx,sse从 a 创建一个 |
| _mm256_zextsi128_si256⚠ | avx,sse2从 128 位整数 vector 创建一个 256 位整数 vector。 低 128 位包含源 vector 的值。上层 128 位设置为零。 |
| _mm512_storeu_ps⚠ | avx512f将来自 |
| _mm_abs_epi8⚠ | ssse3计算 |
| _mm_abs_epi16⚠ | ssse3计算 |
| _mm_abs_epi32⚠ | ssse3计算 |
| _mm_add_epi8⚠ | sse2在 |
| _mm_add_epi16⚠ | sse2在 |
| _mm_add_epi32⚠ | sse2在 |
| _mm_add_epi64⚠ | sse2在 |
| _mm_add_pd⚠ | sse2在 |
| _mm_add_ps⚠ | sse添加 __m128 vectors。 |
| _mm_add_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_add_ss⚠ | sse添加 |
| _mm_adds_epi8⚠ | sse2使用饱和度在 |
| _mm_adds_epi16⚠ | sse2使用饱和度在 |
| _mm_adds_epu8⚠ | sse2使用饱和度在 |
| _mm_adds_epu16⚠ | sse2使用饱和度在 |
| _mm_addsub_pd⚠ | sse3或者，在 |
| _mm_addsub_ps⚠ | sse3或者，在 |
| _mm_aesdec_si128⚠ | aes对 |
| _mm_aesdeclast_si128⚠ | aes对 |
| _mm_aesenc_si128⚠ | aes对 |
| _mm_aesenclast_si128⚠ | aes对 |
| _mm_aesimc_si128⚠ | aes在 |
| _mm_aeskeygenassist_si128⚠ | aes协助扩展 AES 密钥。 |
| _mm_alignr_epi8⚠ | ssse3将 |
| _mm_and_pd⚠ | sse2计算 |
| _mm_and_ps⚠ | sse包装的单精度 (32-bit) 浮点元素的按位与。 |
| _mm_and_si128⚠ | sse2计算 |
| _mm_andnot_pd⚠ | sse2计算 |
| _mm_andnot_ps⚠ | sse包装的单精度 (32-bit) 浮点元素的按位与非运算。 |
| _mm_andnot_si128⚠ | sse2计算 |
| _mm_avg_epu8⚠ | sse2
|
| _mm_avg_epu16⚠ | sse2
|
| _mm_blend_epi16⚠ | sse4.1使用掩码 |
| _mm_blend_epi32⚠ | avx2使用控制掩码 |
| _mm_blend_pd⚠ | sse4.1使用控制掩码 |
| _mm_blend_ps⚠ | sse4.1使用掩码 |
| _mm_blendv_epi8⚠ | sse4.1使用 |
| _mm_blendv_pd⚠ | sse4.1使用 |
| _mm_blendv_ps⚠ | sse4.1使用 |
| _mm_broadcast_ss⚠ | avx从内存向返回的 vector 的所有元素广播单精度 (32-bit) 浮点元素。 |
| _mm_broadcastb_epi8⚠ | avx2将 |
| _mm_broadcastd_epi32⚠ | avx2将 |
| _mm_broadcastq_epi64⚠ | avx2将 |
| _mm_broadcastsd_pd⚠ | avx2将低双精度 (64-bit) 浮点元素从 |
| _mm_broadcastss_ps⚠ | avx2将低单精度 (32-bit) 浮点元素从 |
| _mm_broadcastw_epi16⚠ | avx2将低包装的 16 位整数从 a 广播到 128 位返回值的所有元素 |
| _mm_bslli_si128⚠ | sse2将 |
| _mm_bsrli_si128⚠ | sse2将 |
| _mm_castpd_ps⚠ | sse2将 |
| _mm_castpd_si128⚠ | sse2将 |
| _mm_castps_pd⚠ | sse2将 |
| _mm_castps_si128⚠ | sse2将 |
| _mm_castsi128_pd⚠ | sse2将 128 位整数 vector 转换为 |
| _mm_castsi128_ps⚠ | sse2将 128 位整数 vector 转换为 |
| _mm_ceil_pd⚠ | sse4.1将 |
| _mm_ceil_ps⚠ | sse4.1将 |
| _mm_ceil_sd⚠ | sse4.1将 |
| _mm_ceil_ss⚠ | sse4.1将 |
| _mm_clflush⚠ | sse2使高速缓存层次结构中所有级别的包含 |
| _mm_clmulepi64_si128⚠ | pclmulqdq在有限域 GF(2^k) 上执行两个 64 位多项式的无进位乘法。 |
| _mm_cmp_pd⚠ | avx,sse2根据 |
| _mm_cmp_ps⚠ | avx,sse根据 |
| _mm_cmp_sd⚠ | avx,sse2根据 |
| _mm_cmp_ss⚠ | avx,sse根据 |
| _mm_cmpeq_epi8⚠ | sse2比较 |
| _mm_cmpeq_epi16⚠ | sse2比较 |
| _mm_cmpeq_epi32⚠ | sse2比较 |
| _mm_cmpeq_epi64⚠ | sse4.1比较 |
| _mm_cmpeq_pd⚠ | sse2比较 |
| _mm_cmpeq_ps⚠ | sse将 |
| _mm_cmpeq_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpeq_ss⚠ | sse比较两个输入中的最低 |
| _mm_cmpestra⚠ | sse4.2使用 |
| _mm_cmpestrc⚠ | sse4.2使用 |
| _mm_cmpestri⚠ | sse4.2使用 |
| _mm_cmpestrm⚠ | sse4.2使用 |
| _mm_cmpestro⚠ | sse4.2使用 |
| _mm_cmpestrs⚠ | sse4.2使用 |
| _mm_cmpestrz⚠ | sse4.2使用 |
| _mm_cmpge_pd⚠ | sse2比较 |
| _mm_cmpge_ps⚠ | sse将 |
| _mm_cmpge_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpge_ss⚠ | sse比较两个输入的最低 |
| _mm_cmpgt_epi8⚠ | sse2比较 |
| _mm_cmpgt_epi16⚠ | sse2比较 |
| _mm_cmpgt_epi32⚠ | sse2比较 |
| _mm_cmpgt_epi64⚠ | sse4.2比较 |
| _mm_cmpgt_pd⚠ | sse2比较 |
| _mm_cmpgt_ps⚠ | sse将 |
| _mm_cmpgt_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpgt_ss⚠ | sse比较两个输入的最低 |
| _mm_cmpistra⚠ | sse4.2使用 |
| _mm_cmpistrc⚠ | sse4.2使用 |
| _mm_cmpistri⚠ | sse4.2使用 |
| _mm_cmpistrm⚠ | sse4.2使用 |
| _mm_cmpistro⚠ | sse4.2使用 |
| _mm_cmpistrs⚠ | sse4.2使用 |
| _mm_cmpistrz⚠ | sse4.2使用 |
| _mm_cmple_pd⚠ | sse2比较 |
| _mm_cmple_ps⚠ | sse将 |
| _mm_cmple_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmple_ss⚠ | sse比较两个输入中的最低 |
| _mm_cmplt_epi8⚠ | sse2比较 |
| _mm_cmplt_epi16⚠ | sse2比较 |
| _mm_cmplt_epi32⚠ | sse2比较 |
| _mm_cmplt_pd⚠ | sse2比较 |
| _mm_cmplt_ps⚠ | sse将 |
| _mm_cmplt_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmplt_ss⚠ | sse比较两个输入的最低 |
| _mm_cmpneq_pd⚠ | sse2比较 |
| _mm_cmpneq_ps⚠ | sse将 |
| _mm_cmpneq_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpneq_ss⚠ | sse比较两个输入中最低的 |
| _mm_cmpnge_pd⚠ | sse2比较 |
| _mm_cmpnge_ps⚠ | sse将 |
| _mm_cmpnge_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpnge_ss⚠ | sse比较两个输入中的最低 |
| _mm_cmpngt_pd⚠ | sse2比较 |
| _mm_cmpngt_ps⚠ | sse将 |
| _mm_cmpngt_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpngt_ss⚠ | sse比较两个输入的最低 |
| _mm_cmpnle_pd⚠ | sse2比较 |
| _mm_cmpnle_ps⚠ | sse将 |
| _mm_cmpnle_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpnle_ss⚠ | sse比较两个输入的最低 |
| _mm_cmpnlt_pd⚠ | sse2比较 |
| _mm_cmpnlt_ps⚠ | sse将 |
| _mm_cmpnlt_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpnlt_ss⚠ | sse比较两个输入中的最低 |
| _mm_cmpord_pd⚠ | sse2比较 |
| _mm_cmpord_ps⚠ | sse将 |
| _mm_cmpord_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpord_ss⚠ | sse检查两个输入中最低的 |
| _mm_cmpunord_pd⚠ | sse2比较 |
| _mm_cmpunord_ps⚠ | sse将 |
| _mm_cmpunord_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_cmpunord_ss⚠ | sse检查两个输入中最低的 |
| _mm_comieq_sd⚠ | sse2比较 |
| _mm_comieq_ss⚠ | sse比较 |
| _mm_comige_sd⚠ | sse2比较 |
| _mm_comige_ss⚠ | sse比较 |
| _mm_comigt_sd⚠ | sse2比较 |
| _mm_comigt_ss⚠ | sse比较 |
| _mm_comile_sd⚠ | sse2比较 |
| _mm_comile_ss⚠ | sse比较 |
| _mm_comilt_sd⚠ | sse2比较 |
| _mm_comilt_ss⚠ | sse比较 |
| _mm_comineq_sd⚠ | sse2比较 |
| _mm_comineq_ss⚠ | sse比较 |
| _mm_crc32_u8⚠ | sse4.2从 |
| _mm_crc32_u16⚠ | sse4.2从 |
| _mm_crc32_u32⚠ | sse4.2从 |
| _mm_cvt_si2ss⚠ | sse
|
| _mm_cvt_ss2si⚠ | sse
|
| _mm_cvtepi8_epi16⚠ | sse4.1符号将 |
| _mm_cvtepi8_epi32⚠ | sse4.1符号将 |
| _mm_cvtepi8_epi64⚠ | sse4.1符号将 |
| _mm_cvtepi16_epi32⚠ | sse4.1符号将 |
| _mm_cvtepi16_epi64⚠ | sse4.1符号将 |
| _mm_cvtepi32_epi64⚠ | sse4.1符号将 |
| _mm_cvtepi32_pd⚠ | sse2将 |
| _mm_cvtepi32_ps⚠ | sse2将 |
| _mm_cvtepu8_epi16⚠ | sse4.1零将 |
| _mm_cvtepu8_epi32⚠ | sse4.1零将 |
| _mm_cvtepu8_epi64⚠ | sse4.1零将 |
| _mm_cvtepu16_epi32⚠ | sse4.1零将 |
| _mm_cvtepu16_epi64⚠ | sse4.1零将 |
| _mm_cvtepu32_epi64⚠ | sse4.1零将 |
| _mm_cvtpd_epi32⚠ | sse2将 |
| _mm_cvtpd_ps⚠ | sse2将 |
| _mm_cvtps_epi32⚠ | sse2将 |
| _mm_cvtps_pd⚠ | sse2将 |
| _mm_cvtsd_f64⚠ | sse2返回 |
| _mm_cvtsd_si32⚠ | sse2将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位整数。 |
| _mm_cvtsd_ss⚠ | sse2将 |
| _mm_cvtsi32_sd⚠ | sse2将 |
| _mm_cvtsi32_si128⚠ | sse2返回 vector，其最低元素为 |
| _mm_cvtsi32_ss⚠ | sse将 32 位整数转换为 32 位浮点型。
结果 vector 是输入 vector |
| _mm_cvtsi128_si32⚠ | sse2返回 |
| _mm_cvtss_f32⚠ | sse从输入 vector 中提取最低的 32 位浮点数。 |
| _mm_cvtss_sd⚠ | sse2将 |
| _mm_cvtss_si32⚠ | sse将输入 vector 中的最低 32 位浮点型转换为 32 位整数。 |
| _mm_cvtt_ss2si⚠ | sse
|
| _mm_cvttpd_epi32⚠ | sse2将 |
| _mm_cvttps_epi32⚠ | sse2将 |
| _mm_cvttsd_si32⚠ | sse2将 |
| _mm_cvttss_si32⚠ | sse将输入 vector 中的最低 32 位浮点型转换为带有截断的 32 位整数。 |
| _mm_div_pd⚠ | sse2将 |
| _mm_div_ps⚠ | sse除 __m128 vectors。 |
| _mm_div_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_div_ss⚠ | sse将 |
| _mm_dp_pd⚠ | sse4.1返回两个 __m128d vectors 的点积。 |
| _mm_dp_ps⚠ | sse4.1返回两个 __m128 vectors 的点积。 |
| _mm_extract_epi8⚠ | sse4.1从 |
| _mm_extract_epi16⚠ | sse2返回 |
| _mm_extract_epi32⚠ | sse4.1从 |
| _mm_extract_ps⚠ | sse4.1从 |
| _mm_extract_si64⚠ | sse4a从 |
| _mm_floor_pd⚠ | sse4.1将 |
| _mm_floor_ps⚠ | sse4.1将 |
| _mm_floor_sd⚠ | sse4.1将 |
| _mm_floor_ss⚠ | sse4.1将 |
| _mm_fmadd_pd⚠ | fma将 |
| _mm_fmadd_ps⚠ | fma将 |
| _mm_fmadd_sd⚠ | fma将 |
| _mm_fmadd_ss⚠ | fma将 |
| _mm_fmaddsub_pd⚠ | fma将 |
| _mm_fmaddsub_ps⚠ | fma将 |
| _mm_fmsub_pd⚠ | fma将 |
| _mm_fmsub_ps⚠ | fma将 |
| _mm_fmsub_sd⚠ | fma将 |
| _mm_fmsub_ss⚠ | fma将 |
| _mm_fmsubadd_pd⚠ | fma将 |
| _mm_fmsubadd_ps⚠ | fma将 |
| _mm_fnmadd_pd⚠ | fma将 |
| _mm_fnmadd_ps⚠ | fma将 |
| _mm_fnmadd_sd⚠ | fma将 |
| _mm_fnmadd_ss⚠ | fma将 |
| _mm_fnmsub_pd⚠ | fma将 |
| _mm_fnmsub_ps⚠ | fma将 |
| _mm_fnmsub_sd⚠ | fma将 |
| _mm_fnmsub_ss⚠ | fma将 |
| _mm_getcsr⚠ | sse获取 MXCSR 控制和状态寄存器的无符号 32 位值。 |
| _mm_hadd_epi16⚠ | ssse3水平相加 2 个包装的包中包含的相邻值对
|
| _mm_hadd_epi32⚠ | ssse3水平相加 2 个包装的包中包含的相邻值对
|
| _mm_hadd_pd⚠ | sse3在 |
| _mm_hadd_ps⚠ | sse3在 |
| _mm_hadds_epi16⚠ | ssse3水平相加 2 个包装的包中包含的相邻值对
|
| _mm_hsub_epi16⚠ | ssse3水平减去 |
| _mm_hsub_epi32⚠ | ssse3水平减去 |
| _mm_hsub_pd⚠ | sse3水平减去 |
| _mm_hsub_ps⚠ | sse3在 |
| _mm_hsubs_epi16⚠ | ssse3水平减去 |
| _mm_i32gather_epi32⚠ | avx2从 |
| _mm_i32gather_epi64⚠ | avx2从 |
| _mm_i32gather_pd⚠ | avx2从 |
| _mm_i32gather_ps⚠ | avx2从 |
| _mm_i64gather_epi32⚠ | avx2从 |
| _mm_i64gather_epi64⚠ | avx2从 |
| _mm_i64gather_pd⚠ | avx2从 |
| _mm_i64gather_ps⚠ | avx2从 |
| _mm_insert_epi8⚠ | sse4.1返回 |
| _mm_insert_epi16⚠ | sse2返回一个新的 vector，其中 |
| _mm_insert_epi32⚠ | sse4.1返回 |
| _mm_insert_ps⚠ | sse4.1在 |
| _mm_insert_si64⚠ | sse4a将 |
| _mm_lddqu_si128⚠ | sse3从未对齐的内存中加载 128 位整数数据。
当数据越过缓存行边界时，此内联函数可能比 |
| _mm_lfence⚠ | sse2对在此指令之前发布的所有内存加载指令执行序列化操作。 |
| _mm_load1_pd⚠ | sse2将内存中的双精度 (64-bit) 浮点元素加载到返回的 vector 的两个元素中。 |
| _mm_load1_ps⚠ | sse通过将从 |
| _mm_load_pd⚠ | sse2从内存中将 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 加载到返回的 vector 中。 |
| _mm_load_pd1⚠ | sse2将内存中的双精度 (64-bit) 浮点元素加载到返回的 vector 的两个元素中。 |
| _mm_load_ps⚠ | sse将 aligned 内存中的四个 |
| _mm_load_ps1⚠ | sse
|
| _mm_load_sd⚠ | sse2将 64 位双精度值加载到 128 位整数 vector 并清除高位元素。 |
| _mm_load_si128⚠ | sse2从内存中将 128 位整数数据加载到新的 vector 中。 |
| _mm_load_ss⚠ | sse使用从 |
| _mm_loaddup_pd⚠ | sse3将内存中的双精度 (64-bit) 浮点元素加载到返回 vector 的两个元素中。 |
| _mm_loadh_pd⚠ | sse2将双精度值加载到 |
| _mm_loadl_epi64⚠ | sse2将内存中的 64 位整数加载到返回的 vector 的第一个元素中。 |
| _mm_loadl_pd⚠ | sse2将双精度值加载到 |
| _mm_loadr_pd⚠ | sse2以相反的顺序将 2 个双精度 (64-bit) 浮点元素从内存加载到返回的 vector 中。
|
| _mm_loadr_ps⚠ | sse从对齐的内存中以相反的顺序将四个 |
| _mm_loadu_pd⚠ | sse2从内存中将 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 加载到返回的 vector 中。 |
| _mm_loadu_ps⚠ | sse从内存中将四个 |
| _mm_loadu_si64⚠ | sse将未对齐的 64 位整数数据从内存加载到新的 vector 中。 |
| _mm_loadu_si128⚠ | sse2从内存中将 128 位整数数据加载到新的 vector 中。 |
| _mm_madd_epi16⚠ | sse2在 |
| _mm_maddubs_epi16⚠ | ssse3将第一个源操作数中包含的包装的 8 位无符号整数值与第二个源操作数中包含的包装的 8 位有符号整数值的对应对相乘，相加具有符号饱和度的连续乘积对，并将 16 位和写入到目标中的相应位。 |
| _mm_mask_i32gather_epi32⚠ | avx2从 |
| _mm_mask_i32gather_epi64⚠ | avx2从 |
| _mm_mask_i32gather_pd⚠ | avx2从 |
| _mm_mask_i32gather_ps⚠ | avx2从 |
| _mm_mask_i64gather_epi32⚠ | avx2从 |
| _mm_mask_i64gather_epi64⚠ | avx2从 |
| _mm_mask_i64gather_pd⚠ | avx2从 |
| _mm_mask_i64gather_ps⚠ | avx2从 |
| _mm_maskload_epi32⚠ | avx2使用 |
| _mm_maskload_epi64⚠ | avx2使用 |
| _mm_maskload_pd⚠ | avx使用 |
| _mm_maskload_ps⚠ | avx使用 |
| _mm_maskmoveu_si128⚠ | sse2使用 |
| _mm_maskstore_epi32⚠ | avx2使用 |
| _mm_maskstore_epi64⚠ | avx2使用 |
| _mm_maskstore_pd⚠ | avx使用 |
| _mm_maskstore_ps⚠ | avx使用 |
| _mm_max_epi8⚠ | sse4.1比较 |
| _mm_max_epi16⚠ | sse2比较 |
| _mm_max_epi32⚠ | sse4.1比较 |
| _mm_max_epu8⚠ | sse2比较 |
| _mm_max_epu16⚠ | sse4.1比较 |
| _mm_max_epu32⚠ | sse4.1比较 |
| _mm_max_pd⚠ | sse2返回一个新的 vector，它具有 |
| _mm_max_ps⚠ | sse比较 |
| _mm_max_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_max_ss⚠ | sse比较 |
| _mm_mfence⚠ | sse2对在此指令之前发布的所有从内存加载和存储到内存指令执行序列化操作。 |
| _mm_min_epi8⚠ | sse4.1比较 |
| _mm_min_epi16⚠ | sse2比较 |
| _mm_min_epi32⚠ | sse4.1比较 |
| _mm_min_epu8⚠ | sse2比较 |
| _mm_min_epu16⚠ | sse4.1比较 |
| _mm_min_epu32⚠ | sse4.1比较 |
| _mm_min_pd⚠ | sse2返回一个新的 vector，它具有 |
| _mm_min_ps⚠ | sse比较 |
| _mm_min_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_min_ss⚠ | sse比较 |
| _mm_minpos_epu16⚠ | sse4.1在 128 位 __m128i vector 中查找最小的无符号 16 位元素，并返回一个 vector，其中在第一个位置包含其值，在第二个位置包含其索引; 所有其他元素都设置为零。 |
| _mm_move_epi64⚠ | sse2返回 vector，其中从 |
| _mm_move_sd⚠ | sse2构造 |
| _mm_move_ss⚠ | sse返回 |
| _mm_movedup_pd⚠ | sse3从 |
| _mm_movehdup_ps⚠ | sse3
|
| _mm_movehl_ps⚠ | sse合并 |
| _mm_moveldup_ps⚠ | sse3
|
| _mm_movelh_ps⚠ | sse合并 |
| _mm_movemask_epi8⚠ | sse2返回 |
| _mm_movemask_pd⚠ | sse2返回 |
| _mm_movemask_ps⚠ | sse返回 |
| _mm_mpsadbw_epu8⚠ | sse4.1减去 8 位无符号整数值，然后将差的绝对值计算为目标中的相应位。 |
| _mm_mul_epi32⚠ | sse4.1将 |
| _mm_mul_epu32⚠ | sse2将 |
| _mm_mul_pd⚠ | sse2将 |
| _mm_mul_ps⚠ | sse乘以 __m128 vectors。 |
| _mm_mul_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_mul_ss⚠ | sse将 |
| _mm_mulhi_epi16⚠ | sse2将 |
| _mm_mulhi_epu16⚠ | sse2将 |
| _mm_mulhrs_epi16⚠ | ssse3将包装的 16 位带符号整数值相乘，通过右移将 32 位乘积截断为 18 个最高有效位，通过加 1 舍入舍入后的值，并将 |
| _mm_mullo_epi16⚠ | sse2将 |
| _mm_mullo_epi32⚠ | sse4.1将 |
| _mm_or_pd⚠ | sse2计算 |
| _mm_or_ps⚠ | sse包装的单精度 (32-bit) 浮点元素的按位或。 |
| _mm_or_si128⚠ | sse2计算 |
| _mm_packs_epi16⚠ | sse2使用带符号的饱和度将包装的 16 位整数从 |
| _mm_packs_epi32⚠ | sse2使用带符号的饱和度将包装的 32 位整数从 |
| _mm_packus_epi16⚠ | sse2使用无符号饱和度将 |
| _mm_packus_epi32⚠ | sse4.1使用无符号饱和度将包装的 32 位整数从 |
| _mm_pause⚠ | 向处理器提示代码序列是自旋等待循环。 |
| _mm_permute_pd⚠ | avx,sse2使用 |
| _mm_permute_ps⚠ | avx,sse使用 |
| _mm_permutevar_pd⚠ | avx使用 |
| _mm_permutevar_ps⚠ | avx使用 |
| _mm_prefetch⚠ | sse使用给定的 |
| _mm_rcp_ps⚠ | sse返回 |
| _mm_rcp_ss⚠ | sse返回 |
| _mm_round_pd⚠ | sse4.1使用 |
| _mm_round_ps⚠ | sse4.1使用 |
| _mm_round_sd⚠ | sse4.1使用 |
| _mm_round_ss⚠ | sse4.1使用 |
| _mm_rsqrt_ps⚠ | sse返回 |
| _mm_rsqrt_ss⚠ | sse返回 |
| _mm_sad_epu8⚠ | sse2包装无符号 8 位整数的绝对差之和。 |
| _mm_set1_epi8⚠ | sse2向所有元素广播 8 位整数 |
| _mm_set1_epi16⚠ | sse2向所有元素广播 16 位整数 |
| _mm_set1_epi32⚠ | sse2向所有元素广播 32 位整数 |
| _mm_set1_epi64x⚠ | sse2向所有元素广播 64 位整数 |
| _mm_set1_pd⚠ | sse2向返回值的所有元素广播双精度 (64-bit) 浮点值 a。 |
| _mm_set1_ps⚠ | sse创建一个 |
| _mm_set_epi8⚠ | sse2使用提供的值设置包装的 8 位整数。 |
| _mm_set_epi16⚠ | sse2使用提供的值设置包装的 16 位整数。 |
| _mm_set_epi32⚠ | sse2使用提供的值设置包装的 32 位整数。 |
| _mm_set_epi64x⚠ | sse2使用提供的值 (从最高到最低) 设置包装的 64 位整数。 |
| _mm_set_pd⚠ | sse2使用提供的值在返回值中设置包装的双精度 (64-bit) 浮点元素。 |
| _mm_set_pd1⚠ | sse2向返回值的所有元素广播双精度 (64-bit) 浮点值 a。 |
| _mm_set_ps⚠ | sse从最高到最低的四个浮点值构造 |
| _mm_set_ps1⚠ | sse
|
| _mm_set_sd⚠ | sse2将双精度 (64-bit) 浮点元素 |
| _mm_set_ss⚠ | sse创建一个 |
| _mm_setcsr⚠ | sse用 32 位无符号整数值设置 MXCSR 寄存器。 |
| _mm_setr_epi8⚠ | sse2以相反的顺序设置提供的值的包装 8 位整数。 |
| _mm_setr_epi16⚠ | sse2以相反的顺序设置提供的值的包装 16 位整数。 |
| _mm_setr_epi32⚠ | sse2以相反的顺序设置提供的值的包装 32 位整数。 |
| _mm_setr_pd⚠ | sse2在返回值中设置包装的双精度 (64-bit) 浮点元素，并以相反的顺序提供提供的值。 |
| _mm_setr_ps⚠ | sse从四个最低到最高的浮点值构造 |
| _mm_setzero_pd⚠ | sse2返回全零的包装的双精度 (64-bit) 浮点元素。 |
| _mm_setzero_ps⚠ | sse创建一个 |
| _mm_setzero_si128⚠ | sse2返回所有元素均设置为零的 vector。 |
| _mm_sfence⚠ | sse对在此指令之前发出的所有存储到内存指令执行序列化操作。 |
| _mm_sha1msg1_epu32⚠ | sha使用来自 |
| _mm_sha1msg2_epu32⚠ | sha使用 |
| _mm_sha1nexte_epu32⚠ | sha经过四轮运算后，从当前 SHA1 状态变量 |
| _mm_sha1rnds4_epu32⚠ | sha使用来自 |
| _mm_sha256msg1_epu32⚠ | sha使用来自 |
| _mm_sha256msg2_epu32⚠ | sha使用以前的 |
| _mm_sha256rnds2_epu32⚠ | sha使用来自 |
| _mm_shuffle_epi8⚠ | ssse3根据 |
| _mm_shuffle_epi32⚠ | sse2使用 |
| _mm_shuffle_pd⚠ | sse2从两个创建一个 |
| _mm_shuffle_ps⚠ | sse使用 |
| _mm_shufflehi_epi16⚠ | sse2使用 |
| _mm_shufflelo_epi16⚠ | sse2使用 |
| _mm_sign_epi8⚠ | ssse3当 |
| _mm_sign_epi16⚠ | ssse3当 |
| _mm_sign_epi32⚠ | ssse3当 |
| _mm_sll_epi16⚠ | sse2将 |
| _mm_sll_epi32⚠ | sse2将 |
| _mm_sll_epi64⚠ | sse2将 |
| _mm_slli_epi16⚠ | sse2将 |
| _mm_slli_epi32⚠ | sse2将 |
| _mm_slli_epi64⚠ | sse2将 |
| _mm_slli_si128⚠ | sse2将 |
| _mm_sllv_epi32⚠ | avx2将 |
| _mm_sllv_epi64⚠ | avx2将 |
| _mm_sqrt_pd⚠ | sse2返回一个新的 vector，它具有 |
| _mm_sqrt_ps⚠ | sse返回 |
| _mm_sqrt_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_sqrt_ss⚠ | sse返回 |
| _mm_sra_epi16⚠ | sse2将符号位移入时，将 |
| _mm_sra_epi32⚠ | sse2将符号位移位时，将 |
| _mm_srai_epi16⚠ | sse2将 |
| _mm_srai_epi32⚠ | sse2将 |
| _mm_srav_epi32⚠ | avx2将 |
| _mm_srl_epi16⚠ | sse2将 |
| _mm_srl_epi32⚠ | sse2将 |
| _mm_srl_epi64⚠ | sse2将 |
| _mm_srli_epi16⚠ | sse2将 |
| _mm_srli_epi32⚠ | sse2将 |
| _mm_srli_epi64⚠ | sse2将 |
| _mm_srli_si128⚠ | sse2将 |
| _mm_srlv_epi32⚠ | avx2将 |
| _mm_srlv_epi64⚠ | avx2将 |
| _mm_store1_pd⚠ | sse2将来自 |
| _mm_store1_ps⚠ | sse将 |
| _mm_store_pd⚠ | sse2将来自 |
| _mm_store_pd1⚠ | sse2将来自 |
| _mm_store_ps⚠ | sse将四个 32 位浮点数存储到 aligned 存储器中。 |
| _mm_store_ps1⚠ | sse
|
| _mm_store_sd⚠ | sse2将 |
| _mm_store_si128⚠ | sse2将来自 |
| _mm_store_ss⚠ | sse将 |
| _mm_storeh_pd⚠ | sse2将 |
| _mm_storel_epi64⚠ | sse2将低 64 位整数 |
| _mm_storel_pd⚠ | sse2将 |
| _mm_storer_pd⚠ | sse2将 |
| _mm_storer_ps⚠ | sse以相反的顺序将四个 32 位浮点数存储到 aligned 存储器中。 |
| _mm_storeu_pd⚠ | sse2将来自 |
| _mm_storeu_ps⚠ | sse将四个 32 位浮点数存储到内存中。内存对齐没有任何限制。
对于对齐的内存， |
| _mm_storeu_si128⚠ | sse2将来自 |
| _mm_stream_pd⚠ | sse2将 |
| _mm_stream_ps⚠ | sse使用非临时内存提示将 |
| _mm_stream_sd⚠ | sse4a
|
| _mm_stream_si32⚠ | sse2将 32 位整数值存储在指定的内存位置。 为了最大程度地减少缓存，数据被标记为非时间性的 (不太可能很快再次使用)。 |
| _mm_stream_si128⚠ | sse2将 128 位整数 vector 存储到 128 位对齐的内存位置。 为了最大程度地减少缓存，数据被标记为非时间性的 (不太可能很快再次使用)。 |
| _mm_stream_ss⚠ | sse4a
|
| _mm_sub_epi8⚠ | sse2从 |
| _mm_sub_epi16⚠ | sse2从 |
| _mm_sub_epi32⚠ | sse2从 |
| _mm_sub_epi64⚠ | sse2从 |
| _mm_sub_pd⚠ | sse2从 |
| _mm_sub_ps⚠ | sse减去 __m128 vectors。 |
| _mm_sub_sd⚠ | sse2返回一个新的 vector，其中 |
| _mm_sub_ss⚠ | sse从 |
| _mm_subs_epi8⚠ | sse2使用饱和度从 |
| _mm_subs_epi16⚠ | sse2使用饱和度从 |
| _mm_subs_epu8⚠ | sse2使用饱和度从 |
| _mm_subs_epu16⚠ | sse2使用饱和度从 |
| _mm_test_all_ones⚠ | sse4.1测试 |
| _mm_test_all_zeros⚠ | sse4.1测试 128 位整数 vector 中的指定位是否全部为零。 |
| _mm_test_mix_ones_zeros⚠ | sse4.1测试 128 位整数 vector 中的指定位是否既不是全零也不是全 1。 |
| _mm_testc_pd⚠ | avx计算 |
| _mm_testc_ps⚠ | avx计算 |
| _mm_testc_si128⚠ | sse4.1测试 128 位整数 vector 中的指定位是否全部为 1。 |
| _mm_testnzc_pd⚠ | avx计算 |
| _mm_testnzc_ps⚠ | avx计算 |
| _mm_testnzc_si128⚠ | sse4.1测试 128 位整数 vector 中的指定位是否既不是全零也不是全 1。 |
| _mm_testz_pd⚠ | avx计算 |
| _mm_testz_ps⚠ | avx计算 |
| _mm_testz_si128⚠ | sse4.1测试 128 位整数 vector 中的指定位是否全部为零。 |
| _mm_tzcnt_32⚠ | bmi1计算尾随的最低有效零位的数量。 |
| _mm_ucomieq_sd⚠ | sse2比较 |
| _mm_ucomieq_ss⚠ | sse比较 |
| _mm_ucomige_sd⚠ | sse2比较 |
| _mm_ucomige_ss⚠ | sse比较 |
| _mm_ucomigt_sd⚠ | sse2比较 |
| _mm_ucomigt_ss⚠ | sse比较 |
| _mm_ucomile_sd⚠ | sse2比较 |
| _mm_ucomile_ss⚠ | sse比较 |
| _mm_ucomilt_sd⚠ | sse2比较 |
| _mm_ucomilt_ss⚠ | sse比较 |
| _mm_ucomineq_sd⚠ | sse2比较 |
| _mm_ucomineq_ss⚠ | sse比较 |
| _mm_undefined_pd⚠ | sse2返回带有未定义元素的 __m128d 类型的 vector。 |
| _mm_undefined_ps⚠ | sse返回类型为 __m128 的 vector，其中包含未定义的元素。 |
| _mm_undefined_si128⚠ | sse2返回带有未定义元素的 __m128i 类型的 vector。 |
| _mm_unpackhi_epi8⚠ | sse2从 |
| _mm_unpackhi_epi16⚠ | sse2从 |
| _mm_unpackhi_epi32⚠ | sse2从 |
| _mm_unpackhi_epi64⚠ | sse2从 |
| _mm_unpackhi_pd⚠ | sse2所得的 |
| _mm_unpackhi_ps⚠ | sse从 |
| _mm_unpacklo_epi8⚠ | sse2从 |
| _mm_unpacklo_epi16⚠ | sse2从 |
| _mm_unpacklo_epi32⚠ | sse2从 |
| _mm_unpacklo_epi64⚠ | sse2从 |
| _mm_unpacklo_pd⚠ | sse2所得的 |
| _mm_unpacklo_ps⚠ | sse从 |
| _mm_xor_pd⚠ | sse2计算 |
| _mm_xor_ps⚠ | sse包装的单精度 (32-bit) 浮点元素的按位异或。 |
| _mm_xor_si128⚠ | sse2计算 |
| _mulx_u32⚠ | bmi2无符号乘法，且不影响标志。 |
| _pdep_u32⚠ | bmi2将 |
| _pext_u32⚠ | bmi2将 |
| _popcnt32⚠ | popcnt计算设置的位。 |
| _rdrand16_step⚠ | rdrand读取硬件生成的 16 位随机值，并将结果存储在 val 中。 如果生成随机值，则返回 1，否则返回 0。 |
| _rdrand32_step⚠ | rdrand读取硬件生成的 32 位随机值，并将结果存储在 val 中。 如果生成随机值，则返回 1，否则返回 0。 |
| _rdseed16_step⚠ | rdseed读取符合 NIST SP800-90B 和 SP800-90C 的 16 位随机值，并存储在 val 中。 如果生成随机值，则返回 1，否则返回 0。 |
| _rdseed32_step⚠ | rdseed读取符合 NIST SP800-90B 和 SP800-90C 的 32 位随机值，并存储在 val 中。 如果生成随机值，则返回 1，否则返回 0。 |
| _rdtsc⚠ | 读取处理器时间戳计数器的当前值。 |
| _subborrow_u32⚠ | 将无符号的 32 位整数 |
| _t1mskc_u32⚠ | tbm清除 |
| _t1mskc_u64⚠ | tbm清除 |
| _tzcnt_u32⚠ | bmi1计算尾随的最低有效零位的数量。 |
| _tzmsk_u32⚠ | tbm将所有位设置为低于 |
| _tzmsk_u64⚠ | tbm将所有位设置为低于 |
| _xgetbv⚠ | xsave读取 |
| _xrstor⚠ | xsave使用 |
| _xrstors⚠ | xsave,xsaves使用 |
| _xsave⚠ | xsave将已启用的处理器状态全部或部分保存到 |
| _xsavec⚠ | xsave,xsavec将已启用的处理器状态全部或部分保存到 |
| _xsaveopt⚠ | xsave,xsaveopt将已启用的处理器状态全部或部分保存到 |
| _xsaves⚠ | xsave,xsaves将启用的处理器状态全部或部分保存到以下位置的内存中:
|
| _xsetbv⚠ | xsave从 |
Type Definitions
| _MM_CMPINT_ENUM | Experimental
|
| _MM_MANTISSA_NORM_ENUM | Experimental
|
| _MM_MANTISSA_SIGN_ENUM | Experimental
|
| _MM_PERM_ENUM | Experimental
|
| __mmask8 | Experimental AVX-512 内联函数中使用的 |
| __mmask16 | Experimental AVX-512 内联函数中使用的 |
| __mmask32 | Experimental AVX-512 内联函数中使用的 |
| __mmask64 | Experimental AVX-512 内联函数中使用的 |