# Module core::arch::aarch64
[−][src]

🔬 This is a nightly-only experimental API. (`stdsimd` #27731)
This is supported on AArch64 only.
Expand description

Platform-specific intrinsics for the `aarch64` platform.

See the module documentation for more details.

## Structs

APSR Experimental

Application Program Status Register

SY Experimental

Full system is the required shareability domain, reads and writes are the required access types

float32x2_t Experimental

ARM-specific 64-bit wide vector of two packed `f32`.

float32x4_t Experimental

ARM-specific 128-bit wide vector of four packed `f32`.

float64x1_t Experimental

ARM-specific 64-bit wide vector of one packed `f64`.

float64x2_t Experimental

ARM-specific 128-bit wide vector of two packed `f64`.

int8x8_t Experimental

ARM-specific 64-bit wide vector of eight packed `i8`.

int8x8x2_t Experimental

ARM-specific type containing two `int8x8_t` vectors.

int8x8x3_t Experimental

ARM-specific type containing three `int8x8_t` vectors.

int8x8x4_t Experimental

ARM-specific type containing four `int8x8_t` vectors.

int8x16_t Experimental

ARM-specific 128-bit wide vector of sixteen packed `i8`.

int8x16x2_t Experimental

ARM-specific type containing two `int8x16_t` vectors.

int8x16x3_t Experimental

ARM-specific type containing three `int8x16_t` vectors.

int8x16x4_t Experimental

ARM-specific type containing four `int8x16_t` vectors.

int16x4_t Experimental

ARM-specific 64-bit wide vector of four packed `i16`.

int16x8_t Experimental

ARM-specific 128-bit wide vector of eight packed `i16`.

int32x2_t Experimental

ARM-specific 64-bit wide vector of two packed `i32`.

int32x4_t Experimental

ARM-specific 128-bit wide vector of four packed `i32`.

int64x1_t Experimental

ARM-specific 64-bit wide vector of one packed `i64`.

int64x2_t Experimental

ARM-specific 128-bit wide vector of two packed `i64`.

poly8x8_t Experimental

ARM-specific 64-bit wide polynomial vector of eight packed `p8`.

poly8x8x2_t Experimental

ARM-specific type containing two `poly8x8_t` vectors.

poly8x8x3_t Experimental

ARM-specific type containing three `poly8x8_t` vectors.

poly8x8x4_t Experimental

ARM-specific type containing four `poly8x8_t` vectors.

poly8x16_t Experimental

ARM-specific 128-bit wide vector of sixteen packed `p8`.

poly8x16x2_t Experimental

ARM-specific type containing two `poly8x16_t` vectors.

poly8x16x3_t Experimental

ARM-specific type containing three `poly8x16_t` vectors.

poly8x16x4_t Experimental

ARM-specific type containing four `poly8x16_t` vectors.

poly16x4_t Experimental

ARM-specific 64-bit wide vector of four packed `p16`.

poly16x8_t Experimental

ARM-specific 128-bit wide vector of eight packed `p16`.

poly64x1_t Experimental

ARM-specific 64-bit wide vector of one packed `p64`.

poly64x2_t Experimental

ARM-specific 128-bit wide vector of two packed `p64`.

uint8x8_t Experimental

ARM-specific 64-bit wide vector of eight packed `u8`.

uint8x8x2_t Experimental

ARM-specific type containing two `uint8x8_t` vectors.

uint8x8x3_t Experimental

ARM-specific type containing three `uint8x8_t` vectors.

uint8x8x4_t Experimental

ARM-specific type containing four `uint8x8_t` vectors.

uint8x16_t Experimental

ARM-specific 128-bit wide vector of sixteen packed `u8`.

uint8x16x2_t Experimental

ARM-specific type containing two `uint8x16_t` vectors.

uint8x16x3_t Experimental

ARM-specific type containing three `uint8x16_t` vectors.

uint8x16x4_t Experimental

ARM-specific type containing four `uint8x16_t` vectors.

uint16x4_t Experimental

ARM-specific 64-bit wide vector of four packed `u16`.

uint16x8_t Experimental

ARM-specific 128-bit wide vector of eight packed `u16`.

uint32x2_t Experimental

ARM-specific 64-bit wide vector of two packed `u32`.

uint32x4_t Experimental

ARM-specific 128-bit wide vector of four packed `u32`.

uint64x1_t Experimental

ARM-specific 64-bit wide vector of one packed `u64`.

uint64x2_t Experimental

ARM-specific 128-bit wide vector of two packed `u64`.

## Constants

_PREFETCH_LOCALITY0 Experimental

See `prefetch`.

_PREFETCH_LOCALITY1 Experimental

See `prefetch`.

_PREFETCH_LOCALITY2 Experimental

See `prefetch`.

_PREFETCH_LOCALITY3 Experimental

See `prefetch`.

_PREFETCH_READ Experimental

See `prefetch`.

_PREFETCH_WRITE Experimental

See `prefetch`.

_TMFAILURE_CNCL Experimental

Transaction executed a TCANCEL instruction

_TMFAILURE_DBG Experimental

Transaction aborted due to a debug trap.

_TMFAILURE_ERR Experimental

Transaction aborted because a non-permissible operation was attempted

_TMFAILURE_IMP Experimental

Fallback error type for any other reason

_TMFAILURE_INT Experimental

Transaction failed from interrupt

_TMFAILURE_MEM Experimental

Transaction aborted because a conflict occurred

_TMFAILURE_NEST Experimental

Transaction aborted due to transactional nesting level was exceeded

_TMFAILURE_REASON Experimental

Extraction mask for failure reason

_TMFAILURE_RTRY Experimental

Transaction retry is possible.

_TMFAILURE_SIZE Experimental

Transaction aborted due to read or write set limit was exceeded

_TMFAILURE_TRIVIAL Experimental

Indicates a TRIVIAL version of TM is available

_TMSTART_SUCCESS Experimental

Transaction successfully started.

## Functions

__breakpoint⚠Experimental

Inserts a breakpoint instruction.

__crc32b⚠Experimental `crc`

CRC32 single round checksum for bytes (8 bits).

__crc32cb⚠Experimental `crc`

CRC32-C single round checksum for bytes (8 bits).

__crc32cd⚠Experimental `crc`

CRC32-C single round checksum for quad words (64 bits).

__crc32ch⚠Experimental `crc`

CRC32-C single round checksum for half words (16 bits).

__crc32cw⚠Experimental `crc`

CRC32-C single round checksum for words (32 bits).

__crc32d⚠Experimental `crc`

CRC32 single round checksum for quad words (64 bits).

__crc32h⚠Experimental `crc`

CRC32 single round checksum for half words (16 bits).

__crc32w⚠Experimental `crc`

CRC32 single round checksum for words (32 bits).

__dmb⚠Experimental

Generates a DMB (data memory barrier) instruction or equivalent CP15 instruction.

__dsb⚠Experimental

Generates a DSB (data synchronization barrier) instruction or equivalent CP15 instruction.

__isb⚠Experimental

Generates an ISB (instruction synchronization barrier) instruction or equivalent CP15 instruction.

__nop⚠Experimental

Generates an unspecified no-op instruction.

__rsr⚠Experimental

Reads a 32-bit system register

__rsrp⚠Experimental

Reads a system register containing an address

__sev⚠Experimental

Generates a SEV (send a global event) hint instruction.

__sevl⚠Experimental

Generates a send a local event hint instruction.

__tcancel⚠Experimental `tme`

Cancels the current transaction and discards all state modifications that were performed transactionally.

__tcommit⚠Experimental `tme`

Commits the current transaction. For a nested transaction, the only effect is that the transactional nesting depth is decreased. For an outer transaction, the state modifications performed transactionally are committed to the architectural state.

__tstart⚠Experimental `tme`

Starts a new transaction. When the transaction starts successfully the return value is 0. If the transaction fails, all state modifications are discarded and a cause of the failure is encoded in the return value.

__ttest⚠Experimental `tme`

Tests if executing inside a transaction. If no transaction is currently executing, the return value is 0. Otherwise, this intrinsic returns the depth of the transaction.

__wfe⚠Experimental

Generates a WFE (wait for event) hint instruction, or nothing.

__wfi⚠Experimental

Generates a WFI (wait for interrupt) hint instruction, or nothing.

__wsr⚠Experimental

Writes a 32-bit system register

__wsrp⚠Experimental

Writes a system register containing an address

__yield⚠Experimental

Generates a YIELD hint instruction.

_cls_u32⚠Experimental

Counts the leading most significant bits set.

_cls_u64⚠Experimental

Counts the leading most significant bits set.

_clz_u64⚠Experimental

Count Leading Zeros.

_prefetch⚠Experimental

Fetch the cache line that contains address `p` using the given `RW` and `LOCALITY`.

_rbit_u64⚠Experimental

Reverse the bit order.

_rev_u64⚠Experimental

Reverse the order of the bytes.

brk⚠Experimental

Generates the trap instruction `BRK 1`

vaba_s8⚠Experimental `neon`
vaba_s16⚠Experimental `neon`
vaba_s32⚠Experimental `neon`
vaba_u8⚠Experimental `neon`
vaba_u16⚠Experimental `neon`
vaba_u32⚠Experimental `neon`
vabal_high_s8⚠Experimental `neon`

Signed Absolute difference and Accumulate Long

vabal_high_s16⚠Experimental `neon`

Signed Absolute difference and Accumulate Long

vabal_high_s32⚠Experimental `neon`

Signed Absolute difference and Accumulate Long

vabal_high_u8⚠Experimental `neon`

Unsigned Absolute difference and Accumulate Long

vabal_high_u16⚠Experimental `neon`

Unsigned Absolute difference and Accumulate Long

vabal_high_u32⚠Experimental `neon`

Unsigned Absolute difference and Accumulate Long

vabal_s8⚠Experimental `neon`

Signed Absolute difference and Accumulate Long

vabal_s16⚠Experimental `neon`

Signed Absolute difference and Accumulate Long

vabal_s32⚠Experimental `neon`

Signed Absolute difference and Accumulate Long

vabal_u8⚠Experimental `neon`

Unsigned Absolute difference and Accumulate Long

vabal_u16⚠Experimental `neon`

Unsigned Absolute difference and Accumulate Long

vabal_u32⚠Experimental `neon`

Unsigned Absolute difference and Accumulate Long

vabaq_s8⚠Experimental `neon`
vabaq_s16⚠Experimental `neon`
vabaq_s32⚠Experimental `neon`
vabaq_u8⚠Experimental `neon`
vabaq_u16⚠Experimental `neon`
vabaq_u32⚠Experimental `neon`
vabd_f32⚠Experimental `neon`

Absolute difference between the arguments of Floating

vabd_f64⚠Experimental `neon`

Absolute difference between the arguments of Floating

vabd_s8⚠Experimental `neon`

Absolute difference between the arguments

vabd_s16⚠Experimental `neon`

Absolute difference between the arguments

vabd_s32⚠Experimental `neon`

Absolute difference between the arguments

vabd_u8⚠Experimental `neon`

Absolute difference between the arguments

vabd_u16⚠Experimental `neon`

Absolute difference between the arguments

vabd_u32⚠Experimental `neon`

Absolute difference between the arguments

vabdl_high_s8⚠Experimental `neon`

Signed Absolute difference Long

vabdl_high_s16⚠Experimental `neon`

Signed Absolute difference Long

vabdl_high_s32⚠Experimental `neon`

Signed Absolute difference Long

vabdl_high_u8⚠Experimental `neon`

Unsigned Absolute difference Long

vabdl_high_u16⚠Experimental `neon`

Unsigned Absolute difference Long

vabdl_high_u32⚠Experimental `neon`

Unsigned Absolute difference Long

vabdl_s8⚠Experimental `neon`

Signed Absolute difference Long

vabdl_s16⚠Experimental `neon`

Signed Absolute difference Long

vabdl_s32⚠Experimental `neon`

Signed Absolute difference Long

vabdl_u8⚠Experimental `neon`

Unsigned Absolute difference Long

vabdl_u16⚠Experimental `neon`

Unsigned Absolute difference Long

vabdl_u32⚠Experimental `neon`

Unsigned Absolute difference Long

vabdq_f32⚠Experimental `neon`

Absolute difference between the arguments of Floating

vabdq_f64⚠Experimental `neon`

Absolute difference between the arguments of Floating

vabdq_s8⚠Experimental `neon`

Absolute difference between the arguments

vabdq_s16⚠Experimental `neon`

Absolute difference between the arguments

vabdq_s32⚠Experimental `neon`

Absolute difference between the arguments

vabdq_u8⚠Experimental `neon`

Absolute difference between the arguments

vabdq_u16⚠Experimental `neon`

Absolute difference between the arguments

vabdq_u32⚠Experimental `neon`

Absolute difference between the arguments

vabs_f32⚠Experimental `neon`

Floating-point absolute value

vabs_f64⚠Experimental `neon`

Floating-point absolute value

vabs_s8⚠Experimental `neon`

Absolute value (wrapping).

vabs_s16⚠Experimental `neon`

Absolute value (wrapping).

vabs_s32⚠Experimental `neon`

Absolute value (wrapping).

vabs_s64⚠Experimental `neon`

Absolute Value (wrapping).

vabsd_s64⚠Experimental `neon`

Absolute Value (wrapping).

vabsq_f32⚠Experimental `neon`

Floating-point absolute value

vabsq_f64⚠Experimental `neon`

Floating-point absolute value

vabsq_s8⚠Experimental `neon`

Absolute value (wrapping).

vabsq_s16⚠Experimental `neon`

Absolute value (wrapping).

vabsq_s32⚠Experimental `neon`

Absolute value (wrapping).

vabsq_s64⚠Experimental `neon`

Absolute Value (wrapping).

vadd_f32⚠Experimental `neon`

Vector add.

vadd_f64⚠Experimental `neon`

Vector add.

vadd_s8⚠Experimental `neon`

Vector add.

vadd_s16⚠Experimental `neon`

Vector add.

vadd_s32⚠Experimental `neon`

Vector add.

vadd_s64⚠Experimental `neon`

Vector add.

vadd_u8⚠Experimental `neon`

Vector add.

vadd_u16⚠Experimental `neon`

Vector add.

vadd_u32⚠Experimental `neon`

Vector add.

vadd_u64⚠Experimental `neon`

Vector add.

vaddd_s64⚠Experimental `neon`

Vector add.

vaddd_u64⚠Experimental `neon`

Vector add.

vaddhn_high_s16⚠Experimental `neon`

Add returning High Narrow (high half).

vaddhn_high_s32⚠Experimental `neon`

Add returning High Narrow (high half).

vaddhn_high_s64⚠Experimental `neon`

Add returning High Narrow (high half).

vaddhn_high_u16⚠Experimental `neon`

Add returning High Narrow (high half).

vaddhn_high_u32⚠Experimental `neon`

Add returning High Narrow (high half).

vaddhn_high_u64⚠Experimental `neon`

Add returning High Narrow (high half).

vaddhn_s16⚠Experimental `neon`

Add returning High Narrow.

vaddhn_s32⚠Experimental `neon`

Add returning High Narrow.

vaddhn_s64⚠Experimental `neon`

Add returning High Narrow.

vaddhn_u16⚠Experimental `neon`

Add returning High Narrow.

vaddhn_u32⚠Experimental `neon`

Add returning High Narrow.

vaddhn_u64⚠Experimental `neon`

Add returning High Narrow.

vaddl_high_s8⚠Experimental `neon`

Signed Add Long (vector, high half).

vaddl_high_s16⚠Experimental `neon`

Signed Add Long (vector, high half).

vaddl_high_s32⚠Experimental `neon`

Signed Add Long (vector, high half).

vaddl_high_u8⚠Experimental `neon`

Unsigned Add Long (vector, high half).

vaddl_high_u16⚠Experimental `neon`

Unsigned Add Long (vector, high half).

vaddl_high_u32⚠Experimental `neon`

Unsigned Add Long (vector, high half).

vaddl_s8⚠Experimental `neon`

Signed Add Long (vector).

vaddl_s16⚠Experimental `neon`

Signed Add Long (vector).

vaddl_s32⚠Experimental `neon`

Signed Add Long (vector).

vaddl_u8⚠Experimental `neon`

Unsigned Add Long (vector).

vaddl_u16⚠Experimental `neon`

Unsigned Add Long (vector).

vaddl_u32⚠Experimental `neon`

Unsigned Add Long (vector).

vaddlv_s8⚠Experimental `neon`

Signed Add Long across Vector

vaddlv_s16⚠Experimental `neon`

Signed Add Long across Vector

vaddlv_s32⚠Experimental `neon`

Signed Add Long across Vector

vaddlv_u8⚠Experimental `neon`

Unsigned Add Long across Vector

vaddlv_u16⚠Experimental `neon`

Unsigned Add Long across Vector

vaddlv_u32⚠Experimental `neon`

Unsigned Add Long across Vector

vaddlvq_s8⚠Experimental `neon`

Signed Add Long across Vector

vaddlvq_s16⚠Experimental `neon`

Signed Add Long across Vector

vaddlvq_s32⚠Experimental `neon`

Signed Add Long across Vector

vaddlvq_u8⚠Experimental `neon`

Unsigned Add Long across Vector

vaddlvq_u16⚠Experimental `neon`

Unsigned Add Long across Vector

vaddlvq_u32⚠Experimental `neon`

Unsigned Add Long across Vector

vaddq_f32⚠Experimental `neon`

Vector add.

vaddq_f64⚠Experimental `neon`

Vector add.

vaddq_s8⚠Experimental `neon`

Vector add.

vaddq_s16⚠Experimental `neon`

Vector add.

vaddq_s32⚠Experimental `neon`

Vector add.

vaddq_s64⚠Experimental `neon`

Vector add.

vaddq_u8⚠Experimental `neon`

Vector add.

vaddq_u16⚠Experimental `neon`

Vector add.

vaddq_u32⚠Experimental `neon`

Vector add.

vaddq_u64⚠Experimental `neon`

Vector add.

vaddv_s8⚠Experimental `neon`

Add across vector

vaddv_s16⚠Experimental `neon`

Add across vector

vaddv_s32⚠Experimental `neon`

Add across vector

vaddv_u8⚠Experimental `neon`

Add across vector

vaddv_u16⚠Experimental `neon`

Add across vector

vaddv_u32⚠Experimental `neon`

Add across vector

vaddvq_s8⚠Experimental `neon`

Add across vector

vaddvq_s16⚠Experimental `neon`

Add across vector

vaddvq_s32⚠Experimental `neon`

Add across vector

vaddvq_s64⚠Experimental `neon`

Add across vector

vaddvq_u8⚠Experimental `neon`

Add across vector

vaddvq_u16⚠Experimental `neon`

Add across vector

vaddvq_u32⚠Experimental `neon`

Add across vector

vaddvq_u64⚠Experimental `neon`

Add across vector

vaddw_high_s8⚠Experimental `neon`

Signed Add Wide (high half).

vaddw_high_s16⚠Experimental `neon`

Signed Add Wide (high half).

vaddw_high_s32⚠Experimental `neon`

Signed Add Wide (high half).

vaddw_high_u8⚠Experimental `neon`

Unsigned Add Wide (high half).

vaddw_high_u16⚠Experimental `neon`

Unsigned Add Wide (high half).

vaddw_high_u32⚠Experimental `neon`

Unsigned Add Wide (high half).

vaddw_s8⚠Experimental `neon`

Signed Add Wide.

vaddw_s16⚠Experimental `neon`

Signed Add Wide.

vaddw_s32⚠Experimental `neon`

Signed Add Wide.

vaddw_u8⚠Experimental `neon`

Unsigned Add Wide.

vaddw_u16⚠Experimental `neon`

Unsigned Add Wide.

vaddw_u32⚠Experimental `neon`

Unsigned Add Wide.

vaesdq_u8⚠Experimental `aes`

AES single round decryption.

vaeseq_u8⚠Experimental `aes`

AES single round encryption.

vaesimcq_u8⚠Experimental `aes`

AES inverse mix columns.

vaesmcq_u8⚠Experimental `aes`

AES mix columns.

vand_s8⚠Experimental `neon`

Vector bitwise and

vand_s16⚠Experimental `neon`

Vector bitwise and

vand_s32⚠Experimental `neon`

Vector bitwise and

vand_s64⚠Experimental `neon`

Vector bitwise and

vand_u8⚠Experimental `neon`

Vector bitwise and

vand_u16⚠Experimental `neon`

Vector bitwise and

vand_u32⚠Experimental `neon`

Vector bitwise and

vand_u64⚠Experimental `neon`

Vector bitwise and

vandq_s8⚠Experimental `neon`

Vector bitwise and

vandq_s16⚠Experimental `neon`

Vector bitwise and

vandq_s32⚠Experimental `neon`

Vector bitwise and

vandq_s64⚠Experimental `neon`

Vector bitwise and

vandq_u8⚠Experimental `neon`

Vector bitwise and

vandq_u16⚠Experimental `neon`

Vector bitwise and

vandq_u32⚠Experimental `neon`

Vector bitwise and

vandq_u64⚠Experimental `neon`

Vector bitwise and

vbic_s8⚠Experimental `neon`

Vector bitwise bit clear

vbic_s16⚠Experimental `neon`

Vector bitwise bit clear

vbic_s32⚠Experimental `neon`

Vector bitwise bit clear

vbic_s64⚠Experimental `neon`

Vector bitwise bit clear

vbic_u8⚠Experimental `neon`

Vector bitwise bit clear

vbic_u16⚠Experimental `neon`

Vector bitwise bit clear

vbic_u32⚠Experimental `neon`

Vector bitwise bit clear

vbic_u64⚠Experimental `neon`

Vector bitwise bit clear

vbicq_s8⚠Experimental `neon`

Vector bitwise bit clear

vbicq_s16⚠Experimental `neon`

Vector bitwise bit clear

vbicq_s32⚠Experimental `neon`

Vector bitwise bit clear

vbicq_s64⚠Experimental `neon`

Vector bitwise bit clear

vbicq_u8⚠Experimental `neon`

Vector bitwise bit clear

vbicq_u16⚠Experimental `neon`

Vector bitwise bit clear

vbicq_u32⚠Experimental `neon`

Vector bitwise bit clear

vbicq_u64⚠Experimental `neon`

Vector bitwise bit clear

vbsl_f32⚠Experimental `neon`

Bitwise Select.

vbsl_f64⚠Experimental `neon`

Bitwise Select instructions. This instruction sets each bit in the destination SIMD&FP register to the corresponding bit from the first source SIMD&FP register when the original destination bit was 1, otherwise from the second source SIMD&FP register.

vbsl_p8⚠Experimental `neon`

Bitwise Select.

vbsl_p16⚠Experimental `neon`

Bitwise Select.

vbsl_p64⚠Experimental `neon`

Bitwise Select.

vbsl_s8⚠Experimental `neon`

Bitwise Select instructions. This instruction sets each bit in the destination SIMD&FP register to the corresponding bit from the first source SIMD&FP register when the original destination bit was 1, otherwise from the second source SIMD&FP register. Bitwise Select.

vbsl_s16⚠Experimental `neon`

Bitwise Select.

vbsl_s32⚠Experimental `neon`

Bitwise Select.

vbsl_s64⚠Experimental `neon`

Bitwise Select.

vbsl_u8⚠Experimental `neon`

Bitwise Select.

vbsl_u16⚠Experimental `neon`

Bitwise Select.

vbsl_u32⚠Experimental `neon`

Bitwise Select.

vbsl_u64⚠Experimental `neon`

Bitwise Select.

vbslq_f32⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_f64⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_p8⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_p16⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_p64⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_s8⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_s16⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_s32⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_s64⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_u8⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_u16⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_u32⚠Experimental `neon`

Bitwise Select. (128-bit)

vbslq_u64⚠Experimental `neon`

Bitwise Select. (128-bit)

vcage_f32⚠Experimental `neon`

Floating-point absolute compare greater than or equal

vcage_f64⚠Experimental `neon`

Floating-point absolute compare greater than or equal

vcageq_f32⚠Experimental `neon`

Floating-point absolute compare greater than or equal

vcageq_f64⚠Experimental `neon`

Floating-point absolute compare greater than or equal

vcagt_f32⚠Experimental `neon`

Floating-point absolute compare greater than

vcagt_f64⚠Experimental `neon`

Floating-point absolute compare greater than

vcagtq_f32⚠Experimental `neon`

Floating-point absolute compare greater than

vcagtq_f64⚠Experimental `neon`

Floating-point absolute compare greater than

vcale_f32⚠Experimental `neon`

Floating-point absolute compare less than or equal

vcale_f64⚠Experimental `neon`

Floating-point absolute compare less than or equal

vcaleq_f32⚠Experimental `neon`

Floating-point absolute compare less than or equal

vcaleq_f64⚠Experimental `neon`

Floating-point absolute compare less than or equal

vcalt_f32⚠Experimental `neon`

Floating-point absolute compare less than

vcalt_f64⚠Experimental `neon`

Floating-point absolute compare less than

vcaltq_f32⚠Experimental `neon`

Floating-point absolute compare less than

vcaltq_f64⚠Experimental `neon`

Floating-point absolute compare less than

vceq_f32⚠Experimental `neon`

Floating-point compare equal

vceq_f64⚠Experimental `neon`

Floating-point compare equal

vceq_p8⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_p64⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_s8⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_s16⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_s32⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_s64⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_u8⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_u16⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_u32⚠Experimental `neon`

Compare bitwise Equal (vector)

vceq_u64⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_f32⚠Experimental `neon`

Floating-point compare equal

vceqq_f64⚠Experimental `neon`

Floating-point compare equal

vceqq_p8⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_p64⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_s8⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_s16⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_s32⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_s64⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_u8⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_u16⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_u32⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqq_u64⚠Experimental `neon`

Compare bitwise Equal (vector)

vceqz_f32⚠Experimental `neon`

Floating-point compare bitwise equal to zero

vceqz_f64⚠Experimental `neon`

Floating-point compare bitwise equal to zero

vceqz_p8⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqz_p64⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqz_s8⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqz_s16⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqz_s32⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqz_s64⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqz_u8⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqz_u16⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqz_u32⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqz_u64⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqzq_f32⚠Experimental `neon`

Floating-point compare bitwise equal to zero

vceqzq_f64⚠Experimental `neon`

Floating-point compare bitwise equal to zero

vceqzq_p8⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqzq_p64⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqzq_s8⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqzq_s16⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqzq_s32⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqzq_s64⚠Experimental `neon`

Signed compare bitwise equal to zero

vceqzq_u8⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqzq_u16⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqzq_u32⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vceqzq_u64⚠Experimental `neon`

Unsigned compare bitwise equal to zero

vcge_f32⚠Experimental `neon`

Floating-point compare greater than or equal

vcge_f64⚠Experimental `neon`

Floating-point compare greater than or equal

vcge_s8⚠Experimental `neon`

Compare signed greater than or equal

vcge_s16⚠Experimental `neon`

Compare signed greater than or equal

vcge_s32⚠Experimental `neon`

Compare signed greater than or equal

vcge_s64⚠Experimental `neon`

Compare signed greater than or equal

vcge_u8⚠Experimental `neon`

Compare unsigned greater than or equal

vcge_u16⚠Experimental `neon`

Compare unsigned greater than or equal

vcge_u32⚠Experimental `neon`

Compare unsigned greater than or equal

vcge_u64⚠Experimental `neon`

Compare unsigned greater than or equal

vcgeq_f32⚠Experimental `neon`

Floating-point compare greater than or equal

vcgeq_f64⚠Experimental `neon`

Floating-point compare greater than or equal

vcgeq_s8⚠Experimental `neon`

Compare signed greater than or equal

vcgeq_s16⚠Experimental `neon`

Compare signed greater than or equal

vcgeq_s32⚠Experimental `neon`

Compare signed greater than or equal

vcgeq_s64⚠Experimental `neon`

Compare signed greater than or equal

vcgeq_u8⚠Experimental `neon`

Compare unsigned greater than or equal

vcgeq_u16⚠Experimental `neon`

Compare unsigned greater than or equal

vcgeq_u32⚠Experimental `neon`

Compare unsigned greater than or equal

vcgeq_u64⚠Experimental `neon`

Compare unsigned greater than or equal

vcgez_f32⚠Experimental `neon`

Floating-point compare greater than or equal to zero

vcgez_f64⚠Experimental `neon`

Floating-point compare greater than or equal to zero

vcgez_s8⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgez_s16⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgez_s32⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgez_s64⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgezq_f32⚠Experimental `neon`

Floating-point compare greater than or equal to zero

vcgezq_f64⚠Experimental `neon`

Floating-point compare greater than or equal to zero

vcgezq_s8⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgezq_s16⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgezq_s32⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgezq_s64⚠Experimental `neon`

Compare signed greater than or equal to zero

vcgt_f32⚠Experimental `neon`

Floating-point compare greater than

vcgt_f64⚠Experimental `neon`

Floating-point compare greater than

vcgt_s8⚠Experimental `neon`

Compare signed greater than

vcgt_s16⚠Experimental `neon`

Compare signed greater than

vcgt_s32⚠Experimental `neon`

Compare signed greater than

vcgt_s64⚠Experimental `neon`

Compare signed greater than

vcgt_u8⚠Experimental `neon`

Compare unsigned highe

vcgt_u16⚠Experimental `neon`

Compare unsigned highe

vcgt_u32⚠Experimental `neon`

Compare unsigned highe

vcgt_u64⚠Experimental `neon`

Compare unsigned highe

vcgtq_f32⚠Experimental `neon`

Floating-point compare greater than

vcgtq_f64⚠Experimental `neon`

Floating-point compare greater than

vcgtq_s8⚠Experimental `neon`

Compare signed greater than

vcgtq_s16⚠Experimental `neon`

Compare signed greater than

vcgtq_s32⚠Experimental `neon`

Compare signed greater than

vcgtq_s64⚠Experimental `neon`

Compare signed greater than

vcgtq_u8⚠Experimental `neon`

Compare unsigned highe

vcgtq_u16⚠Experimental `neon`

Compare unsigned highe

vcgtq_u32⚠Experimental `neon`

Compare unsigned highe

vcgtq_u64⚠Experimental `neon`

Compare unsigned highe

vcgtz_f32⚠Experimental `neon`

Floating-point compare greater than zero

vcgtz_f64⚠Experimental `neon`

Floating-point compare greater than zero

vcgtz_s8⚠Experimental `neon`

Compare signed greater than zero

vcgtz_s16⚠Experimental `neon`

Compare signed greater than zero

vcgtz_s32⚠Experimental `neon`

Compare signed greater than zero

vcgtz_s64⚠Experimental `neon`

Compare signed greater than zero

vcgtzq_f32⚠Experimental `neon`

Floating-point compare greater than zero

vcgtzq_f64⚠Experimental `neon`

Floating-point compare greater than zero

vcgtzq_s8⚠Experimental `neon`

Compare signed greater than zero

vcgtzq_s16⚠Experimental `neon`

Compare signed greater than zero

vcgtzq_s32⚠Experimental `neon`

Compare signed greater than zero

vcgtzq_s64⚠Experimental `neon`

Compare signed greater than zero

vcle_f32⚠Experimental `neon`

Floating-point compare less than or equal

vcle_f64⚠Experimental `neon`

Floating-point compare less than or equal

vcle_s8⚠Experimental `neon`

Compare signed less than or equal

vcle_s16⚠Experimental `neon`

Compare signed less than or equal

vcle_s32⚠Experimental `neon`

Compare signed less than or equal

vcle_s64⚠Experimental `neon`

Compare signed less than or equal

vcle_u8⚠Experimental `neon`

Compare unsigned less than or equal

vcle_u16⚠Experimental `neon`

Compare unsigned less than or equal

vcle_u32⚠Experimental `neon`

Compare unsigned less than or equal

vcle_u64⚠Experimental `neon`

Compare unsigned less than or equal

vcleq_f32⚠Experimental `neon`

Floating-point compare less than or equal

vcleq_f64⚠Experimental `neon`

Floating-point compare less than or equal

vcleq_s8⚠Experimental `neon`

Compare signed less than or equal

vcleq_s16⚠Experimental `neon`

Compare signed less than or equal

vcleq_s32⚠Experimental `neon`

Compare signed less than or equal

vcleq_s64⚠Experimental `neon`

Compare signed less than or equal

vcleq_u8⚠Experimental `neon`

Compare unsigned less than or equal

vcleq_u16⚠Experimental `neon`

Compare unsigned less than or equal

vcleq_u32⚠Experimental `neon`

Compare unsigned less than or equal

vcleq_u64⚠Experimental `neon`

Compare unsigned less than or equal

vclez_f32⚠Experimental `neon`

Floating-point compare less than or equal to zero

vclez_f64⚠Experimental `neon`

Floating-point compare less than or equal to zero

vclez_s8⚠Experimental `neon`

Compare signed less than or equal to zero

vclez_s16⚠Experimental `neon`

Compare signed less than or equal to zero

vclez_s32⚠Experimental `neon`

Compare signed less than or equal to zero

vclez_s64⚠Experimental `neon`

Compare signed less than or equal to zero

vclezq_f32⚠Experimental `neon`

Floating-point compare less than or equal to zero

vclezq_f64⚠Experimental `neon`

Floating-point compare less than or equal to zero

vclezq_s8⚠Experimental `neon`

Compare signed less than or equal to zero

vclezq_s16⚠Experimental `neon`

Compare signed less than or equal to zero

vclezq_s32⚠Experimental `neon`

Compare signed less than or equal to zero

vclezq_s64⚠Experimental `neon`

Compare signed less than or equal to zero

vcls_s8⚠Experimental `neon`

Count leading sign bits

vcls_s16⚠Experimental `neon`

Count leading sign bits

vcls_s32⚠Experimental `neon`

Count leading sign bits

vclsq_s8⚠Experimental `neon`

Count leading sign bits

vclsq_s16⚠Experimental `neon`

Count leading sign bits

vclsq_s32⚠Experimental `neon`

Count leading sign bits

vclt_f32⚠Experimental `neon`

Floating-point compare less than

vclt_f64⚠Experimental `neon`

Floating-point compare less than

vclt_s8⚠Experimental `neon`

Compare signed less than

vclt_s16⚠Experimental `neon`

Compare signed less than

vclt_s32⚠Experimental `neon`

Compare signed less than

vclt_s64⚠Experimental `neon`

Compare signed less than

vclt_u8⚠Experimental `neon`

Compare unsigned less than

vclt_u16⚠Experimental `neon`

Compare unsigned less than

vclt_u32⚠Experimental `neon`

Compare unsigned less than

vclt_u64⚠Experimental `neon`

Compare unsigned less than

vcltq_f32⚠Experimental `neon`

Floating-point compare less than

vcltq_f64⚠Experimental `neon`

Floating-point compare less than

vcltq_s8⚠Experimental `neon`

Compare signed less than

vcltq_s16⚠Experimental `neon`

Compare signed less than

vcltq_s32⚠Experimental `neon`

Compare signed less than

vcltq_s64⚠Experimental `neon`

Compare signed less than

vcltq_u8⚠Experimental `neon`

Compare unsigned less than

vcltq_u16⚠Experimental `neon`

Compare unsigned less than

vcltq_u32⚠Experimental `neon`

Compare unsigned less than

vcltq_u64⚠Experimental `neon`

Compare unsigned less than

vcltz_f32⚠Experimental `neon`

Floating-point compare less than zero

vcltz_f64⚠Experimental `neon`

Floating-point compare less than zero

vcltz_s8⚠Experimental `neon`

Compare signed less than zero

vcltz_s16⚠Experimental `neon`

Compare signed less than zero

vcltz_s32⚠Experimental `neon`

Compare signed less than zero

vcltz_s64⚠Experimental `neon`

Compare signed less than zero

vcltzq_f32⚠Experimental `neon`

Floating-point compare less than zero

vcltzq_f64⚠Experimental `neon`

Floating-point compare less than zero

vcltzq_s8⚠Experimental `neon`

Compare signed less than zero

vcltzq_s16⚠Experimental `neon`

Compare signed less than zero

vcltzq_s32⚠Experimental `neon`

Compare signed less than zero

vcltzq_s64⚠Experimental `neon`

Compare signed less than zero

vclz_s8⚠Experimental `neon`

Signed count leading sign bits

vclz_s16⚠Experimental `neon`

Signed count leading sign bits

vclz_s32⚠Experimental `neon`

Signed count leading sign bits

vclz_u8⚠Experimental `neon`

Unsigned count leading sign bits

vclz_u16⚠Experimental `neon`

Unsigned count leading sign bits

vclz_u32⚠Experimental `neon`

Unsigned count leading sign bits

vclzq_s8⚠Experimental `neon`

Signed count leading sign bits

vclzq_s16⚠Experimental `neon`

Signed count leading sign bits

vclzq_s32⚠Experimental `neon`

Signed count leading sign bits

vclzq_u8⚠Experimental `neon`

Unsigned count leading sign bits

vclzq_u16⚠Experimental `neon`

Unsigned count leading sign bits

vclzq_u32⚠Experimental `neon`

Unsigned count leading sign bits

vcnt_p8⚠Experimental `neon`

Population count per byte.

vcnt_s8⚠Experimental `neon`

Population count per byte.

vcnt_u8⚠Experimental `neon`

Population count per byte.

vcntq_p8⚠Experimental `neon`

Population count per byte.

vcntq_s8⚠Experimental `neon`

Population count per byte.

vcntq_u8⚠Experimental `neon`

Population count per byte.

vcombine_f32⚠Experimental `neon`

Vector combine

vcombine_f64⚠Experimental `neon`

Vector combine

vcombine_p8⚠Experimental `neon`

Vector combine

vcombine_p16⚠Experimental `neon`

Vector combine

vcombine_p64⚠Experimental `neon`

Vector combine

vcombine_s8⚠Experimental `neon`

Vector combine

vcombine_s16⚠Experimental `neon`

Vector combine

vcombine_s32⚠Experimental `neon`

Vector combine

vcombine_s64⚠Experimental `neon`

Vector combine

vcombine_u8⚠Experimental `neon`

Vector combine

vcombine_u16⚠Experimental `neon`

Vector combine

vcombine_u32⚠Experimental `neon`

Vector combine

vcombine_u64⚠Experimental `neon`

Vector combine

vcopy_lane_f32⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_lane_p8⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_p16⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_lane_s8⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_s16⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_s32⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_lane_u8⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_u16⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_u32⚠Experimental `neon`

Insert vector element from another vector element

vcopy_lane_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_laneq_f32⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_laneq_p8⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_p16⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_laneq_s8⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_s16⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_s32⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopy_laneq_u8⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_u16⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_u32⚠Experimental `neon`

Insert vector element from another vector element

vcopy_laneq_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vcopyq_lane_f32⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_f64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_p8⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_p16⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_p64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_s8⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_s16⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_s32⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_s64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_u8⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_u16⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_u32⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_lane_u64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_f32⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_f64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_p8⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_p16⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_p64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_s8⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_s16⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_s32⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_s64⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_u8⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_u16⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_u32⚠Experimental `neon`

Insert vector element from another vector element

vcopyq_laneq_u64⚠Experimental `neon`

Insert vector element from another vector element

vcreate_f32⚠Experimental `neon`

Insert vector element from another vector element

vcreate_f64⚠Experimental `neon`

Insert vector element from another vector element

vcreate_p8⚠Experimental `neon`

Insert vector element from another vector element

vcreate_p16⚠Experimental `neon`

Insert vector element from another vector element

vcreate_p64⚠Experimental `neon,crypto`

Insert vector element from another vector element

vcreate_s8⚠Experimental `neon`

Insert vector element from another vector element

vcreate_s32⚠Experimental `neon`

Insert vector element from another vector element

vcreate_s64⚠Experimental `neon`

Insert vector element from another vector element

vcreate_u8⚠Experimental `neon`

Insert vector element from another vector element

vcreate_u32⚠Experimental `neon`

Insert vector element from another vector element

vcreate_u64⚠Experimental `neon`

Insert vector element from another vector element

vcvt_f32_f64⚠Experimental `neon`

Floating-point convert to lower precision narrow

vcvt_f32_s32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvt_f32_u32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvt_f64_f32⚠Experimental `neon`

Floating-point convert to higher precision long

vcvt_f64_s64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvt_f64_u64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvt_high_f32_f64⚠Experimental `neon`

Floating-point convert to lower precision narrow

vcvt_high_f64_f32⚠Experimental `neon`

Floating-point convert to higher precision long

vcvt_n_f64_s64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvt_n_f64_u64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvt_n_s64_f64⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvt_n_u64_f64⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvt_s32_f32⚠Experimental `neon`

Floating-point convert to signed fixed-point, rounding toward zero

vcvt_s64_f64⚠Experimental `neon`

Floating-point convert to signed fixed-point, rounding toward zero

vcvt_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned fixed-point, rounding toward zero

vcvt_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned fixed-point, rounding toward zero

vcvta_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to away

vcvta_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to away

vcvta_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to away

vcvta_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to away

vcvtad_s64_f64⚠Experimental `neon`

Floating-point convert to integer, rounding to nearest with ties to away

vcvtad_u64_f64⚠Experimental `neon`

Floating-point convert to integer, rounding to nearest with ties to away

vcvtaq_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to away

vcvtaq_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to away

vcvtaq_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to away

vcvtaq_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to away

vcvtas_s32_f32⚠Experimental `neon`

Floating-point convert to integer, rounding to nearest with ties to away

vcvtas_u32_f32⚠Experimental `neon`

Floating-point convert to integer, rounding to nearest with ties to away

vcvtd_f64_s64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtd_f64_u64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtd_n_f64_s64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtd_n_f64_u64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtd_n_s64_f64⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvtd_n_u64_f64⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvtd_s64_f64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtd_u64_f64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtm_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward minus infinity

vcvtm_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward minus infinity

vcvtm_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward minus infinity

vcvtm_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward minus infinity

vcvtmd_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward minus infinity

vcvtmd_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward minus infinity

vcvtmq_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward minus infinity

vcvtmq_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward minus infinity

vcvtmq_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward minus infinity

vcvtmq_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward minus infinity

vcvtms_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward minus infinity

vcvtms_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward minus infinity

vcvtn_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to even

vcvtn_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to even

vcvtn_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to even

vcvtn_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to even

vcvtnd_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to even

vcvtnd_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to even

vcvtnq_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to even

vcvtnq_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to even

vcvtnq_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to even

vcvtnq_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to even

vcvtns_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding to nearest with ties to even

vcvtns_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding to nearest with ties to even

vcvtp_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward plus infinity

vcvtp_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward plus infinity

vcvtp_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward plus infinity

vcvtp_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward plus infinity

vcvtpd_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward plus infinity

vcvtpd_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward plus infinity

vcvtpq_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward plus infinity

vcvtpq_s64_f64⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward plus infinity

vcvtpq_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward plus infinity

vcvtpq_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward plus infinity

vcvtps_s32_f32⚠Experimental `neon`

Floating-point convert to signed integer, rounding toward plus infinity

vcvtps_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned integer, rounding toward plus infinity

vcvtq_f32_s32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtq_f32_u32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtq_f64_s64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtq_f64_u64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtq_n_f64_s64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtq_n_f64_u64⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtq_n_s64_f64⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvtq_n_u64_f64⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvtq_s32_f32⚠Experimental `neon`

Floating-point convert to signed fixed-point, rounding toward zero

vcvtq_s64_f64⚠Experimental `neon`

Floating-point convert to signed fixed-point, rounding toward zero

vcvtq_u32_f32⚠Experimental `neon`

Floating-point convert to unsigned fixed-point, rounding toward zero

vcvtq_u64_f64⚠Experimental `neon`

Floating-point convert to unsigned fixed-point, rounding toward zero

vcvts_f32_s32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvts_f32_u32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvts_n_f32_s32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvts_n_f32_u32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvts_n_s32_f32⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvts_n_u32_f32⚠Experimental `neon`

Floating-point convert to fixed-point, rounding toward zero

vcvts_s32_f32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvts_u32_f32⚠Experimental `neon`

Fixed-point convert to floating-point

vcvtx_f32_f64⚠Experimental `neon`

Floating-point convert to lower precision narrow, rounding to odd

vcvtx_high_f32_f64⚠Experimental `neon`

Floating-point convert to lower precision narrow, rounding to odd

vdiv_f32⚠Experimental `neon`

Divide

vdiv_f64⚠Experimental `neon`

Divide

vdivq_f32⚠Experimental `neon`

Divide

vdivq_f64⚠Experimental `neon`

Divide

vdup_lane_f32⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_f64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_p8⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_p16⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_p64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_s8⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_s16⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_s32⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_s64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_u8⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_u16⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_u32⚠Experimental `neon`

Set all vector lanes to the same value

vdup_lane_u64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_f32⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_f64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_p8⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_p16⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_p64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_s8⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_s16⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_s32⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_s64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_u8⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_u16⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_u32⚠Experimental `neon`

Set all vector lanes to the same value

vdup_laneq_u64⚠Experimental `neon`

Set all vector lanes to the same value

vdup_n_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_p8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_p16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_s8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_s16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_s32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_u8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_u16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_u32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdup_n_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupb_lane_p8⚠Experimental `neon`

Set all vector lanes to the same value

vdupb_lane_s8⚠Experimental `neon`

Set all vector lanes to the same value

vdupb_lane_u8⚠Experimental `neon`

Set all vector lanes to the same value

vdupb_laneq_p8⚠Experimental `neon`

Set all vector lanes to the same value

vdupb_laneq_s8⚠Experimental `neon`

Set all vector lanes to the same value

vdupb_laneq_u8⚠Experimental `neon`

Set all vector lanes to the same value

vdupd_lane_f64⚠Experimental `neon`

Set all vector lanes to the same value

vdupd_lane_s64⚠Experimental `neon`

Set all vector lanes to the same value

vdupd_lane_u64⚠Experimental `neon`

Set all vector lanes to the same value

vdupd_laneq_f64⚠Experimental `neon`

Set all vector lanes to the same value

vdupd_laneq_s64⚠Experimental `neon`

Set all vector lanes to the same value

vdupd_laneq_u64⚠Experimental `neon`

Set all vector lanes to the same value

vduph_lane_p16⚠Experimental `neon`

Set all vector lanes to the same value

vduph_lane_s16⚠Experimental `neon`

Set all vector lanes to the same value

vduph_lane_u16⚠Experimental `neon`

Set all vector lanes to the same value

vduph_laneq_p16⚠Experimental `neon`

Set all vector lanes to the same value

vduph_laneq_s16⚠Experimental `neon`

Set all vector lanes to the same value

vduph_laneq_u16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_f32⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_f64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_p8⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_p16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_p64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_s8⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_s16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_s32⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_s64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_u8⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_u16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_u32⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_lane_u64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_f32⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_f64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_p8⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_p16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_p64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_s8⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_s16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_s32⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_s64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_u8⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_u16⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_u32⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_laneq_u64⚠Experimental `neon`

Set all vector lanes to the same value

vdupq_n_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_p8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_p16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_s8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_s16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_s32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_u8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_u16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_u32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdupq_n_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vdups_lane_f32⚠Experimental `neon`

Set all vector lanes to the same value

vdups_lane_s32⚠Experimental `neon`

Set all vector lanes to the same value

vdups_lane_u32⚠Experimental `neon`

Set all vector lanes to the same value

vdups_laneq_f32⚠Experimental `neon`

Set all vector lanes to the same value

vdups_laneq_s32⚠Experimental `neon`

Set all vector lanes to the same value

vdups_laneq_u32⚠Experimental `neon`

Set all vector lanes to the same value

veor_s8⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_s16⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_s32⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_s64⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_u8⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_u16⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_u32⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veor_u64⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_s8⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_s16⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_s32⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_s64⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_u8⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_u16⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_u32⚠Experimental `neon`

Vector bitwise exclusive or (vector)

veorq_u64⚠Experimental `neon`

Vector bitwise exclusive or (vector)

vext_f32⚠Experimental `neon`

Extract vector from pair of vectors

vext_f64⚠Experimental `neon`

Extract vector from pair of vectors

vext_p8⚠Experimental `neon`

Extract vector from pair of vectors

vext_p16⚠Experimental `neon`

Extract vector from pair of vectors

vext_p64⚠Experimental `neon`

Extract vector from pair of vectors

vext_s8⚠Experimental `neon`

Extract vector from pair of vectors

vext_s16⚠Experimental `neon`

Extract vector from pair of vectors

vext_s32⚠Experimental `neon`

Extract vector from pair of vectors

vext_s64⚠Experimental `neon`

Extract vector from pair of vectors

vext_u8⚠Experimental `neon`

Extract vector from pair of vectors

vext_u16⚠Experimental `neon`

Extract vector from pair of vectors

vext_u32⚠Experimental `neon`

Extract vector from pair of vectors

vext_u64⚠Experimental `neon`

Extract vector from pair of vectors

vextq_f32⚠Experimental `neon`

Extract vector from pair of vectors

vextq_f64⚠Experimental `neon`

Extract vector from pair of vectors

vextq_p8⚠Experimental `neon`

Extract vector from pair of vectors

vextq_p16⚠Experimental `neon`

Extract vector from pair of vectors

vextq_p64⚠Experimental `neon`

Extract vector from pair of vectors

vextq_s8⚠Experimental `neon`

Extract vector from pair of vectors

vextq_s16⚠Experimental `neon`

Extract vector from pair of vectors

vextq_s32⚠Experimental `neon`

Extract vector from pair of vectors

vextq_s64⚠Experimental `neon`

Extract vector from pair of vectors

vextq_u8⚠Experimental `neon`

Extract vector from pair of vectors

vextq_u16⚠Experimental `neon`

Extract vector from pair of vectors

vextq_u32⚠Experimental `neon`

Extract vector from pair of vectors

vextq_u64⚠Experimental `neon`

Extract vector from pair of vectors

vfma_f32⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfma_f64⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfma_lane_f32⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfma_lane_f64⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfma_laneq_f32⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfma_laneq_f64⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfma_n_f32⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfma_n_f64⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfmad_lane_f64⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmad_laneq_f64⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmaq_f32⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfmaq_f64⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfmaq_lane_f32⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmaq_lane_f64⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmaq_laneq_f32⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmaq_laneq_f64⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmaq_n_f32⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfmaq_n_f64⚠Experimental `neon`

Floating-point fused Multiply-Add to accumulator(vector)

vfmas_lane_f32⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfmas_laneq_f32⚠Experimental `neon`

Floating-point fused multiply-add to accumulator

vfms_f32⚠Experimental `neon`

Floating-point fused multiply-subtract from accumulator

vfms_f64⚠Experimental `neon`

Floating-point fused multiply-subtract from accumulator

vfms_lane_f32⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfms_lane_f64⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfms_laneq_f32⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfms_laneq_f64⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfms_n_f32⚠Experimental `neon`

Floating-point fused Multiply-subtract to accumulator(vector)

vfms_n_f64⚠Experimental `neon`

Floating-point fused Multiply-subtract to accumulator(vector)

vfmsd_lane_f64⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmsd_laneq_f64⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmsq_f32⚠Experimental `neon`

Floating-point fused multiply-subtract from accumulator

vfmsq_f64⚠Experimental `neon`

Floating-point fused multiply-subtract from accumulator

vfmsq_lane_f32⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmsq_lane_f64⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmsq_laneq_f32⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmsq_laneq_f64⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmsq_n_f32⚠Experimental `neon`

Floating-point fused Multiply-subtract to accumulator(vector)

vfmsq_n_f64⚠Experimental `neon`

Floating-point fused Multiply-subtract to accumulator(vector)

vfmss_lane_f32⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vfmss_laneq_f32⚠Experimental `neon`

Floating-point fused multiply-subtract to accumulator

vget_high_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_p8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_p16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_s8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_s16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_s32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_u8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_u16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_u32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_high_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_lane_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_lane_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_lane_p8⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_p16⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_p64⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_s8⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_s16⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_s32⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_s64⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_u8⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_u16⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_u32⚠Experimental `neon`

Move vector element to general-purpose register

vget_lane_u64⚠Experimental `neon`

Move vector element to general-purpose register

vget_low_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_p8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_p16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_s8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_s16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_s32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_u8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_u16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_u32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vget_low_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vgetq_lane_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vgetq_lane_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vgetq_lane_p8⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_p16⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_p64⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_s8⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_s16⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_s32⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_s64⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_u8⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_u16⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_u32⚠Experimental `neon`

Move vector element to general-purpose register

vgetq_lane_u64⚠Experimental `neon`

Move vector element to general-purpose register

vhadd_s8⚠Experimental `neon`

Halving add

vhadd_s16⚠Experimental `neon`

Halving add

vhadd_s32⚠Experimental `neon`

Halving add

vhadd_u8⚠Experimental `neon`

Halving add

vhadd_u16⚠Experimental `neon`

Halving add

vhadd_u32⚠Experimental `neon`

Halving add

vhaddq_s8⚠Experimental `neon`

Halving add

vhaddq_s16⚠Experimental `neon`

Halving add

vhaddq_s32⚠Experimental `neon`

Halving add

vhaddq_u8⚠Experimental `neon`

Halving add

vhaddq_u16⚠Experimental `neon`

Halving add

vhaddq_u32⚠Experimental `neon`

Halving add

vhsub_s8⚠Experimental `neon`

Signed halving subtract

vhsub_s16⚠Experimental `neon`

Signed halving subtract

vhsub_s32⚠Experimental `neon`

Signed halving subtract

vhsub_u8⚠Experimental `neon`

Signed halving subtract

vhsub_u16⚠Experimental `neon`

Signed halving subtract

vhsub_u32⚠Experimental `neon`

Signed halving subtract

vhsubq_s8⚠Experimental `neon`

Signed halving subtract

vhsubq_s16⚠Experimental `neon`

Signed halving subtract

vhsubq_s32⚠Experimental `neon`

Signed halving subtract

vhsubq_u8⚠Experimental `neon`

Signed halving subtract

vhsubq_u16⚠Experimental `neon`

Signed halving subtract

vhsubq_u32⚠Experimental `neon`

Signed halving subtract

vld1_dup_f32⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_p8⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_p16⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_s8⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_s16⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_s32⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_s64⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_u8⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_u16⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_u32⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_dup_u64⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1_f32⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_f64⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_lane_f32⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_p8⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_p16⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_s8⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_s16⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_s32⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_s64⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_u8⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_u16⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_u32⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_lane_u64⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1_p8⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_p16⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_s8⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_s16⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_s32⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_s64⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_u8⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_u16⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_u32⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1_u64⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_dup_f32⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_p8⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_p16⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_s8⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_s16⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_s32⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_s64⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_u8⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_u16⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_u32⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_dup_u64⚠Experimental `neon`

Load one single-element structure and Replicate to all lanes (of one register).

vld1q_f32⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_f64⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_lane_f32⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_p8⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_p16⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_s8⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_s16⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_s32⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_s64⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_u8⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_u16⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_u32⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_lane_u64⚠Experimental `neon`

Load one single-element structure to one lane of one register.

vld1q_p8⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_p16⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_s8⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_s16⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_s32⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_s64⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_u8⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_u16⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_u32⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vld1q_u64⚠Experimental `neon`

Load multiple single-element structures to one, two, three, or four registers.

vmax_f32⚠Experimental `neon`

Maximum (vector)

vmax_f64⚠Experimental `neon`

Maximum (vector)

vmax_s8⚠Experimental `neon`

Maximum (vector)

vmax_s16⚠Experimental `neon`

Maximum (vector)

vmax_s32⚠Experimental `neon`

Maximum (vector)

vmax_u8⚠Experimental `neon`

Maximum (vector)

vmax_u16⚠Experimental `neon`

Maximum (vector)

vmax_u32⚠Experimental `neon`

Maximum (vector)

vmaxnm_f32⚠Experimental `neon`

Floating-point Maximun Number (vector)

vmaxnm_f64⚠Experimental `neon`

Floating-point Maximun Number (vector)

vmaxnmq_f32⚠Experimental `neon`

Floating-point Maximun Number (vector)

vmaxnmq_f64⚠Experimental `neon`

Floating-point Maximun Number (vector)

vmaxq_f32⚠Experimental `neon`

Maximum (vector)

vmaxq_f64⚠Experimental `neon`

Maximum (vector)

vmaxq_s8⚠Experimental `neon`

Maximum (vector)

vmaxq_s16⚠Experimental `neon`

Maximum (vector)

vmaxq_s32⚠Experimental `neon`

Maximum (vector)

vmaxq_u8⚠Experimental `neon`

Maximum (vector)

vmaxq_u16⚠Experimental `neon`

Maximum (vector)

vmaxq_u32⚠Experimental `neon`

Maximum (vector)

vmaxv_f32⚠Experimental `neon`

Horizontal vector max.

vmaxv_s8⚠Experimental `neon`

Horizontal vector max.

vmaxv_s16⚠Experimental `neon`

Horizontal vector max.

vmaxv_s32⚠Experimental `neon`

Horizontal vector max.

vmaxv_u8⚠Experimental `neon`

Horizontal vector max.

vmaxv_u16⚠Experimental `neon`

Horizontal vector max.

vmaxv_u32⚠Experimental `neon`

Horizontal vector max.

vmaxvq_f32⚠Experimental `neon`

Horizontal vector max.

vmaxvq_f64⚠Experimental `neon`

Horizontal vector max.

vmaxvq_s8⚠Experimental `neon`

Horizontal vector max.

vmaxvq_s16⚠Experimental `neon`

Horizontal vector max.

vmaxvq_s32⚠Experimental `neon`

Horizontal vector max.

vmaxvq_u8⚠Experimental `neon`

Horizontal vector max.

vmaxvq_u16⚠Experimental `neon`

Horizontal vector max.

vmaxvq_u32⚠Experimental `neon`

Horizontal vector max.

vmin_f32⚠Experimental `neon`

Minimum (vector)

vmin_f64⚠Experimental `neon`

Minimum (vector)

vmin_s8⚠Experimental `neon`

Minimum (vector)

vmin_s16⚠Experimental `neon`

Minimum (vector)

vmin_s32⚠Experimental `neon`

Minimum (vector)

vmin_u8⚠Experimental `neon`

Minimum (vector)

vmin_u16⚠Experimental `neon`

Minimum (vector)

vmin_u32⚠Experimental `neon`

Minimum (vector)

vminnm_f32⚠Experimental `neon`

Floating-point Minimun Number (vector)

vminnm_f64⚠Experimental `neon`

Floating-point Minimun Number (vector)

vminnmq_f32⚠Experimental `neon`

Floating-point Minimun Number (vector)

vminnmq_f64⚠Experimental `neon`

Floating-point Minimun Number (vector)

vminq_f32⚠Experimental `neon`

Minimum (vector)

vminq_f64⚠Experimental `neon`

Minimum (vector)

vminq_s8⚠Experimental `neon`

Minimum (vector)

vminq_s16⚠Experimental `neon`

Minimum (vector)

vminq_s32⚠Experimental `neon`

Minimum (vector)

vminq_u8⚠Experimental `neon`

Minimum (vector)

vminq_u16⚠Experimental `neon`

Minimum (vector)

vminq_u32⚠Experimental `neon`

Minimum (vector)

vminv_f32⚠Experimental `neon`

Horizontal vector min.

vminv_s8⚠Experimental `neon`

Horizontal vector min.

vminv_s16⚠Experimental `neon`

Horizontal vector min.

vminv_s32⚠Experimental `neon`

Horizontal vector min.

vminv_u8⚠Experimental `neon`

Horizontal vector min.

vminv_u16⚠Experimental `neon`

Horizontal vector min.

vminv_u32⚠Experimental `neon`

Horizontal vector min.

vminvq_f32⚠Experimental `neon`

Horizontal vector min.

vminvq_f64⚠Experimental `neon`

Horizontal vector min.

vminvq_s8⚠Experimental `neon`

Horizontal vector min.

vminvq_s16⚠Experimental `neon`

Horizontal vector min.

vminvq_s32⚠Experimental `neon`

Horizontal vector min.

vminvq_u8⚠Experimental `neon`

Horizontal vector min.

vminvq_u16⚠Experimental `neon`

Horizontal vector min.

vminvq_u32⚠Experimental `neon`

Horizontal vector min.

vmla_f32⚠Experimental `neon`

Floating-point multiply-add to accumulator

vmla_f64⚠Experimental `neon`

Floating-point multiply-add to accumulator

vmla_lane_f32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_lane_s16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_lane_s32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_lane_u16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_lane_u32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_laneq_f32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_laneq_s16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_laneq_s32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_laneq_u16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_laneq_u32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_n_f32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_n_s16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_n_s32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_n_u16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_n_u32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmla_s8⚠Experimental `neon`

Multiply-add to accumulator

vmla_s16⚠Experimental `neon`

Multiply-add to accumulator

vmla_s32⚠Experimental `neon`

Multiply-add to accumulator

vmla_u8⚠Experimental `neon`

Multiply-add to accumulator

vmla_u16⚠Experimental `neon`

Multiply-add to accumulator

vmla_u32⚠Experimental `neon`

Multiply-add to accumulator

vmlal_high_lane_s16⚠Experimental `neon`

Multiply-add long

vmlal_high_lane_s32⚠Experimental `neon`

Multiply-add long

vmlal_high_lane_u16⚠Experimental `neon`

Multiply-add long

vmlal_high_lane_u32⚠Experimental `neon`

Multiply-add long

vmlal_high_laneq_s16⚠Experimental `neon`

Multiply-add long

vmlal_high_laneq_s32⚠Experimental `neon`

Multiply-add long

vmlal_high_laneq_u16⚠Experimental `neon`

Multiply-add long

vmlal_high_laneq_u32⚠Experimental `neon`

Multiply-add long

vmlal_high_n_s16⚠Experimental `neon`

Multiply-add long

vmlal_high_n_s32⚠Experimental `neon`

Multiply-add long

vmlal_high_n_u16⚠Experimental `neon`

Multiply-add long

vmlal_high_n_u32⚠Experimental `neon`

Multiply-add long

vmlal_high_s8⚠Experimental `neon`

Signed multiply-add long

vmlal_high_s16⚠Experimental `neon`

Signed multiply-add long

vmlal_high_s32⚠Experimental `neon`

Signed multiply-add long

vmlal_high_u8⚠Experimental `neon`

Unsigned multiply-add long

vmlal_high_u16⚠Experimental `neon`

Unsigned multiply-add long

vmlal_high_u32⚠Experimental `neon`

Unsigned multiply-add long

vmlal_lane_s16⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_lane_s32⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_lane_u16⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_lane_u32⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_laneq_s16⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_laneq_s32⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_laneq_u16⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_laneq_u32⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_n_s16⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_n_s32⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_n_u16⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_n_u32⚠Experimental `neon`

Vector widening multiply accumulate with scalar

vmlal_s8⚠Experimental `neon`

Signed multiply-add long

vmlal_s16⚠Experimental `neon`

Signed multiply-add long

vmlal_s32⚠Experimental `neon`

Signed multiply-add long

vmlal_u8⚠Experimental `neon`

Unsigned multiply-add long

vmlal_u16⚠Experimental `neon`

Unsigned multiply-add long

vmlal_u32⚠Experimental `neon`

Unsigned multiply-add long

vmlaq_f32⚠Experimental `neon`

Floating-point multiply-add to accumulator

vmlaq_f64⚠Experimental `neon`

Floating-point multiply-add to accumulator

vmlaq_lane_f32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_lane_s16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_lane_s32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_lane_u16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_lane_u32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_laneq_f32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_laneq_s16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_laneq_s32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_laneq_u16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_laneq_u32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_n_f32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_n_s16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_n_s32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_n_u16⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_n_u32⚠Experimental `neon`

Vector multiply accumulate with scalar

vmlaq_s8⚠Experimental `neon`

Multiply-add to accumulator

vmlaq_s16⚠Experimental `neon`

Multiply-add to accumulator

vmlaq_s32⚠Experimental `neon`

Multiply-add to accumulator

vmlaq_u8⚠Experimental `neon`

Multiply-add to accumulator

vmlaq_u16⚠Experimental `neon`

Multiply-add to accumulator

vmlaq_u32⚠Experimental `neon`

Multiply-add to accumulator

vmls_f32⚠Experimental `neon`

Floating-point multiply-subtract from accumulator

vmls_f64⚠Experimental `neon`

Floating-point multiply-subtract from accumulator

vmls_lane_f32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_lane_s16⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_lane_s32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_lane_u16⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_lane_u32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_laneq_f32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_laneq_s16⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_laneq_s32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_laneq_u16⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_laneq_u32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_n_f32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_n_s16⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_n_s32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_n_u16⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_n_u32⚠Experimental `neon`

Vector multiply subtract with scalar

vmls_s8⚠Experimental `neon`

Multiply-subtract from accumulator

vmls_s16⚠Experimental `neon`

Multiply-subtract from accumulator

vmls_s32⚠Experimental `neon`

Multiply-subtract from accumulator

vmls_u8⚠Experimental `neon`

Multiply-subtract from accumulator

vmls_u16⚠Experimental `neon`

Multiply-subtract from accumulator

vmls_u32⚠Experimental `neon`

Multiply-subtract from accumulator

vmlsl_high_lane_s16⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_lane_s32⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_lane_u16⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_lane_u32⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_laneq_s16⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_laneq_s32⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_laneq_u16⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_laneq_u32⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_n_s16⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_n_s32⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_n_u16⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_n_u32⚠Experimental `neon`

Multiply-subtract long

vmlsl_high_s8⚠Experimental `neon`

Signed multiply-subtract long

vmlsl_high_s16⚠Experimental `neon`

Signed multiply-subtract long

vmlsl_high_s32⚠Experimental `neon`

Signed multiply-subtract long

vmlsl_high_u8⚠Experimental `neon`

Unsigned multiply-subtract long

vmlsl_high_u16⚠Experimental `neon`

Unsigned multiply-subtract long

vmlsl_high_u32⚠Experimental `neon`

Unsigned multiply-subtract long

vmlsl_lane_s16⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_lane_s32⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_lane_u16⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_lane_u32⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_laneq_s16⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_laneq_s32⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_laneq_u16⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_laneq_u32⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_n_s16⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_n_s32⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_n_u16⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_n_u32⚠Experimental `neon`

Vector widening multiply subtract with scalar

vmlsl_s8⚠Experimental `neon`

Signed multiply-subtract long

vmlsl_s16⚠Experimental `neon`

Signed multiply-subtract long

vmlsl_s32⚠Experimental `neon`

Signed multiply-subtract long

vmlsl_u8⚠Experimental `neon`

Unsigned multiply-subtract long

vmlsl_u16⚠Experimental `neon`

Unsigned multiply-subtract long

vmlsl_u32⚠Experimental `neon`

Unsigned multiply-subtract long

vmlsq_f32⚠Experimental `neon`

Floating-point multiply-subtract from accumulator

vmlsq_f64⚠Experimental `neon`

Floating-point multiply-subtract from accumulator

vmlsq_lane_f32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_lane_s16⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_lane_s32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_lane_u16⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_lane_u32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_laneq_f32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_laneq_s16⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_laneq_s32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_laneq_u16⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_laneq_u32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_n_f32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_n_s16⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_n_s32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_n_u16⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_n_u32⚠Experimental `neon`

Vector multiply subtract with scalar

vmlsq_s8⚠Experimental `neon`

Multiply-subtract from accumulator

vmlsq_s16⚠Experimental `neon`

Multiply-subtract from accumulator

vmlsq_s32⚠Experimental `neon`

Multiply-subtract from accumulator

vmlsq_u8⚠Experimental `neon`

Multiply-subtract from accumulator

vmlsq_u16⚠Experimental `neon`

Multiply-subtract from accumulator

vmlsq_u32⚠Experimental `neon`

Multiply-subtract from accumulator

vmov_n_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_p8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_p16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_s8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_s16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_s32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_u8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_u16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_u32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmov_n_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovl_s8⚠Experimental `neon`

Vector long move.

vmovl_s16⚠Experimental `neon`

Vector long move.

vmovl_s32⚠Experimental `neon`

Vector long move.

vmovl_u8⚠Experimental `neon`

Vector long move.

vmovl_u16⚠Experimental `neon`

Vector long move.

vmovl_u32⚠Experimental `neon`

Vector long move.

vmovn_high_s16⚠Experimental `neon`

Extract narrow

vmovn_high_s32⚠Experimental `neon`

Extract narrow

vmovn_high_s64⚠Experimental `neon`

Extract narrow

vmovn_high_u16⚠Experimental `neon`

Extract narrow

vmovn_high_u32⚠Experimental `neon`

Extract narrow

vmovn_high_u64⚠Experimental `neon`

Extract narrow

vmovn_s16⚠Experimental `neon`

Vector narrow integer.

vmovn_s32⚠Experimental `neon`

Vector narrow integer.

vmovn_s64⚠Experimental `neon`

Vector narrow integer.

vmovn_u16⚠Experimental `neon`

Vector narrow integer.

vmovn_u32⚠Experimental `neon`

Vector narrow integer.

vmovn_u64⚠Experimental `neon`

Vector narrow integer.

vmovq_n_f32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_f64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_p8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_p16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_p64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_s8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_s16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_s32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_s64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_u8⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_u16⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_u32⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmovq_n_u64⚠Experimental `neon`

Duplicate vector element to vector or scalar

vmul_f32⚠Experimental `neon`

Multiply

vmul_f64⚠Experimental `neon`

Multiply

vmul_lane_f32⚠Experimental `neon`

Floating-point multiply

vmul_lane_f64⚠Experimental `neon`

Floating-point multiply

vmul_lane_s16⚠Experimental `neon`

Multiply

vmul_lane_s32⚠Experimental `neon`

Multiply

vmul_lane_u16⚠Experimental `neon`

Multiply

vmul_lane_u32⚠Experimental `neon`

Multiply

vmul_laneq_f32⚠Experimental `neon`

Floating-point multiply

vmul_laneq_f64⚠Experimental `neon`

Floating-point multiply

vmul_laneq_s16⚠Experimental `neon`

Multiply

vmul_laneq_s32⚠Experimental `neon`

Multiply

vmul_laneq_u16⚠Experimental `neon`

Multiply

vmul_laneq_u32⚠Experimental `neon`

Multiply

vmul_n_f32⚠Experimental `neon`

Vector multiply by scalar

vmul_n_f64⚠Experimental `neon`

Vector multiply by scalar

vmul_n_s16⚠Experimental `neon`

Vector multiply by scalar

vmul_n_s32⚠Experimental `neon`

Vector multiply by scalar

vmul_n_u16⚠Experimental `neon`

Vector multiply by scalar

vmul_n_u32⚠Experimental `neon`

Vector multiply by scalar

vmul_p8⚠Experimental `neon`

Polynomial multiply

vmul_s8⚠Experimental `neon`

Multiply

vmul_s16⚠Experimental `neon`

Multiply

vmul_s32⚠Experimental `neon`

Multiply

vmul_u8⚠Experimental `neon`

Multiply

vmul_u16⚠Experimental `neon`

Multiply

vmul_u32⚠Experimental `neon`

Multiply

vmuld_lane_f64⚠Experimental `neon`

Floating-point multiply

vmuld_laneq_f64⚠Experimental `neon`

Floating-point multiply

vmull_high_lane_s16⚠Experimental `neon`

Multiply long

vmull_high_lane_s32⚠Experimental `neon`

Multiply long

vmull_high_lane_u16⚠Experimental `neon`

Multiply long

vmull_high_lane_u32⚠Experimental `neon`

Multiply long

vmull_high_laneq_s16⚠Experimental `neon`

Multiply long

vmull_high_laneq_s32⚠Experimental `neon`

Multiply long

vmull_high_laneq_u16⚠Experimental `neon`

Multiply long

vmull_high_laneq_u32⚠Experimental `neon`

Multiply long

vmull_high_n_s16⚠Experimental `neon`

Multiply long

vmull_high_n_s32⚠Experimental `neon`

Multiply long

vmull_high_n_u16⚠Experimental `neon`

Multiply long

vmull_high_n_u32⚠Experimental `neon`

Multiply long

vmull_high_p8⚠Experimental `neon`

Polynomial multiply long

vmull_high_p64⚠Experimental `neon,crypto`

Polynomial multiply long

vmull_high_s8⚠Experimental `neon`

Signed multiply long

vmull_high_s16⚠Experimental `neon`

Signed multiply long

vmull_high_s32⚠Experimental `neon`

Signed multiply long

vmull_high_u8⚠Experimental `neon`

Unsigned multiply long

vmull_high_u16⚠Experimental `neon`

Unsigned multiply long

vmull_high_u32⚠Experimental `neon`

Unsigned multiply long

vmull_lane_s16⚠Experimental `neon`

Vector long multiply by scalar

vmull_lane_s32⚠Experimental `neon`

Vector long multiply by scalar

vmull_lane_u16⚠Experimental `neon`

Vector long multiply by scalar

vmull_lane_u32⚠Experimental `neon`

Vector long multiply by scalar

vmull_laneq_s16⚠Experimental `neon`

Vector long multiply by scalar

vmull_laneq_s32⚠Experimental `neon`

Vector long multiply by scalar

vmull_laneq_u16⚠Experimental `neon`

Vector long multiply by scalar

vmull_laneq_u32⚠Experimental `neon`

Vector long multiply by scalar

vmull_p8⚠Experimental `neon`

Polynomial multiply long

vmull_p64⚠Experimental `neon,crypto`

Polynomial multiply long

vmull_s8⚠Experimental `neon`

Signed multiply long

vmull_s16⚠Experimental `neon`

Signed multiply long

vmull_s32⚠Experimental `neon`

Signed multiply long

vmull_u8⚠Experimental `neon`

Unsigned multiply long

vmull_u16⚠Experimental `neon`

Unsigned multiply long

vmull_u32⚠Experimental `neon`

Unsigned multiply long

vmullh_n_s16⚠Experimental `neon`

Vector long multiply with scalar

vmullh_n_u16⚠Experimental `neon`

Vector long multiply with scalar

vmulls_n_s32⚠Experimental `neon`

Vector long multiply with scalar

vmulls_n_u32⚠Experimental `neon`

Vector long multiply with scalar

vmulq_f32⚠Experimental `neon`

Multiply

vmulq_f64⚠Experimental `neon`

Multiply

vmulq_lane_f32⚠Experimental `neon`

Floating-point multiply

vmulq_lane_f64⚠Experimental `neon`

Floating-point multiply

vmulq_lane_s16⚠Experimental `neon`

Multiply

vmulq_lane_s32⚠Experimental `neon`

Multiply

vmulq_lane_u16⚠Experimental `neon`

Multiply

vmulq_lane_u32⚠Experimental `neon`

Multiply

vmulq_laneq_f32⚠Experimental `neon`

Floating-point multiply

vmulq_laneq_f64⚠Experimental `neon`

Floating-point multiply

vmulq_laneq_s16⚠Experimental `neon`

Multiply

vmulq_laneq_s32⚠Experimental `neon`

Multiply

vmulq_laneq_u16⚠Experimental `neon`

Multiply

vmulq_laneq_u32⚠Experimental `neon`

Multiply

vmulq_n_f32⚠Experimental `neon`

Vector multiply by scalar

vmulq_n_f64⚠Experimental `neon`

Vector multiply by scalar

vmulq_n_s16⚠Experimental `neon`

Vector multiply by scalar

vmulq_n_s32⚠Experimental `neon`

Vector multiply by scalar

vmulq_n_u16⚠Experimental `neon`

Vector multiply by scalar

vmulq_n_u32⚠Experimental `neon`

Vector multiply by scalar

vmulq_p8⚠Experimental `neon`

Polynomial multiply

vmulq_s8⚠Experimental `neon`

Multiply

vmulq_s16⚠Experimental `neon`

Multiply

vmulq_s32⚠Experimental `neon`

Multiply

vmulq_u8⚠Experimental `neon`

Multiply

vmulq_u16⚠Experimental `neon`

Multiply

vmulq_u32⚠Experimental `neon`

Multiply

vmuls_lane_f32⚠Experimental `neon`

Floating-point multiply

vmuls_laneq_f32⚠Experimental `neon`

Floating-point multiply

vmulx_f32⚠Experimental `neon`

Floating-point multiply extended

vmulx_f64⚠Experimental `neon`

Floating-point multiply extended

vmulx_lane_f32⚠Experimental `neon`

Floating-point multiply extended

vmulx_lane_f64⚠Experimental `neon`

Floating-point multiply extended

vmulx_laneq_f32⚠Experimental `neon`

Floating-point multiply extended

vmulx_laneq_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxd_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxd_lane_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxd_laneq_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxq_f32⚠Experimental `neon`

Floating-point multiply extended

vmulxq_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxq_lane_f32⚠Experimental `neon`

Floating-point multiply extended

vmulxq_lane_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxq_laneq_f32⚠Experimental `neon`

Floating-point multiply extended

vmulxq_laneq_f64⚠Experimental `neon`

Floating-point multiply extended

vmulxs_f32⚠Experimental `neon`

Floating-point multiply extended

vmulxs_lane_f32⚠Experimental `neon`

Floating-point multiply extended

vmulxs_laneq_f32⚠Experimental `neon`

Floating-point multiply extended

vmvn_p8⚠Experimental `neon`

Vector bitwise not.

vmvn_s8⚠Experimental `neon`

Vector bitwise not.

vmvn_s16⚠Experimental `neon`

Vector bitwise not.

vmvn_s32⚠Experimental `neon`

Vector bitwise not.

vmvn_u8⚠Experimental `neon`

Vector bitwise not.

vmvn_u16⚠Experimental `neon`

Vector bitwise not.

vmvn_u32⚠Experimental `neon`

Vector bitwise not.

vmvnq_p8⚠Experimental `neon`

Vector bitwise not.

vmvnq_s8⚠Experimental `neon`

Vector bitwise not.

vmvnq_s16⚠Experimental `neon`

Vector bitwise not.

vmvnq_s32⚠Experimental `neon`

Vector bitwise not.

vmvnq_u8⚠Experimental `neon`

Vector bitwise not.

vmvnq_u16⚠Experimental `neon`

Vector bitwise not.

vmvnq_u32⚠Experimental `neon`

Vector bitwise not.

vneg_f32⚠Experimental `neon`

Negate

vneg_f64⚠Experimental `neon`

Negate

vneg_s8⚠Experimental `neon`

Negate

vneg_s16⚠Experimental `neon`

Negate

vneg_s32⚠Experimental `neon`

Negate

vneg_s64⚠Experimental `neon`

Negate

vnegq_f32⚠Experimental `neon`

Negate

vnegq_f64⚠Experimental `neon`

Negate

vnegq_s8⚠Experimental `neon`

Negate

vnegq_s16⚠Experimental `neon`

Negate

vnegq_s32⚠Experimental `neon`

Negate

vnegq_s64⚠Experimental `neon`

Negate

vorn_s8⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_s16⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_s32⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_s64⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_u8⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_u16⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_u32⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorn_u64⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_s8⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_s16⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_s32⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_s64⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_u8⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_u16⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_u32⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vornq_u64⚠Experimental `neon`

Vector bitwise inclusive OR NOT

vorr_s8⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_s16⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_s32⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_s64⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_u8⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_u16⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_u32⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorr_u64⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_s8⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_s16⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_s32⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_s64⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_u8⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_u16⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_u32⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vorrq_u64⚠Experimental `neon`

Vector bitwise or (immediate, inclusive)

vpadal_s8⚠Experimental `neon`

Signed Add and Accumulate Long Pairwise.

vpadal_s16⚠Experimental `neon`

Signed Add and Accumulate Long Pairwise.

vpadal_s32⚠Experimental `neon`

Signed Add and Accumulate Long Pairwise.

vpadal_u8⚠Experimental `neon`

Unsigned Add and Accumulate Long Pairwise.

vpadal_u16⚠Experimental `neon`

Unsigned Add and Accumulate Long Pairwise.

vpadal_u32⚠Experimental `neon`

Unsigned Add and Accumulate Long Pairwise.

vpadalq_s8⚠Experimental `neon`

Signed Add and Accumulate Long Pairwise.

vpadalq_s16⚠Experimental `neon`

Signed Add and Accumulate Long Pairwise.

vpadalq_s32⚠Experimental `neon`

Signed Add and Accumulate Long Pairwise.

vpadalq_u8⚠Experimental `neon`

Unsigned Add and Accumulate Long Pairwise.

vpadalq_u16⚠Experimental `neon`

Unsigned Add and Accumulate Long Pairwise.

vpadalq_u32⚠Experimental `neon`

Unsigned Add and Accumulate Long Pairwise.

vpadd_s8⚠Experimental `neon`

Add pairwise.

vpadd_s16⚠Experimental `neon`

Add pairwise.

vpadd_s32⚠Experimental `neon`

Add pairwise.

vpadd_u8⚠Experimental `neon`

Add pairwise.

vpadd_u16⚠Experimental `neon`

Add pairwise.

vpadd_u32⚠Experimental `neon`

Add pairwise.

vpaddd_s64⚠Experimental `neon`

Add pairwise

vpaddd_u64⚠Experimental `neon`

Add pairwise

vpaddl_s8⚠Experimental `neon`

Signed Add Long Pairwise.

vpaddl_s16⚠Experimental `neon`

Signed Add Long Pairwise.

vpaddl_s32⚠Experimental `neon`

Signed Add Long Pairwise.

vpaddl_u8⚠Experimental `neon`

Unsigned Add Long Pairwise.

vpaddl_u16⚠Experimental `neon`

Unsigned Add Long Pairwise.

vpaddl_u32⚠Experimental `neon`

Unsigned Add Long Pairwise.

vpaddlq_s8⚠Experimental `neon`

Signed Add Long Pairwise.

vpaddlq_s16⚠Experimental `neon`

Signed Add Long Pairwise.

vpaddlq_s32⚠Experimental `neon`

Signed Add Long Pairwise.

vpaddlq_u8⚠Experimental `neon`

Unsigned Add Long Pairwise.

vpaddlq_u16⚠Experimental `neon`

Unsigned Add Long Pairwise.

vpaddlq_u32⚠Experimental `neon`

Unsigned Add Long Pairwise.

vpaddq_s8⚠Experimental `neon`

Add pairwise

vpaddq_s16⚠Experimental `neon`

Add pairwise

vpaddq_s32⚠Experimental `neon`

Add pairwise

vpaddq_u8⚠Experimental `neon`

Add pairwise

vpaddq_u16⚠Experimental `neon`

Add pairwise

vpaddq_u32⚠Experimental `neon`

Add pairwise

vpmax_f32⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmax_s8⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmax_s16⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmax_s32⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmax_u8⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmax_u16⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmax_u32⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxnm_f32⚠Experimental `neon`

Floating-point Maximum Number Pairwise (vector).

vpmaxnmq_f32⚠Experimental `neon`

Floating-point Maximum Number Pairwise (vector).

vpmaxnmq_f64⚠Experimental `neon`

Floating-point Maximum Number Pairwise (vector).

vpmaxq_f32⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_f64⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_s8⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_s16⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_s32⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_u8⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_u16⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmaxq_u32⚠Experimental `neon`

Folding maximum of adjacent pairs

vpmin_f32⚠Experimental `neon`

Folding minimum of adjacent pairs

vpmin_s8⚠Experimental `neon`

Folding minimum of adjacent pairs

vpmin_s16⚠Experimental `neon`

Folding minimum of adjacent pairs

vpmin_s32⚠Experimental `neon`

Folding minimum of adjacent pairs

vpmin_u8⚠Experimental `neon`

Folding minimum of adjacent pairs

vpmin_u16⚠Experimental `neon`

Folding minimum of adjacent pairs

vpmin_u32⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminnm_f32⚠Experimental `neon`

Floating-point Minimum Number Pairwise (vector).

vpminnmq_f32⚠Experimental `neon`

Floating-point Minimum Number Pairwise (vector).

vpminnmq_f64⚠Experimental `neon`

Floating-point Minimum Number Pairwise (vector).

vpminq_f32⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_f64⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_s8⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_s16⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_s32⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_u8⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_u16⚠Experimental `neon`

Folding minimum of adjacent pairs

vpminq_u32⚠Experimental `neon`

Folding minimum of adjacent pairs

vqabs_s8⚠Experimental `neon`

Singned saturating Absolute value

vqabs_s16⚠Experimental `neon`

Singned saturating Absolute value

vqabs_s32⚠Experimental `neon`

Singned saturating Absolute value

vqabs_s64⚠Experimental `neon`

Singned saturating Absolute value

vqabsq_s8⚠Experimental `neon`

Singned saturating Absolute value

vqabsq_s16⚠Experimental `neon`

Singned saturating Absolute value

vqabsq_s32⚠Experimental `neon`

Singned saturating Absolute value

vqabsq_s64⚠Experimental `neon`

Singned saturating Absolute value

vqadd_s8⚠Experimental `neon`

Saturating add

vqadd_s16⚠Experimental `neon`

Saturating add

vqadd_s32⚠Experimental `neon`

Saturating add

vqadd_s64⚠Experimental `neon`

Saturating add

vqadd_u8⚠Experimental `neon`

Saturating add

vqadd_u16⚠Experimental `neon`

Saturating add

vqadd_u32⚠Experimental `neon`

Saturating add

vqadd_u64⚠Experimental `neon`

Saturating add

vqaddb_s8⚠Experimental `neon`

Saturating add

vqaddb_u8⚠Experimental `neon`

Saturating add

vqaddd_s64⚠Experimental `neon`

Saturating add

vqaddd_u64⚠Experimental `neon`

Saturating add

vqaddh_s16⚠Experimental `neon`

Saturating add

vqaddh_u16⚠Experimental `neon`

Saturating add

vqaddq_s8⚠Experimental `neon`

Saturating add

vqaddq_s16⚠Experimental `neon`

Saturating add

vqaddq_s32⚠Experimental `neon`

Saturating add

vqaddq_s64⚠Experimental `neon`

Saturating add

vqaddq_u8⚠Experimental `neon`

Saturating add

vqaddq_u16⚠Experimental `neon`

Saturating add

vqaddq_u32⚠Experimental `neon`

Saturating add

vqaddq_u64⚠Experimental `neon`

Saturating add

vqadds_s32⚠Experimental `neon`

Saturating add

vqadds_u32⚠Experimental `neon`

Saturating add

vqdmlal_high_lane_s16⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_lane_s32⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_laneq_s16⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_laneq_s32⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_n_s16⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_n_s32⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_s16⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_high_s32⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_lane_s16⚠Experimental `neon`

Vector widening saturating doubling multiply accumulate with scalar

vqdmlal_lane_s32⚠Experimental `neon`

Vector widening saturating doubling multiply accumulate with scalar

vqdmlal_laneq_s16⚠Experimental `neon`

Vector widening saturating doubling multiply accumulate with scalar

vqdmlal_laneq_s32⚠Experimental `neon`

Vector widening saturating doubling multiply accumulate with scalar

vqdmlal_n_s16⚠Experimental `neon`

Vector widening saturating doubling multiply accumulate with scalar

vqdmlal_n_s32⚠Experimental `neon`

Vector widening saturating doubling multiply accumulate with scalar

vqdmlal_s16⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlal_s32⚠Experimental `neon`

Signed saturating doubling multiply-add long

vqdmlsl_high_lane_s16⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_lane_s32⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_laneq_s16⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_laneq_s32⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_n_s16⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_n_s32⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_s16⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_high_s32⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_lane_s16⚠Experimental `neon`

Vector widening saturating doubling multiply subtract with scalar

vqdmlsl_lane_s32⚠Experimental `neon`

Vector widening saturating doubling multiply subtract with scalar

vqdmlsl_laneq_s16⚠Experimental `neon`

Vector widening saturating doubling multiply subtract with scalar

vqdmlsl_laneq_s32⚠Experimental `neon`

Vector widening saturating doubling multiply subtract with scalar

vqdmlsl_n_s16⚠Experimental `neon`

Vector widening saturating doubling multiply subtract with scalar

vqdmlsl_n_s32⚠Experimental `neon`

Vector widening saturating doubling multiply subtract with scalar

vqdmlsl_s16⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmlsl_s32⚠Experimental `neon`

Signed saturating doubling multiply-subtract long

vqdmulh_n_s16⚠Experimental `neon`

Vector saturating doubling multiply high with scalar

vqdmulh_n_s32⚠Experimental `neon`

Vector saturating doubling multiply high with scalar

vqdmulh_s16⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulh_s32⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhh_lane_s16⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhh_laneq_s16⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhh_s16⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhq_nq_s16⚠Experimental `neon`

Vector saturating doubling multiply high with scalar

vqdmulhq_nq_s32⚠Experimental `neon`

Vector saturating doubling multiply high with scalar

vqdmulhq_s16⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhq_s32⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhs_lane_s32⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhs_laneq_s32⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmulhs_s32⚠Experimental `neon`

Signed saturating doubling multiply returning high half

vqdmull_high_lane_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_lane_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_laneq_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_laneq_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_n_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_n_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_high_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_lane_s16⚠Experimental `neon`

Vector saturating doubling long multiply by scalar

vqdmull_lane_s32⚠Experimental `neon`

Vector saturating doubling long multiply by scalar

vqdmull_laneq_s16⚠Experimental `neon`

Vector saturating doubling long multiply by scalar

vqdmull_laneq_s32⚠Experimental `neon`

Vector saturating doubling long multiply by scalar

vqdmull_n_s16⚠Experimental `neon`

Vector saturating doubling long multiply with scalar

vqdmull_n_s32⚠Experimental `neon`

Vector saturating doubling long multiply with scalar

vqdmull_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmull_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmullh_lane_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmullh_laneq_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmullh_s16⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmulls_lane_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmulls_laneq_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqdmulls_s32⚠Experimental `neon`

Signed saturating doubling multiply long

vqmovn_high_s16⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_high_s32⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_high_s64⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_high_u16⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_high_u32⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_high_u64⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_s16⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_s32⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_s64⚠Experimental `neon`

Signed saturating extract narrow

vqmovn_u16⚠Experimental `neon`

Unsigned saturating extract narrow

vqmovn_u32⚠Experimental `neon`

Unsigned saturating extract narrow

vqmovn_u64⚠Experimental `neon`

Unsigned saturating extract narrow

vqmovnd_s64⚠Experimental `neon`

Saturating extract narrow

vqmovnd_u64⚠Experimental `neon`

Saturating extract narrow

vqmovnh_s16⚠Experimental `neon`

Saturating extract narrow

vqmovnh_u16⚠Experimental `neon`

Saturating extract narrow

vqmovns_s32⚠Experimental `neon`

Saturating extract narrow

vqmovns_u32⚠Experimental `neon`

Saturating extract narrow

vqmovun_high_s16⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovun_high_s32⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovun_high_s64⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovun_s16⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovun_s32⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovun_s64⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovund_s64⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovunh_s16⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqmovuns_s32⚠Experimental `neon`

Signed saturating extract unsigned narrow

vqneg_s8⚠Experimental `neon`

Signed saturating negate

vqneg_s16⚠Experimental `neon`

Signed saturating negate

vqneg_s32⚠Experimental `neon`

Signed saturating negate

vqneg_s64⚠Experimental `neon`

Signed saturating negate

vqnegq_s8⚠Experimental `neon`

Signed saturating negate

vqnegq_s16⚠Experimental `neon`

Signed saturating negate

vqnegq_s32⚠Experimental `neon`

Signed saturating negate

vqnegq_s64⚠Experimental `neon`

Signed saturating negate

vqrdmlah_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlah_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlah_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlah_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlah_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlah_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahh_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahh_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahh_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahq_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahq_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahq_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahq_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahs_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahs_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlahs_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply accumulate returning high half

vqrdmlsh_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlsh_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlsh_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlsh_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlsh_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlsh_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshh_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshh_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshh_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshq_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshq_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshq_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshq_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshs_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshs_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmlshs_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply subtract returning high half

vqrdmulh_lane_s16⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulh_lane_s32⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulh_laneq_s16⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulh_laneq_s32⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulh_n_s16⚠Experimental `neon`

Vector saturating rounding doubling multiply high with scalar

vqrdmulh_n_s32⚠Experimental `neon`

Vector saturating rounding doubling multiply high with scalar

vqrdmulh_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulh_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhh_lane_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhh_laneq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhh_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhq_lane_s16⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulhq_lane_s32⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulhq_laneq_s16⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulhq_laneq_s32⚠Experimental `neon`

Vector rounding saturating doubling multiply high by scalar

vqrdmulhq_n_s16⚠Experimental `neon`

Vector saturating rounding doubling multiply high with scalar

vqrdmulhq_n_s32⚠Experimental `neon`

Vector saturating rounding doubling multiply high with scalar

vqrdmulhq_s16⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhs_lane_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhs_laneq_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrdmulhs_s32⚠Experimental `neon`

Signed saturating rounding doubling multiply returning high half

vqrshl_s8⚠Experimental `neon`

Signed saturating rounding shift left

vqrshl_s16⚠Experimental `neon`

Signed saturating rounding shift left

vqrshl_s32⚠Experimental `neon`

Signed saturating rounding shift left

vqrshl_s64⚠Experimental `neon`

Signed saturating rounding shift left

vqrshl_u8⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshl_u16⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshl_u32⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshl_u64⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshlb_s8⚠Experimental `neon`

Signed saturating rounding shift left

vqrshlb_u8⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshld_s64⚠Experimental `neon`

Signed saturating rounding shift left

vqrshld_u64⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshlh_s16⚠Experimental `neon`

Signed saturating rounding shift left

vqrshlh_u16⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshlq_s8⚠Experimental `neon`

Signed saturating rounding shift left

vqrshlq_s16⚠Experimental `neon`

Signed saturating rounding shift left

vqrshlq_s32⚠Experimental `neon`

Signed saturating rounding shift left

vqrshlq_s64⚠Experimental `neon`

Signed saturating rounding shift left

vqrshlq_u8⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshlq_u16⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshlq_u32⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshlq_u64⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshls_s32⚠Experimental `neon`

Signed saturating rounding shift left

vqrshls_u32⚠Experimental `neon`

Unsigned signed saturating rounding shift left

vqrshrn_high_n_s16⚠Experimental `neon`

Signed saturating rounded shift right narrow

vqrshrn_high_n_s32⚠Experimental `neon`

Signed saturating rounded shift right narrow

vqrshrn_high_n_s64⚠Experimental `neon`

Signed saturating rounded shift right narrow

vqrshrn_high_n_u16⚠Experimental `neon`

Unsigned saturating rounded shift right narrow

vqrshrn_high_n_u32⚠Experimental `neon`

Unsigned saturating rounded shift right narrow

vqrshrn_high_n_u64⚠Experimental `neon`

Unsigned saturating rounded shift right narrow

vqrshrnd_n_s64⚠Experimental `neon`

Signed saturating rounded shift right narrow

vqrshrnd_n_u64⚠Experimental `neon`

Unsigned saturating rounded shift right narrow

vqrshrnh_n_s16⚠Experimental `neon`

Signed saturating rounded shift right narrow

vqrshrnh_n_u16⚠Experimental `neon`

Unsigned saturating rounded shift right narrow

vqrshrns_n_s32⚠Experimental `neon`

Signed saturating rounded shift right narrow

vqrshrns_n_u32⚠Experimental `neon`

Unsigned saturating rounded shift right narrow

vqrshrun_high_n_s16⚠Experimental `neon`

Signed saturating rounded shift right unsigned narrow

vqrshrun_high_n_s32⚠Experimental `neon`

Signed saturating rounded shift right unsigned narrow

vqrshrun_high_n_s64⚠Experimental `neon`

Signed saturating rounded shift right unsigned narrow

vqrshrund_n_s64⚠Experimental `neon`

Signed saturating rounded shift right unsigned narrow

vqrshrunh_n_s16⚠Experimental `neon`

Signed saturating rounded shift right unsigned narrow

vqrshruns_n_s32⚠Experimental `neon`

Signed saturating rounded shift right unsigned narrow

vqshl_n_s8⚠Experimental `neon`

Signed saturating shift left

vqshl_n_s16⚠Experimental `neon`

Signed saturating shift left

vqshl_n_s32⚠Experimental `neon`

Signed saturating shift left

vqshl_n_s64⚠Experimental `neon`

Signed saturating shift left

vqshl_n_u8⚠Experimental `neon`

Unsigned saturating shift left

vqshl_n_u16⚠Experimental `neon`

Unsigned saturating shift left

vqshl_n_u32⚠Experimental `neon`

Unsigned saturating shift left

vqshl_n_u64⚠Experimental `neon`

Unsigned saturating shift left

vqshl_s8⚠Experimental `neon`

Signed saturating shift left

vqshl_s16⚠Experimental `neon`

Signed saturating shift left

vqshl_s32⚠Experimental `neon`

Signed saturating shift left

vqshl_s64⚠Experimental `neon`

Signed saturating shift left

vqshl_u8⚠Experimental `neon`

Unsigned saturating shift left

vqshl_u16⚠Experimental `neon`

Unsigned saturating shift left

vqshl_u32⚠Experimental `neon`

Unsigned saturating shift left

vqshl_u64⚠Experimental `neon`

Unsigned saturating shift left

vqshlb_n_s8⚠Experimental `neon`

Signed saturating shift left

vqshlb_n_u8⚠Experimental `neon`

Unsigned saturating shift left

vqshlb_s8⚠Experimental `neon`

Signed saturating shift left

vqshlb_u8⚠Experimental `neon`

Unsigned saturating shift left

vqshld_n_s64⚠Experimental `neon`

Signed saturating shift left

vqshld_n_u64⚠Experimental `neon`

Unsigned saturating shift left

vqshld_s64⚠Experimental `neon`

Signed saturating shift left

vqshld_u64⚠Experimental `neon`

Unsigned saturating shift left

vqshlh_n_s16⚠Experimental `neon`

Signed saturating shift left

vqshlh_n_u16⚠Experimental `neon`

Unsigned saturating shift left

vqshlh_s16⚠Experimental `neon`

Signed saturating shift left

vqshlh_u16⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_n_s8⚠Experimental `neon`

Signed saturating shift left

vqshlq_n_s16⚠Experimental `neon`

Signed saturating shift left

vqshlq_n_s32⚠Experimental `neon`

Signed saturating shift left

vqshlq_n_s64⚠Experimental `neon`

Signed saturating shift left

vqshlq_n_u8⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_n_u16⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_n_u32⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_n_u64⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_s8⚠Experimental `neon`

Signed saturating shift left

vqshlq_s16⚠Experimental `neon`

Signed saturating shift left

vqshlq_s32⚠Experimental `neon`

Signed saturating shift left

vqshlq_s64⚠Experimental `neon`

Signed saturating shift left

vqshlq_u8⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_u16⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_u32⚠Experimental `neon`

Unsigned saturating shift left

vqshlq_u64⚠Experimental `neon`

Unsigned saturating shift left

vqshls_n_s32⚠Experimental `neon`

Signed saturating shift left

vqshls_n_u32⚠Experimental `neon`

Unsigned saturating shift left

vqshls_s32⚠Experimental `neon`

Signed saturating shift left

vqshls_u32⚠Experimental `neon`

Unsigned saturating shift left

vqshrn_high_n_s16⚠Experimental `neon`

Signed saturating shift right narrow

vqshrn_high_n_s32⚠Experimental `neon`

Signed saturating shift right narrow

vqshrn_high_n_s64⚠Experimental `neon`

Signed saturating shift right narrow

vqshrn_high_n_u16⚠Experimental `neon`

Unsigned saturating shift right narrow

vqshrn_high_n_u32⚠Experimental `neon`

Unsigned saturating shift right narrow

vqshrn_high_n_u64⚠Experimental `neon`

Unsigned saturating shift right narrow

vqshrnd_n_s64⚠Experimental `neon`

Signed saturating shift right narrow

vqshrnd_n_u64⚠Experimental `neon`

Unsigned saturating shift right narrow

vqshrnh_n_s16⚠Experimental `neon`

Signed saturating shift right narrow

vqshrnh_n_u16⚠Experimental `neon`

Unsigned saturating shift right narrow

vqshrns_n_s32⚠Experimental `neon`

Signed saturating shift right narrow

vqshrns_n_u32⚠Experimental `neon`

Unsigned saturating shift right narrow

vqshrun_high_n_s16⚠Experimental `neon`

Signed saturating shift right unsigned narrow

vqshrun_high_n_s32⚠Experimental `neon`

Signed saturating shift right unsigned narrow

vqshrun_high_n_s64⚠Experimental `neon`

Signed saturating shift right unsigned narrow

vqshrund_n_s64⚠Experimental `neon`

Signed saturating shift right unsigned narrow

vqshrunh_n_s16⚠Experimental `neon`

Signed saturating shift right unsigned narrow

vqshruns_n_s32⚠Experimental `neon`

Signed saturating shift right unsigned narrow

vqsub_s8⚠Experimental `neon`

Saturating subtract

vqsub_s16⚠Experimental `neon`

Saturating subtract

vqsub_s32⚠Experimental `neon`

Saturating subtract

vqsub_s64⚠Experimental `neon`

Saturating subtract

vqsub_u8⚠Experimental `neon`

Saturating subtract

vqsub_u16⚠Experimental `neon`

Saturating subtract

vqsub_u32⚠Experimental `neon`

Saturating subtract

vqsub_u64⚠Experimental `neon`

Saturating subtract

vqsubb_s8⚠Experimental `neon`

Saturating subtract

vqsubb_u8⚠Experimental `neon`

Saturating subtract

vqsubd_s64⚠Experimental `neon`

Saturating subtract

vqsubd_u64⚠Experimental `neon`

Saturating subtract

vqsubh_s16⚠Experimental `neon`

Saturating subtract

vqsubh_u16⚠Experimental `neon`

Saturating subtract

vqsubq_s8⚠Experimental `neon`

Saturating subtract

vqsubq_s16⚠Experimental `neon`

Saturating subtract

vqsubq_s32⚠Experimental `neon`

Saturating subtract

vqsubq_s64⚠Experimental `neon`

Saturating subtract

vqsubq_u8⚠Experimental `neon`

Saturating subtract

vqsubq_u16⚠Experimental `neon`

Saturating subtract

vqsubq_u32⚠Experimental `neon`

Saturating subtract

vqsubq_u64⚠Experimental `neon`

Saturating subtract

vqsubs_s32⚠Experimental `neon`

Saturating subtract

vqsubs_u32⚠Experimental `neon`

Saturating subtract

vqtbl1_p8⚠Experimental `neon`

Table look-up

vqtbl1_s8⚠Experimental `neon`

Table look-up

vqtbl1_u8⚠Experimental `neon`

Table look-up

vqtbl1q_p8⚠Experimental `neon`

Table look-up

vqtbl1q_s8⚠Experimental `neon`

Table look-up

vqtbl1q_u8⚠Experimental `neon`

Table look-up

vqtbl2_p8⚠Experimental `neon`

Table look-up

vqtbl2_s8⚠Experimental `neon`

Table look-up

vqtbl2_u8⚠Experimental `neon`

Table look-up

vqtbl2q_p8⚠Experimental `neon`

Table look-up

vqtbl2q_s8⚠Experimental `neon`

Table look-up

vqtbl2q_u8⚠Experimental `neon`

Table look-up

vqtbl3_p8⚠Experimental `neon`

Table look-up

vqtbl3_s8⚠Experimental `neon`

Table look-up

vqtbl3_u8⚠Experimental `neon`

Table look-up

vqtbl3q_p8⚠Experimental `neon`

Table look-up

vqtbl3q_s8⚠Experimental `neon`

Table look-up

vqtbl3q_u8⚠Experimental `neon`

Table look-up

vqtbl4_p8⚠Experimental `neon`

Table look-up

vqtbl4_s8⚠Experimental `neon`

Table look-up

vqtbl4_u8⚠Experimental `neon`

Table look-up

vqtbl4q_p8⚠Experimental `neon`

Table look-up

vqtbl4q_s8⚠Experimental `neon`

Table look-up

vqtbl4q_u8⚠Experimental `neon`

Table look-up

vqtbx1_p8⚠Experimental `neon`

Extended table look-up

vqtbx1_s8⚠Experimental `neon`

Extended table look-up

vqtbx1_u8⚠Experimental `neon`

Extended table look-up

vqtbx1q_p8⚠Experimental `neon`

Extended table look-up

vqtbx1q_s8⚠Experimental `neon`

Extended table look-up

vqtbx1q_u8⚠Experimental `neon`

Extended table look-up

vqtbx2_p8⚠Experimental `neon`

Extended table look-up

vqtbx2_s8⚠Experimental `neon`

Extended table look-up

vqtbx2_u8⚠Experimental `neon`

Extended table look-up

vqtbx2q_p8⚠Experimental `neon`

Extended table look-up

vqtbx2q_s8⚠Experimental `neon`

Extended table look-up

vqtbx2q_u8⚠Experimental `neon`

Extended table look-up

vqtbx3_p8⚠Experimental `neon`

Extended table look-up

vqtbx3_s8⚠Experimental `neon`

Extended table look-up

vqtbx3_u8⚠Experimental `neon`

Extended table look-up

vqtbx3q_p8⚠Experimental `neon`

Extended table look-up

vqtbx3q_s8⚠Experimental `neon`

Extended table look-up

vqtbx3q_u8⚠Experimental `neon`

Extended table look-up

vqtbx4_p8⚠Experimental `neon`

Extended table look-up

vqtbx4_s8⚠Experimental `neon`

Extended table look-up

vqtbx4_u8⚠Experimental `neon`

Extended table look-up

vqtbx4q_p8⚠Experimental `neon`

Extended table look-up

vqtbx4q_s8⚠Experimental `neon`

Extended table look-up

vqtbx4q_u8⚠Experimental `neon`

Extended table look-up

vraddhn_high_s16⚠Experimental `neon`

Rounding Add returning High Narrow (high half).

vraddhn_high_s32⚠Experimental `neon`

Rounding Add returning High Narrow (high half).

vraddhn_high_s64⚠Experimental `neon`

Rounding Add returning High Narrow (high half).

vraddhn_high_u16⚠Experimental `neon`

Rounding Add returning High Narrow (high half).

vraddhn_high_u32⚠Experimental `neon`

Rounding Add returning High Narrow (high half).

vraddhn_high_u64⚠Experimental `neon`

Rounding Add returning High Narrow (high half).

vraddhn_s16⚠Experimental `neon`

Rounding Add returning High Narrow.

vraddhn_s32⚠Experimental `neon`

Rounding Add returning High Narrow.

vraddhn_s64⚠Experimental `neon`

Rounding Add returning High Narrow.

vraddhn_u16⚠Experimental `neon`

Rounding Add returning High Narrow.

vraddhn_u32⚠Experimental `neon`

Rounding Add returning High Narrow.

vraddhn_u64⚠Experimental `neon`

Rounding Add returning High Narrow.

vrbit_p8⚠Experimental `neon`

Reverse bit order

vrbit_s8⚠Experimental `neon`

Reverse bit order

vrbit_u8⚠Experimental `neon`

Reverse bit order

vrbitq_p8⚠Experimental `neon`

Reverse bit order

vrbitq_s8⚠Experimental `neon`

Reverse bit order

vrbitq_u8⚠Experimental `neon`

Reverse bit order

vrecpe_f32⚠Experimental `neon`

Reciprocal estimate.

vrecpe_f64⚠Experimental `neon`

Reciprocal estimate.

vrecpeq_f32⚠Experimental `neon`

Reciprocal estimate.

vrecpeq_f64⚠Experimental `neon`

Reciprocal estimate.

vreinterpret_f32_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f32_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_f64_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p8_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p16_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_p64_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s8_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s16_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s32_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_s64_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u8_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u16_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u32_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpret_u64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f32_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_f64_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p8_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p16_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_p64_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s8_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s16_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s32_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_s64_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u8_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_u32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u16_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u32_u64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_f32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_f64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_p8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_p16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_p64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_s8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_s16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_s32⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_s64⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_u8⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_u16⚠Experimental `neon`

Vector reinterpret cast operation

vreinterpretq_u64_u32⚠Experimental `neon`

Vector reinterpret cast operation

vrev16_p8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev16_s8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev16_u8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev16q_p8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev16q_s8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev16q_u8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32_p8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32_p16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32_s8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32_s16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32_u8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32_u16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32q_p8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32q_p16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32q_s8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32q_s16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32q_u8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev32q_u16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_f32⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_p8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_p16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_s8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_s16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_s32⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_u8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_u16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64_u32⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_f32⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_p8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_p16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_s8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_s16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_s32⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_u8⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_u16⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrev64q_u32⚠Experimental `neon`

Reversing vector elements (swap endianness)

vrhadd_s8⚠Experimental `neon`

Rounding halving add

vrhadd_s16⚠Experimental `neon`

Rounding halving add

vrhadd_s32⚠Experimental `neon`

Rounding halving add

vrhadd_u8⚠Experimental `neon`

Rounding halving add

vrhadd_u16⚠Experimental `neon`

Rounding halving add

vrhadd_u32⚠Experimental `neon`

Rounding halving add

vrhaddq_s8⚠Experimental `neon`

Rounding halving add

vrhaddq_s16⚠Experimental `neon`

Rounding halving add

vrhaddq_s32⚠Experimental `neon`

Rounding halving add

vrhaddq_u8⚠Experimental `neon`

Rounding halving add

vrhaddq_u16⚠Experimental `neon`

Rounding halving add

vrhaddq_u32⚠Experimental `neon`

Rounding halving add

vrnd_f32⚠Experimental `neon`

Floating-point round to integral, toward zero

vrnd_f64⚠Experimental `neon`

Floating-point round to integral, toward zero

vrnda_f32⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to away

vrnda_f64⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to away

vrndaq_f32⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to away

vrndaq_f64⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to away

vrndi_f32⚠Experimental `neon`

Floating-point round to integral, using current rounding mode

vrndi_f64⚠Experimental `neon`

Floating-point round to integral, using current rounding mode

vrndiq_f32⚠Experimental `neon`

Floating-point round to integral, using current rounding mode

vrndiq_f64⚠Experimental `neon`

Floating-point round to integral, using current rounding mode

vrndm_f32⚠Experimental `neon`

Floating-point round to integral, toward minus infinity

vrndm_f64⚠Experimental `neon`

Floating-point round to integral, toward minus infinity

vrndmq_f32⚠Experimental `neon`

Floating-point round to integral, toward minus infinity

vrndmq_f64⚠Experimental `neon`

Floating-point round to integral, toward minus infinity

vrndn_f32⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to even

vrndn_f64⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to even

vrndnq_f32⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to even

vrndnq_f64⚠Experimental `neon`

Floating-point round to integral, to nearest with ties to even

vrndp_f32⚠Experimental `neon`

Floating-point round to integral, toward plus infinity

vrndp_f64⚠Experimental `neon`

Floating-point round to integral, toward plus infinity

vrndpq_f32⚠Experimental `neon`

Floating-point round to integral, toward plus infinity

vrndpq_f64⚠Experimental `neon`

Floating-point round to integral, toward plus infinity

vrndq_f32⚠Experimental `neon`

Floating-point round to integral, toward zero

vrndq_f64⚠Experimental `neon`

Floating-point round to integral, toward zero

vrndx_f32⚠Experimental `neon`

Floating-point round to integral exact, using current rounding mode

vrndx_f64⚠Experimental `neon`

Floating-point round to integral exact, using current rounding mode

vrndxq_f32⚠Experimental `neon`

Floating-point round to integral exact, using current rounding mode

vrndxq_f64⚠Experimental `neon`

Floating-point round to integral exact, using current rounding mode

vrshl_s8⚠Experimental `neon`

Signed rounding shift left

vrshl_s16⚠Experimental `neon`

Signed rounding shift left

vrshl_s32⚠Experimental `neon`

Signed rounding shift left

vrshl_s64⚠Experimental `neon`

Signed rounding shift left

vrshl_u8⚠Experimental `neon`

Unsigned rounding shift left

vrshl_u16⚠Experimental `neon`

Unsigned rounding shift left

vrshl_u32⚠Experimental `neon`

Unsigned rounding shift left

vrshl_u64⚠Experimental `neon`

Unsigned rounding shift left

vrshld_s64⚠Experimental `neon`

Signed rounding shift left

vrshld_u64⚠Experimental `neon`

Unsigned rounding shift left

vrshlq_s8⚠Experimental `neon`

Signed rounding shift left

vrshlq_s16⚠Experimental `neon`

Signed rounding shift left

vrshlq_s32⚠Experimental `neon`

Signed rounding shift left

vrshlq_s64⚠Experimental `neon`

Signed rounding shift left

vrshlq_u8⚠Experimental `neon`

Unsigned rounding shift left

vrshlq_u16⚠Experimental `neon`

Unsigned rounding shift left

vrshlq_u32⚠Experimental `neon`

Unsigned rounding shift left

vrshlq_u64⚠Experimental `neon`

Unsigned rounding shift left

vrshr_n_s8⚠Experimental `neon`

Signed rounding shift right

vrshr_n_s16⚠Experimental `neon`

Signed rounding shift right

vrshr_n_s32⚠Experimental `neon`

Signed rounding shift right

vrshr_n_s64⚠Experimental `neon`

Signed rounding shift right

vrshr_n_u8⚠Experimental `neon`

Unsigned rounding shift right

vrshr_n_u16⚠Experimental `neon`

Unsigned rounding shift right

vrshr_n_u32⚠Experimental `neon`

Unsigned rounding shift right

vrshr_n_u64⚠Experimental `neon`

Unsigned rounding shift right

vrshrd_n_s64⚠Experimental `neon`

Signed rounding shift right

vrshrd_n_u64⚠Experimental `neon`

Unsigned rounding shift right

vrshrn_high_n_s16⚠Experimental `neon`

Rounding shift right narrow

vrshrn_high_n_s32⚠Experimental `neon`

Rounding shift right narrow

vrshrn_high_n_s64⚠Experimental `neon`

Rounding shift right narrow

vrshrn_high_n_u16⚠Experimental `neon`

Rounding shift right narrow

vrshrn_high_n_u32⚠Experimental `neon`

Rounding shift right narrow

vrshrn_high_n_u64⚠Experimental `neon`

Rounding shift right narrow

vrshrn_n_u16⚠Experimental `neon`

Rounding shift right narrow

vrshrn_n_u32⚠Experimental `neon`

Rounding shift right narrow

vrshrn_n_u64⚠Experimental `neon`

Rounding shift right narrow

vrshrq_n_s8⚠Experimental `neon`

Signed rounding shift right

vrshrq_n_s16⚠Experimental `neon`

Signed rounding shift right

vrshrq_n_s32⚠Experimental `neon`

Signed rounding shift right

vrshrq_n_s64⚠Experimental `neon`

Signed rounding shift right

vrshrq_n_u8⚠Experimental `neon`

Unsigned rounding shift right

vrshrq_n_u16⚠Experimental `neon`

Unsigned rounding shift right

vrshrq_n_u32⚠Experimental `neon`

Unsigned rounding shift right

vrshrq_n_u64⚠Experimental `neon`

Unsigned rounding shift right

vrsqrte_f32⚠Experimental `neon`

Reciprocal square-root estimate.

vrsqrte_f64⚠Experimental `neon`

Reciprocal square-root estimate.

vrsqrteq_f32⚠Experimental `neon`

Reciprocal square-root estimate.

vrsqrteq_f64⚠Experimental `neon`

Reciprocal square-root estimate.

vrsra_n_s8⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsra_n_s16⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsra_n_s32⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsra_n_s64⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsra_n_u8⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsra_n_u16⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsra_n_u32⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsra_n_u64⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsrad_n_s64⚠Experimental `neon`

Signed rounding shift right and accumulate.

vrsrad_n_u64⚠Experimental `neon`

Ungisned rounding shift right and accumulate.

vrsraq_n_s8⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsraq_n_s16⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsraq_n_s32⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsraq_n_s64⚠Experimental `neon`

Signed rounding shift right and accumulate

vrsraq_n_u8⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsraq_n_u16⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsraq_n_u32⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vrsraq_n_u64⚠Experimental `neon`

Unsigned rounding shift right and accumulate

vset_lane_f32⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_f64⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_p8⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_p16⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_p64⚠Experimental `neon,crypto`

Insert vector element from another vector element

vset_lane_s8⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_s16⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_s32⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_s64⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_u8⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_u16⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_u32⚠Experimental `neon`

Insert vector element from another vector element

vset_lane_u64⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_f32⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_f64⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_p8⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_p16⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_p64⚠Experimental `neon,crypto`

Insert vector element from another vector element

vsetq_lane_s8⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_s16⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_s32⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_s64⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_u8⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_u16⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_u32⚠Experimental `neon`

Insert vector element from another vector element

vsetq_lane_u64⚠Experimental `neon`

Insert vector element from another vector element

vsha1cq_u32⚠Experimental `sha2`

SHA1 hash update accelerator, choose.

vsha1h_u32⚠Experimental `sha2`

SHA1 fixed rotate.

vsha1mq_u32⚠Experimental `sha2`

SHA1 hash update accelerator, majority.

vsha1pq_u32⚠Experimental `sha2`

SHA1 hash update accelerator, parity.

vsha1su0q_u32⚠Experimental `sha2`

SHA1 schedule update accelerator, first part.

vsha1su1q_u32⚠Experimental `sha2`

SHA1 schedule update accelerator, second part.

vsha256h2q_u32⚠Experimental `sha2`

SHA256 hash update accelerator, upper part.

vsha256hq_u32⚠Experimental `sha2`

SHA256 hash update accelerator.

vsha256su0q_u32⚠Experimental `sha2`

SHA256 schedule update accelerator, first part.

vsha256su1q_u32⚠Experimental `sha2`

SHA256 schedule update accelerator, second part.

vshl_n_s8⚠Experimental `neon`

Shift left

vshl_n_s16⚠Experimental `neon`

Shift left

vshl_n_s32⚠Experimental `neon`

Shift left

vshl_n_s64⚠Experimental `neon`

Shift left

vshl_n_u8⚠Experimental `neon`

Shift left

vshl_n_u16⚠Experimental `neon`

Shift left

vshl_n_u32⚠Experimental `neon`

Shift left

vshl_n_u64⚠Experimental `neon`

Shift left

vshl_s8⚠Experimental `neon`

Signed Shift left

vshl_s16⚠Experimental `neon`

Signed Shift left

vshl_s32⚠Experimental `neon`

Signed Shift left

vshl_s64⚠Experimental `neon`

Signed Shift left

vshl_u8⚠Experimental `neon`

Unsigned Shift left

vshl_u16⚠Experimental `neon`

Unsigned Shift left

vshl_u32⚠Experimental `neon`

Unsigned Shift left

vshl_u64⚠Experimental `neon`

Unsigned Shift left

vshld_n_s64⚠Experimental `neon`

Shift left

vshld_n_u64⚠Experimental `neon`

Shift left

vshld_s64⚠Experimental `neon`

Signed Shift left

vshld_u64⚠Experimental `neon`

Unsigned Shift left

vshll_high_n_s8⚠Experimental `neon`

Signed shift left long

vshll_high_n_s16⚠Experimental `neon`

Signed shift left long

vshll_high_n_s32⚠Experimental `neon`

Signed shift left long

vshll_high_n_u8⚠Experimental `neon`

Signed shift left long

vshll_high_n_u16⚠Experimental `neon`

Signed shift left long

vshll_high_n_u32⚠Experimental `neon`

Signed shift left long

vshll_n_s8⚠Experimental `neon`

Signed shift left long

vshll_n_s16⚠Experimental `neon`

Signed shift left long

vshll_n_s32⚠Experimental `neon`

Signed shift left long

vshll_n_u8⚠Experimental `neon`

Signed shift left long

vshll_n_u16⚠Experimental `neon`

Signed shift left long

vshll_n_u32⚠Experimental `neon`

Signed shift left long

vshlq_n_s8⚠Experimental `neon`

Shift left

vshlq_n_s16⚠Experimental `neon`

Shift left

vshlq_n_s32⚠Experimental `neon`

Shift left

vshlq_n_s64⚠Experimental `neon`

Shift left

vshlq_n_u8⚠Experimental `neon`

Shift left

vshlq_n_u16⚠Experimental `neon`

Shift left

vshlq_n_u32⚠Experimental `neon`

Shift left

vshlq_n_u64⚠Experimental `neon`

Shift left

vshlq_s8⚠Experimental `neon`

Signed Shift left

vshlq_s16⚠Experimental `neon`

Signed Shift left

vshlq_s32⚠Experimental `neon`

Signed Shift left

vshlq_s64⚠Experimental `neon`

Signed Shift left

vshlq_u8⚠Experimental `neon`

Unsigned Shift left

vshlq_u16⚠Experimental `neon`

Unsigned Shift left

vshlq_u32⚠Experimental `neon`

Unsigned Shift left

vshlq_u64⚠Experimental `neon`

Unsigned Shift left

vshr_n_s8⚠Experimental `neon`

Shift right

vshr_n_s16⚠Experimental `neon`

Shift right

vshr_n_s32⚠Experimental `neon`

Shift right

vshr_n_s64⚠Experimental `neon`

Shift right

vshr_n_u8⚠Experimental `neon`

Shift right

vshr_n_u16⚠Experimental `neon`

Shift right

vshr_n_u32⚠Experimental `neon`

Shift right

vshr_n_u64⚠Experimental `neon`

Shift right

vshrd_n_s64⚠Experimental `neon`

Signed shift right

vshrd_n_u64⚠Experimental `neon`

Unsigned shift right

vshrn_high_n_s16⚠Experimental `neon`

Shift right narrow

vshrn_high_n_s32⚠Experimental `neon`

Shift right narrow

vshrn_high_n_s64⚠Experimental `neon`

Shift right narrow

vshrn_high_n_u16⚠Experimental `neon`

Shift right narrow

vshrn_high_n_u32⚠Experimental `neon`

Shift right narrow

vshrn_high_n_u64⚠Experimental `neon`

Shift right narrow

vshrn_n_s16⚠Experimental `neon`

Shift right narrow

vshrn_n_s32⚠Experimental `neon`

Shift right narrow

vshrn_n_s64⚠Experimental `neon`

Shift right narrow

vshrn_n_u16⚠Experimental `neon`

Shift right narrow

vshrn_n_u32⚠Experimental `neon`

Shift right narrow

vshrn_n_u64⚠Experimental `neon`

Shift right narrow

vshrq_n_s8⚠Experimental `neon`

Shift right

vshrq_n_s16⚠Experimental `neon`

Shift right

vshrq_n_s32⚠Experimental `neon`

Shift right

vshrq_n_s64⚠Experimental `neon`

Shift right

vshrq_n_u8⚠Experimental `neon`

Shift right

vshrq_n_u16⚠Experimental `neon`

Shift right

vshrq_n_u32⚠Experimental `neon`

Shift right

vshrq_n_u64⚠Experimental `neon`

Shift right

vsli_n_p8⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_p16⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_s8⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_s16⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_s32⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_s64⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_u8⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_u16⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_u32⚠Experimental `neon`

Shift Left and Insert (immediate)

vsli_n_u64⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_p8⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_p16⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_s8⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_s16⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_s32⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_s64⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_u8⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_u16⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_u32⚠Experimental `neon`

Shift Left and Insert (immediate)

vsliq_n_u64⚠Experimental `neon`

Shift Left and Insert (immediate)

vsqadd_u8⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqadd_u16⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqadd_u32⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqadd_u64⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqaddq_u8⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqaddq_u16⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqaddq_u32⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqaddq_u64⚠Experimental `neon`

Unsigned saturating Accumulate of Signed value.

vsqrt_f32⚠Experimental `neon`

Calculates the square root of each lane.

vsqrt_f64⚠Experimental `neon`

Calculates the square root of each lane.

vsqrtq_f32⚠Experimental `neon`

Calculates the square root of each lane.

vsqrtq_f64⚠Experimental `neon`

Calculates the square root of each lane.

vsra_n_s8⚠Experimental `neon`

Signed shift right and accumulate

vsra_n_s16⚠Experimental `neon`

Signed shift right and accumulate

vsra_n_s32⚠Experimental `neon`

Signed shift right and accumulate

vsra_n_s64⚠Experimental `neon`

Signed shift right and accumulate

vsra_n_u8⚠Experimental `neon`

Unsigned shift right and accumulate

vsra_n_u16⚠Experimental `neon`

Unsigned shift right and accumulate

vsra_n_u32⚠Experimental `neon`

Unsigned shift right and accumulate

vsra_n_u64⚠Experimental `neon`

Unsigned shift right and accumulate

vsrad_n_s64⚠Experimental `neon`

Signed shift right and accumulate

vsrad_n_u64⚠Experimental `neon`

Unsigned shift right and accumulate

vsraq_n_s8⚠Experimental `neon`

Signed shift right and accumulate

vsraq_n_s16⚠Experimental `neon`

Signed shift right and accumulate

vsraq_n_s32⚠Experimental `neon`

Signed shift right and accumulate

vsraq_n_s64⚠Experimental `neon`

Signed shift right and accumulate

vsraq_n_u8⚠Experimental `neon`

Unsigned shift right and accumulate

vsraq_n_u16⚠Experimental `neon`

Unsigned shift right and accumulate

vsraq_n_u32⚠Experimental `neon`

Unsigned shift right and accumulate

vsraq_n_u64⚠Experimental `neon`

Unsigned shift right and accumulate

vsri_n_p8⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_p16⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_s8⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_s16⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_s32⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_s64⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_u8⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_u16⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_u32⚠Experimental `neon`

Shift Right and Insert (immediate)

vsri_n_u64⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_p8⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_p16⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_s8⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_s16⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_s32⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_s64⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_u8⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_u16⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_u32⚠Experimental `neon`

Shift Right and Insert (immediate)

vsriq_n_u64⚠Experimental `neon`

Shift Right and Insert (immediate)

vst1_f32⚠Experimental `neon`
vst1_f64⚠Experimental `neon`
vst1_p8⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_p16⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_p64⚠Experimental `neon`
vst1_s8⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_s16⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_s32⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_s64⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_u8⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_u16⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_u32⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1_u64⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_f32⚠Experimental `neon`
vst1q_f64⚠Experimental `neon`
vst1q_p8⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_p16⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_p64⚠Experimental `neon`
vst1q_s8⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_s16⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_s32⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_s64⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_u8⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_u16⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_u32⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vst1q_u64⚠Experimental `neon`

Store multiple single-element structures from one, two, three, or four registers.

vsub_f32⚠Experimental `neon`

Subtract

vsub_f64⚠Experimental `neon`

Subtract

vsub_s8⚠Experimental `neon`

Subtract

vsub_s16⚠Experimental `neon`

Subtract

vsub_s32⚠Experimental `neon`

Subtract

vsub_s64⚠Experimental `neon`

Subtract

vsub_u8⚠Experimental `neon`

Subtract

vsub_u16⚠Experimental `neon`

Subtract

vsub_u32⚠Experimental `neon`

Subtract

vsub_u64⚠Experimental `neon`

Subtract

vsubhn_high_s16⚠Experimental `neon`

Subtract returning high narrow

vsubhn_high_s32⚠Experimental `neon`

Subtract returning high narrow

vsubhn_high_s64⚠Experimental `neon`

Subtract returning high narrow

vsubhn_high_u16⚠Experimental `neon`

Subtract returning high narrow

vsubhn_high_u32⚠Experimental `neon`

Subtract returning high narrow

vsubhn_high_u64⚠Experimental `neon`

Subtract returning high narrow

vsubhn_s16⚠Experimental `neon`

Subtract returning high narrow

vsubhn_s32⚠Experimental `neon`

Subtract returning high narrow

vsubhn_s64⚠Experimental `neon`

Subtract returning high narrow

vsubhn_u16⚠Experimental `neon`

Subtract returning high narrow

vsubhn_u32⚠Experimental `neon`

Subtract returning high narrow

vsubhn_u64⚠Experimental `neon`

Subtract returning high narrow

vsubl_high_s8⚠Experimental `neon`

Signed Subtract Long

vsubl_high_s16⚠Experimental `neon`

Signed Subtract Long

vsubl_high_s32⚠Experimental `neon`

Signed Subtract Long

vsubl_high_u8⚠Experimental `neon`

Unsigned Subtract Long

vsubl_high_u16⚠Experimental `neon`

Unsigned Subtract Long

vsubl_high_u32⚠Experimental `neon`

Unsigned Subtract Long

vsubl_s8⚠Experimental `neon`

Signed Subtract Long

vsubl_s16⚠Experimental `neon`

Signed Subtract Long

vsubl_s32⚠Experimental `neon`

Signed Subtract Long

vsubl_u8⚠Experimental `neon`

Unsigned Subtract Long

vsubl_u16⚠Experimental `neon`

Unsigned Subtract Long

vsubl_u32⚠Experimental `neon`

Unsigned Subtract Long

vsubq_f32⚠Experimental `neon`

Subtract

vsubq_f64⚠Experimental `neon`

Subtract

vsubq_s8⚠Experimental `neon`

Subtract

vsubq_s16⚠Experimental `neon`

Subtract

vsubq_s32⚠Experimental `neon`

Subtract

vsubq_s64⚠Experimental `neon`

Subtract

vsubq_u8⚠Experimental `neon`

Subtract

vsubq_u16⚠Experimental `neon`

Subtract

vsubq_u32⚠Experimental `neon`

Subtract

vsubq_u64⚠Experimental `neon`

Subtract

vsubw_high_s8⚠Experimental `neon`

Signed Subtract Wide

vsubw_high_s16⚠Experimental `neon`

Signed Subtract Wide

vsubw_high_s32⚠Experimental `neon`

Signed Subtract Wide

vsubw_high_u8⚠Experimental `neon`

Unsigned Subtract Wide

vsubw_high_u16⚠Experimental `neon`

Unsigned Subtract Wide

vsubw_high_u32⚠Experimental `neon`

Unsigned Subtract Wide

vsubw_s8⚠Experimental `neon`

Signed Subtract Wide

vsubw_s16⚠Experimental `neon`

Signed Subtract Wide

vsubw_s32⚠Experimental `neon`

Signed Subtract Wide

vsubw_u8⚠Experimental `neon`

Unsigned Subtract Wide

vsubw_u16⚠Experimental `neon`

Unsigned Subtract Wide

vsubw_u32⚠Experimental `neon`

Unsigned Subtract Wide

vtbl1_p8⚠Experimental `neon`

Table look-up

vtbl1_s8⚠Experimental `neon`

Table look-up

vtbl1_u8⚠Experimental `neon`

Table look-up

vtbl2_p8⚠Experimental `neon`

Table look-up

vtbl2_s8⚠Experimental `neon`

Table look-up

vtbl2_u8⚠Experimental `neon`

Table look-up

vtbl3_p8⚠Experimental `neon`

Table look-up

vtbl3_s8⚠Experimental `neon`

Table look-up

vtbl3_u8⚠Experimental `neon`

Table look-up

vtbl4_p8⚠Experimental `neon`

Table look-up

vtbl4_s8⚠Experimental `neon`

Table look-up

vtbl4_u8⚠Experimental `neon`

Table look-up

vtbx1_p8⚠Experimental `neon`

Extended table look-up

vtbx1_s8⚠Experimental `neon`

Extended table look-up

vtbx1_u8⚠Experimental `neon`

Extended table look-up

vtbx2_p8⚠Experimental `neon`

Extended table look-up

vtbx2_s8⚠Experimental `neon`

Extended table look-up

vtbx2_u8⚠Experimental `neon`

Extended table look-up

vtbx3_p8⚠Experimental `neon`

Extended table look-up

vtbx3_s8⚠Experimental `neon`

Extended table look-up

vtbx3_u8⚠Experimental `neon`

Extended table look-up

vtbx4_p8⚠Experimental `neon`

Extended table look-up

vtbx4_s8⚠Experimental `neon`

Extended table look-up

vtbx4_u8⚠Experimental `neon`

Extended table look-up

vtrn1_f32⚠Experimental `neon`

Transpose vectors

vtrn1_p8⚠Experimental `neon`

Transpose vectors

vtrn1_p16⚠Experimental `neon`

Transpose vectors

vtrn1_s8⚠Experimental `neon`

Transpose vectors

vtrn1_s16⚠Experimental `neon`

Transpose vectors

vtrn1_s32⚠Experimental `neon`

Transpose vectors

vtrn1_u8⚠Experimental `neon`

Transpose vectors

vtrn1_u16⚠Experimental `neon`

Transpose vectors

vtrn1_u32⚠Experimental `neon`

Transpose vectors

vtrn1q_f32⚠Experimental `neon`

Transpose vectors

vtrn1q_f64⚠Experimental `neon`

Transpose vectors

vtrn1q_p8⚠Experimental `neon`

Transpose vectors

vtrn1q_p16⚠Experimental `neon`

Transpose vectors

vtrn1q_p64⚠Experimental `neon`

Transpose vectors

vtrn1q_s8⚠Experimental `neon`

Transpose vectors

vtrn1q_s16⚠Experimental `neon`

Transpose vectors

vtrn1q_s32⚠Experimental `neon`

Transpose vectors

vtrn1q_s64⚠Experimental `neon`

Transpose vectors

vtrn1q_u8⚠Experimental `neon`

Transpose vectors

vtrn1q_u16⚠Experimental `neon`

Transpose vectors

vtrn1q_u32⚠Experimental `neon`

Transpose vectors

vtrn1q_u64⚠Experimental `neon`

Transpose vectors

vtrn2_f32⚠Experimental `neon`

Transpose vectors

vtrn2_p8⚠Experimental `neon`

Transpose vectors

vtrn2_p16⚠Experimental `neon`

Transpose vectors

vtrn2_s8⚠Experimental `neon`

Transpose vectors

vtrn2_s16⚠Experimental `neon`

Transpose vectors

vtrn2_s32⚠Experimental `neon`

Transpose vectors

vtrn2_u8⚠Experimental `neon`

Transpose vectors

vtrn2_u16⚠Experimental `neon`

Transpose vectors

vtrn2_u32⚠Experimental `neon`

Transpose vectors

vtrn2q_f32⚠Experimental `neon`

Transpose vectors

vtrn2q_f64⚠Experimental `neon`

Transpose vectors

vtrn2q_p8⚠Experimental `neon`

Transpose vectors

vtrn2q_p16⚠Experimental `neon`

Transpose vectors

vtrn2q_p64⚠Experimental `neon`

Transpose vectors

vtrn2q_s8⚠Experimental `neon`

Transpose vectors

vtrn2q_s16⚠Experimental `neon`

Transpose vectors

vtrn2q_s32⚠Experimental `neon`

Transpose vectors

vtrn2q_s64⚠Experimental `neon`

Transpose vectors

vtrn2q_u8⚠Experimental `neon`

Transpose vectors

vtrn2q_u16⚠Experimental `neon`

Transpose vectors

vtrn2q_u32⚠Experimental `neon`

Transpose vectors

vtrn2q_u64⚠Experimental `neon`

Transpose vectors

vtst_p8⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtst_p64⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtst_s8⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtst_s16⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtst_s32⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtst_s64⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtst_u8⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtst_u16⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtst_u32⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtst_u64⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtstq_p8⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtstq_p64⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtstq_s8⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtstq_s16⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtstq_s32⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtstq_s64⚠Experimental `neon`

Signed compare bitwise Test bits nonzero

vtstq_u8⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtstq_u16⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtstq_u32⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vtstq_u64⚠Experimental `neon`

Unsigned compare bitwise Test bits nonzero

vuqadd_s8⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqadd_s16⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqadd_s32⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqadd_s64⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqaddq_s8⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqaddq_s16⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqaddq_s32⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuqaddq_s64⚠Experimental `neon`

Signed saturating Accumulate of Unsigned value.

vuzp1_f32⚠Experimental `neon`

Unzip vectors

vuzp1_p8⚠Experimental `neon`

Unzip vectors

vuzp1_p16⚠Experimental `neon`

Unzip vectors

vuzp1_s8⚠Experimental `neon`

Unzip vectors

vuzp1_s16⚠Experimental `neon`

Unzip vectors

vuzp1_s32⚠Experimental `neon`

Unzip vectors

vuzp1_u8⚠Experimental `neon`

Unzip vectors

vuzp1_u16⚠Experimental `neon`

Unzip vectors

vuzp1_u32⚠Experimental `neon`

Unzip vectors

vuzp1q_f32⚠Experimental `neon`

Unzip vectors

vuzp1q_f64⚠Experimental `neon`

Unzip vectors

vuzp1q_p8⚠Experimental `neon`

Unzip vectors

vuzp1q_p16⚠Experimental `neon`

Unzip vectors

vuzp1q_p64⚠Experimental `neon`

Unzip vectors

vuzp1q_s8⚠Experimental `neon`

Unzip vectors

vuzp1q_s16⚠Experimental `neon`

Unzip vectors

vuzp1q_s32⚠Experimental `neon`

Unzip vectors

vuzp1q_s64⚠Experimental `neon`

Unzip vectors

vuzp1q_u8⚠Experimental `neon`

Unzip vectors

vuzp1q_u16⚠Experimental `neon`

Unzip vectors

vuzp1q_u32⚠Experimental `neon`

Unzip vectors

vuzp1q_u64⚠Experimental `neon`

Unzip vectors

vuzp2_f32⚠Experimental `neon`

Unzip vectors

vuzp2_p8⚠Experimental `neon`

Unzip vectors

vuzp2_p16⚠Experimental `neon`

Unzip vectors

vuzp2_s8⚠Experimental `neon`

Unzip vectors

vuzp2_s16⚠Experimental `neon`

Unzip vectors

vuzp2_s32⚠Experimental `neon`

Unzip vectors

vuzp2_u8⚠Experimental `neon`

Unzip vectors

vuzp2_u16⚠Experimental `neon`

Unzip vectors

vuzp2_u32⚠Experimental `neon`

Unzip vectors

vuzp2q_f32⚠Experimental `neon`

Unzip vectors

vuzp2q_f64⚠Experimental `neon`

Unzip vectors

vuzp2q_p8⚠Experimental `neon`

Unzip vectors

vuzp2q_p16⚠Experimental `neon`

Unzip vectors

vuzp2q_p64⚠Experimental `neon`

Unzip vectors

vuzp2q_s8⚠Experimental `neon`

Unzip vectors

vuzp2q_s16⚠Experimental `neon`

Unzip vectors

vuzp2q_s32⚠Experimental `neon`

Unzip vectors

vuzp2q_s64⚠Experimental `neon`

Unzip vectors

vuzp2q_u8⚠Experimental `neon`

Unzip vectors

vuzp2q_u16⚠Experimental `neon`

Unzip vectors

vuzp2q_u32⚠Experimental `neon`

Unzip vectors

vuzp2q_u64⚠Experimental `neon`

Unzip vectors

vzip1_f32⚠Experimental `neon`

Zip vectors

vzip1_p8⚠Experimental `neon`

Zip vectors

vzip1_p16⚠Experimental `neon`

Zip vectors

vzip1_s8⚠Experimental `neon`

Zip vectors

vzip1_s16⚠Experimental `neon`

Zip vectors

vzip1_s32⚠Experimental `neon`

Zip vectors

vzip1_u8⚠Experimental `neon`

Zip vectors

vzip1_u16⚠Experimental `neon`

Zip vectors

vzip1_u32⚠Experimental `neon`

Zip vectors

vzip1q_f32⚠Experimental `neon`

Zip vectors

vzip1q_f64⚠Experimental `neon`

Zip vectors

vzip1q_p8⚠Experimental `neon`

Zip vectors

vzip1q_p16⚠Experimental `neon`

Zip vectors

vzip1q_p64⚠Experimental `neon`

Zip vectors

vzip1q_s8⚠Experimental `neon`

Zip vectors

vzip1q_s16⚠Experimental `neon`

Zip vectors

vzip1q_s32⚠Experimental `neon`

Zip vectors

vzip1q_s64⚠Experimental `neon`

Zip vectors

vzip1q_u8⚠Experimental `neon`

Zip vectors

vzip1q_u16⚠Experimental `neon`

Zip vectors

vzip1q_u32⚠Experimental `neon`

Zip vectors

vzip1q_u64⚠Experimental `neon`

Zip vectors

vzip2_f32⚠Experimental `neon`

Zip vectors

vzip2_p8⚠Experimental `neon`

Zip vectors

vzip2_p16⚠Experimental `neon`

Zip vectors

vzip2_s8⚠Experimental `neon`

Zip vectors

vzip2_s16⚠Experimental `neon`

Zip vectors

vzip2_s32⚠Experimental `neon`

Zip vectors

vzip2_u8⚠Experimental `neon`

Zip vectors

vzip2_u16⚠Experimental `neon`

Zip vectors

vzip2_u32⚠Experimental `neon`

Zip vectors

vzip2q_f32⚠Experimental `neon`

Zip vectors

vzip2q_f64⚠Experimental `neon`

Zip vectors

vzip2q_p8⚠Experimental `neon`

Zip vectors

vzip2q_p16⚠Experimental `neon`

Zip vectors

vzip2q_p64⚠Experimental `neon`

Zip vectors

vzip2q_s8⚠Experimental `neon`

Zip vectors

vzip2q_s16⚠Experimental `neon`

Zip vectors

vzip2q_s32⚠Experimental `neon`

Zip vectors

vzip2q_s64⚠Experimental `neon`

Zip vectors

vzip2q_u8⚠Experimental `neon`

Zip vectors

vzip2q_u16⚠Experimental `neon`

Zip vectors

vzip2q_u32⚠Experimental `neon`

Zip vectors

vzip2q_u64⚠Experimental `neon`

Zip vectors