Available on x86-64 only.
Expand description
特定于平台的用于 x86_64
平台的内部函数。
有关更多详细信息,请参见 模块级文档。
Structs
- 128 位宽的一组 8 个
u16
类型,特定于 x86 - 256 位宽的 16 种
u16
类型集,特定于 x86 - 512 位宽的十六种
f32
类型集,特定于 x86 - 512 位宽的 32 种
u16
类型集,特定于 x86 - 八种
f64
类型的 512 位宽集,特定于 x86 - 512 位宽的整数 vector 类型,特定于 x86
- CpuidResultx86 or x86-64
cpuid
指令的结果。 - __m128x86 or x86-64四种
f32
类型的 128 位宽集,特定于 x86 - __m128dx86 or x86-64两种
f64
类型的 128 位宽集,特定于 x86 - __m128ix86 or x86-64128 位宽的整数 vector 类型,特定于 x86
- __m256x86 or x86-64256 位宽的八种
f32
类型的集合,特定于 x86 - __m256dx86 or x86-64256 位宽的四种
f64
类型的集合,特定于 x86 - __m256ix86 or x86-64256 位宽的整数 vector 类型,特定于 x86
Constants
- Equal
- False
- Less-than-or-equal
- Less-than
- Not-equal
- 不小于等于
- 不小于
- True
- 区间 [1, 2)
- 区间 [0.5, 1)
- 区间 [0.5, 2)
- 间隔 [0.75,1.5)
- 如果 sign(SRC) =1,则 DEST=NaN
- sign = sign(SRC)
- sign = 0
- 事务中止,因为事务使用了过多的内存。
- 由于与另一个线程发生内存冲突而导致事务中止。
- 事务由于调试陷阱而中止。
- 使用 xabort 显式中止了事务。 传递给 xabort 的参数可用于
_xabort_code(status)
。 - 内部嵌套事务中的事务中止。
- 事务重试是可能的。
- 事务成功开始。
- _CMP_EQ_OQx86 or x86-64相等 (有序,无信号)
- _CMP_EQ_OSx86 or x86-64相等 (有序,发信号)
- _CMP_EQ_UQx86 or x86-64相等 (无序,无信号)
- _CMP_EQ_USx86 or x86-64相等 (无序,发信号)
- _CMP_FALSE_OQx86 or x86-64错误 (有序,无信号)
- _CMP_FALSE_OSx86 or x86-64错误 (有序,发信号)
- _CMP_GE_OQx86 or x86-64大于或等于 (有序,无信号)
- _CMP_GE_OSx86 or x86-64大于或等于 (有序,发信号)
- _CMP_GT_OQx86 or x86-64大于 (有序,无信号)
- _CMP_GT_OSx86 or x86-64大于 (有序,发信号)
- _CMP_LE_OQx86 or x86-64小于或等于 (有序,无信号)
- _CMP_LE_OSx86 or x86-64小于或等于 (有序,发信号)
- _CMP_LT_OQx86 or x86-64小于 (有序,无信号)
- _CMP_LT_OSx86 or x86-64小于 (有序,发信号)
- _CMP_NEQ_OQx86 or x86-64不相等 (有序,无信号)
- _CMP_NEQ_OSx86 or x86-64不相等 (有序,发信号)
- _CMP_NEQ_UQx86 or x86-64不相等 (无序,无信号)
- _CMP_NEQ_USx86 or x86-64不相等 (无序,发信号)
- _CMP_NGE_UQx86 or x86-64不大于等于 (无序,无信号)
- _CMP_NGE_USx86 or x86-64不大于等于 (无序,发信号)
- _CMP_NGT_UQx86 or x86-64不大于 (无序,无信号)
- _CMP_NGT_USx86 or x86-64不大于 (无序,发信号)
- _CMP_NLE_UQx86 or x86-64不小于等于 (无序,无信号)
- _CMP_NLE_USx86 or x86-64不小于等于 (无序,发信号)
- _CMP_NLT_UQx86 or x86-64不少于 (无序,无信号)
- _CMP_NLT_USx86 or x86-64不少于 (无序,发信号)
- _CMP_ORD_Qx86 or x86-64订购 (无信号)
- _CMP_ORD_Sx86 or x86-64订购 (发信号)
- _CMP_TRUE_UQx86 or x86-64真 (无序,无信号)
- _CMP_TRUE_USx86 or x86-64真 (无序,发信号)
- _CMP_UNORD_Qx86 or x86-64无序 (无信号)
- _CMP_UNORD_Sx86 or x86-64无序 (发信号)
- _MM_EXCEPT_DENORMx86 or x86-64请参见
_mm_setcsr
- _MM_EXCEPT_DIV_ZEROx86 or x86-64请参见
_mm_setcsr
- _MM_EXCEPT_INEXACTx86 or x86-64请参见
_mm_setcsr
- _MM_EXCEPT_INVALIDx86 or x86-64请参见
_mm_setcsr
- _MM_EXCEPT_MASKx86 or x86-64
- _MM_EXCEPT_OVERFLOWx86 or x86-64请参见
_mm_setcsr
- _MM_EXCEPT_UNDERFLOWx86 or x86-64请参见
_mm_setcsr
- _MM_FLUSH_ZERO_MASKx86 or x86-64
- _MM_FLUSH_ZERO_OFFx86 or x86-64请参见
_mm_setcsr
- _MM_FLUSH_ZERO_ONx86 or x86-64请参见
_mm_setcsr
- _MM_FROUND_CEILx86 or x86-64向上舍入并且不抑制异常
- _MM_FROUND_CUR_DIRECTIONx86 or x86-64使用 MXCSR.RC; 请参见
vendor::_MM_SET_ROUNDING_MODE
- _MM_FROUND_FLOORx86 or x86-64四舍五入,不抑制异常
- _MM_FROUND_NEARBYINTx86 or x86-64使用 MXCSR.RC 并抑制异常; 请参见
vendor::_MM_SET_ROUNDING_MODE
- _MM_FROUND_NINTx86 or x86-64四舍五入到最接近,不排除异常
- _MM_FROUND_NO_EXCx86 or x86-64抑制异常
- _MM_FROUND_RAISE_EXCx86 or x86-64不要抑制异常
- _MM_FROUND_RINTx86 or x86-64使用 MXCSR.RC 且不抑制异常; 请参见
vendor::_MM_SET_ROUNDING_MODE
- _MM_FROUND_TO_NEAREST_INTx86 or x86-64四舍五入到最接近的
- _MM_FROUND_TO_NEG_INFx86 or x86-64四舍五入
- _MM_FROUND_TO_POS_INFx86 or x86-64围捕
- _MM_FROUND_TO_ZEROx86 or x86-64truncate
- _MM_FROUND_TRUNCx86 or x86-64截断并且不抑制异常
- _MM_HINT_ET0x86 or x86-64请参见
_mm_prefetch
。 - _MM_HINT_ET1x86 or x86-64请参见
_mm_prefetch
。 - _MM_HINT_NTAx86 or x86-64请参见
_mm_prefetch
。 - _MM_HINT_T0x86 or x86-64请参见
_mm_prefetch
。 - _MM_HINT_T1x86 or x86-64请参见
_mm_prefetch
。 - _MM_HINT_T2x86 or x86-64请参见
_mm_prefetch
。 - _MM_MASK_DENORMx86 or x86-64请参见
_mm_setcsr
- _MM_MASK_DIV_ZEROx86 or x86-64请参见
_mm_setcsr
- _MM_MASK_INEXACTx86 or x86-64请参见
_mm_setcsr
- _MM_MASK_INVALIDx86 or x86-64请参见
_mm_setcsr
- _MM_MASK_MASKx86 or x86-64
- _MM_MASK_OVERFLOWx86 or x86-64请参见
_mm_setcsr
- _MM_MASK_UNDERFLOWx86 or x86-64请参见
_mm_setcsr
- _MM_ROUND_DOWNx86 or x86-64请参见
_mm_setcsr
- _MM_ROUND_MASKx86 or x86-64
- _MM_ROUND_NEARESTx86 or x86-64请参见
_mm_setcsr
- _MM_ROUND_TOWARD_ZEROx86 or x86-64请参见
_mm_setcsr
- _MM_ROUND_UPx86 or x86-64请参见
_mm_setcsr
- _SIDD_BIT_MASKx86 or x86-64仅掩码: 返回位掩码
- _SIDD_CMP_EQUAL_ANYx86 or x86-64对于
a
中的每个字符,查找它是否在b
中 (默认) - _SIDD_CMP_EQUAL_EACHx86 or x86-64
a
和b
定义的字符串相等 - _SIDD_CMP_EQUAL_ORDEREDx86 or x86-64在目标中搜索定义的子字符串
- _SIDD_CMP_RANGESx86 or x86-64对于
a
中的每个字符,确定b[0] <= c <= b[1] or b[1] <= c <= b[2]...
- _SIDD_LEAST_SIGNIFICANTx86 or x86-64仅索引: 返回最低有效位 (默认)
- _SIDD_MASKED_NEGATIVE_POLARITYx86 or x86-64仅在字符串结尾之前取反结果
- _SIDD_MASKED_POSITIVE_POLARITYx86 or x86-64不要在字符串结尾之前取反结果
- _SIDD_MOST_SIGNIFICANTx86 or x86-64仅索引: 返回最高有效位
- _SIDD_NEGATIVE_POLARITYx86 or x86-64取反结果
- _SIDD_POSITIVE_POLARITYx86 or x86-64不取消结果 (默认)
- _SIDD_SBYTE_OPSx86 or x86-64字符串包含带符号的 8 位字符
- _SIDD_SWORD_OPSx86 or x86-64字符串包含无符号的 16 位字符
- _SIDD_UBYTE_OPSx86 or x86-64字符串包含无符号的 8 位字符 (默认)
- _SIDD_UNIT_MASKx86 or x86-64仅掩码: 返回字节掩码
- _SIDD_UWORD_OPSx86 or x86-64字符串包含无符号的 16 位字符
- _XCR_XFEATURE_ENABLED_MASKx86 or x86-64
XFEATURE_ENABLED_MASK
为XCR
Functions
- 一个实用程序函数,用于创建与 Intel 重排和置换内部函数一起使用的掩码。
- 将 a 和 b 中的 32 位掩码相加,结果存入 k.
- 将 a 和 b 中的 64 位掩码相加,结果存入 k.
- 计算 16 位掩码 a 和 b 的按位与,并将结果存储在 k.
- 计算 32 位掩码 a 和 b 的按位与,并将结果存储在 k.
- 计算 64 位掩码 a 和 b 的按位与,并将结果存储在 k.
- 计算 16 位掩码 a 的按位非运算,然后与 b 进行与运算,并将结果存储在 k.
- 计算 32 位掩码 a 的按位非运算,然后与 b 进行与运算,并将结果存储在 k.
- 计算 64 位掩码 a 的按位非运算,然后与 b 进行与运算,并将结果存储在 k.
- 计算 16 位掩码 a 的按位非,并将结果存储在 k.
- 计算 32 位掩码 a 的按位非,并将结果存储在 k.
- 计算 64 位掩码 a 的按位非,并将结果存储在 k.
- 计算 16 位掩码 a 和 b 的按位或,并将结果存储在 k.
- 计算 32 位掩码 a 和 b 的按位或,并将结果存储在 k.
- 计算 64 位掩码 a 和 b 的按位或,并将结果存储在 k.
- 计算 16 位掩码 a 和 b 的按位 XNOR,并将结果存储在 k.
- 计算 32 位掩码 a 和 b 的按位 XNOR,并将结果存储在 k.
- 计算 64 位掩码 a 和 b 的按位 XNOR,并将结果存储在 k.
- 计算 16 位掩码 a 和 b 的按位异或,并将结果存储在 k.
- 计算 32 位掩码 a 和 b 的按位异或,并将结果存储在 k.
- 计算 64 位掩码 a 和 b 的按位异或,并将结果存储在 k.
- 从内存中加载 32 位掩码到 k.
- 将内存中的 64 位掩码加载到 k.
- 计算 a 中包装的带符号的 64 位整数的绝对值,并将无符号的结果存储在 dst 中。
- 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行一轮 AES 解密流程。 - 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行最后一轮 AES 解密流程。 - 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行一轮 AES 加密流程。 - 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行最后一轮 AES 加密流程。 - 将 a 和 b 连接成一个 64 字节的 immediate 结果,将结果右移 imm8 个 32 位元素,并将低 32 字节 (8 个元素) 存储在 dst 中。
- 将 a 和 b 连接成 64 字节的 immediate 结果,将结果右移 imm8 个 64 位元素,并将低 32 字节 (4 个元素) 存储在 dst 中。
- 将输入
b
视为包装的 64 位整数,并将c
视为包装的 8 位整数。 然后将c
中的 8 个 8 位值作为索引分组到相应 64 位整数的位中。 然后,选择这些位并将其包装到输出中。 - 从 a 广播 4 个包装的单精度 (32-bit) 浮点元素到 dst 的所有元素。
- 将 4 个包装的 32 位整数从 a 广播到 dst 的所有元素。
- 将输入掩码 k 的低 8 位广播到 dst 的所有 64 位元素。
- 将输入掩码 k 的低 16 位广播到 dst 的所有 32 位元素。
- 在 2 个 128 位 lanes 中的每个 lanes 中,在有限域 GF(2^k) 上执行两个 64 位多项式的无进位乘法。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 8 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 16 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 32 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 64 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 8 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 16 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 32 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 64 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数,比较 a 和 b 中的双精度 (64-bit) 浮点元素,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的单精度 (32-bit) 浮点元素,结果存入 mask vector k.
- 比较 a 和 b 中的有符号 8 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 32 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 64 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 32 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 16 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 32 位整数,并将结果存储在 dst 中。
- 将 A 中的包装的无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 将两个 256 位 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并将结果存入 a
- 将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并将结果存储在 dst 中。 Intel’s documentation
- 将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 8 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 16 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装无符号 32 位整数转换为具有无符号饱和度的包装无符号 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并将结果存储在 dst 中。
- 将 A 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并将结果存储在 dst 中。
- 计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs),并将 16 位结果存储在 dst 中。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间单精度 (32-bit) 浮点元素与 src 中的元素相加,并将结果存储在 dst 中。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果存入 dst。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。使用有符号饱和将这 4 个结果与 src 中相应的 32 位整数相加,并将包装的 32 位结果存储在 dst 中。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果存入 dst。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并将包装的 32 位结果存储在 dst 中。
- 从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用 imm8 进行选择,并将结果存储在 dst 中。
- 从 a 中提取 128 位 (由 4 个包装的 32 位整数组成),用 IMM1 选中,结果存入 dst。
- 使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化,并将结果存储在 dst 中。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 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:
- 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 使用 32 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 将 a 复制到 dst,然后将 b 中的 128 位 (由 4 个压缩单精度 (32 位) 浮点元素组成) 插入到 dst 中 imm8 指定的位置。
- 将 a 复制到 dst,然后将 b 中的 128 位 (由 4 个压缩的 32 位整数组成) 插入到 dst 中 imm8 指定的位置。
- 将 256 位 (由 8 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 将 256 位 (由 4 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 将 256 位 (由 32 个包装的 8 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 将 256 位 (由 16 个包装的 16 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 将 256 位 (由 8 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 将 256 位 (由 4 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并将结果存储在 dst 中。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并将结果存储在 dst 中。
- 将
b
和c
的每个 64 位元素中的包装无符号 52 位整数相乘以形成 104 位中间结果。 将中间结果的高 52 位无符号整数与a
中的相应无符号 64 位整数相加,并将结果存储在dst
中。 - 将
b
和c
的每个 64 位元素中的包装无符号 52 位整数相乘以形成 104 位中间结果。 将中间结果的低 52 位无符号整数与a
中的相应无符号 64 位整数相加,并将结果存储在dst
中。 - 使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 a 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)
- 使用 idx 中的对应选择器和索引在 a 和 b 中的 lanes 中对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素,或者在中间结果中减去并在 c from/to 中包装的元素相乘,然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 c 复制)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的带符号的 16 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的有符号 32 位整数的绝对值,并使用 writemask k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的带符号的 64 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果,将结果右移 imm8 字节,并使用写掩码 k 将低 16 个字节存储在 dst 中 (当相应的屏蔽位未置位时,从 src 复制元素)。
- 将 a 和 b 连接成 64 字节的 immediate 结果,将结果右移 imm8 个 32 位元素,并使用 writemask k 将低 32 字节 (8 个元素) 存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 连接成 64 字节的 immediate 结果,将结果右移 imm8 个 64 位元素,并使用 writemask k 将低 32 字节 (4 个元素) 存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在包装的 a 和 b 的 32 位整数元素之间执行逐个元素的按位 AND,使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位与,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的 32 位整数的按位 NOT,然后与 b 计算 AND,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的 64 位整数的按位 NOT,然后与 b 计算 AND,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 8 位整数平均,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 16 位整数进行平均,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将输入
b
视为包装的 64 位整数,并将c
视为包装的 8 位整数。 然后将c
中的 8 个 8 位值作为索引分组到相应 64 位整数的位中。 然后,选择这些位并将其包装到输出中。 - 使用控制掩码 k 混合 a 和 b 中的包装 8 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装的 16 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合 a 和 b 中的包装 32 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合 a 和 b 中的包装 64 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装后的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用写掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 a 的 4 个包装的 32 位整数广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 d 的低包装的 8 位整数广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低双精度 (64-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低单精度 (32-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 32 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否相等,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的 32 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的 64 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数是否等于或大于等于,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否大于等于,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数是否大于,并将结果使用零掩码 k1 存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数 (小于或等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数 (小于等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数 (小于或等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数以得到小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的 32 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的活动 8 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst,并通过 src 中的其余元素。
- 将 a 中的活动 16 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst,并通过 src 中的其余元素。
- 将活跃的 32 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst,并通过 src 中的其余元素。
- 将活跃的 64 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst,并通过 src 中的其余元素。
- 将活跃的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位在写掩码 k 中设置) 到 dst,并通过 src 中的其余元素。
- 将活跃的单精度 (32-bit) 浮点元素连续存储在 dst 中 (将其各自的位设置在写掩码 k 中的那些元素中) 存储到 dst,并通过 src 中的其余元素。
- 将 a 中的活动 8 位整数 (其各自的位在 writemask k 中设置) 连续存储到 base_addr 处的未对齐内存。
- 将 a 中的活动 16 位整数 (其各自的位在 writemask k 中设置的那些) 连续存储到 base_addr 处的未对齐内存。
- 将活动的 32 位整数连续存储 (在 writemask k 中设置了相应位的那些) 到 base_addr 处的未对齐内存中。
- 将活动的 64 位整数连续存储 (在 writemask k 中设置了相应位的那些) 到 base_addr 处的未对齐内存中。
- 将活动的双精度 (64 位) 浮点元素连续存储 (在 writemask k 中设置了相应位的元素) 到 base_addr 处的未对齐内存中。
- 将活动的单精度 (32 位) 浮点元素连续存储 (在 writemask k 中设置了相应位的元素) 到 base_addr 处的未对齐内存中。
- 使用写掩码 k (当未设置相应的掩码位时,将从 src 复制元素),测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 使用写掩码 k 测试 a 的每个 64 位元素是否与所有其他元素相等 (更接近最低有效位) (当未设置相应的掩码位时,将从 src 复制元素)。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一: (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将包装的 8 位整数从 a 扩展为包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 的低 4 字节中的 8 位整数符号扩展为包装的 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将从 src 复制)。
- 将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将包装后的 16 位整数从 a 扩展为包装后的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数在 a 中转换为带有截断的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 32 位整数转换为带截断的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带有截断的包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带截断的 16 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中包装的 64 位整数转换为包装的 8 位整数并截断,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带截断的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带截断的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 零扩展包装的无符号 8 位整数在 a 的低 8 字节到包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 零扩展包装的无符号 8 位整数在 a 的低 4 字节到包装的 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 零扩展包装的无符号 16 位整数 a 的低 8 字节到包装的 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的单精度 (32-bit) 浮点元素在两个 vector a 和 b 中转换为包装的 BF16 (16-bit) 浮点元素,并使用 writemask k 将结果存储在单个 vector dst 中 (当相应的掩码位不存在时,元素从 src 复制放)。
- 将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装带符号的 16 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 16 位整数转换为有符号饱和的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 16 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的无符号 16 位整数转换为具有无符号饱和的包装的无符号 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的无符号 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。
- 将包装在 a 中的无符号 64 位整数转换为具有无符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 计算 a 中的无符号 8 位整数与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs),并使用写掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间的单精度 (32-bit) 浮点元素与 src 中的元素相加,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (未设置相应掩码位时从 src 复制元素)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。使用符号饱和将这 4 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的有效 32 位整数 (它们各自的位被设置在掩码 k 中),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的有效 64 位整数 (它们各自的位被设置在掩码 k 中),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- _mm256_mask_expandloadu_epi8⚠Experimental(x86 or x86-64) and
avx512f,avx512bw,avx512vbmi2,avx512vl,avx
从 mem_addr 的未对齐内存中加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 src 中复制元素)。 - 从 mem_addr 的未对齐内存中加载连续的活动 16 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 src 中复制元素)。
- 从未对齐内存中的 mem_addr 加载连续的活动 32 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 64 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (64-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位不存在时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (32-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位不存在时,将从 src 复制元素)。
- 从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用 imm8 进行选择,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中提取 128 位 (由 4 个包装的 32 位整数组成),用 IMM1 选中,用 writemask k 将结果存入 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 中复制元素放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位,则从 a 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时,元素将从 a 复制放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 复制元素放)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 将 a 复制到 tmp,然后将 b 中的 128 位 (由 4 个压缩单精度 (32 位) 浮点元素组成) 插入到 tmp 中 imm8 指定的位置。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 复制到 tmp,然后在 imm8 指定的位置,将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 8 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 16 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对,并使用 writemask k 将结果打包到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘,生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对,并使用写掩码 k 将饱和结果包装到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 16 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 32 位整数从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 64 位整数从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘,并使用写掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并使用写掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的带符号的 16 位整数相乘,生成 32 位中间整数,并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 16 位整数相乘,生成 32 位中间整数,并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,通过加 1 舍入,并使用 writemask k 将位 [16:1] 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并使用写掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并使用写掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并使用 writemask k (元素当相应的屏蔽位未设置时,从 src 复制)。
- 计算 a 和 b 中包装的 32 位整数的按位或,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位或,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的控件在 128 位 lane 内将 a 的双精度 (64-bit) 浮点元素进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的控件在 128 位 lane 内将 a 的单精度 (32-bit) 浮点元素打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 a 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 a 和 b 中的 lanes 上对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用 imm8 中的控件在 256 位 lanes 内将 64 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 256 位 lanes 内对双精度 (64-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 的 a 中打乱 8 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中对 32 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引对跨 lanes 中的双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引对跨 lanes 中的单精度 (32-bit) 浮点元素进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 对应元素 b 中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的对应元素中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的对应元素中指定的位数,然后使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 向 dst 的所有元素广播 16 位整数 a (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并使用 writemask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并使用 writemask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并使用 writemask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并使用 writemask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并使用 writemask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并使用 writemask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 使用 b 中相应的 8 位元素中的控件在 128 位 lane 内对 a 中的 8 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件将 128 位 lane 中的 32 位整数随机排列,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 重排,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 进行混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件对 128 位 lane 中的双精度 (64-bit) 浮点元素进行混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,使用 writemask k 将 128 位 lanes 的低 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,使用 writemask k 将 128 位 lanes 的高 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 将包装的 16 位整数按计数左移,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数左移计数,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数左移计数,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数左移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数左移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数向左移动 imm8,同时向零移动,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数按 count 中相应元素指定的数量向左移位,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将填充的 32 位整数向左移动计数中相应元素指定的数量,同时将其移位为零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将填充的 64 位整数向左移动 count 中相应元素指定的数量,同时将其移位为零,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移动符号位的同时右移计数包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移动符号位的同时右移计数包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 count 中相应元素指定的数量,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在将符号位移位的同时,将已包装的 32 位整数向右移动计数中相应元素指定的数量,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移入符号位的同时,将包装的 64 位整数向右移动计数中相应元素指定的数量,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移,同时移零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移,同时移零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 向右移动包装的 32 位整数整数 (由 count 中相应元素指定的数量),同时向零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 向右移位包装的 64 位整数,其数量为计数中相应元素指定的数量,同时向零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask 将 a 中的 32 位整数存储到内存中 k. mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将 a 中的 64 位整数存储到内存中 k. mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将封装的双精度 (64-bit) 浮点元素从 a 存储到内存中 k. mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将封装的单精度 (32-bit) 浮点元素从 a 存储到内存中 k. mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将 a 中的 8 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 16 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 32 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 64 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将封装的双精度 (64-bit) 浮点元素从 a 存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将封装的单精度 (32-bit) 浮点元素从 a 存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度将 b 中的包装 8 位整数减去 b 中的包装 8 位有符号整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 a 饱和度从 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每一位,使用 src、a、b 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 writemask k 在 32 位粒度 (当相应的掩码位未设置时,从 src 复制 32 位元素)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 src、a、b 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 writemask k 在 64 位粒度 (当相应的掩码位未设置时,从 src 复制 64 位元素)。
- 计算 a 和 b 中包装的 8 位整数的按位与,生成中间 8 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 16 位整数的按位与,生成中间的 16 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 32 位整数的按位与,生成中间的 32 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 64 位整数的按位与,生成中间 64 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 8 位整数的按位 NAND,生成中间的 8 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 16 位整数的按位 NAND,生成中间的 16 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 32 位整数的按位 NAND,生成中间的 32 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 64 位整数的按位 NAND,生成中间 64 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的带符号的 16 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的有符号 32 位整数的绝对值,并使用 zeromask k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的带符号的 64 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数添加到 a 和 b 中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数添加到 a 和 b 中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 16 字节块对连接成一个 32 字节的临时结果,将结果右移 imm8 字节,并使用零掩码 k 将低 16 字节存储在 dst 中 (当未设置相应的掩码位时,元素将被清零))。
- 将 a 和 b 连接成一个 64 字节的 immediate 结果,将结果右移 imm8 个 32 位元素,并使用 zeromask k 将低 32 字节 (8 个元素) 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 连接成 64 字节的 immediate 结果,将结果右移 imm8 个 64 位元素,并使用 zeromask k 将低 32 字节 (4 个元素) 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位与,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位与,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的 32 位整数的按位 NOT,然后计算 b 中的 AND,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的 64 位整数的按位 NOT,然后与 b 计算 AND,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 8 位整数进行平均,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 16 位整数进行平均,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 4 的包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 8 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的活动 8 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst,并将其余元素设置为零。
- 将 a 中的活动 16 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst,并将其余元素设置为零。
- 将活跃的 32 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst,并将其余元素设置为零。
- 将活跃的 64 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst,并将其余元素设置为零。
- 将活跃的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst,并将其余元素设置为零。
- 将活跃的单精度 (32-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst,并将其余元素设置为零。
- 使用零掩码 k (当未设置相应的掩码位时,元素将被清零),测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 使用零掩码 k (当未设置相应的掩码位时,元素将被清零),测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 8 位整数从 a 扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 的低 4 字节中的 8 位整数符号扩展为包装的 64 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 符号将包装的 16 位整数从 a 扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 64 位整数转换为带截断的 8 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 64 位整数转换为带截断的 16 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 零扩展包装的无符号 8 位整数 a 的低 8 字节到包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 零扩展包装的无符号 8 位整数在 a 的低 4 字节到包装的 64 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 零扩展包装的无符号 16 位整数 a 的低 8 字节到包装的 64 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在单个 vector dst 中 (当对应的掩码位不存在时,元素归零放)。
- 将包装的单精度 (32-bit) 浮点元素在 a 中转换为包装的 BF16 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装有符号 64 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs) 的总和,并使用零掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间单精度 (32-bit) 浮点元素与 src 中的元素进行累加,并将结果存储在 dst 中使用 zeromask k (当对应的掩码为位未设置)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果使用 zeromask k 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数用带符号饱和求和,并将包装的 32 位结果用 zeromask k 存储在 dst 中 (当对应的掩码位未设置时,元素被清零)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加,并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的有效 32 位整数 (它们各自的位被设置在掩码 k 中),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的有效 64 位整数 (它们各自的位被设置在掩码 k 中),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- _mm256_maskz_expandloadu_epi8⚠Experimental(x86 or x86-64) and
avx512f,avx512bw,avx512vbmi2,avx512vl,avx
从 mem_addr 的未对齐内存中加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素被清零)。 - 从 mem_addr 的未对齐内存中加载连续的活动 16 位整数 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 32 位整数 (在掩码 k 中设置了相应位的那些),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 64 位整数 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (64-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (32-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用 imm8 进行选择,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中提取 128 位 (由 4 个包装的 32 位整数组成),用 IMM1 选择,结果用 zeromask k 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,或者将 C from/to 中的包装元素相减并相加,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 将 a 复制到 tmp,然后将 b 中的 128 位 (由 4 个压缩单精度 (32 位) 浮点元素组成) 插入到 tmp 中 imm8 指定的位置。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时,元素会被清零)。
- 将 a 复制到 tmp,然后在 imm8 指定的位置,将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时,元素会被清零)。
- 使用 zeromask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 8 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 16 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对,并使用 zeromask k 将结果打包到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘,生成中间有符号的 16 位整数。水平添加相邻的一对中间有符号 16 位整数,并使用 zeromask k 将饱和结果打包到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 32 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 32 位整数从 a 移至 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 64 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中每个包装的 64 位元素的低位有符号 32 位整数相乘,并使用零掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并使用零掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的带符号的 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,通过加 1 舍入,并使用 zeromask k 将位 [16:1] 存储到 dst (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并使用零掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并使用 zeromask k (元素当相应的屏蔽位未设置时被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位或,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位或,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的控件在 128 位 lane 内将 a 中的双精度 (64-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的控件在 128 位 lane 内将 a 的单精度 (32-bit) 浮点元素打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 64 位整数进行混洗,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引将 a 和 b 中的双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 256 位 lanes 内将 64 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 256 位 lanes 内将双精度 (64-bit) 浮点元素打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 的 a 中打乱 8 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 32 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 64 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对单精度 (32-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中的包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 b 的相应 8 位元素中的打乱控制掩码对 a 中的包装 8 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 中的 32 位整数中混洗 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件对 128 位 lane 内的双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,使用 zeromask k 将 128 位 lanes 的低 64 位从 a 复制到 dst (当相应的掩码位未设置时,元素被清零) .
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,使用 writemask k 将 128 位 lanes 的高 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 将包装的 16 位整数按计数左移,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数左移计数,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将填充的 64 位整数左移计数,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数左移由 count 中的相应元素指定的数量,同时移入零,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将移位的 32 位整数左移零时,将其对应计数指定的数量左移,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将移位的 64 位整数左移零时,将其对应计数指定的数量左移,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移动符号位的同时右移计数包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移动符号位的同时右移计数包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移由 count 中的相应元素指定的数量,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将符号位移位的同时,将已包装的 32 位整数向右移动计数中相应元素指定的数量,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移入符号位的同时,将包装的 64 位整数右移由 count 中相应元素指定的数量,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将移位的 32 位整数右移,同时移零,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移计数,同时移入零,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 向右移动已包装的 32 位整数,偏移量为相应元素在计数中指定的数量,同时向零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 向右移位包装的 64 位整数,其数量为计数中相应元素指定的数量,同时移位为零,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度从包装的 8 位整数中减去 b 中的包装有符号的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 a 饱和度从 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 a 饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 中的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 32 位粒度的 zeromask k (当未设置相应的掩码位时,32 位元素会被清零)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 中的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 64 位粒度的 zeromask k (当未设置相应的掩码位时,64 位元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 64 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的带符号的 64 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 64 位整数,并将包装的最小值存储在 dst 中。
- 根据相应封装的 8 位整数的最高位设置掩码寄存器 k 的每一位 a.
- 根据相应封装的 16 位整数的最高位设置掩码寄存器 k 的每一位 a.
- 根据 dst 中相应位的值,将 dst 中每个包的 8 位整数设置为全 1 或全 0 k.
- 根据 dst 中相应位的值,将 dst 中每个包的 16 位整数设置为全 1 或全 0 k.
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并将 8 个组装字节存储到 dst 的相应 64 位元素。
- 计算 a 和 b 中包装的 32 位整数的按位或,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 64 位整数的按位或,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并将结果存储在 dst 中。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并将结果存储在 dst 中。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 32 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 256 位 lanes 中的 a 内随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 256 位 lanes 内对双精度 (64-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 idx 中的相应索引将 a 中的 8 位整数打乱到 lanes 中,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 32 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中对双精度 (64-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 idx 中的相应索引对跨 lanes 中的单精度 (32-bit) 浮点元素进行打乱。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 将 a 中每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,然后将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并将高 16 位存储在 dst 中)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并将高 32 位存储在 dst 中。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并将高 64 位存储在 dst 中)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的对应元素中指定的量,并将高 16 位存储在 dst 中。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的对应元素中指定的量,并将高 32 位存储在 dst 中。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的对应元素中指定的量,并将高 64 位存储在 dst 中。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并将低 16 位存储在 dst 中。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并将低 32 位存储在 dst 中。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并将低 64 位存储在 dst 中。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的对应元素中指定的量,并将低 16 位存储在 dst 中。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的对应元素中指定的量,并将低 32 位存储在 dst 中。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的对应元素中指定的量,并将低 64 位存储在 dst 中。
- imm8 从 a 和 b 中随机选择 128 位 (由 4 个单精度 (32-bit) 浮点元素组成),并将结果存储在 dst 中。
- 随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成),并将结果存储在 dst 中。
- 随机排列 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成),并将结果存储在 dst 中。
- 随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成),并将结果存储在 dst 中。
- 将包装的 16 位整数按 count 中相应元素指定的数量向左移位,同时将零移位,并将结果存储在 dst 中。
- 在移动符号位的同时按计数右移包装的 64 位整数,并将结果存储在 dst 中。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并将结果存储在 dst 中。
- 将包装的 16 位整数右移 count 中相应元素指定的数量,同时移入符号位,然后将结果存储在 dst 中。
- 将移位的 64 位整数向右移动计数中相应元素指定的数量,同时移入符号位,并将结果存储在 dst 中。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并将结果存储在 dst 中。
- 将 a 中的 256 位 (由 8 个包装的 32 位整数组成) 存储到内存中。mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 将 a 中的 256 位 (由 4 个包装的 64 位整数组成) 存储到内存中。mem_addr 必须在 32 字节边界上对齐,否则可能会生成一般保护异常。
- 将 a 中的 256 位 (由 32 个包装的 8 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 256 位 (由 16 个包装的 16 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 256 位 (由 8 个包装的 32 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 256 位 (由 4 个包装的 64 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每个位,来自 a,b 和 c 的相应位用于形成到 imm8 的 3 位索引,并且将 imm8 中该位的值写入 dst 中的相应位。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的对应位。
- 计算 a 和 b 中包装的 8 位整数的按位与,生成中间 8 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 16 位整数的按位与,生成中间的 16 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位与,生成中间的 32 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 64 位整数的按位与,生成中间 64 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 8 位整数的按位 NAND,生成中间的 8 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 16 位整数的按位 NAND,生成中间的 16 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位 NAND,生成中间的 32 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 64 位整数的按位 NAND,生成中间的 64 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并将结果存储在 dst 中。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并将无符号的结果存储在 dst 中。
- 计算 a 中包装的带符号的 16 位整数的绝对值,并将无符号的结果存储在 dst 中。
- 计算
a
中包装的 32 位整数的绝对值。 - 计算 a 中包装的带符号的 64 位整数的绝对值,并将无符号的结果存储在 dst 中。
- 查找 v2 中每个包装的双精度 (64-bit) 浮点元素的绝对值,并将结果存储在 dst 中。
- 查找 v2 中每个包装的单精度 (32-bit) 浮点元素的绝对值,并将结果存储在 dst 中。
- 将包装的 8 位整数添加到 a 和 b 中,并将结果存储在 dst 中。
- 将包装的 16 位整数添加到 a 和 b 中,并将结果存储在 dst 中。
- 在 a 和 b 中添加包装的 32 位整数,并将结果存储在 dst 中。
- 在 a 和 b 中添加包装的 64 位整数,并将结果存储在 dst 中。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并将结果存储在 dst 中。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并将结果存储在 dst 中。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并将结果存储在 dst 中。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并将结果存储在 dst 中。
- 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行一轮 AES 解密流程。 - 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行最后一轮 AES 解密流程。 - 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行一轮 AES 加密流程。 - 使用
round_key
中的相应 128 位字 (key) 对a
中的每个 128 位字 (state) 执行最后一轮 AES 加密流程。 - 将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果,将结果右移 imm8 字节,并将低 16 字节存储在 dst 中。
- 将 a 和 b 连接成一个 128 字节的立即结果,将结果右移 imm8 32 位元素,并将低 64 字节 (16 个元素) 存储在 dst 中。
- 将 a 和 b 连接成一个 128 字节的立即结果,将结果右移 imm8 64 位元素,并将低 64 字节 (8 个元素) 存储在 dst 中。
- 计算 a 和 b 中包装的 32 位整数的按位与,并将结果存储在 dst 中。
- 计算 a 和 b 中 512 位 (由包装的 64 位整数组成) 的按位与,并将结果存储在 dst 中。
- 计算 a 和 b 中 512 位 (代表整数数据) 的按位与,并将结果存储在 dst 中。
- 计算 a 中包装的 32 位整数的按位 NOT,然后与 b 计算 AND,并将结果存储在 dst 中。
- 计算 a 中的 512 位 (由包装的 64 位整数组成) 的按位非,然后与 b 计算 AND,并将结果存储在 dst 中。
- 计算 a 中的 512 位 (代表整数数据) 的按位非,然后与 b 计算 AND,并将结果存储在 dst 中。
- 将 a 和 b 中包装的无符号 8 位整数平均,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装无符号 16 位整数进行平均,然后将结果存储在 dst 中。
- 将输入
b
视为包装的 64 位整数,并将c
视为包装的 8 位整数。 然后将c
中的 8 个 8 位值作为索引分组到相应 64 位整数的位中。 然后,选择这些位并将其包装到输出中。 - 从 a 广播 4 个包装的单精度 (32-bit) 浮点元素到 dst 的所有元素。
- 从 a 广播 4 个包装的双精度 (64-bit) 浮点元素到 dst 的所有元素。
- 将 4 个包装的 32 位整数从 a 广播到 dst 的所有元素。
- 将 4 个包装的 64 位整数从 a 广播到 dst 的所有元素。
- 将低包装的 8 位整数从 a 广播到 dst 的所有元素。
- 将低包装的 32 位整数从 a 广播到 dst 的所有元素。
- 将输入掩码 k 的低 8 位广播到 dst 的所有 64 位元素。
- 将输入掩码 k 的低 16 位广播到 dst 的所有 32 位元素。
- 将低包装的 64 位整数从 a 广播到 dst 的所有元素。
- 从 a 广播低双精度 (64-bit) 浮点元素到 dst 的所有元素。
- 将低单精度 (32-bit) 浮点元素从 A 广播到 dst 的所有元素。
- 将低包装的 16 位整数从 a 广播到 dst 的所有元素。
- 向左移动 128 位 lane imm8 字节,同时向零移动,并将结果存储在 dst 中。
- 向右移动 128 位 lane imm8 字节,同时向零移动,并将结果存储在 dst 中。
- 将类型 __m128d 的 vector 强制转换为 __m512d 类型; 结果的高 384 位未定义。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型 __m256d 的 vector 强制转换为 __m512d 类型; 结果的高 256 位未定义。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512d 的 vector 强制转换为类型为 __m128d 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512d 的 vector 强制转换为类型为 __m256d 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512d 的 vector 强制转换为类型 __m512。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512d 的 vector 强制转换为类型为 __m512i 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型 __m128 的 vector 转换为 __m512 类型; 结果的高 384 位未定义。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m256 的 vector 强制转换为类型 __m512; 结果的高 256 位未定义。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512 的 vector 强制转换为类型为 __m128 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512 的 vector 强制转换为类型 __m256。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512 的 vector 强制转换为类型为 __m512d 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512 的 vector 强制转换为类型 __m512i。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m128i 的 vector 强制转换为类型 __m512i; 结果的高 384 位未定义。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m256i 的 vector 强制转换为类型 __m512i; 结果的高 256 位未定义。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512i 的 vector 强制转换为类型为 __m512d 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512i 的 vector 强制转换为类型 __m512。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512i 的 vector 强制转换为类型为 __m128i 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m512i 的 vector 强制转换为类型为 __m256i 的 vector。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 在 4 个 128 位 lanes 中的每一个中,在有限域 GF(2^k) 上执行两个 64 位多项式的无进位乘法。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 8 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 16 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 32 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 64 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 8 位整数,结果存入 mask vector k.
- 根据
IMM8
指定的比较操作数比较 a 和 b 中的无符号 16 位整数,结果存入 mask vector k. - 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 32 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 64 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数,比较 a 和 b 中的双精度 (64-bit) 浮点元素,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的单精度 (32-bit) 浮点元素,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数,比较 a 和 b 中的双精度 (64-bit) 浮点元素,结果存入 mask vector k.
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中的单精度 (32-bit) 浮点元素,结果存入 mask vector k.
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中的有符号 8 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 32 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 64 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较包装的双精度 (64-bit) 浮点数 a 和 b 中的元素是否相等,结果存入 mask vector k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否相等,结果存入 mask vector k.
- 比较 a 和 b 中的有符号 8 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较包的双精度 (64-bit) 中 a 和 b 中的浮点元素是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否小于等于,并将结果存入 mask vector k.
- 比较 a 和 b 中的有符号 8 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较包装的双精度 (64-bit) 浮点数 a 和 b 中的元素是否小于,结果存入 mask vector k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否小于,结果存入 mask vector k.
- 比较 a 和 b 中的有符号 8 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 32 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较包装的双精度 (64-bit) 浮点数 a 和 b 中的元素是否不相等,结果存入 mask vector k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否不相等,结果存入 mask vector k.
- 比较包装的双精度 (64-bit) 中 a 和 b 中的浮点元素是否不小于或等于,并将结果存储在掩码 vector 中 k.
- 比较包装的单精度 (32-bit) 中 a 和 b 中的浮点元素是否不小于或等于,并将结果存储在掩码 vector 中 k.
- 比较包装的双精度 (64-bit) 浮点数 a 和 b 中的元素是否不小于,并将结果存入 mask vector k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否不小于,并将结果存入 mask vector k.
- 比较包装的双精度 (64-bit) 浮点数 a 和 b 中的元素是否都不是 NaN,结果存入 mask vector k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否都不是 NaN,并将结果存储在掩码 vector 中 k.
- 比较包装的双精度 (64-bit) 浮点数 a 和 b 中的元素是否为 NaN,结果存入 mask vector k.
- 比较包装的单精度 (32-bit) 浮点数 a 和 b 中的元素是否为 NaN,结果存入 mask vector k.
- 测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 将包装后的带符号的 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将包装的双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并将结果存储在 dst 中。
- 将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将包装的半精度 (16-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将包装的单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用符号将包装的 8 位整数从 a 扩展到包装的 16 位整数,并将结果存储在 dst 中。
- 使用符号将包装的 8 位整数从 a 扩展到包装的 32 位整数,并将结果存储在 dst 中。
- 符号将 a 的低 8 个字节中的包装 8 位整数扩展为包装 64 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 符号将包装的 16 位整数从 a 扩展为包装的 32 位整数,并将结果存储在 dst 中。
- 使用符号将包装的 16 位整数从 a 扩展到包装的 64 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并将结果存储在 dst 中。
- 使用符号将包装的 32 位整数从 a 扩展到包装的 64 位整数,并将结果存储在 dst 中。
- 将包装后的带符号的 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 将包装后的带符号的 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将 v2 中包装的 32 位整数整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素,将元素进行逐元素转换,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 16 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 8 位整数零扩展为包装 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 8 位整数零扩展为包装 32 位整数,并将结果存储在 dst 中。
- 将低 8 字节 sof 中的包装无符号 8 位整数零扩展到包装 64 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 16 位整数零扩展为包装 64 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并将结果存储在 dst 中。
- 将 A 中的包装的无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将 v2 中包装的 32 位无符号整数整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素,将每个元素进行逐元素转换,并将结果存储在 dst 中。
- 将两个 512 位 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并将结果存入 a
- 将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并将结果存储在 dst 中。 Intel’s documentation
- 将包装的双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并将结果存储在 dst 中。
- 将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将 v2 中的包装的双精度 (64-bit) 浮点元素执行逐元素转换为单精度 (32-bit) 浮点元素并将其存储在 dst 中。元素存储在结果 vector 的下半部分,而其余的上半部分位置设置为 0.
- 将包装的半精度 (16-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对 v2 中包装的单精度 (32-bit) 浮点元素的下半部分到包装的双精度 (64-bit) 浮点元素的下半部分进行逐元素转换,并将结果存储在 dst 中。
- 将 A 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 8 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 16 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低 32 位整数复制到 dst。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装无符号 32 位整数转换为具有无符号饱和度的包装无符号 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并将结果存储在 dst 中。
- 将 A 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并将结果存储在 dst 中。
- 计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs),并将 16 位结果存储在 dst 中。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 b 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后将结果存储在 dst 中。
- 将 b 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素,然后将结果存储在 dst 中。
- 将 b 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,并将结果存储在 dst 中。
- 将 b 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素,然后将结果存储在 dst 中。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间单精度 (32-bit) 浮点元素与 src 中的元素累加,结果存储在 BF16 (16-bit) 浮点对的 dst.Compute 点积中 b、将中间的单精度 (32-bit) 浮点元素与 src 中的元素进行累加,并将结果存入 dst。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果存入 dst。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。使用有符号饱和将这 4 个结果与 src 中相应的 32 位整数相加,并将包装的 32 位结果存储在 dst 中。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果存入 dst。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并将包装的 32 位结果存储在 dst 中。
- 从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用 imm8 进行选择,并将结果存储在 dst 中。
- 从 a 提取 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成),并用 imm8 进行选择,并将结果存储在 dst 中。
- 从 a 中提取 128 位 (由 4 个包装的 32 位整数组成),用 IMM2 选中,结果存入 dst。
- 从 a 中提取 256 位 (由 4 个包装的 64 位整数组成),用 IMM1 选择,并将结果存储在 dst 中。
- 使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并将结果存储在 dst 中。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并将结果存储在 dst 中。
- 在 a 和 b 中乘以包装的双精度 (64-bit) 浮点元素,或者在中间结果中乘以 c to/from 的包装的元素,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,或者将 c to/from 中的包装的元素相加或相减,得到中间结果,并将结果存储在 dst 中。
- 在 a 和 b 中乘以包装的双精度 (64-bit) 浮点元素,或者在中间结果中乘以 c to/from 的包装的元素,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,或者将 c to/from 中的包装的元素相加或相减,得到中间结果,并将结果存储在 dst 中。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并将结果存储在 dst 中。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并将结果存储在 dst 中。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 c from/to 中的包装后的元素相减并相加,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,或者将 c from/to 中的包装的元素相减并相加,得到中间结果,并将结果存储在 dst 中。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 c from/to 中的包装后的元素相减并相加,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,或者将 c from/to 中的包装的元素相减并相加,得到中间结果,并将结果存储在 dst 中。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装的元素,并将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,然后将结果存储在 dst 中。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装的元素,并将结果存储在 dst 中。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,然后将结果存储在 dst 中。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化,并将结果存储在 dst 中。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 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:
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化,并将结果存储在 dst 中。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素的尾数标准化,并将结果存储在 dst 中。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 使用 32 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。收集的元素将合并到 dst 中。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放),且受掩码 k 限制 (未设置相应的掩码位时不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 将 a 复制到 dst,然后将 b 中的 128 位 (由 4 个压缩单精度 (32 位) 浮点元素组成) 插入到 dst 中 imm8 指定的位置。
- 将 a 复制到 dst,然后将 b 中的 256 位 (由 4 个压缩双精度 (64 位) 浮点元素组成) 插入到 dst 中 imm8 指定的位置。
- 将 a 复制到 dst,然后将 b 中的 128 位 (由 4 个压缩的 32 位整数组成) 插入到 dst 中 imm8 指定的位置。
- 将 a 复制到 dst,然后在 imm8 指定的位置将 256 位 (由 4 个包装的 64 位整数组成) 插入 dst。
- 将整数掩码转换为位掩码,并将结果存储在 dst 中。
- 计算 16 位掩码 a 和 b 的按位与,并将结果存储在 k.
- 计算 16 位掩码 a 的按位非运算,然后与 b 进行与运算,并将结果存储在 k.
- 将 16 位掩码 a 复制到 k.
- 计算 16 位掩码 a 的按位非,并将结果存储在 k.
- 计算 16 位掩码 a 和 b 的按位或,并将结果存储在 k.
- 在 k1 和 k2 之间执行按位或运算,将结果存储在 dst 中。如果 dst 全为 1,则设置 CF 标志。
- 解包并交织掩码 a 和 b 的 8 位,并将 16 位结果存储在 k.
- 计算 16 位掩码 a 和 b 的按位 XNOR,并将结果存储在 k.
- 计算 16 位掩码 a 和 b 的按位异或,并将结果存储在 k.
- 将 512 位 (由 16 个包装的 32 位整数组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 512 位 (由 8 个包装的 64 位整数组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 从 dst 加载。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 512 位整数数据从内存加载到 dst 中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 512 位 (由 64 个包装的 8 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。
- 将 512 位 (由 32 个包装的 16 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。
- 将 512 位 (由 16 个包装的 32 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。
- 将 512 位 (由 8 个包装的 64 位整数组成) 从 dst 加载。mem_addr 不需要在任何特定边界上对齐。
- 从内存中加载 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 到结果中。
mem_addr
不需要在任何特定边界上对齐。 - 从内存中将 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 加载到结果中。
mem_addr
不需要在任何特定边界上对齐。 - 将 512 位整数数据从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并将结果存储在 dst 中。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并将结果存储在 dst 中。
- 将
b
和c
的每个 64 位元素中的包装无符号 52 位整数相乘以形成 104 位中间结果。 将中间结果的高 52 位无符号整数与a
中的相应无符号 64 位整数相加,并将结果存储在dst
中。 - 将
b
和c
的每个 64 位元素中的包装无符号 52 位整数相乘以形成 104 位中间结果。 将中间结果的低 52 位无符号整数与a
中的相应无符号 64 位整数相加,并将结果存储在dst
中。 - 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将相邻的 32 位中间整数对水平相加,并将结果打包到 dst 中。
- 将 a 中的每个无符号 8 位整数与 b 中对应的有符号 8 位整数垂直相乘,生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对,并将饱和结果包装到 dst 中。
- 使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 a 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)
- 使用 idx 中的对应选择器和索引在 a 和 b 中的 lanes 中对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 将位掩码 k1 转换为整数值,并将结果存储在 dst 中。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素,或者在中间结果中减去并在 c from/to 中包装的元素相乘,然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素,或者在中间结果中减去并在 c from/to 中包装的元素相乘,然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 c 复制)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 c 复制)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的带符号的 16 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算
a
中包装的 32 位整数的绝对值,并使用写掩码k
将无符号结果存储在dst
中 (如果未设置相应的掩码位,则从src
复制元素)。 - 计算 a 中包装的带符号的 64 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 查找 v2 中每个包装的双精度 (64-bit) 浮点元素的绝对值,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 查找 v2 中每个包装的单精度 (32-bit) 浮点元素的绝对值,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果,将结果右移 imm8 字节,并使用写掩码 k 将低 16 个字节存储在 dst 中 (当相应的屏蔽位未置位时,从 src 复制元素)。
- 将 a 和 b 连接成一个 128 字节的立即结果,将结果右移 imm8 32 位元素,并使用写掩码 k 将低 64 字节 (16 个元素) 存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 连接成一个 128 字节的立即结果,将结果右移 imm8 64 位元素,并使用写掩码 k 将低 64 字节 (8 个元素) 存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在包装的 a 和 b 的 32 位整数元素之间执行逐个元素的按位 AND,使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位与,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的 32 位整数的按位 NOT,然后与 b 计算 AND,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的 64 位整数的按位 NOT,然后与 b 计算 AND,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 8 位整数平均,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 16 位整数进行平均,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将输入
b
视为包装的 64 位整数,并将c
视为包装的 8 位整数。 然后将c
中的 8 个 8 位值作为索引分组到相应 64 位整数的位中。 然后,选择这些位并将其包装到输出中。 - 使用控制掩码 k 混合 a 和 b 中的包装 8 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装的 16 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合 a 和 b 中的包装 32 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合 a 和 b 中的包装 64 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装后的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用写掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 4 个包装的双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 a 的 4 个包装的 32 位整数广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 a 的 4 个包装的 64 位整数广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 d 的低包装的 8 位整数广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低双精度 (64-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低单精度 (32-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 32 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的带符号的 8 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否相等,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的 32 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的 64 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数是否等于或大于等于,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否大于等于,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数是否大于,并将结果使用零掩码 k1 存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数 (小于或等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数 (小于等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数 (小于或等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数以得到小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素的小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的 32 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否相等,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否等于或小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否等于或小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素,看是否都不是 NaN,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,看是否都不是 NaN,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素以查看是否为 NaN,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,看是否为 NaN,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 将 a 中的活动 8 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst,并通过 src 中的其余元素。
- 将 a 中的活动 16 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst,并通过 src 中的其余元素。
- 将活跃的 32 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst,并通过 src 中的其余元素。
- 将活跃的 64 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst,并通过 src 中的其余元素。
- 将活跃的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位在写掩码 k 中设置) 到 dst,并通过 src 中的其余元素。
- 将活跃的单精度 (32-bit) 浮点元素连续存储在 dst 中 (将其各自的位设置在写掩码 k 中的那些元素中) 存储到 dst,并通过 src 中的其余元素。
- 将 a 中的活动 8 位整数 (其各自的位在 writemask k 中设置) 连续存储到 base_addr 处的未对齐内存。
- 将 a 中的活动 16 位整数 (其各自的位在 writemask k 中设置的那些) 连续存储到 base_addr 处的未对齐内存。
- 将活动的 32 位整数连续存储 (在 writemask k 中设置了相应位的那些) 到 base_addr 处的未对齐内存中。
- 将活动的 64 位整数连续存储 (在 writemask k 中设置了相应位的那些) 到 base_addr 处的未对齐内存中。
- 将活动的双精度 (64 位) 浮点元素连续存储 (在 writemask k 中设置了相应位的元素) 到 base_addr 处的未对齐内存中。
- 将活动的单精度 (32 位) 浮点元素连续存储 (在 writemask k 中设置了相应位的元素) 到 base_addr 处的未对齐内存中。
- 使用写掩码 k (当未设置相应的掩码位时,将从 src 复制元素),测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 使用写掩码 k 测试 a 的每个 64 位元素是否与所有其他元素相等 (更接近最低有效位) (当未设置相应的掩码位时,将从 src 复制元素)。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将包装的 8 位整数从 a 扩展为包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将 a 的低 8 个字节中的包装 8 位整数扩展为包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将包装后的 16 位整数从 a 扩展为包装后的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数在 a 中转换为带有截断的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 32 位整数转换为带截断的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 v2 中包装的 32 位整数整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素,进行逐元素转换,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带有截断的包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带截断的 16 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中包装的 64 位整数转换为包装的 8 位整数并截断,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带截断的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带截断的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 的低 8 个字节中的包装无符号 8 位整数零扩展为包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 v2 中 32 位无符号整数元素的下半部分转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中,使用 writemask k (当未设置相应的掩码位时,将从 src 复制元素)。
- 将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 writemask k 将结果存储在单个 vector dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 v2 中的包装的双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,将其逐个元素转换,并使用 writemask k 将它们存储在 dst 中 (当未设置相应的 mask 位时,元素将从 src 复制)。元素存储在结果 vector 的下半部分,而其余的上半部分位置设置为 0.
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 v2 中包装的单精度 (32-bit) 浮点元素的下半部分转换为包装的双精度 (64-bit) 浮点元素的下半部分进行逐元素转换,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 src 复制)。
- 将 a 中的包装带符号的 16 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 16 位整数转换为有符号饱和的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 16 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的无符号 16 位整数转换为具有无符号饱和的包装的无符号 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。
- 将包装在 a 中的无符号 64 位整数转换为具有无符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 计算 a 中的无符号 8 位整数与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs),并使用写掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间的单精度 (32-bit) 浮点元素与 src 中的元素相加,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (未设置相应掩码位时从 src 复制元素)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。使用符号饱和将这 4 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的有效 32 位整数 (它们各自的位被设置在掩码 k 中),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的有效 64 位整数 (它们各自的位被设置在掩码 k 中),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 src 中复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 16 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 src 中复制元素)。
- 从未对齐内存中的 mem_addr 加载连续的活动 32 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 64 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (64-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位不存在时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (32-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位不存在时,将从 src 复制元素)。
- 从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用 imm8 进行选择,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 提取 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成),并用 imm8 进行选择,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中提取 128 位 (由 4 个包装的 32 位整数组成),用 IMM2 选中,用 writemask k 将结果存入 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中提取 256 位 (由 4 个包装的 64 位整数组成),用 IMM1 选中,用 writemask k 将结果存入 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 中复制元素放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 中复制元素放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位,则从 a 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位,则从 a 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时,元素将从 a 复制放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 复制元素放)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时,元素将从 a 复制放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 复制元素放)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 使用 32 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 32 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引按比例中的因子进行缩放) 受掩码 k 的约束 (未设置相应掩码位时,不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址中,并由 vindex 中的每个 32 位元素偏移 (每个索引按比例中的因子进行缩放) 受掩码 k 的约束 (未设置相应掩码位时,不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址中,并由 vindex 中的每个 32 位元素偏移 (每个索引按比例中的因子进行缩放) 受掩码 k 的约束 (未设置相应掩码位时,不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 32 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 32 位元素偏移 (每个索引按比例中的因子进行缩放) 受掩码 k 的约束 (未设置相应掩码位时,不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集 32 位整数。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集 64 位整数。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集双精度 (64-bit) 浮点元素。从 base_addr 开始的地址加载 64 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引从内存中收集单精度 (32-bit) 浮点元素。从 base_addr 开始的地址加载 32 位元素,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放)。使用 writemask k 将收集的元素合并到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将 32 位整数从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放),且受掩码 k 限制 (未设置相应的掩码位时不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将 64 位整数从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址中,并由 vindex 中的每个 64 位元素偏移 (每个索引按比例中的因子进行缩放) 受掩码 k 的约束 (当相应掩码位未设置时,不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将双精度 (64-bit) 浮点元素从 a 分散到内存中。64 位元素存储在从 base_addr 开始的地址中,并由 vindex 中的每个 64 位元素偏移 (每个索引按比例中的因子进行缩放) 受掩码 k 的约束 (当相应掩码位未设置时,不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 使用 64 位索引将单精度 (32-bit) 浮点元素从 a 分散到内存中。32 位元素存储在从 base_addr 开始的地址处,并由 vindex 中的每个 64 位元素偏移 (每个索引都按比例因子进行缩放),且受掩码 k 限制 (未设置相应的掩码位时不存储元素)。scale 应该是 1, 2, 4 或者 8.
- 将 a 复制到 tmp,然后将 b 中的 128 位 (由 4 个压缩单精度 (32 位) 浮点元素组成) 插入到 tmp 中 imm8 指定的位置。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 复制到 tmp,然后将 b 中的 256 位 (由 4 个压缩双精度 (64 位) 浮点元素组成) 插入到 tmp 中 imm8 指定的位置。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 复制到 tmp,然后在 imm8 指定的位置,将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 复制到 tmp,然后在 imm8 指定的位置将 b 的 256 位 (由 4 个包装的 64 位整数组成) 插入 tmp。使用写掩码 k 将 tmp 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 8 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 16 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对,并使用 writemask k 将结果打包到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘,生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对,并使用写掩码 k 将饱和结果包装到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 16 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的带符号的 8 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用写掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 32 位整数从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 64 位整数从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘,并使用写掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并使用写掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的带符号的 16 位整数相乘,生成 32 位中间整数,并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 16 位整数相乘,生成 32 位中间整数,并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,通过加 1 舍入,并使用 writemask k 将位 [16:1] 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并使用写掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并使用写掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数 vectors a 和 b 中的元素相乘,使用写掩码 k 将结果的低 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并使用 writemask k (元素当相应的屏蔽位未设置时,从 src 复制)。
- 计算 a 和 b 中包装的 32 位整数的按位或,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位或,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中对 32 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。请注意,与过去使用 permutevar 名称的内部函数不同,该内部函数在 128 位 lane 上进行了重排。这个内部函数和 _mm512_mask_permutexvar_epi32 是一样的,建议您用那个内部函数名。
- 使用 b 中的控件在 128 位 lane 内将 a 的双精度 (64-bit) 浮点元素进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的控件在 128 位 lane 内将 a 的单精度 (32-bit) 浮点元素打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 a 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 a 和 b 中的 lanes 上对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用 imm8 中的控件在 256 位 lanes 内将 64 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 256 位 lanes 内对双精度 (64-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 的 a 中打乱 8 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中对 32 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引对跨 lanes 中的双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引对跨 lanes 中的单精度 (32-bit) 浮点元素进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 使用掩码 k 通过加法来减少 a 中包装的 32 位整数。返回所有活动元素的总和 a.
- 使用掩码 k 通过加法来减少 a 中包装的 64 位整数。返回所有活动元素的总和 a.
- 通过使用掩膜 k 加法来减少包装的双精度 (64-bit) 浮点元素。返回所有活动元素的总和 a.
- 通过使用掩码 k 加法来减少包装的单精度 (32-bit) 浮点元素。返回所有活动元素的总和 a.
- 使用掩码 k 按位与减少包装的 32 位整数。返回中所有活动元素的按位与 a.
- 使用掩码 k 通过加法来减少 a 中包装的 64 位整数。返回所有活动元素的总和 a.
- 使用掩码 k 最多减少 a 中的包装有符号 32 位整数。返回中所有活动元素的最大值 a.
- 使用掩码 k 最大减少包装的带符号的 64 位整数。返回中所有活动元素的最大值 a.
- 使用掩码 k 最大减少包装的无符号 32 位整数。返回中所有活动元素的最大值 a.
- 使用掩码 k 最大减少包装的无符号 64 位整数。返回中所有活动元素的最大值 a.
- 使用掩码 k 最多减少 a 中包装的双精度 (64-bit) 浮点元素。返回中所有活动元素的最大值 a.
- 最多使用掩码 k 减少包装后的单精度 (32-bit) 浮点元素。返回中所有活动元素的最大值 a.
- 使用掩码 k 最多减少 a 中的包装有符号 32 位整数。返回中所有活动元素的最小值 a.
- 使用掩码 k 最大减少包装的带符号的 64 位整数。返回中所有活动元素的最小值 a.
- 使用掩码 k 最大减少包装的无符号 32 位整数。返回中所有活动元素的最小值 a.
- 使用掩码 k 最大减少包装的带符号的 64 位整数。返回中所有活动元素的最小值 a.
- 使用掩码 k 最多减少 a 中包装的双精度 (64-bit) 浮点元素。返回中所有活动元素的最小值 a.
- 最多使用掩码 k 减少包装后的单精度 (32-bit) 浮点元素。返回中所有活动元素的最小值 a.
- 使用掩码 k 通过乘以减少 a 中包装的 32 位整数。返回中所有活动元素的乘积 a.
- 使用掩码 k 通过乘以减少 a 中包装的 64 位整数。返回中所有活动元素的乘积 a.
- 使用掩码 k 通过乘以减少 a 中包装的双精度 (64-bit) 浮点元素。返回中所有活动元素的乘积 a.
- 使用掩码 k 通过乘以减少 a 中包装的单精度 (32-bit) 浮点元素。返回中所有活动元素的乘积 a.
- 使用掩码 k 按位或减少包装的 32 位整数。返回中所有活动元素的按位或 a.
- 使用掩码 k 按位或减少包装的 64 位整数。返回中所有活动元素的按位或 a.
- 将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 对应元素 b 中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的对应元素中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的对应元素中指定的位数,然后使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 向 dst 的所有元素广播 16 位整数 a (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并使用 writemask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并使用 writemask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并使用 writemask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并使用 writemask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并使用 writemask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并使用 writemask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 使用 b 中相应的 8 位元素中的控件在 128 位 lane 内对 a 中的 8 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件将 128 位 lane 中的 32 位整数随机排列,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 重排,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 进行混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件对 128 位 lane 中的双精度 (64-bit) 浮点元素进行混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,使用 writemask k 将 128 位 lanes 的低 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,使用 writemask k 将 128 位 lanes 的高 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 将包装的 16 位整数按计数左移,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数左移计数,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数左移计数,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数左移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数左移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数向左移动 imm8,同时向零移动,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数按 count 中相应元素指定的数量向左移位,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将填充的 32 位整数向左移动计数中相应元素指定的数量,同时将其移位为零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将填充的 64 位整数向左移动 count 中相应元素指定的数量,同时将其移位为零,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移动符号位的同时右移计数包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移动符号位的同时右移计数包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 count 中相应元素指定的数量,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在将符号位移位的同时,将已包装的 32 位整数向右移动计数中相应元素指定的数量,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移入符号位的同时,将包装的 64 位整数向右移动计数中相应元素指定的数量,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移,同时移零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移,同时移零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 向右移动包装的 32 位整数整数 (由 count 中相应元素指定的数量),同时向零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 向右移位包装的 64 位整数,其数量为计数中相应元素指定的数量,同时向零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask 将 a 中的 32 位整数存储到内存中 k. mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 使用 writemask 将 a 中的 64 位整数存储到内存中 k. mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 使用 writemask 将封装的双精度 (64-bit) 浮点元素从 a 存储到内存中 k. mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 使用 writemask 将封装的单精度 (32-bit) 浮点元素从 a 存储到内存中 k. mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 使用 writemask 将 a 中的 8 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 16 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 32 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 64 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将封装的双精度 (64-bit) 浮点元素从 a 存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将封装的单精度 (32-bit) 浮点元素从 a 存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度将 b 中的包装 8 位整数减去 b 中的包装 8 位有符号整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 a 饱和度从 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每一位,使用 src、a、b 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 writemask k 在 32 位粒度 (当相应的掩码位未设置时,从 src 复制 32 位元素)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 src、a、b 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 writemask k 在 64 位粒度 (当相应的掩码位未设置时,从 src 复制 64 位元素)。
- 计算 a 和 b 中包装的 8 位整数的按位与,生成中间 8 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 16 位整数的按位与,生成中间的 16 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 32 位整数的按位与,生成中间的 32 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 64 位整数的按位与,生成中间 64 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 8 位整数的按位 NAND,生成中间的 8 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 16 位整数的按位 NAND,生成中间的 16 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 32 位整数的按位 NAND,生成中间的 32 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 64 位整数的按位 NAND,生成中间 64 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的带符号的 16 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算
a
中包装的 32 位整数的绝对值,并使用零掩码k
将无符号结果存储在dst
中 (当未设置相应的掩码位时,元素将被清零)。 - 计算 a 中包装的带符号的 64 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数添加到 a 和 b 中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数添加到 a 和 b 中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 16 字节块对连接成一个 32 字节的临时结果,将结果右移 imm8 字节,并使用零掩码 k 将低 16 字节存储在 dst 中 (当未设置相应的掩码位时,元素将被清零))。
- 将 a 和 b 连接成一个 128 字节的立即结果,将结果右移 imm8 32 位元素,并使用零掩码 k 将低 64 字节 (16 个元素) 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 连接成一个 128 字节的立即结果,将结果右移 imm8 64 位元素,并使用零掩码 k 将低 64 字节 (8 个元素) 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位与,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位与,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的 32 位整数的按位 NOT,然后计算 b 中的 AND,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的 64 位整数的按位 NOT,然后与 b 计算 AND,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 8 位整数进行平均,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 16 位整数进行平均,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 4 个包装的单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 4 个包装的双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 4 的包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 4 个包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 8 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低双精度 (64-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的活动 8 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst,并将其余元素设置为零。
- 将 a 中的活动 16 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst,并将其余元素设置为零。
- 将活跃的 32 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst,并将其余元素设置为零。
- 将活跃的 64 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst,并将其余元素设置为零。
- 将活跃的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst,并将其余元素设置为零。
- 将活跃的单精度 (32-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst,并将其余元素设置为零。
- 使用零掩码 k (当未设置相应的掩码位时,元素将被清零),测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 使用零掩码 k (当未设置相应的掩码位时,元素将被清零),测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 8 位整数从 a 扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 符号将 a 的低 8 个字节中的包装 8 位整数扩展为包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 符号将包装的 16 位整数从 a 扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 64 位整数转换为带截断的 8 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 64 位整数转换为带截断的 16 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 的低 8 个字节中的包装无符号 8 位整数零扩展为包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在单个 vector dst 中 (当对应的掩码位不存在时,元素归零放)。
- 将包装的单精度 (32-bit) 浮点元素在 a 中转换为包装的 BF16 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装有符号 64 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装单精度 (32-bit) 浮点元素转换为带有截断的包装无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs) 的总和,并使用零掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间单精度 (32-bit) 浮点元素与 src 中的元素进行累加,并将结果存储在 dst 中使用 zeromask k (当对应的掩码为位未设置)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果使用 zeromask k 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数用带符号饱和求和,并将包装的 32 位结果用 zeromask k 存储在 dst 中 (当对应的掩码位未设置时,元素被清零)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加,并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的有效 32 位整数 (它们各自的位被设置在掩码 k 中),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的有效 64 位整数 (它们各自的位被设置在掩码 k 中),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 16 位整数 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 32 位整数 (在掩码 k 中设置了相应位的那些),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 64 位整数 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (64-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (32-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 a 提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用 imm8 进行选择,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 提取 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成),并用 imm8 进行选择,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中提取 128 位 (由 4 个包装的 32 位整数组成),用 IMM2 选择,结果用 zeromask k 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中提取 256 位 (由 4 个包装的 64 位整数组成),用 IMM1 选择,结果用 zeromask k 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并将结果存储在使用零掩码 k 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,或者将 C from/to 中的包装元素相减并相加,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,或者将 C from/to 中的包装元素相减并相加,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 将 a 复制到 tmp,然后将 b 中的 128 位 (由 4 个压缩单精度 (32 位) 浮点元素组成) 插入到 tmp 中 imm8 指定的位置。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时,元素会被清零)。
- 将 a 复制到 tmp,然后将 b 中的 256 位 (由 4 个压缩双精度 (64 位) 浮点元素组成) 插入到 tmp 中 imm8 指定的位置。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时,元素会被清零)。
- 将 a 复制到 tmp,然后在 imm8 指定的位置,将 b 中的 128 位 (由 4 个包装的 32 位整数组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时,元素会被清零)。
- 将 a 复制到 tmp,然后在 imm8 指定的位置将 b 的 256 位 (由 4 个包装的 64 位整数组成) 插入 tmp。使用 zeromask k 将 tmp 存储到 dst (当未设置相应的掩码位时,元素会被清零)。
- 使用 zeromask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 8 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 16 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对,并使用 zeromask k 将结果打包到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘,生成中间有符号的 16 位整数。水平添加相邻的一对中间有符号 16 位整数,并使用 zeromask k 将饱和结果打包到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 32 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用零掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 32 位整数从 a 移至 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 64 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中每个包装的 64 位元素的低位有符号 32 位整数相乘,并使用零掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并使用零掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的带符号的 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,通过加 1 舍入,并使用 zeromask k 将位 [16:1] 存储到 dst (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并使用零掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并使用 zeromask k (元素当相应的屏蔽位未设置时被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位或,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位或,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的控件在 128 位 lane 内将 a 中的双精度 (64-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的控件在 128 位 lane 内将 a 的单精度 (32-bit) 浮点元素打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 64 位整数进行混洗,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引将 a 和 b 中的双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 256 位 lanes 内将 64 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 256 位 lanes 内将双精度 (64-bit) 浮点元素打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 的 a 中打乱 8 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 32 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 64 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对单精度 (32-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中的包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 b 的相应 8 位元素中的打乱控制掩码对 a 中的包装 8 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 中的 32 位整数中混洗 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个单精度 (32-bit) 浮点元素组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成) 混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件对 128 位 lane 内的双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,使用 zeromask k 将 128 位 lanes 的低 64 位从 a 复制到 dst (当相应的掩码位未设置时,元素被清零) .
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,使用 zeromask k 将 128 位 lanes 的高 64 位从 a 复制到 dst (当相应的掩码位未设置时,元素被清零) .
- 将包装的 16 位整数按计数左移,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数左移计数,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将填充的 64 位整数左移计数,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数左移由 count 中的相应元素指定的数量,同时移入零,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将移位的 32 位整数左移零时,将其对应计数指定的数量左移,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将移位的 64 位整数左移零时,将其对应计数指定的数量左移,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移动符号位的同时右移计数包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移动符号位的同时右移计数包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移由 count 中的相应元素指定的数量,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将符号位移位的同时,将已包装的 32 位整数向右移动计数中相应元素指定的数量,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移入符号位的同时,将包装的 64 位整数右移由 count 中相应元素指定的数量,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将移位的 32 位整数右移,同时移零,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移计数,同时移入零,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 向右移动已包装的 32 位整数,偏移量为相应元素在计数中指定的数量,同时向零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 向右移位包装的 64 位整数,其数量为计数中相应元素指定的数量,同时移位为零,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度从包装的 8 位整数中减去 b 中的包装有符号的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 a 饱和度从 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 a 饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 中的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 32 位粒度的 zeromask k (当未设置相应的掩码位时,32 位元素会被清零)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 中的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 64 位粒度的 zeromask k (当未设置相应的掩码位时,64 位元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的带符号的 16 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的带符号 32 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的带符号的 64 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 8 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 16 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 32 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 64 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素,并将包装的最大值存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将包装的最大值存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的带符号的 8 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的带符号的 16 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的带符号 32 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的带符号的 64 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 8 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 16 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 32 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 64 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素,并将包装的最小值存储在 dst 中。 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中包装的双精度 (64-bit) 浮点元素,并将包装的最小值存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将包装的最小值存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 根据相应封装的 8 位整数的最高位设置掩码寄存器 k 的每一位 a.
- 根据相应封装的 16 位整数的最高位设置掩码寄存器 k 的每一位 a.
- 根据 dst 中相应位的值,将 dst 中每个包的 8 位整数设置为全 1 或全 0 k.
- 根据 dst 中相应位的值,将 dst 中每个包的 16 位整数设置为全 1 或全 0 k.
- 将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘,并将带符号的 64 位结果存储在 dst 中。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并将无符号 64 位结果存储在 dst 中。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并将结果存储在 dst 中。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并将结果存储在 dst 中。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并将结果存储在 dst 中。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并将结果存储在 dst 中。
- 将包装的带符号的 16 位整数与 a 和 b 相乘,生成中间的 32 位整数,并将中间整数的高 16 位存储在 dst 中。
- 将包装的无符号 16 位整数与 a 和 b 相乘,生成中间的 32 位整数,并将中间整数的高 16 位存储在 dst 中。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,加 1 舍入,然后将 [16: 1] 位存储到 dst。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并将中间整数的低 16 位存储在 dst 中。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并将中间整数的低 32 位存储在 dst 中。
- 将包装的 64 位整数 vectors a 和 b 中的元素相乘,将结果的低 64 位存储在 dst 中。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并将 8 个组装字节存储到 dst 的相应 64 位元素。
- 计算 a 和 b 中包装的 32 位整数的按位或,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 64 位整数的按位或,并将结果存储在 dst 中。
- 计算 a 和 b 中 512 位 (代表整数数据) 的按位或,并将结果存储在 dst 中。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并将结果存储在 dst 中。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并将结果存储在 dst 中。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并将结果存储在 dst 中。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 32 位整数,并将结果存储在 dst 中。请注意,与过去使用 permutevar 名称的内部函数不同,该内部函数在 128 位 lane 上进行了重排。此内部函数与 _mm512_permutexvar_epi32 相同,建议您使用该内部函数名称。
- 使用 b 中的控件在 128 位 lane 内将 a 双精度 (64-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 b 中的控件在 128 位 lane 内将 a 单精度 (32-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并将结果存储在 dst 中。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并将结果存储在 dst 中。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 32 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 256 位 lanes 中的 a 内随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 256 位 lanes 内对双精度 (64-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 idx 中的相应索引将 a 中的 8 位整数打乱到 lanes 中,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 32 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中对双精度 (64-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 idx 中的相应索引对跨 lanes 中的单精度 (32-bit) 浮点元素进行打乱。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 通过加法减少包装的 32 位整数。返回所有元素的总和 a.
- 通过加法减少包装的 64 位整数。返回所有元素的总和 a.
- 另外,还减少了包装的双精度 (64-bit) 浮点元素。返回所有元素的总和 a.
- 此外,还减少了包装的单精度 (32-bit) 浮点元素。返回所有元素的总和 a.
- 通过按位 AND 减少包装的 32 位整数。返回中所有元素的按位与 a.
- 通过按位 AND 减少包装的 64 位整数。返回中所有元素的按位与 a.
- 最多减少包装的带符号 32 位整数。返回中所有元素的最大值 a.
- 最大减少包装的带符号的 64 位整数。返回中所有元素的最大值 a.
- 最多减少包装的无符号 32 位整数。返回中所有元素的最大值 a.
- 最多减少包装的无符号 64 位整数。返回中所有元素的最大值 a.
- 最大减少包装的双精度 (64-bit) 浮点元素。返回中所有元素的最大值 a.
- 最大减少包装的单精度 (32-bit) 浮点元素。返回中所有元素的最大值 a.
- 将包装的有符号的 32 位整数减少到最小值。返回所有元素中的最小值 a.
- 将一个包装的有符号 64 位整数减少到最小值。返回所有元素中的最小值 a.
- 将一个包装的无符号 32 位整数减少到最小值。返回所有元素中的最小值 a.
- 将一个包装的无符号 64 位整数减少到最小。返回所有元素中的最小值 a.
- 将一个包装的双精度 (64 位) 浮点元素减少到最小。返回所有元素中的最小值 a.
- 将一个包装的单精度 (32 位) 浮点元素减少到最小。返回所有元素中的最小值 a.
- 通过乘法减少包装的 32 位整数。返回所有元素的乘积 a.
- 通过乘法减少包装的 64 位整数。返回所有元素的乘积 a.
- 通过乘法减少包装的双精度 (64-bit) 浮点元素。返回所有元素的乘积 a.
- 通过乘法减少包装的单精度 (32-bit) 浮点元素。返回所有元素的乘积 a.
- 通过按位 OR 减少包装的 32 位整数。返回中所有元素的按位或 a.
- 通过按位 OR 减少包装的 64 位整数。返回中所有元素的按位或 a.
- 将 a 中每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,然后将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,然后将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 计算 a 和 b 中包装的无符号 8 位整数的绝对差,然后将每个连续的 8 个差水平地求和以生成八个无符号的 16 位整数,并将这些无符号的 16 位整数包装在 64 位元素的低 16 位中在 dst。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 向 dst 的所有元素广播 8 位整数 a。
- 将低包装的 16 位整数从 a 广播到 dst 的所有元素。
- 向
dst
的所有元素广播 32 位整数a
。 - 向
dst
的所有元素广播 64 位整数a
。 - 向
dst
的所有元素广播 64 位浮点数a
。 - 向
dst
的所有元素广播 32 位浮点数a
。 - 使用重复的 4 个元素序列在 dst 中设置包装的 32 位整数。
- 使用重复的 4 个元素序列在 dst 中设置包装的 64 位整数。
- 使用重复的 4 个元素序列在 dst 中设置包装的双精度 (64-bit) 浮点元素。
- 使用重复的 4 个元素序列在 dst 中设置包装的单精度 (32-bit) 浮点元素。
- 使用提供的值在 dst 中设置包装的 8 位整数。
- 使用提供的值在 dst 中设置包装的 16 位整数。
- 使用提供的值在
dst
中设置包装的 32 位整数。 - 使用提供的值在 dst 中设置包装的 64 位整数。
- 使用提供的值在 dst 中设置包装的双精度 (64-bit) 浮点元素。
- 使用提供的值在
dst
中设置包装的 32 位整数。 - 在 dst 中设置包装的 32 位整数,并以相反的顺序重复 4 个元素序列。
- 在 dst 中设置包装的 64 位整数,并以相反的顺序重复 4 个元素序列。
- 在 dst 中设置包装的双精度 (64-bit) 浮点元素,并以相反的顺序重复 4 个元素序列。
- 在 dst 中设置包装的单精度 (32-bit) 浮点元素,并以相反的顺序重复 4 个元素。
- 在
dst
中设置包装的 32 位整数,并以相反的顺序提供所提供的值。 - 在 dst 中设置包装的 64 位整数,并以相反的顺序提供所提供的值。
- 在 dst 中设置包装的双精度 (64-bit) 浮点元素,并以相反的顺序提供所提供的值。
- 在
dst
中设置包装的 32 位整数,并以相反的顺序提供所提供的值。 - 返回 __m512 类型的 vector,所有元素均设置为零。
- 返回类型为 __m512i 的 vector,所有元素均设置为零。
- 返回
__m512d
类型的 vector,所有元素均设置为零。 - 返回
__m512d
类型的 vector,所有元素均设置为零。 - 返回
__m512i
类型的 vector,所有元素均设置为零。 - 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并将高 16 位存储在 dst 中)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并将高 32 位存储在 dst 中。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并将高 64 位存储在 dst 中)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的对应元素中指定的量,并将高 16 位存储在 dst 中。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的对应元素中指定的量,并将高 32 位存储在 dst 中。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的对应元素中指定的量,并将高 64 位存储在 dst 中。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并将低 16 位存储在 dst 中。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并将低 32 位存储在 dst 中。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并将低 64 位存储在 dst 中。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的对应元素中指定的量,并将低 16 位存储在 dst 中。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的对应元素中指定的量,并将低 32 位存储在 dst 中。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的对应元素中指定的量,并将低 64 位存储在 dst 中。
- 根据 b 的对应 8 位元素中的打乱控制掩码,将 a 中的包装 8 位整数进行打乱,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- imm8 从 a 和 b 中随机选择 128 位 (由 4 个单精度 (32-bit) 浮点元素组成),并将结果存储在 dst 中。
- 随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个双精度 (64-bit) 浮点元素组成),并将结果存储在 dst 中。
- 随机排列 imm8 从 a 和 b 中选择的 128 位 (由 4 个 32 位整数组成),并将结果存储在 dst 中。
- 随机排列 imm8 从 a 和 b 中选择的 128 位 (由 2 个 64 位整数组成),并将结果存储在 dst 中。
- 使用 imm8 中的控件对 128 位 lane 中的双精度 (64-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并将结果存储在 dst 中。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,将 128 位 lanes 的低 64 位从 a 复制到 dst。
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,将 128 位 lanes 的高 64 位从 a 复制到 dst。
- 将包装的 16 位整数按计数左移,同时将零移位,并将结果存储在 dst 中。
- 将包装的 32 位整数左移计数,同时将零移位,并将结果存储在 dst 中。
- 将填充的 64 位整数左移计数,同时将零移位,并将结果存储在 dst 中。
- 将包装的 16 位整数左移 imm8,同时将零移位,并将结果存储在 dst 中。
- 将包装的 32 位整数左移 imm8,同时将零移位,并将结果存储在 dst 中。
- 将包装的 64 位整数左移 imm8,同时将零移位,并将结果存储在 dst 中。
- 将包装的 16 位整数按 count 中相应元素指定的数量向左移位,同时将零移位,并将结果存储在 dst 中。
- 将填充的 32 位整数向左移动 count 中相应元素指定的数量,同时向零移动,并将结果存储在 dst 中。
- 将填充的 64 位整数向左移动由 count 中相应元素指定的数量,同时向零移动,并将结果存储在 dst 中。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并将结果存储在 dst 中。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并将结果存储在 dst 中。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并将结果存储在 dst 中。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并将结果存储在 dst 中。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并将结果存储在 dst 中。
- 在移入符号位的同时按计数右移包装的 32 位整数,并将结果存储在 dst 中。
- 在移动符号位的同时按计数右移包装的 64 位整数,并将结果存储在 dst 中。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并将结果存储在 dst 中。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并将结果存储在 dst 中。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并将结果存储在 dst 中。
- 将包装的 16 位整数右移 count 中相应元素指定的数量,同时移入符号位,然后将结果存储在 dst 中。
- 在将符号位移位的同时,将已包装的 32 位整数右移由 count 中相应元素指定的数量,然后将结果存储在 dst 中。
- 将移位的 64 位整数向右移动计数中相应元素指定的数量,同时移入符号位,并将结果存储在 dst 中。
- 将包装的 16 位整数按计数右移,同时将零移位,并将结果存储在 dst 中。
- 将计数包装的 32 位整数右移,同时将零移位,并将结果存储在 dst 中。
- 按计数右移包装的 64 位整数,同时将零移位,并将结果存储在 dst 中。
- 将包装的 16 位整数右移 imm8,同时将零移位,并将结果存储在 dst 中。
- 将包装的 32 位整数右移 imm8,同时将零移位,并将结果存储在 dst 中。
- 将包装的 64 位整数右移 imm8,同时将零移位,并将结果存储在 dst 中。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并将结果存储在 dst 中。
- 向右移动已包装的 32 位整数,偏移量为计数中相应元素指定的数量,同时向零移动,并将结果存储在 dst 中。
- 向右移位包装的 64 位整数 (由 count 中相应元素指定的数量),同时向零移位,并将结果存储在 dst 中。
- 将 a 中的 512 位 (由 16 个包装的 32 位整数组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 a 中的 512 位 (由 8 个包装的 64 位整数组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 a 中的 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 a 中的 512 位整数数据存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 a 中的 512 位整数数据存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 将 a 中的 512 位 (由 64 个包装的 8 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 512 位 (由 32 个包装的 16 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 512 位 (由 16 个包装的 32 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 512 位 (由 8 个包装的 64 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将来自
a
的 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr
不需要在任何特定边界上对齐。 - 将 a 中的 512 位整数数据存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 使用非临时内存提示将 512 位 (由 8 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 使用非临时内存提示将 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 使用非临时内存提示将 512 位整数数据从 a 存储到内存中。mem_addr 必须在 64 字节边界上对齐,否则可能会生成常规保护异常。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并将结果存储在 dst 中。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并将结果存储在 dst 中。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并将结果存储在 dst 中。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并将结果存储在 dst 中。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 中的包装的单精度 (32-bit) 浮点元素中减去 b 中的包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 中的包装的单精度 (32-bit) 浮点元素中减去 b 中的包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用饱和度从包装的 8 位整数中减去 b 中的包装有符号 8 位整数,并将结果存储在 dst 中。
- 使用饱和度从 a 中的包装的 16 位整数减去 b 中的包装的有符号 16 位整数,并将结果存储在 dst 中。
- 使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并将结果存储在 dst 中。
- 使用饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并将结果存储在 dst 中。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每个位,来自 a,b 和 c 的相应位用于形成到 imm8 的 3 位索引,并且将 imm8 中该位的值写入 dst 中的相应位。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的对应位。
- 计算 a 和 b 中包装的 8 位整数的按位与,生成中间 8 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 16 位整数的按位与,生成中间的 16 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位与,生成中间的 32 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 64 位整数的按位与,生成中间 64 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 8 位整数的按位 NAND,生成中间的 8 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 16 位整数的按位 NAND,生成中间的 16 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位 NAND,生成中间的 32 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 64 位整数的按位 NAND,生成中间的 64 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 返回具有不确定元素的 __m512 类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于
mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - 返回具有不确定元素的 __m512i 类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于
mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - 返回具有不确定元素的
__m512d
类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - 返回具有不确定元素的
__m512
类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包并交织双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包并交织 8 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包并交织 16 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织 64 位整数,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的下半部分解解包并交织双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 从 a 和 b 中每个 128 位 lane 的下半部分解压包并交织单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并将结果存储在 dst 中。
- 计算 a 和 b 中 512 位 (代表整数数据) 的按位 XOR,并将结果存储在 dst 中。
- 将类型 __m128d 的 vector 强制转换为 __m512d 类型; 结果的高 384 位被清零。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型 __m256d 的 vector 强制转换为 __m512d 类型; 结果的高 256 位被清零。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型 __m128 的 vector 转换为 __m512 类型; 结果的高 384 位被清零。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m256 的 vector 强制转换为类型 __m512; 结果的高 256 位被清零。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m128i 的 vector 强制转换为类型 __m512i; 结果的高 384 位被清零。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 将类型为 __m256i 的 vector 强制转换为类型 __m512i; 结果的高 256 位被清零。此内部函数仅用于编译,不会生成任何指令,因此具有零延迟。
- 在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素,将结果存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。
- 在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素,将结果存储在 dst 的较低元素中,并将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。
- 将 a 和 b 连接成一个 32 字节的 immediate 结果,将结果右移 imm8 个 32 位元素,并将低 16 字节 (4 个元素) 存储在 dst 中。
- 将 a 和 b 连接成一个 32 字节的 immediate 结果,将结果右移 imm8 个 64 位元素,并将低 16 字节 (2 个元素) 存储在 dst 中。
- 将输入
b
视为包装的 64 位整数,并将c
视为包装的 8 位整数。 然后将c
中的 8 个 8 位值作为索引分组到相应 64 位整数的位中。 然后,选择这些位并将其包装到输出中。 - 将输入掩码 k 的低 8 位广播到 dst 的所有 64 位元素。
- 将输入掩码 k 的低 16 位广播到 dst 的所有 32 位元素。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 8 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 16 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 32 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的有符号 64 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 8 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 16 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 32 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的无符号 64 位整数,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数,比较 a 和 b 中的双精度 (64-bit) 浮点元素,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中的单精度 (32-bit) 浮点元素,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中低位双精度 (64-bit) 浮点元素,结果存入 mask vector k.
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中低位单精度 (32-bit) 浮点元素,结果存入 mask vector k.
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中低位双精度 (64-bit) 浮点元素,结果存入 mask vector k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中低位单精度 (32-bit) 浮点元素,结果存入 mask vector k.
- 比较 a 和 b 中的有符号 8 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 32 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 64 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否大于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否大于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否小于或等于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 32 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否小于,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 8 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 16 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的 32 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的有符号 64 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 8 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 16 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 32 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 比较 a 和 b 中的无符号 64 位整数是否不相等,并将结果存储在掩码 vector 中 k.
- 根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,并返回布尔结果 (0 或 1)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,并返回布尔结果 (0 或 1)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 将带符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
- 将有符号的 64 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存入 dst 的低位元素,将 a 的高位元素复制到 dst 的高位元素。 根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将有符号的 64 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存入 dst 的低位元素,将 a 的高 3 个包装元素从 a 复制到 dst 的高位元素。 根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的低位双精度 (64-bit) 浮点元素转换为 64 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的低位双精度 (64-bit) 浮点元素转换为 64 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位无符号整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的低位双精度 (64-bit) 浮点元素转换为无符号 64 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将带符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
- 将有符号的 64 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存入 dst 的低位元素,将 a 的高位元素复制到 dst 的高位元素。 根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将有符号的 64 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存入 dst 的低位元素,将 a 的高 3 个包装元素从 a 复制到 dst 的高位元素。 根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的低位单精度 (32-bit) 浮点元素转换为 64 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,然后将上部的元素从 a 复制到 dst 的上部元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的低位单精度 (32-bit) 浮点元素转换为 64 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位无符号整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的低位单精度 (32-bit) 浮点元素转换为无符号 64 位整数,并将结果存储在 dst 中。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将无符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将无符号的 64 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,然后将 a 的上部元素复制到 dst 的上部元素。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将无符号的 64 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 8 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 16 位整数,并将结果存储在 dst 中。
- 将带有 a 的包装的 64 位整数转换为带有截断的包装的 32 位整数,并将结果存储在 dst 中。
- 将 A 中的包装的无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 将带符号的 32 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,然后将 a 的上部元素复制到 dst 的上部元素。
- 将带符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
- 将有符号的 64 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存入 dst 的低位元素,将 a 的高位元素复制到 dst 的高位元素。
- 将有符号的 64 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存入 dst 的低位元素,将 a 的高 3 个包装元素从 a 复制到 dst 的高位元素。
- 将两个 128 位 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并将结果存入 a
- 将包装的双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将包装的单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低位双精度 (64-bit) 浮点元素转换为 64 位整数,并将结果存储在 dst 中。
- 将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位无符号整数,并将结果存储在 dst 中。
- 将 a 中的低位双精度 (64-bit) 浮点元素转换为无符号 64 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 8 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 16 位整数,并将结果存储在 dst 中。
- 将包装的带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低位单精度 (32-bit) 浮点元素转换为 64 位整数,并将结果存储在 dst 中。
- 将 a 中的较低单精度 (32-bit) 浮点元素转换为 32 位无符号整数,并将结果存储在 dst 中。
- 将 a 中的低位单精度 (32-bit) 浮点元素转换为无符号 64 位整数,并将结果存储在 dst 中。
- 将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的低位双精度 (64-bit) 浮点元素转换为带有截断的 64 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的低位双精度 (64-bit) 浮点元素转换为带有截断的 64 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的无符号 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的低位双精度 (64-bit) 浮点元素转换为带截断的无符号 64 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的低位单精度 (32-bit) 浮点元素转换为带有截断的 64 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的低位单精度 (32-bit) 浮点元素转换为带有截断的 64 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的无符号 32 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的低位单精度 (32-bit) 浮点元素转换为带截断的无符号 64 位整数,并将结果存储在 dst 中。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低位双精度 (64-bit) 浮点元素转换为带有截断的 64 位整数,并将结果存储在 dst 中。
- 将 a 中的较低双精度 (64-bit) 浮点元素转换为带截断的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低位双精度 (64-bit) 浮点元素转换为带截断的无符号 64 位整数,并将结果存储在 dst 中。
- 将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低位单精度 (32-bit) 浮点元素转换为带有截断的 64 位整数,并将结果存储在 dst 中。
- 将 a 中的较低单精度 (32-bit) 浮点元素转换为带截断的无符号 32 位整数,并将结果存储在 dst 中。
- 将 a 中的低位单精度 (32-bit) 浮点元素转换为带截断的无符号 64 位整数,并将结果存储在 dst 中。
- 将无符号的 32 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存储在 dst 的低位元素中,然后将 a 的高位元素复制到 dst 的高位元素。
- 将无符号的 32 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
- 将无符号的 64 位整数 b 转换为双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,然后将 a 的上部元素复制到 dst 的上部元素。
- 将无符号的 64 位整数 b 转换为单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 dst 的高位元素。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 A 中的包装无符号 32 位整数转换为具有无符号饱和度的包装无符号 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并将结果存储在 dst 中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并将结果存储在 dst 中。
- 将 A 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并将结果存储在 dst 中。
- 计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs),并将 16 位结果存储在 dst 中。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的下部双精度 (64-bit) 浮点元素除以 b 中的下部双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,并将上部的元素从 a 复制到 dst 的上部元素。
- 将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素,将结果存储在 dst 的下部元素中,并将上部 3 个包装的元素从 a 复制到上部元素 dst。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间单精度 (32-bit) 浮点元素与 src 中的元素相加,并将结果存储在 dst 中。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果存入 dst。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。使用有符号饱和将这 4 个结果与 src 中相应的 32 位整数相加,并将包装的 32 位结果存储在 dst 中。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果存入 dst。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并将包装的 32 位结果存储在 dst 中。
- 使用 c 中的包装的 64 位整数修复 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。imm8 用于设置所需的标志报告。
- 使用 c 中的较低 64 位整数修复 a 和 b 中较低的双精度 (64-bit) 浮点元素,将结果存储在 dst 的较低元素中,并将较高的元素从 a 复制到 dst 的较高元素。imm8 用于设置所需的标志报告。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用 c 中的低 32 位整数修复 a 和 b 中的低位单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 a 的高位元素 dst。imm8 用于设置所需的标志报告。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用 c 中的较低 64 位整数修复 a 和 b 中较低的双精度 (64-bit) 浮点元素,将结果存储在 dst 的较低元素中,并将较高的元素从 a 复制到 dst 的较高元素。imm8 用于设置所需的标志报告。
- 使用 c 中的低 32 位整数修复 a 和 b 中的低位单精度 (32-bit) 浮点元素,将结果存储在 dst 的低位元素中,并将高 3 个包装的元素从 a 复制到 a 的高位元素 dst。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,并将中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中,并将较高的元素从 a 复制到 dst 的较高元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,并将中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中,然后将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。将结果存入 dst 的下层元素,将 a 的上层元素复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。将结果存储在 dst 的下部元素中,并将上部 3 个包装的元素从 a 复制到 dst 的上部元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后将求和的中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素中。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后将取反的中间结果与较低元素 in c. Store 相加,将结果与 dst 的较低元素相乘,然后将较高的 3 个包装的元素从 a 复制到 dst。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。将结果存入 dst 的下层元素,将 a 的上层元素复制到 dst 的上层元素。
- 将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的下部元素,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到上部 dst 的元素。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并将结果存储在 dst 中。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,将结果存储在 dst 的低位元素中,并将高位元素从 a 复制到 dst 的上层元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,将结果存储在 dst 的较低元素中,并从 a 中复制较高的 3 个包装的元素到 dst 的上层元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,将结果存储在 dst 的低位元素中,并将高位元素从 a 复制到 dst 的上层元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
- 将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,将结果存储在 dst 的较低元素中,并从 a 中复制较高的 3 个包装的元素到 dst 的上层元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数规格化,并将结果存储在 dst 中。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 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:
- 标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数,将结果存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低单精度 (32-bit) 浮点元素的尾数,将结果存储在 dst 的较低元素中,并将高 3 个包装的元素从 a 复制到 dst 的较高元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数,将结果存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低单精度 (32-bit) 浮点元素的尾数,将结果存储在 dst 的较低元素中,并将高 3 个包装的元素从 a 复制到 dst 的较高元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 将 128 位 (由 4 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 将 128 位 (由 2 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 将 128 位 (由 16 个包装的 8 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 将 128 位 (由 8 个包装的 16 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 将 128 位 (由 4 个包装的 32 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 将 128 位 (由 2 个包装的 64 位整数组成) 从内存加载到 dst 中。mem_addr 不需要在任何特定边界上对齐。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并将结果存储在 dst 中。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并将结果存储在 dst 中。
- 将
b
和c
的每个 64 位元素中的包装无符号 52 位整数相乘以形成 104 位中间结果。 将中间结果的高 52 位无符号整数与a
中的相应无符号 64 位整数相加,并将结果存储在dst
中。 - 将
b
和c
的每个 64 位元素中的包装无符号 52 位整数相乘以形成 104 位中间结果。 将中间结果的低 52 位无符号整数与a
中的相应无符号 64 位整数相加,并将结果存储在dst
中。 - 使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 a 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)
- 使用 idx 中的对应选择器和索引在 a 和 b 中的 lanes 中对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 idx 复制元素)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,并将中间结果与较低的元素 in c. Store 的结果相加,使用 writemask k 在 dst 的较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置),然后将 c 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,并将中间结果加到较低元素 in c. Store 中,并使用 writemask k 将结果存储到 dst 较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置),然后将 c 的高 3 个包装的元素复制到 dst 的高元素。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,并将中间结果与较低的元素 in c. Store 的结果相加,使用 writemask k 在 dst 的较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置),然后将 c 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,并将中间结果加到较低元素 in c. Store 中,并使用 writemask k 将结果存储到 dst 较低元素中 (当未使用 mask bit 0 时从 c 复制该元素) 设置),然后将 c 的高 3 个包装的元素复制到 dst 的高元素。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 在 a 和 b 中分别乘以包装的单精度 (32-bit) 浮点元素,或者在 to/from 中将中间结果乘以包装的元素加减乘以 x,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 c 复制元素) 放)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 c 复制元素)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,从 c 复制元素),并将 c 上的上层元素复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高 3 个包装的元素从 c 复制到 dst 的上部元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,从 c 复制元素),并将 c 上的上层元素复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高 3 个包装的元素从 c 复制到 dst 的上部元素。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 在 a 和 b 中乘以包装的单精度 (32-bit) 浮点元素,或者在中间结果中减去并在 c from/to 中包装的元素相乘,然后使用 writemask k 将结果存储在 dst 中 (当未使用相应的 mask 位时从 c 复制元素) 放)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 c 复制)。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置),然后将 c 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用写掩码 k 将取反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置),然后将 c 的高 3 个包装的元素复制到 dst 的高元素。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置),然后将 c 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用写掩码 k 将取反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时从 c 复制该元素) (未设置),然后将 c 的高 3 个包装的元素复制到 dst 的高元素。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 c 复制元素)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,从 c 复制元素),并将 c 上的上层元素复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高 3 个包装的元素从 c 复制到 dst 的上部元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,从 c 复制元素),并将 c 上的上层元素复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高 3 个包装的元素从 c 复制到 dst 的上部元素。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)
- 计算 a 中包装的带符号的 16 位整数的绝对值,并使用写掩码 k 将无符号的结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的有符号 32 位整数的绝对值,并使用 writemask k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并从中复制较高的元素。a 到 dst 的高位元素。
- 在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时,该元素是从 src 复制的),并复制高位 3 从 a 到 dst 的高位元素。
- 在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并从中复制较高的元素。a 到 dst 的高位元素。
- 在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时,该元素是从 src 复制的),并复制高位 3 从 a 到 dst 的高位元素。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的 16 字节块对连接成 32 字节的临时结果,将结果右移 imm8 字节,并使用写掩码 k 将低 16 个字节存储在 dst 中 (当相应的屏蔽位未置位时,从 src 复制元素)。
- 将 a 和 b 连接成一个 32 字节的 immediate 结果,将结果右移 imm8 个 32 位元素,并使用 writemask k 将低 16 字节 (4 个元素) 存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 连接成 32 字节的 immediate 结果,将结果右移 imm8 个 64 位元素,并使用 writemask k 将低 16 字节 (2 个元素) 存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在包装的 a 和 b 的 32 位整数元素之间执行逐个元素的按位 AND,使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位与,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的 32 位整数的按位 NOT,然后与 b 计算 AND,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的 64 位整数的按位 NOT,然后与 b 计算 AND,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 8 位整数平均,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 16 位整数进行平均,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将输入
b
视为包装的 64 位整数,并将c
视为包装的 8 位整数。 然后将c
中的 8 个 8 位值作为索引分组到相应 64 位整数的位中。 然后,选择这些位并将其包装到输出中。 - 使用控制掩码 k 混合 a 和 b 中的包装 8 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装的 16 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合 a 和 b 中的包装 32 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合 a 和 b 中的包装 64 位整数,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装后的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用控制掩码 k 混合来自 a 和 b 的包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用写掩码 k 将 d 的低包装的 8 位整数广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低单精度 (32-bit) 浮点型元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 32 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 8 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装无符号 32 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据 imm8 指定的比较操作数比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。
- 根据 imm8 指定的比较操作数比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置掩码位 0 时该元素清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否相等,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的 32 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的 64 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数是否等于或大于等于,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否大于等于,然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否大于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数是否大于,并将结果使用零掩码 k1 存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否大于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数 (小于或等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数 (小于等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数 (小于或等于),然后使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数小于零,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数以得到小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否小于等于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否小于,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 16 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的 32 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将清零)。
- 比较 a 和 b 中包装的无符号 8 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数是否不相等,并使用零掩码 k1 将结果存储在掩码 vector k 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的活动 8 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst,并通过 src 中的其余元素。
- 将 a 中的活动 16 位整数 (它们各自的位设置在写掩码 k 中) 连续存储到 dst,并通过 src 中的其余元素。
- 将活跃的 32 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst,并通过 src 中的其余元素。
- 将活跃的 64 位整数连续存储在 dst 中 (它们各自的位在写掩码 k 中设置的整数) 到 dst,并通过 src 中的其余元素。
- 将活跃的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位在写掩码 k 中设置) 到 dst,并通过 src 中的其余元素。
- 将活跃的单精度 (32-bit) 浮点元素连续存储在 dst 中 (将其各自的位设置在写掩码 k 中的那些元素中) 存储到 dst,并通过 src 中的其余元素。
- 将 a 中的活动 8 位整数 (其各自的位在 writemask k 中设置) 连续存储到 base_addr 处的未对齐内存。
- 将 a 中的活动 16 位整数 (其各自的位在 writemask k 中设置的那些) 连续存储到 base_addr 处的未对齐内存。
- 将活动的 32 位整数连续存储 (在 writemask k 中设置了相应位的那些) 到 base_addr 处的未对齐内存中。
- 将活动的 64 位整数连续存储 (在 writemask k 中设置了相应位的那些) 到 base_addr 处的未对齐内存中。
- 将活动的双精度 (64 位) 浮点元素连续存储 (在 writemask k 中设置了相应位的元素) 到 base_addr 处的未对齐内存中。
- 将活动的单精度 (32 位) 浮点元素连续存储 (在 writemask k 中设置了相应位的元素) 到 base_addr 处的未对齐内存中。
- 使用写掩码 k (当未设置相应的掩码位时,将从 src 复制元素),测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 使用写掩码 k 测试 a 的每个 64 位元素是否与所有其他元素相等 (更接近最低有效位) (当未设置相应的掩码位时,将从 src 复制元素)。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),然后将上层元素从 a 复制到 dst 的上层元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将包装的 8 位整数从 a 扩展为包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 的低 2 字节中的 8 位整数符号扩展为包装的 64 位整数,并使用 writemask k 将结果存入 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 符号将包装后的 16 位整数从 a 扩展为包装后的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 16 位整数转换为带有截断的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数在 a 中转换为带有截断的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 32 位整数转换为带截断的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带有截断的包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带截断的 16 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中包装的 64 位整数转换为包装的 8 位整数并截断,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带截断的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装的 64 位整数转换为带截断的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 零扩展包装的无符号 8 位整数在 a 的低 4 字节到包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 零扩展包装的无符号 8 位整数在 a 的低 2 字节到包装的 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 零扩展包装的无符号 16 位整数 a 的低 4 字节到包装的 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 writemask k 将结果存储在单个 vector dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 中的包装带符号的 16 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 16 位整数转换为有符号饱和的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 8 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 32 位整数转换为具有符号饱和的包装的 16 位整数,并将活动结果 (那些在 writemask k 中设置了相应位的结果) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的有符号 64 位整数转换为具有符号饱和的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的无符号 16 位整数转换为具有无符号饱和的包装的无符号 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装在 a 中的无符号 32 位整数转换为具有无符号饱和的包装的无符号 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 8 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 的未对齐内存中。
- 将包装在 a 中的无符号 64 位整数转换为具有无符号饱和的包装的 16 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 将包装的无符号 64 位整数在 a 中转换为具有无符号饱和的包装的 32 位整数,并将活动结果 (在 writemask k 中设置了相应位的那些) 存储到 base_addr 处的未对齐内存中。
- 计算 a 中的无符号 8 位整数与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs),并使用写掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素除以 b 中的包装的元素,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 时,该元素从 src 复制 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 时,该元素从 src 复制 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间的单精度 (32-bit) 浮点元素与 src 中的元素相加,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (未设置相应掩码位时从 src 复制元素)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。使用符号饱和将这 4 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并使用 writemask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的有效 32 位整数 (它们各自的位被设置在掩码 k 中),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的有效 64 位整数 (它们各自的位被设置在掩码 k 中),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 src 中复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 16 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 src 中复制元素)。
- 从未对齐内存中的 mem_addr 加载连续的活动 32 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动 64 位整数 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (64-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位不存在时,将从 src 复制元素)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (32-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位不存在时,将从 src 复制元素)。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 a 复制元素)。imm8 用于设置所需的标志报告。
- 使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用 c 中的较低 32 位整数修复 a 和 b 中的较低单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。
- 使用 c 中的较低 32 位整数修复 a 和 b 中的较低单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的较低元素中 (当 mask bit 0 为 0 时从 a 复制该元素 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时从 a 复制元素)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,并使用 writemask k 将中间结果添加到 dst 较低元素中的较低元素 in c. Store 的结果 (当未使用掩码位 0 时从 a 复制该元素) set),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,并将中间结果加到较低元素 in c. Store 中,并使用 writemask k 将结果添加到 dst 较低元素中 (当未使用 mask bit 0 时从 a 复制该元素设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,并使用 writemask k 将中间结果添加到 dst 较低元素中的较低元素 in c. Store 的结果 (当未使用掩码位 0 时从 a 复制该元素) set),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,并将中间结果加到较低元素 in c. Store 中,并使用 writemask k 将结果添加到 dst 较低元素中 (当未使用 mask bit 0 时从 a 复制该元素设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 中复制元素放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位则从 a 复制元素放)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (如果未设置相应的掩码位,则从 a 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,从 a 复制元素)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 a 复制该元素),然后将 a 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 writemask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,从 a 复制该元素),并将 a 上的 3 个包装的元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 a 复制该元素),然后将 a 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。将结果存储在 dst 的下部元素中,并将上部 3 个包装的元素从 a 复制到 dst 的上部元素。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,并使用 writemask k 将结果存储在 dst 中 (当未使用相应的掩码位时,元素将从 a 复制放)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将中间结果中的包装后的元素 from/to 减去并相加,然后使用 writemask k 将结果存储在 dst 中 (如果没有使用相应的 mask 位,则从 a 复制元素放)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 a 复制 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用写掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时,该元素是从 a 复制的 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,然后使用写掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果相加到 dst 的较低元素中 (当掩码位 0 为 0 时从 a 复制 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用写掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 较低元素中 (当掩码位 0 为 0 时,该元素是从 a 复制的 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用 writemask k 将结果存储在 dst 中 (当当未设置相应的掩码位时,将从 a 复制元素)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高位元素从 a 复制到 dst 的高位元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高 3 个包装的元素从 a 复制到 dst 的上部元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高位元素从 a 复制到 dst 的高位元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时从 c 复制该元素),并将高 3 个包装的元素从 a 复制到 dst 的上部元素。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数,使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置屏蔽位 0 时),然后将 a 的高位元素复制到 dst 的高位元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置掩码位 0 时),并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数,使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置屏蔽位 0 时),然后将 a 的高位元素复制到 dst 的高位元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
- 将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,使用写掩码 k 将结果存储在 dst 的较低元素中 (该元素从 src 复制 (当未设置掩码位 0 时),并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 标准化 a 中包装的单精度 (32-bit) 浮点元素的尾数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 标准化 b 中下部双精度 (64-bit) 浮点元素的尾数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部元素从 a 到 dst 的高位元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低单精度 (32-bit) 浮点元素的尾数,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制高 3 从 a 到 dst 的上层元素的包装的元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中下部双精度 (64-bit) 浮点元素的尾数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部元素从 a 到 dst 的高位元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低单精度 (32-bit) 浮点元素的尾数,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制高 3 从 a 到 dst 的上层元素的包装的元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 使用 writemask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 8 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 16 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对,并使用 writemask k 将结果打包到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘,生成中间有符号的 16 位整数。水平相加相邻的中间带符号的 16 位整数对,并使用写掩码 k 将饱和结果包装到 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 16 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的元素从 a 到 dst 的高位元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的元素从 a 到 dst 的高位元素。
- 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用写掩码 k 将最大值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中包装的单精度 (32-bit) 浮点元素,并使用写掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),然后复制较高的元素从 a 到 dst 的高位元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),然后复制较高的元素从 a 到 dst 的高位元素。
- 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用写掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。
- 使用写掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 32 位整数从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的 64 位整数从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移动到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将低位双精度 (64-bit) 浮点元素从 b 移到 dst 的低位元素 (当未设置掩码位 0 时从 src 复制该元素),并将高位元素从 a 复制到 a 的高位元素 dst。
- 使用写掩码 k 将低位单精度 (32-bit) 浮点元素从 b 移到 dst 的低位元素 (当未设置掩码位 0 时从 src 复制该元素),并将高 3 个包装的元素从 a 复制到高位 dst 的元素。
- 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中每个包装的 64 位元素的低符号 32 位整数相乘,并使用写掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并使用写掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的下部双精度 (64-bit) 浮点元素相乘,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并从中复制上部元素。a 到 dst 的高位元素。
- 将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制包装后的高 3 位元素从 a 到 dst 的高位元素。
- 将 a 和 b 中的下部双精度 (64-bit) 浮点元素相乘,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并从中复制上部元素。a 到 dst 的高位元素。
- 将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制包装后的高 3 位元素从 a 到 dst 的高位元素。
- 将 a 和 b 中包装的带符号的 16 位整数相乘,生成 32 位中间整数,并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中包装的无符号 16 位整数相乘,生成 32 位中间整数,并使用写掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,通过加 1 舍入,并使用 writemask k 将位 [16:1] 存储到 dst (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并使用写掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并使用写掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并使用 writemask k (元素当相应的屏蔽位未设置时,从 src 复制)。
- 计算 a 和 b 中包装的 32 位整数的按位或,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位或,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的控件在 128 位 lane 内将 a 的双精度 (64-bit) 浮点元素进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的控件在 128 位 lane 内将 a 的单精度 (32-bit) 浮点元素打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用相应的选择器和 idx 中的索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 writemask k 将结果存储在 dst 中 (当相应的掩码位未设置时,从 a 复制元素)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用对应的选择器和 idx 中的索引在 a 和 b 中的 lanes 上对 a 和 b 中的单精度 (32-bit) 浮点元素进行混洗,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的 mask 位时,元素将从 a 复制)。
- 使用 idx 中的相应索引在跨 lanes 的 a 中打乱 8 位整数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),并复制较高的 x 元素从 a 到 dst 的高位元素。该近似值的最大相对误差小于 2^-14。
- 计算 b 中下部单精度 (32-bit) 浮点元素的近似倒数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。该近似值的最大相对误差小于 2^-14。
- 将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 对应元素 b 中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的对应元素中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的对应元素中指定的位数,然后使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素四舍五入为 imm8 指定的分数位数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时,该元素从 src 复制),然后将上层元素从 a 复制到 dst 的上层元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时,该元素从 src 复制),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素四舍五入为 imm8 指定的分数位数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时,该元素从 src 复制),然后将上层元素从 a 复制到 dst 的上层元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,使用写掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时,该元素从 src 复制),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的双精度 (64-bit) 浮点元素的近似平方根,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),然后复制从 a 到 dst 的上元素的上元素。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低单精度 (32-bit) 浮点元素的近似倒数平方根,使用写掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时从 src 复制该元素),然后复制从 a 到 dst 的高位元素的前 3 个包装的元素。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部元素从 a 到 dst 的高位元素。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的下部元素 (未设置 mask bit 0 时从 src 复制该元素),并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。
- 使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部元素从 a 到 dst 的高位元素。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 的下部元素 (未设置 mask bit 0 时从 src 复制该元素),并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。
- 使用写掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 向 dst 的所有元素广播 16 位整数 a (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用写掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并使用 writemask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并使用 writemask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并使用 writemask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 16 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 32 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量,并使用 writemask k 将高 64 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并使用 writemask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并使用 writemask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并使用 writemask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 16 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 32 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量,并使用 writemask k 将低 64 位存储在 dst 中 (当相应的掩码位未设置时,元素从 a 中复制)。
- 使用 b 中相应的 8 位元素中的控件在 128 位 lane 内对 a 中的 8 位整数进行打乱,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件将 128 位 lane 中的 32 位整数随机排列,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件对 128 位 lane 中的双精度 (64-bit) 浮点元素进行混洗,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件 shuffle a 中的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,使用 writemask k 将 128 位 lanes 的低 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,使用 writemask k 将 128 位 lanes 的高 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 将包装的 16 位整数按计数左移,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数左移计数,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数左移计数,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数左移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数左移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数向左移动 imm8,同时向零移动,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数按 count 中相应元素指定的数量向左移位,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将填充的 32 位整数向左移动计数中相应元素指定的数量,同时将其移位为零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将填充的 64 位整数向左移动 count 中相应元素指定的数量,同时将其移位为零,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 b 中下部双精度 (64-bit) 浮点元素的平方根,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部元素从 a 到 dst 的高位元素。
- 计算 b 中下部单精度 (32-bit) 浮点元素的平方根,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。
- 计算 b 中下部双精度 (64-bit) 浮点元素的平方根,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部元素从 a 到 dst 的高位元素。
- 计算 b 中下部单精度 (32-bit) 浮点元素的平方根,使用 writemask k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时从 src 复制该元素),并复制上部从 a 到 dst 的上层元素的 3 个包装的元素。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移动符号位的同时右移计数包装的 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移动符号位的同时右移计数包装的 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 count 中相应元素指定的数量,同时将符号位移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在将符号位移位的同时,将已包装的 32 位整数向右移动计数中相应元素指定的数量,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 在移入符号位的同时,将包装的 64 位整数向右移动计数中相应元素指定的数量,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移,同时移零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移,同时移零,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 32 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 64 位整数右移 imm8,同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 向右移动包装的 32 位整数整数 (由 count 中相应元素指定的数量),同时向零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 向右移位包装的 64 位整数,其数量为计数中相应元素指定的数量,同时向零移位,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 writemask 将 a 中的 32 位整数存储到内存中 k. mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将 a 中的 64 位整数存储到内存中 k. mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将封装的双精度 (64-bit) 浮点元素从 a 存储到内存中 k. mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将封装的单精度 (32-bit) 浮点元素从 a 存储到内存中 k. mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 使用 writemask 将 a 中的 8 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 16 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 32 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将 a 中的 64 位整数存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将封装的双精度 (64-bit) 浮点元素从 a 存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 使用 writemask 将封装的单精度 (32-bit) 浮点元素从 a 存储到内存中 k. mem_addr 不需要在任何特定边界上对齐。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时,该元素是从 src 复制的 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 从 a 中的较低单精度 (32-bit) 浮点元素减去 b 中的较低单精度 (32-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中较低的双精度 (64-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时,该元素是从 src 复制的 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 从 a 中的较低单精度 (32-bit) 浮点元素减去 b 中的较低单精度 (32-bit) 浮点元素,使用写掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 时从 src 复制该元素 (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 使用饱和度将 b 中的包装 8 位整数减去 b 中的包装 8 位有符号整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 a 饱和度将 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 使用 a 饱和度从 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每一位,使用 src、a、b 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 writemask k 在 32 位粒度 (当相应的掩码位未设置时,从 src 复制 32 位元素)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 src、a、b 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 writemask k 在 64 位粒度 (当相应的掩码位未设置时,从 src 复制 64 位元素)。
- 计算 a 和 b 中包装的 8 位整数的按位与,生成中间 8 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 16 位整数的按位与,生成中间的 16 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 32 位整数的按位与,生成中间的 32 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 64 位整数的按位与,生成中间 64 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 8 位整数的按位 NAND,生成中间的 8 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 16 位整数的按位 NAND,生成中间的 16 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 32 位整数的按位 NAND,生成中间的 32 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 计算 a 和 b 中包装的 64 位整数的按位 NAND,生成中间 64 位值,如果中间值为零,则在结果掩码 k 中设置相应的位 (以写掩码 k 为准)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 8 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 16 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 64 位整数,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织双精度 (64-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包并交织单精度 (32-bit) 浮点元素,并使用 writemask k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并使用写掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,将从 src 复制元素)。
- 计算 a 中包装的带符号的 8 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的带符号的 16 位整数的绝对值,并使用零掩码 k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的有符号 32 位整数的绝对值,并使用 zeromask k 将无符号结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数添加到 a 和 b 中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数添加到 a 和 b 中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零),然后从 a 中复制较高的元素到 dst 的上层元素。
- 在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素归零),并复制较高的 3 个包装的元素从 a 到 dst 的上层元素。
- 在 a 和 b 中添加较低的双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零),然后从 a 中复制较高的元素到 dst 的上层元素。
- 在 a 和 b 中添加较低的单精度 (32-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素归零),并复制较高的 3 个包装的元素从 a 到 dst 的上层元素。
- 使用饱和度在 a 和 b 中添加包装的带符号的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的带符号的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度在 a 和 b 中添加包装的无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 16 字节块对连接成一个 32 字节的临时结果,将结果右移 imm8 字节,并使用零掩码 k 将低 16 字节存储在 dst 中 (当未设置相应的掩码位时,元素将被清零))。
- 将 a 和 b 连接成 32 字节的 immediate 结果,将结果右移 imm8 个 32 位元素,并使用 zeromask k 将低 16 字节 (4 个元素) 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 连接成 32 字节的 immediate 结果,将结果右移 imm8 个 64 位元素,并使用 zeromask k 将低 16 字节 (2 个元素) 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位与,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位与,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的 32 位整数的按位 NOT,然后计算 b 中的 AND,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的 64 位整数的按位 NOT,然后与 b 计算 AND,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 8 位整数进行平均,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 16 位整数进行平均,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 8 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 32 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 64 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低单精度 (32-bit) 浮点元素从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的活动 8 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst,并将其余元素设置为零。
- 将 a 中的活动 16 位整数 (它们各自的位设置在 zeromask k 中) 连续存储到 dst,并将其余元素设置为零。
- 将活跃的 32 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst,并将其余元素设置为零。
- 将活跃的 64 位整数连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的整数) 为 dst,并将其余元素设置为零。
- 将活跃的双精度 (64-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst,并将其余元素设置为零。
- 将活跃的单精度 (32-bit) 浮点元素连续存储在 dst 中 (它们各自的位设置在零掩码 k 中的那些元素) 为 dst,并将其余元素设置为零。
- 使用零掩码 k (当未设置相应的掩码位时,元素将被清零),测试 a 的每个 32 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 使用零掩码 k (当未设置相应的掩码位时,元素将被清零),测试 a 的每个 64 位元素是否与所有其他元素在最接近最低有效位的相等性相等。每个元素的比较在 dst 中形成零扩展位 vector。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
根据 rounding[3: 0] 参数进行舍入,该参数可以是以下之一:
(_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) // 舍入到最接近的值,并抑制异常
(_MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) // 向下取整并抑制异常
(_MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) // 向上取整并抑制异常
(_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) // 截断并抑制异常
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后将上层元素从 a 复制到 dst 的上层元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用符号将包装的 8 位整数从 a 扩展为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 8 位整数从 a 扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 的低 2 字节中的 8 位整数符号扩展为包装的 64 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 16 位整数转换为带截断的 8 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 符号将包装的 16 位整数从 a 扩展为包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 16 位整数从 a 扩展为包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 32 位整数转换为带有截断的包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 32 位整数转换为带截断的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用符号将包装的 32 位整数从 a 扩展为包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 64 位整数转换为带截断的 8 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的 64 位整数转换为带截断的 16 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的 64 位整数转换为带截断的 32 位包装的整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数零扩展为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 零扩展包装的无符号 8 位整数 a 的后 4 个字节到包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 零扩展包装的无符号 8 位整数在 a 的低 2 字节到包装的 64 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数零扩展为包装 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 零扩展包装的无符号 16 位整数在 a 的低 4 字节到包装的 64 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数零扩展为包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将两个 vectors a 和 b 中的包装的单精度 (32-bit) 浮点元素转换为包装的 BF16 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在单个 vector dst 中 (当对应的掩码位不存在时,元素归零放)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装双精度 (64-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装后的半精度 (16-bit) 浮点元素转换为包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素转换为包装的无符号 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的单精度 (32-bit) 浮点元素转换为包装的半精度 (16-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 中的包装有符号 16 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装有符号 32 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 A 中的包装有符号 32 位整数转换为带符号饱和的包装 16 位整数,并将结果存储在 dst 中。
- 将 a 中的包装有符号 64 位整数转换为带符号饱和的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装带符号的 64 位整数转换为带符号饱和的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将带有 a 的包装的单精度 (32-bit) 浮点元素转换为带有截断的包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装的双精度 (32-bit) 浮点元素转换为带截断的包装的无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 16 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 32 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 64 位整数转换为具有无符号饱和的包装无符号 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中与 b 中的无符号 8 位整数的四元组的绝对差之和 (SADs) 的总和,并使用零掩码 k 将 16 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。对于每个 64 位 lane,在四个 8 位四元组上执行四个 SAD。前两个 SAD 使用 a 中 lane 的低 8 位四元组,而后两个 SAD 使用 a 中 lane 的较高 8 位四元组。根据 imm8 中的控件,从 128 位 lane 中选择 b 中的四元组,并且每个 64 位 lanes 中的每个 SAD 使用 8 位偏移量的选定四元组。
- 将 a 中的包装的双精度 (64-bit) 浮点元素除以 b 中的包装的元素,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装单精度 (32-bit) 浮点元素除以 b 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 为 0 时,该元素归零 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 为 0 时,该元素清零) (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 中的较低双精度 (64-bit) 浮点元素除以 b 中的较低双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 为 0 时,该元素归零 (未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 中的下部单精度 (32-bit) 浮点元素除以 b 中的下部单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当掩码位 0 为 0 时,该元素清零) (未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 计算 a 和 b 中 BF16 (16-bit) 浮点对的点积,将中间单精度 (32-bit) 浮点元素与 src 中的元素进行累加,并将结果存储在 dst 中使用 zeromask k (当对应的掩码为位未设置)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数相加,并将包装的 32 位结果使用 zeromask k 存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的 4 对相邻的无符号 8 位整数组与 b 中的相应有符号 8 位整数相乘,产生 4 个中间有符号 16 位结果。将这 4 个结果与 src 中对应的 32 位整数用带符号饱和求和,并将包装的 32 位结果用 zeromask k 存储在 dst 中 (当对应的掩码位未设置时,元素被清零)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。将这 2 个结果与 src 中对应的 32 位整数相加,并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的 2 对相邻的有符号 16 位整数组与 b 中的相应 16 位整数相乘,产生 2 个中间有符号 32 位结果。使用符号饱和将这 2 个结果与 src 中相应的 32 位整数相加,并使用 zeromask k 将包装的 32 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 加载连续的活动 16 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的有效 32 位整数 (它们各自的位被设置在掩码 k 中),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的有效 64 位整数 (它们各自的位被设置在掩码 k 中),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的活动双精度 (64-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中加载连续的活动单精度 (32-bit) 浮点元素 (其各自的位在掩码 k 中设置),并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 8 位整数 (那些在掩码 k 中设置了相应位的整数),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 16 位整数 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 32 位整数 (在掩码 k 中设置了相应位的那些),并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动 64 位整数 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (64-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 从 mem_addr 的未对齐内存中加载连续的活动单精度 (32-bit) 浮点元素 (它们各自的位被设置在掩码 k 中),并使用 zeromask k 将结果存储在 dst 中 (当相应的掩码位未设置时,元素被清零)。
- 使用 c 中的包装 64 位整数修复 a 和 b 中的包装双精度 (64-bit) 浮点元素,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 使用 c 中的包装 32 位整数修复 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。imm8 用于设置所需的标志报告。
- 使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 的较低元素中 (当不使用掩码位 0 时该元素清零) set),然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用 c 中的较低 32 位整数固定 a 和 b 中的较低单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 的较低元素中 (当未使用掩码 bit 0 时该元素被清零) 设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 使用 c 中的较低 64 位整数修复 a 和 b 中的较低双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 的较低元素中 (当不使用掩码位 0 时该元素清零) set),然后将上层元素从 a 复制到 dst 的上层元素。imm8 用于设置所需的标志报告。
- 使用 c 中的较低 32 位整数固定 a 和 b 中的较低单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 的较低元素中 (当未使用掩码 bit 0 时该元素被清零) 设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。imm8 用于设置所需的标志报告。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后使用零掩码 k 将中间结果与较低元素 in c. Store 的结果加到 dst 较低元素中 (当未设置掩码位 0 时该元素归零) ),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用零掩码 k 将中间结果与较低元素 in c. Store 的中间结果相加到 dst 较低元素中 (未设置掩码位 0 时该元素归零) ),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后使用零掩码 k 将中间结果与较低元素 in c. Store 的结果加到 dst 较低元素中 (当未设置掩码位 0 时该元素归零) ),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用零掩码 k 将中间结果与较低元素 in c. Store 的中间结果相加到 dst 较低元素中 (未设置掩码位 0 时该元素归零) ),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装后的单精度 (32-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或相减,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,从中间结果中减去 c 中的包装的元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当掩码位 0 未设置时元素被清零),并将上元素从 a 复制到 dst 的上元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,元素被清零),并将上层 3 个包装的元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下元素中 (当掩码位 0 未设置时元素被清零),并将上元素从 a 复制到 dst 的上元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,元素被清零),并将上层 3 个包装的元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的包装后的双精度 (64-bit) 浮点元素相乘,或者将 C to/from 中的包装后的元素相加或减去,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,或者将 C from/to 中的包装元素相减并相加,得到中间结果,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,将取反的中间结果添加到 c 中的包装元素中,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,然后使用零掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) set),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用零掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) 设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的较低的双精度 (64-bit) 浮点元素相乘,然后使用零掩码 k 将求反的中间结果与较低的元素 in c. Store 的结果加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) set),然后将上层元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后使用零掩码 k 将求反的中间结果与较低元素 in c. Store 的结果相加到 dst 的较低元素中 (当未使用掩码位 0 时该元素清零) 设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 将 a 和 b 中的包装双精度 (64-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装单精度 (32-bit) 浮点元素相乘,从取反的中间结果中减去 c 中的包装元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 中 (当未设置掩码位 0 时元素被清零),并将上元素从 a 复制到 dst 的上元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,元素被清零),并将上层 3 个包装的元素从 a 复制到 dst 的上层元素。
- 将 a 和 b 中的较低双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 中 (当未设置掩码位 0 时元素被清零),并将上元素从 a 复制到 dst 的上元素。
- 将 a 和 b 中的较低单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去 c 中的较低元素。使用 zeromask k 将结果存储在 dst 的下层元素中 (当掩码位 0 未设置时,元素被清零),并将上层 3 个包装的元素从 a 复制到 dst 的上层元素。
- 将 a 中每个包装的双精度 (64-bit) 浮点元素的指数转换为代表整数指数的双精度 (64-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 a 中每个包装的单精度 (32-bit) 浮点元素的指数转换为代表整数指数的单精度 (32-bit) 浮点数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。本质上,此内部函数为每个元素计算 floor(log2(x))。
- 将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置),然后将较高的元素从 a 复制到 dst 的较高的元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置),并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 将 b 中较低的双精度 (64-bit) 浮点元素的指数转换为表示整数指数的双精度 (64-bit) 浮点数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置),然后将较高的元素从 a 复制到 dst 的较高的元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
- 将 b 中较低的单精度 (32-bit) 浮点元素的指数转换为表示整数指数的单精度 (32-bit) 浮点数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码位 0 未设置),并将高 3 个包装的元素从 a 复制到 dst 的高元素。本质上,此内部函数计算下层元素的 floor(log2(x))。
- 将 a 中的包装的双精度 (64-bit) 浮点元素的尾数标准化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 将 a 中的包装的单精度 (32-bit) 浮点元素的尾数规格化,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1 - 标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数,使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零),然后从中复制较高元素。a 到 dst 的高位元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低单精度 (32-bit) 浮点元素的尾数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零),然后复制高位 3 从 a 到 dst 的高位元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低的双精度 (64-bit) 浮点元素的尾数,使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零),然后从中复制较高元素。a 到 dst 的高位元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 标准化 b 中较低单精度 (32-bit) 浮点元素的尾数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零),然后复制高位 3 从 a 到 dst 的高位元素。此内部函数本质上计算 ±(2^k)*|x.significand|,其中 k 取决于由 interv 定义的间隔范围,而符号取决于 sc 和源符号。
尾数被标准化为由 interv 指定的间隔,该间隔可以采用以下值:
_MM_MANT_NORM_1_2 // 区间 [1, 2)
_MM_MANT_NORM_p5_2 // 区间 [0.5, 2)
_MM_MANT_NORM_p5_1 // 区间 [0.5, 1)
_MM_MANT_NORM_p75_1p5 // interval [0.75, 1.5)
该符号由 sc 确定,可以采用以下值:
_MM_MANT_SIGN_src // sign = sign(src)
_MM_MANT_SIGN_zero // sign = 0
_MM_MANT_SIGN_nan // dst = NaN if sign(src) = 1
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 对包中的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2^8 上计算 a * x + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 对 inverted 中的封装的字节进行仿射变换 x. 也就是说,对于每个包装的字节,在 Galois 字段 2 ^ 8 上计算 a * inv (x) + b,其中 a 是 8x8 位矩阵,b 是恒定 8 位 immediate 数。
- 在包装的字节上执行 GF(2^8) 乘法。 该字段采用多项式表示,归约多项式 x^8 + x^4 + x^3 + x + 1.
- 使用 zeromask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 8 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 16 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 32 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的 64 位整数从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的双精度 (64-bit) 浮点元素从内存加载到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 zeromask k 将包装的单精度 (32-bit) 浮点元素从内存加载到 dst (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中每个包装的 32 位整数中前导零位的数目,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中每个包装的 64 位整数中前导零位的数目,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。水平添加相邻的中间 32 位整数对,并使用 zeromask k 将结果打包到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中的包装无符号 8 位整数与 b 中的包装有符号 8 位整数相乘,生成中间有符号的 16 位整数。水平添加相邻的一对中间有符号 16 位整数,并使用 zeromask k 将饱和结果打包到 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 32 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最大值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后从中复制较高元素。a 到 dst 的高位元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后复制包装后的高 3 位从 a 到 dst 的高位元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后从中复制较高元素。a 到 dst 的高位元素。
- 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用零掩码 k 将最大值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后复制包装后的高 3 位从 a 到 dst 的高位元素。
- 比较 a 和 b 中包装的带符号的 8 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 16 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号 32 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 8 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 16 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 32 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的无符号 64 位整数,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中的包装单精度 (32-bit) 浮点元素,并使用零掩码 k 将包装的最小值存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零),然后从中复制较高元素。a 到 dst 的高位元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后复制包装后的高 3 位从 a 到 dst 的高位元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素清零),然后从中复制较高元素。a 到 dst 的高位元素。
- 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,使用零掩码 k 将最小值存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后复制包装后的高 3 位从 a 到 dst 的高位元素。
- 使用零掩码 k 将包装的 8 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 16 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 32 位整数从 a 移至 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的 64 位整数从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的双精度 (64-bit) 浮点元素从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将包装的单精度 (32-bit) 浮点元素从 a 移到 dst (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将较低的双精度 (64-bit) 浮点元素从 b 移动到 dst 的较低元素 (未设置掩码位 0 时将该元素清零),然后将较高的元素从 a 复制到 dst 的较高元素。
- 使用零掩码 k 将较低的单精度 (32-bit) 浮点元素从 b 移动到 dst 的较低元素 (未设置掩码位 0 时将该元素清零),然后将较高的 3 个包装的元素从 a 复制到较高的元素 dst。
- 从 a 复制偶数索引的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制奇数索引的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 复制偶数索引的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中每个包装的 64 位元素的低位有符号 32 位整数相乘,并使用零掩码 k 将有符号的 64 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中每个包装的 64 位元素的低无符号 32 位整数相乘,并使用零掩码 k 将无符号 64 位结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的双精度 (64-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的单精度 (32-bit) 浮点元素相乘,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的低位双精度 (64-bit) 浮点元素相乘,使用零掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时该元素归零),然后从 a 中复制高位元素到 dst 的上层元素。
- 将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),并复制上部 3 个包装的元素从 a 到 dst 的上层元素。
- 将 a 和 b 中的低位双精度 (64-bit) 浮点元素相乘,使用零掩码 k 将结果存储在 dst 的低位元素中 (当未设置掩码位 0 时该元素归零),然后从 a 中复制高位元素到 dst 的上层元素。
- 将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),并复制上部 3 个包装的元素从 a 到 dst 的上层元素。
- 将 a 和 b 中包装的带符号的 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中包装的无符号 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中乘以包装的带符号的 16 位整数,产生中间的带符号的 32 位整数。将每个中间整数截断为 18 个最高有效位,通过加 1 舍入,并使用 zeromask k 将位 [16:1] 存储到 dst (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的 16 位整数相乘,生成中间的 32 位整数,并使用零掩码 k 将中间整数的低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的包装的 32 位整数相乘,生成中间 64 位整数,并使用零掩码 k 将中间整数的低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并使用 zeromask k (元素当相应的屏蔽位未设置时被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位或,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位或,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用带符号的饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用带符号的饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用无符号饱和度将包装的带符号的 16 位整数从 a 和 b 转换为包装的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用无符号饱和度将包装的带符号的 32 位整数从 a 和 b 转换为包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对双精度 (64-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 内对单精度 (32-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的控件在 128 位 lane 内将 a 中的双精度 (64-bit) 浮点元素进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的控件在 128 位 lane 内将 a 的单精度 (32-bit) 浮点元素打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用相应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 32 位整数进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 64 位整数进行混洗,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用对应的选择器和 idx 中的索引将 a 和 b 中的双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 的 a 中打乱 8 位整数,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数,使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零),然后复制较高元素从 a 到 dst 的高位元素。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的单精度 (32-bit) 浮点元素的近似倒数,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素归零),并复制较高的 3 从 a 到 dst 的上层元素的包装的元素。该近似值的最大相对误差小于 2^-14。
- 将每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零),并将上一个元素从 a 复制到 dst 的上一个元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素四舍五入为 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零),并将上面的 3 个包装的元素从 a 复制到 dst 的上面的元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零),并将上一个元素从 a 复制到 dst 的上一个元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素四舍五入为 imm8 指定的分数位数,并使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置掩码位 0 时该元素清零),并将上面的 3 个包装的元素从 a 复制到 dst 的上面的元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 a 中的包装的双精度 (64-bit) 浮点元素的近似倒数平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数平方根,使用零掩码 k 将结果存储在 dst 的较低元素中 (未设置掩码位 0 时该元素归零),然后复制从 a 到 dst 的上元素的上元素。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低单精度 (32-bit) 浮点元素的近似倒数平方根,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置掩码位 0 时该元素归零),然后复制从 a 到 dst 的上层元素的上 3 个包装的元素。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后复制上部元素从 a 到 dst 的高位元素。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),并复制上部 3 从 a 到 dst 的上层元素的包装的元素。
- 使用 b 中的值缩放 a 中的包装双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后复制上部元素从 a 到 dst 的高位元素。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),并复制上部 3 从 a 到 dst 的上层元素的包装的元素。
- 使用零掩码 k 将 8 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将低包装的 16 位整数从 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 32 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 使用零掩码 k 将 64 位整数 a 广播到 dst 的所有元素 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并使用 zeromask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的相应元素中指定的数量,并使用 zeromask k 将高 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并使用 zeromask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 16 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 32 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的相应元素中指定的数量,并使用 zeromask k 将低 64 位存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 根据 b 的相应 8 位元素中的打乱控制掩码对 a 中的包装 8 位整数进行打乱,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 128 位 lane 中的 32 位整数中混洗 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件对 128 位 lane 内的双精度 (64-bit) 浮点元素进行混洗,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件对 a 中的单精度 (32-bit) 浮点元素进行打乱,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 imm8 中的控件在 a 的 128 位 lane 的高 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的高 64 位中,使用 zeromask k 将 128 位 lanes 的低 64 位从 a 复制到 dst (当相应的掩码位未设置时,元素被清零) .
- 使用 imm8 中的控件在 a 的 128 位 lane 的低 64 位中对 16 位整数进行打乱。将结果存储在 dst 的 128 位 lanes 的低 64 位中,使用 writemask k 将 128 位 lanes 的高 64 位从 a 复制到 dst (当相应的掩码位未设置时,从 src 复制元素)。
- 将包装的 16 位整数按计数左移,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数左移计数,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将填充的 64 位整数左移计数,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数左移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数左移由 count 中的相应元素指定的数量,同时移入零,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将移位的 32 位整数左移零时,将其对应计数指定的数量左移,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将移位的 64 位整数左移零时,将其对应计数指定的数量左移,然后使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的平方根,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 b 中下部双精度 (64-bit) 浮点元素的平方根,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后复制上部元素从 a 到 dst 的高位元素。
- 计算 b 中较低的单精度 (32-bit) 浮点元素的平方根,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后复制高 3 从 a 到 dst 的上层元素的包装的元素。
- 计算 b 中下部双精度 (64-bit) 浮点元素的平方根,使用零掩码 k 将结果存储在 dst 的下部元素中 (当未设置 mask bit 0 时该元素清零),然后复制上部元素从 a 到 dst 的高位元素。
- 计算 b 中较低的单精度 (32-bit) 浮点元素的平方根,使用零掩码 k 将结果存储在 dst 的较低元素中 (当未设置 mask bit 0 时该元素清零),然后复制高 3 从 a 到 dst 的上层元素的包装的元素。
- 将包装的 16 位整数按计数右移,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移动符号位的同时右移计数包装的 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移动符号位的同时右移计数包装的 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移由 count 中的相应元素指定的数量,同时将符号位移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在将符号位移位的同时,将已包装的 32 位整数向右移动计数中相应元素指定的数量,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 在移入符号位的同时,将包装的 64 位整数右移由 count 中相应元素指定的数量,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将移位的 32 位整数右移,同时移零,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移计数,同时移入零,并使用 zeromask k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 32 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 64 位整数右移 imm8,同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 向右移动已包装的 32 位整数,偏移量为相应元素在计数中指定的数量,同时向零移位,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 向右移位包装的 64 位整数,其数量为计数中相应元素指定的数量,同时移位为零,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 8 位整数中减去 b 中的包装 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的 16 位整数中减去 b 中的包装的 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 32 位整数中减去 b 中的包装 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装 64 位整数中减去 b 中的包装 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的包装的双精度 (64-bit) 浮点元素中减去 b 中的包装的双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 将 b 中的包装后的单精度 (32-bit) 浮点元素减去 a 中的包装后的单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中的较低双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时,该元素将被清零。(未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 从 a 中的较低单精度 (32-bit) 浮点元素中减去 b 中的较低单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时,该元素将被清零。(未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中的较低双精度 (64-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时,该元素将被清零。(未设置),然后将上层元素从 a 复制到 dst 的上层元素。
- 从 a 中的较低单精度 (32-bit) 浮点元素中减去 b 中的较低单精度 (32-bit) 浮点元素,使用零掩码 k 将结果存储在 dst 的较低元素中 (当掩码 bit 0 为 0 时,该元素将被清零。(未设置),然后将前 3 个包装的元素从 a 复制到 dst 的高元素。
- 使用饱和度从包装的 8 位整数中减去 b 中的包装有符号的 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用饱和度将 b 中的包装 16 位整数减去 b 中的包装有符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 a 饱和度从 b 中的包装无符号 8 位整数减去 b 中的包装无符号 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 使用 a 饱和度将 b 中的包装无符号 16 位整数减去 b 中的包装无符号 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 中的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 32 位粒度的 zeromask k (当未设置相应的掩码位时,32 位元素会被清零)。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 中的 3 位索引,并将 imm8 中该位的值写入 dst 中的相应位,使用 64 位粒度的 zeromask k (当未设置相应的掩码位时,64 位元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分拆包和交织 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的高半部分解包和交织单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 8 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分拆包和交织 16 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 32 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织 64 位整数,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织双精度 (64-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 从 a 和 b 中每个 128 位 lane 的下半部分解包和交织单精度 (32-bit) 浮点元素,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并使用零掩码 k 将结果存储在 dst 中 (当未设置相应的掩码位时,元素将被清零)。
- 比较 a 和 b 中包装的带符号的 64 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中包装的无符号 64 位整数,并将包装的最大值存储在 dst 中。
- 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,将最大值存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,将最大值存储在 dst 的较低元素中,并将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中包装的无符号 64 位整数,并将包装的最小值存储在 dst 中。
- 比较 a 和 b 中较低的双精度 (64-bit) 浮点元素,将最小值存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 比较 a 和 b 中较低的单精度 (32-bit) 浮点元素,将最小值存储在 dst 的较低元素中,并将较高的 3 个包装的元素从 a 复制到 dst 的较高元素。
可以通过在 sae 参数中传递 _MM_FROUND_NO_EXC 来抑制异常。 - 根据相应封装的 8 位整数的最高位设置掩码寄存器 k 的每一位 a.
- 根据相应封装的 16 位整数的最高位设置掩码寄存器 k 的每一位 a.
- 根据 dst 中相应位的值,将 dst 中每个包的 8 位整数设置为全 1 或全 0 k.
- 根据 dst 中相应位的值,将 dst 中每个包的 16 位整数设置为全 1 或全 0 k.
- 将 a 和 b 中的下部双精度 (64-bit) 浮点元素相乘,将结果存储在 dst 的下部元素中,然后将 a 的上部元素复制到 dst 的上部元素。
- 将 a 和 b 中的下部单精度 (32-bit) 浮点元素相乘,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。
- 对于 b 中的每个 64 位元素,使用 a 的相应 64 位元素内的字节粒度移位控制选择 8 个未对齐的字节,并将 8 个组装字节存储到 dst 的相应 64 位元素。
- 计算 a 和 b 中包装的 32 位整数的按位或,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 64 位整数的按位或,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引将 a 和 b 中的 8 位整数跨 lanes 打乱,并将结果存储在 dst 中。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中对 16 位整数进行打乱,并将结果存储在 dst 中。
- 使用对应的选择器和 idx 中的索引在 lanes 中的 a 和 b 中随机排列 32 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中随机排列 64 位整数,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对双精度 (64-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 idx 中的相应选择器和索引在 lanes 中的 a 和 b 中对单精度 (32-bit) 浮点元素进行混洗,并将结果存储在 dst 中。
- 使用 idx 中的相应索引将 a 中的 8 位整数打乱到 lanes 中,并将结果存储在 dst 中。
- 使用 idx 中的相应索引在跨 lanes 中对 16 位整数进行打乱,并将结果存储在 dst 中。
- 对于每个包装的 8 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 16 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 32 位整数 maps,该值等于逻辑 1 位的数量。
- 对于每个包装的 64 位整数 maps,该值均等于逻辑 1 位的数量。
- 计算 a 中包装的双精度 (64-bit) 浮点元素的近似倒数,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 计算 a 中包装的单精度 (32-bit) 浮点元素的近似倒数,并将结果存储在 dst 中。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数,将结果存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低的单精度 (32-bit) 浮点元素的近似倒数,将结果存储在 dst 的较低元素中,并将高 3 个包装的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。
- 将 a 中每个包装的 32 位整数中的位向左旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向左旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向左旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向左旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向右旋转 imm8 中指定的位数,并将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向右旋转 imm8 中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 32 位整数中的位向右旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中每个包装的 64 位整数中的位向右旋转 b 的相应元素中指定的位数,然后将结果存储在 dst 中。
- 将 a 中包装的双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,并将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 a 中的包装的单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的小数位数,然后将结果存储在 dst 中。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,将结果存储在 dst 的下部元素中,并将上部的元素从 a 复制到 dst 的上部元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部双精度 (64-bit) 浮点元素四舍五入到 imm8 指定的分数位数,将结果存储在 dst 的下部元素中,并将上部的元素从 a 复制到 dst 的上部元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 将 b 中的下部单精度 (32-bit) 浮点元素四舍五入到 imm8 指定的分数位数,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。
根据 imm8[2: 0] 参数进行舍入,该参数可以是以下之一:
_MM_FROUND_TO_NEAREST_INT // 舍入到最接近的值
_MM_FROUND_TO_NEG_INF // 向下取整
_MM_FROUND_TO_POS_INF // 向上舍入
_MM_FROUND_TO_ZERO // 截断
_MM_FROUND_CUR_DIRECTION // 使用 MXCSR.RC; 请参见 _MM_SET_ROUNDING_MODE - 计算 b 中较低的双精度 (64-bit) 浮点元素的近似倒数平方根,将结果存储在 dst 的较低元素中,并将较高的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。
- 计算 b 中较低单精度 (32-bit) 浮点元素的近似倒数平方根,将结果存储在 dst 的较低元素中,并将高 3 个包装的元素从 a 复制到 dst 的较高元素。该近似值的最大相对误差小于 2^-14。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,并将结果存储在 dst 中。
- 使用 b 中的值缩放 a 中包装的单精度 (32-bit) 浮点元素,并将结果存储在 dst 中。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,然后将 a 的上部元素复制到 dst 的上部元素。
- 使用 b 中的值缩放 a 中的包装的单精度 (32-bit) 浮点元素,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。
- 使用 b 中的值缩放 a 中包装的双精度 (64-bit) 浮点元素,将结果存储在 dst 的下部元素中,然后将 a 的上部元素复制到 dst 的上部元素。
- 使用 b 中的值缩放 a 中的包装的单精度 (32-bit) 浮点元素,将结果存储在 dst 的下部元素中,并将上部的 3 个包装的元素从 a 复制到 dst 的上部元素。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 imm8 位,并将高 16 位存储在 dst 中)。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 imm8 位,并将高 32 位存储在 dst 中。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 imm8 位,并将高 64 位存储在 dst 中)。
- 在 a 和 b 中连接包装的 16 位整数,产生一个中间 32 位结果。将结果左移 c 的对应元素中指定的量,并将高 16 位存储在 dst 中。
- 将 a 和 b 中的 32 位整数连接包装产生中间 64 位结果。将结果左移 c 的对应元素中指定的量,并将高 32 位存储在 dst 中。
- 在 a 和 b 中连接包装的 64 位整数,产生一个中间的 128 位结果。将结果左移 c 的对应元素中指定的量,并将高 64 位存储在 dst 中。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 imm8 位,并将低 16 位存储在 dst 中。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 imm8 位,并将低 32 位存储在 dst 中。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 imm8 位,并将低 64 位存储在 dst 中。
- 将 b 和 a 中的包装的 16 位整数连接起来,产生一个中间 32 位结果。将结果右移 c 的对应元素中指定的量,并将低 16 位存储在 dst 中。
- 连接包装在 b 和 a 中的 32 位整数,产生中间 64 位结果。将结果右移 c 的对应元素中指定的量,并将低 32 位存储在 dst 中。
- 将 b 和 a 中的包装的 64 位整数连接起来,产生一个中间的 128 位结果。将结果右移 c 的对应元素中指定的量,并将低 64 位存储在 dst 中。
- 将包装的 16 位整数按 count 中相应元素指定的数量向左移位,同时将零移位,并将结果存储在 dst 中。
- 计算 b 中较低的双精度 (64-bit) 浮点元素的平方根,将结果存储在 dst 的较低元素中,然后将较高的元素从 a 复制到 dst 的较高元素。
- 计算 b 中较低的单精度 (32-bit) 浮点元素的平方根,将结果存储在 dst 的较低元素中,并将高 3 个包装的元素从 a 复制到 dst 的较高元素。
- 在移动符号位的同时按计数右移包装的 64 位整数,并将结果存储在 dst 中。
- 将包装的 64 位整数右移 imm8,同时将符号位移位,并将结果存储在 dst 中。
- 将包装的 16 位整数右移 count 中相应元素指定的数量,同时移入符号位,然后将结果存储在 dst 中。
- 将移位的 64 位整数向右移动计数中相应元素指定的数量,同时移入符号位,并将结果存储在 dst 中。
- 将包装的 16 位整数向右移位 (由 count 中相应元素指定的数量),同时将零移位,并将结果存储在 dst 中。
- 将 a 中的 128 位 (由 4 个包装的 32 位整数组成) 存储到内存中。mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 将 a 中的 128 位 (由 2 个包装的 64 位整数组成) 存储到内存中。mem_addr 必须在 16 字节边界上对齐,否则可能会生成一般保护异常。
- 将 a 中的 128 位 (由 16 个包装的 8 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 128 位 (由 8 个包装的 16 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 128 位 (由 4 个包装的 32 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 将 a 中的 128 位 (由 2 个包装的 64 位整数组成) 存储到内存中。mem_addr 不需要在任何特定边界上对齐。
- 从 a 中的较低双精度 (64-bit) 浮点元素中减去 b 中较低的双精度 (64-bit) 浮点元素,将结果存储在 dst 的较低元素中,并将较高的元素从 a 复制到 dst 的较高元素。
- 从 a 中的下部单精度 (32-bit) 浮点元素中减去 b 中的下部单精度 (32-bit) 浮点元素,将结果存储在 dst 的下部元素中,并将上部 3 个包装的元素从 a 复制到上部元素 dst。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 32 位整数中的每个位,来自 a,b 和 c 的相应位用于形成到 imm8 的 3 位索引,并且将 imm8 中该位的值写入 dst 中的相应位。
- 提供执行任何三操作数二进制函数的功能的按位三元逻辑; 特定的二进制函数由 imm8 中的值指定。对于每个包装的 64 位整数中的每一位,使用 a、b、c 中对应的位构成 imm8 的 3 位索引,并将 imm8 中该位的值写入 dst 中的对应位。
- 计算 a 和 b 中包装的 8 位整数的按位与,生成中间 8 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 16 位整数的按位与,生成中间的 16 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位与,生成中间的 32 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 64 位整数的按位与,生成中间 64 位值,如果中间值不为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 8 位整数的按位 NAND,生成中间的 8 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 16 位整数的按位 NAND,生成中间的 16 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位 NAND,生成中间的 32 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 64 位整数的按位 NAND,生成中间的 64 位值,如果中间值为零,则在结果掩码 k 中设置相应的位。
- 计算 a 和 b 中包装的 32 位整数的按位 XOR,并将结果存储在 dst 中。
- 计算 a 和 b 中包装的 64 位整数的按位 XOR,并将结果存储在 dst 中。
- 将 32 位掩码从 a 存储到内存中。
- 将 64 位掩码从 a 存储到内存中。
- 强制将受限制的事务内存 (RTM) 区域中止。 Intel’s documentation.
- 指定受限制的事务性存储器 (RTM) 代码区域的开始,并返回一个指示状态的值。
- 指定受限制的事务性存储器 (RTM) 代码区域的结尾。 Intel’s documentation.
- 查询处理器是在由受限事务存储器 (RTM) 还是硬件锁定扩展 (HLE) 标识的事务区域中执行。
- 主机是否支持
cpuid
指令? - 生成陷阱指令
UD2
- _MM_GET_EXCEPTION_MASK⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_GET_EXCEPTION_STATE⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_GET_FLUSH_ZERO_MODE⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_GET_ROUNDING_MODE⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_SET_EXCEPTION_MASK⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_SET_EXCEPTION_STATE⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_SET_FLUSH_ZERO_MODE⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_SET_ROUNDING_MODE⚠(x86 or x86-64) and
sse
请参见_mm_setcsr
- _MM_TRANSPOSE4_PS⚠(x86 or x86-64) and
sse
将由 4 行 __m128 组成的 4x4 矩阵转置到位。 - __cpuid⚠x86 or x86-64请参见
__cpuid_count
。 - __cpuid_count⚠x86 or x86-64返回给定
leaf
(EAX
) 和sub_leaf
(ECX
) 的cpuid
指令的结果。 - __get_cpuid_max⚠x86 or x86-64返回最高支持的
leaf
(EAX
) 和子叶 (ECX
)cpuid
值。 - __rdtscp⚠x86 or x86-64读取处理器时间戳计数器和
IA32_TSC_AUX MSR
的当前值。 - _addcarry_u32⚠x86 or x86-64将无符号的 32 位整数
a
和b
与无符号的 8 位进位c_in
(进位标志) 相加,并将无符号的 32 位结果存储在out
中,并返回进位 (进位或溢出标志)。 - 将无符号的 64 位整数
a
和b
与无符号的 8 位进位c_in
(进位标志) 相加,并将无符号的 64 位结果存储在out
中,并返回进位 (进位或溢出标志)。 - _addcarryx_u32⚠(x86 or x86-64) and
adx
将无符号的 32 位整数a
和b
与无符号的 8 位进位c_in
(进位或溢出标志) 相加,并将无符号的 32 位结果存储在out
中,并返回进位 (进位或溢出标志)。 - _addcarryx_u64⚠
adx
将无符号的 64 位整数a
和b
与无符号的 8 位进位c_in
(进位或溢出标志) 相加,并将无符号的 64 位结果存储在out
中,并返回进位 (进位或溢出标志)。 - _andn_u32⚠(x86 or x86-64) and
bmi1
a
和b
的按位逻辑AND
。 - _andn_u64⚠
bmi1
a
和b
的按位逻辑AND
。 - _bextr2_u32⚠(x86 or x86-64) and
bmi1
将control
指定的a
的位提取到结果的最低有效位中。 - _bextr2_u64⚠
bmi1
将control
指定的a
的位提取到结果的最低有效位中。 - _bextr_u32⚠(x86 or x86-64) and
bmi1
从a
提取范围为 [start,start
+length
) 的位到结果的最低有效位。 - _bextr_u64⚠
bmi1
从a
提取范围为 [start,start
+length
) 的位到结果的最低有效位。 - _bittest⚠x86 or x86-64返回由
p
寻址的存储器的位置b
中的位。 - 返回由
p
寻址的存储器的位置b
中的位。 - _bittestandcomplement⚠x86 or x86-64返回由
p
寻址的存储器的位置b
中的位,然后将该位取反。 - 返回由
p
寻址的存储器的位置b
中的位,然后将该位取反。 - _bittestandreset⚠x86 or x86-64返回由
p
寻址的存储器的位置b
中的位,然后将该位重置为0
。 - 返回由
p
寻址的存储器的位置b
中的位,然后将该位重置为0
。 - _bittestandset⚠x86 or x86-64返回由
p
寻址的存储器的位置b
中的位,然后将该位设置为1
。 - 返回由
p
寻址的存储器的位置b
中的位,然后将该位设置为1
。 - _blcfill_u32⚠(x86 or x86-64) and
tbm
清除x
的最低有效零位以下的所有位。 - _blcfill_u64⚠(x86 or x86-64) and
tbm
清除x
的最低有效零位以下的所有位。 - _blci_u32⚠(x86 or x86-64) and
tbm
将x
的所有位 (最低有效零位除外) 设置为 1。 - _blci_u64⚠(x86 or x86-64) and
tbm
将x
的所有位 (最低有效零位除外) 设置为 1。 - _blcic_u32⚠(x86 or x86-64) and
tbm
设置x
的最低有效零位并清除所有其他位。 - _blcic_u64⚠(x86 or x86-64) and
tbm
设置x
的最低有效零位并清除所有其他位。 - _blcmsk_u32⚠(x86 or x86-64) and
tbm
设置x
的最低有效零位,并清除该位上方的所有位。 - _blcmsk_u64⚠(x86 or x86-64) and
tbm
设置x
的最低有效零位,并清除该位上方的所有位。 - _blcs_u32⚠(x86 or x86-64) and
tbm
设置x
的最低有效零位。 - _blcs_u64⚠(x86 or x86-64) and
tbm
设置x
的最低有效零位。 - _blsfill_u32⚠(x86 or x86-64) and
tbm
将x
的所有位设置在最低有效位以下。 - _blsfill_u64⚠(x86 or x86-64) and
tbm
将x
的所有位设置在最低有效位以下。 - _blsi_u32⚠(x86 or x86-64) and
bmi1
提取最低位隔离位。 - _blsi_u64⚠
bmi1
提取最低位隔离位。 - _blsic_u32⚠(x86 or x86-64) and
tbm
清除最低有效位并设置所有其他位。 - _blsic_u64⚠(x86 or x86-64) and
tbm
清除最低有效位并设置所有其他位。 - _blsmsk_u32⚠(x86 or x86-64) and
bmi1
将掩码提高到最低设置位。 - _blsmsk_u64⚠
bmi1
将掩码提高到最低设置位。 - _blsr_u32⚠(x86 or x86-64) and
bmi1
复位x
的最低位。 - _blsr_u64⚠
bmi1
复位x
的最低位。 - _bswap⚠x86 or x86-64返回整数,其字节顺序为 x
- 返回整数,其字节顺序为 x
- _bzhi_u32⚠(x86 or x86-64) and
bmi2
将a
>=index
的高位清零。 - _bzhi_u64⚠
bmi2
将a
>=index
的高位清零。 - _fxrstor⚠(x86 or x86-64) and
fxsr
从以下位置恢复XMM
,MMX
,MXCSR
和x87
FPU 寄存器 512 字节长,16 字节对齐的内存区域mem_addr
。 - _fxrstor64⚠
fxsr
从以下位置恢复XMM
,MMX
,MXCSR
和x87
FPU 寄存器 512 字节长,16 字节对齐的内存区域mem_addr
。 - _fxsave⚠(x86 or x86-64) and
fxsr
将x87
FPU,MMX
技术,XMM
和MXCSR
寄存器保存到 512 字节长,16 字节对齐的内存区域mem_addr
。 - _fxsave64⚠
fxsr
将x87
FPU,MMX
技术,XMM
和MXCSR
寄存器保存到 512 字节长,16 字节对齐的内存区域mem_addr
。 - _lzcnt_u32⚠(x86 or x86-64) and
lzcnt
计算前导最高有效零位。 - _lzcnt_u64⚠
lzcnt
计算前导最高有效零位。 - _mm256_abs_epi8⚠(x86 or x86-64) and
avx2
计算a
中包装的 8 位整数的绝对值。 - _mm256_abs_epi16⚠(x86 or x86-64) and
avx2
计算a
中包装的 16 位整数的绝对值。 - _mm256_abs_epi32⚠(x86 or x86-64) and
avx2
计算a
中包装的 32 位整数的绝对值。 - _mm256_add_epi8⚠(x86 or x86-64) and
avx2
在a
和b
中添加包装的 8 位整数。 - _mm256_add_epi16⚠(x86 or x86-64) and
avx2
在a
和b
中添加包装的 16 位整数。 - _mm256_add_epi32⚠(x86 or x86-64) and
avx2
在a
和b
中添加包装的 32 位整数。 - _mm256_add_epi64⚠(x86 or x86-64) and
avx2
在a
和b
中添加包装的 64 位整数。 - _mm256_add_pd⚠(x86 or x86-64) and
avx
在a
和b
中添加包装的双精度 (64-bit) 浮点元素。 - _mm256_add_ps⚠(x86 or x86-64) and
avx
在a
和b
中添加包装的单精度 (32-bit) 浮点元素。 - _mm256_adds_epi8⚠(x86 or x86-64) and
avx2
使用饱和度在a
和b
中添加包装的 8 位整数。 - _mm256_adds_epi16⚠(x86 or x86-64) and
avx2
使用饱和度在a
和b
中添加包装的 16 位整数。 - _mm256_adds_epu8⚠(x86 or x86-64) and
avx2
使用饱和度在a
和b
中添加包装的无符号 8 位整数。 - _mm256_adds_epu16⚠(x86 or x86-64) and
avx2
使用饱和度在a
和b
中添加包装的无符号 16 位整数。 - _mm256_addsub_pd⚠(x86 or x86-64) and
avx
或者,将a
中的包装双精度 (64 位) 浮点元素与b
中的包装元素进行加减。 - _mm256_addsub_ps⚠(x86 or x86-64) and
avx
或者,将a
中的包装的单精度 (32 位) 浮点元素与b
中的包装的元素进行加减。 - _mm256_alignr_epi8⚠(x86 or x86-64) and
avx2
将a
和b
中的 16 字节块对连接成一个 32 字节的临时结果,将结果右移n
字节,然后返回低 16 字节。 - _mm256_and_pd⚠(x86 or x86-64) and
avx
计算a
和b
中包装的双精度 (64-bit) 浮点元素的按位与。 - _mm256_and_ps⚠(x86 or x86-64) and
avx
计算a
和b
中包装的单精度 (32-bit) 浮点元素的按位与。 - _mm256_and_si256⚠(x86 or x86-64) and
avx2
计算a
和b
中 256 位 (代表整数数据) 的按位与。 - _mm256_andnot_pd⚠(x86 or x86-64) and
avx
计算a
中包装的双精度 (64-bit) 浮点元素的按位 NOT,然后计算b
的 AND。 - _mm256_andnot_ps⚠(x86 or x86-64) and
avx
计算a
中包装的单精度 (32-bit) 浮点元素的按位非,然后计算b
的 AND。 - _mm256_andnot_si256⚠(x86 or x86-64) and
avx2
计算a
中 256 位 (代表整数数据) 的按位非,然后计算b
的与。 - _mm256_avg_epu8⚠(x86 or x86-64) and
avx2
a
和b
中的包装无符号 8 位整数的平均值。 - _mm256_avg_epu16⚠(x86 or x86-64) and
avx2
a
和b
中的包装无符号 16 位整数的平均值。 - _mm256_blend_epi16⚠(x86 or x86-64) and
avx2
使用控制掩码IMM8
混合包装来自a
和b
的 16 位整数。 - _mm256_blend_epi32⚠(x86 or x86-64) and
avx2
使用控制掩码IMM8
混合来自a
和b
的包装的 32 位整数。 - _mm256_blend_pd⚠(x86 or x86-64) and
avx
使用控制掩码imm8
混合来自a
和b
的包装后的双精度 (64-bit) 浮点元素。 - _mm256_blend_ps⚠(x86 or x86-64) and
avx
使用控制掩码imm8
混合来自a
和b
的包装的单精度 (32-bit) 浮点元素。 - _mm256_blendv_epi8⚠(x86 or x86-64) and
avx2
使用mask
混合来自a
和b
的包装的 8 位整数。 - _mm256_blendv_pd⚠(x86 or x86-64) and
avx
使用c
作为掩码,混合来自a
和b
的包装后的双精度 (64-bit) 浮点元素。 - _mm256_blendv_ps⚠(x86 or x86-64) and
avx
使用c
作为掩码,混合来自a
和b
的包装的单精度 (32-bit) 浮点元素。 - _mm256_broadcast_pd⚠(x86 or x86-64) and
avx
将内存中的 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 广播到返回的 vector 的所有元素。 - _mm256_broadcast_ps⚠(x86 or x86-64) and
avx
从内存 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 向广播的 vector 的所有元素广播 128 位。 - _mm256_broadcast_sd⚠(x86 or x86-64) and
avx
从内存向返回的 vector 的所有元素广播双精度 (64-bit) 浮点元素。 - _mm256_broadcast_ss⚠(x86 or x86-64) and
avx
从内存向返回的 vector 的所有元素广播单精度 (32-bit) 浮点元素。 - _mm256_broadcastb_epi8⚠(x86 or x86-64) and
avx2
将a
的低位包装 8 位整数广播到 256 位返回值的所有元素。 - _mm256_broadcastd_epi32⚠(x86 or x86-64) and
avx2
将a
的低位包装 32 位整数广播到 256 位返回值的所有元素。 - _mm256_broadcastq_epi64⚠(x86 or x86-64) and
avx2
将a
的低位包装 64 位整数广播到 256 位返回值的所有元素。 - _mm256_broadcastsd_pd⚠(x86 or x86-64) and
avx2
将低双精度 (64-bit) 浮点元素从a
广播到 256 位返回值的所有元素。 - _mm256_broadcastsi128_si256⚠(x86 or x86-64) and
avx2
从 a 广播 128 位整数数据到 256 位返回值中的所有 128 位 lanes。 - _mm256_broadcastss_ps⚠(x86 or x86-64) and
avx2
将低单精度 (32-bit) 浮点元素从a
广播到 256 位返回值的所有元素。 - _mm256_broadcastw_epi16⚠(x86 or x86-64) and
avx2
将低位包装的 16 位整数从 a 广播到 256 位返回值的所有元素 - _mm256_bslli_epi128⚠(x86 or x86-64) and
avx2
将a
中的 128 位 lanes 向左移imm8
字节,同时向零移位。 - _mm256_bsrli_epi128⚠(x86 or x86-64) and
avx2
将a
中的 128 位 lanes 右移imm8
字节,同时将其移位为零。 - _mm256_castpd128_pd256⚠(x86 or x86-64) and
avx
将类型 __m128d 的 vector 转换为 __m256d 类型; 结果的高 128 位未定义。 - _mm256_castpd256_pd128⚠(x86 or x86-64) and
avx
将类型为 __m256d 的 vector 强制转换为类型为 __m128d 的 vector。 - _mm256_castpd_ps⚠(x86 or x86-64) and
avx
将类型为 __m256d 的 vector 强制转换为类型为 __m256 的 vector。 - _mm256_castpd_si256⚠(x86 or x86-64) and
avx
将类型为 __m256d 的 vector 强制转换为类型为 __m256i 的 vector。 - _mm256_castps128_ps256⚠(x86 or x86-64) and
avx
将类型 __m128 的 vector 转换为 __m256 类型; 结果的高 128 位未定义。 - _mm256_castps256_ps128⚠(x86 or x86-64) and
avx
将类型为 __m256 的 vector 强制转换为类型为 __m128 的 vector。 - _mm256_castps_pd⚠(x86 or x86-64) and
avx
将类型为 __m256 的 vector 强制转换为类型为 __m256d 的 vector。 - _mm256_castps_si256⚠(x86 or x86-64) and
avx
将类型为 __m256 的 vector 强制转换为类型为 __m256i 的 vector。 - _mm256_castsi128_si256⚠(x86 or x86-64) and
avx
将类型为 __m128i 的 vector 强制转换为类型 __m256i; 结果的高 128 位未定义。 - _mm256_castsi256_pd⚠(x86 or x86-64) and
avx
将类型为 __m256i 的 vector 强制转换为类型为 __m256d 的 vector。 - _mm256_castsi256_ps⚠(x86 or x86-64) and
avx
将类型为 __m256i 的 vector 强制转换为类型为 __m256 的 vector。 - _mm256_castsi256_si128⚠(x86 or x86-64) and
avx
将类型为 __m256i 的 vector 强制转换为类型为 __m128i 的 vector。 - _mm256_ceil_pd⚠(x86 or x86-64) and
avx
将a
中的包装的双精度 (64-bit) 浮点元素四舍五入为正无穷大。 - _mm256_ceil_ps⚠(x86 or x86-64) and
avx
将a
中的包装的单精度 (32-bit) 浮点元素四舍五入为正无穷大。 - _mm256_cmp_pd⚠(x86 or x86-64) and
avx
根据IMM5
指定的比较操作数比较a
和b
中包装的双精度 (64-bit) 浮点元素。 - _mm256_cmp_ps⚠(x86 or x86-64) and
avx
根据IMM5
指定的比较操作数比较a
和b
中包装的单精度 (32-bit) 浮点元素。 - _mm256_cmpeq_epi8⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装 8 位整数是否相等。 - _mm256_cmpeq_epi16⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 16 位整数是否相等。 - _mm256_cmpeq_epi32⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装 32 位整数是否相等。 - _mm256_cmpeq_epi64⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装 64 位整数是否相等。 - _mm256_cmpgt_epi8⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 8 位整数是否大于。 - _mm256_cmpgt_epi16⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 16 位整数是否大于。 - _mm256_cmpgt_epi32⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 32 位整数是否大于。 - _mm256_cmpgt_epi64⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装 64 位整数是否大于。 - _mm256_cvtepi8_epi16⚠(x86 or x86-64) and
avx2
将 8 位整数符号扩展为 16 位整数。 - _mm256_cvtepi8_epi32⚠(x86 or x86-64) and
avx2
将 8 位整数符号扩展为 32 位整数。 - _mm256_cvtepi8_epi64⚠(x86 or x86-64) and
avx2
将 8 位整数符号扩展为 64 位整数。 - _mm256_cvtepi16_epi32⚠(x86 or x86-64) and
avx2
将 16 位整数符号扩展为 32 位整数。 - _mm256_cvtepi16_epi64⚠(x86 or x86-64) and
avx2
将 16 位整数符号扩展为 64 位整数。 - _mm256_cvtepi32_epi64⚠(x86 or x86-64) and
avx2
将 32 位整数符号扩展为 64 位整数。 - _mm256_cvtepi32_pd⚠(x86 or x86-64) and
avx
将a
中的包装的 32 位整数转换为包装的双精度 (64-bit) 浮点元素。 - _mm256_cvtepi32_ps⚠(x86 or x86-64) and
avx
将a
中的包装的 32 位整数转换为包装的单精度 (32-bit) 浮点元素。 - _mm256_cvtepu8_epi16⚠(x86 or x86-64) and
avx2
将a
中的无符号 8 位整数零扩展为 16 位整数。 - _mm256_cvtepu8_epi32⚠(x86 or x86-64) and
avx2
将a
中的低八位无符号 8 位整数零扩展为 32 位整数。a
的前八个元素未使用。 - _mm256_cvtepu8_epi64⚠(x86 or x86-64) and
avx2
将a
中的低四位无符号 8 位整数零扩展到 64 位整数。a
的前十二个元素未使用。 - _mm256_cvtepu16_epi32⚠(x86 or x86-64) and
avx2
零将a
中的包装的无符号 16 位整数扩展为包装的 32 位整数,并将结果存储在dst
中。 - _mm256_cvtepu16_epi64⚠(x86 or x86-64) and
avx2
将a
中的低四位无符号 16 位整数零扩展到 64 位整数。a
的前四个元素未使用。 - _mm256_cvtepu32_epi64⚠(x86 or x86-64) and
avx2
将a
中的无符号 32 位整数零扩展为 64 位整数。 - _mm256_cvtpd_epi32⚠(x86 or x86-64) and
avx
将a
中的包装的双精度 (64-bit) 浮点元素转换为包装的 32 位整数。 - _mm256_cvtpd_ps⚠(x86 or x86-64) and
avx
将a
中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素。 - _mm256_cvtph_ps⚠(x86 or x86-64) and
f16c
将 128 位 vectora
中的 8 x 16 位半精度浮点值转换为存储在 256 位宽 vector 中的 8 x 32 位浮点值。 - _mm256_cvtps_epi32⚠(x86 or x86-64) and
avx
将a
中的包装的单精度 (32-bit) 浮点元素转换为包装的 32 位整数。 - _mm256_cvtps_pd⚠(x86 or x86-64) and
avx
将a
中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素。 - _mm256_cvtps_ph⚠(x86 or x86-64) and
f16c
将 256 位 vectora
中的 8 x 32 位浮点值转换为 8 x 16 位半精度浮点值存储在 128 位宽的 vector 中。 - _mm256_cvtsd_f64⚠(x86 or x86-64) and
avx2
返回[4 x double]
的输入 vector 的第一个元素。 - _mm256_cvtsi256_si32⚠(x86 or x86-64) and
avx2
返回[8 x i32]
的输入 vector 的第一个元素。 - _mm256_cvtss_f32⚠(x86 or x86-64) and
avx
返回[8 x float]
的输入 vector 的第一个元素。 - _mm256_cvttpd_epi32⚠(x86 or x86-64) and
avx
将a
中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数。 - _mm256_cvttps_epi32⚠(x86 or x86-64) and
avx
将a
中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数。 - _mm256_div_pd⚠(x86 or x86-64) and
avx
计算a
中的 4 个包装的 64 位浮点元素中的每一个除以b
中相应的封装元素的除法。 - _mm256_div_ps⚠(x86 or x86-64) and
avx
计算a
中的 8 个包装的 32 位浮点元素中的每一个除以b
中相应的封装元素的除法。 - _mm256_dp_ps⚠(x86 or x86-64) and
avx
使用imm8
的高 4 位有条件地将a
和b
中的包装的单精度 (32-bit) 浮点元素相乘,对四个乘积求和,并使用imm8
的低 4 位有条件地返回总和。 - _mm256_extract_epi8⚠(x86 or x86-64) and
avx2
- _mm256_extract_epi16⚠(x86 or x86-64) and
avx2
- _mm256_extract_epi32⚠(x86 or x86-64) and
avx2
从a
中提取一个 32 位整数,用INDEX
选择。 - _mm256_extract_epi64⚠
avx2
从a
中提取一个 64 位整数,用INDEX
选择。 - _mm256_extractf128_pd⚠(x86 or x86-64) and
avx
从a
提取 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成),并使用imm8
进行选择。 - _mm256_extractf128_ps⚠(x86 or x86-64) and
avx
从a
提取 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并用imm8
选择。 - _mm256_extractf128_si256⚠(x86 or x86-64) and
avx
从a
中提取 128 位 (由整数数据组成),并用imm8
选择。 - _mm256_extracti128_si256⚠(x86 or x86-64) and
avx2
从IMM1
选择的a
中提取 128 位 (整数数据)。 - _mm256_floor_pd⚠(x86 or x86-64) and
avx
将a
中的包装的双精度 (64-bit) 浮点元素四舍五入为负无穷大。 - _mm256_floor_ps⚠(x86 or x86-64) and
avx
将a
中的包装的单精度 (32-bit) 浮点元素四舍五入为负无穷大。 - _mm256_fmadd_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,并将中间结果与c
中的包装的元素相加。 - _mm256_fmadd_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装单精度 (32-bit) 浮点元素相乘,并将中间结果添加到c
中的包装元素中。 - _mm256_fmaddsub_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,或者在c
to/from 中将包装的元素相加或减去中间结果。 - _mm256_fmaddsub_ps⚠(x86 or x86-64) and
fma
将a
和b
中包装的单精度 (32-bit) 浮点元素相乘,或者将c
中包装的元素加/减到中间结果中。 - _mm256_fmsub_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,并从中间结果中减去c
中的包装的双精度元素。 - _mm256_fmsub_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装的单精度 (32-bit) 浮点元素相乘,并从中间结果中减去c
中的包装元素。 - _mm256_fmsubadd_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,也可以从中间结果中减去或加上c
中的包装元素。 - _mm256_fmsubadd_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装单精度 (32-bit) 浮点元素相乘,或者将c
中的包装元素从中间结果中减去或加上。 - _mm256_fnmadd_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装双精度 (64-bit) 浮点元素相乘,然后将取反的中间结果添加到c
中的包装元素中。 - _mm256_fnmadd_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装单精度 (32-bit) 浮点元素相乘,并将取反的中间结果添加到c
中的包装元素中。 - _mm256_fnmsub_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,并从取反的中间结果中减去c
中的包装的元素。 - _mm256_fnmsub_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装的单精度 (32-bit) 浮点元素相乘,并从取反的中间结果中减去c
中的包装的元素。 - _mm256_hadd_epi16⚠(x86 or x86-64) and
avx2
在a
和b
中水平添加相邻的 16 位整数对。 - _mm256_hadd_epi32⚠(x86 or x86-64) and
avx2
在a
和b
中水平添加相邻的 32 位整数对。 - _mm256_hadd_pd⚠(x86 or x86-64) and
avx
在 4 个 64 位浮点a
和b
的两个包装的 vectors 中水平相加相邻对。 结果,来自a
的元素之和在偶数位置返回,而来自b
的元素之和在奇数位置返回。 - _mm256_hadd_ps⚠(x86 or x86-64) and
avx
在 8 个 32 位浮点a
和b
的两个包装的 vectors 中水平相加相邻对。 结果,来自a
的元素之和返回到索引 0、1、4、5 的位置; 而b
中的元素总和是位置 - _mm256_hadds_epi16⚠(x86 or x86-64) and
avx2
使用饱和度在a
和b
中水平添加相邻的 16 位整数对。 - _mm256_hsub_epi16⚠(x86 or x86-64) and
avx2
水平减去a
和b
中相邻的 16 位整数对。 - _mm256_hsub_epi32⚠(x86 or x86-64) and
avx2
水平减去a
和b
中相邻的 32 位整数对。 - _mm256_hsub_pd⚠(x86 or x86-64) and
avx
在 4 个 64 位浮点a
和b
的两个包装的 vectors 中对相邻对进行水平减法。 结果,来自a
的元素之和在偶数位置返回,而来自b
的元素之和在奇数位置返回。 - _mm256_hsub_ps⚠(x86 or x86-64) and
avx
将 8 个 32 位浮点a
和b
的两个包装的 vectors 中的相邻对进行水平减法。 结果,来自a
的元素之和返回到索引 0、1、4、5 的位置; 而b
中的元素总和是位置 - _mm256_hsubs_epi16⚠(x86 or x86-64) and
avx2
使用饱和度水平减去a
和b
中相邻的 16 位整数对。 - _mm256_i32gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i32gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i32gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i32gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i64gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i64gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i64gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_i64gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm256_insert_epi8⚠(x86 or x86-64) and
avx
复制a
到结果,并在index
指定的位置将 8 位整数i
插入到结果中。 - _mm256_insert_epi16⚠(x86 or x86-64) and
avx
复制a
到结果,并在index
指定的位置将 16 位整数i
插入到 result 中。 - _mm256_insert_epi32⚠(x86 or x86-64) and
avx
复制a
到结果,然后在index
指定的位置将 32 位整数i
插入到结果中。 - 复制
a
到结果,然后在index
指定的位置将 64 位整数i
插入到 result 中。 - _mm256_insertf128_pd⚠(x86 or x86-64) and
avx
将a
复制到结果中,然后将b
中的 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 插入imm8
指定的位置的结果中。 - _mm256_insertf128_ps⚠(x86 or x86-64) and
avx
将a
复制到结果中,然后将b
中的 128 位 (由 4 个包装的单精度 (32-bit) 浮点元素组成) 插入imm8
指定的位置的结果中。 - _mm256_insertf128_si256⚠(x86 or x86-64) and
avx
复制a
到结果,然后将b
中的 128 位插入到imm8
指定的位置的结果中。 - _mm256_inserti128_si256⚠(x86 or x86-64) and
avx2
将a
复制到dst
,然后在IMM1
指定的位置插入来自b
的 128 位 (整数数据)。 - _mm256_lddqu_si256⚠(x86 or x86-64) and
avx
从未对齐的内存中将 256 位整数数据加载到结果中。 当数据越过高速缓存行边界时,此内部函数的性能可能比_mm256_loadu_si256
更好。 - _mm256_load_pd⚠(x86 or x86-64) and
avx
从内存中将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 加载到结果中。mem_addr
必须在 32 字节边界上对齐,否则可能会产生一个一般的保护异常。 - _mm256_load_ps⚠(x86 or x86-64) and
avx
从内存中将 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成) 加载到结果中。mem_addr
必须在 32 字节边界上对齐,否则可能会产生一个一般的保护异常。 - _mm256_load_si256⚠(x86 or x86-64) and
avx
从内存中将 256 位整数数据加载到结果中。mem_addr
必须在 32 字节边界上对齐,否则可能会产生一个一般的保护异常。 - _mm256_loadu2_m128⚠(x86 or x86-64) and
avx,sse
从内存中加载两个 128 位值 (由 4 个包装的单精度 (32-bit) 浮点元素组成),并将它们组合为 256 位值。 - _mm256_loadu2_m128d⚠(x86 or x86-64) and
avx,sse2
从内存中加载两个 128 位值 (由 2 个包装的双精度 (64-bit) 浮点元素组成),并将它们组合为 256 位值。 - _mm256_loadu2_m128i⚠(x86 or x86-64) and
avx,sse2
从内存中加载两个 128 位值 (由整数数据组成),并将它们组合为 256 位值。hiaddr
和loaddr
不需要在任何特定边界上对齐。 - _mm256_loadu_pd⚠(x86 or x86-64) and
avx
从内存中将 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 加载到结果中。mem_addr
不需要在任何特定边界上对齐。 - _mm256_loadu_ps⚠(x86 or x86-64) and
avx
从内存中将 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成) 加载到结果中。mem_addr
不需要在任何特定边界上对齐。 - _mm256_loadu_si256⚠(x86 or x86-64) and
avx
从内存中将 256 位整数数据加载到结果中。mem_addr
不需要在任何特定边界上对齐。 - _mm256_madd_epi16⚠(x86 or x86-64) and
avx2
将a
和b
中包装的带符号的 16 位整数相乘,产生中间的带符号的 32 位整数。 水平添加相邻的中间 32 位整数对。 - _mm256_maddubs_epi16⚠(x86 or x86-64) and
avx2
将a
中的每个无符号 8 位整数与b
中的相应带符号 8 位整数垂直相乘,生成中间带符号的 16 位整数。 水平相加相邻的中间带符号的 16 位整数对 - _mm256_mask_i32gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i32gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i32gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i32gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i64gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i64gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i64gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_mask_i64gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm256_maskload_epi32⚠(x86 or x86-64) and
avx2
使用mask
从mem_addr
指向的内存中加载包装的 32 位整数 (当未在相应元素中设置最高位时,元素清零)。 - _mm256_maskload_epi64⚠(x86 or x86-64) and
avx2
使用mask
从mem_addr
指向的内存中加载包装的 64 位整数 (当未在相应元素中设置最高位时,元素清零)。 - _mm256_maskload_pd⚠(x86 or x86-64) and
avx
使用mask
将包装的双精度 (64-bit) 浮点元素从内存加载到结果中 (当未设置相应元素的高位时,元素清零)。 - _mm256_maskload_ps⚠(x86 or x86-64) and
avx
使用mask
将包装的单精度 (32-bit) 浮点元素从内存加载到结果中 (当未设置相应元素的高位时,元素清零)。 - _mm256_maskstore_epi32⚠(x86 or x86-64) and
avx2
使用mask
将a
中的包装后的 32 位整数存储到mem_addr
指向的内存中 (当在相应元素中未设置最高位时,不存储元素)。 - _mm256_maskstore_epi64⚠(x86 or x86-64) and
avx2
使用mask
将a
中的包装 64 位整数存储到mem_addr
指向的内存中 (当未在相应元素中设置最高位时,不存储元素)。 - _mm256_maskstore_pd⚠(x86 or x86-64) and
avx
使用mask
将包装的双精度 (64-bit) 浮点元素从a
存储到内存中。 - _mm256_maskstore_ps⚠(x86 or x86-64) and
avx
使用mask
将包装的单精度 (32-bit) 浮点元素从a
存储到内存中。 - _mm256_max_epi8⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 8 位整数,并返回包装的最大值。 - _mm256_max_epi16⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 16 位整数,并返回包装的最大值。 - _mm256_max_epi32⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 32 位整数,并返回包装的最大值。 - _mm256_max_epu8⚠(x86 or x86-64) and
avx2
比较a
和b
中包装的无符号 8 位整数,并返回包装的最大值。 - _mm256_max_epu16⚠(x86 or x86-64) and
avx2
比较a
和b
中包装的无符号 16 位整数,并返回包装的最大值。 - _mm256_max_epu32⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的无符号 32 位整数,并返回包装的最大值。 - _mm256_max_pd⚠(x86 or x86-64) and
avx
比较a
和b
中的包装的双精度 (64-bit) 浮点元素,并返回包装的最大值 - _mm256_max_ps⚠(x86 or x86-64) and
avx
比较a
和b
中的包装的单精度 (32-bit) 浮点元素,并返回包装的最大值 - _mm256_min_epi8⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 8 位整数,并返回包装的最小值。 - _mm256_min_epi16⚠(x86 or x86-64) and
avx2
比较a
和b
中包装的 16 位整数,并返回包装的最小值。 - _mm256_min_epi32⚠(x86 or x86-64) and
avx2
比较a
和b
中的包装的 32 位整数,并返回包装的最小值。 - _mm256_min_epu8⚠(x86 or x86-64) and
avx2
比较a
和b
中包装的无符号 8 位整数,并返回包装的最小值。 - _mm256_min_epu16⚠(x86 or x86-64) and
avx2
比较a
和b
中包装的无符号 16 位整数,并返回包装的最小值。 - _mm256_min_epu32⚠(x86 or x86-64) and
avx2
比较a
和b
中包装的无符号 32 位整数,并返回包装的最小值。 - _mm256_min_pd⚠(x86 or x86-64) and
avx
比较a
和b
中的包装的双精度 (64-bit) 浮点元素,并返回包装的最小值 - _mm256_min_ps⚠(x86 or x86-64) and
avx
比较a
和b
中的包装的单精度 (32-bit) 浮点元素,并返回包装的最小值 - _mm256_movedup_pd⚠(x86 or x86-64) and
avx
从a
复制偶数索引的双精度 (64-bit) 浮点元素,并返回结果。 - _mm256_movehdup_ps⚠(x86 or x86-64) and
avx
从a
复制奇数索引的单精度 (32-bit) 浮点元素,并返回结果。 - _mm256_moveldup_ps⚠(x86 or x86-64) and
avx
从a
复制偶数索引的单精度 (32-bit) 浮点元素,并返回结果。 - _mm256_movemask_epi8⚠(x86 or x86-64) and
avx2
从a
中每个 8 位元素的最高有效位创建掩码,并返回结果。 - _mm256_movemask_pd⚠(x86 or x86-64) and
avx
根据a
中相应的包装的双精度 (64-bit) 浮点元素的最高有效位设置返回掩码的每一位。 - _mm256_movemask_ps⚠(x86 or x86-64) and
avx
基于a
中相应的包装单精度 (32-bit) 浮点元素的最高有效位来设置返回掩码的每一位。 - _mm256_mpsadbw_epu8⚠(x86 or x86-64) and
avx2
计算无符号四元组的绝对差之和 (SADs)a
中的 8 位整数与b
中的 8 位整数相比较,并将 16 位结果存储在 dst 中。 使用来自b
的一个四元组和来自a
的八个四元组,对每个 128 位 lane 执行八个 SAD。 从b
中指定的偏移量开始,从b
中选择一个四元组。 从a
中选择的有序 8 位整数开始的 8 个四元组,起始于imm8
中指定的偏移量。 - _mm256_mul_epi32⚠(x86 or x86-64) and
avx2
将a
和b
中每个包装的 64 位元素的低位 32 位整数相乘 - _mm256_mul_epu32⚠(x86 or x86-64) and
avx2
将a
和b
中每个包装的 64 位元素的低位无符号 32 位整数相乘 - _mm256_mul_pd⚠(x86 or x86-64) and
avx
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘。 - _mm256_mul_ps⚠(x86 or x86-64) and
avx
将a
和b
中的包装的单精度 (32-bit) 浮点元素相乘。 - _mm256_mulhi_epi16⚠(x86 or x86-64) and
avx2
将a
和b
中的包装的 16 位整数相乘,产生 32 位中间整数,并返回中间整数的高 16 位。 - _mm256_mulhi_epu16⚠(x86 or x86-64) and
avx2
将a
和b
中包装的无符号 16 位整数相乘,生成中间的 32 位整数,并返回中间整数的高 16 位。 - _mm256_mulhrs_epi16⚠(x86 or x86-64) and
avx2
将a
和b
中的包装的 16 位整数相乘,生成中间带符号的 32 位整数。 将每个中间整数截断为 18 个最高有效位,再加 1 取整,然后返回[16:1]
位。 - _mm256_mullo_epi16⚠(x86 or x86-64) and
avx2
将a
和b
中的包装的 16 位整数相乘,产生 32 位中间整数,并返回中间整数的低 16 位 - _mm256_mullo_epi32⚠(x86 or x86-64) and
avx2
将a
和b
中的包装的 32 位整数相乘,生成中间 64 位整数,并返回中间整数的低 32 位 - _mm256_or_pd⚠(x86 or x86-64) and
avx
计算a
和b
中按位或包装的双精度 (64-bit) 浮点元素。 - _mm256_or_ps⚠(x86 or x86-64) and
avx
计算a
和b
中按位或包装的单精度 (32-bit) 浮点元素。 - _mm256_or_si256⚠(x86 or x86-64) and
avx2
计算a
和b
中 256 位 (表示整数数据) 的按位或 - _mm256_packs_epi16⚠(x86 or x86-64) and
avx2
使用带符号的饱和度将包装的 16 位整数从a
和b
转换为包装的 8 位整数 - _mm256_packs_epi32⚠(x86 or x86-64) and
avx2
使用带符号的饱和度将包装的 32 位整数从a
和b
转换为包装的 16 位整数 - _mm256_packus_epi16⚠(x86 or x86-64) and
avx2
使用无符号饱和度将包装的 16 位整数从a
和b
转换为包装的 8 位整数 - _mm256_packus_epi32⚠(x86 or x86-64) and
avx2
使用无符号饱和度将包装的 32 位整数从a
和b
转换为包装的 16 位整数 - _mm256_permute2f128_pd⚠(x86 or x86-64) and
avx
混洗 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成),由imm8
从a
和b
中选择。 - _mm256_permute2f128_ps⚠(x86 or x86-64) and
avx
混洗 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成),由imm8
从a
和b
中选择。 - _mm256_permute2f128_si256⚠(x86 or x86-64) and
avx
重排imm8
从a
和b
选择的 128 位 (由整数数据组成)。 - _mm256_permute2x128_si256⚠(x86 or x86-64) and
avx2
打乱由imm8
从a
和b
选择的 128 位整数数据。 - _mm256_permute4x64_epi64⚠(x86 or x86-64) and
avx2
使用控制掩码imm8
从a
置换 64 位整数。 - _mm256_permute4x64_pd⚠(x86 or x86-64) and
avx2
使用imm8
中的控件对a
中的 64 位浮点元素进行打乱。 - _mm256_permute_pd⚠(x86 or x86-64) and
avx
使用imm8
中的控件在 128 位 lanes 内对a
中的双精度 (64-bit) 浮点元素进行混洗。 - _mm256_permute_ps⚠(x86 or x86-64) and
avx
使用imm8
中的控件在 128 位 lanes 内对a
中的单精度 (32-bit) 浮点元素进行混洗。 - _mm256_permutevar8x32_epi32⚠(x86 or x86-64) and
avx2
根据b
的内容,对a
的 32 位整数进行包装的排列。 - _mm256_permutevar8x32_ps⚠(x86 or x86-64) and
avx2
使用idx
中相应的 32 位整数索引跨 lanes 打乱a
中的八个 32 位浮点元素。 - _mm256_permutevar_pd⚠(x86 or x86-64) and
avx
使用b
中的控件在 256 位 lanes 内对a
中的双精度 (64-bit) 浮点元素进行混洗。 - _mm256_permutevar_ps⚠(x86 or x86-64) and
avx
使用b
中的控件在 128 位 lanes 内对a
中的单精度 (32-bit) 浮点元素进行混洗。 - _mm256_rcp_ps⚠(x86 or x86-64) and
avx
计算a
中包装的单精度 (32-bit) 浮点元素的近似倒数,并返回结果。 该近似值的最大相对误差小于 1.5*2^-12。 - _mm256_round_pd⚠(x86 or x86-64) and
avx
根据ROUNDING
标志对a
中的双精度 (64-bit) 浮点包装的 (64-bit) 浮点元素进行舍入。ROUNDING
的值可能如下: - _mm256_round_ps⚠(x86 or x86-64) and
avx
根据标志ROUNDING
对a
中的单精度 (32-bit) 浮点包装元素进行舍入。ROUNDING
的值可能如下: - _mm256_rsqrt_ps⚠(x86 or x86-64) and
avx
计算a
中包装的单精度 (32-bit) 浮点元素的近似倒数平方根,并返回结果。 - _mm256_sad_epu8⚠(x86 or x86-64) and
avx2
计算a
和b
中包装的无符号 8 位整数的绝对差,然后将每个连续的 8 个差水平求和,产生四个无符号的 16 位整数,并将这些无符号的 16 位整数包装在 64 位返回值的低 16 位中 - _mm256_set1_epi8⚠(x86 or x86-64) and
avx
向返回的 vector 的所有元素广播 8 位整数a
。 此内部函数可能会生成vpbroadcastb
。 - _mm256_set1_epi16⚠(x86 or x86-64) and
avx
将 16 位整数a
广播到返回的 vector 的所有元素。 此内部函数可能会生成vpbroadcastw
。 - _mm256_set1_epi32⚠(x86 or x86-64) and
avx
向返回的 vector 的所有元素广播 32 位整数a
。 此内部函数可能会生成vpbroadcastd
。 - _mm256_set1_epi64x⚠(x86 or x86-64) and
avx
向返回的 vector 的所有元素广播 64 位整数a
。 此内部函数可能会生成vpbroadcastq
。 - _mm256_set1_pd⚠(x86 or x86-64) and
avx
向返回的 vector 的所有元素广播双精度 (64-bit) 浮点值a
。 - _mm256_set1_ps⚠(x86 or x86-64) and
avx
向返回的 vector 的所有元素广播单精度 (32-bit) 浮点值a
。 - _mm256_set_epi8⚠(x86 or x86-64) and
avx
使用提供的值在返回的 vector 中设置包装的 8 位整数。 - _mm256_set_epi16⚠(x86 or x86-64) and
avx
使用提供的值在返回的 vector 中设置包装的 16 位整数。 - _mm256_set_epi32⚠(x86 or x86-64) and
avx
使用提供的值在返回的 vector 中设置包装的 32 位整数。 - _mm256_set_epi64x⚠(x86 or x86-64) and
avx
使用提供的值在返回的 vector 中设置包装的 64 位整数。 - _mm256_set_m128⚠(x86 or x86-64) and
avx
设置包装的 __m256 返回的 vector 与提供的值。 - _mm256_set_m128d⚠(x86 or x86-64) and
avx
设置包装的 __m256d 返回的 vector 具有提供的值。 - _mm256_set_m128i⚠(x86 or x86-64) and
avx
包装的 __m256i 集合使用提供的值返回 vector。 - _mm256_set_pd⚠(x86 or x86-64) and
avx
使用提供的值在返回的 vector 中设置包装的双精度 (64-bit) 浮点元素。 - _mm256_set_ps⚠(x86 or x86-64) and
avx
使用提供的值在返回的 vector 中设置包装的单精度 (32-bit) 浮点元素。 - _mm256_setr_epi8⚠(x86 or x86-64) and
avx
在返回的 vector 中设置包装的 8 位整数,并以相反的顺序提供所提供的值。 - _mm256_setr_epi16⚠(x86 or x86-64) and
avx
在返回的 vector 中设置包装的 16 位整数,其提供的值的顺序相反。 - _mm256_setr_epi32⚠(x86 or x86-64) and
avx
在返回的 vector 中设置包装的 32 位整数,并以相反的顺序提供所提供的值。 - _mm256_setr_epi64x⚠(x86 or x86-64) and
avx
在返回的 vector 中设置包装的 64 位整数,其提供的值的顺序相反。 - _mm256_setr_m128⚠(x86 or x86-64) and
avx
设置包装的 __m256 返回的 vector 与提供的值。 - _mm256_setr_m128d⚠(x86 or x86-64) and
avx
设置包装的 __m256d 返回的 vector 具有提供的值。 - _mm256_setr_m128i⚠(x86 or x86-64) and
avx
包装的 __m256i 集合使用提供的值返回 vector。 - _mm256_setr_pd⚠(x86 or x86-64) and
avx
在返回的 vector 中使用反向提供的值设置包装的双精度 (64-bit) 浮点元素。 - _mm256_setr_ps⚠(x86 or x86-64) and
avx
在返回的 vector 中使用反向提供的值设置包装的单精度 (32-bit) 浮点元素。 - _mm256_setzero_pd⚠(x86 or x86-64) and
avx
返回 __m256d 类型的 vector,所有元素均设置为零。 - _mm256_setzero_ps⚠(x86 or x86-64) and
avx
返回 __m256 类型的 vector,所有元素都设置为零。 - _mm256_setzero_si256⚠(x86 or x86-64) and
avx
返回类型为 __m256i 的 vector,所有元素均设置为零。 - _mm256_shuffle_epi8⚠(x86 or x86-64) and
avx2
根据b
的内容,打乱a
中的字节。 - _mm256_shuffle_epi32⚠(x86 or x86-64) and
avx2
使用imm8
中的控件,在a
的 128 位 lanes 中打乱 32 位整数。 - _mm256_shuffle_pd⚠(x86 or x86-64) and
avx
使用imm8
中的控件对 128 位 lanes 中的双精度 (64-bit) 浮点元素进行混洗。 - _mm256_shuffle_ps⚠(x86 or x86-64) and
avx
将a
中的单精度 (32-bit) 浮点元素改组为 使用imm8
中的控件的 128 位 lanes。 - _mm256_shufflehi_epi16⚠(x86 or x86-64) and
avx2
使用imm8
中的控件,在a
的 128 位 lanes 的高 64 位中打乱 16 位整数。a
的 128 位 lanes 的低 64 位被复制到输出中。 - _mm256_shufflelo_epi16⚠(x86 or x86-64) and
avx2
使用imm8
中的控件在a
的 128 位 lanes 的低 64 位中打乱 16 位整数。a
的 128 位 lanes 的高 64 位被复制到输出中。 - _mm256_sign_epi8⚠(x86 or x86-64) and
avx2
当相应的带符号时,将a
中的包装的 8 位整数取反b
中的 8 位整数为负,并返回结果。 当b
中的相应元素为零时,结果归零。 - _mm256_sign_epi16⚠(x86 or x86-64) and
avx2
当相应的带符号时,将a
中的 16 位整数包装为无效b
中的 16 位整数为负,并返回结果。 当b
中的相应元素为零时,结果归零。 - _mm256_sign_epi32⚠(x86 or x86-64) and
avx2
当相应的带符号时,将a
中的包装的 32 位整数取反b
中的 32 位整数为负,并返回结果。 当b
中的相应元素为零时,结果归零。 - _mm256_sll_epi16⚠(x86 or x86-64) and
avx2
将count
左移的a
中的包装的 16 位整数移位,同时移零,并返回结果 - _mm256_sll_epi32⚠(x86 or x86-64) and
avx2
将count
左移的a
中的包装的 32 位整数移位,同时移零,并返回结果 - _mm256_sll_epi64⚠(x86 or x86-64) and
avx2
将count
左移的a
中的包装的 64 位整数移位,同时移零,并返回结果 - _mm256_slli_epi16⚠(x86 or x86-64) and
avx2
将a
中包装的 16 位整数在IMM8
左移同时移零,返回结果; - _mm256_slli_epi32⚠(x86 or x86-64) and
avx2
将a
中的包装的 32 位整数在IMM8
左移同时移零,返回结果; - _mm256_slli_epi64⚠(x86 or x86-64) and
avx2
将a
中的包装的 64 位整数在IMM8
左移同时移零,返回结果; - _mm256_slli_si256⚠(x86 or x86-64) and
avx2
将a
中的 128 位 lanes 向左移imm8
字节,同时向零移位。 - _mm256_sllv_epi32⚠(x86 or x86-64) and
avx2
将a
中的包装的 32 位整数左移count
中相应元素所指定的数量,同时将零移位,并返回结果。 - _mm256_sllv_epi64⚠(x86 or x86-64) and
avx2
将a
中的包装的 64 位整数左移count
中相应元素所指定的数量,同时将零移位,并返回结果。 - _mm256_sqrt_pd⚠(x86 or x86-64) and
avx
返回a
中包装的双精度 (64-bit) 浮点元素的平方根。 - _mm256_sqrt_ps⚠(x86 or x86-64) and
avx
返回a
中包装的单精度 (32-bit) 浮点元素的平方根。 - _mm256_sra_epi16⚠(x86 or x86-64) and
avx2
将符号位移入时,将a
中的包装的 16 位整数右移count
。 - _mm256_sra_epi32⚠(x86 or x86-64) and
avx2
将符号位移位时,将a
中的包装的 32 位整数右移count
。 - _mm256_srai_epi16⚠(x86 or x86-64) and
avx2
将a
中包装的 16 位整数右移IMM8
,同时移入符号位。 - _mm256_srai_epi32⚠(x86 or x86-64) and
avx2
将a
中包装的 32 位整数右移IMM8
,同时移入符号位。 - _mm256_srav_epi32⚠(x86 or x86-64) and
avx2
将a
中的 32 位整数向右移动,移动量由count
中的相应元素指定,同时移入符号位。 - _mm256_srl_epi16⚠(x86 or x86-64) and
avx2
将a
中的包装的 16 位整数右移count
,同时将零移位。 - _mm256_srl_epi32⚠(x86 or x86-64) and
avx2
将a
中的包装的 32 位整数右移count
,同时将零移位。 - _mm256_srl_epi64⚠(x86 or x86-64) and
avx2
将a
中的包装的 64 位整数右移count
,同时将零移位。 - _mm256_srli_epi16⚠(x86 or x86-64) and
avx2
将a
中包装的 16 位整数右移IMM8
,同时将其移入零 - _mm256_srli_epi32⚠(x86 or x86-64) and
avx2
将a
中包装的 32 位整数右移IMM8
,同时将其移入零 - _mm256_srli_epi64⚠(x86 or x86-64) and
avx2
将a
中包装的 64 位整数右移IMM8
,同时将其移入零 - _mm256_srli_si256⚠(x86 or x86-64) and
avx2
将a
中的 128 位 lanes 右移imm8
字节,同时将其移位为零。 - _mm256_srlv_epi32⚠(x86 or x86-64) and
avx2
将a
中的包装的 32 位整数右移count
中相应元素所指定的数量,同时将零移位, - _mm256_srlv_epi64⚠(x86 or x86-64) and
avx2
将a
中的包装的 64 位整数右移count
中相应元素所指定的数量,同时将零移位, - _mm256_store_pd⚠(x86 or x86-64) and
avx
将来自a
的 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr
必须在 32 字节边界上对齐,否则可能会产生一个一般的保护异常。 - _mm256_store_ps⚠(x86 or x86-64) and
avx
将来自a
的 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成) 存储到内存中。mem_addr
必须在 32 字节边界上对齐,否则可能会产生一个一般的保护异常。 - _mm256_store_si256⚠(x86 or x86-64) and
avx
将来自a
的 256 位整数数据存储到内存中。mem_addr
必须在 32 字节边界上对齐,否则可能会产生一个一般的保护异常。 - _mm256_storeu2_m128⚠(x86 or x86-64) and
avx,sse
将来自a
的高和低 128 位半部分 (每个半部分由 4 个包装的单精度 (32-bit) 浮点元素组成) 存储到内存中两个不同的 128 位位置。 - _mm256_storeu2_m128d⚠(x86 or x86-64) and
avx,sse2
将来自a
的高和低 128 位半部分 (每个半部分由 2 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中两个不同的 128 位位置。 - _mm256_storeu2_m128i⚠(x86 or x86-64) and
avx,sse2
将来自a
的高 128 位和低 128 位 (分别由整数数据组成) 存储到内存中两个不同的 128 位位置。 - _mm256_storeu_pd⚠(x86 or x86-64) and
avx
将来自a
的 256 位 (由 4 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr
不需要在任何特定边界上对齐。 - _mm256_storeu_ps⚠(x86 or x86-64) and
avx
将来自a
的 256 位 (由 8 个包装的单精度 (32-bit) 浮点元素组成) 存储到内存中。mem_addr
不需要在任何特定边界上对齐。 - _mm256_storeu_si256⚠(x86 or x86-64) and
avx
将来自a
的 256 位整数数据存储到内存中。mem_addr
不需要在任何特定边界上对齐。 - _mm256_stream_pd⚠(x86 or x86-64) and
avx
将双精度值从[4 x double]
的 256 位 vector 移动到 32 字节对齐的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用)。 - _mm256_stream_ps⚠(x86 or x86-64) and
avx
将单精度浮点值从[8 x float]
的 256 位 vector 移到 32 字节对齐的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用)。 - _mm256_stream_si256⚠(x86 or x86-64) and
avx
将整数数据从 256 位整数 vector 移动到 32 字节对齐的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用) - _mm256_sub_epi8⚠(x86 or x86-64) and
avx2
从a
中的包装的 8 位整数中减去b
中的包装的 8 位整数 - _mm256_sub_epi16⚠(x86 or x86-64) and
avx2
从a
中的包装的 16 位整数减去b
中的包装的 16 位整数 - _mm256_sub_epi32⚠(x86 or x86-64) and
avx2
从a
中的包装的 32 位整数减去b
中的包装的 32 位整数 - _mm256_sub_epi64⚠(x86 or x86-64) and
avx2
从a
中的包装的 64 位整数减去b
中的包装的 64 位整数 - _mm256_sub_pd⚠(x86 or x86-64) and
avx
从a
中的包装的元素中减去b
中的包装后的双精度 (64-bit) 浮点元素。 - _mm256_sub_ps⚠(x86 or x86-64) and
avx
从a
中的包装元素中减去b
中的包装的单精度 (32-bit) 浮点元素。 - _mm256_subs_epi8⚠(x86 or x86-64) and
avx2
使用饱和度从a
的包装的 8 位整数减去b
的包装的 8 位整数。 - _mm256_subs_epi16⚠(x86 or x86-64) and
avx2
使用饱和度从a
的包装的 16 位整数减去b
的包装的 16 位整数。 - _mm256_subs_epu8⚠(x86 or x86-64) and
avx2
使用饱和度从a
的包装的 8 位整数减去b
的包装的无符号 8 位整数。 - _mm256_subs_epu16⚠(x86 or x86-64) and
avx2
使用饱和度从a
的包装的 16 位整数减去b
的包装的无符号 16 位整数。 - _mm256_testc_pd⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示双精度 (64-bit) 浮点元素) 的按位与,产生一个 256 位中间值,如果中间值中每个 64 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 计算a
的按位非,然后与b
与,产生一个中间值,如果中间值中每个 64 位元素的符号位为零,则将CF
设置为 1,否则将CF
设置为 0. 返回CF
值。 - _mm256_testc_ps⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示单精度 (32-bit) 浮点元素) 的按位与,产生一个 256 位中间值,如果中间值中每个 32 位元素的符号位都置ZF
为 1 为零,否则将ZF
设置为 0. 对a
进行按位非运算,然后与b
进行与运算,得到一个中间值,如果中间值中每个 32 位元素的符号位都为零,则将CF
设置为 1,否则将CF
设置为 0. 返回CF
值。 - _mm256_testc_si256⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示整数数据) 的按位与,如果结果为零则将ZF
设置为 1,否则将ZF
设置为 0. - _mm256_testnzc_pd⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示双精度 (64-bit) 浮点元素) 的按位与,产生一个 256 位中间值,如果中间值中每个 64 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 计算a
的按位非,然后与b
与,产生一个中间值,如果中间值中每个 64 位元素的符号位为零,则将CF
设置为 1,否则将CF
设置为 0. 如果ZF
和CF
的值都为零则返回 1,否则返回 0. - _mm256_testnzc_ps⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示单精度 (32-bit) 浮点元素) 的按位与,产生一个 256 位中间值,如果中间值中每个 32 位元素的符号位都置ZF
为 1 为零,否则将ZF
设置为 0. 对a
进行按位非运算,然后与b
进行与运算,得到一个中间值,如果中间值中每个 32 位元素的符号位都为零,则将CF
设置为 1,否则将CF
设置为 0. 如果ZF
和CF
的值都为零则返回 1,否则返回 0. - _mm256_testnzc_si256⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示整数数据) 的按位与,如果结果为零则将ZF
设置为 1,否则将ZF
设置为 0. - _mm256_testz_pd⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示双精度 (64-bit) 浮点元素) 的按位与,产生一个 256 位中间值,如果中间值中每个 64 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 计算a
的按位非,然后与b
与,产生一个中间值,如果中间值中每个 64 位元素的符号位为零,则将CF
设置为 1,否则将CF
设置为 0. 返回ZF
值。 - _mm256_testz_ps⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示单精度 (32-bit) 浮点元素) 的按位与,产生一个 256 位中间值,如果中间值中每个 32 位元素的符号位都置ZF
为 1 为零,否则将ZF
设置为 0. 对a
进行按位非运算,然后与b
进行与运算,得到一个中间值,如果中间值中每个 32 位元素的符号位都为零,则将CF
设置为 1,否则将CF
设置为 0. 返回ZF
值。 - _mm256_testz_si256⚠(x86 or x86-64) and
avx
计算a
和b
中 256 位 (表示整数数据) 的按位与,如果结果为零则将ZF
设置为 1,否则将ZF
设置为 0. - _mm256_undefined_pd⚠(x86 or x86-64) and
avx
返回具有不确定元素的__m256d
类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - _mm256_undefined_ps⚠(x86 or x86-64) and
avx
返回具有不确定元素的__m256
类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - _mm256_undefined_si256⚠(x86 or x86-64) and
avx
返回具有不确定元素的 __m256i 类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - _mm256_unpackhi_epi8⚠(x86 or x86-64) and
avx2
从每个高位的一半拆包并交织 8 位整数a
和b
中的 128 位 lane。 - _mm256_unpackhi_epi16⚠(x86 or x86-64) and
avx2
从每个高位的一半拆包并交织 16 位整数a
和b
的 128 位 lane - _mm256_unpackhi_epi32⚠(x86 or x86-64) and
avx2
从每个高位的一半拆包并交织 32 位整数a
和b
的 128 位 lane - _mm256_unpackhi_epi64⚠(x86 or x86-64) and
avx2
从每个高位的一半拆包并交织 64 位整数a
和b
的 128 位 lane - _mm256_unpackhi_pd⚠(x86 or x86-64) and
avx
从a
和b
中每个 128 位 lane 的上半部分解包并交织双精度 (64-bit) 浮点元素。 - _mm256_unpackhi_ps⚠(x86 or x86-64) and
avx
从a
和b
中每个 128 位 lane 的高半部分解包并交织单精度 (32-bit) 浮点元素。 - _mm256_unpacklo_epi8⚠(x86 or x86-64) and
avx2
从每个低位拆包并交织 8 位整数a
和b
的 128 位 lane - _mm256_unpacklo_epi16⚠(x86 or x86-64) and
avx2
从每个低位拆包并交织 16 位整数a
和b
的 128 位 lane - _mm256_unpacklo_epi32⚠(x86 or x86-64) and
avx2
从每个低位拆包并交织 32 位整数a
和b
的 128 位 lane - _mm256_unpacklo_epi64⚠(x86 or x86-64) and
avx2
从每个字节的下半部分拆包并交织 64 位整数a
和b
的 128 位 lane - _mm256_unpacklo_pd⚠(x86 or x86-64) and
avx
从a
和b
中每个 128 位 lane 的下半部分解包并交织双精度 (64-bit) 浮点元素。 - _mm256_unpacklo_ps⚠(x86 or x86-64) and
avx
从a
和b
中每个 128 位 lanes 的下半部分解包并交织单精度 (32-bit) 浮点元素。 - _mm256_xor_pd⚠(x86 or x86-64) and
avx
计算a
和b
中包装的双精度 (64-bit) 浮点元素的按位 XOR。 - _mm256_xor_ps⚠(x86 or x86-64) and
avx
计算a
和b
中包装的单精度 (32-bit) 浮点元素的按位 XOR。 - _mm256_xor_si256⚠(x86 or x86-64) and
avx2
计算a
和b
中 256 位 (表示整数数据) 的按位 XOR - _mm256_zeroall⚠(x86 or x86-64) and
avx
将所有 XMM 或 YMM 寄存器的内容清零。 - _mm256_zeroupper⚠(x86 or x86-64) and
avx
将所有 YMM 寄存器的高 128 位清零; 寄存器的低 128 位保持不变。 - _mm256_zextpd128_pd256⚠(x86 or x86-64) and
avx,sse2
从 a 创建一个[4 x double]
的 256 位浮点 vector[2 x double]
的 128 位浮点 vector。低 128 位包含源 vector 的值。 高 128 位设置为零。 - _mm256_zextps128_ps256⚠(x86 or x86-64) and
avx,sse
从 a 创建一个[8 x float]
的 256 位浮点 vector[4 x float]
的 128 位浮点 vector。低 128 位包含源 vector 的值。 高 128 位设置为零。 - _mm256_zextsi128_si256⚠(x86 or x86-64) and
avx,sse2
从 128 位整数 vector 创建一个 256 位整数 vector。 低 128 位包含源 vector 的值。上层 128 位设置为零。 - _mm512_storeu_ps⚠(x86 or x86-64) and
avx512f
将来自a
的 512 位 (由 16 个包装的单精度 (32-bit) 浮点元素组成) 存储到内存中。mem_addr
不需要在任何特定边界上对齐。 - _mm_abs_epi8⚠(x86 or x86-64) and
ssse3
计算a
中包装的 8 位带符号整数的绝对值,并返回无符号结果。 - _mm_abs_epi16⚠(x86 or x86-64) and
ssse3
计算a
中每个包装的 16 位有符号整数的绝对值,并返回 16 位无符号整数 - _mm_abs_epi32⚠(x86 or x86-64) and
ssse3
计算a
中每个包装的 32 位有符号整数的绝对值,并返回 32 位无符号整数 - _mm_add_epi8⚠(x86 or x86-64) and
sse2
在a
和b
中添加包装的 8 位整数。 - _mm_add_epi16⚠(x86 or x86-64) and
sse2
在a
和b
中添加包装的 16 位整数。 - _mm_add_epi32⚠(x86 or x86-64) and
sse2
在a
和b
中添加包装的 32 位整数。 - _mm_add_epi64⚠(x86 or x86-64) and
sse2
在a
和b
中添加包装的 64 位整数。 - _mm_add_pd⚠(x86 or x86-64) and
sse2
在a
和b
中添加包装的双精度 (64-bit) 浮点元素。 - _mm_add_ps⚠(x86 or x86-64) and
sse
添加 __m128 vectors。 - _mm_add_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素替换为a
和b
的低位元素之和。 - _mm_add_ss⚠(x86 or x86-64) and
sse
添加a
和b
的第一个组件,其他组件从a
复制。 - _mm_adds_epi8⚠(x86 or x86-64) and
sse2
使用饱和度在a
和b
中添加包装的 8 位整数。 - _mm_adds_epi16⚠(x86 or x86-64) and
sse2
使用饱和度在a
和b
中添加包装的 16 位整数。 - _mm_adds_epu8⚠(x86 or x86-64) and
sse2
使用饱和度在a
和b
中添加包装的无符号 8 位整数。 - _mm_adds_epu16⚠(x86 or x86-64) and
sse2
使用饱和度在a
和b
中添加包装的无符号 16 位整数。 - _mm_addsub_pd⚠(x86 or x86-64) and
sse3
或者,在a
中的包装的双精度 (64-bit) 浮点元素中加减b
中的 to/from 包装的元素。 - _mm_addsub_ps⚠(x86 or x86-64) and
sse3
或者,在a
中的包装的单精度 (32-bit) 浮点元素上加减b
中的包装的元素 to/from。 - _mm_aesdec_si128⚠(x86 or x86-64) and
aes
对a
中的数据 (state) 执行一轮 AES 解密流程。 - _mm_aesdeclast_si128⚠(x86 or x86-64) and
aes
对a
中的数据 (state) 执行 AES 解密流的最后一轮。 - _mm_aesenc_si128⚠(x86 or x86-64) and
aes
对a
中的数据 (state) 执行一轮 AES 加密流程。 - _mm_aesenclast_si128⚠(x86 or x86-64) and
aes
对a
中的数据 (state) 执行最后一轮 AES 加密流程。 - _mm_aesimc_si128⚠(x86 or x86-64) and
aes
在a
上执行InvMixColumns
转换。 - _mm_aeskeygenassist_si128⚠(x86 or x86-64) and
aes
协助扩展 AES 密钥。 - _mm_alignr_epi8⚠(x86 or x86-64) and
ssse3
将a
和b
中的 16 字节块连接成一个 32 字节的临时结果,将结果右移n
字节,然后返回低 16 字节。 - _mm_and_pd⚠(x86 or x86-64) and
sse2
计算a
和b
中包装的双精度 (64-bit) 浮点元素的按位与。 - _mm_and_ps⚠(x86 or x86-64) and
sse
包装的单精度 (32-bit) 浮点元素的按位与。 - _mm_and_si128⚠(x86 or x86-64) and
sse2
计算a
和b
中 128 位 (表示整数数据) 的按位与。 - _mm_andnot_pd⚠(x86 or x86-64) and
sse2
计算a
的按位 NOT,然后计算b
的 AND。 - _mm_andnot_ps⚠(x86 or x86-64) and
sse
包装的单精度 (32-bit) 浮点元素的按位与非运算。 - _mm_andnot_si128⚠(x86 or x86-64) and
sse2
计算a
中 128 位 (代表整数数据) 的按位非,然后计算b
的与。 - _mm_avg_epu8⚠(x86 or x86-64) and
sse2
a
和b
中的包装无符号 8 位整数的平均值。 - _mm_avg_epu16⚠(x86 or x86-64) and
sse2
a
和b
中的包装无符号 16 位整数的平均值。 - _mm_blend_epi16⚠(x86 or x86-64) and
sse4.1
使用掩码IMM8
混合来自a
和b
的 16 位整数包装。 - _mm_blend_epi32⚠(x86 or x86-64) and
avx2
使用控制掩码IMM4
混合来自a
和b
的包装的 32 位整数。 - _mm_blend_pd⚠(x86 or x86-64) and
sse4.1
使用控制掩码IMM2
从a
和b
混合包装的双精度 (64-bit) 浮点元素 - _mm_blend_ps⚠(x86 or x86-64) and
sse4.1
使用掩码IMM4
从a
和b
混合包装的单精度 (32-bit) 浮点元素 - _mm_blendv_epi8⚠(x86 or x86-64) and
sse4.1
使用mask
混合a
和b
中的包装 8 位整数 - _mm_blendv_pd⚠(x86 or x86-64) and
sse4.1
使用mask
混合来自a
和b
的包装的双精度 (64-bit) 浮点元素 - _mm_blendv_ps⚠(x86 or x86-64) and
sse4.1
使用mask
混合来自a
和b
的包装的单精度 (32-bit) 浮点元素 - _mm_broadcast_ss⚠(x86 or x86-64) and
avx
从内存向返回的 vector 的所有元素广播单精度 (32-bit) 浮点元素。 - _mm_broadcastb_epi8⚠(x86 or x86-64) and
avx2
将a
的低位包装 8 位整数广播到 128 位返回值的所有元素。 - _mm_broadcastd_epi32⚠(x86 or x86-64) and
avx2
将a
的低位包装 32 位整数广播到 128 位返回值的所有元素。 - _mm_broadcastq_epi64⚠(x86 or x86-64) and
avx2
将a
的低位包装 64 位整数广播到 128 位返回值的所有元素。 - _mm_broadcastsd_pd⚠(x86 or x86-64) and
avx2
将低双精度 (64-bit) 浮点元素从a
广播到 128 位返回值的所有元素。 - _mm_broadcastss_ps⚠(x86 or x86-64) and
avx2
将低单精度 (32-bit) 浮点元素从a
广播到 128 位返回值的所有元素。 - _mm_broadcastw_epi16⚠(x86 or x86-64) and
avx2
将低包装的 16 位整数从 a 广播到 128 位返回值的所有元素 - _mm_bslli_si128⚠(x86 or x86-64) and
sse2
将a
左移IMM8
个字节,同时移入零。 - _mm_bsrli_si128⚠(x86 or x86-64) and
sse2
将a
右移IMM8
个字节,同时移入零。 - _mm_castpd_ps⚠(x86 or x86-64) and
sse2
将[2 x double]
的 128 位浮点 vector 转换为[4 x float]
的 128 位浮点 vector。 - _mm_castpd_si128⚠(x86 or x86-64) and
sse2
将[2 x double]
的 128 位浮点 vector 转换为 128 位整数 vector。 - _mm_castps_pd⚠(x86 or x86-64) and
sse2
将[4 x float]
的 128 位浮点 vector 转换为[2 x double]
的 128 位浮点 vector。 - _mm_castps_si128⚠(x86 or x86-64) and
sse2
将[4 x float]
的 128 位浮点 vector 转换为 128 位整数 vector。 - _mm_castsi128_pd⚠(x86 or x86-64) and
sse2
将 128 位整数 vector 转换为[2 x double]
的 128 位浮点 vector。 - _mm_castsi128_ps⚠(x86 or x86-64) and
sse2
将 128 位整数 vector 转换为[4 x float]
的 128 位浮点 vector。 - _mm_ceil_pd⚠(x86 or x86-64) and
sse4.1
将a
中的包装的双精度 (64-bit) 浮点元素四舍五入为整数,并将结果存储为包装的双精度浮点元素。 - _mm_ceil_ps⚠(x86 or x86-64) and
sse4.1
将a
中的包装的单精度 (32-bit) 浮点元素四舍五入为整数,并将结果存储为包装的单精度浮点元素。 - _mm_ceil_sd⚠(x86 or x86-64) and
sse4.1
将b
中的低位双精度 (64-bit) 浮点型元素四舍五入为整数,将结果作为双精度浮点型元素存入内部函数结果的低位元素,并将a
中的高位元素复制到内部函数结果的上部元素。 - _mm_ceil_ss⚠(x86 or x86-64) and
sse4.1
将b
中的下部单精度 (32-bit) 浮点元素四舍五入为整数,将结果作为单精度浮点元素存储在内部结果的下部元素中,并将高 3 个包装的元素从a
复制到内在结果的上层要素。 - _mm_clflush⚠(x86 or x86-64) and
sse2
使高速缓存层次结构中所有级别的包含p
的高速缓存行失效并刷新。 - _mm_clmulepi64_si128⚠(x86 or x86-64) and
pclmulqdq
在有限域 GF(2^k) 上执行两个 64 位多项式的无进位乘法。 - _mm_cmp_pd⚠(x86 or x86-64) and
avx,sse2
根据IMM5
指定的比较操作数比较a
和b
中包装的双精度 (64-bit) 浮点元素。 - _mm_cmp_ps⚠(x86 or x86-64) and
avx,sse
根据IMM5
指定的比较操作数比较a
和b
中包装的单精度 (32-bit) 浮点元素。 - _mm_cmp_sd⚠(x86 or x86-64) and
avx,sse2
根据IMM5
指定的比较操作数,比较a
和b
中的低位双精度浮点元素 (64-bit),将结果存入返回的 vector 的低位元素,并将a
的高位元素复制到返回的 vector 的高位元素。 - _mm_cmp_ss⚠(x86 or x86-64) and
avx,sse
根据IMM5
指定的比较操作数比较a
和b
中的低位单精度 (32-bit) 浮点元素,将结果存储在返回的 vector 的低位元素中,并将高 3 个包装的元素从a
复制到返回 vector。 - _mm_cmpeq_epi8⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装 8 位整数是否相等。 - _mm_cmpeq_epi16⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 16 位整数是否相等。 - _mm_cmpeq_epi32⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装 32 位整数是否相等。 - _mm_cmpeq_epi64⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装 64 位整数是否相等 - _mm_cmpeq_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的相应元素是否相等。 - _mm_cmpeq_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果输入元素相等,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpeq_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素的相等比较取代。 - _mm_cmpeq_ss⚠(x86 or x86-64) and
sse
比较两个输入中的最低f32
是否相等。 如果两个输入相等,结果的最低 32 位将为0xffffffff
,否则为0
。 结果的高 96 位是a
的高 96 位。 - _mm_cmpestra⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将a
和b
中的包装字符串与长度la
和lb
进行比较,如果b
不包含空字符且结果掩码为零,则返回1
,否则返回0
。 - _mm_cmpestrc⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将a
和b
中的包装字符串与长度la
和lb
进行比较,如果结果掩码非零则返回1
,否则返回0
。 - _mm_cmpestri⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将包装的字符串a
和b
与长度la
和lb
进行比较,并返回生成的索引。 与_mm_cmpistri
相似,但_mm_cmpistri
隐式确定a
和b
的长度。 - _mm_cmpestrm⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将a
和b
中包装的字符串与长度la
和lb
进行比较,并返回生成的掩码。 - _mm_cmpestro⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将a
和b
中的包装字符串与长度la
和lb
进行比较,并返回结果位掩码的位0
。 - _mm_cmpestrs⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将a
和b
中的包装字符串与长度la
和lb
进行比较,如果 a 中的任何字符为空,则返回1
,否则返回0
。 - _mm_cmpestrz⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将a
和b
中的包装字符串与长度la
和lb
进行比较,如果b
中的任何字符为空,则返回1
,否则返回0
。 - _mm_cmpge_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素是否大于等于。 - _mm_cmpge_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素大于或等于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpge_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素大于或等于的比较所取代。 - _mm_cmpge_ss⚠(x86 or x86-64) and
sse
比较两个输入的最低f32
大于或等于。 如果a.extract(0)
大于或等于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpgt_epi8⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 8 位整数是否大于。 - _mm_cmpgt_epi16⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 16 位整数是否大于。 - _mm_cmpgt_epi32⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 32 位整数是否大于。 - _mm_cmpgt_epi64⚠(x86 or x86-64) and
sse4.2
比较a
和b
中的包装的 64 位整数是否大于,返回结果。 - _mm_cmpgt_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素是否大于。 - _mm_cmpgt_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素大于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpgt_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素大于的比较所代替。 - _mm_cmpgt_ss⚠(x86 or x86-64) and
sse
比较两个输入的最低f32
大于。 如果a.extract(0)
大于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpistra⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件比较a
和b
中隐含长度的包装字符串,如果b
不包含空字符且结果掩码为零,则返回1
,否则返回0
。 - _mm_cmpistrc⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件将包装的字符串与a
和b
中的隐式长度进行比较,如果结果掩码不为零,则返回1
,否则返回0
。 - _mm_cmpistri⚠(x86 or x86-64) and
sse4.2
- _mm_cmpistrm⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件比较a
和b
中隐含长度的包装的字符串,并返回生成的掩码。 - _mm_cmpistro⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件比较a
和b
中隐含长度的包装字符串,并返回结果位掩码的位0
。 - _mm_cmpistrs⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件比较a
和b
中隐含长度的包装字符串,如果a
中的任何字符为空,则返回1
,否则返回0
。 - _mm_cmpistrz⚠(x86 or x86-64) and
sse4.2
使用IMM8
中的控件比较a
和b
中隐含长度的包装字符串,如果b
中的任何字符为空,则返回1
。 - _mm_cmple_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素是否小于等于 - _mm_cmple_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素小于或等于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmple_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素小于或等于的比较所取代。 - _mm_cmple_ss⚠(x86 or x86-64) and
sse
比较两个输入中的最低f32
小于或等于。最低的 如果a.extract(0)
小于或等于b.extract(0)
,则结果的 32 位将为0xffffffff
,否则为0
。 结果的高 96 位是a
的高 96 位。 - _mm_cmplt_epi8⚠(x86 or x86-64) and
sse2
比较a
和b
中小于 8 的包装的 8 位整数。 - _mm_cmplt_epi16⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 16 位整数小于。 - _mm_cmplt_epi32⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 32 位整数是否小于。 - _mm_cmplt_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素小于。 - _mm_cmplt_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素小于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmplt_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素的小于比较所代替。 - _mm_cmplt_ss⚠(x86 or x86-64) and
sse
比较两个输入的最低f32
小于。 如果a.extract(0)
小于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpneq_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素是否相等。 - _mm_cmpneq_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果输入元素不相等,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpneq_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素的不相等比较代替。 - _mm_cmpneq_ss⚠(x86 or x86-64) and
sse
比较两个输入中最低的f32
是否不相等。 如果a.extract(0)
不等于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpnge_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的相应元素是否不大于或等于。 - _mm_cmpnge_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素不大于或等于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpnge_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素的不大于等于相等的比较所取代。 - _mm_cmpnge_ss⚠(x86 or x86-64) and
sse
比较两个输入中的最低f32
,以得出不大于等于。 如果a.extract(0)
不大于或等于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpngt_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中相应元素的不大于。 - _mm_cmpngt_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素不大于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpngt_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素的不大于比较所代替。 - _mm_cmpngt_ss⚠(x86 or x86-64) and
sse
比较两个输入的最低f32
,以得出不大于。 如果a.extract(0)
不大于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpnle_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素是否等于或大于等于。 - _mm_cmpnle_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素不小于或等于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpnle_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素相等或不小于的比较所取代。 - _mm_cmpnle_ss⚠(x86 or x86-64) and
sse
比较两个输入的最低f32
等于或小于等于。 如果a.extract(0)
不小于或等于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpnlt_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的对应元素不少于。 - _mm_cmpnlt_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 如果a
中的输入元素不小于b
中的相应元素,则输出 vector 中的结果将为0xffffffff
,否则为0
。 - _mm_cmpnlt_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素相当的比较所取代。 - _mm_cmpnlt_ss⚠(x86 or x86-64) and
sse
比较两个输入中的最低f32
不少于。 如果a.extract(0)
不小于b.extract(0)
,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpord_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的相应元素以查看NaN
是否都不是。 - _mm_cmpord_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 返回具有两个可能的位模式之一的四个浮点数。 如果a
和b
中的输入元素是有序的 (即,它们都不是 NaN),则输出 vector 中的元素将为0xffffffff
,否则为 0。 - _mm_cmpord_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素都与NaN
进行比较的结果所代替。 如果两者都不等于NaN
,则使用0xFFFFFFFFFFFFFFFF
,否则使用0
。 - _mm_cmpord_ss⚠(x86 or x86-64) and
sse
检查两个输入中最低的f32
是否已订购。 如果a.extract(0)
或b.extract(0)
都不是 NaN,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_cmpunord_pd⚠(x86 or x86-64) and
sse2
比较a
和b
中的相应元素,以查看是否为NaN
。 - _mm_cmpunord_ps⚠(x86 or x86-64) and
sse
将a
中的四个浮点数中的每个与b
中的对应元素进行比较。 返回具有两个可能的位模式之一的四个浮点数。 如果a
和b
中的输入元素无序 (即,至少其中一个是 NaN),则输出 vector 中的元素将为0xffffffff
,否则为 0。 - _mm_cmpunord_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素都与NaN
进行比较的结果所代替。 如果其中一个等于NaN
,则使用0xFFFFFFFFFFFFFFFF
,否则使用0
。 - _mm_cmpunord_ss⚠(x86 or x86-64) and
sse
检查两个输入中最低的f32
是否无序。 如果a.extract(0)
或b.extract(0)
中的任何一个为 NaN,则结果的最低 32 位将为0xffffffff
,否则为0
。 - _mm_comieq_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下部元素是否相等。 - _mm_comieq_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。如果相等则返回1
,否则返回0
。 - _mm_comige_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素是否大于等于。 - _mm_comige_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值大于或等于b
中的值,则返回1
,否则返回0
。 - _mm_comigt_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素是否大于。 - _mm_comigt_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值大于b
中的值,则返回1
,否则返回0
。 - _mm_comile_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素是否等于或小于等于。 - _mm_comile_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值小于或等于b
中的值,则返回1
,否则返回0
。 - _mm_comilt_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素小于。 - _mm_comilt_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值小于b
中的值,则返回1
,否则返回0
。 - _mm_comineq_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的较低元素是否不相等。 - _mm_comineq_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果它们不相等,则返回1
,否则返回0
。 - _mm_crc32_u8⚠(x86 or x86-64) and
sse4.2
从crc
中的初始值开始,返回无符号 8 位整数v
的累积 CRC32-C 值。 - _mm_crc32_u16⚠(x86 or x86-64) and
sse4.2
从crc
中的初始值开始,返回无符号 16 位整数v
的累积 CRC32-C 值。 - _mm_crc32_u32⚠(x86 or x86-64) and
sse4.2
从crc
中的初始值开始,返回无符号 32 位整数v
的累积 CRC32-C 值。 - _mm_crc32_u64⚠
sse4.2
从crc
中的初始值开始,返回无符号 64 位整数v
的累积 CRC32-C 值。 - _mm_cvt_si2ss⚠(x86 or x86-64) and
sse
_mm_cvtsi32_ss
的别名。 - _mm_cvt_ss2si⚠(x86 or x86-64) and
sse
_mm_cvtss_si32
的别名。 - _mm_cvtepi8_epi16⚠(x86 or x86-64) and
sse4.1
符号将a
中的包装 8 位整数扩展为包装 16 位整数 - _mm_cvtepi8_epi32⚠(x86 or x86-64) and
sse4.1
符号将a
中的包装 8 位整数扩展为包装 32 位整数 - _mm_cvtepi8_epi64⚠(x86 or x86-64) and
sse4.1
符号将a
的低 8 字节中的包装的 8 位整数扩展为包装的 64 位整数 - _mm_cvtepi16_epi32⚠(x86 or x86-64) and
sse4.1
符号将a
中的包装的 16 位整数扩展为包装的 32 位整数 - _mm_cvtepi16_epi64⚠(x86 or x86-64) and
sse4.1
符号将a
中的包装 16 位整数扩展为包装 64 位整数 - _mm_cvtepi32_epi64⚠(x86 or x86-64) and
sse4.1
符号将a
中的包装 32 位整数扩展为包装 64 位整数 - _mm_cvtepi32_pd⚠(x86 or x86-64) and
sse2
将a
中的低位两个包装的 32 位整数转换为包装的双精度 (64-bit) 浮点元素。 - _mm_cvtepi32_ps⚠(x86 or x86-64) and
sse2
将a
中的包装的 32 位整数转换为包装的单精度 (32-bit) 浮点元素。 - _mm_cvtepu8_epi16⚠(x86 or x86-64) and
sse4.1
零将a
中的包装的无符号 8 位整数扩展为包装的 16 位整数 - _mm_cvtepu8_epi32⚠(x86 or x86-64) and
sse4.1
零将a
中的包装无符号 8 位整数扩展为包装 32 位整数 - _mm_cvtepu8_epi64⚠(x86 or x86-64) and
sse4.1
零将a
中的包装无符号 8 位整数扩展为包装 64 位整数 - _mm_cvtepu16_epi32⚠(x86 or x86-64) and
sse4.1
零将a
中的包装的无符号 16 位整数扩展为包装的 32 位整数 - _mm_cvtepu16_epi64⚠(x86 or x86-64) and
sse4.1
零将a
中的包装的无符号 16 位整数扩展为包装的 64 位整数 - _mm_cvtepu32_epi64⚠(x86 or x86-64) and
sse4.1
零将a
中的包装无符号 32 位整数扩展为包装 64 位整数 - _mm_cvtpd_epi32⚠(x86 or x86-64) and
sse2
将a
中的包装的双精度 (64-bit) 浮点元素转换为包装的 32 位整数。 - _mm_cvtpd_ps⚠(x86 or x86-64) and
sse2
将a
中的包装的双精度 (64-bit) 浮点元素转换为包装的单精度 (32-bit) 浮点元素 - _mm_cvtph_ps⚠(x86 or x86-64) and
f16c
将 128 位 vectora
的最低 64 位中的 4 x 16 位半精度浮点值转换为存储在 128 位宽的 vector 中的 4 x 32 位浮点值。 - _mm_cvtps_epi32⚠(x86 or x86-64) and
sse2
将a
中的包装的单精度 (32-bit) 浮点元素转换为包装的 32 位整数。 - _mm_cvtps_pd⚠(x86 or x86-64) and
sse2
将a
中的包装的单精度 (32-bit) 浮点元素转换为包装的双精度 (64-bit) 浮点元素。 - _mm_cvtps_ph⚠(x86 or x86-64) and
f16c
将 128 位 vectora
中的 4 x 32 位浮点值转换为 4 x 16 位半精度浮点值存储在 128 位 vector 的最低 64 位中。 - _mm_cvtsd_f64⚠(x86 or x86-64) and
sse2
返回a
的较低的双精度 (64-bit) 浮点元素。 - _mm_cvtsd_si32⚠(x86 or x86-64) and
sse2
将 a 中的较低双精度 (64-bit) 浮点元素转换为 32 位整数。 - _mm_cvtsd_si64⚠
sse2
将 a 中的较低双精度 (64-bit) 浮点元素转换为 64 位整数。 - _mm_cvtsd_si64x⚠
sse2
_mm_cvtsd_si64
的别名 - _mm_cvtsd_ss⚠(x86 or x86-64) and
sse2
将b
中的下部双精度 (64-bit) 浮点元素转换为单精度 (32-bit) 浮点元素,将结果存储在返回值的下部元素中,并将上部元素从a
复制到返回值的上部元素中。 - _mm_cvtsi32_sd⚠(x86 or x86-64) and
sse2
将a
的下位元素转换为f64
后,返回其下位元素为b
的a
。 - _mm_cvtsi32_si128⚠(x86 or x86-64) and
sse2
返回 vector,其最低元素为a
,所有更高元素为0
。 - _mm_cvtsi32_ss⚠(x86 or x86-64) and
sse
将 32 位整数转换为 32 位浮点型。 结果 vector 是输入 vectora
,其最低 32 位浮点数已由转换后的整数替换。 - _mm_cvtsi64_sd⚠
sse2
将a
的下位元素转换为f64
后,返回其下位元素为b
的a
。 - _mm_cvtsi64_si128⚠
sse2
返回 vector,其最低元素为a
,所有更高元素为0
。 - _mm_cvtsi64_ss⚠
sse
将 64 位整数转换为 32 位浮点型。 结果 vector 是输入 vectora
,其最低 32 位浮点数已由转换后的整数替换。 - _mm_cvtsi64x_sd⚠
sse2
将a
的下位元素转换为f64
后,返回其下位元素为b
的a
。 - _mm_cvtsi64x_si128⚠
sse2
返回 vector,其最低元素为a
,所有更高元素为0
。 - _mm_cvtsi128_si32⚠(x86 or x86-64) and
sse2
返回a
的最低元素。 - _mm_cvtsi128_si64⚠
sse2
返回a
的最低元素。 - _mm_cvtsi128_si64x⚠
sse2
返回a
的最低元素。 - _mm_cvtss_f32⚠(x86 or x86-64) and
sse
从输入 vector 中提取最低的 32 位浮点数。 - _mm_cvtss_sd⚠(x86 or x86-64) and
sse2
将b
中的下部单精度 (32-bit) 浮点元素转换为双精度 (64-bit) 浮点元素,将结果存储在返回值的下部元素中,然后将a
的上部元素复制到返回值的上部元素中。 - _mm_cvtss_si32⚠(x86 or x86-64) and
sse
将输入 vector 中的最低 32 位浮点型转换为 32 位整数。 - _mm_cvtss_si64⚠
sse
将输入 vector 中的最低 32 位浮点型转换为 64 位整数。 - _mm_cvtt_ss2si⚠(x86 or x86-64) and
sse
_mm_cvttss_si32
的别名。 - _mm_cvttpd_epi32⚠(x86 or x86-64) and
sse2
将a
中的包装的双精度 (64-bit) 浮点元素转换为带截断的包装的 32 位整数。 - _mm_cvttps_epi32⚠(x86 or x86-64) and
sse2
将a
中的包装的单精度 (32-bit) 浮点元素转换为带截断的包装的 32 位整数。 - _mm_cvttsd_si32⚠(x86 or x86-64) and
sse2
将a
中较低的双精度 (64-bit) 浮点元素转换为带截断的 32 位整数。 - _mm_cvttsd_si64⚠
sse2
将a
中较低的双精度 (64-bit) 浮点元素转换为带截断的 64 位整数。 - _mm_cvttsd_si64x⚠
sse2
_mm_cvttsd_si64
的别名 - _mm_cvttss_si32⚠(x86 or x86-64) and
sse
将输入 vector 中的最低 32 位浮点型转换为带有截断的 32 位整数。 - _mm_cvttss_si64⚠
sse
将输入 vector 中的最低 32 位浮点型转换为带截断的 64 位整数。 - _mm_div_pd⚠(x86 or x86-64) and
sse2
将a
中的包装的双精度 (64-bit) 浮点元素除以b
中的包装的元素。 - _mm_div_ps⚠(x86 or x86-64) and
sse
除 __m128 vectors。 - _mm_div_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的下限元素被a
的下限元素除以b
的下限元素所代替。 - _mm_div_ss⚠(x86 or x86-64) and
sse
将b
的第一个组件除以a
,其他组件则从a
复制。 - _mm_dp_pd⚠(x86 or x86-64) and
sse4.1
返回两个 __m128d vectors 的点积。 - _mm_dp_ps⚠(x86 or x86-64) and
sse4.1
返回两个 __m128 vectors 的点积。 - _mm_extract_epi8⚠(x86 or x86-64) and
sse4.1
- _mm_extract_epi16⚠(x86 or x86-64) and
sse2
返回a
的imm8
元素。 - _mm_extract_epi32⚠(x86 or x86-64) and
sse4.1
从IMM8
选择的a
中提取 32 位整数 - _mm_extract_epi64⚠
sse4.1
从IMM1
选择的a
中提取 64 位整数 - _mm_extract_ps⚠(x86 or x86-64) and
sse4.1
从用IMM8
选择的a
中提取单精度 (32-bit) 浮点元素。 返回的i32
存储浮点数的位模式,并且可以通过转换将其转换回浮点数。 - _mm_extract_si64⚠(x86 or x86-64) and
sse4a
从x
的低 64 位提取y
指定的位范围。 - _mm_floor_pd⚠(x86 or x86-64) and
sse4.1
将a
中的包装的双精度 (64-bit) 浮点元素四舍五入为整数,并将结果存储为包装的双精度浮点元素。 - _mm_floor_ps⚠(x86 or x86-64) and
sse4.1
将a
中的包装的单精度 (32-bit) 浮点元素四舍五入为整数,并将结果存储为包装的单精度浮点元素。 - _mm_floor_sd⚠(x86 or x86-64) and
sse4.1
将b
中的下部双精度 (64-bit) 浮点元素四舍五入为整数值,将结果作为双精度浮点元素存储在内部结果的下部元素中,并将上部元素从a
复制到上部内在结果的元素。 - _mm_floor_ss⚠(x86 or x86-64) and
sse4.1
将b
中的下部单精度 (32-bit) 浮点元素四舍五入为整数值,将结果作为单精度浮点元素存储在内部结果的下部元素中,然后将a
的上部 3 个包装的元素复制到内在结果的上层要素。 - _mm_fmadd_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,并将中间结果与c
中的包装的元素相加。 - _mm_fmadd_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装单精度 (32-bit) 浮点元素相乘,并将中间结果添加到c
中的包装元素中。 - _mm_fmadd_sd⚠(x86 or x86-64) and
fma
将a
和b
中的较低的双精度 (64-bit) 浮点元素相乘,并将中间结果与c
中的较低的元素相加。 - _mm_fmadd_ss⚠(x86 or x86-64) and
fma
将a
和b
中较低的单精度 (32-bit) 浮点元素相乘,并将中间结果与c
中的较低元素相加。 - _mm_fmaddsub_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,或者在c
to/from 中将包装的元素相加或减去中间结果。 - _mm_fmaddsub_ps⚠(x86 or x86-64) and
fma
将a
和b
中包装的单精度 (32-bit) 浮点元素相乘,或者将c
中包装的元素加/减到中间结果中。 - _mm_fmsub_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,并从中间结果中减去c
中的包装的双精度元素。 - _mm_fmsub_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装的单精度 (32-bit) 浮点元素相乘,并从中间结果中减去c
中的包装元素。 - _mm_fmsub_sd⚠(x86 or x86-64) and
fma
将a
和b
中的较低的双精度 (64-bit) 浮点元素相乘,并从中间结果中减去c
中的较低的元素。 将结果存储在返回值的低位元素中,并将高位元素从a
复制到结果的高位元素。 - _mm_fmsub_ss⚠(x86 or x86-64) and
fma
将a
和b
中的较低单精度 (32-bit) 浮点元素相乘,并从中间结果中减去c
中的较低元素。 将结果存储在返回值的低位元素中,并将 3 个高位元素从a
复制到结果的高位元素。 - _mm_fmsubadd_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,也可以从中间结果中减去或加上c
中的包装元素。 - _mm_fmsubadd_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装单精度 (32-bit) 浮点元素相乘,或者将c
中的包装元素从中间结果中减去或加上。 - _mm_fnmadd_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装双精度 (64-bit) 浮点元素相乘,然后将取反的中间结果添加到c
中的包装元素中。 - _mm_fnmadd_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装单精度 (32-bit) 浮点元素相乘,并将取反的中间结果添加到c
中的包装元素中。 - _mm_fnmadd_sd⚠(x86 or x86-64) and
fma
将a
和b
中较低的双精度 (64-bit) 浮点元素相乘,并将取反的中间结果添加到c
中的较低元素。 将结果存储在返回值的低位元素中,并将高位元素从a
复制到结果的高位元素。 - _mm_fnmadd_ss⚠(x86 or x86-64) and
fma
将a
和b
中较低的单精度 (32-bit) 浮点元素相乘,并将取反的中间结果与c
中的较低元素相加。 将结果存储在返回值的低位元素中,并将 3 个高位元素从a
复制到结果的高位元素。 - _mm_fnmsub_pd⚠(x86 or x86-64) and
fma
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘,并从取反的中间结果中减去c
中的包装的元素。 - _mm_fnmsub_ps⚠(x86 or x86-64) and
fma
将a
和b
中的包装的单精度 (32-bit) 浮点元素相乘,并从取反的中间结果中减去c
中的包装的元素。 - _mm_fnmsub_sd⚠(x86 or x86-64) and
fma
将a
和b
中较低的双精度 (64-bit) 浮点元素相乘,然后从取反的中间结果中减去c
中的包装的元素。 将结果存储在返回值的低位元素中,并将高位元素从a
复制到结果的高位元素。 - _mm_fnmsub_ss⚠(x86 or x86-64) and
fma
将a
和b
中较低的单精度 (32-bit) 浮点元素相乘,然后从取反的中间结果中减去c
中的包装元素。 将结果存储在返回值的低位元素中,并将 3 个高位元素从a
复制到结果的高位元素。 - _mm_getcsr⚠(x86 or x86-64) and
sse
获取 MXCSR 控制和状态寄存器的无符号 32 位值。 - _mm_hadd_epi16⚠(x86 or x86-64) and
ssse3
水平相加 2 个包装的包中包含的相邻值对[8 x i16]
的 128 位 vectors。 - _mm_hadd_epi32⚠(x86 or x86-64) and
ssse3
水平相加 2 个包装的包中包含的相邻值对[4 x i32]
的 128 位 vectors。 - _mm_hadd_pd⚠(x86 or x86-64) and
sse3
在a
和b
中水平添加相邻对的双精度 (64-bit) 浮点元素,并包装结果。 - _mm_hadd_ps⚠(x86 or x86-64) and
sse3
在a
和b
中水平添加相邻对的单精度 (32-bit) 浮点元素对,并包装结果。 - _mm_hadds_epi16⚠(x86 or x86-64) and
ssse3
水平相加 2 个包装的包中包含的相邻值对[8 x i16]
的 128 位 vectors。大于 7FFFh 的正和饱和到 7FFFh。 小于 8000h 的负数和将饱和到 8000h。 - _mm_hsub_epi16⚠(x86 or x86-64) and
ssse3
水平减去[8 x i16]
的 2 个包装的 128 位 vectors 中包含的相邻值对。 - _mm_hsub_epi32⚠(x86 or x86-64) and
ssse3
水平减去[4 x i32]
的 2 个包装的 128 位 vectors 中包含的相邻值对。 - _mm_hsub_pd⚠(x86 or x86-64) and
sse3
水平减去a
和b
中相邻的双精度 (64-bit) 浮点元素对,然后包装结果。 - _mm_hsub_ps⚠(x86 or x86-64) and
sse3
在a
和b
中水平添加相邻对的单精度 (32-bit) 浮点元素对,并包装结果。 - _mm_hsubs_epi16⚠(x86 or x86-64) and
ssse3
水平减去[8 x i16]
的 2 个包装的 128 位 vectors 中包含的相邻值对。 正差异大于 7FFFh 饱和到 7FFFh。小于 8000h 的负差会饱和到 8000h。 - _mm_i32gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i32gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i32gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i32gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i64gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i64gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i64gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_i64gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. - _mm_insert_epi8⚠(x86 or x86-64) and
sse4.1
返回a
的副本,其中i
的 8 位整数插入到IMM8
指定的位置。 - _mm_insert_epi16⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的imm8
元素替换为i
。 - _mm_insert_epi32⚠(x86 or x86-64) and
sse4.1
返回a
的副本,其中i
的 32 位整数插入到IMM8
指定的位置。 - _mm_insert_epi64⚠
sse4.1
返回a
的副本,其中i
的 64 位整数插入到IMM1
指定的位置。 - _mm_insert_ps⚠(x86 or x86-64) and
sse4.1
在a
中选择单个值存储在b
中的某个位置,然后根据IMM8
将元素归零。 - _mm_insert_si64⚠(x86 or x86-64) and
sse4a
将y
的[length:0]
位插入index
处的x
。 - _mm_lddqu_si128⚠(x86 or x86-64) and
sse3
从未对齐的内存中加载 128 位整数数据。 当数据越过高速缓存行边界时,此内部函数的性能可能比_mm_loadu_si128
更好。 - _mm_lfence⚠(x86 or x86-64) and
sse2
对在此指令之前发布的所有内存加载指令执行序列化操作。 - _mm_load1_pd⚠(x86 or x86-64) and
sse2
将内存中的双精度 (64-bit) 浮点元素加载到返回的 vector 的两个元素中。 - _mm_load1_ps⚠(x86 or x86-64) and
sse
通过将从p
读取的值复制到所有元素中来构造__m128
。 - _mm_load_pd⚠(x86 or x86-64) and
sse2
从内存中将 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 加载到返回的 vector 中。 - _mm_load_pd1⚠(x86 or x86-64) and
sse2
将内存中的双精度 (64-bit) 浮点元素加载到返回的 vector 的两个元素中。 - _mm_load_ps⚠(x86 or x86-64) and
sse
将 aligned 内存中的四个f32
值加载到__m128
中。 如果指针未与 128 位边界 (16 个字节) 对齐,则将触发一般保护错误 (致命程序崩溃)。 - _mm_load_ps1⚠(x86 or x86-64) and
sse
_mm_load1_ps
的别名 - _mm_load_sd⚠(x86 or x86-64) and
sse2
将 64 位双精度值加载到 128 位整数 vector 并清除高位元素。 - _mm_load_si128⚠(x86 or x86-64) and
sse2
从内存中将 128 位整数数据加载到新的 vector 中。 - _mm_load_ss⚠(x86 or x86-64) and
sse
使用从p
读取的最低元素并将其他元素设置为零来构造__m128
。 - _mm_loaddup_pd⚠(x86 or x86-64) and
sse3
将内存中的双精度 (64-bit) 浮点元素加载到返回 vector 的两个元素中。 - _mm_loadh_pd⚠(x86 or x86-64) and
sse2
将双精度值加载到[2 x double]
的 128 位 vector 的高阶位中。 低位从第一个操作数的低位复制而来。 - _mm_loadl_epi64⚠(x86 or x86-64) and
sse2
将内存中的 64 位整数加载到返回的 vector 的第一个元素中。 - _mm_loadl_pd⚠(x86 or x86-64) and
sse2
将双精度值加载到[2 x double]
的 128 位 vector 的低位中。 高阶位是从第一个操作数的高阶位复制而来的。 - _mm_loadr_pd⚠(x86 or x86-64) and
sse2
以相反的顺序将 2 个双精度 (64-bit) 浮点元素从内存加载到返回的 vector 中。mem_addr
必须对齐在一个 可能会生成 16 字节边界或一般保护异常。 - _mm_loadr_ps⚠(x86 or x86-64) and
sse
从对齐的内存中以相反的顺序将四个f32
值加载到__m128
中。 - _mm_loadu_pd⚠(x86 or x86-64) and
sse2
从内存中将 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 加载到返回的 vector 中。 - _mm_loadu_ps⚠(x86 or x86-64) and
sse
- _mm_loadu_si64⚠(x86 or x86-64) and
sse
将未对齐的 64 位整数数据从内存加载到新的 vector 中。 - _mm_loadu_si128⚠(x86 or x86-64) and
sse2
从内存中将 128 位整数数据加载到新的 vector 中。 - _mm_madd_epi16⚠(x86 or x86-64) and
sse2
在a
和b
中相乘,然后水平相加带符号的 16 位整数。 - _mm_maddubs_epi16⚠(x86 or x86-64) and
ssse3
将第一个源操作数中包含的包装的 8 位无符号整数值与第二个源操作数中包含的包装的 8 位有符号整数值的对应对相乘,相加具有符号饱和度的连续乘积对,并将 16 位和写入到目标中的相应位。 - _mm_mask_i32gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i32gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i32gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i32gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i64gather_epi32⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i64gather_epi64⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i64gather_pd⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_mask_i64gather_ps⚠(x86 or x86-64) and
avx2
从offsets * scale
确定的偏移处返回slice
的值,其中scale
应为 1、2、4 或 8. 如果设置了掩码,请从该位置从src
加载值。 - _mm_maskload_epi32⚠(x86 or x86-64) and
avx2
使用mask
从mem_addr
指向的内存中加载包装的 32 位整数 (当未在相应元素中设置最高位时,元素清零)。 - _mm_maskload_epi64⚠(x86 or x86-64) and
avx2
使用mask
从mem_addr
指向的内存中加载包装的 64 位整数 (当未在相应元素中设置最高位时,元素清零)。 - _mm_maskload_pd⚠(x86 or x86-64) and
avx
使用mask
将包装的双精度 (64-bit) 浮点元素从内存加载到结果中 (当未设置相应元素的高位时,元素清零)。 - _mm_maskload_ps⚠(x86 or x86-64) and
avx
使用mask
将包装的单精度 (32-bit) 浮点元素从内存加载到结果中 (当未设置相应元素的高位时,元素清零)。 - _mm_maskmoveu_si128⚠(x86 or x86-64) and
sse2
使用mask
有条件地将a
中的 8 位整数元素存储到内存中。 - _mm_maskstore_epi32⚠(x86 or x86-64) and
avx2
使用mask
将a
中的包装后的 32 位整数存储到mem_addr
指向的内存中 (当在相应元素中未设置最高位时,不存储元素)。 - _mm_maskstore_epi64⚠(x86 or x86-64) and
avx2
使用mask
将a
中的包装 64 位整数存储到mem_addr
指向的内存中 (当未在相应元素中设置最高位时,不存储元素)。 - _mm_maskstore_pd⚠(x86 or x86-64) and
avx
使用mask
将包装的双精度 (64-bit) 浮点元素从a
存储到内存中。 - _mm_maskstore_ps⚠(x86 or x86-64) and
avx
使用mask
将包装的单精度 (32-bit) 浮点元素从a
存储到内存中。 - _mm_max_epi8⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装的 8 位整数,并以 dst 返回包装的最大值。 - _mm_max_epi16⚠(x86 or x86-64) and
sse2
比较a
和b
中的包装的 16 位整数,并返回包装的最大值。 - _mm_max_epi32⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装的 32 位整数,并返回包装的最大值。 - _mm_max_epu8⚠(x86 or x86-64) and
sse2
比较a
和b
中包装的无符号 8 位整数,并返回包装的最大值。 - _mm_max_epu16⚠(x86 or x86-64) and
sse4.1
比较a
和b
中包装的无符号 16 位整数,并返回包装的最大值。 - _mm_max_epu32⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装无符号 32 位整数,并返回包装最大值。 - _mm_max_pd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,它具有a
和b
中相应元素的最大值。 - _mm_max_ps⚠(x86 or x86-64) and
sse
比较a
和b
中包装的单精度 (32-bit) 浮点元素,并返回相应的最大值。 - _mm_max_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素最大值取代。 - _mm_max_ss⚠(x86 or x86-64) and
sse
比较a
和b
的第一个单精度 (32-bit) 浮点元素,并在返回值的第一个元素中返回最大值,从a
复制其他元素。 - _mm_mfence⚠(x86 or x86-64) and
sse2
对在此指令之前发布的所有从内存加载和存储到内存指令执行序列化操作。 - _mm_min_epi8⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装的 8 位整数,并以 dst 返回包装的最小值。 - _mm_min_epi16⚠(x86 or x86-64) and
sse2
比较a
和b
中包装的 16 位整数,并返回包装的最小值。 - _mm_min_epi32⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装的 32 位整数,并返回包装的最小值。 - _mm_min_epu8⚠(x86 or x86-64) and
sse2
比较a
和b
中包装的无符号 8 位整数,并返回包装的最小值。 - _mm_min_epu16⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装的无符号 16 位整数,并返回包装的最小值。 - _mm_min_epu32⚠(x86 or x86-64) and
sse4.1
比较a
和b
中的包装的无符号 32 位整数,并返回包装的最小值。 - _mm_min_pd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,它具有a
和b
中相应元素的最小值。 - _mm_min_ps⚠(x86 or x86-64) and
sse
比较a
和b
中包装的单精度 (32-bit) 浮点元素,并返回相应的最小值。 - _mm_min_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素的最小值替换。 - _mm_min_ss⚠(x86 or x86-64) and
sse
比较a
和b
的第一个单精度 (32-bit) 浮点元素,并在返回值的第一个元素中返回最小值,从a
复制其他元素。 - _mm_minpos_epu16⚠(x86 or x86-64) and
sse4.1
在 128 位 __m128i vector 中查找最小的无符号 16 位元素,并返回一个 vector,其中在第一个位置包含其值,在第二个位置包含其索引; 所有其他元素都设置为零。 - _mm_move_epi64⚠(x86 or x86-64) and
sse2
返回 vector,其中从a
提取低位元素,其高位元素为零。 - _mm_move_sd⚠(x86 or x86-64) and
sse2
构造[2 x double]
的 128 位浮点 vector。下层 将 64 位设置为第二个参数的低 64 位。上层 将 64 位设置为第一个参数的高 64 位。 - _mm_move_ss⚠(x86 or x86-64) and
sse
返回__m128
,其中第一个组件来自b
,其余组件来自a
。 - _mm_movedup_pd⚠(x86 or x86-64) and
sse3
从a
复制低双精度 (64-bit) 浮点元素。 - _mm_movehdup_ps⚠(x86 or x86-64) and
sse3
a
中重复的奇数索引单精度 (32-bit) 浮点元素。 - _mm_movehl_ps⚠(x86 or x86-64) and
sse
合并a
和b
的上半部分。b
的高半部分占据结果的低半部分。 - _mm_moveldup_ps⚠(x86 or x86-64) and
sse3
a
中重复的偶数索引单精度 (32-bit) 浮点元素。 - _mm_movelh_ps⚠(x86 or x86-64) and
sse
合并a
和b
的下半部分。b
的下半部分占据结果的上半部分。 - _mm_movemask_epi8⚠(x86 or x86-64) and
sse2
返回a
中每个元素的最高有效位的掩码。 - _mm_movemask_pd⚠(x86 or x86-64) and
sse2
返回a
中每个元素的最高有效位的掩码。 - _mm_movemask_ps⚠(x86 or x86-64) and
sse
返回a
中每个元素的最高有效位的掩码。 - _mm_mpsadbw_epu8⚠(x86 or x86-64) and
sse4.1
减去 8 位无符号整数值,然后将差的绝对值计算为目标中的相应位。 - _mm_mul_epi32⚠(x86 or x86-64) and
sse4.1
将a
和b
中每个包装的 64 位元素的低 32 位整数相乘,并返回带符号的 64 位结果。 - _mm_mul_epu32⚠(x86 or x86-64) and
sse2
将a
和b
中每个包装的 64 位元素中的低 32 位无符号整数相乘。 - _mm_mul_pd⚠(x86 or x86-64) and
sse2
将a
和b
中的包装的双精度 (64-bit) 浮点元素相乘。 - _mm_mul_ps⚠(x86 or x86-64) and
sse
乘以 __m128 vectors。 - _mm_mul_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低位元素被a
和b
的低位元素相乘。 - _mm_mul_ss⚠(x86 or x86-64) and
sse
将a
和b
的第一个组件相乘,然后从a
复制其他组件。 - _mm_mulhi_epi16⚠(x86 or x86-64) and
sse2
将a
和b
中的包装的 16 位整数相乘。 - _mm_mulhi_epu16⚠(x86 or x86-64) and
sse2
将a
和b
中包装的无符号 16 位整数相乘。 - _mm_mulhrs_epi16⚠(x86 or x86-64) and
ssse3
将包装的 16 位带符号整数值相乘,通过右移将 32 位乘积截断为 18 个最高有效位,通过加 1 舍入舍入后的值,并将[16:1]
位写入目标位置。 - _mm_mullo_epi16⚠(x86 or x86-64) and
sse2
将a
和b
中的包装的 16 位整数相乘。 - _mm_mullo_epi32⚠(x86 or x86-64) and
sse4.1
将a
和b
中包装的 32 位整数相乘,产生中间值 64 位整数,并返回最低的 32 位 (无论它们是什么),都将重新解释为有符号整数。 虽然pmulld __m128i::splat(2), __m128i::splat(2)
返回明显的__m128i::splat(4)
,但由于包装算术,pmulld __m128i::splat(i32::MAX), __m128i::splat(2)
将返回负数。 - _mm_or_pd⚠(x86 or x86-64) and
sse2
计算a
和b
的按位或。 - _mm_or_ps⚠(x86 or x86-64) and
sse
包装的单精度 (32-bit) 浮点元素的按位或。 - _mm_or_si128⚠(x86 or x86-64) and
sse2
计算a
和b
中 128 位 (表示整数数据) 的按位或。 - _mm_packs_epi16⚠(x86 or x86-64) and
sse2
使用带符号的饱和度将包装的 16 位整数从a
和b
转换为包装的 8 位整数。 - _mm_packs_epi32⚠(x86 or x86-64) and
sse2
使用带符号的饱和度将包装的 32 位整数从a
和b
转换为包装的 16 位整数。 - _mm_packus_epi16⚠(x86 or x86-64) and
sse2
使用无符号饱和度将a
和b
的包装的 16 位整数转换为包装的 8 位整数。 - _mm_packus_epi32⚠(x86 or x86-64) and
sse4.1
使用无符号饱和度将包装的 32 位整数从a
和b
转换为包装的 16 位整数 - _mm_pause⚠x86 or x86-64向处理器提示代码序列是自旋等待循环。
- _mm_permute_pd⚠(x86 or x86-64) and
avx,sse2
使用imm8
中的控件对a
中的双精度 (64-bit) 浮点元素进行混洗。 - _mm_permute_ps⚠(x86 or x86-64) and
avx,sse
使用imm8
中的控件对a
中的单精度 (32-bit) 浮点元素进行混洗。 - _mm_permutevar_pd⚠(x86 or x86-64) and
avx
使用b
中的控件对a
中的双精度 (64-bit) 浮点元素进行混洗。 - _mm_permutevar_ps⚠(x86 or x86-64) and
avx
使用b
中的控件对a
中的单精度 (32-bit) 浮点元素进行混洗。 - _mm_prefetch⚠(x86 or x86-64) and
sse
使用给定的STRATEGY
获取包含地址p
的缓存行。 - _mm_rcp_ps⚠(x86 or x86-64) and
sse
返回a
中包装的单精度 (32-bit) 浮点元素的近似倒数。 - _mm_rcp_ss⚠(x86 or x86-64) and
sse
返回a
中第一个单精度 (32-bit) 浮点元素的近似倒数,其他元素不变。 - _mm_round_pd⚠(x86 or x86-64) and
sse4.1
使用ROUNDING
参数将a
中的包装的双精度 (64-bit) 浮点元素舍入,并将结果存储为包装的双精度浮点元素。 - _mm_round_ps⚠(x86 or x86-64) and
sse4.1
使用ROUNDING
参数将a
中的包装的单精度 (32-bit) 浮点元素舍入,并将结果存储为包装的单精度浮点元素。 - _mm_round_sd⚠(x86 or x86-64) and
sse4.1
使用ROUNDING
参数将b
中的低位双精度浮点元素 (64-bit) 舍入,将结果作为双精度浮点元素存储在内部结果的低位元素中,并将高位元素从a
复制到高位元素的内在结果。 - _mm_round_ss⚠(x86 or x86-64) and
sse4.1
使用ROUNDING
参数对b
中的低位单精度 (32-bit) 浮点元素进行舍入,将结果作为单精度浮点元素存储在内部函数结果的低位元素中,并从a
复制高位 3 个包装元素到内部函数结果的上层元素。 - _mm_rsqrt_ps⚠(x86 or x86-64) and
sse
返回a
中包装的单精度 (32-bit) 浮点元素的近似倒数平方根。 - _mm_rsqrt_ss⚠(x86 or x86-64) and
sse
返回a
中第一个单精度 (32-bit) 浮点元素的近似倒数平方根,其他元素不变。 - _mm_sad_epu8⚠(x86 or x86-64) and
sse2
包装无符号 8 位整数的绝对差之和。 - _mm_set1_epi8⚠(x86 or x86-64) and
sse2
向所有元素广播 8 位整数a
。 - _mm_set1_epi16⚠(x86 or x86-64) and
sse2
向所有元素广播 16 位整数a
。 - _mm_set1_epi32⚠(x86 or x86-64) and
sse2
向所有元素广播 32 位整数a
。 - _mm_set1_epi64x⚠(x86 or x86-64) and
sse2
向所有元素广播 64 位整数a
。 - _mm_set1_pd⚠(x86 or x86-64) and
sse2
向返回值的所有元素广播双精度 (64-bit) 浮点值 a。 - _mm_set1_ps⚠(x86 or x86-64) and
sse
创建一个__m128
,并将所有元素设置为a
。 - _mm_set_epi8⚠(x86 or x86-64) and
sse2
使用提供的值设置包装的 8 位整数。 - _mm_set_epi16⚠(x86 or x86-64) and
sse2
使用提供的值设置包装的 16 位整数。 - _mm_set_epi32⚠(x86 or x86-64) and
sse2
使用提供的值设置包装的 32 位整数。 - _mm_set_epi64x⚠(x86 or x86-64) and
sse2
使用提供的值 (从最高到最低) 设置包装的 64 位整数。 - _mm_set_pd⚠(x86 or x86-64) and
sse2
使用提供的值在返回值中设置包装的双精度 (64-bit) 浮点元素。 - _mm_set_pd1⚠(x86 or x86-64) and
sse2
向返回值的所有元素广播双精度 (64-bit) 浮点值 a。 - _mm_set_ps⚠(x86 or x86-64) and
sse
从最高到最低的四个浮点值构造__m128
。 - _mm_set_ps1⚠(x86 or x86-64) and
sse
_mm_set1_ps
的别名 - _mm_set_sd⚠(x86 or x86-64) and
sse2
将双精度 (64-bit) 浮点元素a
复制到包装的 64 位返回值的低位元素。 - _mm_set_ss⚠(x86 or x86-64) and
sse
创建一个__m128
,将最低元素设置为a
,将剩余部分设置为零。 - _mm_setcsr⚠(x86 or x86-64) and
sse
用 32 位无符号整数值设置 MXCSR 寄存器。 - _mm_setr_epi8⚠(x86 or x86-64) and
sse2
以相反的顺序设置提供的值的包装 8 位整数。 - _mm_setr_epi16⚠(x86 or x86-64) and
sse2
以相反的顺序设置提供的值的包装 16 位整数。 - _mm_setr_epi32⚠(x86 or x86-64) and
sse2
以相反的顺序设置提供的值的包装 32 位整数。 - _mm_setr_pd⚠(x86 or x86-64) and
sse2
在返回值中设置包装的双精度 (64-bit) 浮点元素,并以相反的顺序提供提供的值。 - _mm_setr_ps⚠(x86 or x86-64) and
sse
从四个最低到最高的浮点值构造__m128
。 - _mm_setzero_pd⚠(x86 or x86-64) and
sse2
返回全零的包装的双精度 (64-bit) 浮点元素。 - _mm_setzero_ps⚠(x86 or x86-64) and
sse
创建一个__m128
,并将所有元素初始化为零。 - _mm_setzero_si128⚠(x86 or x86-64) and
sse2
返回所有元素均设置为零的 vector。 - _mm_sfence⚠(x86 or x86-64) and
sse
对在此指令之前发出的所有存储到内存指令执行序列化操作。 - _mm_sha1msg1_epu32⚠(x86 or x86-64) and
sha
使用来自a
和b
的先前消息值,对接下来的四个 SHA1 消息值 (无符号的 32 位整数) 执行中间计算,并返回结果。 - _mm_sha1msg2_epu32⚠(x86 or x86-64) and
sha
使用a
中的中间结果和b
中的先前消息值,对接下来的四个 SHA1 消息值 (无符号的 32 位整数) 执行最终计算,并返回结果。 - _mm_sha1nexte_epu32⚠(x86 or x86-64) and
sha
经过四轮运算后,从当前 SHA1 状态变量a
计算 SHA1 状态变量 E,将该值添加到b
中的计划值 (无符号 32 位整数),然后返回结果。 - _mm_sha1rnds4_epu32⚠(x86 or x86-64) and
sha
使用来自a
的初始 SHA1 状态 (A,B,C,D) 以及接下来的 4 个回合消息值 (一些无符号的 32 位整数) 和来自b
的状态变量 E 的一些预先计算的总和,执行四轮 SHA1 操作,并返回更新的 SHA1 状态 (A,B,C,D)。FUNC
包含逻辑函数和圆常量。 - _mm_sha256msg1_epu32⚠(x86 or x86-64) and
sha
使用来自a
和b
的先前消息值,对接下来的四个 SHA256 消息值 (无符号的 32 位整数) 执行中间计算,并返回结果。 - _mm_sha256msg2_epu32⚠(x86 or x86-64) and
sha
使用以前的a
和b
的消息值,对接下来的四个 SHA256 消息值 (无符号的 32 位整数) 执行最终计算,并返回结果。 - _mm_sha256rnds2_epu32⚠(x86 or x86-64) and
sha
使用来自a
的初始 SHA256 状态 (C,D,G,H),来自b
的初始 SHA256 状态 (A,B,E,F) 以及接下来的 2 个回合消息值 (无符号的 32 位整数) 和来自k
的相应回合常量的预先计算的总和,执行 2 轮 SHA256 操作。,并将更新的 SHA256 状态 (A,B,E,F) 存储在 dst 中。 - _mm_shuffle_epi8⚠(x86 or x86-64) and
ssse3
根据b
的内容,打乱a
中的字节。 - _mm_shuffle_epi32⚠(x86 or x86-64) and
sse2
使用IMM8
中的控件在a
中打乱 32 位整数。 - _mm_shuffle_pd⚠(x86 or x86-64) and
sse2
从两个创建一个[2 x double]
的 128 位浮点 vector[2 x double]
的 128 位 vector 参数,使用立即值参数作为说明符。 - _mm_shuffle_ps⚠(x86 or x86-64) and
sse
使用MASK
在a
和b
中打乱包装的单精度 (32-bit) 浮点元素。 - _mm_shufflehi_epi16⚠(x86 or x86-64) and
sse2
使用IMM8
中的控件在a
的高 64 位中打乱 16 位整数。 - _mm_shufflelo_epi16⚠(x86 or x86-64) and
sse2
使用IMM8
中的控件在a
的低 64 位中打乱 16 位整数。 - _mm_sign_epi8⚠(x86 or x86-64) and
ssse3
当b
中相应的带符号 8 位整数为负时,对a
中的 8 位包装整数取反,并返回结果。 - _mm_sign_epi16⚠(x86 or x86-64) and
ssse3
当b
中相应的带符号 16 位整数为负时,将a
中的 16 位整数包装为无效,并返回结果。 - _mm_sign_epi32⚠(x86 or x86-64) and
ssse3
当b
中相应的带符号 32 位整数为负时,对a
中的包装 32 位整数求反,并返回结果。 - _mm_sll_epi16⚠(x86 or x86-64) and
sse2
将count
左移的a
中的包装的 16 位整数移位,同时将零移位。 - _mm_sll_epi32⚠(x86 or x86-64) and
sse2
将count
左移的a
中的包装的 32 位整数移位,同时将零移位。 - _mm_sll_epi64⚠(x86 or x86-64) and
sse2
将count
左移的a
中的包装的 64 位整数移位,同时将零移位。 - _mm_slli_epi16⚠(x86 or x86-64) and
sse2
将a
中包装的 16 位整数左移IMM8
,同时将其移入零。 - _mm_slli_epi32⚠(x86 or x86-64) and
sse2
将a
中包装的 32 位整数左移IMM8
,同时将其移入零。 - _mm_slli_epi64⚠(x86 or x86-64) and
sse2
将a
中包装的 64 位整数左移IMM8
,同时将其移入零。 - _mm_slli_si128⚠(x86 or x86-64) and
sse2
将a
左移IMM8
个字节,同时移入零。 - _mm_sllv_epi32⚠(x86 or x86-64) and
avx2
将a
中的包装的 32 位整数左移count
中相应元素所指定的数量,同时将零移位,并返回结果。 - _mm_sllv_epi64⚠(x86 or x86-64) and
avx2
将a
中的包装的 64 位整数左移count
中相应元素所指定的数量,同时将零移位,并返回结果。 - _mm_sqrt_pd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,它具有a
中每个值的平方根。 - _mm_sqrt_ps⚠(x86 or x86-64) and
sse
返回a
中包装的单精度 (32-bit) 浮点元素的平方根。 - _mm_sqrt_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低端元素替换为下部元素b
的平方根。 - _mm_sqrt_ss⚠(x86 or x86-64) and
sse
返回a
中第一个单精度 (32-bit) 浮点元素的平方根,其他元素保持不变。 - _mm_sra_epi16⚠(x86 or x86-64) and
sse2
将符号位移入时,将a
中的包装的 16 位整数右移count
。 - _mm_sra_epi32⚠(x86 or x86-64) and
sse2
将符号位移位时,将a
中的包装的 32 位整数右移count
。 - _mm_srai_epi16⚠(x86 or x86-64) and
sse2
将a
中包装的 16 位整数右移IMM8
,同时移入符号位。 - _mm_srai_epi32⚠(x86 or x86-64) and
sse2
将a
中包装的 32 位整数右移IMM8
,同时移入符号位。 - _mm_srav_epi32⚠(x86 or x86-64) and
avx2
将a
中的 32 位整数向右移动,移动量由count
中的相应元素指定,同时移入符号位。 - _mm_srl_epi16⚠(x86 or x86-64) and
sse2
将a
中的包装的 16 位整数右移count
,同时将零移位。 - _mm_srl_epi32⚠(x86 or x86-64) and
sse2
将a
中的包装的 32 位整数右移count
,同时将零移位。 - _mm_srl_epi64⚠(x86 or x86-64) and
sse2
将a
中的包装的 64 位整数右移count
,同时将零移位。 - _mm_srli_epi16⚠(x86 or x86-64) and
sse2
将a
中包装的 16 位整数右移IMM8
,同时将其移入零。 - _mm_srli_epi32⚠(x86 or x86-64) and
sse2
将a
中包装的 32 位整数右移IMM8
,同时将其移入零。 - _mm_srli_epi64⚠(x86 or x86-64) and
sse2
将a
中包装的 64 位整数右移IMM8
,同时将其移入零。 - _mm_srli_si128⚠(x86 or x86-64) and
sse2
将a
右移IMM8
个字节,同时移入零。 - _mm_srlv_epi32⚠(x86 or x86-64) and
avx2
将a
中的包装的 32 位整数右移count
中相应元素所指定的数量,同时将零移位, - _mm_srlv_epi64⚠(x86 or x86-64) and
avx2
将a
中的包装的 64 位整数右移count
中相应元素所指定的数量,同时将零移位, - _mm_store1_pd⚠(x86 or x86-64) and
sse2
将来自a
的较低的双精度 (64-bit) 浮点元素存储到内存中的 2 个连续元素中。mem_addr
必须对齐在一个 可能会生成 16 字节边界或一般保护异常。 - _mm_store1_ps⚠(x86 or x86-64) and
sse
将a
的最低 32 位浮点数重复存储四次到 aligned 存储器中。 - _mm_store_pd⚠(x86 or x86-64) and
sse2
将来自a
的 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr
必须在 16 字节边界上对齐,否则可能会生成通用保护异常。 - _mm_store_pd1⚠(x86 or x86-64) and
sse2
将来自a
的较低的双精度 (64-bit) 浮点元素存储到内存中的 2 个连续元素中。mem_addr
必须对齐在一个 可能会生成 16 字节边界或一般保护异常。 - _mm_store_ps⚠(x86 or x86-64) and
sse
将四个 32 位浮点数存储到 aligned 存储器中。 - _mm_store_ps1⚠(x86 or x86-64) and
sse
_mm_store1_ps
的别名 - _mm_store_sd⚠(x86 or x86-64) and
sse2
将[2 x double]
的 128 位 vector 的低 64 位存储到内存位置。 - _mm_store_si128⚠(x86 or x86-64) and
sse2
将来自a
的 128 位整数数据存储到内存中。 - _mm_store_ss⚠(x86 or x86-64) and
sse
将a
的最低 32 位浮点数存储到内存中。 - _mm_storeh_pd⚠(x86 or x86-64) and
sse2
将[2 x double]
的 128 位 vector 的高 64 位存储到存储位置。 - _mm_storel_epi64⚠(x86 or x86-64) and
sse2
将低 64 位整数a
存储到内存位置。 - _mm_storel_pd⚠(x86 or x86-64) and
sse2
将[2 x double]
的 128 位 vector 的低 64 位存储到内存位置。 - _mm_storer_pd⚠(x86 or x86-64) and
sse2
将a
中的 2 个双精度 (64-bit) 浮点元素以相反的顺序存储到内存中。mem_addr
必须在 16 字节边界上对齐,否则可能会生成通用保护异常。 - _mm_storer_ps⚠(x86 or x86-64) and
sse
以相反的顺序将四个 32 位浮点数存储到 aligned 存储器中。 - _mm_storeu_pd⚠(x86 or x86-64) and
sse2
将来自a
的 128 位 (由 2 个包装的双精度 (64-bit) 浮点元素组成) 存储到内存中。mem_addr
不需要在任何特定边界上对齐。 - _mm_storeu_ps⚠(x86 or x86-64) and
sse
将四个 32 位浮点数存储到内存中。内存对齐没有任何限制。 对于对齐的内存,_mm_store_ps
可能更快。 - _mm_storeu_si128⚠(x86 or x86-64) and
sse2
将来自a
的 128 位整数数据存储到内存中。 - _mm_stream_pd⚠(x86 or x86-64) and
sse2
将[2 x double]
的 128 位浮点 vector 存储到 128 位对齐的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用)。 - _mm_stream_ps⚠(x86 or x86-64) and
sse
使用非临时内存提示将a
存储到mem_addr
的内存中。 - _mm_stream_sd⚠(x86 or x86-64) and
sse4a
a.0
的非临时存储到p
中。 - _mm_stream_si32⚠(x86 or x86-64) and
sse2
将 32 位整数值存储在指定的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用)。 - _mm_stream_si64⚠
sse2
将 64 位整数值存储在指定的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用)。 - _mm_stream_si128⚠(x86 or x86-64) and
sse2
将 128 位整数 vector 存储到 128 位对齐的内存位置。 为了最大程度地减少缓存,数据被标记为非时间性的 (不太可能很快再次使用)。 - _mm_stream_ss⚠(x86 or x86-64) and
sse4a
a.0
的非临时存储到p
中。 - _mm_sub_epi8⚠(x86 or x86-64) and
sse2
从a
中的包装的 8 位整数中减去b
中的包装的 8 位整数。 - _mm_sub_epi16⚠(x86 or x86-64) and
sse2
从a
中的包装的 16 位整数减去b
中的包装的 16 位整数。 - _mm_sub_epi32⚠(x86 or x86-64) and
sse2
从a
中的包装的 32 位整数中减去b
中的包装的 32 位整数。 - _mm_sub_epi64⚠(x86 or x86-64) and
sse2
从a
中的包装的 64 位整数中减去b
中的包装的 64 位整数。 - _mm_sub_pd⚠(x86 or x86-64) and
sse2
从a
中减去b
中的包装的双精度 (64-bit) 浮点元素。 - _mm_sub_ps⚠(x86 or x86-64) and
sse
减去 __m128 vectors。 - _mm_sub_sd⚠(x86 or x86-64) and
sse2
返回一个新的 vector,其中a
的低端元素被a
的低端元素减去b
的低端元素所代替。 - _mm_sub_ss⚠(x86 or x86-64) and
sse
从a
减去b
的第一个组件,从a
复制其他组件。 - _mm_subs_epi8⚠(x86 or x86-64) and
sse2
使用饱和度从a
的包装的 8 位整数减去b
的包装的 8 位整数。 - _mm_subs_epi16⚠(x86 or x86-64) and
sse2
使用饱和度从a
的包装的 16 位整数减去b
的包装的 16 位整数。 - _mm_subs_epu8⚠(x86 or x86-64) and
sse2
使用饱和度从a
中的包装无符号 8 位整数减去b
中的包装无符号 8 位整数。 - _mm_subs_epu16⚠(x86 or x86-64) and
sse2
使用饱和度从a
中的包装的无符号 16 位整数减去b
中的包装的无符号 16 位整数。 - _mm_test_all_ones⚠(x86 or x86-64) and
sse4.1
测试a
128 位整数 vector 中的指定位是否全部为 1。 - _mm_test_all_zeros⚠(x86 or x86-64) and
sse4.1
测试 128 位整数 vector 中的指定位是否全部为零。 - _mm_test_mix_ones_zeros⚠(x86 or x86-64) and
sse4.1
测试 128 位整数 vector 中的指定位是否既不是全零也不是全 1。 - _mm_testc_pd⚠(x86 or x86-64) and
avx
计算a
和b
中 128 位 (表示双精度 (64-bit) 浮点元素) 的按位与,产生一个 128 位中间值,如果中间值中每个 64 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 计算a
的按位非,然后与b
与,产生一个中间值,如果中间值中每个 64 位元素的符号位为零,则将CF
设置为 1,否则将CF
设置为 0. 返回CF
值。 - _mm_testc_ps⚠(x86 or x86-64) and
avx
计算a
和b
中 128 位 (表示单精度 (32-bit) 浮点元素) 的按位与,产生一个 128 位中间值,如果中间值中每个 32 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 对a
进行按位非运算,然后与b
进行与运算,得到一个中间值,如果中间值中每个 32 位元素的符号位都为零,则将CF
设置为 1,否则将CF
设置为 0. 返回CF
值。 - _mm_testc_si128⚠(x86 or x86-64) and
sse4.1
测试 128 位整数 vector 中的指定位是否全部为 1。 - _mm_testnzc_pd⚠(x86 or x86-64) and
avx
计算a
和b
中 128 位 (表示双精度 (64-bit) 浮点元素) 的按位与,产生一个 128 位中间值,如果中间值中每个 64 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 计算a
的按位非,然后与b
与,产生一个中间值,如果中间值中每个 64 位元素的符号位为零,则将CF
设置为 1,否则将CF
设置为 0. 如果ZF
和CF
的值都为零则返回 1,否则返回 0. - _mm_testnzc_ps⚠(x86 or x86-64) and
avx
计算a
和b
中 128 位 (表示单精度 (32-bit) 浮点元素) 的按位与,产生一个 128 位中间值,如果中间值中每个 32 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 对a
进行按位非运算,然后与b
进行与运算,得到一个中间值,如果中间值中每个 32 位元素的符号位都为零,则将CF
设置为 1,否则将CF
设置为 0. 如果ZF
和CF
的值都为零则返回 1,否则返回 0. - _mm_testnzc_si128⚠(x86 or x86-64) and
sse4.1
测试 128 位整数 vector 中的指定位是否既不是全零也不是全 1。 - _mm_testz_pd⚠(x86 or x86-64) and
avx
计算a
和b
中 128 位 (表示双精度 (64-bit) 浮点元素) 的按位与,产生一个 128 位中间值,如果中间值中每个 64 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 计算a
的按位非,然后与b
与,产生一个中间值,如果中间值中每个 64 位元素的符号位为零,则将CF
设置为 1,否则将CF
设置为 0. 返回ZF
值。 - _mm_testz_ps⚠(x86 or x86-64) and
avx
计算a
和b
中 128 位 (表示单精度 (32-bit) 浮点元素) 的按位与,产生一个 128 位中间值,如果中间值中每个 32 位元素的符号位都设置ZF
为 1 为零,否则将ZF
设置为 0. 对a
进行按位非运算,然后与b
进行与运算,得到一个中间值,如果中间值中每个 32 位元素的符号位都为零,则将CF
设置为 1,否则将CF
设置为 0. 返回ZF
值。 - _mm_testz_si128⚠(x86 or x86-64) and
sse4.1
测试 128 位整数 vector 中的指定位是否全部为零。 - _mm_tzcnt_32⚠(x86 or x86-64) and
bmi1
计算尾随的最低有效零位的数量。 - _mm_tzcnt_64⚠
bmi1
计算尾随的最低有效零位的数量。 - _mm_ucomieq_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下部元素是否相等。 - _mm_ucomieq_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。如果相等则返回1
,否则返回0
。 如果任一参数是安静的 NaN,则该指令不会发出异常信号。 - _mm_ucomige_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素是否大于等于。 - _mm_ucomige_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值大于或等于b
中的值,则返回1
,否则返回0
。 如果任一参数是安静的 NaN,则该指令不会发出异常信号。 - _mm_ucomigt_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素是否大于。 - _mm_ucomigt_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值大于b
中的值,则返回1
,否则返回0
。 如果任一参数是安静的 NaN,则该指令不会发出异常信号。 - _mm_ucomile_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素是否等于或小于等于。 - _mm_ucomile_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值小于或等于b
中的值,则返回1
,否则返回0
。 如果任一参数是安静的 NaN,则该指令不会发出异常信号。 - _mm_ucomilt_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的下限元素小于。 - _mm_ucomilt_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果a
中的值小于b
中的值,则返回1
,否则返回0
。 如果任一参数是安静的 NaN,则该指令不会发出异常信号。 - _mm_ucomineq_sd⚠(x86 or x86-64) and
sse2
比较a
和b
的较低元素是否不相等。 - _mm_ucomineq_ss⚠(x86 or x86-64) and
sse
比较a
和b
的低位的两个 32 位浮点数。 如果它们不相等,则返回1
,否则返回0
。 如果任一参数是安静的 NaN,则该指令不会发出异常信号。 - _mm_undefined_pd⚠(x86 or x86-64) and
sse2
返回具有不确定元素的 __m128d 类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - _mm_undefined_ps⚠(x86 or x86-64) and
sse
返回具有不确定元素的 __m128 类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - _mm_undefined_si128⚠(x86 or x86-64) and
sse2
返回具有不确定元素的 __m128i 类型的 vector。 尽管是 “undefined”,但这是一些有效值,并不等同于mem::MaybeUninit
。 实际上,这相当于mem::zeroed
。 - _mm_unpackhi_epi8⚠(x86 or x86-64) and
sse2
从a
和b
的高半部分解包并交织 8 位整数。 - _mm_unpackhi_epi16⚠(x86 or x86-64) and
sse2
从a
和b
的高半部分解包并交织 16 位整数。 - _mm_unpackhi_epi32⚠(x86 or x86-64) and
sse2
从a
和b
的高半部分解包并交织 32 位整数。 - _mm_unpackhi_epi64⚠(x86 or x86-64) and
sse2
从a
和b
的高半部分解包并交织 64 位整数。 - _mm_unpackhi_pd⚠(x86 or x86-64) and
sse2
所得的__m128d
元素由两个__m128d
交错输入元素的低阶值组成,即: - _mm_unpackhi_ps⚠(x86 or x86-64) and
sse
从a
和b
的上半部分解包并交织单精度 (32-bit) 浮点元素。 - _mm_unpacklo_epi8⚠(x86 or x86-64) and
sse2
从a
和b
的下半部分解包并交织 8 位整数。 - _mm_unpacklo_epi16⚠(x86 or x86-64) and
sse2
从a
和b
的下半部分解包并交织 16 位整数。 - _mm_unpacklo_epi32⚠(x86 or x86-64) and
sse2
从a
和b
的下半部分解包并交织 32 位整数。 - _mm_unpacklo_epi64⚠(x86 or x86-64) and
sse2
从a
和b
的下半部分解包并交织 64 位整数。 - _mm_unpacklo_pd⚠(x86 or x86-64) and
sse2
所得的__m128d
元素由两个__m128d
交错输入元素的高阶值组成,即: - _mm_unpacklo_ps⚠(x86 or x86-64) and
sse
从a
和b
的下半部分解包并交织单精度 (32-bit) 浮点元素。 - _mm_xor_pd⚠(x86 or x86-64) and
sse2
计算a
和b
的按位异或。 - _mm_xor_ps⚠(x86 or x86-64) and
sse
包装的单精度 (32-bit) 浮点元素的按位异或。 - _mm_xor_si128⚠(x86 or x86-64) and
sse2
计算a
和b
中 128 位 (表示整数数据) 的按位 XOR。 - _mulx_u32⚠(x86 or x86-64) and
bmi2
无符号乘法,且不影响标志。 - _mulx_u64⚠
bmi2
无符号乘法,且不影响标志。 - _pdep_u32⚠(x86 or x86-64) and
bmi2
将a
的连续低阶位分散到mask
指定的位置处的结果中。 - _pdep_u64⚠
bmi2
将a
的连续低阶位分散到mask
指定的位置处的结果中。 - _pext_u32⚠(x86 or x86-64) and
bmi2
将mask
指定的x
的位收集到结果的连续低阶位位置。 - _pext_u64⚠
bmi2
将mask
指定的x
的位收集到结果的连续低阶位位置。 - _popcnt32⚠(x86 or x86-64) and
popcnt
计算设置的位。 - _popcnt64⚠
popcnt
计算设置的位。 - _rdrand16_step⚠(x86 or x86-64) and
rdrand
读取硬件生成的 16 位随机值,并将结果存储在 val 中。 如果生成随机值,则返回 1,否则返回 0。 - _rdrand32_step⚠(x86 or x86-64) and
rdrand
读取硬件生成的 32 位随机值,并将结果存储在 val 中。 如果生成随机值,则返回 1,否则返回 0。 - _rdrand64_step⚠
rdrand
读取硬件生成的 64 位随机值,并将结果存储在 val 中。 如果生成随机值,则返回 1,否则返回 0。 - _rdseed16_step⚠(x86 or x86-64) and
rdseed
读取符合 NIST SP800-90B 和 SP800-90C 的 16 位随机值,并存储在 val 中。 如果生成随机值,则返回 1,否则返回 0。 - _rdseed32_step⚠(x86 or x86-64) and
rdseed
读取符合 NIST SP800-90B 和 SP800-90C 的 32 位随机值,并存储在 val 中。 如果生成随机值,则返回 1,否则返回 0。 - _rdseed64_step⚠
rdseed
读取符合 NIST SP800-90B 和 SP800-90C 的 64 位随机值,并存储在 val 中。 如果生成随机值,则返回 1,否则返回 0。 - _rdtsc⚠x86 or x86-64读取处理器时间戳计数器的当前值。
- _subborrow_u32⚠x86 or x86-64将无符号的 32 位整数
a
和b
与无符号的 8 位进位c_in
(进位或溢出标志) 相加,并将无符号的 32 位结果存储在out
中,并返回进位 (进位或溢出标志)。 - 将无符号的 64 位整数
a
和b
与无符号的 8 位随身输入c_in
相加。 (进位或溢出标志),并将无符号的 64 位结果存储在out
中,并返回进位 (进位或溢出标志)。 - _t1mskc_u32⚠(x86 or x86-64) and
tbm
清除x
的最低有效零以下的所有位,并设置所有其他位。 - _t1mskc_u64⚠(x86 or x86-64) and
tbm
清除x
的最低有效零以下的所有位,并设置所有其他位。 - _tzcnt_u32⚠(x86 or x86-64) and
bmi1
计算尾随的最低有效零位的数量。 - _tzcnt_u64⚠
bmi1
计算尾随的最低有效零位的数量。 - _tzmsk_u32⚠(x86 or x86-64) and
tbm
将所有位设置为低于x
的最低有效位,并清除所有其他位。 - _tzmsk_u64⚠(x86 or x86-64) and
tbm
将所有位设置为低于x
的最低有效位,并清除所有其他位。 - _xgetbv⚠(x86 or x86-64) and
xsave
读取xcr_no
中指定的扩展控制寄存器XCR
的内容。 - _xrstor⚠(x86 or x86-64) and
xsave
使用mem_addr
内存中存储的状态信息执行已启用处理器状态的全部或部分还原。 - _xrstor64⚠
xsave
使用mem_addr
内存中存储的状态信息执行已启用处理器状态的全部或部分还原。 - _xrstors⚠(x86 or x86-64) and
xsave,xsaves
使用mem_addr
内存中存储的状态信息执行已启用处理器状态的全部或部分还原。 - _xrstors64⚠
xsave,xsaves
使用mem_addr
内存中存储的状态信息执行已启用处理器状态的全部或部分还原。 - _xsave⚠(x86 or x86-64) and
xsave
将已启用的处理器状态全部或部分保存到mem_addr
的内存中。 - _xsave64⚠
xsave
将已启用的处理器状态全部或部分保存到mem_addr
的内存中。 - _xsavec⚠(x86 or x86-64) and
xsave,xsavec
将已启用的处理器状态全部或部分保存到mem_addr
的内存中。 - _xsavec64⚠
xsave,xsavec
将已启用的处理器状态全部或部分保存到mem_addr
的内存中。 - _xsaveopt⚠(x86 or x86-64) and
xsave,xsaveopt
将已启用的处理器状态全部或部分保存到mem_addr
的内存中。 - _xsaveopt64⚠
xsave,xsaveopt
将已启用的处理器状态全部或部分保存到mem_addr
的内存中。 - _xsaves⚠(x86 or x86-64) and
xsave,xsaves
在mem_addr
处将启用的处理器状态全部或部分保存到内存 - _xsaves64⚠
xsave,xsaves
在mem_addr
处将启用的处理器状态全部或部分保存到内存 - _xsetbv⚠(x86 or x86-64) and
xsave
从val
复制 64 位到a
指定的扩展控制寄存器 (XCR
)。 - cmpxchg16b⚠
cmpxchg16b
自动比较和交换 16 字节 (128 位) 的数据。
Type Definitions
_MM_CMPINT_ENUM
类型用于在 AVX-512 内部函数中指定比较操作。MM_MANTISSA_NORM_ENUM
类型用于指定 AVX-512 内部函数中的尾数归一化操作。MM_MANTISSA_SIGN_ENUM
类型用于指定 AVX-512 内部函数中的尾数签名操作。MM_PERM_ENUM
类型用于指定在 AVX-512 内部函数中的重排操作。- AVX-512 内部函数中使用的
__mmask8
类型,一个 8 位整数 - AVX-512 内部函数中使用的
__mmask16
类型,一个 16 位整数 - AVX-512 内部函数中使用的
__mmask32
类型,一个 32 位整数 - AVX-512 内部函数中使用的
__mmask64
类型,一个 64 位整数