Permuted index of instructions

1368ABCDEFGHILMNOPQRSTUVWXZ

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.

FCPY: Copy

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.

ABS: 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.

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.

add vector (predicated).

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.

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 predicates.

ANDV: Bitwise

AND reduction to scalar.

AND vectors (predicated).

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).

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).

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.

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).

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).

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.

BRKAS: Break after first true condition.

BRKB, BRKBS: Break before first true condition.

BRKBS: Break before first true condition.

BRKN, BRKNS: Propagate break to next partition.

BRKNS: Propagate break to next partition.

BRKPA, BRKPAS: Break after first true condition, propagating from previous partition.

BRKPAS: Break after first true condition, propagating from previous partition.

BRKPB, BRKPBS: Break before first true condition, propagating from previous partition.

BRKPBS: Break before first true condition, propagating from previous partition.

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).

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.

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).

bytes (vector plus immediate).

bytes / halfwords / words within elements (predicated).

bytes from a vector (immediate index).

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).

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).

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>.

cc>: Floating-point absolute compare vectors.

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).

clear predicates.

clear vectors (predicated).

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).

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.

CTERMNE: Compare and terminate loop.

DECB, DECD, DECH, DECW (scalar): Decrement scalar by multiple of predicate constraint element count.

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).

dot product by indexed quadtuplet.

UDOT (indexed): Unsigned

dot product by indexed quadtuplet.

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).

doublewords (vector plus immediate).

doublewords from a vector (immediate index).

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).

doublewords to vector (immediate index).

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).

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.

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.

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.

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]).

elements from two half predicates.

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).

even or odd elements from two predicates.

even or odd elements from two predicates.

even or odd elements from two vectors.

UZP1, UZP2 (vectors): Concatenate

even or odd elements from two vectors.

exclusive OR predicates.

exclusive OR vectors (predicated).

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.

FABD: Floating-point absolute difference (predicated).

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.

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).

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).

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.

first-fault doublewords to vector (immediate index).

LDFF1D (scalar plus scalar): Contiguous load

first-fault doublewords to vector (scalar index).

first-fault doublewords to vector (vector index).

SETFFR: Initialise the

first-fault register to all true.

first-fault register.

WRFFR: Write the

first-fault register.

first-fault signed bytes to vector (immediate index).

first-fault signed bytes to vector (scalar index).

first-fault signed bytes to vector (vector index).

first-fault signed halfwords to vector (immediate index).

first-fault signed halfwords to vector (scalar index).

first-fault signed halfwords to vector (vector index).

first-fault signed words to vector (immediate index).

first-fault signed words to vector (scalar index).

first-fault signed words to vector (vector index).

first-fault unsigned bytes to vector (immediate index).

LDFF1B (scalar plus scalar): Contiguous load

first-fault unsigned bytes to vector (scalar index).

first-fault unsigned bytes to vector (vector index).

first-fault unsigned halfwords to vector (immediate index).

LDFF1H (scalar plus scalar): Contiguous load

first-fault unsigned halfwords to vector (scalar index).

first-fault unsigned halfwords to vector (vector index).

first-fault unsigned words to vector (immediate index).

LDFF1W (scalar plus scalar): Contiguous load

first-fault unsigned words to vector (scalar index).

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).

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.

Floating-point absolute difference (predicated).

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).

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).

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].

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].

Floating-point fused multiply-subtract vectors (predicated), writing multiplicand [Zdn = Za + -Zdn * Zm].

FCPY: Copy 8-bit

floating-point immediate to vector elements (predicated).

floating-point immediate to vector elements (predicated): an alias of FCPY.

FDUP: Broadcast 8-bit

floating-point immediate to vector elements (unpredicated).

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).

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).

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).

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).

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).

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.

FP scalar register to vector elements (predicated).

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.

general-purpose register to vector elements (predicated).

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).

halfwords (vector plus immediate).

REVB, REVH, REVW: Reverse bytes /

halfwords / words within elements (predicated).

halfwords from a vector (immediate index).

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).

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).

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 starting from and incremented by general-purpose register.

index starting from and incremented by immediate.

index starting from general-purpose register and incremented by immediate.

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): Broadcast indexed element to vector (unpredicated).

indexed): Floating-point complex multiply-add by indexed values with rotate.

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]).

indexed): Floating-point multiply by indexed elements.

indexed): Signed dot product by indexed quadtuplet.

indexed): Unsigned dot product by indexed quadtuplet.

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).

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).

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.

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).

left by 64-bit wide elements (predicated).

left by 64-bit wide elements (unpredicated).

left by immediate (predicated).

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.

load and replicate eight halfwords (immediate index).

load and replicate eight halfwords (scalar index).

load and replicate four words (immediate index).

load and replicate four words (scalar index).

load and replicate sixteen bytes (immediate index).

load and replicate sixteen bytes (scalar index).

load and replicate two doublewords (immediate index).

load and replicate two doublewords (scalar index).

load doublewords to vector (immediate index).

load doublewords to vector (immediate index).

load doublewords to vector (scalar index).

load doublewords to vector (vector index).

load first-fault doublewords to vector (immediate index).

load first-fault doublewords to vector (scalar index).

load first-fault doublewords to vector (vector index).

load first-fault signed bytes to vector (immediate index).

load first-fault signed bytes to vector (scalar index).

load first-fault signed bytes to vector (vector index).

load first-fault signed halfwords to vector (immediate index).

load first-fault signed halfwords to vector (scalar index).

load first-fault signed halfwords to vector (vector index).

load first-fault signed words to vector (immediate index).

load first-fault signed words to vector (scalar index).

load first-fault signed words to vector (vector index).

load first-fault unsigned bytes to vector (immediate index).

load first-fault unsigned bytes to vector (scalar index).

load first-fault unsigned bytes to vector (vector index).

load first-fault unsigned halfwords to vector (immediate index).

load first-fault unsigned halfwords to vector (scalar index).

load first-fault unsigned halfwords to vector (vector index).

load first-fault unsigned words to vector (immediate index).

load first-fault unsigned words to vector (scalar index).

load first-fault unsigned words to vector (vector index).

load four-byte structures to four vectors (immediate index).

load four-byte structures to four vectors (scalar index).

load four-doubleword structures to four vectors (immediate index).

load four-doubleword structures to four vectors (scalar index).

load four-halfword structures to four vectors (immediate index).

load four-halfword structures to four vectors (scalar index).

load four-word structures to four vectors (immediate index).

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).

load non-temporal bytes to vector (immediate index).

load non-temporal bytes to vector (scalar index).

load non-temporal doublewords to vector (immediate index).

load non-temporal doublewords to vector (scalar index).

load non-temporal halfwords to vector (immediate index).

load non-temporal halfwords to vector (scalar index).

load non-temporal words to vector (immediate index).

load non-temporal words to vector (scalar index).

Load predicate register.

load signed bytes to vector (immediate index).

load signed bytes to vector (immediate index).

load signed bytes to vector (scalar index).

load signed bytes to vector (vector index).

load signed halfwords to vector (immediate index).

load signed halfwords to vector (immediate index).

load signed halfwords to vector (scalar index).

load signed halfwords to vector (vector index).

load signed words to vector (immediate index).

load signed words to vector (immediate index).

load signed words to vector (scalar index).

load signed words to vector (vector index).

load three-byte structures to three vectors (immediate index).

load three-byte structures to three vectors (scalar index).

load three-doubleword structures to three vectors (immediate index).

load three-doubleword structures to three vectors (scalar index).

load three-halfword structures to three vectors (immediate index).

load three-halfword structures to three vectors (scalar index).

load three-word structures to three vectors (immediate index).

load three-word structures to three vectors (scalar index).

load two-byte structures to two vectors (immediate index).

load two-byte structures to two vectors (scalar index).

load two-doubleword structures to two vectors (immediate index).

load two-doubleword structures to two vectors (scalar index).

load two-halfword structures to two vectors (immediate index).

load two-halfword structures to two vectors (scalar index).

load two-word structures to two vectors (immediate index).

load two-word structures to two vectors (scalar index).

load unsigned bytes to vector (immediate index).

load unsigned bytes to vector (immediate index).

load unsigned bytes to vector (scalar index).

load unsigned bytes to vector (vector index).

load unsigned halfwords to vector (immediate index).

load unsigned halfwords to vector (immediate index).

load unsigned halfwords to vector (scalar index).

load unsigned halfwords to vector (vector index).

load unsigned words to vector (immediate index).

load unsigned words to vector (immediate index).

load unsigned words to vector (scalar index).

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).

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).

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).

MAD: Multiply-add 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.

SMAXV: Signed

maximum reduction to scalar.

UMAXV: Unsigned

maximum reduction to scalar.

maximum vectors (predicated).

UMAX (vectors): Unsigned

maximum vectors (predicated).

FMAX (immediate): Floating-point

maximum with immediate (predicated).

maximum with immediate (unpredicated).

UMAX (immediate): Unsigned

maximum with immediate (unpredicated).

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.

minimum vectors (predicated).

UMIN (vectors): Unsigned

minimum vectors (predicated).

FMIN (immediate): Floating-point

minimum with immediate (predicated).

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).

multiply vectors (predicated).

Multiply vectors (predicated).

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.

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).

non-temporal bytes from vector (immediate index).

STNT1B (scalar plus scalar): Contiguous store

non-temporal bytes from vector (scalar index).

non-temporal bytes to vector (immediate index).

LDNT1B (scalar plus scalar): Contiguous load

non-temporal bytes to vector (scalar index).

non-temporal doublewords from vector (immediate index).

STNT1D (scalar plus scalar): Contiguous store

non-temporal doublewords from vector (scalar index).

non-temporal doublewords to vector (immediate index).

LDNT1D (scalar plus scalar): Contiguous load

non-temporal doublewords to vector (scalar index).

non-temporal halfwords from vector (immediate index).

STNT1H (scalar plus scalar): Contiguous store

non-temporal halfwords from vector (scalar index).

non-temporal halfwords to vector (immediate index).

LDNT1H (scalar plus scalar): Contiguous load

non-temporal halfwords to vector (scalar index).

non-temporal words from vector (immediate index).

STNT1W (scalar plus scalar): Contiguous store

non-temporal words from vector (scalar index).

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.

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.

OR inverted predicate.

OR predicate.

EOR, EORS (predicates): Bitwise exclusive

OR predicates.

ORV: Bitwise

OR reduction to scalar.

EOR (vectors, predicated): Bitwise exclusive

OR vectors (predicated).

OR vectors (predicated).

EOR (vectors, unpredicated): Bitwise exclusive

OR vectors (unpredicated).

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.

point add vector (predicated).

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.

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.

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.

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.

point multiply vectors (predicated).

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).

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).

point subtract vectors (predicated).

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).

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.

predicate of succesfully loaded elements.

ADDPL: Add multiple of

predicate register size to scalar register.

predicate register.

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.

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).

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).

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.

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.

prefetch bytes (immediate index).

prefetch bytes (scalar index).

prefetch bytes (scalar plus vector).

prefetch bytes (vector plus immediate).

prefetch doublewords (immediate index).

prefetch doublewords (scalar index).

prefetch doublewords (scalar plus vector).

prefetch doublewords (vector plus immediate).

prefetch halfwords (immediate index).

prefetch halfwords (scalar index).

prefetch halfwords (scalar plus vector).

prefetch halfwords (vector plus immediate).

prefetch words (immediate index).

prefetch words (scalar index).

prefetch words (scalar plus vector).

prefetch words (vector plus immediate).

prefix (predicated).

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.

PTRUES: Initialise predicate from named constraint.

PUNPKHI, PUNPKLO: Unpack and widen half of predicate.

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).

purpose register to vector elements (predicated): an alias of CPY (scalar).

DUP (scalar): Broadcast general-

purpose register to vector elements (unpredicated).

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.

r>: Floating-point round to integral value (predicated).

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.

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).

Reverse bits (predicated).

Reverse bytes / halfwords / words within elements (predicated).

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).

Reversed logical shift left by vector (predicated).

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.

right by 64-bit wide elements (predicated).

right by 64-bit wide elements (predicated).

right by 64-bit wide elements (unpredicated).

right by 64-bit wide elements (unpredicated).

ASR (immediate, predicated): Arithmetic shift

right by immediate (predicated).

right by immediate (predicated).

right by immediate (unpredicated).

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).

SABD: Signed absolute difference (predicated).

SADDV: Signed add reduction to scalar.

saturating add immediate (unpredicated).

saturating add immediate (unpredicated).

saturating add vectors (unpredicated).

UQADD (vectors): Unsigned

saturating add vectors (unpredicated).

saturating decrement scalar by active predicate element count.

UQDECP (scalar): Unsigned

saturating decrement scalar by active predicate element count.

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.

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.

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.

saturating decrement vector by active predicate element count.

UQDECP (vector): Unsigned

saturating decrement vector by active predicate element count.

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.

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.

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.

saturating increment scalar by active predicate element count.

UQINCP (scalar): Unsigned

saturating increment scalar by active predicate element count.

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.

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.

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.

saturating increment vector by active predicate element count.

UQINCP (vector): Unsigned

saturating increment vector by active predicate element count.

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.

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.

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.

saturating subtract immediate (unpredicated).

saturating subtract immediate (unpredicated).

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.

scalar by multiple of predicate constraint element count.

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).

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): Broadcast general-purpose register to vector elements (unpredicated).

scalar): Conditionally extract element after last to general-purpose register.

scalar): Conditionally extract element after last to SIMD&FP scalar register.

scalar): Conditionally extract last element to general-purpose 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 general-purpose register to vector elements (predicated).

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 active predicate element count.

scalar): Decrement scalar by multiple of predicate constraint element count.

scalar): Extract element after last to general-purpose register.

scalar): Extract element after last to SIMD&FP scalar register.

scalar): Extract last element to general-purpose register.

scalar): Extract last element to SIMD&FP scalar register.

scalar): Increment scalar by active predicate element count.

scalar): Increment scalar by multiple of predicate constraint element count.

scalar): Insert general-purpose register in shifted vector.

scalar): Insert SIMD&FP scalar register in shifted vector.

scalar): Signed saturating decrement scalar by active predicate element count.

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 active predicate 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 active predicate 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 active predicate 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.

scalars): Create index starting from and incremented by general-purpose register.

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.

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.

shift left by 64-bit wide elements (predicated).

shift left by 64-bit wide elements (unpredicated).

shift left by immediate (predicated).

shift left by immediate (unpredicated).

LSL (vectors): Logical

shift left by vector (predicated).

LSLR: Reversed logical

shift left by vector (predicated).

shift right by 64-bit wide elements (predicated).

shift right by 64-bit wide elements (predicated).

shift right by 64-bit wide elements (unpredicated).

shift right by 64-bit wide elements (unpredicated).

shift right by immediate (predicated).

shift right by immediate (predicated).

shift right by immediate (unpredicated).

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).

Signed absolute difference (predicated).

Signed add reduction to scalar.

Signed byte / halfword / word extend (predicated).

LD1RSB: Load and broadcast

signed byte to vector.

signed bytes to vector (immediate index).

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).

signed bytes to vector (vector index).

LDFF1SB (scalar plus vector): Gather load first-fault

signed bytes to vector (vector index).

Signed divide (predicated).

Signed dot product by indexed quadtuplet.

Signed dot product.

LD1RSH: Load and broadcast

signed halfword to vector.

signed halfwords to vector (immediate index).

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).

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).

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.

signed words to vector (immediate index).

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).

signed words to vector (vector index).

LDFF1SW (scalar plus vector): Gather load first-fault

signed words to vector (vector index).

SIMD&FP scalar register in shifted vector.

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.

starting from general-purpose register and incremented by immediate.

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).

store bytes from a vector (immediate index).

store bytes from a vector (vector index).

store bytes from vector (immediate index).

store bytes from vector (scalar index).

store doublewords from a vector (immediate index).

store doublewords from a vector (vector index).

store doublewords from vector (immediate index).

store doublewords from vector (scalar index).

store four-byte structures from four vectors (immediate index).

store four-byte structures from four vectors (scalar index).

store four-doubleword structures from four vectors (immediate index).

store four-doubleword structures from four vectors (scalar index).

store four-halfword structures from four vectors (immediate index).

store four-halfword structures from four vectors (scalar index).

store four-word structures from four vectors (immediate index).

store four-word structures from four vectors (scalar index).

store halfwords from a vector (immediate index).

store halfwords from a vector (vector index).

store halfwords from vector (immediate index).

store halfwords from vector (scalar index).

store non-temporal bytes from vector (immediate index).

store non-temporal bytes from vector (scalar index).

store non-temporal doublewords from vector (immediate index).

store non-temporal doublewords from vector (scalar index).

store non-temporal halfwords from vector (immediate index).

store non-temporal halfwords from vector (scalar index).

store non-temporal words from vector (immediate index).

store non-temporal words from vector (scalar index).

Store predicate register.

store three-byte structures from three vectors (immediate index).

store three-byte structures from three vectors (scalar index).

store three-doubleword structures from three vectors (immediate index).

store three-doubleword structures from three vectors (scalar index).

store three-halfword structures from three vectors (immediate index).

store three-halfword structures from three vectors (scalar index).

store three-word structures from three vectors (immediate index).

store three-word structures from three vectors (scalar index).

store two-byte structures from two vectors (immediate index).

store two-byte structures from two vectors (scalar index).

store two-doubleword structures from two vectors (immediate index).

store two-doubleword structures from two vectors (scalar index).

store two-halfword structures from two vectors (immediate index).

store two-halfword structures from two vectors (scalar index).

store two-word structures from two vectors (immediate index).

store two-word structures from two vectors (scalar index).

Store vector register.

store words from a vector (immediate index).

store words from a vector (vector index).

store words from vector (immediate index).

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].

subtract vectors (predicated).

FSUBR (vectors): Floating-point reversed

subtract vectors (predicated).

Subtract vectors (predicated).

SUBR (vectors): Reversed

subtract vectors (predicated).

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.

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).

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).

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).

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).

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).

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).

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).

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).

two-word structures to two vectors (immediate index).

LD2W (scalar plus scalar): Contiguous load

two-word structures to two vectors (scalar index).

UABD: Unsigned absolute difference (predicated).

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.

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).

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).

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).

Unsigned absolute difference (predicated).

Unsigned add reduction to scalar.

Unsigned byte / halfword / word extend (predicated).

LD1RB: Load and broadcast

unsigned byte to vector.

unsigned bytes to vector (immediate index).

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).

unsigned bytes to vector (vector index).

LDFF1B (scalar plus vector): Gather load first-fault

unsigned bytes to vector (vector index).

Unsigned divide (predicated).

Unsigned dot product by indexed quadtuplet.

Unsigned dot product.

LD1RH: Load and broadcast

unsigned halfword to vector.

unsigned halfwords to vector (immediate index).

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).

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.

unsigned words to vector (immediate index).

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).

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.

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.

vector by multiple of predicate constraint element count.

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.

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.

vector register.

STR (vector): Store

vector register.

TBL: Programmable table lookup in single

vector table.

vector to 64-bit wide elements.

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): Bitwise invert vector (predicated).

vector): Decrement vector by active predicate element count.

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 active predicate element count.

vector): Increment vector by multiple of predicate constraint element count.

vector): Load vector register.

vector): Reverse all elements in a vector (unpredicated).

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 active predicate element count.

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 active predicate 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): Store vector register.

vector): Unsigned saturating decrement vector by active predicate 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 active predicate 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).

vectors (predicated).

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).

vectors (predicated).

SMAX (vectors): Signed maximum

vectors (predicated).

SMIN (vectors): Signed minimum

vectors (predicated).

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).

vectors (unpredicated).

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).

vectors (unpredicated).

SQADD (vectors): Signed saturating add

vectors (unpredicated).

SQSUB (vectors): Signed saturating subtract

vectors (unpredicated).

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): Arithmetic shift right by vector (predicated).

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): Compare vectors.

vectors): Concatenate even or odd elements from two vectors.

vectors): Conditionally extract element after last to vector register.

vectors): Conditionally extract last element to vector register.

vectors): Conditionally select elements from two vectors.

vectors): Floating-point compare less than or equal to vector: an alias of FCM<cc> (vectors).

vectors): Floating-point compare less than vector: an alias of FCM<cc> (vectors).

vectors): Floating-point compare vectors.

vectors): Floating-point complex multiply-add with rotate (predicated).

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): Floating-point maximum (predicated).

vectors): Floating-point maximum number (predicated).

vectors): Floating-point minimum (predicated).

vectors): Floating-point minimum number (predicated).

vectors): Floating-point reversed subtract vectors (predicated).

vectors): Interleave elements from two half vectors.

vectors): Interleave even or odd elements from two vectors.

vectors): Logical shift left by vector (predicated).

vectors): Logical shift right by vector (predicated).

vectors): Multiply vectors (predicated).

vectors): Reversed subtract vectors (predicated).

vectors): Signed dot product.

vectors): Signed maximum vectors (predicated).

vectors): Signed minimum vectors (predicated).

vectors): Signed saturating add vectors (unpredicated).

vectors): Signed saturating subtract vectors (unpredicated).

vectors): Unsigned dot product.

vectors): Unsigned maximum vectors (predicated).

vectors): Unsigned minimum vectors (predicated).

vectors): Unsigned saturating add vectors (unpredicated).

vectors): Unsigned saturating subtract vectors (unpredicated).

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).

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).

words (vector plus immediate).

words from a vector (immediate index).

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): Floating-point compare vector with zero.

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).

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.