Module core::arch::arm

🔬 This is a nightly-only experimental API. (stdsimd #27731)

This is supported on ARM only.

特定于平台的用于 arm 平台的内部函数。

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

Modules

dspExperimental

References:

Structs

APSRExperimental

应用程序状态寄存器

SYExperimental

完整的系统是必需的可共享性域，读写是必需的访问类型

float32x2_tExperimental

特定于 ARM 的两个包装的 f32 的 64 位宽 vector。

float32x2x2_tExperimental

特定于 ARM 的包含两个 float32x2_t vectors 的类型。

float32x2x3_tExperimental

特定于 ARM 的包含三个 float32x2_t vectors 的类型。

float32x2x4_tExperimental

特定于 ARM 的包含四个 float32x2_t vectors 的类型。

float32x4_tExperimental

特定于 ARM 的四个包装的 f32 的 128 位宽的 vector。

float32x4x2_tExperimental

特定于 ARM 的包含两个 float32x4_t vectors 的类型。

float32x4x3_tExperimental

特定于 ARM 的包含三个 float32x4_t vectors 的类型。

float32x4x4_tExperimental

特定于 ARM 的包含四个 float32x4_t vectors 的类型。

int8x4_tExperimental

特定于 ARM 的四个包装的 i8 的 32 位宽 vector。

int8x8_tExperimental

特定于 ARM 的八个包装的 i8 的 64 位宽 vector。

int8x8x2_tExperimental

特定于 ARM 的包含两个 int8x8_t vectors 的类型。

int8x8x3_tExperimental

特定于 ARM 的包含三个 int8x8_t vectors 的类型。

int8x8x4_tExperimental

特定于 ARM 的包含四个 int8x8_t vectors 的类型。

int8x16_tExperimental

特定于 ARM 的十六个包装的 i8 的 128 位宽的 vector。

int8x16x2_tExperimental

特定于 ARM 的包含两个 int8x16_t vectors 的类型。

int8x16x3_tExperimental

特定于 ARM 的包含三个 int8x16_t vectors 的类型。

int8x16x4_tExperimental

特定于 ARM 的包含四个 int8x16_t vectors 的类型。

int16x2_tExperimental

特定于 ARM 的两个包装的 i16 的 32 位宽 vector。

int16x4_tExperimental

特定于 ARM 的四个包装的 i16 的 64 位宽 vector。

int16x4x2_tExperimental

特定于 ARM 的包含两个 int16x4_t vectors 的类型。

int16x4x3_tExperimental

特定于 ARM 的包含三个 int16x4_t vectors 的类型。

int16x4x4_tExperimental

特定于 ARM 的包含四个 int16x4_t vectors 的类型。

int16x8_tExperimental

特定于 ARM 的八个包装的 i16 的 128 位宽的 vector。

int16x8x2_tExperimental

特定于 ARM 的包含两个 int16x8_t vectors 的类型。

int16x8x3_tExperimental

特定于 ARM 的包含三个 int16x8_t vectors 的类型。

int16x8x4_tExperimental

特定于 ARM 的包含四个 int16x8_t vectors 的类型。

int32x2_tExperimental

特定于 ARM 的两个包装的 i32 的 64 位宽 vector。

int32x2x2_tExperimental

特定于 ARM 的包含两个 int32x2_t vectors 的类型。

int32x2x3_tExperimental

特定于 ARM 的包含三个 int32x2_t vectors 的类型。

int32x2x4_tExperimental

特定于 ARM 的包含四个 int32x2_t vectors 的类型。

int32x4_tExperimental

特定于 ARM 的四个包装的 i32 的 128 位宽的 vector。

int32x4x2_tExperimental

特定于 ARM 的包含两个 int32x4_t vectors 的类型。

int32x4x3_tExperimental

特定于 ARM 的包含三个 int32x4_t vectors 的类型。

int32x4x4_tExperimental

特定于 ARM 的包含四个 int32x4_t vectors 的类型。

int64x1_tExperimental

特定于 ARM 的一个包装的 i64 的 64 位宽 vector。

int64x1x2_tExperimental

特定于 ARM 的包含四个 int64x1_t vectors 的类型。

int64x1x3_tExperimental

特定于 ARM 的包含四个 int64x1_t vectors 的类型。

int64x1x4_tExperimental

特定于 ARM 的包含四个 int64x1_t vectors 的类型。

int64x2_tExperimental

特定于 ARM 的两个包装的 i64 的 128 位宽的 vector。

int64x2x2_tExperimental

特定于 ARM 的包含四个 int64x2_t vectors 的类型。

int64x2x3_tExperimental

特定于 ARM 的包含四个 int64x2_t vectors 的类型。

int64x2x4_tExperimental

特定于 ARM 的包含四个 int64x2_t vectors 的类型。

poly8x8_tExperimental

特定于 ARM 的八个包装的 p8 的 64 位宽多项式 vector。

poly8x8x2_tExperimental

特定于 ARM 的包含两个 poly8x8_t vectors 的类型。

poly8x8x3_tExperimental

特定于 ARM 的包含三个 poly8x8_t vectors 的类型。

poly8x8x4_tExperimental

特定于 ARM 的包含四个 poly8x8_t vectors 的类型。

poly8x16_tExperimental

特定于 ARM 的十六个包装的 p8 的 128 位宽的 vector。

poly8x16x2_tExperimental

特定于 ARM 的包含两个 poly8x16_t vectors 的类型。

poly8x16x3_tExperimental

特定于 ARM 的包含三个 poly8x16_t vectors 的类型。

poly8x16x4_tExperimental

特定于 ARM 的包含四个 poly8x16_t vectors 的类型。

poly16x4_tExperimental

特定于 ARM 的四个包装的 p16 的 64 位宽 vector。

poly16x4x2_tExperimental

特定于 ARM 的包含两个 poly16x4_t vectors 的类型。

poly16x4x3_tExperimental

特定于 ARM 的包含三个 poly16x4_t vectors 的类型。

poly16x4x4_tExperimental

特定于 ARM 的包含四个 poly16x4_t vectors 的类型。

poly16x8_tExperimental

特定于 ARM 的八个包装的 p16 的 128 位宽的 vector。

poly16x8x2_tExperimental

特定于 ARM 的包含两个 poly16x8_t vectors 的类型。

poly16x8x3_tExperimental

特定于 ARM 的包含三个 poly16x8_t vectors 的类型。

poly16x8x4_tExperimental

特定于 ARM 的包含四个 poly16x8_t vectors 的类型。

poly64x1_tExperimental

特定于 ARM 的一个包装的 p64 的 64 位宽 vector。

poly64x1x2_tExperimental

特定于 ARM 的包含四个 poly64x1_t vectors 的类型。

poly64x1x3_tExperimental

特定于 ARM 的包含四个 poly64x1_t vectors 的类型。

poly64x1x4_tExperimental

特定于 ARM 的包含四个 poly64x1_t vectors 的类型。

poly64x2_tExperimental

特定于 ARM 的两个包装的 p64 的 128 位宽的 vector。

poly64x2x2_tExperimental

特定于 ARM 的包含四个 poly64x2_t vectors 的类型。

poly64x2x3_tExperimental

特定于 ARM 的包含四个 poly64x2_t vectors 的类型。

poly64x2x4_tExperimental

特定于 ARM 的包含四个 poly64x2_t vectors 的类型。

uint8x4_tExperimental

特定于 ARM 的四个包装的 u8 的 32 位宽 vector。

uint8x8_tExperimental

特定于 ARM 的八个包装的 u8 的 64 位宽 vector。

uint8x8x2_tExperimental

特定于 ARM 的包含两个 uint8x8_t vectors 的类型。

uint8x8x3_tExperimental

特定于 ARM 的包含三个 uint8x8_t vectors 的类型。

uint8x8x4_tExperimental

特定于 ARM 的包含四个 uint8x8_t vectors 的类型。

uint8x16_tExperimental

特定于 ARM 的十六个包装的 u8 的 128 位宽的 vector。

uint8x16x2_tExperimental

特定于 ARM 的包含两个 uint8x16_t vectors 的类型。

uint8x16x3_tExperimental

特定于 ARM 的包含三个 uint8x16_t vectors 的类型。

uint8x16x4_tExperimental

特定于 ARM 的包含四个 uint8x16_t vectors 的类型。

uint16x2_tExperimental

特定于 ARM 的两个包装的 u16 的 32 位宽 vector。

uint16x4_tExperimental

特定于 ARM 的四个包装的 u16 的 64 位宽 vector。

uint16x4x2_tExperimental

特定于 ARM 的包含两个 uint16x4_t vectors 的类型。

uint16x4x3_tExperimental

特定于 ARM 的包含三个 uint16x4_t vectors 的类型。

uint16x4x4_tExperimental

特定于 ARM 的包含四个 uint16x4_t vectors 的类型。

uint16x8_tExperimental

特定于 ARM 的八个包装的 u16 的 128 位宽的 vector。

uint16x8x2_tExperimental

特定于 ARM 的包含两个 uint16x8_t vectors 的类型。

uint16x8x3_tExperimental

特定于 ARM 的包含三个 uint16x8_t vectors 的类型。

uint16x8x4_tExperimental

特定于 ARM 的包含四个 uint16x8_t vectors 的类型。

uint32x2_tExperimental

特定于 ARM 的两个包装的 u32 的 64 位宽 vector。

uint32x2x2_tExperimental

特定于 ARM 的包含两个 uint32x2_t vectors 的类型。

uint32x2x3_tExperimental

特定于 ARM 的包含三个 uint32x2_t vectors 的类型。

uint32x2x4_tExperimental

特定于 ARM 的包含四个 uint32x2_t vectors 的类型。

uint32x4_tExperimental

特定于 ARM 的四个包装的 u32 的 128 位宽的 vector。

uint32x4x2_tExperimental

特定于 ARM 的包含两个 uint32x4_t vectors 的类型。

uint32x4x3_tExperimental

特定于 ARM 的包含三个 uint32x4_t vectors 的类型。

uint32x4x4_tExperimental

特定于 ARM 的包含四个 uint32x4_t vectors 的类型。

uint64x1_tExperimental

特定于 ARM 的一个包装的 u64 的 64 位宽 vector。

uint64x1x2_tExperimental

特定于 ARM 的包含四个 uint64x1_t vectors 的类型。

uint64x1x3_tExperimental

特定于 ARM 的包含四个 uint64x1_t vectors 的类型。

uint64x1x4_tExperimental

特定于 ARM 的包含四个 uint64x1_t vectors 的类型。

uint64x2_tExperimental

特定于 ARM 的两个包装的 u64 的 128 位宽的 vector。

uint64x2x2_tExperimental

特定于 ARM 的包含四个 uint64x2_t vectors 的类型。

uint64x2x3_tExperimental

特定于 ARM 的包含四个 uint64x2_t vectors 的类型。

uint64x2x4_tExperimental

特定于 ARM 的包含四个 uint64x2_t vectors 的类型。

Functions

__breakpoint^⚠Experimental

插入断点指令。

__clrex^⚠Experimental

删除由 LDREX 创建的排他锁

__crc32b^⚠Experimentalcrc

CRC32 字节的单轮校验和 (8 位)。

__crc32cb^⚠Experimentalcrc

字节 (8 位) 的 CRC32-C 单回合校验和。

__crc32ch^⚠Experimentalcrc

半字 (16 位) 的 CRC32-C 单回合校验和。

__crc32cw^⚠Experimentalcrc

字 (32 位) 的 CRC32-C 单次校验和。

__crc32h^⚠Experimentalcrc

CRC32 半字的单轮校验和 (16 位)。

__crc32w^⚠Experimentalcrc

CRC32 单轮字校验和 (32 位)。

__dbg^⚠Experimental

生成 DBG 指令。

__dmb^⚠Experimental

生成 DMB (数据存储屏障) 指令或等效的 CP15 指令。

__dsb^⚠Experimental

生成 DSB (数据同步屏障) 指令或等效的 CP15 指令。

__isb^⚠Experimental

生成一个 ISB (指令同步屏障) 指令或等效的 CP15 指令。

__ldrex^⚠Experimental

对 32 位值执行独占 LDR 指令。

__ldrexb^⚠Experimental

对 8 位值执行独占 LDR 指令。

__ldrexh^⚠Experimental

对 16 位值执行独占 LDR 指令。

__nop^⚠Experimental

生成未指定的无操作指令。

__qadd^⚠Experimental

带符号的饱和加法

__qadd8^⚠Experimental

饱和四个 8 位整数加法

__qadd16^⚠Experimental

饱和两个 16 位整数加法

__qasx^⚠Experimental

返回 16 位带符号的饱和等效项

__qdbl^⚠Experimental

插入 QADD 指令

__qsax^⚠Experimental

返回 16 位带符号的饱和等效项

__qsub^⚠Experimental

有符号的饱和减法

__qsub8^⚠Experimental

饱和两个 8 位整数减法

__qsub16^⚠Experimental

饱和两个 16 位整数减法

__rsr^⚠Experimental

读取 32 位系统寄存器

__rsrp^⚠Experimental

读取包含地址的系统寄存器

__sadd8^⚠Experimental

返回 8 位有符号的饱和等效项

__sadd16^⚠Experimental

返回 16 位带符号的饱和等效项

__sasx^⚠Experimental

返回与之等效的 16 位带符号

__sel^⚠Experimental

根据 APSR GE 标志从每个操作数中选择字节

__sev^⚠Experimental

生成 SEV (发送事件) 提示指令。

__sevl^⚠Experimental

生成发送本地事件提示指令。

__shadd8^⚠Experimental

带符号的并行字节加法减半。

__shadd16^⚠Experimental

有符号的减半平行半字加法。

__shsub8^⚠Experimental

有符号的减半平行字节的减法。

__shsub16^⚠Experimental

有符号的减去平行半字的减法。

__smlabb^⚠Experimental

插入 SMLABB 指令

__smlabt^⚠Experimental

插入 SMLABT 指令

__smlad^⚠Experimental

双 16 位有符号乘法，加乘积和 32 位累加。

__smlatb^⚠Experimental

插入 SMLATB 指令

__smlatt^⚠Experimental

插入 SMLATT 指令

__smlawb^⚠Experimental

插入 SMLAWB 指令

__smlawt^⚠Experimental

插入 SMLAWT 指令

__smlsd^⚠Experimental

双 16 位带符号乘积与乘积相减以及 32 位累加和溢出检测。

__smuad^⚠Experimental

带符号的双乘加法。

__smuadx^⚠Experimental

有符号的双数乘法加法反转。

__smulbb^⚠Experimental

插入 SMULBB 指令

__smulbt^⚠Experimental

插入 SMULTB 指令

__smultb^⚠Experimental

插入 SMULTB 指令

__smultt^⚠Experimental

插入 SMULTT 指令

__smulwb^⚠Experimental

插入 SMULWB 指令

__smulwt^⚠Experimental

插入 SMULWT 指令

__smusd^⚠Experimental

有符号的双数乘法减法。

__smusdx^⚠Experimental

有符号的双数乘法减法反转。

__ssub8^⚠Experimental

插入 SSUB8 指令。

__strex^⚠Experimental

对 32 位值执行独占 STR 指令

__strexb^⚠Experimental

对 8 位值执行独占 STR 指令

__usad8^⚠Experimental

8 位绝对差之和。

__usada8^⚠Experimental

8 位绝对差和常量之和。

__usub8^⚠Experimental

插入 USUB8 指令。

__wfe^⚠Experimental

生成 WFE (等待事件) 提示指令，否则不生成任何内容。

__wfi^⚠Experimental

生成 WFI (等待中断) 提示指令，或不执行任何操作。

__wsr^⚠Experimental

写入 32 位系统寄存器

__wsrp^⚠Experimental

写入包含地址的系统寄存器

__yield^⚠Experimental

生成一条 YIELD 提示指令。

_clz_u8^⚠Experimental

计算前导零。

_clz_u16^⚠Experimental

计算前导零。

_clz_u32^⚠Experimental

计算前导零。

_rbit_u32^⚠Experimental

反转位顺序。

_rev_u16^⚠Experimental

颠倒字节顺序。

_rev_u32^⚠Experimental

颠倒字节顺序。

vaba_s8^⚠Experimentalneon

vaba_s16^⚠Experimentalneon

vaba_s32^⚠Experimentalneon

vaba_u8^⚠Experimentalneon

vaba_u16^⚠Experimentalneon

vaba_u32^⚠Experimentalneon

vabal_s8^⚠Experimentalneon

有符号绝对差和累积长

vabal_s16^⚠Experimentalneon

有符号绝对差和累积长

vabal_s32^⚠Experimentalneon

有符号绝对差和累积长

vabal_u8^⚠Experimentalneon

无符号绝对差和累积长

vabal_u16^⚠Experimentalneon

无符号绝对差和累积长

vabal_u32^⚠Experimentalneon

无符号绝对差和累积长

vabaq_s8^⚠Experimentalneon

vabaq_s16^⚠Experimentalneon

vabaq_s32^⚠Experimentalneon

vabaq_u8^⚠Experimentalneon

vabaq_u16^⚠Experimentalneon

vabaq_u32^⚠Experimentalneon

vabd_f32^⚠Experimentalneon

浮动参数之间的绝对差异

vabd_s8^⚠Experimentalneon

参数之间的绝对差异

vabd_s16^⚠Experimentalneon

参数之间的绝对差异

vabd_s32^⚠Experimentalneon

参数之间的绝对差异

vabd_u8^⚠Experimentalneon

参数之间的绝对差异

vabd_u16^⚠Experimentalneon

参数之间的绝对差异

vabd_u32^⚠Experimentalneon

参数之间的绝对差异

vabdl_s8^⚠Experimentalneon

有符号绝对差长

vabdl_s16^⚠Experimentalneon

有符号绝对差长

vabdl_s32^⚠Experimentalneon

有符号绝对差长

vabdl_u8^⚠Experimentalneon

无符号绝对差长

vabdl_u16^⚠Experimentalneon

无符号绝对差长

vabdl_u32^⚠Experimentalneon

无符号绝对差长

vabdq_f32^⚠Experimentalneon

浮动参数之间的绝对差异

vabdq_s8^⚠Experimentalneon

参数之间的绝对差异

vabdq_s16^⚠Experimentalneon

参数之间的绝对差异

vabdq_s32^⚠Experimentalneon

参数之间的绝对差异

vabdq_u8^⚠Experimentalneon

参数之间的绝对差异

vabdq_u16^⚠Experimentalneon

参数之间的绝对差异

vabdq_u32^⚠Experimentalneon

参数之间的绝对差异

vabs_f32^⚠Experimentalneon

浮点绝对值

vabs_s8^⚠Experimentalneon

绝对值 (wrapping)。

vabs_s16^⚠Experimentalneon

绝对值 (wrapping)。

vabs_s32^⚠Experimentalneon

绝对值 (wrapping)。

vabsq_f32^⚠Experimentalneon

浮点绝对值

vabsq_s8^⚠Experimentalneon

绝对值 (wrapping)。

vabsq_s16^⚠Experimentalneon

绝对值 (wrapping)。

vabsq_s32^⚠Experimentalneon

绝对值 (wrapping)。

vadd_f32^⚠Experimentalneon

Vector add。

vadd_p8^⚠Experimentalneon

按位异或

vadd_p16^⚠Experimentalneon

按位异或

vadd_p64^⚠Experimentalneon

按位异或

vadd_s8^⚠Experimentalneon

Vector add。

vadd_s16^⚠Experimentalneon

Vector add。

vadd_s32^⚠Experimentalneon

Vector add。

vadd_u8^⚠Experimentalneon

Vector add。

vadd_u16^⚠Experimentalneon

Vector add。

vadd_u32^⚠Experimentalneon

Vector add。

vaddhn_high_s16^⚠Experimentalneon

添加返回的 High Narrow (高半)。

vaddhn_high_s32^⚠Experimentalneon

添加返回的 High Narrow (高半)。

vaddhn_high_s64^⚠Experimentalneon

添加返回的 High Narrow (高半)。

vaddhn_high_u16^⚠Experimentalneon

添加返回的 High Narrow (高半)。

vaddhn_high_u32^⚠Experimentalneon

添加返回的 High Narrow (高半)。

vaddhn_high_u64^⚠Experimentalneon

添加返回的 High Narrow (高半)。

vaddhn_s16^⚠Experimentalneon

添加返回的 High Narrow。

vaddhn_s32^⚠Experimentalneon

添加返回的 High Narrow。

vaddhn_s64^⚠Experimentalneon

添加返回的 High Narrow。

vaddhn_u16^⚠Experimentalneon

添加返回的 High Narrow。

vaddhn_u32^⚠Experimentalneon

添加返回的 High Narrow。

vaddhn_u64^⚠Experimentalneon

添加返回的 High Narrow。

vaddl_high_s8^⚠Experimentalneon

有符号添加长度 (vector，高一半)。

vaddl_high_s16^⚠Experimentalneon

有符号添加长度 (vector，高一半)。

vaddl_high_s32^⚠Experimentalneon

有符号添加长度 (vector，高一半)。

vaddl_high_u8^⚠Experimentalneon

无符号添加长度 (vector，高一半)。

vaddl_high_u16^⚠Experimentalneon

无符号添加长度 (vector，高一半)。

vaddl_high_u32^⚠Experimentalneon

无符号添加长度 (vector，高一半)。

vaddl_s8^⚠Experimentalneon

有符号添加长度 (vector)。

vaddl_s16^⚠Experimentalneon

有符号添加长度 (vector)。

vaddl_s32^⚠Experimentalneon

有符号添加长度 (vector)。

vaddl_u8^⚠Experimentalneon

无符号添加长度 (vector)。

vaddl_u16^⚠Experimentalneon

无符号添加长度 (vector)。

vaddl_u32^⚠Experimentalneon

无符号添加长度 (vector)。

vaddq_f32^⚠Experimentalneon

Vector add。

vaddq_p8^⚠Experimentalneon

按位异或

vaddq_p16^⚠Experimentalneon

按位异或

vaddq_p64^⚠Experimentalneon

按位异或

vaddq_p128^⚠Experimentalneon

按位异或

vaddq_s8^⚠Experimentalneon

Vector add。

vaddq_s16^⚠Experimentalneon

Vector add。

vaddq_s32^⚠Experimentalneon

Vector add。

vaddq_s64^⚠Experimentalneon

Vector add。

vaddq_u8^⚠Experimentalneon

Vector add。

vaddq_u16^⚠Experimentalneon

Vector add。

vaddq_u32^⚠Experimentalneon

Vector add。

vaddq_u64^⚠Experimentalneon

Vector add。

vaddw_high_s8^⚠Experimentalneon

有符号添加宽 (高一半)。

vaddw_high_s16^⚠Experimentalneon

有符号添加宽 (高一半)。

vaddw_high_s32^⚠Experimentalneon

有符号添加宽 (高一半)。

vaddw_high_u8^⚠Experimentalneon

无符号添加宽 (高一半)。

vaddw_high_u16^⚠Experimentalneon

无符号添加宽 (高一半)。

vaddw_high_u32^⚠Experimentalneon

无符号添加宽 (高一半)。

vaddw_s8^⚠Experimentalneon

有符号添加宽。

vaddw_s16^⚠Experimentalneon

有符号添加宽。

vaddw_s32^⚠Experimentalneon

有符号添加宽。

vaddw_u8^⚠Experimentalneon

无符号添加宽。

vaddw_u16^⚠Experimentalneon

无符号添加宽。

vaddw_u32^⚠Experimentalneon

无符号添加宽。

vaesdq_u8^⚠Experimentalaes

AES 单轮解密。

vaeseq_u8^⚠Experimentalaes

AES 单轮加密。

vaesimcq_u8^⚠Experimentalaes

AES 反向混合列。

vaesmcq_u8^⚠Experimentalaes

AES 混合列。

vand_s8^⚠Experimentalneon

Vector 按位和

vand_s16^⚠Experimentalneon

Vector 按位和

vand_s32^⚠Experimentalneon

Vector 按位和

vand_s64^⚠Experimentalneon

Vector 按位和

vand_u8^⚠Experimentalneon

Vector 按位和

vand_u16^⚠Experimentalneon

Vector 按位和

vand_u32^⚠Experimentalneon

Vector 按位和

vand_u64^⚠Experimentalneon

Vector 按位和

vandq_s8^⚠Experimentalneon

Vector 按位和

vandq_s16^⚠Experimentalneon

Vector 按位和

vandq_s32^⚠Experimentalneon

Vector 按位和

vandq_s64^⚠Experimentalneon

Vector 按位和

vandq_u8^⚠Experimentalneon

Vector 按位和

vandq_u16^⚠Experimentalneon

Vector 按位和

vandq_u32^⚠Experimentalneon

Vector 按位和

vandq_u64^⚠Experimentalneon

Vector 按位和

vbic_s8^⚠Experimentalneon

矢量按位清除

vbic_s16^⚠Experimentalneon

矢量按位清除

vbic_s32^⚠Experimentalneon

矢量按位清除

vbic_s64^⚠Experimentalneon

矢量按位清除

vbic_u8^⚠Experimentalneon

矢量按位清除

vbic_u16^⚠Experimentalneon

矢量按位清除

vbic_u32^⚠Experimentalneon

矢量按位清除

vbic_u64^⚠Experimentalneon

矢量按位清除

vbicq_s8^⚠Experimentalneon

矢量按位清除

vbicq_s16^⚠Experimentalneon

矢量按位清除

vbicq_s32^⚠Experimentalneon

矢量按位清除

vbicq_s64^⚠Experimentalneon

矢量按位清除

vbicq_u8^⚠Experimentalneon

矢量按位清除

vbicq_u16^⚠Experimentalneon

矢量按位清除

vbicq_u32^⚠Experimentalneon

矢量按位清除

vbicq_u64^⚠Experimentalneon

矢量按位清除

vbsl_f32^⚠Experimentalneon

按位选择。

vbsl_p8^⚠Experimentalneon

按位选择。

vbsl_p16^⚠Experimentalneon

按位选择。

vbsl_s8^⚠Experimentalneon

按位选择指令。 当原始目标位为 1 时，该指令将目标 SIMD&FP 寄存器中的每一位设置为来自第一个源 SIMD&FP 寄存器的相应位，否则来自第二个源 SIMD&FP 寄存器。

vbsl_s16^⚠Experimentalneon

按位选择。

vbsl_s32^⚠Experimentalneon

按位选择。

vbsl_s64^⚠Experimentalneon

按位选择。

vbsl_u8^⚠Experimentalneon

按位选择。

vbsl_u16^⚠Experimentalneon

按位选择。

vbsl_u32^⚠Experimentalneon

按位选择。

vbsl_u64^⚠Experimentalneon

按位选择。

vbslq_f32^⚠Experimentalneon

按位选择。(128-bit)

vbslq_p8^⚠Experimentalneon

按位选择。(128-bit)

vbslq_p16^⚠Experimentalneon

按位选择。(128-bit)

vbslq_s8^⚠Experimentalneon

按位选择。(128-bit)

vbslq_s16^⚠Experimentalneon

按位选择。(128-bit)

vbslq_s32^⚠Experimentalneon

按位选择。(128-bit)

vbslq_s64^⚠Experimentalneon

按位选择。(128-bit)

vbslq_u8^⚠Experimentalneon

按位选择。(128-bit)

vbslq_u16^⚠Experimentalneon

按位选择。(128-bit)

vbslq_u32^⚠Experimentalneon

按位选择。(128-bit)

vbslq_u64^⚠Experimentalneon

按位选择。(128-bit)

vcage_f32^⚠Experimentalneon

浮点绝对比较大于或等于

vcageq_f32^⚠Experimentalneon

浮点绝对比较大于或等于

vcagt_f32^⚠Experimentalneon

浮点绝对值比较大于

vcagtq_f32^⚠Experimentalneon

浮点绝对值比较大于

vcale_f32^⚠Experimentalneon

浮点绝对比较小于或等于

vcaleq_f32^⚠Experimentalneon

浮点绝对比较小于或等于

vcalt_f32^⚠Experimentalneon

浮点绝对比较小于

vcaltq_f32^⚠Experimentalneon

浮点绝对比较小于

vceq_f32^⚠Experimentalneon

浮点比较相等

vceq_p8^⚠Experimentalneon

比较按位等于 (vector)

vceq_s8^⚠Experimentalneon

比较按位等于 (vector)

vceq_s16^⚠Experimentalneon

比较按位等于 (vector)

vceq_s32^⚠Experimentalneon

比较按位等于 (vector)

vceq_u8^⚠Experimentalneon

比较按位等于 (vector)

vceq_u16^⚠Experimentalneon

比较按位等于 (vector)

vceq_u32^⚠Experimentalneon

比较按位等于 (vector)

vceqq_f32^⚠Experimentalneon

浮点比较相等

vceqq_p8^⚠Experimentalneon

比较按位等于 (vector)

vceqq_s8^⚠Experimentalneon

比较按位等于 (vector)

vceqq_s16^⚠Experimentalneon

比较按位等于 (vector)

vceqq_s32^⚠Experimentalneon

比较按位等于 (vector)

vceqq_u8^⚠Experimentalneon

比较按位等于 (vector)

vceqq_u16^⚠Experimentalneon

比较按位等于 (vector)

vceqq_u32^⚠Experimentalneon

比较按位等于 (vector)

vcge_f32^⚠Experimentalneon

浮点比较大于或等于

vcge_s8^⚠Experimentalneon

比较有符号大于或等于

vcge_s16^⚠Experimentalneon

比较有符号大于或等于

vcge_s32^⚠Experimentalneon

比较有符号大于或等于

vcge_u8^⚠Experimentalneon

比较无符号大于或等于

vcge_u16^⚠Experimentalneon

比较无符号大于或等于

vcge_u32^⚠Experimentalneon

比较无符号大于或等于

vcgeq_f32^⚠Experimentalneon

浮点比较大于或等于

vcgeq_s8^⚠Experimentalneon

比较有符号大于或等于

vcgeq_s16^⚠Experimentalneon

比较有符号大于或等于

vcgeq_s32^⚠Experimentalneon

比较有符号大于或等于

vcgeq_u8^⚠Experimentalneon

比较无符号大于或等于

vcgeq_u16^⚠Experimentalneon

比较无符号大于或等于

vcgeq_u32^⚠Experimentalneon

比较无符号大于或等于

vcgt_f32^⚠Experimentalneon

浮点比较大于

vcgt_s8^⚠Experimentalneon

比较有符号大于

vcgt_s16^⚠Experimentalneon

比较有符号大于

vcgt_s32^⚠Experimentalneon

比较有符号大于

vcgt_u8^⚠Experimentalneon

比较无符号的高

vcgt_u16^⚠Experimentalneon

比较无符号的高

vcgt_u32^⚠Experimentalneon

比较无符号的高

vcgtq_f32^⚠Experimentalneon

浮点比较大于

vcgtq_s8^⚠Experimentalneon

比较有符号大于

vcgtq_s16^⚠Experimentalneon

比较有符号大于

vcgtq_s32^⚠Experimentalneon

比较有符号大于

vcgtq_u8^⚠Experimentalneon

比较无符号的高

vcgtq_u16^⚠Experimentalneon

比较无符号的高

vcgtq_u32^⚠Experimentalneon

比较无符号的高

vcle_f32^⚠Experimentalneon

浮点比较小于或等于

vcle_s8^⚠Experimentalneon

比较有符号的小于或等于

vcle_s16^⚠Experimentalneon

比较有符号的小于或等于

vcle_s32^⚠Experimentalneon

比较有符号的小于或等于

vcle_u8^⚠Experimentalneon

比较无符号小于或等于

vcle_u16^⚠Experimentalneon

比较无符号小于或等于

vcle_u32^⚠Experimentalneon

比较无符号小于或等于

vcleq_f32^⚠Experimentalneon

浮点比较小于或等于

vcleq_s8^⚠Experimentalneon

比较有符号的小于或等于

vcleq_s16^⚠Experimentalneon

比较有符号的小于或等于

vcleq_s32^⚠Experimentalneon

比较有符号的小于或等于

vcleq_u8^⚠Experimentalneon

比较无符号小于或等于

vcleq_u16^⚠Experimentalneon

比较无符号小于或等于

vcleq_u32^⚠Experimentalneon

比较无符号小于或等于

vcls_s8^⚠Experimentalneon

计数前导符号位

vcls_s16^⚠Experimentalneon

计数前导符号位

vcls_s32^⚠Experimentalneon

计数前导符号位

vcls_u8^⚠Experimentalneon

计数前导符号位

vcls_u16^⚠Experimentalneon

计数前导符号位

vcls_u32^⚠Experimentalneon

计数前导符号位

vclsq_s8^⚠Experimentalneon

计数前导符号位

vclsq_s16^⚠Experimentalneon

计数前导符号位

vclsq_s32^⚠Experimentalneon

计数前导符号位

vclsq_u8^⚠Experimentalneon

计数前导符号位

vclsq_u16^⚠Experimentalneon

计数前导符号位

vclsq_u32^⚠Experimentalneon

计数前导符号位

vclt_f32^⚠Experimentalneon

浮点比较小于

vclt_s8^⚠Experimentalneon

比较有符号少于

vclt_s16^⚠Experimentalneon

比较有符号少于

vclt_s32^⚠Experimentalneon

比较有符号少于

vclt_u8^⚠Experimentalneon

比较无符号小于

vclt_u16^⚠Experimentalneon

比较无符号小于

vclt_u32^⚠Experimentalneon

比较无符号小于

vcltq_f32^⚠Experimentalneon

浮点比较小于

vcltq_s8^⚠Experimentalneon

比较有符号少于

vcltq_s16^⚠Experimentalneon

比较有符号少于

vcltq_s32^⚠Experimentalneon

比较有符号少于

vcltq_u8^⚠Experimentalneon

比较无符号小于

vcltq_u16^⚠Experimentalneon

比较无符号小于

vcltq_u32^⚠Experimentalneon

比较无符号小于

vclz_s8^⚠Experimentalneon

计数前导零位

vclz_s16^⚠Experimentalneon

计数前导零位

vclz_s32^⚠Experimentalneon

计数前导零位

vclz_u8^⚠Experimentalneon

计数前导零位

vclz_u16^⚠Experimentalneon

计数前导零位

vclz_u32^⚠Experimentalneon

计数前导零位

vclzq_s8^⚠Experimentalneon

计数前导零位

vclzq_s16^⚠Experimentalneon

计数前导零位

vclzq_s32^⚠Experimentalneon

计数前导零位

vclzq_u8^⚠Experimentalneon

计数前导零位

vclzq_u16^⚠Experimentalneon

计数前导零位

vclzq_u32^⚠Experimentalneon

计数前导零位

vcnt_p8^⚠Experimentalneon

每个字节的填充计数。

vcnt_s8^⚠Experimentalneon

每个字节的填充计数。

vcnt_u8^⚠Experimentalneon

每个字节的填充计数。

vcntq_p8^⚠Experimentalneon

每个字节的填充计数。

vcntq_s8^⚠Experimentalneon

每个字节的填充计数。

vcntq_u8^⚠Experimentalneon

每个字节的填充计数。

vcreate_f32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_p8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_p16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_p64^⚠Experimentalneon,aes

从另一个 vector 元素插入 vector 元素

vcreate_s8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_s16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_s32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_s64^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_u8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_u16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_u32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcreate_u64^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vcvt_f32_s32^⚠Experimentalneon

定点转换为浮点

vcvt_f32_u32^⚠Experimentalneon

定点转换为浮点

vcvt_s32_f32^⚠Experimentalneon

浮点转换为有符号的定点，四舍五入为零

vcvt_u32_f32^⚠Experimentalneon

浮点转换为无符号定点，四舍五入为零

vcvtq_f32_s32^⚠Experimentalneon

定点转换为浮点

vcvtq_f32_u32^⚠Experimentalneon

定点转换为浮点

vcvtq_s32_f32^⚠Experimentalneon

浮点转换为有符号的定点，四舍五入为零

vcvtq_s32_f32^⚠Experimentalneon and v7

浮点转换为有符号固定点，四舍五入为 (vector)

vcvtq_u32_f32^⚠Experimentalneon

浮点转换为无符号定点，四舍五入为零

vcvtq_u32_f32^⚠Experimentalneon and v7

浮点转换为无符号定点，四舍五入为 (vector)

vdup_lane_f32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_p8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_p16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_s8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_s16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_s32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_s64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_u8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_u16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_u32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_lane_u64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_f32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_p8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_p16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_s8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_s16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_s32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_s64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_u8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_u16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_u32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_laneq_u64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdup_n_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_p8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_p16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_s8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_s16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_s32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_s64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_u8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_u16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_u32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdup_n_u64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_lane_f32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_p8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_p16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_s8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_s16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_s32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_s64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_u8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_u16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_u32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_lane_u64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_f32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_p8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_p16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_s8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_s16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_s32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_s64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_u8^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_u16^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_u32^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_laneq_u64^⚠Experimentalneon

将所有 vector lanes 设置为相同的值

vdupq_n_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_p8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_p16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_s8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_s16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_s32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_s64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_u8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_u16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_u32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vdupq_n_u64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

veor_s8^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_s16^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_s32^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_s64^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_u8^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_u16^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_u32^⚠Experimentalneon

Vector 按位互斥或 (vector)

veor_u64^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_s8^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_s16^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_s32^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_s64^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_u8^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_u16^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_u32^⚠Experimentalneon

Vector 按位互斥或 (vector)

veorq_u64^⚠Experimentalneon

Vector 按位互斥或 (vector)

vext_f32^⚠Experimentalneon

从 vectors 对中提取 vector

vext_p8^⚠Experimentalneon

从 vectors 对中提取 vector

vext_p16^⚠Experimentalneon

从 vectors 对中提取 vector

vext_s8^⚠Experimentalneon

从 vectors 对中提取 vector

vext_s16^⚠Experimentalneon

从 vectors 对中提取 vector

vext_s32^⚠Experimentalneon

从 vectors 对中提取 vector

vext_s64^⚠Experimentalneon

从 vectors 对中提取 vector

vext_u8^⚠Experimentalneon

从 vectors 对中提取 vector

vext_u16^⚠Experimentalneon

从 vectors 对中提取 vector

vext_u32^⚠Experimentalneon

从 vectors 对中提取 vector

vext_u64^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_f32^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_p8^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_p16^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_s8^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_s16^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_s32^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_s64^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_u8^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_u16^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_u32^⚠Experimentalneon

从 vectors 对中提取 vector

vextq_u64^⚠Experimentalneon

从 vectors 对中提取 vector

vfma_f32^⚠Experimentalneon

浮点融合的乘加累加器 accumulator(vector)

vfma_n_f32^⚠Experimentalneon

浮点融合的乘加累加器 accumulator(vector)

vfmaq_f32^⚠Experimentalneon

浮点融合的乘加累加器 accumulator(vector)

vfmaq_n_f32^⚠Experimentalneon

浮点融合的乘加累加器 accumulator(vector)

vfms_f32^⚠Experimentalneon

从累加器中进行浮点相乘相减

vfms_n_f32^⚠Experimentalneon

浮点相乘相减到累加器 accumulator(vector)

vfmsq_f32^⚠Experimentalneon

从累加器中进行浮点相乘相减

vfmsq_n_f32^⚠Experimentalneon

浮点相乘相减到累加器 accumulator(vector)

vget_high_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_p8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_p16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_s8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_s16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_s32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_s64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_u8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_u16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_u32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_high_u64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_lane_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_lane_p8^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_p16^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_p64^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_s8^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_s16^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_s32^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_s64^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_u8^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_u16^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_u32^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_lane_u64^⚠Experimentalneon

将 vector 元素移至通用寄存器

vget_low_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_p8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_p16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_s8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_s16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_s32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_s64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_u8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_u16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_u32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vget_low_u64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vgetq_lane_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vgetq_lane_p8^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_p16^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_p64^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_s8^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_s16^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_s32^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_s64^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_u8^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_u16^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_u32^⚠Experimentalneon

将 vector 元素移至通用寄存器

vgetq_lane_u64^⚠Experimentalneon

将 vector 元素移至通用寄存器

vhadd_s8^⚠Experimentalneon

减半添加

vhadd_s16^⚠Experimentalneon

减半添加

vhadd_s32^⚠Experimentalneon

减半添加

vhadd_u8^⚠Experimentalneon

减半添加

vhadd_u16^⚠Experimentalneon

减半添加

vhadd_u32^⚠Experimentalneon

减半添加

vhaddq_s8^⚠Experimentalneon

减半添加

vhaddq_s16^⚠Experimentalneon

减半添加

vhaddq_s32^⚠Experimentalneon

减半添加

vhaddq_u8^⚠Experimentalneon

减半添加

vhaddq_u16^⚠Experimentalneon

减半添加

vhaddq_u32^⚠Experimentalneon

减半添加

vhsub_s8^⚠Experimentalneon

有符号减半相减

vhsub_s16^⚠Experimentalneon

有符号减半相减

vhsub_s32^⚠Experimentalneon

有符号减半相减

vhsub_u8^⚠Experimentalneon

有符号减半相减

vhsub_u16^⚠Experimentalneon

有符号减半相减

vhsub_u32^⚠Experimentalneon

有符号减半相减

vhsubq_s8^⚠Experimentalneon

有符号减半相减

vhsubq_s16^⚠Experimentalneon

有符号减半相减

vhsubq_s32^⚠Experimentalneon

有符号减半相减

vhsubq_u8^⚠Experimentalneon

有符号减半相减

vhsubq_u16^⚠Experimentalneon

有符号减半相减

vhsubq_u32^⚠Experimentalneon

有符号减半相减

vld1_dup_f32^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_p8^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_p16^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_p64^⚠Experimentalneon,aes

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_s8^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_s16^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_s32^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_s64^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_u8^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_u16^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_u32^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_dup_u64^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1_f32^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_f32_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_f32_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_f32_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_lane_f32^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_p8^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_p16^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_p64^⚠Experimentalneon,aes

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_s8^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_s16^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_s32^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_s64^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_u8^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_u16^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_u32^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_lane_u64^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1_p8^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_p8_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p8_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p8_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p16^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_p16_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p16_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p16_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p64^⚠Experimentalneon,aes

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_p64_x2^⚠Experimentalneon,aes

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p64_x3^⚠Experimentalneon,aes

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_p64_x4^⚠Experimentalneon,aes

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s8^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_s8_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s8_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s8_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s16^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_s16_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s16_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s16_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s32^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_s32_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s32_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s32_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s64^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_s64_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s64_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_s64_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u8^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_u8_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u8_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u8_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u16^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_u16_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u16_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u16_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u32^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_u32_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u32_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u32_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u64^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1_u64_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u64_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1_u64_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_dup_f32^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_p8^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_p16^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_p64^⚠Experimentalneon,aes

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_s8^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_s16^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_s32^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_s64^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_u8^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_u16^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_u32^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_dup_u64^⚠Experimentalneon

加载一个单一元素结构体，然后复制到所有 lanes (一个寄存器)。

vld1q_f32^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_f32_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_f32_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_f32_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_lane_f32^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_p8^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_p16^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_p64^⚠Experimentalneon,aes

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_s8^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_s16^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_s32^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_s64^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_u8^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_u16^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_u32^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_lane_u64^⚠Experimentalneon

将一个单一元素结构体加载到一个寄存器的一个 lane 中。

vld1q_p8^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_p8_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p8_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p8_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p16^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_p16_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p16_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p16_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p64^⚠Experimentalneon,aes

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_p64_x2^⚠Experimentalneon,aes

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p64_x3^⚠Experimentalneon,aes

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_p64_x4^⚠Experimentalneon,aes

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s8^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_s8_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s8_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s8_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s16^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_s16_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s16_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s16_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s32^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_s32_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s32_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s32_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s64^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_s64_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s64_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_s64_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u8^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_u8_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u8_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u8_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u16^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_u16_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u16_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u16_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u32^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_u32_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u32_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u32_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u64^⚠Experimentalneon,v7

将多个单一元素结构加载到一个，两个，三个或四个寄存器中。

vld1q_u64_x2^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u64_x3^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld1q_u64_x4^⚠Experimentalneon

将多个单一元素结构加载到一个、两个、三个或四个寄存器中

vld2_dup_p8^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_dup_p16^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_dup_p64^⚠Experimentalneon,aes

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_dup_u8^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_dup_u16^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_dup_u32^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_dup_u64^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2_lane_p8^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_lane_p16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_lane_u8^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_lane_u16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_lane_u32^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_p8^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_p16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_p64^⚠Experimentalneon,aes

将多个 2 元素结构加载到两个寄存器

vld2_u8^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_u16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_u32^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2_u64^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_dup_p8^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2q_dup_p16^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2q_dup_u8^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2q_dup_u16^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2q_dup_u32^⚠Experimentalneon

加载单个 2 元素结构体并复制到两个寄存器的所有 lanes

vld2q_lane_p16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_lane_u16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_lane_u32^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_p8^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_p16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_u8^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_u16^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld2q_u32^⚠Experimentalneon

将多个 2 元素结构加载到两个寄存器

vld3_dup_p8^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_dup_p16^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_dup_p64^⚠Experimentalneon,aes

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_dup_u8^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_dup_u16^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_dup_u32^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_dup_u64^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3_lane_p8^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_lane_p16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_lane_u8^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_lane_u16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_lane_u32^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_p8^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_p16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_p64^⚠Experimentalneon,aes

将多个 3 元素结构加载到三个寄存器

vld3_u8^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_u16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_u32^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3_u64^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_dup_p8^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3q_dup_p16^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3q_dup_u8^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3q_dup_u16^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3q_dup_u32^⚠Experimentalneon

加载单个 3 元素结构体并复制到三个寄存器的所有 lanes

vld3q_lane_p16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_lane_u16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_lane_u32^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_p8^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_p16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_u8^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_u16^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld3q_u32^⚠Experimentalneon

将多个 3 元素结构加载到三个寄存器

vld4_dup_p8^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_dup_p16^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_dup_p64^⚠Experimentalneon,aes

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_dup_u8^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_dup_u16^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_dup_u32^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_dup_u64^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4_lane_p8^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_lane_p16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_lane_u8^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_lane_u16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_lane_u32^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_p8^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_p16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_p64^⚠Experimentalneon,aes

将多个 4 元素结构加载到四个寄存器

vld4_u8^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_u16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_u32^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4_u64^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_dup_p8^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4q_dup_p16^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4q_dup_u8^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4q_dup_u16^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4q_dup_u32^⚠Experimentalneon

加载单个 4 元素结构体并复制到四个寄存器的所有 lanes

vld4q_lane_p16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_lane_u16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_lane_u32^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_p8^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_p16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_u8^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_u16^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vld4q_u32^⚠Experimentalneon

将多个 4 元素结构加载到四个寄存器

vldrq_p128^⚠Experimentalneon

加载 SIMD&FP 寄存器 (immediate 偏移量)

vmax_f32^⚠Experimentalneon

最大 (vector)

vmax_s8^⚠Experimentalneon

最大 (vector)

vmax_s16^⚠Experimentalneon

最大 (vector)

vmax_s32^⚠Experimentalneon

最大 (vector)

vmax_u8^⚠Experimentalneon

最大 (vector)

vmax_u16^⚠Experimentalneon

最大 (vector)

vmax_u32^⚠Experimentalneon

最大 (vector)

vmaxnm_f32^⚠Experimentalneon

浮点最大值 (vector)

vmaxnmq_f32^⚠Experimentalneon

浮点最大值 (vector)

vmaxq_f32^⚠Experimentalneon

最大 (vector)

vmaxq_s8^⚠Experimentalneon

最大 (vector)

vmaxq_s16^⚠Experimentalneon

最大 (vector)

vmaxq_s32^⚠Experimentalneon

最大 (vector)

vmaxq_u8^⚠Experimentalneon

最大 (vector)

vmaxq_u16^⚠Experimentalneon

最大 (vector)

vmaxq_u32^⚠Experimentalneon

最大 (vector)

vmin_f32^⚠Experimentalneon

最小 (vector)

vmin_s8^⚠Experimentalneon

最小 (vector)

vmin_s16^⚠Experimentalneon

最小 (vector)

vmin_s32^⚠Experimentalneon

最小 (vector)

vmin_u8^⚠Experimentalneon

最小 (vector)

vmin_u16^⚠Experimentalneon

最小 (vector)

vmin_u32^⚠Experimentalneon

最小 (vector)

vminnm_f32^⚠Experimentalneon

浮点最小数 (vector)

vminnmq_f32^⚠Experimentalneon

浮点最小数 (vector)

vminq_f32^⚠Experimentalneon

最小 (vector)

vminq_s8^⚠Experimentalneon

最小 (vector)

vminq_s16^⚠Experimentalneon

最小 (vector)

vminq_s32^⚠Experimentalneon

最小 (vector)

vminq_u8^⚠Experimentalneon

最小 (vector)

vminq_u16^⚠Experimentalneon

最小 (vector)

vminq_u32^⚠Experimentalneon

最小 (vector)

vmla_f32^⚠Experimentalneon

浮点乘加累加器

vmla_lane_f32^⚠Experimentalneon

向量与标量相乘累加

vmla_lane_s16^⚠Experimentalneon

向量与标量相乘累加

vmla_lane_s32^⚠Experimentalneon

向量与标量相乘累加

vmla_lane_u16^⚠Experimentalneon

向量与标量相乘累加

vmla_lane_u32^⚠Experimentalneon

向量与标量相乘累加

vmla_laneq_f32^⚠Experimentalneon

向量与标量相乘累加

vmla_laneq_s16^⚠Experimentalneon

向量与标量相乘累加

vmla_laneq_s32^⚠Experimentalneon

向量与标量相乘累加

vmla_laneq_u16^⚠Experimentalneon

向量与标量相乘累加

vmla_laneq_u32^⚠Experimentalneon

向量与标量相乘累加

vmla_n_f32^⚠Experimentalneon

向量与标量相乘累加

vmla_n_s16^⚠Experimentalneon

向量与标量相乘累加

vmla_n_s32^⚠Experimentalneon

向量与标量相乘累加

vmla_n_u16^⚠Experimentalneon

向量与标量相乘累加

vmla_n_u32^⚠Experimentalneon

向量与标量相乘累加

vmla_s8^⚠Experimentalneon

乘加到累加器

vmla_s16^⚠Experimentalneon

乘加到累加器

vmla_s32^⚠Experimentalneon

乘加到累加器

vmla_u8^⚠Experimentalneon

乘加到累加器

vmla_u16^⚠Experimentalneon

乘加到累加器

vmla_u32^⚠Experimentalneon

乘加到累加器

vmlal_lane_s16^⚠Experimentalneon

向量加宽乘积与标量

vmlal_lane_s32^⚠Experimentalneon

向量加宽乘积与标量

vmlal_lane_u16^⚠Experimentalneon

向量加宽乘积与标量

vmlal_lane_u32^⚠Experimentalneon

向量加宽乘积与标量

vmlal_laneq_s16^⚠Experimentalneon

向量加宽乘积与标量

vmlal_laneq_s32^⚠Experimentalneon

向量加宽乘积与标量

vmlal_laneq_u16^⚠Experimentalneon

向量加宽乘积与标量

vmlal_laneq_u32^⚠Experimentalneon

向量加宽乘积与标量

vmlal_n_s16^⚠Experimentalneon

向量加宽乘积与标量

vmlal_n_s32^⚠Experimentalneon

向量加宽乘积与标量

vmlal_n_u16^⚠Experimentalneon

向量加宽乘积与标量

vmlal_n_u32^⚠Experimentalneon

向量加宽乘积与标量

vmlal_s8^⚠Experimentalneon

有符号乘加长

vmlal_s16^⚠Experimentalneon

有符号乘加长

vmlal_s32^⚠Experimentalneon

有符号乘加长

vmlal_u8^⚠Experimentalneon

无符号乘加长

vmlal_u16^⚠Experimentalneon

无符号乘加长

vmlal_u32^⚠Experimentalneon

无符号乘加长

vmlaq_f32^⚠Experimentalneon

浮点乘加累加器

vmlaq_lane_f32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_lane_s16^⚠Experimentalneon

向量与标量相乘累加

vmlaq_lane_s32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_lane_u16^⚠Experimentalneon

向量与标量相乘累加

vmlaq_lane_u32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_laneq_f32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_laneq_s16^⚠Experimentalneon

向量与标量相乘累加

vmlaq_laneq_s32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_laneq_u16^⚠Experimentalneon

向量与标量相乘累加

vmlaq_laneq_u32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_n_f32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_n_s16^⚠Experimentalneon

向量与标量相乘累加

vmlaq_n_s32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_n_u16^⚠Experimentalneon

向量与标量相乘累加

vmlaq_n_u32^⚠Experimentalneon

向量与标量相乘累加

vmlaq_s8^⚠Experimentalneon

乘加到累加器

vmlaq_s16^⚠Experimentalneon

乘加到累加器

vmlaq_s32^⚠Experimentalneon

乘加到累加器

vmlaq_u8^⚠Experimentalneon

乘加到累加器

vmlaq_u16^⚠Experimentalneon

乘加到累加器

vmlaq_u32^⚠Experimentalneon

乘加到累加器

vmls_f32^⚠Experimentalneon

浮点乘减累加器

vmls_lane_f32^⚠Experimentalneon

向量乘减标量

vmls_lane_s16^⚠Experimentalneon

向量乘减标量

vmls_lane_s32^⚠Experimentalneon

向量乘减标量

vmls_lane_u16^⚠Experimentalneon

向量乘减标量

vmls_lane_u32^⚠Experimentalneon

向量乘减标量

vmls_laneq_f32^⚠Experimentalneon

向量乘减标量

vmls_laneq_s16^⚠Experimentalneon

向量乘减标量

vmls_laneq_s32^⚠Experimentalneon

向量乘减标量

vmls_laneq_u16^⚠Experimentalneon

向量乘减标量

vmls_laneq_u32^⚠Experimentalneon

向量乘减标量

vmls_n_f32^⚠Experimentalneon

向量乘减标量

vmls_n_s16^⚠Experimentalneon

向量乘减标量

vmls_n_s32^⚠Experimentalneon

向量乘减标量

vmls_n_u16^⚠Experimentalneon

向量乘减标量

vmls_n_u32^⚠Experimentalneon

向量乘减标量

vmls_s8^⚠Experimentalneon

累加器的乘减

vmls_s16^⚠Experimentalneon

累加器的乘减

vmls_s32^⚠Experimentalneon

累加器的乘减

vmls_u8^⚠Experimentalneon

累加器的乘减

vmls_u16^⚠Experimentalneon

累加器的乘减

vmls_u32^⚠Experimentalneon

累加器的乘减

vmlsl_lane_s16^⚠Experimentalneon

向量加宽乘减标量

vmlsl_lane_s32^⚠Experimentalneon

向量加宽乘减标量

vmlsl_lane_u16^⚠Experimentalneon

向量加宽乘减标量

vmlsl_lane_u32^⚠Experimentalneon

向量加宽乘减标量

vmlsl_laneq_s16^⚠Experimentalneon

向量加宽乘减标量

vmlsl_laneq_s32^⚠Experimentalneon

向量加宽乘减标量

vmlsl_laneq_u16^⚠Experimentalneon

向量加宽乘减标量

vmlsl_laneq_u32^⚠Experimentalneon

向量加宽乘减标量

vmlsl_n_s16^⚠Experimentalneon

向量加宽乘减标量

vmlsl_n_s32^⚠Experimentalneon

向量加宽乘减标量

vmlsl_n_u16^⚠Experimentalneon

向量加宽乘减标量

vmlsl_n_u32^⚠Experimentalneon

向量加宽乘减标量

vmlsl_s8^⚠Experimentalneon

有符号乘减长

vmlsl_s16^⚠Experimentalneon

有符号乘减长

vmlsl_s32^⚠Experimentalneon

有符号乘减长

vmlsl_u8^⚠Experimentalneon

无符号乘减长

vmlsl_u16^⚠Experimentalneon

无符号乘减长

vmlsl_u32^⚠Experimentalneon

无符号乘减长

vmlsq_f32^⚠Experimentalneon

浮点乘减累加器

vmlsq_lane_f32^⚠Experimentalneon

向量乘减标量

vmlsq_lane_s16^⚠Experimentalneon

向量乘减标量

vmlsq_lane_s32^⚠Experimentalneon

向量乘减标量

vmlsq_lane_u16^⚠Experimentalneon

向量乘减标量

vmlsq_lane_u32^⚠Experimentalneon

向量乘减标量

vmlsq_laneq_f32^⚠Experimentalneon

向量乘减标量

vmlsq_laneq_s16^⚠Experimentalneon

向量乘减标量

vmlsq_laneq_s32^⚠Experimentalneon

向量乘减标量

vmlsq_laneq_u16^⚠Experimentalneon

向量乘减标量

vmlsq_laneq_u32^⚠Experimentalneon

向量乘减标量

vmlsq_n_f32^⚠Experimentalneon

向量乘减标量

vmlsq_n_s16^⚠Experimentalneon

向量乘减标量

vmlsq_n_s32^⚠Experimentalneon

向量乘减标量

vmlsq_n_u16^⚠Experimentalneon

向量乘减标量

vmlsq_n_u32^⚠Experimentalneon

向量乘减标量

vmlsq_s8^⚠Experimentalneon

累加器的乘减

vmlsq_s16^⚠Experimentalneon

累加器的乘减

vmlsq_s32^⚠Experimentalneon

累加器的乘减

vmlsq_u8^⚠Experimentalneon

累加器的乘减

vmlsq_u16^⚠Experimentalneon

累加器的乘减

vmlsq_u32^⚠Experimentalneon

累加器的乘减

vmmlaq_s32^⚠Experimentalneon

8 位整数矩阵乘法累加

vmmlaq_u32^⚠Experimentalneon

8 位整数矩阵乘法累加

vmov_n_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_p8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_p16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_s8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_s16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_s32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_s64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_u8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_u16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_u32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmov_n_u64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovl_s8^⚠Experimentalneon

Vector 长移动。

vmovl_s16^⚠Experimentalneon

Vector 长移动。

vmovl_s32^⚠Experimentalneon

Vector 长移动。

vmovl_u8^⚠Experimentalneon

Vector 长移动。

vmovl_u16^⚠Experimentalneon

Vector 长移动。

vmovl_u32^⚠Experimentalneon

Vector 长移动。

vmovn_s16^⚠Experimentalneon

Vector narrow 整数。

vmovn_s32^⚠Experimentalneon

Vector narrow 整数。

vmovn_s64^⚠Experimentalneon

Vector narrow 整数。

vmovn_u16^⚠Experimentalneon

Vector narrow 整数。

vmovn_u32^⚠Experimentalneon

Vector narrow 整数。

vmovn_u64^⚠Experimentalneon

Vector narrow 整数。

vmovq_n_f32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_p8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_p16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_s8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_s16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_s32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_s64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_u8^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_u16^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_u32^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmovq_n_u64^⚠Experimentalneon

将 vector 元素复制到 vector 或标量

vmul_f32^⚠Experimentalneon

Multiply

vmul_lane_f32^⚠Experimentalneon

浮点乘法

vmul_lane_s16^⚠Experimentalneon

Multiply

vmul_lane_s32^⚠Experimentalneon

Multiply

vmul_lane_u16^⚠Experimentalneon

Multiply

vmul_lane_u32^⚠Experimentalneon

Multiply

vmul_laneq_f32^⚠Experimentalneon

浮点乘法

vmul_laneq_s16^⚠Experimentalneon

Multiply

vmul_laneq_s32^⚠Experimentalneon

Multiply

vmul_laneq_u16^⚠Experimentalneon

Multiply

vmul_laneq_u32^⚠Experimentalneon

Multiply

vmul_n_f32^⚠Experimentalneon

Vector 乘以标量

vmul_n_s16^⚠Experimentalneon

Vector 乘以标量

vmul_n_s32^⚠Experimentalneon

Vector 乘以标量

vmul_n_u16^⚠Experimentalneon

Vector 乘以标量

vmul_n_u32^⚠Experimentalneon

Vector 乘以标量

vmul_p8^⚠Experimentalneon

多项式乘法

vmul_s8^⚠Experimentalneon

Multiply

vmul_s16^⚠Experimentalneon

Multiply

vmul_s32^⚠Experimentalneon

Multiply

vmul_u8^⚠Experimentalneon

Multiply

vmul_u16^⚠Experimentalneon

Multiply

vmul_u32^⚠Experimentalneon

Multiply

vmull_lane_s16^⚠Experimentalneon

Vector 长乘以标量

vmull_lane_s32^⚠Experimentalneon

Vector 长乘以标量

vmull_lane_u16^⚠Experimentalneon

Vector 长乘以标量

vmull_lane_u32^⚠Experimentalneon

Vector 长乘以标量

vmull_laneq_s16^⚠Experimentalneon

Vector 长乘以标量

vmull_laneq_s32^⚠Experimentalneon

Vector 长乘以标量

vmull_laneq_u16^⚠Experimentalneon

Vector 长乘以标量

vmull_laneq_u32^⚠Experimentalneon

Vector 长乘以标量

vmull_n_s16^⚠Experimentalneon

向量长乘以标量

vmull_n_s32^⚠Experimentalneon

向量长乘以标量

vmull_n_u16^⚠Experimentalneon

向量长乘以标量

vmull_n_u32^⚠Experimentalneon

向量长乘以标量

vmull_p8^⚠Experimentalneon

多项式乘长

vmull_s8^⚠Experimentalneon

有符号乘长

vmull_s16^⚠Experimentalneon

有符号乘长

vmull_s32^⚠Experimentalneon

有符号乘长

vmull_u8^⚠Experimentalneon

无符号乘长

vmull_u16^⚠Experimentalneon

无符号乘长

vmull_u32^⚠Experimentalneon

无符号乘长

vmulq_f32^⚠Experimentalneon

Multiply

vmulq_lane_f32^⚠Experimentalneon

浮点乘法

vmulq_lane_s16^⚠Experimentalneon

Multiply

vmulq_lane_s32^⚠Experimentalneon

Multiply

vmulq_lane_u16^⚠Experimentalneon

Multiply

vmulq_lane_u32^⚠Experimentalneon

Multiply

vmulq_laneq_f32^⚠Experimentalneon

浮点乘法

vmulq_laneq_s16^⚠Experimentalneon

Multiply

vmulq_laneq_s32^⚠Experimentalneon

Multiply

vmulq_laneq_u16^⚠Experimentalneon

Multiply

vmulq_laneq_u32^⚠Experimentalneon

Multiply

vmulq_n_f32^⚠Experimentalneon

Vector 乘以标量

vmulq_n_s16^⚠Experimentalneon

Vector 乘以标量

vmulq_n_s32^⚠Experimentalneon

Vector 乘以标量

vmulq_n_u16^⚠Experimentalneon

Vector 乘以标量

vmulq_n_u32^⚠Experimentalneon

Vector 乘以标量

vmulq_p8^⚠Experimentalneon

多项式乘法

vmulq_s8^⚠Experimentalneon

Multiply

vmulq_s16^⚠Experimentalneon

Multiply

vmulq_s32^⚠Experimentalneon

Multiply

vmulq_u8^⚠Experimentalneon

Multiply

vmulq_u16^⚠Experimentalneon

Multiply

vmulq_u32^⚠Experimentalneon

Multiply

vmvn_p8^⚠Experimentalneon

Vector 不是按位的。

vmvn_s8^⚠Experimentalneon

Vector 不是按位的。

vmvn_s16^⚠Experimentalneon

Vector 不是按位的。

vmvn_s32^⚠Experimentalneon

Vector 不是按位的。

vmvn_u8^⚠Experimentalneon

Vector 不是按位的。

vmvn_u16^⚠Experimentalneon

Vector 不是按位的。

vmvn_u32^⚠Experimentalneon

Vector 不是按位的。

vmvnq_p8^⚠Experimentalneon

Vector 不是按位的。

vmvnq_s8^⚠Experimentalneon

Vector 不是按位的。

vmvnq_s16^⚠Experimentalneon

Vector 不是按位的。

vmvnq_s32^⚠Experimentalneon

Vector 不是按位的。

vmvnq_u8^⚠Experimentalneon

Vector 不是按位的。

vmvnq_u16^⚠Experimentalneon

Vector 不是按位的。

vmvnq_u32^⚠Experimentalneon

Vector 不是按位的。

vneg_f32^⚠Experimentalneon

Negate

vneg_s8^⚠Experimentalneon

Negate

vneg_s16^⚠Experimentalneon

Negate

vneg_s32^⚠Experimentalneon

Negate

vnegq_f32^⚠Experimentalneon

Negate

vnegq_s8^⚠Experimentalneon

Negate

vnegq_s16^⚠Experimentalneon

Negate

vnegq_s32^⚠Experimentalneon

Negate

vorn_s8^⚠Experimentalneon

向量按位包含或不包含

vorn_s16^⚠Experimentalneon

向量按位包含或不包含

vorn_s32^⚠Experimentalneon

向量按位包含或不包含

vorn_s64^⚠Experimentalneon

向量按位包含或不包含

vorn_u8^⚠Experimentalneon

向量按位包含或不包含

vorn_u16^⚠Experimentalneon

向量按位包含或不包含

vorn_u32^⚠Experimentalneon

向量按位包含或不包含

vorn_u64^⚠Experimentalneon

向量按位包含或不包含

vornq_s8^⚠Experimentalneon

向量按位包含或不包含

vornq_s16^⚠Experimentalneon

向量按位包含或不包含

vornq_s32^⚠Experimentalneon

向量按位包含或不包含

vornq_s64^⚠Experimentalneon

向量按位包含或不包含

vornq_u8^⚠Experimentalneon

向量按位包含或不包含

vornq_u16^⚠Experimentalneon

向量按位包含或不包含

vornq_u32^⚠Experimentalneon

向量按位包含或不包含

vornq_u64^⚠Experimentalneon

向量按位包含或不包含

vorr_s8^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_s16^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_s32^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_s64^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_u8^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_u16^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_u32^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorr_u64^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_s8^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_s16^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_s32^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_s64^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_u8^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_u16^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_u32^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vorrq_u64^⚠Experimentalneon

Vector 按位或 ( immediate ，包括)

vpadal_s8^⚠Experimentalneon

有符号加和成对累积长。

vpadal_s16^⚠Experimentalneon

有符号加和成对累积长。

vpadal_s32^⚠Experimentalneon

有符号加和成对累积长。

vpadal_u8^⚠Experimentalneon

无符号加和成对累积长。

vpadal_u16^⚠Experimentalneon

无符号加和成对累积长。

vpadal_u32^⚠Experimentalneon

无符号加和成对累积长。

vpadalq_s8^⚠Experimentalneon

有符号加和成对累积长。

vpadalq_s16^⚠Experimentalneon

有符号加和成对累积长。

vpadalq_s32^⚠Experimentalneon

有符号加和成对累积长。

vpadalq_u8^⚠Experimentalneon

无符号加和成对累积长。

vpadalq_u16^⚠Experimentalneon

无符号加和成对累积长。

vpadalq_u32^⚠Experimentalneon

无符号加和成对累积长。

vpadd_f32^⚠Experimentalneon

浮点数成对相加

vpadd_s8^⚠Experimentalneon

成对添加。

vpadd_s16^⚠Experimentalneon

成对添加。

vpadd_s32^⚠Experimentalneon

成对添加。

vpadd_u8^⚠Experimentalneon

成对添加。

vpadd_u16^⚠Experimentalneon

成对添加。

vpadd_u32^⚠Experimentalneon

成对添加。

vpaddl_s8^⚠Experimentalneon

有符号成对加长。

vpaddl_s16^⚠Experimentalneon

有符号成对加长。

vpaddl_s32^⚠Experimentalneon

有符号成对加长。

vpaddl_u8^⚠Experimentalneon

无符号成对加长。

vpaddl_u16^⚠Experimentalneon

无符号成对加长。

vpaddl_u32^⚠Experimentalneon

无符号成对加长。

vpaddlq_s8^⚠Experimentalneon

有符号成对加长。

vpaddlq_s16^⚠Experimentalneon

有符号成对加长。

vpaddlq_s32^⚠Experimentalneon

有符号成对加长。

vpaddlq_u8^⚠Experimentalneon

无符号成对加长。

vpaddlq_u16^⚠Experimentalneon

无符号成对加长。

vpaddlq_u32^⚠Experimentalneon

无符号成对加长。

vpmax_f32^⚠Experimentalneon

相邻对的最大折叠

vpmax_s8^⚠Experimentalneon

相邻对的最大折叠

vpmax_s16^⚠Experimentalneon

相邻对的最大折叠

vpmax_s32^⚠Experimentalneon

相邻对的最大折叠

vpmax_u8^⚠Experimentalneon

相邻对的最大折叠

vpmax_u16^⚠Experimentalneon

相邻对的最大折叠

vpmax_u32^⚠Experimentalneon

相邻对的最大折叠

vpmin_f32^⚠Experimentalneon

相邻对的最小折叠

vpmin_s8^⚠Experimentalneon

相邻对的最小折叠

vpmin_s16^⚠Experimentalneon

相邻对的最小折叠

vpmin_s32^⚠Experimentalneon

相邻对的最小折叠

vpmin_u8^⚠Experimentalneon

相邻对的最小折叠

vpmin_u16^⚠Experimentalneon

相邻对的最小折叠

vpmin_u32^⚠Experimentalneon

相邻对的最小折叠

vqabs_s8^⚠Experimentalneon

饱和绝对值

vqabs_s16^⚠Experimentalneon

饱和绝对值

vqabs_s32^⚠Experimentalneon

饱和绝对值

vqabsq_s8^⚠Experimentalneon

饱和绝对值

vqabsq_s16^⚠Experimentalneon

饱和绝对值

vqabsq_s32^⚠Experimentalneon

饱和绝对值

vqadd_s8^⚠Experimentalneon

饱和添加

vqadd_s16^⚠Experimentalneon

饱和添加

vqadd_s32^⚠Experimentalneon

饱和添加

vqadd_s64^⚠Experimentalneon

饱和添加

vqadd_u8^⚠Experimentalneon

饱和添加

vqadd_u16^⚠Experimentalneon

饱和添加

vqadd_u32^⚠Experimentalneon

饱和添加

vqadd_u64^⚠Experimentalneon

饱和添加

vqaddq_s8^⚠Experimentalneon

饱和添加

vqaddq_s16^⚠Experimentalneon

饱和添加

vqaddq_s32^⚠Experimentalneon

饱和添加

vqaddq_s64^⚠Experimentalneon

饱和添加

vqaddq_u8^⚠Experimentalneon

饱和添加

vqaddq_u16^⚠Experimentalneon

饱和添加

vqaddq_u32^⚠Experimentalneon

饱和添加

vqaddq_u64^⚠Experimentalneon

饱和添加

vqdmlal_lane_s16^⚠Experimentalneon

Vector 加宽饱和加倍乘积与标量

vqdmlal_lane_s32^⚠Experimentalneon

Vector 加宽饱和加倍乘积与标量

vqdmlal_n_s16^⚠Experimentalneon

Vector 加宽饱和加倍乘积与标量

vqdmlal_n_s32^⚠Experimentalneon

Vector 加宽饱和加倍乘积与标量

vqdmlal_s16^⚠Experimentalneon

有符号饱和加倍乘加长

vqdmlal_s32^⚠Experimentalneon

有符号饱和加倍乘加长

vqdmlsl_lane_s16^⚠Experimentalneon

Vector 加宽饱和加倍乘减标量

vqdmlsl_lane_s32^⚠Experimentalneon

Vector 加宽饱和加倍乘减标量

vqdmlsl_n_s16^⚠Experimentalneon

Vector 加宽饱和加倍乘减标量

vqdmlsl_n_s32^⚠Experimentalneon

Vector 加宽饱和加倍乘减标量

vqdmlsl_s16^⚠Experimentalneon

有符号饱和加倍乘减长

vqdmlsl_s32^⚠Experimentalneon

有符号饱和加倍乘减长

vqdmulh_laneq_s16^⚠Experimentalneon

Vector 饱和加倍乘以标量

vqdmulh_laneq_s32^⚠Experimentalneon

Vector 饱和加倍乘以标量

vqdmulh_n_s16^⚠Experimentalneon

向量饱和加倍乘以标量

vqdmulh_n_s32^⚠Experimentalneon

向量饱和加倍乘以标量

vqdmulh_s16^⚠Experimentalneon

有符号饱和加倍乘法返回高半

vqdmulh_s32^⚠Experimentalneon

有符号饱和加倍乘法返回高半

vqdmulhq_laneq_s16^⚠Experimentalneon

Vector 饱和加倍乘以标量

vqdmulhq_laneq_s32^⚠Experimentalneon

Vector 饱和加倍乘以标量

vqdmulhq_n_s16^⚠Experimentalneon

向量饱和加倍乘以标量

vqdmulhq_n_s32^⚠Experimentalneon

向量饱和加倍乘以标量

vqdmulhq_s16^⚠Experimentalneon

有符号饱和加倍乘法返回高半

vqdmulhq_s32^⚠Experimentalneon

有符号饱和加倍乘法返回高半

vqdmull_lane_s16^⚠Experimentalneon

Vector 饱和加倍长乘以标量

vqdmull_lane_s32^⚠Experimentalneon

Vector 饱和加倍长乘以标量

vqdmull_n_s16^⚠Experimentalneon

向量饱和加倍长乘以标量

vqdmull_n_s32^⚠Experimentalneon

向量饱和加倍长乘以标量

vqdmull_s16^⚠Experimentalneon

有符号饱和加倍乘以长

vqdmull_s32^⚠Experimentalneon

有符号饱和加倍乘以长

vqmovn_s16^⚠Experimentalneon

带符号饱和提取 narrow

vqmovn_s32^⚠Experimentalneon

带符号饱和提取 narrow

vqmovn_s64^⚠Experimentalneon

带符号饱和提取 narrow

vqmovn_u16^⚠Experimentalneon

无符号饱和提取 narrow

vqmovn_u32^⚠Experimentalneon

无符号饱和提取 narrow

vqmovn_u64^⚠Experimentalneon

无符号饱和提取 narrow

vqmovun_s16^⚠Experimentalneon

有符号饱和提取无符号 narrow

vqmovun_s32^⚠Experimentalneon

有符号饱和提取无符号 narrow

vqmovun_s64^⚠Experimentalneon

有符号饱和提取无符号 narrow

vqneg_s8^⚠Experimentalneon

有符号饱和否定

vqneg_s16^⚠Experimentalneon

有符号饱和否定

vqneg_s32^⚠Experimentalneon

有符号饱和否定

vqnegq_s8^⚠Experimentalneon

有符号饱和否定

vqnegq_s16^⚠Experimentalneon

有符号饱和否定

vqnegq_s32^⚠Experimentalneon

有符号饱和否定

vqrdmlsh_lane_s16^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlsh_lane_s32^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlsh_laneq_s16^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlsh_laneq_s32^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlsh_s16^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlsh_s32^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlshq_lane_s16^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlshq_lane_s32^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlshq_laneq_s16^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlshq_laneq_s32^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlshq_s16^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmlshq_s32^⚠Experimentalneon

有符号饱和舍入加倍乘减返回高半

vqrdmulh_lane_s16^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulh_lane_s32^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulh_laneq_s16^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulh_laneq_s32^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulh_n_s16^⚠Experimentalneon

向量饱和舍入加倍乘以标量高

vqrdmulh_n_s32^⚠Experimentalneon

向量饱和舍入加倍乘以标量高

vqrdmulh_s16^⚠Experimentalneon

有符号饱和舍入加倍乘法返回高半

vqrdmulh_s32^⚠Experimentalneon

有符号饱和舍入加倍乘法返回高半

vqrdmulhq_lane_s16^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulhq_lane_s32^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulhq_laneq_s16^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulhq_laneq_s32^⚠Experimentalneon

向量舍入饱和加倍乘以标量高

vqrdmulhq_n_s16^⚠Experimentalneon

向量饱和舍入加倍乘以标量高

vqrdmulhq_n_s32^⚠Experimentalneon

向量饱和舍入加倍乘以标量高

vqrdmulhq_s16^⚠Experimentalneon

有符号饱和舍入加倍乘法返回高半

vqrdmulhq_s32^⚠Experimentalneon

有符号饱和舍入加倍乘法返回高半

vqrshl_s8^⚠Experimentalneon

有符号饱和舍入左移

vqrshl_s16^⚠Experimentalneon

有符号饱和舍入左移

vqrshl_s32^⚠Experimentalneon

有符号饱和舍入左移

vqrshl_s64^⚠Experimentalneon

有符号饱和舍入左移

vqrshl_u8^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshl_u16^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshl_u32^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshl_u64^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshlq_s8^⚠Experimentalneon

有符号饱和舍入左移

vqrshlq_s16^⚠Experimentalneon

有符号饱和舍入左移

vqrshlq_s32^⚠Experimentalneon

有符号饱和舍入左移

vqrshlq_s64^⚠Experimentalneon

有符号饱和舍入左移

vqrshlq_u8^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshlq_u16^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshlq_u32^⚠Experimentalneon

无符号有符号饱和舍入左移

vqrshlq_u64^⚠Experimentalneon

无符号有符号饱和舍入左移

vqshl_n_s8^⚠Experimentalneon

有符号饱和左移

vqshl_n_s16^⚠Experimentalneon

有符号饱和左移

vqshl_n_s32^⚠Experimentalneon

有符号饱和左移

vqshl_n_s64^⚠Experimentalneon

有符号饱和左移

vqshl_n_u8^⚠Experimentalneon

无符号饱和左移

vqshl_n_u16^⚠Experimentalneon

无符号饱和左移

vqshl_n_u32^⚠Experimentalneon

无符号饱和左移

vqshl_n_u64^⚠Experimentalneon

无符号饱和左移

vqshl_s8^⚠Experimentalneon

有符号饱和左移

vqshl_s16^⚠Experimentalneon

有符号饱和左移

vqshl_s32^⚠Experimentalneon

有符号饱和左移

vqshl_s64^⚠Experimentalneon

有符号饱和左移

vqshl_u8^⚠Experimentalneon

无符号饱和左移

vqshl_u16^⚠Experimentalneon

无符号饱和左移

vqshl_u32^⚠Experimentalneon

无符号饱和左移

vqshl_u64^⚠Experimentalneon

无符号饱和左移

vqshlq_n_s8^⚠Experimentalneon

有符号饱和左移

vqshlq_n_s16^⚠Experimentalneon

有符号饱和左移

vqshlq_n_s32^⚠Experimentalneon

有符号饱和左移

vqshlq_n_s64^⚠Experimentalneon

有符号饱和左移

vqshlq_n_u8^⚠Experimentalneon

无符号饱和左移

vqshlq_n_u16^⚠Experimentalneon

无符号饱和左移

vqshlq_n_u32^⚠Experimentalneon

无符号饱和左移

vqshlq_n_u64^⚠Experimentalneon

无符号饱和左移

vqshlq_s8^⚠Experimentalneon

有符号饱和左移

vqshlq_s16^⚠Experimentalneon

有符号饱和左移

vqshlq_s32^⚠Experimentalneon

有符号饱和左移

vqshlq_s64^⚠Experimentalneon

有符号饱和左移

vqshlq_u8^⚠Experimentalneon

无符号饱和左移

vqshlq_u16^⚠Experimentalneon

无符号饱和左移

vqshlq_u32^⚠Experimentalneon

无符号饱和左移

vqshlq_u64^⚠Experimentalneon

无符号饱和左移

vqsub_s8^⚠Experimentalneon

饱和减

vqsub_s16^⚠Experimentalneon

饱和减

vqsub_s32^⚠Experimentalneon

饱和减

vqsub_s64^⚠Experimentalneon

饱和减

vqsub_u8^⚠Experimentalneon

饱和减

vqsub_u16^⚠Experimentalneon

饱和减

vqsub_u32^⚠Experimentalneon

饱和减

vqsub_u64^⚠Experimentalneon

饱和减

vqsubq_s8^⚠Experimentalneon

饱和减

vqsubq_s16^⚠Experimentalneon

饱和减

vqsubq_s32^⚠Experimentalneon

饱和减

vqsubq_s64^⚠Experimentalneon

饱和减

vqsubq_u8^⚠Experimentalneon

饱和减

vqsubq_u16^⚠Experimentalneon

饱和减

vqsubq_u32^⚠Experimentalneon

饱和减

vqsubq_u64^⚠Experimentalneon

饱和减

vraddhn_high_s16^⚠Experimentalneon

舍入添加返回的 High Narrow (高半)。

vraddhn_high_s32^⚠Experimentalneon

舍入添加返回的 High Narrow (高半)。

vraddhn_high_s64^⚠Experimentalneon

舍入添加返回的 High Narrow (高半)。

vraddhn_high_u16^⚠Experimentalneon

舍入添加返回的 High Narrow (高半)。

vraddhn_high_u32^⚠Experimentalneon

舍入添加返回的 High Narrow (高半)。

vraddhn_high_u64^⚠Experimentalneon

舍入添加返回的 High Narrow (高半)。

vraddhn_s16^⚠Experimentalneon

舍入添加返回 High Narrow。

vraddhn_s32^⚠Experimentalneon

舍入添加返回 High Narrow。

vraddhn_s64^⚠Experimentalneon

舍入添加返回 High Narrow。

vraddhn_u16^⚠Experimentalneon

舍入添加返回 High Narrow。

vraddhn_u32^⚠Experimentalneon

舍入添加返回 High Narrow。

vraddhn_u64^⚠Experimentalneon

舍入添加返回 High Narrow。

vrecpe_f32^⚠Experimentalneon

相互估计。

vrecpe_u32^⚠Experimentalneon

无符号倒数估计

vrecpeq_f32^⚠Experimentalneon

相互估计。

vrecpeq_u32^⚠Experimentalneon

无符号倒数估计

vrecps_f32^⚠Experimentalneon

浮点倒数步长

vrecpsq_f32^⚠Experimentalneon

浮点倒数步长

vreinterpret_f32_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_f32_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p8_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p8_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p16_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p16_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_p64_p8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_p16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_s8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_s16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_s32^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_u8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_u16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_p64_u32^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_s8_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_s8_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s8_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_s16_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s16_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_s32_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s32_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_s64_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_u8_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u8_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_u16_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u16_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpret_u32_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u32_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpret_u64_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_p128^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_f32_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p8_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p8_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p8_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p16_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p16_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p16_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p64_p8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_p16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_s8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_s16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_s32^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_u8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_u16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p64_u32^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_p128_p8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_p16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_s8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_s16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_s32^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_s64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_u8^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_u16^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_u32^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_p128_u64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s8_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s8_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s8_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s8_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s16_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s16_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s16_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s32_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s32_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s32_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_s64_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_s64_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u8_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u8_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u8_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u16_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u16_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u16_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_p64^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u32_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u32_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u32_u64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_f32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_p8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_p16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_p128^⚠Experimentalneon,aes

Vector 重新解释强制转换操作

vreinterpretq_u64_s8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_s16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_s32^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_s64^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_u8^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_u16^⚠Experimentalneon

Vector 重新解释强制转换操作

vreinterpretq_u64_u32^⚠Experimentalneon

Vector 重新解释强制转换操作

vrev16_p8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev16_s8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev16_u8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev16q_p8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev16q_s8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev16q_u8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32_p8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32_p16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32_s8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32_s16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32_u8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32_u16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32q_p8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32q_p16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32q_s8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32q_s16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32q_u8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev32q_u16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_f32^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_p8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_p16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_s8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_s16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_s32^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_u8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_u16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64_u32^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_f32^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_p8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_p16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_s8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_s16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_s32^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_u8^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_u16^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrev64q_u32^⚠Experimentalneon

反转 vector 元素 (交换字节顺序)

vrhadd_s8^⚠Experimentalneon

舍入减半添加

vrhadd_s16^⚠Experimentalneon

舍入减半添加

vrhadd_s32^⚠Experimentalneon

舍入减半添加

vrhadd_u8^⚠Experimentalneon

舍入减半添加

vrhadd_u16^⚠Experimentalneon

舍入减半添加

vrhadd_u32^⚠Experimentalneon

舍入减半添加

vrhaddq_s8^⚠Experimentalneon

舍入减半添加

vrhaddq_s16^⚠Experimentalneon

舍入减半添加

vrhaddq_s32^⚠Experimentalneon

舍入减半添加

vrhaddq_u8^⚠Experimentalneon

舍入减半添加

vrhaddq_u16^⚠Experimentalneon

舍入减半添加

vrhaddq_u32^⚠Experimentalneon

舍入减半添加

vrndn_f32^⚠Experimentalneon

浮点数舍入到整数，最接近与偶数的关系

vrndnq_f32^⚠Experimentalneon

浮点数舍入到整数，最接近与偶数的关系

vrshl_s8^⚠Experimentalneon

有符号舍入左移

vrshl_s16^⚠Experimentalneon

有符号舍入左移

vrshl_s32^⚠Experimentalneon

有符号舍入左移

vrshl_s64^⚠Experimentalneon

有符号舍入左移

vrshl_u8^⚠Experimentalneon

无符号舍入左移

vrshl_u16^⚠Experimentalneon

无符号舍入左移

vrshl_u32^⚠Experimentalneon

无符号舍入左移

vrshl_u64^⚠Experimentalneon

无符号舍入左移

vrshlq_s8^⚠Experimentalneon

有符号舍入左移

vrshlq_s16^⚠Experimentalneon

有符号舍入左移

vrshlq_s32^⚠Experimentalneon

有符号舍入左移

vrshlq_s64^⚠Experimentalneon

有符号舍入左移

vrshlq_u8^⚠Experimentalneon

无符号舍入左移

vrshlq_u16^⚠Experimentalneon

无符号舍入左移

vrshlq_u32^⚠Experimentalneon

无符号舍入左移

vrshlq_u64^⚠Experimentalneon

无符号舍入左移

vrshr_n_s8^⚠Experimentalneon

有符号舍入右移

vrshr_n_s16^⚠Experimentalneon

有符号舍入右移

vrshr_n_s32^⚠Experimentalneon

有符号舍入右移

vrshr_n_s64^⚠Experimentalneon

有符号舍入右移

vrshr_n_u8^⚠Experimentalneon

无符号舍入右移

vrshr_n_u16^⚠Experimentalneon

无符号舍入右移

vrshr_n_u32^⚠Experimentalneon

无符号舍入右移

vrshr_n_u64^⚠Experimentalneon

无符号舍入右移

vrshrn_n_u16^⚠Experimentalneon

舍入右移变 narrow

vrshrn_n_u32^⚠Experimentalneon

舍入右移变 narrow

vrshrn_n_u64^⚠Experimentalneon

舍入右移变 narrow

vrshrq_n_s8^⚠Experimentalneon

有符号舍入右移

vrshrq_n_s16^⚠Experimentalneon

有符号舍入右移

vrshrq_n_s32^⚠Experimentalneon

有符号舍入右移

vrshrq_n_s64^⚠Experimentalneon

有符号舍入右移

vrshrq_n_u8^⚠Experimentalneon

无符号舍入右移

vrshrq_n_u16^⚠Experimentalneon

无符号舍入右移

vrshrq_n_u32^⚠Experimentalneon

无符号舍入右移

vrshrq_n_u64^⚠Experimentalneon

无符号舍入右移

vrsqrte_f32^⚠Experimentalneon

平方根倒数估算。

vrsqrte_u32^⚠Experimentalneon

无符号倒数平方根估计

vrsqrteq_f32^⚠Experimentalneon

平方根倒数估算。

vrsqrteq_u32^⚠Experimentalneon

无符号倒数平方根估计

vrsqrts_f32^⚠Experimentalneon

浮点倒数平方根步长

vrsqrtsq_f32^⚠Experimentalneon

浮点倒数平方根步长

vrsra_n_s8^⚠Experimentalneon

有符号四舍入移并累加

vrsra_n_s16^⚠Experimentalneon

有符号四舍入移并累加

vrsra_n_s32^⚠Experimentalneon

有符号四舍入移并累加

vrsra_n_s64^⚠Experimentalneon

有符号四舍入移并累加

vrsra_n_u8^⚠Experimentalneon

无符号舍入右移并累加

vrsra_n_u16^⚠Experimentalneon

无符号舍入右移并累加

vrsra_n_u32^⚠Experimentalneon

无符号舍入右移并累加

vrsra_n_u64^⚠Experimentalneon

无符号舍入右移并累加

vrsraq_n_s8^⚠Experimentalneon

有符号四舍入移并累加

vrsraq_n_s16^⚠Experimentalneon

有符号四舍入移并累加

vrsraq_n_s32^⚠Experimentalneon

有符号四舍入移并累加

vrsraq_n_s64^⚠Experimentalneon

有符号四舍入移并累加

vrsraq_n_u8^⚠Experimentalneon

无符号舍入右移并累加

vrsraq_n_u16^⚠Experimentalneon

无符号舍入右移并累加

vrsraq_n_u32^⚠Experimentalneon

无符号舍入右移并累加

vrsraq_n_u64^⚠Experimentalneon

无符号舍入右移并累加

vrsubhn_s16^⚠Experimentalneon

舍入减法返回 high narrow

vrsubhn_s32^⚠Experimentalneon

舍入减法返回 high narrow

vrsubhn_s64^⚠Experimentalneon

舍入减法返回 high narrow

vrsubhn_u16^⚠Experimentalneon

舍入减法返回 high narrow

vrsubhn_u32^⚠Experimentalneon

舍入减法返回 high narrow

vrsubhn_u64^⚠Experimentalneon

舍入减法返回 high narrow

vset_lane_f32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_p8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_p16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_p64^⚠Experimentalneon,aes

从另一个 vector 元素插入 vector 元素

vset_lane_s8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_s16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_s32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_s64^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_u8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_u16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_u32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vset_lane_u64^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_f32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_p8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_p16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_p64^⚠Experimentalneon,aes

从另一个 vector 元素插入 vector 元素

vsetq_lane_s8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_s16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_s32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_s64^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_u8^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_u16^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_u32^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsetq_lane_u64^⚠Experimentalneon

从另一个 vector 元素插入 vector 元素

vsha1cq_u32^⚠Experimentalsha2

SHA1 哈希更新加速器，选择。

vsha1h_u32^⚠Experimentalsha2

SHA1 固定旋转。

vsha1mq_u32^⚠Experimentalsha2

SHA1 哈希更新加速器，多数。

vsha1pq_u32^⚠Experimentalsha2

SHA1 哈希更新加速器，奇偶校验。

vsha1su0q_u32^⚠Experimentalsha2

SHA1 调度更新加速器，第一部分。

vsha1su1q_u32^⚠Experimentalsha2

SHA1 调度更新加速器，第二部分。

vsha256h2q_u32^⚠Experimentalsha2

SHA256 哈希更新加速器，上半部分。

vsha256hq_u32^⚠Experimentalsha2

SHA256 哈希更新加速器。

vsha256su0q_u32^⚠Experimentalsha2

SHA256 调度更新加速器，第一部分。

vsha256su1q_u32^⚠Experimentalsha2

SHA256 调度更新加速器，第二部分。

vshl_n_s8^⚠Experimentalneon

左移

vshl_n_s16^⚠Experimentalneon

左移

vshl_n_s32^⚠Experimentalneon

左移

vshl_n_s64^⚠Experimentalneon

左移

vshl_n_u8^⚠Experimentalneon

左移

vshl_n_u16^⚠Experimentalneon

左移

vshl_n_u32^⚠Experimentalneon

左移

vshl_n_u64^⚠Experimentalneon

左移

vshl_s8^⚠Experimentalneon

有符号左移

vshl_s16^⚠Experimentalneon

有符号左移

vshl_s32^⚠Experimentalneon

有符号左移

vshl_s64^⚠Experimentalneon

有符号左移

vshl_u8^⚠Experimentalneon

无符号左移

vshl_u16^⚠Experimentalneon

无符号左移

vshl_u32^⚠Experimentalneon

无符号左移

vshl_u64^⚠Experimentalneon

无符号左移

vshll_n_s8^⚠Experimentalneon

有符号左移长

vshll_n_s16^⚠Experimentalneon

有符号左移长

vshll_n_s32^⚠Experimentalneon

有符号左移长

vshll_n_u8^⚠Experimentalneon

有符号左移长

vshll_n_u16^⚠Experimentalneon

有符号左移长

vshll_n_u32^⚠Experimentalneon

有符号左移长

vshlq_n_s8^⚠Experimentalneon

左移

vshlq_n_s16^⚠Experimentalneon

左移

vshlq_n_s32^⚠Experimentalneon

左移

vshlq_n_s64^⚠Experimentalneon

左移

vshlq_n_u8^⚠Experimentalneon

左移

vshlq_n_u16^⚠Experimentalneon

左移

vshlq_n_u32^⚠Experimentalneon

左移

vshlq_n_u64^⚠Experimentalneon

左移

vshlq_s8^⚠Experimentalneon

有符号左移

vshlq_s16^⚠Experimentalneon

有符号左移

vshlq_s32^⚠Experimentalneon

有符号左移

vshlq_s64^⚠Experimentalneon

有符号左移

vshlq_u8^⚠Experimentalneon

无符号左移

vshlq_u16^⚠Experimentalneon

无符号左移

vshlq_u32^⚠Experimentalneon

无符号左移

vshlq_u64^⚠Experimentalneon

无符号左移

vshr_n_s8^⚠Experimentalneon

右移

vshr_n_s16^⚠Experimentalneon

右移

vshr_n_s32^⚠Experimentalneon

右移

vshr_n_s64^⚠Experimentalneon

右移

vshr_n_u8^⚠Experimentalneon

右移

vshr_n_u16^⚠Experimentalneon

右移

vshr_n_u32^⚠Experimentalneon

右移

vshr_n_u64^⚠Experimentalneon

右移

vshrn_n_s16^⚠Experimentalneon

右移 narrow

vshrn_n_s32^⚠Experimentalneon

右移 narrow

vshrn_n_s64^⚠Experimentalneon

右移 narrow

vshrn_n_u16^⚠Experimentalneon

右移 narrow

vshrn_n_u32^⚠Experimentalneon

右移 narrow

vshrn_n_u64^⚠Experimentalneon

右移 narrow

vshrq_n_s8^⚠Experimentalneon

右移

vshrq_n_s16^⚠Experimentalneon

右移

vshrq_n_s32^⚠Experimentalneon

右移

vshrq_n_s64^⚠Experimentalneon

右移

vshrq_n_u8^⚠Experimentalneon

右移

vshrq_n_u16^⚠Experimentalneon

右移

vshrq_n_u32^⚠Experimentalneon

右移

vshrq_n_u64^⚠Experimentalneon

右移

vsli_n_p8^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_p16^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_p64^⚠Experimentalneon,v7,aes

左移并插入 (immediate)

vsli_n_s8^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_s16^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_s32^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_s64^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_u8^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_u16^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_u32^⚠Experimentalneon,v7

左移并插入 (immediate)

vsli_n_u64^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_p8^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_p16^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_p64^⚠Experimentalneon,v7,aes

左移并插入 (immediate)

vsliq_n_s8^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_s16^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_s32^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_s64^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_u8^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_u16^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_u32^⚠Experimentalneon,v7

左移并插入 (immediate)

vsliq_n_u64^⚠Experimentalneon,v7

左移并插入 (immediate)

vsra_n_s8^⚠Experimentalneon

有符号右移并累加

vsra_n_s16^⚠Experimentalneon

有符号右移并累加

vsra_n_s32^⚠Experimentalneon

有符号右移并累加

vsra_n_s64^⚠Experimentalneon

有符号右移并累加

vsra_n_u8^⚠Experimentalneon

无符号右移并累加

vsra_n_u16^⚠Experimentalneon

无符号右移并累加

vsra_n_u32^⚠Experimentalneon

无符号右移并累加

vsra_n_u64^⚠Experimentalneon

无符号右移并累加

vsraq_n_s8^⚠Experimentalneon

有符号右移并累加

vsraq_n_s16^⚠Experimentalneon

有符号右移并累加

vsraq_n_s32^⚠Experimentalneon

有符号右移并累加

vsraq_n_s64^⚠Experimentalneon

有符号右移并累加

vsraq_n_u8^⚠Experimentalneon

无符号右移并累加

vsraq_n_u16^⚠Experimentalneon

无符号右移并累加

vsraq_n_u32^⚠Experimentalneon

无符号右移并累加

vsraq_n_u64^⚠Experimentalneon

无符号右移并累加

vsri_n_p8^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_p16^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_p64^⚠Experimentalneon,v7,aes

右移并插入 (immediate)

vsri_n_s8^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_s16^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_s32^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_s64^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_u8^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_u16^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_u32^⚠Experimentalneon,v7

右移并插入 (immediate)

vsri_n_u64^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_p8^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_p16^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_p64^⚠Experimentalneon,v7,aes

右移并插入 (immediate)

vsriq_n_s8^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_s16^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_s32^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_s64^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_u8^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_u16^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_u32^⚠Experimentalneon,v7

右移并插入 (immediate)

vsriq_n_u64^⚠Experimentalneon,v7

右移并插入 (immediate)

vst1_f32^⚠Experimentalneon,v7

vst1_lane_f32^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_p8^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_p16^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_p64^⚠Experimentalneon,aes

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_s8^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_s16^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_s32^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_s64^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_u8^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_u16^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_u32^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_lane_u64^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1_p8^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_p8_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p8_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p8_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p16^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_p16_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p16_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p16_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p64^⚠Experimentalneon,aes,v8

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_p64_x2^⚠Experimentalneon,aes

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p64_x3^⚠Experimentalneon,aes

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_p64_x4^⚠Experimentalneon,aes

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_s8^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_s16^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_s32^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_s64^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_u8^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_u8_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u8_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u8_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u16^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_u16_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u16_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u16_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u32^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_u32_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u32_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u32_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u64^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1_u64_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u64_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1_u64_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_f32^⚠Experimentalneon,v7

vst1q_lane_f32^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_p8^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_p16^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_p64^⚠Experimentalneon,aes

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_s8^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_s16^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_s32^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_s64^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_u8^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_u16^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_u32^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_lane_u64^⚠Experimentalneon

从一个、两个、三个或四个寄存器中存储多个单一元素结构

vst1q_p8^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_p8_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p8_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p8_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p16^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_p16_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p16_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p16_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p64^⚠Experimentalneon,aes,v8

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_p64_x2^⚠Experimentalneon,aes

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p64_x3^⚠Experimentalneon,aes

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_p64_x4^⚠Experimentalneon,aes

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_s8^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_s16^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_s32^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_s64^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_u8^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_u8_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u8_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u8_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u16^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_u16_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u16_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u16_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u32^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_u32_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u32_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u32_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u64^⚠Experimentalneon,v7

从一个、两个、三个或四个寄存器中存储多个单一元素结构。

vst1q_u64_x2^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u64_x3^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst1q_u64_x4^⚠Experimentalneon

将多个单一元素结构存储到一个、两个、三个或四个寄存器中

vst2_lane_p8^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_lane_p16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_lane_u8^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_lane_u16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_lane_u32^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_p8^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_p16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_p64^⚠Experimentalneon,aes

存储来自两个寄存器的多个 2 元素结构

vst2_u8^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_u16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_u32^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2_u64^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_lane_p16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_lane_u16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_lane_u32^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_p8^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_p16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_u8^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_u16^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst2q_u32^⚠Experimentalneon

存储来自两个寄存器的多个 2 元素结构

vst3_lane_p8^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_lane_p16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_lane_u8^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_lane_u16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_lane_u32^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_p8^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_p16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_p64^⚠Experimentalneon,aes

存储来自三个寄存器的多个 3 元素结构

vst3_u8^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_u16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_u32^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3_u64^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_lane_p16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_lane_u16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_lane_u32^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_p8^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_p16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_u8^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_u16^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst3q_u32^⚠Experimentalneon

存储来自三个寄存器的多个 3 元素结构

vst4_lane_p8^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_lane_p16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_lane_u8^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_lane_u16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_lane_u32^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_p8^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_p16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_p64^⚠Experimentalneon,aes

存储来自四个寄存器的多个 4 元素结构

vst4_u8^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_u16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_u32^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4_u64^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_lane_p16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_lane_u16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_lane_u32^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_p8^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_p16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_u8^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_u16^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vst4q_u32^⚠Experimentalneon

存储来自四个寄存器的多个 4 元素结构

vstrq_p128^⚠Experimentalneon

存储 SIMD&FP 寄存器 (immediate 偏移量)

vsub_f32^⚠Experimentalneon

Subtract

vsub_s8^⚠Experimentalneon

Subtract

vsub_s16^⚠Experimentalneon

Subtract

vsub_s32^⚠Experimentalneon

Subtract

vsub_s64^⚠Experimentalneon

Subtract

vsub_u8^⚠Experimentalneon

Subtract

vsub_u16^⚠Experimentalneon

Subtract

vsub_u32^⚠Experimentalneon

Subtract

vsub_u64^⚠Experimentalneon

Subtract

vsubhn_high_s16^⚠Experimentalneon

减去返回 high narrow

vsubhn_high_s32^⚠Experimentalneon

减去返回 high narrow

vsubhn_high_s64^⚠Experimentalneon

减去返回 high narrow

vsubhn_high_u16^⚠Experimentalneon

减去返回 high narrow

vsubhn_high_u32^⚠Experimentalneon

减去返回 high narrow

vsubhn_high_u64^⚠Experimentalneon

减去返回 high narrow

vsubhn_s16^⚠Experimentalneon

减去返回 high narrow

vsubhn_s32^⚠Experimentalneon

减去返回 high narrow

vsubhn_s64^⚠Experimentalneon

减去返回 high narrow

vsubhn_u16^⚠Experimentalneon

减去返回 high narrow

vsubhn_u32^⚠Experimentalneon

减去返回 high narrow

vsubhn_u64^⚠Experimentalneon

减去返回 high narrow

vsubl_s8^⚠Experimentalneon

有符号减长

vsubl_s16^⚠Experimentalneon

有符号减长

vsubl_s32^⚠Experimentalneon

有符号减长

vsubl_u8^⚠Experimentalneon

无符号减长

vsubl_u16^⚠Experimentalneon

无符号减长

vsubl_u32^⚠Experimentalneon

无符号减长

vsubq_f32^⚠Experimentalneon

Subtract

vsubq_s8^⚠Experimentalneon

Subtract

vsubq_s16^⚠Experimentalneon

Subtract

vsubq_s32^⚠Experimentalneon

Subtract

vsubq_s64^⚠Experimentalneon

Subtract

vsubq_u8^⚠Experimentalneon

Subtract

vsubq_u16^⚠Experimentalneon

Subtract

vsubq_u32^⚠Experimentalneon

Subtract

vsubq_u64^⚠Experimentalneon

Subtract

vsubw_s8^⚠Experimentalneon

有符号减宽

vsubw_s16^⚠Experimentalneon

有符号减宽

vsubw_s32^⚠Experimentalneon

有符号减宽

vsubw_u8^⚠Experimentalneon

无符号减宽

vsubw_u16^⚠Experimentalneon

无符号减宽

vsubw_u32^⚠Experimentalneon

无符号减宽

vtbl1_p8^⚠Experimentalneon,v7

查表

vtbl1_s8^⚠Experimentalneon,v7

查表

vtbl1_u8^⚠Experimentalneon,v7

查表

vtbl2_p8^⚠Experimentalneon,v7

查表

vtbl2_s8^⚠Experimentalneon,v7

查表

vtbl2_u8^⚠Experimentalneon,v7

查表

vtbl3_p8^⚠Experimentalneon,v7

查表

vtbl3_s8^⚠Experimentalneon,v7

查表

vtbl3_u8^⚠Experimentalneon,v7

查表

vtbl4_p8^⚠Experimentalneon,v7

查表

vtbl4_s8^⚠Experimentalneon,v7

查表

vtbl4_u8^⚠Experimentalneon,v7

查表

vtbx1_p8^⚠Experimentalneon,v7

扩展表查询

vtbx1_s8^⚠Experimentalneon,v7

扩展表查询

vtbx1_u8^⚠Experimentalneon,v7

扩展表查询

vtbx2_p8^⚠Experimentalneon,v7

扩展表查询

vtbx2_s8^⚠Experimentalneon,v7

扩展表查询

vtbx2_u8^⚠Experimentalneon,v7

扩展表查询

vtbx3_p8^⚠Experimentalneon,v7

扩展表查询

vtbx3_s8^⚠Experimentalneon,v7

扩展表查询

vtbx3_u8^⚠Experimentalneon,v7

扩展表查询

vtbx4_p8^⚠Experimentalneon,v7

扩展表查询

vtbx4_s8^⚠Experimentalneon,v7

扩展表查询

vtbx4_u8^⚠Experimentalneon,v7

扩展表查询

vtrn_f32^⚠Experimentalneon

转置元素

vtrn_p8^⚠Experimentalneon

转置元素

vtrn_p16^⚠Experimentalneon

转置元素

vtrn_s8^⚠Experimentalneon

转置元素

vtrn_s16^⚠Experimentalneon

转置元素

vtrn_s32^⚠Experimentalneon

转置元素

vtrn_u8^⚠Experimentalneon

转置元素

vtrn_u16^⚠Experimentalneon

转置元素

vtrn_u32^⚠Experimentalneon

转置元素

vtrnq_f32^⚠Experimentalneon

转置元素

vtrnq_p8^⚠Experimentalneon

转置元素

vtrnq_p16^⚠Experimentalneon

转置元素

vtrnq_s8^⚠Experimentalneon

转置元素

vtrnq_s16^⚠Experimentalneon

转置元素

vtrnq_s32^⚠Experimentalneon

转置元素

vtrnq_u8^⚠Experimentalneon

转置元素

vtrnq_u16^⚠Experimentalneon

转置元素

vtrnq_u32^⚠Experimentalneon

转置元素

vtst_p8^⚠Experimentalneon

有符号比较按位测试位非零

vtst_s8^⚠Experimentalneon

有符号比较按位测试位非零

vtst_s16^⚠Experimentalneon

有符号比较按位测试位非零

vtst_s32^⚠Experimentalneon

有符号比较按位测试位非零

vtst_u8^⚠Experimentalneon

无符号比较按位测试位非零

vtst_u16^⚠Experimentalneon

无符号比较按位测试位非零

vtst_u32^⚠Experimentalneon

无符号比较按位测试位非零

vtstq_p8^⚠Experimentalneon

有符号比较按位测试位非零

vtstq_s8^⚠Experimentalneon

有符号比较按位测试位非零

vtstq_s16^⚠Experimentalneon

有符号比较按位测试位非零

vtstq_s32^⚠Experimentalneon

有符号比较按位测试位非零

vtstq_u8^⚠Experimentalneon

无符号比较按位测试位非零

vtstq_u16^⚠Experimentalneon

无符号比较按位测试位非零

vtstq_u32^⚠Experimentalneon

无符号比较按位测试位非零

vusmmlaq_s32^⚠Experimentalneon

无符号和有符号 8 位整数矩阵乘法累加

vuzp_f32^⚠Experimentalneon

解压缩 vectors

vuzp_p8^⚠Experimentalneon

解压缩 vectors

vuzp_p16^⚠Experimentalneon

解压缩 vectors

vuzp_s8^⚠Experimentalneon

解压缩 vectors

vuzp_s16^⚠Experimentalneon

解压缩 vectors

vuzp_s32^⚠Experimentalneon

解压缩 vectors

vuzp_u8^⚠Experimentalneon

解压缩 vectors

vuzp_u16^⚠Experimentalneon

解压缩 vectors

vuzp_u32^⚠Experimentalneon

解压缩 vectors

vuzpq_f32^⚠Experimentalneon

解压缩 vectors

vuzpq_p8^⚠Experimentalneon

解压缩 vectors

vuzpq_p16^⚠Experimentalneon

解压缩 vectors

vuzpq_s8^⚠Experimentalneon

解压缩 vectors

vuzpq_s16^⚠Experimentalneon

解压缩 vectors

vuzpq_s32^⚠Experimentalneon

解压缩 vectors

vuzpq_u8^⚠Experimentalneon

解压缩 vectors

vuzpq_u16^⚠Experimentalneon

解压缩 vectors

vuzpq_u32^⚠Experimentalneon

解压缩 vectors

vzip_f32^⚠Experimentalneon

Zip vectors

vzip_p8^⚠Experimentalneon

Zip vectors

vzip_p16^⚠Experimentalneon

Zip vectors

vzip_s8^⚠Experimentalneon

Zip vectors

vzip_s16^⚠Experimentalneon

Zip vectors

vzip_s32^⚠Experimentalneon

Zip vectors

vzip_u8^⚠Experimentalneon

Zip vectors

vzip_u16^⚠Experimentalneon

Zip vectors

vzip_u32^⚠Experimentalneon

Zip vectors

vzipq_f32^⚠Experimentalneon

Zip vectors

vzipq_p8^⚠Experimentalneon

Zip vectors

vzipq_p16^⚠Experimentalneon

Zip vectors

vzipq_s8^⚠Experimentalneon

Zip vectors

vzipq_s16^⚠Experimentalneon

Zip vectors

vzipq_s32^⚠Experimentalneon

Zip vectors

vzipq_u8^⚠Experimentalneon

Zip vectors

vzipq_u16^⚠Experimentalneon

Zip vectors

vzipq_u32^⚠Experimentalneon

Zip vectors