You copied the Doc URL to your clipboard.

Summary of NEON intrinsics

This provides a summary of the NEON intrinsics categories. Use it to locate individual intrinsics. This contains:

Table 44. Summary of NEON intrinsics

Category

Intrinsic description

Addition

Vector add: vadd{q}_<type>. Vr[i]:=Va[i]+Vb[i]

 

Vector long add: vaddl_<type>. Vr[i]:=Va[i]+Vb[i]

 

Vector wide add: vaddw_<type>. Vr[i]:=Va[i]+Vb[i]

 

Vector halving add: vhadd{q}_<type>. Vr[i]:=(Va[i]+Vb[i])>>1

 

Vector rounding halving add: vrhadd{q}_<type>. Vr[i]:=(Va[i]+Vb[i]+1)>>1

 

VQADD: Vector saturating add

 

Vector add high half: vaddhn_<type>.Vr[i]:=Va[i]+Vb[i]

 

Vector rounding add high half: vraddhn_<type>.

Multiplication

Vector multiply: vmul{q}_<type>. Vr[i] := Va[i] * Vb[i]

 

Vector multiply accumulate: vmla{q}_<type>. Vr[i] := Va[i] + Vb[i] * Vc[i]

 

Vector multiply accumulate long: vmlal_<type>. Vr[i] := Va[i] + Vb[i] * Vc[i]

 

Vector multiply subtract: vmls{q}_<type>. Vr[i] := Va[i] - Vb[i] * Vc[i]

 

Vector multiply subtract long

 

Vector saturating doubling multiply high

 

Vector saturating rounding doubling multiply high

 

Vector saturating doubling multiply accumulate long

 

Vector saturating doubling multiply subtract long

 

Vector long multiply

 

Vector saturating doubling long multiply

Subtraction

Vector subtract

 

Vector long subtract: vsubl_<type>. Vr[i]:=Va[i]+Vb[i]

 

Vector wide subtract: vsubw_<type>. Vr[i]:=Va[i]+Vb[i]

 

Vector saturating subtract

 

Vector halving subtract

 

Vector subtract high half

 

Vector rounding subtract high half

Comparison

Vector compare equal

 

Vector compare greater-than or equal

 

Vector compare less-than or equal

 

Vector compare greater-than

 

Vector compare less-than

 

Vector compare absolute greater-than or equal

 

Vector compare absolute less-than or equal

 

Vector compare absolute greater-than

 

Vector compare absolute less-than

 

Vector test bits

Absolute difference

Absolute difference between the arguments: vabd{q}_<type>. Vr[i] = | Va[i] - Vb[i] |

 

Absolute difference - long

 

Absolute difference and accumulate: vaba{q}_<type>. Vr[i] = Va[i] + | Vb[i] - Vc[i] |

 

Absolute difference and accumulate - long

Max and Min

vmax{q}_<type>. Vr[i] := (Va[i] >= Vb[i]) ? Va[i] : Vb[i]

 

vmin{q}_<type>. Vr[i] := (Va[i] >= Vb[i]) ? Vb[i] : Va[i]

Pairwise addition

Pairwise add

 

Long pairwise add

 

Long pairwise add and accumulate

Folding maximum

Folding maximum

Folding minimum

Folding minimum

Reciprocal and Sqrt

Reciprocal/Sqrt

Shifts by signed variable

Vector shift left: vshl{q}_<type>. Vr[i] := Va[i] << Vb[i] (negative values shift right)

 

Vector saturating shift left: (negative values shift right)

 

Vector rounding shift left: (negative values shift right)

 

Vector saturating rounding shift left: (negative values shift right)

Shifts by a constant

Vector shift right by constant

 

Vector shift left by constant

 

Vector rounding shift right by constant

 

Vector shift right by constant and accumulate

 

Vector rounding shift right by constant and accumulate

 

Vector saturating shift left by constant

 

Vector signed->unsigned saturating shift left by constant

 

Vector narrowing shift right by constant

 

Vector signed->unsigned narrowing saturating shift right by constant

 

Vector signed->unsigned rounding narrowing saturating shift right by constant

 

Vector narrowing saturating shift right by constant

 

Vector rounding narrowing shift right by constant

 

Vector rounding narrowing saturating shift right by constant

 

Vector widening shift left by constant

Shifts with insert

Vector shift right and insert

 

Vector shift left and insert

Load vector or lane of a vector

Load a single vector from memory

 

Initialize a vector from a literal bit pattern

 

Load a single lane from memory

 

Load a single lane of a vector from a literal

 

Load all lanes of vector with same value from memory

 

Load all lanes of vector to the same literal value

 

Load all lanes of the vector to the value of a lane of a vector

Extract a lane from a vector

Extract lanes from a vector and put into a register

Store vector or lane of a vector

Store a single vector into memory

 

Store a lane of a vector into memory

Load N-element structure

Load N-element structure from memory

 

Load a single lane of N-element structure from memory

 

Load all lanes of N-element structure with same value from memory

Store N-element structure

Store N-element structure to memory

 

Store a single lane of N-element structure to memory

Combining vectors

Combining vectors

Splitting vectors

Splitting vectors

Converting vectors

Convert from float

 

Convert to float

 

Convert between floats

 

Vector narrow integer

 

Vector long move

 

Vector saturating narrow integer

 

Vector saturating narrow integer signed->unsigned

Table look up

Table look up

Extended table look up

Extended table look up intrinsics

Operations with a scalar

Vector multiply accumulate with scalar

 

Vector widening multiply accumulate with scalar

 

Vector widening saturating doubling multiply accumulate with scalar

 

Vector multiply subtract with scalar

 

Vector widening multiply subtract with scalar

 

Vector widening saturating doubling multiply subtract with scalar

 

Vector multiply by scalar

 

Vector long multiply with scalar

 

Vector long multiply by scalar

 

Vector saturating doubling long multiply with scalar

 

Vector saturating doubling long multiply by scalar

 

Vector saturating doubling multiply high with scalar

 

Vector saturating doubling multiply high by scalar

 

Vector saturating rounding doubling multiply high with scalar

 

Vector rounding saturating doubling multiply high by scalar

 

Vector multiply accumulate with scalar

 

Vector widening multiply accumulate with scalar

 

Vector widening saturating doubling multiply accumulate with scalar

 

Vector multiply subtract with scalar

 

Vector widening multiply subtract with scalar

 

Vector widening saturating doubling multiply subtract with scalar

Vector extract

Vector extract

Reverse vector elements

Reverse vector elements (swap endianness)

Other single operand arithmetic

Absolute: vabs{q}_<type>. Vd[i] = |Va[i]|

 

Saturating absolute: vqabs{q}_<type>. Vd[i] = sat(|Va[i]|)

 

Negate: vneg{q}_<type>. Vd[i] = - Va[i]

 

Saturating Negate: vqneg{q}_<type>. sat(Vd[i] = - Va[i])

 

Count leading sign bits

 

Count leading zeros

 

Count number of set bits

 

Reciprocal estimate

 

Reciprocal square root estimate

Logical operations

Bitwise not

 

Bitwise and

 

Bitwise or

 

Bitwise exclusive or (EOR or XOR)

 

Bit Clear

 

Bitwise OR complement

 

Bitwise Select

Transposition operations

Transpose elements

 

Interleave elements

 

De-Interleave elements


Most NEON instructions have an equivalent NEON intrinsic. The following NEON instructions do not have an equivalent intrinsic:

  • VSWP

  • VLDM

  • VLDR

  • VMRS

  • VMSR

  • VPOP

  • VPUSH

  • VSTM

  • VSTR.

Was this page helpful? Yes No