Available on AArch64 only.
Expand description
特定于平台的用于 aarch64
平台的内部函数。
有关更多详细信息,请参见 模块级文档。
Structs
- APSRExperimental应用程序状态寄存器
- SYExperimental完整的系统是必需的可共享性域,读写是必需的访问类型
- 特定于 ARM 的两个包装的
f32
的 64 位宽 vector。 - 特定于 ARM 的包含两个
float32x2_t
vectors 的类型。 - 特定于 ARM 的包含三个
float32x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
float32x2_t
vectors 的类型。 - 特定于 ARM 的四个包装的
f32
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
float32x4_t
vectors 的类型。 - 特定于 ARM 的包含三个
float32x4_t
vectors 的类型。 - 特定于 ARM 的包含四个
float32x4_t
vectors 的类型。 - 特定于 ARM 的一个包装的
f64
的 64 位宽 vector。 - 特定于 ARM 的包含两个
float64x1_t
vectors 的类型。 - 特定于 ARM 的包含三个
float64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
float64x1_t
vectors 的类型。 - 特定于 ARM 的两个包装的
f64
的 128 位宽 vector。 - 特定于 ARM 的包含两个
float64x2_t
vectors 的类型。 - 特定于 ARM 的包含三个
float64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
float64x2_t
vectors 的类型。 - 特定于 ARM 的八个包装的
i8
的 64 位宽 vector。 - 特定于 ARM 的包含两个
int8x8_t
vectors 的类型。 - 特定于 ARM 的包含三个
int8x8_t
vectors 的类型。 - 特定于 ARM 的包含四个
int8x8_t
vectors 的类型。 - 特定于 ARM 的十六个包装的
i8
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
int8x16_t
vectors 的类型。 - 特定于 ARM 的包含三个
int8x16_t
vectors 的类型。 - 特定于 ARM 的包含四个
int8x16_t
vectors 的类型。 - 特定于 ARM 的四个包装的
i16
的 64 位宽 vector。 - 特定于 ARM 的包含两个
int16x4_t
vectors 的类型。 - 特定于 ARM 的包含三个
int16x4_t
vectors 的类型。 - 特定于 ARM 的包含四个
int16x4_t
vectors 的类型。 - 特定于 ARM 的八个包装的
i16
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
int16x8_t
vectors 的类型。 - 特定于 ARM 的包含三个
int16x8_t
vectors 的类型。 - 特定于 ARM 的包含四个
int16x8_t
vectors 的类型。 - 特定于 ARM 的两个包装的
i32
的 64 位宽 vector。 - 特定于 ARM 的包含两个
int32x2_t
vectors 的类型。 - 特定于 ARM 的包含三个
int32x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
int32x2_t
vectors 的类型。 - 特定于 ARM 的四个包装的
i32
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
int32x4_t
vectors 的类型。 - 特定于 ARM 的包含三个
int32x4_t
vectors 的类型。 - 特定于 ARM 的包含四个
int32x4_t
vectors 的类型。 - 特定于 ARM 的一个包装的
i64
的 64 位宽 vector。 - 特定于 ARM 的包含四个
int64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
int64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
int64x1_t
vectors 的类型。 - 特定于 ARM 的两个包装的
i64
的 128 位宽的 vector。 - 特定于 ARM 的包含四个
int64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
int64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
int64x2_t
vectors 的类型。 - 特定于 ARM 的八个包装的
p8
的 64 位宽多项式 vector。 - 特定于 ARM 的包含两个
poly8x8_t
vectors 的类型。 - 特定于 ARM 的包含三个
poly8x8_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly8x8_t
vectors 的类型。 - 特定于 ARM 的十六个包装的
p8
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
poly8x16_t
vectors 的类型。 - 特定于 ARM 的包含三个
poly8x16_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly8x16_t
vectors 的类型。 - 特定于 ARM 的四个包装的
p16
的 64 位宽 vector。 - 特定于 ARM 的包含两个
poly16x4_t
vectors 的类型。 - 特定于 ARM 的包含三个
poly16x4_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly16x4_t
vectors 的类型。 - 特定于 ARM 的八个包装的
p16
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
poly16x8_t
vectors 的类型。 - 特定于 ARM 的包含三个
poly16x8_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly16x8_t
vectors 的类型。 - 特定于 ARM 的一个包装的
p64
的 64 位宽 vector。 - 特定于 ARM 的包含四个
poly64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly64x1_t
vectors 的类型。 - 特定于 ARM 的两个包装的
p64
的 128 位宽的 vector。 - 特定于 ARM 的包含四个
poly64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
poly64x2_t
vectors 的类型。 - 特定于 ARM 的八个包装的
u8
的 64 位宽 vector。 - 特定于 ARM 的包含两个
uint8x8_t
vectors 的类型。 - 特定于 ARM 的包含三个
uint8x8_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint8x8_t
vectors 的类型。 - 特定于 ARM 的十六个包装的
u8
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
uint8x16_t
vectors 的类型。 - 特定于 ARM 的包含三个
uint8x16_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint8x16_t
vectors 的类型。 - 特定于 ARM 的四个包装的
u16
的 64 位宽 vector。 - 特定于 ARM 的包含两个
uint16x4_t
vectors 的类型。 - 特定于 ARM 的包含三个
uint16x4_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint16x4_t
vectors 的类型。 - 特定于 ARM 的八个包装的
u16
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
uint16x8_t
vectors 的类型。 - 特定于 ARM 的包含三个
uint16x8_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint16x8_t
vectors 的类型。 - 特定于 ARM 的两个包装的
u32
的 64 位宽 vector。 - 特定于 ARM 的包含两个
uint32x2_t
vectors 的类型。 - 特定于 ARM 的包含三个
uint32x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint32x2_t
vectors 的类型。 - 特定于 ARM 的四个包装的
u32
的 128 位宽的 vector。 - 特定于 ARM 的包含两个
uint32x4_t
vectors 的类型。 - 特定于 ARM 的包含三个
uint32x4_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint32x4_t
vectors 的类型。 - 特定于 ARM 的一个包装的
u64
的 64 位宽 vector。 - 特定于 ARM 的包含四个
uint64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint64x1_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint64x1_t
vectors 的类型。 - 特定于 ARM 的两个包装的
u64
的 128 位宽的 vector。 - 特定于 ARM 的包含四个
uint64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint64x2_t
vectors 的类型。 - 特定于 ARM 的包含四个
uint64x2_t
vectors 的类型。
Constants
- _PREFETCH_LOCALITY0Experimental请参见
prefetch
。 - _PREFETCH_LOCALITY1Experimental请参见
prefetch
。 - _PREFETCH_LOCALITY2Experimental请参见
prefetch
。 - _PREFETCH_LOCALITY3Experimental请参见
prefetch
。 - _PREFETCH_READExperimental请参见
prefetch
。 - _PREFETCH_WRITEExperimental请参见
prefetch
。 - _TMFAILURE_CNCLExperimental事务执行了 TCANCEL 指令
- _TMFAILURE_DBGExperimental事务由于调试陷阱而中止。
- _TMFAILURE_ERRExperimental事务中止,因为尝试了不允许的操作
- _TMFAILURE_IMPExperimental后备错误类型 (由于任何其他原因)
- _TMFAILURE_INTExperimental事务因中断而失败
- _TMFAILURE_MEMExperimental事务因发生冲突而中止
- _TMFAILURE_NESTExperimental由于超出了事务嵌套级别,事务中止了
- _TMFAILURE_REASONExperimental故障原因的提取码
- _TMFAILURE_RTRYExperimental事务重试是可能的。
- _TMFAILURE_SIZEExperimental事务由于超出读或写集限制而中止
- _TMFAILURE_TRIVIALExperimental表示 TM 的试用版可用
- _TMSTART_SUCCESSExperimental事务成功开始。
Functions
- __breakpoint⚠Experimental插入断点指令。
- CRC32 字节的单轮校验和 (8 位)。
- 字节 (8 位) 的 CRC32-C 单回合校验和。
- 四字 (64 位) 的 CRC32-C 单回合校验和。
- 半字 (16 位) 的 CRC32-C 单回合校验和。
- 字 (32 位) 的 CRC32-C 单次校验和。
- CRC32 四字 (64 位) 的单轮校验和。
- CRC32 半字的单轮校验和 (16 位)。
- CRC32 单轮字校验和 (32 位)。
- __dmb⚠Experimental生成 DMB (数据存储屏障) 指令或等效的 CP15 指令。
- __dsb⚠Experimental生成 DSB (数据同步屏障) 指令或等效的 CP15 指令。
- __isb⚠Experimental生成一个 ISB (指令同步屏障) 指令或等效的 CP15 指令。
- __nop⚠Experimental生成未指定的无操作指令。
- __rsr⚠Experimental读取 32 位系统寄存器
- __rsrp⚠Experimental读取包含地址的系统寄存器
- __sev⚠Experimental生成 SEV (发送事件) 提示指令。
- __sevl⚠Experimental生成发送本地事件提示指令。
- 取消当前事务,并放弃所有通过事务执行的状态修改。 ARM TME Intrinsics.
- 提交当前事务。 对于嵌套事务,唯一的效果是减少了事务嵌套深度。 对于外部事务,将事务执行的状态修改提交给体系结构状态。
- 开始新的事务。当交易开始成功时,返回值是 0. 如果事务失败,则将丢弃所有状态修改,并将失败原因编码在返回值中。
- 测试是否在事务内执行。 如果当前没有事务正在执行,则返回值为 0. 否则,此内部函数将返回事务的深度。 ARM TME Intrinsics.
- __wfe⚠Experimental生成 WFE (等待事件) 提示指令,否则不生成任何内容。
- __wfi⚠Experimental生成 WFI (等待中断) 提示指令,或不执行任何操作。
- __wsr⚠Experimental写入 32 位系统寄存器
- __wsrp⚠Experimental写入包含地址的系统寄存器
- __yield⚠Experimental生成一条 YIELD 提示指令。
- _cls_u32⚠Experimental计算前导最高有效位集。
- _cls_u64⚠Experimental计算前导最高有效位集。
- _clz_u64⚠Experimental计算前导零。
- _prefetch⚠Experimental使用给定的
RW
和LOCALITY
获取包含地址p
的缓存行。 - _rbit_u64⚠Experimental反转位顺序。
- _rev_u64⚠Experimental颠倒字节顺序。
- brk⚠Experimental生成陷阱指令
BRK 1
- AES 单轮解密。
- AES 单轮加密。
- AES 反向混合列。
- AES 混合列。
- 位清除和异或
- 位清除和异或
- 位清除和异或
- 位清除和异或
- 位清除和异或
- 位清除和异或
- 位清除和异或
- 位清除和异或
- 浮点复数加法
- 浮点复数加法
- 浮点复数加法
- 浮点复数加法
- 浮点复数加法
- 浮点复数加法
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- 浮点复数乘法累加
- Vector 结合
- Vector 结合
- Vector 结合
- Vector 结合
- Vector 结合
- Vector 结合
- Vector 结合
- Vector 结合
- Vector 结合
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 点积算术
- 三路异或
- 三路异或
- 三路异或
- 三路异或
- 三路异或
- 三路异或
- 三路异或
- 三路异或
- 8 位整数矩阵乘法累加
- 8 位整数矩阵乘法累加
- 轮换和异或
- 浮点舍入到 32 位整数,使用当前舍入模式
- 浮点舍入到 32 位整数,使用当前舍入模式
- 浮点数舍入到 32 位整数到零
- 浮点数舍入到 32 位整数到零
- 浮点舍入到 64 位整数,使用当前舍入模式
- 浮点舍入到 64 位整数,使用当前舍入模式
- 浮点数舍入到 64 位整数到零
- 浮点数舍入到 64 位整数到零
- SHA1 哈希更新加速器,选择。
- SHA1 固定旋转。
- SHA1 哈希更新加速器,多数。
- SHA1 哈希更新加速器,奇偶校验。
- SHA1 调度更新加速器,第一部分。
- SHA1 调度更新加速器,第二部分。
- SHA256 哈希更新加速器,上半部分。
- SHA256 哈希更新加速器。
- SHA256 调度更新加速器,第一部分。
- SHA256 调度更新加速器,第二部分。
- SHA512 哈希更新第 2 部分
- SHA512 哈希更新第 1 部分
- SHA512 调度更新 0
- SHA512 调度更新 1
- SM3PARTW1
- SM3PARTW2
- SM3SS1
- SM3TT1A
- SM3TT1B
- SM3TT2A
- SM3TT2B
- SM4 key
- SM4 encode
- 无符号和有符号 8 位整数矩阵乘法累加
- 异或和旋转
- vaba_s8⚠
neon
- vaba_s16⚠
neon
- vaba_s32⚠
neon
- vaba_u8⚠
neon
- vaba_u16⚠
neon
- vaba_u32⚠
neon
- vabal_high_s8⚠
neon
有符号绝对差和累积长 - vabal_high_s16⚠
neon
有符号绝对差和累积长 - vabal_high_s32⚠
neon
有符号绝对差和累积长 - vabal_high_u8⚠
neon
无符号绝对差和累积长 - vabal_high_u16⚠
neon
无符号绝对差和累积长 - vabal_high_u32⚠
neon
无符号绝对差和累积长 - vabal_s8⚠
neon
有符号绝对差和累积长 - vabal_s16⚠
neon
有符号绝对差和累积长 - vabal_s32⚠
neon
有符号绝对差和累积长 - vabal_u8⚠
neon
无符号绝对差和累积长 - vabal_u16⚠
neon
无符号绝对差和累积长 - vabal_u32⚠
neon
无符号绝对差和累积长 - vabaq_s8⚠
neon
- vabaq_s16⚠
neon
- vabaq_s32⚠
neon
- vabaq_u8⚠
neon
- vabaq_u16⚠
neon
- vabaq_u32⚠
neon
- vabd_f32⚠
neon
浮动参数之间的绝对差异 - vabd_f64⚠
neon
浮动参数之间的绝对差异 - vabd_s8⚠
neon
参数之间的绝对差异 - vabd_s16⚠
neon
参数之间的绝对差异 - vabd_s32⚠
neon
参数之间的绝对差异 - vabd_u8⚠
neon
参数之间的绝对差异 - vabd_u16⚠
neon
参数之间的绝对差异 - vabd_u32⚠
neon
参数之间的绝对差异 - vabdd_f64⚠
neon
浮点绝对差 - vabdl_high_s8⚠
neon
有符号绝对差长 - vabdl_high_s16⚠
neon
有符号绝对差长 - vabdl_high_s32⚠
neon
有符号绝对差长 - vabdl_high_u8⚠
neon
无符号绝对差长 - vabdl_high_u16⚠
neon
无符号绝对差长 - vabdl_high_u32⚠
neon
无符号绝对差长 - vabdl_s8⚠
neon
有符号绝对差长 - vabdl_s16⚠
neon
有符号绝对差长 - vabdl_s32⚠
neon
有符号绝对差长 - vabdl_u8⚠
neon
无符号绝对差长 - vabdl_u16⚠
neon
无符号绝对差长 - vabdl_u32⚠
neon
无符号绝对差长 - vabdq_f32⚠
neon
浮动参数之间的绝对差异 - vabdq_f64⚠
neon
浮动参数之间的绝对差异 - vabdq_s8⚠
neon
参数之间的绝对差异 - vabdq_s16⚠
neon
参数之间的绝对差异 - vabdq_s32⚠
neon
参数之间的绝对差异 - vabdq_u8⚠
neon
参数之间的绝对差异 - vabdq_u16⚠
neon
参数之间的绝对差异 - vabdq_u32⚠
neon
参数之间的绝对差异 - vabds_f32⚠
neon
浮点绝对差 - vabs_f32⚠
neon
浮点绝对值 - vabs_f64⚠
neon
浮点绝对值 - vabs_s8⚠
neon
绝对值 (wrapping)。 - vabs_s16⚠
neon
绝对值 (wrapping)。 - vabs_s32⚠
neon
绝对值 (wrapping)。 - vabs_s64⚠
neon
绝对值 (wrapping)。 - vabsd_s64⚠
neon
绝对值 (wrapping)。 - vabsq_f32⚠
neon
浮点绝对值 - vabsq_f64⚠
neon
浮点绝对值 - vabsq_s8⚠
neon
绝对值 (wrapping)。 - vabsq_s16⚠
neon
绝对值 (wrapping)。 - vabsq_s32⚠
neon
绝对值 (wrapping)。 - vabsq_s64⚠
neon
绝对值 (wrapping)。 - vadd_f32⚠
neon
Vector add。 - vadd_f64⚠
neon
Vector add。 - vadd_p8⚠
neon
按位异或 - vadd_p16⚠
neon
按位异或 - vadd_p64⚠
neon
按位异或 - vadd_s8⚠
neon
Vector add。 - vadd_s16⚠
neon
Vector add。 - vadd_s32⚠
neon
Vector add。 - vadd_s64⚠
neon
Vector add。 - vadd_u8⚠
neon
Vector add。 - vadd_u16⚠
neon
Vector add。 - vadd_u32⚠
neon
Vector add。 - vadd_u64⚠
neon
Vector add。 - vaddd_s64⚠
neon
Vector add。 - vaddd_u64⚠
neon
Vector add。 - vaddhn_high_s16⚠
neon
添加返回的 High Narrow (高半)。 - vaddhn_high_s32⚠
neon
添加返回的 High Narrow (高半)。 - vaddhn_high_s64⚠
neon
添加返回的 High Narrow (高半)。 - vaddhn_high_u16⚠
neon
添加返回的 High Narrow (高半)。 - vaddhn_high_u32⚠
neon
添加返回的 High Narrow (高半)。 - vaddhn_high_u64⚠
neon
添加返回的 High Narrow (高半)。 - vaddhn_s16⚠
neon
添加返回的 High Narrow。 - vaddhn_s32⚠
neon
添加返回的 High Narrow。 - vaddhn_s64⚠
neon
添加返回的 High Narrow。 - vaddhn_u16⚠
neon
添加返回的 High Narrow。 - vaddhn_u32⚠
neon
添加返回的 High Narrow。 - vaddhn_u64⚠
neon
添加返回的 High Narrow。 - vaddl_high_s8⚠
neon
有符号添加长度 (vector,高一半)。 - vaddl_high_s16⚠
neon
有符号添加长度 (vector,高一半)。 - vaddl_high_s32⚠
neon
有符号添加长度 (vector,高一半)。 - vaddl_high_u8⚠
neon
无符号添加长度 (vector,高一半)。 - vaddl_high_u16⚠
neon
无符号添加长度 (vector,高一半)。 - vaddl_high_u32⚠
neon
无符号添加长度 (vector,高一半)。 - vaddl_s8⚠
neon
有符号添加长度 (vector)。 - vaddl_s16⚠
neon
有符号添加长度 (vector)。 - vaddl_s32⚠
neon
有符号添加长度 (vector)。 - vaddl_u8⚠
neon
无符号添加长度 (vector)。 - vaddl_u16⚠
neon
无符号添加长度 (vector)。 - vaddl_u32⚠
neon
无符号添加长度 (vector)。 - vaddlv_s8⚠
neon
跨 Vector 签名加长 - vaddlv_s16⚠
neon
跨 Vector 签名加长 - vaddlv_s32⚠
neon
跨 Vector 签名加长 - vaddlv_u8⚠
neon
跨 Vector 的无符号加长 - vaddlv_u16⚠
neon
跨 Vector 的无符号加长 - vaddlv_u32⚠
neon
跨 Vector 的无符号加长 - vaddlvq_s8⚠
neon
跨 Vector 签名加长 - vaddlvq_s16⚠
neon
跨 Vector 签名加长 - vaddlvq_s32⚠
neon
跨 Vector 签名加长 - vaddlvq_u8⚠
neon
跨 Vector 的无符号加长 - vaddlvq_u16⚠
neon
跨 Vector 的无符号加长 - vaddlvq_u32⚠
neon
跨 Vector 的无符号加长 - vaddq_f32⚠
neon
Vector add。 - vaddq_f64⚠
neon
Vector add。 - vaddq_p8⚠
neon
按位异或 - vaddq_p16⚠
neon
按位异或 - vaddq_p64⚠
neon
按位异或 - vaddq_p128⚠
neon
按位异或 - vaddq_s8⚠
neon
Vector add。 - vaddq_s16⚠
neon
Vector add。 - vaddq_s32⚠
neon
Vector add。 - vaddq_s64⚠
neon
Vector add。 - vaddq_u8⚠
neon
Vector add。 - vaddq_u16⚠
neon
Vector add。 - vaddq_u32⚠
neon
Vector add。 - vaddq_u64⚠
neon
Vector add。 - vaddv_f32⚠
neon
跨 vector 的浮点加法 - vaddv_s8⚠
neon
跨 vector 加 - vaddv_s16⚠
neon
跨 vector 加 - vaddv_s32⚠
neon
跨 vector 加 - vaddv_u8⚠
neon
跨 vector 加 - vaddv_u16⚠
neon
跨 vector 加 - vaddv_u32⚠
neon
跨 vector 加 - vaddvq_f32⚠
neon
跨 vector 的浮点加法 - vaddvq_f64⚠
neon
跨 vector 的浮点加法 - vaddvq_s8⚠
neon
跨 vector 加 - vaddvq_s16⚠
neon
跨 vector 加 - vaddvq_s32⚠
neon
跨 vector 加 - vaddvq_s64⚠
neon
跨 vector 加 - vaddvq_u8⚠
neon
跨 vector 加 - vaddvq_u16⚠
neon
跨 vector 加 - vaddvq_u32⚠
neon
跨 vector 加 - vaddvq_u64⚠
neon
跨 vector 加 - vaddw_high_s8⚠
neon
有符号添加宽 (高一半)。 - vaddw_high_s16⚠
neon
有符号添加宽 (高一半)。 - vaddw_high_s32⚠
neon
有符号添加宽 (高一半)。 - vaddw_high_u8⚠
neon
无符号添加宽 (高一半)。 - vaddw_high_u16⚠
neon
无符号添加宽 (高一半)。 - vaddw_high_u32⚠
neon
无符号添加宽 (高一半)。 - vaddw_s8⚠
neon
有符号添加宽。 - vaddw_s16⚠
neon
有符号添加宽。 - vaddw_s32⚠
neon
有符号添加宽。 - vaddw_u8⚠
neon
无符号添加宽。 - vaddw_u16⚠
neon
无符号添加宽。 - vaddw_u32⚠
neon
无符号添加宽。 - vand_s8⚠
neon
Vector 按位和 - vand_s16⚠
neon
Vector 按位和 - vand_s32⚠
neon
Vector 按位和 - vand_s64⚠
neon
Vector 按位和 - vand_u8⚠
neon
Vector 按位和 - vand_u16⚠
neon
Vector 按位和 - vand_u32⚠
neon
Vector 按位和 - vand_u64⚠
neon
Vector 按位和 - vandq_s8⚠
neon
Vector 按位和 - vandq_s16⚠
neon
Vector 按位和 - vandq_s32⚠
neon
Vector 按位和 - vandq_s64⚠
neon
Vector 按位和 - vandq_u8⚠
neon
Vector 按位和 - vandq_u16⚠
neon
Vector 按位和 - vandq_u32⚠
neon
Vector 按位和 - vandq_u64⚠
neon
Vector 按位和 - vbic_s8⚠
neon
矢量按位清除 - vbic_s16⚠
neon
矢量按位清除 - vbic_s32⚠
neon
矢量按位清除 - vbic_s64⚠
neon
矢量按位清除 - vbic_u8⚠
neon
矢量按位清除 - vbic_u16⚠
neon
矢量按位清除 - vbic_u32⚠
neon
矢量按位清除 - vbic_u64⚠
neon
矢量按位清除 - vbicq_s8⚠
neon
矢量按位清除 - vbicq_s16⚠
neon
矢量按位清除 - vbicq_s32⚠
neon
矢量按位清除 - vbicq_s64⚠
neon
矢量按位清除 - vbicq_u8⚠
neon
矢量按位清除 - vbicq_u16⚠
neon
矢量按位清除 - vbicq_u32⚠
neon
矢量按位清除 - vbicq_u64⚠
neon
矢量按位清除 - vbsl_f32⚠
neon
按位选择。 - vbsl_f64⚠
neon
按位选择指令。 当原始目标位为 1 时,该指令将目标 SIMD&FP 寄存器中的每一位设置为来自第一个源 SIMD&FP 寄存器的相应位,否则来自第二个源 SIMD&FP 寄存器。 - vbsl_p8⚠
neon
按位选择。 - vbsl_p16⚠
neon
按位选择。 - vbsl_p64⚠
neon
按位选择。 - vbsl_s8⚠
neon
按位选择指令。 当原始目标位为 1 时,该指令将目标 SIMD&FP 寄存器中的每一位设置为来自第一个源 SIMD&FP 寄存器的相应位,否则来自第二个源 SIMD&FP 寄存器。 - vbsl_s16⚠
neon
按位选择。 - vbsl_s32⚠
neon
按位选择。 - vbsl_s64⚠
neon
按位选择。 - vbsl_u8⚠
neon
按位选择。 - vbsl_u16⚠
neon
按位选择。 - vbsl_u32⚠
neon
按位选择。 - vbsl_u64⚠
neon
按位选择。 - vbslq_f32⚠
neon
按位选择。(128-bit) - vbslq_f64⚠
neon
按位选择。(128-bit) - vbslq_p8⚠
neon
按位选择。(128-bit) - vbslq_p16⚠
neon
按位选择。(128-bit) - vbslq_p64⚠
neon
按位选择。(128-bit) - vbslq_s8⚠
neon
按位选择。(128-bit) - vbslq_s16⚠
neon
按位选择。(128-bit) - vbslq_s32⚠
neon
按位选择。(128-bit) - vbslq_s64⚠
neon
按位选择。(128-bit) - vbslq_u8⚠
neon
按位选择。(128-bit) - vbslq_u16⚠
neon
按位选择。(128-bit) - vbslq_u32⚠
neon
按位选择。(128-bit) - vbslq_u64⚠
neon
按位选择。(128-bit) - vcage_f32⚠
neon
浮点绝对比较大于或等于 - vcage_f64⚠
neon
浮点绝对比较大于或等于 - vcaged_f64⚠
neon
浮点绝对比较大于或等于 - vcageq_f32⚠
neon
浮点绝对比较大于或等于 - vcageq_f64⚠
neon
浮点绝对比较大于或等于 - vcages_f32⚠
neon
浮点绝对比较大于或等于 - vcagt_f32⚠
neon
浮点绝对值比较大于 - vcagt_f64⚠
neon
浮点绝对值比较大于 - vcagtd_f64⚠
neon
浮点绝对值比较大于 - vcagtq_f32⚠
neon
浮点绝对值比较大于 - vcagtq_f64⚠
neon
浮点绝对值比较大于 - vcagts_f32⚠
neon
浮点绝对值比较大于 - vcale_f32⚠
neon
浮点绝对比较小于或等于 - vcale_f64⚠
neon
浮点绝对比较小于或等于 - vcaled_f64⚠
neon
浮点绝对比较小于或等于 - vcaleq_f32⚠
neon
浮点绝对比较小于或等于 - vcaleq_f64⚠
neon
浮点绝对比较小于或等于 - vcales_f32⚠
neon
浮点绝对比较小于或等于 - vcalt_f32⚠
neon
浮点绝对比较小于 - vcalt_f64⚠
neon
浮点绝对比较小于 - vcaltd_f64⚠
neon
浮点绝对比较小于 - vcaltq_f32⚠
neon
浮点绝对比较小于 - vcaltq_f64⚠
neon
浮点绝对比较小于 - vcalts_f32⚠
neon
浮点绝对比较小于 - vceq_f32⚠
neon
浮点比较相等 - vceq_f64⚠
neon
浮点比较相等 - vceq_p8⚠
neon
比较按位等于 (vector) - vceq_p64⚠
neon
比较按位等于 (vector) - vceq_s8⚠
neon
比较按位等于 (vector) - vceq_s16⚠
neon
比较按位等于 (vector) - vceq_s32⚠
neon
比较按位等于 (vector) - vceq_s64⚠
neon
比较按位等于 (vector) - vceq_u8⚠
neon
比较按位等于 (vector) - vceq_u16⚠
neon
比较按位等于 (vector) - vceq_u32⚠
neon
比较按位等于 (vector) - vceq_u64⚠
neon
比较按位等于 (vector) - vceqd_f64⚠
neon
浮点比较相等 - vceqd_s64⚠
neon
按位相等比较 - vceqd_u64⚠
neon
按位相等比较 - vceqq_f32⚠
neon
浮点比较相等 - vceqq_f64⚠
neon
浮点比较相等 - vceqq_p8⚠
neon
比较按位等于 (vector) - vceqq_p64⚠
neon
比较按位等于 (vector) - vceqq_s8⚠
neon
比较按位等于 (vector) - vceqq_s16⚠
neon
比较按位等于 (vector) - vceqq_s32⚠
neon
比较按位等于 (vector) - vceqq_s64⚠
neon
比较按位等于 (vector) - vceqq_u8⚠
neon
比较按位等于 (vector) - vceqq_u16⚠
neon
比较按位等于 (vector) - vceqq_u32⚠
neon
比较按位等于 (vector) - vceqq_u64⚠
neon
比较按位等于 (vector) - vceqs_f32⚠
neon
浮点比较相等 - vceqz_f32⚠
neon
浮点比较按位等于零 - vceqz_f64⚠
neon
浮点比较按位等于零 - vceqz_p8⚠
neon
有符号比较按位等于零 - vceqz_p64⚠
neon
有符号比较按位等于零 - vceqz_s8⚠
neon
有符号比较按位等于零 - vceqz_s16⚠
neon
有符号比较按位等于零 - vceqz_s32⚠
neon
有符号比较按位等于零 - vceqz_s64⚠
neon
有符号比较按位等于零 - vceqz_u8⚠
neon
无符号比较按位等于零 - vceqz_u16⚠
neon
无符号比较按位等于零 - vceqz_u32⚠
neon
无符号比较按位等于零 - vceqz_u64⚠
neon
无符号比较按位等于零 - vceqzd_f64⚠
neon
浮点比较按位等于零 - vceqzd_s64⚠
neon
按位比较等于零 - vceqzd_u64⚠
neon
按位比较等于零 - vceqzq_f32⚠
neon
浮点比较按位等于零 - vceqzq_f64⚠
neon
浮点比较按位等于零 - vceqzq_p8⚠
neon
有符号比较按位等于零 - vceqzq_p64⚠
neon
有符号比较按位等于零 - vceqzq_s8⚠
neon
有符号比较按位等于零 - vceqzq_s16⚠
neon
有符号比较按位等于零 - vceqzq_s32⚠
neon
有符号比较按位等于零 - vceqzq_s64⚠
neon
有符号比较按位等于零 - vceqzq_u8⚠
neon
无符号比较按位等于零 - vceqzq_u16⚠
neon
无符号比较按位等于零 - vceqzq_u32⚠
neon
无符号比较按位等于零 - vceqzq_u64⚠
neon
无符号比较按位等于零 - vceqzs_f32⚠
neon
浮点比较按位等于零 - vcge_f32⚠
neon
浮点比较大于或等于 - vcge_f64⚠
neon
浮点比较大于或等于 - vcge_s8⚠
neon
比较有符号大于或等于 - vcge_s16⚠
neon
比较有符号大于或等于 - vcge_s32⚠
neon
比较有符号大于或等于 - vcge_s64⚠
neon
比较有符号大于或等于 - vcge_u8⚠
neon
比较无符号大于或等于 - vcge_u16⚠
neon
比较无符号大于或等于 - vcge_u32⚠
neon
比较无符号大于或等于 - vcge_u64⚠
neon
比较无符号大于或等于 - vcged_f64⚠
neon
浮点比较大于或等于 - vcged_s64⚠
neon
比较大于或等于 - vcged_u64⚠
neon
比较大于或等于 - vcgeq_f32⚠
neon
浮点比较大于或等于 - vcgeq_f64⚠
neon
浮点比较大于或等于 - vcgeq_s8⚠
neon
比较有符号大于或等于 - vcgeq_s16⚠
neon
比较有符号大于或等于 - vcgeq_s32⚠
neon
比较有符号大于或等于 - vcgeq_s64⚠
neon
比较有符号大于或等于 - vcgeq_u8⚠
neon
比较无符号大于或等于 - vcgeq_u16⚠
neon
比较无符号大于或等于 - vcgeq_u32⚠
neon
比较无符号大于或等于 - vcgeq_u64⚠
neon
比较无符号大于或等于 - vcges_f32⚠
neon
浮点比较大于或等于 - vcgez_f32⚠
neon
浮点比较大于或等于零 - vcgez_f64⚠
neon
浮点比较大于或等于零 - vcgez_s8⚠
neon
比较有符号大于或等于零 - vcgez_s16⚠
neon
比较有符号大于或等于零 - vcgez_s32⚠
neon
比较有符号大于或等于零 - vcgez_s64⚠
neon
比较有符号大于或等于零 - vcgezd_f64⚠
neon
浮点比较大于或等于零 - vcgezd_s64⚠
neon
比较有符号大于或等于零 - vcgezq_f32⚠
neon
浮点比较大于或等于零 - vcgezq_f64⚠
neon
浮点比较大于或等于零 - vcgezq_s8⚠
neon
比较有符号大于或等于零 - vcgezq_s16⚠
neon
比较有符号大于或等于零 - vcgezq_s32⚠
neon
比较有符号大于或等于零 - vcgezq_s64⚠
neon
比较有符号大于或等于零 - vcgezs_f32⚠
neon
浮点比较大于或等于零 - vcgt_f32⚠
neon
浮点比较大于 - vcgt_f64⚠
neon
浮点比较大于 - vcgt_s8⚠
neon
比较有符号大于 - vcgt_s16⚠
neon
比较有符号大于 - vcgt_s32⚠
neon
比较有符号大于 - vcgt_s64⚠
neon
比较有符号大于 - vcgt_u8⚠
neon
比较无符号的高 - vcgt_u16⚠
neon
比较无符号的高 - vcgt_u32⚠
neon
比较无符号的高 - vcgt_u64⚠
neon
比较无符号的高 - vcgtd_f64⚠
neon
浮点比较大于 - vcgtd_s64⚠
neon
比较大于 - vcgtd_u64⚠
neon
比较大于 - vcgtq_f32⚠
neon
浮点比较大于 - vcgtq_f64⚠
neon
浮点比较大于 - vcgtq_s8⚠
neon
比较有符号大于 - vcgtq_s16⚠
neon
比较有符号大于 - vcgtq_s32⚠
neon
比较有符号大于 - vcgtq_s64⚠
neon
比较有符号大于 - vcgtq_u8⚠
neon
比较无符号的高 - vcgtq_u16⚠
neon
比较无符号的高 - vcgtq_u32⚠
neon
比较无符号的高 - vcgtq_u64⚠
neon
比较无符号的高 - vcgts_f32⚠
neon
浮点比较大于 - vcgtz_f32⚠
neon
浮点比较大于零 - vcgtz_f64⚠
neon
浮点比较大于零 - vcgtz_s8⚠
neon
比较有符号大于零 - vcgtz_s16⚠
neon
比较有符号大于零 - vcgtz_s32⚠
neon
比较有符号大于零 - vcgtz_s64⚠
neon
比较有符号大于零 - vcgtzd_f64⚠
neon
浮点比较大于零 - vcgtzd_s64⚠
neon
比较有符号大于零 - vcgtzq_f32⚠
neon
浮点比较大于零 - vcgtzq_f64⚠
neon
浮点比较大于零 - vcgtzq_s8⚠
neon
比较有符号大于零 - vcgtzq_s16⚠
neon
比较有符号大于零 - vcgtzq_s32⚠
neon
比较有符号大于零 - vcgtzq_s64⚠
neon
比较有符号大于零 - vcgtzs_f32⚠
neon
浮点比较大于零 - vcle_f32⚠
neon
浮点比较小于或等于 - vcle_f64⚠
neon
浮点比较小于或等于 - vcle_s8⚠
neon
比较有符号的小于或等于 - vcle_s16⚠
neon
比较有符号的小于或等于 - vcle_s32⚠
neon
比较有符号的小于或等于 - vcle_s64⚠
neon
比较有符号的小于或等于 - vcle_u8⚠
neon
比较无符号小于或等于 - vcle_u16⚠
neon
比较无符号小于或等于 - vcle_u32⚠
neon
比较无符号小于或等于 - vcle_u64⚠
neon
比较无符号小于或等于 - vcled_f64⚠
neon
浮点比较小于或等于 - vcled_s64⚠
neon
比较小于或等于 - vcled_u64⚠
neon
比较小于或等于 - vcleq_f32⚠
neon
浮点比较小于或等于 - vcleq_f64⚠
neon
浮点比较小于或等于 - vcleq_s8⚠
neon
比较有符号的小于或等于 - vcleq_s16⚠
neon
比较有符号的小于或等于 - vcleq_s32⚠
neon
比较有符号的小于或等于 - vcleq_s64⚠
neon
比较有符号的小于或等于 - vcleq_u8⚠
neon
比较无符号小于或等于 - vcleq_u16⚠
neon
比较无符号小于或等于 - vcleq_u32⚠
neon
比较无符号小于或等于 - vcleq_u64⚠
neon
比较无符号小于或等于 - vcles_f32⚠
neon
浮点比较小于或等于 - vclez_f32⚠
neon
浮点比较小于或等于零 - vclez_f64⚠
neon
浮点比较小于或等于零 - vclez_s8⚠
neon
比较有符号小于或等于零 - vclez_s16⚠
neon
比较有符号小于或等于零 - vclez_s32⚠
neon
比较有符号小于或等于零 - vclez_s64⚠
neon
比较有符号小于或等于零 - vclezd_f64⚠
neon
浮点比较小于或等于零 - vclezd_s64⚠
neon
比较小于或等于零 - vclezq_f32⚠
neon
浮点比较小于或等于零 - vclezq_f64⚠
neon
浮点比较小于或等于零 - vclezq_s8⚠
neon
比较有符号小于或等于零 - vclezq_s16⚠
neon
比较有符号小于或等于零 - vclezq_s32⚠
neon
比较有符号小于或等于零 - vclezq_s64⚠
neon
比较有符号小于或等于零 - vclezs_f32⚠
neon
浮点比较小于或等于零 - vcls_s8⚠
neon
计数前导符号位 - vcls_s16⚠
neon
计数前导符号位 - vcls_s32⚠
neon
计数前导符号位 - vcls_u8⚠
neon
计数前导符号位 - vcls_u16⚠
neon
计数前导符号位 - vcls_u32⚠
neon
计数前导符号位 - vclsq_s8⚠
neon
计数前导符号位 - vclsq_s16⚠
neon
计数前导符号位 - vclsq_s32⚠
neon
计数前导符号位 - vclsq_u8⚠
neon
计数前导符号位 - vclsq_u16⚠
neon
计数前导符号位 - vclsq_u32⚠
neon
计数前导符号位 - vclt_f32⚠
neon
浮点比较小于 - vclt_f64⚠
neon
浮点比较小于 - vclt_s8⚠
neon
比较有符号少于 - vclt_s16⚠
neon
比较有符号少于 - vclt_s32⚠
neon
比较有符号少于 - vclt_s64⚠
neon
比较有符号少于 - vclt_u8⚠
neon
比较无符号小于 - vclt_u16⚠
neon
比较无符号小于 - vclt_u32⚠
neon
比较无符号小于 - vclt_u64⚠
neon
比较无符号小于 - vcltd_f64⚠
neon
浮点比较小于 - vcltd_s64⚠
neon
比较小于 - vcltd_u64⚠
neon
比较小于 - vcltq_f32⚠
neon
浮点比较小于 - vcltq_f64⚠
neon
浮点比较小于 - vcltq_s8⚠
neon
比较有符号少于 - vcltq_s16⚠
neon
比较有符号少于 - vcltq_s32⚠
neon
比较有符号少于 - vcltq_s64⚠
neon
比较有符号少于 - vcltq_u8⚠
neon
比较无符号小于 - vcltq_u16⚠
neon
比较无符号小于 - vcltq_u32⚠
neon
比较无符号小于 - vcltq_u64⚠
neon
比较无符号小于 - vclts_f32⚠
neon
浮点比较小于 - vcltz_f32⚠
neon
浮点比较小于零 - vcltz_f64⚠
neon
浮点比较小于零 - vcltz_s8⚠
neon
比较有符号小于零 - vcltz_s16⚠
neon
比较有符号小于零 - vcltz_s32⚠
neon
比较有符号小于零 - vcltz_s64⚠
neon
比较有符号小于零 - vcltzd_f64⚠
neon
浮点比较小于零 - vcltzd_s64⚠
neon
比较小于零 - vcltzq_f32⚠
neon
浮点比较小于零 - vcltzq_f64⚠
neon
浮点比较小于零 - vcltzq_s8⚠
neon
比较有符号小于零 - vcltzq_s16⚠
neon
比较有符号小于零 - vcltzq_s32⚠
neon
比较有符号小于零 - vcltzq_s64⚠
neon
比较有符号小于零 - vcltzs_f32⚠
neon
浮点比较小于零 - vclz_s8⚠
neon
计数前导零位 - vclz_s16⚠
neon
计数前导零位 - vclz_s32⚠
neon
计数前导零位 - vclz_u8⚠
neon
计数前导零位 - vclz_u16⚠
neon
计数前导零位 - vclz_u32⚠
neon
计数前导零位 - vclzq_s8⚠
neon
计数前导零位 - vclzq_s16⚠
neon
计数前导零位 - vclzq_s32⚠
neon
计数前导零位 - vclzq_u8⚠
neon
计数前导零位 - vclzq_u16⚠
neon
计数前导零位 - vclzq_u32⚠
neon
计数前导零位 - vcnt_p8⚠
neon
每个字节的填充计数。 - vcnt_s8⚠
neon
每个字节的填充计数。 - vcnt_u8⚠
neon
每个字节的填充计数。 - vcntq_p8⚠
neon
每个字节的填充计数。 - vcntq_s8⚠
neon
每个字节的填充计数。 - vcntq_u8⚠
neon
每个字节的填充计数。 - vcombine_f32⚠
neon
Vector 结合 - vcombine_f64⚠
neon
Vector 结合 - vcombine_p8⚠
neon
Vector 结合 - vcombine_p16⚠
neon
Vector 结合 - vcopy_lane_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_lane_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_lane_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_lane_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_lane_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_laneq_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_laneq_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_laneq_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopy_laneq_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopy_laneq_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vcopyq_lane_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_f64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_p64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_s64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_lane_u64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_f64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_p64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_s64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcopyq_laneq_u64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_f64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_p64⚠
neon,aes
从另一个 vector 元素插入 vector 元素 - vcreate_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_s64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vcreate_u64⚠
neon
从另一个 vector 元素插入 vector 元素 - vcvt_f32_f64⚠
neon
浮点数转换为低精度 narrow - vcvt_f32_s32⚠
neon
定点转换为浮点 - vcvt_f32_u32⚠
neon
定点转换为浮点 - vcvt_f64_f32⚠
neon
浮点数转换为更高精度的 long - vcvt_f64_s64⚠
neon
定点转换为浮点 - vcvt_f64_u64⚠
neon
定点转换为浮点 - vcvt_high_f32_f64⚠
neon
浮点数转换为低精度 narrow - vcvt_high_f64_f32⚠
neon
浮点数转换为更高精度的 long - vcvt_n_f64_s64⚠
neon
定点转换为浮点 - vcvt_n_f64_u64⚠
neon
定点转换为浮点 - vcvt_n_s64_f64⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvt_n_u64_f64⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvt_s32_f32⚠
neon
浮点转换为有符号的定点,四舍五入为零 - vcvt_s64_f64⚠
neon
浮点转换为有符号的定点,四舍五入为零 - vcvt_u32_f32⚠
neon
浮点转换为无符号定点,四舍五入为零 - vcvt_u64_f64⚠
neon
浮点转换为无符号定点,四舍五入为零 - vcvta_s32_f32⚠
neon
浮点转换为有符号整数,四舍五入到最接近的整数 - vcvta_s64_f64⚠
neon
浮点转换为有符号整数,四舍五入到最接近的整数 - vcvta_u32_f32⚠
neon
浮点数转换为无符号整数,四舍五入到最接近的整数 - vcvta_u64_f64⚠
neon
浮点数转换为无符号整数,四舍五入到最接近的整数 - vcvtad_s64_f64⚠
neon
浮点数转换为整数,四舍五入到最接近的整数 - vcvtad_u64_f64⚠
neon
浮点数转换为整数,四舍五入到最接近的整数 - vcvtaq_s32_f32⚠
neon
浮点转换为有符号整数,四舍五入到最接近的整数 - vcvtaq_s64_f64⚠
neon
浮点转换为有符号整数,四舍五入到最接近的整数 - vcvtaq_u32_f32⚠
neon
浮点数转换为无符号整数,四舍五入到最接近的整数 - vcvtaq_u64_f64⚠
neon
浮点数转换为无符号整数,四舍五入到最接近的整数 - vcvtas_s32_f32⚠
neon
浮点数转换为整数,四舍五入到最接近的整数 - vcvtas_u32_f32⚠
neon
浮点数转换为整数,四舍五入到最接近的整数 - vcvtd_f64_s64⚠
neon
定点转换为浮点 - vcvtd_f64_u64⚠
neon
定点转换为浮点 - vcvtd_n_f64_s64⚠
neon
定点转换为浮点 - vcvtd_n_f64_u64⚠
neon
定点转换为浮点 - vcvtd_n_s64_f64⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvtd_n_u64_f64⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvtd_s64_f64⚠
neon
定点转换为浮点 - vcvtd_u64_f64⚠
neon
定点转换为浮点 - vcvtm_s32_f32⚠
neon
浮点转换为有符号整数,向负无穷四舍五入 - vcvtm_s64_f64⚠
neon
浮点转换为有符号整数,向负无穷四舍五入 - vcvtm_u32_f32⚠
neon
浮点数转换为无符号整数,向负无穷四舍五入 - vcvtm_u64_f64⚠
neon
浮点数转换为无符号整数,向负无穷四舍五入 - vcvtmd_s64_f64⚠
neon
浮点转换为有符号整数,向负无穷四舍五入 - vcvtmd_u64_f64⚠
neon
浮点数转换为无符号整数,向负无穷四舍五入 - vcvtmq_s32_f32⚠
neon
浮点转换为有符号整数,向负无穷四舍五入 - vcvtmq_s64_f64⚠
neon
浮点转换为有符号整数,向负无穷四舍五入 - vcvtmq_u32_f32⚠
neon
浮点数转换为无符号整数,向负无穷四舍五入 - vcvtmq_u64_f64⚠
neon
浮点数转换为无符号整数,向负无穷四舍五入 - vcvtms_s32_f32⚠
neon
浮点转换为有符号整数,向负无穷四舍五入 - vcvtms_u32_f32⚠
neon
浮点数转换为无符号整数,向负无穷四舍五入 - vcvtn_s32_f32⚠
neon
浮点数转换为有符号整数,四舍五入到最接近的与偶数的关系 - vcvtn_s64_f64⚠
neon
浮点数转换为有符号整数,四舍五入到最接近的与偶数的关系 - vcvtn_u32_f32⚠
neon
浮点转换为无符号整数,四舍五入到最接近的偶数 - vcvtn_u64_f64⚠
neon
浮点转换为无符号整数,四舍五入到最接近的偶数 - vcvtnd_s64_f64⚠
neon
浮点数转换为有符号整数,四舍五入到最接近的与偶数的关系 - vcvtnd_u64_f64⚠
neon
浮点转换为无符号整数,四舍五入到最接近的偶数 - vcvtnq_s32_f32⚠
neon
浮点数转换为有符号整数,四舍五入到最接近的与偶数的关系 - vcvtnq_s64_f64⚠
neon
浮点数转换为有符号整数,四舍五入到最接近的与偶数的关系 - vcvtnq_u32_f32⚠
neon
浮点转换为无符号整数,四舍五入到最接近的偶数 - vcvtnq_u64_f64⚠
neon
浮点转换为无符号整数,四舍五入到最接近的偶数 - vcvtns_s32_f32⚠
neon
浮点数转换为有符号整数,四舍五入到最接近的与偶数的关系 - vcvtns_u32_f32⚠
neon
浮点转换为无符号整数,四舍五入到最接近的偶数 - vcvtp_s32_f32⚠
neon
浮点转换为有符号整数,向正无穷大四舍五入 - vcvtp_s64_f64⚠
neon
浮点转换为有符号整数,向正无穷大四舍五入 - vcvtp_u32_f32⚠
neon
浮点数转换为无符号整数,向正无穷大四舍五入 - vcvtp_u64_f64⚠
neon
浮点数转换为无符号整数,向正无穷大四舍五入 - vcvtpd_s64_f64⚠
neon
浮点转换为有符号整数,向正无穷大四舍五入 - vcvtpd_u64_f64⚠
neon
浮点数转换为无符号整数,向正无穷大四舍五入 - vcvtpq_s32_f32⚠
neon
浮点转换为有符号整数,向正无穷大四舍五入 - vcvtpq_s64_f64⚠
neon
浮点转换为有符号整数,向正无穷大四舍五入 - vcvtpq_u32_f32⚠
neon
浮点数转换为无符号整数,向正无穷大四舍五入 - vcvtpq_u64_f64⚠
neon
浮点数转换为无符号整数,向正无穷大四舍五入 - vcvtps_s32_f32⚠
neon
浮点转换为有符号整数,向正无穷大四舍五入 - vcvtps_u32_f32⚠
neon
浮点数转换为无符号整数,向正无穷大四舍五入 - vcvtq_f32_s32⚠
neon
定点转换为浮点 - vcvtq_f32_u32⚠
neon
定点转换为浮点 - vcvtq_f64_s64⚠
neon
定点转换为浮点 - vcvtq_f64_u64⚠
neon
定点转换为浮点 - vcvtq_n_f64_s64⚠
neon
定点转换为浮点 - vcvtq_n_f64_u64⚠
neon
定点转换为浮点 - vcvtq_n_s64_f64⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvtq_n_u64_f64⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvtq_s32_f32⚠
neon
浮点转换为有符号的定点,四舍五入为零 - vcvtq_s64_f64⚠
neon
浮点转换为有符号的定点,四舍五入为零 - vcvtq_u32_f32⚠
neon
浮点转换为无符号定点,四舍五入为零 - vcvtq_u64_f64⚠
neon
浮点转换为无符号定点,四舍五入为零 - vcvts_f32_s32⚠
neon
定点转换为浮点 - vcvts_f32_u32⚠
neon
定点转换为浮点 - vcvts_n_f32_s32⚠
neon
定点转换为浮点 - vcvts_n_f32_u32⚠
neon
定点转换为浮点 - vcvts_n_s32_f32⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvts_n_u32_f32⚠
neon
浮点数转换为定点数,四舍五入为零 - vcvts_s32_f32⚠
neon
定点转换为浮点 - vcvts_u32_f32⚠
neon
定点转换为浮点 - vcvtx_f32_f64⚠
neon
浮点数转换为低精度 narrow,四舍五入为奇数 - vcvtx_high_f32_f64⚠
neon
浮点数转换为低精度 narrow,四舍五入为奇数 - vcvtxd_f32_f64⚠
neon
浮点数转换为低精度 narrow,四舍五入为奇数 - vdiv_f32⚠
neon
Divide - vdiv_f64⚠
neon
Divide - vdivq_f32⚠
neon
Divide - vdivq_f64⚠
neon
Divide - vdup_lane_f32⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_f64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_p8⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_p16⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_p64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_s8⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_s16⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_s32⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_s64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_u8⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_u16⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_u32⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_lane_u64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_f32⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_f64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_p8⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_p16⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_p64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_s8⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_s16⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_s32⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_s64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_u8⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_u16⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_u32⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_laneq_u64⚠
neon
将所有 vector lanes 设置为相同的值 - vdup_n_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_p8⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_p16⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_s8⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_s16⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_s32⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_u8⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_u16⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_u32⚠
neon
将 vector 元素复制到 vector 或标量 - vdup_n_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vdupb_lane_p8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupb_lane_s8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupb_lane_u8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupb_laneq_p8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupb_laneq_s8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupb_laneq_u8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupd_lane_f64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupd_lane_s64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupd_lane_u64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupd_laneq_f64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupd_laneq_s64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupd_laneq_u64⚠
neon
将所有 vector lanes 设置为相同的值 - vduph_lane_p16⚠
neon
将所有 vector lanes 设置为相同的值 - vduph_lane_s16⚠
neon
将所有 vector lanes 设置为相同的值 - vduph_lane_u16⚠
neon
将所有 vector lanes 设置为相同的值 - vduph_laneq_p16⚠
neon
将所有 vector lanes 设置为相同的值 - vduph_laneq_s16⚠
neon
将所有 vector lanes 设置为相同的值 - vduph_laneq_u16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_f32⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_f64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_p8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_p16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_p64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_s8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_s16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_s32⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_s64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_u8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_u16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_u32⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_lane_u64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_f32⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_f64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_p8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_p16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_p64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_s8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_s16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_s32⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_s64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_u8⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_u16⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_u32⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_laneq_u64⚠
neon
将所有 vector lanes 设置为相同的值 - vdupq_n_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_p8⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_p16⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_s8⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_s16⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_s32⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_u8⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_u16⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_u32⚠
neon
将 vector 元素复制到 vector 或标量 - vdupq_n_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vdups_lane_f32⚠
neon
将所有 vector lanes 设置为相同的值 - vdups_lane_s32⚠
neon
将所有 vector lanes 设置为相同的值 - vdups_lane_u32⚠
neon
将所有 vector lanes 设置为相同的值 - vdups_laneq_f32⚠
neon
将所有 vector lanes 设置为相同的值 - vdups_laneq_s32⚠
neon
将所有 vector lanes 设置为相同的值 - vdups_laneq_u32⚠
neon
将所有 vector lanes 设置为相同的值 - veor_s8⚠
neon
Vector 按位互斥或 (vector) - veor_s16⚠
neon
Vector 按位互斥或 (vector) - veor_s32⚠
neon
Vector 按位互斥或 (vector) - veor_s64⚠
neon
Vector 按位互斥或 (vector) - veor_u8⚠
neon
Vector 按位互斥或 (vector) - veor_u16⚠
neon
Vector 按位互斥或 (vector) - veor_u32⚠
neon
Vector 按位互斥或 (vector) - veor_u64⚠
neon
Vector 按位互斥或 (vector) - veorq_s8⚠
neon
Vector 按位互斥或 (vector) - veorq_s16⚠
neon
Vector 按位互斥或 (vector) - veorq_s32⚠
neon
Vector 按位互斥或 (vector) - veorq_s64⚠
neon
Vector 按位互斥或 (vector) - veorq_u8⚠
neon
Vector 按位互斥或 (vector) - veorq_u16⚠
neon
Vector 按位互斥或 (vector) - veorq_u32⚠
neon
Vector 按位互斥或 (vector) - veorq_u64⚠
neon
Vector 按位互斥或 (vector) - vext_f32⚠
neon
从 vectors 对中提取 vector - vext_f64⚠
neon
从 vectors 对中提取 vector - vext_p8⚠
neon
从 vectors 对中提取 vector - vext_p16⚠
neon
从 vectors 对中提取 vector - vext_p64⚠
neon
从 vectors 对中提取 vector - vext_s8⚠
neon
从 vectors 对中提取 vector - vext_s16⚠
neon
从 vectors 对中提取 vector - vext_s32⚠
neon
从 vectors 对中提取 vector - vext_s64⚠
neon
从 vectors 对中提取 vector - vext_u8⚠
neon
从 vectors 对中提取 vector - vext_u16⚠
neon
从 vectors 对中提取 vector - vext_u32⚠
neon
从 vectors 对中提取 vector - vext_u64⚠
neon
从 vectors 对中提取 vector - vextq_f32⚠
neon
从 vectors 对中提取 vector - vextq_f64⚠
neon
从 vectors 对中提取 vector - vextq_p8⚠
neon
从 vectors 对中提取 vector - vextq_p16⚠
neon
从 vectors 对中提取 vector - vextq_p64⚠
neon
从 vectors 对中提取 vector - vextq_s8⚠
neon
从 vectors 对中提取 vector - vextq_s16⚠
neon
从 vectors 对中提取 vector - vextq_s32⚠
neon
从 vectors 对中提取 vector - vextq_s64⚠
neon
从 vectors 对中提取 vector - vextq_u8⚠
neon
从 vectors 对中提取 vector - vextq_u16⚠
neon
从 vectors 对中提取 vector - vextq_u32⚠
neon
从 vectors 对中提取 vector - vextq_u64⚠
neon
从 vectors 对中提取 vector - vfma_f32⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfma_f64⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfma_lane_f32⚠
neon
浮点融合乘加累加器 - vfma_lane_f64⚠
neon
浮点融合乘加累加器 - vfma_laneq_f32⚠
neon
浮点融合乘加累加器 - vfma_laneq_f64⚠
neon
浮点融合乘加累加器 - vfma_n_f32⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfma_n_f64⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfmad_lane_f64⚠
neon
浮点融合乘加累加器 - vfmad_laneq_f64⚠
neon
浮点融合乘加累加器 - vfmaq_f32⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfmaq_f64⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfmaq_lane_f32⚠
neon
浮点融合乘加累加器 - vfmaq_lane_f64⚠
neon
浮点融合乘加累加器 - vfmaq_laneq_f32⚠
neon
浮点融合乘加累加器 - vfmaq_laneq_f64⚠
neon
浮点融合乘加累加器 - vfmaq_n_f32⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfmaq_n_f64⚠
neon
浮点融合的乘加累加器 accumulator(vector) - vfmas_lane_f32⚠
neon
浮点融合乘加累加器 - vfmas_laneq_f32⚠
neon
浮点融合乘加累加器 - vfms_f32⚠
neon
从累加器中进行浮点相乘相减 - vfms_f64⚠
neon
从累加器中进行浮点相乘相减 - vfms_lane_f32⚠
neon
浮点融合乘减累加器 - vfms_lane_f64⚠
neon
浮点融合乘减累加器 - vfms_laneq_f32⚠
neon
浮点融合乘减累加器 - vfms_laneq_f64⚠
neon
浮点融合乘减累加器 - vfms_n_f32⚠
neon
浮点相乘相减到累加器 accumulator(vector) - vfms_n_f64⚠
neon
浮点相乘相减到累加器 accumulator(vector) - vfmsd_lane_f64⚠
neon
浮点融合乘减累加器 - vfmsd_laneq_f64⚠
neon
浮点融合乘减累加器 - vfmsq_f32⚠
neon
从累加器中进行浮点相乘相减 - vfmsq_f64⚠
neon
从累加器中进行浮点相乘相减 - vfmsq_lane_f32⚠
neon
浮点融合乘减累加器 - vfmsq_lane_f64⚠
neon
浮点融合乘减累加器 - vfmsq_laneq_f32⚠
neon
浮点融合乘减累加器 - vfmsq_laneq_f64⚠
neon
浮点融合乘减累加器 - vfmsq_n_f32⚠
neon
浮点相乘相减到累加器 accumulator(vector) - vfmsq_n_f64⚠
neon
浮点相乘相减到累加器 accumulator(vector) - vfmss_lane_f32⚠
neon
浮点融合乘减累加器 - vfmss_laneq_f32⚠
neon
浮点融合乘减累加器 - vget_high_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_p8⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_p16⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_s8⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_s16⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_s32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_u8⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_u16⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_u32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_high_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_lane_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_lane_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_lane_p8⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_p16⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_p64⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_s8⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_s16⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_s32⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_s64⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_u8⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_u16⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_u32⚠
neon
将 vector 元素移至通用寄存器 - vget_lane_u64⚠
neon
将 vector 元素移至通用寄存器 - vget_low_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_p8⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_p16⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_s8⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_s16⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_s32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_u8⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_u16⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_u32⚠
neon
将 vector 元素复制到 vector 或标量 - vget_low_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vgetq_lane_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vgetq_lane_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vgetq_lane_p8⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_p16⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_p64⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_s8⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_s16⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_s32⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_s64⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_u8⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_u16⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_u32⚠
neon
将 vector 元素移至通用寄存器 - vgetq_lane_u64⚠
neon
将 vector 元素移至通用寄存器 - vhadd_s8⚠
neon
减半添加 - vhadd_s16⚠
neon
减半添加 - vhadd_s32⚠
neon
减半添加 - vhadd_u8⚠
neon
减半添加 - vhadd_u16⚠
neon
减半添加 - vhadd_u32⚠
neon
减半添加 - vhaddq_s8⚠
neon
减半添加 - vhaddq_s16⚠
neon
减半添加 - vhaddq_s32⚠
neon
减半添加 - vhaddq_u8⚠
neon
减半添加 - vhaddq_u16⚠
neon
减半添加 - vhaddq_u32⚠
neon
减半添加 - vhsub_s8⚠
neon
有符号减半相减 - vhsub_s16⚠
neon
有符号减半相减 - vhsub_s32⚠
neon
有符号减半相减 - vhsub_u8⚠
neon
有符号减半相减 - vhsub_u16⚠
neon
有符号减半相减 - vhsub_u32⚠
neon
有符号减半相减 - vhsubq_s8⚠
neon
有符号减半相减 - vhsubq_s16⚠
neon
有符号减半相减 - vhsubq_s32⚠
neon
有符号减半相减 - vhsubq_u8⚠
neon
有符号减半相减 - vhsubq_u16⚠
neon
有符号减半相减 - vhsubq_u32⚠
neon
有符号减半相减 - vld1_dup_f32⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_f64⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_dup_p8⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_p16⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_p64⚠
neon,aes
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_s8⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_s16⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_s32⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_s64⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_u8⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_u16⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_u32⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_dup_u64⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1_f32⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_f32_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_f32_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_f32_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_f64⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_f64_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_f64_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_f64_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_lane_f32⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_f64⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_p8⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_p16⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_p64⚠
neon,aes
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_s8⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_s16⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_s32⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_s64⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_u8⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_u16⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_u32⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_lane_u64⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1_p8⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_p8_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p8_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p8_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p16⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_p16_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p16_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p16_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p64⚠
neon,aes
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_p64_x2⚠
neon,aes
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p64_x3⚠
neon,aes
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_p64_x4⚠
neon,aes
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s8⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_s8_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s8_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s8_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s16⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_s16_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s16_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s16_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s32⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_s32_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s32_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s32_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s64⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_s64_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s64_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_s64_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u8⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_u8_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u8_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u8_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u16⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_u16_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u16_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u16_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u32⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_u32_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u32_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u32_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u64⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1_u64_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u64_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1_u64_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_dup_f32⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_f64⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_dup_p8⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_p16⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_p64⚠
neon,aes
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_s8⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_s16⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_s32⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_s64⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_u8⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_u16⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_u32⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_dup_u64⚠
neon
加载一个单一元素结构体,然后复制到所有 lanes (一个寄存器)。 - vld1q_f32⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_f32_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_f32_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_f32_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_f64⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_f64_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_f64_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_f64_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_lane_f32⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_f64⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_p8⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_p16⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_p64⚠
neon,aes
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_s8⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_s16⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_s32⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_s64⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_u8⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_u16⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_u32⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_lane_u64⚠
neon
将一个单一元素结构体加载到一个寄存器的一个 lane 中。 - vld1q_p8⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_p8_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p8_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p8_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p16⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_p16_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p16_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p16_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p64⚠
neon,aes
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_p64_x2⚠
neon,aes
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p64_x3⚠
neon,aes
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_p64_x4⚠
neon,aes
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s8⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_s8_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s8_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s8_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s16⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_s16_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s16_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s16_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s32⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_s32_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s32_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s32_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s64⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_s64_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s64_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_s64_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u8⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_u8_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u8_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u8_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u16⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_u16_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u16_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u16_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u32⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_u32_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u32_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u32_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u64⚠
neon
将多个单一元素结构加载到一个,两个,三个或四个寄存器中。 - vld1q_u64_x2⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u64_x3⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld1q_u64_x4⚠
neon
将多个单一元素结构加载到一个、两个、三个或四个寄存器中 - vld2_dup_f64⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_p8⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_p16⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_p64⚠
neon,aes
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_u8⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_u16⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_u32⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_dup_u64⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2_f64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_f64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_p8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_p16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_p64⚠
neon,aes
将多个 2 元素结构加载到两个寄存器 - vld2_lane_s64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_u8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_u16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_u32⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_lane_u64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_p8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_p16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_p64⚠
neon,aes
将多个 2 元素结构加载到两个寄存器 - vld2_u8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_u16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_u32⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2_u64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_dup_f64⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_p8⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_p16⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_p64⚠
neon,aes
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_s64⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_u8⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_u16⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_u32⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_dup_u64⚠
neon
加载单个 2 元素结构体并复制到两个寄存器的所有 lanes - vld2q_f64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_f64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_p8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_p16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_p64⚠
neon,aes
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_s8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_s64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_u8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_u16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_u32⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_lane_u64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_p8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_p16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_p64⚠
neon,aes
将多个 2 元素结构加载到两个寄存器 - vld2q_s64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_u8⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_u16⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_u32⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld2q_u64⚠
neon
将多个 2 元素结构加载到两个寄存器 - vld3_dup_f64⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_p8⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_p16⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_p64⚠
neon,aes
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_u8⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_u16⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_u32⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_dup_u64⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3_f64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_f64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_p8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_p16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_p64⚠
neon,aes
将多个 3 元素结构加载到三个寄存器 - vld3_lane_s64⚠
neon
将多个 3 元素结构加载到两个寄存器 - vld3_lane_u8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_u16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_u32⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_lane_u64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_p8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_p16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_p64⚠
neon,aes
将多个 3 元素结构加载到三个寄存器 - vld3_u8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_u16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_u32⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3_u64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_dup_f64⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_p8⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_p16⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_p64⚠
neon,aes
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_s64⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_u8⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_u16⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_u32⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_dup_u64⚠
neon
加载单个 3 元素结构体并复制到三个寄存器的所有 lanes - vld3q_f64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_f64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_p8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_p16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_p64⚠
neon,aes
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_s8⚠
neon
将多个 3 元素结构加载到两个寄存器 - vld3q_lane_s64⚠
neon
将多个 3 元素结构加载到两个寄存器 - vld3q_lane_u8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_u16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_u32⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_lane_u64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_p8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_p16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_p64⚠
neon,aes
将多个 3 元素结构加载到三个寄存器 - vld3q_s64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_u8⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_u16⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_u32⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld3q_u64⚠
neon
将多个 3 元素结构加载到三个寄存器 - vld4_dup_f64⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_p8⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_p16⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_p64⚠
neon,aes
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_u8⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_u16⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_u32⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_dup_u64⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4_f64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_f64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_p8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_p16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_p64⚠
neon,aes
将多个 4 元素结构加载到四个寄存器 - vld4_lane_s64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_u8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_u16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_u32⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_lane_u64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_p8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_p16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_p64⚠
neon,aes
将多个 4 元素结构加载到四个寄存器 - vld4_u8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_u16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_u32⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4_u64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_dup_f64⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_p8⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_p16⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_p64⚠
neon,aes
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_s64⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_u8⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_u16⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_u32⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_dup_u64⚠
neon
加载单个 4 元素结构体并复制到四个寄存器的所有 lanes - vld4q_f64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_f64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_p8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_p16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_p64⚠
neon,aes
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_s8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_s64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_u8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_u16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_u32⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_lane_u64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_p8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_p16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_p64⚠
neon,aes
将多个 4 元素结构加载到四个寄存器 - vld4q_s64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_u8⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_u16⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_u32⚠
neon
将多个 4 元素结构加载到四个寄存器 - vld4q_u64⚠
neon
将多个 4 元素结构加载到四个寄存器 - vldrq_p128⚠
neon
加载 SIMD&FP 寄存器 (immediate 偏移量) - vmax_f32⚠
neon
最大 (vector) - vmax_f64⚠
neon
最大 (vector) - vmax_s8⚠
neon
最大 (vector) - vmax_s16⚠
neon
最大 (vector) - vmax_s32⚠
neon
最大 (vector) - vmax_u8⚠
neon
最大 (vector) - vmax_u16⚠
neon
最大 (vector) - vmax_u32⚠
neon
最大 (vector) - vmaxnm_f32⚠
neon
浮点数最大数 (vector) - vmaxnm_f64⚠
neon
浮点数最大数 (vector) - vmaxnmq_f32⚠
neon
浮点数最大数 (vector) - vmaxnmq_f64⚠
neon
浮点数最大数 (vector) - vmaxnmv_f32⚠
neon
vector 上的最大浮点数 - vmaxnmvq_f32⚠
neon
vector 上的最大浮点数 - vmaxnmvq_f64⚠
neon
vector 上的最大浮点数 - vmaxq_f32⚠
neon
最大 (vector) - vmaxq_f64⚠
neon
最大 (vector) - vmaxq_s8⚠
neon
最大 (vector) - vmaxq_s16⚠
neon
最大 (vector) - vmaxq_s32⚠
neon
最大 (vector) - vmaxq_u8⚠
neon
最大 (vector) - vmaxq_u16⚠
neon
最大 (vector) - vmaxq_u32⚠
neon
最大 (vector) - vmaxv_f32⚠
neon
水平 vector 最大值。 - vmaxv_s8⚠
neon
水平 vector 最大值。 - vmaxv_s16⚠
neon
水平 vector 最大值。 - vmaxv_s32⚠
neon
水平 vector 最大值。 - vmaxv_u8⚠
neon
水平 vector 最大值。 - vmaxv_u16⚠
neon
水平 vector 最大值。 - vmaxv_u32⚠
neon
水平 vector 最大值。 - vmaxvq_f32⚠
neon
水平 vector 最大值。 - vmaxvq_f64⚠
neon
水平 vector 最大值。 - vmaxvq_s8⚠
neon
水平 vector 最大值。 - vmaxvq_s16⚠
neon
水平 vector 最大值。 - vmaxvq_s32⚠
neon
水平 vector 最大值。 - vmaxvq_u8⚠
neon
水平 vector 最大值。 - vmaxvq_u16⚠
neon
水平 vector 最大值。 - vmaxvq_u32⚠
neon
水平 vector 最大值。 - vmin_f32⚠
neon
最小 (vector) - vmin_f64⚠
neon
最小 (vector) - vmin_s8⚠
neon
最小 (vector) - vmin_s16⚠
neon
最小 (vector) - vmin_s32⚠
neon
最小 (vector) - vmin_u8⚠
neon
最小 (vector) - vmin_u16⚠
neon
最小 (vector) - vmin_u32⚠
neon
最小 (vector) - vminnm_f32⚠
neon
浮点最小数 (vector) - vminnm_f64⚠
neon
浮点最小数 (vector) - vminnmq_f32⚠
neon
浮点最小数 (vector) - vminnmq_f64⚠
neon
浮点最小数 (vector) - vminnmv_f32⚠
neon
vector 上的浮点最小数 - vminnmvq_f32⚠
neon
vector 上的浮点最小数 - vminnmvq_f64⚠
neon
vector 上的浮点最小数 - vminq_f32⚠
neon
最小 (vector) - vminq_f64⚠
neon
最小 (vector) - vminq_s8⚠
neon
最小 (vector) - vminq_s16⚠
neon
最小 (vector) - vminq_s32⚠
neon
最小 (vector) - vminq_u8⚠
neon
最小 (vector) - vminq_u16⚠
neon
最小 (vector) - vminq_u32⚠
neon
最小 (vector) - vminv_f32⚠
neon
水平 vector 最小值 - vminv_s8⚠
neon
水平 vector 最小值 - vminv_s16⚠
neon
水平 vector 最小值 - vminv_s32⚠
neon
水平 vector 最小值 - vminv_u8⚠
neon
水平 vector 最小值 - vminv_u16⚠
neon
水平 vector 最小值 - vminv_u32⚠
neon
水平 vector 最小值 - vminvq_f32⚠
neon
水平 vector 最小值 - vminvq_f64⚠
neon
水平 vector 最小值 - vminvq_s8⚠
neon
水平 vector 最小值 - vminvq_s16⚠
neon
水平 vector 最小值 - vminvq_s32⚠
neon
水平 vector 最小值 - vminvq_u8⚠
neon
水平 vector 最小值 - vminvq_u16⚠
neon
水平 vector 最小值 - vminvq_u32⚠
neon
水平 vector 最小值 - vmla_f32⚠
neon
浮点乘加累加器 - vmla_f64⚠
neon
浮点乘加累加器 - vmla_lane_f32⚠
neon
向量与标量相乘累加 - vmla_lane_s16⚠
neon
向量与标量相乘累加 - vmla_lane_s32⚠
neon
向量与标量相乘累加 - vmla_lane_u16⚠
neon
向量与标量相乘累加 - vmla_lane_u32⚠
neon
向量与标量相乘累加 - vmla_laneq_f32⚠
neon
向量与标量相乘累加 - vmla_laneq_s16⚠
neon
向量与标量相乘累加 - vmla_laneq_s32⚠
neon
向量与标量相乘累加 - vmla_laneq_u16⚠
neon
向量与标量相乘累加 - vmla_laneq_u32⚠
neon
向量与标量相乘累加 - vmla_n_f32⚠
neon
向量与标量相乘累加 - vmla_n_s16⚠
neon
向量与标量相乘累加 - vmla_n_s32⚠
neon
向量与标量相乘累加 - vmla_n_u16⚠
neon
向量与标量相乘累加 - vmla_n_u32⚠
neon
向量与标量相乘累加 - vmla_s8⚠
neon
乘加到累加器 - vmla_s16⚠
neon
乘加到累加器 - vmla_s32⚠
neon
乘加到累加器 - vmla_u8⚠
neon
乘加到累加器 - vmla_u16⚠
neon
乘加到累加器 - vmla_u32⚠
neon
乘加到累加器 - vmlal_high_lane_s16⚠
neon
乘加长 - vmlal_high_lane_s32⚠
neon
乘加长 - vmlal_high_lane_u16⚠
neon
乘加长 - vmlal_high_lane_u32⚠
neon
乘加长 - vmlal_high_laneq_s16⚠
neon
乘加长 - vmlal_high_laneq_s32⚠
neon
乘加长 - vmlal_high_laneq_u16⚠
neon
乘加长 - vmlal_high_laneq_u32⚠
neon
乘加长 - vmlal_high_n_s16⚠
neon
乘加长 - vmlal_high_n_s32⚠
neon
乘加长 - vmlal_high_n_u16⚠
neon
乘加长 - vmlal_high_n_u32⚠
neon
乘加长 - vmlal_high_s8⚠
neon
有符号乘加长 - vmlal_high_s16⚠
neon
有符号乘加长 - vmlal_high_s32⚠
neon
有符号乘加长 - vmlal_high_u8⚠
neon
无符号乘加长 - vmlal_high_u16⚠
neon
无符号乘加长 - vmlal_high_u32⚠
neon
无符号乘加长 - vmlal_lane_s16⚠
neon
向量加宽乘积与标量 - vmlal_lane_s32⚠
neon
向量加宽乘积与标量 - vmlal_lane_u16⚠
neon
向量加宽乘积与标量 - vmlal_lane_u32⚠
neon
向量加宽乘积与标量 - vmlal_laneq_s16⚠
neon
向量加宽乘积与标量 - vmlal_laneq_s32⚠
neon
向量加宽乘积与标量 - vmlal_laneq_u16⚠
neon
向量加宽乘积与标量 - vmlal_laneq_u32⚠
neon
向量加宽乘积与标量 - vmlal_n_s16⚠
neon
向量加宽乘积与标量 - vmlal_n_s32⚠
neon
向量加宽乘积与标量 - vmlal_n_u16⚠
neon
向量加宽乘积与标量 - vmlal_n_u32⚠
neon
向量加宽乘积与标量 - vmlal_s8⚠
neon
有符号乘加长 - vmlal_s16⚠
neon
有符号乘加长 - vmlal_s32⚠
neon
有符号乘加长 - vmlal_u8⚠
neon
无符号乘加长 - vmlal_u16⚠
neon
无符号乘加长 - vmlal_u32⚠
neon
无符号乘加长 - vmlaq_f32⚠
neon
浮点乘加累加器 - vmlaq_f64⚠
neon
浮点乘加累加器 - vmlaq_lane_f32⚠
neon
向量与标量相乘累加 - vmlaq_lane_s16⚠
neon
向量与标量相乘累加 - vmlaq_lane_s32⚠
neon
向量与标量相乘累加 - vmlaq_lane_u16⚠
neon
向量与标量相乘累加 - vmlaq_lane_u32⚠
neon
向量与标量相乘累加 - vmlaq_laneq_f32⚠
neon
向量与标量相乘累加 - vmlaq_laneq_s16⚠
neon
向量与标量相乘累加 - vmlaq_laneq_s32⚠
neon
向量与标量相乘累加 - vmlaq_laneq_u16⚠
neon
向量与标量相乘累加 - vmlaq_laneq_u32⚠
neon
向量与标量相乘累加 - vmlaq_n_f32⚠
neon
向量与标量相乘累加 - vmlaq_n_s16⚠
neon
向量与标量相乘累加 - vmlaq_n_s32⚠
neon
向量与标量相乘累加 - vmlaq_n_u16⚠
neon
向量与标量相乘累加 - vmlaq_n_u32⚠
neon
向量与标量相乘累加 - vmlaq_s8⚠
neon
乘加到累加器 - vmlaq_s16⚠
neon
乘加到累加器 - vmlaq_s32⚠
neon
乘加到累加器 - vmlaq_u8⚠
neon
乘加到累加器 - vmlaq_u16⚠
neon
乘加到累加器 - vmlaq_u32⚠
neon
乘加到累加器 - vmls_f32⚠
neon
浮点乘减累加器 - vmls_f64⚠
neon
浮点乘减累加器 - vmls_lane_f32⚠
neon
向量乘减标量 - vmls_lane_s16⚠
neon
向量乘减标量 - vmls_lane_s32⚠
neon
向量乘减标量 - vmls_lane_u16⚠
neon
向量乘减标量 - vmls_lane_u32⚠
neon
向量乘减标量 - vmls_laneq_f32⚠
neon
向量乘减标量 - vmls_laneq_s16⚠
neon
向量乘减标量 - vmls_laneq_s32⚠
neon
向量乘减标量 - vmls_laneq_u16⚠
neon
向量乘减标量 - vmls_laneq_u32⚠
neon
向量乘减标量 - vmls_n_f32⚠
neon
向量乘减标量 - vmls_n_s16⚠
neon
向量乘减标量 - vmls_n_s32⚠
neon
向量乘减标量 - vmls_n_u16⚠
neon
向量乘减标量 - vmls_n_u32⚠
neon
向量乘减标量 - vmls_s8⚠
neon
累加器的乘减 - vmls_s16⚠
neon
累加器的乘减 - vmls_s32⚠
neon
累加器的乘减 - vmls_u8⚠
neon
累加器的乘减 - vmls_u16⚠
neon
累加器的乘减 - vmls_u32⚠
neon
累加器的乘减 - vmlsl_high_lane_s16⚠
neon
乘减长 - vmlsl_high_lane_s32⚠
neon
乘减长 - vmlsl_high_lane_u16⚠
neon
乘减长 - vmlsl_high_lane_u32⚠
neon
乘减长 - vmlsl_high_laneq_s16⚠
neon
乘减长 - vmlsl_high_laneq_s32⚠
neon
乘减长 - vmlsl_high_laneq_u16⚠
neon
乘减长 - vmlsl_high_laneq_u32⚠
neon
乘减长 - vmlsl_high_n_s16⚠
neon
乘减长 - vmlsl_high_n_s32⚠
neon
乘减长 - vmlsl_high_n_u16⚠
neon
乘减长 - vmlsl_high_n_u32⚠
neon
乘减长 - vmlsl_high_s8⚠
neon
有符号乘减长 - vmlsl_high_s16⚠
neon
有符号乘减长 - vmlsl_high_s32⚠
neon
有符号乘减长 - vmlsl_high_u8⚠
neon
无符号乘减长 - vmlsl_high_u16⚠
neon
无符号乘减长 - vmlsl_high_u32⚠
neon
无符号乘减长 - vmlsl_lane_s16⚠
neon
向量加宽乘减标量 - vmlsl_lane_s32⚠
neon
向量加宽乘减标量 - vmlsl_lane_u16⚠
neon
向量加宽乘减标量 - vmlsl_lane_u32⚠
neon
向量加宽乘减标量 - vmlsl_laneq_s16⚠
neon
向量加宽乘减标量 - vmlsl_laneq_s32⚠
neon
向量加宽乘减标量 - vmlsl_laneq_u16⚠
neon
向量加宽乘减标量 - vmlsl_laneq_u32⚠
neon
向量加宽乘减标量 - vmlsl_n_s16⚠
neon
向量加宽乘减标量 - vmlsl_n_s32⚠
neon
向量加宽乘减标量 - vmlsl_n_u16⚠
neon
向量加宽乘减标量 - vmlsl_n_u32⚠
neon
向量加宽乘减标量 - vmlsl_s8⚠
neon
有符号乘减长 - vmlsl_s16⚠
neon
有符号乘减长 - vmlsl_s32⚠
neon
有符号乘减长 - vmlsl_u8⚠
neon
无符号乘减长 - vmlsl_u16⚠
neon
无符号乘减长 - vmlsl_u32⚠
neon
无符号乘减长 - vmlsq_f32⚠
neon
浮点乘减累加器 - vmlsq_f64⚠
neon
浮点乘减累加器 - vmlsq_lane_f32⚠
neon
向量乘减标量 - vmlsq_lane_s16⚠
neon
向量乘减标量 - vmlsq_lane_s32⚠
neon
向量乘减标量 - vmlsq_lane_u16⚠
neon
向量乘减标量 - vmlsq_lane_u32⚠
neon
向量乘减标量 - vmlsq_laneq_f32⚠
neon
向量乘减标量 - vmlsq_laneq_s16⚠
neon
向量乘减标量 - vmlsq_laneq_s32⚠
neon
向量乘减标量 - vmlsq_laneq_u16⚠
neon
向量乘减标量 - vmlsq_laneq_u32⚠
neon
向量乘减标量 - vmlsq_n_f32⚠
neon
向量乘减标量 - vmlsq_n_s16⚠
neon
向量乘减标量 - vmlsq_n_s32⚠
neon
向量乘减标量 - vmlsq_n_u16⚠
neon
向量乘减标量 - vmlsq_n_u32⚠
neon
向量乘减标量 - vmlsq_s8⚠
neon
累加器的乘减 - vmlsq_s16⚠
neon
累加器的乘减 - vmlsq_s32⚠
neon
累加器的乘减 - vmlsq_u8⚠
neon
累加器的乘减 - vmlsq_u16⚠
neon
累加器的乘减 - vmlsq_u32⚠
neon
累加器的乘减 - vmov_n_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_p8⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_p16⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_s8⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_s16⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_s32⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_u8⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_u16⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_u32⚠
neon
将 vector 元素复制到 vector 或标量 - vmov_n_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vmovl_high_s8⚠
neon
Vector 移动 - vmovl_high_s16⚠
neon
Vector 移动 - vmovl_high_s32⚠
neon
Vector 移动 - vmovl_high_u8⚠
neon
Vector 移动 - vmovl_high_u16⚠
neon
Vector 移动 - vmovl_high_u32⚠
neon
Vector 移动 - vmovl_s8⚠
neon
Vector 长移动。 - vmovl_s16⚠
neon
Vector 长移动。 - vmovl_s32⚠
neon
Vector 长移动。 - vmovl_u8⚠
neon
Vector 长移动。 - vmovl_u16⚠
neon
Vector 长移动。 - vmovl_u32⚠
neon
Vector 长移动。 - vmovn_high_s16⚠
neon
提取 narrow - vmovn_high_s32⚠
neon
提取 narrow - vmovn_high_s64⚠
neon
提取 narrow - vmovn_high_u16⚠
neon
提取 narrow - vmovn_high_u32⚠
neon
提取 narrow - vmovn_high_u64⚠
neon
提取 narrow - vmovn_s16⚠
neon
Vector narrow 整数。 - vmovn_s32⚠
neon
Vector narrow 整数。 - vmovn_s64⚠
neon
Vector narrow 整数。 - vmovn_u16⚠
neon
Vector narrow 整数。 - vmovn_u32⚠
neon
Vector narrow 整数。 - vmovn_u64⚠
neon
Vector narrow 整数。 - vmovq_n_f32⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_f64⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_p8⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_p16⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_p64⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_s8⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_s16⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_s32⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_s64⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_u8⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_u16⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_u32⚠
neon
将 vector 元素复制到 vector 或标量 - vmovq_n_u64⚠
neon
将 vector 元素复制到 vector 或标量 - vmul_f32⚠
neon
Multiply - vmul_f64⚠
neon
Multiply - vmul_lane_f32⚠
neon
浮点乘法 - vmul_lane_f64⚠
neon
浮点乘法 - vmul_lane_s16⚠
neon
Multiply - vmul_lane_s32⚠
neon
Multiply - vmul_lane_u16⚠
neon
Multiply - vmul_lane_u32⚠
neon
Multiply - vmul_laneq_f32⚠
neon
浮点乘法 - vmul_laneq_f64⚠
neon
浮点乘法 - vmul_laneq_s16⚠
neon
Multiply - vmul_laneq_s32⚠
neon
Multiply - vmul_laneq_u16⚠
neon
Multiply - vmul_laneq_u32⚠
neon
Multiply - vmul_n_f32⚠
neon
Vector 乘以标量 - vmul_n_f64⚠
neon
Vector 乘以标量 - vmul_n_s16⚠
neon
Vector 乘以标量 - vmul_n_s32⚠
neon
Vector 乘以标量 - vmul_n_u16⚠
neon
Vector 乘以标量 - vmul_n_u32⚠
neon
Vector 乘以标量 - vmul_p8⚠
neon
多项式乘法 - vmul_s8⚠
neon
Multiply - vmul_s16⚠
neon
Multiply - vmul_s32⚠
neon
Multiply - vmul_u8⚠
neon
Multiply - vmul_u16⚠
neon
Multiply - vmul_u32⚠
neon
Multiply - vmuld_lane_f64⚠
neon
浮点乘法 - vmuld_laneq_f64⚠
neon
浮点乘法 - vmull_high_lane_s16⚠
neon
乘长 - vmull_high_lane_s32⚠
neon
乘长 - vmull_high_lane_u16⚠
neon
乘长 - vmull_high_lane_u32⚠
neon
乘长 - vmull_high_laneq_s16⚠
neon
乘长 - vmull_high_laneq_s32⚠
neon
乘长 - vmull_high_laneq_u16⚠
neon
乘长 - vmull_high_laneq_u32⚠
neon
乘长 - vmull_high_n_s16⚠
neon
乘长 - vmull_high_n_s32⚠
neon
乘长 - vmull_high_n_u16⚠
neon
乘长 - vmull_high_n_u32⚠
neon
乘长 - vmull_high_p8⚠
neon
多项式乘长 - vmull_high_p64⚠
neon,aes
多项式乘长 - vmull_high_s8⚠
neon
有符号乘长 - vmull_high_s16⚠
neon
有符号乘长 - vmull_high_s32⚠
neon
有符号乘长 - vmull_high_u8⚠
neon
无符号乘长 - vmull_high_u16⚠
neon
无符号乘长 - vmull_high_u32⚠
neon
无符号乘长 - vmull_lane_s16⚠
neon
Vector 长乘以标量 - vmull_lane_s32⚠
neon
Vector 长乘以标量 - vmull_lane_u16⚠
neon
Vector 长乘以标量 - vmull_lane_u32⚠
neon
Vector 长乘以标量 - vmull_laneq_s16⚠
neon
Vector 长乘以标量 - vmull_laneq_s32⚠
neon
Vector 长乘以标量 - vmull_laneq_u16⚠
neon
Vector 长乘以标量 - vmull_laneq_u32⚠
neon
Vector 长乘以标量 - vmull_n_s16⚠
neon
向量长乘以标量 - vmull_n_s32⚠
neon
向量长乘以标量 - vmull_n_u16⚠
neon
向量长乘以标量 - vmull_n_u32⚠
neon
向量长乘以标量 - vmull_p8⚠
neon
多项式乘长 - vmull_p64⚠
neon,aes
多项式乘长 - vmull_s8⚠
neon
有符号乘长 - vmull_s16⚠
neon
有符号乘长 - vmull_s32⚠
neon
有符号乘长 - vmull_u8⚠
neon
无符号乘长 - vmull_u16⚠
neon
无符号乘长 - vmull_u32⚠
neon
无符号乘长 - vmulq_f32⚠
neon
Multiply - vmulq_f64⚠
neon
Multiply - vmulq_lane_f32⚠
neon
浮点乘法 - vmulq_lane_f64⚠
neon
浮点乘法 - vmulq_lane_s16⚠
neon
Multiply - vmulq_lane_s32⚠
neon
Multiply - vmulq_lane_u16⚠
neon
Multiply - vmulq_lane_u32⚠
neon
Multiply - vmulq_laneq_f32⚠
neon
浮点乘法 - vmulq_laneq_f64⚠
neon
浮点乘法 - vmulq_laneq_s16⚠
neon
Multiply - vmulq_laneq_s32⚠
neon
Multiply - vmulq_laneq_u16⚠
neon
Multiply - vmulq_laneq_u32⚠
neon
Multiply - vmulq_n_f32⚠
neon
Vector 乘以标量 - vmulq_n_f64⚠
neon
Vector 乘以标量 - vmulq_n_s16⚠
neon
Vector 乘以标量 - vmulq_n_s32⚠
neon
Vector 乘以标量 - vmulq_n_u16⚠
neon
Vector 乘以标量 - vmulq_n_u32⚠
neon
Vector 乘以标量 - vmulq_p8⚠
neon
多项式乘法 - vmulq_s8⚠
neon
Multiply - vmulq_s16⚠
neon
Multiply - vmulq_s32⚠
neon
Multiply - vmulq_u8⚠
neon
Multiply - vmulq_u16⚠
neon
Multiply - vmulq_u32⚠
neon
Multiply - vmuls_lane_f32⚠
neon
浮点乘法 - vmuls_laneq_f32⚠
neon
浮点乘法 - vmulx_f32⚠
neon
浮点乘法扩展 - vmulx_f64⚠
neon
浮点乘法扩展 - vmulx_lane_f32⚠
neon
浮点乘法扩展 - vmulx_lane_f64⚠
neon
浮点乘法扩展 - vmulx_laneq_f32⚠
neon
浮点乘法扩展 - vmulx_laneq_f64⚠
neon
浮点乘法扩展 - vmulxd_f64⚠
neon
浮点乘法扩展 - vmulxd_lane_f64⚠
neon
浮点乘法扩展 - vmulxd_laneq_f64⚠
neon
浮点乘法扩展 - vmulxq_f32⚠
neon
浮点乘法扩展 - vmulxq_f64⚠
neon
浮点乘法扩展 - vmulxq_lane_f32⚠
neon
浮点乘法扩展 - vmulxq_lane_f64⚠
neon
浮点乘法扩展 - vmulxq_laneq_f32⚠
neon
浮点乘法扩展 - vmulxq_laneq_f64⚠
neon
浮点乘法扩展 - vmulxs_f32⚠
neon
浮点乘法扩展 - vmulxs_lane_f32⚠
neon
浮点乘法扩展 - vmulxs_laneq_f32⚠
neon
浮点乘法扩展 - vmvn_p8⚠
neon
Vector 不是按位的。 - vmvn_s8⚠
neon
Vector 不是按位的。 - vmvn_s16⚠
neon
Vector 不是按位的。 - vmvn_s32⚠
neon
Vector 不是按位的。 - vmvn_u8⚠
neon
Vector 不是按位的。 - vmvn_u16⚠
neon
Vector 不是按位的。 - vmvn_u32⚠
neon
Vector 不是按位的。 - vmvnq_p8⚠
neon
Vector 不是按位的。 - vmvnq_s8⚠
neon
Vector 不是按位的。 - vmvnq_s16⚠
neon
Vector 不是按位的。 - vmvnq_s32⚠
neon
Vector 不是按位的。 - vmvnq_u8⚠
neon
Vector 不是按位的。 - vmvnq_u16⚠
neon
Vector 不是按位的。 - vmvnq_u32⚠
neon
Vector 不是按位的。 - vneg_f32⚠
neon
Negate - vneg_f64⚠
neon
Negate - vneg_s8⚠
neon
Negate - vneg_s16⚠
neon
Negate - vneg_s32⚠
neon
Negate - vneg_s64⚠
neon
Negate - vnegd_s64⚠
neon
Negate - vnegq_f32⚠
neon
Negate - vnegq_f64⚠
neon
Negate - vnegq_s8⚠
neon
Negate - vnegq_s16⚠
neon
Negate - vnegq_s32⚠
neon
Negate - vnegq_s64⚠
neon
Negate - vorn_s8⚠
neon
向量按位包含或不包含 - vorn_s16⚠
neon
向量按位包含或不包含 - vorn_s32⚠
neon
向量按位包含或不包含 - vorn_s64⚠
neon
向量按位包含或不包含 - vorn_u8⚠
neon
向量按位包含或不包含 - vorn_u16⚠
neon
向量按位包含或不包含 - vorn_u32⚠
neon
向量按位包含或不包含 - vorn_u64⚠
neon
向量按位包含或不包含 - vornq_s8⚠
neon
向量按位包含或不包含 - vornq_s16⚠
neon
向量按位包含或不包含 - vornq_s32⚠
neon
向量按位包含或不包含 - vornq_s64⚠
neon
向量按位包含或不包含 - vornq_u8⚠
neon
向量按位包含或不包含 - vornq_u16⚠
neon
向量按位包含或不包含 - vornq_u32⚠
neon
向量按位包含或不包含 - vornq_u64⚠
neon
向量按位包含或不包含 - vorr_s8⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_s16⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_s32⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_s64⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_u8⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_u16⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_u32⚠
neon
Vector 按位或 ( immediate ,包括) - vorr_u64⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_s8⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_s16⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_s32⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_s64⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_u8⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_u16⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_u32⚠
neon
Vector 按位或 ( immediate ,包括) - vorrq_u64⚠
neon
Vector 按位或 ( immediate ,包括) - vpadal_s8⚠
neon
有符号加和成对累积长。 - vpadal_s16⚠
neon
有符号加和成对累积长。 - vpadal_s32⚠
neon
有符号加和成对累积长。 - vpadal_u8⚠
neon
无符号加和成对累积长。 - vpadal_u16⚠
neon
无符号加和成对累积长。 - vpadal_u32⚠
neon
无符号加和成对累积长。 - vpadalq_s8⚠
neon
有符号加和成对累积长。 - vpadalq_s16⚠
neon
有符号加和成对累积长。 - vpadalq_s32⚠
neon
有符号加和成对累积长。 - vpadalq_u8⚠
neon
无符号加和成对累积长。 - vpadalq_u16⚠
neon
无符号加和成对累积长。 - vpadalq_u32⚠
neon
无符号加和成对累积长。 - vpadd_f32⚠
neon
浮点数成对相加 - vpadd_s8⚠
neon
成对添加。 - vpadd_s16⚠
neon
成对添加。 - vpadd_s32⚠
neon
成对添加。 - vpadd_u8⚠
neon
成对添加。 - vpadd_u16⚠
neon
成对添加。 - vpadd_u32⚠
neon
成对添加。 - vpaddd_f64⚠
neon
浮点数成对相加 - vpaddd_s64⚠
neon
逐对添加 - vpaddd_u64⚠
neon
逐对添加 - vpaddl_s8⚠
neon
有符号成对加长。 - vpaddl_s16⚠
neon
有符号成对加长。 - vpaddl_s32⚠
neon
有符号成对加长。 - vpaddl_u8⚠
neon
无符号成对加长。 - vpaddl_u16⚠
neon
无符号成对加长。 - vpaddl_u32⚠
neon
无符号成对加长。 - vpaddlq_s8⚠
neon
有符号成对加长。 - vpaddlq_s16⚠
neon
有符号成对加长。 - vpaddlq_s32⚠
neon
有符号成对加长。 - vpaddlq_u8⚠
neon
无符号成对加长。 - vpaddlq_u16⚠
neon
无符号成对加长。 - vpaddlq_u32⚠
neon
无符号成对加长。 - vpaddq_f32⚠
neon
浮点数成对相加 - vpaddq_f64⚠
neon
浮点数成对相加 - vpaddq_s8⚠
neon
逐对添加 - vpaddq_s16⚠
neon
逐对添加 - vpaddq_s32⚠
neon
逐对添加 - vpaddq_s64⚠
neon
逐对添加 - vpaddq_u8⚠
neon
逐对添加 - vpaddq_u16⚠
neon
逐对添加 - vpaddq_u32⚠
neon
逐对添加 - vpaddq_u64⚠
neon
逐对添加 - vpadds_f32⚠
neon
浮点数成对相加 - vpmax_f32⚠
neon
相邻对的最大折叠 - vpmax_s8⚠
neon
相邻对的最大折叠 - vpmax_s16⚠
neon
相邻对的最大折叠 - vpmax_s32⚠
neon
相邻对的最大折叠 - vpmax_u8⚠
neon
相邻对的最大折叠 - vpmax_u16⚠
neon
相邻对的最大折叠 - vpmax_u32⚠
neon
相邻对的最大折叠 - vpmaxnm_f32⚠
neon
浮点最大数成对 (vector)。 - vpmaxnmq_f32⚠
neon
浮点最大数成对 (vector)。 - vpmaxnmq_f64⚠
neon
浮点最大数成对 (vector)。 - vpmaxnmqd_f64⚠
neon
成对的浮点最大数 - vpmaxnms_f32⚠
neon
成对的浮点最大数 - vpmaxq_f32⚠
neon
相邻对的最大折叠 - vpmaxq_f64⚠
neon
相邻对的最大折叠 - vpmaxq_s8⚠
neon
相邻对的最大折叠 - vpmaxq_s16⚠
neon
相邻对的最大折叠 - vpmaxq_s32⚠
neon
相邻对的最大折叠 - vpmaxq_u8⚠
neon
相邻对的最大折叠 - vpmaxq_u16⚠
neon
相邻对的最大折叠 - vpmaxq_u32⚠
neon
相邻对的最大折叠 - vpmaxqd_f64⚠
neon
成对的浮点最大值 - vpmaxs_f32⚠
neon
成对的浮点最大值 - vpmin_f32⚠
neon
相邻对的最小折叠 - vpmin_s8⚠
neon
相邻对的最小折叠 - vpmin_s16⚠
neon
相邻对的最小折叠 - vpmin_s32⚠
neon
相邻对的最小折叠 - vpmin_u8⚠
neon
相邻对的最小折叠 - vpmin_u16⚠
neon
相邻对的最小折叠 - vpmin_u32⚠
neon
相邻对的最小折叠 - vpminnm_f32⚠
neon
浮点最小数成对 (vector)。 - vpminnmq_f32⚠
neon
浮点最小数成对 (vector)。 - vpminnmq_f64⚠
neon
浮点最小数成对 (vector)。 - vpminnmqd_f64⚠
neon
成对的浮点最小数 - vpminnms_f32⚠
neon
成对的浮点最小数 - vpminq_f32⚠
neon
相邻对的最小折叠 - vpminq_f64⚠
neon
相邻对的最小折叠 - vpminq_s8⚠
neon
相邻对的最小折叠 - vpminq_s16⚠
neon
相邻对的最小折叠 - vpminq_s32⚠
neon
相邻对的最小折叠 - vpminq_u8⚠
neon
相邻对的最小折叠 - vpminq_u16⚠
neon
相邻对的最小折叠 - vpminq_u32⚠
neon
相邻对的最小折叠 - vpminqd_f64⚠
neon
成对的浮点最小值 - vpmins_f32⚠
neon
成对的浮点最小值 - vqabs_s8⚠
neon
有符号饱和绝对值 - vqabs_s16⚠
neon
有符号饱和绝对值 - vqabs_s32⚠
neon
有符号饱和绝对值 - vqabs_s64⚠
neon
有符号饱和绝对值 - vqabsb_s8⚠
neon
有符号饱和绝对值 - vqabsd_s64⚠
neon
有符号饱和绝对值 - vqabsh_s16⚠
neon
有符号饱和绝对值 - vqabsq_s8⚠
neon
有符号饱和绝对值 - vqabsq_s16⚠
neon
有符号饱和绝对值 - vqabsq_s32⚠
neon
有符号饱和绝对值 - vqabsq_s64⚠
neon
有符号饱和绝对值 - vqabss_s32⚠
neon
有符号饱和绝对值 - vqadd_s8⚠
neon
饱和添加 - vqadd_s16⚠
neon
饱和添加 - vqadd_s32⚠
neon
饱和添加 - vqadd_s64⚠
neon
饱和添加 - vqadd_u8⚠
neon
饱和添加 - vqadd_u16⚠
neon
饱和添加 - vqadd_u32⚠
neon
饱和添加 - vqadd_u64⚠
neon
饱和添加 - vqaddb_s8⚠
neon
饱和添加 - vqaddb_u8⚠
neon
饱和添加 - vqaddd_s64⚠
neon
饱和添加 - vqaddd_u64⚠
neon
饱和添加 - vqaddh_s16⚠
neon
饱和添加 - vqaddh_u16⚠
neon
饱和添加 - vqaddq_s8⚠
neon
饱和添加 - vqaddq_s16⚠
neon
饱和添加 - vqaddq_s32⚠
neon
饱和添加 - vqaddq_s64⚠
neon
饱和添加 - vqaddq_u8⚠
neon
饱和添加 - vqaddq_u16⚠
neon
饱和添加 - vqaddq_u32⚠
neon
饱和添加 - vqaddq_u64⚠
neon
饱和添加 - vqadds_s32⚠
neon
饱和添加 - vqadds_u32⚠
neon
饱和添加 - 有符号饱和加倍乘加长
- 有符号饱和加倍乘加长
- 有符号饱和加倍乘加长
- 有符号饱和加倍乘加长
- vqdmlal_high_n_s16⚠
neon
有符号饱和加倍乘加长 - vqdmlal_high_n_s32⚠
neon
有符号饱和加倍乘加长 - vqdmlal_high_s16⚠
neon
有符号饱和加倍乘加长 - vqdmlal_high_s32⚠
neon
有符号饱和加倍乘加长 - vqdmlal_lane_s16⚠
neon
Vector 加宽饱和加倍乘积与标量 - vqdmlal_lane_s32⚠
neon
Vector 加宽饱和加倍乘积与标量 - vqdmlal_laneq_s16⚠
neon
Vector 加宽饱和加倍乘积与标量 - vqdmlal_laneq_s32⚠
neon
Vector 加宽饱和加倍乘积与标量 - vqdmlal_n_s16⚠
neon
Vector 加宽饱和加倍乘积与标量 - vqdmlal_n_s32⚠
neon
Vector 加宽饱和加倍乘积与标量 - vqdmlal_s16⚠
neon
有符号饱和加倍乘加长 - vqdmlal_s32⚠
neon
有符号饱和加倍乘加长 - vqdmlalh_lane_s16⚠
neon
有符号饱和加倍乘加长 - vqdmlalh_laneq_s16⚠
neon
有符号饱和加倍乘加长 - vqdmlalh_s16⚠
neon
有符号饱和加倍乘加长 - vqdmlals_lane_s32⚠
neon
有符号饱和加倍乘加长 - vqdmlals_laneq_s32⚠
neon
有符号饱和加倍乘加长 - vqdmlals_s32⚠
neon
有符号饱和加倍乘加长 - 有符号饱和加倍乘减长
- 有符号饱和加倍乘减长
- 有符号饱和加倍乘减长
- 有符号饱和加倍乘减长
- vqdmlsl_high_n_s16⚠
neon
有符号饱和加倍乘减长 - vqdmlsl_high_n_s32⚠
neon
有符号饱和加倍乘减长 - vqdmlsl_high_s16⚠
neon
有符号饱和加倍乘减长 - vqdmlsl_high_s32⚠
neon
有符号饱和加倍乘减长 - vqdmlsl_lane_s16⚠
neon
Vector 加宽饱和加倍乘减标量 - vqdmlsl_lane_s32⚠
neon
Vector 加宽饱和加倍乘减标量 - vqdmlsl_laneq_s16⚠
neon
Vector 加宽饱和加倍乘减标量 - vqdmlsl_laneq_s32⚠
neon
Vector 加宽饱和加倍乘减标量 - vqdmlsl_n_s16⚠
neon
Vector 加宽饱和加倍乘减标量 - vqdmlsl_n_s32⚠
neon
Vector 加宽饱和加倍乘减标量 - vqdmlsl_s16⚠
neon
有符号饱和加倍乘减长 - vqdmlsl_s32⚠
neon
有符号饱和加倍乘减长 - vqdmlslh_lane_s16⚠
neon
有符号饱和加倍乘减长 - vqdmlslh_laneq_s16⚠
neon
有符号饱和加倍乘减长 - vqdmlslh_s16⚠
neon
有符号饱和加倍乘减长 - vqdmlsls_lane_s32⚠
neon
有符号饱和加倍乘减长 - vqdmlsls_laneq_s32⚠
neon
有符号饱和加倍乘减长 - vqdmlsls_s32⚠
neon
有符号饱和加倍乘减长 - vqdmulh_lane_s16⚠
neon
Vector 饱和加倍乘以标量 - vqdmulh_lane_s32⚠
neon
Vector 饱和加倍乘以标量 - vqdmulh_laneq_s16⚠
neon
Vector 饱和加倍乘以标量 - vqdmulh_laneq_s32⚠
neon
Vector 饱和加倍乘以标量 - vqdmulh_n_s16⚠
neon
向量饱和加倍乘以标量 - vqdmulh_n_s32⚠
neon
向量饱和加倍乘以标量 - vqdmulh_s16⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulh_s32⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhh_lane_s16⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhh_laneq_s16⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhh_s16⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhq_lane_s16⚠
neon
Vector 饱和加倍乘以标量 - vqdmulhq_lane_s32⚠
neon
Vector 饱和加倍乘以标量 - vqdmulhq_laneq_s16⚠
neon
Vector 饱和加倍乘以标量 - vqdmulhq_laneq_s32⚠
neon
Vector 饱和加倍乘以标量 - vqdmulhq_n_s16⚠
neon
向量饱和加倍乘以标量 - vqdmulhq_n_s32⚠
neon
向量饱和加倍乘以标量 - vqdmulhq_s16⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhq_s32⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhs_lane_s32⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhs_laneq_s32⚠
neon
有符号饱和加倍乘法返回高半 - vqdmulhs_s32⚠
neon
有符号饱和加倍乘法返回高半 - 有符号饱和加倍乘以长
- 有符号饱和加倍乘以长
- 有符号饱和加倍乘以长
- 有符号饱和加倍乘以长
- vqdmull_high_n_s16⚠
neon
有符号饱和加倍乘以长 - vqdmull_high_n_s32⚠
neon
有符号饱和加倍乘以长 - vqdmull_high_s16⚠
neon
有符号饱和加倍乘以长 - vqdmull_high_s32⚠
neon
有符号饱和加倍乘以长 - vqdmull_lane_s16⚠
neon
Vector 饱和加倍长乘以标量 - vqdmull_lane_s32⚠
neon
Vector 饱和加倍长乘以标量 - vqdmull_laneq_s16⚠
neon
Vector 饱和加倍长乘以标量 - vqdmull_laneq_s32⚠
neon
Vector 饱和加倍长乘以标量 - vqdmull_n_s16⚠
neon
向量饱和加倍长乘以标量 - vqdmull_n_s32⚠
neon
向量饱和加倍长乘以标量 - vqdmull_s16⚠
neon
有符号饱和加倍乘以长 - vqdmull_s32⚠
neon
有符号饱和加倍乘以长 - vqdmullh_lane_s16⚠
neon
有符号饱和加倍乘以长 - vqdmullh_laneq_s16⚠
neon
有符号饱和加倍乘以长 - vqdmullh_s16⚠
neon
有符号饱和加倍乘以长 - vqdmulls_lane_s32⚠
neon
有符号饱和加倍乘以长 - vqdmulls_laneq_s32⚠
neon
有符号饱和加倍乘以长 - vqdmulls_s32⚠
neon
有符号饱和加倍乘以长 - vqmovn_high_s16⚠
neon
带符号饱和提取 narrow - vqmovn_high_s32⚠
neon
带符号饱和提取 narrow - vqmovn_high_s64⚠
neon
带符号饱和提取 narrow - vqmovn_high_u16⚠
neon
带符号饱和提取 narrow - vqmovn_high_u32⚠
neon
带符号饱和提取 narrow - vqmovn_high_u64⚠
neon
带符号饱和提取 narrow - vqmovn_s16⚠
neon
带符号饱和提取 narrow - vqmovn_s32⚠
neon
带符号饱和提取 narrow - vqmovn_s64⚠
neon
带符号饱和提取 narrow - vqmovn_u16⚠
neon
无符号饱和提取 narrow - vqmovn_u32⚠
neon
无符号饱和提取 narrow - vqmovn_u64⚠
neon
无符号饱和提取 narrow - vqmovnd_s64⚠
neon
饱和提取 narrow - vqmovnd_u64⚠
neon
饱和提取 narrow - vqmovnh_s16⚠
neon
饱和提取 narrow - vqmovnh_u16⚠
neon
饱和提取 narrow - vqmovns_s32⚠
neon
饱和提取 narrow - vqmovns_u32⚠
neon
饱和提取 narrow - vqmovun_high_s16⚠
neon
有符号饱和提取无符号 narrow - vqmovun_high_s32⚠
neon
有符号饱和提取无符号 narrow - vqmovun_high_s64⚠
neon
有符号饱和提取无符号 narrow - vqmovun_s16⚠
neon
有符号饱和提取无符号 narrow - vqmovun_s32⚠
neon
有符号饱和提取无符号 narrow - vqmovun_s64⚠
neon
有符号饱和提取无符号 narrow - vqmovund_s64⚠
neon
有符号饱和提取无符号 narrow - vqmovunh_s16⚠
neon
有符号饱和提取无符号 narrow - vqmovuns_s32⚠
neon
有符号饱和提取无符号 narrow - vqneg_s8⚠
neon
有符号饱和否定 - vqneg_s16⚠
neon
有符号饱和否定 - vqneg_s32⚠
neon
有符号饱和否定 - vqneg_s64⚠
neon
有符号饱和否定 - vqnegb_s8⚠
neon
有符号饱和否定 - vqnegd_s64⚠
neon
有符号饱和否定 - vqnegh_s16⚠
neon
有符号饱和否定 - vqnegq_s8⚠
neon
有符号饱和否定 - vqnegq_s16⚠
neon
有符号饱和否定 - vqnegq_s32⚠
neon
有符号饱和否定 - vqnegq_s64⚠
neon
有符号饱和否定 - vqnegs_s32⚠
neon
有符号饱和否定 - 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- vqrdmlah_s16⚠
rdm
有符号饱和四舍五入加倍累加返回高半 - vqrdmlah_s32⚠
rdm
有符号饱和四舍五入加倍累加返回高半 - 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- vqrdmlahh_s16⚠
rdm
有符号饱和四舍五入加倍累加返回高半 - 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- vqrdmlahq_s16⚠
rdm
有符号饱和四舍五入加倍累加返回高半 - vqrdmlahq_s32⚠
rdm
有符号饱和四舍五入加倍累加返回高半 - 有符号饱和四舍五入加倍累加返回高半
- 有符号饱和四舍五入加倍累加返回高半
- vqrdmlahs_s32⚠
rdm
有符号饱和四舍五入加倍累加返回高半 - 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- vqrdmlsh_s16⚠
rdm
有符号饱和舍入加倍乘减返回高半 - vqrdmlsh_s32⚠
rdm
有符号饱和舍入加倍乘减返回高半 - 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- vqrdmlshh_s16⚠
rdm
有符号饱和舍入加倍乘减返回高半 - 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- vqrdmlshq_s16⚠
rdm
有符号饱和舍入加倍乘减返回高半 - vqrdmlshq_s32⚠
rdm
有符号饱和舍入加倍乘减返回高半 - 有符号饱和舍入加倍乘减返回高半
- 有符号饱和舍入加倍乘减返回高半
- vqrdmlshs_s32⚠
rdm
有符号饱和舍入加倍乘减返回高半 - vqrdmulh_lane_s16⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulh_lane_s32⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulh_laneq_s16⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulh_laneq_s32⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulh_n_s16⚠
neon
向量饱和舍入加倍乘以标量高 - vqrdmulh_n_s32⚠
neon
向量饱和舍入加倍乘以标量高 - vqrdmulh_s16⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulh_s32⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhh_lane_s16⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhh_laneq_s16⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhh_s16⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhq_lane_s16⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulhq_lane_s32⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulhq_laneq_s16⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulhq_laneq_s32⚠
neon
向量舍入饱和加倍乘以标量高 - vqrdmulhq_n_s16⚠
neon
向量饱和舍入加倍乘以标量高 - vqrdmulhq_n_s32⚠
neon
向量饱和舍入加倍乘以标量高 - vqrdmulhq_s16⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhq_s32⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhs_lane_s32⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhs_laneq_s32⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrdmulhs_s32⚠
neon
有符号饱和舍入加倍乘法返回高半 - vqrshl_s8⚠
neon
有符号饱和舍入左移 - vqrshl_s16⚠
neon
有符号饱和舍入左移 - vqrshl_s32⚠
neon
有符号饱和舍入左移 - vqrshl_s64⚠
neon
有符号饱和舍入左移 - vqrshl_u8⚠
neon
无符号有符号饱和舍入左移 - vqrshl_u16⚠
neon
无符号有符号饱和舍入左移 - vqrshl_u32⚠
neon
无符号有符号饱和舍入左移 - vqrshl_u64⚠
neon
无符号有符号饱和舍入左移 - vqrshlb_s8⚠
neon
有符号饱和舍入左移 - vqrshlb_u8⚠
neon
无符号有符号饱和舍入左移 - vqrshld_s64⚠
neon
有符号饱和舍入左移 - vqrshld_u64⚠
neon
无符号有符号饱和舍入左移 - vqrshlh_s16⚠
neon
有符号饱和舍入左移 - vqrshlh_u16⚠
neon
无符号有符号饱和舍入左移 - vqrshlq_s8⚠
neon
有符号饱和舍入左移 - vqrshlq_s16⚠
neon
有符号饱和舍入左移 - vqrshlq_s32⚠
neon
有符号饱和舍入左移 - vqrshlq_s64⚠
neon
有符号饱和舍入左移 - vqrshlq_u8⚠
neon
无符号有符号饱和舍入左移 - vqrshlq_u16⚠
neon
无符号有符号饱和舍入左移 - vqrshlq_u32⚠
neon
无符号有符号饱和舍入左移 - vqrshlq_u64⚠
neon
无符号有符号饱和舍入左移 - vqrshls_s32⚠
neon
有符号饱和舍入左移 - vqrshls_u32⚠
neon
无符号有符号饱和舍入左移 - vqrshrn_high_n_s16⚠
neon
有符号饱和圆角右移 narrow - vqrshrn_high_n_s32⚠
neon
有符号饱和圆角右移 narrow - vqrshrn_high_n_s64⚠
neon
有符号饱和圆角右移 narrow - vqrshrn_high_n_u16⚠
neon
无符号饱和圆角右移 narrow - vqrshrn_high_n_u32⚠
neon
无符号饱和圆角右移 narrow - vqrshrn_high_n_u64⚠
neon
无符号饱和圆角右移 narrow - vqrshrnd_n_s64⚠
neon
有符号饱和圆角右移 narrow - vqrshrnd_n_u64⚠
neon
无符号饱和圆角右移 narrow - vqrshrnh_n_s16⚠
neon
有符号饱和圆角右移 narrow - vqrshrnh_n_u16⚠
neon
无符号饱和圆角右移 narrow - vqrshrns_n_s32⚠
neon
有符号饱和圆角右移 narrow - vqrshrns_n_u32⚠
neon
无符号饱和圆角右移 narrow - vqrshrun_high_n_s16⚠
neon
有符号饱和四舍五入右移无符号 narrow - vqrshrun_high_n_s32⚠
neon
有符号饱和四舍五入右移无符号 narrow - vqrshrun_high_n_s64⚠
neon
有符号饱和四舍五入右移无符号 narrow - vqrshrund_n_s64⚠
neon
有符号饱和四舍五入右移无符号 narrow - vqrshrunh_n_s16⚠
neon
有符号饱和四舍五入右移无符号 narrow - vqrshruns_n_s32⚠
neon
有符号饱和四舍五入右移无符号 narrow - vqshl_n_s8⚠
neon
有符号饱和左移 - vqshl_n_s16⚠
neon
有符号饱和左移 - vqshl_n_s32⚠
neon
有符号饱和左移 - vqshl_n_s64⚠
neon
有符号饱和左移 - vqshl_n_u8⚠
neon
无符号饱和左移 - vqshl_n_u16⚠
neon
无符号饱和左移 - vqshl_n_u32⚠
neon
无符号饱和左移 - vqshl_n_u64⚠
neon
无符号饱和左移 - vqshl_s8⚠
neon
有符号饱和左移 - vqshl_s16⚠
neon
有符号饱和左移 - vqshl_s32⚠
neon
有符号饱和左移 - vqshl_s64⚠
neon
有符号饱和左移 - vqshl_u8⚠
neon
无符号饱和左移 - vqshl_u16⚠
neon
无符号饱和左移 - vqshl_u32⚠
neon
无符号饱和左移 - vqshl_u64⚠
neon
无符号饱和左移 - vqshlb_n_s8⚠
neon
有符号饱和左移 - vqshlb_n_u8⚠
neon
无符号饱和左移 - vqshlb_s8⚠
neon
有符号饱和左移 - vqshlb_u8⚠
neon
无符号饱和左移 - vqshld_n_s64⚠
neon
有符号饱和左移 - vqshld_n_u64⚠
neon
无符号饱和左移 - vqshld_s64⚠
neon
有符号饱和左移 - vqshld_u64⚠
neon
无符号饱和左移 - vqshlh_n_s16⚠
neon
有符号饱和左移 - vqshlh_n_u16⚠
neon
无符号饱和左移 - vqshlh_s16⚠
neon
有符号饱和左移 - vqshlh_u16⚠
neon
无符号饱和左移 - vqshlq_n_s8⚠
neon
有符号饱和左移 - vqshlq_n_s16⚠
neon
有符号饱和左移 - vqshlq_n_s32⚠
neon
有符号饱和左移 - vqshlq_n_s64⚠
neon
有符号饱和左移 - vqshlq_n_u8⚠
neon
无符号饱和左移 - vqshlq_n_u16⚠
neon
无符号饱和左移 - vqshlq_n_u32⚠
neon
无符号饱和左移 - vqshlq_n_u64⚠
neon
无符号饱和左移 - vqshlq_s8⚠
neon
有符号饱和左移 - vqshlq_s16⚠
neon
有符号饱和左移 - vqshlq_s32⚠
neon
有符号饱和左移 - vqshlq_s64⚠
neon
有符号饱和左移 - vqshlq_u8⚠
neon
无符号饱和左移 - vqshlq_u16⚠
neon
无符号饱和左移 - vqshlq_u32⚠
neon
无符号饱和左移 - vqshlq_u64⚠
neon
无符号饱和左移 - vqshls_n_s32⚠
neon
有符号饱和左移 - vqshls_n_u32⚠
neon
无符号饱和左移 - vqshls_s32⚠
neon
有符号饱和左移 - vqshls_u32⚠
neon
无符号饱和左移 - vqshlub_n_s8⚠
neon
有符号饱和左移无符号 - vqshlud_n_s64⚠
neon
有符号饱和左移无符号 - vqshluh_n_s16⚠
neon
有符号饱和左移无符号 - vqshlus_n_s32⚠
neon
有符号饱和左移无符号 - vqshrn_high_n_s16⚠
neon
有符号饱和右移 narrow - vqshrn_high_n_s32⚠
neon
有符号饱和右移 narrow - vqshrn_high_n_s64⚠
neon
有符号饱和右移 narrow - vqshrn_high_n_u16⚠
neon
无符号饱和右移 narrow - vqshrn_high_n_u32⚠
neon
无符号饱和右移 narrow - vqshrn_high_n_u64⚠
neon
无符号饱和右移 narrow - vqshrnd_n_s64⚠
neon
有符号饱和右移 narrow - vqshrnd_n_u64⚠
neon
无符号饱和右移 narrow - vqshrnh_n_s16⚠
neon
有符号饱和右移 narrow - vqshrnh_n_u16⚠
neon
无符号饱和右移 narrow - vqshrns_n_s32⚠
neon
有符号饱和右移 narrow - vqshrns_n_u32⚠
neon
无符号饱和右移 narrow - vqshrun_high_n_s16⚠
neon
有符号饱和右移无符号 narrow - vqshrun_high_n_s32⚠
neon
有符号饱和右移无符号 narrow - vqshrun_high_n_s64⚠
neon
有符号饱和右移无符号 narrow - vqshrund_n_s64⚠
neon
有符号饱和右移无符号 narrow - vqshrunh_n_s16⚠
neon
有符号饱和右移无符号 narrow - vqshruns_n_s32⚠
neon
有符号饱和右移无符号 narrow - vqsub_s8⚠
neon
饱和减 - vqsub_s16⚠
neon
饱和减 - vqsub_s32⚠
neon
饱和减 - vqsub_s64⚠
neon
饱和减 - vqsub_u8⚠
neon
饱和减 - vqsub_u16⚠
neon
饱和减 - vqsub_u32⚠
neon
饱和减 - vqsub_u64⚠
neon
饱和减 - vqsubb_s8⚠
neon
饱和减 - vqsubb_u8⚠
neon
饱和减 - vqsubd_s64⚠
neon
饱和减 - vqsubd_u64⚠
neon
饱和减 - vqsubh_s16⚠
neon
饱和减 - vqsubh_u16⚠
neon
饱和减 - vqsubq_s8⚠
neon
饱和减 - vqsubq_s16⚠
neon
饱和减 - vqsubq_s32⚠
neon
饱和减 - vqsubq_s64⚠
neon
饱和减 - vqsubq_u8⚠
neon
饱和减 - vqsubq_u16⚠
neon
饱和减 - vqsubq_u32⚠
neon
饱和减 - vqsubq_u64⚠
neon
饱和减 - vqsubs_s32⚠
neon
饱和减 - vqsubs_u32⚠
neon
饱和减 - vqtbl1_p8⚠
neon
查表 - vqtbl1_s8⚠
neon
查表 - vqtbl1_u8⚠
neon
查表 - vqtbl1q_p8⚠
neon
查表 - vqtbl1q_s8⚠
neon
查表 - vqtbl1q_u8⚠
neon
查表 - vqtbl2_p8⚠
neon
查表 - vqtbl2_s8⚠
neon
查表 - vqtbl2_u8⚠
neon
查表 - vqtbl2q_p8⚠
neon
查表 - vqtbl2q_s8⚠
neon
查表 - vqtbl2q_u8⚠
neon
查表 - vqtbl3_p8⚠
neon
查表 - vqtbl3_s8⚠
neon
查表 - vqtbl3_u8⚠
neon
查表 - vqtbl3q_p8⚠
neon
查表 - vqtbl3q_s8⚠
neon
查表 - vqtbl3q_u8⚠
neon
查表 - vqtbl4_p8⚠
neon
查表 - vqtbl4_s8⚠
neon
查表 - vqtbl4_u8⚠
neon
查表 - vqtbl4q_p8⚠
neon
查表 - vqtbl4q_s8⚠
neon
查表 - vqtbl4q_u8⚠
neon
查表 - vqtbx1_p8⚠
neon
扩展表查询 - vqtbx1_s8⚠
neon
扩展表查询 - vqtbx1_u8⚠
neon
扩展表查询 - vqtbx1q_p8⚠
neon
扩展表查询 - vqtbx1q_s8⚠
neon
扩展表查询 - vqtbx1q_u8⚠
neon
扩展表查询 - vqtbx2_p8⚠
neon
扩展表查询 - vqtbx2_s8⚠
neon
扩展表查询 - vqtbx2_u8⚠
neon
扩展表查询 - vqtbx2q_p8⚠
neon
扩展表查询 - vqtbx2q_s8⚠
neon
扩展表查询 - vqtbx2q_u8⚠
neon
扩展表查询 - vqtbx3_p8⚠
neon
扩展表查询 - vqtbx3_s8⚠
neon
扩展表查询 - vqtbx3_u8⚠
neon
扩展表查询 - vqtbx3q_p8⚠
neon
扩展表查询 - vqtbx3q_s8⚠
neon
扩展表查询 - vqtbx3q_u8⚠
neon
扩展表查询 - vqtbx4_p8⚠
neon
扩展表查询 - vqtbx4_s8⚠
neon
扩展表查询 - vqtbx4_u8⚠
neon
扩展表查询 - vqtbx4q_p8⚠
neon
扩展表查询 - vqtbx4q_s8⚠
neon
扩展表查询 - vqtbx4q_u8⚠
neon
扩展表查询 - vraddhn_high_s16⚠
neon
舍入添加返回的 High Narrow (高半)。 - vraddhn_high_s32⚠
neon
舍入添加返回的 High Narrow (高半)。 - vraddhn_high_s64⚠
neon
舍入添加返回的 High Narrow (高半)。 - vraddhn_high_u16⚠
neon
舍入添加返回的 High Narrow (高半)。 - vraddhn_high_u32⚠
neon
舍入添加返回的 High Narrow (高半)。 - vraddhn_high_u64⚠
neon
舍入添加返回的 High Narrow (高半)。 - vraddhn_s16⚠
neon
舍入添加返回 High Narrow。 - vraddhn_s32⚠
neon
舍入添加返回 High Narrow。 - vraddhn_s64⚠
neon
舍入添加返回 High Narrow。 - vraddhn_u16⚠
neon
舍入添加返回 High Narrow。 - vraddhn_u32⚠
neon
舍入添加返回 High Narrow。 - vraddhn_u64⚠
neon
舍入添加返回 High Narrow。 - vrbit_p8⚠
neon
反转位序 - vrbit_s8⚠
neon
反转位序 - vrbit_u8⚠
neon
反转位序 - vrbitq_p8⚠
neon
反转位序 - vrbitq_s8⚠
neon
反转位序 - vrbitq_u8⚠
neon
反转位序 - vrecpe_f32⚠
neon
相互估计。 - vrecpe_f64⚠
neon
相互估计。 - vrecpe_u32⚠
neon
无符号倒数估计 - vrecped_f64⚠
neon
相互估计。 - vrecpeq_f32⚠
neon
相互估计。 - vrecpeq_f64⚠
neon
相互估计。 - vrecpeq_u32⚠
neon
无符号倒数估计 - vrecpes_f32⚠
neon
相互估计。 - vrecps_f32⚠
neon
浮点倒数步长 - vrecps_f64⚠
neon
浮点倒数步长 - vrecpsd_f64⚠
neon
浮点倒数步长 - vrecpsq_f32⚠
neon
浮点倒数步长 - vrecpsq_f64⚠
neon
浮点倒数步长 - vrecpss_f32⚠
neon
浮点倒数步长 - vrecpxd_f64⚠
neon
浮点倒数指数 - vrecpxs_f32⚠
neon
浮点倒数指数 - vreinterpret_f32_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_p64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f32_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_p64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_f64_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p8_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p8_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p16_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p16_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p64_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p64_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p64_p8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_p16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_s8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_s16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_s32⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_p64_u8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_u16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_u32⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_p64_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_s8_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s8_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_s16_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s16_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_s32_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s32_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_p64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_s64_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_u8_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u8_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_u16_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u16_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpret_u32_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u32_u64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_p64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpret_u64_u32⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- vreinterpretq_f32_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_f32_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_f32_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_f64_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_f64_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_f64_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_p8_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p8_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p8_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p8_u64⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_p16_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_p16_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p16_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p16_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_p16_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_p64_p8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_p16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_s8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_s16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_s32⚠
neon,aes
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- vreinterpretq_p64_u8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_u16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p64_u32⚠
neon,aes
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_p128_p8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_p16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_s8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_s16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_s32⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_s64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_u8⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_u16⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_u32⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_p128_u64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s8_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s8_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s8_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_u8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_s8_u64⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s16_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- vreinterpretq_s16_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s16_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s16_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s16_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s32_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- vreinterpretq_s32_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s32_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s32_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s32_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s64_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s64_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_s64_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_s64_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u8_f32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_f64⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_p8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_p16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u8_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u8_s8⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_s16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_s32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_s64⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_u16⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_u32⚠
neon
Vector 重新解释强制转换操作 - vreinterpretq_u8_u64⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u16_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- vreinterpretq_u16_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u16_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u16_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u16_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u32_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- vreinterpretq_u32_p64⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u32_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u32_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u32_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u64_p8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u64_p128⚠
neon,aes
Vector 重新解释强制转换操作 - vreinterpretq_u64_s8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vreinterpretq_u64_u8⚠
neon
Vector 重新解释强制转换操作 - Vector 重新解释强制转换操作
- Vector 重新解释强制转换操作
- vrev16_p8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev16_s8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev16_u8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev16q_p8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev16q_s8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev16q_u8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32_p8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32_p16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32_s8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32_s16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32_u8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32_u16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32q_p8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32q_p16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32q_s8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32q_s16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32q_u8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev32q_u16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_f32⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_p8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_p16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_s8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_s16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_s32⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_u8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_u16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64_u32⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_f32⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_p8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_p16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_s8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_s16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_s32⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_u8⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_u16⚠
neon
反转 vector 元素 (交换字节顺序) - vrev64q_u32⚠
neon
反转 vector 元素 (交换字节顺序) - vrhadd_s8⚠
neon
舍入减半添加 - vrhadd_s16⚠
neon
舍入减半添加 - vrhadd_s32⚠
neon
舍入减半添加 - vrhadd_u8⚠
neon
舍入减半添加 - vrhadd_u16⚠
neon
舍入减半添加 - vrhadd_u32⚠
neon
舍入减半添加 - vrhaddq_s8⚠
neon
舍入减半添加 - vrhaddq_s16⚠
neon
舍入减半添加 - vrhaddq_s32⚠
neon
舍入减半添加 - vrhaddq_u8⚠
neon
舍入减半添加 - vrhaddq_u16⚠
neon
舍入减半添加 - vrhaddq_u32⚠
neon
舍入减半添加 - vrnd_f32⚠
neon
浮点四舍五入为整数,接近零 - vrnd_f64⚠
neon
浮点四舍五入为整数,接近零 - vrnda_f32⚠
neon
浮点数舍入到整数,到最近的与远离的关系 - vrnda_f64⚠
neon
浮点数舍入到整数,到最近的与远离的关系 - vrndaq_f32⚠
neon
浮点数舍入到整数,到最近的与远离的关系 - vrndaq_f64⚠
neon
浮点数舍入到整数,到最近的与远离的关系 - vrndi_f32⚠
neon
浮点四舍五入到整数,使用当前舍入模式 - vrndi_f64⚠
neon
浮点四舍五入到整数,使用当前舍入模式 - vrndiq_f32⚠
neon
浮点四舍五入到整数,使用当前舍入模式 - vrndiq_f64⚠
neon
浮点四舍五入到整数,使用当前舍入模式 - vrndm_f32⚠
neon
浮点舍入为整数,向负无穷大 - vrndm_f64⚠
neon
浮点舍入为整数,向负无穷大 - vrndmq_f32⚠
neon
浮点舍入为整数,向负无穷大 - vrndmq_f64⚠
neon
浮点舍入为整数,向负无穷大 - vrndn_f32⚠
neon
浮点数舍入到整数,最接近与偶数的关系 - vrndn_f64⚠
neon
浮点数舍入到整数,最接近与偶数的关系 - vrndnq_f32⚠
neon
浮点数舍入到整数,最接近与偶数的关系 - vrndnq_f64⚠
neon
浮点数舍入到整数,最接近与偶数的关系 - vrndns_f32⚠
neon
浮点数舍入到整数,最接近与偶数的关系 - vrndp_f32⚠
neon
浮点舍入为整数,朝向正无穷大 - vrndp_f64⚠
neon
浮点舍入为整数,朝向正无穷大 - vrndpq_f32⚠
neon
浮点舍入为整数,朝向正无穷大 - vrndpq_f64⚠
neon
浮点舍入为整数,朝向正无穷大 - vrndq_f32⚠
neon
浮点四舍五入为整数,接近零 - vrndq_f64⚠
neon
浮点四舍五入为整数,接近零 - vrndx_f32⚠
neon
使用当前舍入模式将浮点舍入精确到整数 - vrndx_f64⚠
neon
使用当前舍入模式将浮点舍入精确到整数 - vrndxq_f32⚠
neon
使用当前舍入模式将浮点舍入精确到整数 - vrndxq_f64⚠
neon
使用当前舍入模式将浮点舍入精确到整数 - vrshl_s8⚠
neon
有符号舍入左移 - vrshl_s16⚠
neon
有符号舍入左移 - vrshl_s32⚠
neon
有符号舍入左移 - vrshl_s64⚠
neon
有符号舍入左移 - vrshl_u8⚠
neon
无符号舍入左移 - vrshl_u16⚠
neon
无符号舍入左移 - vrshl_u32⚠
neon
无符号舍入左移 - vrshl_u64⚠
neon
无符号舍入左移 - vrshld_s64⚠
neon
有符号舍入左移 - vrshld_u64⚠
neon
无符号舍入左移 - vrshlq_s8⚠
neon
有符号舍入左移 - vrshlq_s16⚠
neon
有符号舍入左移 - vrshlq_s32⚠
neon
有符号舍入左移 - vrshlq_s64⚠
neon
有符号舍入左移 - vrshlq_u8⚠
neon
无符号舍入左移 - vrshlq_u16⚠
neon
无符号舍入左移 - vrshlq_u32⚠
neon
无符号舍入左移 - vrshlq_u64⚠
neon
无符号舍入左移 - vrshr_n_s8⚠
neon
有符号舍入右移 - vrshr_n_s16⚠
neon
有符号舍入右移 - vrshr_n_s32⚠
neon
有符号舍入右移 - vrshr_n_s64⚠
neon
有符号舍入右移 - vrshr_n_u8⚠
neon
无符号舍入右移 - vrshr_n_u16⚠
neon
无符号舍入右移 - vrshr_n_u32⚠
neon
无符号舍入右移 - vrshr_n_u64⚠
neon
无符号舍入右移 - vrshrd_n_s64⚠
neon
有符号舍入右移 - vrshrd_n_u64⚠
neon
无符号舍入右移 - vrshrn_high_n_s16⚠
neon
舍入右移变 narrow - vrshrn_high_n_s32⚠
neon
舍入右移变 narrow - vrshrn_high_n_s64⚠
neon
舍入右移变 narrow - vrshrn_high_n_u16⚠
neon
舍入右移变 narrow - vrshrn_high_n_u32⚠
neon
舍入右移变 narrow - vrshrn_high_n_u64⚠
neon
舍入右移变 narrow - vrshrn_n_u16⚠
neon
舍入右移变 narrow - vrshrn_n_u32⚠
neon
舍入右移变 narrow - vrshrn_n_u64⚠
neon
舍入右移变 narrow - vrshrq_n_s8⚠
neon
有符号舍入右移 - vrshrq_n_s16⚠
neon
有符号舍入右移 - vrshrq_n_s32⚠
neon
有符号舍入右移 - vrshrq_n_s64⚠
neon
有符号舍入右移 - vrshrq_n_u8⚠
neon
无符号舍入右移 - vrshrq_n_u16⚠
neon
无符号舍入右移 - vrshrq_n_u32⚠
neon
无符号舍入右移 - vrshrq_n_u64⚠
neon
无符号舍入右移 - vrsqrte_f32⚠
neon
平方根倒数估算。 - vrsqrte_f64⚠
neon
平方根倒数估算。 - vrsqrte_u32⚠
neon
无符号倒数平方根估计 - vrsqrted_f64⚠
neon
平方根倒数估算。 - vrsqrteq_f32⚠
neon
平方根倒数估算。 - vrsqrteq_f64⚠
neon
平方根倒数估算。 - vrsqrteq_u32⚠
neon
无符号倒数平方根估计 - vrsqrtes_f32⚠
neon
平方根倒数估算。 - vrsqrts_f32⚠
neon
浮点倒数平方根步长 - vrsqrts_f64⚠
neon
浮点倒数平方根步长 - vrsqrtsd_f64⚠
neon
浮点倒数平方根步长 - vrsqrtsq_f32⚠
neon
浮点倒数平方根步长 - vrsqrtsq_f64⚠
neon
浮点倒数平方根步长 - vrsqrtss_f32⚠
neon
浮点倒数平方根步长 - vrsra_n_s8⚠
neon
有符号四舍入移并累加 - vrsra_n_s16⚠
neon
有符号四舍入移并累加 - vrsra_n_s32⚠
neon
有符号四舍入移并累加 - vrsra_n_s64⚠
neon
有符号四舍入移并累加 - vrsra_n_u8⚠
neon
无符号舍入右移并累加 - vrsra_n_u16⚠
neon
无符号舍入右移并累加 - vrsra_n_u32⚠
neon
无符号舍入右移并累加 - vrsra_n_u64⚠
neon
无符号舍入右移并累加 - vrsrad_n_s64⚠
neon
有符号舍入右移并累加。 - vrsrad_n_u64⚠
neon
未定义的舍入右移并累加。 - vrsraq_n_s8⚠
neon
有符号四舍入移并累加 - vrsraq_n_s16⚠
neon
有符号四舍入移并累加 - vrsraq_n_s32⚠
neon
有符号四舍入移并累加 - vrsraq_n_s64⚠
neon
有符号四舍入移并累加 - vrsraq_n_u8⚠
neon
无符号舍入右移并累加 - vrsraq_n_u16⚠
neon
无符号舍入右移并累加 - vrsraq_n_u32⚠
neon
无符号舍入右移并累加 - vrsraq_n_u64⚠
neon
无符号舍入右移并累加 - vrsubhn_high_s16⚠
neon
舍入减法返回 high narrow - vrsubhn_high_s32⚠
neon
舍入减法返回 high narrow - vrsubhn_high_s64⚠
neon
舍入减法返回 high narrow - vrsubhn_high_u16⚠
neon
舍入减法返回 high narrow - vrsubhn_high_u32⚠
neon
舍入减法返回 high narrow - vrsubhn_high_u64⚠
neon
舍入减法返回 high narrow - vrsubhn_s16⚠
neon
舍入减法返回 high narrow - vrsubhn_s32⚠
neon
舍入减法返回 high narrow - vrsubhn_s64⚠
neon
舍入减法返回 high narrow - vrsubhn_u16⚠
neon
舍入减法返回 high narrow - vrsubhn_u32⚠
neon
舍入减法返回 high narrow - vrsubhn_u64⚠
neon
舍入减法返回 high narrow - vset_lane_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_f64⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_p64⚠
neon,aes
从另一个 vector 元素插入 vector 元素 - vset_lane_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_s64⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vset_lane_u64⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_f32⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_f64⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_p8⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_p16⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_p64⚠
neon,aes
从另一个 vector 元素插入 vector 元素 - vsetq_lane_s8⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_s16⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_s32⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_s64⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_u8⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_u16⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_u32⚠
neon
从另一个 vector 元素插入 vector 元素 - vsetq_lane_u64⚠
neon
从另一个 vector 元素插入 vector 元素 - vshl_n_s8⚠
neon
左移 - vshl_n_s16⚠
neon
左移 - vshl_n_s32⚠
neon
左移 - vshl_n_s64⚠
neon
左移 - vshl_n_u8⚠
neon
左移 - vshl_n_u16⚠
neon
左移 - vshl_n_u32⚠
neon
左移 - vshl_n_u64⚠
neon
左移 - vshl_s8⚠
neon
有符号左移 - vshl_s16⚠
neon
有符号左移 - vshl_s32⚠
neon
有符号左移 - vshl_s64⚠
neon
有符号左移 - vshl_u8⚠
neon
无符号左移 - vshl_u16⚠
neon
无符号左移 - vshl_u32⚠
neon
无符号左移 - vshl_u64⚠
neon
无符号左移 - vshld_n_s64⚠
neon
左移 - vshld_n_u64⚠
neon
左移 - vshld_s64⚠
neon
有符号左移 - vshld_u64⚠
neon
无符号左移 - vshll_high_n_s8⚠
neon
有符号左移长 - vshll_high_n_s16⚠
neon
有符号左移长 - vshll_high_n_s32⚠
neon
有符号左移长 - vshll_high_n_u8⚠
neon
有符号左移长 - vshll_high_n_u16⚠
neon
有符号左移长 - vshll_high_n_u32⚠
neon
有符号左移长 - vshll_n_s8⚠
neon
有符号左移长 - vshll_n_s16⚠
neon
有符号左移长 - vshll_n_s32⚠
neon
有符号左移长 - vshll_n_u8⚠
neon
有符号左移长 - vshll_n_u16⚠
neon
有符号左移长 - vshll_n_u32⚠
neon
有符号左移长 - vshlq_n_s8⚠
neon
左移 - vshlq_n_s16⚠
neon
左移 - vshlq_n_s32⚠
neon
左移 - vshlq_n_s64⚠
neon
左移 - vshlq_n_u8⚠
neon
左移 - vshlq_n_u16⚠
neon
左移 - vshlq_n_u32⚠
neon
左移 - vshlq_n_u64⚠
neon
左移 - vshlq_s8⚠
neon
有符号左移 - vshlq_s16⚠
neon
有符号左移 - vshlq_s32⚠
neon
有符号左移 - vshlq_s64⚠
neon
有符号左移 - vshlq_u8⚠
neon
无符号左移 - vshlq_u16⚠
neon
无符号左移 - vshlq_u32⚠
neon
无符号左移 - vshlq_u64⚠
neon
无符号左移 - vshr_n_s8⚠
neon
右移 - vshr_n_s16⚠
neon
右移 - vshr_n_s32⚠
neon
右移 - vshr_n_s64⚠
neon
右移 - vshr_n_u8⚠
neon
右移 - vshr_n_u16⚠
neon
右移 - vshr_n_u32⚠
neon
右移 - vshr_n_u64⚠
neon
右移 - vshrd_n_s64⚠
neon
有符号右移 - vshrd_n_u64⚠
neon
无符号右移 - vshrn_high_n_s16⚠
neon
右移 narrow - vshrn_high_n_s32⚠
neon
右移 narrow - vshrn_high_n_s64⚠
neon
右移 narrow - vshrn_high_n_u16⚠
neon
右移 narrow - vshrn_high_n_u32⚠
neon
右移 narrow - vshrn_high_n_u64⚠
neon
右移 narrow - vshrn_n_s16⚠
neon
右移 narrow - vshrn_n_s32⚠
neon
右移 narrow - vshrn_n_s64⚠
neon
右移 narrow - vshrn_n_u16⚠
neon
右移 narrow - vshrn_n_u32⚠
neon
右移 narrow - vshrn_n_u64⚠
neon
右移 narrow - vshrq_n_s8⚠
neon
右移 - vshrq_n_s16⚠
neon
右移 - vshrq_n_s32⚠
neon
右移 - vshrq_n_s64⚠
neon
右移 - vshrq_n_u8⚠
neon
右移 - vshrq_n_u16⚠
neon
右移 - vshrq_n_u32⚠
neon
右移 - vshrq_n_u64⚠
neon
右移 - vsli_n_p8⚠
neon
左移并插入 (immediate) - vsli_n_p16⚠
neon
左移并插入 (immediate) - vsli_n_p64⚠
neon,aes
左移并插入 (immediate) - vsli_n_s8⚠
neon
左移并插入 (immediate) - vsli_n_s16⚠
neon
左移并插入 (immediate) - vsli_n_s32⚠
neon
左移并插入 (immediate) - vsli_n_s64⚠
neon
左移并插入 (immediate) - vsli_n_u8⚠
neon
左移并插入 (immediate) - vsli_n_u16⚠
neon
左移并插入 (immediate) - vsli_n_u32⚠
neon
左移并插入 (immediate) - vsli_n_u64⚠
neon
左移并插入 (immediate) - vslid_n_s64⚠
neon
左移并插入 - vslid_n_u64⚠
neon
左移并插入 - vsliq_n_p8⚠
neon
左移并插入 (immediate) - vsliq_n_p16⚠
neon
左移并插入 (immediate) - vsliq_n_p64⚠
neon,aes
左移并插入 (immediate) - vsliq_n_s8⚠
neon
左移并插入 (immediate) - vsliq_n_s16⚠
neon
左移并插入 (immediate) - vsliq_n_s32⚠
neon
左移并插入 (immediate) - vsliq_n_s64⚠
neon
左移并插入 (immediate) - vsliq_n_u8⚠
neon
左移并插入 (immediate) - vsliq_n_u16⚠
neon
左移并插入 (immediate) - vsliq_n_u32⚠
neon
左移并插入 (immediate) - vsliq_n_u64⚠
neon
左移并插入 (immediate) - vsqadd_u8⚠
neon
无符号饱和的有符号值的累加。 - vsqadd_u16⚠
neon
无符号饱和的有符号值的累加。 - vsqadd_u32⚠
neon
无符号饱和的有符号值的累加。 - vsqadd_u64⚠
neon
无符号饱和的有符号值的累加。 - vsqaddb_u8⚠
neon
有符号值的无符号饱和累加 - vsqaddd_u64⚠
neon
有符号值的无符号饱和累加 - vsqaddh_u16⚠
neon
有符号值的无符号饱和累加 - vsqaddq_u8⚠
neon
无符号饱和的有符号值的累加。 - vsqaddq_u16⚠
neon
无符号饱和的有符号值的累加。 - vsqaddq_u32⚠
neon
无符号饱和的有符号值的累加。 - vsqaddq_u64⚠
neon
无符号饱和的有符号值的累加。 - vsqadds_u32⚠
neon
有符号值的无符号饱和累加 - vsqrt_f32⚠
neon
计算每个 lane 的平方根。 - vsqrt_f64⚠
neon
计算每个 lane 的平方根。 - vsqrtq_f32⚠
neon
计算每个 lane 的平方根。 - vsqrtq_f64⚠
neon
计算每个 lane 的平方根。 - vsra_n_s8⚠
neon
有符号右移并累加 - vsra_n_s16⚠
neon
有符号右移并累加 - vsra_n_s32⚠
neon
有符号右移并累加 - vsra_n_s64⚠
neon
有符号右移并累加 - vsra_n_u8⚠
neon
无符号右移并累加 - vsra_n_u16⚠
neon
无符号右移并累加 - vsra_n_u32⚠
neon
无符号右移并累加 - vsra_n_u64⚠
neon
无符号右移并累加 - vsrad_n_s64⚠
neon
有符号右移并累加 - vsrad_n_u64⚠
neon
无符号右移并累加 - vsraq_n_s8⚠
neon
有符号右移并累加 - vsraq_n_s16⚠
neon
有符号右移并累加 - vsraq_n_s32⚠
neon
有符号右移并累加 - vsraq_n_s64⚠
neon
有符号右移并累加 - vsraq_n_u8⚠
neon
无符号右移并累加 - vsraq_n_u16⚠
neon
无符号右移并累加 - vsraq_n_u32⚠
neon
无符号右移并累加 - vsraq_n_u64⚠
neon
无符号右移并累加 - vsri_n_p8⚠
neon
右移并插入 (immediate) - vsri_n_p16⚠
neon
右移并插入 (immediate) - vsri_n_p64⚠
neon,aes
右移并插入 (immediate) - vsri_n_s8⚠
neon
右移并插入 (immediate) - vsri_n_s16⚠
neon
右移并插入 (immediate) - vsri_n_s32⚠
neon
右移并插入 (immediate) - vsri_n_s64⚠
neon
右移并插入 (immediate) - vsri_n_u8⚠
neon
右移并插入 (immediate) - vsri_n_u16⚠
neon
右移并插入 (immediate) - vsri_n_u32⚠
neon
右移并插入 (immediate) - vsri_n_u64⚠
neon
右移并插入 (immediate) - vsrid_n_s64⚠
neon
右移并插入 - vsrid_n_u64⚠
neon
右移并插入 - vsriq_n_p8⚠
neon
右移并插入 (immediate) - vsriq_n_p16⚠
neon
右移并插入 (immediate) - vsriq_n_p64⚠
neon,aes
右移并插入 (immediate) - vsriq_n_s8⚠
neon
右移并插入 (immediate) - vsriq_n_s16⚠
neon
右移并插入 (immediate) - vsriq_n_s32⚠
neon
右移并插入 (immediate) - vsriq_n_s64⚠
neon
右移并插入 (immediate) - vsriq_n_u8⚠
neon
右移并插入 (immediate) - vsriq_n_u16⚠
neon
右移并插入 (immediate) - vsriq_n_u32⚠
neon
右移并插入 (immediate) - vsriq_n_u64⚠
neon
右移并插入 (immediate) - vst1_f32⚠
neon
- vst1_f64⚠
neon
- vst1_f64_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_f64_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_f64_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_lane_f32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_f64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_p8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_p16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_p64⚠
neon,aes
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_s8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_s16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_s32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_s64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_u8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_u16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_u32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_lane_u64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1_p8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_p8_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p8_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p8_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_p16_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p16_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p16_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p64⚠
neon,aes
- vst1_p64_x2⚠
neon,aes
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p64_x3⚠
neon,aes
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_p64_x4⚠
neon,aes
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_s8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_s16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_s32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_s64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_u8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_u8_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u8_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u8_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_u16_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u16_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u16_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_u32_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u32_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u32_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1_u64_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u64_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1_u64_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_f32⚠
neon
- vst1q_f64⚠
neon
- vst1q_f64_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_f64_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_f64_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_lane_f32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_f64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_p8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_p16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_p64⚠
neon,aes
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_s8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_s16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_s32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_s64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_u8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_u16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_u32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_lane_u64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构 - vst1q_p8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_p8_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p8_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p8_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_p16_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p16_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p16_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p64⚠
neon,aes
- vst1q_p64_x2⚠
neon,aes
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p64_x3⚠
neon,aes
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_p64_x4⚠
neon,aes
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_s8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_s16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_s32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_s64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_u8⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_u8_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u8_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u8_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u16⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_u16_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u16_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u16_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u32⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_u32_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u32_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u32_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u64⚠
neon
从一个、两个、三个或四个寄存器中存储多个单一元素结构。 - vst1q_u64_x2⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u64_x3⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst1q_u64_x4⚠
neon
将多个单一元素结构存储到一个、两个、三个或四个寄存器中 - vst2_f64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_f64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_p8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_p16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_p64⚠
neon,aes
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_s64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_u8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_u16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_u32⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_lane_u64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_p8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_p16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_p64⚠
neon,aes
存储来自两个寄存器的多个 2 元素结构 - vst2_u8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_u16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_u32⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2_u64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_f64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_f64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_p8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_p16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_p64⚠
neon,aes
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_s8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_s64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_u8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_u16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_u32⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_lane_u64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_p8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_p16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_p64⚠
neon,aes
存储来自两个寄存器的多个 2 元素结构 - vst2q_s64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_u8⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_u16⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_u32⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst2q_u64⚠
neon
存储来自两个寄存器的多个 2 元素结构 - vst3_f64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_f64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_p8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_p16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_p64⚠
neon,aes
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_s64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_u8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_u16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_u32⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_lane_u64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_p8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_p16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_p64⚠
neon,aes
存储来自三个寄存器的多个 3 元素结构 - vst3_u8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_u16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_u32⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3_u64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_f64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_f64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_p8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_p16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_p64⚠
neon,aes
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_s8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_s64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_u8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_u16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_u32⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_lane_u64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_p8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_p16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_p64⚠
neon,aes
存储来自三个寄存器的多个 3 元素结构 - vst3q_s64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_u8⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_u16⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_u32⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst3q_u64⚠
neon
存储来自三个寄存器的多个 3 元素结构 - vst4_f64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_f64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_p8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_p16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_p64⚠
neon,aes
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_s64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_u8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_u16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_u32⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_lane_u64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_p8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_p16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_p64⚠
neon,aes
存储来自四个寄存器的多个 4 元素结构 - vst4_u8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_u16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_u32⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4_u64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_f64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_f64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_p8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_p16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_p64⚠
neon,aes
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_s8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_s64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_u8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_u16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_u32⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_lane_u64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_p8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_p16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_p64⚠
neon,aes
存储来自四个寄存器的多个 4 元素结构 - vst4q_s64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_u8⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_u16⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_u32⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vst4q_u64⚠
neon
存储来自四个寄存器的多个 4 元素结构 - vstrq_p128⚠
neon
存储 SIMD&FP 寄存器 (immediate 偏移量) - vsub_f32⚠
neon
Subtract - vsub_f64⚠
neon
Subtract - vsub_s8⚠
neon
Subtract - vsub_s16⚠
neon
Subtract - vsub_s32⚠
neon
Subtract - vsub_s64⚠
neon
Subtract - vsub_u8⚠
neon
Subtract - vsub_u16⚠
neon
Subtract - vsub_u32⚠
neon
Subtract - vsub_u64⚠
neon
Subtract - vsubd_s64⚠
neon
Subtract - vsubd_u64⚠
neon
Subtract - vsubhn_high_s16⚠
neon
减去返回 high narrow - vsubhn_high_s32⚠
neon
减去返回 high narrow - vsubhn_high_s64⚠
neon
减去返回 high narrow - vsubhn_high_u16⚠
neon
减去返回 high narrow - vsubhn_high_u32⚠
neon
减去返回 high narrow - vsubhn_high_u64⚠
neon
减去返回 high narrow - vsubhn_s16⚠
neon
减去返回 high narrow - vsubhn_s32⚠
neon
减去返回 high narrow - vsubhn_s64⚠
neon
减去返回 high narrow - vsubhn_u16⚠
neon
减去返回 high narrow - vsubhn_u32⚠
neon
减去返回 high narrow - vsubhn_u64⚠
neon
减去返回 high narrow - vsubl_high_s8⚠
neon
有符号减长 - vsubl_high_s16⚠
neon
有符号减长 - vsubl_high_s32⚠
neon
有符号减长 - vsubl_high_u8⚠
neon
无符号减长 - vsubl_high_u16⚠
neon
无符号减长 - vsubl_high_u32⚠
neon
无符号减长 - vsubl_s8⚠
neon
有符号减长 - vsubl_s16⚠
neon
有符号减长 - vsubl_s32⚠
neon
有符号减长 - vsubl_u8⚠
neon
无符号减长 - vsubl_u16⚠
neon
无符号减长 - vsubl_u32⚠
neon
无符号减长 - vsubq_f32⚠
neon
Subtract - vsubq_f64⚠
neon
Subtract - vsubq_s8⚠
neon
Subtract - vsubq_s16⚠
neon
Subtract - vsubq_s32⚠
neon
Subtract - vsubq_s64⚠
neon
Subtract - vsubq_u8⚠
neon
Subtract - vsubq_u16⚠
neon
Subtract - vsubq_u32⚠
neon
Subtract - vsubq_u64⚠
neon
Subtract - vsubw_high_s8⚠
neon
有符号减宽 - vsubw_high_s16⚠
neon
有符号减宽 - vsubw_high_s32⚠
neon
有符号减宽 - vsubw_high_u8⚠
neon
无符号减宽 - vsubw_high_u16⚠
neon
无符号减宽 - vsubw_high_u32⚠
neon
无符号减宽 - vsubw_s8⚠
neon
有符号减宽 - vsubw_s16⚠
neon
有符号减宽 - vsubw_s32⚠
neon
有符号减宽 - vsubw_u8⚠
neon
无符号减宽 - vsubw_u16⚠
neon
无符号减宽 - vsubw_u32⚠
neon
无符号减宽 - vtbl1_p8⚠
neon
查表 - vtbl1_s8⚠
neon
查表 - vtbl1_u8⚠
neon
查表 - vtbl2_p8⚠
neon
查表 - vtbl2_s8⚠
neon
查表 - vtbl2_u8⚠
neon
查表 - vtbl3_p8⚠
neon
查表 - vtbl3_s8⚠
neon
查表 - vtbl3_u8⚠
neon
查表 - vtbl4_p8⚠
neon
查表 - vtbl4_s8⚠
neon
查表 - vtbl4_u8⚠
neon
查表 - vtbx1_p8⚠
neon
扩展表查询 - vtbx1_s8⚠
neon
扩展表查询 - vtbx1_u8⚠
neon
扩展表查询 - vtbx2_p8⚠
neon
扩展表查询 - vtbx2_s8⚠
neon
扩展表查询 - vtbx2_u8⚠
neon
扩展表查询 - vtbx3_p8⚠
neon
扩展表查询 - vtbx3_s8⚠
neon
扩展表查询 - vtbx3_u8⚠
neon
扩展表查询 - vtbx4_p8⚠
neon
扩展表查询 - vtbx4_s8⚠
neon
扩展表查询 - vtbx4_u8⚠
neon
扩展表查询 - vtrn1_f32⚠
neon
转置向量 - vtrn1_p8⚠
neon
转置向量 - vtrn1_p16⚠
neon
转置向量 - vtrn1_s8⚠
neon
转置向量 - vtrn1_s16⚠
neon
转置向量 - vtrn1_s32⚠
neon
转置向量 - vtrn1_u8⚠
neon
转置向量 - vtrn1_u16⚠
neon
转置向量 - vtrn1_u32⚠
neon
转置向量 - vtrn1q_f32⚠
neon
转置向量 - vtrn1q_f64⚠
neon
转置向量 - vtrn1q_p8⚠
neon
转置向量 - vtrn1q_p16⚠
neon
转置向量 - vtrn1q_p64⚠
neon
转置向量 - vtrn1q_s8⚠
neon
转置向量 - vtrn1q_s16⚠
neon
转置向量 - vtrn1q_s32⚠
neon
转置向量 - vtrn1q_s64⚠
neon
转置向量 - vtrn1q_u8⚠
neon
转置向量 - vtrn1q_u16⚠
neon
转置向量 - vtrn1q_u32⚠
neon
转置向量 - vtrn1q_u64⚠
neon
转置向量 - vtrn2_f32⚠
neon
转置向量 - vtrn2_p8⚠
neon
转置向量 - vtrn2_p16⚠
neon
转置向量 - vtrn2_s8⚠
neon
转置向量 - vtrn2_s16⚠
neon
转置向量 - vtrn2_s32⚠
neon
转置向量 - vtrn2_u8⚠
neon
转置向量 - vtrn2_u16⚠
neon
转置向量 - vtrn2_u32⚠
neon
转置向量 - vtrn2q_f32⚠
neon
转置向量 - vtrn2q_f64⚠
neon
转置向量 - vtrn2q_p8⚠
neon
转置向量 - vtrn2q_p16⚠
neon
转置向量 - vtrn2q_p64⚠
neon
转置向量 - vtrn2q_s8⚠
neon
转置向量 - vtrn2q_s16⚠
neon
转置向量 - vtrn2q_s32⚠
neon
转置向量 - vtrn2q_s64⚠
neon
转置向量 - vtrn2q_u8⚠
neon
转置向量 - vtrn2q_u16⚠
neon
转置向量 - vtrn2q_u32⚠
neon
转置向量 - vtrn2q_u64⚠
neon
转置向量 - vtrn_f32⚠
neon
转置元素 - vtrn_p8⚠
neon
转置元素 - vtrn_p16⚠
neon
转置元素 - vtrn_s8⚠
neon
转置元素 - vtrn_s16⚠
neon
转置元素 - vtrn_s32⚠
neon
转置元素 - vtrn_u8⚠
neon
转置元素 - vtrn_u16⚠
neon
转置元素 - vtrn_u32⚠
neon
转置元素 - vtrnq_f32⚠
neon
转置元素 - vtrnq_p8⚠
neon
转置元素 - vtrnq_p16⚠
neon
转置元素 - vtrnq_s8⚠
neon
转置元素 - vtrnq_s16⚠
neon
转置元素 - vtrnq_s32⚠
neon
转置元素 - vtrnq_u8⚠
neon
转置元素 - vtrnq_u16⚠
neon
转置元素 - vtrnq_u32⚠
neon
转置元素 - vtst_p8⚠
neon
有符号比较按位测试位非零 - vtst_p16⚠
neon
有符号比较按位测试位非零 - vtst_p64⚠
neon
有符号比较按位测试位非零 - vtst_s8⚠
neon
有符号比较按位测试位非零 - vtst_s16⚠
neon
有符号比较按位测试位非零 - vtst_s32⚠
neon
有符号比较按位测试位非零 - vtst_s64⚠
neon
有符号比较按位测试位非零 - vtst_u8⚠
neon
无符号比较按位测试位非零 - vtst_u16⚠
neon
无符号比较按位测试位非零 - vtst_u32⚠
neon
无符号比较按位测试位非零 - vtst_u64⚠
neon
无符号比较按位测试位非零 - vtstd_s64⚠
neon
比较非零的按位测试位 - vtstd_u64⚠
neon
比较非零的按位测试位 - vtstq_p8⚠
neon
有符号比较按位测试位非零 - vtstq_p16⚠
neon
有符号比较按位测试位非零 - vtstq_p64⚠
neon
有符号比较按位测试位非零 - vtstq_s8⚠
neon
有符号比较按位测试位非零 - vtstq_s16⚠
neon
有符号比较按位测试位非零 - vtstq_s32⚠
neon
有符号比较按位测试位非零 - vtstq_s64⚠
neon
有符号比较按位测试位非零 - vtstq_u8⚠
neon
无符号比较按位测试位非零 - vtstq_u16⚠
neon
无符号比较按位测试位非零 - vtstq_u32⚠
neon
无符号比较按位测试位非零 - vtstq_u64⚠
neon
无符号比较按位测试位非零 - vuqadd_s8⚠
neon
有符号的饱和无符号值的累加。 - vuqadd_s16⚠
neon
有符号的饱和无符号值的累加。 - vuqadd_s32⚠
neon
有符号的饱和无符号值的累加。 - vuqadd_s64⚠
neon
有符号的饱和无符号值的累加。 - vuqaddb_s8⚠
neon
无符号值的有符号饱和累加 - vuqaddd_s64⚠
neon
无符号值的有符号饱和累加 - vuqaddh_s16⚠
neon
无符号值的有符号饱和累加 - vuqaddq_s8⚠
neon
有符号的饱和无符号值的累加。 - vuqaddq_s16⚠
neon
有符号的饱和无符号值的累加。 - vuqaddq_s32⚠
neon
有符号的饱和无符号值的累加。 - vuqaddq_s64⚠
neon
有符号的饱和无符号值的累加。 - vuqadds_s32⚠
neon
无符号值的有符号饱和累加 - vuzp1_f32⚠
neon
解压缩 vectors - vuzp1_p8⚠
neon
解压缩 vectors - vuzp1_p16⚠
neon
解压缩 vectors - vuzp1_s8⚠
neon
解压缩 vectors - vuzp1_s16⚠
neon
解压缩 vectors - vuzp1_s32⚠
neon
解压缩 vectors - vuzp1_u8⚠
neon
解压缩 vectors - vuzp1_u16⚠
neon
解压缩 vectors - vuzp1_u32⚠
neon
解压缩 vectors - vuzp1q_f32⚠
neon
解压缩 vectors - vuzp1q_f64⚠
neon
解压缩 vectors - vuzp1q_p8⚠
neon
解压缩 vectors - vuzp1q_p16⚠
neon
解压缩 vectors - vuzp1q_p64⚠
neon
解压缩 vectors - vuzp1q_s8⚠
neon
解压缩 vectors - vuzp1q_s16⚠
neon
解压缩 vectors - vuzp1q_s32⚠
neon
解压缩 vectors - vuzp1q_s64⚠
neon
解压缩 vectors - vuzp1q_u8⚠
neon
解压缩 vectors - vuzp1q_u16⚠
neon
解压缩 vectors - vuzp1q_u32⚠
neon
解压缩 vectors - vuzp1q_u64⚠
neon
解压缩 vectors - vuzp2_f32⚠
neon
解压缩 vectors - vuzp2_p8⚠
neon
解压缩 vectors - vuzp2_p16⚠
neon
解压缩 vectors - vuzp2_s8⚠
neon
解压缩 vectors - vuzp2_s16⚠
neon
解压缩 vectors - vuzp2_s32⚠
neon
解压缩 vectors - vuzp2_u8⚠
neon
解压缩 vectors - vuzp2_u16⚠
neon
解压缩 vectors - vuzp2_u32⚠
neon
解压缩 vectors - vuzp2q_f32⚠
neon
解压缩 vectors - vuzp2q_f64⚠
neon
解压缩 vectors - vuzp2q_p8⚠
neon
解压缩 vectors - vuzp2q_p16⚠
neon
解压缩 vectors - vuzp2q_p64⚠
neon
解压缩 vectors - vuzp2q_s8⚠
neon
解压缩 vectors - vuzp2q_s16⚠
neon
解压缩 vectors - vuzp2q_s32⚠
neon
解压缩 vectors - vuzp2q_s64⚠
neon
解压缩 vectors - vuzp2q_u8⚠
neon
解压缩 vectors - vuzp2q_u16⚠
neon
解压缩 vectors - vuzp2q_u32⚠
neon
解压缩 vectors - vuzp2q_u64⚠
neon
解压缩 vectors - vuzp_f32⚠
neon
解压缩 vectors - vuzp_p8⚠
neon
解压缩 vectors - vuzp_p16⚠
neon
解压缩 vectors - vuzp_s8⚠
neon
解压缩 vectors - vuzp_s16⚠
neon
解压缩 vectors - vuzp_s32⚠
neon
解压缩 vectors - vuzp_u8⚠
neon
解压缩 vectors - vuzp_u16⚠
neon
解压缩 vectors - vuzp_u32⚠
neon
解压缩 vectors - vuzpq_f32⚠
neon
解压缩 vectors - vuzpq_p8⚠
neon
解压缩 vectors - vuzpq_p16⚠
neon
解压缩 vectors - vuzpq_s8⚠
neon
解压缩 vectors - vuzpq_s16⚠
neon
解压缩 vectors - vuzpq_s32⚠
neon
解压缩 vectors - vuzpq_u8⚠
neon
解压缩 vectors - vuzpq_u16⚠
neon
解压缩 vectors - vuzpq_u32⚠
neon
解压缩 vectors - vzip1_f32⚠
neon
Zip vectors - vzip1_p8⚠
neon
Zip vectors - vzip1_p16⚠
neon
Zip vectors - vzip1_s8⚠
neon
Zip vectors - vzip1_s16⚠
neon
Zip vectors - vzip1_s32⚠
neon
Zip vectors - vzip1_u8⚠
neon
Zip vectors - vzip1_u16⚠
neon
Zip vectors - vzip1_u32⚠
neon
Zip vectors - vzip1q_f32⚠
neon
Zip vectors - vzip1q_f64⚠
neon
Zip vectors - vzip1q_p8⚠
neon
Zip vectors - vzip1q_p16⚠
neon
Zip vectors - vzip1q_p64⚠
neon
Zip vectors - vzip1q_s8⚠
neon
Zip vectors - vzip1q_s16⚠
neon
Zip vectors - vzip1q_s32⚠
neon
Zip vectors - vzip1q_s64⚠
neon
Zip vectors - vzip1q_u8⚠
neon
Zip vectors - vzip1q_u16⚠
neon
Zip vectors - vzip1q_u32⚠
neon
Zip vectors - vzip1q_u64⚠
neon
Zip vectors - vzip2_f32⚠
neon
Zip vectors - vzip2_p8⚠
neon
Zip vectors - vzip2_p16⚠
neon
Zip vectors - vzip2_s8⚠
neon
Zip vectors - vzip2_s16⚠
neon
Zip vectors - vzip2_s32⚠
neon
Zip vectors - vzip2_u8⚠
neon
Zip vectors - vzip2_u16⚠
neon
Zip vectors - vzip2_u32⚠
neon
Zip vectors - vzip2q_f32⚠
neon
Zip vectors - vzip2q_f64⚠
neon
Zip vectors - vzip2q_p8⚠
neon
Zip vectors - vzip2q_p16⚠
neon
Zip vectors - vzip2q_p64⚠
neon
Zip vectors - vzip2q_s8⚠
neon
Zip vectors - vzip2q_s16⚠
neon
Zip vectors - vzip2q_s32⚠
neon
Zip vectors - vzip2q_s64⚠
neon
Zip vectors - vzip2q_u8⚠
neon
Zip vectors - vzip2q_u16⚠
neon
Zip vectors - vzip2q_u32⚠
neon
Zip vectors - vzip2q_u64⚠
neon
Zip vectors - vzip_f32⚠
neon
Zip vectors - vzip_p8⚠
neon
Zip vectors - vzip_p16⚠
neon
Zip vectors - vzip_s8⚠
neon
Zip vectors - vzip_s16⚠
neon
Zip vectors - vzip_s32⚠
neon
Zip vectors - vzip_u8⚠
neon
Zip vectors - vzip_u16⚠
neon
Zip vectors - vzip_u32⚠
neon
Zip vectors - vzipq_f32⚠
neon
Zip vectors - vzipq_p8⚠
neon
Zip vectors - vzipq_p16⚠
neon
Zip vectors - vzipq_s8⚠
neon
Zip vectors - vzipq_s16⚠
neon
Zip vectors - vzipq_s32⚠
neon
Zip vectors - vzipq_u8⚠
neon
Zip vectors - vzipq_u16⚠
neon
Zip vectors - vzipq_u32⚠
neon
Zip vectors