1 | 3 | 6 | 8 | A | B | C | D | E | F | G | H | I | L | M | N | O | P | Q | R | S | T | U | V | W | X | Z |
SQDECH (scalar): Signed saturating decrement scalar by multiple of
SQDECH (vector): Signed saturating decrement vector by multiple of
16-bit predicate constraint element count.
SQINCH (scalar): Signed saturating increment scalar by multiple of
16-bit predicate constraint element count.
SQINCH (vector): Signed saturating increment vector by multiple of
16-bit predicate constraint element count.
UQDECH (scalar): Unsigned saturating decrement scalar by multiple of
16-bit predicate constraint element count.
UQDECH (vector): Unsigned saturating decrement vector by multiple of
16-bit predicate constraint element count.
UQINCH (scalar): Unsigned saturating increment scalar by multiple of
16-bit predicate constraint element count.
UQINCH (vector): Unsigned saturating increment vector by multiple of
16-bit predicate constraint element count.
SQDECW (scalar): Signed saturating decrement scalar by multiple of
SQDECW (vector): Signed saturating decrement vector by multiple of
32-bit predicate constraint element count.
SQINCW (scalar): Signed saturating increment scalar by multiple of
32-bit predicate constraint element count.
SQINCW (vector): Signed saturating increment vector by multiple of
32-bit predicate constraint element count.
UQDECW (scalar): Unsigned saturating decrement scalar by multiple of
32-bit predicate constraint element count.
UQDECW (vector): Unsigned saturating decrement vector by multiple of
32-bit predicate constraint element count.
UQINCW (scalar): Unsigned saturating increment scalar by multiple of
32-bit predicate constraint element count.
UQINCW (vector): Unsigned saturating increment vector by multiple of
32-bit predicate constraint element count.
SQDECD (scalar): Signed saturating decrement scalar by multiple of
SQDECD (vector): Signed saturating decrement vector by multiple of
64-bit predicate constraint element count.
SQINCD (scalar): Signed saturating increment scalar by multiple of
64-bit predicate constraint element count.
SQINCD (vector): Signed saturating increment vector by multiple of
64-bit predicate constraint element count.
UQDECD (scalar): Unsigned saturating decrement scalar by multiple of
64-bit predicate constraint element count.
UQDECD (vector): Unsigned saturating decrement vector by multiple of
64-bit predicate constraint element count.
UQINCD (scalar): Unsigned saturating increment scalar by multiple of
64-bit predicate constraint element count.
UQINCD (vector): Unsigned saturating increment vector by multiple of
64-bit predicate constraint element count.
ASR (wide elements, predicated): Arithmetic shift right by
64-bit wide elements (predicated).
LSL (wide elements, predicated): Logical shift left by
64-bit wide elements (predicated).
LSR (wide elements, predicated): Logical shift right by
64-bit wide elements (predicated).
ASR (wide elements, unpredicated): Arithmetic shift right by
64-bit wide elements (unpredicated).
LSL (wide elements, unpredicated): Logical shift left by
64-bit wide elements (unpredicated).
LSR (wide elements, unpredicated): Logical shift right by
64-bit wide elements (unpredicated).
CMP<cc> (wide elements): Compare vector to
64-bit wide elements.
8-bit floating-point immediate to vector elements (predicated): an alias of FCPY.
FDUP: Broadcast
8-bit floating-point immediate to vector elements (unpredicated).
8-bit floating-point immediate to vector elements (unpredicated): an alias of FDUP.
SQDECB: Signed saturating decrement scalar by multiple of
8-bit predicate constraint element count.
SQINCB: Signed saturating increment scalar by multiple of
8-bit predicate constraint element count.
UQDECB: Unsigned saturating decrement scalar by multiple of
8-bit predicate constraint element count.
UQINCB: Unsigned saturating increment scalar by multiple of
8-bit predicate constraint element count.
FACLE: Floating-point
absolute compare less than or equal: an alias of FAC<cc>.
FACLT: Floating-point
absolute compare less than: an alias of FAC<cc>.
FAC<cc>: Floating-point
absolute compare vectors.
FABD: Floating-point
absolute difference (predicated).
SABD: Signed
absolute difference (predicated).
UABD: Unsigned
absolute difference (predicated).
ABS:
Absolute value (predicated).
FABS: Floating-point
absolute value (predicated).
FEXPA: Floating-point exponential
accelerator.
FADDA: Floating-point add strictly-ordered reduction,
accumulating in scalar.
COMPACT: Shuffle
active elements of vector to the right and fill with zero.
CNTP: Set scalar to
active predicate element count.
DECP (scalar): Decrement scalar by
active predicate element count.
DECP (vector): Decrement vector by
active predicate element count.
INCP (scalar): Increment scalar by
active predicate element count.
INCP (vector): Increment vector by
active predicate element count.
SQDECP (scalar): Signed saturating decrement scalar by
active predicate element count.
SQDECP (vector): Signed saturating decrement vector by
active predicate element count.
SQINCP (scalar): Signed saturating increment scalar by
active predicate element count.
SQINCP (vector): Signed saturating increment vector by
active predicate element count.
UQDECP (scalar): Unsigned saturating decrement scalar by
active predicate element count.
UQDECP (vector): Unsigned saturating decrement vector by
active predicate element count.
UQINCP (scalar): Unsigned saturating increment scalar by
active predicate element count.
UQINCP (vector): Unsigned saturating increment vector by
active predicate element count.
PFIRST: Set the first
active predicate element to true.
PNEXT: Find next
active predicate.
ADD (immediate): Add immediate (unpredicated).
ADD (vectors, predicated): Add vectors (predicated).
ADD (vectors, unpredicated): Add vectors (unpredicated).
FMLA (indexed): Floating-point fused multiply-
add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
FCMLA (indexed): Floating-point complex multiply-
add by indexed values with rotate.
FTMAD: Floating-point trigonometric multiply-
add coefficient.
FADD (immediate): Floating-point
add immediate (predicated).
Add immediate (unpredicated).
SQADD (immediate): Signed saturating
add immediate (unpredicated).
UQADD (immediate): Unsigned saturating
add immediate (unpredicated).
Add multiple of predicate register size to scalar register.
Add multiple of vector register size to scalar register.
FADDV: Floating-point
add recursive reduction to scalar.
SADDV: Signed
add reduction to scalar.
UADDV: Unsigned
add reduction to scalar.
FADDA: Floating-point
add strictly-ordered reduction, accumulating in scalar.
FADD (vectors, predicated): Floating-point
add vector (predicated).
FADD (vectors, unpredicated): Floating-point
add vector (unpredicated).
FNMLA: Floating-point negated fused multiply-
add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FMLA (vectors): Floating-point fused multiply-
add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
MLA: Multiply-
add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
FNMAD: Floating-point negated fused multiply-
add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-
add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
MAD: Multiply-
add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
Add vectors (predicated).
Add vectors (unpredicated).
SQADD (vectors): Signed saturating
add vectors (unpredicated).
UQADD (vectors): Unsigned saturating
add vectors (unpredicated).
FCADD: Floating-point complex
add with rotate (predicated).
FCMLA (vectors): Floating-point complex multiply-
add with rotate (predicated).
FNMLA: Floating-point negated fused multiply-add vectors (predicated), writing
addend [Zda = -Zda + -Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated), writing
addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated), writing
addend [Zda = Zda + -Zn * Zm].
FMLA (vectors): Floating-point fused multiply-add vectors (predicated), writing
addend [Zda = Zda + Zn * Zm].
MLA: Multiply-add vectors (predicated), writing
addend [Zda = Zda + Zn * Zm].
MLS: Multiply-subtract vectors (predicated), writing
addend [Zda = Zda - Zn * Zm].
ADDPL: Add multiple of predicate register size to scalar register.
ADR: Compute vector
address.
ADDVL: Add multiple of vector register size to scalar register.
FSCALE: Floating-point
adjust exponent by vector (predicated).
ADR: Compute vector address.
BRKPA, BRKPAS: Break
after first true condition, propagating from previous partition.
BRKA, BRKAS: Break
after first true condition.
CLASTA (scalar): Conditionally extract element
after last to general-purpose register.
LASTA (scalar): Extract element
after last to general-purpose register.
CLASTA (SIMD&FP scalar): Conditionally extract element
after last to SIMD&FP scalar register.
LASTA (SIMD&FP scalar): Extract element
after last to SIMD&FP scalar register.
CLASTA (vectors): Conditionally extract element
after last to vector register.
BIC (immediate): Bitwise clear bits using immediate (unpredicated): an
alias of AND (immediate).
MOV (predicate, predicated, zeroing): Move predicates (zeroing): an
alias of AND, ANDS (predicates).
MOVS (predicated): Move predicates (zeroing), setting the condition flags: an
alias of AND, ANDS (predicates).
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition flags: an
alias of CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition flags: an
alias of CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition flags: an
alias of CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition flags: an
alias of CMP<cc> (vectors).
FMOV (zero, predicated): Move floating-point +0.0 to vector elements (predicated): an
alias of CPY (immediate).
MOV (immediate, predicated): Move signed integer immediate to vector elements (predicated): an
alias of CPY (immediate).
MOV (scalar, predicated): Move general-purpose register to vector elements (predicated): an
alias of CPY (scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an
alias of CPY (SIMD&FP scalar).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector elements (unpredicated): an
alias of DUP (immediate).
MOV (immediate, unpredicated): Move signed immediate to vector elements (unpredicated): an
alias of DUP (immediate).
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an
alias of DUP (indexed).
MOV (scalar, unpredicated): Move general-purpose register to vector elements (unpredicated): an
alias of DUP (scalar).
MOV (bitmask immediate): Move logical bitmask immediate to vector (unpredicated): an
alias of DUPM.
EON: Bitwise exclusive OR with inverted immediate (unpredicated): an
alias of EOR (immediate).
NOT (predicate): Bitwise invert predicate: an
alias of EOR, EORS (predicates).
NOTS: Bitwise invert predicate, setting the condition flags: an
alias of EOR, EORS (predicates).
FACLE: Floating-point absolute compare less than or equal: an
alias of FAC<cc>.
FACLT: Floating-point absolute compare less than: an
alias of FAC<cc>.
FCMLE (vectors): Floating-point compare less than or equal to vector: an
alias of FCM<cc> (vectors).
FCMLT (vectors): Floating-point compare less than vector: an
alias of FCM<cc> (vectors).
FMOV (immediate, predicated): Move 8-bit floating-point immediate to vector elements (predicated): an
alias of FCPY.
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to vector elements (unpredicated): an
alias of FDUP.
ORN (immediate): Bitwise OR with inverted immediate (unpredicated): an
alias of ORR (immediate).
MOV (vector, unpredicated): Move vector register (unpredicated): an
alias of ORR (vectors, unpredicated).
MOV (predicate, unpredicated): Move predicate (unpredicated): an
alias of ORR, ORRS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition flags: an
alias of ORR, ORRS (predicates).
MOV (predicate, predicated, merging): Move predicates (merging): an
alias of SEL (predicates).
MOV (vector, predicated): Move vector elements (predicated): an
alias of SEL (vectors).
REV (predicate): Reverse
all elements in a predicate.
REV (vector): Reverse
all elements in a vector (unpredicated).
PFALSE: Set
all predicate elements to false.
SETFFR: Initialise the first-fault register to
all true.
BIC (immediate): Bitwise clear bits using immediate (unpredicated):
an alias of AND (immediate).
MOV (predicate, predicated, zeroing): Move predicates (zeroing):
an alias of AND, ANDS (predicates).
MOVS (predicated): Move predicates (zeroing), setting the condition flags:
an alias of AND, ANDS (predicates).
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition flags:
an alias of CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition flags:
an alias of CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition flags:
an alias of CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition flags:
an alias of CMP<cc> (vectors).
FMOV (zero, predicated): Move floating-point +0.0 to vector elements (predicated):
an alias of CPY (immediate).
MOV (immediate, predicated): Move signed integer immediate to vector elements (predicated):
an alias of CPY (immediate).
MOV (scalar, predicated): Move general-purpose register to vector elements (predicated):
an alias of CPY (scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated):
an alias of CPY (SIMD&FP scalar).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector elements (unpredicated):
an alias of DUP (immediate).
MOV (immediate, unpredicated): Move signed immediate to vector elements (unpredicated):
an alias of DUP (immediate).
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated):
an alias of DUP (indexed).
MOV (scalar, unpredicated): Move general-purpose register to vector elements (unpredicated):
an alias of DUP (scalar).
MOV (bitmask immediate): Move logical bitmask immediate to vector (unpredicated):
an alias of DUPM.
EON: Bitwise exclusive OR with inverted immediate (unpredicated):
an alias of EOR (immediate).
NOT (predicate): Bitwise invert predicate:
an alias of EOR, EORS (predicates).
NOTS: Bitwise invert predicate, setting the condition flags:
an alias of EOR, EORS (predicates).
FACLE: Floating-point absolute compare less than or equal:
an alias of FAC<cc>.
FACLT: Floating-point absolute compare less than:
an alias of FAC<cc>.
FCMLE (vectors): Floating-point compare less than or equal to vector:
an alias of FCM<cc> (vectors).
FCMLT (vectors): Floating-point compare less than vector:
an alias of FCM<cc> (vectors).
FMOV (immediate, predicated): Move 8-bit floating-point immediate to vector elements (predicated):
an alias of FCPY.
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to vector elements (unpredicated):
an alias of FDUP.
ORN (immediate): Bitwise OR with inverted immediate (unpredicated):
an alias of ORR (immediate).
MOV (vector, unpredicated): Move vector register (unpredicated):
an alias of ORR (vectors, unpredicated).
MOV (predicate, unpredicated): Move predicate (unpredicated):
an alias of ORR, ORRS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition flags:
an alias of ORR, ORRS (predicates).
MOV (predicate, predicated, merging): Move predicates (merging):
an alias of SEL (predicates).
MOV (vector, predicated): Move vector elements (predicated):
an alias of SEL (vectors).
BIC (immediate): Bitwise clear bits using immediate (unpredicated): an alias of
AND (immediate).
AND (immediate): Bitwise AND with immediate (unpredicated).
AND (vectors, predicated): Bitwise AND vectors (predicated).
AND (vectors, unpredicated): Bitwise AND vectors (unpredicated).
AND, ANDS (predicates): Bitwise
AND predicates.
ANDV: Bitwise
AND reduction to scalar.
AND (vectors, predicated): Bitwise
AND vectors (predicated).
AND (vectors, unpredicated): Bitwise
AND vectors (unpredicated).
AND (immediate): Bitwise
AND with immediate (unpredicated).
MOV (predicate, predicated, zeroing): Move predicates (zeroing): an alias of
AND, ANDS (predicates).
MOVS (predicated): Move predicates (zeroing), setting the condition flags: an alias of
AND, ANDS (predicates).
AND, ANDS (predicates): Bitwise AND predicates.
MOV (predicate, predicated, zeroing): Move predicates (zeroing): an alias of AND,
ANDS (predicates).
MOVS (predicated): Move predicates (zeroing), setting the condition flags: an alias of AND,
ANDS (predicates).
ANDS (predicates): Bitwise AND predicates.
ANDV: Bitwise AND reduction to scalar.
Arithmetic shift right by 64-bit wide elements (predicated).
Arithmetic shift right by 64-bit wide elements (unpredicated).
Arithmetic shift right by immediate (predicated).
Arithmetic shift right by immediate (unpredicated).
Arithmetic shift right by vector (predicated).
ASRR: Reversed
arithmetic shift right by vector (predicated).
ASRD:
Arithmetic shift right for divide by immediate (predicated).
WHILELS: While incrementing unsigned scalar lower or same
as scalar.
CMPLS (vectors): Compare unsigned lower or same
as vector, setting the condition flags: an alias of CMP<cc> (vectors).
ASR (immediate, predicated): Arithmetic shift right by immediate (predicated).
ASR (immediate, unpredicated): Arithmetic shift right by immediate (unpredicated).
ASR (vectors): Arithmetic shift right by vector (predicated).
ASR (wide elements, predicated): Arithmetic shift right by 64-bit wide elements (predicated).
ASR (wide elements, unpredicated): Arithmetic shift right by 64-bit wide elements (unpredicated).
ASRD: Arithmetic shift right for divide by immediate (predicated).
ASRR: Reversed arithmetic shift right by vector (predicated).
BRKB, BRKBS: Break
before first true condition.
BIC (immediate): Bitwise clear bits using immediate (unpredicated): an alias of AND (immediate).
BIC (vectors, predicated): Bitwise clear vectors (predicated).
BIC (vectors, unpredicated): Bitwise clear vectors (unpredicated).
BIC, BICS (predicates): Bitwise clear predicates.
BICS (predicates): Bitwise clear predicates.
DUPM: Broadcast logical
bitmask immediate to vector (unpredicated).
MOV (bitmask immediate): Move logical
bitmask immediate to vector (unpredicated): an alias of DUPM.
bitmask immediate): Move logical bitmask immediate to vector (unpredicated): an alias of DUPM.
CLS: Count leading sign
bits (predicated).
CLZ: Count leading zero
bits (predicated).
CNT: Count non-zero
bits (predicated).
RBIT: Reverse
bits (predicated).
BIC (immediate): Bitwise clear
bits using immediate (unpredicated): an alias of AND (immediate).
Bitwise AND predicates.
ANDV:
Bitwise AND reduction to scalar.
Bitwise AND vectors (predicated).
Bitwise AND vectors (unpredicated).
Bitwise AND with immediate (unpredicated).
Bitwise clear bits using immediate (unpredicated): an alias of AND (immediate).
Bitwise clear predicates.
Bitwise clear vectors (predicated).
Bitwise clear vectors (unpredicated).
Bitwise exclusive OR predicates.
Bitwise exclusive OR vectors (predicated).
Bitwise exclusive OR vectors (unpredicated).
Bitwise exclusive OR with immediate (unpredicated).
EON:
Bitwise exclusive OR with inverted immediate (unpredicated): an alias of EOR (immediate).
NOTS:
Bitwise invert predicate, setting the condition flags: an alias of EOR, EORS (predicates).
Bitwise invert predicate: an alias of EOR, EORS (predicates).
Bitwise invert vector (predicated).
Bitwise NAND predicates.
Bitwise NOR predicates.
Bitwise OR inverted predicate.
Bitwise OR predicate.
ORV:
Bitwise OR reduction to scalar.
Bitwise OR vectors (predicated).
Bitwise OR vectors (unpredicated).
Bitwise OR with immediate (unpredicated).
Bitwise OR with inverted immediate (unpredicated): an alias of ORR (immediate).
EORV:
Bitwise XOR reduction to scalar.
CNOT: Logically invert
boolean condition in vector (predicated).
Break after first true condition, propagating from previous partition.
Break after first true condition.
Break before first true condition, propagating from previous partition.
Break before first true condition.
BRKN, BRKNS: Propagate
break to next partition.
BRKA, BRKAS: Break after first true condition.
BRKB, BRKBS: Break before first true condition.
BRKN, BRKNS: Propagate break to next partition.
BRKPA, BRKPAS: Break after first true condition, propagating from previous partition.
BRKPB, BRKPBS: Break before first true condition, propagating from previous partition.
FDUP:
Broadcast 8-bit floating-point immediate to vector elements (unpredicated).
LD1RD: Load and
broadcast doubleword to vector.
Broadcast general-purpose register to vector elements (unpredicated).
Broadcast indexed element to vector (unpredicated).
DUPM:
Broadcast logical bitmask immediate to vector (unpredicated).
LD1RSB: Load and
broadcast signed byte to vector.
LD1RSH: Load and
broadcast signed halfword to vector.
Broadcast signed immediate to vector elements (unpredicated).
LD1RSW: Load and
broadcast signed word to vector.
LD1RB: Load and
broadcast unsigned byte to vector.
LD1RH: Load and
broadcast unsigned halfword to vector.
LD1RW: Load and
broadcast unsigned word to vector.
SXTB, SXTH, SXTW: Signed
byte / halfword / word extend (predicated).
UXTB, UXTH, UXTW: Unsigned
byte / halfword / word extend (predicated).
ST4B (scalar plus immediate): Contiguous store four-
byte structures from four vectors (immediate index).
ST4B (scalar plus scalar): Contiguous store four-
byte structures from four vectors (scalar index).
ST3B (scalar plus immediate): Contiguous store three-
byte structures from three vectors (immediate index).
ST3B (scalar plus scalar): Contiguous store three-
byte structures from three vectors (scalar index).
ST2B (scalar plus immediate): Contiguous store two-
byte structures from two vectors (immediate index).
ST2B (scalar plus scalar): Contiguous store two-
byte structures from two vectors (scalar index).
LD4B (scalar plus immediate): Contiguous load four-
byte structures to four vectors (immediate index).
LD4B (scalar plus scalar): Contiguous load four-
byte structures to four vectors (scalar index).
LD3B (scalar plus immediate): Contiguous load three-
byte structures to three vectors (immediate index).
LD3B (scalar plus scalar): Contiguous load three-
byte structures to three vectors (scalar index).
LD2B (scalar plus immediate): Contiguous load two-
byte structures to two vectors (immediate index).
LD2B (scalar plus scalar): Contiguous load two-
byte structures to two vectors (scalar index).
LD1RB: Load and broadcast unsigned
byte to vector.
LD1RSB: Load and broadcast signed
byte to vector.
LD1RQB (scalar plus immediate): Contiguous load and replicate sixteen
bytes (immediate index).
PRFB (scalar plus immediate): Contiguous prefetch
bytes (immediate index).
LD1RQB (scalar plus scalar): Contiguous load and replicate sixteen
bytes (scalar index).
PRFB (scalar plus scalar): Contiguous prefetch
bytes (scalar index).
PRFB (scalar plus vector): Gather prefetch
bytes (scalar plus vector).
PRFB (vector plus immediate): Gather prefetch
bytes (vector plus immediate).
REVB, REVH, REVW: Reverse
bytes / halfwords / words within elements (predicated).
ST1B (vector plus immediate): Scatter store
bytes from a vector (immediate index).
ST1B (scalar plus vector): Scatter store
bytes from a vector (vector index).
ST1B (scalar plus immediate): Contiguous store
bytes from vector (immediate index).
STNT1B (scalar plus immediate): Contiguous store non-temporal
bytes from vector (immediate index).
ST1B (scalar plus scalar): Contiguous store
bytes from vector (scalar index).
STNT1B (scalar plus scalar): Contiguous store non-temporal
bytes from vector (scalar index).
LD1B (scalar plus immediate): Contiguous load unsigned
bytes to vector (immediate index).
LD1B (vector plus immediate): Gather load unsigned
bytes to vector (immediate index).
LD1SB (scalar plus immediate): Contiguous load signed
bytes to vector (immediate index).
LD1SB (vector plus immediate): Gather load signed
bytes to vector (immediate index).
LDFF1B (vector plus immediate): Gather load first-fault unsigned
bytes to vector (immediate index).
LDFF1SB (vector plus immediate): Gather load first-fault signed
bytes to vector (immediate index).
LDNF1B: Contiguous load non-fault unsigned
bytes to vector (immediate index).
LDNF1SB: Contiguous load non-fault signed
bytes to vector (immediate index).
LDNT1B (scalar plus immediate): Contiguous load non-temporal
bytes to vector (immediate index).
LD1B (scalar plus scalar): Contiguous load unsigned
bytes to vector (scalar index).
LD1SB (scalar plus scalar): Contiguous load signed
bytes to vector (scalar index).
LDFF1B (scalar plus scalar): Contiguous load first-fault unsigned
bytes to vector (scalar index).
LDFF1SB (scalar plus scalar): Contiguous load first-fault signed
bytes to vector (scalar index).
LDNT1B (scalar plus scalar): Contiguous load non-temporal
bytes to vector (scalar index).
LD1B (scalar plus vector): Gather load unsigned
bytes to vector (vector index).
LD1SB (scalar plus vector): Gather load signed
bytes to vector (vector index).
LDFF1B (scalar plus vector): Gather load first-fault unsigned
bytes to vector (vector index).
LDFF1SB (scalar plus vector): Gather load first-fault signed
bytes to vector (vector index).
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition flags: an alias of CMP<
cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition flags: an alias of CMP<
cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition flags: an alias of CMP<
cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition flags: an alias of CMP<
cc> (vectors).
FCMLE (vectors): Floating-point compare less than or equal to vector: an alias of FCM<
cc> (vectors).
FCMLT (vectors): Floating-point compare less than vector: an alias of FCM<
cc> (vectors).
cc> (vectors): Compare vectors.
cc> (vectors): Floating-point compare vectors.
cc> (wide elements): Compare vector to 64-bit wide elements.
cc> (zero): Floating-point compare vector with zero.
FACLE: Floating-point absolute compare less than or equal: an alias of FAC<
cc>.
FACLT: Floating-point absolute compare less than: an alias of FAC<
cc>.
CLASTA (scalar): Conditionally extract element after last to general-purpose register.
CLASTA (SIMD&FP scalar): Conditionally extract element after last to SIMD&FP scalar register.
CLASTA (vectors): Conditionally extract element after last to vector register.
CLASTB (scalar): Conditionally extract last element to general-purpose register.
CLASTB (SIMD&FP scalar): Conditionally extract last element to SIMD&FP scalar register.
CLASTB (vectors): Conditionally extract last element to vector register.
BIC (immediate): Bitwise
clear bits using immediate (unpredicated): an alias of AND (immediate).
BIC, BICS (predicates): Bitwise
clear predicates.
BIC (vectors, predicated): Bitwise
clear vectors (predicated).
BIC (vectors, unpredicated): Bitwise
clear vectors (unpredicated).
CLS: Count leading sign bits (predicated).
CLZ: Count leading zero bits (predicated).
CMP<cc> (immediate): Compare vector to immediate.
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition flags: an alias of
CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition flags: an alias of
CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition flags: an alias of
CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition flags: an alias of
CMP<cc> (vectors).
CMP<cc> (vectors): Compare vectors.
CMP<cc> (wide elements): Compare vector to 64-bit wide elements.
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition flags: an alias of CMP<cc> (vectors).
CNOT: Logically invert boolean condition in vector (predicated).
CNT: Count non-zero bits (predicated).
CNTB, CNTD, CNTH, CNTW: Set scalar to multiple of predicate constraint element count.
CNTD, CNTH, CNTW: Set scalar to multiple of predicate constraint element count.
CNTH, CNTW: Set scalar to multiple of predicate constraint element count.
CNTP: Set scalar to active predicate element count.
CNTW: Set scalar to multiple of predicate constraint element count.
FTMAD: Floating-point trigonometric multiply-add
coefficient.
FTSSEL: Floating-point trigonometric select
coefficient.
COMPACT: Shuffle active elements of vector to the right and fill with zero.
Compare and terminate loop.
FCMLE (vectors): Floating-point
compare less than or equal to vector: an alias of FCM<cc> (vectors).
FACLE: Floating-point absolute
compare less than or equal: an alias of FAC<cc>.
FCMLT (vectors): Floating-point
compare less than vector: an alias of FCM<cc> (vectors).
FACLT: Floating-point absolute
compare less than: an alias of FAC<cc>.
Compare signed less than or equal to vector, setting the condition flags: an alias of CMP<cc> (vectors).
Compare signed less than vector, setting the condition flags: an alias of CMP<cc> (vectors).
Compare unsigned lower or same as vector, setting the condition flags: an alias of CMP<cc> (vectors).
Compare unsigned lower than vector, setting the condition flags: an alias of CMP<cc> (vectors).
Compare vector to 64-bit wide elements.
Compare vector to immediate.
FCM<cc> (zero): Floating-point
compare vector with zero.
Compare vectors.
FAC<cc>: Floating-point absolute
compare vectors.
FCM<cc> (vectors): Floating-point
compare vectors.
FCADD: Floating-point
complex add with rotate (predicated).
FCMLA (indexed): Floating-point
complex multiply-add by indexed values with rotate.
FCMLA (vectors): Floating-point
complex multiply-add with rotate (predicated).
ADR:
Compute vector address.
Concatenate even or odd elements from two predicates.
Concatenate even or odd elements from two vectors.
PTEST: Set
condition flags for predicate.
MOVS (predicated): Move predicates (zeroing), setting the
condition flags: an alias of AND, ANDS (predicates).
CMPLE (vectors): Compare signed less than or equal to vector, setting the
condition flags: an alias of CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the
condition flags: an alias of CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the
condition flags: an alias of CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the
condition flags: an alias of CMP<cc> (vectors).
NOTS: Bitwise invert predicate, setting the
condition flags: an alias of EOR, EORS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the
condition flags: an alias of ORR, ORRS (predicates).
CNOT: Logically invert boolean
condition in vector (predicated).
BRKPA, BRKPAS: Break after first true
condition, propagating from previous partition.
BRKPB, BRKPBS: Break before first true
condition, propagating from previous partition.
BRKA, BRKAS: Break after first true
condition.
BRKB, BRKBS: Break before first true
condition.
Conditionally extract element after last to general-purpose register.
Conditionally extract element after last to SIMD&FP scalar register.
Conditionally extract element after last to vector register.
Conditionally extract last element to general-purpose register.
Conditionally extract last element to SIMD&FP scalar register.
Conditionally extract last element to vector register.
Conditionally select elements from two predicates.
Conditionally select elements from two vectors.
CNTB, CNTD, CNTH, CNTW: Set scalar to multiple of predicate
constraint element count.
DECB, DECD, DECH, DECW (scalar): Decrement scalar by multiple of predicate
constraint element count.
DECD, DECH, DECW (vector): Decrement vector by multiple of predicate
constraint element count.
INCB, INCD, INCH, INCW (scalar): Increment scalar by multiple of predicate
constraint element count.
INCD, INCH, INCW (vector): Increment vector by multiple of predicate
constraint element count.
SQDECB: Signed saturating decrement scalar by multiple of 8-bit predicate
constraint element count.
SQDECD (scalar): Signed saturating decrement scalar by multiple of 64-bit predicate
constraint element count.
SQDECD (vector): Signed saturating decrement vector by multiple of 64-bit predicate
constraint element count.
SQDECH (scalar): Signed saturating decrement scalar by multiple of 16-bit predicate
constraint element count.
SQDECH (vector): Signed saturating decrement vector by multiple of 16-bit predicate
constraint element count.
SQDECW (scalar): Signed saturating decrement scalar by multiple of 32-bit predicate
constraint element count.
SQDECW (vector): Signed saturating decrement vector by multiple of 32-bit predicate
constraint element count.
SQINCB: Signed saturating increment scalar by multiple of 8-bit predicate
constraint element count.
SQINCD (scalar): Signed saturating increment scalar by multiple of 64-bit predicate
constraint element count.
SQINCD (vector): Signed saturating increment vector by multiple of 64-bit predicate
constraint element count.
SQINCH (scalar): Signed saturating increment scalar by multiple of 16-bit predicate
constraint element count.
SQINCH (vector): Signed saturating increment vector by multiple of 16-bit predicate
constraint element count.
SQINCW (scalar): Signed saturating increment scalar by multiple of 32-bit predicate
constraint element count.
SQINCW (vector): Signed saturating increment vector by multiple of 32-bit predicate
constraint element count.
UQDECB: Unsigned saturating decrement scalar by multiple of 8-bit predicate
constraint element count.
UQDECD (scalar): Unsigned saturating decrement scalar by multiple of 64-bit predicate
constraint element count.
UQDECD (vector): Unsigned saturating decrement vector by multiple of 64-bit predicate
constraint element count.
UQDECH (scalar): Unsigned saturating decrement scalar by multiple of 16-bit predicate
constraint element count.
UQDECH (vector): Unsigned saturating decrement vector by multiple of 16-bit predicate
constraint element count.
UQDECW (scalar): Unsigned saturating decrement scalar by multiple of 32-bit predicate
constraint element count.
UQDECW (vector): Unsigned saturating decrement vector by multiple of 32-bit predicate
constraint element count.
UQINCB: Unsigned saturating increment scalar by multiple of 8-bit predicate
constraint element count.
UQINCD (scalar): Unsigned saturating increment scalar by multiple of 64-bit predicate
constraint element count.
UQINCD (vector): Unsigned saturating increment vector by multiple of 64-bit predicate
constraint element count.
UQINCH (scalar): Unsigned saturating increment scalar by multiple of 16-bit predicate
constraint element count.
UQINCH (vector): Unsigned saturating increment vector by multiple of 16-bit predicate
constraint element count.
UQINCW (scalar): Unsigned saturating increment scalar by multiple of 32-bit predicate
constraint element count.
UQINCW (vector): Unsigned saturating increment vector by multiple of 32-bit predicate
constraint element count.
PTRUE, PTRUES: Initialise predicate from named
constraint.
Contiguous load and replicate eight halfwords (immediate index).
Contiguous load and replicate eight halfwords (scalar index).
Contiguous load and replicate four words (immediate index).
Contiguous load and replicate four words (scalar index).
Contiguous load and replicate sixteen bytes (immediate index).
Contiguous load and replicate sixteen bytes (scalar index).
Contiguous load and replicate two doublewords (immediate index).
Contiguous load and replicate two doublewords (scalar index).
Contiguous load doublewords to vector (immediate index).
Contiguous load doublewords to vector (scalar index).
Contiguous load first-fault doublewords to vector (scalar index).
Contiguous load first-fault signed bytes to vector (scalar index).
Contiguous load first-fault signed halfwords to vector (scalar index).
Contiguous load first-fault signed words to vector (scalar index).
Contiguous load first-fault unsigned bytes to vector (scalar index).
Contiguous load first-fault unsigned halfwords to vector (scalar index).
Contiguous load first-fault unsigned words to vector (scalar index).
Contiguous load four-byte structures to four vectors (immediate index).
Contiguous load four-byte structures to four vectors (scalar index).
Contiguous load four-doubleword structures to four vectors (immediate index).
Contiguous load four-doubleword structures to four vectors (scalar index).
Contiguous load four-halfword structures to four vectors (immediate index).
Contiguous load four-halfword structures to four vectors (scalar index).
Contiguous load four-word structures to four vectors (immediate index).
Contiguous load four-word structures to four vectors (scalar index).
Contiguous load non-fault doublewords to vector (immediate index).
Contiguous load non-fault signed bytes to vector (immediate index).
Contiguous load non-fault signed halfwords to vector (immediate index).
Contiguous load non-fault signed words to vector (immediate index).
Contiguous load non-fault unsigned bytes to vector (immediate index).
Contiguous load non-fault unsigned halfwords to vector (immediate index).
Contiguous load non-fault unsigned words to vector (immediate index).
Contiguous load non-temporal bytes to vector (immediate index).
Contiguous load non-temporal bytes to vector (scalar index).
Contiguous load non-temporal doublewords to vector (immediate index).
Contiguous load non-temporal doublewords to vector (scalar index).
Contiguous load non-temporal halfwords to vector (immediate index).
Contiguous load non-temporal halfwords to vector (scalar index).
Contiguous load non-temporal words to vector (immediate index).
Contiguous load non-temporal words to vector (scalar index).
Contiguous load signed bytes to vector (immediate index).
Contiguous load signed bytes to vector (scalar index).
Contiguous load signed halfwords to vector (immediate index).
Contiguous load signed halfwords to vector (scalar index).
Contiguous load signed words to vector (immediate index).
Contiguous load signed words to vector (scalar index).
Contiguous load three-byte structures to three vectors (immediate index).
Contiguous load three-byte structures to three vectors (scalar index).
Contiguous load three-doubleword structures to three vectors (immediate index).
Contiguous load three-doubleword structures to three vectors (scalar index).
Contiguous load three-halfword structures to three vectors (immediate index).
Contiguous load three-halfword structures to three vectors (scalar index).
Contiguous load three-word structures to three vectors (immediate index).
Contiguous load three-word structures to three vectors (scalar index).
Contiguous load two-byte structures to two vectors (immediate index).
Contiguous load two-byte structures to two vectors (scalar index).
Contiguous load two-doubleword structures to two vectors (immediate index).
Contiguous load two-doubleword structures to two vectors (scalar index).
Contiguous load two-halfword structures to two vectors (immediate index).
Contiguous load two-halfword structures to two vectors (scalar index).
Contiguous load two-word structures to two vectors (immediate index).
Contiguous load two-word structures to two vectors (scalar index).
Contiguous load unsigned bytes to vector (immediate index).
Contiguous load unsigned bytes to vector (scalar index).
Contiguous load unsigned halfwords to vector (immediate index).
Contiguous load unsigned halfwords to vector (scalar index).
Contiguous load unsigned words to vector (immediate index).
Contiguous load unsigned words to vector (scalar index).
Contiguous prefetch bytes (immediate index).
Contiguous prefetch bytes (scalar index).
Contiguous prefetch doublewords (immediate index).
Contiguous prefetch doublewords (scalar index).
Contiguous prefetch halfwords (immediate index).
Contiguous prefetch halfwords (scalar index).
Contiguous prefetch words (immediate index).
Contiguous prefetch words (scalar index).
Contiguous store bytes from vector (immediate index).
Contiguous store bytes from vector (scalar index).
Contiguous store doublewords from vector (immediate index).
Contiguous store doublewords from vector (scalar index).
Contiguous store four-byte structures from four vectors (immediate index).
Contiguous store four-byte structures from four vectors (scalar index).
Contiguous store four-doubleword structures from four vectors (immediate index).
Contiguous store four-doubleword structures from four vectors (scalar index).
Contiguous store four-halfword structures from four vectors (immediate index).
Contiguous store four-halfword structures from four vectors (scalar index).
Contiguous store four-word structures from four vectors (immediate index).
Contiguous store four-word structures from four vectors (scalar index).
Contiguous store halfwords from vector (immediate index).
Contiguous store halfwords from vector (scalar index).
Contiguous store non-temporal bytes from vector (immediate index).
Contiguous store non-temporal bytes from vector (scalar index).
Contiguous store non-temporal doublewords from vector (immediate index).
Contiguous store non-temporal doublewords from vector (scalar index).
Contiguous store non-temporal halfwords from vector (immediate index).
Contiguous store non-temporal halfwords from vector (scalar index).
Contiguous store non-temporal words from vector (immediate index).
Contiguous store non-temporal words from vector (scalar index).
Contiguous store three-byte structures from three vectors (immediate index).
Contiguous store three-byte structures from three vectors (scalar index).
Contiguous store three-doubleword structures from three vectors (immediate index).
Contiguous store three-doubleword structures from three vectors (scalar index).
Contiguous store three-halfword structures from three vectors (immediate index).
Contiguous store three-halfword structures from three vectors (scalar index).
Contiguous store three-word structures from three vectors (immediate index).
Contiguous store three-word structures from three vectors (scalar index).
Contiguous store two-byte structures from two vectors (immediate index).
Contiguous store two-byte structures from two vectors (scalar index).
Contiguous store two-doubleword structures from two vectors (immediate index).
Contiguous store two-doubleword structures from two vectors (scalar index).
Contiguous store two-halfword structures from two vectors (immediate index).
Contiguous store two-halfword structures from two vectors (scalar index).
Contiguous store two-word structures from two vectors (immediate index).
Contiguous store two-word structures from two vectors (scalar index).
Contiguous store words from vector (immediate index).
Contiguous store words from vector (scalar index).
SPLICE: Splice two vectors under predicate
control.
FCVT: Floating-point
convert precision (predicated).
SCVTF: Signed integer
convert to floating-point (predicated).
UCVTF: Unsigned integer
convert to floating-point (predicated).
FCVTZS: Floating-point
convert to signed integer, rounding toward zero (predicated).
FCVTZU: Floating-point
convert to unsigned integer, rounding toward zero (predicated).
FCPY:
Copy 8-bit floating-point immediate to vector elements (predicated).
Copy general-purpose register to vector elements (predicated).
Copy signed integer immediate to vector elements (predicated).
Copy SIMD&FP scalar register to vector elements (predicated).
CLS:
Count leading sign bits (predicated).
CLZ:
Count leading zero bits (predicated).
CNT:
Count non-zero bits (predicated).
CNTB, CNTD, CNTH, CNTW: Set scalar to multiple of predicate constraint element
count.
CNTP: Set scalar to active predicate element
count.
DECB, DECD, DECH, DECW (scalar): Decrement scalar by multiple of predicate constraint element
count.
DECD, DECH, DECW (vector): Decrement vector by multiple of predicate constraint element
count.
DECP (scalar): Decrement scalar by active predicate element
count.
DECP (vector): Decrement vector by active predicate element
count.
INCB, INCD, INCH, INCW (scalar): Increment scalar by multiple of predicate constraint element
count.
INCD, INCH, INCW (vector): Increment vector by multiple of predicate constraint element
count.
INCP (scalar): Increment scalar by active predicate element
count.
INCP (vector): Increment vector by active predicate element
count.
SQDECB: Signed saturating decrement scalar by multiple of 8-bit predicate constraint element
count.
SQDECD (scalar): Signed saturating decrement scalar by multiple of 64-bit predicate constraint element
count.
SQDECD (vector): Signed saturating decrement vector by multiple of 64-bit predicate constraint element
count.
SQDECH (scalar): Signed saturating decrement scalar by multiple of 16-bit predicate constraint element
count.
SQDECH (vector): Signed saturating decrement vector by multiple of 16-bit predicate constraint element
count.
SQDECP (scalar): Signed saturating decrement scalar by active predicate element
count.
SQDECP (vector): Signed saturating decrement vector by active predicate element
count.
SQDECW (scalar): Signed saturating decrement scalar by multiple of 32-bit predicate constraint element
count.
SQDECW (vector): Signed saturating decrement vector by multiple of 32-bit predicate constraint element
count.
SQINCB: Signed saturating increment scalar by multiple of 8-bit predicate constraint element
count.
SQINCD (scalar): Signed saturating increment scalar by multiple of 64-bit predicate constraint element
count.
SQINCD (vector): Signed saturating increment vector by multiple of 64-bit predicate constraint element
count.
SQINCH (scalar): Signed saturating increment scalar by multiple of 16-bit predicate constraint element
count.
SQINCH (vector): Signed saturating increment vector by multiple of 16-bit predicate constraint element
count.
SQINCP (scalar): Signed saturating increment scalar by active predicate element
count.
SQINCP (vector): Signed saturating increment vector by active predicate element
count.
SQINCW (scalar): Signed saturating increment scalar by multiple of 32-bit predicate constraint element
count.
SQINCW (vector): Signed saturating increment vector by multiple of 32-bit predicate constraint element
count.
UQDECB: Unsigned saturating decrement scalar by multiple of 8-bit predicate constraint element
count.
UQDECD (scalar): Unsigned saturating decrement scalar by multiple of 64-bit predicate constraint element
count.
UQDECD (vector): Unsigned saturating decrement vector by multiple of 64-bit predicate constraint element
count.
UQDECH (scalar): Unsigned saturating decrement scalar by multiple of 16-bit predicate constraint element
count.
UQDECH (vector): Unsigned saturating decrement vector by multiple of 16-bit predicate constraint element
count.
UQDECP (scalar): Unsigned saturating decrement scalar by active predicate element
count.
UQDECP (vector): Unsigned saturating decrement vector by active predicate element
count.
UQDECW (scalar): Unsigned saturating decrement scalar by multiple of 32-bit predicate constraint element
count.
UQDECW (vector): Unsigned saturating decrement vector by multiple of 32-bit predicate constraint element
count.
UQINCB: Unsigned saturating increment scalar by multiple of 8-bit predicate constraint element
count.
UQINCD (scalar): Unsigned saturating increment scalar by multiple of 64-bit predicate constraint element
count.
UQINCD (vector): Unsigned saturating increment vector by multiple of 64-bit predicate constraint element
count.
UQINCH (scalar): Unsigned saturating increment scalar by multiple of 16-bit predicate constraint element
count.
UQINCH (vector): Unsigned saturating increment vector by multiple of 16-bit predicate constraint element
count.
UQINCP (scalar): Unsigned saturating increment scalar by active predicate element
count.
UQINCP (vector): Unsigned saturating increment vector by active predicate element
count.
UQINCW (scalar): Unsigned saturating increment scalar by multiple of 32-bit predicate constraint element
count.
UQINCW (vector): Unsigned saturating increment vector by multiple of 32-bit predicate constraint element
count.
FMOV (zero, predicated): Move floating-point +0.0 to vector elements (predicated): an alias of
CPY (immediate).
MOV (immediate, predicated): Move signed integer immediate to vector elements (predicated): an alias of
CPY (immediate).
CPY (immediate): Copy signed integer immediate to vector elements (predicated).
MOV (scalar, predicated): Move general-purpose register to vector elements (predicated): an alias of
CPY (scalar).
CPY (scalar): Copy general-purpose register to vector elements (predicated).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of
CPY (SIMD&FP scalar).
CPY (SIMD&FP scalar): Copy SIMD&FP scalar register to vector elements (predicated).
Create index starting from and incremented by general-purpose register.
Create index starting from and incremented by immediate.
Create index starting from general-purpose register and incremented by immediate.
Create index starting from immediate and incremented by general-purpose register.
CTERMEQ, CTERMNE: Compare and terminate loop.
DECD, DECH, DECW (scalar): Decrement scalar by multiple of predicate constraint element count.
DECD, DECH, DECW (vector): Decrement vector by multiple of predicate constraint element count.
DECH, DECW (scalar): Decrement scalar by multiple of predicate constraint element count.
DECH, DECW (vector): Decrement vector by multiple of predicate constraint element count.
DECP (scalar): Decrement scalar by active predicate element count.
DECP (vector): Decrement vector by active predicate element count.
Decrement scalar by active predicate element count.
SQDECP (scalar): Signed saturating
decrement scalar by active predicate element count.
UQDECP (scalar): Unsigned saturating
decrement scalar by active predicate element count.
SQDECH (scalar): Signed saturating
decrement scalar by multiple of 16-bit predicate constraint element count.
UQDECH (scalar): Unsigned saturating
decrement scalar by multiple of 16-bit predicate constraint element count.
SQDECW (scalar): Signed saturating
decrement scalar by multiple of 32-bit predicate constraint element count.
UQDECW (scalar): Unsigned saturating
decrement scalar by multiple of 32-bit predicate constraint element count.
SQDECD (scalar): Signed saturating
decrement scalar by multiple of 64-bit predicate constraint element count.
UQDECD (scalar): Unsigned saturating
decrement scalar by multiple of 64-bit predicate constraint element count.
SQDECB: Signed saturating
decrement scalar by multiple of 8-bit predicate constraint element count.
UQDECB: Unsigned saturating
decrement scalar by multiple of 8-bit predicate constraint element count.
Decrement scalar by multiple of predicate constraint element count.
Decrement vector by active predicate element count.
SQDECP (vector): Signed saturating
decrement vector by active predicate element count.
UQDECP (vector): Unsigned saturating
decrement vector by active predicate element count.
SQDECH (vector): Signed saturating
decrement vector by multiple of 16-bit predicate constraint element count.
UQDECH (vector): Unsigned saturating
decrement vector by multiple of 16-bit predicate constraint element count.
SQDECW (vector): Signed saturating
decrement vector by multiple of 32-bit predicate constraint element count.
UQDECW (vector): Unsigned saturating
decrement vector by multiple of 32-bit predicate constraint element count.
SQDECD (vector): Signed saturating
decrement vector by multiple of 64-bit predicate constraint element count.
UQDECD (vector): Unsigned saturating
decrement vector by multiple of 64-bit predicate constraint element count.
Decrement vector by multiple of predicate constraint element count.
DECW (scalar): Decrement scalar by multiple of predicate constraint element count.
DECW (vector): Decrement vector by multiple of predicate constraint element count.
FABD: Floating-point absolute
difference (predicated).
SABD: Signed absolute
difference (predicated).
UABD: Unsigned absolute
difference (predicated).
SDIV: Signed
divide (predicated).
SDIVR: Signed reversed
divide (predicated).
UDIV: Unsigned
divide (predicated).
UDIVR: Unsigned reversed
divide (predicated).
ASRD: Arithmetic shift right for
divide by immediate (predicated).
FDIV: Floating-point
divide by vector (predicated).
FDIVR: Floating-point reversed
divide by vector (predicated).
SDOT (indexed): Signed
dot product by indexed quadtuplet.
UDOT (indexed): Unsigned
dot product by indexed quadtuplet.
SDOT (vectors): Signed
dot product.
UDOT (vectors): Unsigned
dot product.
ST4D (scalar plus immediate): Contiguous store four-
doubleword structures from four vectors (immediate index).
ST4D (scalar plus scalar): Contiguous store four-
doubleword structures from four vectors (scalar index).
ST3D (scalar plus immediate): Contiguous store three-
doubleword structures from three vectors (immediate index).
ST3D (scalar plus scalar): Contiguous store three-
doubleword structures from three vectors (scalar index).
ST2D (scalar plus immediate): Contiguous store two-
doubleword structures from two vectors (immediate index).
ST2D (scalar plus scalar): Contiguous store two-
doubleword structures from two vectors (scalar index).
LD4D (scalar plus immediate): Contiguous load four-
doubleword structures to four vectors (immediate index).
LD4D (scalar plus scalar): Contiguous load four-
doubleword structures to four vectors (scalar index).
LD3D (scalar plus immediate): Contiguous load three-
doubleword structures to three vectors (immediate index).
LD3D (scalar plus scalar): Contiguous load three-
doubleword structures to three vectors (scalar index).
LD2D (scalar plus immediate): Contiguous load two-
doubleword structures to two vectors (immediate index).
LD2D (scalar plus scalar): Contiguous load two-
doubleword structures to two vectors (scalar index).
LD1RD: Load and broadcast
doubleword to vector.
LD1RQD (scalar plus immediate): Contiguous load and replicate two
doublewords (immediate index).
PRFD (scalar plus immediate): Contiguous prefetch
doublewords (immediate index).
LD1RQD (scalar plus scalar): Contiguous load and replicate two
doublewords (scalar index).
PRFD (scalar plus scalar): Contiguous prefetch
doublewords (scalar index).
PRFD (scalar plus vector): Gather prefetch
doublewords (scalar plus vector).
PRFD (vector plus immediate): Gather prefetch
doublewords (vector plus immediate).
ST1D (vector plus immediate): Scatter store
doublewords from a vector (immediate index).
ST1D (scalar plus vector): Scatter store
doublewords from a vector (vector index).
ST1D (scalar plus immediate): Contiguous store
doublewords from vector (immediate index).
STNT1D (scalar plus immediate): Contiguous store non-temporal
doublewords from vector (immediate index).
ST1D (scalar plus scalar): Contiguous store
doublewords from vector (scalar index).
STNT1D (scalar plus scalar): Contiguous store non-temporal
doublewords from vector (scalar index).
LD1D (scalar plus immediate): Contiguous load
doublewords to vector (immediate index).
LD1D (vector plus immediate): Gather load
doublewords to vector (immediate index).
LDFF1D (vector plus immediate): Gather load first-fault
doublewords to vector (immediate index).
LDNF1D: Contiguous load non-fault
doublewords to vector (immediate index).
LDNT1D (scalar plus immediate): Contiguous load non-temporal
doublewords to vector (immediate index).
LD1D (scalar plus scalar): Contiguous load
doublewords to vector (scalar index).
LDFF1D (scalar plus scalar): Contiguous load first-fault
doublewords to vector (scalar index).
LDNT1D (scalar plus scalar): Contiguous load non-temporal
doublewords to vector (scalar index).
LD1D (scalar plus vector): Gather load
doublewords to vector (vector index).
LDFF1D (scalar plus vector): Gather load first-fault
doublewords to vector (vector index).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector elements (unpredicated): an alias of
DUP (immediate).
MOV (immediate, unpredicated): Move signed immediate to vector elements (unpredicated): an alias of
DUP (immediate).
DUP (immediate): Broadcast signed immediate to vector elements (unpredicated).
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of
DUP (indexed).
DUP (indexed): Broadcast indexed element to vector (unpredicated).
MOV (scalar, unpredicated): Move general-purpose register to vector elements (unpredicated): an alias of
DUP (scalar).
DUP (scalar): Broadcast general-purpose register to vector elements (unpredicated).
MOV (bitmask immediate): Move logical bitmask immediate to vector (unpredicated): an alias of
DUPM.
DUPM: Broadcast logical bitmask immediate to vector (unpredicated).
LD1RQH (scalar plus immediate): Contiguous load and replicate
LD1RQH (scalar plus scalar): Contiguous load and replicate
eight halfwords (scalar index).
CLASTA (scalar): Conditionally extract
element after last to general-purpose register.
LASTA (scalar): Extract
element after last to general-purpose register.
CLASTA (SIMD&FP scalar): Conditionally extract
element after last to SIMD&FP scalar register.
LASTA (SIMD&FP scalar): Extract
element after last to SIMD&FP scalar register.
CLASTA (vectors): Conditionally extract
element after last to vector register.
CNTB, CNTD, CNTH, CNTW: Set scalar to multiple of predicate constraint
element count.
CNTP: Set scalar to active predicate
element count.
DECB, DECD, DECH, DECW (scalar): Decrement scalar by multiple of predicate constraint
element count.
DECD, DECH, DECW (vector): Decrement vector by multiple of predicate constraint
element count.
DECP (scalar): Decrement scalar by active predicate
element count.
DECP (vector): Decrement vector by active predicate
element count.
INCB, INCD, INCH, INCW (scalar): Increment scalar by multiple of predicate constraint
element count.
INCD, INCH, INCW (vector): Increment vector by multiple of predicate constraint
element count.
INCP (scalar): Increment scalar by active predicate
element count.
INCP (vector): Increment vector by active predicate
element count.
SQDECB: Signed saturating decrement scalar by multiple of 8-bit predicate constraint
element count.
SQDECD (scalar): Signed saturating decrement scalar by multiple of 64-bit predicate constraint
element count.
SQDECD (vector): Signed saturating decrement vector by multiple of 64-bit predicate constraint
element count.
SQDECH (scalar): Signed saturating decrement scalar by multiple of 16-bit predicate constraint
element count.
SQDECH (vector): Signed saturating decrement vector by multiple of 16-bit predicate constraint
element count.
SQDECP (scalar): Signed saturating decrement scalar by active predicate
element count.
SQDECP (vector): Signed saturating decrement vector by active predicate
element count.
SQDECW (scalar): Signed saturating decrement scalar by multiple of 32-bit predicate constraint
element count.
SQDECW (vector): Signed saturating decrement vector by multiple of 32-bit predicate constraint
element count.
SQINCB: Signed saturating increment scalar by multiple of 8-bit predicate constraint
element count.
SQINCD (scalar): Signed saturating increment scalar by multiple of 64-bit predicate constraint
element count.
SQINCD (vector): Signed saturating increment vector by multiple of 64-bit predicate constraint
element count.
SQINCH (scalar): Signed saturating increment scalar by multiple of 16-bit predicate constraint
element count.
SQINCH (vector): Signed saturating increment vector by multiple of 16-bit predicate constraint
element count.
SQINCP (scalar): Signed saturating increment scalar by active predicate
element count.
SQINCP (vector): Signed saturating increment vector by active predicate
element count.
SQINCW (scalar): Signed saturating increment scalar by multiple of 32-bit predicate constraint
element count.
SQINCW (vector): Signed saturating increment vector by multiple of 32-bit predicate constraint
element count.
UQDECB: Unsigned saturating decrement scalar by multiple of 8-bit predicate constraint
element count.
UQDECD (scalar): Unsigned saturating decrement scalar by multiple of 64-bit predicate constraint
element count.
UQDECD (vector): Unsigned saturating decrement vector by multiple of 64-bit predicate constraint
element count.
UQDECH (scalar): Unsigned saturating decrement scalar by multiple of 16-bit predicate constraint
element count.
UQDECH (vector): Unsigned saturating decrement vector by multiple of 16-bit predicate constraint
element count.
UQDECP (scalar): Unsigned saturating decrement scalar by active predicate
element count.
UQDECP (vector): Unsigned saturating decrement vector by active predicate
element count.
UQDECW (scalar): Unsigned saturating decrement scalar by multiple of 32-bit predicate constraint
element count.
UQDECW (vector): Unsigned saturating decrement vector by multiple of 32-bit predicate constraint
element count.
UQINCB: Unsigned saturating increment scalar by multiple of 8-bit predicate constraint
element count.
UQINCD (scalar): Unsigned saturating increment scalar by multiple of 64-bit predicate constraint
element count.
UQINCD (vector): Unsigned saturating increment vector by multiple of 64-bit predicate constraint
element count.
UQINCH (scalar): Unsigned saturating increment scalar by multiple of 16-bit predicate constraint
element count.
UQINCH (vector): Unsigned saturating increment vector by multiple of 16-bit predicate constraint
element count.
UQINCP (scalar): Unsigned saturating increment scalar by active predicate
element count.
UQINCP (vector): Unsigned saturating increment vector by active predicate
element count.
UQINCW (scalar): Unsigned saturating increment scalar by multiple of 32-bit predicate constraint
element count.
UQINCW (vector): Unsigned saturating increment vector by multiple of 32-bit predicate constraint
element count.
MOV (SIMD&FP scalar, unpredicated): Move indexed
element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
CLASTB (scalar): Conditionally extract last
element to general-purpose register.
LASTB (scalar): Extract last
element to general-purpose register.
CLASTB (SIMD&FP scalar): Conditionally extract last
element to SIMD&FP scalar register.
LASTB (SIMD&FP scalar): Extract last
element to SIMD&FP scalar register.
PFIRST: Set the first active predicate
element to true.
DUP (indexed): Broadcast indexed
element to vector (unpredicated).
CLASTB (vectors): Conditionally extract last
element to vector register.
ASR (wide elements, predicated): Arithmetic shift right by 64-bit wide
elements (predicated).
CPY (immediate): Copy signed integer immediate to vector
elements (predicated).
CPY (scalar): Copy general-purpose register to vector
elements (predicated).
CPY (SIMD&FP scalar): Copy SIMD&FP scalar register to vector
elements (predicated).
FCPY: Copy 8-bit floating-point immediate to vector
elements (predicated).
LSL (wide elements, predicated): Logical shift left by 64-bit wide
elements (predicated).
LSR (wide elements, predicated): Logical shift right by 64-bit wide
elements (predicated).
REVB, REVH, REVW: Reverse bytes / halfwords / words within
elements (predicated).
FMOV (zero, predicated): Move floating-point +0.0 to vector
elements (predicated): an alias of CPY (immediate).
MOV (immediate, predicated): Move signed integer immediate to vector
elements (predicated): an alias of CPY (immediate).
MOV (scalar, predicated): Move general-purpose register to vector
elements (predicated): an alias of CPY (scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector
elements (predicated): an alias of CPY (SIMD&FP scalar).
FMOV (immediate, predicated): Move 8-bit floating-point immediate to vector
elements (predicated): an alias of FCPY.
MOV (vector, predicated): Move vector
elements (predicated): an alias of SEL (vectors).
ASR (wide elements, unpredicated): Arithmetic shift right by 64-bit wide
elements (unpredicated).
DUP (immediate): Broadcast signed immediate to vector
elements (unpredicated).
DUP (scalar): Broadcast general-purpose register to vector
elements (unpredicated).
FDUP: Broadcast 8-bit floating-point immediate to vector
elements (unpredicated).
LSL (wide elements, unpredicated): Logical shift left by 64-bit wide
elements (unpredicated).
LSR (wide elements, unpredicated): Logical shift right by 64-bit wide
elements (unpredicated).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector
elements (unpredicated): an alias of DUP (immediate).
MOV (immediate, unpredicated): Move signed immediate to vector
elements (unpredicated): an alias of DUP (immediate).
MOV (scalar, unpredicated): Move general-purpose register to vector
elements (unpredicated): an alias of DUP (scalar).
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to vector
elements (unpredicated): an alias of FDUP.
FMLS (indexed): Floating-point fused multiply-subtract by indexed
elements (Zda = Zda + -Zn * Zm[indexed]).
FMLA (indexed): Floating-point fused multiply-add by indexed
elements (Zda = Zda + Zn * Zm[indexed]).
ZIP1, ZIP2 (predicates): Interleave
elements from two half predicates.
ZIP1, ZIP2 (vectors): Interleave
elements from two half vectors.
SEL (predicates): Conditionally select
elements from two predicates.
TRN1, TRN2 (predicates): Interleave even or odd
elements from two predicates.
UZP1, UZP2 (predicates): Concatenate even or odd
elements from two predicates.
SEL (vectors): Conditionally select
elements from two vectors.
TRN1, TRN2 (vectors): Interleave even or odd
elements from two vectors.
UZP1, UZP2 (vectors): Concatenate even or odd
elements from two vectors.
REV (predicate): Reverse all
elements in a predicate.
REV (vector): Reverse all
elements in a vector (unpredicated).
COMPACT: Shuffle active
elements of vector to the right and fill with zero.
PFALSE: Set all predicate
elements to false.
elements): Compare vector to 64-bit wide elements.
elements, predicated): Arithmetic shift right by 64-bit wide elements (predicated).
elements, predicated): Logical shift left by 64-bit wide elements (predicated).
elements, predicated): Logical shift right by 64-bit wide elements (predicated).
elements, unpredicated): Arithmetic shift right by 64-bit wide elements (unpredicated).
elements, unpredicated): Logical shift left by 64-bit wide elements (unpredicated).
elements, unpredicated): Logical shift right by 64-bit wide elements (unpredicated).
CMP<cc> (wide elements): Compare vector to 64-bit wide
elements.
FMUL (indexed): Floating-point multiply by indexed
elements.
RDFFR, RDFFRS (predicated): Return predicate of succesfully loaded
elements.
EON: Bitwise exclusive OR with inverted immediate (unpredicated): an alias of EOR (immediate).
EON: Bitwise exclusive OR with inverted immediate (unpredicated): an alias of
EOR (immediate).
EOR (immediate): Bitwise exclusive OR with immediate (unpredicated).
EOR (vectors, predicated): Bitwise exclusive OR vectors (predicated).
EOR (vectors, unpredicated): Bitwise exclusive OR vectors (unpredicated).
NOT (predicate): Bitwise invert predicate: an alias of
EOR, EORS (predicates).
NOTS: Bitwise invert predicate, setting the condition flags: an alias of
EOR, EORS (predicates).
EOR, EORS (predicates): Bitwise exclusive OR predicates.
NOT (predicate): Bitwise invert predicate: an alias of EOR,
EORS (predicates).
NOTS: Bitwise invert predicate, setting the condition flags: an alias of EOR,
EORS (predicates).
EORS (predicates): Bitwise exclusive OR predicates.
EORV: Bitwise XOR reduction to scalar.
WHILELE: While incrementing signed scalar less than or
equal to scalar.
CMPLE (vectors): Compare signed less than or
equal to vector, setting the condition flags: an alias of CMP<cc> (vectors).
FCMLE (vectors): Floating-point compare less than or
equal to vector: an alias of FCM<cc> (vectors).
FACLE: Floating-point absolute compare less than or
equal: an alias of FAC<cc>.
FRECPE: Floating-point reciprocal
estimate (unpredicated).
FRSQRTE: Floating-point reciprocal square root
estimate (unpredicated).
TRN1, TRN2 (predicates): Interleave
even or odd elements from two predicates.
UZP1, UZP2 (predicates): Concatenate
even or odd elements from two predicates.
TRN1, TRN2 (vectors): Interleave
even or odd elements from two vectors.
UZP1, UZP2 (vectors): Concatenate
even or odd elements from two vectors.
EOR, EORS (predicates): Bitwise
exclusive OR predicates.
EOR (vectors, predicated): Bitwise
exclusive OR vectors (predicated).
EOR (vectors, unpredicated): Bitwise
exclusive OR vectors (unpredicated).
EOR (immediate): Bitwise
exclusive OR with immediate (unpredicated).
EON: Bitwise
exclusive OR with inverted immediate (unpredicated): an alias of EOR (immediate).
FRECPX: Floating-point reciprocal
exponent (predicated).
FSCALE: Floating-point adjust
exponent by vector (predicated).
FEXPA: Floating-point
exponential accelerator.
EXT: Extract vector from pair of vectors.
SXTB, SXTH, SXTW: Signed byte / halfword / word
extend (predicated).
UXTB, UXTH, UXTW: Unsigned byte / halfword / word
extend (predicated).
SUNPKHI, SUNPKLO: Signed unpack and
extend half of vector.
UUNPKHI, UUNPKLO: Unsigned unpack and
extend half of vector.
FMULX: Floating-point multiply-
extended vectors (predicated).
CLASTA (scalar): Conditionally
extract element after last to general-purpose register.
Extract element after last to general-purpose register.
CLASTA (SIMD&FP scalar): Conditionally
extract element after last to SIMD&FP scalar register.
Extract element after last to SIMD&FP scalar register.
CLASTA (vectors): Conditionally
extract element after last to vector register.
CLASTB (scalar): Conditionally
extract last element to general-purpose register.
Extract last element to general-purpose register.
CLASTB (SIMD&FP scalar): Conditionally
extract last element to SIMD&FP scalar register.
Extract last element to SIMD&FP scalar register.
CLASTB (vectors): Conditionally
extract last element to vector register.
EXT:
Extract vector from pair of vectors.
FABS: Floating-point absolute value (predicated).
FACLE: Floating-point absolute compare less than or equal: an alias of
FAC<cc>.
FACLT: Floating-point absolute compare less than: an alias of
FAC<cc>.
FAC<cc>: Floating-point absolute compare vectors.
FACLE: Floating-point absolute compare less than or equal: an alias of FAC<cc>.
FACLT: Floating-point absolute compare less than: an alias of FAC<cc>.
FADD (immediate): Floating-point add immediate (predicated).
FADD (vectors, predicated): Floating-point add vector (predicated).
FADD (vectors, unpredicated): Floating-point add vector (unpredicated).
FADDA: Floating-point add strictly-ordered reduction, accumulating in scalar.
FADDV: Floating-point add recursive reduction to scalar.
PFALSE: Set all predicate elements to
false.
LDFF1D (vector plus immediate): Gather load first-
fault doublewords to vector (immediate index).
LDNF1D: Contiguous load non-
fault doublewords to vector (immediate index).
LDFF1D (scalar plus scalar): Contiguous load first-
fault doublewords to vector (scalar index).
LDFF1D (scalar plus vector): Gather load first-
fault doublewords to vector (vector index).
SETFFR: Initialise the first-
fault register to all true.
RDFFR (unpredicated): Read the first-
fault register.
WRFFR: Write the first-
fault register.
LDFF1SB (vector plus immediate): Gather load first-
fault signed bytes to vector (immediate index).
LDNF1SB: Contiguous load non-
fault signed bytes to vector (immediate index).
LDFF1SB (scalar plus scalar): Contiguous load first-
fault signed bytes to vector (scalar index).
LDFF1SB (scalar plus vector): Gather load first-
fault signed bytes to vector (vector index).
LDFF1SH (vector plus immediate): Gather load first-
fault signed halfwords to vector (immediate index).
LDNF1SH: Contiguous load non-
fault signed halfwords to vector (immediate index).
LDFF1SH (scalar plus scalar): Contiguous load first-
fault signed halfwords to vector (scalar index).
LDFF1SH (scalar plus vector): Gather load first-
fault signed halfwords to vector (vector index).
LDFF1SW (vector plus immediate): Gather load first-
fault signed words to vector (immediate index).
LDNF1SW: Contiguous load non-
fault signed words to vector (immediate index).
LDFF1SW (scalar plus scalar): Contiguous load first-
fault signed words to vector (scalar index).
LDFF1SW (scalar plus vector): Gather load first-
fault signed words to vector (vector index).
LDFF1B (vector plus immediate): Gather load first-
fault unsigned bytes to vector (immediate index).
LDNF1B: Contiguous load non-
fault unsigned bytes to vector (immediate index).
LDFF1B (scalar plus scalar): Contiguous load first-
fault unsigned bytes to vector (scalar index).
LDFF1B (scalar plus vector): Gather load first-
fault unsigned bytes to vector (vector index).
LDFF1H (vector plus immediate): Gather load first-
fault unsigned halfwords to vector (immediate index).
LDNF1H: Contiguous load non-
fault unsigned halfwords to vector (immediate index).
LDFF1H (scalar plus scalar): Contiguous load first-
fault unsigned halfwords to vector (scalar index).
LDFF1H (scalar plus vector): Gather load first-
fault unsigned halfwords to vector (vector index).
LDFF1W (vector plus immediate): Gather load first-
fault unsigned words to vector (immediate index).
LDNF1W: Contiguous load non-
fault unsigned words to vector (immediate index).
LDFF1W (scalar plus scalar): Contiguous load first-
fault unsigned words to vector (scalar index).
LDFF1W (scalar plus vector): Gather load first-
fault unsigned words to vector (vector index).
FCADD: Floating-point complex add with rotate (predicated).
FCMLE (vectors): Floating-point compare less than or equal to vector: an alias of
FCM<cc> (vectors).
FCMLT (vectors): Floating-point compare less than vector: an alias of
FCM<cc> (vectors).
FCM<cc> (vectors): Floating-point compare vectors.
FCM<cc> (zero): Floating-point compare vector with zero.
FCMLA (indexed): Floating-point complex multiply-add by indexed values with rotate.
FCMLA (vectors): Floating-point complex multiply-add with rotate (predicated).
FCMLE (vectors): Floating-point compare less than or equal to vector: an alias of FCM<cc> (vectors).
FCMLT (vectors): Floating-point compare less than vector: an alias of FCM<cc> (vectors).
FMOV (immediate, predicated): Move 8-bit floating-point immediate to vector elements (predicated): an alias of
FCPY.
FCPY: Copy 8-bit floating-point immediate to vector elements (predicated).
FCVT: Floating-point convert precision (predicated).
FCVTZS: Floating-point convert to signed integer, rounding toward zero (predicated).
FCVTZU: Floating-point convert to unsigned integer, rounding toward zero (predicated).
FDIV: Floating-point divide by vector (predicated).
FDIVR: Floating-point reversed divide by vector (predicated).
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to vector elements (unpredicated): an alias of
FDUP.
FDUP: Broadcast 8-bit floating-point immediate to vector elements (unpredicated).
FEXPA: Floating-point exponential accelerator.
COMPACT: Shuffle active elements of vector to the right and
fill with zero.
Find next active predicate.
PFIRST: Set the
first active predicate element to true.
BRKPA, BRKPAS: Break after
first true condition, propagating from previous partition.
BRKPB, BRKPBS: Break before
first true condition, propagating from previous partition.
BRKA, BRKAS: Break after
first true condition.
BRKB, BRKBS: Break before
first true condition.
LDFF1D (vector plus immediate): Gather load
first-fault doublewords to vector (immediate index).
LDFF1D (scalar plus scalar): Contiguous load
first-fault doublewords to vector (scalar index).
LDFF1D (scalar plus vector): Gather load
first-fault doublewords to vector (vector index).
SETFFR: Initialise the
first-fault register to all true.
RDFFR (unpredicated): Read the
first-fault register.
WRFFR: Write the
first-fault register.
LDFF1SB (vector plus immediate): Gather load
first-fault signed bytes to vector (immediate index).
LDFF1SB (scalar plus scalar): Contiguous load
first-fault signed bytes to vector (scalar index).
LDFF1SB (scalar plus vector): Gather load
first-fault signed bytes to vector (vector index).
LDFF1SH (vector plus immediate): Gather load
first-fault signed halfwords to vector (immediate index).
LDFF1SH (scalar plus scalar): Contiguous load
first-fault signed halfwords to vector (scalar index).
LDFF1SH (scalar plus vector): Gather load
first-fault signed halfwords to vector (vector index).
LDFF1SW (vector plus immediate): Gather load
first-fault signed words to vector (immediate index).
LDFF1SW (scalar plus scalar): Contiguous load
first-fault signed words to vector (scalar index).
LDFF1SW (scalar plus vector): Gather load
first-fault signed words to vector (vector index).
LDFF1B (vector plus immediate): Gather load
first-fault unsigned bytes to vector (immediate index).
LDFF1B (scalar plus scalar): Contiguous load
first-fault unsigned bytes to vector (scalar index).
LDFF1B (scalar plus vector): Gather load
first-fault unsigned bytes to vector (vector index).
LDFF1H (vector plus immediate): Gather load
first-fault unsigned halfwords to vector (immediate index).
LDFF1H (scalar plus scalar): Contiguous load
first-fault unsigned halfwords to vector (scalar index).
LDFF1H (scalar plus vector): Gather load
first-fault unsigned halfwords to vector (vector index).
LDFF1W (vector plus immediate): Gather load
first-fault unsigned words to vector (immediate index).
LDFF1W (scalar plus scalar): Contiguous load
first-fault unsigned words to vector (scalar index).
LDFF1W (scalar plus vector): Gather load
first-fault unsigned words to vector (vector index).
PTEST: Set condition
flags for predicate.
MOVS (predicated): Move predicates (zeroing), setting the condition
flags: an alias of AND, ANDS (predicates).
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition
flags: an alias of CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition
flags: an alias of CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition
flags: an alias of CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition
flags: an alias of CMP<cc> (vectors).
NOTS: Bitwise invert predicate, setting the condition
flags: an alias of EOR, EORS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition
flags: an alias of ORR, ORRS (predicates).
SCVTF: Signed integer convert to
floating-point (predicated).
UCVTF: Unsigned integer convert to
floating-point (predicated).
FMOV (zero, predicated): Move
floating-point +0.0 to vector elements (predicated): an alias of CPY (immediate).
floating-point +0.0 to vector elements (unpredicated): an alias of DUP (immediate).
Floating-point absolute compare less than or equal: an alias of FAC<cc>.
Floating-point absolute compare less than: an alias of FAC<cc>.
Floating-point absolute compare vectors.
FABD:
Floating-point absolute difference (predicated).
FABS:
Floating-point absolute value (predicated).
Floating-point add immediate (predicated).
Floating-point add recursive reduction to scalar.
Floating-point add strictly-ordered reduction, accumulating in scalar.
Floating-point add vector (predicated).
Floating-point add vector (unpredicated).
Floating-point adjust exponent by vector (predicated).
Floating-point compare less than or equal to vector: an alias of FCM<cc> (vectors).
Floating-point compare less than vector: an alias of FCM<cc> (vectors).
Floating-point compare vector with zero.
Floating-point compare vectors.
Floating-point complex add with rotate (predicated).
Floating-point complex multiply-add by indexed values with rotate.
Floating-point complex multiply-add with rotate (predicated).
FCVT:
Floating-point convert precision (predicated).
Floating-point convert to signed integer, rounding toward zero (predicated).
Floating-point convert to unsigned integer, rounding toward zero (predicated).
FDIV:
Floating-point divide by vector (predicated).
Floating-point exponential accelerator.
Floating-point fused multiply-add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
Floating-point fused multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
FMAD:
Floating-point fused multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
Floating-point fused multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
Floating-point fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
FMSB:
Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
FCPY: Copy 8-bit
floating-point immediate to vector elements (predicated).
FMOV (immediate, predicated): Move 8-bit
floating-point immediate to vector elements (predicated): an alias of FCPY.
FDUP: Broadcast 8-bit
floating-point immediate to vector elements (unpredicated).
FMOV (immediate, unpredicated): Move 8-bit
floating-point immediate to vector elements (unpredicated): an alias of FDUP.
Floating-point maximum (predicated).
Floating-point maximum number (predicated).
Floating-point maximum number recursive reduction to scalar.
Floating-point maximum number with immediate (predicated).
Floating-point maximum recursive reduction to scalar.
Floating-point maximum with immediate (predicated).
Floating-point minimum (predicated).
Floating-point minimum number (predicated).
Floating-point minimum number recursive reduction to scalar.
Floating-point minimum number with immediate (predicated).
Floating-point minimum recursive reduction to scalar.
Floating-point minimum with immediate (predicated).
Floating-point multiply by immediate (predicated).
Floating-point multiply by indexed elements.
Floating-point multiply vectors (predicated).
Floating-point multiply vectors (unpredicated).
Floating-point multiply-extended vectors (predicated).
FNEG:
Floating-point negate (predicated).
Floating-point negated fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
Floating-point negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
Floating-point negated fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
Floating-point negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
Floating-point reciprocal estimate (unpredicated).
Floating-point reciprocal exponent (predicated).
Floating-point reciprocal square root estimate (unpredicated).
Floating-point reciprocal square root step (unpredicated).
Floating-point reciprocal step (unpredicated).
Floating-point reversed divide by vector (predicated).
Floating-point reversed subtract from immediate (predicated).
Floating-point reversed subtract vectors (predicated).
Floating-point round to integral value (predicated).
Floating-point square root (predicated).
Floating-point subtract immediate (predicated).
Floating-point subtract vectors (predicated).
Floating-point subtract vectors (unpredicated).
Floating-point trigonometric multiply-add coefficient.
Floating-point trigonometric select coefficient.
Floating-point trigonometric starting value.
FMAD: Floating-point fused multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
FMAX (immediate): Floating-point maximum with immediate (predicated).
FMAX (vectors): Floating-point maximum (predicated).
FMAXNM (immediate): Floating-point maximum number with immediate (predicated).
FMAXNM (vectors): Floating-point maximum number (predicated).
FMAXNMV: Floating-point maximum number recursive reduction to scalar.
FMAXV: Floating-point maximum recursive reduction to scalar.
FMIN (immediate): Floating-point minimum with immediate (predicated).
FMIN (vectors): Floating-point minimum (predicated).
FMINNM (immediate): Floating-point minimum number with immediate (predicated).
FMINNM (vectors): Floating-point minimum number (predicated).
FMINNMV: Floating-point minimum number recursive reduction to scalar.
FMINV: Floating-point minimum recursive reduction to scalar.
FMLA (indexed): Floating-point fused multiply-add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
FMLA (vectors): Floating-point fused multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
FMLS (indexed): Floating-point fused multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
FMOV (immediate, predicated): Move 8-bit floating-point immediate to vector elements (predicated): an alias of FCPY.
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to vector elements (unpredicated): an alias of FDUP.
FMOV (zero, predicated): Move floating-point +0.0 to vector elements (predicated): an alias of CPY (immediate).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector elements (unpredicated): an alias of DUP (immediate).
FMSB: Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
FMUL (immediate): Floating-point multiply by immediate (predicated).
FMUL (indexed): Floating-point multiply by indexed elements.
FMUL (vectors, predicated): Floating-point multiply vectors (predicated).
FMUL (vectors, unpredicated): Floating-point multiply vectors (unpredicated).
FMULX: Floating-point multiply-extended vectors (predicated).
FNEG: Floating-point negate (predicated).
FNMAD: Floating-point negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FNMLA: Floating-point negated fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
ASRD: Arithmetic shift right
for divide by immediate (predicated).
PTEST: Set condition flags
for predicate.
LD4B (scalar plus immediate): Contiguous load four-byte structures to
four vectors (immediate index).
LD4D (scalar plus immediate): Contiguous load four-doubleword structures to
four vectors (immediate index).
LD4H (scalar plus immediate): Contiguous load four-halfword structures to
four vectors (immediate index).
LD4W (scalar plus immediate): Contiguous load four-word structures to
four vectors (immediate index).
ST4B (scalar plus immediate): Contiguous store four-byte structures from
four vectors (immediate index).
ST4D (scalar plus immediate): Contiguous store four-doubleword structures from
four vectors (immediate index).
ST4H (scalar plus immediate): Contiguous store four-halfword structures from
four vectors (immediate index).
ST4W (scalar plus immediate): Contiguous store four-word structures from
four vectors (immediate index).
LD4B (scalar plus scalar): Contiguous load four-byte structures to
four vectors (scalar index).
LD4D (scalar plus scalar): Contiguous load four-doubleword structures to
four vectors (scalar index).
LD4H (scalar plus scalar): Contiguous load four-halfword structures to
four vectors (scalar index).
LD4W (scalar plus scalar): Contiguous load four-word structures to
four vectors (scalar index).
ST4B (scalar plus scalar): Contiguous store four-byte structures from
four vectors (scalar index).
ST4D (scalar plus scalar): Contiguous store four-doubleword structures from
four vectors (scalar index).
ST4H (scalar plus scalar): Contiguous store four-halfword structures from
four vectors (scalar index).
ST4W (scalar plus scalar): Contiguous store four-word structures from
four vectors (scalar index).
LD1RQW (scalar plus immediate): Contiguous load and replicate
four words (immediate index).
LD1RQW (scalar plus scalar): Contiguous load and replicate
four words (scalar index).
ST4B (scalar plus immediate): Contiguous store
four-byte structures from four vectors (immediate index).
ST4B (scalar plus scalar): Contiguous store
four-byte structures from four vectors (scalar index).
LD4B (scalar plus immediate): Contiguous load
four-byte structures to four vectors (immediate index).
LD4B (scalar plus scalar): Contiguous load
four-byte structures to four vectors (scalar index).
ST4D (scalar plus immediate): Contiguous store
four-doubleword structures from four vectors (immediate index).
ST4D (scalar plus scalar): Contiguous store
four-doubleword structures from four vectors (scalar index).
LD4D (scalar plus immediate): Contiguous load
four-doubleword structures to four vectors (immediate index).
LD4D (scalar plus scalar): Contiguous load
four-doubleword structures to four vectors (scalar index).
ST4H (scalar plus immediate): Contiguous store
four-halfword structures from four vectors (immediate index).
ST4H (scalar plus scalar): Contiguous store
four-halfword structures from four vectors (scalar index).
LD4H (scalar plus immediate): Contiguous load
four-halfword structures to four vectors (immediate index).
LD4H (scalar plus scalar): Contiguous load
four-halfword structures to four vectors (scalar index).
ST4W (scalar plus immediate): Contiguous store
four-word structures from four vectors (immediate index).
ST4W (scalar plus scalar): Contiguous store
four-word structures from four vectors (scalar index).
LD4W (scalar plus immediate): Contiguous load
four-word structures to four vectors (immediate index).
LD4W (scalar plus scalar): Contiguous load
four-word structures to four vectors (scalar index).
INSR (SIMD&FP scalar): Insert SIMD&
FP scalar register in shifted vector.
CPY (SIMD&FP scalar): Copy SIMD&
FP scalar register to vector elements (predicated).
MOV (SIMD&FP scalar, predicated): Move SIMD&
FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
CLASTA (SIMD&FP scalar): Conditionally extract element after last to SIMD&
FP scalar register.
CLASTB (SIMD&FP scalar): Conditionally extract last element to SIMD&
FP scalar register.
LASTA (SIMD&FP scalar): Extract element after last to SIMD&
FP scalar register.
LASTB (SIMD&FP scalar): Extract last element to SIMD&
FP scalar register.
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&
FP scalar to vector (unpredicated): an alias of DUP (indexed).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&
FP scalar).
FP scalar): Conditionally extract element after last to SIMD&FP scalar register.
FP scalar): Conditionally extract last element to SIMD&FP scalar register.
FP scalar): Copy SIMD&FP scalar register to vector elements (predicated).
FP scalar): Extract element after last to SIMD&FP scalar register.
FP scalar): Extract last element to SIMD&FP scalar register.
FP scalar): Insert SIMD&FP scalar register in shifted vector.
FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
FRECPE: Floating-point reciprocal estimate (unpredicated).
FRECPS: Floating-point reciprocal step (unpredicated).
FRECPX: Floating-point reciprocal exponent (predicated).
FRINT<r>: Floating-point round to integral value (predicated).
FRSQRTE: Floating-point reciprocal square root estimate (unpredicated).
FRSQRTS: Floating-point reciprocal square root step (unpredicated).
FSCALE: Floating-point adjust exponent by vector (predicated).
FSQRT: Floating-point square root (predicated).
FSUB (immediate): Floating-point subtract immediate (predicated).
FSUB (vectors, predicated): Floating-point subtract vectors (predicated).
FSUB (vectors, unpredicated): Floating-point subtract vectors (unpredicated).
FSUBR (immediate): Floating-point reversed subtract from immediate (predicated).
FSUBR (vectors): Floating-point reversed subtract vectors (predicated).
FTMAD: Floating-point trigonometric multiply-add coefficient.
FTSMUL: Floating-point trigonometric starting value.
FTSSEL: Floating-point trigonometric select coefficient.
FMLA (indexed): Floating-point
fused multiply-add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
FNMLA: Floating-point negated
fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FMLA (vectors): Floating-point
fused multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
FNMAD: Floating-point negated
fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FMAD: Floating-point
fused multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
FMLS (indexed): Floating-point
fused multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FNMLS: Floating-point negated
fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point
fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
FNMSB: Floating-point negated
fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point
fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
Gather load doublewords to vector (vector index).
Gather load first-fault doublewords to vector (immediate index).
Gather load first-fault doublewords to vector (vector index).
Gather load first-fault signed bytes to vector (immediate index).
Gather load first-fault signed bytes to vector (vector index).
Gather load first-fault signed halfwords to vector (immediate index).
Gather load first-fault signed halfwords to vector (vector index).
Gather load first-fault signed words to vector (immediate index).
Gather load first-fault signed words to vector (vector index).
Gather load first-fault unsigned bytes to vector (immediate index).
Gather load first-fault unsigned bytes to vector (vector index).
Gather load first-fault unsigned halfwords to vector (immediate index).
Gather load first-fault unsigned halfwords to vector (vector index).
Gather load first-fault unsigned words to vector (immediate index).
Gather load first-fault unsigned words to vector (vector index).
Gather load signed bytes to vector (immediate index).
Gather load signed bytes to vector (vector index).
Gather load signed halfwords to vector (immediate index).
Gather load signed halfwords to vector (vector index).
Gather load signed words to vector (immediate index).
Gather load signed words to vector (vector index).
Gather load unsigned bytes to vector (immediate index).
Gather load unsigned bytes to vector (vector index).
Gather load unsigned halfwords to vector (immediate index).
Gather load unsigned halfwords to vector (vector index).
Gather load unsigned words to vector (immediate index).
Gather load unsigned words to vector (vector index).
Gather prefetch bytes (scalar plus vector).
Gather prefetch bytes (vector plus immediate).
Gather prefetch doublewords (scalar plus vector).
Gather prefetch doublewords (vector plus immediate).
Gather prefetch halfwords (scalar plus vector).
Gather prefetch halfwords (vector plus immediate).
Gather prefetch words (scalar plus vector).
Gather prefetch words (vector plus immediate).
INDEX (scalar, immediate): Create index starting from
general-purpose register and incremented by immediate.
INSR (scalar): Insert
general-purpose register in shifted vector.
CPY (scalar): Copy
general-purpose register to vector elements (predicated).
MOV (scalar, predicated): Move
general-purpose register to vector elements (predicated): an alias of CPY (scalar).
DUP (scalar): Broadcast
general-purpose register to vector elements (unpredicated).
general-purpose register to vector elements (unpredicated): an alias of DUP (scalar).
CLASTA (scalar): Conditionally extract element after last to
general-purpose register.
CLASTB (scalar): Conditionally extract last element to
general-purpose register.
INDEX (immediate, scalar): Create index starting from immediate and incremented by
general-purpose register.
INDEX (scalars): Create index starting from and incremented by
general-purpose register.
LASTA (scalar): Extract element after last to
general-purpose register.
LASTB (scalar): Extract last element to
general-purpose register.
SMULH: Signed multiply returning high
UMULH: Unsigned multiply returning high
half (predicated).
PUNPKHI, PUNPKLO: Unpack and widen
half of predicate.
SUNPKHI, SUNPKLO: Signed unpack and extend
half of vector.
UUNPKHI, UUNPKLO: Unsigned unpack and extend
half of vector.
ZIP1, ZIP2 (predicates): Interleave elements from two
half predicates.
ZIP1, ZIP2 (vectors): Interleave elements from two
half vectors.
SXTB, SXTH, SXTW: Signed byte /
halfword / word extend (predicated).
UXTB, UXTH, UXTW: Unsigned byte /
halfword / word extend (predicated).
ST4H (scalar plus immediate): Contiguous store four-
halfword structures from four vectors (immediate index).
ST4H (scalar plus scalar): Contiguous store four-
halfword structures from four vectors (scalar index).
ST3H (scalar plus immediate): Contiguous store three-
halfword structures from three vectors (immediate index).
ST3H (scalar plus scalar): Contiguous store three-
halfword structures from three vectors (scalar index).
ST2H (scalar plus immediate): Contiguous store two-
halfword structures from two vectors (immediate index).
ST2H (scalar plus scalar): Contiguous store two-
halfword structures from two vectors (scalar index).
LD4H (scalar plus immediate): Contiguous load four-
halfword structures to four vectors (immediate index).
LD4H (scalar plus scalar): Contiguous load four-
halfword structures to four vectors (scalar index).
LD3H (scalar plus immediate): Contiguous load three-
halfword structures to three vectors (immediate index).
LD3H (scalar plus scalar): Contiguous load three-
halfword structures to three vectors (scalar index).
LD2H (scalar plus immediate): Contiguous load two-
halfword structures to two vectors (immediate index).
LD2H (scalar plus scalar): Contiguous load two-
halfword structures to two vectors (scalar index).
LD1RH: Load and broadcast unsigned
halfword to vector.
LD1RSH: Load and broadcast signed
halfword to vector.
LD1RQH (scalar plus immediate): Contiguous load and replicate eight
halfwords (immediate index).
PRFH (scalar plus immediate): Contiguous prefetch
halfwords (immediate index).
LD1RQH (scalar plus scalar): Contiguous load and replicate eight
halfwords (scalar index).
PRFH (scalar plus scalar): Contiguous prefetch
halfwords (scalar index).
PRFH (scalar plus vector): Gather prefetch
halfwords (scalar plus vector).
PRFH (vector plus immediate): Gather prefetch
halfwords (vector plus immediate).
REVB, REVH, REVW: Reverse bytes /
halfwords / words within elements (predicated).
ST1H (vector plus immediate): Scatter store
halfwords from a vector (immediate index).
ST1H (scalar plus vector): Scatter store
halfwords from a vector (vector index).
ST1H (scalar plus immediate): Contiguous store
halfwords from vector (immediate index).
STNT1H (scalar plus immediate): Contiguous store non-temporal
halfwords from vector (immediate index).
ST1H (scalar plus scalar): Contiguous store
halfwords from vector (scalar index).
STNT1H (scalar plus scalar): Contiguous store non-temporal
halfwords from vector (scalar index).
LD1H (scalar plus immediate): Contiguous load unsigned
halfwords to vector (immediate index).
LD1H (vector plus immediate): Gather load unsigned
halfwords to vector (immediate index).
LD1SH (scalar plus immediate): Contiguous load signed
halfwords to vector (immediate index).
LD1SH (vector plus immediate): Gather load signed
halfwords to vector (immediate index).
LDFF1H (vector plus immediate): Gather load first-fault unsigned
halfwords to vector (immediate index).
LDFF1SH (vector plus immediate): Gather load first-fault signed
halfwords to vector (immediate index).
LDNF1H: Contiguous load non-fault unsigned
halfwords to vector (immediate index).
LDNF1SH: Contiguous load non-fault signed
halfwords to vector (immediate index).
LDNT1H (scalar plus immediate): Contiguous load non-temporal
halfwords to vector (immediate index).
LD1H (scalar plus scalar): Contiguous load unsigned
halfwords to vector (scalar index).
LD1SH (scalar plus scalar): Contiguous load signed
halfwords to vector (scalar index).
LDFF1H (scalar plus scalar): Contiguous load first-fault unsigned
halfwords to vector (scalar index).
LDFF1SH (scalar plus scalar): Contiguous load first-fault signed
halfwords to vector (scalar index).
LDNT1H (scalar plus scalar): Contiguous load non-temporal
halfwords to vector (scalar index).
LD1H (scalar plus vector): Gather load unsigned
halfwords to vector (vector index).
LD1SH (scalar plus vector): Gather load signed
halfwords to vector (vector index).
LDFF1H (scalar plus vector): Gather load first-fault unsigned
halfwords to vector (vector index).
LDFF1SH (scalar plus vector): Gather load first-fault signed
halfwords to vector (vector index).
SMULH: Signed multiply returning
high half (predicated).
UMULH: Unsigned multiply returning
high half (predicated).
ASR (immediate, predicated): Arithmetic shift right by
ASRD: Arithmetic shift right for divide by
immediate (predicated).
FADD (immediate): Floating-point add
immediate (predicated).
FMAX (immediate): Floating-point maximum with
immediate (predicated).
FMAXNM (immediate): Floating-point maximum number with
immediate (predicated).
FMIN (immediate): Floating-point minimum with
immediate (predicated).
FMINNM (immediate): Floating-point minimum number with
immediate (predicated).
FMUL (immediate): Floating-point multiply by
immediate (predicated).
FSUB (immediate): Floating-point subtract
immediate (predicated).
FSUBR (immediate): Floating-point reversed subtract from
immediate (predicated).
LSL (immediate, predicated): Logical shift left by
immediate (predicated).
LSR (immediate, predicated): Logical shift right by
immediate (predicated).
ADD (immediate): Add
immediate (unpredicated).
AND (immediate): Bitwise AND with
immediate (unpredicated).
ASR (immediate, unpredicated): Arithmetic shift right by
immediate (unpredicated).
EOR (immediate): Bitwise exclusive OR with
immediate (unpredicated).
LSL (immediate, unpredicated): Logical shift left by
immediate (unpredicated).
LSR (immediate, unpredicated): Logical shift right by
immediate (unpredicated).
MUL (immediate): Multiply by
immediate (unpredicated).
ORR (immediate): Bitwise OR with
immediate (unpredicated).
SMAX (immediate): Signed maximum with
immediate (unpredicated).
SMIN (immediate): Signed minimum with
immediate (unpredicated).
SQADD (immediate): Signed saturating add
immediate (unpredicated).
SQSUB (immediate): Signed saturating subtract
immediate (unpredicated).
SUB (immediate): Subtract
immediate (unpredicated).
SUBR (immediate): Reversed subtract from
immediate (unpredicated).
UMAX (immediate): Unsigned maximum with
immediate (unpredicated).
UMIN (immediate): Unsigned minimum with
immediate (unpredicated).
UQADD (immediate): Unsigned saturating add
immediate (unpredicated).
UQSUB (immediate): Unsigned saturating subtract
immediate (unpredicated).
BIC (immediate): Bitwise clear bits using
immediate (unpredicated): an alias of AND (immediate).
EON: Bitwise exclusive OR with inverted
immediate (unpredicated): an alias of EOR (immediate).
ORN (immediate): Bitwise OR with inverted
immediate (unpredicated): an alias of ORR (immediate).
INDEX (immediate, scalar): Create index starting from
immediate and incremented by general-purpose register.
LD1B (scalar plus immediate): Contiguous load unsigned bytes to vector (
immediate index).
LD1B (vector plus immediate): Gather load unsigned bytes to vector (
immediate index).
LD1D (scalar plus immediate): Contiguous load doublewords to vector (
immediate index).
LD1D (vector plus immediate): Gather load doublewords to vector (
immediate index).
LD1H (scalar plus immediate): Contiguous load unsigned halfwords to vector (
immediate index).
LD1H (vector plus immediate): Gather load unsigned halfwords to vector (
immediate index).
LD1RQB (scalar plus immediate): Contiguous load and replicate sixteen bytes (
immediate index).
LD1RQD (scalar plus immediate): Contiguous load and replicate two doublewords (
immediate index).
LD1RQH (scalar plus immediate): Contiguous load and replicate eight halfwords (
immediate index).
LD1RQW (scalar plus immediate): Contiguous load and replicate four words (
immediate index).
LD1SB (scalar plus immediate): Contiguous load signed bytes to vector (
immediate index).
LD1SB (vector plus immediate): Gather load signed bytes to vector (
immediate index).
LD1SH (scalar plus immediate): Contiguous load signed halfwords to vector (
immediate index).
LD1SH (vector plus immediate): Gather load signed halfwords to vector (
immediate index).
LD1SW (scalar plus immediate): Contiguous load signed words to vector (
immediate index).
LD1SW (vector plus immediate): Gather load signed words to vector (
immediate index).
LD1W (scalar plus immediate): Contiguous load unsigned words to vector (
immediate index).
LD1W (vector plus immediate): Gather load unsigned words to vector (
immediate index).
LD2B (scalar plus immediate): Contiguous load two-byte structures to two vectors (
immediate index).
LD2D (scalar plus immediate): Contiguous load two-doubleword structures to two vectors (
immediate index).
LD2H (scalar plus immediate): Contiguous load two-halfword structures to two vectors (
immediate index).
LD2W (scalar plus immediate): Contiguous load two-word structures to two vectors (
immediate index).
LD3B (scalar plus immediate): Contiguous load three-byte structures to three vectors (
immediate index).
LD3D (scalar plus immediate): Contiguous load three-doubleword structures to three vectors (
immediate index).
LD3H (scalar plus immediate): Contiguous load three-halfword structures to three vectors (
immediate index).
LD3W (scalar plus immediate): Contiguous load three-word structures to three vectors (
immediate index).
LD4B (scalar plus immediate): Contiguous load four-byte structures to four vectors (
immediate index).
LD4D (scalar plus immediate): Contiguous load four-doubleword structures to four vectors (
immediate index).
LD4H (scalar plus immediate): Contiguous load four-halfword structures to four vectors (
immediate index).
LD4W (scalar plus immediate): Contiguous load four-word structures to four vectors (
immediate index).
LDFF1B (vector plus immediate): Gather load first-fault unsigned bytes to vector (
immediate index).
LDFF1D (vector plus immediate): Gather load first-fault doublewords to vector (
immediate index).
LDFF1H (vector plus immediate): Gather load first-fault unsigned halfwords to vector (
immediate index).
LDFF1SB (vector plus immediate): Gather load first-fault signed bytes to vector (
immediate index).
LDFF1SH (vector plus immediate): Gather load first-fault signed halfwords to vector (
immediate index).
LDFF1SW (vector plus immediate): Gather load first-fault signed words to vector (
immediate index).
LDFF1W (vector plus immediate): Gather load first-fault unsigned words to vector (
immediate index).
LDNF1B: Contiguous load non-fault unsigned bytes to vector (
immediate index).
LDNF1D: Contiguous load non-fault doublewords to vector (
immediate index).
LDNF1H: Contiguous load non-fault unsigned halfwords to vector (
immediate index).
LDNF1SB: Contiguous load non-fault signed bytes to vector (
immediate index).
LDNF1SH: Contiguous load non-fault signed halfwords to vector (
immediate index).
LDNF1SW: Contiguous load non-fault signed words to vector (
immediate index).
LDNF1W: Contiguous load non-fault unsigned words to vector (
immediate index).
LDNT1B (scalar plus immediate): Contiguous load non-temporal bytes to vector (
immediate index).
LDNT1D (scalar plus immediate): Contiguous load non-temporal doublewords to vector (
immediate index).
LDNT1H (scalar plus immediate): Contiguous load non-temporal halfwords to vector (
immediate index).
LDNT1W (scalar plus immediate): Contiguous load non-temporal words to vector (
immediate index).
PRFB (scalar plus immediate): Contiguous prefetch bytes (
immediate index).
PRFD (scalar plus immediate): Contiguous prefetch doublewords (
immediate index).
PRFH (scalar plus immediate): Contiguous prefetch halfwords (
immediate index).
PRFW (scalar plus immediate): Contiguous prefetch words (
immediate index).
ST1B (scalar plus immediate): Contiguous store bytes from vector (
immediate index).
ST1B (vector plus immediate): Scatter store bytes from a vector (
immediate index).
ST1D (scalar plus immediate): Contiguous store doublewords from vector (
immediate index).
ST1D (vector plus immediate): Scatter store doublewords from a vector (
immediate index).
ST1H (scalar plus immediate): Contiguous store halfwords from vector (
immediate index).
ST1H (vector plus immediate): Scatter store halfwords from a vector (
immediate index).
ST1W (scalar plus immediate): Contiguous store words from vector (
immediate index).
ST1W (vector plus immediate): Scatter store words from a vector (
immediate index).
ST2B (scalar plus immediate): Contiguous store two-byte structures from two vectors (
immediate index).
ST2D (scalar plus immediate): Contiguous store two-doubleword structures from two vectors (
immediate index).
ST2H (scalar plus immediate): Contiguous store two-halfword structures from two vectors (
immediate index).
ST2W (scalar plus immediate): Contiguous store two-word structures from two vectors (
immediate index).
ST3B (scalar plus immediate): Contiguous store three-byte structures from three vectors (
immediate index).
ST3D (scalar plus immediate): Contiguous store three-doubleword structures from three vectors (
immediate index).
ST3H (scalar plus immediate): Contiguous store three-halfword structures from three vectors (
immediate index).
ST3W (scalar plus immediate): Contiguous store three-word structures from three vectors (
immediate index).
ST4B (scalar plus immediate): Contiguous store four-byte structures from four vectors (
immediate index).
ST4D (scalar plus immediate): Contiguous store four-doubleword structures from four vectors (
immediate index).
ST4H (scalar plus immediate): Contiguous store four-halfword structures from four vectors (
immediate index).
ST4W (scalar plus immediate): Contiguous store four-word structures from four vectors (
immediate index).
STNT1B (scalar plus immediate): Contiguous store non-temporal bytes from vector (
immediate index).
STNT1D (scalar plus immediate): Contiguous store non-temporal doublewords from vector (
immediate index).
STNT1H (scalar plus immediate): Contiguous store non-temporal halfwords from vector (
immediate index).
STNT1W (scalar plus immediate): Contiguous store non-temporal words from vector (
immediate index).
DUPM: Broadcast logical bitmask
immediate to vector (unpredicated).
MOV (bitmask immediate): Move logical bitmask
immediate to vector (unpredicated): an alias of DUPM.
CPY (immediate): Copy signed integer
immediate to vector elements (predicated).
FCPY: Copy 8-bit floating-point
immediate to vector elements (predicated).
MOV (immediate, predicated): Move signed integer
immediate to vector elements (predicated): an alias of CPY (immediate).
FMOV (immediate, predicated): Move 8-bit floating-point
immediate to vector elements (predicated): an alias of FCPY.
DUP (immediate): Broadcast signed
immediate to vector elements (unpredicated).
FDUP: Broadcast 8-bit floating-point
immediate to vector elements (unpredicated).
MOV (immediate, unpredicated): Move signed
immediate to vector elements (unpredicated): an alias of DUP (immediate).
FMOV (immediate, unpredicated): Move 8-bit floating-point
immediate to vector elements (unpredicated): an alias of FDUP.
BIC (immediate): Bitwise clear bits using immediate (unpredicated): an alias of AND (
immediate).
EON: Bitwise exclusive OR with inverted immediate (unpredicated): an alias of EOR (
immediate).
FMOV (zero, predicated): Move floating-point +0.0 to vector elements (predicated): an alias of CPY (
immediate).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector elements (unpredicated): an alias of DUP (
immediate).
MOV (immediate, predicated): Move signed integer immediate to vector elements (predicated): an alias of CPY (
immediate).
MOV (immediate, unpredicated): Move signed immediate to vector elements (unpredicated): an alias of DUP (
immediate).
ORN (immediate): Bitwise OR with inverted immediate (unpredicated): an alias of ORR (
immediate).
PRFB (vector plus immediate): Gather prefetch bytes (vector plus
immediate).
PRFD (vector plus immediate): Gather prefetch doublewords (vector plus
immediate).
PRFH (vector plus immediate): Gather prefetch halfwords (vector plus
immediate).
PRFW (vector plus immediate): Gather prefetch words (vector plus
immediate).
immediate): Add immediate (unpredicated).
immediate): Bitwise AND with immediate (unpredicated).
immediate): Bitwise clear bits using immediate (unpredicated): an alias of AND (immediate).
immediate): Bitwise exclusive OR with immediate (unpredicated).
immediate): Bitwise OR with immediate (unpredicated).
immediate): Bitwise OR with inverted immediate (unpredicated): an alias of ORR (immediate).
immediate): Broadcast signed immediate to vector elements (unpredicated).
immediate): Compare vector to immediate.
immediate): Contiguous load and replicate eight halfwords (immediate index).
immediate): Contiguous load and replicate four words (immediate index).
immediate): Contiguous load and replicate sixteen bytes (immediate index).
immediate): Contiguous load and replicate two doublewords (immediate index).
immediate): Contiguous load doublewords to vector (immediate index).
immediate): Contiguous load four-byte structures to four vectors (immediate index).
immediate): Contiguous load four-doubleword structures to four vectors (immediate index).
immediate): Contiguous load four-halfword structures to four vectors (immediate index).
immediate): Contiguous load four-word structures to four vectors (immediate index).
immediate): Contiguous load non-temporal bytes to vector (immediate index).
immediate): Contiguous load non-temporal doublewords to vector (immediate index).
immediate): Contiguous load non-temporal halfwords to vector (immediate index).
immediate): Contiguous load non-temporal words to vector (immediate index).
immediate): Contiguous load signed bytes to vector (immediate index).
immediate): Contiguous load signed halfwords to vector (immediate index).
immediate): Contiguous load signed words to vector (immediate index).
immediate): Contiguous load three-byte structures to three vectors (immediate index).
immediate): Contiguous load three-doubleword structures to three vectors (immediate index).
immediate): Contiguous load three-halfword structures to three vectors (immediate index).
immediate): Contiguous load three-word structures to three vectors (immediate index).
immediate): Contiguous load two-byte structures to two vectors (immediate index).
immediate): Contiguous load two-doubleword structures to two vectors (immediate index).
immediate): Contiguous load two-halfword structures to two vectors (immediate index).
immediate): Contiguous load two-word structures to two vectors (immediate index).
immediate): Contiguous load unsigned bytes to vector (immediate index).
immediate): Contiguous load unsigned halfwords to vector (immediate index).
immediate): Contiguous load unsigned words to vector (immediate index).
immediate): Contiguous prefetch bytes (immediate index).
immediate): Contiguous prefetch doublewords (immediate index).
immediate): Contiguous prefetch halfwords (immediate index).
immediate): Contiguous prefetch words (immediate index).
immediate): Contiguous store bytes from vector (immediate index).
immediate): Contiguous store doublewords from vector (immediate index).
immediate): Contiguous store four-byte structures from four vectors (immediate index).
immediate): Contiguous store four-doubleword structures from four vectors (immediate index).
immediate): Contiguous store four-halfword structures from four vectors (immediate index).
immediate): Contiguous store four-word structures from four vectors (immediate index).
immediate): Contiguous store halfwords from vector (immediate index).
immediate): Contiguous store non-temporal bytes from vector (immediate index).
immediate): Contiguous store non-temporal doublewords from vector (immediate index).
immediate): Contiguous store non-temporal halfwords from vector (immediate index).
immediate): Contiguous store non-temporal words from vector (immediate index).
immediate): Contiguous store three-byte structures from three vectors (immediate index).
immediate): Contiguous store three-doubleword structures from three vectors (immediate index).
immediate): Contiguous store three-halfword structures from three vectors (immediate index).
immediate): Contiguous store three-word structures from three vectors (immediate index).
immediate): Contiguous store two-byte structures from two vectors (immediate index).
immediate): Contiguous store two-doubleword structures from two vectors (immediate index).
immediate): Contiguous store two-halfword structures from two vectors (immediate index).
immediate): Contiguous store two-word structures from two vectors (immediate index).
immediate): Contiguous store words from vector (immediate index).
immediate): Copy signed integer immediate to vector elements (predicated).
immediate): Create index starting from general-purpose register and incremented by immediate.
immediate): Floating-point add immediate (predicated).
immediate): Floating-point maximum number with immediate (predicated).
immediate): Floating-point maximum with immediate (predicated).
immediate): Floating-point minimum number with immediate (predicated).
immediate): Floating-point minimum with immediate (predicated).
immediate): Floating-point multiply by immediate (predicated).
immediate): Floating-point reversed subtract from immediate (predicated).
immediate): Floating-point subtract immediate (predicated).
immediate): Gather load doublewords to vector (immediate index).
immediate): Gather load first-fault doublewords to vector (immediate index).
immediate): Gather load first-fault signed bytes to vector (immediate index).
immediate): Gather load first-fault signed halfwords to vector (immediate index).
immediate): Gather load first-fault signed words to vector (immediate index).
immediate): Gather load first-fault unsigned bytes to vector (immediate index).
immediate): Gather load first-fault unsigned halfwords to vector (immediate index).
immediate): Gather load first-fault unsigned words to vector (immediate index).
immediate): Gather load signed bytes to vector (immediate index).
immediate): Gather load signed halfwords to vector (immediate index).
immediate): Gather load signed words to vector (immediate index).
immediate): Gather load unsigned bytes to vector (immediate index).
immediate): Gather load unsigned halfwords to vector (immediate index).
immediate): Gather load unsigned words to vector (immediate index).
immediate): Gather prefetch bytes (vector plus immediate).
immediate): Gather prefetch doublewords (vector plus immediate).
immediate): Gather prefetch halfwords (vector plus immediate).
immediate): Gather prefetch words (vector plus immediate).
immediate): Move logical bitmask immediate to vector (unpredicated): an alias of DUPM.
immediate): Multiply by immediate (unpredicated).
immediate): Reversed subtract from immediate (unpredicated).
immediate): Scatter store bytes from a vector (immediate index).
immediate): Scatter store doublewords from a vector (immediate index).
immediate): Scatter store halfwords from a vector (immediate index).
immediate): Scatter store words from a vector (immediate index).
immediate): Signed maximum with immediate (unpredicated).
immediate): Signed minimum with immediate (unpredicated).
immediate): Signed saturating add immediate (unpredicated).
immediate): Signed saturating subtract immediate (unpredicated).
immediate): Subtract immediate (unpredicated).
immediate): Unsigned maximum with immediate (unpredicated).
immediate): Unsigned minimum with immediate (unpredicated).
immediate): Unsigned saturating add immediate (unpredicated).
immediate): Unsigned saturating subtract immediate (unpredicated).
immediate, predicated): Arithmetic shift right by immediate (predicated).
immediate, predicated): Logical shift left by immediate (predicated).
immediate, predicated): Logical shift right by immediate (predicated).
immediate, predicated): Move 8-bit floating-point immediate to vector elements (predicated): an alias of FCPY.
immediate, predicated): Move signed integer immediate to vector elements (predicated): an alias of CPY (immediate).
immediate, scalar): Create index starting from immediate and incremented by general-purpose register.
immediate, unpredicated): Arithmetic shift right by immediate (unpredicated).
immediate, unpredicated): Logical shift left by immediate (unpredicated).
immediate, unpredicated): Logical shift right by immediate (unpredicated).
immediate, unpredicated): Move 8-bit floating-point immediate to vector elements (unpredicated): an alias of FDUP.
immediate, unpredicated): Move signed immediate to vector elements (unpredicated): an alias of DUP (immediate).
CMP<cc> (immediate): Compare vector to
immediate.
INDEX (immediates): Create index starting from and incremented by
immediate.
INDEX (scalar, immediate): Create index starting from general-purpose register and incremented by
immediate.
immediates): Create index starting from and incremented by immediate.
INCB, INCD, INCH, INCW (scalar): Increment scalar by multiple of predicate constraint element count.
INCD, INCH, INCW (scalar): Increment scalar by multiple of predicate constraint element count.
INCD, INCH, INCW (vector): Increment vector by multiple of predicate constraint element count.
INCH, INCW (scalar): Increment scalar by multiple of predicate constraint element count.
INCH, INCW (vector): Increment vector by multiple of predicate constraint element count.
INCP (scalar): Increment scalar by active predicate element count.
INCP (vector): Increment vector by active predicate element count.
Increment scalar by active predicate element count.
SQINCP (scalar): Signed saturating
increment scalar by active predicate element count.
UQINCP (scalar): Unsigned saturating
increment scalar by active predicate element count.
SQINCH (scalar): Signed saturating
increment scalar by multiple of 16-bit predicate constraint element count.
UQINCH (scalar): Unsigned saturating
increment scalar by multiple of 16-bit predicate constraint element count.
SQINCW (scalar): Signed saturating
increment scalar by multiple of 32-bit predicate constraint element count.
UQINCW (scalar): Unsigned saturating
increment scalar by multiple of 32-bit predicate constraint element count.
SQINCD (scalar): Signed saturating
increment scalar by multiple of 64-bit predicate constraint element count.
UQINCD (scalar): Unsigned saturating
increment scalar by multiple of 64-bit predicate constraint element count.
SQINCB: Signed saturating
increment scalar by multiple of 8-bit predicate constraint element count.
UQINCB: Unsigned saturating
increment scalar by multiple of 8-bit predicate constraint element count.
Increment scalar by multiple of predicate constraint element count.
Increment vector by active predicate element count.
SQINCP (vector): Signed saturating
increment vector by active predicate element count.
UQINCP (vector): Unsigned saturating
increment vector by active predicate element count.
SQINCH (vector): Signed saturating
increment vector by multiple of 16-bit predicate constraint element count.
UQINCH (vector): Unsigned saturating
increment vector by multiple of 16-bit predicate constraint element count.
SQINCW (vector): Signed saturating
increment vector by multiple of 32-bit predicate constraint element count.
UQINCW (vector): Unsigned saturating
increment vector by multiple of 32-bit predicate constraint element count.
SQINCD (vector): Signed saturating
increment vector by multiple of 64-bit predicate constraint element count.
UQINCD (vector): Unsigned saturating
increment vector by multiple of 64-bit predicate constraint element count.
Increment vector by multiple of predicate constraint element count.
INDEX (immediate, scalar): Create index starting from immediate and
incremented by general-purpose register.
INDEX (scalars): Create index starting from and
incremented by general-purpose register.
INDEX (immediates): Create index starting from and
incremented by immediate.
INDEX (scalar, immediate): Create index starting from general-purpose register and
incremented by immediate.
WHILELE: While
incrementing signed scalar less than or equal to scalar.
WHILELT: While
incrementing signed scalar less than scalar.
WHILELS: While
incrementing unsigned scalar lower or same as scalar.
WHILELO: While
incrementing unsigned scalar lower than scalar.
INCW (scalar): Increment scalar by multiple of predicate constraint element count.
INCW (vector): Increment vector by multiple of predicate constraint element count.
INDEX (immediate, scalar): Create index starting from immediate and incremented by general-purpose register.
INDEX (immediates): Create index starting from and incremented by immediate.
INDEX (scalar, immediate): Create index starting from general-purpose register and incremented by immediate.
INDEX (scalars): Create index starting from and incremented by general-purpose register.
INDEX (scalars): Create
index starting from and incremented by general-purpose register.
INDEX (immediates): Create
index starting from and incremented by immediate.
INDEX (scalar, immediate): Create
index starting from general-purpose register and incremented by immediate.
INDEX (immediate, scalar): Create
index starting from immediate and incremented by general-purpose register.
LD1B (scalar plus immediate): Contiguous load unsigned bytes to vector (immediate
index).
LD1B (scalar plus scalar): Contiguous load unsigned bytes to vector (scalar
index).
LD1B (scalar plus vector): Gather load unsigned bytes to vector (vector
index).
LD1B (vector plus immediate): Gather load unsigned bytes to vector (immediate
index).
LD1D (scalar plus immediate): Contiguous load doublewords to vector (immediate
index).
LD1D (scalar plus scalar): Contiguous load doublewords to vector (scalar
index).
LD1D (scalar plus vector): Gather load doublewords to vector (vector
index).
LD1D (vector plus immediate): Gather load doublewords to vector (immediate
index).
LD1H (scalar plus immediate): Contiguous load unsigned halfwords to vector (immediate
index).
LD1H (scalar plus scalar): Contiguous load unsigned halfwords to vector (scalar
index).
LD1H (scalar plus vector): Gather load unsigned halfwords to vector (vector
index).
LD1H (vector plus immediate): Gather load unsigned halfwords to vector (immediate
index).
LD1RQB (scalar plus immediate): Contiguous load and replicate sixteen bytes (immediate
index).
LD1RQB (scalar plus scalar): Contiguous load and replicate sixteen bytes (scalar
index).
LD1RQD (scalar plus immediate): Contiguous load and replicate two doublewords (immediate
index).
LD1RQD (scalar plus scalar): Contiguous load and replicate two doublewords (scalar
index).
LD1RQH (scalar plus immediate): Contiguous load and replicate eight halfwords (immediate
index).
LD1RQH (scalar plus scalar): Contiguous load and replicate eight halfwords (scalar
index).
LD1RQW (scalar plus immediate): Contiguous load and replicate four words (immediate
index).
LD1RQW (scalar plus scalar): Contiguous load and replicate four words (scalar
index).
LD1SB (scalar plus immediate): Contiguous load signed bytes to vector (immediate
index).
LD1SB (scalar plus scalar): Contiguous load signed bytes to vector (scalar
index).
LD1SB (scalar plus vector): Gather load signed bytes to vector (vector
index).
LD1SB (vector plus immediate): Gather load signed bytes to vector (immediate
index).
LD1SH (scalar plus immediate): Contiguous load signed halfwords to vector (immediate
index).
LD1SH (scalar plus scalar): Contiguous load signed halfwords to vector (scalar
index).
LD1SH (scalar plus vector): Gather load signed halfwords to vector (vector
index).
LD1SH (vector plus immediate): Gather load signed halfwords to vector (immediate
index).
LD1SW (scalar plus immediate): Contiguous load signed words to vector (immediate
index).
LD1SW (scalar plus scalar): Contiguous load signed words to vector (scalar
index).
LD1SW (scalar plus vector): Gather load signed words to vector (vector
index).
LD1SW (vector plus immediate): Gather load signed words to vector (immediate
index).
LD1W (scalar plus immediate): Contiguous load unsigned words to vector (immediate
index).
LD1W (scalar plus scalar): Contiguous load unsigned words to vector (scalar
index).
LD1W (scalar plus vector): Gather load unsigned words to vector (vector
index).
LD1W (vector plus immediate): Gather load unsigned words to vector (immediate
index).
LD2B (scalar plus immediate): Contiguous load two-byte structures to two vectors (immediate
index).
LD2B (scalar plus scalar): Contiguous load two-byte structures to two vectors (scalar
index).
LD2D (scalar plus immediate): Contiguous load two-doubleword structures to two vectors (immediate
index).
LD2D (scalar plus scalar): Contiguous load two-doubleword structures to two vectors (scalar
index).
LD2H (scalar plus immediate): Contiguous load two-halfword structures to two vectors (immediate
index).
LD2H (scalar plus scalar): Contiguous load two-halfword structures to two vectors (scalar
index).
LD2W (scalar plus immediate): Contiguous load two-word structures to two vectors (immediate
index).
LD2W (scalar plus scalar): Contiguous load two-word structures to two vectors (scalar
index).
LD3B (scalar plus immediate): Contiguous load three-byte structures to three vectors (immediate
index).
LD3B (scalar plus scalar): Contiguous load three-byte structures to three vectors (scalar
index).
LD3D (scalar plus immediate): Contiguous load three-doubleword structures to three vectors (immediate
index).
LD3D (scalar plus scalar): Contiguous load three-doubleword structures to three vectors (scalar
index).
LD3H (scalar plus immediate): Contiguous load three-halfword structures to three vectors (immediate
index).
LD3H (scalar plus scalar): Contiguous load three-halfword structures to three vectors (scalar
index).
LD3W (scalar plus immediate): Contiguous load three-word structures to three vectors (immediate
index).
LD3W (scalar plus scalar): Contiguous load three-word structures to three vectors (scalar
index).
LD4B (scalar plus immediate): Contiguous load four-byte structures to four vectors (immediate
index).
LD4B (scalar plus scalar): Contiguous load four-byte structures to four vectors (scalar
index).
LD4D (scalar plus immediate): Contiguous load four-doubleword structures to four vectors (immediate
index).
LD4D (scalar plus scalar): Contiguous load four-doubleword structures to four vectors (scalar
index).
LD4H (scalar plus immediate): Contiguous load four-halfword structures to four vectors (immediate
index).
LD4H (scalar plus scalar): Contiguous load four-halfword structures to four vectors (scalar
index).
LD4W (scalar plus immediate): Contiguous load four-word structures to four vectors (immediate
index).
LD4W (scalar plus scalar): Contiguous load four-word structures to four vectors (scalar
index).
LDFF1B (scalar plus scalar): Contiguous load first-fault unsigned bytes to vector (scalar
index).
LDFF1B (scalar plus vector): Gather load first-fault unsigned bytes to vector (vector
index).
LDFF1B (vector plus immediate): Gather load first-fault unsigned bytes to vector (immediate
index).
LDFF1D (scalar plus scalar): Contiguous load first-fault doublewords to vector (scalar
index).
LDFF1D (scalar plus vector): Gather load first-fault doublewords to vector (vector
index).
LDFF1D (vector plus immediate): Gather load first-fault doublewords to vector (immediate
index).
LDFF1H (scalar plus scalar): Contiguous load first-fault unsigned halfwords to vector (scalar
index).
LDFF1H (scalar plus vector): Gather load first-fault unsigned halfwords to vector (vector
index).
LDFF1H (vector plus immediate): Gather load first-fault unsigned halfwords to vector (immediate
index).
LDFF1SB (scalar plus scalar): Contiguous load first-fault signed bytes to vector (scalar
index).
LDFF1SB (scalar plus vector): Gather load first-fault signed bytes to vector (vector
index).
LDFF1SB (vector plus immediate): Gather load first-fault signed bytes to vector (immediate
index).
LDFF1SH (scalar plus scalar): Contiguous load first-fault signed halfwords to vector (scalar
index).
LDFF1SH (scalar plus vector): Gather load first-fault signed halfwords to vector (vector
index).
LDFF1SH (vector plus immediate): Gather load first-fault signed halfwords to vector (immediate
index).
LDFF1SW (scalar plus scalar): Contiguous load first-fault signed words to vector (scalar
index).
LDFF1SW (scalar plus vector): Gather load first-fault signed words to vector (vector
index).
LDFF1SW (vector plus immediate): Gather load first-fault signed words to vector (immediate
index).
LDFF1W (scalar plus scalar): Contiguous load first-fault unsigned words to vector (scalar
index).
LDFF1W (scalar plus vector): Gather load first-fault unsigned words to vector (vector
index).
LDFF1W (vector plus immediate): Gather load first-fault unsigned words to vector (immediate
index).
LDNF1B: Contiguous load non-fault unsigned bytes to vector (immediate
index).
LDNF1D: Contiguous load non-fault doublewords to vector (immediate
index).
LDNF1H: Contiguous load non-fault unsigned halfwords to vector (immediate
index).
LDNF1SB: Contiguous load non-fault signed bytes to vector (immediate
index).
LDNF1SH: Contiguous load non-fault signed halfwords to vector (immediate
index).
LDNF1SW: Contiguous load non-fault signed words to vector (immediate
index).
LDNF1W: Contiguous load non-fault unsigned words to vector (immediate
index).
LDNT1B (scalar plus immediate): Contiguous load non-temporal bytes to vector (immediate
index).
LDNT1B (scalar plus scalar): Contiguous load non-temporal bytes to vector (scalar
index).
LDNT1D (scalar plus immediate): Contiguous load non-temporal doublewords to vector (immediate
index).
LDNT1D (scalar plus scalar): Contiguous load non-temporal doublewords to vector (scalar
index).
LDNT1H (scalar plus immediate): Contiguous load non-temporal halfwords to vector (immediate
index).
LDNT1H (scalar plus scalar): Contiguous load non-temporal halfwords to vector (scalar
index).
LDNT1W (scalar plus immediate): Contiguous load non-temporal words to vector (immediate
index).
LDNT1W (scalar plus scalar): Contiguous load non-temporal words to vector (scalar
index).
PRFB (scalar plus immediate): Contiguous prefetch bytes (immediate
index).
PRFB (scalar plus scalar): Contiguous prefetch bytes (scalar
index).
PRFD (scalar plus immediate): Contiguous prefetch doublewords (immediate
index).
PRFD (scalar plus scalar): Contiguous prefetch doublewords (scalar
index).
PRFH (scalar plus immediate): Contiguous prefetch halfwords (immediate
index).
PRFH (scalar plus scalar): Contiguous prefetch halfwords (scalar
index).
PRFW (scalar plus immediate): Contiguous prefetch words (immediate
index).
PRFW (scalar plus scalar): Contiguous prefetch words (scalar
index).
ST1B (scalar plus immediate): Contiguous store bytes from vector (immediate
index).
ST1B (scalar plus scalar): Contiguous store bytes from vector (scalar
index).
ST1B (scalar plus vector): Scatter store bytes from a vector (vector
index).
ST1B (vector plus immediate): Scatter store bytes from a vector (immediate
index).
ST1D (scalar plus immediate): Contiguous store doublewords from vector (immediate
index).
ST1D (scalar plus scalar): Contiguous store doublewords from vector (scalar
index).
ST1D (scalar plus vector): Scatter store doublewords from a vector (vector
index).
ST1D (vector plus immediate): Scatter store doublewords from a vector (immediate
index).
ST1H (scalar plus immediate): Contiguous store halfwords from vector (immediate
index).
ST1H (scalar plus scalar): Contiguous store halfwords from vector (scalar
index).
ST1H (scalar plus vector): Scatter store halfwords from a vector (vector
index).
ST1H (vector plus immediate): Scatter store halfwords from a vector (immediate
index).
ST1W (scalar plus immediate): Contiguous store words from vector (immediate
index).
ST1W (scalar plus scalar): Contiguous store words from vector (scalar
index).
ST1W (scalar plus vector): Scatter store words from a vector (vector
index).
ST1W (vector plus immediate): Scatter store words from a vector (immediate
index).
ST2B (scalar plus immediate): Contiguous store two-byte structures from two vectors (immediate
index).
ST2B (scalar plus scalar): Contiguous store two-byte structures from two vectors (scalar
index).
ST2D (scalar plus immediate): Contiguous store two-doubleword structures from two vectors (immediate
index).
ST2D (scalar plus scalar): Contiguous store two-doubleword structures from two vectors (scalar
index).
ST2H (scalar plus immediate): Contiguous store two-halfword structures from two vectors (immediate
index).
ST2H (scalar plus scalar): Contiguous store two-halfword structures from two vectors (scalar
index).
ST2W (scalar plus immediate): Contiguous store two-word structures from two vectors (immediate
index).
ST2W (scalar plus scalar): Contiguous store two-word structures from two vectors (scalar
index).
ST3B (scalar plus immediate): Contiguous store three-byte structures from three vectors (immediate
index).
ST3B (scalar plus scalar): Contiguous store three-byte structures from three vectors (scalar
index).
ST3D (scalar plus immediate): Contiguous store three-doubleword structures from three vectors (immediate
index).
ST3D (scalar plus scalar): Contiguous store three-doubleword structures from three vectors (scalar
index).
ST3H (scalar plus immediate): Contiguous store three-halfword structures from three vectors (immediate
index).
ST3H (scalar plus scalar): Contiguous store three-halfword structures from three vectors (scalar
index).
ST3W (scalar plus immediate): Contiguous store three-word structures from three vectors (immediate
index).
ST3W (scalar plus scalar): Contiguous store three-word structures from three vectors (scalar
index).
ST4B (scalar plus immediate): Contiguous store four-byte structures from four vectors (immediate
index).
ST4B (scalar plus scalar): Contiguous store four-byte structures from four vectors (scalar
index).
ST4D (scalar plus immediate): Contiguous store four-doubleword structures from four vectors (immediate
index).
ST4D (scalar plus scalar): Contiguous store four-doubleword structures from four vectors (scalar
index).
ST4H (scalar plus immediate): Contiguous store four-halfword structures from four vectors (immediate
index).
ST4H (scalar plus scalar): Contiguous store four-halfword structures from four vectors (scalar
index).
ST4W (scalar plus immediate): Contiguous store four-word structures from four vectors (immediate
index).
ST4W (scalar plus scalar): Contiguous store four-word structures from four vectors (scalar
index).
STNT1B (scalar plus immediate): Contiguous store non-temporal bytes from vector (immediate
index).
STNT1B (scalar plus scalar): Contiguous store non-temporal bytes from vector (scalar
index).
STNT1D (scalar plus immediate): Contiguous store non-temporal doublewords from vector (immediate
index).
STNT1D (scalar plus scalar): Contiguous store non-temporal doublewords from vector (scalar
index).
STNT1H (scalar plus immediate): Contiguous store non-temporal halfwords from vector (immediate
index).
STNT1H (scalar plus scalar): Contiguous store non-temporal halfwords from vector (scalar
index).
STNT1W (scalar plus immediate): Contiguous store non-temporal words from vector (immediate
index).
STNT1W (scalar plus scalar): Contiguous store non-temporal words from vector (scalar
index).
indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
DUP (indexed): Broadcast
indexed element to vector (unpredicated).
FMLS (indexed): Floating-point fused multiply-subtract by
indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FMLA (indexed): Floating-point fused multiply-add by
indexed elements (Zda = Zda + Zn * Zm[indexed]).
FMUL (indexed): Floating-point multiply by
indexed elements.
SDOT (indexed): Signed dot product by
indexed quadtuplet.
UDOT (indexed): Unsigned dot product by
indexed quadtuplet.
FCMLA (indexed): Floating-point complex multiply-add by
indexed values with rotate.
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (
indexed).
indexed): Floating-point fused multiply-add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
indexed): Floating-point fused multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FMLA (indexed): Floating-point fused multiply-add by indexed elements (Zda = Zda + Zn * Zm[
indexed]).
FMLS (indexed): Floating-point fused multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[
indexed]).
Initialise predicate from named constraint.
Initialise the first-fault register to all true.
Insert general-purpose register in shifted vector.
Insert SIMD&FP scalar register in shifted vector.
INSR (scalar): Insert general-purpose register in shifted vector.
INSR (SIMD&FP scalar): Insert SIMD&FP scalar register in shifted vector.
SCVTF: Signed
integer convert to floating-point (predicated).
UCVTF: Unsigned
integer convert to floating-point (predicated).
CPY (immediate): Copy signed
integer immediate to vector elements (predicated).
MOV (immediate, predicated): Move signed
integer immediate to vector elements (predicated): an alias of CPY (immediate).
FCVTZS: Floating-point convert to signed
integer, rounding toward zero (predicated).
FCVTZU: Floating-point convert to unsigned
integer, rounding toward zero (predicated).
FRINT<r>: Floating-point round to
integral value (predicated).
Interleave elements from two half predicates.
Interleave elements from two half vectors.
Interleave even or odd elements from two predicates.
Interleave even or odd elements from two vectors.
CNOT: Logically
invert boolean condition in vector (predicated).
NOTS: Bitwise
invert predicate, setting the condition flags: an alias of EOR, EORS (predicates).
NOT (predicate): Bitwise
invert predicate: an alias of EOR, EORS (predicates).
NOT (vector): Bitwise
invert vector (predicated).
EON: Bitwise exclusive OR with
inverted immediate (unpredicated): an alias of EOR (immediate).
ORN (immediate): Bitwise OR with
inverted immediate (unpredicated): an alias of ORR (immediate).
ORN, ORNS (predicates): Bitwise OR
inverted predicate.
CLASTB (scalar): Conditionally extract
LASTB (scalar): Extract
last element to general-purpose register.
CLASTB (SIMD&FP scalar): Conditionally extract
last element to SIMD&FP scalar register.
LASTB (SIMD&FP scalar): Extract
last element to SIMD&FP scalar register.
CLASTB (vectors): Conditionally extract
last element to vector register.
CLASTA (scalar): Conditionally extract element after
last to general-purpose register.
LASTA (scalar): Extract element after
last to general-purpose register.
CLASTA (SIMD&FP scalar): Conditionally extract element after
last to SIMD&FP scalar register.
LASTA (SIMD&FP scalar): Extract element after
last to SIMD&FP scalar register.
CLASTA (vectors): Conditionally extract element after
last to vector register.
LASTA (scalar): Extract element after last to general-purpose register.
LASTA (SIMD&FP scalar): Extract element after last to SIMD&FP scalar register.
LASTB (scalar): Extract last element to general-purpose register.
LASTB (SIMD&FP scalar): Extract last element to SIMD&FP scalar register.
LD1B (scalar plus immediate): Contiguous load unsigned bytes to vector (immediate index).
LD1B (scalar plus scalar): Contiguous load unsigned bytes to vector (scalar index).
LD1B (scalar plus vector): Gather load unsigned bytes to vector (vector index).
LD1B (vector plus immediate): Gather load unsigned bytes to vector (immediate index).
LD1D (scalar plus immediate): Contiguous load doublewords to vector (immediate index).
LD1D (scalar plus scalar): Contiguous load doublewords to vector (scalar index).
LD1D (scalar plus vector): Gather load doublewords to vector (vector index).
LD1D (vector plus immediate): Gather load doublewords to vector (immediate index).
LD1H (scalar plus immediate): Contiguous load unsigned halfwords to vector (immediate index).
LD1H (scalar plus scalar): Contiguous load unsigned halfwords to vector (scalar index).
LD1H (scalar plus vector): Gather load unsigned halfwords to vector (vector index).
LD1H (vector plus immediate): Gather load unsigned halfwords to vector (immediate index).
LD1RB: Load and broadcast unsigned byte to vector.
LD1RD: Load and broadcast doubleword to vector.
LD1RH: Load and broadcast unsigned halfword to vector.
LD1RQB (scalar plus immediate): Contiguous load and replicate sixteen bytes (immediate index).
LD1RQB (scalar plus scalar): Contiguous load and replicate sixteen bytes (scalar index).
LD1RQD (scalar plus immediate): Contiguous load and replicate two doublewords (immediate index).
LD1RQD (scalar plus scalar): Contiguous load and replicate two doublewords (scalar index).
LD1RQH (scalar plus immediate): Contiguous load and replicate eight halfwords (immediate index).
LD1RQH (scalar plus scalar): Contiguous load and replicate eight halfwords (scalar index).
LD1RQW (scalar plus immediate): Contiguous load and replicate four words (immediate index).
LD1RQW (scalar plus scalar): Contiguous load and replicate four words (scalar index).
LD1RSB: Load and broadcast signed byte to vector.
LD1RSH: Load and broadcast signed halfword to vector.
LD1RSW: Load and broadcast signed word to vector.
LD1RW: Load and broadcast unsigned word to vector.
LD1SB (scalar plus immediate): Contiguous load signed bytes to vector (immediate index).
LD1SB (scalar plus scalar): Contiguous load signed bytes to vector (scalar index).
LD1SB (scalar plus vector): Gather load signed bytes to vector (vector index).
LD1SB (vector plus immediate): Gather load signed bytes to vector (immediate index).
LD1SH (scalar plus immediate): Contiguous load signed halfwords to vector (immediate index).
LD1SH (scalar plus scalar): Contiguous load signed halfwords to vector (scalar index).
LD1SH (scalar plus vector): Gather load signed halfwords to vector (vector index).
LD1SH (vector plus immediate): Gather load signed halfwords to vector (immediate index).
LD1SW (scalar plus immediate): Contiguous load signed words to vector (immediate index).
LD1SW (scalar plus scalar): Contiguous load signed words to vector (scalar index).
LD1SW (scalar plus vector): Gather load signed words to vector (vector index).
LD1SW (vector plus immediate): Gather load signed words to vector (immediate index).
LD1W (scalar plus immediate): Contiguous load unsigned words to vector (immediate index).
LD1W (scalar plus scalar): Contiguous load unsigned words to vector (scalar index).
LD1W (scalar plus vector): Gather load unsigned words to vector (vector index).
LD1W (vector plus immediate): Gather load unsigned words to vector (immediate index).
LD2B (scalar plus immediate): Contiguous load two-byte structures to two vectors (immediate index).
LD2B (scalar plus scalar): Contiguous load two-byte structures to two vectors (scalar index).
LD2D (scalar plus immediate): Contiguous load two-doubleword structures to two vectors (immediate index).
LD2D (scalar plus scalar): Contiguous load two-doubleword structures to two vectors (scalar index).
LD2H (scalar plus immediate): Contiguous load two-halfword structures to two vectors (immediate index).
LD2H (scalar plus scalar): Contiguous load two-halfword structures to two vectors (scalar index).
LD2W (scalar plus immediate): Contiguous load two-word structures to two vectors (immediate index).
LD2W (scalar plus scalar): Contiguous load two-word structures to two vectors (scalar index).
LD3B (scalar plus immediate): Contiguous load three-byte structures to three vectors (immediate index).
LD3B (scalar plus scalar): Contiguous load three-byte structures to three vectors (scalar index).
LD3D (scalar plus immediate): Contiguous load three-doubleword structures to three vectors (immediate index).
LD3D (scalar plus scalar): Contiguous load three-doubleword structures to three vectors (scalar index).
LD3H (scalar plus immediate): Contiguous load three-halfword structures to three vectors (immediate index).
LD3H (scalar plus scalar): Contiguous load three-halfword structures to three vectors (scalar index).
LD3W (scalar plus immediate): Contiguous load three-word structures to three vectors (immediate index).
LD3W (scalar plus scalar): Contiguous load three-word structures to three vectors (scalar index).
LD4B (scalar plus immediate): Contiguous load four-byte structures to four vectors (immediate index).
LD4B (scalar plus scalar): Contiguous load four-byte structures to four vectors (scalar index).
LD4D (scalar plus immediate): Contiguous load four-doubleword structures to four vectors (immediate index).
LD4D (scalar plus scalar): Contiguous load four-doubleword structures to four vectors (scalar index).
LD4H (scalar plus immediate): Contiguous load four-halfword structures to four vectors (immediate index).
LD4H (scalar plus scalar): Contiguous load four-halfword structures to four vectors (scalar index).
LD4W (scalar plus immediate): Contiguous load four-word structures to four vectors (immediate index).
LD4W (scalar plus scalar): Contiguous load four-word structures to four vectors (scalar index).
LDFF1B (scalar plus scalar): Contiguous load first-fault unsigned bytes to vector (scalar index).
LDFF1B (scalar plus vector): Gather load first-fault unsigned bytes to vector (vector index).
LDFF1B (vector plus immediate): Gather load first-fault unsigned bytes to vector (immediate index).
LDFF1D (scalar plus scalar): Contiguous load first-fault doublewords to vector (scalar index).
LDFF1D (scalar plus vector): Gather load first-fault doublewords to vector (vector index).
LDFF1D (vector plus immediate): Gather load first-fault doublewords to vector (immediate index).
LDFF1H (scalar plus scalar): Contiguous load first-fault unsigned halfwords to vector (scalar index).
LDFF1H (scalar plus vector): Gather load first-fault unsigned halfwords to vector (vector index).
LDFF1H (vector plus immediate): Gather load first-fault unsigned halfwords to vector (immediate index).
LDFF1SB (scalar plus scalar): Contiguous load first-fault signed bytes to vector (scalar index).
LDFF1SB (scalar plus vector): Gather load first-fault signed bytes to vector (vector index).
LDFF1SB (vector plus immediate): Gather load first-fault signed bytes to vector (immediate index).
LDFF1SH (scalar plus scalar): Contiguous load first-fault signed halfwords to vector (scalar index).
LDFF1SH (scalar plus vector): Gather load first-fault signed halfwords to vector (vector index).
LDFF1SH (vector plus immediate): Gather load first-fault signed halfwords to vector (immediate index).
LDFF1SW (scalar plus scalar): Contiguous load first-fault signed words to vector (scalar index).
LDFF1SW (scalar plus vector): Gather load first-fault signed words to vector (vector index).
LDFF1SW (vector plus immediate): Gather load first-fault signed words to vector (immediate index).
LDFF1W (scalar plus scalar): Contiguous load first-fault unsigned words to vector (scalar index).
LDFF1W (scalar plus vector): Gather load first-fault unsigned words to vector (vector index).
LDFF1W (vector plus immediate): Gather load first-fault unsigned words to vector (immediate index).
LDNF1B: Contiguous load non-fault unsigned bytes to vector (immediate index).
LDNF1D: Contiguous load non-fault doublewords to vector (immediate index).
LDNF1H: Contiguous load non-fault unsigned halfwords to vector (immediate index).
LDNF1SB: Contiguous load non-fault signed bytes to vector (immediate index).
LDNF1SH: Contiguous load non-fault signed halfwords to vector (immediate index).
LDNF1SW: Contiguous load non-fault signed words to vector (immediate index).
LDNF1W: Contiguous load non-fault unsigned words to vector (immediate index).
LDNT1B (scalar plus immediate): Contiguous load non-temporal bytes to vector (immediate index).
LDNT1B (scalar plus scalar): Contiguous load non-temporal bytes to vector (scalar index).
LDNT1D (scalar plus immediate): Contiguous load non-temporal doublewords to vector (immediate index).
LDNT1D (scalar plus scalar): Contiguous load non-temporal doublewords to vector (scalar index).
LDNT1H (scalar plus immediate): Contiguous load non-temporal halfwords to vector (immediate index).
LDNT1H (scalar plus scalar): Contiguous load non-temporal halfwords to vector (scalar index).
LDNT1W (scalar plus immediate): Contiguous load non-temporal words to vector (immediate index).
LDNT1W (scalar plus scalar): Contiguous load non-temporal words to vector (scalar index).
LDR (predicate): Load predicate register.
LDR (vector): Load vector register.
CLS: Count
leading sign bits (predicated).
CLZ: Count
leading zero bits (predicated).
LSL (wide elements, predicated): Logical shift
left by 64-bit wide elements (predicated).
LSL (wide elements, unpredicated): Logical shift
left by 64-bit wide elements (unpredicated).
LSL (immediate, predicated): Logical shift
left by immediate (predicated).
LSL (immediate, unpredicated): Logical shift
left by immediate (unpredicated).
LSL (vectors): Logical shift
left by vector (predicated).
LSLR: Reversed logical shift
left by vector (predicated).
WHILELE: While incrementing signed scalar
less than or equal to scalar.
CMPLE (vectors): Compare signed
less than or equal to vector, setting the condition flags: an alias of CMP<cc> (vectors).
FCMLE (vectors): Floating-point compare
less than or equal to vector: an alias of FCM<cc> (vectors).
FACLE: Floating-point absolute compare
less than or equal: an alias of FAC<cc>.
WHILELT: While incrementing signed scalar
less than scalar.
CMPLT (vectors): Compare signed
less than vector, setting the condition flags: an alias of CMP<cc> (vectors).
FCMLT (vectors): Floating-point compare
less than vector: an alias of FCM<cc> (vectors).
FACLT: Floating-point absolute compare
less than: an alias of FAC<cc>.
Load and broadcast doubleword to vector.
Load and broadcast signed byte to vector.
Load and broadcast signed halfword to vector.
Load and broadcast signed word to vector.
Load and broadcast unsigned byte to vector.
Load and broadcast unsigned halfword to vector.
Load and broadcast unsigned word to vector.
LD1RQH (scalar plus immediate): Contiguous
load and replicate eight halfwords (immediate index).
LD1RQH (scalar plus scalar): Contiguous
load and replicate eight halfwords (scalar index).
LD1RQW (scalar plus immediate): Contiguous
load and replicate four words (immediate index).
LD1RQW (scalar plus scalar): Contiguous
load and replicate four words (scalar index).
LD1RQB (scalar plus immediate): Contiguous
load and replicate sixteen bytes (immediate index).
LD1RQB (scalar plus scalar): Contiguous
load and replicate sixteen bytes (scalar index).
LD1RQD (scalar plus immediate): Contiguous
load and replicate two doublewords (immediate index).
LD1RQD (scalar plus scalar): Contiguous
load and replicate two doublewords (scalar index).
LD1D (scalar plus immediate): Contiguous
load doublewords to vector (immediate index).
LD1D (vector plus immediate): Gather
load doublewords to vector (immediate index).
LD1D (scalar plus scalar): Contiguous
load doublewords to vector (scalar index).
LD1D (scalar plus vector): Gather
load doublewords to vector (vector index).
LDFF1D (vector plus immediate): Gather
load first-fault doublewords to vector (immediate index).
LDFF1D (scalar plus scalar): Contiguous
load first-fault doublewords to vector (scalar index).
LDFF1D (scalar plus vector): Gather
load first-fault doublewords to vector (vector index).
LDFF1SB (vector plus immediate): Gather
load first-fault signed bytes to vector (immediate index).
LDFF1SB (scalar plus scalar): Contiguous
load first-fault signed bytes to vector (scalar index).
LDFF1SB (scalar plus vector): Gather
load first-fault signed bytes to vector (vector index).
LDFF1SH (vector plus immediate): Gather
load first-fault signed halfwords to vector (immediate index).
LDFF1SH (scalar plus scalar): Contiguous
load first-fault signed halfwords to vector (scalar index).
LDFF1SH (scalar plus vector): Gather
load first-fault signed halfwords to vector (vector index).
LDFF1SW (vector plus immediate): Gather
load first-fault signed words to vector (immediate index).
LDFF1SW (scalar plus scalar): Contiguous
load first-fault signed words to vector (scalar index).
LDFF1SW (scalar plus vector): Gather
load first-fault signed words to vector (vector index).
LDFF1B (vector plus immediate): Gather
load first-fault unsigned bytes to vector (immediate index).
LDFF1B (scalar plus scalar): Contiguous
load first-fault unsigned bytes to vector (scalar index).
LDFF1B (scalar plus vector): Gather
load first-fault unsigned bytes to vector (vector index).
LDFF1H (vector plus immediate): Gather
load first-fault unsigned halfwords to vector (immediate index).
LDFF1H (scalar plus scalar): Contiguous
load first-fault unsigned halfwords to vector (scalar index).
LDFF1H (scalar plus vector): Gather
load first-fault unsigned halfwords to vector (vector index).
LDFF1W (vector plus immediate): Gather
load first-fault unsigned words to vector (immediate index).
LDFF1W (scalar plus scalar): Contiguous
load first-fault unsigned words to vector (scalar index).
LDFF1W (scalar plus vector): Gather
load first-fault unsigned words to vector (vector index).
LD4B (scalar plus immediate): Contiguous
load four-byte structures to four vectors (immediate index).
LD4B (scalar plus scalar): Contiguous
load four-byte structures to four vectors (scalar index).
LD4D (scalar plus immediate): Contiguous
load four-doubleword structures to four vectors (immediate index).
LD4D (scalar plus scalar): Contiguous
load four-doubleword structures to four vectors (scalar index).
LD4H (scalar plus immediate): Contiguous
load four-halfword structures to four vectors (immediate index).
LD4H (scalar plus scalar): Contiguous
load four-halfword structures to four vectors (scalar index).
LD4W (scalar plus immediate): Contiguous
load four-word structures to four vectors (immediate index).
LD4W (scalar plus scalar): Contiguous
load four-word structures to four vectors (scalar index).
LDNF1D: Contiguous
load non-fault doublewords to vector (immediate index).
LDNF1SB: Contiguous
load non-fault signed bytes to vector (immediate index).
LDNF1SH: Contiguous
load non-fault signed halfwords to vector (immediate index).
LDNF1SW: Contiguous
load non-fault signed words to vector (immediate index).
LDNF1B: Contiguous
load non-fault unsigned bytes to vector (immediate index).
LDNF1H: Contiguous
load non-fault unsigned halfwords to vector (immediate index).
LDNF1W: Contiguous
load non-fault unsigned words to vector (immediate index).
LDNT1B (scalar plus immediate): Contiguous
load non-temporal bytes to vector (immediate index).
LDNT1B (scalar plus scalar): Contiguous
load non-temporal bytes to vector (scalar index).
LDNT1D (scalar plus immediate): Contiguous
load non-temporal doublewords to vector (immediate index).
LDNT1D (scalar plus scalar): Contiguous
load non-temporal doublewords to vector (scalar index).
LDNT1H (scalar plus immediate): Contiguous
load non-temporal halfwords to vector (immediate index).
LDNT1H (scalar plus scalar): Contiguous
load non-temporal halfwords to vector (scalar index).
LDNT1W (scalar plus immediate): Contiguous
load non-temporal words to vector (immediate index).
LDNT1W (scalar plus scalar): Contiguous
load non-temporal words to vector (scalar index).
Load predicate register.
LD1SB (scalar plus immediate): Contiguous
load signed bytes to vector (immediate index).
LD1SB (vector plus immediate): Gather
load signed bytes to vector (immediate index).
LD1SB (scalar plus scalar): Contiguous
load signed bytes to vector (scalar index).
LD1SB (scalar plus vector): Gather
load signed bytes to vector (vector index).
LD1SH (scalar plus immediate): Contiguous
load signed halfwords to vector (immediate index).
LD1SH (vector plus immediate): Gather
load signed halfwords to vector (immediate index).
LD1SH (scalar plus scalar): Contiguous
load signed halfwords to vector (scalar index).
LD1SH (scalar plus vector): Gather
load signed halfwords to vector (vector index).
LD1SW (scalar plus immediate): Contiguous
load signed words to vector (immediate index).
LD1SW (vector plus immediate): Gather
load signed words to vector (immediate index).
LD1SW (scalar plus scalar): Contiguous
load signed words to vector (scalar index).
LD1SW (scalar plus vector): Gather
load signed words to vector (vector index).
LD3B (scalar plus immediate): Contiguous
load three-byte structures to three vectors (immediate index).
LD3B (scalar plus scalar): Contiguous
load three-byte structures to three vectors (scalar index).
LD3D (scalar plus immediate): Contiguous
load three-doubleword structures to three vectors (immediate index).
LD3D (scalar plus scalar): Contiguous
load three-doubleword structures to three vectors (scalar index).
LD3H (scalar plus immediate): Contiguous
load three-halfword structures to three vectors (immediate index).
LD3H (scalar plus scalar): Contiguous
load three-halfword structures to three vectors (scalar index).
LD3W (scalar plus immediate): Contiguous
load three-word structures to three vectors (immediate index).
LD3W (scalar plus scalar): Contiguous
load three-word structures to three vectors (scalar index).
LD2B (scalar plus immediate): Contiguous
load two-byte structures to two vectors (immediate index).
LD2B (scalar plus scalar): Contiguous
load two-byte structures to two vectors (scalar index).
LD2D (scalar plus immediate): Contiguous
load two-doubleword structures to two vectors (immediate index).
LD2D (scalar plus scalar): Contiguous
load two-doubleword structures to two vectors (scalar index).
LD2H (scalar plus immediate): Contiguous
load two-halfword structures to two vectors (immediate index).
LD2H (scalar plus scalar): Contiguous
load two-halfword structures to two vectors (scalar index).
LD2W (scalar plus immediate): Contiguous
load two-word structures to two vectors (immediate index).
LD2W (scalar plus scalar): Contiguous
load two-word structures to two vectors (scalar index).
LD1B (scalar plus immediate): Contiguous
load unsigned bytes to vector (immediate index).
LD1B (vector plus immediate): Gather
load unsigned bytes to vector (immediate index).
LD1B (scalar plus scalar): Contiguous
load unsigned bytes to vector (scalar index).
LD1B (scalar plus vector): Gather
load unsigned bytes to vector (vector index).
LD1H (scalar plus immediate): Contiguous
load unsigned halfwords to vector (immediate index).
LD1H (vector plus immediate): Gather
load unsigned halfwords to vector (immediate index).
LD1H (scalar plus scalar): Contiguous
load unsigned halfwords to vector (scalar index).
LD1H (scalar plus vector): Gather
load unsigned halfwords to vector (vector index).
LD1W (scalar plus immediate): Contiguous
load unsigned words to vector (immediate index).
LD1W (vector plus immediate): Gather
load unsigned words to vector (immediate index).
LD1W (scalar plus scalar): Contiguous
load unsigned words to vector (scalar index).
LD1W (scalar plus vector): Gather
load unsigned words to vector (vector index).
Load vector register.
RDFFR, RDFFRS (predicated): Return predicate of succesfully
loaded elements.
DUPM: Broadcast
logical bitmask immediate to vector (unpredicated).
MOV (bitmask immediate): Move
logical bitmask immediate to vector (unpredicated): an alias of DUPM.
Logical shift left by 64-bit wide elements (predicated).
Logical shift left by 64-bit wide elements (unpredicated).
Logical shift left by immediate (predicated).
Logical shift left by immediate (unpredicated).
Logical shift left by vector (predicated).
LSLR: Reversed
logical shift left by vector (predicated).
Logical shift right by 64-bit wide elements (predicated).
Logical shift right by 64-bit wide elements (unpredicated).
Logical shift right by immediate (predicated).
Logical shift right by immediate (unpredicated).
Logical shift right by vector (predicated).
LSRR: Reversed
logical shift right by vector (predicated).
CNOT:
Logically invert boolean condition in vector (predicated).
TBL: Programmable table
lookup in single vector table.
CTERMEQ, CTERMNE: Compare and terminate
loop.
WHILELS: While incrementing unsigned scalar
lower or same as scalar.
CMPLS (vectors): Compare unsigned
lower or same as vector, setting the condition flags: an alias of CMP<cc> (vectors).
WHILELO: While incrementing unsigned scalar
lower than scalar.
CMPLO (vectors): Compare unsigned
lower than vector, setting the condition flags: an alias of CMP<cc> (vectors).
LSL (immediate, predicated): Logical shift left by immediate (predicated).
LSL (immediate, unpredicated): Logical shift left by immediate (unpredicated).
LSL (vectors): Logical shift left by vector (predicated).
LSL (wide elements, predicated): Logical shift left by 64-bit wide elements (predicated).
LSL (wide elements, unpredicated): Logical shift left by 64-bit wide elements (unpredicated).
LSLR: Reversed logical shift left by vector (predicated).
LSR (immediate, predicated): Logical shift right by immediate (predicated).
LSR (immediate, unpredicated): Logical shift right by immediate (unpredicated).
LSR (vectors): Logical shift right by vector (predicated).
LSR (wide elements, predicated): Logical shift right by 64-bit wide elements (predicated).
LSR (wide elements, unpredicated): Logical shift right by 64-bit wide elements (unpredicated).
LSRR: Reversed logical shift right by vector (predicated).
FMAX (vectors): Floating-point
maximum (predicated).
FMAXNM (vectors): Floating-point
maximum number (predicated).
FMAXNMV: Floating-point
maximum number recursive reduction to scalar.
FMAXNM (immediate): Floating-point
maximum number with immediate (predicated).
FMAXV: Floating-point
maximum recursive reduction to scalar.
SMAXV: Signed
maximum reduction to scalar.
UMAXV: Unsigned
maximum reduction to scalar.
SMAX (vectors): Signed
maximum vectors (predicated).
UMAX (vectors): Unsigned
maximum vectors (predicated).
FMAX (immediate): Floating-point
maximum with immediate (predicated).
SMAX (immediate): Signed
maximum with immediate (unpredicated).
UMAX (immediate): Unsigned
maximum with immediate (unpredicated).
MOV (predicate, predicated, merging): Move predicates (
merging): an alias of SEL (predicates).
merging): Move predicates (merging): an alias of SEL (predicates).
FMIN (vectors): Floating-point
minimum (predicated).
FMINNM (vectors): Floating-point
minimum number (predicated).
FMINNMV: Floating-point
minimum number recursive reduction to scalar.
FMINNM (immediate): Floating-point
minimum number with immediate (predicated).
FMINV: Floating-point
minimum recursive reduction to scalar.
SMINV: Signed
minimum reduction to scalar.
UMINV: Unsigned
minimum reduction to scalar.
SMIN (vectors): Signed
minimum vectors (predicated).
UMIN (vectors): Unsigned
minimum vectors (predicated).
FMIN (immediate): Floating-point
minimum with immediate (predicated).
SMIN (immediate): Signed
minimum with immediate (unpredicated).
UMIN (immediate): Unsigned
minimum with immediate (unpredicated).
MLA: Multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
MLS: Multiply-subtract vectors (predicated), writing addend [Zda = Zda - Zn * Zm].
MOV (bitmask immediate): Move logical bitmask immediate to vector (unpredicated): an alias of DUPM.
MOV (immediate, predicated): Move signed integer immediate to vector elements (predicated): an alias of CPY (immediate).
MOV (immediate, unpredicated): Move signed immediate to vector elements (unpredicated): an alias of DUP (immediate).
MOV (predicate, predicated, merging): Move predicates (merging): an alias of SEL (predicates).
MOV (predicate, predicated, zeroing): Move predicates (zeroing): an alias of AND, ANDS (predicates).
MOV (predicate, unpredicated): Move predicate (unpredicated): an alias of ORR, ORRS (predicates).
MOV (scalar, predicated): Move general-purpose register to vector elements (predicated): an alias of CPY (scalar).
MOV (scalar, unpredicated): Move general-purpose register to vector elements (unpredicated): an alias of DUP (scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
MOV (vector, predicated): Move vector elements (predicated): an alias of SEL (vectors).
MOV (vector, unpredicated): Move vector register (unpredicated): an alias of ORR (vectors, unpredicated).
Move 8-bit floating-point immediate to vector elements (predicated): an alias of FCPY.
Move 8-bit floating-point immediate to vector elements (unpredicated): an alias of FDUP.
Move floating-point +0.0 to vector elements (predicated): an alias of CPY (immediate).
Move floating-point +0.0 to vector elements (unpredicated): an alias of DUP (immediate).
Move general-purpose register to vector elements (predicated): an alias of CPY (scalar).
Move general-purpose register to vector elements (unpredicated): an alias of DUP (scalar).
Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
Move logical bitmask immediate to vector (unpredicated): an alias of DUPM.
Move predicate (unpredicated), setting the condition flags: an alias of ORR, ORRS (predicates).
Move predicate (unpredicated): an alias of ORR, ORRS (predicates).
Move predicates (merging): an alias of SEL (predicates).
Move predicates (zeroing), setting the condition flags: an alias of AND, ANDS (predicates).
Move predicates (zeroing): an alias of AND, ANDS (predicates).
Move prefix (predicated).
Move prefix (unpredicated).
Move signed immediate to vector elements (unpredicated): an alias of DUP (immediate).
Move signed integer immediate to vector elements (predicated): an alias of CPY (immediate).
Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
Move vector elements (predicated): an alias of SEL (vectors).
Move vector register (unpredicated): an alias of ORR (vectors, unpredicated).
MOVPRFX (predicated): Move prefix (predicated).
MOVPRFX (unpredicated): Move prefix (unpredicated).
MOVS (predicated): Move predicates (zeroing), setting the condition flags: an alias of AND, ANDS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition flags: an alias of ORR, ORRS (predicates).
MSB: Multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za - Zdn * Zm].
MUL (immediate): Multiply by immediate (unpredicated).
MUL (vectors): Multiply vectors (predicated).
SQDECH (scalar): Signed saturating decrement scalar by
multiple of 16-bit predicate constraint element count.
SQDECH (vector): Signed saturating decrement vector by
multiple of 16-bit predicate constraint element count.
SQINCH (scalar): Signed saturating increment scalar by
multiple of 16-bit predicate constraint element count.
SQINCH (vector): Signed saturating increment vector by
multiple of 16-bit predicate constraint element count.
UQDECH (scalar): Unsigned saturating decrement scalar by
multiple of 16-bit predicate constraint element count.
UQDECH (vector): Unsigned saturating decrement vector by
multiple of 16-bit predicate constraint element count.
UQINCH (scalar): Unsigned saturating increment scalar by
multiple of 16-bit predicate constraint element count.
UQINCH (vector): Unsigned saturating increment vector by
multiple of 16-bit predicate constraint element count.
SQDECW (scalar): Signed saturating decrement scalar by
multiple of 32-bit predicate constraint element count.
SQDECW (vector): Signed saturating decrement vector by
multiple of 32-bit predicate constraint element count.
SQINCW (scalar): Signed saturating increment scalar by
multiple of 32-bit predicate constraint element count.
SQINCW (vector): Signed saturating increment vector by
multiple of 32-bit predicate constraint element count.
UQDECW (scalar): Unsigned saturating decrement scalar by
multiple of 32-bit predicate constraint element count.
UQDECW (vector): Unsigned saturating decrement vector by
multiple of 32-bit predicate constraint element count.
UQINCW (scalar): Unsigned saturating increment scalar by
multiple of 32-bit predicate constraint element count.
UQINCW (vector): Unsigned saturating increment vector by
multiple of 32-bit predicate constraint element count.
SQDECD (scalar): Signed saturating decrement scalar by
multiple of 64-bit predicate constraint element count.
SQDECD (vector): Signed saturating decrement vector by
multiple of 64-bit predicate constraint element count.
SQINCD (scalar): Signed saturating increment scalar by
multiple of 64-bit predicate constraint element count.
SQINCD (vector): Signed saturating increment vector by
multiple of 64-bit predicate constraint element count.
UQDECD (scalar): Unsigned saturating decrement scalar by
multiple of 64-bit predicate constraint element count.
UQDECD (vector): Unsigned saturating decrement vector by
multiple of 64-bit predicate constraint element count.
UQINCD (scalar): Unsigned saturating increment scalar by
multiple of 64-bit predicate constraint element count.
UQINCD (vector): Unsigned saturating increment vector by
multiple of 64-bit predicate constraint element count.
SQDECB: Signed saturating decrement scalar by
multiple of 8-bit predicate constraint element count.
SQINCB: Signed saturating increment scalar by
multiple of 8-bit predicate constraint element count.
UQDECB: Unsigned saturating decrement scalar by
multiple of 8-bit predicate constraint element count.
UQINCB: Unsigned saturating increment scalar by
multiple of 8-bit predicate constraint element count.
CNTB, CNTD, CNTH, CNTW: Set scalar to
multiple of predicate constraint element count.
DECB, DECD, DECH, DECW (scalar): Decrement scalar by
multiple of predicate constraint element count.
DECD, DECH, DECW (vector): Decrement vector by
multiple of predicate constraint element count.
INCB, INCD, INCH, INCW (scalar): Increment scalar by
multiple of predicate constraint element count.
INCD, INCH, INCW (vector): Increment vector by
multiple of predicate constraint element count.
ADDPL: Add
multiple of predicate register size to scalar register.
ADDVL: Add
multiple of vector register size to scalar register.
RDVL: Read
multiple of vector register size to scalar register.
FNMAD: Floating-point negated fused multiply-add vectors (predicated), writing
multiplicand [Zdn = -Za + -Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated), writing
multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused multiply-subtract vectors (predicated), writing
multiplicand [Zdn = Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-add vectors (predicated), writing
multiplicand [Zdn = Za + Zdn * Zm].
MAD: Multiply-add vectors (predicated), writing
multiplicand [Zdn = Za + Zdn * Zm].
MSB: Multiply-subtract vectors (predicated), writing
multiplicand [Zdn = Za - Zdn * Zm].
FMUL (immediate): Floating-point
multiply by immediate (predicated).
Multiply by immediate (unpredicated).
FMUL (indexed): Floating-point
multiply by indexed elements.
SMULH: Signed
multiply returning high half (predicated).
UMULH: Unsigned
multiply returning high half (predicated).
FMUL (vectors, predicated): Floating-point
multiply vectors (predicated).
Multiply vectors (predicated).
FMUL (vectors, unpredicated): Floating-point
multiply vectors (unpredicated).
FMLA (indexed): Floating-point fused
multiply-add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
FCMLA (indexed): Floating-point complex
multiply-add by indexed values with rotate.
FTMAD: Floating-point trigonometric
multiply-add coefficient.
FNMLA: Floating-point negated fused
multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FMLA (vectors): Floating-point fused
multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
MLA:
Multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
FNMAD: Floating-point negated fused
multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FMAD: Floating-point fused
multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
MAD:
Multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
FCMLA (vectors): Floating-point complex
multiply-add with rotate (predicated).
FMULX: Floating-point
multiply-extended vectors (predicated).
FMLS (indexed): Floating-point fused
multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FNMLS: Floating-point negated fused
multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point fused
multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
MLS:
Multiply-subtract vectors (predicated), writing addend [Zda = Zda - Zn * Zm].
FNMSB: Floating-point negated fused
multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused
multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
MSB:
Multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za - Zdn * Zm].
PTRUE, PTRUES: Initialise predicate from
NAND, NANDS: Bitwise
NAND predicates.
NAND, NANDS: Bitwise NAND predicates.
NEG: Negate (predicated).
FNEG: Floating-point
negate (predicated).
NEG:
Negate (predicated).
FNMLA: Floating-point
negated fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FNMAD: Floating-point
negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FNMLS: Floating-point
negated fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FNMSB: Floating-point
negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
PNEXT: Find
next active predicate.
BRKN, BRKNS: Propagate break to
next partition.
LDNF1D: Contiguous load
non-fault doublewords to vector (immediate index).
LDNF1SB: Contiguous load
non-fault signed bytes to vector (immediate index).
LDNF1SH: Contiguous load
non-fault signed halfwords to vector (immediate index).
LDNF1SW: Contiguous load
non-fault signed words to vector (immediate index).
LDNF1B: Contiguous load
non-fault unsigned bytes to vector (immediate index).
LDNF1H: Contiguous load
non-fault unsigned halfwords to vector (immediate index).
LDNF1W: Contiguous load
non-fault unsigned words to vector (immediate index).
STNT1B (scalar plus immediate): Contiguous store
non-temporal bytes from vector (immediate index).
STNT1B (scalar plus scalar): Contiguous store
non-temporal bytes from vector (scalar index).
LDNT1B (scalar plus immediate): Contiguous load
non-temporal bytes to vector (immediate index).
LDNT1B (scalar plus scalar): Contiguous load
non-temporal bytes to vector (scalar index).
STNT1D (scalar plus immediate): Contiguous store
non-temporal doublewords from vector (immediate index).
STNT1D (scalar plus scalar): Contiguous store
non-temporal doublewords from vector (scalar index).
LDNT1D (scalar plus immediate): Contiguous load
non-temporal doublewords to vector (immediate index).
LDNT1D (scalar plus scalar): Contiguous load
non-temporal doublewords to vector (scalar index).
STNT1H (scalar plus immediate): Contiguous store
non-temporal halfwords from vector (immediate index).
STNT1H (scalar plus scalar): Contiguous store
non-temporal halfwords from vector (scalar index).
LDNT1H (scalar plus immediate): Contiguous load
non-temporal halfwords to vector (immediate index).
LDNT1H (scalar plus scalar): Contiguous load
non-temporal halfwords to vector (scalar index).
STNT1W (scalar plus immediate): Contiguous store
non-temporal words from vector (immediate index).
STNT1W (scalar plus scalar): Contiguous store
non-temporal words from vector (scalar index).
LDNT1W (scalar plus immediate): Contiguous load
non-temporal words to vector (immediate index).
LDNT1W (scalar plus scalar): Contiguous load
non-temporal words to vector (scalar index).
CNT: Count
non-zero bits (predicated).
NOR, NORS: Bitwise
NOR predicates.
NOR, NORS: Bitwise NOR predicates.
NOT (predicate): Bitwise invert predicate: an alias of EOR, EORS (predicates).
NOT (vector): Bitwise invert vector (predicated).
NOTS: Bitwise invert predicate, setting the condition flags: an alias of EOR, EORS (predicates).
TRN1, TRN2 (predicates): Interleave even or
UZP1, UZP2 (predicates): Concatenate even or
odd elements from two predicates.
TRN1, TRN2 (vectors): Interleave even or
odd elements from two vectors.
UZP1, UZP2 (vectors): Concatenate even or
odd elements from two vectors.
ORN, ORNS (predicates): Bitwise
OR inverted predicate.
ORR, ORRS (predicates): Bitwise
OR predicate.
EOR, EORS (predicates): Bitwise exclusive
OR predicates.
ORV: Bitwise
OR reduction to scalar.
EOR (vectors, predicated): Bitwise exclusive
OR vectors (predicated).
ORR (vectors, predicated): Bitwise
OR vectors (predicated).
EOR (vectors, unpredicated): Bitwise exclusive
OR vectors (unpredicated).
ORR (vectors, unpredicated): Bitwise
OR vectors (unpredicated).
EOR (immediate): Bitwise exclusive
OR with immediate (unpredicated).
ORR (immediate): Bitwise
OR with immediate (unpredicated).
EON: Bitwise exclusive
OR with inverted immediate (unpredicated): an alias of EOR (immediate).
ORN (immediate): Bitwise
OR with inverted immediate (unpredicated): an alias of ORR (immediate).
FADDA: Floating-point add strictly-
ordered reduction, accumulating in scalar.
ORN (immediate): Bitwise OR with inverted immediate (unpredicated): an alias of ORR (immediate).
ORN, ORNS (predicates): Bitwise OR inverted predicate.
ORNS (predicates): Bitwise OR inverted predicate.
ORN (immediate): Bitwise OR with inverted immediate (unpredicated): an alias of
ORR (immediate).
ORR (immediate): Bitwise OR with immediate (unpredicated).
ORR (vectors, predicated): Bitwise OR vectors (predicated).
MOV (vector, unpredicated): Move vector register (unpredicated): an alias of
ORR (vectors, unpredicated).
ORR (vectors, unpredicated): Bitwise OR vectors (unpredicated).
MOV (predicate, unpredicated): Move predicate (unpredicated): an alias of
ORR, ORRS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition flags: an alias of
ORR, ORRS (predicates).
ORR, ORRS (predicates): Bitwise OR predicate.
MOV (predicate, unpredicated): Move predicate (unpredicated): an alias of ORR,
ORRS (predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition flags: an alias of ORR,
ORRS (predicates).
ORRS (predicates): Bitwise OR predicate.
ORV: Bitwise OR reduction to scalar.
EXT: Extract vector from
BRKN, BRKNS: Propagate break to next
partition.
BRKPA, BRKPAS: Break after first true condition, propagating from previous
partition.
BRKPB, BRKPBS: Break before first true condition, propagating from previous
partition.
PFALSE: Set all predicate elements to false.
PFIRST: Set the first active predicate element to true.
PRFB (vector plus immediate): Gather prefetch bytes (vector
plus immediate).
PRFD (vector plus immediate): Gather prefetch doublewords (vector
plus immediate).
PRFH (vector plus immediate): Gather prefetch halfwords (vector
plus immediate).
PRFW (vector plus immediate): Gather prefetch words (vector
plus immediate).
plus immediate): Contiguous load and replicate eight halfwords (immediate index).
plus immediate): Contiguous load and replicate four words (immediate index).
plus immediate): Contiguous load and replicate sixteen bytes (immediate index).
plus immediate): Contiguous load and replicate two doublewords (immediate index).
plus immediate): Contiguous load doublewords to vector (immediate index).
plus immediate): Contiguous load four-byte structures to four vectors (immediate index).
plus immediate): Contiguous load four-doubleword structures to four vectors (immediate index).
plus immediate): Contiguous load four-halfword structures to four vectors (immediate index).
plus immediate): Contiguous load four-word structures to four vectors (immediate index).
plus immediate): Contiguous load non-temporal bytes to vector (immediate index).
plus immediate): Contiguous load non-temporal doublewords to vector (immediate index).
plus immediate): Contiguous load non-temporal halfwords to vector (immediate index).
plus immediate): Contiguous load non-temporal words to vector (immediate index).
plus immediate): Contiguous load signed bytes to vector (immediate index).
plus immediate): Contiguous load signed halfwords to vector (immediate index).
plus immediate): Contiguous load signed words to vector (immediate index).
plus immediate): Contiguous load three-byte structures to three vectors (immediate index).
plus immediate): Contiguous load three-doubleword structures to three vectors (immediate index).
plus immediate): Contiguous load three-halfword structures to three vectors (immediate index).
plus immediate): Contiguous load three-word structures to three vectors (immediate index).
plus immediate): Contiguous load two-byte structures to two vectors (immediate index).
plus immediate): Contiguous load two-doubleword structures to two vectors (immediate index).
plus immediate): Contiguous load two-halfword structures to two vectors (immediate index).
plus immediate): Contiguous load two-word structures to two vectors (immediate index).
plus immediate): Contiguous load unsigned bytes to vector (immediate index).
plus immediate): Contiguous load unsigned halfwords to vector (immediate index).
plus immediate): Contiguous load unsigned words to vector (immediate index).
plus immediate): Contiguous prefetch bytes (immediate index).
plus immediate): Contiguous prefetch doublewords (immediate index).
plus immediate): Contiguous prefetch halfwords (immediate index).
plus immediate): Contiguous prefetch words (immediate index).
plus immediate): Contiguous store bytes from vector (immediate index).
plus immediate): Contiguous store doublewords from vector (immediate index).
plus immediate): Contiguous store four-byte structures from four vectors (immediate index).
plus immediate): Contiguous store four-doubleword structures from four vectors (immediate index).
plus immediate): Contiguous store four-halfword structures from four vectors (immediate index).
plus immediate): Contiguous store four-word structures from four vectors (immediate index).
plus immediate): Contiguous store halfwords from vector (immediate index).
plus immediate): Contiguous store non-temporal bytes from vector (immediate index).
plus immediate): Contiguous store non-temporal doublewords from vector (immediate index).
plus immediate): Contiguous store non-temporal halfwords from vector (immediate index).
plus immediate): Contiguous store non-temporal words from vector (immediate index).
plus immediate): Contiguous store three-byte structures from three vectors (immediate index).
plus immediate): Contiguous store three-doubleword structures from three vectors (immediate index).
plus immediate): Contiguous store three-halfword structures from three vectors (immediate index).
plus immediate): Contiguous store three-word structures from three vectors (immediate index).
plus immediate): Contiguous store two-byte structures from two vectors (immediate index).
plus immediate): Contiguous store two-doubleword structures from two vectors (immediate index).
plus immediate): Contiguous store two-halfword structures from two vectors (immediate index).
plus immediate): Contiguous store two-word structures from two vectors (immediate index).
plus immediate): Contiguous store words from vector (immediate index).
plus immediate): Gather load doublewords to vector (immediate index).
plus immediate): Gather load first-fault doublewords to vector (immediate index).
plus immediate): Gather load first-fault signed bytes to vector (immediate index).
plus immediate): Gather load first-fault signed halfwords to vector (immediate index).
plus immediate): Gather load first-fault signed words to vector (immediate index).
plus immediate): Gather load first-fault unsigned bytes to vector (immediate index).
plus immediate): Gather load first-fault unsigned halfwords to vector (immediate index).
plus immediate): Gather load first-fault unsigned words to vector (immediate index).
plus immediate): Gather load signed bytes to vector (immediate index).
plus immediate): Gather load signed halfwords to vector (immediate index).
plus immediate): Gather load signed words to vector (immediate index).
plus immediate): Gather load unsigned bytes to vector (immediate index).
plus immediate): Gather load unsigned halfwords to vector (immediate index).
plus immediate): Gather load unsigned words to vector (immediate index).
plus immediate): Gather prefetch bytes (vector plus immediate).
plus immediate): Gather prefetch doublewords (vector plus immediate).
plus immediate): Gather prefetch halfwords (vector plus immediate).
plus immediate): Gather prefetch words (vector plus immediate).
plus immediate): Scatter store bytes from a vector (immediate index).
plus immediate): Scatter store doublewords from a vector (immediate index).
plus immediate): Scatter store halfwords from a vector (immediate index).
plus immediate): Scatter store words from a vector (immediate index).
plus scalar): Contiguous load and replicate eight halfwords (scalar index).
plus scalar): Contiguous load and replicate four words (scalar index).
plus scalar): Contiguous load and replicate sixteen bytes (scalar index).
plus scalar): Contiguous load and replicate two doublewords (scalar index).
plus scalar): Contiguous load doublewords to vector (scalar index).
plus scalar): Contiguous load first-fault doublewords to vector (scalar index).
plus scalar): Contiguous load first-fault signed bytes to vector (scalar index).
plus scalar): Contiguous load first-fault signed halfwords to vector (scalar index).
plus scalar): Contiguous load first-fault signed words to vector (scalar index).
plus scalar): Contiguous load first-fault unsigned bytes to vector (scalar index).
plus scalar): Contiguous load first-fault unsigned halfwords to vector (scalar index).
plus scalar): Contiguous load first-fault unsigned words to vector (scalar index).
plus scalar): Contiguous load four-byte structures to four vectors (scalar index).
plus scalar): Contiguous load four-doubleword structures to four vectors (scalar index).
plus scalar): Contiguous load four-halfword structures to four vectors (scalar index).
plus scalar): Contiguous load four-word structures to four vectors (scalar index).
plus scalar): Contiguous load non-temporal bytes to vector (scalar index).
plus scalar): Contiguous load non-temporal doublewords to vector (scalar index).
plus scalar): Contiguous load non-temporal halfwords to vector (scalar index).
plus scalar): Contiguous load non-temporal words to vector (scalar index).
plus scalar): Contiguous load signed bytes to vector (scalar index).
plus scalar): Contiguous load signed halfwords to vector (scalar index).
plus scalar): Contiguous load signed words to vector (scalar index).
plus scalar): Contiguous load three-byte structures to three vectors (scalar index).
plus scalar): Contiguous load three-doubleword structures to three vectors (scalar index).
plus scalar): Contiguous load three-halfword structures to three vectors (scalar index).
plus scalar): Contiguous load three-word structures to three vectors (scalar index).
plus scalar): Contiguous load two-byte structures to two vectors (scalar index).
plus scalar): Contiguous load two-doubleword structures to two vectors (scalar index).
plus scalar): Contiguous load two-halfword structures to two vectors (scalar index).
plus scalar): Contiguous load two-word structures to two vectors (scalar index).
plus scalar): Contiguous load unsigned bytes to vector (scalar index).
plus scalar): Contiguous load unsigned halfwords to vector (scalar index).
plus scalar): Contiguous load unsigned words to vector (scalar index).
plus scalar): Contiguous prefetch bytes (scalar index).
plus scalar): Contiguous prefetch doublewords (scalar index).
plus scalar): Contiguous prefetch halfwords (scalar index).
plus scalar): Contiguous prefetch words (scalar index).
plus scalar): Contiguous store bytes from vector (scalar index).
plus scalar): Contiguous store doublewords from vector (scalar index).
plus scalar): Contiguous store four-byte structures from four vectors (scalar index).
plus scalar): Contiguous store four-doubleword structures from four vectors (scalar index).
plus scalar): Contiguous store four-halfword structures from four vectors (scalar index).
plus scalar): Contiguous store four-word structures from four vectors (scalar index).
plus scalar): Contiguous store halfwords from vector (scalar index).
plus scalar): Contiguous store non-temporal bytes from vector (scalar index).
plus scalar): Contiguous store non-temporal doublewords from vector (scalar index).
plus scalar): Contiguous store non-temporal halfwords from vector (scalar index).
plus scalar): Contiguous store non-temporal words from vector (scalar index).
plus scalar): Contiguous store three-byte structures from three vectors (scalar index).
plus scalar): Contiguous store three-doubleword structures from three vectors (scalar index).
plus scalar): Contiguous store three-halfword structures from three vectors (scalar index).
plus scalar): Contiguous store three-word structures from three vectors (scalar index).
plus scalar): Contiguous store two-byte structures from two vectors (scalar index).
plus scalar): Contiguous store two-doubleword structures from two vectors (scalar index).
plus scalar): Contiguous store two-halfword structures from two vectors (scalar index).
plus scalar): Contiguous store two-word structures from two vectors (scalar index).
plus scalar): Contiguous store words from vector (scalar index).
PRFB (scalar plus vector): Gather prefetch bytes (scalar
plus vector).
PRFD (scalar plus vector): Gather prefetch doublewords (scalar
plus vector).
PRFH (scalar plus vector): Gather prefetch halfwords (scalar
plus vector).
PRFW (scalar plus vector): Gather prefetch words (scalar
plus vector).
plus vector): Gather load doublewords to vector (vector index).
plus vector): Gather load first-fault doublewords to vector (vector index).
plus vector): Gather load first-fault signed bytes to vector (vector index).
plus vector): Gather load first-fault signed halfwords to vector (vector index).
plus vector): Gather load first-fault signed words to vector (vector index).
plus vector): Gather load first-fault unsigned bytes to vector (vector index).
plus vector): Gather load first-fault unsigned halfwords to vector (vector index).
plus vector): Gather load first-fault unsigned words to vector (vector index).
plus vector): Gather load signed bytes to vector (vector index).
plus vector): Gather load signed halfwords to vector (vector index).
plus vector): Gather load signed words to vector (vector index).
plus vector): Gather load unsigned bytes to vector (vector index).
plus vector): Gather load unsigned halfwords to vector (vector index).
plus vector): Gather load unsigned words to vector (vector index).
plus vector): Gather prefetch bytes (scalar plus vector).
plus vector): Gather prefetch doublewords (scalar plus vector).
plus vector): Gather prefetch halfwords (scalar plus vector).
plus vector): Gather prefetch words (scalar plus vector).
plus vector): Scatter store bytes from a vector (vector index).
plus vector): Scatter store doublewords from a vector (vector index).
plus vector): Scatter store halfwords from a vector (vector index).
plus vector): Scatter store words from a vector (vector index).
PNEXT: Find next active predicate.
FACLE: Floating-
point absolute compare less than or equal: an alias of FAC<cc>.
FACLT: Floating-
point absolute compare less than: an alias of FAC<cc>.
FAC<cc>: Floating-
point absolute compare vectors.
FABD: Floating-
point absolute difference (predicated).
FABS: Floating-
point absolute value (predicated).
FADD (immediate): Floating-
point add immediate (predicated).
FADDV: Floating-
point add recursive reduction to scalar.
FADDA: Floating-
point add strictly-ordered reduction, accumulating in scalar.
FADD (vectors, predicated): Floating-
point add vector (predicated).
FADD (vectors, unpredicated): Floating-
point add vector (unpredicated).
FSCALE: Floating-
point adjust exponent by vector (predicated).
FCMLE (vectors): Floating-
point compare less than or equal to vector: an alias of FCM<cc> (vectors).
FCMLT (vectors): Floating-
point compare less than vector: an alias of FCM<cc> (vectors).
FCM<cc> (zero): Floating-
point compare vector with zero.
FCM<cc> (vectors): Floating-
point compare vectors.
FCADD: Floating-
point complex add with rotate (predicated).
FCMLA (indexed): Floating-
point complex multiply-add by indexed values with rotate.
FCMLA (vectors): Floating-
point complex multiply-add with rotate (predicated).
FCVT: Floating-
point convert precision (predicated).
FCVTZS: Floating-
point convert to signed integer, rounding toward zero (predicated).
FCVTZU: Floating-
point convert to unsigned integer, rounding toward zero (predicated).
FDIV: Floating-
point divide by vector (predicated).
FEXPA: Floating-
point exponential accelerator.
FMLA (indexed): Floating-
point fused multiply-add by indexed elements (Zda = Zda + Zn * Zm[indexed]).
FMLA (vectors): Floating-
point fused multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
FMAD: Floating-
point fused multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
FMLS (indexed): Floating-
point fused multiply-subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FMLS (vectors): Floating-
point fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
FMSB: Floating-
point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
FMAX (vectors): Floating-
point maximum (predicated).
FMAXNM (vectors): Floating-
point maximum number (predicated).
FMAXNMV: Floating-
point maximum number recursive reduction to scalar.
FMAXNM (immediate): Floating-
point maximum number with immediate (predicated).
FMAXV: Floating-
point maximum recursive reduction to scalar.
FMAX (immediate): Floating-
point maximum with immediate (predicated).
FMIN (vectors): Floating-
point minimum (predicated).
FMINNM (vectors): Floating-
point minimum number (predicated).
FMINNMV: Floating-
point minimum number recursive reduction to scalar.
FMINNM (immediate): Floating-
point minimum number with immediate (predicated).
FMINV: Floating-
point minimum recursive reduction to scalar.
FMIN (immediate): Floating-
point minimum with immediate (predicated).
FMUL (immediate): Floating-
point multiply by immediate (predicated).
FMUL (indexed): Floating-
point multiply by indexed elements.
FMUL (vectors, predicated): Floating-
point multiply vectors (predicated).
FMUL (vectors, unpredicated): Floating-
point multiply vectors (unpredicated).
FMULX: Floating-
point multiply-extended vectors (predicated).
FNEG: Floating-
point negate (predicated).
FNMLA: Floating-
point negated fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FNMAD: Floating-
point negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FNMLS: Floating-
point negated fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FNMSB: Floating-
point negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
FRECPE: Floating-
point reciprocal estimate (unpredicated).
FRECPX: Floating-
point reciprocal exponent (predicated).
FRSQRTE: Floating-
point reciprocal square root estimate (unpredicated).
FRSQRTS: Floating-
point reciprocal square root step (unpredicated).
FRECPS: Floating-
point reciprocal step (unpredicated).
FDIVR: Floating-
point reversed divide by vector (predicated).
FSUBR (immediate): Floating-
point reversed subtract from immediate (predicated).
FSUBR (vectors): Floating-
point reversed subtract vectors (predicated).
FRINT<r>: Floating-
point round to integral value (predicated).
FSQRT: Floating-
point square root (predicated).
FSUB (immediate): Floating-
point subtract immediate (predicated).
FSUB (vectors, predicated): Floating-
point subtract vectors (predicated).
FSUB (vectors, unpredicated): Floating-
point subtract vectors (unpredicated).
FTMAD: Floating-
point trigonometric multiply-add coefficient.
FTSSEL: Floating-
point trigonometric select coefficient.
FTSMUL: Floating-
point trigonometric starting value.
FCVT: Floating-point convert
precision (predicated).
MOVS (unpredicated): Move
predicate (unpredicated), setting the condition flags: an alias of ORR, ORRS (predicates).
predicate (unpredicated): an alias of ORR, ORRS (predicates).
CNTB, CNTD, CNTH, CNTW: Set scalar to multiple of
predicate constraint element count.
DECB, DECD, DECH, DECW (scalar): Decrement scalar by multiple of
predicate constraint element count.
DECD, DECH, DECW (vector): Decrement vector by multiple of
predicate constraint element count.
INCB, INCD, INCH, INCW (scalar): Increment scalar by multiple of
predicate constraint element count.
INCD, INCH, INCW (vector): Increment vector by multiple of
predicate constraint element count.
SQDECB: Signed saturating decrement scalar by multiple of 8-bit
predicate constraint element count.
SQDECD (scalar): Signed saturating decrement scalar by multiple of 64-bit
predicate constraint element count.
SQDECD (vector): Signed saturating decrement vector by multiple of 64-bit
predicate constraint element count.
SQDECH (scalar): Signed saturating decrement scalar by multiple of 16-bit
predicate constraint element count.
SQDECH (vector): Signed saturating decrement vector by multiple of 16-bit
predicate constraint element count.
SQDECW (scalar): Signed saturating decrement scalar by multiple of 32-bit
predicate constraint element count.
SQDECW (vector): Signed saturating decrement vector by multiple of 32-bit
predicate constraint element count.
SQINCB: Signed saturating increment scalar by multiple of 8-bit
predicate constraint element count.
SQINCD (scalar): Signed saturating increment scalar by multiple of 64-bit
predicate constraint element count.
SQINCD (vector): Signed saturating increment vector by multiple of 64-bit
predicate constraint element count.
SQINCH (scalar): Signed saturating increment scalar by multiple of 16-bit
predicate constraint element count.
SQINCH (vector): Signed saturating increment vector by multiple of 16-bit
predicate constraint element count.
SQINCW (scalar): Signed saturating increment scalar by multiple of 32-bit
predicate constraint element count.
SQINCW (vector): Signed saturating increment vector by multiple of 32-bit
predicate constraint element count.
UQDECB: Unsigned saturating decrement scalar by multiple of 8-bit
predicate constraint element count.
UQDECD (scalar): Unsigned saturating decrement scalar by multiple of 64-bit
predicate constraint element count.
UQDECD (vector): Unsigned saturating decrement vector by multiple of 64-bit
predicate constraint element count.
UQDECH (scalar): Unsigned saturating decrement scalar by multiple of 16-bit
predicate constraint element count.
UQDECH (vector): Unsigned saturating decrement vector by multiple of 16-bit
predicate constraint element count.
UQDECW (scalar): Unsigned saturating decrement scalar by multiple of 32-bit
predicate constraint element count.
UQDECW (vector): Unsigned saturating decrement vector by multiple of 32-bit
predicate constraint element count.
UQINCB: Unsigned saturating increment scalar by multiple of 8-bit
predicate constraint element count.
UQINCD (scalar): Unsigned saturating increment scalar by multiple of 64-bit
predicate constraint element count.
UQINCD (vector): Unsigned saturating increment vector by multiple of 64-bit
predicate constraint element count.
UQINCH (scalar): Unsigned saturating increment scalar by multiple of 16-bit
predicate constraint element count.
UQINCH (vector): Unsigned saturating increment vector by multiple of 16-bit
predicate constraint element count.
UQINCW (scalar): Unsigned saturating increment scalar by multiple of 32-bit
predicate constraint element count.
UQINCW (vector): Unsigned saturating increment vector by multiple of 32-bit
predicate constraint element count.
SPLICE: Splice two vectors under
predicate control.
CNTP: Set scalar to active
predicate element count.
DECP (scalar): Decrement scalar by active
predicate element count.
DECP (vector): Decrement vector by active
predicate element count.
INCP (scalar): Increment scalar by active
predicate element count.
INCP (vector): Increment vector by active
predicate element count.
SQDECP (scalar): Signed saturating decrement scalar by active
predicate element count.
SQDECP (vector): Signed saturating decrement vector by active
predicate element count.
SQINCP (scalar): Signed saturating increment scalar by active
predicate element count.
SQINCP (vector): Signed saturating increment vector by active
predicate element count.
UQDECP (scalar): Unsigned saturating decrement scalar by active
predicate element count.
UQDECP (vector): Unsigned saturating decrement vector by active
predicate element count.
UQINCP (scalar): Unsigned saturating increment scalar by active
predicate element count.
UQINCP (vector): Unsigned saturating increment vector by active
predicate element count.
PFIRST: Set the first active
predicate element to true.
PFALSE: Set all
predicate elements to false.
PTRUE, PTRUES: Initialise
predicate from named constraint.
RDFFR, RDFFRS (predicated): Return
predicate of succesfully loaded elements.
ADDPL: Add multiple of
predicate register size to scalar register.
LDR (predicate): Load
predicate register.
STR (predicate): Store
predicate register.
predicate): Bitwise invert predicate: an alias of EOR, EORS (predicates).
predicate): Load predicate register.
predicate): Reverse all elements in a predicate.
predicate): Store predicate register.
predicate, predicated, merging): Move predicates (merging): an alias of SEL (predicates).
predicate, predicated, zeroing): Move predicates (zeroing): an alias of AND, ANDS (predicates).
NOTS: Bitwise invert
predicate, setting the condition flags: an alias of EOR, EORS (predicates).
predicate, unpredicated): Move predicate (unpredicated): an alias of ORR, ORRS (predicates).
ORN, ORNS (predicates): Bitwise OR inverted
predicate.
ORR, ORRS (predicates): Bitwise OR
predicate.
PNEXT: Find next active
predicate.
PTEST: Set condition flags for
predicate.
PUNPKHI, PUNPKLO: Unpack and widen half of
predicate.
REV (predicate): Reverse all elements in a
predicate.
NOT (predicate): Bitwise invert
predicate: an alias of EOR, EORS (predicates).
FNMLA: Floating-point negated fused multiply-add vectors (
predicated), writing addend [Zda = -Zda + -Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (
predicated), writing addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point fused multiply-subtract vectors (
predicated), writing addend [Zda = Zda + -Zn * Zm].
FMLA (vectors): Floating-point fused multiply-add vectors (
predicated), writing addend [Zda = Zda + Zn * Zm].
MLA: Multiply-add vectors (
predicated), writing addend [Zda = Zda + Zn * Zm].
MLS: Multiply-subtract vectors (
predicated), writing addend [Zda = Zda - Zn * Zm].
FNMAD: Floating-point negated fused multiply-add vectors (
predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (
predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused multiply-subtract vectors (
predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-add vectors (
predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
MAD: Multiply-add vectors (
predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
MSB: Multiply-subtract vectors (
predicated), writing multiplicand [Zdn = Za - Zdn * Zm].
ABS: Absolute value (
predicated).
ADD (vectors, predicated): Add vectors (
predicated).
AND (vectors, predicated): Bitwise AND vectors (
predicated).
ASR (immediate, predicated): Arithmetic shift right by immediate (
predicated).
ASR (vectors): Arithmetic shift right by vector (
predicated).
ASR (wide elements, predicated): Arithmetic shift right by 64-bit wide elements (
predicated).
ASRD: Arithmetic shift right for divide by immediate (
predicated).
ASRR: Reversed arithmetic shift right by vector (
predicated).
BIC (vectors, predicated): Bitwise clear vectors (
predicated).
CLS: Count leading sign bits (
predicated).
CLZ: Count leading zero bits (
predicated).
CNOT: Logically invert boolean condition in vector (
predicated).
CNT: Count non-zero bits (
predicated).
CPY (immediate): Copy signed integer immediate to vector elements (
predicated).
CPY (scalar): Copy general-purpose register to vector elements (
predicated).
CPY (SIMD&FP scalar): Copy SIMD&FP scalar register to vector elements (
predicated).
EOR (vectors, predicated): Bitwise exclusive OR vectors (
predicated).
FABD: Floating-point absolute difference (
predicated).
FABS: Floating-point absolute value (
predicated).
FADD (immediate): Floating-point add immediate (
predicated).
FADD (vectors, predicated): Floating-point add vector (
predicated).
FCADD: Floating-point complex add with rotate (
predicated).
FCMLA (vectors): Floating-point complex multiply-add with rotate (
predicated).
FCPY: Copy 8-bit floating-point immediate to vector elements (
predicated).
FCVT: Floating-point convert precision (
predicated).
FCVTZS: Floating-point convert to signed integer, rounding toward zero (
predicated).
FCVTZU: Floating-point convert to unsigned integer, rounding toward zero (
predicated).
FDIV: Floating-point divide by vector (
predicated).
FDIVR: Floating-point reversed divide by vector (
predicated).
FMAX (immediate): Floating-point maximum with immediate (
predicated).
FMAX (vectors): Floating-point maximum (
predicated).
FMAXNM (immediate): Floating-point maximum number with immediate (
predicated).
FMAXNM (vectors): Floating-point maximum number (
predicated).
FMIN (immediate): Floating-point minimum with immediate (
predicated).
FMIN (vectors): Floating-point minimum (
predicated).
FMINNM (immediate): Floating-point minimum number with immediate (
predicated).
FMINNM (vectors): Floating-point minimum number (
predicated).
FMUL (immediate): Floating-point multiply by immediate (
predicated).
FMUL (vectors, predicated): Floating-point multiply vectors (
predicated).
FMULX: Floating-point multiply-extended vectors (
predicated).
FNEG: Floating-point negate (
predicated).
FRECPX: Floating-point reciprocal exponent (
predicated).
FRINT<r>: Floating-point round to integral value (
predicated).
FSCALE: Floating-point adjust exponent by vector (
predicated).
FSQRT: Floating-point square root (
predicated).
FSUB (immediate): Floating-point subtract immediate (
predicated).
FSUB (vectors, predicated): Floating-point subtract vectors (
predicated).
FSUBR (immediate): Floating-point reversed subtract from immediate (
predicated).
FSUBR (vectors): Floating-point reversed subtract vectors (
predicated).
LSL (immediate, predicated): Logical shift left by immediate (
predicated).
LSL (vectors): Logical shift left by vector (
predicated).
LSL (wide elements, predicated): Logical shift left by 64-bit wide elements (
predicated).
LSLR: Reversed logical shift left by vector (
predicated).
LSR (immediate, predicated): Logical shift right by immediate (
predicated).
LSR (vectors): Logical shift right by vector (
predicated).
LSR (wide elements, predicated): Logical shift right by 64-bit wide elements (
predicated).
LSRR: Reversed logical shift right by vector (
predicated).
MOVPRFX (predicated): Move prefix (
predicated).
MUL (vectors): Multiply vectors (
predicated).
NEG: Negate (
predicated).
NOT (vector): Bitwise invert vector (
predicated).
ORR (vectors, predicated): Bitwise OR vectors (
predicated).
RBIT: Reverse bits (
predicated).
REVB, REVH, REVW: Reverse bytes / halfwords / words within elements (
predicated).
SABD: Signed absolute difference (
predicated).
SCVTF: Signed integer convert to floating-point (
predicated).
SDIV: Signed divide (
predicated).
SDIVR: Signed reversed divide (
predicated).
SMAX (vectors): Signed maximum vectors (
predicated).
SMIN (vectors): Signed minimum vectors (
predicated).
SMULH: Signed multiply returning high half (
predicated).
SUB (vectors, predicated): Subtract vectors (
predicated).
SUBR (vectors): Reversed subtract vectors (
predicated).
SXTB, SXTH, SXTW: Signed byte / halfword / word extend (
predicated).
UABD: Unsigned absolute difference (
predicated).
UCVTF: Unsigned integer convert to floating-point (
predicated).
UDIV: Unsigned divide (
predicated).
UDIVR: Unsigned reversed divide (
predicated).
UMAX (vectors): Unsigned maximum vectors (
predicated).
UMIN (vectors): Unsigned minimum vectors (
predicated).
UMULH: Unsigned multiply returning high half (
predicated).
UXTB, UXTH, UXTW: Unsigned byte / halfword / word extend (
predicated).
predicated): Add vectors (predicated).
FMOV (zero, predicated): Move floating-point +0.0 to vector elements (
predicated): an alias of CPY (immediate).
MOV (immediate, predicated): Move signed integer immediate to vector elements (
predicated): an alias of CPY (immediate).
MOV (scalar, predicated): Move general-purpose register to vector elements (
predicated): an alias of CPY (scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (
predicated): an alias of CPY (SIMD&FP scalar).
FMOV (immediate, predicated): Move 8-bit floating-point immediate to vector elements (
predicated): an alias of FCPY.
MOV (vector, predicated): Move vector elements (
predicated): an alias of SEL (vectors).
predicated): Arithmetic shift right by 64-bit wide elements (predicated).
predicated): Arithmetic shift right by immediate (predicated).
predicated): Bitwise AND vectors (predicated).
predicated): Bitwise clear vectors (predicated).
predicated): Bitwise exclusive OR vectors (predicated).
predicated): Bitwise OR vectors (predicated).
predicated): Floating-point add vector (predicated).
predicated): Floating-point multiply vectors (predicated).
predicated): Floating-point subtract vectors (predicated).
predicated): Logical shift left by 64-bit wide elements (predicated).
predicated): Logical shift left by immediate (predicated).
predicated): Logical shift right by 64-bit wide elements (predicated).
predicated): Logical shift right by immediate (predicated).
predicated): Move 8-bit floating-point immediate to vector elements (predicated): an alias of FCPY.
predicated): Move floating-point +0.0 to vector elements (predicated): an alias of CPY (immediate).
predicated): Move general-purpose register to vector elements (predicated): an alias of CPY (scalar).
predicated): Move predicates (zeroing), setting the condition flags: an alias of AND, ANDS (predicates).
predicated): Move prefix (predicated).
predicated): Move signed integer immediate to vector elements (predicated): an alias of CPY (immediate).
predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
predicated): Move vector elements (predicated): an alias of SEL (vectors).
predicated): Return predicate of succesfully loaded elements.
predicated): Subtract vectors (predicated).
predicated, merging): Move predicates (merging): an alias of SEL (predicates).
predicated, zeroing): Move predicates (zeroing): an alias of AND, ANDS (predicates).
predicates (merging): an alias of SEL (predicates).
MOVS (predicated): Move
predicates (zeroing), setting the condition flags: an alias of AND, ANDS (predicates).
predicates (zeroing): an alias of AND, ANDS (predicates).
MOV (predicate, predicated, merging): Move predicates (merging): an alias of SEL (
predicates).
MOV (predicate, predicated, zeroing): Move predicates (zeroing): an alias of AND, ANDS (
predicates).
MOV (predicate, unpredicated): Move predicate (unpredicated): an alias of ORR, ORRS (
predicates).
MOVS (predicated): Move predicates (zeroing), setting the condition flags: an alias of AND, ANDS (
predicates).
MOVS (unpredicated): Move predicate (unpredicated), setting the condition flags: an alias of ORR, ORRS (
predicates).
NOT (predicate): Bitwise invert predicate: an alias of EOR, EORS (
predicates).
NOTS: Bitwise invert predicate, setting the condition flags: an alias of EOR, EORS (
predicates).
predicates): Bitwise AND predicates.
predicates): Bitwise clear predicates.
predicates): Bitwise exclusive OR predicates.
predicates): Bitwise OR inverted predicate.
predicates): Bitwise OR predicate.
predicates): Concatenate even or odd elements from two predicates.
predicates): Conditionally select elements from two predicates.
predicates): Interleave elements from two half predicates.
predicates): Interleave even or odd elements from two predicates.
AND, ANDS (predicates): Bitwise AND
predicates.
BIC, BICS (predicates): Bitwise clear
predicates.
EOR, EORS (predicates): Bitwise exclusive OR
predicates.
NAND, NANDS: Bitwise NAND
predicates.
NOR, NORS: Bitwise NOR
predicates.
SEL (predicates): Conditionally select elements from two
predicates.
TRN1, TRN2 (predicates): Interleave even or odd elements from two
predicates.
UZP1, UZP2 (predicates): Concatenate even or odd elements from two
predicates.
ZIP1, ZIP2 (predicates): Interleave elements from two half
predicates.
PRFB (scalar plus immediate): Contiguous
prefetch bytes (immediate index).
PRFB (scalar plus scalar): Contiguous
prefetch bytes (scalar index).
PRFB (scalar plus vector): Gather
prefetch bytes (scalar plus vector).
PRFB (vector plus immediate): Gather
prefetch bytes (vector plus immediate).
PRFD (scalar plus immediate): Contiguous
prefetch doublewords (immediate index).
PRFD (scalar plus scalar): Contiguous
prefetch doublewords (scalar index).
PRFD (scalar plus vector): Gather
prefetch doublewords (scalar plus vector).
PRFD (vector plus immediate): Gather
prefetch doublewords (vector plus immediate).
PRFH (scalar plus immediate): Contiguous
prefetch halfwords (immediate index).
PRFH (scalar plus scalar): Contiguous
prefetch halfwords (scalar index).
PRFH (scalar plus vector): Gather
prefetch halfwords (scalar plus vector).
PRFH (vector plus immediate): Gather
prefetch halfwords (vector plus immediate).
PRFW (scalar plus immediate): Contiguous
prefetch words (immediate index).
PRFW (scalar plus scalar): Contiguous
prefetch words (scalar index).
PRFW (scalar plus vector): Gather
prefetch words (scalar plus vector).
PRFW (vector plus immediate): Gather
prefetch words (vector plus immediate).
MOVPRFX (predicated): Move
prefix (predicated).
MOVPRFX (unpredicated): Move
prefix (unpredicated).
BRKPA, BRKPAS: Break after first true condition, propagating from
previous partition.
BRKPB, BRKPBS: Break before first true condition, propagating from
previous partition.
PRFB (scalar plus immediate): Contiguous prefetch bytes (immediate index).
PRFB (scalar plus scalar): Contiguous prefetch bytes (scalar index).
PRFB (scalar plus vector): Gather prefetch bytes (scalar plus vector).
PRFB (vector plus immediate): Gather prefetch bytes (vector plus immediate).
PRFD (scalar plus immediate): Contiguous prefetch doublewords (immediate index).
PRFD (scalar plus scalar): Contiguous prefetch doublewords (scalar index).
PRFD (scalar plus vector): Gather prefetch doublewords (scalar plus vector).
PRFD (vector plus immediate): Gather prefetch doublewords (vector plus immediate).
PRFH (scalar plus immediate): Contiguous prefetch halfwords (immediate index).
PRFH (scalar plus scalar): Contiguous prefetch halfwords (scalar index).
PRFH (scalar plus vector): Gather prefetch halfwords (scalar plus vector).
PRFH (vector plus immediate): Gather prefetch halfwords (vector plus immediate).
PRFW (scalar plus immediate): Contiguous prefetch words (immediate index).
PRFW (scalar plus scalar): Contiguous prefetch words (scalar index).
PRFW (scalar plus vector): Gather prefetch words (scalar plus vector).
PRFW (vector plus immediate): Gather prefetch words (vector plus immediate).
SDOT (indexed): Signed dot
product by indexed quadtuplet.
UDOT (indexed): Unsigned dot
product by indexed quadtuplet.
SDOT (vectors): Signed dot
product.
UDOT (vectors): Unsigned dot
product.
TBL:
Programmable table lookup in single vector table.
Propagate break to next partition.
BRKPA, BRKPAS: Break after first true condition,
propagating from previous partition.
BRKPB, BRKPBS: Break before first true condition,
propagating from previous partition.
PTEST: Set condition flags for predicate.
PTRUE, PTRUES: Initialise predicate from named constraint.
PUNPKHI, PUNPKLO: Unpack and widen half of predicate.
INDEX (scalar, immediate): Create index starting from general-
purpose register and incremented by immediate.
INSR (scalar): Insert general-
purpose register in shifted vector.
CPY (scalar): Copy general-
purpose register to vector elements (predicated).
MOV (scalar, predicated): Move general-
purpose register to vector elements (predicated): an alias of CPY (scalar).
DUP (scalar): Broadcast general-
purpose register to vector elements (unpredicated).
MOV (scalar, unpredicated): Move general-
purpose register to vector elements (unpredicated): an alias of DUP (scalar).
CLASTA (scalar): Conditionally extract element after last to general-
purpose register.
CLASTB (scalar): Conditionally extract last element to general-
purpose register.
INDEX (immediate, scalar): Create index starting from immediate and incremented by general-
purpose register.
INDEX (scalars): Create index starting from and incremented by general-
purpose register.
LASTA (scalar): Extract element after last to general-
purpose register.
LASTB (scalar): Extract last element to general-
purpose register.
SDOT (indexed): Signed dot product by indexed
UDOT (indexed): Unsigned dot product by indexed
quadtuplet.
RBIT: Reverse bits (predicated).
RDFFR (unpredicated): Read the first-fault register.
RDFFR, RDFFRS (predicated): Return predicate of succesfully loaded elements.
RDFFRS (predicated): Return predicate of succesfully loaded elements.
RDVL: Read multiple of vector register size to scalar register.
RDVL:
Read multiple of vector register size to scalar register.
Read the first-fault register.
FRECPE: Floating-point
reciprocal estimate (unpredicated).
FRECPX: Floating-point
reciprocal exponent (predicated).
FRSQRTE: Floating-point
reciprocal square root estimate (unpredicated).
FRSQRTS: Floating-point
reciprocal square root step (unpredicated).
FRECPS: Floating-point
reciprocal step (unpredicated).
FADDV: Floating-point add
recursive reduction to scalar.
FMAXNMV: Floating-point maximum number
recursive reduction to scalar.
FMAXV: Floating-point maximum
recursive reduction to scalar.
FMINNMV: Floating-point minimum number
recursive reduction to scalar.
FMINV: Floating-point minimum
recursive reduction to scalar.
ANDV: Bitwise AND
reduction to scalar.
EORV: Bitwise XOR
reduction to scalar.
FADDV: Floating-point add recursive
reduction to scalar.
FMAXNMV: Floating-point maximum number recursive
reduction to scalar.
FMAXV: Floating-point maximum recursive
reduction to scalar.
FMINNMV: Floating-point minimum number recursive
reduction to scalar.
FMINV: Floating-point minimum recursive
reduction to scalar.
ORV: Bitwise OR
reduction to scalar.
SADDV: Signed add
reduction to scalar.
SMAXV: Signed maximum
reduction to scalar.
SMINV: Signed minimum
reduction to scalar.
UADDV: Unsigned add
reduction to scalar.
UMAXV: Unsigned maximum
reduction to scalar.
UMINV: Unsigned minimum
reduction to scalar.
FADDA: Floating-point add strictly-ordered
reduction, accumulating in scalar.
LD1RQH (scalar plus immediate): Contiguous load and
replicate eight halfwords (immediate index).
LD1RQH (scalar plus scalar): Contiguous load and
replicate eight halfwords (scalar index).
LD1RQW (scalar plus immediate): Contiguous load and
replicate four words (immediate index).
LD1RQW (scalar plus scalar): Contiguous load and
replicate four words (scalar index).
LD1RQB (scalar plus immediate): Contiguous load and
replicate sixteen bytes (immediate index).
LD1RQB (scalar plus scalar): Contiguous load and
replicate sixteen bytes (scalar index).
LD1RQD (scalar plus immediate): Contiguous load and
replicate two doublewords (immediate index).
LD1RQD (scalar plus scalar): Contiguous load and
replicate two doublewords (scalar index).
Return predicate of succesfully loaded elements.
SMULH: Signed multiply
returning high half (predicated).
UMULH: Unsigned multiply
returning high half (predicated).
REV (predicate): Reverse all elements in a predicate.
REV (vector): Reverse all elements in a vector (unpredicated).
REVB, REVH, REVW: Reverse bytes / halfwords / words within elements (predicated).
Reverse all elements in a predicate.
Reverse all elements in a vector (unpredicated).
RBIT:
Reverse bits (predicated).
Reverse bytes / halfwords / words within elements (predicated).
ASRR:
Reversed arithmetic shift right by vector (predicated).
SDIVR: Signed
reversed divide (predicated).
UDIVR: Unsigned
reversed divide (predicated).
FDIVR: Floating-point
reversed divide by vector (predicated).
LSLR:
Reversed logical shift left by vector (predicated).
LSRR:
Reversed logical shift right by vector (predicated).
FSUBR (immediate): Floating-point
reversed subtract from immediate (predicated).
Reversed subtract from immediate (unpredicated).
FSUBR (vectors): Floating-point
reversed subtract vectors (predicated).
Reversed subtract vectors (predicated).
REVH, REVW: Reverse bytes / halfwords / words within elements (predicated).
REVW: Reverse bytes / halfwords / words within elements (predicated).
COMPACT: Shuffle active elements of vector to the
right and fill with zero.
ASR (wide elements, predicated): Arithmetic shift
right by 64-bit wide elements (predicated).
LSR (wide elements, predicated): Logical shift
right by 64-bit wide elements (predicated).
ASR (wide elements, unpredicated): Arithmetic shift
right by 64-bit wide elements (unpredicated).
LSR (wide elements, unpredicated): Logical shift
right by 64-bit wide elements (unpredicated).
ASR (immediate, predicated): Arithmetic shift
right by immediate (predicated).
LSR (immediate, predicated): Logical shift
right by immediate (predicated).
ASR (immediate, unpredicated): Arithmetic shift
right by immediate (unpredicated).
LSR (immediate, unpredicated): Logical shift
right by immediate (unpredicated).
ASR (vectors): Arithmetic shift
right by vector (predicated).
ASRR: Reversed arithmetic shift
right by vector (predicated).
LSR (vectors): Logical shift
right by vector (predicated).
LSRR: Reversed logical shift
right by vector (predicated).
ASRD: Arithmetic shift
right for divide by immediate (predicated).
FSQRT: Floating-point square
root (predicated).
FRSQRTE: Floating-point reciprocal square
root estimate (unpredicated).
FRSQRTS: Floating-point reciprocal square
root step (unpredicated).
FCADD: Floating-point complex add with
rotate (predicated).
FCMLA (vectors): Floating-point complex multiply-add with
rotate (predicated).
FCMLA (indexed): Floating-point complex multiply-add by indexed values with
rotate.
FRINT<r>: Floating-point
round to integral value (predicated).
FCVTZS: Floating-point convert to signed integer,
rounding toward zero (predicated).
FCVTZU: Floating-point convert to unsigned integer,
rounding toward zero (predicated).
SADDV: Signed add reduction to scalar.
SQADD (immediate): Signed
saturating add immediate (unpredicated).
UQADD (immediate): Unsigned
saturating add immediate (unpredicated).
SQADD (vectors): Signed
saturating add vectors (unpredicated).
UQADD (vectors): Unsigned
saturating add vectors (unpredicated).
SQDECP (scalar): Signed
saturating decrement scalar by active predicate element count.
UQDECP (scalar): Unsigned
saturating decrement scalar by active predicate element count.
SQDECH (scalar): Signed
saturating decrement scalar by multiple of 16-bit predicate constraint element count.
UQDECH (scalar): Unsigned
saturating decrement scalar by multiple of 16-bit predicate constraint element count.
SQDECW (scalar): Signed
saturating decrement scalar by multiple of 32-bit predicate constraint element count.
UQDECW (scalar): Unsigned
saturating decrement scalar by multiple of 32-bit predicate constraint element count.
SQDECD (scalar): Signed
saturating decrement scalar by multiple of 64-bit predicate constraint element count.
UQDECD (scalar): Unsigned
saturating decrement scalar by multiple of 64-bit predicate constraint element count.
SQDECB: Signed
saturating decrement scalar by multiple of 8-bit predicate constraint element count.
UQDECB: Unsigned
saturating decrement scalar by multiple of 8-bit predicate constraint element count.
SQDECP (vector): Signed
saturating decrement vector by active predicate element count.
UQDECP (vector): Unsigned
saturating decrement vector by active predicate element count.
SQDECH (vector): Signed
saturating decrement vector by multiple of 16-bit predicate constraint element count.
UQDECH (vector): Unsigned
saturating decrement vector by multiple of 16-bit predicate constraint element count.
SQDECW (vector): Signed
saturating decrement vector by multiple of 32-bit predicate constraint element count.
UQDECW (vector): Unsigned
saturating decrement vector by multiple of 32-bit predicate constraint element count.
SQDECD (vector): Signed
saturating decrement vector by multiple of 64-bit predicate constraint element count.
UQDECD (vector): Unsigned
saturating decrement vector by multiple of 64-bit predicate constraint element count.
SQINCP (scalar): Signed
saturating increment scalar by active predicate element count.
UQINCP (scalar): Unsigned
saturating increment scalar by active predicate element count.
SQINCH (scalar): Signed
saturating increment scalar by multiple of 16-bit predicate constraint element count.
UQINCH (scalar): Unsigned
saturating increment scalar by multiple of 16-bit predicate constraint element count.
SQINCW (scalar): Signed
saturating increment scalar by multiple of 32-bit predicate constraint element count.
UQINCW (scalar): Unsigned
saturating increment scalar by multiple of 32-bit predicate constraint element count.
SQINCD (scalar): Signed
saturating increment scalar by multiple of 64-bit predicate constraint element count.
UQINCD (scalar): Unsigned
saturating increment scalar by multiple of 64-bit predicate constraint element count.
SQINCB: Signed
saturating increment scalar by multiple of 8-bit predicate constraint element count.
UQINCB: Unsigned
saturating increment scalar by multiple of 8-bit predicate constraint element count.
SQINCP (vector): Signed
saturating increment vector by active predicate element count.
UQINCP (vector): Unsigned
saturating increment vector by active predicate element count.
SQINCH (vector): Signed
saturating increment vector by multiple of 16-bit predicate constraint element count.
UQINCH (vector): Unsigned
saturating increment vector by multiple of 16-bit predicate constraint element count.
SQINCW (vector): Signed
saturating increment vector by multiple of 32-bit predicate constraint element count.
UQINCW (vector): Unsigned
saturating increment vector by multiple of 32-bit predicate constraint element count.
SQINCD (vector): Signed
saturating increment vector by multiple of 64-bit predicate constraint element count.
UQINCD (vector): Unsigned
saturating increment vector by multiple of 64-bit predicate constraint element count.
SQSUB (immediate): Signed
saturating subtract immediate (unpredicated).
UQSUB (immediate): Unsigned
saturating subtract immediate (unpredicated).
SQSUB (vectors): Signed
saturating subtract vectors (unpredicated).
UQSUB (vectors): Unsigned
saturating subtract vectors (unpredicated).
DECP (scalar): Decrement
scalar by active predicate element count.
INCP (scalar): Increment
scalar by active predicate element count.
SQDECP (scalar): Signed saturating decrement
scalar by active predicate element count.
SQINCP (scalar): Signed saturating increment
scalar by active predicate element count.
UQDECP (scalar): Unsigned saturating decrement
scalar by active predicate element count.
UQINCP (scalar): Unsigned saturating increment
scalar by active predicate element count.
SQDECH (scalar): Signed saturating decrement
scalar by multiple of 16-bit predicate constraint element count.
SQINCH (scalar): Signed saturating increment
scalar by multiple of 16-bit predicate constraint element count.
UQDECH (scalar): Unsigned saturating decrement
scalar by multiple of 16-bit predicate constraint element count.
UQINCH (scalar): Unsigned saturating increment
scalar by multiple of 16-bit predicate constraint element count.
SQDECW (scalar): Signed saturating decrement
scalar by multiple of 32-bit predicate constraint element count.
SQINCW (scalar): Signed saturating increment
scalar by multiple of 32-bit predicate constraint element count.
UQDECW (scalar): Unsigned saturating decrement
scalar by multiple of 32-bit predicate constraint element count.
UQINCW (scalar): Unsigned saturating increment
scalar by multiple of 32-bit predicate constraint element count.
SQDECD (scalar): Signed saturating decrement
scalar by multiple of 64-bit predicate constraint element count.
SQINCD (scalar): Signed saturating increment
scalar by multiple of 64-bit predicate constraint element count.
UQDECD (scalar): Unsigned saturating decrement
scalar by multiple of 64-bit predicate constraint element count.
UQINCD (scalar): Unsigned saturating increment
scalar by multiple of 64-bit predicate constraint element count.
SQDECB: Signed saturating decrement
scalar by multiple of 8-bit predicate constraint element count.
SQINCB: Signed saturating increment
scalar by multiple of 8-bit predicate constraint element count.
UQDECB: Unsigned saturating decrement
scalar by multiple of 8-bit predicate constraint element count.
UQINCB: Unsigned saturating increment
scalar by multiple of 8-bit predicate constraint element count.
DECB, DECD, DECH, DECW (scalar): Decrement
scalar by multiple of predicate constraint element count.
INCB, INCD, INCH, INCW (scalar): Increment
scalar by multiple of predicate constraint element count.
LD1B (scalar plus scalar): Contiguous load unsigned bytes to vector (
scalar index).
LD1D (scalar plus scalar): Contiguous load doublewords to vector (
scalar index).
LD1H (scalar plus scalar): Contiguous load unsigned halfwords to vector (
scalar index).
LD1RQB (scalar plus scalar): Contiguous load and replicate sixteen bytes (
scalar index).
LD1RQD (scalar plus scalar): Contiguous load and replicate two doublewords (
scalar index).
LD1RQH (scalar plus scalar): Contiguous load and replicate eight halfwords (
scalar index).
LD1RQW (scalar plus scalar): Contiguous load and replicate four words (
scalar index).
LD1SB (scalar plus scalar): Contiguous load signed bytes to vector (
scalar index).
LD1SH (scalar plus scalar): Contiguous load signed halfwords to vector (
scalar index).
LD1SW (scalar plus scalar): Contiguous load signed words to vector (
scalar index).
LD1W (scalar plus scalar): Contiguous load unsigned words to vector (
scalar index).
LD2B (scalar plus scalar): Contiguous load two-byte structures to two vectors (
scalar index).
LD2D (scalar plus scalar): Contiguous load two-doubleword structures to two vectors (
scalar index).
LD2H (scalar plus scalar): Contiguous load two-halfword structures to two vectors (
scalar index).
LD2W (scalar plus scalar): Contiguous load two-word structures to two vectors (
scalar index).
LD3B (scalar plus scalar): Contiguous load three-byte structures to three vectors (
scalar index).
LD3D (scalar plus scalar): Contiguous load three-doubleword structures to three vectors (
scalar index).
LD3H (scalar plus scalar): Contiguous load three-halfword structures to three vectors (
scalar index).
LD3W (scalar plus scalar): Contiguous load three-word structures to three vectors (
scalar index).
LD4B (scalar plus scalar): Contiguous load four-byte structures to four vectors (
scalar index).
LD4D (scalar plus scalar): Contiguous load four-doubleword structures to four vectors (
scalar index).
LD4H (scalar plus scalar): Contiguous load four-halfword structures to four vectors (
scalar index).
LD4W (scalar plus scalar): Contiguous load four-word structures to four vectors (
scalar index).
LDFF1B (scalar plus scalar): Contiguous load first-fault unsigned bytes to vector (
scalar index).
LDFF1D (scalar plus scalar): Contiguous load first-fault doublewords to vector (
scalar index).
LDFF1H (scalar plus scalar): Contiguous load first-fault unsigned halfwords to vector (
scalar index).
LDFF1SB (scalar plus scalar): Contiguous load first-fault signed bytes to vector (
scalar index).
LDFF1SH (scalar plus scalar): Contiguous load first-fault signed halfwords to vector (
scalar index).
LDFF1SW (scalar plus scalar): Contiguous load first-fault signed words to vector (
scalar index).
LDFF1W (scalar plus scalar): Contiguous load first-fault unsigned words to vector (
scalar index).
LDNT1B (scalar plus scalar): Contiguous load non-temporal bytes to vector (
scalar index).
LDNT1D (scalar plus scalar): Contiguous load non-temporal doublewords to vector (
scalar index).
LDNT1H (scalar plus scalar): Contiguous load non-temporal halfwords to vector (
scalar index).
LDNT1W (scalar plus scalar): Contiguous load non-temporal words to vector (
scalar index).
PRFB (scalar plus scalar): Contiguous prefetch bytes (
scalar index).
PRFD (scalar plus scalar): Contiguous prefetch doublewords (
scalar index).
PRFH (scalar plus scalar): Contiguous prefetch halfwords (
scalar index).
PRFW (scalar plus scalar): Contiguous prefetch words (
scalar index).
ST1B (scalar plus scalar): Contiguous store bytes from vector (
scalar index).
ST1D (scalar plus scalar): Contiguous store doublewords from vector (
scalar index).
ST1H (scalar plus scalar): Contiguous store halfwords from vector (
scalar index).
ST1W (scalar plus scalar): Contiguous store words from vector (
scalar index).
ST2B (scalar plus scalar): Contiguous store two-byte structures from two vectors (
scalar index).
ST2D (scalar plus scalar): Contiguous store two-doubleword structures from two vectors (
scalar index).
ST2H (scalar plus scalar): Contiguous store two-halfword structures from two vectors (
scalar index).
ST2W (scalar plus scalar): Contiguous store two-word structures from two vectors (
scalar index).
ST3B (scalar plus scalar): Contiguous store three-byte structures from three vectors (
scalar index).
ST3D (scalar plus scalar): Contiguous store three-doubleword structures from three vectors (
scalar index).
ST3H (scalar plus scalar): Contiguous store three-halfword structures from three vectors (
scalar index).
ST3W (scalar plus scalar): Contiguous store three-word structures from three vectors (
scalar index).
ST4B (scalar plus scalar): Contiguous store four-byte structures from four vectors (
scalar index).
ST4D (scalar plus scalar): Contiguous store four-doubleword structures from four vectors (
scalar index).
ST4H (scalar plus scalar): Contiguous store four-halfword structures from four vectors (
scalar index).
ST4W (scalar plus scalar): Contiguous store four-word structures from four vectors (
scalar index).
STNT1B (scalar plus scalar): Contiguous store non-temporal bytes from vector (
scalar index).
STNT1D (scalar plus scalar): Contiguous store non-temporal doublewords from vector (
scalar index).
STNT1H (scalar plus scalar): Contiguous store non-temporal halfwords from vector (
scalar index).
STNT1W (scalar plus scalar): Contiguous store non-temporal words from vector (
scalar index).
WHILELE: While incrementing signed
scalar less than or equal to scalar.
WHILELT: While incrementing signed
scalar less than scalar.
WHILELS: While incrementing unsigned
scalar lower or same as scalar.
WHILELO: While incrementing unsigned
scalar lower than scalar.
scalar plus immediate): Contiguous load and replicate eight halfwords (immediate index).
scalar plus immediate): Contiguous load and replicate four words (immediate index).
scalar plus immediate): Contiguous load and replicate sixteen bytes (immediate index).
scalar plus immediate): Contiguous load and replicate two doublewords (immediate index).
scalar plus immediate): Contiguous load doublewords to vector (immediate index).
scalar plus immediate): Contiguous load four-byte structures to four vectors (immediate index).
scalar plus immediate): Contiguous load four-doubleword structures to four vectors (immediate index).
scalar plus immediate): Contiguous load four-halfword structures to four vectors (immediate index).
scalar plus immediate): Contiguous load four-word structures to four vectors (immediate index).
scalar plus immediate): Contiguous load non-temporal bytes to vector (immediate index).
scalar plus immediate): Contiguous load non-temporal doublewords to vector (immediate index).
scalar plus immediate): Contiguous load non-temporal halfwords to vector (immediate index).
scalar plus immediate): Contiguous load non-temporal words to vector (immediate index).
scalar plus immediate): Contiguous load signed bytes to vector (immediate index).
scalar plus immediate): Contiguous load signed halfwords to vector (immediate index).
scalar plus immediate): Contiguous load signed words to vector (immediate index).
scalar plus immediate): Contiguous load three-byte structures to three vectors (immediate index).
scalar plus immediate): Contiguous load three-doubleword structures to three vectors (immediate index).
scalar plus immediate): Contiguous load three-halfword structures to three vectors (immediate index).
scalar plus immediate): Contiguous load three-word structures to three vectors (immediate index).
scalar plus immediate): Contiguous load two-byte structures to two vectors (immediate index).
scalar plus immediate): Contiguous load two-doubleword structures to two vectors (immediate index).
scalar plus immediate): Contiguous load two-halfword structures to two vectors (immediate index).
scalar plus immediate): Contiguous load two-word structures to two vectors (immediate index).
scalar plus immediate): Contiguous load unsigned bytes to vector (immediate index).
scalar plus immediate): Contiguous load unsigned halfwords to vector (immediate index).
scalar plus immediate): Contiguous load unsigned words to vector (immediate index).
scalar plus immediate): Contiguous prefetch bytes (immediate index).
scalar plus immediate): Contiguous prefetch doublewords (immediate index).
scalar plus immediate): Contiguous prefetch halfwords (immediate index).
scalar plus immediate): Contiguous prefetch words (immediate index).
scalar plus immediate): Contiguous store bytes from vector (immediate index).
scalar plus immediate): Contiguous store doublewords from vector (immediate index).
scalar plus immediate): Contiguous store four-byte structures from four vectors (immediate index).
scalar plus immediate): Contiguous store four-doubleword structures from four vectors (immediate index).
scalar plus immediate): Contiguous store four-halfword structures from four vectors (immediate index).
scalar plus immediate): Contiguous store four-word structures from four vectors (immediate index).
scalar plus immediate): Contiguous store halfwords from vector (immediate index).
scalar plus immediate): Contiguous store non-temporal bytes from vector (immediate index).
scalar plus immediate): Contiguous store non-temporal doublewords from vector (immediate index).
scalar plus immediate): Contiguous store non-temporal halfwords from vector (immediate index).
scalar plus immediate): Contiguous store non-temporal words from vector (immediate index).
scalar plus immediate): Contiguous store three-byte structures from three vectors (immediate index).
scalar plus immediate): Contiguous store three-doubleword structures from three vectors (immediate index).
scalar plus immediate): Contiguous store three-halfword structures from three vectors (immediate index).
scalar plus immediate): Contiguous store three-word structures from three vectors (immediate index).
scalar plus immediate): Contiguous store two-byte structures from two vectors (immediate index).
scalar plus immediate): Contiguous store two-doubleword structures from two vectors (immediate index).
scalar plus immediate): Contiguous store two-halfword structures from two vectors (immediate index).
scalar plus immediate): Contiguous store two-word structures from two vectors (immediate index).
scalar plus immediate): Contiguous store words from vector (immediate index).
scalar plus scalar): Contiguous load and replicate eight halfwords (scalar index).
scalar plus scalar): Contiguous load and replicate four words (scalar index).
scalar plus scalar): Contiguous load and replicate sixteen bytes (scalar index).
scalar plus scalar): Contiguous load and replicate two doublewords (scalar index).
scalar plus scalar): Contiguous load doublewords to vector (scalar index).
scalar plus scalar): Contiguous load first-fault doublewords to vector (scalar index).
scalar plus scalar): Contiguous load first-fault signed bytes to vector (scalar index).
scalar plus scalar): Contiguous load first-fault signed halfwords to vector (scalar index).
scalar plus scalar): Contiguous load first-fault signed words to vector (scalar index).
scalar plus scalar): Contiguous load first-fault unsigned bytes to vector (scalar index).
scalar plus scalar): Contiguous load first-fault unsigned halfwords to vector (scalar index).
scalar plus scalar): Contiguous load first-fault unsigned words to vector (scalar index).
scalar plus scalar): Contiguous load four-byte structures to four vectors (scalar index).
scalar plus scalar): Contiguous load four-doubleword structures to four vectors (scalar index).
scalar plus scalar): Contiguous load four-halfword structures to four vectors (scalar index).
scalar plus scalar): Contiguous load four-word structures to four vectors (scalar index).
scalar plus scalar): Contiguous load non-temporal bytes to vector (scalar index).
scalar plus scalar): Contiguous load non-temporal doublewords to vector (scalar index).
scalar plus scalar): Contiguous load non-temporal halfwords to vector (scalar index).
scalar plus scalar): Contiguous load non-temporal words to vector (scalar index).
scalar plus scalar): Contiguous load signed bytes to vector (scalar index).
scalar plus scalar): Contiguous load signed halfwords to vector (scalar index).
scalar plus scalar): Contiguous load signed words to vector (scalar index).
scalar plus scalar): Contiguous load three-byte structures to three vectors (scalar index).
scalar plus scalar): Contiguous load three-doubleword structures to three vectors (scalar index).
scalar plus scalar): Contiguous load three-halfword structures to three vectors (scalar index).
scalar plus scalar): Contiguous load three-word structures to three vectors (scalar index).
scalar plus scalar): Contiguous load two-byte structures to two vectors (scalar index).
scalar plus scalar): Contiguous load two-doubleword structures to two vectors (scalar index).
scalar plus scalar): Contiguous load two-halfword structures to two vectors (scalar index).
scalar plus scalar): Contiguous load two-word structures to two vectors (scalar index).
scalar plus scalar): Contiguous load unsigned bytes to vector (scalar index).
scalar plus scalar): Contiguous load unsigned halfwords to vector (scalar index).
scalar plus scalar): Contiguous load unsigned words to vector (scalar index).
scalar plus scalar): Contiguous prefetch bytes (scalar index).
scalar plus scalar): Contiguous prefetch doublewords (scalar index).
scalar plus scalar): Contiguous prefetch halfwords (scalar index).
scalar plus scalar): Contiguous prefetch words (scalar index).
scalar plus scalar): Contiguous store bytes from vector (scalar index).
scalar plus scalar): Contiguous store doublewords from vector (scalar index).
scalar plus scalar): Contiguous store four-byte structures from four vectors (scalar index).
scalar plus scalar): Contiguous store four-doubleword structures from four vectors (scalar index).
scalar plus scalar): Contiguous store four-halfword structures from four vectors (scalar index).
scalar plus scalar): Contiguous store four-word structures from four vectors (scalar index).
scalar plus scalar): Contiguous store halfwords from vector (scalar index).
scalar plus scalar): Contiguous store non-temporal bytes from vector (scalar index).
scalar plus scalar): Contiguous store non-temporal doublewords from vector (scalar index).
scalar plus scalar): Contiguous store non-temporal halfwords from vector (scalar index).
scalar plus scalar): Contiguous store non-temporal words from vector (scalar index).
scalar plus scalar): Contiguous store three-byte structures from three vectors (scalar index).
scalar plus scalar): Contiguous store three-doubleword structures from three vectors (scalar index).
scalar plus scalar): Contiguous store three-halfword structures from three vectors (scalar index).
scalar plus scalar): Contiguous store three-word structures from three vectors (scalar index).
scalar plus scalar): Contiguous store two-byte structures from two vectors (scalar index).
scalar plus scalar): Contiguous store two-doubleword structures from two vectors (scalar index).
scalar plus scalar): Contiguous store two-halfword structures from two vectors (scalar index).
scalar plus scalar): Contiguous store two-word structures from two vectors (scalar index).
scalar plus scalar): Contiguous store words from vector (scalar index).
PRFB (scalar plus vector): Gather prefetch bytes (
scalar plus vector).
PRFD (scalar plus vector): Gather prefetch doublewords (
scalar plus vector).
PRFH (scalar plus vector): Gather prefetch halfwords (
scalar plus vector).
PRFW (scalar plus vector): Gather prefetch words (
scalar plus vector).
scalar plus vector): Gather load doublewords to vector (vector index).
scalar plus vector): Gather load first-fault doublewords to vector (vector index).
scalar plus vector): Gather load first-fault signed bytes to vector (vector index).
scalar plus vector): Gather load first-fault signed halfwords to vector (vector index).
scalar plus vector): Gather load first-fault signed words to vector (vector index).
scalar plus vector): Gather load first-fault unsigned bytes to vector (vector index).
scalar plus vector): Gather load first-fault unsigned halfwords to vector (vector index).
scalar plus vector): Gather load first-fault unsigned words to vector (vector index).
scalar plus vector): Gather load signed bytes to vector (vector index).
scalar plus vector): Gather load signed halfwords to vector (vector index).
scalar plus vector): Gather load signed words to vector (vector index).
scalar plus vector): Gather load unsigned bytes to vector (vector index).
scalar plus vector): Gather load unsigned halfwords to vector (vector index).
scalar plus vector): Gather load unsigned words to vector (vector index).
scalar plus vector): Gather prefetch bytes (scalar plus vector).
scalar plus vector): Gather prefetch doublewords (scalar plus vector).
scalar plus vector): Gather prefetch halfwords (scalar plus vector).
scalar plus vector): Gather prefetch words (scalar plus vector).
scalar plus vector): Scatter store bytes from a vector (vector index).
scalar plus vector): Scatter store doublewords from a vector (vector index).
scalar plus vector): Scatter store halfwords from a vector (vector index).
scalar plus vector): Scatter store words from a vector (vector index).
INSR (SIMD&FP scalar): Insert SIMD&FP
scalar register in shifted vector.
CPY (SIMD&FP scalar): Copy SIMD&FP
scalar register to vector elements (predicated).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP
scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
ADDPL: Add multiple of predicate register size to
scalar register.
ADDVL: Add multiple of vector register size to
scalar register.
CLASTA (SIMD&FP scalar): Conditionally extract element after last to SIMD&FP
scalar register.
CLASTB (SIMD&FP scalar): Conditionally extract last element to SIMD&FP
scalar register.
LASTA (SIMD&FP scalar): Extract element after last to SIMD&FP
scalar register.
LASTB (SIMD&FP scalar): Extract last element to SIMD&FP
scalar register.
RDVL: Read multiple of vector register size to
scalar register.
CNTP: Set
scalar to active predicate element count.
scalar to multiple of predicate constraint element count.
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP
scalar to vector (unpredicated): an alias of DUP (indexed).
MOV (scalar, predicated): Move general-purpose register to vector elements (predicated): an alias of CPY (
scalar).
MOV (scalar, unpredicated): Move general-purpose register to vector elements (unpredicated): an alias of DUP (
scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP
scalar).
scalar): Conditionally extract element after last to SIMD&FP scalar register.
scalar): Conditionally extract last element to SIMD&FP scalar register.
scalar): Contiguous load and replicate eight halfwords (scalar index).
scalar): Contiguous load and replicate four words (scalar index).
scalar): Contiguous load and replicate sixteen bytes (scalar index).
scalar): Contiguous load and replicate two doublewords (scalar index).
scalar): Contiguous load doublewords to vector (scalar index).
scalar): Contiguous load first-fault doublewords to vector (scalar index).
scalar): Contiguous load first-fault signed bytes to vector (scalar index).
scalar): Contiguous load first-fault signed halfwords to vector (scalar index).
scalar): Contiguous load first-fault signed words to vector (scalar index).
scalar): Contiguous load first-fault unsigned bytes to vector (scalar index).
scalar): Contiguous load first-fault unsigned halfwords to vector (scalar index).
scalar): Contiguous load first-fault unsigned words to vector (scalar index).
scalar): Contiguous load four-byte structures to four vectors (scalar index).
scalar): Contiguous load four-doubleword structures to four vectors (scalar index).
scalar): Contiguous load four-halfword structures to four vectors (scalar index).
scalar): Contiguous load four-word structures to four vectors (scalar index).
scalar): Contiguous load non-temporal bytes to vector (scalar index).
scalar): Contiguous load non-temporal doublewords to vector (scalar index).
scalar): Contiguous load non-temporal halfwords to vector (scalar index).
scalar): Contiguous load non-temporal words to vector (scalar index).
scalar): Contiguous load signed bytes to vector (scalar index).
scalar): Contiguous load signed halfwords to vector (scalar index).
scalar): Contiguous load signed words to vector (scalar index).
scalar): Contiguous load three-byte structures to three vectors (scalar index).
scalar): Contiguous load three-doubleword structures to three vectors (scalar index).
scalar): Contiguous load three-halfword structures to three vectors (scalar index).
scalar): Contiguous load three-word structures to three vectors (scalar index).
scalar): Contiguous load two-byte structures to two vectors (scalar index).
scalar): Contiguous load two-doubleword structures to two vectors (scalar index).
scalar): Contiguous load two-halfword structures to two vectors (scalar index).
scalar): Contiguous load two-word structures to two vectors (scalar index).
scalar): Contiguous load unsigned bytes to vector (scalar index).
scalar): Contiguous load unsigned halfwords to vector (scalar index).
scalar): Contiguous load unsigned words to vector (scalar index).
scalar): Contiguous prefetch bytes (scalar index).
scalar): Contiguous prefetch doublewords (scalar index).
scalar): Contiguous prefetch halfwords (scalar index).
scalar): Contiguous prefetch words (scalar index).
scalar): Contiguous store bytes from vector (scalar index).
scalar): Contiguous store doublewords from vector (scalar index).
scalar): Contiguous store four-byte structures from four vectors (scalar index).
scalar): Contiguous store four-doubleword structures from four vectors (scalar index).
scalar): Contiguous store four-halfword structures from four vectors (scalar index).
scalar): Contiguous store four-word structures from four vectors (scalar index).
scalar): Contiguous store halfwords from vector (scalar index).
scalar): Contiguous store non-temporal bytes from vector (scalar index).
scalar): Contiguous store non-temporal doublewords from vector (scalar index).
scalar): Contiguous store non-temporal halfwords from vector (scalar index).
scalar): Contiguous store non-temporal words from vector (scalar index).
scalar): Contiguous store three-byte structures from three vectors (scalar index).
scalar): Contiguous store three-doubleword structures from three vectors (scalar index).
scalar): Contiguous store three-halfword structures from three vectors (scalar index).
scalar): Contiguous store three-word structures from three vectors (scalar index).
scalar): Contiguous store two-byte structures from two vectors (scalar index).
scalar): Contiguous store two-doubleword structures from two vectors (scalar index).
scalar): Contiguous store two-halfword structures from two vectors (scalar index).
scalar): Contiguous store two-word structures from two vectors (scalar index).
scalar): Contiguous store words from vector (scalar index).
scalar): Copy SIMD&FP scalar register to vector elements (predicated).
scalar): Create index starting from immediate and incremented by general-purpose register.
scalar): Decrement scalar by multiple of predicate constraint element count.
scalar): Extract element after last to SIMD&FP scalar register.
scalar): Extract last element to SIMD&FP scalar register.
scalar): Increment scalar by multiple of predicate constraint element count.
scalar): Insert SIMD&FP scalar register in shifted vector.
scalar): Signed saturating decrement scalar by multiple of 16-bit predicate constraint element count.
scalar): Signed saturating decrement scalar by multiple of 32-bit predicate constraint element count.
scalar): Signed saturating decrement scalar by multiple of 64-bit predicate constraint element count.
scalar): Signed saturating increment scalar by multiple of 16-bit predicate constraint element count.
scalar): Signed saturating increment scalar by multiple of 32-bit predicate constraint element count.
scalar): Signed saturating increment scalar by multiple of 64-bit predicate constraint element count.
scalar): Unsigned saturating decrement scalar by multiple of 16-bit predicate constraint element count.
scalar): Unsigned saturating decrement scalar by multiple of 32-bit predicate constraint element count.
scalar): Unsigned saturating decrement scalar by multiple of 64-bit predicate constraint element count.
scalar): Unsigned saturating increment scalar by multiple of 16-bit predicate constraint element count.
scalar): Unsigned saturating increment scalar by multiple of 32-bit predicate constraint element count.
scalar): Unsigned saturating increment scalar by multiple of 64-bit predicate constraint element count.
scalar, immediate): Create index starting from general-purpose register and incremented by immediate.
scalar, predicated): Move general-purpose register to vector elements (predicated): an alias of CPY (scalar).
scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
scalar, unpredicated): Move general-purpose register to vector elements (unpredicated): an alias of DUP (scalar).
scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
ANDV: Bitwise AND reduction to
scalar.
EORV: Bitwise XOR reduction to
scalar.
FADDA: Floating-point add strictly-ordered reduction, accumulating in
scalar.
FADDV: Floating-point add recursive reduction to
scalar.
FMAXNMV: Floating-point maximum number recursive reduction to
scalar.
FMAXV: Floating-point maximum recursive reduction to
scalar.
FMINNMV: Floating-point minimum number recursive reduction to
scalar.
FMINV: Floating-point minimum recursive reduction to
scalar.
ORV: Bitwise OR reduction to
scalar.
SADDV: Signed add reduction to
scalar.
SMAXV: Signed maximum reduction to
scalar.
SMINV: Signed minimum reduction to
scalar.
UADDV: Unsigned add reduction to
scalar.
UMAXV: Unsigned maximum reduction to
scalar.
UMINV: Unsigned minimum reduction to
scalar.
WHILELE: While incrementing signed scalar less than or equal to
scalar.
WHILELO: While incrementing unsigned scalar lower than
scalar.
WHILELS: While incrementing unsigned scalar lower or same as
scalar.
WHILELT: While incrementing signed scalar less than
scalar.
Scatter store bytes from a vector (immediate index).
Scatter store bytes from a vector (vector index).
Scatter store doublewords from a vector (immediate index).
Scatter store doublewords from a vector (vector index).
Scatter store halfwords from a vector (immediate index).
Scatter store halfwords from a vector (vector index).
Scatter store words from a vector (immediate index).
Scatter store words from a vector (vector index).
SCVTF: Signed integer convert to floating-point (predicated).
SDIV: Signed divide (predicated).
SDIVR: Signed reversed divide (predicated).
SDOT (indexed): Signed dot product by indexed quadtuplet.
SDOT (vectors): Signed dot product.
MOV (predicate, predicated, merging): Move predicates (merging): an alias of
SEL (predicates).
SEL (predicates): Conditionally select elements from two predicates.
MOV (vector, predicated): Move vector elements (predicated): an alias of
SEL (vectors).
SEL (vectors): Conditionally select elements from two vectors.
FTSSEL: Floating-point trigonometric
select coefficient.
SEL (predicates): Conditionally
select elements from two predicates.
SEL (vectors): Conditionally
select elements from two vectors.
Set all predicate elements to false.
Set condition flags for predicate.
CNTP:
Set scalar to active predicate element count.
Set scalar to multiple of predicate constraint element count.
Set the first active predicate element to true.
SETFFR: Initialise the first-fault register to all true.
LSL (wide elements, predicated): Logical
shift left by 64-bit wide elements (predicated).
LSL (wide elements, unpredicated): Logical
shift left by 64-bit wide elements (unpredicated).
LSL (immediate, predicated): Logical
shift left by immediate (predicated).
LSL (immediate, unpredicated): Logical
shift left by immediate (unpredicated).
LSL (vectors): Logical
shift left by vector (predicated).
LSLR: Reversed logical
shift left by vector (predicated).
ASR (wide elements, predicated): Arithmetic
shift right by 64-bit wide elements (predicated).
LSR (wide elements, predicated): Logical
shift right by 64-bit wide elements (predicated).
ASR (wide elements, unpredicated): Arithmetic
shift right by 64-bit wide elements (unpredicated).
LSR (wide elements, unpredicated): Logical
shift right by 64-bit wide elements (unpredicated).
ASR (immediate, predicated): Arithmetic
shift right by immediate (predicated).
LSR (immediate, predicated): Logical
shift right by immediate (predicated).
ASR (immediate, unpredicated): Arithmetic
shift right by immediate (unpredicated).
LSR (immediate, unpredicated): Logical
shift right by immediate (unpredicated).
ASR (vectors): Arithmetic
shift right by vector (predicated).
ASRR: Reversed arithmetic
shift right by vector (predicated).
LSR (vectors): Logical
shift right by vector (predicated).
LSRR: Reversed logical
shift right by vector (predicated).
ASRD: Arithmetic
shift right for divide by immediate (predicated).
INSR (scalar): Insert general-purpose register in
shifted vector.
INSR (SIMD&FP scalar): Insert SIMD&FP scalar register in
shifted vector.
Shuffle active elements of vector to the right and fill with zero.
CLS: Count leading
sign bits (predicated).
SABD:
Signed absolute difference (predicated).
Signed add reduction to scalar.
Signed byte / halfword / word extend (predicated).
LD1RSB: Load and broadcast
signed byte to vector.
LD1SB (scalar plus immediate): Contiguous load
signed bytes to vector (immediate index).
LD1SB (vector plus immediate): Gather load
signed bytes to vector (immediate index).
LDFF1SB (vector plus immediate): Gather load first-fault
signed bytes to vector (immediate index).
LDNF1SB: Contiguous load non-fault
signed bytes to vector (immediate index).
LD1SB (scalar plus scalar): Contiguous load
signed bytes to vector (scalar index).
LDFF1SB (scalar plus scalar): Contiguous load first-fault
signed bytes to vector (scalar index).
LD1SB (scalar plus vector): Gather load
signed bytes to vector (vector index).
LDFF1SB (scalar plus vector): Gather load first-fault
signed bytes to vector (vector index).
SDIV:
Signed divide (predicated).
Signed dot product by indexed quadtuplet.
Signed dot product.
LD1RSH: Load and broadcast
signed halfword to vector.
LD1SH (scalar plus immediate): Contiguous load
signed halfwords to vector (immediate index).
LD1SH (vector plus immediate): Gather load
signed halfwords to vector (immediate index).
LDFF1SH (vector plus immediate): Gather load first-fault
signed halfwords to vector (immediate index).
LDNF1SH: Contiguous load non-fault
signed halfwords to vector (immediate index).
LD1SH (scalar plus scalar): Contiguous load
signed halfwords to vector (scalar index).
LDFF1SH (scalar plus scalar): Contiguous load first-fault
signed halfwords to vector (scalar index).
LD1SH (scalar plus vector): Gather load
signed halfwords to vector (vector index).
LDFF1SH (scalar plus vector): Gather load first-fault
signed halfwords to vector (vector index).
DUP (immediate): Broadcast
signed immediate to vector elements (unpredicated).
signed immediate to vector elements (unpredicated): an alias of DUP (immediate).
Signed integer convert to floating-point (predicated).
CPY (immediate): Copy
signed integer immediate to vector elements (predicated).
signed integer immediate to vector elements (predicated): an alias of CPY (immediate).
FCVTZS: Floating-point convert to
signed integer, rounding toward zero (predicated).
CMPLE (vectors): Compare
signed less than or equal to vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLT (vectors): Compare
signed less than vector, setting the condition flags: an alias of CMP<cc> (vectors).
Signed maximum reduction to scalar.
Signed maximum vectors (predicated).
Signed maximum with immediate (unpredicated).
Signed minimum reduction to scalar.
Signed minimum vectors (predicated).
Signed minimum with immediate (unpredicated).
Signed multiply returning high half (predicated).
Signed reversed divide (predicated).
Signed saturating add immediate (unpredicated).
Signed saturating add vectors (unpredicated).
Signed saturating decrement scalar by active predicate element count.
Signed saturating decrement scalar by multiple of 16-bit predicate constraint element count.
Signed saturating decrement scalar by multiple of 32-bit predicate constraint element count.
Signed saturating decrement scalar by multiple of 64-bit predicate constraint element count.
Signed saturating decrement scalar by multiple of 8-bit predicate constraint element count.
Signed saturating decrement vector by active predicate element count.
Signed saturating decrement vector by multiple of 16-bit predicate constraint element count.
Signed saturating decrement vector by multiple of 32-bit predicate constraint element count.
Signed saturating decrement vector by multiple of 64-bit predicate constraint element count.
Signed saturating increment scalar by active predicate element count.
Signed saturating increment scalar by multiple of 16-bit predicate constraint element count.
Signed saturating increment scalar by multiple of 32-bit predicate constraint element count.
Signed saturating increment scalar by multiple of 64-bit predicate constraint element count.
Signed saturating increment scalar by multiple of 8-bit predicate constraint element count.
Signed saturating increment vector by active predicate element count.
Signed saturating increment vector by multiple of 16-bit predicate constraint element count.
Signed saturating increment vector by multiple of 32-bit predicate constraint element count.
Signed saturating increment vector by multiple of 64-bit predicate constraint element count.
Signed saturating subtract immediate (unpredicated).
Signed saturating subtract vectors (unpredicated).
WHILELE: While incrementing
signed scalar less than or equal to scalar.
WHILELT: While incrementing
signed scalar less than scalar.
Signed unpack and extend half of vector.
LD1RSW: Load and broadcast
signed word to vector.
LD1SW (scalar plus immediate): Contiguous load
signed words to vector (immediate index).
LD1SW (vector plus immediate): Gather load
signed words to vector (immediate index).
LDFF1SW (vector plus immediate): Gather load first-fault
signed words to vector (immediate index).
LDNF1SW: Contiguous load non-fault
signed words to vector (immediate index).
LD1SW (scalar plus scalar): Contiguous load
signed words to vector (scalar index).
LDFF1SW (scalar plus scalar): Contiguous load first-fault
signed words to vector (scalar index).
LD1SW (scalar plus vector): Gather load
signed words to vector (vector index).
LDFF1SW (scalar plus vector): Gather load first-fault
signed words to vector (vector index).
INSR (SIMD&FP scalar): Insert
SIMD&FP scalar register in shifted vector.
CPY (SIMD&FP scalar): Copy
SIMD&FP scalar register to vector elements (predicated).
SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
CLASTA (SIMD&FP scalar): Conditionally extract element after last to
SIMD&FP scalar register.
CLASTB (SIMD&FP scalar): Conditionally extract last element to
SIMD&FP scalar register.
LASTA (SIMD&FP scalar): Extract element after last to
SIMD&FP scalar register.
LASTB (SIMD&FP scalar): Extract last element to
SIMD&FP scalar register.
MOV (SIMD&FP scalar, unpredicated): Move indexed element or
SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (
SIMD&FP scalar).
SIMD&FP scalar): Conditionally extract element after last to SIMD&FP scalar register.
SIMD&FP scalar): Conditionally extract last element to SIMD&FP scalar register.
SIMD&FP scalar): Copy SIMD&FP scalar register to vector elements (predicated).
SIMD&FP scalar): Extract element after last to SIMD&FP scalar register.
SIMD&FP scalar): Extract last element to SIMD&FP scalar register.
SIMD&FP scalar): Insert SIMD&FP scalar register in shifted vector.
SIMD&FP scalar, predicated): Move SIMD&FP scalar register to vector elements (predicated): an alias of CPY (SIMD&FP scalar).
SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
TBL: Programmable table lookup in
single vector table.
LD1RQB (scalar plus immediate): Contiguous load and replicate
sixteen bytes (immediate index).
LD1RQB (scalar plus scalar): Contiguous load and replicate
sixteen bytes (scalar index).
ADDPL: Add multiple of predicate register
size to scalar register.
ADDVL: Add multiple of vector register
size to scalar register.
RDVL: Read multiple of vector register
size to scalar register.
SMAX (immediate): Signed maximum with immediate (unpredicated).
SMAX (vectors): Signed maximum vectors (predicated).
SMAXV: Signed maximum reduction to scalar.
SMIN (immediate): Signed minimum with immediate (unpredicated).
SMIN (vectors): Signed minimum vectors (predicated).
SMINV: Signed minimum reduction to scalar.
SMULH: Signed multiply returning high half (predicated).
Splice two vectors under predicate control.
SPLICE: Splice two vectors under predicate control.
SQADD (immediate): Signed saturating add immediate (unpredicated).
SQADD (vectors): Signed saturating add vectors (unpredicated).
SQDECB: Signed saturating decrement scalar by multiple of 8-bit predicate constraint element count.
SQDECD (scalar): Signed saturating decrement scalar by multiple of 64-bit predicate constraint element count.
SQDECD (vector): Signed saturating decrement vector by multiple of 64-bit predicate constraint element count.
SQDECH (scalar): Signed saturating decrement scalar by multiple of 16-bit predicate constraint element count.
SQDECH (vector): Signed saturating decrement vector by multiple of 16-bit predicate constraint element count.
SQDECP (scalar): Signed saturating decrement scalar by active predicate element count.
SQDECP (vector): Signed saturating decrement vector by active predicate element count.
SQDECW (scalar): Signed saturating decrement scalar by multiple of 32-bit predicate constraint element count.
SQDECW (vector): Signed saturating decrement vector by multiple of 32-bit predicate constraint element count.
SQINCB: Signed saturating increment scalar by multiple of 8-bit predicate constraint element count.
SQINCD (scalar): Signed saturating increment scalar by multiple of 64-bit predicate constraint element count.
SQINCD (vector): Signed saturating increment vector by multiple of 64-bit predicate constraint element count.
SQINCH (scalar): Signed saturating increment scalar by multiple of 16-bit predicate constraint element count.
SQINCH (vector): Signed saturating increment vector by multiple of 16-bit predicate constraint element count.
SQINCP (scalar): Signed saturating increment scalar by active predicate element count.
SQINCP (vector): Signed saturating increment vector by active predicate element count.
SQINCW (scalar): Signed saturating increment scalar by multiple of 32-bit predicate constraint element count.
SQINCW (vector): Signed saturating increment vector by multiple of 32-bit predicate constraint element count.
SQSUB (immediate): Signed saturating subtract immediate (unpredicated).
SQSUB (vectors): Signed saturating subtract vectors (unpredicated).
FSQRT: Floating-point
square root (predicated).
FRSQRTE: Floating-point reciprocal
square root estimate (unpredicated).
FRSQRTS: Floating-point reciprocal
square root step (unpredicated).
ST1B (scalar plus immediate): Contiguous store bytes from vector (immediate index).
ST1B (scalar plus scalar): Contiguous store bytes from vector (scalar index).
ST1B (scalar plus vector): Scatter store bytes from a vector (vector index).
ST1B (vector plus immediate): Scatter store bytes from a vector (immediate index).
ST1D (scalar plus immediate): Contiguous store doublewords from vector (immediate index).
ST1D (scalar plus scalar): Contiguous store doublewords from vector (scalar index).
ST1D (scalar plus vector): Scatter store doublewords from a vector (vector index).
ST1D (vector plus immediate): Scatter store doublewords from a vector (immediate index).
ST1H (scalar plus immediate): Contiguous store halfwords from vector (immediate index).
ST1H (scalar plus scalar): Contiguous store halfwords from vector (scalar index).
ST1H (scalar plus vector): Scatter store halfwords from a vector (vector index).
ST1H (vector plus immediate): Scatter store halfwords from a vector (immediate index).
ST1W (scalar plus immediate): Contiguous store words from vector (immediate index).
ST1W (scalar plus scalar): Contiguous store words from vector (scalar index).
ST1W (scalar plus vector): Scatter store words from a vector (vector index).
ST1W (vector plus immediate): Scatter store words from a vector (immediate index).
ST2B (scalar plus immediate): Contiguous store two-byte structures from two vectors (immediate index).
ST2B (scalar plus scalar): Contiguous store two-byte structures from two vectors (scalar index).
ST2D (scalar plus immediate): Contiguous store two-doubleword structures from two vectors (immediate index).
ST2D (scalar plus scalar): Contiguous store two-doubleword structures from two vectors (scalar index).
ST2H (scalar plus immediate): Contiguous store two-halfword structures from two vectors (immediate index).
ST2H (scalar plus scalar): Contiguous store two-halfword structures from two vectors (scalar index).
ST2W (scalar plus immediate): Contiguous store two-word structures from two vectors (immediate index).
ST2W (scalar plus scalar): Contiguous store two-word structures from two vectors (scalar index).
ST3B (scalar plus immediate): Contiguous store three-byte structures from three vectors (immediate index).
ST3B (scalar plus scalar): Contiguous store three-byte structures from three vectors (scalar index).
ST3D (scalar plus immediate): Contiguous store three-doubleword structures from three vectors (immediate index).
ST3D (scalar plus scalar): Contiguous store three-doubleword structures from three vectors (scalar index).
ST3H (scalar plus immediate): Contiguous store three-halfword structures from three vectors (immediate index).
ST3H (scalar plus scalar): Contiguous store three-halfword structures from three vectors (scalar index).
ST3W (scalar plus immediate): Contiguous store three-word structures from three vectors (immediate index).
ST3W (scalar plus scalar): Contiguous store three-word structures from three vectors (scalar index).
ST4B (scalar plus immediate): Contiguous store four-byte structures from four vectors (immediate index).
ST4B (scalar plus scalar): Contiguous store four-byte structures from four vectors (scalar index).
ST4D (scalar plus immediate): Contiguous store four-doubleword structures from four vectors (immediate index).
ST4D (scalar plus scalar): Contiguous store four-doubleword structures from four vectors (scalar index).
ST4H (scalar plus immediate): Contiguous store four-halfword structures from four vectors (immediate index).
ST4H (scalar plus scalar): Contiguous store four-halfword structures from four vectors (scalar index).
ST4W (scalar plus immediate): Contiguous store four-word structures from four vectors (immediate index).
ST4W (scalar plus scalar): Contiguous store four-word structures from four vectors (scalar index).
INDEX (scalars): Create index
starting from and incremented by general-purpose register.
INDEX (immediates): Create index
starting from and incremented by immediate.
INDEX (scalar, immediate): Create index
starting from general-purpose register and incremented by immediate.
INDEX (immediate, scalar): Create index
starting from immediate and incremented by general-purpose register.
FTSMUL: Floating-point trigonometric
starting value.
FRECPS: Floating-point reciprocal
step (unpredicated).
FRSQRTS: Floating-point reciprocal square root
step (unpredicated).
STNT1B (scalar plus immediate): Contiguous store non-temporal bytes from vector (immediate index).
STNT1B (scalar plus scalar): Contiguous store non-temporal bytes from vector (scalar index).
STNT1D (scalar plus immediate): Contiguous store non-temporal doublewords from vector (immediate index).
STNT1D (scalar plus scalar): Contiguous store non-temporal doublewords from vector (scalar index).
STNT1H (scalar plus immediate): Contiguous store non-temporal halfwords from vector (immediate index).
STNT1H (scalar plus scalar): Contiguous store non-temporal halfwords from vector (scalar index).
STNT1W (scalar plus immediate): Contiguous store non-temporal words from vector (immediate index).
STNT1W (scalar plus scalar): Contiguous store non-temporal words from vector (scalar index).
ST1B (vector plus immediate): Scatter
store bytes from a vector (immediate index).
ST1B (scalar plus vector): Scatter
store bytes from a vector (vector index).
ST1B (scalar plus immediate): Contiguous
store bytes from vector (immediate index).
ST1B (scalar plus scalar): Contiguous
store bytes from vector (scalar index).
ST1D (vector plus immediate): Scatter
store doublewords from a vector (immediate index).
ST1D (scalar plus vector): Scatter
store doublewords from a vector (vector index).
ST1D (scalar plus immediate): Contiguous
store doublewords from vector (immediate index).
ST1D (scalar plus scalar): Contiguous
store doublewords from vector (scalar index).
ST4B (scalar plus immediate): Contiguous
store four-byte structures from four vectors (immediate index).
ST4B (scalar plus scalar): Contiguous
store four-byte structures from four vectors (scalar index).
ST4D (scalar plus immediate): Contiguous
store four-doubleword structures from four vectors (immediate index).
ST4D (scalar plus scalar): Contiguous
store four-doubleword structures from four vectors (scalar index).
ST4H (scalar plus immediate): Contiguous
store four-halfword structures from four vectors (immediate index).
ST4H (scalar plus scalar): Contiguous
store four-halfword structures from four vectors (scalar index).
ST4W (scalar plus immediate): Contiguous
store four-word structures from four vectors (immediate index).
ST4W (scalar plus scalar): Contiguous
store four-word structures from four vectors (scalar index).
ST1H (vector plus immediate): Scatter
store halfwords from a vector (immediate index).
ST1H (scalar plus vector): Scatter
store halfwords from a vector (vector index).
ST1H (scalar plus immediate): Contiguous
store halfwords from vector (immediate index).
ST1H (scalar plus scalar): Contiguous
store halfwords from vector (scalar index).
STNT1B (scalar plus immediate): Contiguous
store non-temporal bytes from vector (immediate index).
STNT1B (scalar plus scalar): Contiguous
store non-temporal bytes from vector (scalar index).
STNT1D (scalar plus immediate): Contiguous
store non-temporal doublewords from vector (immediate index).
STNT1D (scalar plus scalar): Contiguous
store non-temporal doublewords from vector (scalar index).
STNT1H (scalar plus immediate): Contiguous
store non-temporal halfwords from vector (immediate index).
STNT1H (scalar plus scalar): Contiguous
store non-temporal halfwords from vector (scalar index).
STNT1W (scalar plus immediate): Contiguous
store non-temporal words from vector (immediate index).
STNT1W (scalar plus scalar): Contiguous
store non-temporal words from vector (scalar index).
Store predicate register.
ST3B (scalar plus immediate): Contiguous
store three-byte structures from three vectors (immediate index).
ST3B (scalar plus scalar): Contiguous
store three-byte structures from three vectors (scalar index).
ST3D (scalar plus immediate): Contiguous
store three-doubleword structures from three vectors (immediate index).
ST3D (scalar plus scalar): Contiguous
store three-doubleword structures from three vectors (scalar index).
ST3H (scalar plus immediate): Contiguous
store three-halfword structures from three vectors (immediate index).
ST3H (scalar plus scalar): Contiguous
store three-halfword structures from three vectors (scalar index).
ST3W (scalar plus immediate): Contiguous
store three-word structures from three vectors (immediate index).
ST3W (scalar plus scalar): Contiguous
store three-word structures from three vectors (scalar index).
ST2B (scalar plus immediate): Contiguous
store two-byte structures from two vectors (immediate index).
ST2B (scalar plus scalar): Contiguous
store two-byte structures from two vectors (scalar index).
ST2D (scalar plus immediate): Contiguous
store two-doubleword structures from two vectors (immediate index).
ST2D (scalar plus scalar): Contiguous
store two-doubleword structures from two vectors (scalar index).
ST2H (scalar plus immediate): Contiguous
store two-halfword structures from two vectors (immediate index).
ST2H (scalar plus scalar): Contiguous
store two-halfword structures from two vectors (scalar index).
ST2W (scalar plus immediate): Contiguous
store two-word structures from two vectors (immediate index).
ST2W (scalar plus scalar): Contiguous
store two-word structures from two vectors (scalar index).
Store vector register.
ST1W (vector plus immediate): Scatter
store words from a vector (immediate index).
ST1W (scalar plus vector): Scatter
store words from a vector (vector index).
ST1W (scalar plus immediate): Contiguous
store words from vector (immediate index).
ST1W (scalar plus scalar): Contiguous
store words from vector (scalar index).
STR (predicate): Store predicate register.
STR (vector): Store vector register.
FADDA: Floating-point add
strictly-ordered reduction, accumulating in scalar.
ST4B (scalar plus immediate): Contiguous store four-byte
structures from four vectors (immediate index).
ST4D (scalar plus immediate): Contiguous store four-doubleword
structures from four vectors (immediate index).
ST4H (scalar plus immediate): Contiguous store four-halfword
structures from four vectors (immediate index).
ST4W (scalar plus immediate): Contiguous store four-word
structures from four vectors (immediate index).
ST4B (scalar plus scalar): Contiguous store four-byte
structures from four vectors (scalar index).
ST4D (scalar plus scalar): Contiguous store four-doubleword
structures from four vectors (scalar index).
ST4H (scalar plus scalar): Contiguous store four-halfword
structures from four vectors (scalar index).
ST4W (scalar plus scalar): Contiguous store four-word
structures from four vectors (scalar index).
ST3B (scalar plus immediate): Contiguous store three-byte
structures from three vectors (immediate index).
ST3D (scalar plus immediate): Contiguous store three-doubleword
structures from three vectors (immediate index).
ST3H (scalar plus immediate): Contiguous store three-halfword
structures from three vectors (immediate index).
ST3W (scalar plus immediate): Contiguous store three-word
structures from three vectors (immediate index).
ST3B (scalar plus scalar): Contiguous store three-byte
structures from three vectors (scalar index).
ST3D (scalar plus scalar): Contiguous store three-doubleword
structures from three vectors (scalar index).
ST3H (scalar plus scalar): Contiguous store three-halfword
structures from three vectors (scalar index).
ST3W (scalar plus scalar): Contiguous store three-word
structures from three vectors (scalar index).
ST2B (scalar plus immediate): Contiguous store two-byte
structures from two vectors (immediate index).
ST2D (scalar plus immediate): Contiguous store two-doubleword
structures from two vectors (immediate index).
ST2H (scalar plus immediate): Contiguous store two-halfword
structures from two vectors (immediate index).
ST2W (scalar plus immediate): Contiguous store two-word
structures from two vectors (immediate index).
ST2B (scalar plus scalar): Contiguous store two-byte
structures from two vectors (scalar index).
ST2D (scalar plus scalar): Contiguous store two-doubleword
structures from two vectors (scalar index).
ST2H (scalar plus scalar): Contiguous store two-halfword
structures from two vectors (scalar index).
ST2W (scalar plus scalar): Contiguous store two-word
structures from two vectors (scalar index).
LD4B (scalar plus immediate): Contiguous load four-byte
structures to four vectors (immediate index).
LD4D (scalar plus immediate): Contiguous load four-doubleword
structures to four vectors (immediate index).
LD4H (scalar plus immediate): Contiguous load four-halfword
structures to four vectors (immediate index).
LD4W (scalar plus immediate): Contiguous load four-word
structures to four vectors (immediate index).
LD4B (scalar plus scalar): Contiguous load four-byte
structures to four vectors (scalar index).
LD4D (scalar plus scalar): Contiguous load four-doubleword
structures to four vectors (scalar index).
LD4H (scalar plus scalar): Contiguous load four-halfword
structures to four vectors (scalar index).
LD4W (scalar plus scalar): Contiguous load four-word
structures to four vectors (scalar index).
LD3B (scalar plus immediate): Contiguous load three-byte
structures to three vectors (immediate index).
LD3D (scalar plus immediate): Contiguous load three-doubleword
structures to three vectors (immediate index).
LD3H (scalar plus immediate): Contiguous load three-halfword
structures to three vectors (immediate index).
LD3W (scalar plus immediate): Contiguous load three-word
structures to three vectors (immediate index).
LD3B (scalar plus scalar): Contiguous load three-byte
structures to three vectors (scalar index).
LD3D (scalar plus scalar): Contiguous load three-doubleword
structures to three vectors (scalar index).
LD3H (scalar plus scalar): Contiguous load three-halfword
structures to three vectors (scalar index).
LD3W (scalar plus scalar): Contiguous load three-word
structures to three vectors (scalar index).
LD2B (scalar plus immediate): Contiguous load two-byte
structures to two vectors (immediate index).
LD2D (scalar plus immediate): Contiguous load two-doubleword
structures to two vectors (immediate index).
LD2H (scalar plus immediate): Contiguous load two-halfword
structures to two vectors (immediate index).
LD2W (scalar plus immediate): Contiguous load two-word
structures to two vectors (immediate index).
LD2B (scalar plus scalar): Contiguous load two-byte
structures to two vectors (scalar index).
LD2D (scalar plus scalar): Contiguous load two-doubleword
structures to two vectors (scalar index).
LD2H (scalar plus scalar): Contiguous load two-halfword
structures to two vectors (scalar index).
LD2W (scalar plus scalar): Contiguous load two-word
structures to two vectors (scalar index).
SUB (immediate): Subtract immediate (unpredicated).
SUB (vectors, predicated): Subtract vectors (predicated).
SUB (vectors, unpredicated): Subtract vectors (unpredicated).
SUBR (immediate): Reversed subtract from immediate (unpredicated).
SUBR (vectors): Reversed subtract vectors (predicated).
FMLS (indexed): Floating-point fused multiply-
subtract by indexed elements (Zda = Zda + -Zn * Zm[indexed]).
FSUBR (immediate): Floating-point reversed
subtract from immediate (predicated).
SUBR (immediate): Reversed
subtract from immediate (unpredicated).
FSUB (immediate): Floating-point
subtract immediate (predicated).
SQSUB (immediate): Signed saturating
subtract immediate (unpredicated).
Subtract immediate (unpredicated).
UQSUB (immediate): Unsigned saturating
subtract immediate (unpredicated).
FNMLS: Floating-point negated fused multiply-
subtract vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point fused multiply-
subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
MLS: Multiply-
subtract vectors (predicated), writing addend [Zda = Zda - Zn * Zm].
FNMSB: Floating-point negated fused multiply-
subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused multiply-
subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
MSB: Multiply-
subtract vectors (predicated), writing multiplicand [Zdn = Za - Zdn * Zm].
FSUB (vectors, predicated): Floating-point
subtract vectors (predicated).
FSUBR (vectors): Floating-point reversed
subtract vectors (predicated).
Subtract vectors (predicated).
SUBR (vectors): Reversed
subtract vectors (predicated).
FSUB (vectors, unpredicated): Floating-point
subtract vectors (unpredicated).
SQSUB (vectors): Signed saturating
subtract vectors (unpredicated).
Subtract vectors (unpredicated).
UQSUB (vectors): Unsigned saturating
subtract vectors (unpredicated).
RDFFR, RDFFRS (predicated): Return predicate of
succesfully loaded elements.
SUNPKHI, SUNPKLO: Signed unpack and extend half of vector.
SXTB, SXTH, SXTW: Signed byte / halfword / word extend (predicated).
SXTH, SXTW: Signed byte / halfword / word extend (predicated).
SXTW: Signed byte / halfword / word extend (predicated).
TBL: Programmable
TBL: Programmable table lookup in single vector
table.
TBL: Programmable table lookup in single vector table.
STNT1B (scalar plus immediate): Contiguous store non-
temporal bytes from vector (immediate index).
STNT1B (scalar plus scalar): Contiguous store non-
temporal bytes from vector (scalar index).
LDNT1B (scalar plus immediate): Contiguous load non-
temporal bytes to vector (immediate index).
LDNT1B (scalar plus scalar): Contiguous load non-
temporal bytes to vector (scalar index).
STNT1D (scalar plus immediate): Contiguous store non-
temporal doublewords from vector (immediate index).
STNT1D (scalar plus scalar): Contiguous store non-
temporal doublewords from vector (scalar index).
LDNT1D (scalar plus immediate): Contiguous load non-
temporal doublewords to vector (immediate index).
LDNT1D (scalar plus scalar): Contiguous load non-
temporal doublewords to vector (scalar index).
STNT1H (scalar plus immediate): Contiguous store non-
temporal halfwords from vector (immediate index).
STNT1H (scalar plus scalar): Contiguous store non-
temporal halfwords from vector (scalar index).
LDNT1H (scalar plus immediate): Contiguous load non-
temporal halfwords to vector (immediate index).
LDNT1H (scalar plus scalar): Contiguous load non-
temporal halfwords to vector (scalar index).
STNT1W (scalar plus immediate): Contiguous store non-
temporal words from vector (immediate index).
STNT1W (scalar plus scalar): Contiguous store non-
temporal words from vector (scalar index).
LDNT1W (scalar plus immediate): Contiguous load non-
temporal words to vector (immediate index).
LDNT1W (scalar plus scalar): Contiguous load non-
temporal words to vector (scalar index).
CTERMEQ, CTERMNE: Compare and
terminate loop.
LD3B (scalar plus immediate): Contiguous load three-byte structures to
three vectors (immediate index).
LD3D (scalar plus immediate): Contiguous load three-doubleword structures to
three vectors (immediate index).
LD3H (scalar plus immediate): Contiguous load three-halfword structures to
three vectors (immediate index).
LD3W (scalar plus immediate): Contiguous load three-word structures to
three vectors (immediate index).
ST3B (scalar plus immediate): Contiguous store three-byte structures from
three vectors (immediate index).
ST3D (scalar plus immediate): Contiguous store three-doubleword structures from
three vectors (immediate index).
ST3H (scalar plus immediate): Contiguous store three-halfword structures from
three vectors (immediate index).
ST3W (scalar plus immediate): Contiguous store three-word structures from
three vectors (immediate index).
LD3B (scalar plus scalar): Contiguous load three-byte structures to
three vectors (scalar index).
LD3D (scalar plus scalar): Contiguous load three-doubleword structures to
three vectors (scalar index).
LD3H (scalar plus scalar): Contiguous load three-halfword structures to
three vectors (scalar index).
LD3W (scalar plus scalar): Contiguous load three-word structures to
three vectors (scalar index).
ST3B (scalar plus scalar): Contiguous store three-byte structures from
three vectors (scalar index).
ST3D (scalar plus scalar): Contiguous store three-doubleword structures from
three vectors (scalar index).
ST3H (scalar plus scalar): Contiguous store three-halfword structures from
three vectors (scalar index).
ST3W (scalar plus scalar): Contiguous store three-word structures from
three vectors (scalar index).
ST3B (scalar plus immediate): Contiguous store
three-byte structures from three vectors (immediate index).
ST3B (scalar plus scalar): Contiguous store
three-byte structures from three vectors (scalar index).
LD3B (scalar plus immediate): Contiguous load
three-byte structures to three vectors (immediate index).
LD3B (scalar plus scalar): Contiguous load
three-byte structures to three vectors (scalar index).
ST3D (scalar plus immediate): Contiguous store
three-doubleword structures from three vectors (immediate index).
ST3D (scalar plus scalar): Contiguous store
three-doubleword structures from three vectors (scalar index).
LD3D (scalar plus immediate): Contiguous load
three-doubleword structures to three vectors (immediate index).
LD3D (scalar plus scalar): Contiguous load
three-doubleword structures to three vectors (scalar index).
ST3H (scalar plus immediate): Contiguous store
three-halfword structures from three vectors (immediate index).
ST3H (scalar plus scalar): Contiguous store
three-halfword structures from three vectors (scalar index).
LD3H (scalar plus immediate): Contiguous load
three-halfword structures to three vectors (immediate index).
LD3H (scalar plus scalar): Contiguous load
three-halfword structures to three vectors (scalar index).
ST3W (scalar plus immediate): Contiguous store
three-word structures from three vectors (immediate index).
ST3W (scalar plus scalar): Contiguous store
three-word structures from three vectors (scalar index).
LD3W (scalar plus immediate): Contiguous load
three-word structures to three vectors (immediate index).
LD3W (scalar plus scalar): Contiguous load
three-word structures to three vectors (scalar index).
FCVTZS: Floating-point convert to signed integer, rounding
toward zero (predicated).
FCVTZU: Floating-point convert to unsigned integer, rounding
toward zero (predicated).
FTMAD: Floating-point
trigonometric multiply-add coefficient.
FTSSEL: Floating-point
trigonometric select coefficient.
FTSMUL: Floating-point
trigonometric starting value.
TRN1, TRN2 (predicates): Interleave even or odd elements from two predicates.
TRN1, TRN2 (vectors): Interleave even or odd elements from two vectors.
TRN2 (predicates): Interleave even or odd elements from two predicates.
TRN2 (vectors): Interleave even or odd elements from two vectors.
BRKPA, BRKPAS: Break after first
true condition, propagating from previous partition.
BRKPB, BRKPBS: Break before first
true condition, propagating from previous partition.
BRKA, BRKAS: Break after first
true condition.
BRKB, BRKBS: Break before first
true condition.
PFIRST: Set the first active predicate element to
true.
SETFFR: Initialise the first-fault register to all
true.
LD1RQD (scalar plus immediate): Contiguous load and replicate
two doublewords (immediate index).
LD1RQD (scalar plus scalar): Contiguous load and replicate
two doublewords (scalar index).
ZIP1, ZIP2 (predicates): Interleave elements from
two half predicates.
ZIP1, ZIP2 (vectors): Interleave elements from
two half vectors.
SEL (predicates): Conditionally select elements from
two predicates.
TRN1, TRN2 (predicates): Interleave even or odd elements from
two predicates.
UZP1, UZP2 (predicates): Concatenate even or odd elements from
two predicates.
LD2B (scalar plus immediate): Contiguous load two-byte structures to
two vectors (immediate index).
LD2D (scalar plus immediate): Contiguous load two-doubleword structures to
two vectors (immediate index).
LD2H (scalar plus immediate): Contiguous load two-halfword structures to
two vectors (immediate index).
LD2W (scalar plus immediate): Contiguous load two-word structures to
two vectors (immediate index).
ST2B (scalar plus immediate): Contiguous store two-byte structures from
two vectors (immediate index).
ST2D (scalar plus immediate): Contiguous store two-doubleword structures from
two vectors (immediate index).
ST2H (scalar plus immediate): Contiguous store two-halfword structures from
two vectors (immediate index).
ST2W (scalar plus immediate): Contiguous store two-word structures from
two vectors (immediate index).
LD2B (scalar plus scalar): Contiguous load two-byte structures to
two vectors (scalar index).
LD2D (scalar plus scalar): Contiguous load two-doubleword structures to
two vectors (scalar index).
LD2H (scalar plus scalar): Contiguous load two-halfword structures to
two vectors (scalar index).
LD2W (scalar plus scalar): Contiguous load two-word structures to
two vectors (scalar index).
ST2B (scalar plus scalar): Contiguous store two-byte structures from
two vectors (scalar index).
ST2D (scalar plus scalar): Contiguous store two-doubleword structures from
two vectors (scalar index).
ST2H (scalar plus scalar): Contiguous store two-halfword structures from
two vectors (scalar index).
ST2W (scalar plus scalar): Contiguous store two-word structures from
two vectors (scalar index).
SPLICE: Splice
two vectors under predicate control.
SEL (vectors): Conditionally select elements from
two vectors.
TRN1, TRN2 (vectors): Interleave even or odd elements from
two vectors.
UZP1, UZP2 (vectors): Concatenate even or odd elements from
two vectors.
ST2B (scalar plus immediate): Contiguous store
two-byte structures from two vectors (immediate index).
ST2B (scalar plus scalar): Contiguous store
two-byte structures from two vectors (scalar index).
LD2B (scalar plus immediate): Contiguous load
two-byte structures to two vectors (immediate index).
LD2B (scalar plus scalar): Contiguous load
two-byte structures to two vectors (scalar index).
ST2D (scalar plus immediate): Contiguous store
two-doubleword structures from two vectors (immediate index).
ST2D (scalar plus scalar): Contiguous store
two-doubleword structures from two vectors (scalar index).
LD2D (scalar plus immediate): Contiguous load
two-doubleword structures to two vectors (immediate index).
LD2D (scalar plus scalar): Contiguous load
two-doubleword structures to two vectors (scalar index).
ST2H (scalar plus immediate): Contiguous store
two-halfword structures from two vectors (immediate index).
ST2H (scalar plus scalar): Contiguous store
two-halfword structures from two vectors (scalar index).
LD2H (scalar plus immediate): Contiguous load
two-halfword structures to two vectors (immediate index).
LD2H (scalar plus scalar): Contiguous load
two-halfword structures to two vectors (scalar index).
ST2W (scalar plus immediate): Contiguous store
two-word structures from two vectors (immediate index).
ST2W (scalar plus scalar): Contiguous store
two-word structures from two vectors (scalar index).
LD2W (scalar plus immediate): Contiguous load
two-word structures to two vectors (immediate index).
LD2W (scalar plus scalar): Contiguous load
two-word structures to two vectors (scalar index).
UADDV: Unsigned add reduction to scalar.
UCVTF: Unsigned integer convert to floating-point (predicated).
UDIV: Unsigned divide (predicated).
UDIVR: Unsigned reversed divide (predicated).
UDOT (indexed): Unsigned dot product by indexed quadtuplet.
UDOT (vectors): Unsigned dot product.
UMAX (immediate): Unsigned maximum with immediate (unpredicated).
UMAX (vectors): Unsigned maximum vectors (predicated).
UMAXV: Unsigned maximum reduction to scalar.
UMIN (immediate): Unsigned minimum with immediate (unpredicated).
UMIN (vectors): Unsigned minimum vectors (predicated).
UMINV: Unsigned minimum reduction to scalar.
UMULH: Unsigned multiply returning high half (predicated).
SPLICE: Splice two vectors
under predicate control.
SUNPKHI, SUNPKLO: Signed
unpack and extend half of vector.
UUNPKHI, UUNPKLO: Unsigned
unpack and extend half of vector.
Unpack and widen half of predicate.
MOVS (unpredicated): Move predicate (
unpredicated), setting the condition flags: an alias of ORR, ORRS (predicates).
ADD (immediate): Add immediate (
unpredicated).
ADD (vectors, unpredicated): Add vectors (
unpredicated).
AND (immediate): Bitwise AND with immediate (
unpredicated).
AND (vectors, unpredicated): Bitwise AND vectors (
unpredicated).
ASR (immediate, unpredicated): Arithmetic shift right by immediate (
unpredicated).
ASR (wide elements, unpredicated): Arithmetic shift right by 64-bit wide elements (
unpredicated).
BIC (vectors, unpredicated): Bitwise clear vectors (
unpredicated).
DUP (immediate): Broadcast signed immediate to vector elements (
unpredicated).
DUP (indexed): Broadcast indexed element to vector (
unpredicated).
DUP (scalar): Broadcast general-purpose register to vector elements (
unpredicated).
DUPM: Broadcast logical bitmask immediate to vector (
unpredicated).
EOR (immediate): Bitwise exclusive OR with immediate (
unpredicated).
EOR (vectors, unpredicated): Bitwise exclusive OR vectors (
unpredicated).
FADD (vectors, unpredicated): Floating-point add vector (
unpredicated).
FDUP: Broadcast 8-bit floating-point immediate to vector elements (
unpredicated).
FMUL (vectors, unpredicated): Floating-point multiply vectors (
unpredicated).
FRECPE: Floating-point reciprocal estimate (
unpredicated).
FRECPS: Floating-point reciprocal step (
unpredicated).
FRSQRTE: Floating-point reciprocal square root estimate (
unpredicated).
FRSQRTS: Floating-point reciprocal square root step (
unpredicated).
FSUB (vectors, unpredicated): Floating-point subtract vectors (
unpredicated).
LSL (immediate, unpredicated): Logical shift left by immediate (
unpredicated).
LSL (wide elements, unpredicated): Logical shift left by 64-bit wide elements (
unpredicated).
LSR (immediate, unpredicated): Logical shift right by immediate (
unpredicated).
LSR (wide elements, unpredicated): Logical shift right by 64-bit wide elements (
unpredicated).
MOV (vector, unpredicated): Move vector register (unpredicated): an alias of ORR (vectors,
unpredicated).
MOVPRFX (unpredicated): Move prefix (
unpredicated).
MUL (immediate): Multiply by immediate (
unpredicated).
ORR (immediate): Bitwise OR with immediate (
unpredicated).
ORR (vectors, unpredicated): Bitwise OR vectors (
unpredicated).
REV (vector): Reverse all elements in a vector (
unpredicated).
SMAX (immediate): Signed maximum with immediate (
unpredicated).
SMIN (immediate): Signed minimum with immediate (
unpredicated).
SQADD (immediate): Signed saturating add immediate (
unpredicated).
SQADD (vectors): Signed saturating add vectors (
unpredicated).
SQSUB (immediate): Signed saturating subtract immediate (
unpredicated).
SQSUB (vectors): Signed saturating subtract vectors (
unpredicated).
SUB (immediate): Subtract immediate (
unpredicated).
SUB (vectors, unpredicated): Subtract vectors (
unpredicated).
SUBR (immediate): Reversed subtract from immediate (
unpredicated).
UMAX (immediate): Unsigned maximum with immediate (
unpredicated).
UMIN (immediate): Unsigned minimum with immediate (
unpredicated).
UQADD (immediate): Unsigned saturating add immediate (
unpredicated).
UQADD (vectors): Unsigned saturating add vectors (
unpredicated).
UQSUB (immediate): Unsigned saturating subtract immediate (
unpredicated).
UQSUB (vectors): Unsigned saturating subtract vectors (
unpredicated).
unpredicated): Add vectors (unpredicated).
BIC (immediate): Bitwise clear bits using immediate (
unpredicated): an alias of AND (immediate).
FMOV (zero, unpredicated): Move floating-point +0.0 to vector elements (
unpredicated): an alias of DUP (immediate).
MOV (immediate, unpredicated): Move signed immediate to vector elements (
unpredicated): an alias of DUP (immediate).
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to vector (
unpredicated): an alias of DUP (indexed).
MOV (scalar, unpredicated): Move general-purpose register to vector elements (
unpredicated): an alias of DUP (scalar).
MOV (bitmask immediate): Move logical bitmask immediate to vector (
unpredicated): an alias of DUPM.
EON: Bitwise exclusive OR with inverted immediate (
unpredicated): an alias of EOR (immediate).
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to vector elements (
unpredicated): an alias of FDUP.
ORN (immediate): Bitwise OR with inverted immediate (
unpredicated): an alias of ORR (immediate).
MOV (vector, unpredicated): Move vector register (
unpredicated): an alias of ORR (vectors, unpredicated).
MOV (predicate, unpredicated): Move predicate (
unpredicated): an alias of ORR, ORRS (predicates).
unpredicated): Arithmetic shift right by 64-bit wide elements (unpredicated).
unpredicated): Arithmetic shift right by immediate (unpredicated).
unpredicated): Bitwise AND vectors (unpredicated).
unpredicated): Bitwise clear vectors (unpredicated).
unpredicated): Bitwise exclusive OR vectors (unpredicated).
unpredicated): Bitwise OR vectors (unpredicated).
unpredicated): Floating-point add vector (unpredicated).
unpredicated): Floating-point multiply vectors (unpredicated).
unpredicated): Floating-point subtract vectors (unpredicated).
unpredicated): Logical shift left by 64-bit wide elements (unpredicated).
unpredicated): Logical shift left by immediate (unpredicated).
unpredicated): Logical shift right by 64-bit wide elements (unpredicated).
unpredicated): Logical shift right by immediate (unpredicated).
unpredicated): Move 8-bit floating-point immediate to vector elements (unpredicated): an alias of FDUP.
unpredicated): Move floating-point +0.0 to vector elements (unpredicated): an alias of DUP (immediate).
unpredicated): Move general-purpose register to vector elements (unpredicated): an alias of DUP (scalar).
unpredicated): Move indexed element or SIMD&FP scalar to vector (unpredicated): an alias of DUP (indexed).
unpredicated): Move predicate (unpredicated), setting the condition flags: an alias of ORR, ORRS (predicates).
unpredicated): Move predicate (unpredicated): an alias of ORR, ORRS (predicates).
unpredicated): Move prefix (unpredicated).
unpredicated): Move signed immediate to vector elements (unpredicated): an alias of DUP (immediate).
unpredicated): Move vector register (unpredicated): an alias of ORR (vectors, unpredicated).
unpredicated): Read the first-fault register.
unpredicated): Subtract vectors (unpredicated).
UABD:
Unsigned absolute difference (predicated).
Unsigned add reduction to scalar.
Unsigned byte / halfword / word extend (predicated).
LD1RB: Load and broadcast
unsigned byte to vector.
LD1B (scalar plus immediate): Contiguous load
unsigned bytes to vector (immediate index).
LD1B (vector plus immediate): Gather load
unsigned bytes to vector (immediate index).
LDFF1B (vector plus immediate): Gather load first-fault
unsigned bytes to vector (immediate index).
LDNF1B: Contiguous load non-fault
unsigned bytes to vector (immediate index).
LD1B (scalar plus scalar): Contiguous load
unsigned bytes to vector (scalar index).
LDFF1B (scalar plus scalar): Contiguous load first-fault
unsigned bytes to vector (scalar index).
LD1B (scalar plus vector): Gather load
unsigned bytes to vector (vector index).
LDFF1B (scalar plus vector): Gather load first-fault
unsigned bytes to vector (vector index).
UDIV:
Unsigned divide (predicated).
Unsigned dot product by indexed quadtuplet.
Unsigned dot product.
LD1RH: Load and broadcast
unsigned halfword to vector.
LD1H (scalar plus immediate): Contiguous load
unsigned halfwords to vector (immediate index).
LD1H (vector plus immediate): Gather load
unsigned halfwords to vector (immediate index).
LDFF1H (vector plus immediate): Gather load first-fault
unsigned halfwords to vector (immediate index).
LDNF1H: Contiguous load non-fault
unsigned halfwords to vector (immediate index).
LD1H (scalar plus scalar): Contiguous load
unsigned halfwords to vector (scalar index).
LDFF1H (scalar plus scalar): Contiguous load first-fault
unsigned halfwords to vector (scalar index).
LD1H (scalar plus vector): Gather load
unsigned halfwords to vector (vector index).
LDFF1H (scalar plus vector): Gather load first-fault
unsigned halfwords to vector (vector index).
Unsigned integer convert to floating-point (predicated).
FCVTZU: Floating-point convert to
unsigned integer, rounding toward zero (predicated).
CMPLS (vectors): Compare
unsigned lower or same as vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLO (vectors): Compare
unsigned lower than vector, setting the condition flags: an alias of CMP<cc> (vectors).
Unsigned maximum reduction to scalar.
Unsigned maximum vectors (predicated).
Unsigned maximum with immediate (unpredicated).
Unsigned minimum reduction to scalar.
Unsigned minimum vectors (predicated).
Unsigned minimum with immediate (unpredicated).
Unsigned multiply returning high half (predicated).
Unsigned reversed divide (predicated).
Unsigned saturating add immediate (unpredicated).
Unsigned saturating add vectors (unpredicated).
Unsigned saturating decrement scalar by active predicate element count.
Unsigned saturating decrement scalar by multiple of 16-bit predicate constraint element count.
Unsigned saturating decrement scalar by multiple of 32-bit predicate constraint element count.
Unsigned saturating decrement scalar by multiple of 64-bit predicate constraint element count.
Unsigned saturating decrement scalar by multiple of 8-bit predicate constraint element count.
Unsigned saturating decrement vector by active predicate element count.
Unsigned saturating decrement vector by multiple of 16-bit predicate constraint element count.
Unsigned saturating decrement vector by multiple of 32-bit predicate constraint element count.
Unsigned saturating decrement vector by multiple of 64-bit predicate constraint element count.
Unsigned saturating increment scalar by active predicate element count.
Unsigned saturating increment scalar by multiple of 16-bit predicate constraint element count.
Unsigned saturating increment scalar by multiple of 32-bit predicate constraint element count.
Unsigned saturating increment scalar by multiple of 64-bit predicate constraint element count.
Unsigned saturating increment scalar by multiple of 8-bit predicate constraint element count.
Unsigned saturating increment vector by active predicate element count.
Unsigned saturating increment vector by multiple of 16-bit predicate constraint element count.
Unsigned saturating increment vector by multiple of 32-bit predicate constraint element count.
Unsigned saturating increment vector by multiple of 64-bit predicate constraint element count.
Unsigned saturating subtract immediate (unpredicated).
Unsigned saturating subtract vectors (unpredicated).
WHILELS: While incrementing
unsigned scalar lower or same as scalar.
WHILELO: While incrementing
unsigned scalar lower than scalar.
Unsigned unpack and extend half of vector.
LD1RW: Load and broadcast
unsigned word to vector.
LD1W (scalar plus immediate): Contiguous load
unsigned words to vector (immediate index).
LD1W (vector plus immediate): Gather load
unsigned words to vector (immediate index).
LDFF1W (vector plus immediate): Gather load first-fault
unsigned words to vector (immediate index).
LDNF1W: Contiguous load non-fault
unsigned words to vector (immediate index).
LD1W (scalar plus scalar): Contiguous load
unsigned words to vector (scalar index).
LDFF1W (scalar plus scalar): Contiguous load first-fault
unsigned words to vector (scalar index).
LD1W (scalar plus vector): Gather load
unsigned words to vector (vector index).
LDFF1W (scalar plus vector): Gather load first-fault
unsigned words to vector (vector index).
UQADD (immediate): Unsigned saturating add immediate (unpredicated).
UQADD (vectors): Unsigned saturating add vectors (unpredicated).
UQDECB: Unsigned saturating decrement scalar by multiple of 8-bit predicate constraint element count.
UQDECD (scalar): Unsigned saturating decrement scalar by multiple of 64-bit predicate constraint element count.
UQDECD (vector): Unsigned saturating decrement vector by multiple of 64-bit predicate constraint element count.
UQDECH (scalar): Unsigned saturating decrement scalar by multiple of 16-bit predicate constraint element count.
UQDECH (vector): Unsigned saturating decrement vector by multiple of 16-bit predicate constraint element count.
UQDECP (scalar): Unsigned saturating decrement scalar by active predicate element count.
UQDECP (vector): Unsigned saturating decrement vector by active predicate element count.
UQDECW (scalar): Unsigned saturating decrement scalar by multiple of 32-bit predicate constraint element count.
UQDECW (vector): Unsigned saturating decrement vector by multiple of 32-bit predicate constraint element count.
UQINCB: Unsigned saturating increment scalar by multiple of 8-bit predicate constraint element count.
UQINCD (scalar): Unsigned saturating increment scalar by multiple of 64-bit predicate constraint element count.
UQINCD (vector): Unsigned saturating increment vector by multiple of 64-bit predicate constraint element count.
UQINCH (scalar): Unsigned saturating increment scalar by multiple of 16-bit predicate constraint element count.
UQINCH (vector): Unsigned saturating increment vector by multiple of 16-bit predicate constraint element count.
UQINCP (scalar): Unsigned saturating increment scalar by active predicate element count.
UQINCP (vector): Unsigned saturating increment vector by active predicate element count.
UQINCW (scalar): Unsigned saturating increment scalar by multiple of 32-bit predicate constraint element count.
UQINCW (vector): Unsigned saturating increment vector by multiple of 32-bit predicate constraint element count.
UQSUB (immediate): Unsigned saturating subtract immediate (unpredicated).
UQSUB (vectors): Unsigned saturating subtract vectors (unpredicated).
BIC (immediate): Bitwise clear bits
using immediate (unpredicated): an alias of AND (immediate).
UUNPKHI, UUNPKLO: Unsigned unpack and extend half of vector.
UXTB, UXTH, UXTW: Unsigned byte / halfword / word extend (predicated).
UXTH, UXTW: Unsigned byte / halfword / word extend (predicated).
UXTW: Unsigned byte / halfword / word extend (predicated).
UZP1, UZP2 (predicates): Concatenate even or odd elements from two predicates.
UZP1, UZP2 (vectors): Concatenate even or odd elements from two vectors.
UZP2 (predicates): Concatenate even or odd elements from two predicates.
UZP2 (vectors): Concatenate even or odd elements from two vectors.
FCMLA (indexed): Floating-point complex multiply-add by indexed
LD1B (scalar plus immediate): Contiguous load unsigned bytes to
vector (immediate index).
LD1B (vector plus immediate): Gather load unsigned bytes to
vector (immediate index).
LD1D (scalar plus immediate): Contiguous load doublewords to
vector (immediate index).
LD1D (vector plus immediate): Gather load doublewords to
vector (immediate index).
LD1H (scalar plus immediate): Contiguous load unsigned halfwords to
vector (immediate index).
LD1H (vector plus immediate): Gather load unsigned halfwords to
vector (immediate index).
LD1SB (scalar plus immediate): Contiguous load signed bytes to
vector (immediate index).
LD1SB (vector plus immediate): Gather load signed bytes to
vector (immediate index).
LD1SH (scalar plus immediate): Contiguous load signed halfwords to
vector (immediate index).
LD1SH (vector plus immediate): Gather load signed halfwords to
vector (immediate index).
LD1SW (scalar plus immediate): Contiguous load signed words to
vector (immediate index).
LD1SW (vector plus immediate): Gather load signed words to
vector (immediate index).
LD1W (scalar plus immediate): Contiguous load unsigned words to
vector (immediate index).
LD1W (vector plus immediate): Gather load unsigned words to
vector (immediate index).
LDFF1B (vector plus immediate): Gather load first-fault unsigned bytes to
vector (immediate index).
LDFF1D (vector plus immediate): Gather load first-fault doublewords to
vector (immediate index).
LDFF1H (vector plus immediate): Gather load first-fault unsigned halfwords to
vector (immediate index).
LDFF1SB (vector plus immediate): Gather load first-fault signed bytes to
vector (immediate index).
LDFF1SH (vector plus immediate): Gather load first-fault signed halfwords to
vector (immediate index).
LDFF1SW (vector plus immediate): Gather load first-fault signed words to
vector (immediate index).
LDFF1W (vector plus immediate): Gather load first-fault unsigned words to
vector (immediate index).
LDNF1B: Contiguous load non-fault unsigned bytes to
vector (immediate index).
LDNF1D: Contiguous load non-fault doublewords to
vector (immediate index).
LDNF1H: Contiguous load non-fault unsigned halfwords to
vector (immediate index).
LDNF1SB: Contiguous load non-fault signed bytes to
vector (immediate index).
LDNF1SH: Contiguous load non-fault signed halfwords to
vector (immediate index).
LDNF1SW: Contiguous load non-fault signed words to
vector (immediate index).
LDNF1W: Contiguous load non-fault unsigned words to
vector (immediate index).
LDNT1B (scalar plus immediate): Contiguous load non-temporal bytes to
vector (immediate index).
LDNT1D (scalar plus immediate): Contiguous load non-temporal doublewords to
vector (immediate index).
LDNT1H (scalar plus immediate): Contiguous load non-temporal halfwords to
vector (immediate index).
LDNT1W (scalar plus immediate): Contiguous load non-temporal words to
vector (immediate index).
ST1B (scalar plus immediate): Contiguous store bytes from
vector (immediate index).
ST1B (vector plus immediate): Scatter store bytes from a
vector (immediate index).
ST1D (scalar plus immediate): Contiguous store doublewords from
vector (immediate index).
ST1D (vector plus immediate): Scatter store doublewords from a
vector (immediate index).
ST1H (scalar plus immediate): Contiguous store halfwords from
vector (immediate index).
ST1H (vector plus immediate): Scatter store halfwords from a
vector (immediate index).
ST1W (scalar plus immediate): Contiguous store words from
vector (immediate index).
ST1W (vector plus immediate): Scatter store words from a
vector (immediate index).
STNT1B (scalar plus immediate): Contiguous store non-temporal bytes from
vector (immediate index).
STNT1D (scalar plus immediate): Contiguous store non-temporal doublewords from
vector (immediate index).
STNT1H (scalar plus immediate): Contiguous store non-temporal halfwords from
vector (immediate index).
STNT1W (scalar plus immediate): Contiguous store non-temporal words from
vector (immediate index).
ASR (vectors): Arithmetic shift right by
vector (predicated).
ASRR: Reversed arithmetic shift right by
vector (predicated).
CNOT: Logically invert boolean condition in
vector (predicated).
FADD (vectors, predicated): Floating-point add
vector (predicated).
FDIV: Floating-point divide by
vector (predicated).
FDIVR: Floating-point reversed divide by
vector (predicated).
FSCALE: Floating-point adjust exponent by
vector (predicated).
LSL (vectors): Logical shift left by
vector (predicated).
LSLR: Reversed logical shift left by
vector (predicated).
LSR (vectors): Logical shift right by
vector (predicated).
LSRR: Reversed logical shift right by
vector (predicated).
NOT (vector): Bitwise invert
vector (predicated).
LD1B (scalar plus scalar): Contiguous load unsigned bytes to
vector (scalar index).
LD1D (scalar plus scalar): Contiguous load doublewords to
vector (scalar index).
LD1H (scalar plus scalar): Contiguous load unsigned halfwords to
vector (scalar index).
LD1SB (scalar plus scalar): Contiguous load signed bytes to
vector (scalar index).
LD1SH (scalar plus scalar): Contiguous load signed halfwords to
vector (scalar index).
LD1SW (scalar plus scalar): Contiguous load signed words to
vector (scalar index).
LD1W (scalar plus scalar): Contiguous load unsigned words to
vector (scalar index).
LDFF1B (scalar plus scalar): Contiguous load first-fault unsigned bytes to
vector (scalar index).
LDFF1D (scalar plus scalar): Contiguous load first-fault doublewords to
vector (scalar index).
LDFF1H (scalar plus scalar): Contiguous load first-fault unsigned halfwords to
vector (scalar index).
LDFF1SB (scalar plus scalar): Contiguous load first-fault signed bytes to
vector (scalar index).
LDFF1SH (scalar plus scalar): Contiguous load first-fault signed halfwords to
vector (scalar index).
LDFF1SW (scalar plus scalar): Contiguous load first-fault signed words to
vector (scalar index).
LDFF1W (scalar plus scalar): Contiguous load first-fault unsigned words to
vector (scalar index).
LDNT1B (scalar plus scalar): Contiguous load non-temporal bytes to
vector (scalar index).
LDNT1D (scalar plus scalar): Contiguous load non-temporal doublewords to
vector (scalar index).
LDNT1H (scalar plus scalar): Contiguous load non-temporal halfwords to
vector (scalar index).
LDNT1W (scalar plus scalar): Contiguous load non-temporal words to
vector (scalar index).
ST1B (scalar plus scalar): Contiguous store bytes from
vector (scalar index).
ST1D (scalar plus scalar): Contiguous store doublewords from
vector (scalar index).
ST1H (scalar plus scalar): Contiguous store halfwords from
vector (scalar index).
ST1W (scalar plus scalar): Contiguous store words from
vector (scalar index).
STNT1B (scalar plus scalar): Contiguous store non-temporal bytes from
vector (scalar index).
STNT1D (scalar plus scalar): Contiguous store non-temporal doublewords from
vector (scalar index).
STNT1H (scalar plus scalar): Contiguous store non-temporal halfwords from
vector (scalar index).
STNT1W (scalar plus scalar): Contiguous store non-temporal words from
vector (scalar index).
DUP (indexed): Broadcast indexed element to
vector (unpredicated).
DUPM: Broadcast logical bitmask immediate to
vector (unpredicated).
FADD (vectors, unpredicated): Floating-point add
vector (unpredicated).
REV (vector): Reverse all elements in a
vector (unpredicated).
MOV (SIMD&FP scalar, unpredicated): Move indexed element or SIMD&FP scalar to
vector (unpredicated): an alias of DUP (indexed).
MOV (bitmask immediate): Move logical bitmask immediate to
vector (unpredicated): an alias of DUPM.
LD1B (scalar plus vector): Gather load unsigned bytes to
vector (vector index).
LD1D (scalar plus vector): Gather load doublewords to
vector (vector index).
LD1H (scalar plus vector): Gather load unsigned halfwords to
vector (vector index).
LD1SB (scalar plus vector): Gather load signed bytes to
vector (vector index).
LD1SH (scalar plus vector): Gather load signed halfwords to
vector (vector index).
LD1SW (scalar plus vector): Gather load signed words to
vector (vector index).
LD1W (scalar plus vector): Gather load unsigned words to
vector (vector index).
LDFF1B (scalar plus vector): Gather load first-fault unsigned bytes to
vector (vector index).
LDFF1D (scalar plus vector): Gather load first-fault doublewords to
vector (vector index).
LDFF1H (scalar plus vector): Gather load first-fault unsigned halfwords to
vector (vector index).
LDFF1SB (scalar plus vector): Gather load first-fault signed bytes to
vector (vector index).
LDFF1SH (scalar plus vector): Gather load first-fault signed halfwords to
vector (vector index).
LDFF1SW (scalar plus vector): Gather load first-fault signed words to
vector (vector index).
LDFF1W (scalar plus vector): Gather load first-fault unsigned words to
vector (vector index).
ST1B (scalar plus vector): Scatter store bytes from a
vector (vector index).
ST1D (scalar plus vector): Scatter store doublewords from a
vector (vector index).
ST1H (scalar plus vector): Scatter store halfwords from a
vector (vector index).
ST1W (scalar plus vector): Scatter store words from a
vector (vector index).
ADR: Compute
vector address.
DECP (vector): Decrement
vector by active predicate element count.
INCP (vector): Increment
vector by active predicate element count.
SQDECP (vector): Signed saturating decrement
vector by active predicate element count.
SQINCP (vector): Signed saturating increment
vector by active predicate element count.
UQDECP (vector): Unsigned saturating decrement
vector by active predicate element count.
UQINCP (vector): Unsigned saturating increment
vector by active predicate element count.
SQDECH (vector): Signed saturating decrement
vector by multiple of 16-bit predicate constraint element count.
SQINCH (vector): Signed saturating increment
vector by multiple of 16-bit predicate constraint element count.
UQDECH (vector): Unsigned saturating decrement
vector by multiple of 16-bit predicate constraint element count.
UQINCH (vector): Unsigned saturating increment
vector by multiple of 16-bit predicate constraint element count.
SQDECW (vector): Signed saturating decrement
vector by multiple of 32-bit predicate constraint element count.
SQINCW (vector): Signed saturating increment
vector by multiple of 32-bit predicate constraint element count.
UQDECW (vector): Unsigned saturating decrement
vector by multiple of 32-bit predicate constraint element count.
UQINCW (vector): Unsigned saturating increment
vector by multiple of 32-bit predicate constraint element count.
SQDECD (vector): Signed saturating decrement
vector by multiple of 64-bit predicate constraint element count.
SQINCD (vector): Signed saturating increment
vector by multiple of 64-bit predicate constraint element count.
UQDECD (vector): Unsigned saturating decrement
vector by multiple of 64-bit predicate constraint element count.
UQINCD (vector): Unsigned saturating increment
vector by multiple of 64-bit predicate constraint element count.
DECD, DECH, DECW (vector): Decrement
vector by multiple of predicate constraint element count.
INCD, INCH, INCW (vector): Increment
vector by multiple of predicate constraint element count.
CPY (immediate): Copy signed integer immediate to
vector elements (predicated).
CPY (scalar): Copy general-purpose register to
vector elements (predicated).
CPY (SIMD&FP scalar): Copy SIMD&FP scalar register to
vector elements (predicated).
FCPY: Copy 8-bit floating-point immediate to
vector elements (predicated).
FMOV (zero, predicated): Move floating-point +0.0 to
vector elements (predicated): an alias of CPY (immediate).
MOV (immediate, predicated): Move signed integer immediate to
vector elements (predicated): an alias of CPY (immediate).
MOV (scalar, predicated): Move general-purpose register to
vector elements (predicated): an alias of CPY (scalar).
MOV (SIMD&FP scalar, predicated): Move SIMD&FP scalar register to
vector elements (predicated): an alias of CPY (SIMD&FP scalar).
FMOV (immediate, predicated): Move 8-bit floating-point immediate to
vector elements (predicated): an alias of FCPY.
MOV (vector, predicated): Move
vector elements (predicated): an alias of SEL (vectors).
DUP (immediate): Broadcast signed immediate to
vector elements (unpredicated).
DUP (scalar): Broadcast general-purpose register to
vector elements (unpredicated).
FDUP: Broadcast 8-bit floating-point immediate to
vector elements (unpredicated).
FMOV (zero, unpredicated): Move floating-point +0.0 to
vector elements (unpredicated): an alias of DUP (immediate).
MOV (immediate, unpredicated): Move signed immediate to
vector elements (unpredicated): an alias of DUP (immediate).
MOV (scalar, unpredicated): Move general-purpose register to
vector elements (unpredicated): an alias of DUP (scalar).
FMOV (immediate, unpredicated): Move 8-bit floating-point immediate to
vector elements (unpredicated): an alias of FDUP.
EXT: Extract
vector from pair of vectors.
LD1B (scalar plus vector): Gather load unsigned bytes to vector (
vector index).
LD1D (scalar plus vector): Gather load doublewords to vector (
vector index).
LD1H (scalar plus vector): Gather load unsigned halfwords to vector (
vector index).
LD1SB (scalar plus vector): Gather load signed bytes to vector (
vector index).
LD1SH (scalar plus vector): Gather load signed halfwords to vector (
vector index).
LD1SW (scalar plus vector): Gather load signed words to vector (
vector index).
LD1W (scalar plus vector): Gather load unsigned words to vector (
vector index).
LDFF1B (scalar plus vector): Gather load first-fault unsigned bytes to vector (
vector index).
LDFF1D (scalar plus vector): Gather load first-fault doublewords to vector (
vector index).
LDFF1H (scalar plus vector): Gather load first-fault unsigned halfwords to vector (
vector index).
LDFF1SB (scalar plus vector): Gather load first-fault signed bytes to vector (
vector index).
LDFF1SH (scalar plus vector): Gather load first-fault signed halfwords to vector (
vector index).
LDFF1SW (scalar plus vector): Gather load first-fault signed words to vector (
vector index).
LDFF1W (scalar plus vector): Gather load first-fault unsigned words to vector (
vector index).
ST1B (scalar plus vector): Scatter store bytes from a vector (
vector index).
ST1D (scalar plus vector): Scatter store doublewords from a vector (
vector index).
ST1H (scalar plus vector): Scatter store halfwords from a vector (
vector index).
ST1W (scalar plus vector): Scatter store words from a vector (
vector index).
PRFB (vector plus immediate): Gather prefetch bytes (
vector plus immediate).
PRFD (vector plus immediate): Gather prefetch doublewords (
vector plus immediate).
PRFH (vector plus immediate): Gather prefetch halfwords (
vector plus immediate).
PRFW (vector plus immediate): Gather prefetch words (
vector plus immediate).
vector plus immediate): Gather load doublewords to vector (immediate index).
vector plus immediate): Gather load first-fault doublewords to vector (immediate index).
vector plus immediate): Gather load first-fault signed bytes to vector (immediate index).
vector plus immediate): Gather load first-fault signed halfwords to vector (immediate index).
vector plus immediate): Gather load first-fault signed words to vector (immediate index).
vector plus immediate): Gather load first-fault unsigned bytes to vector (immediate index).
vector plus immediate): Gather load first-fault unsigned halfwords to vector (immediate index).
vector plus immediate): Gather load first-fault unsigned words to vector (immediate index).
vector plus immediate): Gather load signed bytes to vector (immediate index).
vector plus immediate): Gather load signed halfwords to vector (immediate index).
vector plus immediate): Gather load signed words to vector (immediate index).
vector plus immediate): Gather load unsigned bytes to vector (immediate index).
vector plus immediate): Gather load unsigned halfwords to vector (immediate index).
vector plus immediate): Gather load unsigned words to vector (immediate index).
vector plus immediate): Gather prefetch bytes (vector plus immediate).
vector plus immediate): Gather prefetch doublewords (vector plus immediate).
vector plus immediate): Gather prefetch halfwords (vector plus immediate).
vector plus immediate): Gather prefetch words (vector plus immediate).
vector plus immediate): Scatter store bytes from a vector (immediate index).
vector plus immediate): Scatter store doublewords from a vector (immediate index).
vector plus immediate): Scatter store halfwords from a vector (immediate index).
vector plus immediate): Scatter store words from a vector (immediate index).
vector register (unpredicated): an alias of ORR (vectors, unpredicated).
ADDVL: Add multiple of
vector register size to scalar register.
RDVL: Read multiple of
vector register size to scalar register.
CLASTA (vectors): Conditionally extract element after last to
vector register.
CLASTB (vectors): Conditionally extract last element to
vector register.
LDR (vector): Load
vector register.
STR (vector): Store
vector register.
TBL: Programmable table lookup in single
vector table.
CMP<cc> (wide elements): Compare
vector to 64-bit wide elements.
CMP<cc> (immediate): Compare
vector to immediate.
COMPACT: Shuffle active elements of
vector to the right and fill with zero.
FCM<cc> (zero): Floating-point compare
vector with zero.
PRFB (scalar plus vector): Gather prefetch bytes (scalar plus
vector).
PRFD (scalar plus vector): Gather prefetch doublewords (scalar plus
vector).
PRFH (scalar plus vector): Gather prefetch halfwords (scalar plus
vector).
PRFW (scalar plus vector): Gather prefetch words (scalar plus
vector).
vector): Decrement vector by multiple of predicate constraint element count.
vector): Gather load doublewords to vector (vector index).
vector): Gather load first-fault doublewords to vector (vector index).
vector): Gather load first-fault signed bytes to vector (vector index).
vector): Gather load first-fault signed halfwords to vector (vector index).
vector): Gather load first-fault signed words to vector (vector index).
vector): Gather load first-fault unsigned bytes to vector (vector index).
vector): Gather load first-fault unsigned halfwords to vector (vector index).
vector): Gather load first-fault unsigned words to vector (vector index).
vector): Gather load signed bytes to vector (vector index).
vector): Gather load signed halfwords to vector (vector index).
vector): Gather load signed words to vector (vector index).
vector): Gather load unsigned bytes to vector (vector index).
vector): Gather load unsigned halfwords to vector (vector index).
vector): Gather load unsigned words to vector (vector index).
vector): Gather prefetch bytes (scalar plus vector).
vector): Gather prefetch doublewords (scalar plus vector).
vector): Gather prefetch halfwords (scalar plus vector).
vector): Gather prefetch words (scalar plus vector).
vector): Increment vector by multiple of predicate constraint element count.
vector): Scatter store bytes from a vector (vector index).
vector): Scatter store doublewords from a vector (vector index).
vector): Scatter store halfwords from a vector (vector index).
vector): Scatter store words from a vector (vector index).
vector): Signed saturating decrement vector by multiple of 16-bit predicate constraint element count.
vector): Signed saturating decrement vector by multiple of 32-bit predicate constraint element count.
vector): Signed saturating decrement vector by multiple of 64-bit predicate constraint element count.
vector): Signed saturating increment vector by multiple of 16-bit predicate constraint element count.
vector): Signed saturating increment vector by multiple of 32-bit predicate constraint element count.
vector): Signed saturating increment vector by multiple of 64-bit predicate constraint element count.
vector): Unsigned saturating decrement vector by multiple of 16-bit predicate constraint element count.
vector): Unsigned saturating decrement vector by multiple of 32-bit predicate constraint element count.
vector): Unsigned saturating decrement vector by multiple of 64-bit predicate constraint element count.
vector): Unsigned saturating increment vector by multiple of 16-bit predicate constraint element count.
vector): Unsigned saturating increment vector by multiple of 32-bit predicate constraint element count.
vector): Unsigned saturating increment vector by multiple of 64-bit predicate constraint element count.
vector, predicated): Move vector elements (predicated): an alias of SEL (vectors).
CMPLE (vectors): Compare signed less than or equal to
vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLO (vectors): Compare unsigned lower than
vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLS (vectors): Compare unsigned lower or same as
vector, setting the condition flags: an alias of CMP<cc> (vectors).
CMPLT (vectors): Compare signed less than
vector, setting the condition flags: an alias of CMP<cc> (vectors).
vector, unpredicated): Move vector register (unpredicated): an alias of ORR (vectors, unpredicated).
INSR (scalar): Insert general-purpose register in shifted
vector.
INSR (SIMD&FP scalar): Insert SIMD&FP scalar register in shifted
vector.
LD1RB: Load and broadcast unsigned byte to
vector.
LD1RD: Load and broadcast doubleword to
vector.
LD1RH: Load and broadcast unsigned halfword to
vector.
LD1RSB: Load and broadcast signed byte to
vector.
LD1RSH: Load and broadcast signed halfword to
vector.
LD1RSW: Load and broadcast signed word to
vector.
LD1RW: Load and broadcast unsigned word to
vector.
SUNPKHI, SUNPKLO: Signed unpack and extend half of
vector.
UUNPKHI, UUNPKLO: Unsigned unpack and extend half of
vector.
FCMLE (vectors): Floating-point compare less than or equal to
vector: an alias of FCM<cc> (vectors).
FCMLT (vectors): Floating-point compare less than
vector: an alias of FCM<cc> (vectors).
LD2B (scalar plus immediate): Contiguous load two-byte structures to two
vectors (immediate index).
LD2D (scalar plus immediate): Contiguous load two-doubleword structures to two
vectors (immediate index).
LD2H (scalar plus immediate): Contiguous load two-halfword structures to two
vectors (immediate index).
LD2W (scalar plus immediate): Contiguous load two-word structures to two
vectors (immediate index).
LD3B (scalar plus immediate): Contiguous load three-byte structures to three
vectors (immediate index).
LD3D (scalar plus immediate): Contiguous load three-doubleword structures to three
vectors (immediate index).
LD3H (scalar plus immediate): Contiguous load three-halfword structures to three
vectors (immediate index).
LD3W (scalar plus immediate): Contiguous load three-word structures to three
vectors (immediate index).
LD4B (scalar plus immediate): Contiguous load four-byte structures to four
vectors (immediate index).
LD4D (scalar plus immediate): Contiguous load four-doubleword structures to four
vectors (immediate index).
LD4H (scalar plus immediate): Contiguous load four-halfword structures to four
vectors (immediate index).
LD4W (scalar plus immediate): Contiguous load four-word structures to four
vectors (immediate index).
ST2B (scalar plus immediate): Contiguous store two-byte structures from two
vectors (immediate index).
ST2D (scalar plus immediate): Contiguous store two-doubleword structures from two
vectors (immediate index).
ST2H (scalar plus immediate): Contiguous store two-halfword structures from two
vectors (immediate index).
ST2W (scalar plus immediate): Contiguous store two-word structures from two
vectors (immediate index).
ST3B (scalar plus immediate): Contiguous store three-byte structures from three
vectors (immediate index).
ST3D (scalar plus immediate): Contiguous store three-doubleword structures from three
vectors (immediate index).
ST3H (scalar plus immediate): Contiguous store three-halfword structures from three
vectors (immediate index).
ST3W (scalar plus immediate): Contiguous store three-word structures from three
vectors (immediate index).
ST4B (scalar plus immediate): Contiguous store four-byte structures from four
vectors (immediate index).
ST4D (scalar plus immediate): Contiguous store four-doubleword structures from four
vectors (immediate index).
ST4H (scalar plus immediate): Contiguous store four-halfword structures from four
vectors (immediate index).
ST4W (scalar plus immediate): Contiguous store four-word structures from four
vectors (immediate index).
FNMLA: Floating-point negated fused multiply-add
vectors (predicated), writing addend [Zda = -Zda + -Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract
vectors (predicated), writing addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point fused multiply-subtract
vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
FMLA (vectors): Floating-point fused multiply-add
vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
MLA: Multiply-add
vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
MLS: Multiply-subtract
vectors (predicated), writing addend [Zda = Zda - Zn * Zm].
FNMAD: Floating-point negated fused multiply-add
vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract
vectors (predicated), writing multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused multiply-subtract
vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-add
vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
MAD: Multiply-add
vectors (predicated), writing multiplicand [Zdn = Za + Zdn * Zm].
MSB: Multiply-subtract
vectors (predicated), writing multiplicand [Zdn = Za - Zdn * Zm].
vectors (predicated).
AND (vectors, predicated): Bitwise AND
vectors (predicated).
BIC (vectors, predicated): Bitwise clear
vectors (predicated).
EOR (vectors, predicated): Bitwise exclusive OR
vectors (predicated).
FMUL (vectors, predicated): Floating-point multiply
vectors (predicated).
FMULX: Floating-point multiply-extended
vectors (predicated).
FSUB (vectors, predicated): Floating-point subtract
vectors (predicated).
FSUBR (vectors): Floating-point reversed subtract
vectors (predicated).
MUL (vectors): Multiply
vectors (predicated).
ORR (vectors, predicated): Bitwise OR
vectors (predicated).
SMAX (vectors): Signed maximum
vectors (predicated).
SMIN (vectors): Signed minimum
vectors (predicated).
SUB (vectors, predicated): Subtract
vectors (predicated).
SUBR (vectors): Reversed subtract
vectors (predicated).
UMAX (vectors): Unsigned maximum
vectors (predicated).
UMIN (vectors): Unsigned minimum
vectors (predicated).
LD2B (scalar plus scalar): Contiguous load two-byte structures to two
vectors (scalar index).
LD2D (scalar plus scalar): Contiguous load two-doubleword structures to two
vectors (scalar index).
LD2H (scalar plus scalar): Contiguous load two-halfword structures to two
vectors (scalar index).
LD2W (scalar plus scalar): Contiguous load two-word structures to two
vectors (scalar index).
LD3B (scalar plus scalar): Contiguous load three-byte structures to three
vectors (scalar index).
LD3D (scalar plus scalar): Contiguous load three-doubleword structures to three
vectors (scalar index).
LD3H (scalar plus scalar): Contiguous load three-halfword structures to three
vectors (scalar index).
LD3W (scalar plus scalar): Contiguous load three-word structures to three
vectors (scalar index).
LD4B (scalar plus scalar): Contiguous load four-byte structures to four
vectors (scalar index).
LD4D (scalar plus scalar): Contiguous load four-doubleword structures to four
vectors (scalar index).
LD4H (scalar plus scalar): Contiguous load four-halfword structures to four
vectors (scalar index).
LD4W (scalar plus scalar): Contiguous load four-word structures to four
vectors (scalar index).
ST2B (scalar plus scalar): Contiguous store two-byte structures from two
vectors (scalar index).
ST2D (scalar plus scalar): Contiguous store two-doubleword structures from two
vectors (scalar index).
ST2H (scalar plus scalar): Contiguous store two-halfword structures from two
vectors (scalar index).
ST2W (scalar plus scalar): Contiguous store two-word structures from two
vectors (scalar index).
ST3B (scalar plus scalar): Contiguous store three-byte structures from three
vectors (scalar index).
ST3D (scalar plus scalar): Contiguous store three-doubleword structures from three
vectors (scalar index).
ST3H (scalar plus scalar): Contiguous store three-halfword structures from three
vectors (scalar index).
ST3W (scalar plus scalar): Contiguous store three-word structures from three
vectors (scalar index).
ST4B (scalar plus scalar): Contiguous store four-byte structures from four
vectors (scalar index).
ST4D (scalar plus scalar): Contiguous store four-doubleword structures from four
vectors (scalar index).
ST4H (scalar plus scalar): Contiguous store four-halfword structures from four
vectors (scalar index).
ST4W (scalar plus scalar): Contiguous store four-word structures from four
vectors (scalar index).
vectors (unpredicated).
AND (vectors, unpredicated): Bitwise AND
vectors (unpredicated).
BIC (vectors, unpredicated): Bitwise clear
vectors (unpredicated).
EOR (vectors, unpredicated): Bitwise exclusive OR
vectors (unpredicated).
FMUL (vectors, unpredicated): Floating-point multiply
vectors (unpredicated).
FSUB (vectors, unpredicated): Floating-point subtract
vectors (unpredicated).
ORR (vectors, unpredicated): Bitwise OR
vectors (unpredicated).
SQADD (vectors): Signed saturating add
vectors (unpredicated).
SQSUB (vectors): Signed saturating subtract
vectors (unpredicated).
SUB (vectors, unpredicated): Subtract
vectors (unpredicated).
UQADD (vectors): Unsigned saturating add
vectors (unpredicated).
UQSUB (vectors): Unsigned saturating subtract
vectors (unpredicated).
SPLICE: Splice two
vectors under predicate control.
CMPLE (vectors): Compare signed less than or equal to vector, setting the condition flags: an alias of CMP<cc> (
vectors).
CMPLO (vectors): Compare unsigned lower than vector, setting the condition flags: an alias of CMP<cc> (
vectors).
CMPLS (vectors): Compare unsigned lower or same as vector, setting the condition flags: an alias of CMP<cc> (
vectors).
CMPLT (vectors): Compare signed less than vector, setting the condition flags: an alias of CMP<cc> (
vectors).
FCMLE (vectors): Floating-point compare less than or equal to vector: an alias of FCM<cc> (
vectors).
FCMLT (vectors): Floating-point compare less than vector: an alias of FCM<cc> (
vectors).
MOV (vector, predicated): Move vector elements (predicated): an alias of SEL (
vectors).
vectors): Compare signed less than or equal to vector, setting the condition flags: an alias of CMP<cc> (vectors).
vectors): Compare signed less than vector, setting the condition flags: an alias of CMP<cc> (vectors).
vectors): Compare unsigned lower or same as vector, setting the condition flags: an alias of CMP<cc> (vectors).
vectors): Compare unsigned lower than vector, setting the condition flags: an alias of CMP<cc> (vectors).
vectors): Concatenate even or odd elements from two vectors.
vectors): Floating-point compare less than or equal to vector: an alias of FCM<cc> (vectors).
vectors): Floating-point fused multiply-add vectors (predicated), writing addend [Zda = Zda + Zn * Zm].
vectors): Floating-point fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn * Zm].
vectors): Interleave elements from two half vectors.
vectors): Interleave even or odd elements from two vectors.
vectors, predicated): Add vectors (predicated).
vectors, predicated): Bitwise AND vectors (predicated).
vectors, predicated): Bitwise clear vectors (predicated).
vectors, predicated): Bitwise exclusive OR vectors (predicated).
vectors, predicated): Bitwise OR vectors (predicated).
vectors, predicated): Floating-point add vector (predicated).
vectors, predicated): Floating-point multiply vectors (predicated).
vectors, predicated): Floating-point subtract vectors (predicated).
vectors, predicated): Subtract vectors (predicated).
MOV (vector, unpredicated): Move vector register (unpredicated): an alias of ORR (
vectors, unpredicated).
vectors, unpredicated): Add vectors (unpredicated).
vectors, unpredicated): Bitwise AND vectors (unpredicated).
vectors, unpredicated): Bitwise clear vectors (unpredicated).
vectors, unpredicated): Bitwise exclusive OR vectors (unpredicated).
vectors, unpredicated): Bitwise OR vectors (unpredicated).
vectors, unpredicated): Floating-point add vector (unpredicated).
vectors, unpredicated): Floating-point multiply vectors (unpredicated).
vectors, unpredicated): Floating-point subtract vectors (unpredicated).
vectors, unpredicated): Subtract vectors (unpredicated).
CMP<cc> (vectors): Compare
vectors.
EXT: Extract vector from pair of
vectors.
FAC<cc>: Floating-point absolute compare
vectors.
FCM<cc> (vectors): Floating-point compare
vectors.
SEL (vectors): Conditionally select elements from two
vectors.
TRN1, TRN2 (vectors): Interleave even or odd elements from two
vectors.
UZP1, UZP2 (vectors): Concatenate even or odd elements from two
vectors.
ZIP1, ZIP2 (vectors): Interleave elements from two half
vectors.
While incrementing signed scalar less than scalar.
While incrementing unsigned scalar lower or same as scalar.
While incrementing unsigned scalar lower than scalar.
WHILELE: While incrementing signed scalar less than or equal to scalar.
WHILELO: While incrementing unsigned scalar lower than scalar.
WHILELS: While incrementing unsigned scalar lower or same as scalar.
WHILELT: While incrementing signed scalar less than scalar.
ASR (wide elements, predicated): Arithmetic shift right by 64-bit
wide elements (predicated).
LSL (wide elements, predicated): Logical shift left by 64-bit
wide elements (predicated).
LSR (wide elements, predicated): Logical shift right by 64-bit
wide elements (predicated).
ASR (wide elements, unpredicated): Arithmetic shift right by 64-bit
wide elements (unpredicated).
LSL (wide elements, unpredicated): Logical shift left by 64-bit
wide elements (unpredicated).
LSR (wide elements, unpredicated): Logical shift right by 64-bit
wide elements (unpredicated).
wide elements): Compare vector to 64-bit wide elements.
wide elements, predicated): Arithmetic shift right by 64-bit wide elements (predicated).
wide elements, predicated): Logical shift left by 64-bit wide elements (predicated).
wide elements, predicated): Logical shift right by 64-bit wide elements (predicated).
wide elements, unpredicated): Arithmetic shift right by 64-bit wide elements (unpredicated).
wide elements, unpredicated): Logical shift left by 64-bit wide elements (unpredicated).
wide elements, unpredicated): Logical shift right by 64-bit wide elements (unpredicated).
CMP<cc> (wide elements): Compare vector to 64-bit
wide elements.
PUNPKHI, PUNPKLO: Unpack and
widen half of predicate.
REVB, REVH, REVW: Reverse bytes / halfwords / words
within elements (predicated).
SXTB, SXTH, SXTW: Signed byte / halfword /
word extend (predicated).
UXTB, UXTH, UXTW: Unsigned byte / halfword /
word extend (predicated).
ST4W (scalar plus immediate): Contiguous store four-
word structures from four vectors (immediate index).
ST4W (scalar plus scalar): Contiguous store four-
word structures from four vectors (scalar index).
ST3W (scalar plus immediate): Contiguous store three-
word structures from three vectors (immediate index).
ST3W (scalar plus scalar): Contiguous store three-
word structures from three vectors (scalar index).
ST2W (scalar plus immediate): Contiguous store two-
word structures from two vectors (immediate index).
ST2W (scalar plus scalar): Contiguous store two-
word structures from two vectors (scalar index).
LD4W (scalar plus immediate): Contiguous load four-
word structures to four vectors (immediate index).
LD4W (scalar plus scalar): Contiguous load four-
word structures to four vectors (scalar index).
LD3W (scalar plus immediate): Contiguous load three-
word structures to three vectors (immediate index).
LD3W (scalar plus scalar): Contiguous load three-
word structures to three vectors (scalar index).
LD2W (scalar plus immediate): Contiguous load two-
word structures to two vectors (immediate index).
LD2W (scalar plus scalar): Contiguous load two-
word structures to two vectors (scalar index).
LD1RSW: Load and broadcast signed
word to vector.
LD1RW: Load and broadcast unsigned
word to vector.
LD1RQW (scalar plus immediate): Contiguous load and replicate four
words (immediate index).
PRFW (scalar plus immediate): Contiguous prefetch
words (immediate index).
LD1RQW (scalar plus scalar): Contiguous load and replicate four
words (scalar index).
PRFW (scalar plus scalar): Contiguous prefetch
words (scalar index).
PRFW (scalar plus vector): Gather prefetch
words (scalar plus vector).
PRFW (vector plus immediate): Gather prefetch
words (vector plus immediate).
ST1W (vector plus immediate): Scatter store
words from a vector (immediate index).
ST1W (scalar plus vector): Scatter store
words from a vector (vector index).
ST1W (scalar plus immediate): Contiguous store
words from vector (immediate index).
STNT1W (scalar plus immediate): Contiguous store non-temporal
words from vector (immediate index).
ST1W (scalar plus scalar): Contiguous store
words from vector (scalar index).
STNT1W (scalar plus scalar): Contiguous store non-temporal
words from vector (scalar index).
LD1SW (scalar plus immediate): Contiguous load signed
words to vector (immediate index).
LD1SW (vector plus immediate): Gather load signed
words to vector (immediate index).
LD1W (scalar plus immediate): Contiguous load unsigned
words to vector (immediate index).
LD1W (vector plus immediate): Gather load unsigned
words to vector (immediate index).
LDFF1SW (vector plus immediate): Gather load first-fault signed
words to vector (immediate index).
LDFF1W (vector plus immediate): Gather load first-fault unsigned
words to vector (immediate index).
LDNF1SW: Contiguous load non-fault signed
words to vector (immediate index).
LDNF1W: Contiguous load non-fault unsigned
words to vector (immediate index).
LDNT1W (scalar plus immediate): Contiguous load non-temporal
words to vector (immediate index).
LD1SW (scalar plus scalar): Contiguous load signed
words to vector (scalar index).
LD1W (scalar plus scalar): Contiguous load unsigned
words to vector (scalar index).
LDFF1SW (scalar plus scalar): Contiguous load first-fault signed
words to vector (scalar index).
LDFF1W (scalar plus scalar): Contiguous load first-fault unsigned
words to vector (scalar index).
LDNT1W (scalar plus scalar): Contiguous load non-temporal
words to vector (scalar index).
LD1SW (scalar plus vector): Gather load signed
words to vector (vector index).
LD1W (scalar plus vector): Gather load unsigned
words to vector (vector index).
LDFF1SW (scalar plus vector): Gather load first-fault signed
words to vector (vector index).
LDFF1W (scalar plus vector): Gather load first-fault unsigned
words to vector (vector index).
REVB, REVH, REVW: Reverse bytes / halfwords /
words within elements (predicated).
WRFFR: Write the first-fault register.
Write the first-fault register.
FNMLA: Floating-point negated fused multiply-add vectors (predicated),
writing addend [Zda = -Zda + -Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated),
writing addend [Zda = -Zda + Zn * Zm].
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated),
writing addend [Zda = Zda + -Zn * Zm].
FMLA (vectors): Floating-point fused multiply-add vectors (predicated),
writing addend [Zda = Zda + Zn * Zm].
MLA: Multiply-add vectors (predicated),
writing addend [Zda = Zda + Zn * Zm].
MLS: Multiply-subtract vectors (predicated),
writing addend [Zda = Zda - Zn * Zm].
FNMAD: Floating-point negated fused multiply-add vectors (predicated),
writing multiplicand [Zdn = -Za + -Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated),
writing multiplicand [Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused multiply-subtract vectors (predicated),
writing multiplicand [Zdn = Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-add vectors (predicated),
writing multiplicand [Zdn = Za + Zdn * Zm].
MAD: Multiply-add vectors (predicated),
writing multiplicand [Zdn = Za + Zdn * Zm].
MSB: Multiply-subtract vectors (predicated),
writing multiplicand [Zdn = Za - Zdn * Zm].
EORV: Bitwise
FMSB: Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn =
FNMAD: Floating-point negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -
Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-add vectors (predicated), writing multiplicand [Zdn =
Za + Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -
Za + Zdn * Zm].
MAD: Multiply-add vectors (predicated), writing multiplicand [Zdn =
Za + Zdn * Zm].
MSB: Multiply-subtract vectors (predicated), writing multiplicand [Zdn =
Za - Zdn * Zm].
FMLS (indexed): Floating-point fused multiply-subtract by indexed elements (Zda =
Zda + -Zn * Zm[indexed]).
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated), writing addend [Zda =
Zda + -Zn * Zm].
FNMLA: Floating-point negated fused multiply-add vectors (predicated), writing addend [Zda = -
Zda + -Zn * Zm].
FMLA (indexed): Floating-point fused multiply-add by indexed elements (Zda =
Zda + Zn * Zm[indexed]).
FMLA (vectors): Floating-point fused multiply-add vectors (predicated), writing addend [Zda =
Zda + Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated), writing addend [Zda = -
Zda + Zn * Zm].
MLA: Multiply-add vectors (predicated), writing addend [Zda =
Zda + Zn * Zm].
MLS: Multiply-subtract vectors (predicated), writing addend [Zda =
Zda - Zn * Zm].
FNMLA: Floating-point negated fused multiply-add vectors (predicated), writing addend [
Zda = -Zda + -Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated), writing addend [
Zda = -Zda + Zn * Zm].
FMLS (indexed): Floating-point fused multiply-subtract by indexed elements (
Zda = Zda + -Zn * Zm[indexed]).
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated), writing addend [
Zda = Zda + -Zn * Zm].
FMLA (indexed): Floating-point fused multiply-add by indexed elements (
Zda = Zda + Zn * Zm[indexed]).
FMLA (vectors): Floating-point fused multiply-add vectors (predicated), writing addend [
Zda = Zda + Zn * Zm].
MLA: Multiply-add vectors (predicated), writing addend [
Zda = Zda + Zn * Zm].
MLS: Multiply-subtract vectors (predicated), writing addend [
Zda = Zda - Zn * Zm].
FMAD: Floating-point fused multiply-add vectors (predicated), writing multiplicand [Zdn = Za +
Zdn * Zm].
FMSB: Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -
Zdn * Zm].
FNMAD: Floating-point negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -
Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za +
Zdn * Zm].
MAD: Multiply-add vectors (predicated), writing multiplicand [Zdn = Za +
Zdn * Zm].
MSB: Multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za -
Zdn * Zm].
FNMAD: Floating-point negated fused multiply-add vectors (predicated), writing multiplicand [
Zdn = -Za + -Zdn * Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated), writing multiplicand [
Zdn = -Za + Zdn * Zm].
FMSB: Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [
Zdn = Za + -Zdn * Zm].
FMAD: Floating-point fused multiply-add vectors (predicated), writing multiplicand [
Zdn = Za + Zdn * Zm].
MAD: Multiply-add vectors (predicated), writing multiplicand [
Zdn = Za + Zdn * Zm].
MSB: Multiply-subtract vectors (predicated), writing multiplicand [
Zdn = Za - Zdn * Zm].
FCVTZS: Floating-point convert to signed integer, rounding toward
zero (predicated).
FCVTZU: Floating-point convert to unsigned integer, rounding toward
zero (predicated).
CLZ: Count leading
zero bits (predicated).
CNT: Count non-
zero bits (predicated).
zero, predicated): Move floating-point +0.0 to vector elements (predicated): an alias of CPY (immediate).
zero, unpredicated): Move floating-point +0.0 to vector elements (unpredicated): an alias of DUP (immediate).
COMPACT: Shuffle active elements of vector to the right and fill with
zero.
FCM<cc> (zero): Floating-point compare vector with
zero.
MOVS (predicated): Move predicates (
zeroing), setting the condition flags: an alias of AND, ANDS (predicates).
MOV (predicate, predicated, zeroing): Move predicates (
zeroing): an alias of AND, ANDS (predicates).
zeroing): Move predicates (zeroing): an alias of AND, ANDS (predicates).
ZIP1, ZIP2 (predicates): Interleave elements from two half predicates.
ZIP1, ZIP2 (vectors): Interleave elements from two half vectors.
ZIP2 (predicates): Interleave elements from two half predicates.
ZIP2 (vectors): Interleave elements from two half vectors.
FMLA (indexed): Floating-point fused multiply-add by indexed elements (Zda = Zda + Zn *
Zm[indexed]).
FMLS (indexed): Floating-point fused multiply-subtract by indexed elements (Zda = Zda + -Zn *
Zm[indexed]).
FMAD: Floating-point fused multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn *
Zm].
FMLA (vectors): Floating-point fused multiply-add vectors (predicated), writing addend [Zda = Zda + Zn *
Zm].
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -Zn *
Zm].
FMSB: Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn *
Zm].
FNMAD: Floating-point negated fused multiply-add vectors (predicated), writing multiplicand [Zdn = -Za + -Zdn *
Zm].
FNMLA: Floating-point negated fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -Zn *
Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda + Zn *
Zm].
FNMSB: Floating-point negated fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = -Za + Zdn *
Zm].
MAD: Multiply-add vectors (predicated), writing multiplicand [Zdn = Za + Zdn *
Zm].
MLA: Multiply-add vectors (predicated), writing addend [Zda = Zda + Zn *
Zm].
MLS: Multiply-subtract vectors (predicated), writing addend [Zda = Zda - Zn *
Zm].
MSB: Multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za - Zdn *
Zm].
FMLA (indexed): Floating-point fused multiply-add by indexed elements (Zda = Zda +
Zn * Zm[indexed]).
FMLS (indexed): Floating-point fused multiply-subtract by indexed elements (Zda = Zda + -
Zn * Zm[indexed]).
FMLA (vectors): Floating-point fused multiply-add vectors (predicated), writing addend [Zda = Zda +
Zn * Zm].
FMLS (vectors): Floating-point fused multiply-subtract vectors (predicated), writing addend [Zda = Zda + -
Zn * Zm].
FNMLA: Floating-point negated fused multiply-add vectors (predicated), writing addend [Zda = -Zda + -
Zn * Zm].
FNMLS: Floating-point negated fused multiply-subtract vectors (predicated), writing addend [Zda = -Zda +
Zn * Zm].
MLA: Multiply-add vectors (predicated), writing addend [Zda = Zda +
Zn * Zm].
MLS: Multiply-subtract vectors (predicated), writing addend [Zda = Zda -
Zn * Zm].
Release: 00rel5-manual
Copyright © 2010-2018 ARM Limited or its affiliates. All rights reserved. This document is Non-Confidential.